pax_global_header00006660000000000000000000000064144501164760014522gustar00rootroot0000000000000052 comment=596501bab9008a69ea20f499911e7c751fe0f29e opensmt-2.5.2/000077500000000000000000000000001445011647600132155ustar00rootroot00000000000000opensmt-2.5.2/.circleci/000077500000000000000000000000001445011647600150505ustar00rootroot00000000000000opensmt-2.5.2/.circleci/config.yml000066400000000000000000000136771445011647600170560ustar00rootroot00000000000000version: 2.1 jobs: formatter: docker: - image: usiverify/verify-env:current auth: username: mydockerhub-user password: $DOCKERHUB_PASSWORD steps: - checkout - run: name: run clang formatter command: cat .clang-files | xargs clang-format --Werror --dry-run build-recent-gcc-debug: docker: - image: usiverify/verify-env:current auth: username: mydockerhub-user password: $DOCKERHUB_PASSWORD environment: CMAKE_BUILD_TYPE: Debug MODEL_VALIDATION: Dolmen ENABLE_LINE_EDITING: ON PARALLEL: ON FLAGS: -Wall -Wextra -Werror OSMT_INSTALL: ~/osmt-install steps: - checkout - run: name: Debug build gcc command: | eval $(opam env) ./ci/run_travis_commands.sh build-recent-gcc-release: docker: - image: usiverify/verify-env:current auth: username: mydockerhub-user password: $DOCKERHUB_PASSWORD environment: CMAKE_BUILD_TYPE: Release FLAGS: -Wall -Wextra -Werror OSMT_INSTALL: ~/osmt-install USE_READLINE: OFF PARALLEL: OFF steps: - checkout - run: name: Release build gcc command: ./ci/run_travis_commands.sh build-recent-clang-debug: docker: - image: usiverify/verify-env:current auth: username: mydockerhub-user password: $DOCKERHUB_PASSWORD environment: CMAKE_BUILD_TYPE: Debug MODEL_VALIDATION: Dolmen ENABLE_LINE_EDITING: ON PARALLEL: ON FLAGS: -Wall -Wextra -Werror -fsanitize=signed-integer-overflow,address,undefined OSMT_INSTALL: ~/osmt-install steps: - checkout - run: name: Setup clang command: sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++ 60 - run: name: Debug build llvm command: | eval $(opam env) ./ci/run_travis_commands.sh build-recent-clang-release: docker: - image: usiverify/verify-env:current auth: username: mydockerhub-user password: $DOCKERHUB_PASSWORD environment: CMAKE_BUILD_TYPE: Release PARALLEL: ON FLAGS: -Wall -Wextra -Werror OSMT_INSTALL: ~/osmt-install steps: - checkout - run: name: Setup clang command: sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++ 60 - run: name: Release build llvm command: ./ci/run_travis_commands.sh build-starexec-debug: docker: - image: usiverify/verify-env:starexec auth: username: mydockerhub-user password: $DOCKERHUB_PASSWORD environment: FLAGS: -Wall -Wextra -Werror OSMT_INSTALL: ~/osmt-install USE_READLINE: OFF CMAKE_BUILD_TYPE: Debug MODEL_VALIDATION: pySMT steps: - checkout - run: name: Debug build gcc under devtoolset-8 command: | cat ./ci/run_travis_commands.sh |scl enable devtoolset-8 bash build-starexec-release: docker: - image: usiverify/verify-env:starexec auth: username: mydockerhub-user password: $DOCKERHUB_PASSWORD environment: CMAKE_BUILD_TYPE: Release FLAGS: -Wall -Wextra -Werror OSMT_INSTALL: ~/osmt-install USE_READLINE: OFF PARALLEL: ON steps: - checkout - run: name: Release build gcc under devtoolset-8 command: | cat ./ci/build_maximally_static.sh |scl enable devtoolset-8 bash build-macos: macos: xcode: 14.2.0 resource_class: macos.x86.medium.gen2 steps: - run: name: Packages command: | brew install cmake brew install gmp brew install bison brew install flex - checkout - run: name: Store path command: echo 'export PATH=/usr/local/opt/flex/bin:/usr/local/opt/bison/bin:$PATH' >> $BASH_ENV - run: name: Release build OS X command: ./ci/run_travis_commands.sh environment: CMAKE_BUILD_TYPE: Release FLAGS: -Wall -Wextra -Werror OSMT_INSTALL: ~/osmt-install PARALLEL: ON workflows: build-test: jobs: - formatter - build-starexec-debug: filters: &filters-build-test tags: only: /^v.*/ - build-starexec-release: filters: <<: *filters-build-test - build-recent-gcc-debug: filters: <<: *filters-build-test - build-recent-gcc-release: filters: <<: *filters-build-test - build-recent-clang-debug: filters: <<: *filters-build-test - build-recent-clang-release: filters: <<: *filters-build-test - build-macos: filters: <<: *filters-build-test opensmt-2.5.2/.clang-files000066400000000000000000000006621445011647600154060ustar00rootroot00000000000000./src/cnfizers/TermMapper.cc ./src/cnfizers/TermMapper.h ./src/proof/PGCheck.cc ./src/rewriters/ArithmeticEqualityRewriter.h ./src/rewriters/DistinctRewriter.h ./src/rewriters/DistinctRewriter.cc ./src/rewriters/DivModRewriter.h ./src/rewriters/Rewriter.h ./src/rewriters/Substitutor.h ./src/tsolvers/lasolver/Tableau.h ./src/tsolvers/lasolver/Tableau.cc ./src/smtsolvers/LookaheadSMTSolver.h ./src/smtsolvers/LookaheadSMTSolver.cc opensmt-2.5.2/.clang-format000066400000000000000000000004601445011647600155700ustar00rootroot00000000000000--- Language: Cpp BasedOnStyle: LLVM ColumnLimit: 120 IndentWidth: 4 AccessModifierOffset: -4 PointerAlignment: Middle AllowShortFunctionsOnASingleLine: Inline AllowShortBlocksOnASingleLine: Always AllowShortIfStatementsOnASingleLine: WithoutElse IndentCaseLabels: True SpaceAfterTemplateKeyword: False opensmt-2.5.2/.gitignore000066400000000000000000000024731445011647600152130ustar00rootroot00000000000000*.[oa] *.lo *.la Makefile.in .deps .idea .DS_Store cmake-build-* Makefile .*.swp INSTALL aclocal.m4 autom4te.cache/ autotools/ config.log config.status configure libtool m4/libtool.m4 m4/ltoptions.m4 m4/ltsugar.m4 m4/ltversion.m4 m4/lt~obsolete.m4 opensmt src/bin/.dirstamp regression/log-* src/PySMT/opensmt.py .ycm_extra_conf.py .ycm_extra_conf.pyc authors.txt build/ delta/parser/__pycache__/ examples/_opensmt.so examples/opensmt.py examples/opensmt.pyc examples/pyopensmt.so examples/test examples/test2 examples/test_c examples/test_itp examples/test_lra_itp implies.smt2 incrementality.smt2 loopbreak-0.dot opensmt-master regression/NEQ004_size4_writestate.osmt2 regression/linkage/test regression/linkage/test_c regression/state-dump/bar-00.smt2 regression/state-dump/bar-01.smt2 regression/state-dump/foo-00.osmt2 regression/state-dump/foo-01.osmt2 src/PySMT/opensmt_python_wrap.c src/api/.dirstamp test/bmwlin_20_5_1.inter.mbc_k100_first.smt2 test/bmwlin_20_5_1.inter.mbc_k100_first_simplified_0.smt2 test/equality-simple.smt2 test/good.smt2 test/iso_icl_nogen_sk012_itptest_itp0.smt2 test/no_op_accs.base.smt2 test/no_op_accs.base_simplified_0.smt2 test/pd_init_op_accs.induction.simplified_0.smt2 test/pursuit-safety-15.smt2 test/pursuit-safety-15_simplified_0.smt2 test/push_test.smt2 verifyinterp_A.smt2 verifyinterp_B.smt2 opensmt-2.5.2/.travis.yml000066400000000000000000000022701445011647600153270ustar00rootroot00000000000000language: cpp #safelist of branches where travis should run branches: only: - master os: - linux dist: xenial compiler: - clang - gcc env: global: - USE_READLINE=OFF - PACKAGE_BENCHMARKS=ON matrix: - CMAKE_BUILD_TYPE=Release - CMAKE_BUILD_TYPE=Debug matrix: include: - os: linux dist: trusty compiler: gcc - os: linux dist: trusty compiler: clang - os: linux dist: bionic compiler: gcc - os: linux dist: bionic compiler: clang # Commented out temporarily until we figure out Travis price plan #- os: osx #compiler: clang #env: CMAKE_BUILD_TYPE=Debug addons: apt: update: true sources: - ubuntu-toolchain-r-test packages: - libgmp-dev - libedit-dev - bison - flex before_install: - if [ "$TRAVIS_OS_NAME" = "osx" ]; then brew install bison; export PATH="/usr/local/opt/bison/bin:$PATH"; fi install: skip before_script: - export FLAGS="-Wall -Werror" - export INSTALL=${TRAVIS_BUILD_DIR}/install - mkdir build && mkdir ${INSTALL} - cmake --version script: - ./ci/run_travis_commands.sh opensmt-2.5.2/AUTHORS000066400000000000000000000015541445011647600142720ustar00rootroot00000000000000-------------------------------------------------------------- Universita' della Svizzera Italiana Department of Informatics Verification and Security Group Led by Prof. Natasha Sharygina -------------------------------------------------------------- Project leader and main code designer ------------------------------------- Dr. Antti Hyvarinen Previous project leader and main code designer ------------------------------------- Dr. Roberto Bruttomesso Previous members ---------------- Dr. Aliaksei Tsitovich Dr. Simone Fulvio Rollini Edgar Pek Acknowledgments --------------- This work has been supported by TASSO Foundation opensmt-2.5.2/CMakeLists.txt000066400000000000000000000146641445011647600157700ustar00rootroot00000000000000cmake_minimum_required(VERSION 3.3) if (POLICY CMP0074) # Policy 0074 has been introduced in CMake 3.12, so we need a check, otherwise older version would give an error cmake_policy(SET CMP0074 NEW) endif() set(OPENSMT_VERSION_MAJOR 2) set(OPENSMT_VERSION_MINOR 5) set(OPENSMT_VERSION_PATCH 1) set(OPENSMT_VERSION ${OPENSMT_VERSION_MAJOR}.${OPENSMT_VERSION_MINOR}.${OPENSMT_VERSION_PATCH}) project(opensmt VERSION ${OPENSMT_VERSION} LANGUAGES CXX) set(CMAKE_CXX_STANDARD 17) set(CMAKE_SOURCE_DIR "src") get_filename_component(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/../cmake_modules/" ABSOLUTE) set(CMAKE_POSITION_INDEPENDENT_CODE ON) #message(${CMAKE_C_COMPILER_ID}) #message(${CMAKE_CXX_COMPILER_ID}) #Set the default build type if this is the first time cmake is run and nothing has been set if (NOT EXISTS ${CMAKE_BINARY_DIR}/CMakeCache.txt) if (NOT CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel." FORCE) endif() endif() set(INSTALL_HEADERS_DIR include/opensmt) option(PARTITION_PRETTYPRINT "Term pretty printing shows partitions" OFF) option(ITP_DEBUG "Debug interpolation" OFF) option(PEDANTIC_DEBUG "Pedantic debug" OFF) option(DEBUG_SIMPLIFICATION "Debug simplification" OFF) option(VERBOSE_FOPS "Verbose file operations" OFF) option(VERBOSE_SAT "Verbose sat" OFF) option(PRINT_UNITS "Print units" OFF) option(DEBUG_GC "Debug garbage collection" OFF) option(LADEBUG "Debug lookahead" OFF) option(PRINT_DECOMPOSED_STATS "Print statistics about decomposed interpolants" OFF) option(EXPLICIT_CONGRUENCE_EXPLANATIONS "Construct explicit congruence explanations" OFF) option(MATRIX_DEBUG "Trace matrix operations (noisy output)" OFF) option(STATISTICS "Compute and print solver's statistics" OFF) option(ENABLE_LINE_EDITING "Enable line editing with readline or libedit" OFF) option(USE_READLINE "Use readline over libedit" OFF) option(BUILD_STATIC_LIBS "Build static library" ON) option(BUILD_SHARED_LIBS "Build shared library" ON) option(BUILD_EXECUTABLES "Build executables" ON) option(PARALLEL "Build parallel library" OFF) option(PACKAGE_TESTS "Build the tests" ON) option(PACKAGE_BENCHMARKS "Build the benchmarks" OFF) option(MAXIMALLY_STATIC_BINARY "Link to static versions of the libraries as much as reasonably possible" OFF) if (MAXIMALLY_STATIC_BINARY) MESSAGE("Building maximally static binaries. Shared libraries and unit tests will not be built") set(FORCE_STATIC_GMP ON) set(BUILD_SHARED_LIBS OFF) set(PACKAGE_TESTS OFF) set(PACKAGE_BENCHMARKS OFF) endif(MAXIMALLY_STATIC_BINARY) find_package(GMP REQUIRED) set(THREADS_PREFER_PTHREAD_FLAG ON) find_package(Threads REQUIRED) include_directories( ${CMAKE_SOURCE_DIR}/minisat/mtl ${CMAKE_SOURCE_DIR}/minisat/core ${CMAKE_SOURCE_DIR}/common ${CMAKE_SOURCE_DIR}/sorts ${CMAKE_SOURCE_DIR}/symbols ${CMAKE_SOURCE_DIR}/options ${CMAKE_SOURCE_DIR}/api ${CMAKE_SOURCE_DIR}/tsolvers ${CMAKE_SOURCE_DIR}/tsolvers/axdiffsolver ${CMAKE_SOURCE_DIR}/tsolvers/egraph ${CMAKE_SOURCE_DIR}/tsolvers/lasolver ${CMAKE_SOURCE_DIR}/tsolvers/stpsolver ${CMAKE_SOURCE_DIR}/tsolvers/lrasolver ${CMAKE_SOURCE_DIR}/tsolvers/liasolver ${CMAKE_SOURCE_DIR}/cnfizers ${CMAKE_SOURCE_DIR}/pterms ${CMAKE_SOURCE_DIR}/logics ${CMAKE_SOURCE_DIR}/smtsolvers ${CMAKE_SOURCE_DIR}/parsers/smt2new ${CMAKE_SOURCE_DIR}/simplifiers ${CMAKE_SOURCE_DIR}/rewriters ${CMAKE_SOURCE_DIR}/proof ${CMAKE_SOURCE_DIR}/models ${CMAKE_SOURCE_DIR}/itehandler ${CMAKE_SOURCE_DIR}/interpolation ${CMAKE_SOURCE_DIR}/parallel ) ####################################################################################################### # workaround for older versions of CMake where we cannot use target_link_libraries for object libraries get_property(GMP_INCLUDE_DIRS TARGET GMP::GMP PROPERTY INTERFACE_INCLUDE_DIRECTORIES) if (NOT GMP_INCLUDE_DIRS) message(FATAL_ERROR "GMP includes not found") endif() include_directories(${GMP_INCLUDE_DIRS}) ####################################################################################################### if (BUILD_EXECUTABLES AND NOT BUILD_STATIC_LIBS) message(FATAL_ERROR "Cannot build executables without also building static libraries") endif() if (ITP_DEBUG) add_definitions(-DITP_DEBUG) endif (ITP_DEBUG) if (PEDANTIC_DEBUG) add_definitions(-DPEDANTIC_DEBUG) endif(PEDANTIC_DEBUG) if(DEBUG_SIMPLIFICATION) add_definitions(-DSIMPLIFY_DEBUG) endif() if(DEBUG_GC) add_definitions(-DGC_DEBUG) endif() if(VERBOSE_FOPS) add_definitions(-DVERBOSE_FOPS) endif(VERBOSE_FOPS) if (LADEBUG) add_definitions(-DLADEBUG) endif () if(STATISTICS) add_definitions(-DSTATISTICS) endif(STATISTICS) if (ENABLE_LINE_EDITING) add_definitions(-DENABLE_LINE_EDITING) if (USE_READLINE) add_definitions(-DUSE_READLINE) endif() endif() if (EXPLICIT_CONGRUENCE_EXPLANATIONS) add_definitions(-DEXPLICIT_CONGRUENCE_EXPLANATIONS) endif() if (MATRIX_DEBUG) add_definitions(-DENABLE_MATRIX_TRACE) endif() add_subdirectory(${CMAKE_SOURCE_DIR}) ################# TESTING ############################################# if(PACKAGE_TESTS) if (NOT BUILD_SHARED_LIBS) message(FATAL_ERROR "Building tests requires shared libraries") endif() if(CMAKE_VERSION VERSION_LESS 3.11) MESSAGE(WARNING "Minimum CMAKE version for building tests is 3.11") else(CMAKE_VERSION VERSION_LESS 3.11) enable_testing() add_subdirectory(${PROJECT_SOURCE_DIR}/test) if (PARALLEL) add_subdirectory(${PROJECT_SOURCE_DIR}/parallel-test) endif() endif(CMAKE_VERSION VERSION_LESS 3.11) endif() ######################################################################### ################# BENCHMARKING ########################################## if (PACKAGE_BENCHMARKS) if(CMAKE_VERSION VERSION_LESS 3.11) MESSAGE(WARNING "Minimum CMAKE version for building benchmarking is 3.11") else() add_subdirectory(${PROJECT_SOURCE_DIR}/benchmark) endif() endif() ######################################################################### install(FILES ${CMAKE_SOURCE_DIR}/opensmt2.h DESTINATION ${INSTALL_HEADERS_DIR}) if (ENABLE_LINE_EDITING AND USE_READLINE) message("You have chosen to build OpenSMT against optional GPL-licensed components (readline)." "\n" "As these libraries are covered under the GPL, so will the resulting binary of OpenSMT.") endif() opensmt-2.5.2/COPYING000066400000000000000000000431101445011647600142470ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, 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 or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's 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 give any other recipients of the Program a copy of this License along with the Program. 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 Program or any portion of it, thus forming a work based on the Program, 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) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, 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 Program, 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 Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) 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; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, 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 executable. However, as a special exception, the source code 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. If distribution of executable or 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 counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program 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. 5. 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 Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program 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 to this License. 7. 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 Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program 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 Program. 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. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program 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. 9. The Free Software Foundation may publish revised and/or new versions of the 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 Program 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 Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, 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 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "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 PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. 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 PROGRAM 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 PROGRAM (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 PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), 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 Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. 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 program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. opensmt-2.5.2/Changelog.md000066400000000000000000000153571445011647600154410ustar00rootroot00000000000000### 2.5.1 (unreleased) Bug fixes: - SMT-LIB frontend: Fix spurious error when a formal argument in define-fun command had the same name, but different sort than a declared variable - SMT-LIB fronted: Fix response to get-value command - Preprocessing: Fix infinite cycle in computation of substitutions ### 2.5.0 (2023-03-27) Bug fixes: - QF_AX: Fix unsoundness bug due to missing literals in read-over-weak-eq lemmas API changes: - Pterms: Change operator < on PTRefs to more intuitive implementation New features: - Implemented the interpolant production and incrementality for the Lookahead - Support for the combination of arrays and linear arithmetic (QF_ALIA, QF_AUFLIA) - Implemented new solving heuristic - Picky CDCL, as an extension for the lookahead ### 2.4.3 (2022-11-21) Bug fixes: - UFLA: Fix unsoundness bug due to LASolver not signalling the presence of conflict correctly - ArithLogic: Fix substitution computation in the presence of uninterpreted functions - Logic: Evaluate `distinct` function on constant arguments (required for model evaluation) ### 2.4.2 (2022-10-24) Bug fixes: - TSolverHandler: Remove dependency on the global objects initialization order - ScatterSplitter: Fix the implementation of scattering Performance improvements: - ArithLogic: Improved computation of substitutions from equalities - ScatterSplitter: Limit sizes of shared literal representations New features: - The shared clause representation is now portable between solvers for all terms Build: - Support for Apple M1 ### 2.4.1 (2022-07-28) Bug fixes: - Logic: Fix use of uninitialized value ### 2.4.0 (2022-07-22) Bug fixes: - Fix handling of scoped `define-fun`s in incremental mode Performance improvements: - CoreSMTSolver: Use Luby restart scheme - CoreSMTSolver: Sticky polarities with phase flipping - CoreSMTSolver: Do not delete learned clauses with glue score < 4 New features: - A library for use in parallel SMT solving - Support for the theory of arrays with extensionality (QF_AX) ### 2.3.2 (2022-04-20) Bug fixes: - STP: Fix crash on problems with no theory variables - UF+Interpolation: Fix bug in congruence graph coloring Build: - Support building statically linked executable ### 2.3.1 (2022-03-16) Bug fixes: - Fix crash on non-standard SMT-LIB scripts Various improvements: - Small performance improvements for Arithmetic theories - Small performance improvements for preprocessing Build: - Fix version number in CMake files ### 2.3.0 (2022-03-09) Performance improvements: - Arithmetic: Pooling of `mpq_class` objects for memory reuse. - UF: Avoid unnecessary `Enode` instances (negated booleans) - UF: Simplified `Enode` representation of terms. - Integer arithmetic: Support of cuts-from-proofs algorithm to better avoid divergence. Bug fixes: - UF: Fix internal error on top-level distinct in incremental mode. - LIA+Interpolation: Fix interpolation in incremental mode when split clauses are involved. - UF+Interpolation: Fix interpolation in the presence of `distinct`s. - Logic+Parser: Fix handling of (unusual) quoted identifiers. - Logic+Parser: Fix handling of qualified terms (operator `as`). API changes: - Logic: `Logic` now takes SMT-LIB logic type as a constructor parameter to determine which terms it should support. - Logic: Support for sorts with arity > 0. - Logic: Unification of all arithmetic `Logic`s into a single `ArithLogic`. New features: - Support for theory combination: QF_UFLRA, QF_UFLIA. Build: - The default build does not depend on line editing libraries. Various improvements: - Fix several memory leaks mostly related to string manipulation. ### 2.2.0 (2021-10-04) API changes: - LA: Inequalities with multiple arguments are now handled according to SMT-LIB standard. - Logic: Refactoring of methods for term creation (added overloads for taking arguments as r-value reference). Bug fixes: - LA: Fix bound store not being cleared properly between consecutive `(check-sat)` commands. - LA: Fix incorrect update of bounds after split. Build: - Switch to C++17. Various improvements: - Interpolation mode now also uses theory propagation. - LA: Arithmetic equalities are now normalized in the same way as inequalities are. ### 2.1.0 (2021-08-16) API changes: - Single `Logic` can now be used by multiple `MainSolver`s. - `MainSolver`, when provied with a `Logic`, is now responsible for all other compenents in the solver. - Standalone `Model` object can now be obtained from `MainSolver` in sat state using `MainSolver::getModel`. This model object can be queried for value of various terms. - Interpolants are now computed using a standalone `InterpolationContext` object that can be obtained from `MainSolver` using `MainSolver::getInterpolationContext`. - Methods for term rewriting has been moved to separate classes. This includes term substitution and rewriting of mod/div operations or distinct terms. - Support for parallel / distributed solving with `SMTS` is removed for this release, but is being currently developed in a different branch. Various improvements: - Parser: Improved processing of nested let terms. - Terms: Better processing of ITE terms. - LIA: Inequalities are strengthened when created in `LIALogic`. - LIA: Various performance improvements through better memory usage - LIA: Added support for interpolation in `QF_LIA`. - LIA: Allow the use of div and mod in the api and through an option in smtlib2 files - SMT-LIB: The output of `(get-interpolants)` command now conforms to the interpolation proposal. - Data structures: Added `MapWithKeys` that supports easy and efficient iteration over map's keys. - SMT-LIB: Added dedicated solvers for `QF_RDL` and `QF_IDL`. - Models: Enable producing models in `QF_UF`. - Interpolation: Determinising theory interpolation Bug fixes: - `FastRationals`: Fixed undefined behaviour in `FastRational::absVal` - `FastRationals`: Fixed overflow in subtraction. - `FastRationals`: Faster implementations for operators - UF: Fixed various issues with handling boolean terms inside uninterpreted functions. - Interpret: Support correctly push and pop commands with integer argument. - Interpret: Standard-compliant handling of `declare-const` - Interpret: fix the methods for unbuffered reading from pipe - Data structures: Do not use `mtl::vec` when the stored type is not trivially copyable. - Fixed handling of distinct that are not on the top level of the input formula. - Interpolating mode: Fixed incremental solving with empty frames. Build: - `OpenSMT`'s executable is now created directly in the build directory. - `OpenSMT`'s libraries are created in lib subdirectory of the build directory. - `OpenSMT` now provides and installs `CMake` package for easier integration in projects using `CMake`. opensmt-2.5.2/KNOWN_BUGS000066400000000000000000000002611445011647600146530ustar00rootroot00000000000000KNOWN BUGS ------------------------------------------ 1. Parser Memory leak There is a constant memory leak of 16k somewhere in the parser, due to the allocation of a buffer. opensmt-2.5.2/LICENSE000066400000000000000000000021601445011647600142210ustar00rootroot00000000000000OpenSMT2 -- Copyright (c) 2008 - 2012 Roberto Bruttomesso 2012 - 2020 Antti Hyvarinen 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. opensmt-2.5.2/NEWS000066400000000000000000000000001445011647600137020ustar00rootroot00000000000000opensmt-2.5.2/README.md000066400000000000000000000136451445011647600145050ustar00rootroot00000000000000[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Build Status](https://travis-ci.com/usi-verification-and-security/opensmt.svg?branch=master)](https://travis-ci.com/usi-verification-and-security/opensmt) [![Gitter](https://badges.gitter.im/usi-verification-and-security/opensmt.svg)](https://gitter.im/usi-verification-and-security/opensmt?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) # OpenSMT2 Copyright 2019 Antti Hyvarinen Copyright 2009 Roberto Bruttomesso Project page: http://verify.inf.usi.ch/opensmt OpenSMT 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. OpenSMT2 is an SMT solver written in C++. It supports reading files in [SMT-LIB2](http://smtlib.cs.uiowa.edu) format and the theories `QF_UF`, `QF_RDL`, `QF_IDL`, `QF_LRA`, `QF_LIA`, `QF_UFLRA`, `QF_UFLIA` and `QF_AX`. The system also provides an API; the distribution includes a minimal example how to use the API. ## Building from source To build the system from the source code repository, you need a C++17 compliant compiler and the following libraries and headers installed: - gmp - libedit or readline (optional) In addition the `smtlib2` parser uses `flex` and `bison`. OpenSMT2 uses `cmake` as a build system generator. To compile OpenSMT2 (using `make` build system), use the following command ``` $ mkdir build; cd build; cmake ..; make ``` For better interactive experience from shell, OpenSMT can be linked against the BSD-licensed line-editing library [Editline Library](https://thrysoee.dk/editline/). You can optionally choose to build OpenSMT against the GPL-licensed [GNU Readline Library](https://tiswww.case.edu/php/chet/readline/rltop.html). Building OpenSMT in this way means that the resulting binary is GPL licensed, and not MIT licensed. To enable line editing with editline: ``` $ cmake -DENABLE_LINE_EDITING:BOOL=ON .. ``` and to enable `readline` and create a GPL-licensed build of OpenSMT: ``` $ cmake -DENABLE_LINE_EDITING:BOOL=ON -DUSE_READLINE:BOOL=ON .. ``` ### Changing build type The default build type is RELEASE. Different build type can be configured using cmake variable CMAKE_BUILD_TYPE. For example, to create a debug build use ``` $ cmake -DCMAKE_BUILD_TYPE=Debug .. ``` ### Restricting components to build By default, when building OpenSMT, an executable, a static library, and a shared library are created. However, in certain circumstances, it is desirable not to build components you do not need. In these instances, you *turn off* building components: - Passing `-DBUILD_STATIC_LIBS:BOOL=OFF` will *turn off* building the static archive for OpenSMT (`libopensmt2.a`) - Passing `-DBUILD_SHARED_LIBS:BOOL=OFF` will *turn off* building the shared library for OpenSMT (`libopensmt2.so`) - Passing `-DBUILD_EXECUTABLES:BOOL=OFF` will *turn off* building the OpenSMT executable (`opensmt`) Given how the `opensmt` executable is built, you cannot build the executable (i.e., with the default value of `-DBUILD_EXECUTABLES:BOOL=ON`) with the static archive *off* (i.e., with `-DBUILD_STATIC_LIBS:BOOL=OFF`). ## Unit tests If you have cmake version 3.11 or higher, the build system will construct unit tests. These are available through ``` $ ctest ``` ## Installing OpenSMT2 As long as you haven't disabled building them, the path to the OpenSMT executable is `/src/bin/opensmt`, the OpenSMT libraries are located in `/src/api`. To install OpenSMT in your system simply run ``` $ make install ``` The install directory can be customized using cmake variable CMAKE_INSTALL_PREFIX. The default is `/usr/local`. This installs the library in the folder `/lib` and puts the necessary header files in the folder `/include/opensmt`. ## Capabilities and usage examples OpenSMT is an SMT solver, it decides satisfiability of logical formulas in fragments of first-order logic. The input format is SMT-LIB2 and OpenSMT currently supports the following SMT-LIB logics: `QF_UF`, `QF_RDL`, `QF_IDL`, `QF_LRA`, `QF_LIA`, `QF_UFLRA` and `QF_UFLIA`, both in a single-query and an incremental mode. Support for `QF_AX` is preliminary and only in a single-query mode. To run OpenSMT on a SMT-LIB2 file (.smt2) simply pass the path to the file as an argument to the executable: ``` $ opensmt test.smt2 ``` It is also possible to run OpenSMT without any arguments, in which case it reads the input from the standard input. ### Other engines OpenSMT supports multiple SMT solving approaches. By the default it uses CDCL(T) with VSDIS decision heuristic. But it can also utilize Lookahead, possibly with picky heuristic based on VSDIS score. Those engines can be enabled by using following config: ``` (set-option :pure-lookahead true) ``` or ``` (set-option :picky true) ``` ### Interpolation OpenSMT supports a range of interpolation algorithms for propositional logic, linear real arithmetic, and uninterpreted functions with equality. When using OpenSMT as an executable, interpolation is off by default. It can be enabled by passing `-i` option to the executable, or by setting the SMT-LIB option `produce-interpolants` in the input file **before** the `(set-logic)` command. ``` (set-option :produce-interpolants 1) ``` When using OpenSMT as a library, the option needs to be set in `SMTConfig` **before** `Opensmt` object is created, see [this example](examples/test_lra_itp.cc). Interpolation is supported for SMT-LIB logics `QF_UF`, `QF_LRA`, and `QF_LIA` in both single-query and incremental mode. An example of how SMT-LIB2 file can be extended to instruct OpenSMT to compute interpolants can be found [here](regression_itp/itp_bug_small.smt2). ## Contact If you have questions please mail them to me at antti.hyvarinen@gmail.com, or at [github](https://github.com/usi-verification-and-security/opensmt) opensmt-2.5.2/benchmark/000077500000000000000000000000001445011647600151475ustar00rootroot00000000000000opensmt-2.5.2/benchmark/CMakeLists.txt000066400000000000000000000010641445011647600177100ustar00rootroot00000000000000include(FetchContent) FetchContent_Declare( googlebenchmark GIT_REPOSITORY https://github.com/google/benchmark.git GIT_TAG v1.7.0 ) FetchContent_GetProperties(googlebenchmark) if (NOT benchmark_POPULATED) FetchContent_Populate(googlebenchmark) set(BENCHMARK_ENABLE_GTEST_TESTS OFF CACHE INTERNAL "") set(BENCHMARK_ENABLE_INSTALL OFF CACHE INTERNAL "") set(BENCHMARK_ENABLE_TESTING OFF CACHE INTERNAL "") add_subdirectory(${googlebenchmark_SOURCE_DIR} ${googlebenchmark_BINARY_DIR} EXCLUDE_FROM_ALL) endif () add_subdirectory(performance) opensmt-2.5.2/benchmark/performance/000077500000000000000000000000001445011647600174505ustar00rootroot00000000000000opensmt-2.5.2/benchmark/performance/CMakeLists.txt000066400000000000000000000013711445011647600222120ustar00rootroot00000000000000add_executable(RationalEfficiencyBenchmark) target_sources(RationalEfficiencyBenchmark PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/perf_RationalEfficiency.cc" ) target_link_libraries(RationalEfficiencyBenchmark OpenSMT benchmark::benchmark benchmark_main) add_executable(MakeTermsBenchmarkSmall) target_sources(MakeTermsBenchmarkSmall PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/perf_mkTermsSmallConj.cc" ) target_link_libraries(MakeTermsBenchmarkSmall OpenSMT benchmark::benchmark benchmark_main) add_executable(MakeTermsBenchmarkBig) target_sources(MakeTermsBenchmarkBig PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/perf_mkTermsBigConj.cc" ) target_link_libraries(MakeTermsBenchmarkBig OpenSMT benchmark::benchmark benchmark_main) opensmt-2.5.2/benchmark/performance/perf_RationalEfficiency.cc000066400000000000000000000062071445011647600245360ustar00rootroot00000000000000/* * Copyright (c) 2020, Antti Hyvarinen * * SPDX-License-Identifier: MIT * */ #include #include #include #include #include #include #include using Real = opensmt::Real; class RationalEfficiencyFixture : public ::benchmark::Fixture { protected: // INT32_MIN Real rmin {"-2147483648"}; // INT32_MAX Real rmax {"2147493647"}; Real bigmin = rmin*rmin*rmin; Real bigmax = rmax*rmax*rmax; public: void SetUp(const ::benchmark::State&) { } void TearDown(const ::benchmark::State&) { } }; BENCHMARK_F(RationalEfficiencyFixture, AdditionAssignBigMin)(benchmark::State& st) { Real bg(bigmin); for (auto _ : st) benchmark::DoNotOptimize(bg += 1); } BENCHMARK_F(RationalEfficiencyFixture, AdditionAssignSmallMin)(benchmark::State& st) { Real sn(rmin); for (auto _ : st) benchmark::DoNotOptimize(sn += 1); } BENCHMARK_F(RationalEfficiencyFixture, sumSmallCommonUnity)(benchmark::State& st) { Real a(1, 3); Real b(1, 5); Real c; for (auto _ : st) { c = a + b; benchmark::DoNotOptimize(c); } } BENCHMARK_F(RationalEfficiencyFixture, sumSmallCommonNonUnity)(benchmark::State& st) { Real a(1, 3); Real b(1, 6); Real c; for (auto _ : st) { c = a + b; benchmark::DoNotOptimize(c); } } BENCHMARK_F(RationalEfficiencyFixture, smallMulInv)(benchmark::State& st) { Real a(13, 29); Real b(29, 13); Real c; for (auto _ : st) { c = a * b; benchmark::DoNotOptimize(c); } } BENCHMARK_F(RationalEfficiencyFixture, smallMulNonInv)(benchmark::State& st) { Real a(13, 29); Real b(29, 7); Real c; for (auto _ : st) { c = a * b; benchmark::DoNotOptimize(c); } } BENCHMARK_F(RationalEfficiencyFixture, smallSumNegation)(benchmark::State& st) { int nom = 1; int den = 2; Real c; for (auto _ : st) { c = Real(nom, den) + Real(-nom, den); nom = (nom + 1) % INT32_MAX; den = std::max(1, (den + 1) % INT32_MAX); benchmark::DoNotOptimize(c); } } BENCHMARK_F(RationalEfficiencyFixture, smallSubtractionEqual)(benchmark::State& st) { int nom = 1; int den = 2; Real c; for (auto _ : st) { c = Real(nom, den) - Real(nom, den); nom = (nom + 1) % INT32_MAX; den = std::max(1, (den + 1) % INT32_MAX); benchmark::DoNotOptimize(c); } } BENCHMARK_F(RationalEfficiencyFixture, smallSum)(benchmark::State& st) { int nom = 1; int den = 2; Real c; for (auto _ : st) { c = Real(nom, den) + Real(nom, den); nom = (nom + 1) % INT32_MAX; den = std::max(1, (den + 1) % INT32_MAX); benchmark::DoNotOptimize(c); } } BENCHMARK_F(RationalEfficiencyFixture, smallSubtraction)(benchmark::State& st) { int nom = 1; int den = 2; Real c; for (auto _ : st) { c = Real(nom, den) - Real(-nom, den); nom = (nom + 1) % INT32_MAX; den = std::max(1, (den + 1) % INT32_MAX); benchmark::DoNotOptimize(c); } }opensmt-2.5.2/benchmark/performance/perf_mkTermsBigConj.cc000066400000000000000000000034171445011647600236560ustar00rootroot00000000000000/* * Copyright (c) 2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #include #include #include #include class MkTerms : public ::benchmark::Fixture { protected: public: void SetUp(const ::benchmark::State&) { } void TearDown(const ::benchmark::State&) { } }; BENCHMARK_F(MkTerms, Pos)(benchmark::State& st) { Logic logic{opensmt::Logic_t::QF_UF}; std::vector vars; for (int i = 0; i < 100; ++i) { auto name = std::string("b") + std::to_string(i); vars.push_back(logic.mkBoolVar(name.c_str())); } vec args = vars; for (auto _ : st) { PTRef conj = logic.mkAnd(args); benchmark::DoNotOptimize(conj); } } BENCHMARK_F(MkTerms, Neg)(benchmark::State& st) { Logic logic{opensmt::Logic_t::QF_UF}; std::vector vars; for (int i = 0; i < 100; ++i) { auto name = std::string("b") + std::to_string(i); vars.push_back(logic.mkBoolVar(name.c_str())); } vec args; args.capacity(vars.size()); for (PTRef var : vars) { args.push(logic.mkNot(var)); } for (auto _ : st) { PTRef conj = logic.mkAnd(args); benchmark::DoNotOptimize(conj); } } BENCHMARK_F(MkTerms, PosRand)(benchmark::State& st) { Logic logic{opensmt::Logic_t::QF_UF}; std::vector vars; for (int i = 0; i < 100; ++i) { auto name = std::string("b") + std::to_string(i); vars.push_back(logic.mkBoolVar(name.c_str())); } vec args = vars; std::shuffle(args.begin(), args.end(), std::default_random_engine(0)); for (auto _ : st) { PTRef conj = logic.mkAnd(args); benchmark::DoNotOptimize(conj); } }opensmt-2.5.2/benchmark/performance/perf_mkTermsSmallConj.cc000066400000000000000000000042361445011647600242250ustar00rootroot00000000000000/* * Copyright (c) 2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #include #include #include #include class MkTerms : public ::benchmark::Fixture { protected: public: void SetUp(const ::benchmark::State&) { } void TearDown(const ::benchmark::State&) { } }; BENCHMARK_F(MkTerms, Pos)(benchmark::State& st) { Logic logic{opensmt::Logic_t::QF_UF}; std::vector vars; for (int i = 0; i < 50; ++i) { auto name = std::string("b") + std::to_string(i); vars.push_back(logic.mkBoolVar(name.c_str())); } for (auto _ : st) { for (auto i = 0u; i < vars.size(); ++i) { PTRef var1 = vars[i]; for (auto j = 0u; j < vars.size(); ++j) { PTRef conj = logic.mkAnd(var1, vars[j]); benchmark::DoNotOptimize(conj); } } } } BENCHMARK_F(MkTerms, Neg)(benchmark::State& st) { Logic logic{opensmt::Logic_t::QF_UF}; std::vector vars; for (int i = 0; i < 50; ++i) { auto name = std::string("b") + std::to_string(i); vars.push_back(logic.mkNot(logic.mkBoolVar(name.c_str()))); } for (auto _ : st) { for (auto i = 0u; i < vars.size(); ++i) { PTRef var1 = vars[i]; for (auto j = 0u; j < vars.size(); ++j) { PTRef conj = logic.mkAnd(var1, vars[j]); benchmark::DoNotOptimize(conj); } } } } BENCHMARK_F(MkTerms, Mix)(benchmark::State& st) { Logic logic{opensmt::Logic_t::QF_UF}; std::vector vars; for (int i = 0; i < 25; ++i) { auto name = std::string("b") + std::to_string(i); vars.push_back(logic.mkBoolVar(name.c_str())); } for (int i = 0; i < 25; ++i) { vars.push_back(logic.mkNot(vars[i])); } for (auto _ : st) { for (auto i = 0u; i < vars.size(); ++i) { PTRef var1 = vars[i]; for (auto j = 0u; j < vars.size(); ++j) { PTRef conj = logic.mkAnd(var1, vars[j]); benchmark::DoNotOptimize(conj); } } } } opensmt-2.5.2/benchmarking/000077500000000000000000000000001445011647600156455ustar00rootroot00000000000000opensmt-2.5.2/benchmarking/README.md000066400000000000000000000043101445011647600171220ustar00rootroot00000000000000# Simple scripts for benchmarking with visualisation Our typical use case is that there are two branches that differ in some intersting way in the implementation of a function. Google's micro benchmarking provides a way to write benchmarks for the functionality. These scripts make it easier to visualise the run time difference in the two branches. ## Benchmarking The process consists of three phases. 1. In the fist phase the two branches are compiled and the resulting benchmarks are *saved* (see below). 2. In the second phase the two benchmarks are run and a bar chart is produced as a `gnuplot` script. 3. Cleanup. Remove the stored benchmarks. ### Saving the benchmark `save-benchmark.sh` takes as an argument a path to the benchmark. It needs to be run in the build directory (the directory with `lib/libopensmt.so`). It copies the benchmark to the directory `work` in the same directory where the `save-benchmark.sh` script is, along with `lib/libopensmt.so`, using the name of the current git (short) commit hash. It makes therefore sense that the benchmark being saved is the one compiled in the current commit hash without changes. For example: ``` $ cd build $ git checkout 9ceb3836; make -j4 $ ../benchmarking/save-benchmark.sh benchmark/performance/MakeTermsBenchmarkBig $ git checkout c64fdd4e; make -j4 $ ../benchmarking/save-benchmark.sh benchmark/performance/MakeTermsBenchmarkBig ``` As a result `../benchmarking/work/` will be populated as follows: ``` $ ls ../benchmarking/work c64fdd4e 9ceb3836 lib-c64fdd4e lib-9ceb3836 ``` ### Benchmarking Proper The benchmarks are run with the script `compare.sh` which uses the stored benchmarks from the first step. Continuing the above example, the usage is ``` $ ../benchmarking/compare.sh 9ceb3836 c64fdd4e |gnuplot > test.png ``` This will place the bar plot in the file `test.png`. ### Cleaning up The scripts do not remove the directory `../benchmarking/work/`. To avoid it growing too big, clean the directory from time to time. ## Notes For the visualisation to work, it is useful to design the benchmarks so that there aren't too many sub-tests in a benchmark (say, have only three per benchmark), and that the sub-test names are not too long. opensmt-2.5.2/benchmarking/compare.sh000077500000000000000000000046761445011647600176470ustar00rootroot00000000000000#!/bin/bash function run_with_lib() { if [[ "$OSTYPE" == "darwin"* ]]; then DYLD_LIBRARY_PATH=$1 $2 $3 else LD_LIBRARY_PATH=$1 $2 $3 fi } workdir=$(cd $(dirname $0); pwd)/work usage="Usage: $0 [-h] " while [ $# -gt 0 ]; do case $1 in -h|--help) echo "${usage}" exit 1 ;; -*) echo "Error: invalid option '$1'" exit 1 ;; *) break esac shift; shift done if [ $# != 2 ]; then echo ${usage} exit 1 fi benchmark1=$workdir/$1 benchmark2=$workdir/$2 lib1=$workdir/lib-$(basename $benchmark1) lib2=$workdir/lib-$(basename $benchmark2) if [ ! -x $benchmark1 ]; then echo "Not executable: $benchmark1" exit 1; fi if [ ! -x $benchmark2 ]; then echo "Not executable: $benchmark2" exit 1; fi if [ ! -d $lib1 ]; then echo "library directory not found: $lib1" exit 1; fi if [ ! -d $lib2 ]; then echo "library directory not found: $lib2" exit 1; fi TMPDIR=$(mktemp -d) trap "rm -rf ${TMPDIR}" EXIT tests=`run_with_lib $lib1 $benchmark1 --benchmark_list_tests` echo "Running benchmark $benchmark1 three times and saving the last" >&2 for ((j=0; j < 3; j++)); do run_with_lib $lib1 $benchmark1 --benchmark_format=csv \ |csvcut -c 'name,real_time' > $TMPDIR/bm1.csv done echo "Running benchmark $benchmark2 three times and saving the last" >&2 for ((i=0; i < 3; i++)); do run_with_lib $lib2 $benchmark2 --benchmark_format=csv \ |csvcut -c 'name,real_time' > $TMPDIR/bm2.csv done echo "set term pngcairo color" echo -n "set xtics (" offset=0 for test in $tests; do echo -n "\"$test\" $(echo "$offset+0.25" | bc -l), " offset=$(echo "$offset+1.5" | bc -l) done echo ")" echo set yrange [0:] echo set boxwidth 0.5 echo set style fill solid echo "plot '-' using 1:2 with boxes ls 1 title '$(basename $benchmark1)', '-' using 1:2 with boxes ls 2 title '$(basename $benchmark2)'" offset=0 for test in $tests; do bm1res=$(csvgrep -m $test -c name $TMPDIR/bm1.csv |csvcut -c real_time |tail -1) bm2res=$(csvgrep -m $test -c name $TMPDIR/bm2.csv |csvcut -c real_time |tail -1) echo $offset $bm1res offset=$(echo $offset + 1.5 |bc -l) done echo e offset=0 for test in $tests; do bm2res=$(csvgrep -m $test -c name $TMPDIR/bm2.csv |csvcut -c real_time |tail -1) echo $(echo $offset+0.5 |bc -l) $bm2res offset=$(echo $offset + 1.5 |bc -l) done opensmt-2.5.2/benchmarking/save-benchmark.sh000077500000000000000000000011741445011647600210750ustar00rootroot00000000000000#!/bin/sh workdir=$(cd $(dirname $0); pwd)/work usage="Usage: $0 [-h] " while [ $# -gt 0 ]; do case $1 in -h|--help) echo "${usage}" exit 1 ;; -*) echo "Error: invalid option '$1'" exit 1 ;; *) break esac shift; shift done if [ $# -ne 1 ]; then echo $usage exit 1 fi if [ ! -x $1 ]; then echo "Benchmark $1 is not executable" fi current_head=`git rev-parse --short HEAD` benchmark=$1 mkdir -p $workdir cp -R lib $workdir/lib-$current_head cp $benchmark $workdir/$current_head opensmt-2.5.2/bin/000077500000000000000000000000001445011647600137655ustar00rootroot00000000000000opensmt-2.5.2/bin/opensmt.C000066400000000000000000000170461445011647600155660ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ //#include "Egraph.h" //#include "OpenSMTContext.h" //#include "SimpSMTSolver.h" //#include "Tseitin.h" //#include "ExpandITEs.h" //#include "ArraySimplify.h" //#include "BVBooleanize.h" //#include "TopLevelProp.h" //#include "DLRescale.h" //#include "Ackermanize.h" #include "Interpret.h" #include "net/net.h" #include #include #include #include #if defined(__GLIBC__) #include #endif namespace opensmt { void catcher ( int ); //extern bool stop; } // namespace opensmt //extern int smtset_in ( FILE * ); //extern int smtparse ( ); //extern int cnfset_in ( FILE * ); //extern int cnfparse ( ); //extern int smt2set_in ( FILE * ); //extern int smt2parse ( ); //OpenSMTContext * parser_ctx; /*****************************************************************************\ * * * MAIN * * * \*****************************************************************************/ int main( int argc, char * argv[] ) { // opensmt::stop = false; // Allocates Command Handler (since SMT-LIB 2.0) // OpenSMTContext context( argc, argv ); // Catch SigTerm, so that it answers even on ctrl-c signal( SIGTERM, opensmt::catcher ); signal( SIGINT , opensmt::catcher ); // // This trick (copied from Main.C of MiniSAT) is to allow // the repeatability of experiments that might be compromised // by the floating point unit approximations on doubles // #if defined(__GLIBC__) && !defined( SMTCOMP ) fpu_control_t oldcw, newcw; _FPU_GETCW(oldcw); newcw = (oldcw & ~_FPU_EXTENDED) | _FPU_DOUBLE; _FPU_SETCW(newcw); #endif #ifdef PEDANTIC_DEBUG cerr << "; pedantic assertion checking enabled (very slow)" << endl; #endif #ifndef OPTIMIZE cerr << "; this binary is compiled with optimizations disabled (slow)" << endl; #endif cerr << "; svn rev: " << SVN_REVISION << endl; cerr << "; symbol enode size: " << EnodeAllocator::symEnodeWord32Size() << endl; cerr << "; list enode size: " << EnodeAllocator::listEnodeWord32Size() << endl; cerr << "; term enode size: " << EnodeAllocator::termEnodeWord32Size() << endl; cerr << "; Configured with args " << CONFIG_FLAGS << endl; cerr << "; preprocessor definitions set in configure " << CONFIGTIME_DEFFLAGS << endl; cerr << "; compiler flags set in configure " << CONFIGTIME_COMPFLAGS << endl; #ifndef SMTCOMP // if ( context.getConfig( ).verbosity > 0 ) if ( false ) { const int len_pack = strlen( PACKAGE_STRING ); const char * site = "http://verify.inf.usi.ch/opensmt"; const int len_site = strlen( site ); cerr << "#" << endl << "# -------------------------------------------------------------------------" << endl << "# " << PACKAGE_STRING; for ( int i = 0 ; i < 73 - len_site - len_pack ; i ++ ) cerr << " "; cerr << site << endl << "# Compiled with gcc " << __VERSION__ << " on " << __DATE__ << endl << "# -------------------------------------------------------------------------" << endl << "#" << endl; } #endif // Initialize pointer to context for parsing // parser_ctx = &context; // Accepts file from stdin if nothing specified FILE * fin = NULL; int opt, i; // WorkerClient *w; while ((opt = getopt(argc, argv, "hs:r:")) != -1) { switch (opt) { // -s server to listen for problems // -r clauses database case 's': case 'r': for(i=0;optarg[i]!=':' && optarg[i]!='\0';i++){} if(optarg[i]!=':'){ fprintf(stderr, "Invalid host:port argument\n", argv[0]); return 1; } optarg[i]='\0'; if(opt == 's') { try { // w = new WorkerClient(optarg, atoi(&optarg[i+1])); // w->runForever(); } catch (char const *s) { std::cout << "Exception: " << s << "\n"; } return 0; } if(opt == 'r'){ //NetCfg::database_host = std::string(optarg); //NetCfg::database_port = atoi(&optarg[i+1]); } break; case 'h': // context.getConfig( ).printHelp( ); default: /* '?' */ fprintf(stderr, "Usage:\n\t%s filename [...]\n\t%s -s host:port\n\t%s -h\n", argv[0], argv[0], argv[0]); return 0; } } if (argc == 1) { fin = stdin; Interpret interpreter; int rval = interpreter.interpInteractive(fin); } else { Interpret interpreter; for (int i = 1; i < argc; i++) { const char * filename = argv[i]; assert( filename ); if ( strncmp( filename, "--", 2 ) == 0 || strncmp( filename, "-", 1 ) == 0 ) { opensmt_error( "input file must be last argument" ); } else if ( (fin = fopen( filename, "rt" )) == NULL ) opensmt_error( "can't open file" ); const char * extension = strrchr( filename, '.' ); if ( strcmp( extension, ".smt" ) == 0 ) { opensmt_error( "SMTLIB 1.2 format is not supported in this version, sorry" ); } else if ( strcmp( extension, ".smt2" ) == 0 ) { int rval = interpreter.interpFile(fin); // smt2set_in( fin ); // smt2parse( ); } else opensmt_error2( extension, " extension not recognized. Please use one in { smt2, cnf } or stdin (smtlib2 is assumed)" ); } fclose( fin ); } // // Execute accumulated commands // function defined in OpenSMTContext.C // // return context.executeCommands( ); return 0; } namespace opensmt { void catcher( int sig ) { switch (sig) { case SIGINT: case SIGTERM: exit(1); printf("Exit from signal\n"); // if ( opensmt::stop ) // { // parser_ctx->PrintResult( l_Undef ); // exit( 1 ); // } // opensmt::stop = true; break; } } } // namespace opensmt opensmt-2.5.2/ci/000077500000000000000000000000001445011647600136105ustar00rootroot00000000000000opensmt-2.5.2/ci/build_maximally_static.sh000077500000000000000000000017731445011647600207020ustar00rootroot00000000000000#!/bin/bash set -e if [ -d build ]; then rm -rf build; fi mkdir -p build cd build if [ ! -z ${CMAKE_CXX_COMPILER} ]; then COMPILER_OPTION="-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}" fi if [[ $OSTYPE != "darwin"* ]]; then LINKER_OPTIONS="-DCMAKE_EXE_LINKER_FLAGS=-static" fi cmake -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} \ -DCMAKE_CXX_FLAGS="${FLAGS}" \ -DUSE_READLINE:BOOL=${USE_READLINE} \ -DENABLE_LINE_EDITING:BOOL=${ENABLE_LINE_EDITING} \ -DCMAKE_INSTALL_PREFIX=${OSMT_INSTALL} \ -DMAXIMALLY_STATIC_BINARY=YES\ ${COMPILER_OPTION} \ ${LINKER_OPTIONS} \ -DPARALLEL:BOOL=${PARALLEL} \ .. cmake --build . -j 4 strip opensmt tar jcf opensmt.tar.bz2 opensmt echo "Placed stripped, maximally static binary in $(pwd)/opensmt.tar.bz2" if [[ "${PARALLEL}" == "ON" ]]; then strip opensmt-splitter tar jcf opensmt-splitter.tar.bz2 opensmt-splitter echo "Opensmt-Splitter placed stripped, maximally static binary in $(pwd)/opensmt-splitter.tar.bz2" fiopensmt-2.5.2/ci/run_travis_commands.sh000077500000000000000000000030071445011647600202240ustar00rootroot00000000000000#!/bin/bash set -ev if [ -d build ]; then rm -rf build; fi mkdir -p build cd build if [ ! -z ${CMAKE_CXX_COMPILER} ]; then COMPILER_OPTION="-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}" fi cmake -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} \ -DCMAKE_CXX_FLAGS="${FLAGS}" \ -DUSE_READLINE:BOOL=${USE_READLINE} \ -DENABLE_LINE_EDITING:BOOL=${ENABLE_LINE_EDITING} \ -DCMAKE_INSTALL_PREFIX=${OSMT_INSTALL} \ -DPACKAGE_BENCHMARKS=${PACKAGE_BENCHMARKS} \ ${COMPILER_OPTION} \ -DPARALLEL:BOOL=${PARALLEL} \ .. make -j4 make test make install if [[ ${CMAKE_BUILD_TYPE} == Debug ]]; then cd ../regression && ./run-test-notiming.sh ../build/opensmt; cd ../regression_itp && ./run-tests.sh ../build/opensmt; if [[ "${PARALLEL}" == "ON" ]]; then cd ../regression_splitting && ./bin/run-tests.sh ../build/opensmt-splitter; fi cd ../regression_pipe && ./run-tests.sh ../build/opensmt; cd ../regression_models if [[ x"${MODEL_VALIDATION}" == x"Dolmen" || -f ./data/ENV-MODERN ]]; then ./bin/run-tests-dolmen.sh ../build/opensmt; elif [[ x"${MODEL_VALIDATION}" == x"pySMT" || -f ./data/ENV-SMTCOMP ]]; then ./bin/run-tests-smtcomp.sh ../build/opensmt; else echo "Error: the model regression environment is not set." exit 1 fi fi cd ../examples && rm -rf build && mkdir -p build && cd build cmake \ -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} \ -DCMAKE_CXX_FLAGS="${FLAGS}" \ -DOpenSMT_DIR=${OSMT_INSTALL} \ .. make -j4 opensmt-2.5.2/cmake_modules/000077500000000000000000000000001445011647600160255ustar00rootroot00000000000000opensmt-2.5.2/cmake_modules/FindGMP.cmake000066400000000000000000000041551445011647600202600ustar00rootroot00000000000000# Try to find the GMP librairies # GMP_FOUND - system has GMP lib # GMP_INCLUDE_DIR - the GMP include directory # GMP_LIBRARIES - Libraries needed to use GMP if(FORCE_STATIC_GMP) #message("Trying to find static version of GMP") find_library(GMP_LIBRARY NAMES libgmp.a REQUIRED) find_library(GMPXX_LIBRARY NAMES libgmpxx.a REQUIRED) if(NOT ${GMP_LIBRARY} MATCHES ".*\.a$" OR NOT ${GMPXX_LIBRARY} MATCHES ".*\.a$") MESSAGE(WARNING "Failed to find static libraries for GMP or GMPXX.\n" "Hint: Try clearing CMakeCache.txt and request static libs on command line. " "cmake will not switch to static libraries if it was previously configured " "with shared libraries. ") MESSAGE(SEND_ERROR "Static GMP libs were not found") endif() endif(FORCE_STATIC_GMP) find_library(GMP_LIBRARY NAMES gmp) find_library(GMPXX_LIBRARY NAMES gmpxx) find_path(GMP_INCLUDE_DIR NAMES gmp.h) mark_as_advanced(GMP_INCLUDE_DIR GMP_LIBRARY GMPXX_LIBRARY) MESSAGE(STATUS "GMP libs: " ${GMP_LIBRARY} " " ${GMPXX_LIBRARY} ) MESSAGE(STATUS "GMP include: " ${GMP_INCLUDE_DIR}) include(FindPackageHandleStandardArgs) FIND_PACKAGE_HANDLE_STANDARD_ARGS(GMP DEFAULT_MSG GMP_INCLUDE_DIR GMP_LIBRARY GMPXX_LIBRARY) if(GMP_FOUND AND NOT TARGET GMP::GMP) add_library(GMP::GMP_C UNKNOWN IMPORTED) set_target_properties(GMP::GMP_C PROPERTIES IMPORTED_LOCATION "${GMP_LIBRARY}" INTERFACE_INCLUDE_DIRECTORIES "${GMP_INCLUDE_DIR}" ) add_library(GMP::GMP_CXX UNKNOWN IMPORTED) set_target_properties(GMP::GMP_CXX PROPERTIES IMPORTED_LOCATION "${GMPXX_LIBRARY}" ) add_library(GMP::GMP INTERFACE IMPORTED) set_property(TARGET GMP::GMP APPEND PROPERTY INTERFACE_LINK_LIBRARIES GMP::GMP_C GMP::GMP_CXX ) set_property(TARGET GMP::GMP APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${GMP_INCLUDE_DIR} ) # the above command is for compatibillity with old versions of CMAKE, the version below is simpler, but works only from CMake 3.11 #target_link_libraries(GMP::GMP INTERFACE GMP::GMP_C GMP::GMP_CXX) endif() opensmt-2.5.2/cmake_modules/FindLibEdit.cmake000066400000000000000000000014151445011647600211450ustar00rootroot00000000000000# Find LibEdit # LibEdit_FOUND - found LibEdit lib # LibEdit_INCLUDE_DIR - the LibEdit include directory # LibEdit_LIBRARIES - Libraries needed to use LibEdit find_path(LibEdit_INCLUDE_DIR NAMES histedit.h) find_library(LibEdit_LIBRARY NAMES edit libedit) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(LibEdit DEFAULT_MSG LibEdit_INCLUDE_DIR LibEdit_LIBRARY) message(STATUS "LibEdit library: ${LibEdit_LIBRARY}") mark_as_advanced(LibEdit_INCLUDE_DIR LibEdit_LIBRARY) if(LibEdit_FOUND AND NOT TARGET LibEdit::LibEdit) add_library(LibEdit::LibEdit UNKNOWN IMPORTED) set_target_properties(LibEdit::LibEdit PROPERTIES IMPORTED_LOCATION "${LibEdit_LIBRARY}" INTERFACE_INCLUDE_DIRECTORIES "${LibEdit_INCLUDE_DIR}" ) endif() opensmt-2.5.2/cmake_modules/FindReadline.cmake000066400000000000000000000017171445011647600213610ustar00rootroot00000000000000# Search for the path containing library's headers find_path(Readline_ROOT_DIR NAMES include/readline/readline.h ) # Search for include directory find_path(Readline_INCLUDE_DIR NAMES readline/readline.h HINTS ${Readline_ROOT_DIR}/include ) # Search for library find_library(Readline_LIBRARY NAMES readline HINTS ${Readline_ROOT_DIR}/lib ) # Hide these variables in cmake GUIs mark_as_advanced( Readline_ROOT_DIR Readline_INCLUDE_DIR Readline_LIBRARY ) MESSAGE(STATUS "Readline library: " ${Readline_LIBRARY} ) include(FindPackageHandleStandardArgs) FIND_PACKAGE_HANDLE_STANDARD_ARGS(Readline DEFAULT_MSG Readline_INCLUDE_DIR Readline_LIBRARY ) if(Readline_FOUND AND NOT TARGET Readline::Readline) add_library(Readline::Readline UNKNOWN IMPORTED) set_target_properties(Readline::Readline PROPERTIES IMPORTED_LOCATION "${Readline_LIBRARY}" INTERFACE_INCLUDE_DIRECTORIES "${Readline_INCLUDE_DIR}" ) endif() opensmt-2.5.2/docs/000077500000000000000000000000001445011647600141455ustar00rootroot00000000000000opensmt-2.5.2/docs/.gitignore000066400000000000000000000000451445011647600161340ustar00rootroot00000000000000*.swp Gemfile.lock howto-serve _site opensmt-2.5.2/docs/Gemfile000066400000000000000000000002741445011647600154430ustar00rootroot00000000000000source 'https://rubygems.org' gem 'github-pages', group: :jekyll_plugins gem 'jekyll' group :jekyll_plugins do gem 'jekyll-sitemap' gem 'jekyll-feed' gem 'jekyll-seo-tag' end opensmt-2.5.2/docs/_config.yml000066400000000000000000000002621445011647600162740ustar00rootroot00000000000000theme: jekyll-theme-dinky title: Opensmt description: Opensmt solver collections: show_downloads: true repository_url: "https://github.com/usi-verification-and-security/opensmt" opensmt-2.5.2/docs/_data/000077500000000000000000000000001445011647600152155ustar00rootroot00000000000000opensmt-2.5.2/docs/_data/navigation.yml000066400000000000000000000001651445011647600201010ustar00rootroot00000000000000- name: Opensmt link: index.html - name: Manual link: manual.html - name: Publications link: publications.html opensmt-2.5.2/docs/_includes/000077500000000000000000000000001445011647600161125ustar00rootroot00000000000000opensmt-2.5.2/docs/_includes/footer.html000066400000000000000000000004351445011647600203000ustar00rootroot00000000000000 opensmt-2.5.2/docs/_includes/head.html000066400000000000000000000011241445011647600176770ustar00rootroot00000000000000 {% seo %}
{% include navigation.html %}
opensmt-2.5.2/docs/_includes/navigation.html000066400000000000000000000012271445011647600211410ustar00rootroot00000000000000

{{ site.title | default: site.github.repository_name }}

{% if site.logo %} Logo {% endif %}

{{ site.description | default: site.github.project_tagline }}

{% for item in site.data.navigation %} {{ item.name }}
{% endfor %}

{% if site.show_downloads %} View On GitHub {% endif %}
opensmt-2.5.2/docs/_includes/tablesorter.html000066400000000000000000000005561445011647600213340ustar00rootroot00000000000000 opensmt-2.5.2/docs/_includes/tail.html000066400000000000000000000012701445011647600177310ustar00rootroot00000000000000
{% include footer.html %}
{% if site.google_analytics %} {% endif %} opensmt-2.5.2/docs/_layouts/000077500000000000000000000000001445011647600160045ustar00rootroot00000000000000opensmt-2.5.2/docs/_layouts/default.html000066400000000000000000000000761445011647600203210ustar00rootroot00000000000000{% include head.html %} {{ content }} {% include tail.html %} opensmt-2.5.2/docs/_layouts/news.html000066400000000000000000000004131445011647600176440ustar00rootroot00000000000000--- layout: default ---

{{ page.title }}

{{ page.newsdate | date_to_string }} {% assign author = site.authors | where: 'short_name', page.author | first %} {{ content }} {% if author %} - {{ page.author }} {% endif %}

opensmt-2.5.2/docs/abstract.bib000066400000000000000000001041241445011647600164300ustar00rootroot00000000000000@string { SCIENCE = "Science" } @string { LNCS = "LNCS" } @string { ACM = "ACM" } @string { AI = "Artificial Intelligence" } @string { AIM = "{AI} Magazine"} @string { AICOM = "{AI} Communications" } @string { CONSTRAINTS = "Constraints" } @string { SV = "Springer" } @string { IEEETRANC = "IEEE Transactions on Computers" } @string { IEEEP = "IEEE Press" } @string { JSAT = "Journal on Satisfiability Boolean Modeling and Computation" } @string { JSC = "Journal of Symbolic Computation"} @string { AMAI = "Annals of Mathematics and Artificial Intelligence"} @string { FI = "Fundamenta Informaticae" } @inproceedings{RakadjievSMO15, author = {Emil Rakadjiev and Taku Shimosawa and Hiroshi Mine and Satoshi Oshima}, title = {Parallel {SMT} Solving and Concurrent Symbolic Execution}, booktitle = {2015 {IEEE} TrustCom/BigDataSE/ISPA, Helsinki, Finland, August 20-22, 2015, Volume 3}, pages = {17--26}, year = {2015}, OPTurl = {http://dx.doi.org/10.1109/Trustcom.2015.608}, doi = {10.1109/Trustcom.2015.608}, timestamp = {Fri, 11 Dec 2015 14:36:57 +0100}, } @inproceedings{AsadiBFHESC18, author = {Sepideh Asadi and Martin Blicha and Grigory Fedyukovich and Antti E. J. Hyv{\"{a}}rinen and Karine Even{-}Mendoza and Natasha Sharygina and Hana Chockler}, title = {Function Summarization Modulo Theories}, booktitle = {{LPAR-22.} 22nd International Conference on Logic for Programming, Artificial Intelligence and Reasoning, Awassa, Ethiopia, 16-21 November 2018}, pages = {56--75}, year = {2018}, publisher = {EasyChair}, series = {EPiC Series in Computing}, volume = {57}, } @inproceedings{MarescottiHS16, author = {Matteo Marescotti and Antti E. J. Hyv{\"{a}}rinen and Natasha Sharygina}, title = {Clause Sharing and Partitioning for Cloud-Based {SMT} Solving}, booktitle = {Automated Technology for Verification and Analysis - 14th International Symposium, {ATVA} 2016, Chiba, Japan, October 17-20, 2016, Proceedings}, pages = {428--443}, year = {2016}, } @inproceedings{HyvarinenMSCS18, author = {Antti E. J. Hyv{\"{a}}rinen and Matteo Marescotti and Parvin Sadigova and Hana Chockler and Natasha Sharygina}, title = {Lookahead-Based {SMT} Solving}, booktitle = {Proc.~LPAR-22}, OPTbooktitle = {{LPAR-22.} 22nd International Conference on Logic for Programming, Artificial Intelligence and Reasoning, Awassa, Ethiopia, 16-21 November 2018}, pages = {418--434}, year = {2018}, publisher = {EasyChair}, series = {EPiC Series in Computing}, volume = {57}, } @inproceedings{MarescottiHS18, author = {Matteo Marescotti and Antti E. J. Hyv{\"{a}}rinen and Natasha Sharygina}, title = {{SMTS:} Distributed, Visualized Constraint Solving}, booktitle = {Proc.~LPAR-22}, OPTbooktitle = {{LPAR-22.} 22nd International Conference on Logic for Programming, Artificial Intelligence and Reasoning, Awassa, Ethiopia, 16-21 November 2018}, pages = {534--542}, year = {2018}, publisher = {EasyChair}, series = {EPiC Series in Computing}, volume = {57}, } @inproceedings{JancikAFHKS16, author = {Pavel Janc{\'{\i}}k and Leonardo Alt and Grigory Fedyukovich and Antti E. J. Hyv{\"{a}}rinen and Jan Kofron and Natasha Sharygina}, title = {{PVAIR:} Partial Variable Assignment InterpolatoR}, booktitle = {Fundamental Approaches to Software Engineering - 19th International Conference, {FASE} 2016, Held as Part of the European Joint Conferences on Theory and Practice of Software, {ETAPS} 2016, Eindhoven, The Netherlands, April 2-8, 2016, Proceedings}, pages = {419--434}, year = {2016}, } @inproceedings{AltHAS17, author = {Leonardo Alt and Antti Eero Johannes Hyv{\"{a}}rinen and Sepideh Asadi and Natasha Sharygina}, title = {Duality-based interpolation for quantifier-free equalities and uninterpreted functions}, booktitle = {2017 Formal Methods in Computer Aided Design, {FMCAD} 2017, Vienna, Austria, October 2-6, 2017}, pages = {39--46}, year = {2017}, } @inproceedings{BlichaHKS19, author = {Martin Blicha and Antti E. J. Hyv{\"{a}}rinen and Jan Kofron and Natasha Sharygina}, title = {Decomposing {Farkas} Interpolants}, booktitle = {Proc.~TACAS 2019}, OPTbooktitle = {Tools and Algorithms for the Construction and Analysis of Systems - 25th International Conference, {TACAS} 2019, Held as Part of the European Joint Conferences on Theory and Practice of Software, {ETAPS} 2019, Prague, Czech Republic, April 6-11, 2019, Proceedings, Part {I}}, pages = {3--20}, year = {2019}, series = LNCS, volume = {11427}, publisher = SV, } @inproceedings{AltACMFHS17, author = {Leonardo Alt and Sepideh Asadi and Hana Chockler and Karine Even{-}Mendoza and Grigory Fedyukovich and Antti E. J. Hyv{\"{a}}rinen and Natasha Sharygina}, title = {{HiFrog}: {SMT}-based Function Summarization for Software Verification}, booktitle = {Proc.~TACAS 2017}, OPTbooktitle = {Tools and Algorithms for the Construction and Analysis of Systems - 23rd International Conference, {TACAS} 2017, Held as Part of the European Joint Conferences on Theory and Practice of Software, {ETAPS} 2017, Uppsala, Sweden, April 22-29, 2017, Proceedings, Part {II}}, pages = {207--213}, year = {2017}, series = LNCS, publisher = SV, volume = {10206}, } @inproceedings{HyvarinenMAS16, author = {Antti E. J. Hyv{\"{a}}rinen and Matteo Marescotti and Leonardo Alt and Natasha Sharygina}, title = {{OpenSMT2}: An {SMT} Solver for Multi-core and Cloud Computing}, booktitle = {Proc.~SAT 2016}, OPTbooktitle = {Theory and Applications of Satisfiability Testing - {SAT} 2016 - 19th International Conference, Bordeaux, France, July 5-8, 2016, Proceedings}, pages = {547--553}, year = {2016}, publisher = SV, volume = {9710}, series = LNCS, } @inproceedings{Holzmann:VMCAI16, author = {Gerard J. Holzmann}, title = {Cloud-Based Verification of Concurrent Software}, booktitle = {Verification, Model Checking, and Abstract Interpretation - 17th International Conference, {VMCAI} 2016, St. Petersburg, FL, USA, January 17-19, 2016. Proceedings}, pages = {311--327}, year = {2016}, url = {http://dx.doi.org/10.1007/978-3-662-49122-5_15}, doi = {10.1007/978-3-662-49122-5_15}, timestamp = {Tue, 05 Jan 2016 12:40:34 +0100}, } @inproceedings{BalyoSS:SAT15, author = {Tomas Balyo and Peter Sanders and Carsten Sinz}, title = {HordeSat: {A} Massively Parallel Portfolio {SAT} Solver}, booktitle = {Theory and Applications of Satisfiability Testing - {SAT} 2015 - 18th International Conference, Austin, TX, USA, September 24-27, 2015. Proceedings}, pages = {156--172}, year = {2015}, url = {http://dx.doi.org/10.1007/978-3-319-24318-4_12}, doi = {10.1007/978-3-319-24318-4_12}, timestamp = {Thu, 17 Sep 2015 13:26:14 +0200}, } @inproceedings{HyvarinenMS:SAT15, author = {Antti E. J. Hyv{\"{a}}rinen and Matteo Marescotti and Natasha Sharygina}, title = {Search-Space Partitioning for Parallelizing {SMT} Solvers}, booktitle = {Proc.~SAT 2015}, OPTbooktitle = {Theory and Applications of Satisfiability Testing, {SAT} 2015, 18th International Conference, Austin, TX, USA, September 24-27, 2015. Proceedings}, pages = {369--386}, year = {2015}, OPTurl = {http://dx.doi.org/10.1007/978-3-319-24318-4_27}, doi = {10.1007/978-3-319-24318-4_27}, timestamp = {Thu, 17 Sep 2015 13:26:14 +0200}, series = LNCS, publisher = SV, volume = {9340}, } @inproceedings{Manthey:PoS2011, author = {Norbert Manthey}, title = {Parallel {SAT} Solving -- Using More Cores}, booktitle = {Easychair Proceedings of the 2nd Pragmatics of SAT Wokshop (PoS11)}, year = {2011}, pages = {1--14}, } @inproceedings{EenS:SAT03, author = {Niklas E{\'e}n and Niklas S{\"o}rensson}, title = {An Extensible {SAT}-solver}, booktitle = {Proc.~SAT 2004}, publisher = SV, series = LNCS, volume = {2919}, year = {2004}, pages = {502--518}, } @inproceedings{MoskewiczMZZM:DAC01, author = {Matthew W. Moskewicz and Conor F. Madigan and Ying Zhao and Lintao Zhang and Sharad Malik}, title = {Chaff: Engineering an Efficient {SAT} Solver}, booktitle = {Proc.~DAC 2001}, publisher = ACM, year = {2001}, pages = {530--535}, } @inproceedings{HolldoblerMS:LPAR2010, author = {Steffen H{\"o}lldobler and Norbert Manthey and Ari Saptawijaya}, title = {Improving Resource-Unaware {SAT} Solvers}, booktitle = {Proc.~LPAR 2010}, publisher = SV, series = LNCS, volume = {6397}, year = {2010}, pages = {519 -- 534}, } @techreport{Biere:2010, author = {Armin Biere}, title = {{Lingeling}, {Plingeling}, {PicoSAT} and {PrecoSAT} at {SAT} race 2010}, institution = {Institute for Formal Models and Verification, Johannes Kepler University}, address = {Altenbergenstr. 69, 4040 Linz, Austria}, series = {Technical Report 10/1}, month = AUG, year = {2010}, } @inproceedings{WintersteigerHM:CAV09, author = {Christoph M. Wintersteiger and Youssef Hamadi and Leonardo Mendon{\c{c}}a de Moura}, title = {A Concurrent Portfolio Approach to {SMT} Solving}, OPTbooktitle = {Computer Aided Verification, 21st International Conference, {CAV} 2009, Grenoble, France, June 26 - July 2, 2009. Proceedings}, booktitle = {Proc.~CAV 2009}, year = {2009}, pages = {715--720}, series = LNCS, volume = {5643}, publisher = SV, } @inproceedings{PalikarevaC:CAV13, author = {Hristina Palikareva and Cristian Cadar}, title = {Multi-solver Support in Symbolic Execution}, OPTbooktitle = {Computer Aided Verification - 25th International Conference, {CAV} 2013, Saint Petersburg, Russia, July 13-19, 2013. Proceedings}, booktitle = {Proc.~CAV 2013}, year = {2013}, pages = {53--68}, series = LNCS, volume = {8044}, publisher = SV, } @inproceedings{BruttomessoPST:TACAS10, author = {Roberto Bruttomesso and Edgar Pek and Natasha Sharygina and Aliaksei Tsitovich}, title = {The {OpenSMT} Solver}, OPTbooktitle = {Tools and Algorithms for the Construction and Analysis of Systems, 16th International Conference, {TACAS} 2010, Held as Part of the Joint European Conferences on Theory and Practice of Software, {ETAPS} 23010, Paphos, Cyprus, March 20 -- 28, 2010. Proceedings}, booktitle = {Proc.~TACAS 2010}, year = {2010}, pages = {150--153}, series = LNCS, volume = {6015}, publisher = {Springer}, } @inproceedings{NieuwenhuisO:RTA05, author = {Robert Nieuwenhuis and Albert Oliveras}, title = {Proof-Producing Congruence Closure}, OPTbooktitle = {Term Rewriting and Applications, 16th International Conference, RTA 2005, Nara, Japan, April 19--21, 2005, Proceedings}, booktitle = {Proc.~RTA 2005}, year = {2005}, pages = {453 -- 468}, publisher = SV, series = LNCS, volume = {3467}, } @inproceedings{SorenssonEen:SAT2003, author = {Niklas E{\'e}n and Niklas S{\"o}rensson}, title = {An Extensible {SAT}-solver}, booktitle = {Proc.\ SAT'03}, OPTbooktitle = {Proceedings of the 6th International Conference on Theory and Applications of Satisfiability Testing (SAT 2003), Selected Revised Papers}, OPTbooktitle = {Theory and Applications of Satisfiability Testing}, OPTeditor = {Enrico Giunchiglia and Armando Tacchella}, year = {2004}, pages = {502--518}, publisher = SV, series = LNCS, volume = {2919}, OPTcrossref = {SAT2003}, } @article{DetlefsNS:JACM05, author = {David Detlefs and Greg Nelson and James B. Saxe}, title = {Simplify: a theorem prover for program checking}, journal = {Journal of the ACM}, year = {2005}, volume = {52}, number = {3}, pages = {365--473}, } @article{DavisLL:ACM1962, author = {Martin Davis and George Logemann and Donald W. Loveland}, title = {A machine program for theorem-proving}, journal = {Commun. {ACM}}, volume = {5}, number = {7}, pages = {394--397}, year = {1962}, url = {http://doi.acm.org/10.1145/368273.368557}, doi = {10.1145/368273.368557}, timestamp = {Thu, 20 Nov 2003 13:05:43 +0100}, } @article{NieuwenhuisOT:JACM06, author = {Robert Nieuwenhuis and Albert Oliveras and Cesare Tinelli}, title = {Solving {SAT} and {SAT} Modulo Theories: From an abstract {Davis}--{Putnam}--{Logemann}--{Loveland} procedure to {DPLL(T)}}, journal = {Journal of the ACM}, year = {2006}, volume = {53}, number = {6}, pages = {937 -- 977}, } @inproceedings{AlbertiBGRS:CAV12, author = {Francesco Alberti and Roberto Bruttomesso and Silvio Ghilardi and Silvio Ranise and Natasha Sharygina}, title = {{SAFARI:} {SMT}-Based Abstraction for Arrays with Interpolants}, OPTbooktitle = {Computer Aided Verification - 24th International Conference, {CAV} 2012, Berkeley, CA, USA, July 7-13, 2012 Proceedings}, booktitle = {Proc.~CAV 2012}, year = {2012}, pages = {679--685}, series = LNCS, volume = {7358}, publisher = SV, } @inproceedings{LiAKGC:POPL14, author = {Yi Li and Aws Albarghouthi and Zachary Kincaid and Arie Gurfinkel and Marsha Chechik}, title = {Symbolic optimization with {SMT} solvers}, OPTbooktitle = {The 41st Annual {ACM} {SIGPLAN-SIGACT} Symposium on Principles of Programming Languages, {POPL} '14, San Diego, CA, USA, January 20-21, 2014}, booktitle = {Proc.~POPL 2014}, year = {2014}, pages = {607--618}, publisher = ACM, } @inproceedings{NieuwenhuisO:SAT06, author = {Robert Nieuwenhuis and Albert Oliveras}, title = {On {SAT} Modulo Theories and Optimization Problems}, OPTbooktitle = {Theory and Applications of Satisfiability Testing - {SAT} 2006, 9th International Conference, Seattle, WA, USA, August 12-15, 2006, Proceedings}, booktitle = {Proc.~SAT 2006}, year = {2006}, pages = {156--169}, series = LNCS, volume = {4121}, publisher = SV, } @inproceedings{BarretCDHJKRT:CAV11, author = {Clark Barrett and Christopher L. Conway and Morgan Deters and Liana Hadarean and Dejan Jovanovic and Tim King and Andrew Reynolds and Cesare Tinelli}, title = {{CVC4}}, OPTbooktitle = {Computer Aided Verification --- 23rd International Conference, {CAV} 2011, Snowbird, UT, USA, July 14 -- 20, 2011. Proceedings}, booktitle = {Proc.~CAV 2011}, year = {2011}, pages = {171 -- 177}, series = LNCS, volume = {6806}, publisher = {Springer}, } @inproceedings{Dutertre:CAV14, author = {Bruno Dutertre}, title = {Yices 2.2}, OPTbooktitle = {Computer Aided Verification --- 26th International Conference, {CAV} 2014, Held as Part of the Vienna Summer of Logic, {VSL} 2014, Vienna, Austria, July 18 -- 22, 2014. Proceedings}, booktitle = {CAV 2014}, year = {2014}, pages = {737 -- 744}, volume = {8599}, publisher = {Springer}, series = LNCS, } @inproceedings{CimattiGSS:TACAS13, author = {Alessandro Cimatti and Alberto Griggio and Bastiaan Joost Schaafsma and Roberto Sebastiani}, title = {The {MathSAT5} {SMT} Solver}, OPTbooktitle = {Tools and Algorithms for the Construction and Analysis of Systems --- 19th International Conference, {TACAS} 2013, Held as Part of the European Joint Conferences on Theory and Practice of Software, {ETAPS} 2013, Rome, Italy, March 16 -- 24, 2013. Proceedings}, booktitle = {Proc.~TACAS 2013}, year = {2013}, pages = {93 -- 107}, series = LNCS, publisher = {Springer}, volume = {7795}, } @inproceedings{MouraB:TACAS08, author = {Leonardo Mendon{\c{c}}a de Moura and Nikolaj Bj{\o}rner}, title = {{Z3:} An Efficient {SMT} Solver}, OPTbooktitle = {Tools and Algorithms for the Construction and Analysis of Systems, 14th International Conference, {TACAS} 2008, Held as Part of the Joint European Conferences on Theory and Practice of Software, {ETAPS} 2008, Budapest, Hungary, March 29 -- April 6, 2008. Proceedings}, booktitle = {Proc.~TACAS 2008}, year = {2008}, pages = {337 -- 340}, series = LNCS, volume = {4963}, publisher = {Springer}, } @article{MarquesSilvaS:IEEETRANC99, author = {Jo{\~a}o P. Marques-Silva and Karem A. Sakallah}, title = {{GRASP}: A Search Algorithm for Propositional Satisfiability}, journal = IEEETRANC, volume = {48}, number = {5}, year = {1999}, pages = {506--521}, OPTpublisher = IEEEP, } @phdthesis{Hyvarinen:PhD, author = {Antti E. J. Hyv\"{a}rinen}, title = {Grid-Based Propositional Satisfiability Solving}, school = {Aalto University School of Science}, year = {2011}, month = {11}, number = {DD118/2011}, address = {Aalto Print, Helsinki, Finland}, } @inproceedings{HyvarinenM:SAT2012, author = {Antti Eero Johannes Hyv{\"{a}}rinen and Norbert Manthey}, title = {Designing Scalable Parallel {SAT} Solvers}, OPTbooktitle = {Theory and Applications of Satisfiability Testing - {SAT} 2012 - 15th International Conference, Trento, Italy, June 17-20, 2012. Proceedings}, booktitle = {Proc.~SAT 2012}, year = {2012}, pages = {214--227}, series = LNCS, volume = {7317}, publisher = SV, } @article{HamadiJS_09, author = {Youssef Hamadi and Said Jabbour and Lakhdar Sais}, title = {{ManySAT}: a Parallel {SAT} Solver}, journal = JSAT, volume = {6}, number = {4}, year = {2009}, pages = {245 -- 262}, } @inproceedings{AudemardHJP:POS14, author = {Gilles Audemard and Beno\^it Hoessen and Sa\"id Jabbour and C\'edric Piette}, title = {Dolius: A Distributed Parallel {SAT} Solving Framework}, booktitle = {POS-14}, OPTeditor = {Daniel Le Berre}, series = {EPiC Series}, volume = {27}, pages = {1-11}, year = {2014}, publisher = {EasyChair}, bibsource = {EasyChair, http://www.easychair.org}, issn = {2040-557X}, } @inproceedings{KatsirelosSSS:AAAI2013, author = {George Katsirelos and Ashish Sabharwal and Horst Samulowitz and Laurent Simon}, title = {Resolution and Parallelizability: Barriers to the Efficient Parallelization of {SAT} Solvers}, OPTbooktitle = {Proceedings of the Twenty-Seventh {AAAI} Conference on Artificial Intelligence, July 14-18, 2013, Bellevue, Washington, {USA.}}, booktitle = {Proc.~AAAI 2013}, year = {2013}, OPTeditor = {Marie desJardins and Michael L. Littman}, publisher = {{AAAI} Press}, } @article{HamadiW:2013, author = {Youssef Hamadi and Christoph M. Wintersteiger}, title = {Seven Challenges in Parallel {SAT} Solving}, journal = AIM, year = {2013}, volume = {34}, number = {2}, pages = {99--106}, } @article{MartinsML:2012, author = {Ruben Martins and Vasco M. Manquinho and In{\^{e}}s Lynce}, title = {An overview of parallel {SAT} solving}, journal = CONSTRAINTS, year = {2012}, volume = {17}, number = {3}, pages = {304--347}, } @inproceedings{BjornerPF:TACAS15, author = {Nikolaj Bj{\o}rner and Anh{-}Dung Phan and Lars Fleckenstein}, title = {{\(\nu\)}Z - An Optimizing {SMT} Solver}, booktitle = {Proc.~TACAS 2015}, OPTbooktitle = {Tools and Algorithms for the Construction and Analysis of Systems - 21st International Conference, {TACAS} 2015, Held as Part of the European Joint Conferences on Theory and Practice of Software, {ETAPS} 2015, London, UK, April 11-18, 2015. Proceedings}, pages = {194--199}, year = {2015}, series = LNCS, volume = {9035}, publisher = SV, } @inproceedings{GhilardiR:IJCAR10, author = {Silvio Ghilardi and Silvio Ranise}, title = {{MCMT:} {A} Model Checker Modulo Theories}, booktitle = {Proc.~IJCAR 2010}, OPTbooktitle = {Automated Reasoning, 5th International Joint Conference, {IJCAR} 2010, Edinburgh, UK, July 16-19, 2010. Proceedings}, pages = {22--29}, year = {2010}, series = LNCS, volume = {6173}, publisher = SV, } @article{HyvarinenJN:JSAT09, author = {Antti Eero Johannes Hyv{\"{a}}rinen and Tommi A. Junttila and Ilkka Niemel{\"{a}}}, title = {Incorporating Clause Learning in Grid-Based Randomized {SAT} Solving}, journal = JSAT, volume = {6}, number = {4}, pages = {223--244}, year = {2009}, } @article{HyvarinenJN:FI11, author = {Antti Eero Johannes Hyv{\"{a}}rinen and Tommi A. Junttila and Ilkka Niemel{\"{a}}}, title = {Partitioning Search Spaces of a Randomized Search}, journal = FI, volume = {107}, number = {2-3}, pages = {289--311}, year = {2011}, } @inproceedings{TakHB:SAT12, author = {Peter van der Tak and Marijn Heule and Armin Biere}, title = {Concurrent Cube-and-Conquer - (Poster Presentation)}, booktitle = {Proc.~SAT 2012}, OPTbooktitle = {Theory and Applications of Satisfiability Testing - {SAT} 2012 - 15th International Conference, Trento, Italy, June 17-20, 2012. Proceedings}, pages = {475--476}, year = {2012}, series = LNCS, volume = {7317}, publisher = SV, } @inproceedings{ChrabakhW:SC03, author = {Wahid Chrabakh and Richard Wolski}, title = {{GridSAT}: {A} Chaff-based Distributed {SAT} Solver for the Grid}, booktitle = {Proc.~SC 2003}, OPTbooktitle = {Proceedings of the {ACM/IEEE} {SC2003} Conference on High Performance Networking and Computing, 15-21 November 2003, Phoenix, AZ, USA, CD-Rom}, pages = {37}, year = {2003}, publisher = ACM, } @inproceedings{HeuleKWB:HVC11, author = {Marijn Heule and Oliver Kullmann and Siert Wieringa and Armin Biere}, title = {Cube and Conquer: Guiding {CDCL} {SAT} Solvers by Lookaheads}, booktitle = {Proc.~HVC 2011}, OPTbooktitle = {Hardware and Software: Verification and Testing - 7th International Haifa Verification Conference, {HVC} 2011, Haifa, Israel, December 6-8, 2011, Revised Selected Papers}, pages = {50--65}, series = LNCS, volume = {7261}, publisher = SV, year = {2012}, } @mastersthesis{Reisenberger:MsC2014, author = {Christian Reisenberger}, title = {{PBoolector}: a Parallel {SMT} Solver for {QF\_BV} by Combining Bit-Blasting with Look-Ahead}, school = {Johannes Kepler Univesit\"{a}t Linz}, address = {Linz, Austria}, year = {2014}, } @article{zhang:psato, author = {H. Zhang and M. Bonacina and J. Hsiang}, title = {{PSATO}: {A} Distributed Propositional Prover and its Application to Quasigroup Problems}, journal = JSC, volume = {21}, number = {4}, pages = {543--560}, year = {1996}, url = {citeseer.ist.psu.edu/zhang96psato.html} } @article{boehm:parallelsolver, author = {Max B{\"o}hm and Ewald Speckenmeyer}, title = {A Fast Parallel {SAT}-solver: Efficient workload balancing}, journal = AMAI, volume = {17}, number = {4--3}, year = {1996}, pages = {381--400} } @inproceedings{DeharbeFMP:CADE11, author = {David D{\'{e}}harbe and Pascal Fontaine and Stephan Merz and Bruno Woltzenlogel Paleo}, title = {Exploiting Symmetry in {SMT} Problems}, OPTbooktitle = {Automated Deduction - {CADE-23} - 23rd International Conference on Automated Deduction, Wroclaw, Poland, July 31 - August 5, 2011. Proceedings}, booktitle = {Proc.~CADE-13}, pages = {222--236}, year = {2011}, series = LNCS, volume = {6803}, publisher = SV, } @incollection{HeuleM09, author = {Marijn Heule and Hans van Maaren}, title = {Look-Ahead Based {SAT} Solvers}, booktitle = {Handbook of Satisfiability}, pages = {155--184}, year = {2009}, OPTeditor = {Armin Biere and Marijn Heule and Hans van Maaren and Toby Walsh}, series = {Frontiers in Artificial Intelligence and Applications}, volume = {185}, publisher = {{IOS} Press}, isbn = {978-1-58603-929-5}, timestamp = {Wed, 16 Sep 2009 11:21:15 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/series/faia/2009-185}, bibsource = {dblp computer science bibliography, http://dblp.org} } @inproceedings{SebastianiT12, author = {Roberto Sebastiani and Silvia Tomasi}, title = {Optimization in {SMT} with {LA(Q)} Cost Functions}, booktitle = {Proc. IJCAR 2012}, OPTbooktitle = {Automated Reasoning - 6th International Joint Conference, {IJCAR} 2012, Manchester, UK, June 26-29, 2012. Proceedings}, pages = {484--498}, year = {2012}, series = LNCS, volume = {7364}, publisher = SV, } @inproceedings{BCCFZ:DAC99, author = {A. Biere and A. Cimatti and E.M. Clarke and M. Fujita and Y. Zhu}, title = {Symbolic Model Checking Using {SAT} Procedures instead of {BDDs}}, booktitle = {DAC}, year = {1999}, pages = {317-320}, ee = {http://doi.acm.org/10.1145/309847.309942}, bibsource = {DBLP, http://dblp.uni-trier.de} } @inproceedings{BCCZ99, author = {Armin Biere and Alessandro Cimatti and Edmund M. Clarke and Yunshan Zhu}, title = {Symbolic Model Checking without {BDDs}}, booktitle = {Proc.~TACAS '99}, series = LNCS, publisher = SV, volume = {1579}, year = {1999}, pages = {193--207}, } @inproceedings{HJMS:SPIN03, author = {Thomas A. Henzinger and Ranjit Jhala and Rupak Majumdar and Gregoire Sutre}, title = {Software Verification with {Blast}}, booktitle = {Tenth International Workshop on Model Checking of Software (SPIN)}, series = LNCS, volume = {2648}, publisher = SV, year = {2003}, pages = {235--239} } @inproceedings{DutertreM:CAV2006, author = {Bruno Dutertre and Leonardo Mendon{\c{c}}a de Moura}, title = {A Fast Linear-Arithmetic Solver for {DPLL(T)}}, booktitle = {Proc.~CAV 2006}, pages = {81--94}, year = {2006}, volume = {4144}, series = LNCS, publisher = SV, } @inproceedings{YordanovWHK:NFM13, author = {Boyan Yordanov and Christoph M. Wintersteiger and Youssef Hamadi and Hillel Kugler}, title = {SMT-Based Analysis of Biological Computation}, booktitle = {Proc.~NFM 2013}, pages = {78--92}, year = {2013}, series = LNCS, volume = {7871}, publisher = SV, } @article{SebastianiT:ACMTCL15, author = {Roberto Sebastiani and Silvia Tomasi}, title = {Optimization Modulo Theories with Linear Rational Costs}, journal = {{ACM} Transactions on Computational Logic}, volume = {16}, number = {2}, pages = {12:1--12:43}, year = {2015}, } @article{HyvarinenMS:SAT2015, author = {Antti E. J. Hyv{\"a}rinen and Matteo Marescotti and Natasha Sharygina}, title = {Search-Space Partitioning for Parallelizing {SMT} Solvers}, pages = {369--386}, year = {2015}, booktitle = {Proc.\ SAT 2015}, volume = {9340}, series = LNCS, publisher = SV, } @article{HyvarinenJN:SAT2006, author = {Antti E. J. Hyv{\"a}rinen and Tommi Junttila and Ilkka Niemel{\"a}}, title = {A Distribution Method for Solving {SAT} in Grids}, booktitle = {Proc.\ SAT 2006}, pages = {430--435}, year = {2006}, series = LNCS, volume = {4121}, publisher = SV, } @inproceedings{FSS_TACAS13, title = {{eVolCheck}: Incremental Upgrade Checker for {C}}, OPTbooktitle = {19th International Conference on Tools and Algorithms for the Construction and Analysis of Systems (TACAS 2013)}, booktitle = {Proc.~TACAS 2013}, year = {2013}, pages = {292-307}, volume = {7795}, series = LNCS, publisher = SV, author = {Grigory Fedyukovich and Ondrej Sery and Natasha Sharygina}, } @inproceedings{SFS_ATVA12, author = {Ondrej Sery and Grigory Fedyukovich and Natasha Sharygina}, title = {{FunFrog}: Bounded Model Checking with Interpolation-based Function Summarization}, OPTbooktitle = {The 10th International Symposium on Automated Technology for Verification and Analysis (ATVA 2012)}, booktitle = {Proc.~ATVA 2012}, pages = {203-207}, volume = {7561}, publisher = SV, series = LNCS, year = {2012}, } @inproceedings{RolliniAFHS:LPAR2013, author = {Simone Fulvio Rollini and Leonardo Alt and Grigory Fedyukovich and Antti Eero Johannes Hyv{\"{a}}rinen and Natasha Sharygina}, title = {{PeRIPLO}: {A} Framework for Producing Effective Interpolants in {SAT}-Based Software Verification}, OPTbooktitle = {Logic for Programming, Artificial Intelligence, and Reasoning - 19th International Conference, LPAR-19, Stellenbosch, South Africa, December 14-19, 2013. Proceedings}, booktitle = {Proc.~LPAR 2013}, pages = {683--693}, year = {2013}, series = LNCS, volume = {8312}, publisher = SV, } @inproceedings{AltFHS:VSTTE2015, author = {Leonardo Alt and Grigory Fedyukovich and Antti E. J. Hyv{\"{a}}rinen and Natasha Sharygina}, title = {A Proof-Sensitive Approach for Small Propositional Interpolants}, OPTbooktitle = {Verified Software: Theories, Tools, and Experiments - 7th International Conference, {VSTTE} 2015, San Francisco, CA, USA, July 18-19, 2015. Revised Selected Papers}, booktitle = {Proc.~VSTTE 2015}, pages = {1--18}, series = LNCS, volume = {9593}, publisher = SV, year = {2016}, } @article{HubermanLH_science97, author = {Bernardo A. Huberman and Rajan M. Lukose and Tad Hogg}, title = {An Economics Approach to Hard Computational Problems}, journal = SCIENCE, volume = {275}, number = {5296}, pages = {51--54}, year = {1997}, } @inproceedings{JovanovicD:FMCAD16, author = {Dejan Jovanovic and Bruno Dutertre}, title = {Property-directed k-induction}, booktitle = {Proc.~FMCAD 2016}, OPTbooktitle = {2016 Formal Methods in Computer-Aided Design, {FMCAD} 2016, Mountain View, CA, USA, October 3-6, 2016}, pages = {85--92}, year = {2016}, OPTeditor = {Ruzica Piskac and Muralidhar Talupur}, publisher = {{IEEE}}, } @inproceedings{AltHAS:FMCAD17, author = {Leonardo Alt and Antti Eero Johannes Hyv{\"{a}}rinen and Sepideh Asadi and Natasha Sharygina}, title = {Duality-based interpolation for quantifier-free equalities and uninterpreted functions}, booktitle = {Proc.~FMCAD 2017}, OPTbooktitle = {2017 Formal Methods in Computer Aided Design, {FMCAD} 2017, Vienna, Austria, October 2-6, 2017}, pages = {39--46}, year = {2017}, OPTeditor = {Daryl Stewart and Georg Weissenbacher}, publisher = {{IEEE}}, } @inproceedings{DutertreM:CAV06, author = {Bruno Dutertre and Leonardo Mendon{\c{c}}a de Moura}, title = {A Fast Linear-Arithmetic Solver for {DPLL(T)}}, booktitle = {Proc.~CAV 2006}, OPTbooktitle = {Computer Aided Verification, 18th International Conference, {CAV} 2006, Seattle, WA, USA, August 17-20, 2006, Proceedings}, pages = {81--94}, year = {2006}, OPTeditor = {Thomas Ball and Robert B. Jones}, series = {LNCS}, volume = {4144}, publisher = {Springer}, } @article{DetlefsNS:JAC05, author = {David Detlefs and Greg Nelson and James B. Saxe}, title = {Simplify: a theorem prover for program checking}, journal = {J. {ACM}}, volume = {52}, number = {3}, pages = {365--473}, year = {2005}, } opensmt-2.5.2/docs/abstract.tex000066400000000000000000000111461445011647600164750ustar00rootroot00000000000000\documentclass{easychair} \usepackage{hyperref} \title{The OpenSMT Solver in SMT-COMP 2019} \author{ Martin Blicha \and Antti E. J. Hyv{\"a}rinen \and Matteo Marescotti \and Natasha Sharygina \\ } \institute{Universit{\`a} della Svizzera italiana (USI), Lugano, Switzerland} \date{} \titlerunning{The OpenSMT Solver in SMT-COMP 2019} \authorrunning{M. Blicha, A. E. J. Hyv{\"a}rinen, M. Marescotti, and N. Sharygina} \begin{document} \maketitle \section{Overview} OpenSMT~\cite{HyvarinenMAS16} is a T-DPLL based SMT solver~\cite{NieuwenhuisOT:JACM06} that has been developed at USI, Switzerland, since 2008. The solver is written in {\tt C++} and currently supports the quantifier-free logics of equality with uninterpreted functions (QF\_UF), and linear real arithmetic (QF\_LRA). The solver has a rudimentary support for quantifier-free linear integer arithmetic (QF\_LIA) based on branch-and-bound, and supports some aspects of bit-vector logic (QF\_BV). In comparison to 2018, the 2019 competition entry features a wide range of performance improvements in simplification, the Simplex algorithm~\cite{DutertreM:CAV06}, and the Egraph algorithm~\cite{DetlefsNS:JAC05}, several bug fixes related to solver soundness, and improved support for the logics. In the process, the solver high-level architecture improved and low-level code cleaning resulted in fewer compiler warnings. The solver development process is better defined in comparison to the previous state. The main public repository is now hosted in GitHub, where the commit process is integrated with Travis CI to ensure the passing of regression tests and different compilation. Commits are integrated to the master branch through pull requests once they pass a human review and the Travis CI configuration. OpenSMT features not exercised in the competition include support for a wide range of interpolation algorithms for propositional logic~\cite{AltFHS:VSTTE2015}, linear real arithmetic~\cite{BlichaHKS19}, and uninterpreted functions~\cite{AltHAS:FMCAD17}; an experimental look\-ahead-based search algorithm~\cite{HyvarinenMSCS18} as an alternative to the more standard CDCL algorithm; and features that support search-space partitioning in particular designed for parallel solving~\cite{HyvarinenMS:SAT15}. \section{External Code and Contributors} The SAT solver driving OpenSMT is based on the MiniSAT solver~\cite{EenS:SAT03}, and the rational number implementation is inspired by a library written by David Monniaux. Several people have directly contributed to the OpenSMT code. In alphabetical order, the major contributors are % Leonardo Alt (Ethereum Foundation), Sepideh Asadi (USI), Martin Blicha (USI, Charles University), Roberto Bruttomesso (Cybersecurity / Nozomi Networks), Antti E. J. Hyv{\"a}rinen (USI), Matteo Marescotti (USI), Edgar Pek (University of Illinois, Urbana-Champaign), Simone Fulvio Rollini (United Technologies Research Center), Parvin Sadigova (King's College London), and Aliaksei Tsitovich (Sonova). % The solver is being developed in Natasha Sharygina's software verification group at USI. \section{Utilization} OpenSMT is used in a range of projects as a back-end solver. Recent examples include its use as an interpolation engine of the Sally model checker~\cite{JovanovicD:FMCAD16} which won the transition systems category in the constrained Horn clause competition 2019. OpenSMT also forms the basis of our own model checkers such as HiFrog~\cite{AltACMFHS17}. OpenSMT is compatible with the SMTS parallelization framework~\cite{MarescottiHS18}. \section{Availability} The source code repository and more information on the solver is available at \begin{itemize} \item \url{https://github.com/usi-verification-and-security/opensmt} and \item \url{http://verify.inf.usi.ch/opensmt} \end{itemize} \iffalse in chronological order, work on interpolation algorithms~\cite{BlichaHKS19,AltHAS17,JancikAFHKS16,AsadiBFHESC18} and parallel SMT solving~\cite{HyvarinenMSCS18,MarescottiHS18,HyvarinenMS:SAT15}. OpenSMT2 is used as the back-end in model-checking tools HiFrog~\cite{AltACMFHS17}, eVolCheck~\cite{FSS_TACAS13}, FunFrog~\cite{SFS_ATVA12}, and PeRIPLO~\cite{RolliniAFHS:LPAR2013,AltFHS:VSTTE2015}. OpenSMT2 is a supported engine in the parallel solving framework SMTS~\cite{MarescottiHS16}. \section{Acknowledgements} We thank everyone who helped developing OpenSMT2. In particular, Leonardo Alt, Sepideh Asadi, Martin Blicha, Roberto Bruttomesso, Antti E. J. Hyv{\"a}rinen, Matteo Marescotti, Edgar Pek, Simone Fulvio Rollini, Parvin Sadigova, Natasha Sharygina, Aliaksei Tsitovich. \fi \bibliography{abstract} \bibliographystyle{plain} \end{document} opensmt-2.5.2/docs/easychair.cls000066400000000000000000000533431445011647600166300ustar00rootroot00000000000000% % Some credits % \def\easychairstyleauthor{easychair class style, by Serguei A. Mokhov and Andrei Voronkov <10 December 2015>} \def\easychairstylerevision{CVS Revision: $Id: easychair.cls,v 3.4 2017/03/26 09:52 voronkov Exp $} \def\easychairstylepurpose{Designed for easyChair.org, under guidelines and suggestions of} \def\easychairstylevoronkov{\space\space\space\space\space\space\space\space\space\space\space\space\space Andrei Voronkov , and} \def\easychairstylesutcliffe{\space\space\space\space\space\space\space\space\space\space\space\space\space Geoff Sutcliffe } \def\easychairstylecopyright{Copyright terms are that of easychair.org} \def\easychairstylebugs{For bug reports, please contact } \everyjob{\typeout{\easychairstyleauthor}} \everyjob{\typeout{\easychairstylerevision}} \everyjob{\typeout{\easychairstylepurpose}} \everyjob{\typeout{\easychairstylevoronkov}} \everyjob{\typeout{\easychairstylesutcliffe}} \everyjob{\typeout{\easychairstylecopyright}} \everyjob{\typeout{\easychairstylebugs}} \immediate\write10{\easychairstyleauthor} \immediate\write10{\easychairstylerevision} \immediate\write10{\easychairstylepurpose} \immediate\write10{\easychairstylevoronkov} \immediate\write10{\easychairstylesutcliffe} \immediate\write10{\easychairstylecopyright} \immediate\write10{\easychairstylebugs} % % Require LaTeX 2.09 or later % \NeedsTeXFormat{LaTeX2e}[1995/12/01] \ProvidesClass{easychair}[2017/03/26 v3.5] \def\@tempa#1#2\@nil{\edef\@classname{#1}} \expandafter\@tempa\@currnamestack{}{}{}\@nil \ifx\@classname\@empty \edef\@classname{\@currname}\fi \RequirePackage{xcolor} % % Debug % \def\easychairdebug#1{\gdef\@EasyDebug{#1}} \def\@EasyDebug{} \newif\ifdebug \debugfalse \DeclareOption{debug}{\debugtrue} \newif\ifEPiC \EPiCfalse \DeclareOption{EPiC}{\EPiCtrue} \newif\ifKalpa \Kalpafalse \DeclareOption{Kalpa}{\Kalpatrue} % EPiC with the empty header \newif\ifEPiCempty \EPiCemptyfalse \DeclareOption{EPiCempty}{\EPiCemptytrue} % Kalpa with the empty header \newif\ifKalpaempty \Kalpaemptyfalse \DeclareOption{Kalpaempty}{\Kalpa emptytrue} \newif\ifEPiCfinal \EPiCfinalfalse \DeclareOption{EPiCfinal}{\EPiCfinaltrue} \def\easychairframe#1{\gdef\@EasyFrame{#1}} \def\@EasyFrame{} \newif\ifframe \framefalse \DeclareOption{frame}{\frametrue} \def\easychairverbose#1{\gdef\@EasyVerbose{#1}} \def\@EasyVerbose{} \newif\ifverbose \verbosefalse \DeclareOption{verbose}{\verbosetrue} % % Thesis % Perh Geoff, February 23, 2010 with support from Andrei % \def\easythesis#1{\gdef\@EasyThesis{#1}} \def\@EasyThesis{} \newif\ifthesis \thesisfalse \DeclareOption{thesis}{\thesistrue} % % Times New Roman or not % \def\easytimes#1{\gdef\@EasyTimes{#1}} \def\@EasyTimes{} \newif\ifnotimes \notimesfalse \DeclareOption{notimes}{\notimestrue} \newif\ifwithtimes \withtimesfalse \DeclareOption{withtimes}{\withtimestrue} %% Code added to use llncs style author list \newcounter{@inst} \newcounter{@auth} \newcounter{auco} \newdimen\instindent \def\institute#1{\gdef\@institute{#1}} \def\institutename{\par \begingroup \parskip=\z@ \parindent=\z@ \setcounter{@inst}{1}% \def\and{\par\stepcounter{@inst}% \noindent$^{\the@inst}$\enspace\ignorespaces}% \setbox0=\vbox{\def\thanks##1{}\@institute}% \ifnum\c@@inst=1\relax \gdef\fnnstart{0}% \else \xdef\fnnstart{\c@@inst}% \setcounter{@inst}{1}% \noindent$^{\the@inst}$\enspace \fi \ignorespaces \@institute\par \endgroup} \def\inst#1{\unskip$^{#1}$} \def\fnmsep{\unskip$^,$} \def\email#1{{\tt#1}} %% \newif\ifauthorundefined \authorundefinedtrue \let\oldauthor=\author \renewcommand {\author} [1] {% \ifauthorundefined \oldauthor{#1} \authorundefinedfalse \else \PackageWarning{easychair}{Another use of author ignored} \fi } \newif\iftitleundefined \titleundefinedtrue \let\oldtitle=\title \renewcommand {\title} [1] { \iftitleundefined \oldtitle{#1} \titleundefinedfalse \else \PackageWarning{easychair}{Another use of title ignored} \fi } % % Running heads definitions % %\def\titlerunning#1{\gdef\@titleRunning{#1}} %\def\authorrunning#1{\gdef\@authorRunning{#1}} %\titlerunning{easychair: Running title head is undefined.} %\authorrunning{easychair: Running author head is undefined.} \newif\iftitlerunningundefined \titlerunningundefinedtrue \newif\ifauthorrunningundefined \authorrunningundefinedtrue \gdef\@titleRunning{easychair: Running title head is undefined.} \gdef\@authorRunning{easychair: Running author head is undefined.} \def\titlerunning#1 { \iftitlerunningundefined \gdef\@titleRunning{#1} \titlerunningundefinedfalse \else \PackageWarning{easychair}{Another use of titlerunning ignored} \fi } \def\authorrunning#1 { \ifauthorrunningundefined \gdef\@authorRunning{#1} \authorrunningundefinedfalse \else \PackageWarning{easychair}{Another use of authorrunning ignored} \fi } % % Affiliations % \newcommand{\affiliation}[1]{\footnotesize{#1}\vspace{-3pt}} % % Decide between letter and A4 paper formats % as well as orientation % % Default is 'letterpaper' \def\paperformat#1{\gdef\@PaperFormat{#1}} \def\@PaperFormat{letterpaper} \newif\ifletterpaper \newif\ifafourpaper \newif\ifcustompaper \letterpapertrue \DeclareOption{letterpaper}{\paperformat{letterpaper}\afourpaperfalse\custompaperfalse} \DeclareOption{a4paper}{\paperformat{a4paper}\afourpapertrue\letterpaperfalse\custompaperfalse} \DeclareOption{custompaper}{\paperformat{letterpaper}\afourpaperfalse\letterpaperfalse\custompapertrue} \ExecuteOptions{letterpaper} \newlength{\@LMarginSize} \newlength{\@RMarginSize} \newlength{\@TMarginSize} \newlength{\@BMarginSize} \DeclareOption{lmargin}{} \DeclareOption{rmargin}{} \DeclareOption{tmargin}{} \DeclareOption{bmargin}{} % Default is portrait {} \def\paperorientation#1{\gdef\@PaperOrientation{#1}} \def\@PaperOrientation{} \DeclareOption{portrait}{\paperorientation{}} \DeclareOption{landscape}{\paperorientation{landscape}} % Two sided running heads for titlerunning and author running % twosided is the default \newif\iftwosided \twosidedfalse \DeclareOption{onesided}{} \DeclareOption{twosided}{\twosidedtrue} % % Decide between 1- or 2-column formats % \def\columnCount#1{\gdef\@ColumnCount{#1}} \def\@ColumnCount{onecolumn} \DeclareOption{onecolumn}{} \DeclareOption{twocolumn}{\columnCount{twocolumn}} % % Decide on line spacing % \def\lineSpacing#1{\gdef\@LineSpacing{#1}} \def\@LineSpacing{1.0} \DeclareOption{zerospacing}{\lineSpacing{0.0}} \DeclareOption{singlespacing}{\lineSpacing{1.0}} \DeclareOption{lineandhalfspacing}{\lineSpacing{1.5}} \DeclareOption{doublespacing}{\lineSpacing{2.0}} \DeclareOption{0.0}{\lineSpacing{0.0}} \DeclareOption{1.0}{\lineSpacing{1.0}} \DeclareOption{1.5}{\lineSpacing{1.5}} \DeclareOption{2.0}{\lineSpacing{2.0}} \DeclareOption{0.0pt}{\lineSpacing{0.0}} \DeclareOption{1.0pt}{\lineSpacing{1.0}} \DeclareOption{1.5pt}{\lineSpacing{1.5}} \DeclareOption{2.0pt}{\lineSpacing{2.0}} % % Font point size; default is 10pt % % The \headheight will have to be changed later accordingly % such that fancyhdr does not complain it is too small. % \def\baseFontSize#1{\gdef\@BaseFontSize{#1}} \def\headHeightSize#1{\gdef\@HeadHeightSize{#1}} \def\headSepSize#1{\gdef\@HeadSepSize{#1}} \def\footSkipSize#1{\gdef\@FootSkipSize{#1}} \def\@BaseFontSize{10pt} \def\@HeadHeightSize{12.0pt} \def\@HeadSepSize{16.0pt} % instead of the default 25pt \def\@FootSkipSize{26.0pt} % instead of the default 30pt \DeclareOption{8pt}{\PackageWarning{easychair}{Option '\CurrentOption' is not supported.}} \DeclareOption{9pt}{\PackageWarning{easychair}{Option '\CurrentOption' is not supported.}} \DeclareOption{10pt}{\baseFontSize{10pt}\headHeightSize{12.0pt}\headSepSize{16.0pt}\footSkipSize{26pt}} \DeclareOption{11pt}{\baseFontSize{11pt}\headHeightSize{13.6pt}\headSepSize{23.0pt}\footSkipSize{28pt}} \DeclareOption{12pt}{\baseFontSize{12pt}\headHeightSize{14.5pt}\headSepSize{25.0pt}\footSkipSize{30pt}} \ExecuteOptions{10pt} % % Page sizing % %\newif\iffullpage %\newif\ifsavetrees % %\DeclareOption{fullpage}{\fullpagetrue} %\DeclareOption{savetrees}{\savetreestrue} % Bark at any unknown package option \DeclareOption*{\PackageWarning{easychair}{Unknown option '\CurrentOption'}} \DeclareOption*{\PassOptionsToPackage{\CurrentOption}{geometry}} %\DeclareOption*{\PassOptionsToClass{\CurrentOption}{article}} %\ExecuteOptions{centertags,portrait,10pt,twoside,onecolumn,final} %\ExecuteOptions{} \ProcessOptions\relax % % Required packages and classes. % % All must be standard as per most common LaTeX % distributions. % \ifthesis \LoadClass[\@PaperFormat,\@PaperOrientation,\@ColumnCount,\@BaseFontSize,twoside]{report} \RequirePackage{makeidx} \else % We are an article (more customized later) \LoadClass[\@PaperFormat,\@PaperOrientation,\@ColumnCount,\@BaseFontSize,twoside]{article} %\LoadClass[\@PaperFormat,\@PaperOrientation,\@ColumnCount,\@BaseFontSize]{article} \fi % Require UTF8 encoding, per Andrei Voronkov, to accomodate % all sorts of author names. %\RequirePackage[utf8]{inputenc} % To ensure the footnotes are always at the bottom. % IMPORTANT: footmisc should precede hyperref for the footnotes to hyperlink % correctly to their pages where they are at instead of always at % page 1. Per bug reports from a couple of users and a suggestion by % Uwe Pfeiffer. \RequirePackage[bottom]{footmisc} % TOC/thumbnail LHS preview in the PDFs as well as active URLs and other cross-refs % Newer versions of hyperref declare a4paper or letterpaper as obsolete and issue warnings \definecolor{linkcolor}{RGB}{170,0,0} % aa0000 \definecolor{citecolor}{RGB}{44,160,46} % 2ca02d \definecolor{urlcolor}{RGB}{0,51,153} % 003399 \RequirePackage[linktocpage,pdfcreator=easychair.cls-3.4,colorlinks=True,urlcolor=urlcolor,citecolor=citecolor,linkcolor=linkcolor]{hyperref} % Traditional graphics processing \RequirePackage{graphicx} %\RequirePackage{pdflscape} %\RequirePackage{lscape} %% Fonts, generally more compact but preserving point size % Pick "Times Roman" as a base font unless explicitly told not to \ifnotimes \ifwithtimes \PackageWarning{easychair}{Cannot really use 'notimes' and 'withtimes' together} \PackageWarning{easychair}{Defaulting to 'notimes'...} \else \PackageWarning{easychair}{'notimes' has been deprecated as it is the default in 2.0} \fi \else \ifwithtimes \RequirePackage{mathptmx} \fi \fi % Pick "Helvetica" as a "Sans-Serif" font %\RequirePackage[scaled=.85]{helvet} % For algorithm and source code listings \RequirePackage{listings} %% Different Math and non-Math symbols and definitions \RequirePackage{latexsym} \RequirePackage{amsthm} \RequirePackage{empheq} %% Line spacing to be applied AFTER the above space saving packages \renewcommand{\baselinestretch}{\@LineSpacing} %% Final text printing area, per Geoff Sutcliffe \RequirePackage{keyval} \define@key{Ec}{lmargin}{\Ec@defbylen{lmargin}{#1}} \newlength{\@MarginSize} \setlength{\@MarginSize}{1in} \setlength{\@LMarginSize}{\@MarginSize} %\setlength{\@LMarginSize}{\Ec@lmargin} \setlength{\@RMarginSize}{\@MarginSize} \setlength{\@TMarginSize}{\@MarginSize} \setlength{\@BMarginSize}{\@MarginSize} % Head height is dependent on the font point size \setlength{\headheight}{\@HeadHeightSize} \setlength{\headsep}{\@HeadSepSize} \setlength{\footskip}{\@FootSkipSize} \ifletterpaper \immediate\write10{easychair: Selecting letter paper margin sizes.} \RequirePackage[% papersize={8.5in,11in}, total={145mm,224mm}, centering, twoside, includeheadfoot]{geometry} \fi \ifafourpaper \immediate\write10{easychair: Selecting A4 paper margin sizes.} \RequirePackage[% papersize={210mm,297mm}, total={145mm,224mm}, centering, twoside, includeheadfoot]{geometry} \fi \ifcustompaper \immediate\write10{easychair: Selecting custom paper margin sizes.} \RequirePackage[% papersize={189mm,246mm}, total={145mm,224mm}, top=9mm, left=24mm, twoside, includeheadfoot]{geometry} \headHeightSize{12.0pt} \headSepSize{16.0pt} \footSkipSize{26pt} \fi %\setlength{\textwidth}{16cm} %\setlength{\textheight}{9in} % % Volume % \RequirePackage{lastpage} \newif\ifvolumeundefined \volumeundefinedtrue % e.g. % \volumeinfo % {J. Bloe} % editor(s) #1 % {1} % No. of editors #2 % {LICS 2008} % event title #3 % {1} % volume number #4 % {4} % issue #5 % {134} % start page #6 \def\@EasyFontStyle{\footnotesize} \newcommand{\headfootstyle}[1]{\def\@EasyFontStyle{#1}} \def\@EasyVolumeInfo{} \ifthesis \newcommand{\volumeinfo}[6] {\PackageWarning{easychair}{Cannot use volumeinfo with 'thesis' option. Ignoring...}} \else \newcommand{\volumeinfo}[6]{% \ifvolumeundefined % \def\@makefntext##1{\noindent ##1}% \def\@EasyEdsNames{#1}% \def\@EasyEds{ed.}% \def\@EasyEvent{#3}% \def\@EasyVolume{}% \def\@EasyIssue{}% \def\@EasyFirstPage{#6}% \ifnum #2>1 \gdef\@EasyEds{eds.}\fi% \ifnum #4>0 \gdef\@EasyVolume{; Volume #4}\fi% \ifnum #5>0 \gdef\@EasyIssue{, issue: #5} \fi% % \footnotetext[0]{\sf \@EasyEdsNames (\@EasyEds); \@EasyEvent\@EasyVolume\@EasyIssue, pp. #6-\pageref*{LastPage}}% % \def\@EasyVolumeInfo{\footnotesize{\sf\@EasyEdsNames~(\@EasyEds); \@EasyEvent\@EasyVolume\@EasyIssue, pp. \@EasyFirstPage--\pageref*{LastPage}}}% \def\@EasyVolumeInfo{\@EasyFontStyle\@EasyEdsNames~(\@EasyEds); \@EasyEvent\@EasyVolume\@EasyIssue, pp. \@EasyFirstPage--\pageref*{LastPage}}% %\def\@makefntext##1{\noindent\@makefnmark##1}% \setcounter{page}{\@EasyFirstPage} \volumeundefinedfalse \else {\PackageWarning{easychair}{May not redefine volumeinfo}} \fi } \fi \def\@EventInfo{} \def\@VolumeInfo{} % % Allow for more space to place floats. % \renewcommand{\topfraction}{0.95} \renewcommand{\bottomfraction}{0.95} \renewcommand{\textfraction}{0.05} \renewcommand{\floatpagefraction}{0.8} % % Running heads and ``foots'' % \RequirePackage{fancyhdr} \pagestyle{fancy} \fancyhead{} %\ifdebug % \iftwosided % \fancyhead[RE]{\overline{\@titleRunning}} % \fancyhead[RO]{\overline{\@authorRunning}} % \else % \fancyhead[LO,LE]{\begin{math}\overline{\mbox{\@titleRunning}}\end{math}} % \fancyhead[RO,RE]{\begin{math}\overline{\mbox{\@authorRunning}}\end{math}} % \fi %\else \iftwosided \fancyhead[RE]{{\@EasyFontStyle\@titleRunning}} \fancyhead[RO]{{\@EasyFontStyle\@authorRunning}} \else \fancyhead[LO,LE]{{\@EasyFontStyle\@titleRunning}} \fancyhead[RO,RE]{{\@EasyFontStyle\@authorRunning}} \fi %\fi \fancyfoot{} \ifodd\c@page \fancyfoot[LO]{{\@EasyFontStyle\@VolumeInfo}} \fancyfoot[RE]{{\@EasyFontStyle\@EventInfo}} \else \fancyfoot[RE]{{\@EasyFontStyle\@VolumeInfo}} \fancyfoot[LO]{{\@EasyFontStyle\@EventInfo}} \fi \ifodd\c@page \fancyfoot[RO]{{\normalsize\thepage}} \fancyfoot[LE]{{\normalsize\thepage}} \else \fancyfoot[LE]{{\normalsize\thepage}} \fancyfoot[RO]{{\normalsize\thepage}} \fi \renewcommand{\headrulewidth}{0pt} \renewcommand{\footrulewidth}{0pt} %\fi % Suppress the default date, per Geoff \date{} % For the first page \fancypagestyle{plain}{% \fancyhf{} % clear all header and footer fields \ifodd\c@page \fancyfoot[L]{\@EasyVolumeInfo{}}% \fancyfoot[R]{} \else \fancyfoot[R]{\@EasyVolumeInfo}% \fancyfoot[L]{} \fi \renewcommand{\headrulewidth}{0pt} \renewcommand{\footrulewidth}{0pt}} \def\@maketitle{% %% Code added to use llncs style author list \def\andname{and} \def\lastandname{\unskip, and} \def\lastand{\ifnum\value{@inst}=2\relax \unskip{} \andname\ \else \unskip \lastandname\ \fi}% \def\and{\stepcounter{@auth}\relax \ifnum\value{@auth}=\value{@inst}% \lastand \else \unskip, \fi}% %% \newpage \null % Facelift a bit the title and make it bold, per Geoff \vspace{-1cm} \begin{center}% \let\footnote\thanks% \ifwithtimes {\LARGE{\@title}\par} \else {\LARGE\@title\par} \fi \vskip \baselineskip \@date {\large \setbox0=\vbox{\setcounter{@auth}{1}\def\and{\stepcounter{@auth}}% \def\thanks##1{}\@author}% \global\value{@inst}=\value{@auth}% \global\value{auco}=\value{@auth}% \setcounter{@auth}{1}% {\lineskip .5em \noindent\ignorespaces \@author\vskip.35cm}} {\small\institutename} \end{center}% } \ifEPiCfinal \definecolor{volume}{RGB}{0,112,144} \def\EPiCSeries{EPiC Series in Computer Science} \def\EPiCVolume{XXX} \def\EPiCYear{2017} \def\EPiCPages{Pages 19--27} \def\EPiCConference{99th International Conference on Topics of Superb Significance (CATSS)} \def\ChairLogo{logo_chair.png} \def\EPiCLogo{logo_epic.png} \fi % ------------------------------------------------ % Change the maketitle command in EPiC \let\oldmaketitle=\@maketitle % ------------------------------------------------ \def\@maketitle{% \ifEPiCfinal %\vspace*{-10mm}\par \definecolor{headerframe}{rgb}{0.473,0.676,0.656} % 79ada8 \definecolor{headerback}{rgb}{0.953125,0.95703125,0.9609375} % f4f5f6 \begin{tcolorbox}[ enhanced,center,width=\linewidth-2cm, underlay={ \node[inner sep=0pt,outer sep=0pt,right] at ([xshift=-1cm]frame.west) {\includegraphics[height=74.5pt]{\ChairLogo}}; \node[inner sep=0pt,outer sep=0pt,left] at ([xshift=1cm]frame.east) {\includegraphics[height=73pt]{\EPiCLogo}}; }, before skip=0pt,% <--- before box after skip=6pt,% <--- after box left=71.54pt-1cm+4mm, right=56.22423pt-1cm+4mm, sharp corners,text fill, colback=headerback,colframe=headerframe, height=73pt,toprule=0.5pt,bottomrule=0.5pt,leftrule=0pt,rightrule=0pt, halign=center,valign=center,boxsep=0pt, top=2mm,% space to top border bottom=2mm,% space to bottom border ]% {\Large \EPiCSeries}\par\vfill% {\color{volume}Volume \EPiCVolume, \EPiCYear, \EPiCPages}\par\vfill% \EPiCConference \end{tcolorbox} \par\ \vspace*{12pt}\par {\let\newpage\relax\oldmaketitle}% \else \ifEPiC \definecolor{grayheader}{RGB}{112,112,112}% {\color{grayheader}\vspace*{-23pt}\noindent \hrulefill\\ \noindent\centering \raisebox{0pt}[36.5pt][36.5pt]{This space is reserved for the EPiC Series header, do not use it}% \noindent\hrulefill}% \\ {\let\newpage\relax\oldmaketitle}% \else \ifEPiCempty \raisebox{0pt}[47pt][47pt]{~} \\ {\let\newpage\relax\oldmaketitle}% % otherwise the old maketitle \else \oldmaketitle \fi\fi\fi } % ------------------------------------------------ % Tighten up bibliography \let\oldthebibliography=\thebibliography \let\endoldthebibliography=\endthebibliography \renewenvironment{thebibliography}[1] { \small \begin{oldthebibliography}{#1} \setlength{\parskip}{2pt} \setlength{\itemsep}{0pt} } { \end{oldthebibliography} } \ifdebug \ifverbose \RequirePackage[colorgrid,pscoord]{eso-pic}% \else \RequirePackage[pscoord]{eso-pic} \newcommand\ShowFramePicture{% \begingroup \color{red} \AtTextLowerLeft{\framebox(\LenToUnit{\textwidth},\LenToUnit{\textheight}){}}% \AtTextUpperLeft{\put(0,\LenToUnit{\headsep}){\framebox(\LenToUnit{\textwidth},\LenToUnit{\headheight}){}}}% \AtTextLowerLeft{\put(0,\LenToUnit{-\footskip}){\framebox(\LenToUnit{\textwidth},\LenToUnit{\headheight}){}}}% \endgroup } \AddToShipoutPicture{\ShowFramePicture} \fi %\RequirePackage[a4,cam,center]{crop}% %\RequirePackage[cam,center]{crop}% \fi \ifframe \ifverbose \RequirePackage[colorgrid,pscoord]{eso-pic}% \else \RequirePackage[pscoord]{eso-pic} \newcommand\ShowBlueFrame{% \begingroup \color{blue} % odd page % \AtTextLowerLeft{\put(\LenToUnit{-23.6mm},\LenToUnit{-21.8mm}){\framebox(\LenToUnit{188.3mm},\LenToUnit{245.4mm}){}}}% % even page % \AtTextLowerLeft{\put(\LenToUnit{-19.6mm},\LenToUnit{-21.8mm}){\framebox(\LenToUnit{188.3mm},\LenToUnit{245.4mm}){}}}% \endgroup } \AddToShipoutPicture{\ShowBlueFrame} \fi \fi % \geometry{papersize={170mm,240mm},total={124mm,185mm}} %% Indexing options for proceedings to link up people's names to their %% various participation and affiliation options. \newcommand {\indexedperson} [3] {\index{#2!#1}\index{#1}\index{#1!#3}} \newcommand {\indexedauthor} [1] {\indexedperson{#1}{Authors}{Author}} \newcommand {\indexededitor} [1] {\indexedperson{#1}{Editors}{Editor}} \newcommand {\indexedpcmember} [1] {\indexedperson{#1}{PC Members}{PC Member}} \newcommand {\indexedreviewer} [1] {\indexedperson{#1}{Reviewers}{Reviewer}} \newcommand {\indexedorganizer} [1] {\indexedperson{#1}{Organizers}{Organizer}} \newcommand {\indexedwebmaster} [1] {\indexedperson{#1}{Webmasters}{Webmaster}} \newcommand {\indexedaffiliation} [2] {\indexedperson{#1}{#2}{#2}} \newcommand {\indexedsupervisor} [2] {\indexedperson{#1}{}{Supervisor: #2}\indexedperson{#2}{Supervisors}{Supervisor}} \endinput % \crop[font=\upshape\mdseries\small\textsf] % EOF opensmt-2.5.2/docs/index.md000066400000000000000000000002411445011647600155730ustar00rootroot00000000000000## Opensmt Solver ### Description ### News {% for news in site.news %} - {{ news.newsdate | date_to_string }} [{{news.title}}]({{ news.url }}) {% endfor %} opensmt-2.5.2/docs/manual.md000066400000000000000000000030511445011647600157430ustar00rootroot00000000000000**Interpolation:** LRA interpolation algorithms can be changed with the following option in the command line: `(set-option :interpolation-lra-algorithm )` where N can be: - 0 for Farkas interpolation [TACAS'04](https://link.springer.com/chapter/10.1007/978-3-540-24730-2_2) - 2 for dual Farkas interpolation - 4 for decomposed interpolants [TACAS'19](https://link.springer.com/chapter/10.1007/978-3-030-17462-0_1) - 5 for dual decomposed interpolants [TACAS 2019](https://link.springer.com/chapter/10.1007/978-3-030-17462-0_1) - 3 for no-man's land algorithm [HVC'17](https://link.springer.com/chapter/10.1007/978-3-319-70389-3_13) For the flexible no-man's land algorithm we can alter the interpolant within the interval `alpha = [0 , 1)` To do so, the following option can be used: `(set-option :interpolation-lra-factor "alpha")` An example for demonstration purpose: ``` (set-logic QF_LRA) (set-option :produce-interpolants true) (set-option :interpolation-lra-algorithm 3) ;to specify interpolation Alg (set-option :interpolation-lra-factor "1/5") ;to specify alpha (declare-fun x () Real) (declare-fun y () Real) (declare-fun z () Real) (assert (!(<= 1 (+ (* 2 x) y (* 3 z) ) ) :named A)) ;to specify partition A (assert (!(<= 3 (+ (* (- 1) x) (* (- 1) y) (* (- 1) z))) :named B)) ;to specify partition B (assert (!(<= 0 (+ x (* 3 y) (* (- 1) z) ) ) :named C)) (check-sat) (get-interpolants A (and B C)) ``` To get a model for a SAT formula we use `get-value ()` and specify the desired terms. For e.g, `(get-value (x y))` will print the value for x and y. opensmt-2.5.2/docs/publications.md000066400000000000000000000000511445011647600171570ustar00rootroot00000000000000## List of Opensmt related publications opensmt-2.5.2/examples/000077500000000000000000000000001445011647600150335ustar00rootroot00000000000000opensmt-2.5.2/examples/CMakeLists.txt000066400000000000000000000013241445011647600175730ustar00rootroot00000000000000cmake_minimum_required(VERSION 3.3) project(opensmt-examples) set(CMAKE_CXX_STANDARD 17) if (POLICY CMP0074) # Policy 0074 has been introduced in CMake 3.12, so we need a check, otherwise older version would give an error cmake_policy(SET CMP0074 NEW) endif() set(OpenSMT_DIR CACHE PATH "Path to OpenSMT installation directory") find_package(OpenSMT REQUIRED CONFIG PATHS ${OpenSMT_DIR}) file(GLOB_RECURSE my_c_list RELATIVE ${CMAKE_CURRENT_LIST_DIR} "*.cc") foreach(file_path ${my_c_list}) string( REPLACE ".cc" "" new_name ${file_path} ) get_filename_component(filename ${new_name} NAME) add_executable( ${filename} ${file_path} ) target_link_libraries(${filename} OpenSMT::OpenSMT) endforeach() opensmt-2.5.2/examples/README.md000066400000000000000000000011611445011647600163110ustar00rootroot00000000000000## OpenSMT as a library for your tool This directory contains examples which may serve as a base for integrating OpenSMT into an external tool through libraries. ### Compiling Assuming you've installed OpenSMT headers and libraries under a directory ``, the examples can be compiled by running $ cd examples && mkdir build && cd build $ cmake -DOPENSMT_DIR= .. $ make ### Notes The files serve another purpose: a light-weight regression tests for the library interface for OpenSMT developers. Our Travis setup checks that the compilation passes before a commit is accepted in the master branch. opensmt-2.5.2/examples/test-bv.cc000066400000000000000000000071011445011647600167250ustar00rootroot00000000000000#include #include #include int main(int argc, char** argv) { if (argc != 5) { printf("Computes a b on bit width \n"); printf("Usage: %s \n", argv[0]); return 1; } char* op = argv[2]; //int c1_int = atoi(argv[3]); //int c2_int = atoi(argv[4]); const char* c1_str = argv[3]; const char* c2_str = argv[4]; int bw = atoi(argv[1]); SMTConfig c; BVLogic* logic_ = new BVLogic(opensmt::Logic_t::QF_BV, bw); BVLogic& logic = *logic_; MainSolver* mainSolver_ = new MainSolver(logic, c, "test solver"); MainSolver& mainSolver = *mainSolver_; PTRef a = logic.mkBVNumVar("a"); PTRef b = logic.mkBVNumVar("b"); //PTRef c1 = logic.mkBVConst(c1_int); PTRef c1 = logic.mkBVConst(c1_str); //PTRef c2 = logic.mkBVConst(c2_int); PTRef c2 = logic.mkBVConst(c2_str); PTRef eq1 = logic.mkBVEq(a, c1); PTRef eq2 = logic.mkBVEq(b, c2); //printf("Computing %d (%s) %s %d (%s)\n", c1_int, logic.printTerm(c1), op, c2_int, logic.printTerm(c2)); printf("Computing %s (%s) %s %s (%s)\n", c1_str, logic.printTerm(c1).c_str(), op, c2_str, logic.printTerm(c2).c_str()); PTRef op_tr; if (strcmp(op, "/") == 0) op_tr = logic.mkBVDiv(a, b); else if (strcmp(op, "*") == 0) op_tr = logic.mkBVTimes(a, b); else if (strcmp(op, "+") == 0) op_tr = logic.mkBVPlus(a, b); else if (strcmp(op, "-") == 0) op_tr = logic.mkBVMinus(a, b); else if (strcmp(op, "s<") == 0) op_tr = logic.mkBVSlt(a, b); else if (strcmp(op, "s<=") == 0) op_tr = logic.mkBVSleq(a, b); else if (strcmp(op, "u<=") == 0) op_tr = logic.mkBVUleq(a, b); else if (strcmp(op, "s>=") == 0) op_tr = logic.mkBVSgeq(a, b); else if (strcmp(op, "s>") == 0) op_tr = logic.mkBVSgt(a, b); else if (strcmp(op, "<<") == 0) op_tr = logic.mkBVLshift(a, b); else if (strcmp(op, "a>>") == 0) op_tr = logic.mkBVARshift(a, b); else if (strcmp(op, "l>>") == 0) op_tr = logic.mkBVLRshift(a, b); else if (strcmp(op, "%") == 0) op_tr = logic.mkBVMod(a, b); else if (strcmp(op, "&") == 0) op_tr = logic.mkBVBwAnd(a, b); else if (strcmp(op, "|") == 0) op_tr = logic.mkBVBwOr(a, b); else if (strcmp(op, "=") == 0) op_tr = logic.mkBVEq(a, b); else if (strcmp(op, "&&") == 0) op_tr = logic.mkBVLand(a, b); else if (strcmp(op, "^") == 0) op_tr = logic.mkBVBwXor(a, b); else if (strcmp(op, "==") == 0) op_tr = logic.mkBVEq(a, b); else { printf("Unknown operator: %s", op); return 1; } PTRef d = logic.mkBVNumVar("d"); PTRef eq3 = logic.mkBVEq(op_tr, d); vec asgns; vec foo; SolverId id = {42}; BitBlaster bbb(id, c, mainSolver, logic, asgns, foo); BVRef output; lbool stat; stat = bbb.insertEq(eq1, output); bbb.insertEq(eq2, output); bbb.insertEq(eq3, output); char* msg; mainSolver.insertFormula(logic.getTerm_true(), &msg); sstat r = mainSolver.check(); if (r == s_True) { printf("sat\n"); bbb.computeModel(); PTRef v = bbb.getValue(d); auto val = logic.pp(v); char* bin; opensmt::wordToBinary(atoi(val.c_str()), bin, bw); printf("%s (%s)\n", val.c_str(), bin); free(bin); } else if (r == s_False) printf("unsat\n"); else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/examples/test-cuf.cc000066400000000000000000000032441445011647600170770ustar00rootroot00000000000000#include #include #include int main(int argc, char** argv) { if (argc != 3) { printf("Test Glue: set a & b to values in BV and compares their equality on EUF\n"); printf("Usage: %s \n", argv[0]); return 1; } int c1_int = atoi(argv[1]); int c2_int = atoi(argv[2]); BVLogic* logic_ = new BVLogic(opensmt::Logic_t::QF_BV); BVLogic& logic = *logic_; SMTConfig c; MainSolver* mainSolver_ = new MainSolver(logic, c, "test solver"); MainSolver& mainSolver = *mainSolver_; PTRef a = logic.mkCUFNumVar("a"); PTRef b = logic.mkCUFNumVar("b"); PTRef a_bv = logic.mkBVNumVar("a"); PTRef b_bv = logic.mkBVNumVar("b"); PTRef c1 = logic.mkBVConst(c1_int); PTRef c2 = logic.mkBVConst(c2_int); PTRef eq1 = logic.mkBVEq(a_bv, c1); PTRef eq2 = logic.mkBVEq(b_bv, c2); PTRef eq3 = logic.mkEq(a, b); char* msg; mainSolver.insertFormula(eq3, &msg); vec asgns; vec foo; SolverId id = {42}; BitBlaster bbb(id, c, mainSolver, logic, asgns, foo); BVRef output; lbool stat; bbb.insertEq(eq1, output); bbb.insertEq(eq2, output); bbb.bindCUFToBV(a, a_bv); bbb.bindCUFToBV(b, b_bv); // bbb.notifyEquality(eq3); sstat r = mainSolver.check(); if (r == s_True) { printf("sat\n"); bbb.computeModel(); std::cout << logic.pp(bbb.getValue(a_bv)) << '\n' << logic.pp(bbb.getValue(a)) << std::endl; } else if (r == s_False) printf("unsat\n"); else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/examples/test-cuf3.cc000066400000000000000000000040031445011647600171540ustar00rootroot00000000000000#include #include #include int main() { BVLogic logic{opensmt::Logic_t::QF_BV}; SMTConfig c; MainSolver* mainSolver_ = new MainSolver(logic, c, "test solver"); MainSolver& mainSolver = *mainSolver_; PTRef a = logic.mkBVNumVar("a"); PTRef b = logic.mkBVNumVar("b"); PTRef ab = logic.mkBVBwAnd(a, b); PTRef d = logic.mkBVNumVar("b"); PTRef f = logic.mkBVNumVar("a"); PTRef ba = logic.mkBVBwAnd(d, f); PTRef eq = logic.mkBVEq(ab,ba); PTRef eq_neg = logic.mkBVNot(eq); (void)eq_neg; vec asgns; vec foo; SolverId id = {42}; BitBlaster bbb(id, c, mainSolver, logic, asgns, foo); BVRef output; lbool stat; stat = bbb.insertEq(eq, output); if (stat == l_True) printf("sat after eq\n"); if (stat == l_False) printf("unsat after eq\n"); // BVRef output2; // stat = bbb.insert(eq_neg, output2); // if (stat == l_True) // printf("sat after eq_neg\n"); // if (stat == l_False) // printf("unsat after eq_neg\n"); // PTRef uf1 = logic.mkCUFVar("uf1"); // PTRef uf2 = logic.mkCUFVar("uf2"); // PTRef bv1 = logic.mkNumVar("bv1"); // PTRef bv2 = logic.mkNumVar("bv2"); // PTRef bv_eq1 = logic.mkBVEq(bv1, eq); // PTRef bv_eq2 = logic.mkBVEq(bv2, eq_neg); // PTRef bv_eq3 = logic.mkBVEq(bv1, bv2); // // BVRef bvr1; // BVRef bvr2; // BVRef bvr3; // // bbb.insertEq(bv_eq1, bvr1); // bbb.insertEq(bv_eq2, bvr2); // bbb.insertEq(bv_eq3, bvr3); // // // stat = bbb.glueUFtoB(uf1, bvr1); // stat = bbb.glueUFtoB(uf2, bvr2); // // stat = bbb.glueUFtoUF(uf1, uf2); // // PTRef uf_eq = logic.mkEq(uf1, uf2); // char* msg; // mainSolver.insertFormula(uf_eq, &msg); sstat r = mainSolver.check(); if (r == s_True) printf("sat\n"); else if (r == s_False) printf("unsat\n"); else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/examples/test1.cc000066400000000000000000000013111445011647600163760ustar00rootroot00000000000000#include #include int main() { Logic logic{opensmt::Logic_t::QF_UF}; // UF Logic SMTConfig c; MainSolver* mainSolver_ = new MainSolver(logic, c, "test solver"); MainSolver& mainSolver = *mainSolver_; PTRef v = logic.mkBoolVar("a"); PTRef v_neg = logic.mkNot(v); vec args; args.push(v); args.push(v_neg); PTRef a = logic.mkAnd(args); mainSolver.push(a); printf("Running check!\n"); sstat r = mainSolver.check(); if (r == s_True) printf("sat\n"); else if (r == s_False) printf("unsat\n"); else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/examples/test10_BV.cc000066400000000000000000000022471445011647600170560ustar00rootroot00000000000000/************************************************ * Created on: Jan 25, 2017 * (not (a=1) \/ b=3 ) * result : sat ************************************************/ #include #include #include int main() { BVLogic logic{opensmt::Logic_t::QF_BV}; SMTConfig c; MainSolver* mainSolver_ = new MainSolver(logic, c, "test solver"); MainSolver& mainSolver = *mainSolver_; PTRef a = logic.mkBVNumVar("a"); PTRef const1 = logic.mkBVConst(1); PTRef eq1 = logic.mkBVEq(a, const1); PTRef b = logic.mkBVNumVar("b"); PTRef const2 = logic.mkBVConst(3); PTRef eq2 = logic.mkBVEq(b, const2); PTRef eq1_neg = logic.mkBVNot(eq1); PTRef LOr = logic.mkBVLor(eq1_neg, eq2); vec asgns; vec foo; SolverId id = {42}; BitBlaster bbb(id, c, mainSolver, logic, asgns, foo); BVRef output1; lbool stat; stat = bbb.insertOr(LOr, output1); sstat r = mainSolver.check(); if (r == s_True) printf("sat\n"); else if (r == s_False) printf("unsat\n"); else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/examples/test11_BV.cc000066400000000000000000000034111445011647600170510ustar00rootroot00000000000000/************************************************ * Created on: Jan 25, 2017 * second formula * a=5 /\ b=1 /\ ( not a \/ b=3 ) * * For values: * a=1, b=0, b=3 : unsat * a=5, b=4, b=4 : sat * a=1, b=1, b=1 : sat ************************************************/ #include #include #include int main() { BVLogic logic{opensmt::Logic_t::QF_BV}; SMTConfig c; MainSolver* mainSolver_ = new MainSolver(logic, c, "test solver"); MainSolver& mainSolver = *mainSolver_; PTRef a = logic.mkBVNumVar("a"); PTRef const1 = logic.mkBVConst(5); PTRef eq1 = logic.mkBVEq(a, const1); PTRef b = logic.mkBVNumVar("b"); PTRef const2 = logic.mkBVConst(4); PTRef eq2 = logic.mkBVEq(b, const2); PTRef a_neg = logic.mkBVNot(a); PTRef const4 = logic.mkBVConst(4); PTRef eq4 = logic.mkBVEq(b, const4); PTRef LOr = logic.mkBVLor(a_neg, eq4); //PTRef eq4 = logic.mkBVEq(eq3, LOr); vec asgns; vec foo; SolverId id = {42}; BitBlaster bbb(id, c, mainSolver, logic, asgns, foo); BVRef output1; lbool stat; stat = bbb.insertEq(eq1, output1); BVRef output2; stat = bbb.insertEq(eq2, output2); BVRef output3; stat = bbb.insertOr(LOr, output3); // BVRef output4; // stat = bbb.insertEq(eq4, output4); std::cout << logic.printTerm(eq1) << "\n"; std::cout << logic.printTerm(eq2) << "\n"; std::cout << logic.printTerm(LOr) << "\n"; // std::cout << logic.printTerm(LOr) << "\n"; // std::cout << logic.printTerm(eq4) << "\n"; sstat r = mainSolver.check(); if (r == s_True) printf("sat\n"); else if (r == s_False) printf("unsat\n"); else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/examples/test13_BV.cc000066400000000000000000000030621445011647600170550ustar00rootroot00000000000000/************************************************ * Created on: Jan 25, 2017 * second formula * (a=5 \/ b=1) /\ ( not a \/ b=3 ) * * For values: * sat ************************************************/ #include #include #include int main() { BVLogic logic{opensmt::Logic_t::QF_BV}; SMTConfig c; MainSolver* mainSolver_ = new MainSolver(logic, c, "test solver"); MainSolver& mainSolver = *mainSolver_; PTRef a = logic.mkBVNumVar("a"); PTRef const1 = logic.mkBVConst(5); PTRef eq1 = logic.mkBVEq(a, const1); PTRef b = logic.mkBVNumVar("b"); PTRef const2 = logic.mkBVConst(1); PTRef eq2 = logic.mkBVEq(b, const2); PTRef eq3 = logic.mkBVLor(eq1, eq2); PTRef a_neg = logic.mkBVNot(a); PTRef const4 = logic.mkBVConst(3); PTRef eq4 = logic.mkBVEq(b, const4); PTRef eq5 = logic.mkBVLor(a_neg, eq4); //PTRef eq4 = logic.mkBVEq(eq3, LOr); vec asgns; vec foo; SolverId id = {42}; BitBlaster bbb(id, c, mainSolver, logic, asgns, foo); BVRef output1; lbool stat; stat = bbb.insertOr(eq3, output1); BVRef output2; stat = bbb.insertOr(eq5, output2); // BVRef output4; // stat = bbb.insertEq(eq4, output4); std::cout << logic.printTerm(eq3) << "\n"; std::cout << logic.printTerm(eq5) << "\n"; sstat r = mainSolver.check(); if (r == s_True) printf("sat\n"); else if (r == s_False) printf("unsat\n"); else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/examples/test15_ex1CADE.cc000066400000000000000000000037361445011647600176720ustar00rootroot00000000000000/************************************************ * Created on: Jan 30, 2017 * unsigned f=g; >>eq1 unsigned d = e*( f % 2 ); >>eq2 unsigned d_p = e*( g % 2); >>eq3 assert(d == d_p); >> (d != d_p ) = 1 } ************************************************/ #include #include #include int main() { BVLogic logic{opensmt::Logic_t::QF_BV}; SMTConfig c; MainSolver* mainSolver_ = new MainSolver(logic, c, "test solver"); MainSolver& mainSolver = *mainSolver_; PTRef const1 = logic.mkBVConst(2); PTRef f = logic.mkBVNumVar("f"); PTRef g = logic.mkBVNumVar("g"); PTRef d = logic.mkBVNumVar("d"); PTRef d_p = logic.mkBVNumVar("d_p"); PTRef e = logic.mkBVNumVar("e"); PTRef eq1 = logic.mkBVEq(f, g); PTRef mod1 = logic.mkBVMod(f, const1); PTRef mod2 = logic.mkBVMod(g, const1); PTRef mul1 = logic.mkBVTimes(mod1, e ); PTRef mul2 = logic.mkBVTimes(mod2, e ); PTRef eq2 = logic.mkBVEq(mul1, d); PTRef eq3 = logic.mkBVEq(mul2, d_p); PTRef eq_not = logic.mkBVNeq(d, d_p); PTRef constOne = logic.getTerm_BVOne(); PTRef assert = logic.mkBVEq(constOne, eq_not); vec asgns; vec foo; SolverId id = {42}; BitBlaster bbb(id, c, mainSolver, logic, asgns, foo); BVRef output1; lbool stat; stat = bbb.insertEq(eq1, output1); BVRef output2; stat = bbb.insertEq(eq2, output2); BVRef output3; stat = bbb.insertEq(eq3, output3); BVRef output4; stat = bbb.insertEq(assert, output4); std::cout << logic.printTerm(eq1) << "\n"; std::cout << logic.printTerm(eq2) << "\n"; std::cout << logic.printTerm(eq3) << "\n"; std::cout << logic.printTerm(assert) << "\n"; sstat r = mainSolver.check(); if (r == s_True) printf("sat\n"); else if (r == s_False) printf("unsat\n"); else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/examples/test16_ex2CADE_BV.cc000066400000000000000000000062341445011647600202570ustar00rootroot00000000000000/************************************************ * Created on: Jan 30, 2017 unsigned a; unsigned b; unsigned c1 = (((a % 2) + (b % 2))) % 2; //eq1 unsigned c2 = (a + b) % 2; //eq2 unsigned e, f; e=g; f=h; unsigned d = e*f*c1; //eq3 unsigned d_p = g*h*c2; //eq4 assert(d == d_p); //assert ((d != d_p ) = 1) } The result is UNSAT,means c1=c2 holds! ************************************************/ #include #include #include int main() { BVLogic logic{opensmt::Logic_t::QF_BV}; SMTConfig c; MainSolver* mainSolver_ = new MainSolver(logic, c, "test solver"); MainSolver& mainSolver = *mainSolver_; // PTRef k = logic.mkBVNumVar("k"); no need for it; by using mkBVMod it is already in the server. PTRef a = logic.mkBVNumVar("a"); PTRef b = logic.mkBVNumVar("b"); PTRef e = logic.mkBVNumVar("e"); PTRef f = logic.mkBVNumVar("f"); PTRef g = logic.mkBVNumVar("g"); PTRef h = logic.mkBVNumVar("h"); PTRef d = logic.mkBVNumVar("d"); PTRef d_p = logic.mkBVNumVar("d_p"); PTRef eq_eg = logic.mkBVEq(e, g); PTRef eq_fh = logic.mkBVEq(f, h); PTRef const2 = logic.mkBVConst(2); // PTRef eq_two = logic.mkBVEq(k, const2); PTRef c1 = logic.mkBVNumVar("c1"); PTRef c2 = logic.mkBVNumVar("c2"); PTRef mod1 = logic.mkBVMod(a, const2); PTRef mod2 = logic.mkBVMod(b, const2); PTRef plus1 = logic.mkBVPlus(mod1, mod2); PTRef mod3 = logic.mkBVMod(plus1, const2); PTRef eq1= logic.mkBVEq(mod3, c1); PTRef plus2 = logic.mkBVPlus(a, b); PTRef mod4 = logic.mkBVMod(plus2, const2); PTRef eq2 = logic.mkBVEq(mod4, c2); PTRef mul1 = logic.mkBVTimes(e, c1); PTRef mul2 = logic.mkBVTimes(mul1, f); PTRef eq3= logic.mkBVEq(mul2, d); PTRef mul3 = logic.mkBVTimes(g, c2); PTRef mul4 = logic.mkBVTimes(mul3, h); PTRef eq4= logic.mkBVEq(mul4, d_p); PTRef NotEq = logic.mkBVNeq(c1, c2); PTRef constOne = logic.getTerm_BVOne(); PTRef assert = logic.mkBVEq(constOne , NotEq); vec asgns; vec foo; SolverId id = {42}; BitBlaster bbb(id, c, mainSolver, logic, asgns, foo); BVRef output1; lbool stat; stat = bbb.insertEq(eq1, output1); BVRef output2; stat = bbb.insertEq(eq2, output2); BVRef output3; stat = bbb.insertEq(eq3, output3); //d BVRef output4; stat = bbb.insertEq(eq4, output4); //d_p // BVRef output5; // stat = bbb.insertEq(eq5, output5); BVRef output6; stat = bbb.insertEq(eq_eg, output6); BVRef output7; stat = bbb.insertEq(eq_fh, output7); // BVRef output8; // stat = bbb.insertEq(eq_two, output8); BVRef output9; stat = bbb.insertEq(assert, output9); std::cout << logic.printTerm(eq1) << "\n"; std::cout << logic.printTerm(eq2) << "\n"; std::cout << logic.printTerm(eq3) << "\n"; std::cout << logic.printTerm(eq4) << "\n"; std::cout << logic.printTerm(NotEq) << "\n"; std::cout << logic.printTerm(assert) << "\n"; sstat r = mainSolver.check(); if (r == s_True) printf("sat\n"); else if (r == s_False) printf("unsat\n"); else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/examples/test17_ex2CADE_CUF.cc000066400000000000000000000071301445011647600203620ustar00rootroot00000000000000/************************************************ * Created on: Jan 30, 2017 unsigned a; unsigned b; unsigned c1 = (((a % 2) + (b % 2))) % 2; //eq1 unsigned c2 = (a + b) % 2; //eq2 unsigned e, f; e=g; f=h; unsigned d = e*f*c1; //eq3 unsigned d_p = g*h*c2; //eq4 assert(d == d_p); //assert ((d != d_p ) = 1) } The result is SAT, manifesting spurious counter-example ************************************************/ #include #include #include int main() { BVLogic logic{opensmt::Logic_t::QF_BV}; SMTConfig c; MainSolver* mainSolver_ = new MainSolver(logic, c, "test solver"); MainSolver& mainSolver = *mainSolver_; PTRef a = logic.mkCUFNumVar("a"); PTRef b = logic.mkCUFNumVar("b"); PTRef e = logic.mkCUFNumVar("e"); PTRef f = logic.mkCUFNumVar("f"); PTRef g = logic.mkCUFNumVar("g"); PTRef h = logic.mkCUFNumVar("h"); PTRef d = logic.mkCUFNumVar("d"); PTRef d_p = logic.mkCUFNumVar("d_p"); PTRef eq_eg = logic.mkEq(e, g); PTRef eq_fh = logic.mkEq(f, h); PTRef const2 = logic.mkCUFConst(2); PTRef c1 = logic.mkCUFNumVar("c1"); PTRef c2 = logic.mkCUFNumVar("c2"); PTRef mod1 = logic.mkCUFMod(a, const2); PTRef mod2 = logic.mkCUFMod(b, const2); PTRef plus1 = logic.mkCUFPlus(mod1, mod2); PTRef mod3 = logic.mkCUFMod(plus1, const2); PTRef eq1= logic.mkEq(mod3, c1); PTRef plus2 = logic.mkCUFPlus(a, b); PTRef mod4 = logic.mkCUFMod(plus2, const2); PTRef eq2 = logic.mkEq(mod4, c2); PTRef mul1 = logic.mkCUFTimes(e, c1); PTRef mul2 = logic.mkCUFTimes(mul1, f); PTRef eq3= logic.mkEq(mul2, d); PTRef mul3 = logic.mkCUFTimes(g, c2); PTRef mul4 = logic.mkCUFTimes(mul3, h); PTRef eq4= logic.mkEq(mul4, d_p); PTRef NotEq = logic.mkCUFNeq(d, d_p); vec asgns; vec foo; char* msg; mainSolver.insertFormula(eq1, &msg); mainSolver.insertFormula(eq2, &msg); mainSolver.insertFormula(eq3, &msg); mainSolver.insertFormula(eq4, &msg); mainSolver.insertFormula(eq_eg, &msg); mainSolver.insertFormula(eq_fh, &msg); mainSolver.insertFormula(NotEq, &msg); // mainSolver.insertFormula(eq_two, & msg); /* BitBlaster bbb(id, c, mainSolver, logic, asgns, deds, foo); BVRef output1; lbool stat; stat = bbb.insertEq(eq1, output1); BVRef output2; stat = bbb.insertEq(eq2, output2); BVRef output3; stat = bbb.insertEq(eq3, output3); //d BVRef output4; stat = bbb.insertEq(eq4, output4); //d_p // BVRef output5; // stat = bbb.insertEq(eq5, output5); BVRef output6; stat = bbb.insertEq(eq0, output6); BVRef output7; stat = bbb.insertEq(eq00, output7); BVRef output8; stat = bbb.insertEq(eq_two, output8); BVRef output9; stat = bbb.insertEq(assert, output9);*/ std::cout << logic.printTerm(eq1) << "\n"; std::cout << logic.printTerm(eq2) << "\n"; std::cout << logic.printTerm(eq3) << "\n"; std::cout << logic.printTerm(eq4) << "\n"; std::cout << logic.printTerm(NotEq) << "\n"; //std::cout << logic.printTerm(assert) << "\n"; sstat r = mainSolver.check(); auto m = mainSolver.getModel(); std::cout << logic.pp(m->evaluate(a)) << "\n"; std::cout << logic.pp(m->evaluate(b)) << "\n"; std::cout << logic.pp(m->evaluate(c1)) << "\n"; std::cout << logic.pp(m->evaluate(c2)) << "\n"; std::cout << logic.pp(m->evaluate(d)) << "\n"; std::cout << logic.pp(m->evaluate(d_p)) << "\n"; if (r == s_True) printf("sat\n"); else if (r == s_False) printf("unsat\n"); else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/examples/test18_ex2CADE_glue_BV-CUF.cc000066400000000000000000000116011445011647600217020ustar00rootroot00000000000000/************************************************ * test18_ex2CADE_ glue_BV-CUF.cc * Created on: Feb2, 2017 unsigned a; unsigned b; unsigned c1 = (((a % 2) + (b % 2))) % 2; //eq1 between mod3 and c1 unsigned c2 = (a + b) % 2; //eq2 unsigned e, f; e=g; f=h; unsigned d = e*f*c1; //eq3 unsigned d_p = g*h*c2; //eq4 assert(d == d_p); //assert ((d != d_p ) = 1) } ************************************************/ #include #include #include void printValue(PTRef tr, std::unique_ptr & m, const Logic & l) { auto name = l.pp(tr); auto value = l.pp(m->evaluate(tr)); std::cout << name << " " << value << "\n"; } int main() { BVLogic logic{opensmt::Logic_t::QF_BV}; SMTConfig c; MainSolver* mainSolver_ = new MainSolver(logic, c, "test solver"); MainSolver& mainSolver = *mainSolver_; PTRef a = logic.mkCUFNumVar("a"); PTRef b = logic.mkCUFNumVar("b"); PTRef a_bv = logic.mkBVNumVar("a"); PTRef b_bv = logic.mkBVNumVar("b"); PTRef e = logic.mkCUFNumVar("e"); PTRef f = logic.mkCUFNumVar("f"); PTRef g = logic.mkCUFNumVar("g"); PTRef h = logic.mkCUFNumVar("h"); PTRef d = logic.mkCUFNumVar("d"); PTRef d_p = logic.mkCUFNumVar("d_p"); PTRef eq_eg = logic.mkEq(e, g); PTRef eq_fh = logic.mkEq(f, h); PTRef const2 = logic.mkCUFConst(2); PTRef c1 = logic.mkCUFNumVar("c1"); PTRef c2 = logic.mkCUFNumVar("c2"); //CUF version of C1 PTRef mod1 = logic.mkCUFMod(a, const2); PTRef mod2 = logic.mkCUFMod(b, const2); PTRef plus1 = logic.mkCUFPlus(mod1, mod2); PTRef mod3 = logic.mkCUFMod(plus1, const2); PTRef eq1= logic.mkEq(mod3, c1); // CUF version of C2 PTRef plus2 = logic.mkCUFPlus(a, b); PTRef mod4 = logic.mkCUFMod(plus2, const2); PTRef eq2 = logic.mkEq(mod4, c2); PTRef mul1 = logic.mkCUFTimes(e, c1); PTRef mul2 = logic.mkCUFTimes(mul1, f); PTRef eq3= logic.mkEq(mul2, d); PTRef mul3 = logic.mkCUFTimes(g, c2); PTRef mul4 = logic.mkCUFTimes(mul3, h); PTRef eq4= logic.mkEq(mul4, d_p); PTRef NotEq = logic.mkCUFNeq(d, d_p); // PTRef constOne = logic.getTerm_CUFOne(); // // PTRef assert = logic.mkEq(constOne , NotEq); char* msg; mainSolver.insertFormula(eq1, &msg); mainSolver.insertFormula(eq2, &msg); mainSolver.insertFormula(eq3, &msg); mainSolver.insertFormula(eq4, &msg); mainSolver.insertFormula(eq_eg, &msg); mainSolver.insertFormula(eq_fh, &msg); mainSolver.insertFormula(NotEq, &msg); //***********BV version of C1 and C2 and 2************** PTRef const2_bv = logic.mkBVConst(2); PTRef c1_bv = logic.mkBVNumVar("c1"); PTRef c2_bv = logic.mkBVNumVar("c2"); // BV of C1 PTRef mod1_bv = logic.mkBVMod(a_bv, const2_bv); PTRef mod2_bv = logic.mkBVMod(b_bv, const2_bv); PTRef plus1_bv = logic.mkBVPlus(mod1_bv, mod2_bv); PTRef mod3_bv = logic.mkBVMod(plus1_bv, const2_bv); PTRef eq1_bv= logic.mkBVEq(mod3_bv, c1_bv); // BV of C2 PTRef plus2_bv = logic.mkBVPlus(a_bv, b_bv); PTRef mod4_bv = logic.mkBVMod(plus2_bv, const2_bv); PTRef eq2_bv = logic.mkBVEq(mod4_bv, c2_bv); //***** BItBlasting of C1_bv and C2_bv and two****** vec asgns; vec foo; SolverId id = {42}; BitBlaster bbb(id, c, mainSolver, logic, asgns, foo); BVRef output1; lbool stat; stat = bbb.insertEq(eq1_bv, output1); BVRef output2; stat = bbb.insertEq(eq2_bv, output2); //********End of BitBlasting*********** //********bind CUF to BV left-hand-side & right-hand-side*********** bbb.bindCUFToBV(mod3, mod3_bv); bbb.bindCUFToBV(mod4, mod4_bv); //*******notify******** // bbb.notifyEquality(eq1); // bbb.notifyEquality(eq2); bbb.notifyEqualities(); // BVRef output4; // stat = bbb.insertEq(eq4, output4); //d_p // BVRef output5; // stat = bbb.insertEq(eq5, output5); // BVRef output6; // stat = bbb.insertEq(eq_two, output6); /* BVRef output7; stat = bbb.insertEq(eq00, output7); BVRef output8; stat = bbb.insertEq(eq_two, output8); BVRef output9; stat = bbb.insertEq(assert, output9);*/ std::cout << logic.printTerm(eq1) << "\n"; std::cout << logic.printTerm(eq2) << "\n"; std::cout << logic.printTerm(eq3) << "\n"; std::cout << logic.printTerm(eq4) << "\n"; std::cout << logic.printTerm(NotEq) << "\n"; sstat r = mainSolver.check(); if (r == s_True) { printf("sat\n"); auto m = mainSolver.getModel(); printValue(a, m, logic); printValue(b, m, logic); printValue(c1, m, logic); printValue(c2, m, logic); printValue(d, m, logic); printValue(d_p, m, logic); } else if (r == s_False) printf("unsat\n"); else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/examples/test2.cc000066400000000000000000000023701445011647600164050ustar00rootroot00000000000000#include #include int main() { Logic logic{opensmt::Logic_t::QF_UF}; // UF Logic SMTConfig c; MainSolver* mainSolver_ = new MainSolver(logic, c, "test solver"); MainSolver& mainSolver = *mainSolver_; PTRef v1 = logic.mkBoolVar("a"); PTRef v2 = logic.mkBoolVar("b"); vec args; args.push(logic.mkNot(v1)); args.push(logic.mkNot(v2)); mainSolver.push(logic.mkOr(args)); args.clear(); args.push(v1); args.push(logic.mkNot(v2)); mainSolver.push(logic.mkOr(args)); args.clear(); args.push(logic.mkNot(v1)); args.push(v2); mainSolver.push(logic.mkOr(args)); sstat r = mainSolver.check(); if (r == s_True) { printf("sat\n"); auto m = mainSolver.getModel(); auto v1_p = logic.pp(m->evaluate(v1)); auto v2_p = logic.pp(m->evaluate(v2)); auto var_a_s = logic.pp(v1); auto var_b_s = logic.pp(v2); printf("var %s has value %s\n", var_a_s.c_str(), v1_p.c_str()); printf("var %s has value %s\n", var_b_s.c_str(), v2_p.c_str()); } else if (r == s_False) printf("unsat\n"); else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/examples/test3_BV.cc000066400000000000000000000022031445011647600167700ustar00rootroot00000000000000/******************************************** * Created on: Jan 17, 2017 * Author: Sepideh Asadi * check the negation of : y && z == z && y ********************************************/ #include #include #include int main() { BVLogic bvlogic{opensmt::Logic_t::QF_BV}; SMTConfig c; MainSolver* mainSolver_ = new MainSolver(bvlogic, c, "test solver"); MainSolver& mainSolver = *mainSolver_; PTRef y_bb = bvlogic.mkBVNumVar("y"); PTRef z_bb = bvlogic.mkBVNumVar("z"); PTRef yz_bb = bvlogic.mkBVBwAnd(y_bb, z_bb); PTRef z2_bb = bvlogic.mkBVNumVar("z"); PTRef y2_bb = bvlogic.mkBVNumVar("y"); PTRef zy_bb = bvlogic.mkBVBwAnd(z2_bb, y2_bb); PTRef eq_bb = bvlogic.mkBVEq(yz_bb, zy_bb); PTRef eq_bb_neg = bvlogic.mkBVNot(eq_bb); // MB: TODO: How to turn BVsort to boolean? mainSolver.push(eq_bb_neg); sstat r = mainSolver.check(); if (r == s_True) printf("sat\n"); else if (r == s_False) printf("unsat\n"); else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/examples/test4_BV.cc000066400000000000000000000055451445011647600170050ustar00rootroot00000000000000/************************************************ * Created on: Jan 17, 2017 * Author: Sepideh Asadi * a=1 /\ b=1 /\ d=0 /\ d=a & b ************************************************/ #include #include #include int main() { BVLogic logic{opensmt::Logic_t::QF_BV}; SMTConfig c; MainSolver* mainSolver_ = new MainSolver(logic, c, "test solver"); MainSolver& mainSolver = *mainSolver_; PTRef a = logic.mkBVNumVar("a"); PTRef const1 = logic.mkBVConst(-1); PTRef eq1 = logic.mkBVEq(a, const1); PTRef b = logic.mkBVNumVar("b"); PTRef const2 = logic.mkBVConst(4); PTRef eq2 = logic.mkBVEq(b, const2); PTRef d = logic.mkBVNumVar("d"); PTRef const3 = logic.mkBVConst(4); PTRef eq3 = logic.mkBVEq(d, const3); //PTRef eq3_neg = logic.mkBVNot(eq3); PTRef d2 = logic.mkBVBwAnd(a, b); PTRef eq4 = logic.mkBVEq(d, d2); /* vec args; args.push(eq1); args.push(eq2); args.push(eq3_neg); args.push(eq4); PTRef eq = logic.mkAnd(args);*/ vec asgns; vec foo; BitBlaster bbb({42}, c, mainSolver, logic, asgns, foo); BVRef output1; lbool stat; stat = bbb.insertEq(eq1, output1); if (stat == l_True) printf("sat after eq\n"); if (stat == l_False) printf("unsat after eq\n"); BVRef output2; stat = bbb.insertEq(eq2, output2); // if (stat == l_True) // printf("sat after eq_neg\n"); // if (stat == l_False) // printf("unsat after eq_neg\n"); BVRef output3; stat = bbb.insertEq(eq3, output3); // if (stat == l_True) // printf("sat after eq_neg\n"); // if (stat == l_False) // printf("unsat after eq_neg\n"); BVRef output4; stat = bbb.insertEq(eq4, output4); // if (stat == l_True) // printf("sat after eq_neg\n"); // if (stat == l_False) // printf("unsat after eq_neg\n"); /****************************************************/ /* PTRef uf1 = logic.mkCUFVar("uf1"); PTRef uf2 = logic.mkCUFVar("uf2"); stat = bbb.glueUFtoB(uf1, output); stat = bbb.glueBtoUF(output, uf1); if (stat == l_True) printf("sat after uf1\n"); if (stat == l_False) printf("unsat after uf1\n"); stat = bbb.glueUFtoB(uf2, output2); stat = bbb.glueBtoUF(output2, uf2); if (stat == l_True) printf("sat after uf2\n"); if (stat == l_False) printf("unsat after uf2\n"); PTRef uf_eq = logic.mkEq(uf1, uf2); char* msg; mainSolver.insertFormula(uf_eq, &msg); mainSolver.push(eq);*/ std::cout << logic.printTerm(eq1) << "\n"; std::cout << logic.printTerm(eq2) << "\n"; std::cout << logic.printTerm(eq3) << "\n"; std::cout << logic.printTerm(d2) << "\n"; std::cout << logic.printTerm(eq4) << "\n"; sstat r = mainSolver.check(); if (r == s_True) printf("sat\n"); else if (r == s_False) printf("unsat\n"); else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/examples/test5_BV.cc000066400000000000000000000036761445011647600170110ustar00rootroot00000000000000/*************************************************** * Created on: Jan 17, 2017 * Author: Sepideh Asadi * d=a*b /\ a=2 /\ b=5 /\ d=1 * * For values: * a=0, b=5 , d=0 : sat * a=2, b=5 , d=11 : unsat * a=2, b=5 , d=10 : sat * * Insert four Equalities with InsertEq() * we cannot have such not(d=10) ***************************************************/ #include #include #include int main() { BVLogic logic{opensmt::Logic_t::QF_BV}; SMTConfig c; MainSolver* mainSolver_ = new MainSolver(logic, c, "test solver"); MainSolver& mainSolver = *mainSolver_; PTRef const1 = logic.mkBVConst(0); PTRef const2 = logic.mkBVConst(5); PTRef const3 = logic.mkBVConst(0); PTRef a = logic.mkBVNumVar("a"); PTRef b = logic.mkBVNumVar("b"); PTRef d = logic.mkBVNumVar("d"); PTRef eq1 = logic.mkBVEq(a, const1); PTRef eq2 = logic.mkBVEq(b, const2); PTRef eq3 = logic.mkBVEq(d, const3); //PTRef eq3_neg = logic.mkNot(eq3); PTRef d2 = logic.mkBVTimes(a, b); PTRef eq4 = logic.mkBVEq(d, d2); /******************************************************/ vec asgns; vec foo; SolverId id = {42}; BitBlaster bbb(id, c, mainSolver, logic, asgns, foo); BVRef output1; lbool stat; stat = bbb.insertEq(eq1, output1); BVRef output2; stat = bbb.insertEq(eq2, output2); BVRef output3; stat = bbb.insertEq(eq3, output3); BVRef output4; stat = bbb.insertEq(eq4, output4); std::cout << logic.printTerm(eq1) << "\n"; std::cout << logic.printTerm(eq2) << "\n"; std::cout << logic.printTerm(eq3) << "\n"; //std::cout << logic.printTerm(eq3_neg) << "\n"; std::cout << logic.printTerm(eq4) << "\n"; sstat r = mainSolver.check(); if (r == s_True) printf("sat\n"); else if (r == s_False) printf("unsat\n"); else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/examples/test7_BV.cc000066400000000000000000000034211445011647600167770ustar00rootroot00000000000000/************************************************ * Created on: Jan 25, 2017 * a=2 /\ b=0 /\ d=1 /\ d=((not a) || b) * * Insert four Equalities with InsertEq() * zero means false anything else is True ************************************************/ #include #include #include int main() { BVLogic logic{opensmt::Logic_t::QF_BV}; SMTConfig c; MainSolver* mainSolver_ = new MainSolver(logic, c, "test solver"); MainSolver& mainSolver = *mainSolver_; PTRef a = logic.mkBVNumVar("a"); PTRef const1 = logic.mkBVConst(2); PTRef eq1 = logic.mkBVEq(a, const1); PTRef b = logic.mkBVNumVar("b"); PTRef const2 = logic.mkBVConst(5); PTRef eq2 = logic.mkBVEq(b, const2); PTRef d = logic.mkBVNumVar("d"); PTRef const3 = logic.mkBVConst(1); PTRef eq3 = logic.mkBVEq(d, const3); PTRef a_neg = logic.mkBVNot(a); PTRef LOr = logic.mkBVLor(a_neg, b); PTRef eq4 = logic.mkBVEq(d, LOr); vec asgns; vec foo; SolverId id = {42}; BitBlaster bbb(id, c, mainSolver, logic, asgns, foo); BVRef output1; lbool stat; stat = bbb.insertEq(eq1, output1); BVRef output2; stat = bbb.insertEq(eq2, output2); BVRef output3; stat = bbb.insertEq(eq3, output3); BVRef output4; stat = bbb.insertEq(eq4, output4); std::cout << logic.printTerm(eq1) << "\n"; std::cout << logic.printTerm(eq2) << "\n"; std::cout << logic.printTerm(eq3) << "\n"; std::cout << logic.printTerm(LOr) << "\n"; std::cout << logic.printTerm(eq4) << "\n"; sstat r = mainSolver.check(); if (r == s_True) printf("sat\n"); else if (r == s_False) printf("unsat\n"); else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/examples/test8_BV.cc000066400000000000000000000030021445011647600167730ustar00rootroot00000000000000/*********************************************************** * Created on: Jan 25, 2017 * a=-2 /\ b=3 /\ a>b ==true * push 3 equalities ***********************************************************/ #include #include #include int main() { BVLogic logic{opensmt::Logic_t::QF_BV}; SMTConfig c; MainSolver* mainSolver_ = new MainSolver(logic, c, "test solver"); MainSolver& mainSolver = *mainSolver_; PTRef a = logic.mkBVNumVar("a"); PTRef const1 = logic.mkBVConst(-2); PTRef b = logic.mkBVNumVar("b"); PTRef const2 = logic.mkBVConst(3); PTRef eq1 = logic.mkBVEq(a, const1); PTRef eq2 = logic.mkBVEq(b, const2); vec args; args.push(a); args.push(b); PTRef GT = logic.mkBVSgt(args); PTRef one = logic.mkBVConst(1); PTRef eq3 = logic.mkBVEq(GT, one); vec asgns; vec foo; SolverId id = {42}; BitBlaster bbb(id, c, mainSolver, logic, asgns, foo); BVRef output1; lbool stat; stat = bbb.insertEq(eq1, output1); BVRef output2; stat = bbb.insertEq(eq2, output2); BVRef output3; stat = bbb.insertEq(eq3, output3); std::cout << logic.printTerm(eq1) << "\n"; std::cout << logic.printTerm(eq2) << "\n"; std::cout << logic.printTerm(eq3) << "\n"; sstat r = mainSolver.check(); if (r == s_True) printf("sat\n"); else if (r == s_False) printf("unsat\n"); else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/examples/test9_BV.cc000066400000000000000000000040341445011647600170020ustar00rootroot00000000000000/************************************************ * Created on: Jan 25, 2017 , Grisha's email example * ( (not a) \/ ( b = ( d + 1))) * in general(without value) it is sat * * For Values: * a=1 , b=1 , d=0 sat * a=7 , b=2 , d=1 sat * a=7 , b=2 , d=11 sat * * You are allowed only to use: InsertEq and InsertOr ************************************************/ #include #include #include int main() { BVLogic logic{opensmt::Logic_t::QF_BV}; SMTConfig c; MainSolver* mainSolver_ = new MainSolver(logic, c, "test solver"); MainSolver& mainSolver = *mainSolver_; PTRef a = logic.mkBVNumVar("a"); PTRef const1 = logic.mkBVConst(7); PTRef eq1 = logic.mkBVEq(a, const1); PTRef a_neg = logic.mkBVNot(a); PTRef b = logic.mkBVNumVar("b"); PTRef const2 = logic.mkBVConst(2); PTRef eq2 = logic.mkBVEq(b, const2); PTRef d = logic.mkBVNumVar("d"); PTRef const3 = logic.mkBVConst(11); PTRef eq3 = logic.mkBVEq(d, const3); PTRef one = logic.mkBVConst(1); PTRef dplusOne = logic.mkBVPlus(d, one); PTRef eq4 = logic.mkBVEq(b, dplusOne); PTRef eq5 = logic.mkBVLor(a_neg, eq4); vec asgns; vec foo; SolverId id = {42}; BitBlaster bbb(id, c, mainSolver, logic, asgns, foo); BVRef output1; lbool stat; stat = bbb.insertOr(eq5 , output1); BVRef output2; stat = bbb.insertEq(eq1, output2); BVRef output3; stat = bbb.insertEq(eq2, output3); BVRef output4; stat = bbb.insertEq(eq3, output4); // std::cout << logic.printTerm(eq1) << "\n"; // std::cout << logic.printTerm(eq2) << "\n"; // std::cout << logic.printTerm(eq3) << "\n"; // //std::cout << logic.printTerm(LOr) << "\n"; // std::cout << logic.printTerm(eq4) << "\n"; // std::cout << logic.printTerm(eq5) << "\n"; sstat r = mainSolver.check(); if (r == s_True) printf("sat\n"); else if (r == s_False) printf("unsat\n"); else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/examples/test_arrays.cc000066400000000000000000000043151445011647600177050ustar00rootroot00000000000000/* * Copyright (c) 2023, Martin Blicha * * SPDX-License-Identifier: MIT * */ #include void usingWrapper(); void creatingComponentsDirectly(); int main() { // There are now two ways to construct the necessary objects // 1. Using a provided wrapper usingWrapper(); // 2. Creating the necessary components directly creatingComponentsDirectly(); return 0; } void usingWrapper() { Opensmt osmt(qf_alia, "OpenSMT"); MainSolver & mainSolver = osmt.getMainSolver(); // You can ask the wrapper for the concrete subclass of Logic, but YOU need to make sure it matches the type you // have provided in the constructor ArithLogic & logic = osmt.getLIALogic(); SRef int2intSort = logic.getArraySort(logic.getSort_int(), logic.getSort_int()); PTRef zero = logic.getTerm_IntZero(); PTRef one = logic.getTerm_IntOne(); PTRef a = logic.mkVar(int2intSort, "a"); // assertion a<0 -> 1>[0] = 1 PTRef store = logic.mkStore({a, zero, one}); PTRef select = logic.mkSelect({store, zero}); PTRef eq = logic.mkEq(select, one); // test if the negation is satisfiable mainSolver.insertFormula(logic.mkNot(eq)); sstat r = mainSolver.check(); assert(r == s_False); if (r == s_True) printf("sat\n"); else if (r == s_False) { printf("unsat\n"); } else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); } void creatingComponentsDirectly() { ArithLogic logic{opensmt::Logic_t::QF_ALIA}; SMTConfig config; MainSolver mainSolver(logic, config, "ALIA solver"); SRef int2intSort = logic.getArraySort(logic.getSort_int(), logic.getSort_int()); // check that two arrays can be different PTRef a = logic.mkVar(int2intSort, "a"); PTRef b = logic.mkVar(int2intSort, "b"); PTRef eq = logic.mkEq(a, b); mainSolver.insertFormula(logic.mkNot(eq)); sstat r = mainSolver.check(); assert(r == s_True); // TODO: print model if (r == s_True) printf("sat\n"); else if (r == s_False) { printf("unsat\n"); } else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); } opensmt-2.5.2/examples/test_itp.cc000066400000000000000000000042271445011647600172020ustar00rootroot00000000000000#include #include Opensmt* pre() { auto config = std::make_unique(); const char* msg; config->setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); Opensmt* osmt = new Opensmt(opensmt_logic::qf_lra, "test solver", std::move(config)); return osmt; } int main() { Opensmt* osmt = pre(); SMTConfig& c = osmt->getConfig(); MainSolver& mainSolver = osmt->getMainSolver(); Logic& logic = osmt->getLogic(); // Let's build two assertions // First assertion (a /\ b) PTRef a = logic.mkBoolVar("a"); PTRef b = logic.mkBoolVar("b"); vec args1; args1.push(a); args1.push(b); PTRef ass1 = logic.mkAnd(args1); // Second assertion (!a \/ !b) PTRef neg_a = logic.mkNot(a); PTRef neg_b = logic.mkNot(b); vec args2; args2.push(neg_a); args2.push(neg_b); PTRef ass2 = logic.mkOr(args2); char* msg2; mainSolver.insertFormula(ass1, &msg2); mainSolver.insertFormula(ass2, &msg2); // Check sstat r = mainSolver.check(); if (r == s_True) printf("sat\n"); else if (r == s_False) { printf("unsat\n"); // Set labeling function const char* msg; c.setOption(SMTConfig::o_itp_bool_alg, SMTOption(0), msg); auto itp_context = mainSolver.getInterpolationContext(); // Create the partitioning mask // Mask has first partition in A and second in B // This is the way that OpenSMT represents partitions \. //ipartitions_t mask = 1; //mask <<= 1; // HighFrog has another representation, which in this case would be std::vector part; part.push_back(0); // It can be converted to OpenSMT's representation via ipartitions_t mask = 0; for(unsigned i = 0; i < part.size(); ++i) opensmt::setbit(mask, part[i] + 1); std::vector itps; itp_context->getSingleInterpolant(itps, mask); std::cerr << ";Interpolant:\n;" << logic.printTerm(itps[0]) << std::endl; } else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/examples/test_lia.cc000066400000000000000000000037411445011647600171530ustar00rootroot00000000000000// // Created by Martin Blicha on 29.07.20. // #include #include void usingWrapper(); void creatingComponentsDirectly(); int main() { // There are now two ways to construct the necessary objects // 1. Using a provided wrapper usingWrapper(); // 2. Creating the necessary components directly creatingComponentsDirectly(); return 0; } void usingWrapper() { Opensmt* osmt = new Opensmt(qf_lia, "OpenSMT"); MainSolver& mainSolver = osmt->getMainSolver(); // You can ask the wrapper for the concrete subclass of Logic, but YOU need to make sure it matches the type you // have provided in the constructor auto & logic = osmt->getLIALogic(); PTRef x = logic.mkIntVar("x"); PTRef y = logic.mkIntVar("y"); // assertion x + y = y + x PTRef lhs = logic.mkPlus(x, y); PTRef rhs = logic.mkPlus(y, x); PTRef eq = logic.mkEq(lhs, rhs); // test if the negation is satisfiable mainSolver.insertFormula(logic.mkNot(eq)); sstat r = mainSolver.check(); assert(r == s_False); if (r == s_True) printf("sat\n"); else if (r == s_False) { printf("unsat\n"); } else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); } void creatingComponentsDirectly() { ArithLogic logic{opensmt::Logic_t::QF_LIA}; SMTConfig config; MainSolver mainSolver(logic, config, "LIA solver"); PTRef x = logic.mkIntVar("x"); PTRef y = logic.mkIntVar("y"); // assertion x + y = y + x PTRef lhs = logic.mkPlus(x, y); PTRef rhs = logic.mkPlus(y, x); PTRef eq = logic.mkEq(lhs, rhs); // test if the negation is satisfiable mainSolver.insertFormula(logic.mkNot(eq)); sstat r = mainSolver.check(); assert(r == s_False); if (r == s_True) printf("sat\n"); else if (r == s_False) { printf("unsat\n"); } else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); } opensmt-2.5.2/examples/test_lra.cc000066400000000000000000000013511445011647600171570ustar00rootroot00000000000000#include #include Opensmt* pre() { Opensmt* osmt = new Opensmt(opensmt_logic::qf_lra, "test solver"); return osmt; } int main() { Opensmt* osmt = pre(); MainSolver& mainSolver = osmt->getMainSolver(); auto & logic = osmt->getLRALogic(); // Create the constant PTRef cons = logic.mkRealConst(-1); // assertion (<= -1 0) PTRef le1 = logic.mkLeq(cons, logic.getTerm_RealZero()); mainSolver.push(le1); // Check sstat r = mainSolver.check(); if (r == s_True) printf("sat\n"); else if (r == s_False) { printf("unsat\n"); } else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/examples/test_lra_itp.cc000066400000000000000000000046221445011647600200370ustar00rootroot00000000000000#include #include Opensmt* pre() { auto config = std::make_unique(); const char* msg; config->setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); Opensmt* osmt = new Opensmt(opensmt_logic::qf_lra, "test solver", std::move(config)); return osmt; } int main() { Opensmt* osmt = pre(); SMTConfig& c = osmt->getConfig(); MainSolver& mainSolver = osmt->getMainSolver(); auto & logic = osmt->getLRALogic(); // Let's build two assertions // Create vars PTRef x1 = logic.mkRealVar("x1"); PTRef x2 = logic.mkRealVar("x2"); PTRef x3 = logic.mkRealVar("x3"); PTRef x4 = logic.mkRealVar("x4"); // First assertion (and (<= x1 x2) (<= x3 x4)) PTRef le1 = logic.mkLeq(x1, x2); PTRef le2 = logic.mkLeq(x3, x4); vec args1; args1.push(le1); args1.push(le2); PTRef ass1 = logic.mkAnd(args1); // Second assertion (and (<= x2 x3) (< x4 x1)) PTRef le3 = logic.mkLeq(x2, x3); PTRef l4 = logic.mkLt(x4, x1); vec args2; args2.push(le3); args2.push(l4); PTRef ass2 = logic.mkAnd(args2); char* msg_2; mainSolver.insertFormula(ass1, &msg_2); mainSolver.insertFormula(ass2, &msg_2); // Check sstat r = mainSolver.check(); if (r == s_True) printf("sat\n"); else if (r == s_False) { printf("unsat\n"); // Set labeling function const char* msg; c.setOption(SMTConfig::o_itp_bool_alg, SMTOption(0), msg); // Create the proof graph auto itp_context = mainSolver.getInterpolationContext(); // Create the partitioning mask // Mask has first partition in A and second in B // This is the way that OpenSMT represents partitions \. //ipartitions_t mask = 1; //mask <<= 1; // HighFrog has another representation, which in this case would be std::vector part; part.push_back(0); // It can be converted to OpenSMT's representation via ipartitions_t mask = 0; for(unsigned i = 0; i < part.size(); ++i) opensmt::setbit(mask, part[i] + 1); std::vector itps; itp_context->getSingleInterpolant(itps, mask); std::cerr << ";Interpolant:\n;" << logic.printTerm(itps[0]) << std::endl; } else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/examples/test_lra_value.cc000066400000000000000000000066361445011647600203660ustar00rootroot00000000000000#include #include Opensmt* pre() { auto config = std::unique_ptr(new SMTConfig()); const char* msg; config->setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); Opensmt* osmt = new Opensmt(opensmt_logic::qf_lra, "test solver", std::move(config)); return osmt; } void kill(Opensmt* osmt) { delete osmt; } int main() { Opensmt* osmt = pre(); SMTConfig& c = osmt->getConfig(); MainSolver& mainSolver = osmt->getMainSolver(); auto & logic = osmt->getLRALogic(); // Let's build two assertions // Create vars PTRef x1 = logic.mkRealVar("x1"); PTRef x2 = logic.mkRealVar("x2"); PTRef x3 = logic.mkRealVar("x3"); PTRef x4 = logic.mkRealVar("x4"); // First assertion (and (<= x1 x2) (<= x3 x4)) vec leq_args; leq_args.push(x1); leq_args.push(x2); PTRef le1 = logic.mkLeq(leq_args); leq_args.clear(); leq_args.push(x3); leq_args.push(x4); PTRef le2 = logic.mkLeq(leq_args); vec args1; args1.push(le1); args1.push(le2); PTRef ass1 = logic.mkAnd(args1); // Second assertion (and (<= x2 x3) (< x4 2)) leq_args.clear(); leq_args.push(x2); leq_args.push(x3); PTRef le3 = logic.mkLeq(leq_args); leq_args.clear(); leq_args.push(x4); leq_args.push(logic.mkConst("2")); PTRef l4 = logic.mkLt(leq_args); vec args2; args2.push(le3); args2.push(l4); PTRef ass2 = logic.mkAnd(args2); char* msg2; mainSolver.insertFormula(ass1, &msg2); mainSolver.insertFormula(ass2, &msg2); // Check sstat r = mainSolver.check(); if (r == s_True) { printf("sat\n"); auto m = mainSolver.getModel(); PTRef v1 = m->evaluate(x1); auto name = logic.printTerm(x1); auto value = logic.printTerm(v1); std::cout << name << ": " << value << '\n'; PTRef v2 = m->evaluate(x2); name = logic.printTerm(x2); value = logic.printTerm(v2); std::cout << name << ": " << value << '\n'; PTRef v3 = m->evaluate(x3); name = logic.printTerm(x3); value = logic.printTerm(v3); std::cout << name << ": " << value << '\n'; PTRef v4 = m->evaluate(x4); name = logic.printTerm(x4); value = logic.printTerm(v4); std::cout << name << ": " << value << '\n'; } else if (r == s_False) { printf("unsat\n"); // Set labeling function const char* msg; c.setOption(SMTConfig::o_itp_bool_alg, SMTOption(0), msg); auto itp_context = mainSolver.getInterpolationContext(); // Create the partitioning mask // Mask has first partition in A and second in B // This is the way that OpenSMT represents partitions \. //ipartitions_t mask = 1; //mask <<= 1; // HighFrog has another representation, which in this case would be std::vector part; part.push_back(0); // It can be converted to OpenSMT's representation via ipartitions_t mask = 0; for(unsigned i = 0; i < part.size(); ++i) opensmt::setbit(mask, part[i] + 1); std::vector itps; itp_context->getSingleInterpolant(itps, mask); std::cerr << ";Interpolant:\n;" << logic.printTerm(itps[0]) << std::endl; } else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); kill(osmt); return 0; } opensmt-2.5.2/get-python-wrappers.sh000077500000000000000000000004631445011647600175160ustar00rootroot00000000000000#!/usr/bin/env sh OSMT_INSTALL=/home/hyvaeria/opensmt-install swig -I${OSMT_INSTALL}/include/opensmt -python -o src/PySMT/opensmt_python_wrap.c src/PySMT/opensmt_python.i python src/PySMT/setup.py ${OSMT_INSTALL} build cp build/lib.linux-x86_64-2.7/_opensmt.so examples/ cp src/PySMT/opensmt.py examples/ opensmt-2.5.2/parallel-test/000077500000000000000000000000001445011647600157665ustar00rootroot00000000000000opensmt-2.5.2/parallel-test/CMakeLists.txt000066400000000000000000000005661445011647600205350ustar00rootroot00000000000000include(FetchContent) FetchContent_Declare( googletest GIT_REPOSITORY https://github.com/google/googletest.git GIT_TAG release-1.11.0 ) FetchContent_GetProperties(googletest) if(NOT googletest_POPULATED) FetchContent_Populate(googletest) add_subdirectory(${googletest_SOURCE_DIR} ${googletest_BINARY_DIR} EXCLUDE_FROM_ALL) endif() add_subdirectory(unit) opensmt-2.5.2/parallel-test/unit/000077500000000000000000000000001445011647600167455ustar00rootroot00000000000000opensmt-2.5.2/parallel-test/unit/CMakeLists.txt000066400000000000000000000000241445011647600215010ustar00rootroot00000000000000include(GoogleTest) opensmt-2.5.2/regression/000077500000000000000000000000001445011647600153755ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_ALIA/000077500000000000000000000000001445011647600164715ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_ALIA/basic_unsat.smt2000066400000000000000000000011661445011647600215770ustar00rootroot00000000000000(set-logic QF_ALIA) (set-info :status unsat) (declare-fun a_3 () (Array Int Int)) (declare-fun a_7 () (Array Int Int)) (declare-fun e_0 () Int) (declare-fun e_1 () Int) (declare-fun e_2 () Int) (declare-fun e_4 () Int) (declare-fun e_5 () Int) (declare-fun e_6 () Int) (declare-fun a () (Array Int Int)) (declare-fun i () Int) (assert (= a_3 (store a e_0 e_2))) (assert (= a_7 (store a e_4 e_6))) (assert (= e_0 (+ i 1))) (assert (= e_1 (select a i))) (assert (= e_2 (+ e_1 1))) (assert (= e_4 (+ i 0))) (assert (= e_5 (select a e_0))) (assert (= e_6 (- e_5 1))) (assert (= a_3 a_7)) (assert (not (= e_2 e_5))) (check-sat) (exit) opensmt-2.5.2/regression/QF_ALIA/basic_unsat.smt2.expected.err000066400000000000000000000000001445011647600241500ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_ALIA/basic_unsat.smt2.expected.out000066400000000000000000000000061445011647600241750ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_ALIA/basic_unsat_2.smt2000066400000000000000000000003171445011647600220150ustar00rootroot00000000000000(set-logic QF_ALIA) (set-info :status unsat) (declare-fun i () Int) (declare-fun j () Int) (declare-fun a () (Array Int Int)) (assert (and (distinct i (select a 5)) (= a (store a j i)) (= j 5))) (check-sat) opensmt-2.5.2/regression/QF_ALIA/basic_unsat_2.smt2.expected.err000066400000000000000000000000001445011647600243710ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_ALIA/basic_unsat_2.smt2.expected.out000066400000000000000000000000061445011647600244160ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_ALIA/distinct.smt2000066400000000000000000000002421445011647600211170ustar00rootroot00000000000000(set-logic QF_ALIA) (set-info :status unsat) (declare-fun a () (Array Int Int)) (declare-fun i () Int) (assert (distinct i (select (store a i i) i))) (check-sat) opensmt-2.5.2/regression/QF_ALIA/distinct.smt2.expected.err000066400000000000000000000000001445011647600234760ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_ALIA/distinct.smt2.expected.out000066400000000000000000000000061445011647600235230ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_ALIA/distinct_2.smt2000066400000000000000000000004041445011647600213400ustar00rootroot00000000000000(set-logic QF_ALIA) (set-info :status unsat) (declare-fun b () (Array Int Int)) (declare-fun j () Int) (declare-fun a () (Array Int Int)) (declare-fun i () Int) (assert (= (store b i j) (store a (select a i) i))) (assert (distinct j (select a i))) (check-sat) opensmt-2.5.2/regression/QF_ALIA/distinct_2.smt2.expected.err000066400000000000000000000000001445011647600237170ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_ALIA/distinct_2.smt2.expected.out000066400000000000000000000000061445011647600237440ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_ALIA/int-based_array_conflict.smt2000066400000000000000000000002271445011647600242260ustar00rootroot00000000000000(set-logic QF_ALIA) (set-info :status unsat) (declare-fun a () (Array Int Int)) (assert (distinct 0 (select (store (store a 3 0) 0 0) 3))) (check-sat) opensmt-2.5.2/regression/QF_ALIA/int-based_array_conflict.smt2.expected.err000066400000000000000000000000001445011647600266020ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_ALIA/int-based_array_conflict.smt2.expected.out000066400000000000000000000000061445011647600266270ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_ALIA/interface_equality_from_arrays.smt2000066400000000000000000000003621445011647600255620ustar00rootroot00000000000000(set-logic QF_ALIA) (set-info :status unsat) (declare-fun j () Int) (declare-fun v () Int) (declare-fun a () (Array Int Int)) (declare-fun i () Int) (assert (and (< j i) (distinct v (select a j)) (= a (store (store a j v) i 0)))) (check-sat) opensmt-2.5.2/regression/QF_ALIA/interface_equality_from_arrays.smt2.expected.err000066400000000000000000000000001445011647600301360ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_ALIA/interface_equality_from_arrays.smt2.expected.out000066400000000000000000000000061445011647600301630ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_ALIA/interface_vars_from_array.smt2000066400000000000000000000003351445011647600245150ustar00rootroot00000000000000(set-logic QF_ALIA) (set-info :status unsat) (declare-fun i () Int) (declare-fun a () (Array Int Int)) (declare-fun j () Int) (assert (and (= i 0) (= 1 (select a j)) (= a (store a 1 0)) (or (= 1 i) (= j 1)))) (check-sat) opensmt-2.5.2/regression/QF_ALIA/interface_vars_from_array.smt2.expected.err000066400000000000000000000000001445011647600270710ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_ALIA/interface_vars_from_array.smt2.expected.out000066400000000000000000000000061445011647600271160ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_ALIA/purification.smt2000066400000000000000000000001401445011647600217670ustar00rootroot00000000000000(set-logic QF_ALIA) (declare-fun a () (Array Int Int)) (assert (<= 0 (select a 0))) (check-sat) opensmt-2.5.2/regression/QF_ALIA/purification.smt2.expected.err000066400000000000000000000000001445011647600243510ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_ALIA/purification.smt2.expected.out000066400000000000000000000000041445011647600243740ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_ALIA/smt-lib_example.smt2000066400000000000000000000637031445011647600223730ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_ALIA) (set-info :source | Translated from old SVC processor verification benchmarks. Contact Clark Barrett at barrett@cs.nyu.edu for more information. This benchmark was automatically translated into SMT-LIB format from CVC format using CVC Lite |) (set-info :category "industrial") (set-info :status unsat) (declare-fun INSTRISLOAD_S2M_INIT () Bool) (declare-fun INSTRISSTORE_S2M_INIT () Bool) (declare-fun EXTSTATE_S2_INIT () Int) (declare-fun FLUSHSTATE_S2_INIT () Int) (declare-fun CONFSTATE_S2_INIT () Int) (declare-fun DEXTREAD_S2_INIT () Bool) (declare-fun XFERCNT_S2_INIT () Int) (declare-fun DCACHERW_S2M_INIT () Bool) (declare-fun DCACHESEL_S2M_INIT () Bool) (declare-fun DTAG1_RW1_S2_INIT () Bool) (declare-fun DTAG1_SEL1_S2_INIT () Bool) (declare-fun DTAGREAD_S2M_INIT () Bool) (declare-fun DIRTY1_RW1_S2_INIT () Bool) (declare-fun DIRTY1_SEL1_S2_INIT () Bool) (declare-fun DIRTY1_DATA_INIT () Bool) (declare-fun DIRTY1_CACHEDOUT_S2_INIT () Bool) (declare-fun VALID1_DATA_INIT () Bool) (declare-fun VALID1_CACHEDOUT_S2_INIT () Bool) (declare-fun VALID1_RW1_S2_INIT () Bool) (declare-fun VALID1_SEL1_S2_INIT () Bool) (declare-fun VALID1_IN_S2_INIT () Bool) (declare-fun DCACHEDATAVALID_S2_INIT () Bool) (declare-fun MCREAD_S2_INIT () Bool) (declare-fun EXTSTATE_S1_INIT () Int) (declare-fun FLUSHSTATE_S1_INIT () Int) (declare-fun DEXTREQ_S2_INIT () Bool) (declare-fun CONFSTALL_S2M_INIT () Bool) (declare-fun INSTRISSTORE_S1W_INIT () Bool) (declare-fun INSTRISSTORE_S2W_INIT () Bool) (declare-fun RESTARTED_S2_INIT () Bool) (declare-fun MCREQ_S2_INIT () Bool) (declare-fun SB_RW_S2_INIT () Bool) (declare-fun SBWRITE_S2_INIT () Bool) (declare-fun DELAYEDMCWRITE_S2_INIT () Bool) (declare-fun DCACHEHIT1_S1W_INIT () Bool) (declare-fun DIRTY1_IN_S2_INIT () Bool) (declare-fun DCACHEDATAVALID_S1_INIT () Bool) (declare-fun DCACHEMISS_S1W_INIT () Bool) (declare-fun MCBUSY_S2_INIT () Bool) (declare-fun REQWAITING_S2_INIT () Bool) (declare-fun CCMEMREQ_S1_INIT () Bool) (declare-fun MCREAD_S1_INIT () Bool) (declare-fun DELAYEDMCWRITE_S1_INIT () Bool) (declare-fun XFERCNT_S1_INIT () Int) (declare-fun DRVMCDBDATA_S1_INIT () Bool) (declare-fun CONFSTATE_S1_INIT () Int) (declare-fun MCDBDATAVALID_S1_INIT () Bool) (declare-fun MCDBDATAVALID_S2_INIT () Bool) (declare-fun RESTARTED_S1_INIT () Bool) (declare-fun SBWRITE_S1_INIT () Bool) (declare-fun BWASLOAD_S1W_INIT () Bool) (declare-fun DTAG1_ADDR_S2_INIT () Int) (declare-fun VALID1_ADDR_S2_INIT () Int) (declare-fun DTAG1_CACHEDOUT_S2_INIT () Int) (declare-fun DTAG1_DATA_INIT () Int) (declare-fun SB_DATA_INIT () Int) (declare-fun SB_OUT_S2_INIT () Int) (declare-fun DCACHE_ADDR_S2_INIT () Int) (declare-fun DIRTY1_ADDR_S2_INIT () Int) (declare-fun DCACHE_DATA_INIT () Int) (declare-fun DCACHE_OUT_S2_INIT () Int) (declare-fun SB_SEL_S2_INIT () Bool) (declare-fun DELAYEDMCADDR_S1_INIT () Int) (declare-fun DELAYEDMCADDR_S2_INIT () Int) (declare-fun SB_IN_S1_INIT () Int) (declare-fun SB_IN_S2_INIT () Int) (declare-fun SBOUT_S1_INIT () Int) (declare-fun SBOUT_S2_INIT () Int) (declare-fun DRVMCDBDATA_S2_INIT () Bool) (declare-fun MISSADDR_S1W_INIT () Int) (declare-fun SBDELAYADDR_S2_INIT () Int) (declare-fun REQWAITING_S1B_INIT () Bool) (declare-fun SBDELAYADDR_S1_INIT () Int) (declare-fun NO_VALUE () Int) (declare-fun SB_ADDR_S2_INIT () Int) (declare-fun DTAGDATA1_S1_INIT () Int) (declare-fun MCADDR_S2_INIT () Int) (declare-fun DCACHE_IN_S2_INIT () Int) (declare-fun STOREDATA_S1W_INIT () Int) (declare-fun MCDATA_S1_INIT () Int) (declare-fun DMEM_INIT () (Array Int Int)) (declare-fun MCDBDATA_OUT_S2_INIT () Int) (declare-fun STOREADDR_S1W_INIT () Int) (declare-fun STOREADDR_S2M_INIT () Int) (declare-fun DOLOAD_INIT () Bool) (declare-fun DOSOMETHING_INIT () Bool) (declare-fun NON_DET_DELAY_INIT () Bool) (declare-fun STOREDATA_S2M_INIT () Int) (declare-fun MEMADDR_S1M_INIT () Int) (declare-fun STOREDATA_S1M_INIT () Int) (declare-fun BLOADDATA_S1W_INIT () Int) (assert (let ((?v_0 (ite INSTRISLOAD_S2M_INIT false true)) (?v_1 (ite INSTRISSTORE_S2M_INIT false true)) (?v_2 (= EXTSTATE_S2_INIT 11)) (?v_3 (= FLUSHSTATE_S2_INIT 16)) (?v_4 (= CONFSTATE_S2_INIT 10)) (?v_101 (= XFERCNT_S2_INIT 25)) (?v_36 (ite DTAGREAD_S2M_INIT false true)) (?v_21 (ite DIRTY1_SEL1_S2_INIT false true)) (?v_18 (ite DIRTY1_DATA_INIT false true)) (?v_17 (ite VALID1_DATA_INIT false true)) (?v_22 (ite VALID1_SEL1_S2_INIT false true)) (?v_93 (ite MCREAD_S2_INIT false true)) (?v_59 (= EXTSTATE_S1_INIT 11)) (?v_82 (ite CONFSTALL_S2M_INIT false true)) (?v_81 (ite INSTRISSTORE_S1W_INIT false true)) (?v_94 (ite INSTRISSTORE_S2W_INIT false true)) (?v_11 (ite RESTARTED_S2_INIT false true)) (?v_46 (ite MCREQ_S2_INIT false true)) (?v_142 (ite SBWRITE_S2_INIT false true)) (?v_42 (ite DELAYEDMCWRITE_S2_INIT false true)) (?v_78 (ite DCACHEMISS_S1W_INIT false true)) (?v_121 (ite MCBUSY_S2_INIT false true)) (?v_41 (ite MCREAD_S1_INIT false true)) (?v_38 (= CONFSTATE_S1_INIT 10)) (?v_90 (ite RESTARTED_S1_INIT false true)) (?v_43 (ite SBWRITE_S1_INIT false true)) (?v_13 (= EXTSTATE_S2_INIT 13)) (?v_14 (= EXTSTATE_S2_INIT 15)) (?v_15 (= EXTSTATE_S2_INIT 17)) (?v_5 (= EXTSTATE_S2_INIT 18)) (?v_9 (= EXTSTATE_S2_INIT 22)) (?v_6 (= EXTSTATE_S2_INIT 19)) (?v_10 (= EXTSTATE_S2_INIT 23)) (?v_7 (= FLUSHSTATE_S2_INIT 21)) (?v_8 (= FLUSHSTATE_S2_INIT 27)) (?v_19 (= FLUSHSTATE_S2_INIT 24)) (?v_29 (= FLUSHSTATE_S2_INIT 28)) (?v_28 (= FLUSHSTATE_S2_INIT 29))) (let ((?v_31 (ite ?v_29 true ?v_28))) (let ((?v_12 (ite ?v_19 true ?v_31)) (?v_49 (= CONFSTATE_S2_INIT 12)) (?v_53 (= CONFSTATE_S2_INIT 14)) (?v_100 (ite ?v_7 true ?v_8)) (?v_16 (ite ?v_9 true ?v_10)) (?v_25 (ite ?v_7 false true))) (let ((?v_114 (ite ?v_6 true ?v_16)) (?v_146 (ite DTAG1_RW1_S2_INIT false true)) (?v_20 (ite ?v_19 true DEXTREAD_S2_INIT)) (?v_23 (= EXTSTATE_S1_INIT 17)) (?v_24 (ite ?v_6 false true)) (?v_26 (= EXTSTATE_S1_INIT 19)) (?v_83 (= EXTSTATE_S1_INIT 22))) (let ((?v_27 (ite ?v_83 true DCACHERW_S2M_INIT)) (?v_106 (ite ?v_28 true ?v_29))) (let ((?v_30 (ite (ite ?v_25 VALID1_IN_S2_INIT false) true ?v_106)) (?v_32 (ite ?v_31 true SBWRITE_S1_INIT)) (?v_34 (ite VALID1_IN_S2_INIT DCACHEDATAVALID_S1_INIT false))) (let ((?v_33 (ite DTAGREAD_S2M_INIT true ?v_34)) (?v_35 (ite ?v_34 false true)) (?v_58 (ite ?v_4 false true)) (?v_37 (ite ?v_14 true DEXTREAD_S2_INIT))) (let ((?v_39 (ite VALID1_RW1_S2_INIT true ?v_37)) (?v_40 (ite ?v_36 false true)) (?v_44 (ite DRVMCDBDATA_S1_INIT true ?v_28)) (?v_45 (ite REQWAITING_S2_INIT true CCMEMREQ_S1_INIT)) (?v_47 (ite MCREQ_S2_INIT MCREAD_S1_INIT MCDBDATAVALID_S1_INIT)) (?v_48 (ite (ite (ite REQWAITING_S1B_INIT false true) MCREQ_S2_INIT false) true REQWAITING_S1B_INIT)) (?v_143 (= EXTSTATE_S1_INIT 18)) (?v_63 (ite INSTRISSTORE_S1W_INIT ?v_2 false)) (?v_54 (ite ?v_10 INSTRISSTORE_S1W_INIT false))) (let ((?v_50 (ite ?v_49 true (ite ?v_13 true ?v_54))) (?v_51 (= DCACHE_IN_S2_INIT STOREDATA_S1W_INIT)) (?v_52 (= DCACHE_IN_S2_INIT MCDATA_S1_INIT)) (?v_55 (ite ?v_53 true (ite ?v_14 true SBWRITE_S2_INIT))) (?v_64 (ite ?v_2 ?v_4 false)) (?v_56 (ite ?v_49 true ?v_13)) (?v_57 (ite (ite (ite VALID1_IN_S2_INIT true ?v_9) DCACHEDATAVALID_S1_INIT false) true ?v_54))) (let ((?v_75 (ite (ite DCACHEHIT1_S1W_INIT (ite (ite INSTRISSTORE_S1W_INIT ?v_64 false) true ?v_56) false) true ?v_57)) (?v_84 (ite ?v_49 false true)) (?v_76 (ite (ite DCACHEHIT1_S1W_INIT ?v_56 false) true ?v_57)) (?v_103 (ite ?v_2 false true))) (let ((?v_60 (ite ?v_58 true (ite ?v_103 true DCACHEMISS_S1W_INIT))) (?v_97 (ite ?v_59 false true))) (let ((?v_89 (ite ?v_58 true (ite ?v_97 true DCACHEMISS_S1W_INIT)))) (let ((?v_92 (ite ?v_89 false true))) (let ((?v_91 (ite ?v_92 false BWASLOAD_S1W_INIT)) (?v_61 (ite MCREAD_S2_INIT MCREQ_S2_INIT false)) (?v_62 (= (select DMEM_INIT MCADDR_S2_INIT) MCDBDATA_OUT_S2_INIT)) (?v_66 (ite ?v_58 true ?v_13))) (let ((?v_70 (ite ?v_63 true ?v_66)) (?v_67 (= DTAG1_ADDR_S2_INIT STOREADDR_S1W_INIT)) (?v_68 (= DTAG1_ADDR_S2_INIT MISSADDR_S1W_INIT))) (let ((?v_65 (ite ?v_70 ?v_67 ?v_68)) (?v_69 (ite ?v_66 ?v_67 ?v_68)) (?v_71 (= DIRTY1_ADDR_S2_INIT STOREADDR_S1W_INIT)) (?v_72 (= DIRTY1_ADDR_S2_INIT MISSADDR_S1W_INIT)) (?v_73 (ite ?v_4 ?v_2 false))) (let ((?v_74 (ite ?v_66 ?v_71 ?v_72)) (?v_77 (ite DCACHERW_S2M_INIT false true)) (?v_79 (ite DCACHEDATAVALID_S1_INIT ?v_28 ?v_29)) (?v_80 (ite MCREQ_S2_INIT ?v_29 ?v_19)) (?v_118 (ite ?v_81 ?v_82 true)) (?v_85 (ite ?v_53 true (ite (= EXTSTATE_S1_INIT 15) true SBWRITE_S2_INIT))) (?v_86 (ite ?v_49 true (= EXTSTATE_S1_INIT 13))) (?v_87 (ite (ite (ite VALID1_IN_S2_INIT true ?v_83) DCACHEDATAVALID_S1_INIT false) true (ite (= EXTSTATE_S1_INIT 23) INSTRISSTORE_S1W_INIT false)))) (let ((?v_95 (ite (ite DCACHEHIT1_S1W_INIT (ite (ite INSTRISSTORE_S1W_INIT (ite ?v_59 ?v_4 false) false) true ?v_86) false) true ?v_87)) (?v_88 (ite ?v_21 false true)) (?v_96 (ite (ite DCACHEHIT1_S1W_INIT ?v_86 false) true ?v_87)) (?v_98 (ite BWASLOAD_S1W_INIT DCACHEDATAVALID_S1_INIT false))) (let ((?v_99 (ite ?v_98 true ?v_97)) (?v_155 (ite SB_RW_S2_INIT false true)) (?v_115 (ite INSTRISLOAD_S2M_INIT true INSTRISSTORE_S2M_INIT)) (?v_109 (= DTAG1_ADDR_S2_INIT STOREADDR_S2M_INIT)) (?v_105 (ite ?v_101 false true))) (let ((?v_102 (ite BWASLOAD_S1W_INIT (ite (ite (ite ?v_6 (ite ?v_105 true ?v_100) false) true ?v_9) DCACHEDATAVALID_S1_INIT false) false))) (let ((?v_104 (ite ?v_102 true ?v_103)) (?v_117 (ite INSTRISLOAD_S2M_INIT INSTRISSTORE_S1W_INIT false)) (?v_107 (= STOREADDR_S1W_INIT STOREADDR_S2M_INIT)) (?v_116 (ite ?v_103 (ite ?v_13 false true) false)) (?v_108 (ite INSTRISSTORE_S2M_INIT ?v_103 false)) (?v_119 (= XFERCNT_S2_INIT 20))) (let ((?v_111 (ite ?v_9 true (ite ?v_10 true (ite ?v_6 (ite ?v_25 ?v_119 false) false))))) (let ((?v_110 (ite INSTRISSTORE_S2M_INIT ?v_111 false)) (?v_112 (= DTAG1_ADDR_S2_INIT DTAG1_DATA_INIT)) (?v_113 (= DTAG1_DATA_INIT STOREADDR_S2M_INIT)) (?v_125 (= XFERCNT_S2_INIT 26)) (?v_126 (ite (ite VALID1_SEL1_S2_INIT VALID1_RW1_S2_INIT false) VALID1_CACHEDOUT_S2_INIT false)) (?v_132 (= DTAG1_ADDR_S2_INIT DTAG1_CACHEDOUT_S2_INIT))) (let ((?v_120 (ite (ite (ite ?v_126 false true) true (ite ?v_132 false true)) DTAGREAD_S2M_INIT false))) (let ((?v_135 (ite ?v_4 (ite (ite CONFSTALL_S2M_INIT (ite (ite ?v_120 false true) (ite INSTRISLOAD_S2M_INIT ?v_2 false) false) false) 12 10) (ite ?v_49 (ite ?v_13 10 14) 10)))) (let ((?v_134 (= ?v_135 10)) (?v_127 (ite ?v_121 DEXTREQ_S2_INIT false))) (let ((?v_124 (ite ?v_2 (ite (ite ?v_120 INSTRISSTORE_S2W_INIT false) 13 (ite (ite ?v_120 ?v_94 false) 15 11)) (ite ?v_13 15 (ite ?v_14 (ite (ite ?v_3 false true) 15 17) (ite ?v_15 (ite ?v_127 18 17) (ite ?v_5 19 (ite ?v_6 (ite (ite ?v_119 ?v_25 false) 22 19) (ite ?v_9 23 11))))))))) (let ((?v_133 (= ?v_124 11))) (let ((?v_122 (ite ?v_133 false true))) (let ((?v_174 (ite (ite ?v_134 false true) true (ite ?v_122 true ?v_120))) (?v_169 (ite INSTRISLOAD_S2M_INIT (ite ?v_6 DCACHEDATAVALID_S2_INIT false) false))) (let ((?v_175 (ite (ite ?v_169 true (ite RESTARTED_S2_INIT ?v_122 false)) false true)) (?v_123 (ite DOLOAD_INIT DOSOMETHING_INIT false)) (?v_173 (ite DOLOAD_INIT false true))) (let ((?v_129 (ite ?v_173 DOSOMETHING_INIT false))) (let ((?v_128 (ite (ite ?v_174 (ite ?v_175 true (ite ?v_123 true ?v_129)) false) false true)) (?v_188 (ite DOSOMETHING_INIT DOLOAD_INIT false))) (let ((?v_172 (ite ?v_128 ?v_188 false)) (?v_185 (ite (ite ?v_174 ?v_175 false) false true)) (?v_136 (= ?v_124 19))) (let ((?v_130 (ite ?v_136 false true)) (?v_137 (= ?v_124 22))) (let ((?v_131 (ite ?v_137 false true))) (let ((?v_176 (ite ?v_130 ?v_131 false)) (?v_170 (ite DTAGREAD_S2M_INIT (ite ?v_126 ?v_132 false) false))) (let ((?v_177 (ite (ite INSTRISSTORE_S2M_INIT DTAGREAD_S2M_INIT false) ?v_170 DCACHEHIT1_S1W_INIT)) (?v_158 (ite ?v_0 true ?v_56))) (let ((?v_139 (ite ?v_158 (ite INSTRISSTORE_S2M_INIT (ite ?v_10 false true) false) INSTRISSTORE_S1W_INIT)) (?v_178 (ite ?v_133 ?v_134 false)) (?v_161 (= ?v_135 12)) (?v_162 (= ?v_124 13))) (let ((?v_179 (ite ?v_161 true ?v_162)) (?v_140 (ite ?v_136 true ?v_137)) (?v_138 (= ?v_124 23))) (let ((?v_163 (ite ?v_138 ?v_139 false))) (let ((?v_180 (ite (ite ?v_140 DCACHEDATAVALID_S2_INIT false) true ?v_163)) (?v_141 (ite ?v_3 (ite (ite ?v_14 (ite (ite (ite DIRTY1_SEL1_S2_INIT DIRTY1_RW1_S2_INIT false) DIRTY1_CACHEDOUT_S2_INIT false) ?v_126 false) false) 21 16) (ite ?v_7 (ite ?v_119 27 21) (ite ?v_8 (ite ?v_10 24 27) (ite ?v_19 (ite ?v_127 28 24) (ite ?v_29 (ite DCACHEDATAVALID_S2_INIT 29 28) (ite ?v_28 (ite ?v_119 16 29) 16)))))))) (let ((?v_147 (= ?v_141 27)) (?v_148 (ite ?v_142 false true)) (?v_149 (= ?v_124 17)) (?v_153 (= ?v_141 29)) (?v_145 (ite DELAYEDMCWRITE_S2_INIT (store DMEM_INIT DELAYEDMCADDR_S2_INIT (ite DRVMCDBDATA_S2_INIT SBOUT_S2_INIT NO_VALUE)) DMEM_INIT)) (?v_144 (= FLUSHSTATE_S1_INIT 28))) (let ((?v_150 (ite (ite (ite ?v_28 true ?v_153) (ite MCREQ_S2_INIT ?v_93 false) false) (store ?v_145 (ite (ite ?v_143 true ?v_144) (ite ?v_144 DTAGDATA1_S1_INIT MISSADDR_S1W_INIT) NO_VALUE) (ite (ite SB_SEL_S2_INIT SB_RW_S2_INIT false) SB_OUT_S2_INIT NO_VALUE)) ?v_145)) (?v_154 (ite ?v_146 DTAG1_ADDR_S2_INIT DTAG1_DATA_INIT)) (?v_171 (ite (ite DCACHESEL_S2M_INIT DCACHERW_S2M_INIT false) DCACHE_OUT_S2_INIT NO_VALUE))) (let ((?v_151 (ite ?v_7 ?v_171 NO_VALUE)) (?v_156 (ite ?v_15 (ite (ite DTAG1_SEL1_S2_INIT DTAG1_RW1_S2_INIT false) DTAG1_CACHEDOUT_S2_INIT NO_VALUE) DTAGDATA1_S1_INIT)) (?v_152 (= ?v_141 21)) (?v_157 (ite ?v_155 SB_IN_S2_INIT SB_DATA_INIT))) (let ((?v_159 (ite (ite ?v_147 (ite ?v_148 ?v_149 false) false) (store ?v_150 ?v_154 ?v_151) (ite (ite ?v_147 (ite ?v_148 (ite ?v_149 false true) false) false) (store ?v_150 ?v_156 ?v_151) (ite (ite (ite (= ?v_141 16) false true) (ite (ite ?v_152 false true) (ite ?v_153 false true) false) false) (ite ?v_149 (store ?v_150 ?v_154 ?v_157) (store ?v_150 ?v_156 ?v_157)) ?v_150)))) (?v_165 (ite ?v_158 STOREADDR_S2M_INIT STOREADDR_S1W_INIT)) (?v_164 (ite ?v_158 STOREDATA_S2M_INIT STOREDATA_S1W_INIT))) (let ((?v_181 (ite ?v_139 (store ?v_159 ?v_165 ?v_164) ?v_159)) (?v_182 (ite ?v_161 true (ite ?v_162 true ?v_163))) (?v_183 (ite DCACHEDATAVALID_S2_INIT MCDBDATA_OUT_S2_INIT MCDATA_S1_INIT)) (?v_166 (ite (ite (ite (ite DIRTY1_RW1_S2_INIT false true) DIRTY1_IN_S2_INIT DIRTY1_DATA_INIT) (ite (ite (ite VALID1_RW1_S2_INIT false true) VALID1_IN_S2_INIT VALID1_DATA_INIT) (ite ?v_147 false true) false) false) (store ?v_159 ?v_154 (ite ?v_77 DCACHE_IN_S2_INIT DCACHE_DATA_INIT)) ?v_159))) (let ((?v_184 (ite ?v_139 (store ?v_166 ?v_165 ?v_164) ?v_166))) (let ((?v_186 (ite (ite (ite (ite (ite (ite ?v_177 (ite (ite ?v_139 ?v_178 false) true ?v_179) false) true ?v_180) false true) false true) ?v_130 false) (ite ?v_140 ?v_181 (store ?v_159 ?v_154 (ite (ite (ite ?v_139 ?v_133 false) true ?v_182) ?v_164 ?v_183))) ?v_184)) (?v_190 (ite ?v_185 MEMADDR_S1M_INIT STOREADDR_S2M_INIT))) (let ((?v_187 (ite (ite (ite ?v_185 false INSTRISSTORE_S2M_INIT) ?v_176 false) (store ?v_186 ?v_190 (ite ?v_185 STOREDATA_S1M_INIT STOREDATA_S2M_INIT)) ?v_186)) (?v_189 (ite (ite ?v_130 true (ite (= (ite (ite ?v_19 true (ite ?v_14 ?v_3 false)) 25 (ite (ite DCACHEDATAVALID_S2_INIT true ?v_7) (ite ?v_101 26 (ite (ite ?v_125 NON_DET_DELAY_INIT false) 26 (ite (ite ?v_125 (ite NON_DET_DELAY_INIT false true) false) 20 25))) XFERCNT_S2_INIT)) 25) true ?v_152)) (ite ?v_131 (ite ?v_138 false true) false) false)) (?v_191 (ite (ite ?v_11 (ite (ite INSTRISLOAD_S2M_INIT DTAGREAD_S2M_INIT false) true ?v_169) false) (ite ?v_169 MCDBDATA_OUT_S2_INIT (ite (ite INSTRISLOAD_S2M_INIT ?v_170 false) ?v_171 NO_VALUE)) BLOADDATA_S1W_INIT)) (?v_160 (ite ?v_123 false true))) (let ((?v_167 (ite (ite (ite (ite (ite (ite ?v_177 (ite (ite ?v_139 (ite ?v_160 ?v_178 false) false) true ?v_179) false) true ?v_180) false true) false true) ?v_130 false) (ite ?v_140 ?v_181 (store ?v_159 ?v_154 (ite (ite (ite ?v_139 (ite ?v_160 ?v_133 false) false) true ?v_182) ?v_164 ?v_183))) ?v_184)) (?v_168 (ite ?v_128 MEMADDR_S1M_INIT STOREADDR_S2M_INIT))) (not (ite (ite (ite ?v_0 (ite ?v_1 (ite ?v_2 (ite ?v_3 (ite ?v_4 (ite (ite DEXTREAD_S2_INIT false true) (ite ?v_101 (ite DCACHERW_S2M_INIT (ite (ite DCACHESEL_S2M_INIT false true) (ite DTAG1_RW1_S2_INIT (ite (ite DTAG1_SEL1_S2_INIT false true) (ite ?v_36 (ite DIRTY1_RW1_S2_INIT (ite ?v_21 (ite ?v_18 (ite (ite DIRTY1_CACHEDOUT_S2_INIT false true) (ite ?v_17 (ite (ite VALID1_CACHEDOUT_S2_INIT false true) (ite VALID1_RW1_S2_INIT (ite ?v_22 (ite (ite VALID1_IN_S2_INIT false true) (ite (ite DCACHEDATAVALID_S2_INIT false true) (ite ?v_93 (ite ?v_59 (ite (= FLUSHSTATE_S1_INIT 16) (ite (ite DEXTREQ_S2_INIT false true) (ite ?v_82 (ite ?v_81 (ite ?v_94 (ite ?v_11 (ite ?v_46 (ite SB_RW_S2_INIT (ite ?v_142 (ite ?v_42 (ite (ite DCACHEHIT1_S1W_INIT false true) (ite DIRTY1_IN_S2_INIT (ite (ite DCACHEDATAVALID_S1_INIT false true) (ite ?v_78 (ite ?v_121 (ite (ite REQWAITING_S2_INIT false true) (ite (ite CCMEMREQ_S1_INIT false true) (ite ?v_41 (ite (ite DELAYEDMCWRITE_S1_INIT false true) (ite (= XFERCNT_S1_INIT 25) (ite (ite DRVMCDBDATA_S1_INIT false true) (ite ?v_38 (ite (ite MCDBDATAVALID_S1_INIT false true) (ite (ite MCDBDATAVALID_S2_INIT false true) (ite ?v_90 (ite ?v_43 (ite BWASLOAD_S1W_INIT false true) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) true (ite (ite ?v_0 true ?v_1) (ite (ite ?v_2 true (ite ?v_13 true (ite ?v_14 true (ite ?v_15 true (ite ?v_5 true (ite ?v_9 true (ite ?v_6 true ?v_10))))))) (ite (ite ?v_3 true (ite ?v_7 true (ite ?v_8 true ?v_12))) (ite (ite ?v_4 true (ite ?v_49 true ?v_53)) (ite (ite (ite ?v_5 true ?v_6) (ite ?v_3 true ?v_100) true) (ite (ite ?v_16 (ite ?v_3 true ?v_8) true) (ite (ite ?v_2 (ite ?v_11 (ite ?v_3 true (ite ?v_25 true ?v_12)) false) true) (ite (ite ?v_12 (ite ?v_2 true (ite ?v_13 true ?v_14)) true) (ite (ite ?v_8 (ite ?v_15 true (ite ?v_5 true ?v_114)) true) (ite (ite ?v_7 (ite ?v_15 true (ite ?v_5 true (ite ?v_6 true ?v_9))) true) (ite (= DTAG1_ADDR_S2_INIT VALID1_ADDR_S2_INIT) (ite (ite VALID1_CACHEDOUT_S2_INIT VALID1_DATA_INIT ?v_17) (ite (= FLUSHSTATE_S1_INIT FLUSHSTATE_S2_INIT) (ite (ite DIRTY1_CACHEDOUT_S2_INIT DIRTY1_DATA_INIT ?v_18) (ite (= DTAG1_CACHEDOUT_S2_INIT DTAG1_DATA_INIT) (ite (ite VALID1_RW1_S2_INIT DTAG1_RW1_S2_INIT ?v_146) (ite (= SB_DATA_INIT SB_OUT_S2_INIT) (ite (= DCACHE_ADDR_S2_INIT DIRTY1_ADDR_S2_INIT) (ite (ite DEXTREQ_S2_INIT ?v_20 (ite ?v_20 false true)) (ite (ite DCACHESEL_S2M_INIT DIRTY1_SEL1_S2_INIT ?v_21) (ite (ite DTAG1_SEL1_S2_INIT VALID1_SEL1_S2_INIT ?v_22) (ite (= EXTSTATE_S1_INIT EXTSTATE_S2_INIT) (ite (ite DEXTREAD_S2_INIT ?v_23 (ite ?v_23 false true)) (ite (= DCACHE_DATA_INIT DCACHE_OUT_S2_INIT) (ite (ite DIRTY1_IN_S2_INIT ?v_24 (ite ?v_24 false true)) (ite (ite SBWRITE_S2_INIT ?v_7 ?v_25) (ite (ite VALID1_IN_S2_INIT ?v_26 (ite ?v_26 false true)) (ite (ite DIRTY1_RW1_S2_INIT ?v_27 (ite ?v_27 false true)) (ite (ite DCACHEDATAVALID_S2_INIT ?v_30 (ite ?v_30 false true)) (ite (ite SB_SEL_S2_INIT ?v_32 (ite ?v_32 false true)) (ite (ite VALID1_SEL1_S2_INIT ?v_33 (ite ?v_33 false true)) (ite (ite DTAG1_RW1_S2_INIT ?v_35 (ite ?v_35 false true)) (ite (ite (ite (ite (ite ?v_58 VALID1_RW1_S2_INIT false) true ?v_37) DTAGREAD_S2M_INIT ?v_36) true (ite ?v_39 DTAGREAD_S2M_INIT ?v_36)) (ite (ite (ite (ite (ite (ite (ite ?v_38 false true) VALID1_RW1_S2_INIT false) true ?v_37) false true) ?v_36 ?v_40) true (ite (ite ?v_39 false true) ?v_36 ?v_40)) (ite (ite MCREAD_S2_INIT MCREAD_S1_INIT ?v_41) (ite (ite DELAYEDMCWRITE_S1_INIT DELAYEDMCWRITE_S2_INIT ?v_42) (ite (= XFERCNT_S1_INIT XFERCNT_S2_INIT) (ite (= DELAYEDMCADDR_S1_INIT DELAYEDMCADDR_S2_INIT) (ite (= SB_IN_S1_INIT SB_IN_S2_INIT) (ite (= SBOUT_S1_INIT SBOUT_S2_INIT) (ite (ite RESTARTED_S1_INIT RESTARTED_S2_INIT ?v_11) (ite (= CONFSTATE_S1_INIT CONFSTATE_S2_INIT) (ite (ite SB_RW_S2_INIT ?v_43 (ite ?v_43 false true)) (ite (ite DRVMCDBDATA_S2_INIT ?v_44 (ite ?v_44 false true)) (ite (ite MCBUSY_S2_INIT ?v_45 (ite ?v_45 false true)) (ite (ite CCMEMREQ_S1_INIT MCREQ_S2_INIT ?v_46) (ite (= MISSADDR_S1W_INIT SBDELAYADDR_S2_INIT) (ite (ite MCDBDATAVALID_S2_INIT ?v_47 (ite ?v_47 false true)) (ite (ite REQWAITING_S2_INIT ?v_48 (ite ?v_48 false true)) (ite (= (ite SBWRITE_S1_INIT SBDELAYADDR_S1_INIT NO_VALUE) SB_ADDR_S2_INIT) (ite (= (ite (ite ?v_143 true ?v_29) (ite ?v_29 DTAGDATA1_S1_INIT MISSADDR_S1W_INIT) NO_VALUE) MCADDR_S2_INIT) (ite (ite (ite (ite ?v_63 true ?v_50) ?v_51 ?v_52) true (ite ?v_50 ?v_51 ?v_52)) (ite (ite (ite (ite ?v_55 true ?v_75) DIRTY1_SEL1_S2_INIT ?v_21) true (ite (ite (ite (ite ?v_84 ?v_2 false) true ?v_55) true ?v_76) DIRTY1_SEL1_S2_INIT ?v_21)) (ite (ite (ite (ite (ite (ite ?v_60 ?v_11 false) false true) false BWASLOAD_S1W_INIT) INSTRISLOAD_S2M_INIT ?v_0) true (ite (ite ?v_91 INSTRISLOAD_S2M_INIT ?v_0) true (ite (ite (ite ?v_60 false true) true BWASLOAD_S1W_INIT) INSTRISLOAD_S2M_INIT ?v_0))) (ite (ite (ite ?v_61 ?v_62 false) true (ite ?v_61 ?v_62 true)) (ite (ite ?v_65 true (ite (ite ?v_64 false ?v_65) true (ite (ite ?v_64 true ?v_65) true (ite (ite ?v_64 false ?v_69) true (ite ?v_64 true ?v_69))))) (ite (ite (ite ?v_70 ?v_71 ?v_72) true (ite (ite ?v_73 false ?v_74) true (ite ?v_73 true ?v_74))) (ite (ite ?v_2 true (ite ?v_10 true (ite ?v_6 true (ite ?v_9 true (ite (ite MCREQ_S2_INIT ?v_5 ?v_15) true (ite ?v_15 true (ite ?v_14 true (ite (ite DCACHEMISS_S1W_INIT ?v_13 ?v_2) true (ite DCACHEMISS_S1W_INIT ?v_14 ?v_2))))))))) (ite (ite (ite (ite ?v_75 false true) DCACHERW_S2M_INIT ?v_77) true (ite (ite ?v_76 false true) DCACHERW_S2M_INIT ?v_77)) (ite (ite ?v_4 true (ite ?v_53 true (ite (ite ?v_78 BWASLOAD_S1W_INIT false) ?v_49 ?v_4))) (ite (ite DRVMCDBDATA_S1_INIT DCACHEDATAVALID_S1_INIT true) (ite (ite (ite SBWRITE_S1_INIT ?v_7 (ite DRVMCDBDATA_S1_INIT ?v_28 ?v_3)) true (ite (ite SBWRITE_S1_INIT ?v_8 ?v_3) true (ite (ite SBWRITE_S1_INIT ?v_7 ?v_79) true (ite (ite SBWRITE_S1_INIT ?v_8 ?v_79) true (ite (ite SBWRITE_S1_INIT ?v_7 ?v_80) true (ite (ite SBWRITE_S1_INIT ?v_8 ?v_80) true (ite (ite SBWRITE_S1_INIT ?v_7 ?v_8) true (ite ?v_8 true (ite (ite SBWRITE_S1_INIT ?v_7 ?v_19) true (ite (ite SBWRITE_S1_INIT ?v_8 ?v_19) true (ite ?v_3 true ?v_7))))))))))) (ite ?v_118 (ite (ite (ite (ite (ite ?v_85 true ?v_95) false true) ?v_21 ?v_88) true (ite (ite (ite (ite (ite ?v_84 ?v_59 false) true ?v_85) true ?v_96) false true) ?v_21 ?v_88)) (ite (ite (ite (ite (ite (ite (ite ?v_89 ?v_90 false) false true) false BWASLOAD_S1W_INIT) false true) (ite (ite ?v_91 false true) (ite (ite ?v_92 true BWASLOAD_S1W_INIT) false true) false) false) ?v_0 true) (ite (ite (ite (ite MCREQ_S2_INIT MCREQ_S2_INIT false) false true) ?v_93 true) (ite (ite (ite (ite (ite ?v_92 INSTRISSTORE_S1W_INIT false) false true) (ite (ite (ite ?v_89 ?v_11 false) false true) (ite ?v_92 (ite (ite ?v_92 INSTRISSTORE_S1W_INIT true) false true) false) false) false) ?v_94 true) (ite (ite (ite ?v_95 ?v_96 false) ?v_77 true) (ite (ite ?v_90 true (ite (ite RESTARTED_S1_INIT ?v_97 (ite ?v_97 false true)) true (ite (ite RESTARTED_S1_INIT ?v_98 (ite ?v_98 false true)) true (ite RESTARTED_S1_INIT ?v_99 (ite ?v_99 false true))))) (ite (ite MCREQ_S2_INIT (ite ?v_29 true ?v_5) true) (ite (ite MCREAD_S2_INIT ?v_5 (ite ?v_5 false true)) (ite (ite ?v_155 ?v_100 true) (ite (ite (ite ?v_115 (ite ?v_2 (ite ?v_4 ?v_78 false) false) false) ?v_109 true) (ite (ite (ite RESTARTED_S1_INIT ?v_102 (ite ?v_102 false true)) true (ite RESTARTED_S1_INIT ?v_104 (ite ?v_104 false true))) (ite (ite ?v_117 INSTRISSTORE_S2W_INIT true) (ite (ite (ite INSTRISLOAD_S2M_INIT (ite INSTRISSTORE_S1W_INIT (ite ?v_2 ?v_107 false) false) false) (ite CONFSTALL_S2M_INIT true ?v_49) true) (ite (ite (ite INSTRISLOAD_S2M_INIT ?v_116 false) ?v_81 true) (ite (ite ?v_105 (ite ?v_6 true (ite ?v_7 true ?v_106)) true) (ite (ite (ite ?v_105 ?v_25 false) DCACHEDATAVALID_S1_INIT true) (ite (ite ?v_108 (ite INSTRISSTORE_S1W_INIT ?v_107 false) true) (ite (ite ?v_110 ?v_112 true) (ite (ite (ite INSTRISSTORE_S2M_INIT ?v_16 false) ?v_113 true) (ite (ite ?v_108 ?v_11 true) (ite (ite (ite ?v_6 (ite ?v_25 INSTRISSTORE_S2M_INIT false) false) ?v_109 true) (ite (ite ?v_110 VALID1_DATA_INIT true) (ite (ite (ite ?v_2 INSTRISSTORE_S2M_INIT false) ?v_78 true) (ite (ite (ite INSTRISLOAD_S2M_INIT ?v_111 false) ?v_112 true) (ite (ite (ite INSTRISLOAD_S2M_INIT ?v_16 false) ?v_113 true) (ite (ite (ite ?v_14 true (ite ?v_15 true (ite ?v_5 true (ite ?v_13 true ?v_7)))) ?v_11 true) (ite (ite (ite ?v_6 (ite ?v_25 INSTRISLOAD_S2M_INIT false) false) ?v_109 true) (ite (ite (ite INSTRISLOAD_S2M_INIT ?v_114 false) (= MISSADDR_S1W_INIT STOREADDR_S2M_INIT) true) (ite (ite ?v_16 VALID1_DATA_INIT true) (ite (ite (ite ?v_115 ?v_2 false) DTAGREAD_S2M_INIT true) (ite (ite ?v_116 ?v_4 true) (ite (ite (ite ?v_49 ?v_2 false) (ite ?v_112 VALID1_DATA_INIT false) true) (ite (ite (ite ?v_2 (ite CONFSTALL_S2M_INIT ?v_117 false) false) (ite ?v_109 (ite VALID1_DATA_INIT ?v_107 false) false) true) (ite ?v_118 (ite (ite (ite ?v_2 ?v_117 false) ?v_109 true) (ite (ite ?v_58 ?v_107 true) (ite (ite ?v_63 (= DTAG1_DATA_INIT STOREADDR_S1W_INIT) true) (ite ?v_101 true (ite ?v_125 true ?v_119)) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false) false)) (= (ite (ite (ite ?v_128 ?v_123 INSTRISLOAD_S2M_INIT) ?v_189 false) (select (ite (ite (ite ?v_128 ?v_129 INSTRISSTORE_S2M_INIT) ?v_176 false) (store ?v_167 ?v_168 (ite ?v_128 STOREDATA_S1M_INIT STOREDATA_S2M_INIT)) ?v_167) ?v_168) ?v_191) (ite ?v_172 (ite ?v_172 (select (ite (ite (ite DOSOMETHING_INIT ?v_173 false) ?v_128 false) (store ?v_187 MEMADDR_S1M_INIT STOREDATA_S1M_INIT) ?v_187) (ite (ite ?v_188 ?v_128 false) MEMADDR_S1M_INIT NO_VALUE)) NO_VALUE) (ite (ite (ite ?v_185 false INSTRISLOAD_S2M_INIT) ?v_189 false) (select ?v_187 ?v_190) ?v_191))) true)))))))))))))))))))))))))))))))))))))))))))))))))))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_ALIA/smt-lib_example.smt2.expected.err000066400000000000000000000000001445011647600247370ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_ALIA/smt-lib_example.smt2.expected.out000066400000000000000000000000061445011647600247640ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_AX/000077500000000000000000000000001445011647600162735ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/arrays_extensionality_no_selects.smt2000066400000000000000000000003141445011647600257560ustar00rootroot00000000000000(set-logic QF_AX) (set-info :status sat) (set-info :smt-lib-version 2.6) (declare-sort I 0) (declare-sort E 0) (declare-fun S () (Array I E)) (declare-fun SS () (Array I E)) (assert (= S SS)) (check-sat) opensmt-2.5.2/regression/QF_AX/arrays_extensionality_no_selects.smt2.expected.err000066400000000000000000000000001445011647600303350ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/arrays_extensionality_no_selects.smt2.expected.out000066400000000000000000000000041445011647600303600ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_AX/arrays_extensionality_no_selects_unsat.smt2000066400000000000000000000004341445011647600271730ustar00rootroot00000000000000(set-logic QF_AX) (set-info :status unsat) (set-info :smt-lib-version 2.6) (declare-sort I 0) (declare-sort E 0) (declare-fun S () (Array I E)) (declare-fun SS () (Array I E)) (declare-fun SSS () (Array I E)) (assert (= S SS)) (assert (= SS SSS)) (assert (not (= S SSS))) (check-sat) opensmt-2.5.2/regression/QF_AX/arrays_extensionality_no_selects_unsat.smt2.expected.err000066400000000000000000000000001445011647600315470ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/arrays_extensionality_no_selects_unsat.smt2.expected.out000066400000000000000000000000061445011647600315740ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_AX/arrays_extensionality_simple.smt2000066400000000000000000000010751445011647600251160ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_AX) (set-info :source | Benchmarks used in the followin paper: Big proof engines as little proof engines: new results on rewrite-based satisfiability procedure Alessandro Armando, Maria Paola Bonacina, Silvio Ranise, Stephan Schulz. PDPAR'05 http://www.ai.dist.unige.it/pdpar05/ |) (set-info :category "crafted") (set-info :status unsat) (declare-sort Index 0) (declare-sort Element 0) (declare-fun a1 () (Array Index Element)) (declare-fun i0 () Index) (assert (not (= a1 (store a1 i0 (select a1 i0))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_AX/arrays_extensionality_simple.smt2.expected.err000066400000000000000000000000001445011647600274700ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/arrays_extensionality_simple.smt2.expected.out000066400000000000000000000000061445011647600275150ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_AX/arrays_extensionality_simple_2.smt2000066400000000000000000000004361445011647600253370ustar00rootroot00000000000000(set-logic QF_AX) (set-info :status unsat) (declare-sort I 0) (declare-sort E 0) (declare-fun a () (Array I E)) (declare-fun i () I) (declare-fun i1 () I) (assert (not (= (store (store a i (select a i1)) i1 (select a i)) (store (store a i1 (select a i)) i (select a i1))))) (check-sat) opensmt-2.5.2/regression/QF_AX/arrays_extensionality_simple_2.smt2.expected.err000066400000000000000000000000001445011647600277110ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/arrays_extensionality_simple_2.smt2.expected.out000066400000000000000000000000061445011647600277360ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_AX/arrays_extensionality_simple_3.smt2000066400000000000000000000003071445011647600253350ustar00rootroot00000000000000(set-logic QF_AX) (set-info :status sat) (declare-sort I 0) (declare-sort E 0) (declare-fun a () (Array I E)) (declare-fun e () E) (declare-fun i () I) (assert (not (= a (store a i e)))) (check-sat) opensmt-2.5.2/regression/QF_AX/arrays_extensionality_simple_3.smt2.expected.err000066400000000000000000000000001445011647600277120ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/arrays_extensionality_simple_3.smt2.expected.out000066400000000000000000000000041445011647600277350ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_AX/arrays_extensionality_simple_4.smt2000066400000000000000000000004771445011647600253460ustar00rootroot00000000000000(set-logic QF_AX) (set-info :status sat) (declare-sort I 0) (declare-sort E 0) (declare-fun a () (Array I E)) (declare-fun e1 () E) (declare-fun e2 () E) (declare-fun e () E) (declare-fun i1 () I) (declare-fun i () I) (assert (not (= (store (store a i e) i1 e1) (store (store (store a i1 e1) i e) i1 e2)))) (check-sat) opensmt-2.5.2/regression/QF_AX/arrays_extensionality_simple_4.smt2.expected.err000066400000000000000000000000001445011647600277130ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/arrays_extensionality_simple_4.smt2.expected.out000066400000000000000000000000041445011647600277360ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_AX/arrays_extensionality_simple_5.smt2000066400000000000000000000006041445011647600253370ustar00rootroot00000000000000(set-logic QF_AX) (set-info :status unsat) (declare-sort I 0) (declare-sort E 0) (declare-fun a () (Array I E)) (declare-fun a2 () (Array I E)) (declare-fun i () I) (declare-fun i2 () I) (assert (= (store (store a i (select a2 i)) i2 (select (store a2 i (select a i2)) i2)) (store (store a2 i (select a i)) i2 (select (store a i (select a2 i2)) i2)))) (assert (not (= a a2))) (check-sat) opensmt-2.5.2/regression/QF_AX/arrays_extensionality_simple_5.smt2.expected.err000066400000000000000000000000001445011647600277140ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/arrays_extensionality_simple_5.smt2.expected.out000066400000000000000000000000061445011647600277410ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_AX/conflict_detection_1.smt2000066400000000000000000000005771445011647600231720ustar00rootroot00000000000000(set-logic QF_AX) (set-info :status sat) (declare-sort I 0) (declare-sort E 0) (declare-fun a () (Array I E)) (declare-fun a2 () (Array I E)) (declare-fun i1 () I) (declare-fun i3 () I) (declare-fun i4 () I) (declare-fun i () I) (assert (= a (store (store a2 i (select a i4)) i (select (store a2 i1 (select (store a2 i3 (select a2 i4)) i4)) i)))) (assert (not (= a a2))) (check-sat) opensmt-2.5.2/regression/QF_AX/conflict_detection_1.smt2.expected.err000066400000000000000000000000001445011647600255360ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/conflict_detection_1.smt2.expected.out000066400000000000000000000000041445011647600255610ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_AX/conflict_detection_2.smt2000066400000000000000000000005761445011647600231720ustar00rootroot00000000000000(set-logic QF_AX) (set-info :status sat) (declare-sort I 0) (declare-sort E 0) (declare-fun a () (Array I E)) (declare-fun a2 () (Array I E)) (declare-fun i2 () I) (declare-fun i3 () I) (declare-fun i4 () I) (declare-fun i () I) (assert (= a (store (store (store (store a2 i4 (select a i2)) i2 (select a i4)) i3 (select a i)) i (select a2 i4)))) (assert (not (= a a2))) (check-sat) opensmt-2.5.2/regression/QF_AX/conflict_detection_2.smt2.expected.err000066400000000000000000000000001445011647600255370ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/conflict_detection_2.smt2.expected.out000066400000000000000000000000041445011647600255620ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_AX/contradicts_axiom.smt2000066400000000000000000000005241445011647600226150ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_AX) (set-info :status unsat) (declare-sort Index 0) (declare-sort Element 0) (declare-fun a () (Array Index Element)) (declare-fun i () Index) (declare-fun j () Index) (declare-fun e () Element) (assert (not (= i j))) (assert (not (= (select a j) (select (store a i e) j)))) (check-sat) (exit) opensmt-2.5.2/regression/QF_AX/contradicts_axiom.smt2.expected.err000066400000000000000000000000001445011647600251710ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/contradicts_axiom.smt2.expected.out000066400000000000000000000000061445011647600252160ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_AX/explanation_not_cleared_bug.smt2000066400000000000000000000053551445011647600246300ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_AX) (set-info :source | Benchmarks used in the followin paper: Big proof engines as little proof engines: new results on rewrite-based satisfiability procedure Alessandro Armando, Maria Paola Bonacina, Silvio Ranise, Stephan Schulz. PDPAR'05 http://www.ai.dist.unige.it/pdpar05/ |) (set-info :category "crafted") (set-info :status unsat) (declare-sort Index 0) (declare-sort Element 0) (declare-fun a_1 () (Array Index Element)) (declare-fun a_11 () (Array Index Element)) (declare-fun a_13 () (Array Index Element)) (declare-fun a_15 () (Array Index Element)) (declare-fun a_17 () (Array Index Element)) (declare-fun a_19 () (Array Index Element)) (declare-fun a_21 () (Array Index Element)) (declare-fun a_23 () (Array Index Element)) (declare-fun a_25 () (Array Index Element)) (declare-fun a_27 () (Array Index Element)) (declare-fun a_3 () (Array Index Element)) (declare-fun a_5 () (Array Index Element)) (declare-fun a_7 () (Array Index Element)) (declare-fun a_9 () (Array Index Element)) (declare-fun e_0 () Element) (declare-fun e_10 () Element) (declare-fun e_12 () Element) (declare-fun e_14 () Element) (declare-fun e_16 () Element) (declare-fun e_18 () Element) (declare-fun e_2 () Element) (declare-fun e_20 () Element) (declare-fun e_22 () Element) (declare-fun e_24 () Element) (declare-fun e_26 () Element) (declare-fun e_4 () Element) (declare-fun e_6 () Element) (declare-fun e_8 () Element) (declare-fun a1 () (Array Index Element)) (declare-fun a2 () (Array Index Element)) (declare-fun i1 () Index) (declare-fun i2 () Index) (declare-fun i3 () Index) (declare-fun i4 () Index) (declare-fun i5 () Index) (declare-fun i6 () Index) (declare-fun i7 () Index) (assert (= a_1 (store a1 i1 e_0))) (assert (= a_11 (store a_7 i3 e_10))) (assert (= a_13 (store a_9 i4 e_12))) (assert (= a_15 (store a_11 i4 e_14))) (assert (= a_17 (store a_13 i5 e_16))) (assert (= a_19 (store a_15 i5 e_18))) (assert (= a_21 (store a_17 i6 e_20))) (assert (= a_23 (store a_19 i6 e_22))) (assert (= a_25 (store a_21 i7 e_24))) (assert (= a_27 (store a_23 i7 e_26))) (assert (= a_3 (store a2 i1 e_2))) (assert (= a_5 (store a_1 i2 e_4))) (assert (= a_7 (store a_3 i2 e_6))) (assert (= a_9 (store a_5 i3 e_8))) (assert (= e_0 (select a2 i1))) (assert (= e_10 (select a_5 i3))) (assert (= e_12 (select a_11 i4))) (assert (= e_14 (select a_9 i4))) (assert (= e_16 (select a_15 i5))) (assert (= e_18 (select a_13 i5))) (assert (= e_2 (select a1 i1))) (assert (= e_20 (select a_19 i6))) (assert (= e_22 (select a_17 i6))) (assert (= e_24 (select a_23 i7))) (assert (= e_26 (select a_21 i7))) (assert (= e_4 (select a_3 i2))) (assert (= e_6 (select a_1 i2))) (assert (= e_8 (select a_7 i3))) (assert (= a_25 a_27)) (assert (not (= a1 a2))) (check-sat) (exit) opensmt-2.5.2/regression/QF_AX/explanation_not_cleared_bug.smt2.expected.err000066400000000000000000000000001445011647600271750ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/explanation_not_cleared_bug.smt2.expected.out000066400000000000000000000000061445011647600272220ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_AX/extensionality_bug.smt2000066400000000000000000000006631445011647600230230ustar00rootroot00000000000000(set-logic QF_AX) (set-info :status sat) (declare-sort I 0) (declare-sort E 0) (declare-fun a () (Array I E)) (declare-fun b () (Array I E)) (declare-fun c () (Array I E)) (declare-fun el () E) (declare-fun i () I) (declare-fun j () I) (assert (= (store a i el) (store c i el))) (assert (= c a)) (assert (= (select a j) (select b j))) (assert (= el (select (store a i el) j))) (assert (not (= a (store a j (select a i))))) (check-sat) opensmt-2.5.2/regression/QF_AX/extensionality_bug.smt2.expected.err000066400000000000000000000000001445011647600253730ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/extensionality_bug.smt2.expected.out000066400000000000000000000000041445011647600254160ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_AX/read_over_weak_eq_lemma.smt2000066400000000000000000000007011445011647600237150ustar00rootroot00000000000000(set-logic QF_AX) (set-info :status sat) (declare-sort I 0) (declare-sort E 0) (declare-fun a () (Array I E)) (declare-fun b () (Array I E)) (declare-fun i () I) (declare-fun j () I) (declare-fun v () E) (declare-fun w () E) (declare-fun u () E) (declare-fun x () Bool) (assert (not (= i j))) (assert (= (select a i) v)) (assert (= (select b i) u)) (assert (= (store a j w) b)) (assert (or (not x) (not (= (select a i) (select b i))))) (check-sat) opensmt-2.5.2/regression/QF_AX/read_over_weak_eq_lemma.smt2.expected.err000066400000000000000000000000001445011647600262740ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/read_over_weak_eq_lemma.smt2.expected.out000066400000000000000000000000041445011647600263170ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_AX/read_over_weak_eq_lemma_2.smt2000066400000000000000000000006071445011647600241430ustar00rootroot00000000000000(set-logic QF_AX) (set-info :status unsat) (declare-sort I 0) (declare-sort E 0) (declare-fun a () (Array I E)) (declare-fun v () E) (declare-fun i1 () I) (declare-fun i2 () I) (declare-fun i3 () I) (declare-fun x () Bool) (assert (=> x (= i2 i3))) (assert (=> (not x) (= i2 i3))) (assert (not (= i1 i2))) (assert (not (= (select a i1) (select (store (store a i2 v) i3 v) i1)))) (check-sat) opensmt-2.5.2/regression/QF_AX/read_over_weak_eq_lemma_2.smt2.expected.err000066400000000000000000000000001445011647600265150ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/read_over_weak_eq_lemma_2.smt2.expected.out000066400000000000000000000000061445011647600265420ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_AX/read_over_weak_eq_lemma_3.smt2000066400000000000000000000007071445011647600241450ustar00rootroot00000000000000(set-logic QF_AX) (set-info :status sat) (declare-sort I 0) (declare-sort E 0) (declare-fun a () (Array I E)) (declare-fun b () (Array I E)) (declare-fun c () (Array I E)) (declare-fun j () I) (declare-fun k () I) (declare-fun i () I) (declare-fun v () E) (declare-fun x () Bool) (assert (= b (store a i v))) (assert (distinct k i)) (assert (distinct (select a j) (select b j))) (assert (=> x (= j k))) (assert (= (select c k) (select b k))) (check-sat) opensmt-2.5.2/regression/QF_AX/read_over_weak_eq_lemma_3.smt2.expected.err000066400000000000000000000000001445011647600265160ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/read_over_weak_eq_lemma_3.smt2.expected.out000066400000000000000000000000041445011647600265410ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_AX/simple_sat.smt2000066400000000000000000000005611445011647600212440ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_AX) (set-info :status sat) (declare-sort Index 0) (declare-sort Element 0) (declare-fun a () (Array Index Element)) (declare-fun i () Index) (declare-fun j () Index) (declare-fun e () Element) (declare-fun b () Bool) (assert (not (= i j))) (assert (or b (not (= (select a j) (select (store a i e) j))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_AX/simple_sat.smt2.expected.err000066400000000000000000000000001445011647600236170ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/simple_sat.smt2.expected.out000066400000000000000000000000041445011647600236420ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_AX/split_clauses_same_propagated_literal.smt2000066400000000000000000000030531445011647600267040ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_AX) (set-info :source | Benchmarks used in the followin paper: Big proof engines as little proof engines: new results on rewrite-based satisfiability procedure Alessandro Armando, Maria Paola Bonacina, Silvio Ranise, Stephan Schulz. PDPAR'05 http://www.ai.dist.unige.it/pdpar05/ |) (set-info :category "crafted") (set-info :status sat) (declare-sort Index 0) (declare-sort Element 0) (declare-fun a1 () (Array Index Element)) (declare-fun i1 () Index) (declare-fun i2 () Index) (declare-fun i3 () Index) (declare-fun i4 () Index) (declare-fun i5 () Index) (declare-fun i6 () Index) (declare-fun i7 () Index) (assert (let ((?v_0 (store (store a1 i4 (select a1 i3)) i3 (select a1 i4)))) (let ((?v_1 (store (store ?v_0 i6 (select ?v_0 i7)) i7 (select ?v_0 i6)))) (let ((?v_2 (store (store ?v_1 i2 (select ?v_1 i4)) i4 (select ?v_1 i2)))) (let ((?v_3 (store (store ?v_2 i2 (select ?v_2 i3)) i3 (select ?v_2 i2)))) (let ((?v_7 (select ?v_3 i2)) (?v_8 (select ?v_3 i5))) (let ((?v_4 (store (store ?v_3 i2 ?v_8) i5 ?v_7))) (let ((?v_5 (store (store ?v_4 i5 (select ?v_4 i1)) i1 (select ?v_4 i5)))) (let ((?v_6 (store (store ?v_5 i3 (select ?v_5 i7)) i7 (select ?v_5 i3))) (?v_9 (store (store ?v_3 i5 ?v_7) i2 ?v_8))) (let ((?v_10 (store (store ?v_9 i1 (select ?v_9 i5)) i5 (select ?v_9 i1)))) (let ((?v_11 (store (store ?v_10 i3 (select ?v_10 i7)) i7 (select ?v_10 i3)))) (not (= (store (store ?v_6 i5 (select ?v_6 i1)) i1 (select ?v_6 i5)) (store (store ?v_11 i6 (select ?v_11 i1)) i1 (select ?v_11 i6))))))))))))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_AX/split_clauses_same_propagated_literal.smt2.expected.err000066400000000000000000000000001445011647600312600ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/split_clauses_same_propagated_literal.smt2.expected.out000066400000000000000000000000041445011647600313030ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_AX/swap_trivial_unsat.smt2000066400000000000000000000006551445011647600230260ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_AX) (set-info :status unsat) (declare-sort Index 0) (declare-sort Element 0) (declare-fun a1 () (Array Index Element)) (declare-fun i0 () Index) (declare-fun i1 () Index) (assert (let ((?v_0 (select a1 i1))) (let ((?v_1 (store (store a1 i1 ?v_0) i1 ?v_0))) (let ((?v_2 (select ?v_1 i0))) (let ((?v_3 (store (store ?v_1 i0 ?v_2) i0 ?v_2))) (not (= ?v_3 ?v_3))))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_AX/swap_trivial_unsat.smt2.expected.err000066400000000000000000000000001445011647600253750ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/swap_trivial_unsat.smt2.expected.out000066400000000000000000000000061445011647600254220ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_AX/trivially_unsat.smt2000066400000000000000000000004411445011647600223320ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_AX) (set-info :status unsat) (declare-sort Index 0) (declare-sort Element 0) (declare-fun a1 () (Array Index Element)) (declare-fun i0 () Index) (declare-fun e0 () Element) (assert (not (= (select (store a1 i0 e0) i0) e0))) (check-sat) (exit) opensmt-2.5.2/regression/QF_AX/trivially_unsat.smt2.expected.err000066400000000000000000000000001445011647600247100ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/trivially_unsat.smt2.expected.out000066400000000000000000000000061445011647600247350ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_AX/unsat_with_decisions.smt2000066400000000000000000000006711445011647600233330ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_AX) (set-info :status unsat) (declare-sort Index 0) (declare-sort Element 0) (declare-fun a () (Array Index Element)) (declare-fun i () Index) (declare-fun j () Index) (declare-fun e () Element) (declare-fun b () Bool) (assert (not (= i j))) (assert (or b (not (= (select a j) (select (store a i e) j))))) (assert (or (not b) (not (= (select a j) (select (store a i e) j))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_AX/unsat_with_decisions.smt2.expected.err000066400000000000000000000000001445011647600257040ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/unsat_with_decisions.smt2.expected.out000066400000000000000000000000061445011647600257310ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_AX/unsatisfied_clause_bug.smt2000066400000000000000000000010531445011647600236100ustar00rootroot00000000000000(set-logic QF_AX) (set-info :status sat) (declare-sort I 0) (declare-sort E 0) (declare-fun a1 () (Array I E)) (declare-fun a2 () (Array I E)) (declare-fun a3 () (Array I E)) (declare-fun v1 () E) (declare-fun v2 () E) (declare-fun v3 () E) (declare-fun i1 () I) (declare-fun i2 () I) (declare-fun i3 () I) (declare-fun i4 () I) (assert (= (store (store a2 i4 v1) i4 v3) (store a3 i3 v3))) (assert (= (select a2 i3) (select a3 i2))) (assert (= (store a1 i4 (select a3 i1)) (store a2 i2 v2))) (assert (not (= a3 (store a2 i2 (select a3 i3))))) (check-sat) opensmt-2.5.2/regression/QF_AX/unsatisfied_clause_bug.smt2.expected.err000066400000000000000000000000001445011647600261660ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_AX/unsatisfied_clause_bug.smt2.expected.out000066400000000000000000000000041445011647600262110ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_BV/000077500000000000000000000000001445011647600162725ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_BV/bar.smt2000066400000000000000000000003101445011647600176370ustar00rootroot00000000000000(set-logic QF_BV) (declare-fun v0 () (_ BitVec 4)) (declare-fun v1 () (_ BitVec 4)) (assert (or (= (_ extract 1 1 v0) (_ extract 1 1 v1)) (not (= (_ extract 1 1 v0) (_ extract 1 1 v1))))) (check-sat) opensmt-2.5.2/regression/QF_BV/bar.smt2.expected.err000066400000000000000000000000001445011647600222220ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_BV/bar.smt2.expected.out000066400000000000000000000001041445011647600222460ustar00rootroot00000000000000At line 4: syntax error, unexpected TK_SYM, expecting TK_NUM or ')' opensmt-2.5.2/regression/QF_BV/bar.smt2.expected.time000066400000000000000000000000351445011647600224000ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_BV/bvnor.smt2000066400000000000000000000005131445011647600202260ustar00rootroot00000000000000(set-logic QF_BV) (set-info :source | Constructed by Trevor Hansen to test bvnor nesting. |) (set-info :smt-lib-version 2.0) (set-info :category "check") (set-info :status unsat) (declare-fun v0 () (_ BitVec 1)) (assert (= (_ bv0 1) ((_ extract 1 1) (bvnor (_ bv0 2) (bvnor (_ bv2 2) (concat (_ bv0 1) v0)))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_BV/bvnor.smt2.expected.err000066400000000000000000000000001445011647600226040ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_BV/bvnor.smt2.expected.out000066400000000000000000000003031445011647600226310ustar00rootroot00000000000000(error "unknown logic QF_BV") (error "Illegal command before set-logic: declare-fun") (error "Illegal command before set-logic: assert") (error "Illegal command before set-logic: check-sat") opensmt-2.5.2/regression/QF_BV/bvnor.smt2.expected.time000066400000000000000000000000351445011647600227620ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_BV/edit.smt2000066400000000000000000000004451445011647600200310ustar00rootroot00000000000000; This example is completed with comments. (set-logic QF_BV) (set-info :source | Constructed by Trevor Hansen to test bvnor nesting. |) (set-info :smt-lib-version 2.0) (set-info :category "check") (set-info :status unsat) (declare-fun v0 () (_ BitVec 1)) (assert (not (= v0 v0))) (check-sat) opensmt-2.5.2/regression/QF_BV/edit.smt2.expected.err000066400000000000000000000000001445011647600224030ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_BV/edit.smt2.expected.out000066400000000000000000000003031445011647600224300ustar00rootroot00000000000000(error "unknown logic QF_BV") (error "Illegal command before set-logic: declare-fun") (error "Illegal command before set-logic: assert") (error "Illegal command before set-logic: check-sat") opensmt-2.5.2/regression/QF_BV/edit.smt2.expected.time000066400000000000000000000000351445011647600225610ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_BV/setlogic.smt2000066400000000000000000000000221445011647600207040ustar00rootroot00000000000000(set-logic QF_BV) opensmt-2.5.2/regression/QF_BV/setlogic.smt2.expected.err000066400000000000000000000000001445011647600232670ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_BV/setlogic.smt2.expected.out000066400000000000000000000000371445011647600233200ustar00rootroot00000000000000(error "unknown logic QF_BV") opensmt-2.5.2/regression/QF_BV/setlogic.smt2.expected.time000066400000000000000000000000351445011647600234450ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_IDL/000077500000000000000000000000001445011647600163735ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_IDL/basic_sat.smt2000066400000000000000000000002031445011647600211250ustar00rootroot00000000000000(set-logic QF_IDL) (declare-fun a () Int) (declare-fun b () Int) (set-info :status sat) (assert (> (- a b) 10)) (check-sat) (exit) opensmt-2.5.2/regression/QF_IDL/basic_sat.smt2.expected.err000066400000000000000000000000001445011647600235070ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_IDL/basic_sat.smt2.expected.out000066400000000000000000000000041445011647600235320ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_IDL/basic_unsat.smt2000066400000000000000000000001651445011647600214770ustar00rootroot00000000000000(set-logic QF_IDL) (declare-fun b () Int) (set-info :status unsat) (assert (and (< 0 b) (< b 1))) (check-sat) (exit) opensmt-2.5.2/regression/QF_IDL/basic_unsat.smt2.expected.err000066400000000000000000000000001445011647600240520ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_IDL/basic_unsat.smt2.expected.out000066400000000000000000000000061445011647600240770ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_IDL/incremental.smt2000066400000000000000000000004211445011647600215000ustar00rootroot00000000000000(set-logic QF_IDL) (declare-fun a () Int) (declare-fun b () Int) (declare-fun c () Int) (set-info :status sat) (assert (> (- a b) 10)) (check-sat) (assert (> (- b c) 5)) (set-info :status sat) (check-sat) (assert (> (- c a) 0)) (set-info :status unsat) (check-sat) (exit) opensmt-2.5.2/regression/QF_IDL/incremental.smt2.expected.err000066400000000000000000000000001445011647600240600ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_IDL/incremental.smt2.expected.out000066400000000000000000000000161445011647600241060ustar00rootroot00000000000000sat sat unsat opensmt-2.5.2/regression/QF_LIA/000077500000000000000000000000001445011647600163705ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/can_solve/000077500000000000000000000000001445011647600203415ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/can_solve/ex10100_2600_100.smt2000066400000000000000000002420061445011647600232010ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_LIA) (set-info :source | Benchmarks from Miquel Bofill coming from a wastewater treatment scheduling problem |) (set-info :category "random") (set-info :status unsat) (declare-fun xH1 () Int) (declare-fun xH2 () Int) (declare-fun xH3 () Int) (declare-fun xH4 () Int) (declare-fun xH5 () Int) (declare-fun xH6 () Int) (declare-fun xH7 () Int) (declare-fun xH8 () Int) (declare-fun xH9 () Int) (declare-fun xH10 () Int) (declare-fun xH11 () Int) (declare-fun xH12 () Int) (declare-fun xH13 () Int) (declare-fun xH14 () Int) (declare-fun xH15 () Int) (declare-fun xH16 () Int) (declare-fun xH17 () Int) (declare-fun xH18 () Int) (declare-fun xH19 () Int) (declare-fun xH20 () Int) (declare-fun xH21 () Int) (declare-fun xH22 () Int) (declare-fun xH23 () Int) (declare-fun xH24 () Int) (declare-fun xH25 () Int) (declare-fun xH26 () Int) (declare-fun xH27 () Int) (declare-fun xH28 () Int) (declare-fun xH29 () Int) (declare-fun xH30 () Int) (declare-fun xH31 () Int) (declare-fun xH32 () Int) (declare-fun xH33 () Int) (declare-fun xH34 () Int) (declare-fun xH35 () Int) (declare-fun xH36 () Int) (declare-fun xH37 () Int) (declare-fun xH38 () Int) (declare-fun xH39 () Int) (declare-fun xH40 () Int) (declare-fun xH41 () Int) (declare-fun xH42 () Int) (declare-fun xH43 () Int) (declare-fun xH44 () Int) (declare-fun xH45 () Int) (declare-fun xH46 () Int) (declare-fun xH47 () Int) (declare-fun xH48 () Int) (declare-fun xH49 () Int) (declare-fun xH50 () Int) (declare-fun xH51 () Int) (declare-fun xH52 () Int) (declare-fun xH53 () Int) (declare-fun xH54 () Int) (declare-fun xH55 () Int) (declare-fun xH56 () Int) (declare-fun xH57 () Int) (declare-fun xH58 () Int) (declare-fun xH59 () Int) (declare-fun xH60 () Int) (declare-fun xH61 () Int) (declare-fun xH62 () Int) (declare-fun xH63 () Int) (declare-fun xH64 () Int) (declare-fun xH65 () Int) (declare-fun xH66 () Int) (declare-fun xH67 () Int) (declare-fun xH68 () Int) (declare-fun xH69 () Int) (declare-fun xH70 () Int) (declare-fun xH71 () Int) (declare-fun xH72 () Int) (declare-fun xH73 () Int) (declare-fun xH74 () Int) (declare-fun xH75 () Int) (declare-fun xH76 () Int) (declare-fun xH77 () Int) (declare-fun xH78 () Int) (declare-fun xH79 () Int) (declare-fun xH80 () Int) (declare-fun xH81 () Int) (declare-fun xH82 () Int) (declare-fun xH83 () Int) (declare-fun xH84 () Int) (declare-fun xH85 () Int) (declare-fun xH86 () Int) (declare-fun xH87 () Int) (declare-fun xH88 () Int) (declare-fun xH89 () Int) (declare-fun xH90 () Int) (declare-fun xH91 () Int) (declare-fun xH92 () Int) (declare-fun xH93 () Int) (declare-fun xH94 () Int) (declare-fun xH95 () Int) (declare-fun xH96 () Int) (declare-fun xH97 () Int) (declare-fun xH98 () Int) (declare-fun xH99 () Int) (declare-fun xH100 () Int) (declare-fun xH101 () Int) (declare-fun xH102 () Int) (declare-fun xH103 () Int) (declare-fun xH104 () Int) (declare-fun xH105 () Int) (declare-fun xH106 () Int) (declare-fun xH107 () Int) (declare-fun xH108 () Int) (declare-fun xH109 () Int) (declare-fun xH110 () Int) (declare-fun xH111 () Int) (declare-fun xH112 () Int) (declare-fun xH113 () Int) (declare-fun xH114 () Int) (declare-fun xH115 () Int) (declare-fun xH116 () Int) (declare-fun xH117 () Int) (declare-fun xH118 () Int) (declare-fun xH119 () Int) (declare-fun xH120 () Int) (declare-fun xH121 () Int) (declare-fun xH122 () Int) (declare-fun xH123 () Int) (declare-fun xH124 () Int) (declare-fun xH125 () Int) (declare-fun xH126 () Int) (declare-fun xH127 () Int) (declare-fun xH128 () Int) (declare-fun xH129 () Int) (declare-fun xH130 () Int) (declare-fun xH131 () Int) (declare-fun xH132 () Int) (declare-fun xH133 () Int) (declare-fun xH134 () Int) (declare-fun xH135 () Int) (declare-fun xH136 () Int) (declare-fun xH137 () Int) (declare-fun xH138 () Int) (declare-fun xH139 () Int) (declare-fun xH140 () Int) (declare-fun xH141 () Int) (declare-fun xH142 () Int) (declare-fun xH143 () Int) (declare-fun xH144 () Int) (declare-fun xH145 () Int) (declare-fun xH146 () Int) (declare-fun xH147 () Int) (declare-fun xH148 () Int) (declare-fun xH149 () Int) (declare-fun xH150 () Int) (declare-fun xH151 () Int) (declare-fun xH152 () Int) (declare-fun xH153 () Int) (declare-fun xH154 () Int) (declare-fun xH155 () Int) (declare-fun xH156 () Int) (declare-fun xH157 () Int) (declare-fun xH158 () Int) (declare-fun xH159 () Int) (declare-fun xH160 () Int) (declare-fun xH161 () Int) (declare-fun xH162 () Int) (declare-fun xH163 () Int) (declare-fun xH164 () Int) (declare-fun xH165 () Int) (declare-fun xH166 () Int) (declare-fun xH167 () Int) (declare-fun xH168 () Int) (declare-fun xH169 () Int) (declare-fun xH170 () Int) (declare-fun xH171 () Int) (declare-fun xH172 () Int) (declare-fun xH173 () Int) (declare-fun xH174 () Int) (declare-fun xH175 () Int) (declare-fun xH176 () Int) (declare-fun xH177 () Int) (declare-fun xH178 () Int) (declare-fun xH179 () Int) (declare-fun xH180 () Int) (declare-fun xH181 () Int) (declare-fun xH182 () Int) (declare-fun xH183 () Int) (declare-fun xH184 () Int) (declare-fun xH185 () Int) (declare-fun xH186 () Int) (declare-fun xH187 () Int) (declare-fun xH188 () Int) (declare-fun xH189 () Int) (declare-fun xH190 () Int) (declare-fun xH191 () Int) (declare-fun xH192 () Int) (declare-fun xH193 () Int) (declare-fun xH194 () Int) (declare-fun xH195 () Int) (declare-fun xH196 () Int) (declare-fun xH197 () Int) (declare-fun xH198 () Int) (declare-fun xH199 () Int) (declare-fun xH200 () Int) (declare-fun xH201 () Int) (declare-fun xH202 () Int) (declare-fun xH203 () Int) (declare-fun xH204 () Int) (declare-fun xH205 () Int) (declare-fun xH206 () Int) (declare-fun xH207 () Int) (declare-fun xH208 () Int) (declare-fun xH209 () Int) (declare-fun xH210 () Int) (declare-fun xH211 () Int) (declare-fun xH212 () Int) (declare-fun xH213 () Int) (declare-fun xH214 () Int) (declare-fun xH215 () Int) (declare-fun xH216 () Int) (declare-fun xH217 () Int) (declare-fun xH218 () Int) (declare-fun xH219 () Int) (declare-fun xH220 () Int) (declare-fun xH221 () Int) (declare-fun xH222 () Int) (declare-fun xH223 () Int) (declare-fun xH224 () Int) (declare-fun xH225 () Int) (declare-fun xH226 () Int) (declare-fun xH227 () Int) (declare-fun xH228 () Int) (declare-fun xH229 () Int) (declare-fun xH230 () Int) (declare-fun xH231 () Int) (declare-fun xH232 () Int) (declare-fun xH233 () Int) (declare-fun xH234 () Int) (declare-fun xH235 () Int) (declare-fun xH236 () Int) (declare-fun xH237 () Int) (declare-fun xH238 () Int) (declare-fun xH239 () Int) (declare-fun xH240 () Int) (declare-fun xH241 () Int) (declare-fun xH242 () Int) (declare-fun xH243 () Int) (declare-fun xH244 () Int) (declare-fun xH245 () Int) (declare-fun xH246 () Int) (declare-fun xH247 () Int) (declare-fun xH248 () Int) (declare-fun xH249 () Int) (declare-fun xH250 () Int) (declare-fun xH251 () Int) (declare-fun xH252 () Int) (declare-fun xH253 () Int) (declare-fun xH254 () Int) (declare-fun xH255 () Int) (declare-fun xH256 () Int) (declare-fun xH257 () Int) (declare-fun xH258 () Int) (declare-fun xH259 () Int) (declare-fun xH260 () Int) (declare-fun xH261 () Int) (declare-fun xH262 () Int) (declare-fun xH263 () Int) (declare-fun xH264 () Int) (declare-fun xH265 () Int) (declare-fun xH266 () Int) (declare-fun xH267 () Int) (declare-fun xH268 () Int) (declare-fun xH269 () Int) (declare-fun xH270 () Int) (declare-fun xH271 () Int) (declare-fun xH272 () Int) (declare-fun xH273 () Int) (declare-fun xH274 () Int) (declare-fun xH275 () Int) (declare-fun xH276 () Int) (declare-fun xH277 () Int) (declare-fun xH278 () Int) (declare-fun xH279 () Int) (declare-fun xH280 () Int) (declare-fun xH281 () Int) (declare-fun xH282 () Int) (declare-fun xH283 () Int) (declare-fun xH284 () Int) (declare-fun xH285 () Int) (declare-fun xH286 () Int) (declare-fun xH287 () Int) (declare-fun xH288 () Int) (declare-fun xH289 () Int) (declare-fun xH290 () Int) (declare-fun xH291 () Int) (declare-fun xH292 () Int) (declare-fun xH293 () Int) (declare-fun xH294 () Int) (declare-fun xH295 () Int) (declare-fun xH296 () Int) (declare-fun xH297 () Int) (declare-fun xH298 () Int) (declare-fun xH299 () Int) (declare-fun xH300 () Int) (declare-fun xH301 () Int) (declare-fun xH302 () Int) (declare-fun xH303 () Int) (declare-fun xH304 () Int) (declare-fun xH305 () Int) (declare-fun xH306 () Int) (declare-fun xH307 () Int) (declare-fun xH308 () Int) (declare-fun xH309 () Int) (declare-fun xH310 () Int) (declare-fun xH311 () Int) (declare-fun xH312 () Int) (declare-fun xH313 () Int) (declare-fun xH314 () Int) (declare-fun xH315 () Int) (declare-fun xH316 () Int) (declare-fun xH317 () Int) (declare-fun xH318 () Int) (declare-fun xH319 () Int) (declare-fun xH320 () Int) (declare-fun xH321 () Int) (declare-fun xH322 () Int) (declare-fun xH323 () Int) (declare-fun xH324 () Int) (declare-fun xH325 () Int) (declare-fun xH326 () Int) (declare-fun xH327 () Int) (declare-fun xH328 () Int) (declare-fun xH329 () Int) (declare-fun xH330 () Int) (declare-fun xH331 () Int) (declare-fun xH332 () Int) (declare-fun xH333 () Int) (declare-fun xH334 () Int) (declare-fun xH335 () Int) (declare-fun xH336 () Int) (declare-fun xH337 () Int) (declare-fun xH338 () Int) (declare-fun xH339 () Int) (declare-fun xH340 () Int) (declare-fun xH341 () Int) (declare-fun xH342 () Int) (declare-fun xH343 () Int) (declare-fun xH344 () Int) (declare-fun xH345 () Int) (declare-fun xH346 () Int) (declare-fun xH347 () Int) (declare-fun xH348 () Int) (declare-fun xH349 () Int) (declare-fun xH350 () Int) (declare-fun xH351 () Int) (declare-fun xH352 () Int) (declare-fun xH353 () Int) (declare-fun xH354 () Int) (declare-fun xH355 () Int) (declare-fun xH356 () Int) (declare-fun xH357 () Int) (declare-fun xH358 () Int) (declare-fun xH359 () Int) (declare-fun xH360 () Int) (declare-fun xH361 () Int) (declare-fun xH362 () Int) (declare-fun xH363 () Int) (declare-fun xH364 () Int) (declare-fun xH365 () Int) (declare-fun xH366 () Int) (declare-fun xH367 () Int) (declare-fun xH368 () Int) (declare-fun xH369 () Int) (declare-fun xH370 () Int) (declare-fun xH371 () Int) (declare-fun xH372 () Int) (declare-fun xH373 () Int) (declare-fun xH374 () Int) (declare-fun xH375 () Int) (declare-fun xH376 () Int) (declare-fun xH377 () Int) (declare-fun xH378 () Int) (declare-fun xH379 () Int) (declare-fun xH380 () Int) (declare-fun xH381 () Int) (declare-fun xH382 () Int) (declare-fun xH383 () Int) (declare-fun xH384 () Int) (declare-fun xH385 () Int) (declare-fun xH386 () Int) (declare-fun xH387 () Int) (declare-fun xH388 () Int) (declare-fun xH389 () Int) (declare-fun xH390 () Int) (declare-fun xH391 () Int) (declare-fun xH392 () Int) (declare-fun xH393 () Int) (declare-fun xH394 () Int) (declare-fun xH395 () Int) (declare-fun xH396 () Int) (declare-fun xH397 () Int) (declare-fun xH398 () Int) (declare-fun xH399 () Int) (declare-fun xH400 () Int) (declare-fun xH401 () Int) (declare-fun xH402 () Int) (declare-fun xH403 () Int) (declare-fun xH404 () Int) (declare-fun xH405 () Int) (declare-fun xH406 () Int) (declare-fun xH407 () Int) (declare-fun xH408 () Int) (declare-fun xH409 () Int) (declare-fun xH410 () Int) (declare-fun xH411 () Int) (declare-fun xH412 () Int) (declare-fun xH413 () Int) (declare-fun xH414 () Int) (declare-fun xH415 () Int) (declare-fun xH416 () Int) (declare-fun xH417 () Int) (declare-fun xH418 () Int) (declare-fun xH419 () Int) (declare-fun xH420 () Int) (declare-fun xH421 () Int) (declare-fun xH422 () Int) (declare-fun xH423 () Int) (declare-fun xH424 () Int) (declare-fun xH425 () Int) (declare-fun xH426 () Int) (declare-fun xH427 () Int) (declare-fun xH428 () Int) (declare-fun xH429 () Int) (declare-fun xH430 () Int) (declare-fun xH431 () Int) (declare-fun xH432 () Int) (declare-fun xH433 () Int) (declare-fun xH434 () Int) (declare-fun xH435 () Int) (declare-fun xH436 () Int) (declare-fun xH437 () Int) (declare-fun xH438 () Int) (declare-fun xH439 () Int) (declare-fun xH440 () Int) (declare-fun xH441 () Int) (declare-fun xH442 () Int) (declare-fun xH443 () Int) (declare-fun xH444 () Int) (declare-fun xH445 () Int) (declare-fun xH446 () Int) (declare-fun xH447 () Int) (declare-fun xH448 () Int) (declare-fun xH449 () Int) (declare-fun xH450 () Int) (declare-fun xH451 () Int) (declare-fun xH452 () Int) (declare-fun xH453 () Int) (declare-fun xH454 () Int) (declare-fun xH455 () Int) (declare-fun xH456 () Int) (declare-fun xH457 () Int) (declare-fun xH458 () Int) (declare-fun xH459 () Int) (declare-fun xH460 () Int) (declare-fun xH461 () Int) (declare-fun xH462 () Int) (declare-fun xH463 () Int) (declare-fun xH464 () Int) (declare-fun xH465 () Int) (declare-fun xH466 () Int) (declare-fun xH467 () Int) (declare-fun xH468 () Int) (declare-fun xH469 () Int) (declare-fun xH470 () Int) (declare-fun xH471 () Int) (declare-fun xH472 () Int) (declare-fun xH473 () Int) (declare-fun xH474 () Int) (declare-fun xH475 () Int) (declare-fun xH476 () Int) (declare-fun xH477 () Int) (declare-fun xH478 () Int) (declare-fun xH479 () Int) (declare-fun xH480 () Int) (declare-fun xH481 () Int) (declare-fun xH482 () Int) (declare-fun xH483 () Int) (declare-fun xH484 () Int) (declare-fun xH485 () Int) (declare-fun xH486 () Int) (declare-fun xH487 () Int) (declare-fun xH488 () Int) (declare-fun xH489 () Int) (declare-fun xH490 () Int) (declare-fun xH491 () Int) (declare-fun xH492 () Int) (declare-fun xH493 () Int) (declare-fun xH494 () Int) (declare-fun xH495 () Int) (declare-fun xH496 () Int) (declare-fun xH497 () Int) (declare-fun xH498 () Int) (declare-fun xH499 () Int) (declare-fun xH500 () Int) (declare-fun xH501 () Int) (declare-fun xH502 () Int) (declare-fun xH503 () Int) (declare-fun xH504 () Int) (declare-fun xH505 () Int) (declare-fun xH506 () Int) (declare-fun xH507 () Int) (declare-fun xH508 () Int) (declare-fun xH509 () Int) (declare-fun xH510 () Int) (declare-fun xH511 () Int) (declare-fun xH512 () Int) (declare-fun xH513 () Int) (declare-fun xH514 () Int) (declare-fun xH515 () Int) (declare-fun xH516 () Int) (declare-fun xH517 () Int) (declare-fun xH518 () Int) (declare-fun xH519 () Int) (declare-fun xH520 () Int) (declare-fun xH521 () Int) (declare-fun xH522 () Int) (declare-fun xH523 () Int) (declare-fun xH524 () Int) (declare-fun xH525 () Int) (declare-fun xH526 () Int) (declare-fun xH527 () Int) (declare-fun xH528 () Int) (declare-fun xH529 () Int) (declare-fun xH530 () Int) (declare-fun xH531 () Int) (declare-fun xH532 () Int) (declare-fun xH533 () Int) (declare-fun xH534 () Int) (declare-fun xH535 () Int) (declare-fun xH536 () Int) (declare-fun xH537 () Int) (declare-fun xH538 () Int) (declare-fun xH539 () Int) (declare-fun xH540 () Int) (declare-fun xH541 () Int) (declare-fun xH542 () Int) (declare-fun xH543 () Int) (declare-fun xH544 () Int) (declare-fun xH545 () Int) (declare-fun xH546 () Int) (declare-fun xH547 () Int) (declare-fun xH548 () Int) (declare-fun xH549 () Int) (declare-fun xH550 () Int) (declare-fun xH551 () Int) (declare-fun xH552 () Int) (declare-fun xH553 () Int) (declare-fun xH554 () Int) (declare-fun xH555 () Int) (declare-fun xH556 () Int) (declare-fun xH557 () Int) (declare-fun xH558 () Int) (declare-fun xH559 () Int) (declare-fun xH560 () Int) (declare-fun xH561 () Int) (declare-fun xH562 () Int) (declare-fun xH563 () Int) (declare-fun xH564 () Int) (declare-fun xH565 () Int) (declare-fun xH566 () Int) (declare-fun xH567 () Int) (declare-fun xH568 () Int) (declare-fun xH569 () Int) (declare-fun xH570 () Int) (declare-fun xH571 () Int) (declare-fun xH572 () Int) (declare-fun xH573 () Int) (declare-fun xH574 () Int) (declare-fun xH575 () Int) (declare-fun xH576 () Int) (declare-fun xH577 () Int) (declare-fun xH578 () Int) (declare-fun xH579 () Int) (declare-fun xH580 () Int) (declare-fun xH581 () Int) (declare-fun xH582 () Int) (declare-fun xH583 () Int) (declare-fun xH584 () Int) (declare-fun xH585 () Int) (declare-fun xH586 () Int) (declare-fun xH587 () Int) (declare-fun xH588 () Int) (declare-fun xH589 () Int) (declare-fun xH590 () Int) (declare-fun xH591 () Int) (declare-fun xH592 () Int) (declare-fun xH593 () Int) (declare-fun xH594 () Int) (declare-fun xH595 () Int) (declare-fun xH596 () Int) (declare-fun xH597 () Int) (declare-fun xH598 () Int) (declare-fun xH599 () Int) (declare-fun xH600 () Int) (declare-fun xH601 () Int) (declare-fun xH602 () Int) (declare-fun xH603 () Int) (declare-fun xH604 () Int) (declare-fun xH605 () Int) (declare-fun xH606 () Int) (declare-fun xH607 () Int) (declare-fun xH608 () Int) (declare-fun xH609 () Int) (declare-fun xH610 () Int) (declare-fun xH611 () Int) (declare-fun xH612 () Int) (declare-fun xH613 () Int) (declare-fun xH614 () Int) (declare-fun xH615 () Int) (declare-fun xH616 () Int) (declare-fun xH617 () Int) (declare-fun xH618 () Int) (declare-fun xH619 () Int) (declare-fun xH620 () Int) (declare-fun xH621 () Int) (declare-fun xH622 () Int) (declare-fun xH623 () Int) (declare-fun xH624 () Int) (declare-fun xH625 () Int) (declare-fun xH626 () Int) (declare-fun xH627 () Int) (declare-fun xH628 () Int) (declare-fun xH629 () Int) (declare-fun xH630 () Int) (declare-fun xH631 () Int) (declare-fun xH632 () Int) (declare-fun xH633 () Int) (declare-fun xH634 () Int) (declare-fun xH635 () Int) (declare-fun xH636 () Int) (declare-fun xH637 () Int) (declare-fun xH638 () Int) (declare-fun xH639 () Int) (declare-fun xH640 () Int) (declare-fun xH641 () Int) (declare-fun xH642 () Int) (declare-fun xH643 () Int) (declare-fun xH644 () Int) (declare-fun xH645 () Int) (declare-fun xH646 () Int) (declare-fun xH647 () Int) (declare-fun xH648 () Int) (declare-fun xH649 () Int) (declare-fun xH650 () Int) (declare-fun xH651 () Int) (declare-fun xH652 () Int) (declare-fun xH653 () Int) (declare-fun xH654 () Int) (declare-fun xH655 () Int) (declare-fun xH656 () Int) (declare-fun xH657 () Int) (declare-fun xH658 () Int) (declare-fun xH659 () Int) (declare-fun xH660 () Int) (declare-fun xH661 () Int) (declare-fun xH662 () Int) (declare-fun xH663 () Int) (declare-fun xH664 () Int) (declare-fun xH665 () Int) (declare-fun xH666 () Int) (declare-fun xH667 () Int) (declare-fun xH668 () Int) (declare-fun xH669 () Int) (declare-fun xH670 () Int) (declare-fun xH671 () Int) (declare-fun xH672 () Int) (declare-fun xH673 () Int) (declare-fun xH674 () Int) (declare-fun xH675 () Int) (declare-fun xH676 () Int) (declare-fun xH677 () Int) (declare-fun xH678 () Int) (declare-fun xH679 () Int) (declare-fun xH680 () Int) (declare-fun xH681 () Int) (declare-fun xH682 () Int) (declare-fun xH683 () Int) (declare-fun xH684 () Int) (declare-fun xH685 () Int) (declare-fun xH686 () Int) (declare-fun xH687 () Int) (declare-fun xH688 () Int) (declare-fun xH689 () Int) (declare-fun xH690 () Int) (declare-fun xH691 () Int) (declare-fun xH692 () Int) (declare-fun xH693 () Int) (declare-fun xH694 () Int) (declare-fun xH695 () Int) (declare-fun xH696 () Int) (declare-fun xH697 () Int) (declare-fun xH698 () Int) (declare-fun xH699 () Int) (declare-fun xH700 () Int) (declare-fun xH701 () Int) (declare-fun xH702 () Int) (declare-fun xH703 () Int) (declare-fun xH704 () Int) (declare-fun xH705 () Int) (declare-fun xH706 () Int) (declare-fun xH707 () Int) (declare-fun xH708 () Int) (declare-fun xH709 () Int) (declare-fun xH710 () Int) (declare-fun xH711 () Int) (declare-fun xH712 () Int) (declare-fun xH713 () Int) (declare-fun xH714 () Int) (declare-fun xH715 () Int) (declare-fun xH716 () Int) (declare-fun xH717 () Int) (declare-fun xH718 () Int) (declare-fun xH719 () Int) (declare-fun xH720 () Int) (declare-fun xH721 () Int) (declare-fun xH722 () Int) (declare-fun xH723 () Int) (declare-fun xH724 () Int) (declare-fun xH725 () Int) (declare-fun xH726 () Int) (declare-fun xH727 () Int) (declare-fun xH728 () Int) (declare-fun xH729 () Int) (declare-fun xH730 () Int) (declare-fun xH731 () Int) (declare-fun xH732 () Int) (declare-fun xH733 () Int) (declare-fun xH734 () Int) (declare-fun xH735 () Int) (declare-fun xH736 () Int) (declare-fun xH737 () Int) (declare-fun xH738 () Int) (declare-fun xH739 () Int) (declare-fun xH740 () Int) (declare-fun xH741 () Int) (declare-fun xH742 () Int) (declare-fun xH743 () Int) (declare-fun xH744 () Int) (declare-fun xH745 () Int) (declare-fun xH746 () Int) (declare-fun xH747 () Int) (declare-fun xH748 () Int) (declare-fun xH749 () Int) (declare-fun xH750 () Int) (declare-fun xH751 () Int) (declare-fun xH752 () Int) (declare-fun xH753 () Int) (declare-fun xH754 () Int) (declare-fun xH755 () Int) (declare-fun xH756 () Int) (declare-fun xH757 () Int) (declare-fun xH758 () Int) (declare-fun xH759 () Int) (declare-fun xH760 () Int) (declare-fun xH761 () Int) (declare-fun xH762 () Int) (declare-fun xH763 () Int) (declare-fun xH764 () Int) (declare-fun xH765 () Int) (declare-fun xH766 () Int) (declare-fun xH767 () Int) (declare-fun xH768 () Int) (declare-fun xH769 () Int) (declare-fun xH770 () Int) (declare-fun xH771 () Int) (declare-fun xH772 () Int) (declare-fun xH773 () Int) (declare-fun xH774 () Int) (declare-fun xH775 () Int) (declare-fun xH776 () Int) (declare-fun xH777 () Int) (declare-fun xH778 () Int) (declare-fun xH779 () Int) (declare-fun xH780 () Int) (assert (and (= xH1 (- 4795 xH521)) (= xH2 (- (+ (- xH1 xH262) 4795) xH522)) (or (and (= xH521 4795) (= xH522 4795)) (and (= xH521 0) (= xH522 0))) (= xH3 (- xH2 xH263)) (= xH523 0) (= xH4 (- (+ (- xH3 xH264) 116) xH524)) (= xH5 (- (+ (- xH4 xH265) 116) xH525)) (= xH6 (- (+ (- xH5 xH266) 116) xH526)) (= xH7 (- (+ (- xH6 xH267) 116) xH527)) (or (and (= xH524 116) (= xH525 116) (= xH526 116) (= xH527 116)) (and (= xH524 0) (= xH525 0) (= xH526 0) (= xH527 0))) (= xH8 (- (+ (- xH7 xH268) 2954) xH528)) (or (= xH528 2954) (= xH528 0)) (= xH9 (- (+ (- xH8 xH269) 1123) xH529)) (= xH10 (- (+ (- xH9 xH270) 1123) xH530)) (or (and (= xH529 1123) (= xH530 1123)) (and (= xH529 0) (= xH530 0))) (= xH11 (- (+ (- xH10 xH271) 1284) xH531)) (or (= xH531 1284) (= xH531 0)) (= xH12 (- xH11 xH272)) (= xH532 0) (= xH13 (- (+ (- xH12 xH273) 426) xH533)) (or (= xH533 426) (= xH533 0)) (= xH14 (- (+ (- xH13 xH274) 1424) xH534)) (or (= xH534 1424) (= xH534 0)) (= xH15 (- xH14 xH275)) (= xH535 0) (= xH16 (- (+ (- xH15 xH276) 1231) xH536)) (or (= xH536 1231) (= xH536 0)) (= xH17 (- xH16 xH277)) (= xH537 0) (= xH18 (- (+ (- xH17 xH278) 1180) xH538)) (or (= xH538 1180) (= xH538 0)) (= xH19 (- (+ (- xH18 xH279) 671) xH539)) (or (= xH539 671) (= xH539 0)) (= xH20 (- xH19 xH280)) (= xH540 0) (= xH21 (- (+ (- xH20 xH281) 4573) xH541)) (or (= xH541 4573) (= xH541 0)) (= xH22 (- xH21 xH282)) (= xH542 0) (= xH23 (- (+ (- xH22 xH283) 222) xH543)) (= xH24 (- (+ (- xH23 xH284) 222) xH544)) (or (and (= xH543 222) (= xH544 222)) (and (= xH543 0) (= xH544 0))) (= xH25 (- xH24 xH285)) (= xH545 0) (= xH26 (- xH25 xH286)) (= xH546 0) (= xH27 (- 250 xH547)) (= xH28 (- (+ (- xH27 xH288) 250) xH548)) (= xH29 (- (+ (- xH28 xH289) 250) xH549)) (= xH30 (- (+ (- xH29 xH290) 250) xH550)) (or (and (= xH547 250) (= xH548 250) (= xH549 250) (= xH550 250)) (and (= xH547 0) (= xH548 0) (= xH549 0) (= xH550 0))) (= xH31 (- xH30 xH291)) (= xH551 0) (= xH32 (- (+ (- xH31 xH292) 723) xH552)) (or (= xH552 723) (= xH552 0)) (= xH33 (- (+ (- xH32 xH293) 3911) xH553)) (or (= xH553 3911) (= xH553 0)) (= xH34 (- (+ (- xH33 xH294) 1103) xH554)) (= xH35 (- (+ (- xH34 xH295) 1103) xH555)) (= xH36 (- (+ (- xH35 xH296) 1103) xH556)) (or (and (= xH554 1103) (= xH555 1103) (= xH556 1103)) (and (= xH554 0) (= xH555 0) (= xH556 0))) (= xH37 (- (+ (- xH36 xH297) 366) xH557)) (or (= xH557 366) (= xH557 0)) (= xH38 (- (+ (- xH37 xH298) 3357) xH558)) (or (= xH558 3357) (= xH558 0)) (= xH39 (- (+ (- xH38 xH299) 967) xH559)) (= xH40 (- (+ (- xH39 xH300) 967) xH560)) (= xH41 (- (+ (- xH40 xH301) 967) xH561)) (or (and (= xH559 967) (= xH560 967) (= xH561 967)) (and (= xH559 0) (= xH560 0) (= xH561 0))) (= xH42 (- (+ (- xH41 xH302) 1380) xH562)) (or (= xH562 1380) (= xH562 0)) (= xH43 (- (+ (- xH42 xH303) 4054) xH563)) (or (= xH563 4054) (= xH563 0)) (= xH44 (- (+ (- xH43 xH304) 2858) xH564)) (= xH45 (- (+ (- xH44 xH305) 2858) xH565)) (= xH46 (- (+ (- xH45 xH306) 2858) xH566)) (= xH47 (- (+ (- xH46 xH307) 2858) xH567)) (or (and (= xH564 2858) (= xH565 2858) (= xH566 2858) (= xH567 2858)) (and (= xH564 0) (= xH565 0) (= xH566 0) (= xH567 0))) (= xH48 (- xH47 xH308)) (= xH568 0) (= xH49 (- (+ (- xH48 xH309) 3518) xH569)) (= xH50 (- (+ (- xH49 xH310) 3518) xH570)) (or (and (= xH569 3518) (= xH570 3518)) (and (= xH569 0) (= xH570 0))) (= xH51 (- xH50 xH311)) (= xH571 0) (= xH52 (- xH51 xH312)) (= xH572 0) (= xH53 (- 127 xH573)) (or (= xH573 127) (= xH573 0)) (= xH54 (- (+ (- xH53 xH314) 1853) xH574)) (or (= xH574 1853) (= xH574 0)) (= xH55 (- xH54 xH315)) (= xH575 0) (= xH56 (- (+ (- xH55 xH316) 260) xH576)) (or (= xH576 260) (= xH576 0)) (= xH57 (- (+ (- xH56 xH317) 2430) xH577)) (or (= xH577 2430) (= xH577 0)) (= xH58 (- (+ (- xH57 xH318) 289) xH578)) (= xH59 (- (+ (- xH58 xH319) 289) xH579)) (or (and (= xH578 289) (= xH579 289)) (and (= xH578 0) (= xH579 0))) (= xH60 (- (+ (- xH59 xH320) 4968) xH580)) (or (= xH580 4968) (= xH580 0)) (= xH61 (- xH60 xH321)) (= xH581 0) (= xH62 (- (+ (- xH61 xH322) 309) xH582)) (= xH63 (- (+ (- xH62 xH323) 309) xH583)) (= xH64 (- (+ (- xH63 xH324) 309) xH584)) (= xH65 (- (+ (- xH64 xH325) 309) xH585)) (or (and (= xH582 309) (= xH583 309) (= xH584 309) (= xH585 309)) (and (= xH582 0) (= xH583 0) (= xH584 0) (= xH585 0))) (= xH66 (- (+ (- xH65 xH326) 4012) xH586)) (or (= xH586 4012) (= xH586 0)) (= xH67 (- xH66 xH327)) (= xH587 0) (= xH68 (- (+ (- xH67 xH328) 1075) xH588)) (= xH69 (- (+ (- xH68 xH329) 1075) xH589)) (= xH70 (- (+ (- xH69 xH330) 1075) xH590)) (= xH71 (- (+ (- xH70 xH331) 1075) xH591)) (or (and (= xH588 1075) (= xH589 1075) (= xH590 1075) (= xH591 1075)) (and (= xH588 0) (= xH589 0) (= xH590 0) (= xH591 0))) (= xH72 (- (+ (- xH71 xH332) 3425) xH592)) (or (= xH592 3425) (= xH592 0)) (= xH73 (- (+ (- xH72 xH333) 342) xH593)) (= xH74 (- (+ (- xH73 xH334) 342) xH594)) (= xH75 (- (+ (- xH74 xH335) 342) xH595)) (or (and (= xH593 342) (= xH594 342) (= xH595 342)) (and (= xH593 0) (= xH594 0) (= xH595 0))) (= xH76 (- (+ (- xH75 xH336) 4681) xH596)) (or (= xH596 4681) (= xH596 0)) (= xH77 (- xH76 xH337)) (= xH597 0) (= xH78 (- xH77 xH338)) (= xH598 0) (= xH79 0) (= xH599 0) (= xH80 (- (+ (- xH79 xH340) 3065) xH600)) (or (= xH600 3065) (= xH600 0)) (= xH81 (- xH80 xH341)) (= xH601 0) (= xH82 (- (+ (- xH81 xH342) 4059) xH602)) (= xH83 (- (+ (- xH82 xH343) 4059) xH603)) (= xH84 (- (+ (- xH83 xH344) 4059) xH604)) (or (and (= xH602 4059) (= xH603 4059) (= xH604 4059)) (and (= xH602 0) (= xH603 0) (= xH604 0))) (= xH85 (- (+ (- xH84 xH345) 2126) xH605)) (= xH86 (- (+ (- xH85 xH346) 2126) xH606)) (= xH87 (- (+ (- xH86 xH347) 2126) xH607)) (= xH88 (- (+ (- xH87 xH348) 2126) xH608)) (or (and (= xH605 2126) (= xH606 2126) (= xH607 2126) (= xH608 2126)) (and (= xH605 0) (= xH606 0) (= xH607 0) (= xH608 0))) (= xH89 (- xH88 xH349)) (= xH609 0) (= xH90 (- (+ (- xH89 xH350) 1652) xH610)) (= xH91 (- (+ (- xH90 xH351) 1652) xH611)) (or (and (= xH610 1652) (= xH611 1652)) (and (= xH610 0) (= xH611 0))) (= xH92 (- (+ (- xH91 xH352) 619) xH612)) (or (= xH612 619) (= xH612 0)) (= xH93 (- xH92 xH353)) (= xH613 0) (= xH94 (- (+ (- xH93 xH354) 2042) xH614)) (or (= xH614 2042) (= xH614 0)) (= xH95 (- xH94 xH355)) (= xH615 0) (= xH96 (- (+ (- xH95 xH356) 135) xH616)) (= xH97 (- (+ (- xH96 xH357) 135) xH617)) (or (and (= xH616 135) (= xH617 135)) (and (= xH616 0) (= xH617 0))) (= xH98 (- xH97 xH358)) (= xH618 0) (= xH99 (- (+ (- xH98 xH359) 2411) xH619)) (or (= xH619 2411) (= xH619 0)) (= xH100 (- (+ (- xH99 xH360) 512) xH620)) (= xH101 (- (+ (- xH100 xH361) 512) xH621)) (or (and (= xH620 512) (= xH621 512)) (and (= xH620 0) (= xH621 0))) (= xH102 (- (+ (- xH101 xH362) 953) xH622)) (or (= xH622 953) (= xH622 0)) (= xH103 (- xH102 xH363)) (= xH623 0) (= xH104 (- xH103 xH364)) (= xH624 0) (= xH105 0) (= xH625 0) (= xH106 (- (+ (- xH105 xH366) 684) xH626)) (= xH107 (- (+ (- xH106 xH367) 684) xH627)) (= xH108 (- (+ (- xH107 xH368) 684) xH628)) (= xH109 (- (+ (- xH108 xH369) 684) xH629)) (or (and (= xH626 684) (= xH627 684) (= xH628 684) (= xH629 684)) (and (= xH626 0) (= xH627 0) (= xH628 0) (= xH629 0))) (= xH110 (- xH109 xH370)) (= xH630 0) (= xH111 (- (+ (- xH110 xH371) 268) xH631)) (or (= xH631 268) (= xH631 0)) (= xH112 (- (+ (- xH111 xH372) 612) xH632)) (or (= xH632 612) (= xH632 0)) (= xH113 (- (+ (- xH112 xH373) 142) xH633)) (or (= xH633 142) (= xH633 0)) (= xH114 (- xH113 xH374)) (= xH634 0) (= xH115 (- (+ (- xH114 xH375) 430) xH635)) (or (= xH635 430) (= xH635 0)) (= xH116 (- xH115 xH376)) (= xH636 0) (= xH117 (- (+ (- xH116 xH377) 2815) xH637)) (or (= xH637 2815) (= xH637 0)) (= xH118 (- (+ (- xH117 xH378) 1610) xH638)) (= xH119 (- (+ (- xH118 xH379) 1610) xH639)) (or (and (= xH638 1610) (= xH639 1610)) (and (= xH638 0) (= xH639 0))) (= xH120 (- xH119 xH380)) (= xH640 0) (= xH121 (- (+ (- xH120 xH381) 1097) xH641)) (or (= xH641 1097) (= xH641 0)) (= xH122 (- xH121 xH382)) (= xH642 0) (= xH123 (- (+ (- xH122 xH383) 2183) xH643)) (or (= xH643 2183) (= xH643 0)) (= xH124 (- xH123 xH384)) (= xH644 0) (= xH125 (- (+ (- xH124 xH385) 4499) xH645)) (= xH126 (- (+ (- xH125 xH386) 4499) xH646)) (or (and (= xH645 4499) (= xH646 4499)) (and (= xH645 0) (= xH646 0))) (= xH127 (- xH126 xH387)) (= xH647 0) (= xH128 (- (+ (- xH127 xH388) 4543) xH648)) (or (= xH648 4543) (= xH648 0)) (= xH129 (- xH128 xH389)) (= xH649 0) (= xH130 (- xH129 xH390)) (= xH650 0) (= xH131 0) (= xH651 0) (= xH132 (- (+ (- xH131 xH392) 865) xH652)) (or (= xH652 865) (= xH652 0)) (= xH133 (- xH132 xH393)) (= xH653 0) (= xH134 (- (+ (- xH133 xH394) 995) xH654)) (or (= xH654 995) (= xH654 0)) (= xH135 (- xH134 xH395)) (= xH655 0) (= xH136 (- (+ (- xH135 xH396) 4667) xH656)) (or (= xH656 4667) (= xH656 0)) (= xH137 (- xH136 xH397)) (= xH657 0) (= xH138 (- (+ (- xH137 xH398) 771) xH658)) (= xH139 (- (+ (- xH138 xH399) 771) xH659)) (= xH140 (- (+ (- xH139 xH400) 771) xH660)) (= xH141 (- (+ (- xH140 xH401) 771) xH661)) (or (and (= xH658 771) (= xH659 771) (= xH660 771) (= xH661 771)) (and (= xH658 0) (= xH659 0) (= xH660 0) (= xH661 0))) (= xH142 (- (+ (- xH141 xH402) 4816) xH662)) (or (= xH662 4816) (= xH662 0)) (= xH143 (- (+ (- xH142 xH403) 1334) xH663)) (= xH144 (- (+ (- xH143 xH404) 1334) xH664)) (= xH145 (- (+ (- xH144 xH405) 1334) xH665)) (= xH146 (- (+ (- xH145 xH406) 1334) xH666)) (or (and (= xH663 1334) (= xH664 1334) (= xH665 1334) (= xH666 1334)) (and (= xH663 0) (= xH664 0) (= xH665 0) (= xH666 0))) (= xH147 (- (+ (- xH146 xH407) 635) xH667)) (or (= xH667 635) (= xH667 0)) (= xH148 (- (+ (- xH147 xH408) 2693) xH668)) (or (= xH668 2693) (= xH668 0)) (= xH149 (- (+ (- xH148 xH409) 394) xH669)) (= xH150 (- (+ (- xH149 xH410) 394) xH670)) (or (and (= xH669 394) (= xH670 394)) (and (= xH669 0) (= xH670 0))) (= xH151 (- (+ (- xH150 xH411) 1290) xH671)) (or (= xH671 1290) (= xH671 0)) (= xH152 (- xH151 xH412)) (= xH672 0) (= xH153 (- (+ (- xH152 xH413) 4011) xH673)) (or (= xH673 4011) (= xH673 0)) (= xH154 (- xH153 xH414)) (= xH674 0) (= xH155 (- xH154 xH415)) (= xH675 0) (= xH156 (- xH155 xH416)) (= xH676 0) (= xH157 0) (= xH677 0) (= xH158 (- (+ (- xH157 xH418) 1360) xH678)) (= xH159 (- (+ (- xH158 xH419) 1360) xH679)) (= xH160 (- (+ (- xH159 xH420) 1360) xH680)) (= xH161 (- (+ (- xH160 xH421) 1360) xH681)) (or (and (= xH678 1360) (= xH679 1360) (= xH680 1360) (= xH681 1360)) (and (= xH678 0) (= xH679 0) (= xH680 0) (= xH681 0))) (= xH162 (- (+ (- xH161 xH422) 263) xH682)) (or (= xH682 263) (= xH682 0)) (= xH163 (- xH162 xH423)) (= xH683 0) (= xH164 (- (+ (- xH163 xH424) 2658) xH684)) (or (= xH684 2658) (= xH684 0)) (= xH165 (- (+ (- xH164 xH425) 952) xH685)) (= xH166 (- (+ (- xH165 xH426) 952) xH686)) (or (and (= xH685 952) (= xH686 952)) (and (= xH685 0) (= xH686 0))) (= xH167 (- (+ (- xH166 xH427) 4559) xH687)) (or (= xH687 4559) (= xH687 0)) (= xH168 (- (+ (- xH167 xH428) 2949) xH688)) (= xH169 (- (+ (- xH168 xH429) 2949) xH689)) (= xH170 (- (+ (- xH169 xH430) 2949) xH690)) (= xH171 (- (+ (- xH170 xH431) 2949) xH691)) (or (and (= xH688 2949) (= xH689 2949) (= xH690 2949) (= xH691 2949)) (and (= xH688 0) (= xH689 0) (= xH690 0) (= xH691 0))) (= xH172 (- (+ (- xH171 xH432) 3953) xH692)) (= xH173 (- (+ (- xH172 xH433) 3953) xH693)) (or (and (= xH692 3953) (= xH693 3953)) (and (= xH692 0) (= xH693 0))) (= xH174 (- (+ (- xH173 xH434) 795) xH694)) (= xH175 (- (+ (- xH174 xH435) 795) xH695)) (= xH176 (- (+ (- xH175 xH436) 795) xH696)) (or (and (= xH694 795) (= xH695 795) (= xH696 795)) (and (= xH694 0) (= xH695 0) (= xH696 0))) (= xH177 (- xH176 xH437)) (= xH697 0) (= xH178 (- (+ (- xH177 xH438) 475) xH698)) (or (= xH698 475) (= xH698 0)) (= xH179 (- (+ (- xH178 xH439) 586) xH699)) (or (= xH699 586) (= xH699 0)) (= xH180 (- (+ (- xH179 xH440) 850) xH700)) (or (= xH700 850) (= xH700 0)) (= xH181 (- xH180 xH441)) (= xH701 0) (= xH182 (- xH181 xH442)) (= xH702 0) (= xH183 0) (= xH703 0) (= xH184 (- (+ (- xH183 xH444) 3120) xH704)) (or (= xH704 3120) (= xH704 0)) (= xH185 (- (+ (- xH184 xH445) 1962) xH705)) (= xH186 (- (+ (- xH185 xH446) 1962) xH706)) (= xH187 (- (+ (- xH186 xH447) 1962) xH707)) (or (and (= xH705 1962) (= xH706 1962) (= xH707 1962)) (and (= xH705 0) (= xH706 0) (= xH707 0))) (= xH188 (- (+ (- xH187 xH448) 153) xH708)) (or (= xH708 153) (= xH708 0)) (= xH189 (- xH188 xH449)) (= xH709 0) (= xH190 (- (+ (- xH189 xH450) 3015) xH710)) (or (= xH710 3015) (= xH710 0)) (= xH191 (- xH190 xH451)) (= xH711 0) (= xH192 (- (+ (- xH191 xH452) 3776) xH712)) (= xH193 (- (+ (- xH192 xH453) 3776) xH713)) (= xH194 (- (+ (- xH193 xH454) 3776) xH714)) (or (and (= xH712 3776) (= xH713 3776) (= xH714 3776)) (and (= xH712 0) (= xH713 0) (= xH714 0))) (= xH195 (- (+ (- xH194 xH455) 500) xH715)) (= xH196 (- (+ (- xH195 xH456) 500) xH716)) (= xH197 (- (+ (- xH196 xH457) 500) xH717)) (or (and (= xH715 500) (= xH716 500) (= xH717 500)) (and (= xH715 0) (= xH716 0) (= xH717 0))) (= xH198 (- xH197 xH458)) (= xH718 0) (= xH199 (- (+ (- xH198 xH459) 213) xH719)) (or (= xH719 213) (= xH719 0)) (= xH200 (- xH199 xH460)) (= xH720 0) (= xH201 (- (+ (- xH200 xH461) 821) xH721)) (or (= xH721 821) (= xH721 0)) (= xH202 (- (+ (- xH201 xH462) 1968) xH722)) (or (= xH722 1968) (= xH722 0)) (= xH203 (- (+ (- xH202 xH463) 686) xH723)) (or (= xH723 686) (= xH723 0)) (= xH204 (- (+ (- xH203 xH464) 1775) xH724)) (or (= xH724 1775) (= xH724 0)) (= xH205 (- xH204 xH465)) (= xH725 0) (= xH206 (- (+ (- xH205 xH466) 1734) xH726)) (or (= xH726 1734) (= xH726 0)) (= xH207 (- xH206 xH467)) (= xH727 0) (= xH208 (- xH207 xH468)) (= xH728 0) (= xH209 (- 2004 xH729)) (or (= xH729 2004) (= xH729 0)) (= xH210 (- xH209 xH470)) (= xH730 0) (= xH211 (- (+ (- xH210 xH471) 1753) xH731)) (= xH212 (- (+ (- xH211 xH472) 1753) xH732)) (or (and (= xH731 1753) (= xH732 1753)) (and (= xH731 0) (= xH732 0))) (= xH213 (- (+ (- xH212 xH473) 275) xH733)) (or (= xH733 275) (= xH733 0)) (= xH214 (- (+ (- xH213 xH474) 435) xH734)) (or (= xH734 435) (= xH734 0)) (= xH215 (- (+ (- xH214 xH475) 518) xH735)) (or (= xH735 518) (= xH735 0)) (= xH216 (- (+ (- xH215 xH476) 1384) xH736)) (or (= xH736 1384) (= xH736 0)) (= xH217 (- (+ (- xH216 xH477) 384) xH737)) (or (= xH737 384) (= xH737 0)) (= xH218 (- (+ (- xH217 xH478) 1346) xH738)) (or (= xH738 1346) (= xH738 0)) (= xH219 (- (+ (- xH218 xH479) 895) xH739)) (or (= xH739 895) (= xH739 0)) (= xH220 (- (+ (- xH219 xH480) 449) xH740)) (or (= xH740 449) (= xH740 0)) (= xH221 (- (+ (- xH220 xH481) 1077) xH741)) (or (= xH741 1077) (= xH741 0)) (= xH222 (- (+ (- xH221 xH482) 221) xH742)) (or (= xH742 221) (= xH742 0)) (= xH223 (- xH222 xH483)) (= xH743 0) (= xH224 (- (+ (- xH223 xH484) 3371) xH744)) (or (= xH744 3371) (= xH744 0)) (= xH225 (- (+ (- xH224 xH485) 192) xH745)) (= xH226 (- (+ (- xH225 xH486) 192) xH746)) (= xH227 (- (+ (- xH226 xH487) 192) xH747)) (or (and (= xH745 192) (= xH746 192) (= xH747 192)) (and (= xH745 0) (= xH746 0) (= xH747 0))) (= xH228 (- xH227 xH488)) (= xH748 0) (= xH229 (- (+ (- xH228 xH489) 100) xH749)) (or (= xH749 100) (= xH749 0)) (= xH230 (- xH229 xH490)) (= xH750 0) (= xH231 (- (+ (- xH230 xH491) 4120) xH751)) (or (= xH751 4120) (= xH751 0)) (= xH232 (- xH231 xH492)) (= xH752 0) (= xH233 (- xH232 xH493)) (= xH753 0) (= xH234 (- xH233 xH494)) (= xH754 0) (= xH235 0) (= xH755 0) (= xH236 (- (+ (- xH235 xH496) 170) xH756)) (= xH237 (- (+ (- xH236 xH497) 170) xH757)) (= xH238 (- (+ (- xH237 xH498) 170) xH758)) (= xH239 (- (+ (- xH238 xH499) 170) xH759)) (or (and (= xH756 170) (= xH757 170) (= xH758 170) (= xH759 170)) (and (= xH756 0) (= xH757 0) (= xH758 0) (= xH759 0))) (= xH240 (- (+ (- xH239 xH500) 723) xH760)) (or (= xH760 723) (= xH760 0)) (= xH241 (- (+ (- xH240 xH501) 2701) xH761)) (or (= xH761 2701) (= xH761 0)) (= xH242 (- xH241 xH502)) (= xH762 0) (= xH243 (- (+ (- xH242 xH503) 2975) xH763)) (= xH244 (- (+ (- xH243 xH504) 2975) xH764)) (or (and (= xH763 2975) (= xH764 2975)) (and (= xH763 0) (= xH764 0))) (= xH245 (- (+ (- xH244 xH505) 3603) xH765)) (= xH246 (- (+ (- xH245 xH506) 3603) xH766)) (or (and (= xH765 3603) (= xH766 3603)) (and (= xH765 0) (= xH766 0))) (= xH247 (- xH246 xH507)) (= xH767 0) (= xH248 (- (+ (- xH247 xH508) 4616) xH768)) (= xH249 (- (+ (- xH248 xH509) 4616) xH769)) (= xH250 (- (+ (- xH249 xH510) 4616) xH770)) (or (and (= xH768 4616) (= xH769 4616) (= xH770 4616)) (and (= xH768 0) (= xH769 0) (= xH770 0))) (= xH251 (- xH250 xH511)) (= xH771 0) (= xH252 (- (+ (- xH251 xH512) 3985) xH772)) (= xH253 (- (+ (- xH252 xH513) 3985) xH773)) (= xH254 (- (+ (- xH253 xH514) 3985) xH774)) (= xH255 (- (+ (- xH254 xH515) 3985) xH775)) (or (and (= xH772 3985) (= xH773 3985) (= xH774 3985) (= xH775 3985)) (and (= xH772 0) (= xH773 0) (= xH774 0) (= xH775 0))) (= xH256 (- (+ (- xH255 xH516) 879) xH776)) (= xH257 (- (+ (- xH256 xH517) 879) xH777)) (= xH258 (- (+ (- xH257 xH518) 879) xH778)) (or (and (= xH776 879) (= xH777 879) (= xH778 879)) (and (= xH776 0) (= xH777 0) (= xH778 0))) (= xH259 (- xH258 xH519)) (= xH779 0) (= xH260 (- xH259 xH520)) (= xH780 0) (<= 0 xH1) (<= xH1 9241) (<= 0 xH2) (<= xH2 9241) (<= 0 xH3) (<= xH3 9241) (<= 0 xH4) (<= xH4 9241) (<= 0 xH5) (<= xH5 9241) (<= 0 xH6) (<= xH6 9241) (<= 0 xH7) (<= xH7 9241) (<= 0 xH8) (<= xH8 9241) (<= 0 xH9) (<= xH9 9241) (<= 0 xH10) (<= xH10 9241) (<= 0 xH11) (<= xH11 9241) (<= 0 xH12) (<= xH12 9241) (<= 0 xH13) (<= xH13 9241) (<= 0 xH14) (<= xH14 9241) (<= 0 xH15) (<= xH15 9241) (<= 0 xH16) (<= xH16 9241) (<= 0 xH17) (<= xH17 9241) (<= 0 xH18) (<= xH18 9241) (<= 0 xH19) (<= xH19 9241) (<= 0 xH20) (<= xH20 9241) (<= 0 xH21) (<= xH21 9241) (<= 0 xH22) (<= xH22 9241) (<= 0 xH23) (<= xH23 9241) (<= 0 xH24) (<= xH24 9241) (<= 0 xH25) (<= xH25 9241) (= xH26 0) (<= 0 xH27) (<= xH27 6147) (<= 0 xH28) (<= xH28 6147) (<= 0 xH29) (<= xH29 6147) (<= 0 xH30) (<= xH30 6147) (<= 0 xH31) (<= xH31 6147) (<= 0 xH32) (<= xH32 6147) (<= 0 xH33) (<= xH33 6147) (<= 0 xH34) (<= xH34 6147) (<= 0 xH35) (<= xH35 6147) (<= 0 xH36) (<= xH36 6147) (<= 0 xH37) (<= xH37 6147) (<= 0 xH38) (<= xH38 6147) (<= 0 xH39) (<= xH39 6147) (<= 0 xH40) (<= xH40 6147) (<= 0 xH41) (<= xH41 6147) (<= 0 xH42) (<= xH42 6147) (<= 0 xH43) (<= xH43 6147) (<= 0 xH44) (<= xH44 6147) (<= 0 xH45) (<= xH45 6147) (<= 0 xH46) (<= xH46 6147) (<= 0 xH47) (<= xH47 6147) (<= 0 xH48) (<= xH48 6147) (<= 0 xH49) (<= xH49 6147) (<= 0 xH50) (<= xH50 6147) (<= 0 xH51) (<= xH51 6147) (= xH52 0) (<= 0 xH53) (<= xH53 1701) (<= 0 xH54) (<= xH54 1701) (<= 0 xH55) (<= xH55 1701) (<= 0 xH56) (<= xH56 1701) (<= 0 xH57) (<= xH57 1701) (<= 0 xH58) (<= xH58 1701) (<= 0 xH59) (<= xH59 1701) (<= 0 xH60) (<= xH60 1701) (<= 0 xH61) (<= xH61 1701) (<= 0 xH62) (<= xH62 1701) (<= 0 xH63) (<= xH63 1701) (<= 0 xH64) (<= xH64 1701) (<= 0 xH65) (<= xH65 1701) (<= 0 xH66) (<= xH66 1701) (<= 0 xH67) (<= xH67 1701) (<= 0 xH68) (<= xH68 1701) (<= 0 xH69) (<= xH69 1701) (<= 0 xH70) (<= xH70 1701) (<= 0 xH71) (<= xH71 1701) (<= 0 xH72) (<= xH72 1701) (<= 0 xH73) (<= xH73 1701) (<= 0 xH74) (<= xH74 1701) (<= 0 xH75) (<= xH75 1701) (<= 0 xH76) (<= xH76 1701) (<= 0 xH77) (<= xH77 1701) (= xH78 0) (<= 0 xH79) (<= xH79 8472) (<= 0 xH80) (<= xH80 8472) (<= 0 xH81) (<= xH81 8472) (<= 0 xH82) (<= xH82 8472) (<= 0 xH83) (<= xH83 8472) (<= 0 xH84) (<= xH84 8472) (<= 0 xH85) (<= xH85 8472) (<= 0 xH86) (<= xH86 8472) (<= 0 xH87) (<= xH87 8472) (<= 0 xH88) (<= xH88 8472) (<= 0 xH89) (<= xH89 8472) (<= 0 xH90) (<= xH90 8472) (<= 0 xH91) (<= xH91 8472) (<= 0 xH92) (<= xH92 8472) (<= 0 xH93) (<= xH93 8472) (<= 0 xH94) (<= xH94 8472) (<= 0 xH95) (<= xH95 8472) (<= 0 xH96) (<= xH96 8472) (<= 0 xH97) (<= xH97 8472) (<= 0 xH98) (<= xH98 8472) (<= 0 xH99) (<= xH99 8472) (<= 0 xH100) (<= xH100 8472) (<= 0 xH101) (<= xH101 8472) (<= 0 xH102) (<= xH102 8472) (<= 0 xH103) (<= xH103 8472) (= xH104 0) (<= 0 xH105) (<= xH105 1227) (<= 0 xH106) (<= xH106 1227) (<= 0 xH107) (<= xH107 1227) (<= 0 xH108) (<= xH108 1227) (<= 0 xH109) (<= xH109 1227) (<= 0 xH110) (<= xH110 1227) (<= 0 xH111) (<= xH111 1227) (<= 0 xH112) (<= xH112 1227) (<= 0 xH113) (<= xH113 1227) (<= 0 xH114) (<= xH114 1227) (<= 0 xH115) (<= xH115 1227) (<= 0 xH116) (<= xH116 1227) (<= 0 xH117) (<= xH117 1227) (<= 0 xH118) (<= xH118 1227) (<= 0 xH119) (<= xH119 1227) (<= 0 xH120) (<= xH120 1227) (<= 0 xH121) (<= xH121 1227) (<= 0 xH122) (<= xH122 1227) (<= 0 xH123) (<= xH123 1227) (<= 0 xH124) (<= xH124 1227) (<= 0 xH125) (<= xH125 1227) (<= 0 xH126) (<= xH126 1227) (<= 0 xH127) (<= xH127 1227) (<= 0 xH128) (<= xH128 1227) (<= 0 xH129) (<= xH129 1227) (= xH130 0) (<= 0 xH131) (<= xH131 2252) (<= 0 xH132) (<= xH132 2252) (<= 0 xH133) (<= xH133 2252) (<= 0 xH134) (<= xH134 2252) (<= 0 xH135) (<= xH135 2252) (<= 0 xH136) (<= xH136 2252) (<= 0 xH137) (<= xH137 2252) (<= 0 xH138) (<= xH138 2252) (<= 0 xH139) (<= xH139 2252) (<= 0 xH140) (<= xH140 2252) (<= 0 xH141) (<= xH141 2252) (<= 0 xH142) (<= xH142 2252) (<= 0 xH143) (<= xH143 2252) (<= 0 xH144) (<= xH144 2252) (<= 0 xH145) (<= xH145 2252) (<= 0 xH146) (<= xH146 2252) (<= 0 xH147) (<= xH147 2252) (<= 0 xH148) (<= xH148 2252) (<= 0 xH149) (<= xH149 2252) (<= 0 xH150) (<= xH150 2252) (<= 0 xH151) (<= xH151 2252) (<= 0 xH152) (<= xH152 2252) (<= 0 xH153) (<= xH153 2252) (<= 0 xH154) (<= xH154 2252) (<= 0 xH155) (<= xH155 2252) (= xH156 0) (<= 0 xH157) (<= xH157 8643) (<= 0 xH158) (<= xH158 8643) (<= 0 xH159) (<= xH159 8643) (<= 0 xH160) (<= xH160 8643) (<= 0 xH161) (<= xH161 8643) (<= 0 xH162) (<= xH162 8643) (<= 0 xH163) (<= xH163 8643) (<= 0 xH164) (<= xH164 8643) (<= 0 xH165) (<= xH165 8643) (<= 0 xH166) (<= xH166 8643) (<= 0 xH167) (<= xH167 8643) (<= 0 xH168) (<= xH168 8643) (<= 0 xH169) (<= xH169 8643) (<= 0 xH170) (<= xH170 8643) (<= 0 xH171) (<= xH171 8643) (<= 0 xH172) (<= xH172 8643) (<= 0 xH173) (<= xH173 8643) (<= 0 xH174) (<= xH174 8643) (<= 0 xH175) (<= xH175 8643) (<= 0 xH176) (<= xH176 8643) (<= 0 xH177) (<= xH177 8643) (<= 0 xH178) (<= xH178 8643) (<= 0 xH179) (<= xH179 8643) (<= 0 xH180) (<= xH180 8643) (<= 0 xH181) (<= xH181 8643) (= xH182 0) (<= 0 xH183) (<= xH183 4018) (<= 0 xH184) (<= xH184 4018) (<= 0 xH185) (<= xH185 4018) (<= 0 xH186) (<= xH186 4018) (<= 0 xH187) (<= xH187 4018) (<= 0 xH188) (<= xH188 4018) (<= 0 xH189) (<= xH189 4018) (<= 0 xH190) (<= xH190 4018) (<= 0 xH191) (<= xH191 4018) (<= 0 xH192) (<= xH192 4018) (<= 0 xH193) (<= xH193 4018) (<= 0 xH194) (<= xH194 4018) (<= 0 xH195) (<= xH195 4018) (<= 0 xH196) (<= xH196 4018) (<= 0 xH197) (<= xH197 4018) (<= 0 xH198) (<= xH198 4018) (<= 0 xH199) (<= xH199 4018) (<= 0 xH200) (<= xH200 4018) (<= 0 xH201) (<= xH201 4018) (<= 0 xH202) (<= xH202 4018) (<= 0 xH203) (<= xH203 4018) (<= 0 xH204) (<= xH204 4018) (<= 0 xH205) (<= xH205 4018) (<= 0 xH206) (<= xH206 4018) (<= 0 xH207) (<= xH207 4018) (= xH208 0) (<= 0 xH209) (<= xH209 1958) (<= 0 xH210) (<= xH210 1958) (<= 0 xH211) (<= xH211 1958) (<= 0 xH212) (<= xH212 1958) (<= 0 xH213) (<= xH213 1958) (<= 0 xH214) (<= xH214 1958) (<= 0 xH215) (<= xH215 1958) (<= 0 xH216) (<= xH216 1958) (<= 0 xH217) (<= xH217 1958) (<= 0 xH218) (<= xH218 1958) (<= 0 xH219) (<= xH219 1958) (<= 0 xH220) (<= xH220 1958) (<= 0 xH221) (<= xH221 1958) (<= 0 xH222) (<= xH222 1958) (<= 0 xH223) (<= xH223 1958) (<= 0 xH224) (<= xH224 1958) (<= 0 xH225) (<= xH225 1958) (<= 0 xH226) (<= xH226 1958) (<= 0 xH227) (<= xH227 1958) (<= 0 xH228) (<= xH228 1958) (<= 0 xH229) (<= xH229 1958) (<= 0 xH230) (<= xH230 1958) (<= 0 xH231) (<= xH231 1958) (<= 0 xH232) (<= xH232 1958) (<= 0 xH233) (<= xH233 1958) (= xH234 0) (<= 0 xH235) (<= xH235 7259) (<= 0 xH236) (<= xH236 7259) (<= 0 xH237) (<= xH237 7259) (<= 0 xH238) (<= xH238 7259) (<= 0 xH239) (<= xH239 7259) (<= 0 xH240) (<= xH240 7259) (<= 0 xH241) (<= xH241 7259) (<= 0 xH242) (<= xH242 7259) (<= 0 xH243) (<= xH243 7259) (<= 0 xH244) (<= xH244 7259) (<= 0 xH245) (<= xH245 7259) (<= 0 xH246) (<= xH246 7259) (<= 0 xH247) (<= xH247 7259) (<= 0 xH248) (<= xH248 7259) (<= 0 xH249) (<= xH249 7259) (<= 0 xH250) (<= xH250 7259) (<= 0 xH251) (<= xH251 7259) (<= 0 xH252) (<= xH252 7259) (<= 0 xH253) (<= xH253 7259) (<= 0 xH254) (<= xH254 7259) (<= 0 xH255) (<= xH255 7259) (<= 0 xH256) (<= xH256 7259) (<= 0 xH257) (<= xH257 7259) (<= 0 xH258) (<= xH258 7259) (<= 0 xH259) (<= xH259 7259) (= xH260 0) (= xH261 0) (or (= xH262 0) (and (= xH262 2477) (>= xH1 2477)) (and (= xH262 xH1) (<= xH1 2477))) (or (= xH263 0) (and (= xH263 2477) (>= xH2 2477)) (and (= xH263 xH2) (<= xH2 2477))) (or (= xH264 0) (and (= xH264 2477) (>= xH3 2477)) (and (= xH264 xH3) (<= xH3 2477))) (or (= xH265 0) (and (= xH265 2477) (>= xH4 2477)) (and (= xH265 xH4) (<= xH4 2477))) (or (= xH266 0) (and (= xH266 2477) (>= xH5 2477)) (and (= xH266 xH5) (<= xH5 2477))) (or (= xH267 0) (and (= xH267 2477) (>= xH6 2477)) (and (= xH267 xH6) (<= xH6 2477))) (or (= xH268 0) (and (= xH268 2477) (>= xH7 2477)) (and (= xH268 xH7) (<= xH7 2477))) (or (= xH269 0) (and (= xH269 2477) (>= xH8 2477)) (and (= xH269 xH8) (<= xH8 2477))) (or (= xH270 0) (and (= xH270 2477) (>= xH9 2477)) (and (= xH270 xH9) (<= xH9 2477))) (or (= xH271 0) (and (= xH271 2477) (>= xH10 2477)) (and (= xH271 xH10) (<= xH10 2477))) (or (= xH272 0) (and (= xH272 2477) (>= xH11 2477)) (and (= xH272 xH11) (<= xH11 2477))) (or (= xH273 0) (and (= xH273 2477) (>= xH12 2477)) (and (= xH273 xH12) (<= xH12 2477))) (or (= xH274 0) (and (= xH274 2477) (>= xH13 2477)) (and (= xH274 xH13) (<= xH13 2477))) (or (= xH275 0) (and (= xH275 2477) (>= xH14 2477)) (and (= xH275 xH14) (<= xH14 2477))) (or (= xH276 0) (and (= xH276 2477) (>= xH15 2477)) (and (= xH276 xH15) (<= xH15 2477))) (or (= xH277 0) (and (= xH277 2477) (>= xH16 2477)) (and (= xH277 xH16) (<= xH16 2477))) (or (= xH278 0) (and (= xH278 2477) (>= xH17 2477)) (and (= xH278 xH17) (<= xH17 2477))) (or (= xH279 0) (and (= xH279 2477) (>= xH18 2477)) (and (= xH279 xH18) (<= xH18 2477))) (or (= xH280 0) (and (= xH280 2477) (>= xH19 2477)) (and (= xH280 xH19) (<= xH19 2477))) (or (= xH281 0) (and (= xH281 2477) (>= xH20 2477)) (and (= xH281 xH20) (<= xH20 2477))) (or (= xH282 0) (and (= xH282 2477) (>= xH21 2477)) (and (= xH282 xH21) (<= xH21 2477))) (or (= xH283 0) (and (= xH283 2477) (>= xH22 2477)) (and (= xH283 xH22) (<= xH22 2477))) (or (= xH284 0) (and (= xH284 2477) (>= xH23 2477)) (and (= xH284 xH23) (<= xH23 2477))) (or (= xH285 0) (and (= xH285 2477) (>= xH24 2477)) (and (= xH285 xH24) (<= xH24 2477))) (or (= xH286 0) (and (= xH286 2477) (>= xH25 2477)) (and (= xH286 xH25) (<= xH25 2477))) (= xH287 0) (or (= xH288 0) (and (= xH288 4957) (>= xH27 4957)) (and (= xH288 xH27) (<= xH27 4957))) (or (= xH289 0) (and (= xH289 4957) (>= xH28 4957)) (and (= xH289 xH28) (<= xH28 4957))) (or (= xH290 0) (and (= xH290 4957) (>= xH29 4957)) (and (= xH290 xH29) (<= xH29 4957))) (or (= xH291 0) (and (= xH291 4957) (>= xH30 4957)) (and (= xH291 xH30) (<= xH30 4957))) (or (= xH292 0) (and (= xH292 4957) (>= xH31 4957)) (and (= xH292 xH31) (<= xH31 4957))) (or (= xH293 0) (and (= xH293 4957) (>= xH32 4957)) (and (= xH293 xH32) (<= xH32 4957))) (or (= xH294 0) (and (= xH294 4957) (>= xH33 4957)) (and (= xH294 xH33) (<= xH33 4957))) (or (= xH295 0) (and (= xH295 4957) (>= xH34 4957)) (and (= xH295 xH34) (<= xH34 4957))) (or (= xH296 0) (and (= xH296 4957) (>= xH35 4957)) (and (= xH296 xH35) (<= xH35 4957))) (or (= xH297 0) (and (= xH297 4957) (>= xH36 4957)) (and (= xH297 xH36) (<= xH36 4957))) (or (= xH298 0) (and (= xH298 4957) (>= xH37 4957)) (and (= xH298 xH37) (<= xH37 4957))) (or (= xH299 0) (and (= xH299 4957) (>= xH38 4957)) (and (= xH299 xH38) (<= xH38 4957))) (or (= xH300 0) (and (= xH300 4957) (>= xH39 4957)) (and (= xH300 xH39) (<= xH39 4957))) (or (= xH301 0) (and (= xH301 4957) (>= xH40 4957)) (and (= xH301 xH40) (<= xH40 4957))) (or (= xH302 0) (and (= xH302 4957) (>= xH41 4957)) (and (= xH302 xH41) (<= xH41 4957))) (or (= xH303 0) (and (= xH303 4957) (>= xH42 4957)) (and (= xH303 xH42) (<= xH42 4957))) (or (= xH304 0) (and (= xH304 4957) (>= xH43 4957)) (and (= xH304 xH43) (<= xH43 4957))) (or (= xH305 0) (and (= xH305 4957) (>= xH44 4957)) (and (= xH305 xH44) (<= xH44 4957))) (or (= xH306 0) (and (= xH306 4957) (>= xH45 4957)) (and (= xH306 xH45) (<= xH45 4957))) (or (= xH307 0) (and (= xH307 4957) (>= xH46 4957)) (and (= xH307 xH46) (<= xH46 4957))) (or (= xH308 0) (and (= xH308 4957) (>= xH47 4957)) (and (= xH308 xH47) (<= xH47 4957))) (or (= xH309 0) (and (= xH309 4957) (>= xH48 4957)) (and (= xH309 xH48) (<= xH48 4957))) (or (= xH310 0) (and (= xH310 4957) (>= xH49 4957)) (and (= xH310 xH49) (<= xH49 4957))) (or (= xH311 0) (and (= xH311 4957) (>= xH50 4957)) (and (= xH311 xH50) (<= xH50 4957))) (or (= xH312 0) (and (= xH312 4957) (>= xH51 4957)) (and (= xH312 xH51) (<= xH51 4957))) (= xH313 0) (or (= xH314 0) (and (= xH314 1244) (>= xH53 1244)) (and (= xH314 xH53) (<= xH53 1244))) (or (= xH315 0) (and (= xH315 1244) (>= xH54 1244)) (and (= xH315 xH54) (<= xH54 1244))) (or (= xH316 0) (and (= xH316 1244) (>= xH55 1244)) (and (= xH316 xH55) (<= xH55 1244))) (or (= xH317 0) (and (= xH317 1244) (>= xH56 1244)) (and (= xH317 xH56) (<= xH56 1244))) (or (= xH318 0) (and (= xH318 1244) (>= xH57 1244)) (and (= xH318 xH57) (<= xH57 1244))) (or (= xH319 0) (and (= xH319 1244) (>= xH58 1244)) (and (= xH319 xH58) (<= xH58 1244))) (or (= xH320 0) (and (= xH320 1244) (>= xH59 1244)) (and (= xH320 xH59) (<= xH59 1244))) (or (= xH321 0) (and (= xH321 1244) (>= xH60 1244)) (and (= xH321 xH60) (<= xH60 1244))) (or (= xH322 0) (and (= xH322 1244) (>= xH61 1244)) (and (= xH322 xH61) (<= xH61 1244))) (or (= xH323 0) (and (= xH323 1244) (>= xH62 1244)) (and (= xH323 xH62) (<= xH62 1244))) (or (= xH324 0) (and (= xH324 1244) (>= xH63 1244)) (and (= xH324 xH63) (<= xH63 1244))) (or (= xH325 0) (and (= xH325 1244) (>= xH64 1244)) (and (= xH325 xH64) (<= xH64 1244))) (or (= xH326 0) (and (= xH326 1244) (>= xH65 1244)) (and (= xH326 xH65) (<= xH65 1244))) (or (= xH327 0) (and (= xH327 1244) (>= xH66 1244)) (and (= xH327 xH66) (<= xH66 1244))) (or (= xH328 0) (and (= xH328 1244) (>= xH67 1244)) (and (= xH328 xH67) (<= xH67 1244))) (or (= xH329 0) (and (= xH329 1244) (>= xH68 1244)) (and (= xH329 xH68) (<= xH68 1244))) (or (= xH330 0) (and (= xH330 1244) (>= xH69 1244)) (and (= xH330 xH69) (<= xH69 1244))) (or (= xH331 0) (and (= xH331 1244) (>= xH70 1244)) (and (= xH331 xH70) (<= xH70 1244))) (or (= xH332 0) (and (= xH332 1244) (>= xH71 1244)) (and (= xH332 xH71) (<= xH71 1244))) (or (= xH333 0) (and (= xH333 1244) (>= xH72 1244)) (and (= xH333 xH72) (<= xH72 1244))) (or (= xH334 0) (and (= xH334 1244) (>= xH73 1244)) (and (= xH334 xH73) (<= xH73 1244))) (or (= xH335 0) (and (= xH335 1244) (>= xH74 1244)) (and (= xH335 xH74) (<= xH74 1244))) (or (= xH336 0) (and (= xH336 1244) (>= xH75 1244)) (and (= xH336 xH75) (<= xH75 1244))) (or (= xH337 0) (and (= xH337 1244) (>= xH76 1244)) (and (= xH337 xH76) (<= xH76 1244))) (or (= xH338 0) (and (= xH338 1244) (>= xH77 1244)) (and (= xH338 xH77) (<= xH77 1244))) (= xH339 0) (or (= xH340 0) (and (= xH340 547) (>= xH79 547)) (and (= xH340 xH79) (<= xH79 547))) (or (= xH341 0) (and (= xH341 547) (>= xH80 547)) (and (= xH341 xH80) (<= xH80 547))) (or (= xH342 0) (and (= xH342 547) (>= xH81 547)) (and (= xH342 xH81) (<= xH81 547))) (or (= xH343 0) (and (= xH343 547) (>= xH82 547)) (and (= xH343 xH82) (<= xH82 547))) (or (= xH344 0) (and (= xH344 547) (>= xH83 547)) (and (= xH344 xH83) (<= xH83 547))) (or (= xH345 0) (and (= xH345 547) (>= xH84 547)) (and (= xH345 xH84) (<= xH84 547))) (or (= xH346 0) (and (= xH346 547) (>= xH85 547)) (and (= xH346 xH85) (<= xH85 547))) (or (= xH347 0) (and (= xH347 547) (>= xH86 547)) (and (= xH347 xH86) (<= xH86 547))) (or (= xH348 0) (and (= xH348 547) (>= xH87 547)) (and (= xH348 xH87) (<= xH87 547))) (or (= xH349 0) (and (= xH349 547) (>= xH88 547)) (and (= xH349 xH88) (<= xH88 547))) (or (= xH350 0) (and (= xH350 547) (>= xH89 547)) (and (= xH350 xH89) (<= xH89 547))) (or (= xH351 0) (and (= xH351 547) (>= xH90 547)) (and (= xH351 xH90) (<= xH90 547))) (or (= xH352 0) (and (= xH352 547) (>= xH91 547)) (and (= xH352 xH91) (<= xH91 547))) (or (= xH353 0) (and (= xH353 547) (>= xH92 547)) (and (= xH353 xH92) (<= xH92 547))) (or (= xH354 0) (and (= xH354 547) (>= xH93 547)) (and (= xH354 xH93) (<= xH93 547))) (or (= xH355 0) (and (= xH355 547) (>= xH94 547)) (and (= xH355 xH94) (<= xH94 547))) (or (= xH356 0) (and (= xH356 547) (>= xH95 547)) (and (= xH356 xH95) (<= xH95 547))) (or (= xH357 0) (and (= xH357 547) (>= xH96 547)) (and (= xH357 xH96) (<= xH96 547))) (or (= xH358 0) (and (= xH358 547) (>= xH97 547)) (and (= xH358 xH97) (<= xH97 547))) (or (= xH359 0) (and (= xH359 547) (>= xH98 547)) (and (= xH359 xH98) (<= xH98 547))) (or (= xH360 0) (and (= xH360 547) (>= xH99 547)) (and (= xH360 xH99) (<= xH99 547))) (or (= xH361 0) (and (= xH361 547) (>= xH100 547)) (and (= xH361 xH100) (<= xH100 547))) (or (= xH362 0) (and (= xH362 547) (>= xH101 547)) (and (= xH362 xH101) (<= xH101 547))) (or (= xH363 0) (and (= xH363 547) (>= xH102 547)) (and (= xH363 xH102) (<= xH102 547))) (or (= xH364 0) (and (= xH364 547) (>= xH103 547)) (and (= xH364 xH103) (<= xH103 547))) (= xH365 0) (or (= xH366 0) (and (= xH366 4485) (>= xH105 4485)) (and (= xH366 xH105) (<= xH105 4485))) (or (= xH367 0) (and (= xH367 4485) (>= xH106 4485)) (and (= xH367 xH106) (<= xH106 4485))) (or (= xH368 0) (and (= xH368 4485) (>= xH107 4485)) (and (= xH368 xH107) (<= xH107 4485))) (or (= xH369 0) (and (= xH369 4485) (>= xH108 4485)) (and (= xH369 xH108) (<= xH108 4485))) (or (= xH370 0) (and (= xH370 4485) (>= xH109 4485)) (and (= xH370 xH109) (<= xH109 4485))) (or (= xH371 0) (and (= xH371 4485) (>= xH110 4485)) (and (= xH371 xH110) (<= xH110 4485))) (or (= xH372 0) (and (= xH372 4485) (>= xH111 4485)) (and (= xH372 xH111) (<= xH111 4485))) (or (= xH373 0) (and (= xH373 4485) (>= xH112 4485)) (and (= xH373 xH112) (<= xH112 4485))) (or (= xH374 0) (and (= xH374 4485) (>= xH113 4485)) (and (= xH374 xH113) (<= xH113 4485))) (or (= xH375 0) (and (= xH375 4485) (>= xH114 4485)) (and (= xH375 xH114) (<= xH114 4485))) (or (= xH376 0) (and (= xH376 4485) (>= xH115 4485)) (and (= xH376 xH115) (<= xH115 4485))) (or (= xH377 0) (and (= xH377 4485) (>= xH116 4485)) (and (= xH377 xH116) (<= xH116 4485))) (or (= xH378 0) (and (= xH378 4485) (>= xH117 4485)) (and (= xH378 xH117) (<= xH117 4485))) (or (= xH379 0) (and (= xH379 4485) (>= xH118 4485)) (and (= xH379 xH118) (<= xH118 4485))) (or (= xH380 0) (and (= xH380 4485) (>= xH119 4485)) (and (= xH380 xH119) (<= xH119 4485))) (or (= xH381 0) (and (= xH381 4485) (>= xH120 4485)) (and (= xH381 xH120) (<= xH120 4485))) (or (= xH382 0) (and (= xH382 4485) (>= xH121 4485)) (and (= xH382 xH121) (<= xH121 4485))) (or (= xH383 0) (and (= xH383 4485) (>= xH122 4485)) (and (= xH383 xH122) (<= xH122 4485))) (or (= xH384 0) (and (= xH384 4485) (>= xH123 4485)) (and (= xH384 xH123) (<= xH123 4485))) (or (= xH385 0) (and (= xH385 4485) (>= xH124 4485)) (and (= xH385 xH124) (<= xH124 4485))) (or (= xH386 0) (and (= xH386 4485) (>= xH125 4485)) (and (= xH386 xH125) (<= xH125 4485))) (or (= xH387 0) (and (= xH387 4485) (>= xH126 4485)) (and (= xH387 xH126) (<= xH126 4485))) (or (= xH388 0) (and (= xH388 4485) (>= xH127 4485)) (and (= xH388 xH127) (<= xH127 4485))) (or (= xH389 0) (and (= xH389 4485) (>= xH128 4485)) (and (= xH389 xH128) (<= xH128 4485))) (or (= xH390 0) (and (= xH390 4485) (>= xH129 4485)) (and (= xH390 xH129) (<= xH129 4485))) (= xH391 0) (or (= xH392 0) (and (= xH392 942) (>= xH131 942)) (and (= xH392 xH131) (<= xH131 942))) (or (= xH393 0) (and (= xH393 942) (>= xH132 942)) (and (= xH393 xH132) (<= xH132 942))) (or (= xH394 0) (and (= xH394 942) (>= xH133 942)) (and (= xH394 xH133) (<= xH133 942))) (or (= xH395 0) (and (= xH395 942) (>= xH134 942)) (and (= xH395 xH134) (<= xH134 942))) (or (= xH396 0) (and (= xH396 942) (>= xH135 942)) (and (= xH396 xH135) (<= xH135 942))) (or (= xH397 0) (and (= xH397 942) (>= xH136 942)) (and (= xH397 xH136) (<= xH136 942))) (or (= xH398 0) (and (= xH398 942) (>= xH137 942)) (and (= xH398 xH137) (<= xH137 942))) (or (= xH399 0) (and (= xH399 942) (>= xH138 942)) (and (= xH399 xH138) (<= xH138 942))) (or (= xH400 0) (and (= xH400 942) (>= xH139 942)) (and (= xH400 xH139) (<= xH139 942))) (or (= xH401 0) (and (= xH401 942) (>= xH140 942)) (and (= xH401 xH140) (<= xH140 942))) (or (= xH402 0) (and (= xH402 942) (>= xH141 942)) (and (= xH402 xH141) (<= xH141 942))) (or (= xH403 0) (and (= xH403 942) (>= xH142 942)) (and (= xH403 xH142) (<= xH142 942))) (or (= xH404 0) (and (= xH404 942) (>= xH143 942)) (and (= xH404 xH143) (<= xH143 942))) (or (= xH405 0) (and (= xH405 942) (>= xH144 942)) (and (= xH405 xH144) (<= xH144 942))) (or (= xH406 0) (and (= xH406 942) (>= xH145 942)) (and (= xH406 xH145) (<= xH145 942))) (or (= xH407 0) (and (= xH407 942) (>= xH146 942)) (and (= xH407 xH146) (<= xH146 942))) (or (= xH408 0) (and (= xH408 942) (>= xH147 942)) (and (= xH408 xH147) (<= xH147 942))) (or (= xH409 0) (and (= xH409 942) (>= xH148 942)) (and (= xH409 xH148) (<= xH148 942))) (or (= xH410 0) (and (= xH410 942) (>= xH149 942)) (and (= xH410 xH149) (<= xH149 942))) (or (= xH411 0) (and (= xH411 942) (>= xH150 942)) (and (= xH411 xH150) (<= xH150 942))) (or (= xH412 0) (and (= xH412 942) (>= xH151 942)) (and (= xH412 xH151) (<= xH151 942))) (or (= xH413 0) (and (= xH413 942) (>= xH152 942)) (and (= xH413 xH152) (<= xH152 942))) (or (= xH414 0) (and (= xH414 942) (>= xH153 942)) (and (= xH414 xH153) (<= xH153 942))) (or (= xH415 0) (and (= xH415 942) (>= xH154 942)) (and (= xH415 xH154) (<= xH154 942))) (or (= xH416 0) (and (= xH416 942) (>= xH155 942)) (and (= xH416 xH155) (<= xH155 942))) (= xH417 0) (or (= xH418 0) (and (= xH418 4214) (>= xH157 4214)) (and (= xH418 xH157) (<= xH157 4214))) (or (= xH419 0) (and (= xH419 4214) (>= xH158 4214)) (and (= xH419 xH158) (<= xH158 4214))) (or (= xH420 0) (and (= xH420 4214) (>= xH159 4214)) (and (= xH420 xH159) (<= xH159 4214))) (or (= xH421 0) (and (= xH421 4214) (>= xH160 4214)) (and (= xH421 xH160) (<= xH160 4214))) (or (= xH422 0) (and (= xH422 4214) (>= xH161 4214)) (and (= xH422 xH161) (<= xH161 4214))) (or (= xH423 0) (and (= xH423 4214) (>= xH162 4214)) (and (= xH423 xH162) (<= xH162 4214))) (or (= xH424 0) (and (= xH424 4214) (>= xH163 4214)) (and (= xH424 xH163) (<= xH163 4214))) (or (= xH425 0) (and (= xH425 4214) (>= xH164 4214)) (and (= xH425 xH164) (<= xH164 4214))) (or (= xH426 0) (and (= xH426 4214) (>= xH165 4214)) (and (= xH426 xH165) (<= xH165 4214))) (or (= xH427 0) (and (= xH427 4214) (>= xH166 4214)) (and (= xH427 xH166) (<= xH166 4214))) (or (= xH428 0) (and (= xH428 4214) (>= xH167 4214)) (and (= xH428 xH167) (<= xH167 4214))) (or (= xH429 0) (and (= xH429 4214) (>= xH168 4214)) (and (= xH429 xH168) (<= xH168 4214))) (or (= xH430 0) (and (= xH430 4214) (>= xH169 4214)) (and (= xH430 xH169) (<= xH169 4214))) (or (= xH431 0) (and (= xH431 4214) (>= xH170 4214)) (and (= xH431 xH170) (<= xH170 4214))) (or (= xH432 0) (and (= xH432 4214) (>= xH171 4214)) (and (= xH432 xH171) (<= xH171 4214))) (or (= xH433 0) (and (= xH433 4214) (>= xH172 4214)) (and (= xH433 xH172) (<= xH172 4214))) (or (= xH434 0) (and (= xH434 4214) (>= xH173 4214)) (and (= xH434 xH173) (<= xH173 4214))) (or (= xH435 0) (and (= xH435 4214) (>= xH174 4214)) (and (= xH435 xH174) (<= xH174 4214))) (or (= xH436 0) (and (= xH436 4214) (>= xH175 4214)) (and (= xH436 xH175) (<= xH175 4214))) (or (= xH437 0) (and (= xH437 4214) (>= xH176 4214)) (and (= xH437 xH176) (<= xH176 4214))) (or (= xH438 0) (and (= xH438 4214) (>= xH177 4214)) (and (= xH438 xH177) (<= xH177 4214))) (or (= xH439 0) (and (= xH439 4214) (>= xH178 4214)) (and (= xH439 xH178) (<= xH178 4214))) (or (= xH440 0) (and (= xH440 4214) (>= xH179 4214)) (and (= xH440 xH179) (<= xH179 4214))) (or (= xH441 0) (and (= xH441 4214) (>= xH180 4214)) (and (= xH441 xH180) (<= xH180 4214))) (or (= xH442 0) (and (= xH442 4214) (>= xH181 4214)) (and (= xH442 xH181) (<= xH181 4214))) (= xH443 0) (or (= xH444 0) (and (= xH444 864) (>= xH183 864)) (and (= xH444 xH183) (<= xH183 864))) (or (= xH445 0) (and (= xH445 864) (>= xH184 864)) (and (= xH445 xH184) (<= xH184 864))) (or (= xH446 0) (and (= xH446 864) (>= xH185 864)) (and (= xH446 xH185) (<= xH185 864))) (or (= xH447 0) (and (= xH447 864) (>= xH186 864)) (and (= xH447 xH186) (<= xH186 864))) (or (= xH448 0) (and (= xH448 864) (>= xH187 864)) (and (= xH448 xH187) (<= xH187 864))) (or (= xH449 0) (and (= xH449 864) (>= xH188 864)) (and (= xH449 xH188) (<= xH188 864))) (or (= xH450 0) (and (= xH450 864) (>= xH189 864)) (and (= xH450 xH189) (<= xH189 864))) (or (= xH451 0) (and (= xH451 864) (>= xH190 864)) (and (= xH451 xH190) (<= xH190 864))) (or (= xH452 0) (and (= xH452 864) (>= xH191 864)) (and (= xH452 xH191) (<= xH191 864))) (or (= xH453 0) (and (= xH453 864) (>= xH192 864)) (and (= xH453 xH192) (<= xH192 864))) (or (= xH454 0) (and (= xH454 864) (>= xH193 864)) (and (= xH454 xH193) (<= xH193 864))) (or (= xH455 0) (and (= xH455 864) (>= xH194 864)) (and (= xH455 xH194) (<= xH194 864))) (or (= xH456 0) (and (= xH456 864) (>= xH195 864)) (and (= xH456 xH195) (<= xH195 864))) (or (= xH457 0) (and (= xH457 864) (>= xH196 864)) (and (= xH457 xH196) (<= xH196 864))) (or (= xH458 0) (and (= xH458 864) (>= xH197 864)) (and (= xH458 xH197) (<= xH197 864))) (or (= xH459 0) (and (= xH459 864) (>= xH198 864)) (and (= xH459 xH198) (<= xH198 864))) (or (= xH460 0) (and (= xH460 864) (>= xH199 864)) (and (= xH460 xH199) (<= xH199 864))) (or (= xH461 0) (and (= xH461 864) (>= xH200 864)) (and (= xH461 xH200) (<= xH200 864))) (or (= xH462 0) (and (= xH462 864) (>= xH201 864)) (and (= xH462 xH201) (<= xH201 864))) (or (= xH463 0) (and (= xH463 864) (>= xH202 864)) (and (= xH463 xH202) (<= xH202 864))) (or (= xH464 0) (and (= xH464 864) (>= xH203 864)) (and (= xH464 xH203) (<= xH203 864))) (or (= xH465 0) (and (= xH465 864) (>= xH204 864)) (and (= xH465 xH204) (<= xH204 864))) (or (= xH466 0) (and (= xH466 864) (>= xH205 864)) (and (= xH466 xH205) (<= xH205 864))) (or (= xH467 0) (and (= xH467 864) (>= xH206 864)) (and (= xH467 xH206) (<= xH206 864))) (or (= xH468 0) (and (= xH468 864) (>= xH207 864)) (and (= xH468 xH207) (<= xH207 864))) (= xH469 0) (or (= xH470 0) (and (= xH470 1453) (>= xH209 1453)) (and (= xH470 xH209) (<= xH209 1453))) (or (= xH471 0) (and (= xH471 1453) (>= xH210 1453)) (and (= xH471 xH210) (<= xH210 1453))) (or (= xH472 0) (and (= xH472 1453) (>= xH211 1453)) (and (= xH472 xH211) (<= xH211 1453))) (or (= xH473 0) (and (= xH473 1453) (>= xH212 1453)) (and (= xH473 xH212) (<= xH212 1453))) (or (= xH474 0) (and (= xH474 1453) (>= xH213 1453)) (and (= xH474 xH213) (<= xH213 1453))) (or (= xH475 0) (and (= xH475 1453) (>= xH214 1453)) (and (= xH475 xH214) (<= xH214 1453))) (or (= xH476 0) (and (= xH476 1453) (>= xH215 1453)) (and (= xH476 xH215) (<= xH215 1453))) (or (= xH477 0) (and (= xH477 1453) (>= xH216 1453)) (and (= xH477 xH216) (<= xH216 1453))) (or (= xH478 0) (and (= xH478 1453) (>= xH217 1453)) (and (= xH478 xH217) (<= xH217 1453))) (or (= xH479 0) (and (= xH479 1453) (>= xH218 1453)) (and (= xH479 xH218) (<= xH218 1453))) (or (= xH480 0) (and (= xH480 1453) (>= xH219 1453)) (and (= xH480 xH219) (<= xH219 1453))) (or (= xH481 0) (and (= xH481 1453) (>= xH220 1453)) (and (= xH481 xH220) (<= xH220 1453))) (or (= xH482 0) (and (= xH482 1453) (>= xH221 1453)) (and (= xH482 xH221) (<= xH221 1453))) (or (= xH483 0) (and (= xH483 1453) (>= xH222 1453)) (and (= xH483 xH222) (<= xH222 1453))) (or (= xH484 0) (and (= xH484 1453) (>= xH223 1453)) (and (= xH484 xH223) (<= xH223 1453))) (or (= xH485 0) (and (= xH485 1453) (>= xH224 1453)) (and (= xH485 xH224) (<= xH224 1453))) (or (= xH486 0) (and (= xH486 1453) (>= xH225 1453)) (and (= xH486 xH225) (<= xH225 1453))) (or (= xH487 0) (and (= xH487 1453) (>= xH226 1453)) (and (= xH487 xH226) (<= xH226 1453))) (or (= xH488 0) (and (= xH488 1453) (>= xH227 1453)) (and (= xH488 xH227) (<= xH227 1453))) (or (= xH489 0) (and (= xH489 1453) (>= xH228 1453)) (and (= xH489 xH228) (<= xH228 1453))) (or (= xH490 0) (and (= xH490 1453) (>= xH229 1453)) (and (= xH490 xH229) (<= xH229 1453))) (or (= xH491 0) (and (= xH491 1453) (>= xH230 1453)) (and (= xH491 xH230) (<= xH230 1453))) (or (= xH492 0) (and (= xH492 1453) (>= xH231 1453)) (and (= xH492 xH231) (<= xH231 1453))) (or (= xH493 0) (and (= xH493 1453) (>= xH232 1453)) (and (= xH493 xH232) (<= xH232 1453))) (or (= xH494 0) (and (= xH494 1453) (>= xH233 1453)) (and (= xH494 xH233) (<= xH233 1453))) (= xH495 0) (or (= xH496 0) (and (= xH496 4759) (>= xH235 4759)) (and (= xH496 xH235) (<= xH235 4759))) (or (= xH497 0) (and (= xH497 4759) (>= xH236 4759)) (and (= xH497 xH236) (<= xH236 4759))) (or (= xH498 0) (and (= xH498 4759) (>= xH237 4759)) (and (= xH498 xH237) (<= xH237 4759))) (or (= xH499 0) (and (= xH499 4759) (>= xH238 4759)) (and (= xH499 xH238) (<= xH238 4759))) (or (= xH500 0) (and (= xH500 4759) (>= xH239 4759)) (and (= xH500 xH239) (<= xH239 4759))) (or (= xH501 0) (and (= xH501 4759) (>= xH240 4759)) (and (= xH501 xH240) (<= xH240 4759))) (or (= xH502 0) (and (= xH502 4759) (>= xH241 4759)) (and (= xH502 xH241) (<= xH241 4759))) (or (= xH503 0) (and (= xH503 4759) (>= xH242 4759)) (and (= xH503 xH242) (<= xH242 4759))) (or (= xH504 0) (and (= xH504 4759) (>= xH243 4759)) (and (= xH504 xH243) (<= xH243 4759))) (or (= xH505 0) (and (= xH505 4759) (>= xH244 4759)) (and (= xH505 xH244) (<= xH244 4759))) (or (= xH506 0) (and (= xH506 4759) (>= xH245 4759)) (and (= xH506 xH245) (<= xH245 4759))) (or (= xH507 0) (and (= xH507 4759) (>= xH246 4759)) (and (= xH507 xH246) (<= xH246 4759))) (or (= xH508 0) (and (= xH508 4759) (>= xH247 4759)) (and (= xH508 xH247) (<= xH247 4759))) (or (= xH509 0) (and (= xH509 4759) (>= xH248 4759)) (and (= xH509 xH248) (<= xH248 4759))) (or (= xH510 0) (and (= xH510 4759) (>= xH249 4759)) (and (= xH510 xH249) (<= xH249 4759))) (or (= xH511 0) (and (= xH511 4759) (>= xH250 4759)) (and (= xH511 xH250) (<= xH250 4759))) (or (= xH512 0) (and (= xH512 4759) (>= xH251 4759)) (and (= xH512 xH251) (<= xH251 4759))) (or (= xH513 0) (and (= xH513 4759) (>= xH252 4759)) (and (= xH513 xH252) (<= xH252 4759))) (or (= xH514 0) (and (= xH514 4759) (>= xH253 4759)) (and (= xH514 xH253) (<= xH253 4759))) (or (= xH515 0) (and (= xH515 4759) (>= xH254 4759)) (and (= xH515 xH254) (<= xH254 4759))) (or (= xH516 0) (and (= xH516 4759) (>= xH255 4759)) (and (= xH516 xH255) (<= xH255 4759))) (or (= xH517 0) (and (= xH517 4759) (>= xH256 4759)) (and (= xH517 xH256) (<= xH256 4759))) (or (= xH518 0) (and (= xH518 4759) (>= xH257 4759)) (and (= xH518 xH257) (<= xH257 4759))) (or (= xH519 0) (and (= xH519 4759) (>= xH258 4759)) (and (= xH519 xH258) (<= xH258 4759))) (or (= xH520 0) (and (= xH520 4759) (>= xH259 4759)) (and (= xH520 xH259) (<= xH259 4759))) (<= (+ xH521 xH547 xH573 xH599 xH625 xH651 xH677 xH703 xH729 xH755 xH261 xH287 xH313 xH339 xH365 xH391 xH417 xH443 xH469 xH495) 10100) (<= (+ xH522 xH548 xH574 xH600 xH626 xH652 xH678 xH704 xH730 xH756 xH262 xH288 xH314 xH340 xH366 xH392 xH418 xH444 xH470 xH496) 10100) (<= (+ xH523 xH549 xH575 xH601 xH627 xH653 xH679 xH705 xH731 xH757 xH263 xH289 xH315 xH341 xH367 xH393 xH419 xH445 xH471 xH497) 10100) (<= (+ xH524 xH550 xH576 xH602 xH628 xH654 xH680 xH706 xH732 xH758 xH264 xH290 xH316 xH342 xH368 xH394 xH420 xH446 xH472 xH498) 10100) (<= (+ xH525 xH551 xH577 xH603 xH629 xH655 xH681 xH707 xH733 xH759 xH265 xH291 xH317 xH343 xH369 xH395 xH421 xH447 xH473 xH499) 10100) (<= (+ xH526 xH552 xH578 xH604 xH630 xH656 xH682 xH708 xH734 xH760 xH266 xH292 xH318 xH344 xH370 xH396 xH422 xH448 xH474 xH500) 10100) (<= (+ xH527 xH553 xH579 xH605 xH631 xH657 xH683 xH709 xH735 xH761 xH267 xH293 xH319 xH345 xH371 xH397 xH423 xH449 xH475 xH501) 10100) (<= (+ xH528 xH554 xH580 xH606 xH632 xH658 xH684 xH710 xH736 xH762 xH268 xH294 xH320 xH346 xH372 xH398 xH424 xH450 xH476 xH502) 10100) (<= (+ xH529 xH555 xH581 xH607 xH633 xH659 xH685 xH711 xH737 xH763 xH269 xH295 xH321 xH347 xH373 xH399 xH425 xH451 xH477 xH503) 10100) (<= (+ xH530 xH556 xH582 xH608 xH634 xH660 xH686 xH712 xH738 xH764 xH270 xH296 xH322 xH348 xH374 xH400 xH426 xH452 xH478 xH504) 10100) (<= (+ xH531 xH557 xH583 xH609 xH635 xH661 xH687 xH713 xH739 xH765 xH271 xH297 xH323 xH349 xH375 xH401 xH427 xH453 xH479 xH505) 10100) (<= (+ xH532 xH558 xH584 xH610 xH636 xH662 xH688 xH714 xH740 xH766 xH272 xH298 xH324 xH350 xH376 xH402 xH428 xH454 xH480 xH506) 10100) (<= (+ xH533 xH559 xH585 xH611 xH637 xH663 xH689 xH715 xH741 xH767 xH273 xH299 xH325 xH351 xH377 xH403 xH429 xH455 xH481 xH507) 10100) (<= (+ xH534 xH560 xH586 xH612 xH638 xH664 xH690 xH716 xH742 xH768 xH274 xH300 xH326 xH352 xH378 xH404 xH430 xH456 xH482 xH508) 10100) (<= (+ xH535 xH561 xH587 xH613 xH639 xH665 xH691 xH717 xH743 xH769 xH275 xH301 xH327 xH353 xH379 xH405 xH431 xH457 xH483 xH509) 10100) (<= (+ xH536 xH562 xH588 xH614 xH640 xH666 xH692 xH718 xH744 xH770 xH276 xH302 xH328 xH354 xH380 xH406 xH432 xH458 xH484 xH510) 10100) (<= (+ xH537 xH563 xH589 xH615 xH641 xH667 xH693 xH719 xH745 xH771 xH277 xH303 xH329 xH355 xH381 xH407 xH433 xH459 xH485 xH511) 10100) (<= (+ xH538 xH564 xH590 xH616 xH642 xH668 xH694 xH720 xH746 xH772 xH278 xH304 xH330 xH356 xH382 xH408 xH434 xH460 xH486 xH512) 10100) (<= (+ xH539 xH565 xH591 xH617 xH643 xH669 xH695 xH721 xH747 xH773 xH279 xH305 xH331 xH357 xH383 xH409 xH435 xH461 xH487 xH513) 10100) (<= (+ xH540 xH566 xH592 xH618 xH644 xH670 xH696 xH722 xH748 xH774 xH280 xH306 xH332 xH358 xH384 xH410 xH436 xH462 xH488 xH514) 10100) (<= (+ xH541 xH567 xH593 xH619 xH645 xH671 xH697 xH723 xH749 xH775 xH281 xH307 xH333 xH359 xH385 xH411 xH437 xH463 xH489 xH515) 10100) (<= (+ xH542 xH568 xH594 xH620 xH646 xH672 xH698 xH724 xH750 xH776 xH282 xH308 xH334 xH360 xH386 xH412 xH438 xH464 xH490 xH516) 10100) (<= (+ xH543 xH569 xH595 xH621 xH647 xH673 xH699 xH725 xH751 xH777 xH283 xH309 xH335 xH361 xH387 xH413 xH439 xH465 xH491 xH517) 10100) (<= (+ xH544 xH570 xH596 xH622 xH648 xH674 xH700 xH726 xH752 xH778 xH284 xH310 xH336 xH362 xH388 xH414 xH440 xH466 xH492 xH518) 10100) (<= (+ xH545 xH571 xH597 xH623 xH649 xH675 xH701 xH727 xH753 xH779 xH285 xH311 xH337 xH363 xH389 xH415 xH441 xH467 xH493 xH519) 10100) (<= (+ xH546 xH572 xH598 xH624 xH650 xH676 xH702 xH728 xH754 xH780 xH286 xH312 xH338 xH364 xH390 xH416 xH442 xH468 xH494 xH520) 10100) (<= 0 xH261) (<= xH261 2477) (<= 0 xH262) (<= xH262 2477) (<= 0 xH263) (<= xH263 2477) (<= 0 xH264) (<= xH264 2477) (<= 0 xH265) (<= xH265 2477) (<= 0 xH266) (<= xH266 2477) (<= 0 xH267) (<= xH267 2477) (<= 0 xH268) (<= xH268 2477) (<= 0 xH269) (<= xH269 2477) (<= 0 xH270) (<= xH270 2477) (<= 0 xH271) (<= xH271 2477) (<= 0 xH272) (<= xH272 2477) (<= 0 xH273) (<= xH273 2477) (<= 0 xH274) (<= xH274 2477) (<= 0 xH275) (<= xH275 2477) (<= 0 xH276) (<= xH276 2477) (<= 0 xH277) (<= xH277 2477) (<= 0 xH278) (<= xH278 2477) (<= 0 xH279) (<= xH279 2477) (<= 0 xH280) (<= xH280 2477) (<= 0 xH281) (<= xH281 2477) (<= 0 xH282) (<= xH282 2477) (<= 0 xH283) (<= xH283 2477) (<= 0 xH284) (<= xH284 2477) (<= 0 xH285) (<= xH285 2477) (<= 0 xH286) (<= xH286 2477) (<= 0 xH287) (<= xH287 4957) (<= 0 xH288) (<= xH288 4957) (<= 0 xH289) (<= xH289 4957) (<= 0 xH290) (<= xH290 4957) (<= 0 xH291) (<= xH291 4957) (<= 0 xH292) (<= xH292 4957) (<= 0 xH293) (<= xH293 4957) (<= 0 xH294) (<= xH294 4957) (<= 0 xH295) (<= xH295 4957) (<= 0 xH296) (<= xH296 4957) (<= 0 xH297) (<= xH297 4957) (<= 0 xH298) (<= xH298 4957) (<= 0 xH299) (<= xH299 4957) (<= 0 xH300) (<= xH300 4957) (<= 0 xH301) (<= xH301 4957) (<= 0 xH302) (<= xH302 4957) (<= 0 xH303) (<= xH303 4957) (<= 0 xH304) (<= xH304 4957) (<= 0 xH305) (<= xH305 4957) (<= 0 xH306) (<= xH306 4957) (<= 0 xH307) (<= xH307 4957) (<= 0 xH308) (<= xH308 4957) (<= 0 xH309) (<= xH309 4957) (<= 0 xH310) (<= xH310 4957) (<= 0 xH311) (<= xH311 4957) (<= 0 xH312) (<= xH312 4957) (<= 0 xH313) (<= xH313 1244) (<= 0 xH314) (<= xH314 1244) (<= 0 xH315) (<= xH315 1244) (<= 0 xH316) (<= xH316 1244) (<= 0 xH317) (<= xH317 1244) (<= 0 xH318) (<= xH318 1244) (<= 0 xH319) (<= xH319 1244) (<= 0 xH320) (<= xH320 1244) (<= 0 xH321) (<= xH321 1244) (<= 0 xH322) (<= xH322 1244) (<= 0 xH323) (<= xH323 1244) (<= 0 xH324) (<= xH324 1244) (<= 0 xH325) (<= xH325 1244) (<= 0 xH326) (<= xH326 1244) (<= 0 xH327) (<= xH327 1244) (<= 0 xH328) (<= xH328 1244) (<= 0 xH329) (<= xH329 1244) (<= 0 xH330) (<= xH330 1244) (<= 0 xH331) (<= xH331 1244) (<= 0 xH332) (<= xH332 1244) (<= 0 xH333) (<= xH333 1244) (<= 0 xH334) (<= xH334 1244) (<= 0 xH335) (<= xH335 1244) (<= 0 xH336) (<= xH336 1244) (<= 0 xH337) (<= xH337 1244) (<= 0 xH338) (<= xH338 1244) (<= 0 xH339) (<= xH339 547) (<= 0 xH340) (<= xH340 547) (<= 0 xH341) (<= xH341 547) (<= 0 xH342) (<= xH342 547) (<= 0 xH343) (<= xH343 547) (<= 0 xH344) (<= xH344 547) (<= 0 xH345) (<= xH345 547) (<= 0 xH346) (<= xH346 547) (<= 0 xH347) (<= xH347 547) (<= 0 xH348) (<= xH348 547) (<= 0 xH349) (<= xH349 547) (<= 0 xH350) (<= xH350 547) (<= 0 xH351) (<= xH351 547) (<= 0 xH352) (<= xH352 547) (<= 0 xH353) (<= xH353 547) (<= 0 xH354) (<= xH354 547) (<= 0 xH355) (<= xH355 547) (<= 0 xH356) (<= xH356 547) (<= 0 xH357) (<= xH357 547) (<= 0 xH358) (<= xH358 547) (<= 0 xH359) (<= xH359 547) (<= 0 xH360) (<= xH360 547) (<= 0 xH361) (<= xH361 547) (<= 0 xH362) (<= xH362 547) (<= 0 xH363) (<= xH363 547) (<= 0 xH364) (<= xH364 547) (<= 0 xH365) (<= xH365 4485) (<= 0 xH366) (<= xH366 4485) (<= 0 xH367) (<= xH367 4485) (<= 0 xH368) (<= xH368 4485) (<= 0 xH369) (<= xH369 4485) (<= 0 xH370) (<= xH370 4485) (<= 0 xH371) (<= xH371 4485) (<= 0 xH372) (<= xH372 4485) (<= 0 xH373) (<= xH373 4485) (<= 0 xH374) (<= xH374 4485) (<= 0 xH375) (<= xH375 4485) (<= 0 xH376) (<= xH376 4485) (<= 0 xH377) (<= xH377 4485) (<= 0 xH378) (<= xH378 4485) (<= 0 xH379) (<= xH379 4485) (<= 0 xH380) (<= xH380 4485) (<= 0 xH381) (<= xH381 4485) (<= 0 xH382) (<= xH382 4485) (<= 0 xH383) (<= xH383 4485) (<= 0 xH384) (<= xH384 4485) (<= 0 xH385) (<= xH385 4485) (<= 0 xH386) (<= xH386 4485) (<= 0 xH387) (<= xH387 4485) (<= 0 xH388) (<= xH388 4485) (<= 0 xH389) (<= xH389 4485) (<= 0 xH390) (<= xH390 4485) (<= 0 xH391) (<= xH391 942) (<= 0 xH392) (<= xH392 942) (<= 0 xH393) (<= xH393 942) (<= 0 xH394) (<= xH394 942) (<= 0 xH395) (<= xH395 942) (<= 0 xH396) (<= xH396 942) (<= 0 xH397) (<= xH397 942) (<= 0 xH398) (<= xH398 942) (<= 0 xH399) (<= xH399 942) (<= 0 xH400) (<= xH400 942) (<= 0 xH401) (<= xH401 942) (<= 0 xH402) (<= xH402 942) (<= 0 xH403) (<= xH403 942) (<= 0 xH404) (<= xH404 942) (<= 0 xH405) (<= xH405 942) (<= 0 xH406) (<= xH406 942) (<= 0 xH407) (<= xH407 942) (<= 0 xH408) (<= xH408 942) (<= 0 xH409) (<= xH409 942) (<= 0 xH410) (<= xH410 942) (<= 0 xH411) (<= xH411 942) (<= 0 xH412) (<= xH412 942) (<= 0 xH413) (<= xH413 942) (<= 0 xH414) (<= xH414 942) (<= 0 xH415) (<= xH415 942) (<= 0 xH416) (<= xH416 942) (<= 0 xH417) (<= xH417 4214) (<= 0 xH418) (<= xH418 4214) (<= 0 xH419) (<= xH419 4214) (<= 0 xH420) (<= xH420 4214) (<= 0 xH421) (<= xH421 4214) (<= 0 xH422) (<= xH422 4214) (<= 0 xH423) (<= xH423 4214) (<= 0 xH424) (<= xH424 4214) (<= 0 xH425) (<= xH425 4214) (<= 0 xH426) (<= xH426 4214) (<= 0 xH427) (<= xH427 4214) (<= 0 xH428) (<= xH428 4214) (<= 0 xH429) (<= xH429 4214) (<= 0 xH430) (<= xH430 4214) (<= 0 xH431) (<= xH431 4214) (<= 0 xH432) (<= xH432 4214) (<= 0 xH433) (<= xH433 4214) (<= 0 xH434) (<= xH434 4214) (<= 0 xH435) (<= xH435 4214) (<= 0 xH436) (<= xH436 4214) (<= 0 xH437) (<= xH437 4214) (<= 0 xH438) (<= xH438 4214) (<= 0 xH439) (<= xH439 4214) (<= 0 xH440) (<= xH440 4214) (<= 0 xH441) (<= xH441 4214) (<= 0 xH442) (<= xH442 4214) (<= 0 xH443) (<= xH443 864) (<= 0 xH444) (<= xH444 864) (<= 0 xH445) (<= xH445 864) (<= 0 xH446) (<= xH446 864) (<= 0 xH447) (<= xH447 864) (<= 0 xH448) (<= xH448 864) (<= 0 xH449) (<= xH449 864) (<= 0 xH450) (<= xH450 864) (<= 0 xH451) (<= xH451 864) (<= 0 xH452) (<= xH452 864) (<= 0 xH453) (<= xH453 864) (<= 0 xH454) (<= xH454 864) (<= 0 xH455) (<= xH455 864) (<= 0 xH456) (<= xH456 864) (<= 0 xH457) (<= xH457 864) (<= 0 xH458) (<= xH458 864) (<= 0 xH459) (<= xH459 864) (<= 0 xH460) (<= xH460 864) (<= 0 xH461) (<= xH461 864) (<= 0 xH462) (<= xH462 864) (<= 0 xH463) (<= xH463 864) (<= 0 xH464) (<= xH464 864) (<= 0 xH465) (<= xH465 864) (<= 0 xH466) (<= xH466 864) (<= 0 xH467) (<= xH467 864) (<= 0 xH468) (<= xH468 864) (<= 0 xH469) (<= xH469 1453) (<= 0 xH470) (<= xH470 1453) (<= 0 xH471) (<= xH471 1453) (<= 0 xH472) (<= xH472 1453) (<= 0 xH473) (<= xH473 1453) (<= 0 xH474) (<= xH474 1453) (<= 0 xH475) (<= xH475 1453) (<= 0 xH476) (<= xH476 1453) (<= 0 xH477) (<= xH477 1453) (<= 0 xH478) (<= xH478 1453) (<= 0 xH479) (<= xH479 1453) (<= 0 xH480) (<= xH480 1453) (<= 0 xH481) (<= xH481 1453) (<= 0 xH482) (<= xH482 1453) (<= 0 xH483) (<= xH483 1453) (<= 0 xH484) (<= xH484 1453) (<= 0 xH485) (<= xH485 1453) (<= 0 xH486) (<= xH486 1453) (<= 0 xH487) (<= xH487 1453) (<= 0 xH488) (<= xH488 1453) (<= 0 xH489) (<= xH489 1453) (<= 0 xH490) (<= xH490 1453) (<= 0 xH491) (<= xH491 1453) (<= 0 xH492) (<= xH492 1453) (<= 0 xH493) (<= xH493 1453) (<= 0 xH494) (<= xH494 1453) (<= 0 xH495) (<= xH495 4759) (<= 0 xH496) (<= xH496 4759) (<= 0 xH497) (<= xH497 4759) (<= 0 xH498) (<= xH498 4759) (<= 0 xH499) (<= xH499 4759) (<= 0 xH500) (<= xH500 4759) (<= 0 xH501) (<= xH501 4759) (<= 0 xH502) (<= xH502 4759) (<= 0 xH503) (<= xH503 4759) (<= 0 xH504) (<= xH504 4759) (<= 0 xH505) (<= xH505 4759) (<= 0 xH506) (<= xH506 4759) (<= 0 xH507) (<= xH507 4759) (<= 0 xH508) (<= xH508 4759) (<= 0 xH509) (<= xH509 4759) (<= 0 xH510) (<= xH510 4759) (<= 0 xH511) (<= xH511 4759) (<= 0 xH512) (<= xH512 4759) (<= 0 xH513) (<= xH513 4759) (<= 0 xH514) (<= xH514 4759) (<= 0 xH515) (<= xH515 4759) (<= 0 xH516) (<= xH516 4759) (<= 0 xH517) (<= xH517 4759) (<= 0 xH518) (<= xH518 4759) (<= 0 xH519) (<= xH519 4759) (<= 0 xH520) (<= xH520 4759) (<= xH262 xH1) (<= xH263 xH2) (<= xH264 xH3) (<= xH265 xH4) (<= xH266 xH5) (<= xH267 xH6) (<= xH268 xH7) (<= xH269 xH8) (<= xH270 xH9) (<= xH271 xH10) (<= xH272 xH11) (<= xH273 xH12) (<= xH274 xH13) (<= xH275 xH14) (<= xH276 xH15) (<= xH277 xH16) (<= xH278 xH17) (<= xH279 xH18) (<= xH280 xH19) (<= xH281 xH20) (<= xH282 xH21) (<= xH283 xH22) (<= xH284 xH23) (<= xH285 xH24) (<= xH286 xH25) (<= xH288 xH27) (<= xH289 xH28) (<= xH290 xH29) (<= xH291 xH30) (<= xH292 xH31) (<= xH293 xH32) (<= xH294 xH33) (<= xH295 xH34) (<= xH296 xH35) (<= xH297 xH36) (<= xH298 xH37) (<= xH299 xH38) (<= xH300 xH39) (<= xH301 xH40) (<= xH302 xH41) (<= xH303 xH42) (<= xH304 xH43) (<= xH305 xH44) (<= xH306 xH45) (<= xH307 xH46) (<= xH308 xH47) (<= xH309 xH48) (<= xH310 xH49) (<= xH311 xH50) (<= xH312 xH51) (<= xH314 xH53) (<= xH315 xH54) (<= xH316 xH55) (<= xH317 xH56) (<= xH318 xH57) (<= xH319 xH58) (<= xH320 xH59) (<= xH321 xH60) (<= xH322 xH61) (<= xH323 xH62) (<= xH324 xH63) (<= xH325 xH64) (<= xH326 xH65) (<= xH327 xH66) (<= xH328 xH67) (<= xH329 xH68) (<= xH330 xH69) (<= xH331 xH70) (<= xH332 xH71) (<= xH333 xH72) (<= xH334 xH73) (<= xH335 xH74) (<= xH336 xH75) (<= xH337 xH76) (<= xH338 xH77) (<= xH340 xH79) (<= xH341 xH80) (<= xH342 xH81) (<= xH343 xH82) (<= xH344 xH83) (<= xH345 xH84) (<= xH346 xH85) (<= xH347 xH86) (<= xH348 xH87) (<= xH349 xH88) (<= xH350 xH89) (<= xH351 xH90) (<= xH352 xH91) (<= xH353 xH92) (<= xH354 xH93) (<= xH355 xH94) (<= xH356 xH95) (<= xH357 xH96) (<= xH358 xH97) (<= xH359 xH98) (<= xH360 xH99) (<= xH361 xH100) (<= xH362 xH101) (<= xH363 xH102) (<= xH364 xH103) (<= xH366 xH105) (<= xH367 xH106) (<= xH368 xH107) (<= xH369 xH108) (<= xH370 xH109) (<= xH371 xH110) (<= xH372 xH111) (<= xH373 xH112) (<= xH374 xH113) (<= xH375 xH114) (<= xH376 xH115) (<= xH377 xH116) (<= xH378 xH117) (<= xH379 xH118) (<= xH380 xH119) (<= xH381 xH120) (<= xH382 xH121) (<= xH383 xH122) (<= xH384 xH123) (<= xH385 xH124) (<= xH386 xH125) (<= xH387 xH126) (<= xH388 xH127) (<= xH389 xH128) (<= xH390 xH129) (<= xH392 xH131) (<= xH393 xH132) (<= xH394 xH133) (<= xH395 xH134) (<= xH396 xH135) (<= xH397 xH136) (<= xH398 xH137) (<= xH399 xH138) (<= xH400 xH139) (<= xH401 xH140) (<= xH402 xH141) (<= xH403 xH142) (<= xH404 xH143) (<= xH405 xH144) (<= xH406 xH145) (<= xH407 xH146) (<= xH408 xH147) (<= xH409 xH148) (<= xH410 xH149) (<= xH411 xH150) (<= xH412 xH151) (<= xH413 xH152) (<= xH414 xH153) (<= xH415 xH154) (<= xH416 xH155) (<= xH418 xH157) (<= xH419 xH158) (<= xH420 xH159) (<= xH421 xH160) (<= xH422 xH161) (<= xH423 xH162) (<= xH424 xH163) (<= xH425 xH164) (<= xH426 xH165) (<= xH427 xH166) (<= xH428 xH167) (<= xH429 xH168) (<= xH430 xH169) (<= xH431 xH170) (<= xH432 xH171) (<= xH433 xH172) (<= xH434 xH173) (<= xH435 xH174) (<= xH436 xH175) (<= xH437 xH176) (<= xH438 xH177) (<= xH439 xH178) (<= xH440 xH179) (<= xH441 xH180) (<= xH442 xH181) (<= xH444 xH183) (<= xH445 xH184) (<= xH446 xH185) (<= xH447 xH186) (<= xH448 xH187) (<= xH449 xH188) (<= xH450 xH189) (<= xH451 xH190) (<= xH452 xH191) (<= xH453 xH192) (<= xH454 xH193) (<= xH455 xH194) (<= xH456 xH195) (<= xH457 xH196) (<= xH458 xH197) (<= xH459 xH198) (<= xH460 xH199) (<= xH461 xH200) (<= xH462 xH201) (<= xH463 xH202) (<= xH464 xH203) (<= xH465 xH204) (<= xH466 xH205) (<= xH467 xH206) (<= xH468 xH207) (<= xH470 xH209) (<= xH471 xH210) (<= xH472 xH211) (<= xH473 xH212) (<= xH474 xH213) (<= xH475 xH214) (<= xH476 xH215) (<= xH477 xH216) (<= xH478 xH217) (<= xH479 xH218) (<= xH480 xH219) (<= xH481 xH220) (<= xH482 xH221) (<= xH483 xH222) (<= xH484 xH223) (<= xH485 xH224) (<= xH486 xH225) (<= xH487 xH226) (<= xH488 xH227) (<= xH489 xH228) (<= xH490 xH229) (<= xH491 xH230) (<= xH492 xH231) (<= xH493 xH232) (<= xH494 xH233) (<= xH496 xH235) (<= xH497 xH236) (<= xH498 xH237) (<= xH499 xH238) (<= xH500 xH239) (<= xH501 xH240) (<= xH502 xH241) (<= xH503 xH242) (<= xH504 xH243) (<= xH505 xH244) (<= xH506 xH245) (<= xH507 xH246) (<= xH508 xH247) (<= xH509 xH248) (<= xH510 xH249) (<= xH511 xH250) (<= xH512 xH251) (<= xH513 xH252) (<= xH514 xH253) (<= xH515 xH254) (<= xH516 xH255) (<= xH517 xH256) (<= xH518 xH257) (<= xH519 xH258) (<= xH520 xH259))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LIA/can_solve/ex10100_2600_100.smt2.expected.err000066400000000000000000000000001445011647600255520ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/can_solve/ex10100_2600_100.smt2.expected.out000066400000000000000000000000061445011647600255770ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LIA/check/000077500000000000000000000000001445011647600174455ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/check/bignum_lia1.smt2000066400000000000000000000012631445011647600224450ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_LIA) (set-info :source | SMT-COMP'06 organizers |) (set-info :category "check") (set-info :status unsat) (set-info :notes |This benchmark is designed to check if the DP supports bignumbers.|) (declare-fun x1 () Int) (declare-fun x2 () Int) (declare-fun x3 () Int) (declare-fun x4 () Int) (declare-fun x5 () Int) (declare-fun x6 () Int) (assert (and (or (>= x1 1000) (>= x1 1002)) (or (>= x2 (* 1230 x1)) (>= x2 (* 1003 x1))) (or (>= x3 (* 1310 x2)) (>= x3 (* 1999 x2))) (or (>= x4 (* 4000 x3)) (>= x4 (* 8000 x3))) (or (<= x5 (* (- 4000) x4)) (<= x5 (* (- 8000) x4))) (or (>= x6 (* (- 3) x5)) (>= x6 (* (- 2) x5))) (< x6 0))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LIA/check/bignum_lia1.smt2.expected.err000066400000000000000000000000001445011647600250200ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/check/bignum_lia1.smt2.expected.out000066400000000000000000000000061445011647600250450ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LIA/check/bignum_lia2.smt2000066400000000000000000000012611445011647600224440ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_LIA) (set-info :source | SMT-COMP'06 organizers |) (set-info :category "check") (set-info :status sat) (set-info :notes |This benchmark is designed to check if the DP supports bignumbers.|) (declare-fun x1 () Int) (declare-fun x2 () Int) (declare-fun x3 () Int) (declare-fun x4 () Int) (declare-fun x5 () Int) (declare-fun x6 () Int) (assert (and (or (>= x1 1000) (>= x1 1002)) (or (>= x2 (* 1230 x1)) (>= x2 (* 1003 x1))) (or (>= x3 (* 1310 x2)) (>= x3 (* 1999 x2))) (or (>= x4 (* 4000 x3)) (>= x4 (* 8000 x3))) (or (<= x5 (* (- 4000) x4)) (<= x5 (* (- 8000) x4))) (or (>= x6 (* (- 3) x5)) (>= x6 (* (- 2) x5))) (> x6 0))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LIA/check/bignum_lia2.smt2.expected.err000066400000000000000000000000001445011647600250210ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/check/bignum_lia2.smt2.expected.out000066400000000000000000000000041445011647600250440ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LIA/check/run.sh000077500000000000000000000001171445011647600206070ustar00rootroot00000000000000for i in $(ls); do /Users/polarstar/PHD/opensmt2/build/src/bin/opensmt $i done opensmt-2.5.2/regression/QF_LIA/crafted/000077500000000000000000000000001445011647600200005ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/crafted/small-interval.smt2000066400000000000000000000001251445011647600235370ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun x () Int) (assert (and (> x 0) (< x 1))) (check-sat) opensmt-2.5.2/regression/QF_LIA/crafted/small-interval.smt2.expected.err000066400000000000000000000000001445011647600261160ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/crafted/small-interval.smt2.expected.out000066400000000000000000000000061445011647600261430ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LIA/cuts_from_proofs_1.smt2000066400000000000000000000003121445011647600230040ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun x () Int) (declare-fun y () Int) (declare-fun z () Int) (assert (and (<= y (* 2 x)) (>= y (* 2 x)))) (assert (and (<= y (+ 1 (* 2 z))) (>= y (+ 1 (* 2 z))))) (check-sat) opensmt-2.5.2/regression/QF_LIA/cuts_from_proofs_1.smt2.expected.err000066400000000000000000000000001445011647600253650ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/cuts_from_proofs_1.smt2.expected.out000066400000000000000000000000061445011647600254120ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LIA/dilling/000077500000000000000000000000001445011647600200125ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/dilling/10-15.smt2000066400000000000000000000016141445011647600212660ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_LIA) (set-info :category "industrial") (set-info :status sat) (declare-fun x0 () Int) (declare-fun x1 () Int) (declare-fun x2 () Int) (declare-fun x3 () Int) (declare-fun x4 () Int) (declare-fun x5 () Int) (declare-fun x6 () Int) (declare-fun x7 () Int) (declare-fun x8 () Int) (declare-fun x9 () Int) (assert (let ((?v_0 (* 0 x6)) (?v_5 (* 1 x4)) (?v_1 (* 1 x8)) (?v_7 (* 1 x5)) (?v_2 (* 0 x7)) (?v_4 (* 1 x2)) (?v_6 (* 1 x0)) (?v_3 (* (- 1) x8))) (and (<= (+ (* (- 1) x0) (+ (* 0 x1) (+ ?v_0 (+ ?v_5 ?v_1)))) 0) (<= (+ (* (- 1) x1) (+ (* (- 1) x3) (+ (* (- 1) x4) (+ ?v_7 (+ ?v_2 (+ ?v_3 (+ (* (- 1) x9) ?v_4))))))) 0) (<= (+ (* 1 x1) (+ (* 0 x3) (+ (* (- 1) x7) (+ (* 0 x4) (+ (* 0 x5) (+ ?v_0 ?v_1)))))) (- 1)) (<= (+ ?v_2 (+ ?v_3 (+ ?v_6 (+ ?v_4 (+ (* 1 x3) ?v_5))))) 0) (<= (+ ?v_6 (+ (* (- 1) x2) (+ ?v_7 (+ (* 2 x6) (* 0 x8))))) 1)))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LIA/dilling/10-15.smt2.expected.err000066400000000000000000000000001445011647600236410ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/dilling/10-15.smt2.expected.out000066400000000000000000000000041445011647600236640ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LIA/dilling/10-21.smt2000066400000000000000000000025411445011647600212630ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_LIA) (set-info :category "industrial") (set-info :status sat) (declare-fun x0 () Int) (declare-fun x1 () Int) (declare-fun x2 () Int) (declare-fun x3 () Int) (declare-fun x4 () Int) (declare-fun x5 () Int) (declare-fun x6 () Int) (declare-fun x7 () Int) (declare-fun x8 () Int) (declare-fun x9 () Int) (assert (let ((?v_5 (* 0 x1)) (?v_7 (* 1 x2)) (?v_1 (* 1 x4)) (?v_2 (* 1 x6)) (?v_6 (* 0 x7)) (?v_3 (* 0 x8)) (?v_15 (* 0 x2)) (?v_19 (* 1 x8)) (?v_9 (* 0 x3)) (?v_18 (* 1 x9)) (?v_12 (* 0 x0)) (?v_13 (* 0 x9)) (?v_17 (* 1 x5)) (?v_16 (* 1 x0)) (?v_0 (* (- 1) x0)) (?v_4 (* (- 1) x5)) (?v_8 (* (- 1) x2)) (?v_10 (* (- 1) x4)) (?v_14 (* (- 1) x3)) (?v_11 (* (- 1) x6))) (and (<= (+ ?v_0 (+ ?v_5 (+ ?v_7 (+ ?v_1 (+ (* 0 x5) (+ ?v_2 (+ ?v_6 ?v_3))))))) 1) (<= (+ ?v_0 (+ ?v_15 (+ ?v_1 (+ ?v_4 (+ (* 0 x6) ?v_19))))) 0) (<= (+ ?v_8 (+ ?v_9 (+ ?v_2 (+ ?v_3 ?v_18)))) 0) (<= (+ (* (- 2) x2) (+ (* 1 x3) (+ ?v_10 (+ ?v_4 (+ ?v_2 ?v_3))))) (- 1)) (<= (+ ?v_14 (+ ?v_4 (+ ?v_11 (+ ?v_12 (+ ?v_5 (+ ?v_6 (+ ?v_13 ?v_7))))))) 0) (<= (+ ?v_8 (+ ?v_9 (+ ?v_10 (+ ?v_11 (+ (* (- 1) x9) (+ ?v_12 (+ (* 1 x1) ?v_17))))))) 0) (<= (+ (* (- 1) x7) (+ ?v_16 (+ ?v_5 (+ ?v_9 (+ ?v_3 ?v_13))))) (- 1)) (<= (+ ?v_14 (+ ?v_15 (+ ?v_6 (+ ?v_16 (+ ?v_17 ?v_18))))) 1) (<= (+ ?v_11 (+ (* 0 x4) (+ ?v_6 (+ ?v_13 (+ ?v_17 ?v_19))))) 0)))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LIA/dilling/10-21.smt2.expected.err000066400000000000000000000000001445011647600236360ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/dilling/10-21.smt2.expected.out000066400000000000000000000000041445011647600236610ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LIA/dilling/10-28.smt2000066400000000000000000000027371445011647600213010ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_LIA) (set-info :category "industrial") (set-info :status sat) (declare-fun x0 () Int) (declare-fun x1 () Int) (declare-fun x2 () Int) (declare-fun x3 () Int) (declare-fun x4 () Int) (declare-fun x5 () Int) (declare-fun x6 () Int) (declare-fun x7 () Int) (declare-fun x8 () Int) (declare-fun x9 () Int) (assert (let ((?v_1 (* 0 x1)) (?v_6 (* 0 x4)) (?v_3 (* 1 x6)) (?v_8 (* 0 x9)) (?v_2 (* 0 x2)) (?v_5 (* 0 x3)) (?v_7 (* 0 x6)) (?v_4 (* 1 x8)) (?v_13 (* 1 x9)) (?v_14 (* 0 x5)) (?v_12 (* 0 x0)) (?v_16 (* 1 x1)) (?v_15 (* 0 x7)) (?v_19 (* 1 x0)) (?v_0 (* (- 1) x0)) (?v_9 (* (- 1) x3)) (?v_10 (* (- 1) x4)) (?v_11 (* (- 1) x5)) (?v_18 (* (- 1) x7)) (?v_17 (* (- 1) x6))) (and (<= (+ ?v_0 (+ (* (- 1) x2) (+ ?v_1 (+ ?v_9 (+ ?v_6 (+ ?v_3 ?v_8)))))) (- 1)) (<= (+ (* (- 2) x1) (+ ?v_0 (+ ?v_2 (+ ?v_5 (+ ?v_7 (+ ?v_4 (+ (* 2 x4) ?v_13))))))) 0) (<= (+ ?v_0 (+ ?v_1 (+ ?v_2 (+ ?v_10 (+ ?v_14 (+ ?v_3 (+ ?v_4 (* (- 1) x9)))))))) 1) (<= (+ (* (- 1) x1) (+ ?v_5 (+ ?v_6 (+ ?v_11 (+ ?v_7 (+ (* 1 x7) ?v_8)))))) 0) (<= (+ ?v_18 (+ (* (- 1) x8) (+ ?v_12 (+ (* 1 x2) (+ ?v_5 (+ ?v_6 ?v_8)))))) 0) (<= (+ ?v_9 (+ ?v_10 (+ ?v_11 (+ ?v_12 (+ ?v_16 (+ ?v_15 (+ ?v_4 ?v_13))))))) 0) (<= (+ ?v_1 (+ ?v_2 (+ ?v_5 (+ ?v_3 (* 3 x9))))) (- 1)) (<= (+ ?v_17 (+ ?v_1 (+ ?v_2 (+ (* 1 x3) (+ (* 1 x4) (+ ?v_14 (+ ?v_15 ?v_19))))))) 0) (<= (+ ?v_16 (+ ?v_9 (+ ?v_17 (+ ?v_14 (+ (* 0 x8) ?v_13))))) 1) (<= (+ ?v_9 (+ ?v_11 (+ ?v_7 (+ ?v_18 (+ ?v_19 ?v_8))))) 0)))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LIA/dilling/10-28.smt2.expected.err000066400000000000000000000000001445011647600236450ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/dilling/10-28.smt2.expected.out000066400000000000000000000000041445011647600236700ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LIA/dilling/10-29.smt2000066400000000000000000000026451445011647600213000ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_LIA) (set-info :category "industrial") (set-info :status sat) (declare-fun x0 () Int) (declare-fun x1 () Int) (declare-fun x2 () Int) (declare-fun x3 () Int) (declare-fun x4 () Int) (declare-fun x5 () Int) (declare-fun x6 () Int) (declare-fun x7 () Int) (declare-fun x8 () Int) (declare-fun x9 () Int) (assert (let ((?v_7 (* 0 x0)) (?v_17 (* 1 x2)) (?v_3 (* 0 x6)) (?v_5 (* 0 x8)) (?v_4 (* 1 x0)) (?v_1 (* 0 x1)) (?v_2 (* 0 x4)) (?v_6 (* 1 x5)) (?v_9 (* 0 x2))) (let ((?v_19 (+ ?v_3 (* 2 x8))) (?v_8 (* 1 x7)) (?v_10 (* 0 x9)) (?v_12 (* 1 x3)) (?v_11 (* 1 x1)) (?v_18 (* 0 x5)) (?v_0 (* (- 1) x9)) (?v_14 (* (- 1) x3)) (?v_15 (* (- 1) x0)) (?v_16 (* (- 1) x7)) (?v_13 (* (- 1) x6))) (and (<= (+ ?v_7 (+ ?v_17 (+ (* (- 2) x3) (+ ?v_0 (+ ?v_3 (+ ?v_5 (* 1 x4))))))) 0) (<= (+ ?v_4 (+ ?v_1 (+ ?v_14 (+ ?v_0 (+ ?v_2 ?v_6))))) 1) (<= (+ ?v_15 (+ ?v_0 (+ ?v_1 (+ ?v_9 (+ ?v_2 ?v_19))))) 0) (<= (+ ?v_4 (+ ?v_1 (+ (* 0 x3) (+ ?v_2 (+ ?v_3 ?v_8))))) 1) (<= (+ ?v_16 (+ ?v_5 (+ ?v_10 (+ ?v_12 (+ ?v_6 (* 1 x6)))))) 0) (<= (+ ?v_7 (+ ?v_13 (+ (* (- 1) x8) (+ ?v_11 (+ ?v_2 (+ ?v_8 (* 2 x9))))))) 0) (<= (+ ?v_9 (+ ?v_10 (+ ?v_11 (+ ?v_12 (+ ?v_6 (+ ?v_8 (* 1 x8))))))) 1) (<= (+ (* (- 1) x5) (+ (* (- 2) x9) (+ ?v_13 (+ ?v_9 (+ ?v_11 ?v_14))))) (- 1)) (<= (+ ?v_15 (+ ?v_16 (+ ?v_17 (+ ?v_2 (+ ?v_18 (+ ?v_5 ?v_10)))))) 0) (<= (+ ?v_17 (+ (* (- 2) x4) (+ ?v_18 (+ ?v_0 ?v_19)))) (- 1)))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LIA/dilling/10-29.smt2.expected.err000066400000000000000000000000001445011647600236460ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/dilling/10-29.smt2.expected.out000066400000000000000000000000041445011647600236710ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LIA/distinct_sat.smt2000066400000000000000000000002341445011647600216660ustar00rootroot00000000000000(set-logic QF_LIA) (set-info :status sat) (declare-fun a () Int) (declare-fun b () Int) (declare-fun c () Int) (assert (distinct a b c)) (check-sat) (exit) opensmt-2.5.2/regression/QF_LIA/distinct_sat.smt2.expected.err000066400000000000000000000000001445011647600242440ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/distinct_sat.smt2.expected.out000066400000000000000000000000041445011647600242670ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LIA/distinct_unsat.smt2000066400000000000000000000003511445011647600222310ustar00rootroot00000000000000(set-logic QF_LIA) (set-info :status unsat) (declare-fun a () Int) (declare-fun b () Int) (declare-fun c () Int) (assert (not (distinct a b c))) (assert (not (= a b))) (assert (not (= a c))) (assert (not (= b c))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LIA/distinct_unsat.smt2.expected.err000066400000000000000000000000001445011647600246070ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/distinct_unsat.smt2.expected.out000066400000000000000000000000061445011647600246340ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LIA/double-check-sat-bug.smt2000066400000000000000000000006721445011647600230710ustar00rootroot00000000000000(set-logic QF_LIA) (declare-const x3 Int) (declare-const x Int) (declare-fun |:| () Int) (declare-fun |s:| () Int) (declare-fun s () Int) (declare-fun |::| () Int) (declare-fun t () Int) (assert (and (or (= 0 s) (and (= |::| 1) (= -2 (* -1 |:|)))) (or (and (= -1 |s:|) (= 0 x3) (= 0 x) (> 0 (+ s (* -1 t)))) (and (= 0 s) (> 0 (+ s (* -1 t))) (= 0 (+ |:| (* -50 t))) (or (= 0 s) (and (= |::| 1) (= -2 (* -1 |:|)))))))) (check-sat) (check-sat) opensmt-2.5.2/regression/QF_LIA/double-check-sat-bug.smt2.expected.err000066400000000000000000000000001445011647600254410ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/double-check-sat-bug.smt2.expected.out000066400000000000000000000000101445011647600254610ustar00rootroot00000000000000sat sat opensmt-2.5.2/regression/QF_LIA/infinite_bound_refinement.smt2000066400000000000000000000001771445011647600244140ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun x () Int) (declare-fun y () Int) (assert (> (- y x) 0)) (assert (> (- x y) (- 1))) (check-sat) opensmt-2.5.2/regression/QF_LIA/infinite_bound_refinement.smt2.expected.err000066400000000000000000000000001445011647600267640ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/infinite_bound_refinement.smt2.expected.out000066400000000000000000000000061445011647600270110ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LIA/ite-in-define-fun.smt2000066400000000000000000000002061445011647600224000ustar00rootroot00000000000000(set-logic QF_LIA) (set-info :status unsat) (define-fun m ((x Int) (y Int)) Int (ite (< x y) y x)) (assert (= 0 (m 0 1))) (check-sat) opensmt-2.5.2/regression/QF_LIA/ite-in-define-fun.smt2.expected.err000066400000000000000000000000001445011647600247570ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/ite-in-define-fun.smt2.expected.out000066400000000000000000000000061445011647600250040ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LIA/mathsat/000077500000000000000000000000001445011647600200315ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/mathsat/FISCHER1-1-fair.smt2000066400000000000000000000123031445011647600230600ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_LIA) (set-info :source | Older mathsat benchmarks. Contact Mathsat group at http://mathsat.itc.it/ for more information. This benchmark was automatically translated into SMT-LIB format from CVC format using CVC Lite |) (set-info :category "industrial") (set-info :status sat) (declare-fun AT0_PROC1_X () Int) (declare-fun AT0_ID0 () Bool) (declare-fun AT0_ID1 () Bool) (declare-fun AT0_PROC1_C () Bool) (declare-fun AT0_PROC1_B () Bool) (declare-fun AT0_PROC1_A () Bool) (declare-fun AT1_ID0 () Bool) (declare-fun AT1_ID1 () Bool) (declare-fun AT0_PROC1_SW_CS_A_TAU () Bool) (declare-fun AT1_PROC1_X () Int) (declare-fun AT1_Z () Int) (declare-fun AT0_PROC1_SW_C_B_TAU () Bool) (declare-fun AT0_PROC1_CS () Bool) (declare-fun AT0_PROC1_TAU () Bool) (declare-fun AT0_PROC1_SW_C_CS_TAU () Bool) (declare-fun AT0_PROC1_WAIT () Bool) (declare-fun AT1_PROC1_C () Bool) (declare-fun AT1_PROC1_B () Bool) (declare-fun AT1_PROC1_A () Bool) (declare-fun AT0_DELTA () Bool) (declare-fun AT1_PROC1_CS () Bool) (declare-fun AT0_PROC1_SW_A_B_TAU () Bool) (declare-fun AT0_Z () Int) (declare-fun AT0_PROC1_SW_B_C_TAU () Bool) (assert (let ((?v_0 (not AT0_PROC1_A)) (?v_1 (not AT0_PROC1_B)) (?v_2 (not AT0_PROC1_C)) (?v_3 (not AT0_PROC1_CS)) (?v_4 (not AT1_PROC1_A)) (?v_5 (not AT1_PROC1_B)) (?v_6 (not AT1_PROC1_C)) (?v_7 (not AT1_PROC1_CS)) (?v_8 (= AT0_PROC1_X AT0_Z)) (?v_9 (> AT0_PROC1_X AT0_Z))) (let ((?v_29 (not ?v_8)) (?v_10 (= AT1_PROC1_X AT1_Z)) (?v_11 (> AT1_PROC1_X AT1_Z))) (let ((?v_28 (not ?v_10)) (?v_17 (- AT0_PROC1_X AT0_Z))) (let ((?v_14 (<= ?v_17 10)) (?v_12 (not AT0_PROC1_SW_A_B_TAU)) (?v_13 (not AT0_PROC1_SW_B_C_TAU)) (?v_15 (not AT0_PROC1_SW_C_B_TAU)) (?v_16 (not AT0_PROC1_SW_C_CS_TAU)) (?v_21 (= AT1_PROC1_X AT0_PROC1_X)) (?v_18 (not AT0_PROC1_SW_CS_A_TAU)) (?v_19 (= AT1_Z AT0_Z)) (?v_20 (not AT0_PROC1_WAIT)) (?v_23 (not AT0_PROC1_TAU)) (?v_22 (not AT0_DELTA)) (?v_25 (< AT1_Z AT0_Z)) (?v_24 (< AT1_PROC1_X AT0_PROC1_X))) (let ((?v_26 (not ?v_21)) (?v_27 (not ?v_19)) (?v_31 (not ?v_25))) (let ((?v_30 (or ?v_29 ?v_26)) (?v_33 (not AT0_ID0)) (?v_32 (not AT0_ID1)) (?v_34 (not AT1_ID1)) (?v_35 (- AT1_PROC1_X AT1_Z))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (or ?v_0 ?v_1) (or ?v_0 ?v_2)) (or ?v_0 ?v_3)) (or ?v_1 ?v_2)) (or ?v_1 ?v_3)) (or ?v_2 ?v_3)) (or ?v_4 ?v_5)) (or ?v_4 ?v_6)) (or ?v_4 ?v_7)) (or ?v_5 ?v_6)) (or ?v_5 ?v_7)) (or ?v_6 ?v_7)) (or ?v_8 ?v_9)) (or ?v_29 (not ?v_9))) (or ?v_10 ?v_11)) (or ?v_28 (not ?v_11))) (or ?v_1 ?v_14)) (or ?v_5 (<= ?v_35 10))) (or (or (or (or (or (or AT0_PROC1_WAIT AT0_DELTA) AT0_PROC1_SW_A_B_TAU) AT0_PROC1_SW_B_C_TAU) AT0_PROC1_SW_C_B_TAU) AT0_PROC1_SW_C_CS_TAU) AT0_PROC1_SW_CS_A_TAU)) (or ?v_12 AT0_PROC1_A)) (or ?v_12 AT0_PROC1_TAU)) (or ?v_12 AT1_PROC1_B)) (or ?v_12 ?v_10)) (or ?v_13 AT0_PROC1_B)) (or ?v_13 AT0_PROC1_TAU)) (or ?v_13 AT1_PROC1_C)) (or ?v_13 ?v_14)) (or ?v_13 ?v_10)) (or ?v_15 AT0_PROC1_C)) (or ?v_15 AT0_PROC1_TAU)) (or ?v_15 AT1_PROC1_B)) (or ?v_15 ?v_10)) (or ?v_16 AT0_PROC1_C)) (or ?v_16 AT0_PROC1_TAU)) (or ?v_16 AT1_PROC1_CS)) (or ?v_16 (> ?v_17 10))) (or ?v_16 ?v_21)) (or ?v_18 AT0_PROC1_CS)) (or ?v_18 AT0_PROC1_TAU)) (or ?v_18 AT1_PROC1_A)) (or ?v_18 ?v_10)) (or ?v_12 ?v_19)) (or ?v_13 ?v_19)) (or ?v_15 ?v_19)) (or ?v_16 ?v_19)) (or ?v_18 ?v_19)) (or (or ?v_20 ?v_0) AT1_PROC1_A)) (or (or ?v_20 AT0_PROC1_A) ?v_4)) (or (or ?v_20 ?v_1) AT1_PROC1_B)) (or (or ?v_20 AT0_PROC1_B) ?v_5)) (or (or ?v_20 ?v_2) AT1_PROC1_C)) (or (or ?v_20 AT0_PROC1_C) ?v_6)) (or (or ?v_20 ?v_3) AT1_PROC1_CS)) (or (or ?v_20 AT0_PROC1_CS) ?v_7)) (or ?v_20 ?v_23)) (or ?v_20 ?v_21)) (or ?v_20 ?v_19)) (or (or ?v_22 ?v_0) AT1_PROC1_A)) (or (or ?v_22 AT0_PROC1_A) ?v_4)) (or (or ?v_22 ?v_1) AT1_PROC1_B)) (or (or ?v_22 AT0_PROC1_B) ?v_5)) (or (or ?v_22 ?v_2) AT1_PROC1_C)) (or (or ?v_22 AT0_PROC1_C) ?v_6)) (or (or ?v_22 ?v_3) AT1_PROC1_CS)) (or (or ?v_22 AT0_PROC1_CS) ?v_7)) (or ?v_22 ?v_21)) (or ?v_22 ?v_23)) (or ?v_22 ?v_25)) (or ?v_21 ?v_24)) (or ?v_26 (not ?v_24))) (or ?v_19 ?v_25)) (or ?v_27 ?v_31)) (or (or (or ?v_8 ?v_26) ?v_27) ?v_28)) (or (or (or ?v_29 ?v_21) ?v_27) ?v_28)) (or (or ?v_30 ?v_19) ?v_28)) (or (or ?v_30 ?v_27) ?v_10)) (or (or (or (not (< AT0_Z AT0_PROC1_X)) ?v_26) ?v_31) (< AT1_Z AT1_PROC1_X))) AT0_PROC1_A) ?v_8) AT0_ID0) ?v_20) (or ?v_33 ?v_32)) (or (not AT1_ID0) ?v_34)) (or ?v_12 AT0_ID0)) (or ?v_12 AT1_ID0)) (or ?v_13 AT1_ID1)) (or ?v_15 AT0_ID0)) (or ?v_15 AT1_ID0)) (or ?v_16 AT0_ID1)) (or ?v_16 AT1_ID1)) (or ?v_18 AT1_ID0)) (or (or ?v_22 ?v_32) AT1_ID1)) (or (or ?v_22 ?v_33) AT1_ID0)) (or ?v_4 AT1_PROC1_A)) (or AT1_PROC1_A ?v_4)) (or ?v_5 AT1_PROC1_B)) (or AT1_PROC1_B ?v_5)) (or ?v_6 AT1_PROC1_C)) (or AT1_PROC1_C ?v_6)) (or ?v_7 AT1_PROC1_CS)) (or AT1_PROC1_CS ?v_7)) (or ?v_34 AT1_ID1)) (or AT1_ID1 ?v_34)) (= ?v_35 ?v_35)) AT1_PROC1_B) ?v_7)))))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LIA/mathsat/FISCHER1-1-fair.smt2.expected.err000066400000000000000000000000001445011647600254360ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/mathsat/FISCHER1-1-fair.smt2.expected.out000066400000000000000000000000041445011647600254610ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LIA/mathsat/FISCHER1-2-fair.smt2000066400000000000000000000220221445011647600230600ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_LIA) (set-info :source | Older mathsat benchmarks. Contact Mathsat group at http://mathsat.itc.it/ for more information. This benchmark was automatically translated into SMT-LIB format from CVC format using CVC Lite |) (set-info :category "industrial") (set-info :status unsat) (declare-fun AT2_PROC1_X () Int) (declare-fun AT0_PROC1_X () Int) (declare-fun AT1_PROC1_SW_B_C_TAU () Bool) (declare-fun AT0_ID0 () Bool) (declare-fun AT0_ID1 () Bool) (declare-fun AT1_PROC1_WAIT () Bool) (declare-fun AT2_Z () Int) (declare-fun AT2_PROC1_C () Bool) (declare-fun AT2_PROC1_B () Bool) (declare-fun AT2_PROC1_A () Bool) (declare-fun AT0_PROC1_C () Bool) (declare-fun AT0_PROC1_B () Bool) (declare-fun AT0_PROC1_A () Bool) (declare-fun AT2_PROC1_CS () Bool) (declare-fun AT1_ID0 () Bool) (declare-fun AT1_ID1 () Bool) (declare-fun AT0_PROC1_SW_CS_A_TAU () Bool) (declare-fun AT1_PROC1_X () Int) (declare-fun AT1_Z () Int) (declare-fun AT2_ID0 () Bool) (declare-fun AT2_ID1 () Bool) (declare-fun AT0_PROC1_SW_C_B_TAU () Bool) (declare-fun AT0_PROC1_CS () Bool) (declare-fun AT0_PROC1_TAU () Bool) (declare-fun AT0_PROC1_SW_C_CS_TAU () Bool) (declare-fun AT0_PROC1_WAIT () Bool) (declare-fun AT1_PROC1_SW_C_B_TAU () Bool) (declare-fun AT1_PROC1_C () Bool) (declare-fun AT1_PROC1_SW_C_CS_TAU () Bool) (declare-fun AT1_PROC1_B () Bool) (declare-fun AT1_PROC1_A () Bool) (declare-fun AT0_DELTA () Bool) (declare-fun AT1_PROC1_TAU () Bool) (declare-fun AT1_PROC1_CS () Bool) (declare-fun AT0_PROC1_SW_A_B_TAU () Bool) (declare-fun AT1_DELTA () Bool) (declare-fun AT1_PROC1_SW_A_B_TAU () Bool) (declare-fun AT0_Z () Int) (declare-fun AT1_PROC1_SW_CS_A_TAU () Bool) (declare-fun AT0_PROC1_SW_B_C_TAU () Bool) (assert (let ((?v_0 (not AT0_PROC1_A)) (?v_1 (not AT0_PROC1_B)) (?v_2 (not AT0_PROC1_C)) (?v_3 (not AT0_PROC1_CS)) (?v_4 (not AT1_PROC1_A)) (?v_5 (not AT1_PROC1_B)) (?v_6 (not AT1_PROC1_C)) (?v_7 (not AT1_PROC1_CS)) (?v_8 (not AT2_PROC1_A)) (?v_9 (not AT2_PROC1_B)) (?v_10 (not AT2_PROC1_C)) (?v_11 (not AT2_PROC1_CS)) (?v_12 (= AT0_PROC1_X AT0_Z)) (?v_13 (> AT0_PROC1_X AT0_Z))) (let ((?v_49 (not ?v_12)) (?v_14 (= AT1_PROC1_X AT1_Z)) (?v_15 (> AT1_PROC1_X AT1_Z))) (let ((?v_48 (not ?v_14)) (?v_16 (= AT2_PROC1_X AT2_Z)) (?v_17 (> AT2_PROC1_X AT2_Z))) (let ((?v_54 (not ?v_16)) (?v_23 (- AT0_PROC1_X AT0_Z))) (let ((?v_20 (<= ?v_23 10)) (?v_30 (- AT1_PROC1_X AT1_Z))) (let ((?v_27 (<= ?v_30 10)) (?v_18 (not AT0_PROC1_SW_A_B_TAU)) (?v_19 (not AT0_PROC1_SW_B_C_TAU)) (?v_21 (not AT0_PROC1_SW_C_B_TAU)) (?v_22 (not AT0_PROC1_SW_C_CS_TAU)) (?v_35 (= AT1_PROC1_X AT0_PROC1_X)) (?v_24 (not AT0_PROC1_SW_CS_A_TAU)) (?v_25 (not AT1_PROC1_SW_A_B_TAU)) (?v_26 (not AT1_PROC1_SW_B_C_TAU)) (?v_28 (not AT1_PROC1_SW_C_B_TAU)) (?v_29 (not AT1_PROC1_SW_C_CS_TAU)) (?v_37 (= AT2_PROC1_X AT1_PROC1_X)) (?v_31 (not AT1_PROC1_SW_CS_A_TAU)) (?v_32 (= AT1_Z AT0_Z)) (?v_33 (= AT2_Z AT1_Z)) (?v_34 (not AT0_PROC1_WAIT)) (?v_39 (not AT0_PROC1_TAU)) (?v_36 (not AT1_PROC1_WAIT)) (?v_41 (not AT1_PROC1_TAU)) (?v_38 (not AT0_DELTA)) (?v_44 (< AT1_Z AT0_Z)) (?v_40 (not AT1_DELTA)) (?v_45 (< AT2_Z AT1_Z)) (?v_42 (< AT1_PROC1_X AT0_PROC1_X))) (let ((?v_46 (not ?v_35)) (?v_43 (< AT2_PROC1_X AT1_PROC1_X)) (?v_52 (not ?v_37)) (?v_47 (not ?v_32)) (?v_51 (not ?v_44)) (?v_53 (not ?v_33)) (?v_57 (not ?v_45))) (let ((?v_50 (or ?v_49 ?v_46)) (?v_56 (< AT1_Z AT1_PROC1_X)) (?v_55 (or ?v_48 ?v_52)) (?v_59 (not AT0_ID0)) (?v_58 (not AT0_ID1)) (?v_61 (not AT1_ID0)) (?v_60 (not AT1_ID1)) (?v_62 (not AT2_ID1)) (?v_63 (- AT2_PROC1_X AT2_Z))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (or ?v_0 ?v_1) (or ?v_0 ?v_2)) (or ?v_0 ?v_3)) (or ?v_1 ?v_2)) (or ?v_1 ?v_3)) (or ?v_2 ?v_3)) (or ?v_4 ?v_5)) (or ?v_4 ?v_6)) (or ?v_4 ?v_7)) (or ?v_5 ?v_6)) (or ?v_5 ?v_7)) (or ?v_6 ?v_7)) (or ?v_8 ?v_9)) (or ?v_8 ?v_10)) (or ?v_8 ?v_11)) (or ?v_9 ?v_10)) (or ?v_9 ?v_11)) (or ?v_10 ?v_11)) (or ?v_12 ?v_13)) (or ?v_49 (not ?v_13))) (or ?v_14 ?v_15)) (or ?v_48 (not ?v_15))) (or ?v_16 ?v_17)) (or ?v_54 (not ?v_17))) (or ?v_1 ?v_20)) (or ?v_5 ?v_27)) (or ?v_9 (<= ?v_63 10))) (or (or (or (or (or (or AT0_PROC1_WAIT AT0_DELTA) AT0_PROC1_SW_A_B_TAU) AT0_PROC1_SW_B_C_TAU) AT0_PROC1_SW_C_B_TAU) AT0_PROC1_SW_C_CS_TAU) AT0_PROC1_SW_CS_A_TAU)) (or (or (or (or (or (or AT1_PROC1_WAIT AT1_DELTA) AT1_PROC1_SW_A_B_TAU) AT1_PROC1_SW_B_C_TAU) AT1_PROC1_SW_C_B_TAU) AT1_PROC1_SW_C_CS_TAU) AT1_PROC1_SW_CS_A_TAU)) (or ?v_18 AT0_PROC1_A)) (or ?v_18 AT0_PROC1_TAU)) (or ?v_18 AT1_PROC1_B)) (or ?v_18 ?v_14)) (or ?v_19 AT0_PROC1_B)) (or ?v_19 AT0_PROC1_TAU)) (or ?v_19 AT1_PROC1_C)) (or ?v_19 ?v_20)) (or ?v_19 ?v_14)) (or ?v_21 AT0_PROC1_C)) (or ?v_21 AT0_PROC1_TAU)) (or ?v_21 AT1_PROC1_B)) (or ?v_21 ?v_14)) (or ?v_22 AT0_PROC1_C)) (or ?v_22 AT0_PROC1_TAU)) (or ?v_22 AT1_PROC1_CS)) (or ?v_22 (> ?v_23 10))) (or ?v_22 ?v_35)) (or ?v_24 AT0_PROC1_CS)) (or ?v_24 AT0_PROC1_TAU)) (or ?v_24 AT1_PROC1_A)) (or ?v_24 ?v_14)) (or ?v_25 AT1_PROC1_A)) (or ?v_25 AT1_PROC1_TAU)) (or ?v_25 AT2_PROC1_B)) (or ?v_25 ?v_16)) (or ?v_26 AT1_PROC1_B)) (or ?v_26 AT1_PROC1_TAU)) (or ?v_26 AT2_PROC1_C)) (or ?v_26 ?v_27)) (or ?v_26 ?v_16)) (or ?v_28 AT1_PROC1_C)) (or ?v_28 AT1_PROC1_TAU)) (or ?v_28 AT2_PROC1_B)) (or ?v_28 ?v_16)) (or ?v_29 AT1_PROC1_C)) (or ?v_29 AT1_PROC1_TAU)) (or ?v_29 AT2_PROC1_CS)) (or ?v_29 (> ?v_30 10))) (or ?v_29 ?v_37)) (or ?v_31 AT1_PROC1_CS)) (or ?v_31 AT1_PROC1_TAU)) (or ?v_31 AT2_PROC1_A)) (or ?v_31 ?v_16)) (or ?v_18 ?v_32)) (or ?v_19 ?v_32)) (or ?v_21 ?v_32)) (or ?v_22 ?v_32)) (or ?v_24 ?v_32)) (or ?v_25 ?v_33)) (or ?v_26 ?v_33)) (or ?v_28 ?v_33)) (or ?v_29 ?v_33)) (or ?v_31 ?v_33)) (or (or ?v_34 ?v_0) AT1_PROC1_A)) (or (or ?v_34 AT0_PROC1_A) ?v_4)) (or (or ?v_34 ?v_1) AT1_PROC1_B)) (or (or ?v_34 AT0_PROC1_B) ?v_5)) (or (or ?v_34 ?v_2) AT1_PROC1_C)) (or (or ?v_34 AT0_PROC1_C) ?v_6)) (or (or ?v_34 ?v_3) AT1_PROC1_CS)) (or (or ?v_34 AT0_PROC1_CS) ?v_7)) (or ?v_34 ?v_39)) (or ?v_34 ?v_35)) (or ?v_34 ?v_32)) (or (or ?v_36 ?v_4) AT2_PROC1_A)) (or (or ?v_36 AT1_PROC1_A) ?v_8)) (or (or ?v_36 ?v_5) AT2_PROC1_B)) (or (or ?v_36 AT1_PROC1_B) ?v_9)) (or (or ?v_36 ?v_6) AT2_PROC1_C)) (or (or ?v_36 AT1_PROC1_C) ?v_10)) (or (or ?v_36 ?v_7) AT2_PROC1_CS)) (or (or ?v_36 AT1_PROC1_CS) ?v_11)) (or ?v_36 ?v_41)) (or ?v_36 ?v_37)) (or ?v_36 ?v_33)) (or (or ?v_38 ?v_0) AT1_PROC1_A)) (or (or ?v_38 AT0_PROC1_A) ?v_4)) (or (or ?v_38 ?v_1) AT1_PROC1_B)) (or (or ?v_38 AT0_PROC1_B) ?v_5)) (or (or ?v_38 ?v_2) AT1_PROC1_C)) (or (or ?v_38 AT0_PROC1_C) ?v_6)) (or (or ?v_38 ?v_3) AT1_PROC1_CS)) (or (or ?v_38 AT0_PROC1_CS) ?v_7)) (or ?v_38 ?v_35)) (or ?v_38 ?v_39)) (or ?v_38 ?v_44)) (or (or ?v_40 ?v_4) AT2_PROC1_A)) (or (or ?v_40 AT1_PROC1_A) ?v_8)) (or (or ?v_40 ?v_5) AT2_PROC1_B)) (or (or ?v_40 AT1_PROC1_B) ?v_9)) (or (or ?v_40 ?v_6) AT2_PROC1_C)) (or (or ?v_40 AT1_PROC1_C) ?v_10)) (or (or ?v_40 ?v_7) AT2_PROC1_CS)) (or (or ?v_40 AT1_PROC1_CS) ?v_11)) (or ?v_40 ?v_37)) (or ?v_40 ?v_41)) (or ?v_40 ?v_45)) (or ?v_35 ?v_42)) (or ?v_46 (not ?v_42))) (or ?v_37 ?v_43)) (or ?v_52 (not ?v_43))) (or ?v_38 ?v_40)) (or ?v_32 ?v_44)) (or ?v_47 ?v_51)) (or ?v_33 ?v_45)) (or ?v_53 ?v_57)) (or (or (or ?v_12 ?v_46) ?v_47) ?v_48)) (or (or (or ?v_49 ?v_35) ?v_47) ?v_48)) (or (or ?v_50 ?v_32) ?v_48)) (or (or ?v_50 ?v_47) ?v_14)) (or (or (or (not (< AT0_Z AT0_PROC1_X)) ?v_46) ?v_51) ?v_56)) (or (or (or ?v_14 ?v_52) ?v_53) ?v_54)) (or (or (or ?v_48 ?v_37) ?v_53) ?v_54)) (or (or ?v_55 ?v_33) ?v_54)) (or (or ?v_55 ?v_53) ?v_16)) (or (or (or (not ?v_56) ?v_52) ?v_57) (< AT2_Z AT2_PROC1_X))) AT0_PROC1_A) ?v_12) AT0_ID0) ?v_34) ?v_36) (or ?v_59 ?v_58)) (or ?v_61 ?v_60)) (or (not AT2_ID0) ?v_62)) (or ?v_18 AT0_ID0)) (or ?v_18 AT1_ID0)) (or ?v_19 AT1_ID1)) (or ?v_21 AT0_ID0)) (or ?v_21 AT1_ID0)) (or ?v_22 AT0_ID1)) (or ?v_22 AT1_ID1)) (or ?v_24 AT1_ID0)) (or (or ?v_38 ?v_58) AT1_ID1)) (or (or ?v_38 ?v_59) AT1_ID0)) (or ?v_25 AT1_ID0)) (or ?v_25 AT2_ID0)) (or ?v_26 AT2_ID1)) (or ?v_28 AT1_ID0)) (or ?v_28 AT2_ID0)) (or ?v_29 AT1_ID1)) (or ?v_29 AT2_ID1)) (or ?v_31 AT2_ID0)) (or (or ?v_40 ?v_60) AT2_ID1)) (or (or ?v_40 ?v_61) AT2_ID0)) (or ?v_4 AT2_PROC1_A)) (or AT1_PROC1_A ?v_8)) (or ?v_5 AT2_PROC1_B)) (or AT1_PROC1_B ?v_9)) (or ?v_6 AT2_PROC1_C)) (or AT1_PROC1_C ?v_10)) (or ?v_7 AT2_PROC1_CS)) (or AT1_PROC1_CS ?v_11)) (or ?v_60 AT2_ID1)) (or AT1_ID1 ?v_62)) (= ?v_30 ?v_63)) (or AT1_PROC1_B AT2_PROC1_B)) ?v_7) ?v_11)))))))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LIA/mathsat/FISCHER1-2-fair.smt2.expected.err000066400000000000000000000000001445011647600254370ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/mathsat/FISCHER1-2-fair.smt2.expected.out000066400000000000000000000000061445011647600254640ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LIA/problem-002267.cvc.1_simplified_0.smt2000066400000000000000000000002471445011647600247350ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun v1 () Int) (set-info :status unsat) (assert (let ( (?v_9 (= v1 0)) ) (= v1 (ite (ite (= v1 0) true false) 1 0)))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LIA/problem-002267.cvc.1_simplified_0.smt2.expected.err000066400000000000000000000000001445011647600273070ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/problem-002267.cvc.1_simplified_0.smt2.expected.out000066400000000000000000000000061445011647600273340ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LIA/prp-0-12_simplified_1.smt2000066400000000000000000000003041445011647600227770ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun v () Int) (set-info :status sat) (assert (= (ite (= (ite (= v 0) 1 0) 0) (ite (= v 0) 1 0) (ite (= (ite (= v 0) 1 0) 0) 1 0)) 0 )) (check-sat) (exit) opensmt-2.5.2/regression/QF_LIA/prp-0-12_simplified_1.smt2.expected.err000066400000000000000000000000001445011647600253570ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/prp-0-12_simplified_1.smt2.expected.out000066400000000000000000000000041445011647600254020ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LIA/prp-0-12_simplified_2.smt2000066400000000000000000000003101445011647600227750ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun b () Bool) (set-info :status sat) (assert (= (ite (= (ite b 1 0) 0) (ite b 1 0) (ite (= (ite b 1 0) 1) 1 0 ) ) 0 ) ) (check-sat) (exit) opensmt-2.5.2/regression/QF_LIA/prp-0-12_simplified_2.smt2.expected.err000066400000000000000000000000001445011647600253600ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/prp-0-12_simplified_2.smt2.expected.out000066400000000000000000000000041445011647600254030ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LIA/prp-0-12_simplified_3.smt2000066400000000000000000000003011445011647600227760ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun v0 () Int) (declare-fun v2 () Int) (set-info :status sat) (assert (= (ite (= v2 0) (ite (= v0 0) 1 0) (ite (= (ite (= v0 0) 1 0) 0) 1 0)) 0)) (check-sat) (exit) opensmt-2.5.2/regression/QF_LIA/prp-0-12_simplified_3.smt2.expected.err000066400000000000000000000000001445011647600253610ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/prp-0-12_simplified_3.smt2.expected.out000066400000000000000000000000041445011647600254040ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LIA/prp-0-12_simplified_4.smt2000066400000000000000000000003431445011647600230050ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun v0 () Int) (declare-fun v2 () Int) (set-info :status unsat) (assert (= (ite (= v2 0) (ite (= v2 0) 0 1) (ite (= (ite (= v2 0) 1 0) 0) 0 1 )) 1 )) (check-sat) (exit) opensmt-2.5.2/regression/QF_LIA/prp-0-12_simplified_4.smt2.expected.err000066400000000000000000000000001445011647600253620ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/prp-0-12_simplified_4.smt2.expected.out000066400000000000000000000000061445011647600254070ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LIA/regression/000077500000000000000000000000001445011647600205505ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/regression/issue116.smt2000066400000000000000000000004071445011647600227400ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun i0 () Int) (declare-fun i1 () Int) (declare-fun i2 () Int) (declare-fun v12 () Bool) (assert (< 0 i2)) (assert (= (> i2 0) v12)) (assert (or (> (- i0) 0) v12)) (assert (>= i1 i2)) (assert (< (- i1 185) (* 185 (- i0)))) (check-sat) opensmt-2.5.2/regression/QF_LIA/regression/issue116.smt2.expected.err000066400000000000000000000000001445011647600253140ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/regression/issue116.smt2.expected.out000066400000000000000000000000041445011647600253370ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LIA/regression/issue62.smt2000066400000000000000000000001331445011647600226540ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun i2 () Int) (assert (= 8 i2)) (assert (= 0 i2)) (check-sat) opensmt-2.5.2/regression/QF_LIA/regression/issue62.smt2.expected.err000066400000000000000000000000001445011647600252340ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/regression/issue62.smt2.expected.out000066400000000000000000000000061445011647600252610ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LIA/regression/issue63.smt2000066400000000000000000000003111445011647600226530ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun i5 () Int) (declare-fun i13 () Int) (declare-fun i19 () Int) (assert (> i19 i5)) (assert (=> (> 89 i19) (> i13 55))) (push 1) (assert (=> (> i13 55) false)) (check-sat) opensmt-2.5.2/regression/QF_LIA/regression/issue63.smt2.expected.err000066400000000000000000000000001445011647600252350ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/regression/issue63.smt2.expected.out000066400000000000000000000000041445011647600252600ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LIA/regression/issue66.smt2000066400000000000000000000005241445011647600226640ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun v0 () Bool) (declare-fun i2 () Int) (declare-fun i4 () Int) (declare-fun i6 () Int) (declare-fun i9 () Int) (push 1) (declare-fun v9 () Bool) (assert (distinct v9 (= (< 68 i9) (< 68 i9)))) (assert (or v9 (distinct i2 68))) (assert (< i4 i2)) (check-sat) (pop 1) (assert (=> v0 (> (- i9 68) i6))) (check-sat) opensmt-2.5.2/regression/QF_LIA/regression/issue66.smt2.expected.err000066400000000000000000000000001445011647600252400ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/regression/issue66.smt2.expected.out000066400000000000000000000000101445011647600252600ustar00rootroot00000000000000sat sat opensmt-2.5.2/regression/QF_LIA/regression/lia_subst.smt2000066400000000000000000000002631445011647600233450ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun x () Int) (declare-fun y () Int) (declare-fun a () Bool) (assert (= x (* 2 y))) (assert (=> a (= x 1))) (assert (=> (not a) (= x 1))) (check-sat) opensmt-2.5.2/regression/QF_LIA/regression/lia_subst.smt2.expected.err000066400000000000000000000000001445011647600257210ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/regression/lia_subst.smt2.expected.out000066400000000000000000000000061445011647600257460ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LIA/regression/rounding_bounds_bug.smt2000066400000000000000000000002521445011647600254120ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun x () Int) (declare-fun y () Int) (assert (>= x 0)) (assert (>= y 1)) (assert (>= (+ (* (- 7) x) (* (- 10) y)) (- 10))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LIA/regression/rounding_bounds_bug.smt2.expected.err000066400000000000000000000000001445011647600277700ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/regression/rounding_bounds_bug.smt2.expected.out000066400000000000000000000000041445011647600300130ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LIA/regression/substitution.smt2000066400000000000000000000002131445011647600241270ustar00rootroot00000000000000(set-logic QF_LIA) (set-info :status unsat) (declare-fun x () Int) (declare-fun H () Int) (assert (and (= H x) (= 1 (- x H)))) (check-sat) opensmt-2.5.2/regression/QF_LIA/regression/substitution.smt2.expected.err000066400000000000000000000000001445011647600265100ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/regression/substitution.smt2.expected.out000066400000000000000000000000061445011647600265350ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LIA/rings/000077500000000000000000000000001445011647600175125ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/rings/ring_2exp10_3vars_0ite_unsat.smt2000066400000000000000000000041441445011647600256330ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_LIA) (set-info :source | show equivalence of the following terms: (4 * v2 + (1 * v0 + 2 * v1)) v0 + 2 * (v1 + 2 * (v2)) in arithmetic modulo 2exp10 STATUS: unsat generated by: Alberto Griggio |) (set-info :category "crafted") (set-info :status unsat) (declare-fun v0 () Int) (declare-fun v1 () Int) (declare-fun v2 () Int) (declare-fun s_0 () Int) (declare-fun o_0 () Int) (declare-fun s_1 () Int) (declare-fun o_1 () Int) (declare-fun s_2 () Int) (declare-fun o_2 () Int) (declare-fun s_3 () Int) (declare-fun o_3 () Int) (assert (let ((?v_6 (* v2 2))) (let ((?v_7 (- ?v_6 (* s_2 1024)))) (let ((?v_4 (+ ?v_7 v1))) (let ((?v_5 (- ?v_4 (* o_2 1024))) (?v_10 (* v2 4))) (let ((?v_11 (- ?v_10 (* s_1 1024))) (?v_14 (* v1 2))) (let ((?v_15 (- ?v_14 (* s_0 1024)))) (let ((?v_12 (+ ?v_15 v0))) (let ((?v_13 (- ?v_12 (* o_0 1024)))) (let ((?v_8 (+ ?v_11 ?v_13))) (let ((?v_9 (- ?v_8 (* o_1 1024))) (?v_2 (- (+ (- (* 4 v2) (* 2048 s_2)) (* 2 v1)) (* 2048 o_2)))) (let ((?v_3 (- ?v_2 (* s_3 1024)))) (let ((?v_0 (+ ?v_3 v0))) (let ((?v_1 (- ?v_0 (* o_3 1024)))) (and (not (= ?v_1 ?v_9)) (and (= (> ?v_0 1024) (= o_3 1)) (and (and (< ?v_1 1024) (<= 0 ?v_1)) (and (and (<= o_3 1) (<= 0 o_3)) (and (= (> ?v_2 1024) (>= s_3 1)) (and (and (< ?v_3 1024) (<= 0 ?v_3)) (and (and (< s_3 2) (<= 0 s_3)) (and (= (> ?v_4 1024) (= o_2 1)) (and (and (< ?v_5 1024) (<= 0 ?v_5)) (and (and (<= o_2 1) (<= 0 o_2)) (and (= (> ?v_6 1024) (>= s_2 1)) (and (and (< ?v_7 1024) (<= 0 ?v_7)) (and (and (< s_2 2) (<= 0 s_2)) (and (= (> ?v_8 1024) (= o_1 1)) (and (and (< ?v_9 1024) (<= 0 ?v_9)) (and (and (<= o_1 1) (<= 0 o_1)) (and (= (> ?v_10 1024) (>= s_1 1)) (and (and (< ?v_11 1024) (<= 0 ?v_11)) (and (and (< s_1 4) (<= 0 s_1)) (and (= (> ?v_12 1024) (= o_0 1)) (and (and (< ?v_13 1024) (<= 0 ?v_13)) (and (and (<= o_0 1) (<= 0 o_0)) (and (= (> ?v_14 1024) (>= s_0 1)) (and (and (< ?v_15 1024) (<= 0 ?v_15)) (and (and (< s_0 2) (<= 0 s_0)) (and (and (< v2 1024) (>= v2 0)) (and (and (< v1 1024) (>= v1 0)) (and (< v0 1024) (>= v0 0))))))))))))))))))))))))))))))))))))))))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LIA/rings/ring_2exp10_3vars_0ite_unsat.smt2.expected.err000066400000000000000000000000001445011647600302050ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/rings/ring_2exp10_3vars_0ite_unsat.smt2.expected.out000066400000000000000000000000061445011647600302320ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LIA/rings/ring_2exp10_3vars_1ite_unsat.smt2000066400000000000000000000041341445011647600256330ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_LIA) (set-info :source | show equivalence of the following terms: (4 * v2 + (1 * v0 + 2 * v1)) v0 + 2 * (v1 + 2 * (v2)) in arithmetic modulo 2exp10 STATUS: unsat generated by: Alberto Griggio |) (set-info :category "crafted") (set-info :status unsat) (declare-fun v0 () Int) (declare-fun v1 () Int) (declare-fun v2 () Int) (declare-fun s_0 () Int) (declare-fun o_0 () Int) (declare-fun s_1 () Int) (declare-fun o_1 () Int) (declare-fun o_2 () Int) (declare-fun s_3 () Int) (declare-fun o_3 () Int) (assert (let ((?v_0 (* v2 2))) (let ((?v_6 (< ?v_0 1024)) (?v_7 (< ?v_0 2048))) (let ((?v_8 (+ (ite ?v_6 ?v_0 (ite ?v_7 (- ?v_0 1024) (- ?v_0 2048))) v1))) (let ((?v_9 (- ?v_8 (* o_2 1024))) (?v_12 (* v2 4))) (let ((?v_13 (- ?v_12 (* s_1 1024))) (?v_16 (* v1 2))) (let ((?v_17 (- ?v_16 (* s_0 1024)))) (let ((?v_14 (+ ?v_17 v0))) (let ((?v_15 (- ?v_14 (* o_0 1024)))) (let ((?v_10 (+ ?v_13 ?v_15))) (let ((?v_11 (- ?v_10 (* o_1 1024))) (?v_1 (* 4 v2))) (let ((?v_4 (- (+ (ite ?v_6 ?v_1 (ite ?v_7 (- ?v_1 2048) (- ?v_1 4096))) (* 2 v1)) (* 2048 o_2)))) (let ((?v_5 (- ?v_4 (* s_3 1024)))) (let ((?v_2 (+ ?v_5 v0))) (let ((?v_3 (- ?v_2 (* o_3 1024)))) (and (not (= ?v_3 ?v_11)) (and (= (> ?v_2 1024) (= o_3 1)) (and (and (< ?v_3 1024) (<= 0 ?v_3)) (and (and (<= o_3 1) (<= 0 o_3)) (and (= (> ?v_4 1024) (>= s_3 1)) (and (and (< ?v_5 1024) (<= 0 ?v_5)) (and (and (< s_3 2) (<= 0 s_3)) (and (= (> ?v_8 1024) (= o_2 1)) (and (and (< ?v_9 1024) (<= 0 ?v_9)) (and (and (<= o_2 1) (<= 0 o_2)) (and (= (> ?v_10 1024) (= o_1 1)) (and (and (< ?v_11 1024) (<= 0 ?v_11)) (and (and (<= o_1 1) (<= 0 o_1)) (and (= (> ?v_12 1024) (>= s_1 1)) (and (and (< ?v_13 1024) (<= 0 ?v_13)) (and (and (< s_1 4) (<= 0 s_1)) (and (= (> ?v_14 1024) (= o_0 1)) (and (and (< ?v_15 1024) (<= 0 ?v_15)) (and (and (<= o_0 1) (<= 0 o_0)) (and (= (> ?v_16 1024) (>= s_0 1)) (and (and (< ?v_17 1024) (<= 0 ?v_17)) (and (and (< s_0 2) (<= 0 s_0)) (and (and (< v2 1024) (>= v2 0)) (and (and (< v1 1024) (>= v1 0)) (and (< v0 1024) (>= v0 0))))))))))))))))))))))))))))))))))))))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LIA/rings/ring_2exp10_3vars_1ite_unsat.smt2.expected.err000066400000000000000000000000001445011647600302060ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/rings/ring_2exp10_3vars_1ite_unsat.smt2.expected.out000066400000000000000000000000061445011647600302330ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LIA/slacks/000077500000000000000000000000001445011647600176505ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/slacks/10-12.slack.smt2000066400000000000000000000032241445011647600222140ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_LIA) (set-info :category "random") (set-info :status sat) (declare-fun x0_minus () Int) (declare-fun x0_plus () Int) (declare-fun x1_minus () Int) (declare-fun x1_plus () Int) (declare-fun x2_minus () Int) (declare-fun x2_plus () Int) (declare-fun x3_minus () Int) (declare-fun x3_plus () Int) (declare-fun x4_minus () Int) (declare-fun x4_plus () Int) (declare-fun x5_minus () Int) (declare-fun x5_plus () Int) (declare-fun x6_minus () Int) (declare-fun x6_plus () Int) (declare-fun x7_minus () Int) (declare-fun x7_plus () Int) (declare-fun x8_minus () Int) (declare-fun x8_plus () Int) (declare-fun x9_minus () Int) (declare-fun x9_plus () Int) (assert (>= x0_minus 0)) (assert (>= x0_plus 0)) (assert (>= x1_minus 0)) (assert (>= x1_plus 0)) (assert (>= x2_minus 0)) (assert (>= x2_plus 0)) (assert (>= x3_minus 0)) (assert (>= x3_plus 0)) (assert (>= x4_minus 0)) (assert (>= x4_plus 0)) (assert (>= x5_minus 0)) (assert (>= x5_plus 0)) (assert (>= x6_minus 0)) (assert (>= x6_plus 0)) (assert (>= x7_minus 0)) (assert (>= x7_plus 0)) (assert (>= x8_minus 0)) (assert (>= x8_plus 0)) (assert (>= x9_minus 0)) (assert (>= x9_plus 0)) (assert (>= (+ x0_plus (- x8_plus) (- x9_plus) (- x0_minus) x8_minus x9_minus) 0)) (assert (>= (+ (* (- 2) x2_plus) (- x6_plus) x8_plus (* 2 x2_minus) x6_minus (- x8_minus)) 0)) (assert (>= (+ (- x0_plus) (- x1_plus) (- x7_plus) (* (- 2) x9_plus) x0_minus x1_minus x7_minus (* 2 x9_minus)) 0)) (assert (>= (+ (- x6_plus) x6_minus) 1)) (assert (>= (+ (- x1_plus) (- x3_plus) (- x4_plus) x5_plus (- x6_plus) x9_plus x1_minus x3_minus x4_minus (- x5_minus) x6_minus (- x9_minus)) 0)) (check-sat) (exit) opensmt-2.5.2/regression/QF_LIA/slacks/10-12.slack.smt2.expected.err000066400000000000000000000000001445011647600245700ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/slacks/10-12.slack.smt2.expected.out000066400000000000000000000000041445011647600246130ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LIA/slacks/10-13.slack.smt2000066400000000000000000000031571445011647600222220ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_LIA) (set-info :category "random") (set-info :status sat) (declare-fun x0_minus () Int) (declare-fun x0_plus () Int) (declare-fun x1_minus () Int) (declare-fun x1_plus () Int) (declare-fun x2_minus () Int) (declare-fun x2_plus () Int) (declare-fun x3_minus () Int) (declare-fun x3_plus () Int) (declare-fun x4_minus () Int) (declare-fun x4_plus () Int) (declare-fun x5_minus () Int) (declare-fun x5_plus () Int) (declare-fun x6_minus () Int) (declare-fun x6_plus () Int) (declare-fun x7_minus () Int) (declare-fun x7_plus () Int) (declare-fun x8_minus () Int) (declare-fun x8_plus () Int) (declare-fun x9_minus () Int) (declare-fun x9_plus () Int) (assert (>= x0_minus 0)) (assert (>= x0_plus 0)) (assert (>= x1_minus 0)) (assert (>= x1_plus 0)) (assert (>= x2_minus 0)) (assert (>= x2_plus 0)) (assert (>= x3_minus 0)) (assert (>= x3_plus 0)) (assert (>= x4_minus 0)) (assert (>= x4_plus 0)) (assert (>= x5_minus 0)) (assert (>= x5_plus 0)) (assert (>= x6_minus 0)) (assert (>= x6_plus 0)) (assert (>= x7_minus 0)) (assert (>= x7_plus 0)) (assert (>= x8_minus 0)) (assert (>= x8_plus 0)) (assert (>= x9_minus 0)) (assert (>= x9_plus 0)) (assert (>= (+ x0_plus x4_plus x6_plus (- x9_plus) (- x0_minus) (- x4_minus) (- x6_minus) x9_minus) (- 1))) (assert (>= (+ x2_plus x7_plus (- x8_plus) (- x2_minus) (- x7_minus) x8_minus) 0)) (assert (>= (+ x1_plus (- x2_plus) x5_plus (- x7_plus) (- x1_minus) x2_minus (- x5_minus) x7_minus) (- 1))) (assert (>= (+ (- x8_plus) x8_minus) 1)) (assert (>= (+ (- x1_plus) (- x3_plus) (- x4_plus) (- x6_plus) x1_minus x3_minus x4_minus x6_minus) 1)) (check-sat) (exit) opensmt-2.5.2/regression/QF_LIA/slacks/10-13.slack.smt2.expected.err000066400000000000000000000000001445011647600245710ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LIA/slacks/10-13.slack.smt2.expected.out000066400000000000000000000000041445011647600246140ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LRA/000077500000000000000000000000001445011647600164015ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/LRA_test.smt2000066400000000000000000000001611445011647600206630ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun f () Real) (declare-fun b () Bool) (assert (> 0 (ite b f 1))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/LRA_test.smt2.expected.err000066400000000000000000000000001445011647600232420ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/LRA_test.smt2.expected.out000066400000000000000000000000041445011647600232650ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LRA/LRA_test.smt2.expected.time000066400000000000000000000000751445011647600234240ustar00rootroot00000000000000Command terminated by signal 11 real 0.19 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/LRA_test2.smt2000066400000000000000000000000661445011647600207510ustar00rootroot00000000000000(set-logic QF_LRA) (assert (> (- 1 2) 0)) (check-sat) opensmt-2.5.2/regression/QF_LRA/LRA_test2.smt2.expected.err000066400000000000000000000000001445011647600233240ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/LRA_test2.smt2.expected.out000066400000000000000000000000061445011647600233510ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LRA/LRA_test2.smt2.expected.time000066400000000000000000000000351445011647600235020ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/Ultimate_half_2.i_3_6_2.bpl_7_simplified.1.smt2000066400000000000000000000126551445011647600267050ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun _substvar_4_ () Real) (declare-fun _substvar_7_ () Real) (declare-fun _substvar_9_ () Real) (declare-fun _substvar_20_ () Real) (declare-fun _substvar_21_ () Real) (declare-fun _substvar_22_ () Real) (declare-fun _substvar_23_ () Real) (declare-fun motzkin_1639_2 () Real) (declare-fun motzkin_1639_3 () Real) (declare-fun motzkin_1639_4 () Real) (declare-fun motzkin_1639_5 () Real) (declare-fun motzkin_1640_3 () Real) (declare-fun motzkin_1640_4 () Real) (declare-fun motzkin_1640_6 () Real) (declare-fun motzkin_1651_2 () Real) (declare-fun motzkin_1651_3 () Real) (declare-fun motzkin_1652_0 () Real) (declare-fun motzkin_1652_2 () Real) (declare-fun motzkin_1652_3 () Real) (assert (>= _substvar_23_ 0.0)) (assert (>= motzkin_1639_3 0.0)) (assert (or (and (= (+ _substvar_20_ motzkin_1639_4) 0.0) (= (+ motzkin_1639_2 motzkin_1639_3) 0.0) (= (+ motzkin_1639_5 _substvar_23_) 0.0) (< (+ _substvar_23_ motzkin_1639_3) 0.0) ) (and (= (+ (* motzkin_1639_2 (- 1.0)) motzkin_1639_4) 0.0) (= (+ (* (- 1.0) _substvar_22_) motzkin_1639_2 motzkin_1639_3 (* motzkin_1639_4 (- 1.0))) 0.0) (= (+ _substvar_20_ motzkin_1639_5 _substvar_23_) 0.0) (<= (+ (* (- 1.0) _substvar_23_) (* motzkin_1639_3 2147483648.0)) 0.0) ) ) ) (assert (or (and (= motzkin_1640_4 0.0) (= _substvar_23_ 0.0) (< (+ _substvar_23_ _substvar_20_) 0.0) ) (and (= motzkin_1640_4 0.0) (= motzkin_1640_3 0.0) (= motzkin_1640_6 0.0) (<= _substvar_20_ 0.0) ) ) ) (assert (or (and (= motzkin_1651_3 0.0) (< (+ _substvar_23_ _substvar_23_ _substvar_23_) 0.0) ) (and (= _substvar_20_ 0.0) (< _substvar_20_ 0.0) ) (and (= (+ _substvar_20_ (* motzkin_1651_3 (- 1.0)) _substvar_21_) 0.0) (<= _substvar_20_ 0.0) ) (and (= motzkin_1651_2 0.0) (<= (+ _substvar_23_ _substvar_20_) 0.0) (< (+ _substvar_23_ _substvar_20_ _substvar_23_ _substvar_23_) 0.0) ) (<= (+ _substvar_20_ (* motzkin_1651_2 (- 1.0))) 0.0) (= (+ motzkin_1651_3 _substvar_23_) 0.0) (and (= (+ _substvar_20_ (* motzkin_1651_3 (- 1.0)) _substvar_21_) 0.0) (= (+ motzkin_1651_3 _substvar_22_) 0.0) ) (and (= (+ _substvar_20_ (* motzkin_1651_3 (- 1.0))) 0.0) (= (+ motzkin_1651_3 _substvar_20_) 0.0) (< (+ _substvar_23_ _substvar_23_ _substvar_20_ _substvar_23_ _substvar_23_) 0.0) ) (and (= _substvar_20_ 0.0) (= (+ motzkin_1651_3 _substvar_20_ _substvar_20_) 0.0) ) (and (= (+ _substvar_20_ (* motzkin_1651_3 (- 1.0)) _substvar_21_ _substvar_20_) 0.0) (= (+ motzkin_1651_3 _substvar_22_ _substvar_20_) 0.0) (< (+ _substvar_23_ _substvar_23_ _substvar_23_ _substvar_23_ _substvar_23_ _substvar_20_) 0.0) ) (= (+ motzkin_1651_3 _substvar_20_ _substvar_20_ _substvar_20_) 0.0) (and (= (+ motzkin_1651_3 _substvar_20_ _substvar_20_) 0.0) (<= _substvar_20_ 0.0) ) (and (= motzkin_1651_2 0.0) (= (+ motzkin_1651_3 _substvar_20_) 0.0) (<= (+ (* _substvar_20_ 2.0) (* motzkin_1651_2 (- 1.0)) (* motzkin_1651_3 (- 1.0)) _substvar_20_) 0.0) ) (and (= (+ motzkin_1651_2 _substvar_20_) 0.0) (= _substvar_20_ 0.0) (= (+ _substvar_20_ (* motzkin_1651_3 (- 1.0)) _substvar_21_ _substvar_20_) 0.0) (= (+ motzkin_1651_3 _substvar_22_ _substvar_20_) 0.0) (<= (+ (* _substvar_20_ 3.0) (* motzkin_1651_2 (- 1.0)) (* motzkin_1651_3 (- 1.0))) 0.0) ) ) ) (assert (or (and (= motzkin_1652_2 0.0) (< motzkin_1652_0 0.0) ) (= (+ motzkin_1652_3 _substvar_23_) 0.0) (and (= _substvar_20_ 0.0) (< (+ motzkin_1652_0 _substvar_23_) 0.0) ) (and (= (+ (* motzkin_1652_3 (- 1.0)) (* 1.0 _substvar_21_)) 0.0) (= (+ motzkin_1652_3 _substvar_22_) 0.0) (<= (+ motzkin_1652_0 (* (- 1.0) _substvar_20_)) 0.0) ) (and (= (+ motzkin_1652_3 _substvar_20_) 0.0) (< (+ motzkin_1652_0 _substvar_20_) 0.0) ) (and (= (* motzkin_1652_3 (- 1.0)) 0.0) (= (+ motzkin_1652_3 (* (- 1.0) _substvar_20_)) 0.0) ) (and (= _substvar_21_ 0.0) (= (+ motzkin_1652_3 _substvar_22_ _substvar_20_) 0.0) (<= (+ motzkin_1652_0 _substvar_23_ _substvar_23_) 0.0) (< (+ motzkin_1652_0 _substvar_23_ _substvar_23_) 0.0) ) (and (= (+ (* motzkin_1652_0 (- 1.0)) motzkin_1652_2) 0.0) (= _substvar_20_ 0.0) (= (+ (* motzkin_1652_3 (- 1.0)) _substvar_21_) 0.0) ) (and (= _substvar_20_ 0.0) (<= (+ motzkin_1652_0 _substvar_20_) 0.0) ) (and (= _substvar_23_ 0.0) (<= (+ motzkin_1652_0 (* motzkin_1652_3 (- 1.0))) 0.0) ) (and (= (+ (* motzkin_1652_3 (- 1.0)) _substvar_20_) 0.0) (= (+ motzkin_1652_3 _substvar_20_) 0.0) ) (and (= motzkin_1652_0 0.0) (= (+ (* motzkin_1652_0 (- 1.0)) motzkin_1652_2 _substvar_20_) 0.0) (= (+ (* motzkin_1652_3 (- 1.0)) _substvar_21_ _substvar_20_) 0.0) (= motzkin_1652_3 0.0) (<= (+ motzkin_1652_0 _substvar_20_ _substvar_23_) 0.0) (or (< (+ motzkin_1652_0 (* motzkin_1652_3 (- 1.0)) _substvar_23_ _substvar_20_ _substvar_20_) 0.0) ) ) (and (= (+ motzkin_1652_0 (* motzkin_1652_2 (- 1.0)) (* (- 1.0) _substvar_20_)) 0.0) (= (+ (* motzkin_1652_3 (- 1.0)) _substvar_21_ _substvar_20_) 0.0) (= (+ motzkin_1652_3 _substvar_22_ _substvar_20_) 0.0) ) ) ) (assert (or (and (= _substvar_23_ 0.0) (< _substvar_9_ 0.0) ) (and (= (+ _substvar_4_ (* _substvar_7_ 2.0)) 0.0) (= (+ _substvar_23_ _substvar_21_) 0.0) (= (+ (* _substvar_23_ (- 1.0)) (* _substvar_7_ (- 1.0))) 0.0) (< (+ (* _substvar_4_ (- 1.0)) _substvar_7_ _substvar_23_) 0.0) ) ) ) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/Ultimate_half_2.i_3_6_2.bpl_7_simplified.1.smt2.expected.err000066400000000000000000000000001445011647600312510ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/Ultimate_half_2.i_3_6_2.bpl_7_simplified.1.smt2.expected.out000066400000000000000000000000041445011647600312740ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LRA/Ultimate_half_2.i_3_6_2.bpl_7_simplified.1.smt2.expected.time000066400000000000000000000000351445011647600314270ustar00rootroot00000000000000real 0.02 user 0.02 sys 0.00 opensmt-2.5.2/regression/QF_LRA/bignum_lra1.smt2000066400000000000000000000014111445011647600214050ustar00rootroot00000000000000(set-logic QF_LRA) (set-info :source | SMT-COMP'06 organizers |) (set-info :smt-lib-version 2.0) (set-info :category "check") (set-info :status sat) (set-info :notes |This benchmark is designed to check if the DP supports bignumbers.|) (declare-fun x1 () Real) (declare-fun x2 () Real) (declare-fun x3 () Real) (declare-fun x4 () Real) (declare-fun x5 () Real) (declare-fun x6 () Real) (assert (and (or (= x1 (/ 1 100000)) (= x1 (/ 1 100002))) (or (= x2 (* (/ 1 120030) x1)) (= x2 (* (/ 1 10003) x1))) (or (= x3 (* (/ 1 100310) x2)) (= x3 (* (/ 1 199900) x2))) (or (= x4 (* (/ 1 400000) x3)) (= x4 (* (/ 1 800000) x3))) (or (= x5 (* (/ (- 1) 40000) x4)) (= x5 (* (/ (- 1) 8000) x4))) (or (= x6 (* (/ (- 1) 3000) x5)) (= x6 (* (/ (- 1) 2000) x5))) (> x6 0))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/bignum_lra1.smt2.expected.err000066400000000000000000000000001445011647600237650ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/bignum_lra1.smt2.expected.out000066400000000000000000000000041445011647600240100ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LRA/bignum_lra1.smt2.expected.time000066400000000000000000000000351445011647600241430ustar00rootroot00000000000000real 0.01 user 0.01 sys 0.00 opensmt-2.5.2/regression/QF_LRA/bignum_lra2.smt2000066400000000000000000000013631445011647600214140ustar00rootroot00000000000000(set-logic QF_LRA) (set-info :source | SMT-COMP'06 organizers |) (set-info :smt-lib-version 2.0) (set-info :category "check") (set-info :notes |This benchmark is designed to check if the DP supports bignumbers.|) (declare-fun x1 () Real) (declare-fun x2 () Real) (declare-fun x3 () Real) (declare-fun x4 () Real) (declare-fun x5 () Real) (declare-fun x6 () Real) (assert (and (or (= x1 (/ 1 100000)) (= x1 (/ 1 100002))) (or (= x2 (* (/ 1 120030) x1)) (= x2 (* (/ 1 10003) x1))) (or (= x3 (* (/ 1 100310) x2)) (= x3 (* (/ 1 199900) x2))) (or (= x4 (* (/ 1 400000) x3)) (= x4 (* (/ 1 800000) x3))) (or (= x5 (* (/ (- 1) 40000) x4)) (= x5 (* (/ (- 1) 8000) x4))) (or (= x6 (* (/ (- 1) 3000) x5)) (= x6 (* (/ (- 1) 2000) x5))) (<= x6 0))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/bignum_lra2.smt2.expected.err000066400000000000000000000000001445011647600237660ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/bignum_lra2.smt2.expected.out000066400000000000000000000000061445011647600240130ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LRA/bignum_lra2.smt2.expected.time000066400000000000000000000000351445011647600241440ustar00rootroot00000000000000real 0.01 user 0.01 sys 0.00 opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified0.smt2000066400000000000000000000001611445011647600236740ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun v () Real) (assert (or (= 0.0 (* (/ 1 120030) v)) (= 0.0 v))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified0.smt2.expected.err000066400000000000000000000000001445011647600262530ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified0.smt2.expected.out000066400000000000000000000000041445011647600262760ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified0.smt2.expected.time000066400000000000000000000000351445011647600264310ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified1.smt2000066400000000000000000000002451445011647600237000ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun v () Real) (assert (and (or (= v (/ 1 100000)) (= v (/ 1 100002))) (or (= 0.0 v) (= 0.0 (* (/ 1 10003) v))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified1.smt2.expected.err000066400000000000000000000000001445011647600262540ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified1.smt2.expected.out000066400000000000000000000000061445011647600263010ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified1.smt2.expected.time000066400000000000000000000000351445011647600264320ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified3.smt2000066400000000000000000000003201445011647600236740ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun v3 () Real) (declare-fun v2 () Real) (assert (and (or (= v3 (/ 1 100000)) (= v3 (/ 1 100002))) (or (= v3 (* (/ 1 120030) v3)) (= v3 v2)) (= 0.0 v2) )) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified3.smt2.expected.err000066400000000000000000000000001445011647600262560ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified3.smt2.expected.out000066400000000000000000000000061445011647600263030ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified3.smt2.expected.time000066400000000000000000000000351445011647600264340ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified3a.smt2000066400000000000000000000001431445011647600240400ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun v3 () Real) (assert (= v3 (* (/ 1 120030) v3))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified3a.smt2.expected.err000066400000000000000000000000001445011647600264170ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified3a.smt2.expected.out000066400000000000000000000000041445011647600264420ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified3a.smt2.expected.time000066400000000000000000000000351445011647600265750ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified4b.smt2000066400000000000000000000002141445011647600240410ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun v0 () Real) (declare-fun v2 () Real) (assert (and (= v0 v2) (or (= 0 v0) (= 0 v2)))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified4b.smt2.expected.err000066400000000000000000000000001445011647600264210ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified4b.smt2.expected.out000066400000000000000000000000041445011647600264440ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified4b.smt2.expected.time000066400000000000000000000000351445011647600265770ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified4c.smt2000066400000000000000000000012311445011647600240420ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun v2 () Real) (declare-fun v0 () Real) (assert (and (or (= v2 1) (= v2 (/ 1 2))) (or (= v0 v2) (= v0 (* 2 v2))) (or (= 0.0 v0) (= 0.0 v2)))) (check-sat) (exit) ;(and ; v2 = 0 or v0 = 0 ; (or (and (<= 0 v2) ; (<= 0 (* v2 -1))) ; (and (<= 0 v0) ; (<= 0 (* v0 -1)))) ; v2 = 1/2*v0, i.e., v0 = 2*v2 or v0 = v2 ; (or (and (<= 0 (+ v2 (* v0 -1/2))) ; (<= 0 (+ (* v2 -1) (* 1/2 v0)))) ; (and (<= 0 (+ v0 (* v2 -1))) ; (<= 0 (+ v2 (* v0 -1))))) ; v2 = 1/2 or v2 = 1 ; (or (and (<= -1/2 (* v2 -1)) ; (<= 1/2 v2)) ; (and (<= 1 v2) ; (<= -1 (* v2 -1))))) opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified4c.smt2.expected.err000066400000000000000000000000001445011647600264220ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified4c.smt2.expected.out000066400000000000000000000000061445011647600264470ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LRA/bignum_lra2_simplified4c.smt2.expected.time000066400000000000000000000000351445011647600266000ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/chainable_inequality.smt2000066400000000000000000000002541445011647600233630ustar00rootroot00000000000000(set-logic QF_LRA) (set-info :status unsat) (declare-fun a () Real) (declare-fun b () Real) (declare-fun c () Real) (assert (<= a b c)) (assert (> a c)) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/chainable_inequality.smt2.expected.err000066400000000000000000000000001445011647600257370ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/chainable_inequality.smt2.expected.out000066400000000000000000000000061445011647600257640ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LRA/clocksynchro_2clocks.worst_case_skew.induct.smt2000066400000000000000000000110461445011647600300210ustar00rootroot00000000000000(set-logic QF_LRA) (set-info :source | Clock Synchronization. Bruno Dutertre (bruno@csl.sri.com) |) (set-info :smt-lib-version 2.0) (set-info :category "industrial") (declare-fun x_0 () Real) (declare-fun x_1 () Real) (declare-fun x_2 () Real) (declare-fun x_3 () Real) (declare-fun x_4 () Real) (declare-fun x_5 () Real) (declare-fun x_6 () Real) (declare-fun x_7 () Real) (declare-fun x_8 () Real) (declare-fun x_9 () Real) (declare-fun x_10 () Real) (declare-fun x_11 () Real) (declare-fun x_12 () Real) (declare-fun x_13 () Real) (declare-fun x_14 () Real) (declare-fun x_15 () Real) (declare-fun x_16 () Real) (declare-fun x_17 () Real) (declare-fun x_18 () Real) (declare-fun x_19 () Real) (declare-fun x_20 () Real) (declare-fun x_21 () Real) (declare-fun x_22 () Real) (declare-fun x_23 () Real) (declare-fun x_24 () Real) (declare-fun x_25 () Real) (declare-fun x_26 () Real) (declare-fun x_27 () Real) (assert (let ((?v_21 (<= x_7 x_12)) (?v_25 (<= x_10 x_12)) (?v_9 (= x_19 x_12)) (?v_10 (= x_20 x_12))) (let ((?v_15 (not ?v_9)) (?v_18 (not ?v_10)) (?v_8 (+ (+ x_12 x_13) x_14))) (let ((?v_22 (= x_19 ?v_8)) (?v_26 (= x_20 ?v_8))) (let ((?v_35 (not ?v_22))) (let ((?v_29 (and ?v_21 ?v_35)) (?v_36 (not ?v_26))) (let ((?v_32 (and ?v_25 ?v_36)) (?v_2 (- x_1 x_6)) (?v_3 (- x_7 x_8)) (?v_4 (- x_2 x_9)) (?v_5 (- x_10 x_11)) (?v_6 (- x_12 x_17)) (?v_7 (- x_12 x_18)) (?v_11 (- x_1 x_4)) (?v_12 (- x_7 x_21)) (?v_13 (- x_2 x_5)) (?v_14 (- x_10 x_22)) (?v_16 (- x_1 x_23)) (?v_17 (- x_7 x_12)) (?v_19 (- x_2 x_24)) (?v_20 (- x_10 x_12)) (?v_30 (- x_23 x_4))) (let ((?v_23 (* ?v_30 1000)) (?v_24 (* (- x_23 x_5) 1000)) (?v_27 (* (- x_24 x_4) 1000)) (?v_33 (- x_24 x_5))) (let ((?v_28 (* ?v_33 1000)) (?v_31 (- x_12 x_21)) (?v_34 (- x_12 x_22)) (?v_37 (- x_6 x_23)) (?v_39 (- x_9 x_24)) (?v_0 (+ x_0 (/ 1001 1000))) (?v_1 (+ x_3 (/ 1001 1000))) (?v_38 (* (* x_14 999) (/ 1 1000))) (?v_40 (* (* x_14 1001) (/ 1 1000))) (?v_41 (+ (+ (+ x_15 x_16) (* (* (+ x_17 x_14) 2) (/ 1 999))) (/ 2335 666)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (<= x_13 0)) (not (<= x_14 0))) (not (<= x_15 0))) (not (< x_16 (+ x_15 (* (* (+ (* (* x_14 1) (/ 1 2)) 1) 1001) (/ 1 999)))))) (< x_17 (- (* (* (- (- x_14 x_16) 1) 999) (/ 1 2)) 1))) (not (< x_17 (* (* (+ (+ (+ x_13 x_15) x_16) (/ 1501 1000)) 1001) (/ 1 999))))) (not (<= x_18 0))) (<= x_18 (- x_13 (+ (+ x_15 (* (* (+ x_14 2) 1001) (/ 1 999))) (/ 1 2))))) (<= x_0 x_1)) (<= x_0 x_2)) (<= x_1 ?v_0)) (<= x_2 ?v_0)) (<= x_3 x_4)) (<= x_3 x_5)) (<= x_4 ?v_1)) (<= x_5 ?v_1)) (<= (* (* ?v_3 999) (/ 1 1000)) ?v_2)) (<= (* (* ?v_5 999) (/ 1 1000)) ?v_4)) (<= ?v_2 (* (* ?v_3 1001) (/ 1 1000)))) (<= ?v_4 (* (* ?v_5 1001) (/ 1 1000)))) (<= ?v_6 x_21)) (<= ?v_6 x_22)) (<= x_21 ?v_7)) (<= x_22 ?v_7)) (<= (- x_21 x_21) x_16)) (<= (- x_22 x_21) x_16)) (<= (- x_21 x_22) x_16)) (<= (- x_22 x_22) x_16)) (or (and ?v_9 (<= x_7 x_25)) ?v_22)) (or (and ?v_10 (<= x_10 x_25)) ?v_26)) (or ?v_9 ?v_10)) (or ?v_15 (and (<= (* (* ?v_12 999) (/ 1 1000)) ?v_11) (<= ?v_11 (* (* ?v_12 1001) (/ 1 1000)))))) (or ?v_18 (and (<= (* (* ?v_14 999) (/ 1 1000)) ?v_13) (<= ?v_13 (* (* ?v_14 1001) (/ 1 1000)))))) (or (or ?v_15 ?v_21) (and (and (not (< x_0 x_23)) (<= (* (* ?v_17 999) (/ 1 1000)) ?v_16)) (<= ?v_16 (* (* ?v_17 1001) (/ 1 1000)))))) (or (or ?v_18 ?v_25) (and (and (not (< x_0 x_24)) (<= (* (* ?v_20 999) (/ 1 1000)) ?v_19)) (<= ?v_19 (* (* ?v_20 1001) (/ 1 1000)))))) (or ?v_29 (and (<= x_26 (+ (+ (* (* (+ (+ (+ x_21 (* ?v_23 (/ 1 999))) x_22) (* ?v_24 (/ 1 999))) 1) (/ 1 2)) x_15) (/ 3001 1998))) (not (< x_26 (- (- (* (* (+ (+ (+ x_21 (* ?v_23 (/ 1 1001))) x_22) (* ?v_24 (/ 1 1001))) 1) (/ 1 2)) x_15) (/ 1 2))))))) (or ?v_32 (and (<= x_27 (+ (+ (* (* (+ (+ (+ x_21 (* ?v_27 (/ 1 999))) x_22) (* ?v_28 (/ 1 999))) 1) (/ 1 2)) x_15) (/ 3001 1998))) (not (< x_27 (- (- (* (* (+ (+ (+ x_21 (* ?v_27 (/ 1 1001))) x_22) (* ?v_28 (/ 1 1001))) 1) (/ 1 2)) x_15) (/ 1 2))))))) (or ?v_29 (and (<= (* (* ?v_31 999) (/ 1 1000)) ?v_30) (<= ?v_30 (* (* ?v_31 1001) (/ 1 1000)))))) (or ?v_32 (and (<= (* (* ?v_34 999) (/ 1 1000)) ?v_33) (<= ?v_33 (* (* ?v_34 1001) (/ 1 1000)))))) (or ?v_35 (= x_8 (+ x_26 x_14)))) (or ?v_36 (= x_11 (+ x_27 x_14)))) (or ?v_35 (and (<= ?v_38 ?v_37) (<= ?v_37 ?v_40)))) (or ?v_36 (and (<= ?v_38 ?v_39) (<= ?v_39 ?v_40)))) (= x_25 (+ x_12 x_14))) (or (or (or (not (<= (- x_7 x_7) ?v_41)) (not (<= (- x_10 x_7) ?v_41))) (not (<= (- x_7 x_10) ?v_41))) (not (<= (- x_10 x_10) ?v_41))))))))))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/clocksynchro_2clocks.worst_case_skew.induct.smt2.expected.err000066400000000000000000000000001445011647600323740ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/clocksynchro_2clocks.worst_case_skew.induct.smt2.expected.out000066400000000000000000000000061445011647600324210ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LRA/clocksynchro_2clocks.worst_case_skew.induct.smt2.expected.time000066400000000000000000000000351445011647600325520ustar00rootroot00000000000000real 0.17 user 0.17 sys 0.00 opensmt-2.5.2/regression/QF_LRA/clocksynchro_2clocks.worst_case_skew.induct_simplified_0.smt2000066400000000000000000000003031445011647600324370ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun v2 () Real) (assert (<= 0.0 (- v2 (+ (+ 0.0 (* (* (+ v2 2) 1001) (/ 1 999))) 0.0)))) (check-sat) (exit) clocksynchro_2clocks.worst_case_skew.induct_simplified_0.smt2.expected.err000066400000000000000000000000001445011647600347410ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRAclocksynchro_2clocks.worst_case_skew.induct_simplified_0.smt2.expected.out000066400000000000000000000000041445011647600347640ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRAsat clocksynchro_2clocks.worst_case_skew.induct_simplified_0.smt2.expected.time000066400000000000000000000000351445011647600351170ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRAreal 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/clocksynchro_3clocks.worst_case_skew.induct_delta_1.smt2000066400000000000000000000007771445011647600314240ustar00rootroot00000000000000(set-option :ghost-vars 1) (set-logic QF_LRA) (declare-fun v17 () Real) (declare-fun v23 () Real) (declare-fun v31 () Real) (declare-fun v26 () Real) (declare-fun v16 () Real) (assert (let ((?v_11 (= v26 v16)) (?v_13 (= v23 v16))) (and (not (<= v26 0)) (<= v23 v31) (or (or (= v26 v16) (= 0.0 v16)) (= v23 v16)) (or (<= v17 v16) (and (<= v31 0.0) (<= 0.0 v17))) (or (or (not (<= v16 v31)) (not (<= v17 v31))) (not (<= (- v17 v16) v31)))))) (check-sat) (exit) clocksynchro_3clocks.worst_case_skew.induct_delta_1.smt2.expected.err000066400000000000000000000000001445011647600337070ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRAclocksynchro_3clocks.worst_case_skew.induct_delta_1.smt2.expected.out000066400000000000000000000000041445011647600337320ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRAsat opensmt-2.5.2/regression/QF_LRA/constraints-cooking01-assignment.smt2000066400000000000000000000036041445011647600255200ustar00rootroot00000000000000(set-logic QF_LRA) (set-info :source | TLP-GP automated DTP to SMT-LIB encoding for planning by F.Maris and P.Regnier, IRIT - Universite Paul Sabatier, Toulouse |) (set-info :smt-lib-version 2.0) (set-info :category "industrial") (declare-fun spy () Real) (declare-fun I_0 () Real) (declare-fun G_6 () Real) (declare-fun EGGS () Real) (declare-fun OIL () Real) (declare-fun LARD () Real) (declare-fun FIRE () Real) (declare-fun WATER () Real) (declare-fun NOODLES () Real) (declare-fun COOKING () Real) (declare-fun EATING () Real) (assert (and (!(= spy (+ 1 I_0)) :named spy_n) (!(>= G_6 I_0) :named goal) (!(>= (- EGGS I_0) 0) :named eggs_after) (!(>= (- G_6 EGGS) 2) :named eggs_before) (!(>= (- OIL I_0) 0) :named oil_after) (!(>= (- G_6 OIL) 10) :named oil_before) (!(>= (- LARD I_0) 0) :named lard_after) (!(>= (- G_6 LARD) 13) :named lard_before) (!(>= (- FIRE I_0) 0) :named fire_before) (>= (- G_6 FIRE) 15) (>= (- WATER I_0) 0) (>= (- G_6 WATER) 10) (>= (- NOODLES I_0) 0) (>= (- G_6 NOODLES) 14) (>= (- COOKING I_0) 0) (>= (- G_6 COOKING) 1) (>= (- EATING I_0) 0) (>= (- G_6 EATING) 5) (<= (- EATING LARD) 8) (< (- EATING LARD) 8) (>= (- EATING LARD) 5) (<= (- EATING NOODLES) 17) (< (- EATING NOODLES) 17) (>= (- EATING NOODLES) 6) (>= (- COOKING EGGS) 2) (<= (- WATER FIRE) 5) (<= (- OIL FIRE) 5) (< (- OIL FIRE) 5) (>= (- OIL FIRE) 1) (>= (- LARD OIL) 2) (>= (- COOKING LARD) 5) (<= (- WATER FIRE) 5) (>= (- WATER FIRE) 1) (>= (- NOODLES WATER) 2) (>= (- COOKING NOODLES) 6) (>= (- EATING COOKING) 1) (>= (- G_6 EATING) 6))) (check-sat) (get-value (spy I_0 G_6 EGGS OIL LARD FIRE WATER NOODLES COOKING EATING)) (exit) opensmt-2.5.2/regression/QF_LRA/constraints-cooking01-assignment.smt2.expected.err000066400000000000000000000000001445011647600300720ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/constraints-cooking01-assignment.smt2.expected.out000066400000000000000000000001561445011647600301250ustar00rootroot00000000000000sat ((spy 0)(I_0 (- 1))(G_6 16)(EGGS 7)(OIL 1)(LARD 3)(FIRE (- 1))(WATER 0)(NOODLES 2)(COOKING 9)(EATING 10)) opensmt-2.5.2/regression/QF_LRA/constraints-cooking01-assignment.smt2.expected.time000066400000000000000000000000351445011647600302500ustar00rootroot00000000000000real 0.03 user 0.03 sys 0.00 opensmt-2.5.2/regression/QF_LRA/constraints-cooking01-edit.smt2000066400000000000000000000035131445011647600242740ustar00rootroot00000000000000(set-logic QF_LRA) (set-info :source | TLP-GP automated DTP to SMT-LIB encoding for planning by F.Maris and P.Regnier, IRIT - Universite Paul Sabatier, Toulouse |) (set-info :smt-lib-version 2.0) (set-info :category "industrial") (declare-fun spy () Real) (declare-fun I_0 () Real) (declare-fun G_6 () Real) (declare-fun EGGS () Real) (declare-fun OIL () Real) (declare-fun LARD () Real) (declare-fun FIRE () Real) (declare-fun WATER () Real) (declare-fun NOODLES () Real) (declare-fun COOKING () Real) (declare-fun EATING () Real) (assert (and (!(= spy (+ 1 I_0)) :named spy_n) (!(>= G_6 I_0) :named goal) (!(>= (- EGGS I_0) 0) :named eggs_after) (!(>= (- G_6 EGGS) 2) :named eggs_before) (!(>= (- OIL I_0) 0) :named oil_after) (!(>= (- G_6 OIL) 10) :named oil_before) (!(>= (- LARD I_0) 0) :named lard_after) (!(>= (- G_6 LARD) 13) :named lard_before) (!(>= (- FIRE I_0) 0) :named fire_before) (>= (- G_6 FIRE) 15) (>= (- WATER I_0) 0) (>= (- G_6 WATER) 10) (>= (- NOODLES I_0) 0) (>= (- G_6 NOODLES) 14) (>= (- COOKING I_0) 0) (>= (- G_6 COOKING) 1) (>= (- EATING I_0) 0) (>= (- G_6 EATING) 5) (<= (- EATING LARD) 8) (< (- EATING LARD) 8) (>= (- EATING LARD) 5) (<= (- EATING NOODLES) 17) (< (- EATING NOODLES) 17) (>= (- EATING NOODLES) 6) (>= (- COOKING EGGS) 2) (<= (- WATER FIRE) 5) (<= (- OIL FIRE) 5) (< (- OIL FIRE) 5) (>= (- OIL FIRE) 1) (>= (- LARD OIL) 2) (>= (- COOKING LARD) 5) (<= (- WATER FIRE) 5) (>= (- WATER FIRE) 1) (>= (- NOODLES WATER) 2) (>= (- COOKING NOODLES) 6) (>= (- EATING COOKING) 1) (>= (- G_6 EATING) 6))) (check-sat) (get-assignment) (exit) opensmt-2.5.2/regression/QF_LRA/constraints-cooking01-edit.smt2.expected.err000066400000000000000000000000001445011647600266470ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/constraints-cooking01-edit.smt2.expected.out000066400000000000000000000002611445011647600266770ustar00rootroot00000000000000sat ((spy_n unknown) (goal unknown) (eggs_after unknown) (eggs_before true) (oil_after unknown) (oil_before true) (lard_after unknown) (lard_before true) (fire_before unknown)) opensmt-2.5.2/regression/QF_LRA/constraints-cooking01-edit.smt2.expected.time000066400000000000000000000000351445011647600270250ustar00rootroot00000000000000real 0.02 user 0.02 sys 0.00 opensmt-2.5.2/regression/QF_LRA/constraints-cooking01-edit2.smt2000066400000000000000000000034721445011647600243620ustar00rootroot00000000000000(set-logic QF_LRA) (set-info :source | TLP-GP automated DTP to SMT-LIB encoding for planning by F.Maris and P.Regnier, IRIT - Universite Paul Sabatier, Toulouse |) (set-info :smt-lib-version 2.0) (set-info :category "industrial") (declare-fun spy () Real) (declare-fun I_0 () Real) (declare-fun G_6 () Real) (declare-fun EGGS () Real) (declare-fun OIL () Real) (declare-fun LARD () Real) (declare-fun FIRE () Real) (declare-fun WATER () Real) (declare-fun NOODLES () Real) (declare-fun COOKING () Real) (declare-fun EATING () Real) (assert (and (!(= spy (+ 1 I_0)) :named spy_n) (!(>= G_6 I_0) :named goal) (!(>= (- EGGS I_0) 0) :named eggs_after) (!(>= (- G_6 EGGS) 2) :named eggs_before) (!(>= (- OIL I_0) 0) :named oil_after) (!(>= (- G_6 OIL) 10) :named oil_before) (!(>= (- LARD I_0) 0) :named lard_after) (!(>= (- G_6 LARD) 13) :named lard_before) (!(>= (- FIRE I_0) 0) :named fire_before) (>= (- G_6 FIRE) 15) (>= (- WATER I_0) 0) (>= (- G_6 WATER) 10) (>= (- NOODLES I_0) 0) (>= (- G_6 NOODLES) 14) (>= (- COOKING I_0) 0) (>= (- G_6 COOKING) 1) (>= (- EATING I_0) 0) (>= (- G_6 EATING) 5) (<= (- EATING LARD) 8) (< (- EATING LARD) 8) (>= (- EATING LARD) 5) (<= (- EATING NOODLES) 17) (< (- EATING NOODLES) 17) (>= (- EATING NOODLES) 6) (>= (- COOKING EGGS) 2) (<= (- WATER FIRE) 5) (<= (- OIL FIRE) 5) (< (- OIL FIRE) 5) (>= (- OIL FIRE) 1) (>= (- LARD OIL) 2) (>= (- COOKING LARD) 5) (<= (- WATER FIRE) 5) (>= (- WATER FIRE) 1) (>= (- NOODLES WATER) 2) (>= (- COOKING NOODLES) 6) (>= (- EATING COOKING) 1) (>= (- G_6 EATING) 6))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/constraints-cooking01-edit2.smt2.expected.err000066400000000000000000000000001445011647600267310ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/constraints-cooking01-edit2.smt2.expected.out000066400000000000000000000000041445011647600267540ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LRA/constraints-cooking01-edit2.smt2.expected.time000066400000000000000000000000351445011647600271070ustar00rootroot00000000000000real 0.02 user 0.01 sys 0.00 opensmt-2.5.2/regression/QF_LRA/constraints-cooking01.smt2000066400000000000000000000052171445011647600233540ustar00rootroot00000000000000(set-logic QF_LRA) (set-info :source | TLP-GP automated DTP to SMT-LIB encoding for planning by F.Maris and P.Regnier, IRIT - Universite Paul Sabatier, Toulouse |) (set-info :smt-lib-version 2.0) (set-info :category "industrial") (set-info :status unknown) (declare-fun St_spy_variable () Real) (declare-fun t_Init_0 () Real) (declare-fun t_Goal_6 () Real) (declare-fun t_BREAKING_EGGS_e1_1 () Real) (declare-fun t_BOILING_OIL_p1_o1_2 () Real) (declare-fun t_COOKING_LARDON_o1_l1_3 () Real) (declare-fun t_FIRE_COOKING_PLATE_p1_1 () Real) (declare-fun t_BOILING_WATER_p1_w1_2 () Real) (declare-fun t_COOKING_NOODLES_w1_n1_3 () Real) (declare-fun t_COOKING_CARBONARA_n1_l1_e1_4 () Real) (declare-fun t_EATING_CARBONARA_n1_l1_e1_5 () Real) (assert (let ( (?v_5 (- t_Goal_6 t_EATING_CARBONARA_n1_l1_e1_5)) (?v_0 (- t_EATING_CARBONARA_n1_l1_e1_5 t_COOKING_LARDON_o1_l1_3)) (?v_1 (- t_EATING_CARBONARA_n1_l1_e1_5 t_COOKING_NOODLES_w1_n1_3)) (?v_4 (- t_BOILING_WATER_p1_w1_2 t_FIRE_COOKING_PLATE_p1_1))) (let ( (?v_3 (<= ?v_4 5)) (?v_2 (- t_BOILING_OIL_p1_o1_2 t_FIRE_COOKING_PLATE_p1_1))) (and (= St_spy_variable (+ 1 t_Init_0)) (>= t_Goal_6 t_Init_0) (>= (- t_BREAKING_EGGS_e1_1 t_Init_0) 0) (>= (- t_Goal_6 t_BREAKING_EGGS_e1_1) 2) (>= (- t_BOILING_OIL_p1_o1_2 t_Init_0) 0) (>= (- t_Goal_6 t_BOILING_OIL_p1_o1_2) 10) (>= (- t_COOKING_LARDON_o1_l1_3 t_Init_0) 0) (>= (- t_Goal_6 t_COOKING_LARDON_o1_l1_3) 13) (>= (- t_FIRE_COOKING_PLATE_p1_1 t_Init_0) 0) (>= (- t_Goal_6 t_FIRE_COOKING_PLATE_p1_1) 15) (>= (- t_BOILING_WATER_p1_w1_2 t_Init_0) 0) (>= (- t_Goal_6 t_BOILING_WATER_p1_w1_2) 10) (>= (- t_COOKING_NOODLES_w1_n1_3 t_Init_0) 0) (>= (- t_Goal_6 t_COOKING_NOODLES_w1_n1_3) 14) (>= (- t_COOKING_CARBONARA_n1_l1_e1_4 t_Init_0) 0) (>= (- t_Goal_6 t_COOKING_CARBONARA_n1_l1_e1_4) 1) (>= (- t_EATING_CARBONARA_n1_l1_e1_5 t_Init_0) 0) (>= ?v_5 5) (<= ?v_0 8) (< ?v_0 8) (>= ?v_0 5) (<= ?v_1 17) (< ?v_1 17) (>= ?v_1 6) (>= (- t_COOKING_CARBONARA_n1_l1_e1_4 t_BREAKING_EGGS_e1_1) 2) ?v_3 (<= ?v_2 5) (< ?v_2 5) (>= ?v_2 1) (>= (- t_COOKING_LARDON_o1_l1_3 t_BOILING_OIL_p1_o1_2) 2) (>= (- t_COOKING_CARBONARA_n1_l1_e1_4 t_COOKING_LARDON_o1_l1_3) 5) ?v_3 (>= ?v_4 1) (>= (- t_COOKING_NOODLES_w1_n1_3 t_BOILING_WATER_p1_w1_2) 2) (>= (- t_COOKING_CARBONARA_n1_l1_e1_4 t_COOKING_NOODLES_w1_n1_3) 6) (>= (- t_EATING_CARBONARA_n1_l1_e1_5 t_COOKING_CARBONARA_n1_l1_e1_4) 1) (>= ?v_5 6))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/constraints-cooking01.smt2.expected.err000066400000000000000000000000001445011647600257240ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/constraints-cooking01.smt2.expected.out000066400000000000000000000000041445011647600257470ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LRA/constraints-cooking01.smt2.expected.time000066400000000000000000000000351445011647600261020ustar00rootroot00000000000000real 0.02 user 0.02 sys 0.00 opensmt-2.5.2/regression/QF_LRA/constraints-temporal-machine-shop-2-3-A04.smt2000066400000000000000000000164461445011647600266050ustar00rootroot00000000000000(set-logic QF_LRA) (set-info :source | TLP-GP automated DTP to SMT-LIB encoding for planning by F.Maris and P.Regnier, IRIT - Universite Paul Sabatier, Toulouse |) (set-info :smt-lib-version 2.0) (set-info :category "industrial") (declare-fun St_spy_variable () Real) (declare-fun t_Init_0 () Real) (declare-fun t_Goal_6 () Real) (declare-fun t_BAKE_CERAMIC2_p2_k2_2 () Real) (declare-fun t_TREAT_CERAMIC2_p2_3 () Real) (declare-fun t_BAKE_CERAMIC2_p2_k2_3 () Real) (declare-fun t_BAKE_CERAMIC1_p1_k2_2 () Real) (declare-fun t_TREAT_CERAMIC1_p1_3 () Real) (declare-fun t_FIRE_KILN2_k2_2 () Real) (declare-fun t_BAKE_CERAMIC1_p1_k2_3 () Real) (declare-fun t_MAKE_STRUCTURE_p1_p2_4 () Real) (declare-fun t_BAKE_STRUCTURE_p1_p2_k1_5 () Real) (declare-fun t_BAKE_CERAMIC3_p4_k2_2 () Real) (declare-fun t_TREAT_CERAMIC3_p4_3 () Real) (declare-fun t_BAKE_CERAMIC3_p4_k1_3 () Real) (declare-fun t_FIRE_KILN2_k2_1 () Real) (declare-fun t_BAKE_CERAMIC3_p3_k2_2 () Real) (declare-fun t_TREAT_CERAMIC3_p3_3 () Real) (declare-fun t_FIRE_KILN1_k1_2 () Real) (declare-fun t_BAKE_CERAMIC3_p3_k1_3 () Real) (declare-fun t_MAKE_STRUCTURE_p3_p4_4 () Real) (declare-fun t_FIRE_KILN1_k1_1 () Real) (declare-fun t_BAKE_STRUCTURE_p3_p4_k1_5 () Real) (assert (let ((?v_11 (- t_Goal_6 t_BAKE_STRUCTURE_p1_p2_k1_5)) (?v_21 (- t_Goal_6 t_BAKE_STRUCTURE_p3_p4_k1_5)) (?v_15 (- t_BAKE_CERAMIC3_p3_k2_2 t_FIRE_KILN2_k2_1))) (let ((?v_2 (<= ?v_15 15)) (?v_12 (- t_BAKE_CERAMIC3_p4_k2_2 t_FIRE_KILN2_k2_1))) (let ((?v_3 (<= ?v_12 15)) (?v_7 (- t_BAKE_CERAMIC1_p1_k2_2 t_FIRE_KILN2_k2_1))) (let ((?v_4 (<= ?v_7 5)) (?v_6 (- t_BAKE_CERAMIC2_p2_k2_3 t_FIRE_KILN2_k2_1))) (let ((?v_5 (<= ?v_6 10)) (?v_0 (- t_BAKE_CERAMIC2_p2_k2_2 t_FIRE_KILN2_k2_1)) (?v_1 (- t_TREAT_CERAMIC2_p2_3 t_BAKE_CERAMIC2_p2_k2_2)) (?v_8 (- t_TREAT_CERAMIC1_p1_3 t_BAKE_CERAMIC1_p1_k2_2)) (?v_9 (- t_BAKE_CERAMIC1_p1_k2_3 t_FIRE_KILN2_k2_2)) (?v_20 (- t_BAKE_STRUCTURE_p3_p4_k1_5 t_FIRE_KILN1_k1_1))) (let ((?v_19 (<= ?v_20 5)) (?v_10 (- t_BAKE_STRUCTURE_p1_p2_k1_5 t_FIRE_KILN1_k1_1)) (?v_13 (- t_TREAT_CERAMIC3_p4_3 t_BAKE_CERAMIC3_p4_k2_2)) (?v_18 (- t_BAKE_CERAMIC3_p3_k1_3 t_FIRE_KILN1_k1_2))) (let ((?v_17 (<= ?v_18 3)) (?v_14 (- t_BAKE_CERAMIC3_p4_k1_3 t_FIRE_KILN1_k1_2)) (?v_16 (- t_TREAT_CERAMIC3_p3_3 t_BAKE_CERAMIC3_p3_k2_2)) (?v_29 (- t_BAKE_CERAMIC1_p1_k2_3 t_FIRE_KILN2_k2_1)) (?v_28 (> (- t_FIRE_KILN2_k2_2 t_FIRE_KILN2_k2_1) 20))) (let ((?v_24 (or (<= ?v_29 5) ?v_28)) (?v_25 (> (- t_FIRE_KILN2_k2_1 t_FIRE_KILN2_k2_2) 20)) (?v_23 (- t_BAKE_CERAMIC2_p2_k2_2 t_BAKE_CERAMIC2_p2_k2_3)) (?v_22 (- t_BAKE_CERAMIC2_p2_k2_3 t_BAKE_CERAMIC2_p2_k2_2)) (?v_27 (- t_BAKE_CERAMIC1_p1_k2_2 t_BAKE_CERAMIC1_p1_k2_3)) (?v_26 (- t_BAKE_CERAMIC1_p1_k2_3 t_BAKE_CERAMIC1_p1_k2_2)) (?v_38 (- t_BAKE_CERAMIC3_p3_k1_3 t_FIRE_KILN1_k1_1)) (?v_30 (> (- t_FIRE_KILN1_k1_2 t_FIRE_KILN1_k1_1) 8)) (?v_34 (- t_BAKE_CERAMIC3_p4_k1_3 t_FIRE_KILN1_k1_1)) (?v_33 (> (- t_FIRE_KILN1_k1_1 t_FIRE_KILN1_k1_2) 8)) (?v_32 (- t_BAKE_CERAMIC3_p4_k2_2 t_BAKE_CERAMIC3_p4_k1_3)) (?v_31 (- t_BAKE_CERAMIC3_p4_k1_3 t_BAKE_CERAMIC3_p4_k2_2))) (let ((?v_37 (or (<= (- t_BAKE_STRUCTURE_p3_p4_k1_5 t_FIRE_KILN1_k1_2) 5) ?v_33)) (?v_36 (- t_BAKE_CERAMIC3_p3_k2_2 t_BAKE_CERAMIC3_p3_k1_3)) (?v_35 (- t_BAKE_CERAMIC3_p3_k1_3 t_BAKE_CERAMIC3_p3_k2_2))) (and (= St_spy_variable (+ 1 t_Init_0)) (>= t_Goal_6 t_Init_0) (>= (- t_BAKE_CERAMIC2_p2_k2_2 t_Init_0) 0) (>= (- t_Goal_6 t_BAKE_CERAMIC2_p2_k2_2) 10) (>= (- t_TREAT_CERAMIC2_p2_3 t_Init_0) 0) (>= (- t_Goal_6 t_TREAT_CERAMIC2_p2_3) 2) (>= (- t_BAKE_CERAMIC2_p2_k2_3 t_Init_0) 0) (>= (- t_Goal_6 t_BAKE_CERAMIC2_p2_k2_3) 10) (>= (- t_BAKE_CERAMIC1_p1_k2_2 t_Init_0) 0) (>= (- t_Goal_6 t_BAKE_CERAMIC1_p1_k2_2) 15) (>= (- t_TREAT_CERAMIC1_p1_3 t_Init_0) 0) (>= (- t_Goal_6 t_TREAT_CERAMIC1_p1_3) 3) (>= (- t_FIRE_KILN2_k2_2 t_Init_0) 0) (>= (- t_Goal_6 t_FIRE_KILN2_k2_2) 20) (>= (- t_BAKE_CERAMIC1_p1_k2_3 t_Init_0) 0) (>= (- t_Goal_6 t_BAKE_CERAMIC1_p1_k2_3) 15) (>= (- t_MAKE_STRUCTURE_p1_p2_4 t_Init_0) 0) (>= (- t_Goal_6 t_MAKE_STRUCTURE_p1_p2_4) 1) (>= (- t_BAKE_STRUCTURE_p1_p2_k1_5 t_Init_0) 0) (>= ?v_11 3) (>= (- t_BAKE_CERAMIC3_p4_k2_2 t_Init_0) 0) (>= (- t_Goal_6 t_BAKE_CERAMIC3_p4_k2_2) 5) (>= (- t_TREAT_CERAMIC3_p4_3 t_Init_0) 0) (>= (- t_Goal_6 t_TREAT_CERAMIC3_p4_3) 1) (>= (- t_BAKE_CERAMIC3_p4_k1_3 t_Init_0) 0) (>= (- t_Goal_6 t_BAKE_CERAMIC3_p4_k1_3) 5) (>= (- t_FIRE_KILN2_k2_1 t_Init_0) 0) (>= (- t_Goal_6 t_FIRE_KILN2_k2_1) 20) (>= (- t_BAKE_CERAMIC3_p3_k2_2 t_Init_0) 0) (>= (- t_Goal_6 t_BAKE_CERAMIC3_p3_k2_2) 5) (>= (- t_TREAT_CERAMIC3_p3_3 t_Init_0) 0) (>= (- t_Goal_6 t_TREAT_CERAMIC3_p3_3) 1) (>= (- t_FIRE_KILN1_k1_2 t_Init_0) 0) (>= (- t_Goal_6 t_FIRE_KILN1_k1_2) 8) (>= (- t_BAKE_CERAMIC3_p3_k1_3 t_Init_0) 0) (>= (- t_Goal_6 t_BAKE_CERAMIC3_p3_k1_3) 5) (>= (- t_MAKE_STRUCTURE_p3_p4_4 t_Init_0) 0) (>= (- t_Goal_6 t_MAKE_STRUCTURE_p3_p4_4) 1) (>= (- t_FIRE_KILN1_k1_1 t_Init_0) 0) (>= (- t_Goal_6 t_FIRE_KILN1_k1_1) 8) (>= (- t_BAKE_STRUCTURE_p3_p4_k1_5 t_Init_0) 0) (>= ?v_21 3) ?v_2 ?v_3 ?v_4 ?v_5 (<= ?v_0 10) (< ?v_0 10) (>= ?v_0 2) (<= ?v_1 8) (>= ?v_1 0) (>= (- t_MAKE_STRUCTURE_p1_p2_4 t_TREAT_CERAMIC2_p2_3) 2) ?v_2 ?v_3 ?v_4 ?v_5 (< ?v_6 10) (>= ?v_6 2) (>= (- t_MAKE_STRUCTURE_p1_p2_4 t_BAKE_CERAMIC2_p2_k2_3) 10) ?v_2 ?v_3 ?v_4 (< ?v_7 5) (>= ?v_7 2) (<= ?v_8 12) (>= ?v_8 0) (>= (- t_MAKE_STRUCTURE_p1_p2_4 t_TREAT_CERAMIC1_p1_3) 3) (<= ?v_9 5) (>= ?v_9 2) (>= (- t_MAKE_STRUCTURE_p1_p2_4 t_BAKE_CERAMIC1_p1_k2_3) 15) (>= (- t_BAKE_STRUCTURE_p1_p2_k1_5 t_MAKE_STRUCTURE_p1_p2_4) 1) ?v_19 (<= ?v_10 5) (< ?v_10 5) (>= ?v_10 1) (>= ?v_11 4) ?v_2 ?v_3 (< ?v_12 15) (>= ?v_12 2) (<= ?v_13 4) (>= ?v_13 0) (>= (- t_MAKE_STRUCTURE_p3_p4_4 t_TREAT_CERAMIC3_p4_3) 1) ?v_17 (<= ?v_14 3) (< ?v_14 3) (>= ?v_14 1) (>= (- t_MAKE_STRUCTURE_p3_p4_4 t_BAKE_CERAMIC3_p4_k1_3) 5) ?v_2 (>= ?v_15 2) (<= ?v_16 4) (>= ?v_16 0) (>= (- t_MAKE_STRUCTURE_p3_p4_4 t_TREAT_CERAMIC3_p3_3) 1) ?v_17 (>= ?v_18 1) (>= (- t_MAKE_STRUCTURE_p3_p4_4 t_BAKE_CERAMIC3_p3_k1_3) 5) (>= (- t_BAKE_STRUCTURE_p3_p4_k1_5 t_MAKE_STRUCTURE_p3_p4_4) 1) ?v_19 (>= ?v_20 1) (>= ?v_21 4) ?v_24 (or ?v_25 (< (- t_BAKE_CERAMIC2_p2_k2_2 t_FIRE_KILN2_k2_2) 10)) (or (>= (- t_BAKE_CERAMIC2_p2_k2_2 t_MAKE_STRUCTURE_p1_p2_4) 1) (< ?v_23 7)) (or (<= ?v_22 0) (> ?v_22 10)) (or (>= ?v_23 3) (> ?v_22 7)) (or (> ?v_23 10) (< (- t_TREAT_CERAMIC2_p2_3 t_BAKE_CERAMIC2_p2_k2_3) 8)) ?v_24 (or ?v_25 (< (- t_BAKE_CERAMIC2_p2_k2_3 t_FIRE_KILN2_k2_2) 10)) ?v_24 (or ?v_25 (< (- t_BAKE_CERAMIC1_p1_k2_2 t_FIRE_KILN2_k2_2) 5)) (or (>= (- t_BAKE_CERAMIC1_p1_k2_2 t_MAKE_STRUCTURE_p1_p2_4) 1) (< ?v_27 10)) (or (<= ?v_26 0) (> ?v_26 15)) (or (>= ?v_27 5) (> ?v_26 10)) (or (> ?v_27 15) (< (- t_TREAT_CERAMIC1_p1_3 t_BAKE_CERAMIC1_p1_k2_3) 12)) (or (<= (- t_BAKE_CERAMIC3_p3_k2_2 t_FIRE_KILN2_k2_2) 15) ?v_25) (or (<= (- t_BAKE_CERAMIC3_p4_k2_2 t_FIRE_KILN2_k2_2) 15) ?v_25) (or ?v_28 (< ?v_29 5)) (or (<= ?v_38 3) ?v_30) (or (<= ?v_34 3) ?v_30) (or ?v_33 (< (- t_BAKE_STRUCTURE_p1_p2_k1_5 t_FIRE_KILN1_k1_2) 5)) (or (>= (- t_BAKE_CERAMIC3_p4_k2_2 t_MAKE_STRUCTURE_p3_p4_4) 1) (< ?v_32 4)) (or (<= ?v_31 0) (> ?v_31 5)) (or (>= ?v_32 1) (> ?v_31 4)) (or (> ?v_32 5) (< (- t_TREAT_CERAMIC3_p4_3 t_BAKE_CERAMIC3_p4_k1_3) 4)) ?v_37 (or ?v_30 (< ?v_34 3)) (or (>= (- t_BAKE_CERAMIC3_p3_k2_2 t_MAKE_STRUCTURE_p3_p4_4) 1) (< ?v_36 4)) (or (<= ?v_35 0) (> ?v_35 5)) (or (>= ?v_36 1) (> ?v_35 4)) (or (> ?v_36 5) (< (- t_TREAT_CERAMIC3_p3_3 t_BAKE_CERAMIC3_p3_k1_3) 4)) ?v_37 (or ?v_30 (< ?v_38 3))))))))))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/constraints-temporal-machine-shop-2-3-A04.smt2.expected.err000066400000000000000000000000001445011647600311470ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/constraints-temporal-machine-shop-2-3-A04.smt2.expected.out000066400000000000000000000000041445011647600311720ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LRA/constraints-temporal-machine-shop-2-3-A04.smt2.expected.time000066400000000000000000000000351445011647600313250ustar00rootroot00000000000000real 0.29 user 0.17 sys 0.12 opensmt-2.5.2/regression/QF_LRA/constraints-temporal-machine-shop-2-3-A04_simplified_0.smt2000066400000000000000000000005321445011647600312160ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun v41 () Real) (declare-fun v44 () Real) (declare-fun v42 () Real) (declare-fun v47 () Real) (declare-fun v1 () Real) (assert (and (<= (- v42) 5) (>= (- v47 v41) 1) (or (>= v44 5) (> v42 10)) (or (<= (- v47 v42) 3) (> (- v41 v42) 8)) (>= (- v47) 1) (or (> (- v41 v42) 8) (< v1 3)) )) (check-sat) (exit) constraints-temporal-machine-shop-2-3-A04_simplified_0.smt2.expected.err000066400000000000000000000000001445011647600335140ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRAconstraints-temporal-machine-shop-2-3-A04_simplified_0.smt2.expected.out000066400000000000000000000000041445011647600335370ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRAsat constraints-temporal-machine-shop-2-3-A04_simplified_0.smt2.expected.time000066400000000000000000000000351445011647600336720ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRAreal 0.01 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/distinct_sat.smt2000066400000000000000000000002371445011647600217020ustar00rootroot00000000000000(set-logic QF_LRA) (set-info :status sat) (declare-fun a () Real) (declare-fun b () Real) (declare-fun c () Real) (assert (distinct a b c)) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/distinct_sat.smt2.expected.err000066400000000000000000000000001445011647600242550ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/distinct_sat.smt2.expected.out000066400000000000000000000000041445011647600243000ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LRA/distinct_unsat.smt2000066400000000000000000000003541445011647600222450ustar00rootroot00000000000000(set-logic QF_LRA) (set-info :status unsat) (declare-fun a () Real) (declare-fun b () Real) (declare-fun c () Real) (assert (not (distinct a b c))) (assert (not (= a b))) (assert (not (= a c))) (assert (not (= b c))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/distinct_unsat.smt2.expected.err000066400000000000000000000000001445011647600246200ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/distinct_unsat.smt2.expected.out000066400000000000000000000000061445011647600246450ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LRA/div_simplification.smt2000066400000000000000000000001771445011647600230710ustar00rootroot00000000000000(set-logic QF_LRA) (assert (and false false false false false (or (= 0.0 (* (/ 0 3000) 0.0)) false) false)) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/div_simplification.smt2.expected.err000066400000000000000000000000001445011647600254410ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/div_simplification.smt2.expected.out000066400000000000000000000000061445011647600254660ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LRA/div_simplification.smt2.expected.time000066400000000000000000000000351445011647600256170ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/get_value_unconstrained_var.smt2000066400000000000000000000001631445011647600247670ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun x () Real) (declare-fun y () Real) (assert (>= x 2)) (check-sat) (get-value (x y)) opensmt-2.5.2/regression/QF_LRA/get_value_unconstrained_var.smt2.expected.err000066400000000000000000000000001445011647600273440ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/get_value_unconstrained_var.smt2.expected.out000066400000000000000000000000211445011647600273660ustar00rootroot00000000000000sat ((x 2)(y 0)) opensmt-2.5.2/regression/QF_LRA/ite_with_equalities.smt2000066400000000000000000000003061445011647600232500ustar00rootroot00000000000000(set-info :status unsat) (set-logic QF_LRA) (declare-fun x8 () Real) (declare-fun x7 () Real) (declare-fun x9 () Real) (assert (and (= x7 (ite (= x8 0) x8 0)) (not (= x7 0)) )) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/ite_with_equalities.smt2.expected.err000066400000000000000000000000001445011647600256260ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/ite_with_equalities.smt2.expected.out000066400000000000000000000000061445011647600256530ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LRA/ite_with_equalities_bool.smt2000066400000000000000000000003451445011647600242660ustar00rootroot00000000000000(set-info :status unsat) (set-logic QF_LRA) (declare-fun x8 () Real) (declare-fun x7 () Real) (declare-fun x9 () Real) (declare-fun a () Bool) (assert (and (ite (= x8 0) (= x7 x8) (= x7 0)) (not (= x7 0)) )) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/ite_with_equalities_bool.smt2.expected.err000066400000000000000000000000001445011647600266410ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/ite_with_equalities_bool.smt2.expected.out000066400000000000000000000000061445011647600266660ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LRA/lra_const_minus.smt2000066400000000000000000000003521445011647600224070ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun x () Real) (assert (> 0 (* (- 1) x))) (assert (> 0 (* 1 x))) (assert (< (- 1) (* 0 x))) (assert (> 0 (* (- 1) 2 x))) (assert (> 0 (/ x (- 2)))) (assert (> 0 (- 1 2))) (assert (> 0 (/ 1 0))) (check-sat) opensmt-2.5.2/regression/QF_LRA/lra_const_minus.smt2.expected.err000066400000000000000000000000001445011647600247640ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/lra_const_minus.smt2.expected.out000066400000000000000000000001451445011647600250150ustar00rootroot00000000000000(error "Explicit division by zero encountered!") (error "assertion returns an unknown sort") unsat opensmt-2.5.2/regression/QF_LRA/lra_const_minus.smt2.expected.time000066400000000000000000000000741445011647600251450ustar00rootroot00000000000000Command terminated by signal 6 real 0.20 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/lra_const_subst.smt2000066400000000000000000000001441445011647600224130ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun x () Real) (assert (and (= x 0) (or (> x 0) (<= x 0)))) (check-sat) opensmt-2.5.2/regression/QF_LRA/lra_const_subst.smt2.expected.err000066400000000000000000000000001445011647600247710ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/lra_const_subst.smt2.expected.out000066400000000000000000000000041445011647600250140ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LRA/lra_const_subst.smt2.expected.time000066400000000000000000000000741445011647600251520ustar00rootroot00000000000000Command terminated by signal 6 real 0.20 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/lra_const_subst2.smt2000066400000000000000000000001101445011647600224660ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun x () Real) (assert (= 0 0)) (check-sat) opensmt-2.5.2/regression/QF_LRA/lra_const_subst2.smt2.expected.err000066400000000000000000000000001445011647600250530ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/lra_const_subst2.smt2.expected.out000066400000000000000000000000041445011647600250760ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LRA/lra_const_subst2.smt2.expected.time000066400000000000000000000000351445011647600252310ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/lra_const_subst3.smt2000066400000000000000000000001101445011647600224670ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun x () Real) (assert (= 0 1)) (check-sat) opensmt-2.5.2/regression/QF_LRA/lra_const_subst3.smt2.expected.err000066400000000000000000000000001445011647600250540ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/lra_const_subst3.smt2.expected.out000066400000000000000000000000061445011647600251010ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LRA/lra_const_subst3.smt2.expected.time000066400000000000000000000000351445011647600252320ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/lra_const_sum.smt2000066400000000000000000000003361445011647600220620ustar00rootroot00000000000000(set-logic QF_LRA) (assert (< 0 (+ 1.23 2))) (assert (< 0 (+ 0.123 2))) (assert (< 0 (+ 12.34 2))) (assert (< 0 (+ 1 2))) (assert (< 0 (+ 10 2))) (assert (< 0 (+ 1.2300 2))) (assert (< 0 (+ 1.23001 2))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/lra_const_sum.smt2.expected.err000066400000000000000000000000001445011647600244350ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/lra_const_sum.smt2.expected.out000066400000000000000000000000041445011647600244600ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LRA/lra_const_sum.smt2.expected.time000066400000000000000000000000351445011647600246130ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/lra_const_zero.smt2000066400000000000000000000000531445011647600222310ustar00rootroot00000000000000(set-logic QF_LRA) (assert (> (- 1) 0.0)) opensmt-2.5.2/regression/QF_LRA/lra_const_zero.smt2.expected.err000066400000000000000000000000001445011647600246100ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/lra_const_zero.smt2.expected.out000066400000000000000000000000001445011647600246270ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/lra_const_zero.smt2.expected.time000066400000000000000000000000351445011647600247660ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/lra_const_zero2.smt2000066400000000000000000000000721445011647600223140ustar00rootroot00000000000000(set-logic QF_LRA) (assert (= 0 (+ 0 0 0 0))) (check-sat) opensmt-2.5.2/regression/QF_LRA/lra_const_zero2.smt2.expected.err000066400000000000000000000000001445011647600246720ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/lra_const_zero2.smt2.expected.out000066400000000000000000000000041445011647600247150ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LRA/lra_const_zero2.smt2.expected.time000066400000000000000000000000351445011647600250500ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/no_op_accs.base_simplified_0.smt2000066400000000000000000000003041445011647600246450ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun v_9 () Real) (declare-fun x_4 () Bool) (assert (and (not x_4) (= v_9 (ite (not x_4) (ite (<= 0.0 v_9) 0.0 0.0) 0.0)) (or x_4 (= v_9 3)))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/no_op_accs.base_simplified_0.smt2.expected.err000066400000000000000000000000001445011647600272250ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/no_op_accs.base_simplified_0.smt2.expected.out000066400000000000000000000000061445011647600272520ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LRA/no_op_accs.base_simplified_0.smt2.expected.time000066400000000000000000000000351445011647600274030ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/pd_finish.induction.smt2000066400000000000000000000176671445011647600231670ustar00rootroot00000000000000(set-logic QF_LRA) (set-info :source | The Formal Verification of a Reintegration Protocol. Author: Lee Pike. Website: http://www.cs.indiana.edu/~lepike/pub_pages/emsoft.html. This benchmark was automatically translated into SMT-LIB format from CVC format using CVC Lite |) (set-info :smt-lib-version 2.0) (set-info :category "industrial") (declare-fun x_0 () Real) (declare-fun x_1 () Real) (declare-fun x_2 () Real) (declare-fun x_3 () Real) (declare-fun x_4 () Real) (declare-fun x_5 () Real) (declare-fun x_6 () Bool) (declare-fun x_7 () Bool) (declare-fun x_8 () Real) (declare-fun x_9 () Bool) (declare-fun x_10 () Bool) (declare-fun x_11 () Bool) (declare-fun x_12 () Bool) (declare-fun x_13 () Bool) (declare-fun x_14 () Bool) (declare-fun x_15 () Bool) (declare-fun x_16 () Bool) (declare-fun x_17 () Bool) (declare-fun x_18 () Bool) (declare-fun x_19 () Bool) (declare-fun x_20 () Bool) (declare-fun x_21 () Real) (declare-fun x_22 () Real) (declare-fun x_23 () Real) (declare-fun x_24 () Real) (declare-fun x_25 () Real) (declare-fun x_26 () Real) (declare-fun x_27 () Real) (declare-fun x_28 () Bool) (declare-fun x_29 () Bool) (declare-fun x_30 () Bool) (declare-fun x_31 () Bool) (declare-fun x_32 () Bool) (declare-fun x_33 () Bool) (declare-fun x_34 () Bool) (declare-fun x_35 () Bool) (declare-fun x_36 () Bool) (declare-fun x_37 () Bool) (declare-fun x_38 () Real) (declare-fun x_39 () Real) (declare-fun x_40 () Real) (declare-fun x_41 () Real) (declare-fun x_42 () Real) (declare-fun x_43 () Real) (declare-fun x_44 () Real) (declare-fun x_45 () Real) (declare-fun x_46 () Real) (declare-fun x_47 () Real) (declare-fun x_48 () Real) (declare-fun x_49 () Real) (declare-fun x_50 () Real) (declare-fun x_51 () Real) (declare-fun x_52 () Real) (declare-fun x_53 () Bool) (declare-fun x_54 () Real) (declare-fun x_55 () Real) (declare-fun x_56 () Real) (assert (let ((?v_25 (+ x_1 x_3)) (?v_66 (<= x_4 x_5)) (?v_50 (= x_6 x_7)) (?v_9 (= x_8 0)) (?v_10 (< x_4 x_0)) (?v_34 (= x_5 x_4)) (?v_57 (= x_8 2)) (?v_59 (= x_9 x_10)) (?v_60 (and (= x_11 x_12) (= x_13 x_14))) (?v_48 (= x_15 x_16)) (?v_49 (and (= x_17 x_18) (= x_19 x_20))) (?v_61 (= x_21 x_22)) (?v_62 (and (= x_23 x_24) (= x_25 x_26))) (?v_20 (= x_27 x_0)) (?v_47 (= x_28 x_29)) (?v_45 (= x_30 x_31)) (?v_46 (and (= x_32 x_33) (= x_34 x_35))) (?v_63 (= x_36 x_37)) (?v_67 (- x_38 x_1)) (?v_38 (= x_8 1)) (?v_42 (+ x_3 x_1)) (?v_37 (<= x_39 x_5))) (let ((?v_44 (= x_9 (or x_10 (and ?v_37 x_31)))) (?v_27 (<= x_42 ?v_25)) (?v_29 (<= x_43 ?v_25)) (?v_26 (<= x_42 x_3)) (?v_28 (<= x_43 x_3)) (?v_22 (not x_12)) (?v_51 (< x_42 x_4)) (?v_52 (= x_5 x_42)) (?v_24 (not x_14)) (?v_53 (< x_43 x_4)) (?v_54 (= x_5 x_43)) (?v_13 (not x_10)) (?v_68 (not ?v_66)) (?v_31 (not x_33)) (?v_32 (not x_35)) (?v_33 (not x_31))) (let ((?v_21 (not ?v_26))) (let ((?v_35 (and ?v_21 (<= x_42 x_5))) (?v_23 (not ?v_28))) (let ((?v_36 (and ?v_23 (<= x_43 x_5)))) (let ((?v_43 (and (= x_11 (or x_12 (and ?v_35 x_33))) (= x_13 (or x_14 (and ?v_36 x_35))))) (?v_30 (<= x_39 ?v_25)) (?v_55 (< x_39 x_4)) (?v_56 (= x_5 x_39)) (?v_39 (not ?v_27)) (?v_40 (not ?v_29)) (?v_1 (and (not (<= x_39 x_3)) ?v_37)) (?v_2 (and (not (<= x_44 x_3)) (<= x_44 x_5)))) (let ((?v_41 (not ?v_30)) (?v_19 (= x_21 0)) (?v_8 (= x_21 3)) (?v_15 (= x_23 0)) (?v_6 (= x_23 3)) (?v_17 (= x_25 0)) (?v_7 (= x_25 3)) (?v_3 (and (not (<= x_47 x_3)) (<= x_47 x_5))) (?v_11 (= x_23 (ite ?v_22 (ite (and ?v_35 (< x_24 3)) (+ x_24 1) x_24) x_24))) (?v_12 (= x_25 (ite ?v_24 (ite (and ?v_36 (< x_26 3)) (+ x_26 1) x_26) x_26)))) (let ((?v_14 (or x_12 ?v_6)) (?v_16 (or x_14 ?v_7)) (?v_18 (or x_10 ?v_8)) (?v_64 (= x_50 0)) (?v_65 (= x_50 1)) (?v_69 (+ (* x_2 2) x_1)) (?v_0 (ite ?v_1 2 1)) (?v_4 (ite ?v_1 3 2)) (?v_5 (ite ?v_1 1 0)) (?v_58 (<= (ite x_16 (ite x_20 (ite x_18 3 2) x_40) (ite x_20 x_40 (ite x_18 1 0))) (* (* (ite x_10 (ite x_14 (ite x_12 0 1) x_41) (ite x_14 x_41 (ite x_12 2 3))) 1) (/ 1 2))))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (<= x_50 2) (>= x_50 0)) (<= x_8 2)) (>= x_8 0)) (>= x_0 0)) (> x_1 0)) (>= x_1 0)) (not (<= x_2 (* x_1 3)))) (>= x_2 0)) (>= x_3 0)) (>= x_4 0)) (>= x_5 0)) (or (or (or ?v_19 (= x_21 1)) (= x_21 2)) ?v_8)) (not (< x_21 0))) (<= x_21 3)) (or (or (or (= x_22 0) (= x_22 1)) (= x_22 2)) (= x_22 3))) (not (< x_22 0))) (<= x_22 3)) (or (or (or ?v_15 (= x_23 1)) (= x_23 2)) ?v_6)) (not (< x_23 0))) (<= x_23 3)) (or (or (or (= x_24 0) (= x_24 1)) (= x_24 2)) (= x_24 3))) (not (< x_24 0))) (<= x_24 3)) (or (or (or ?v_17 (= x_25 1)) (= x_25 2)) ?v_7)) (not (< x_25 0))) (<= x_25 3)) (or (or (or (= x_26 0) (= x_26 1)) (= x_26 2)) (= x_26 3))) (not (< x_26 0))) (<= x_26 3)) (>= x_27 0)) (>= x_38 0)) (>= x_39 0)) (>= x_42 0)) (>= x_43 0)) (>= x_44 0)) (>= x_47 0)) (>= x_51 0)) (>= x_52 0)) (>= x_54 0)) (>= x_55 0)) (>= x_56 0)) (< x_0 ?v_69)) (= x_40 (ite x_18 2 1))) (= x_41 (ite x_12 1 2))) (= x_45 ?v_0)) (= x_46 ?v_0)) (= x_48 (+ (ite ?v_3 (ite ?v_2 ?v_4 x_45) (ite ?v_2 x_45 ?v_5)) x_22))) (= x_49 (+ (ite ?v_3 (ite ?v_2 ?v_4 x_46) (ite ?v_2 x_46 ?v_5)) x_22))) (or (or (and (and (and (and (and (and (or (and (and (and (and (and (and (and (and (and (and ?v_9 ?v_10) ?v_34) ?v_11) ?v_12) (= x_21 (ite ?v_13 (ite (not (< x_48 3)) 3 x_48) x_22))) (= x_11 ?v_14)) (= x_13 ?v_16)) (= x_9 ?v_18)) ?v_47) ?v_20) (and (and (and (and (and (and (and (and (and (and ?v_9 (not ?v_10)) x_28) (= x_5 x_0)) ?v_11) ?v_12) (= x_21 (ite ?v_13 (ite (not (< x_49 3)) 3 x_49) x_22))) (= x_11 (or ?v_14 ?v_15))) (= x_13 (or ?v_16 ?v_17))) (= x_9 (or ?v_18 ?v_19))) ?v_20)) ?v_45) ?v_46) ?v_63) ?v_48) ?v_49) ?v_50) (and (and (and (and (and (and (and (or (and (and (and (and (and (and (and (and (and (and (and ?v_38 (or (or (and (and (and ?v_21 ?v_22) ?v_31) ?v_27) (and (and (and ?v_23 ?v_24) ?v_32) ?v_29)) (and (and ?v_13 ?v_33) ?v_30))) (not x_36)) (or (or (or (or ?v_26 ?v_39) x_33) x_12) (not (< x_5 x_42)))) (or (or (or (or ?v_28 ?v_40) x_35) x_14) (not (< x_5 x_43)))) (or (or (or ?v_41 x_31) x_10) (not (< x_5 x_39)))) (or (or (or (and (and (and (and ?v_31 ?v_22) ?v_27) ?v_51) ?v_52) (and (and (and (and ?v_32 ?v_24) ?v_29) ?v_53) ?v_54)) (and (and (and (and ?v_33 ?v_13) ?v_30) ?v_55) ?v_56)) (and (< x_4 ?v_42) ?v_34))) (= x_32 (or x_33 ?v_35))) (= x_34 (or x_35 ?v_36))) (= x_30 (or x_31 ?v_37))) ?v_43) ?v_44) (and (and (and (and (and (and (and (and (and ?v_38 (or (or (or ?v_26 x_33) x_12) ?v_39)) (or (or (or ?v_28 x_35) x_14) ?v_40)) (or (or x_31 x_10) ?v_41)) x_36) (= x_5 ?v_42)) ?v_43) ?v_44) ?v_45) ?v_46)) ?v_61) ?v_62) ?v_20) ?v_47) ?v_48) ?v_49) ?v_50)) (and (and (and (and (and (and (and (or (and (and (and (and (and (and (and (and (and (and (and ?v_57 ?v_58) (not x_6)) (or (or (or ?v_26 x_18) x_12) (<= x_5 x_42))) (or (or (or ?v_28 x_20) x_14) (<= x_5 x_43))) (or (or x_16 x_10) (<= x_5 x_39))) (or (or (or (and (and (and (and (not x_18) ?v_22) (< x_3 x_42)) ?v_51) ?v_52) (and (and (and (and (not x_20) ?v_24) (< x_3 x_43)) ?v_53) ?v_54)) (and (and (and (not x_16) ?v_13) ?v_55) ?v_56)) ?v_34)) (= x_17 (or x_18 (= x_42 x_5)))) (= x_19 (or x_20 (= x_43 x_5)))) (= x_15 (or x_16 (= x_39 x_5)))) ?v_59) ?v_60) (and (and (and (and (and (and (and ?v_57 (not ?v_58)) x_6) ?v_59) ?v_60) (= x_5 x_3)) ?v_48) ?v_49)) ?v_61) ?v_62) ?v_20) ?v_47) ?v_45) ?v_46) ?v_63))) (or (or (and ?v_64 (= x_8 (ite (not x_29) x_50 1))) (and ?v_65 (= x_8 (ite (not x_37) x_50 2)))) (and (and (not ?v_64) (not ?v_65)) (= x_8 x_50)))) (or (and (and ?v_66 (not (<= x_38 x_51))) (not (<= x_51 ?v_67))) (and ?v_68 (= x_51 x_42)))) (or (and (and ?v_66 (not (<= x_38 x_52))) (not (<= x_52 ?v_67))) (and ?v_68 (= x_52 x_43)))) (or (and (and ?v_66 (= x_38 (+ x_4 x_2))) x_53) (and (and ?v_68 (not x_53)) (= x_38 x_4)))) (or (and (and (and (and ?v_37 (not (<= x_54 x_5))) (not (<= x_55 x_5))) (< x_54 x_55)) (< x_55 x_56)) (and (and (and (not ?v_37) (= x_54 x_39)) (= x_55 x_44)) (= x_56 x_47)))) (not (< x_27 ?v_69)))))))))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/pd_finish.induction.smt2.expected.err000066400000000000000000000000001445011647600255230ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/pd_finish.induction.smt2.expected.out000066400000000000000000000000061445011647600255500ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LRA/pd_finish.induction.smt2.expected.time000066400000000000000000000000351445011647600257010ustar00rootroot00000000000000real 0.12 user 0.11 sys 0.00 opensmt-2.5.2/regression/QF_LRA/pd_finish.induction_simplified_0.smt2000066400000000000000000000001271445011647600255720ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun v () Real) (assert (= 0.0 (+ v v))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/pd_finish.induction_simplified_0.smt2.expected.err000066400000000000000000000000001445011647600301470ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/pd_finish.induction_simplified_0.smt2.expected.out000066400000000000000000000000041445011647600301720ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LRA/pd_finish.induction_simplified_0.smt2.expected.time000066400000000000000000000000351445011647600303250ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/pd_init_op_accs.induction.smt2000066400000000000000000000200171445011647600243200ustar00rootroot00000000000000(set-logic QF_LRA) (set-info :source | The Formal Verification of a Reintegration Protocol. Author: Lee Pike. Website: http://www.cs.indiana.edu/~lepike/pub_pages/emsoft.html. This benchmark was automatically translated into SMT-LIB format from CVC format using CVC Lite |) (set-info :smt-lib-version 2.0) (set-info :category "industrial") (declare-fun x_0 () Real) (declare-fun x_1 () Bool) (declare-fun x_2 () Real) (declare-fun x_3 () Bool) (declare-fun x_4 () Real) (declare-fun x_5 () Bool) (declare-fun x_6 () Real) (declare-fun x_7 () Real) (declare-fun x_8 () Real) (declare-fun x_9 () Real) (declare-fun x_10 () Bool) (declare-fun x_11 () Bool) (declare-fun x_12 () Real) (declare-fun x_13 () Real) (declare-fun x_14 () Bool) (declare-fun x_15 () Bool) (declare-fun x_16 () Bool) (declare-fun x_17 () Bool) (declare-fun x_18 () Bool) (declare-fun x_19 () Bool) (declare-fun x_20 () Bool) (declare-fun x_21 () Bool) (declare-fun x_22 () Bool) (declare-fun x_23 () Bool) (declare-fun x_24 () Real) (declare-fun x_25 () Real) (declare-fun x_26 () Real) (declare-fun x_27 () Real) (declare-fun x_28 () Real) (declare-fun x_29 () Bool) (declare-fun x_30 () Bool) (declare-fun x_31 () Bool) (declare-fun x_32 () Bool) (declare-fun x_33 () Bool) (declare-fun x_34 () Bool) (declare-fun x_35 () Bool) (declare-fun x_36 () Bool) (declare-fun x_37 () Bool) (declare-fun x_38 () Real) (declare-fun x_39 () Real) (declare-fun x_40 () Real) (declare-fun x_41 () Real) (declare-fun x_42 () Real) (declare-fun x_43 () Real) (declare-fun x_44 () Real) (declare-fun x_45 () Real) (declare-fun x_46 () Real) (declare-fun x_47 () Real) (declare-fun x_48 () Real) (declare-fun x_49 () Real) (declare-fun x_50 () Real) (declare-fun x_51 () Real) (declare-fun x_52 () Real) (declare-fun x_53 () Bool) (declare-fun x_54 () Real) (declare-fun x_55 () Real) (declare-fun x_56 () Real) (assert (let ((?v_27 (+ x_6 x_7)) (?v_69 (<= x_8 x_9)) (?v_52 (= x_10 x_11)) (?v_13 (= x_12 0)) (?v_14 (< x_8 x_13)) (?v_36 (= x_9 x_8)) (?v_59 (= x_12 2)) (?v_61 (= x_14 x_15)) (?v_62 (and (= x_16 x_3) (= x_17 x_5))) (?v_50 (= x_18 x_19)) (?v_51 (and (= x_20 x_21) (= x_22 x_23))) (?v_63 (= x_24 x_25)) (?v_64 (and (= x_26 x_2) (= x_27 x_4))) (?v_24 (= x_28 x_13)) (?v_49 (= x_29 x_1)) (?v_47 (= x_30 x_31)) (?v_48 (and (= x_32 x_33) (= x_34 x_35))) (?v_65 (= x_36 x_37)) (?v_70 (- x_38 x_6)) (?v_40 (= x_12 1)) (?v_44 (+ x_7 x_6)) (?v_39 (<= x_39 x_9))) (let ((?v_46 (= x_14 (or x_15 (and ?v_39 x_31)))) (?v_29 (<= x_42 ?v_27)) (?v_31 (<= x_43 ?v_27)) (?v_28 (<= x_42 x_7)) (?v_30 (<= x_43 x_7)) (?v_8 (not x_3)) (?v_53 (< x_42 x_8)) (?v_54 (= x_9 x_42)) (?v_9 (not x_5)) (?v_55 (< x_43 x_8)) (?v_56 (= x_9 x_43)) (?v_17 (not x_15)) (?v_71 (not ?v_69)) (?v_33 (not x_33)) (?v_34 (not x_35)) (?v_35 (not x_31))) (let ((?v_25 (not ?v_28))) (let ((?v_37 (and ?v_25 (<= x_42 x_9))) (?v_26 (not ?v_30))) (let ((?v_38 (and ?v_26 (<= x_43 x_9)))) (let ((?v_45 (and (= x_16 (or x_3 (and ?v_37 x_33))) (= x_17 (or x_5 (and ?v_38 x_35))))) (?v_32 (<= x_39 ?v_27)) (?v_57 (< x_39 x_8)) (?v_58 (= x_9 x_39)) (?v_41 (not ?v_29)) (?v_42 (not ?v_31)) (?v_3 (and (not (<= x_39 x_7)) ?v_39)) (?v_4 (and (not (<= x_44 x_7)) (<= x_44 x_9)))) (let ((?v_43 (not ?v_32)) (?v_0 (= x_2 0)) (?v_1 (= x_4 0)) (?v_23 (= x_24 0)) (?v_12 (= x_24 3)) (?v_19 (= x_26 0)) (?v_10 (= x_26 3)) (?v_21 (= x_27 0)) (?v_11 (= x_27 3)) (?v_66 (= x_0 0))) (let ((?v_67 (not ?v_66)) (?v_5 (and (not (<= x_47 x_7)) (<= x_47 x_9))) (?v_15 (= x_26 (ite ?v_8 (ite (and ?v_37 (< x_2 3)) (+ x_2 1) x_2) x_2))) (?v_16 (= x_27 (ite ?v_9 (ite (and ?v_38 (< x_4 3)) (+ x_4 1) x_4) x_4))) (?v_18 (or x_3 ?v_10)) (?v_20 (or x_5 ?v_11)) (?v_22 (or x_15 ?v_12)) (?v_68 (= x_0 1)) (?v_2 (ite ?v_3 2 1)) (?v_6 (ite ?v_3 3 2)) (?v_7 (ite ?v_3 1 0)) (?v_60 (<= (ite x_19 (ite x_23 (ite x_21 3 2) x_40) (ite x_23 x_40 (ite x_21 1 0))) (* (* (ite x_15 (ite x_5 (ite x_3 0 1) x_41) (ite x_5 x_41 (ite x_3 2 3))) 1) (/ 1 2))))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (<= x_12 2) (>= x_12 0)) (<= x_0 2)) (>= x_0 0)) (or (or (or ?v_0 (= x_2 1)) (= x_2 2)) (= x_2 3))) (not (< x_2 0))) (<= x_2 3)) (or (or (or ?v_1 (= x_4 1)) (= x_4 2)) (= x_4 3))) (not (< x_4 0))) (<= x_4 3)) (> x_6 0)) (>= x_6 0)) (>= x_7 0)) (>= x_8 0)) (>= x_9 0)) (>= x_13 0)) (or (or (or ?v_23 (= x_24 1)) (= x_24 2)) ?v_12)) (not (< x_24 0))) (<= x_24 3)) (or (or (or (= x_25 0) (= x_25 1)) (= x_25 2)) (= x_25 3))) (not (< x_25 0))) (<= x_25 3)) (or (or (or ?v_19 (= x_26 1)) (= x_26 2)) ?v_10)) (not (< x_26 0))) (<= x_26 3)) (or (or (or ?v_21 (= x_27 1)) (= x_27 2)) ?v_11)) (not (< x_27 0))) (<= x_27 3)) (>= x_28 0)) (>= x_38 0)) (>= x_39 0)) (>= x_42 0)) (>= x_43 0)) (>= x_44 0)) (>= x_47 0)) (>= x_50 0)) (>= x_51 0)) (not (<= x_52 (* x_6 3)))) (>= x_52 0)) (>= x_54 0)) (>= x_55 0)) (>= x_56 0)) (or (or ?v_67 x_1) (and (or (not ?v_0) ?v_8) (or (not ?v_1) ?v_9)))) (= x_40 (ite x_21 2 1))) (= x_41 (ite x_3 1 2))) (= x_45 ?v_2)) (= x_46 ?v_2)) (= x_48 (+ (ite ?v_5 (ite ?v_4 ?v_6 x_45) (ite ?v_4 x_45 ?v_7)) x_25))) (= x_49 (+ (ite ?v_5 (ite ?v_4 ?v_6 x_46) (ite ?v_4 x_46 ?v_7)) x_25))) (or (or (and (and (and (and (and (and (or (and (and (and (and (and (and (and (and (and (and ?v_13 ?v_14) ?v_36) ?v_15) ?v_16) (= x_24 (ite ?v_17 (ite (not (< x_48 3)) 3 x_48) x_25))) (= x_16 ?v_18)) (= x_17 ?v_20)) (= x_14 ?v_22)) ?v_49) ?v_24) (and (and (and (and (and (and (and (and (and (and ?v_13 (not ?v_14)) x_29) (= x_9 x_13)) ?v_15) ?v_16) (= x_24 (ite ?v_17 (ite (not (< x_49 3)) 3 x_49) x_25))) (= x_16 (or ?v_18 ?v_19))) (= x_17 (or ?v_20 ?v_21))) (= x_14 (or ?v_22 ?v_23))) ?v_24)) ?v_47) ?v_48) ?v_65) ?v_50) ?v_51) ?v_52) (and (and (and (and (and (and (and (or (and (and (and (and (and (and (and (and (and (and (and ?v_40 (or (or (and (and (and ?v_25 ?v_8) ?v_33) ?v_29) (and (and (and ?v_26 ?v_9) ?v_34) ?v_31)) (and (and ?v_17 ?v_35) ?v_32))) (not x_36)) (or (or (or (or ?v_28 ?v_41) x_33) x_3) (not (< x_9 x_42)))) (or (or (or (or ?v_30 ?v_42) x_35) x_5) (not (< x_9 x_43)))) (or (or (or ?v_43 x_31) x_15) (not (< x_9 x_39)))) (or (or (or (and (and (and (and ?v_33 ?v_8) ?v_29) ?v_53) ?v_54) (and (and (and (and ?v_34 ?v_9) ?v_31) ?v_55) ?v_56)) (and (and (and (and ?v_35 ?v_17) ?v_32) ?v_57) ?v_58)) (and (< x_8 ?v_44) ?v_36))) (= x_32 (or x_33 ?v_37))) (= x_34 (or x_35 ?v_38))) (= x_30 (or x_31 ?v_39))) ?v_45) ?v_46) (and (and (and (and (and (and (and (and (and ?v_40 (or (or (or ?v_28 x_33) x_3) ?v_41)) (or (or (or ?v_30 x_35) x_5) ?v_42)) (or (or x_31 x_15) ?v_43)) x_36) (= x_9 ?v_44)) ?v_45) ?v_46) ?v_47) ?v_48)) ?v_63) ?v_64) ?v_24) ?v_49) ?v_50) ?v_51) ?v_52)) (and (and (and (and (and (and (and (or (and (and (and (and (and (and (and (and (and (and (and ?v_59 ?v_60) (not x_10)) (or (or (or ?v_28 x_21) x_3) (<= x_9 x_42))) (or (or (or ?v_30 x_23) x_5) (<= x_9 x_43))) (or (or x_19 x_15) (<= x_9 x_39))) (or (or (or (and (and (and (and (not x_21) ?v_8) (< x_7 x_42)) ?v_53) ?v_54) (and (and (and (and (not x_23) ?v_9) (< x_7 x_43)) ?v_55) ?v_56)) (and (and (and (not x_19) ?v_17) ?v_57) ?v_58)) ?v_36)) (= x_20 (or x_21 (= x_42 x_9)))) (= x_22 (or x_23 (= x_43 x_9)))) (= x_18 (or x_19 (= x_39 x_9)))) ?v_61) ?v_62) (and (and (and (and (and (and (and ?v_59 (not ?v_60)) x_10) ?v_61) ?v_62) (= x_9 x_7)) ?v_50) ?v_51)) ?v_63) ?v_64) ?v_24) ?v_49) ?v_47) ?v_48) ?v_65))) (or (or (and ?v_66 (= x_12 (ite (not x_1) x_0 1))) (and ?v_68 (= x_12 (ite (not x_37) x_0 2)))) (and (and ?v_67 (not ?v_68)) (= x_12 x_0)))) (or (and (and ?v_69 (not (<= x_38 x_50))) (not (<= x_50 ?v_70))) (and ?v_71 (= x_50 x_42)))) (or (and (and ?v_69 (not (<= x_38 x_51))) (not (<= x_51 ?v_70))) (and ?v_71 (= x_51 x_43)))) (or (and (and ?v_69 (= x_38 (+ x_8 x_52))) x_53) (and (and ?v_71 (not x_53)) (= x_38 x_8)))) (or (and (and (and (and ?v_39 (not (<= x_54 x_9))) (not (<= x_55 x_9))) (< x_54 x_55)) (< x_55 x_56)) (and (and (and (not ?v_39) (= x_54 x_39)) (= x_55 x_44)) (= x_56 x_47)))) ?v_13) (not x_29)) (or (and ?v_19 x_16) (and ?v_21 x_17)))))))))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/pd_init_op_accs.induction.smt2.expected.err000066400000000000000000000000001445011647600266750ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/pd_init_op_accs.induction.smt2.expected.out000066400000000000000000000000061445011647600267220ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LRA/pd_init_op_accs.induction.smt2.expected.time000066400000000000000000000000351445011647600270530ustar00rootroot00000000000000real 0.11 user 0.11 sys 0.00 opensmt-2.5.2/regression/QF_LRA/pd_init_op_accs.induction_simplified.0.smt2000066400000000000000000000015141445011647600266640ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun v12 () Real) (declare-fun v13 () Real) (declare-fun x_37 () Bool) (assert (and (>= v13 0) (or (= v12 0) (= v12 2) (= v12 3)) (or (not (= v13 0)) (not (= v12 0))) (= 0.0 (ite x_37 v13 2)))) ; (and (and (or (not x_37) (= v13 .oite0)) (or x_37 (= 2 .oite0))) (and ; (<= 0 v13) (= 0 .oite0) (and (<= 0 v13) (or (= 0 v12) (= v12 2) (= v12 ; 3)) (or (not (= 0 v12)) (not (= 0 v13)))))) ; (and (<= 0 v13) (or (not (and (<= 0 v13) (<= 0 (* v13 -1)))) (not (and ; (<= 0 v12) (<= 0 (* v12 -1))))) (or (and (<= 0 v12) (<= 0 (* v12 -1))) ; (and (<= -3 (* v12 -1)) (<= 3 v12)) (and (<= -2 (* v12 -1)) (<= 2 v12))) ; (<= 0 .oite0) (<= 0 (* .oite0 -1)) (or x_37 (and (<= 2 .oite0) (<= -2 (* ; .oite0 -1)))) (or (not x_37) (and (<= 0 (+ .oite0 (* v13 -1))) (<= 0 (+ ; v13 (* .oite0 -1)))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/pd_init_op_accs.induction_simplified.0.smt2.expected.err000066400000000000000000000000001445011647600312400ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/pd_init_op_accs.induction_simplified.0.smt2.expected.out000066400000000000000000000000041445011647600312630ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LRA/pd_init_op_accs.induction_simplified.0.smt2.expected.time000066400000000000000000000000351445011647600314160ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/pursuit-safety-15_simplified_0.smt2000066400000000000000000000040001445011647600250550ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun _substvar_36_ () Real) (assert (let ((?v_3 (= _substvar_36_ 40)) (?v_28 0.0) (?v_4 (= _substvar_36_ 0)) (?v_2 false) (?v_6 false) (?v_13 false) (?v_31 0.0) (?v_29 0.0) (?v_10 false) (?v_7 false) (?v_24 true)) (let ((?v_17 false) (?v_0 true) (?v_12 false) (?v_9 true) (?v_27 false) (?v_11 false) (?v_26 false) (?v_20 false) (?v_16 false) (?v_19 (= 0.0 (ite ?v_3 0 (ite ?v_4 40 _substvar_36_)))) (?v_25 false) (?v_36 false) (?v_58 0.0) (?v_37 true) (?v_35 false) (?v_39 false) (?v_46 false) (?v_61 0.0) (?v_59 0.0) (?v_43 false) (?v_40 false) (?v_54 true)) (let ((?v_50 false) (?v_38 true) (?v_41 false) (?v_34 true) (?v_47 false) (?v_33 true) (?v_45 false) (?v_42 true) (?v_57 false) (?v_44 false) (?v_56 false) (?v_52 false) (?v_49 false) (?v_51 (= _substvar_36_ 0.0)) (?v_55 false) (?v_66 false) (?v_88 0.0) (?v_67 true) (?v_65 false) (?v_69 false) (?v_76 false) (?v_91 0.0) (?v_89 0.0) (?v_73 false) (?v_70 false) (?v_84 true)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and true (or (or (or (or (or (or (or (or false (and (and (and true ?v_19) true) true)) false) false) false) false) false) false) false)) true) true) true) (or (or (or (or (or (or (or (or false (and (and (and true ?v_51) true) true)) false) false) false) false) false) false) false)) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true) true))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/pursuit-safety-15_simplified_0.smt2.expected.err000066400000000000000000000000001445011647600274400ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/pursuit-safety-15_simplified_0.smt2.expected.out000066400000000000000000000000061445011647600274650ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LRA/pursuit-safety-15_simplified_0.smt2.expected.time000066400000000000000000000000351445011647600276160ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/sc-5.induction.cvc.smt2000066400000000000000000000260411445011647600225270ustar00rootroot00000000000000(set-logic QF_LRA) (set-info :source | Fully parameterized specification and verification of a synchronizer circuit modeling metastability at various levels of refinement. A paper describing this specification, to be published in Designing Correct Circuits (DCC), 2006, is available from the authors. Geoffrey Brown, Indiana University Lee Pike, Galois Connections, Inc. Translated into CVC format by Leonardo de Moura. This benchmark was automatically translated into SMT-LIB format from CVC format using CVC Lite |) (set-info :smt-lib-version 2.0) (set-info :category "industrial") (set-info :status sat) (declare-fun x_0 () Bool) (declare-fun x_1 () Bool) (declare-fun x_2 () Real) (declare-fun x_3 () Real) (declare-fun x_4 () Bool) (declare-fun x_5 () Bool) (declare-fun x_6 () Real) (declare-fun x_7 () Real) (declare-fun x_8 () Bool) (declare-fun x_9 () Bool) (declare-fun x_10 () Real) (declare-fun x_11 () Real) (declare-fun x_12 () Bool) (declare-fun x_13 () Bool) (declare-fun x_14 () Real) (declare-fun x_15 () Real) (declare-fun x_16 () Bool) (declare-fun x_17 () Bool) (declare-fun x_18 () Real) (declare-fun x_19 () Real) (declare-fun x_20 () Real) (declare-fun x_21 () Real) (declare-fun x_22 () Real) (declare-fun x_23 () Real) (declare-fun x_24 () Real) (declare-fun x_25 () Real) (declare-fun x_26 () Real) (declare-fun x_27 () Real) (declare-fun x_28 () Real) (declare-fun x_29 () Real) (declare-fun x_30 () Bool) (declare-fun x_31 () Bool) (declare-fun x_32 () Real) (declare-fun x_33 () Real) (declare-fun x_34 () Real) (declare-fun x_35 () Real) (declare-fun x_36 () Bool) (declare-fun x_37 () Bool) (declare-fun x_38 () Bool) (declare-fun x_39 () Bool) (declare-fun x_40 () Bool) (declare-fun x_41 () Real) (declare-fun x_42 () Bool) (declare-fun x_43 () Real) (declare-fun x_44 () Real) (declare-fun x_45 () Real) (declare-fun x_46 () Real) (declare-fun x_47 () Real) (declare-fun x_48 () Real) (declare-fun x_49 () Real) (declare-fun x_50 () Real) (declare-fun x_51 () Real) (declare-fun x_52 () Bool) (declare-fun x_53 () Real) (declare-fun x_54 () Bool) (declare-fun x_55 () Bool) (declare-fun x_56 () Real) (declare-fun x_57 () Bool) (declare-fun x_58 () Real) (declare-fun x_59 () Real) (declare-fun x_60 () Real) (declare-fun x_61 () Real) (declare-fun x_62 () Real) (declare-fun x_63 () Real) (declare-fun x_64 () Real) (declare-fun x_65 () Real) (declare-fun x_66 () Bool) (declare-fun x_67 () Real) (declare-fun x_68 () Bool) (declare-fun x_69 () Bool) (declare-fun x_70 () Real) (declare-fun x_71 () Bool) (declare-fun x_72 () Real) (declare-fun x_73 () Real) (declare-fun x_74 () Real) (declare-fun x_75 () Real) (declare-fun x_76 () Real) (declare-fun x_77 () Real) (declare-fun x_78 () Real) (declare-fun x_79 () Real) (declare-fun x_80 () Bool) (declare-fun x_81 () Real) (declare-fun x_82 () Bool) (declare-fun x_83 () Bool) (declare-fun x_84 () Real) (declare-fun x_85 () Bool) (declare-fun x_86 () Real) (declare-fun x_87 () Real) (declare-fun x_88 () Real) (declare-fun x_89 () Real) (declare-fun x_90 () Real) (declare-fun x_91 () Real) (declare-fun x_92 () Real) (declare-fun x_93 () Real) (declare-fun x_94 () Bool) (declare-fun x_95 () Real) (declare-fun x_96 () Real) (declare-fun x_97 () Bool) (declare-fun x_98 () Bool) (declare-fun x_99 () Bool) (declare-fun x_100 () Bool) (declare-fun x_101 () Real) (declare-fun x_102 () Bool) (declare-fun x_103 () Real) (declare-fun x_104 () Real) (declare-fun x_105 () Real) (declare-fun x_106 () Real) (assert (let ((?v_58 (= x_20 x_21)) (?v_59 (= x_22 x_23)) (?v_60 (= x_24 x_25)) (?v_56 (= x_26 x_27))) (let ((?v_61 (not ?v_56)) (?v_64 (= x_28 x_29)) (?v_53 (= x_30 x_31)) (?v_54 (= x_7 x_3)) (?v_57 (ite (<= x_22 x_26) x_22 x_26)) (?v_52 (ite (<= x_26 x_22) x_26 x_22)) (?v_45 (= x_47 x_20)) (?v_46 (= x_23 x_48)) (?v_47 (= x_49 x_24)) (?v_43 (= x_27 x_50))) (let ((?v_48 (not ?v_43)) (?v_51 (= x_51 x_28)) (?v_40 (= x_52 x_30)) (?v_41 (= x_11 x_7)) (?v_44 (ite (<= x_23 x_27) x_23 x_27)) (?v_39 (ite (<= x_27 x_23) x_27 x_23)) (?v_32 (= x_61 x_47)) (?v_33 (= x_48 x_62)) (?v_34 (= x_63 x_49)) (?v_30 (= x_50 x_64))) (let ((?v_35 (not ?v_30)) (?v_38 (= x_65 x_51)) (?v_27 (= x_66 x_52)) (?v_28 (= x_15 x_11)) (?v_31 (ite (<= x_48 x_50) x_48 x_50)) (?v_26 (ite (<= x_50 x_48) x_50 x_48)) (?v_19 (= x_75 x_61)) (?v_20 (= x_62 x_76)) (?v_21 (= x_77 x_63)) (?v_17 (= x_64 x_78))) (let ((?v_22 (not ?v_17)) (?v_25 (= x_79 x_65)) (?v_14 (= x_80 x_66)) (?v_15 (= x_19 x_15)) (?v_18 (ite (<= x_62 x_64) x_62 x_64)) (?v_13 (ite (<= x_64 x_62) x_64 x_62)) (?v_6 (= x_89 x_75)) (?v_7 (= x_76 x_90)) (?v_8 (= x_91 x_77)) (?v_4 (= x_78 x_92))) (let ((?v_9 (not ?v_4)) (?v_12 (= x_93 x_79)) (?v_1 (= x_94 x_80)) (?v_2 (= x_95 x_19)) (?v_5 (ite (<= x_76 x_78) x_76 x_78)) (?v_0 (ite (<= x_78 x_76) x_78 x_76)) (?v_3 (= x_98 x_17)) (?v_11 (= x_19 x_95)) (?v_16 (= x_17 x_13)) (?v_24 (= x_15 x_19)) (?v_29 (= x_13 x_9)) (?v_37 (= x_11 x_15)) (?v_42 (= x_9 x_5)) (?v_50 (= x_7 x_11)) (?v_55 (= x_5 x_1)) (?v_63 (= x_3 x_7))) (let ((?v_10 (+ ?v_5 x_34)) (?v_23 (+ ?v_18 x_34)) (?v_36 (+ ?v_31 x_34)) (?v_49 (+ ?v_44 x_34)) (?v_62 (+ ?v_57 x_34))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (> x_32 0) (> x_33 0)) (>= x_34 0)) (< x_34 x_32)) (< x_34 x_33)) (>= x_45 0)) (< x_45 x_32)) (< x_45 x_33)) (or (= x_16 x_17) (= x_18 x_19))) (or (= x_12 x_13) (= x_14 x_15))) (or (= x_8 x_9) (= x_10 x_11))) (or (= x_4 x_5) (= x_6 x_7))) (or (= x_0 x_1) (= x_2 x_3))) (or (and (and (and (and (and (and (and (and (and (= x_96 0) (= x_97 x_85)) (= ?v_0 x_78)) (<= (+ ?v_0 x_32) x_92)) (or ?v_3 (= x_98 x_16))) (= x_99 x_82)) (= x_100 x_83)) (= x_90 x_76)) ?v_1) ?v_2) (and (and (and (and (and (and (and (and (and (= x_96 1) (= x_100 x_82)) (= ?v_0 x_76)) (<= (+ ?v_0 x_33) x_90)) (or (and (and (= x_101 0) ?v_1) ?v_2) (and (and (= x_101 1) (= x_80 x_83)) (= x_94 (not x_80))))) (= x_102 x_85)) (= x_97 x_16)) (= x_103 x_18)) (= x_92 x_78)) ?v_3))) (or (or (and (and (and (= x_104 0) ?v_9) (or (not (<= x_75 ?v_5)) (= x_102 x_80))) ?v_6) (and (and (and (= x_104 1) ?v_4) (xor x_80 x_94)) (= x_89 ?v_10))) (and (and (and (= x_104 2) ?v_4) (= x_80 x_94)) ?v_6))) (or (or (and (and (and (= x_105 0) (not ?v_7)) (or (not (<= x_77 ?v_0)) (= x_99 x_17))) ?v_8) (and (and (and (= x_105 1) ?v_7) (xor x_17 x_98)) (= x_91 (+ ?v_0 x_45)))) (and (and (and (= x_105 2) ?v_7) (= x_17 x_98)) ?v_8))) (or (or (and (and (and (= x_106 0) ?v_9) (or (not (<= x_79 ?v_5)) (= x_103 x_19))) ?v_12) (and (and (and (= x_106 1) ?v_4) (not ?v_11)) (= x_93 ?v_10))) (and (and (and (= x_106 2) ?v_4) ?v_11) ?v_12))) (or (and (and (and (and (and (and (and (and (and (= x_81 0) (= x_16 x_71)) (= ?v_13 x_64)) (<= (+ ?v_13 x_32) x_78)) (or ?v_16 (= x_17 x_12))) (= x_82 x_68)) (= x_83 x_69)) (= x_76 x_62)) ?v_14) ?v_15) (and (and (and (and (and (and (and (and (and (= x_81 1) (= x_83 x_68)) (= ?v_13 x_62)) (<= (+ ?v_13 x_33) x_76)) (or (and (and (= x_84 0) ?v_14) ?v_15) (and (and (= x_84 1) (= x_66 x_69)) (= x_80 (not x_66))))) (= x_85 x_71)) (= x_16 x_12)) (= x_18 x_14)) (= x_78 x_64)) ?v_16))) (or (or (and (and (and (= x_86 0) ?v_22) (or (not (<= x_61 ?v_18)) (= x_85 x_66))) ?v_19) (and (and (and (= x_86 1) ?v_17) (xor x_66 x_80)) (= x_75 ?v_23))) (and (and (and (= x_86 2) ?v_17) (= x_66 x_80)) ?v_19))) (or (or (and (and (and (= x_87 0) (not ?v_20)) (or (not (<= x_63 ?v_13)) (= x_82 x_13))) ?v_21) (and (and (and (= x_87 1) ?v_20) (xor x_13 x_17)) (= x_77 (+ ?v_13 x_45)))) (and (and (and (= x_87 2) ?v_20) (= x_13 x_17)) ?v_21))) (or (or (and (and (and (= x_88 0) ?v_22) (or (not (<= x_65 ?v_18)) (= x_18 x_15))) ?v_25) (and (and (and (= x_88 1) ?v_17) (not ?v_24)) (= x_79 ?v_23))) (and (and (and (= x_88 2) ?v_17) ?v_24) ?v_25))) (or (and (and (and (and (and (and (and (and (and (= x_67 0) (= x_12 x_57)) (= ?v_26 x_50)) (<= (+ ?v_26 x_32) x_64)) (or ?v_29 (= x_13 x_8))) (= x_68 x_54)) (= x_69 x_55)) (= x_62 x_48)) ?v_27) ?v_28) (and (and (and (and (and (and (and (and (and (= x_67 1) (= x_69 x_54)) (= ?v_26 x_48)) (<= (+ ?v_26 x_33) x_62)) (or (and (and (= x_70 0) ?v_27) ?v_28) (and (and (= x_70 1) (= x_52 x_55)) (= x_66 (not x_52))))) (= x_71 x_57)) (= x_12 x_8)) (= x_14 x_10)) (= x_64 x_50)) ?v_29))) (or (or (and (and (and (= x_72 0) ?v_35) (or (not (<= x_47 ?v_31)) (= x_71 x_52))) ?v_32) (and (and (and (= x_72 1) ?v_30) (xor x_52 x_66)) (= x_61 ?v_36))) (and (and (and (= x_72 2) ?v_30) (= x_52 x_66)) ?v_32))) (or (or (and (and (and (= x_73 0) (not ?v_33)) (or (not (<= x_49 ?v_26)) (= x_68 x_9))) ?v_34) (and (and (and (= x_73 1) ?v_33) (xor x_9 x_13)) (= x_63 (+ ?v_26 x_45)))) (and (and (and (= x_73 2) ?v_33) (= x_9 x_13)) ?v_34))) (or (or (and (and (and (= x_74 0) ?v_35) (or (not (<= x_51 ?v_31)) (= x_14 x_11))) ?v_38) (and (and (and (= x_74 1) ?v_30) (not ?v_37)) (= x_65 ?v_36))) (and (and (and (= x_74 2) ?v_30) ?v_37) ?v_38))) (or (and (and (and (and (and (and (and (and (and (= x_53 0) (= x_8 x_42)) (= ?v_39 x_27)) (<= (+ ?v_39 x_32) x_50)) (or ?v_42 (= x_9 x_4))) (= x_54 x_37)) (= x_55 x_39)) (= x_48 x_23)) ?v_40) ?v_41) (and (and (and (and (and (and (and (and (and (= x_53 1) (= x_55 x_37)) (= ?v_39 x_23)) (<= (+ ?v_39 x_33) x_48)) (or (and (and (= x_56 0) ?v_40) ?v_41) (and (and (= x_56 1) (= x_30 x_39)) (= x_52 (not x_30))))) (= x_57 x_42)) (= x_8 x_4)) (= x_10 x_6)) (= x_50 x_27)) ?v_42))) (or (or (and (and (and (= x_58 0) ?v_48) (or (not (<= x_20 ?v_44)) (= x_57 x_30))) ?v_45) (and (and (and (= x_58 1) ?v_43) (xor x_30 x_52)) (= x_47 ?v_49))) (and (and (and (= x_58 2) ?v_43) (= x_30 x_52)) ?v_45))) (or (or (and (and (and (= x_59 0) (not ?v_46)) (or (not (<= x_24 ?v_39)) (= x_54 x_5))) ?v_47) (and (and (and (= x_59 1) ?v_46) (xor x_5 x_9)) (= x_49 (+ ?v_39 x_45)))) (and (and (and (= x_59 2) ?v_46) (= x_5 x_9)) ?v_47))) (or (or (and (and (and (= x_60 0) ?v_48) (or (not (<= x_28 ?v_44)) (= x_10 x_7))) ?v_51) (and (and (and (= x_60 1) ?v_43) (not ?v_50)) (= x_51 ?v_49))) (and (and (and (= x_60 2) ?v_43) ?v_50) ?v_51))) (or (and (and (and (and (and (and (and (and (and (= x_35 0) (= x_4 x_36)) (= ?v_52 x_26)) (<= (+ ?v_52 x_32) x_27)) (or ?v_55 (= x_5 x_0))) (= x_37 x_38)) (= x_39 x_40)) (= x_23 x_22)) ?v_53) ?v_54) (and (and (and (and (and (and (and (and (and (= x_35 1) (= x_39 x_38)) (= ?v_52 x_22)) (<= (+ ?v_52 x_33) x_23)) (or (and (and (= x_41 0) ?v_53) ?v_54) (and (and (= x_41 1) (= x_31 x_40)) (= x_30 (not x_31))))) (= x_42 x_36)) (= x_4 x_0)) (= x_6 x_2)) (= x_27 x_26)) ?v_55))) (or (or (and (and (and (= x_43 0) ?v_61) (or (not (<= x_21 ?v_57)) (= x_42 x_31))) ?v_58) (and (and (and (= x_43 1) ?v_56) (xor x_31 x_30)) (= x_20 ?v_62))) (and (and (and (= x_43 2) ?v_56) (= x_31 x_30)) ?v_58))) (or (or (and (and (and (= x_44 0) (not ?v_59)) (or (not (<= x_25 ?v_52)) (= x_37 x_1))) ?v_60) (and (and (and (= x_44 1) ?v_59) (xor x_1 x_5)) (= x_24 (+ ?v_52 x_45)))) (and (and (and (= x_44 2) ?v_59) (= x_1 x_5)) ?v_60))) (or (or (and (and (and (= x_46 0) ?v_61) (or (not (<= x_29 ?v_57)) (= x_6 x_3))) ?v_64) (and (and (and (= x_46 1) ?v_56) (not ?v_63)) (= x_28 ?v_62))) (and (and (and (= x_46 2) ?v_56) ?v_63) ?v_64))) (xor x_97 x_98)) (not (= x_103 x_95))))))))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/sc-5.induction.cvc.smt2.expected.err000066400000000000000000000000001445011647600251010ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/sc-5.induction.cvc.smt2.expected.out000066400000000000000000000000041445011647600251240ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LRA/sc-5.induction.cvc.smt2.expected.time000066400000000000000000000000351445011647600252570ustar00rootroot00000000000000real 0.75 user 0.74 sys 0.00 opensmt-2.5.2/regression/QF_LRA/simple_startup_3nodes.abstract.base.smt2000066400000000000000000000407241445011647600262600ustar00rootroot00000000000000(set-logic QF_LRA) (set-info :source | TTA Startup. Bruno Dutertre (bruno@csl.sri.com) |) (set-info :smt-lib-version 2.0) (set-info :category "industrial") (declare-fun x_0 () Real) (declare-fun x_1 () Real) (declare-fun x_2 () Real) (declare-fun x_3 () Real) (declare-fun x_4 () Real) (declare-fun x_5 () Real) (declare-fun x_6 () Real) (declare-fun x_7 () Bool) (declare-fun x_8 () Bool) (declare-fun x_9 () Bool) (declare-fun x_10 () Real) (declare-fun x_11 () Bool) (declare-fun x_12 () Bool) (declare-fun x_13 () Bool) (declare-fun x_14 () Real) (declare-fun x_15 () Real) (declare-fun x_16 () Real) (declare-fun x_17 () Real) (declare-fun x_18 () Real) (declare-fun x_19 () Real) (declare-fun x_20 () Real) (declare-fun x_21 () Real) (declare-fun x_22 () Real) (declare-fun x_23 () Real) (declare-fun x_24 () Real) (declare-fun x_25 () Real) (declare-fun x_26 () Real) (declare-fun x_27 () Real) (declare-fun x_28 () Real) (declare-fun x_29 () Real) (declare-fun x_30 () Real) (declare-fun x_31 () Real) (declare-fun x_32 () Real) (declare-fun x_33 () Real) (declare-fun x_34 () Real) (declare-fun x_35 () Real) (declare-fun x_36 () Real) (declare-fun x_37 () Real) (declare-fun x_38 () Bool) (declare-fun x_39 () Real) (declare-fun x_40 () Bool) (declare-fun x_41 () Bool) (declare-fun x_42 () Real) (declare-fun x_43 () Real) (declare-fun x_44 () Real) (declare-fun x_45 () Real) (declare-fun x_46 () Real) (declare-fun x_47 () Real) (declare-fun x_48 () Real) (declare-fun x_49 () Real) (assert (let ((?v_55 (= x_0 0)) (?v_69 (= x_0 1)) (?v_74 (= x_0 2)) (?v_96 (= x_1 0)) (?v_103 (= x_1 1)) (?v_107 (= x_1 2)) (?v_119 (= x_2 0)) (?v_126 (= x_2 1)) (?v_129 (= x_2 2)) (?v_73 (= x_6 0)) (?v_89 (= x_0 3)) (?v_118 (= x_1 3)) (?v_138 (= x_2 3)) (?v_43 (not x_7)) (?v_44 (not x_8)) (?v_45 (not x_9)) (?v_1 (= x_10 3)) (?v_2 (= x_10 2)) (?v_56 (= x_24 1)) (?v_67 (= x_24 2)) (?v_97 (= x_25 1)) (?v_100 (= x_25 2)) (?v_120 (= x_26 1)) (?v_123 (= x_26 2))) (let ((?v_148 (not ?v_56)) (?v_170 (not (< x_27 (+ x_28 18)))) (?v_149 (not ?v_97)) (?v_172 (not (< x_29 (+ x_28 21)))) (?v_150 (not ?v_120)) (?v_174 (not (< x_30 (+ x_28 24)))) (?v_145 (not ?v_67)) (?v_146 (not ?v_100)) (?v_147 (not ?v_123)) (?v_160 (not (<= (- x_29 x_27) x_14))) (?v_161 (not (<= (- x_30 x_27) x_14))) (?v_162 (not (<= (- x_30 x_29) x_14))) (?v_166 (not (< (- x_27 x_28) 9))) (?v_157 (<= (- x_27 x_23) 9)) (?v_167 (not (< (- x_29 x_28) 12))) (?v_158 (<= (- x_29 x_23) 12)) (?v_168 (not (< (- x_30 x_28) 15))) (?v_159 (<= (- x_30 x_23) 15)) (?v_19 (= x_32 x_33)) (?v_22 (= x_32 x_34)) (?v_25 (= x_33 x_32)) (?v_29 (= x_33 x_34)) (?v_31 (= x_34 x_32)) (?v_32 (= x_34 x_33)) (?v_17 (not (< x_23 x_27))) (?v_182 (= x_32 x_36)) (?v_24 (not (< x_23 x_29))) (?v_184 (= x_33 x_36)) (?v_28 (not (< x_23 x_30))) (?v_186 (= x_34 x_36)) (?v_11 (= x_24 3))) (let ((?v_15 (not ?v_11)) (?v_18 (not (= x_23 x_27))) (?v_12 (= x_25 3))) (let ((?v_16 (not ?v_12)) (?v_20 (not (= x_23 x_29))) (?v_14 (= x_26 3))) (let ((?v_21 (not ?v_14)) (?v_23 (not (= x_23 x_30))) (?v_169 (and x_38 (< x_39 x_27))) (?v_171 (and x_40 (< x_39 x_29))) (?v_173 (and x_41 (< x_39 x_30))) (?v_84 (not x_38)) (?v_116 (not x_40)) (?v_136 (not x_41)) (?v_33 (< x_32 1)) (?v_179 (or (or x_38 x_40) x_41)) (?v_6 (= x_36 3)) (?v_7 (= x_36 2))) (let ((?v_180 (ite ?v_6 x_30 (ite ?v_7 x_29 x_27))) (?v_8 (= x_32 3))) (let ((?v_187 (ite ?v_8 1 (+ x_32 1))) (?v_9 (= x_33 3))) (let ((?v_188 (ite ?v_9 1 (+ x_33 1))) (?v_10 (= x_34 3))) (let ((?v_189 (ite ?v_10 1 (+ x_34 1))) (?v_77 (= x_6 1)) (?v_3 (= x_15 3))) (let ((?v_42 (ite ?v_3 1 (+ x_15 1))) (?v_4 (= x_16 3))) (let ((?v_40 (ite ?v_4 1 (+ x_16 1))) (?v_5 (= x_17 3))) (let ((?v_41 (ite ?v_5 1 (+ x_17 1))) (?v_60 (= x_40 x_8)) (?v_61 (= x_41 x_9)) (?v_62 (= x_36 x_10)) (?v_111 (= x_33 x_10)) (?v_52 (= x_23 x_3)) (?v_53 (= x_23 x_4)) (?v_54 (= x_23 x_5)) (?v_133 (= x_34 x_10)) (?v_93 (= x_26 x_2)) (?v_94 (= x_34 x_17)) (?v_95 (= x_30 x_5)) (?v_64 (= x_24 x_0)) (?v_58 (= x_32 x_15)) (?v_65 (= x_27 x_3)) (?v_90 (= x_25 x_1)) (?v_91 (= x_33 x_16)) (?v_92 (= x_29 x_4)) (?v_79 (= x_32 x_10)) (?v_50 (and (and ?v_43 ?v_44) ?v_45)) (?v_68 (= x_38 false)) (?v_102 (= x_40 false)) (?v_125 (= x_41 false)) (?v_0 (= x_10 1)) (?v_163 (not x_11)) (?v_151 (not x_12))) (let ((?v_177 (and ?v_163 ?v_151)) (?v_152 (not x_13))) (let ((?v_140 (and ?v_177 ?v_152)) (?v_193 (and x_11 ?v_151)) (?v_195 (or x_11 x_12)) (?v_196 (or ?v_163 x_12))) (let ((?v_197 (and (and (and (and (and (or ?v_195 x_13) (or ?v_196 x_13)) (or (or x_11 ?v_151) x_13)) (or (or ?v_163 ?v_151) x_13)) (or ?v_195 ?v_152)) (or ?v_196 ?v_152))) (?v_46 (> x_3 0)) (?v_47 (> x_4 0)) (?v_48 (> x_5 0)) (?v_141 (and (and ?v_84 ?v_116) ?v_136)) (?v_181 (or ?v_15 ?v_17)) (?v_183 (or ?v_16 ?v_24)) (?v_185 (or ?v_21 ?v_28)) (?v_35 (and ?v_148 ?v_145)) (?v_36 (and ?v_149 ?v_146)) (?v_38 (and ?v_150 ?v_147)) (?v_13 (+ x_23 3)) (?v_26 (+ x_27 3)) (?v_27 (+ x_29 3)) (?v_30 (+ x_30 3)) (?v_34 (+ (+ x_27 (* (ite ?v_33 (- (- 1 x_32) 1) (- (+ (- 3 x_32) 1) 1)) 3)) x_14)) (?v_37 (+ (+ x_29 (* (ite (< x_33 2) (- (- 2 x_33) 1) (- (+ (- 3 x_33) 2) 1)) 3)) x_14)) (?v_39 (+ (+ x_30 (* (ite (< x_34 3) (- x_35 1) (- (+ x_35 3) 1)) 3)) x_14))) (let ((?v_178 (and (and (and (and (and (and (and (and (and (and ?v_141 (or (or ?v_11 ?v_12) ?v_14)) (or ?v_15 (<= x_27 ?v_13))) (or ?v_16 (<= x_29 ?v_13))) (or ?v_21 (<= x_30 ?v_13))) (or ?v_15 (and (and (or (or ?v_181 ?v_18) (and (= x_32 x_42) (= x_27 ?v_26))) (or ?v_16 (and (and (or (or ?v_17 ?v_24) (and ?v_19 (= x_27 x_29))) (or (or ?v_18 ?v_20) ?v_19)) (or (or ?v_17 ?v_20) (and (= x_32 x_43) (= x_27 ?v_27)))))) (or ?v_21 (and (and (or (or ?v_17 ?v_28) (and ?v_22 (= x_27 x_30))) (or (or ?v_18 ?v_23) ?v_22)) (or (or ?v_17 ?v_23) (and (= x_32 x_44) (= x_27 ?v_30)))))))) (or ?v_16 (and (and (or ?v_15 (and (and (or (or ?v_24 ?v_17) (and ?v_25 (= x_29 x_27))) (or (or ?v_20 ?v_18) ?v_25)) (or (or ?v_24 ?v_18) (and (= x_33 x_42) (= x_29 ?v_26))))) (or (or ?v_183 ?v_20) (and (= x_33 x_43) (= x_29 ?v_27)))) (or ?v_21 (and (and (or (or ?v_24 ?v_28) (and ?v_29 (= x_29 x_30))) (or (or ?v_20 ?v_23) ?v_29)) (or (or ?v_24 ?v_23) (and (= x_33 x_44) (= x_29 ?v_30)))))))) (or ?v_21 (and (and (or ?v_15 (and (and (or (or ?v_28 ?v_17) (and ?v_31 (= x_30 x_27))) (or (or ?v_23 ?v_18) ?v_31)) (or (or ?v_28 ?v_18) (and (= x_34 x_42) (= x_30 ?v_26))))) (or ?v_16 (and (and (or (or ?v_28 ?v_24) (and ?v_32 (= x_30 x_29))) (or (or ?v_23 ?v_20) ?v_32)) (or (or ?v_28 ?v_20) (and (= x_34 x_43) (= x_30 ?v_27)))))) (or (or ?v_185 ?v_23) (and (= x_34 x_44) (= x_30 ?v_30)))))) (or ?v_15 (and (and (or ?v_35 (not (<= x_27 ?v_34))) (or ?v_36 (not (<= x_29 ?v_34)))) (or ?v_38 (not (<= x_30 ?v_34)))))) (or ?v_16 (and (and (or ?v_35 (not (<= x_27 ?v_37))) (or ?v_36 (not (<= x_29 ?v_37)))) (or ?v_38 (not (<= x_30 ?v_37)))))) (or ?v_21 (and (and (or ?v_35 (not (<= x_27 ?v_39))) (or ?v_36 (not (<= x_29 ?v_39)))) (or ?v_38 (not (<= x_30 ?v_39))))))) (?v_49 (and (and ?v_46 ?v_47) ?v_48)) (?v_51 (and (and (<= x_23 x_3) (<= x_23 x_4)) (<= x_23 x_5))) (?v_139 (= x_23 0)) (?v_59 (and (= x_31 x_6) (= x_39 0)))) (let ((?v_98 (and ?v_59 (= x_38 x_7)))) (let ((?v_121 (and ?v_98 ?v_60)) (?v_63 (= x_28 0))) (let ((?v_57 (and (and (and ?v_121 ?v_61) ?v_62) ?v_63)) (?v_66 (= 0 x_3)) (?v_70 (= 0 0)) (?v_72 (and (and (and (and (and ?v_59 ?v_68) ?v_60) ?v_61) ?v_62) ?v_63)) (?v_71 (+ 0 9))) (let ((?v_75 (= x_27 ?v_71)) (?v_83 (= x_39 (ite ?v_50 (+ 0 x_14) 0)))) (let ((?v_101 (and (= x_31 (ite ?v_50 0 x_6)) ?v_83)) (?v_85 (= x_40 (or ?v_50 x_8))) (?v_86 (= x_41 (or ?v_50 x_9))) (?v_87 (= x_36 (ite ?v_50 1 x_10))) (?v_88 (= x_28 (ite ?v_50 0 0)))) (let ((?v_76 (and (and (and (and (and ?v_101 ?v_68) ?v_85) ?v_86) ?v_87) ?v_88)) (?v_80 (+ 0 3))) (let ((?v_106 (- ?v_80 x_14))) (let ((?v_78 (= x_27 ?v_106)) (?v_81 (and ?v_89 ?v_66)) (?v_82 (= x_27 ?v_80)) (?v_114 (= x_31 (ite ?v_50 1 x_6))) (?v_99 (= 0 x_4)) (?v_105 (and (and (and (and ?v_98 ?v_102) ?v_61) ?v_62) ?v_63)) (?v_104 (+ 0 12))) (let ((?v_108 (= x_29 ?v_104)) (?v_115 (= x_38 (or ?v_50 x_7)))) (let ((?v_124 (and ?v_101 ?v_115)) (?v_117 (= x_36 (ite ?v_50 2 x_10)))) (let ((?v_109 (and (and (and (and ?v_124 ?v_102) ?v_86) ?v_117) ?v_88)) (?v_110 (= x_29 ?v_106)) (?v_112 (and ?v_118 ?v_99)) (?v_113 (= x_29 ?v_80)) (?v_122 (= 0 x_5)) (?v_128 (and (and (and ?v_121 ?v_125) ?v_62) ?v_63)) (?v_127 (+ 0 15))) (let ((?v_130 (= x_30 ?v_127)) (?v_137 (= x_36 (ite ?v_50 3 x_10)))) (let ((?v_131 (and (and (and (and ?v_124 ?v_85) ?v_125) ?v_137) ?v_88)) (?v_132 (= x_30 ?v_106)) (?v_134 (and ?v_138 ?v_122)) (?v_135 (= x_30 ?v_80)) (?v_142 (or (= x_24 0) ?v_56)) (?v_143 (or (= x_25 0) ?v_97)) (?v_144 (or (= x_26 0) ?v_120)) (?v_165 (and (and ?v_179 (= x_31 0)) (= x_37 2)))) (let ((?v_154 (or ?v_142 ?v_67)) (?v_155 (or ?v_143 ?v_100)) (?v_156 (or ?v_144 ?v_123))) (let ((?v_153 (and (and (and (and (and (and (and (and (and ?v_165 ?v_154) ?v_155) ?v_156) (or ?v_145 (and (and ?v_84 ?v_166) ?v_157))) (or ?v_146 (and (and ?v_116 ?v_167) ?v_158))) (or ?v_147 (and (and ?v_136 ?v_168) ?v_159))) (or (or ?v_148 x_38) ?v_170)) (or (or ?v_149 x_40) ?v_172)) (or (or ?v_150 x_41) ?v_174))) (?v_164 (and (and (and (and (and (and (and (and (and (and (and (and ?v_141 (or (or ?v_67 ?v_100) ?v_123)) ?v_154) ?v_155) ?v_156) (or ?v_145 ?v_157)) (or ?v_146 ?v_158)) (or ?v_147 ?v_159)) (or ?v_145 (and (or ?v_146 ?v_160) (or ?v_147 ?v_161)))) (or (or ?v_146 ?v_147) ?v_162)) (or ?v_145 (and (and (or ?v_148 (not (<= (- x_27 x_27) x_14))) (or ?v_149 ?v_160)) (or ?v_150 ?v_161)))) (or ?v_146 (and (and (or ?v_148 (not (<= (- x_27 x_29) x_14))) (or ?v_149 (not (<= (- x_29 x_29) x_14)))) (or ?v_150 ?v_162)))) (or ?v_147 (and (and (or ?v_148 (not (<= (- x_27 x_30) x_14))) (or ?v_149 (not (<= (- x_29 x_30) x_14)))) (or ?v_150 (not (<= (- x_30 x_30) x_14))))))) (?v_190 (or (or ?v_148 ?v_169) ?v_170)) (?v_191 (or (or ?v_149 ?v_171) ?v_172)) (?v_192 (or (or ?v_150 ?v_173) ?v_174)) (?v_175 (+ x_28 3))) (let ((?v_176 (and (and (and (and (and (and (and (and (and (and (and ?v_165 (= ?v_180 (+ (+ x_28 (* (- x_36 1) 3)) 9))) (not (ite ?v_6 x_41 (ite ?v_7 x_40 x_38)))) (or (or (or ?v_145 (= 1 x_36)) ?v_169) (and ?v_166 ?v_157))) (or (or (or ?v_146 (= 2 x_36)) ?v_171) (and ?v_167 ?v_158))) (or (or (or ?v_147 (= 3 x_36)) ?v_173) (and ?v_168 ?v_159))) ?v_190) ?v_191) ?v_192) (or ?v_15 (and ?v_182 (= x_27 ?v_175)))) (or ?v_16 (and ?v_184 (= x_29 ?v_175)))) (or ?v_21 (and ?v_186 (= x_30 ?v_175))))) (?v_194 (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and ?v_179 (= x_31 1)) (= x_37 3)) (= (ite ?v_6 x_34 (ite ?v_7 x_33 x_32)) x_36)) (= ?v_180 ?v_175)) (or ?v_181 (and ?v_182 (= x_27 ?v_180)))) (or ?v_183 (and ?v_184 (= x_29 ?v_180)))) (or ?v_185 (and ?v_186 (= x_30 ?v_180)))) (or (or ?v_15 ?v_18) (and (= ?v_187 x_36) (= ?v_180 ?v_26)))) (or (or ?v_16 ?v_20) (and (= ?v_188 x_36) (= ?v_180 ?v_27)))) (or (or ?v_21 ?v_23) (and (= ?v_189 x_36) (= ?v_180 ?v_30)))) ?v_190) ?v_191) ?v_192) (or ?v_145 ?v_169)) (or ?v_146 ?v_171)) (or ?v_147 ?v_173)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (<= x_49 6) (>= x_49 0)) (<= x_45 6)) (>= x_45 0)) (<= x_37 3)) (>= x_37 0)) (<= x_31 1)) (>= x_31 0)) (<= x_26 3)) (>= x_26 0)) (<= x_25 3)) (>= x_25 0)) (<= x_24 3)) (>= x_24 0)) (<= x_19 3)) (>= x_19 0)) (<= x_6 1)) (>= x_6 0)) (<= x_2 3)) (>= x_2 0)) (<= x_1 3)) (>= x_1 0)) (<= x_0 3)) (>= x_0 0)) (or (or ?v_0 ?v_2) ?v_1)) (not (< x_10 1))) (<= x_10 3)) (> x_14 0)) (< x_14 (/ 3 2))) (or (or (= x_15 1) (= x_15 2)) ?v_3)) (not (< x_15 1))) (<= x_15 3)) (or (or (= x_16 1) (= x_16 2)) ?v_4)) (not (< x_16 1))) (<= x_16 3)) (or (or (= x_17 1) (= x_17 2)) ?v_5)) (not (< x_17 1))) (<= x_17 3)) (or (or (= x_32 1) (= x_32 2)) ?v_8)) (not ?v_33)) (<= x_32 3)) (or (or (= x_33 1) (= x_33 2)) ?v_9)) (not (< x_33 1))) (<= x_33 3)) (or (or (= x_34 1) (= x_34 2)) ?v_10)) (not (< x_34 1))) (<= x_34 3)) (or (or (= x_36 1) ?v_7) ?v_6)) (not (< x_36 1))) (<= x_36 3)) ?v_55) ?v_96) ?v_119) ?v_46) (< x_3 30)) ?v_47) (< x_4 30)) ?v_48) (< x_5 30)) ?v_77) ?v_43) ?v_44) ?v_45) ?v_0) ?v_140) (= x_18 (- 3 x_17))) (= x_19 (ite ?v_1 x_2 (ite ?v_2 x_1 x_0)))) (= x_20 ?v_42)) (= x_21 ?v_40)) (= x_22 ?v_41)) (= x_35 (- 3 x_34))) (= x_37 (ite ?v_6 x_26 (ite ?v_7 x_25 x_24)))) (= x_42 ?v_187)) (= x_43 ?v_188)) (= x_44 ?v_189)) (= x_45 (ite ?v_178 4 6))) (= x_46 ?v_40)) (= x_47 ?v_41)) (= x_48 ?v_42)) (or (and (and (and (and (and (and (and (and (and (and (and (ite ?v_50 ?v_49 (and ?v_49 (> 0 0))) (ite ?v_50 (and ?v_51 (or (or ?v_52 ?v_53) ?v_54)) (and (and ?v_51 (<= x_23 0)) (or (or (or ?v_139 ?v_52) ?v_53) ?v_54)))) ?v_64) ?v_90) ?v_93) ?v_58) ?v_91) ?v_94) ?v_65) ?v_92) ?v_95) ?v_57) (and (or (or (and (and (and (and (and (and (or (or (or (or (or (or (or (or (or (and (and (and (and (and ?v_55 ?v_66) ?v_56) (= x_27 (+ 0 18))) ?v_57) ?v_58) (and (and (and (and (and (and ?v_55 x_7) ?v_70) ?v_72) ?v_64) ?v_58) ?v_65)) (and (and (and (and (and ?v_69 ?v_66) ?v_67) ?v_75) ?v_76) ?v_58)) (and (and (and (and (and (and (and ?v_69 x_7) ?v_73) ?v_70) ?v_67) (= x_27 (- ?v_71 x_14))) ?v_72) ?v_58)) (and (and (and (and (and (and (and ?v_74 x_7) ?v_73) ?v_70) ?v_11) ?v_78) ?v_79) ?v_72)) (and (and (and (and (and ?v_74 ?v_66) ?v_75) ?v_76) ?v_64) ?v_58)) (and (and (and (and (and (and (and (or ?v_69 ?v_74) x_7) ?v_77) ?v_70) ?v_11) ?v_78) ?v_79) ?v_72)) (and (and (and (and (and ?v_81 (not (= ?v_42 1))) ?v_82) (= x_32 x_48)) ?v_57) ?v_64)) (and (and (and (and (and (and (and (and (and (and (and ?v_81 (= x_48 1)) ?v_82) (= x_32 ?v_42)) ?v_114) ?v_83) ?v_84) ?v_85) ?v_86) ?v_87) ?v_88) ?v_64)) (and (and (and (and (and (and (and ?v_89 x_7) ?v_77) ?v_70) ?v_72) ?v_64) ?v_58) ?v_65)) ?v_90) ?v_91) ?v_92) ?v_93) ?v_94) ?v_95) (and (and (and (and (and (and (or (or (or (or (or (or (or (or (or (and (and (and (and (and ?v_96 ?v_99) ?v_97) (= x_29 (+ 0 21))) ?v_57) ?v_91) (and (and (and (and (and (and ?v_96 x_8) ?v_70) ?v_105) ?v_90) ?v_91) ?v_92)) (and (and (and (and (and ?v_103 ?v_99) ?v_100) ?v_108) ?v_109) ?v_91)) (and (and (and (and (and (and (and ?v_103 x_8) ?v_73) ?v_70) ?v_100) (= x_29 (- ?v_104 x_14))) ?v_105) ?v_91)) (and (and (and (and (and (and (and ?v_107 x_8) ?v_73) ?v_70) ?v_12) ?v_110) ?v_111) ?v_105)) (and (and (and (and (and ?v_107 ?v_99) ?v_108) ?v_109) ?v_90) ?v_91)) (and (and (and (and (and (and (and (or ?v_103 ?v_107) x_8) ?v_77) ?v_70) ?v_12) ?v_110) ?v_111) ?v_105)) (and (and (and (and (and ?v_112 (not (= ?v_40 2))) ?v_113) (= x_33 x_46)) ?v_57) ?v_90)) (and (and (and (and (and (and (and (and (and (and (and ?v_112 (= x_46 2)) ?v_113) (= x_33 ?v_40)) ?v_114) ?v_83) ?v_115) ?v_116) ?v_86) ?v_117) ?v_88) ?v_90)) (and (and (and (and (and (and (and ?v_118 x_8) ?v_77) ?v_70) ?v_105) ?v_90) ?v_91) ?v_92)) ?v_64) ?v_58) ?v_65) ?v_93) ?v_94) ?v_95)) (and (and (and (and (and (and (or (or (or (or (or (or (or (or (or (and (and (and (and (and ?v_119 ?v_122) ?v_120) (= x_30 (+ 0 24))) ?v_57) ?v_94) (and (and (and (and (and (and ?v_119 x_9) ?v_70) ?v_128) ?v_93) ?v_94) ?v_95)) (and (and (and (and (and ?v_126 ?v_122) ?v_123) ?v_130) ?v_131) ?v_94)) (and (and (and (and (and (and (and ?v_126 x_9) ?v_73) ?v_70) ?v_123) (= x_30 (- ?v_127 x_14))) ?v_128) ?v_94)) (and (and (and (and (and (and (and ?v_129 x_9) ?v_73) ?v_70) ?v_14) ?v_132) ?v_133) ?v_128)) (and (and (and (and (and ?v_129 ?v_122) ?v_130) ?v_131) ?v_93) ?v_94)) (and (and (and (and (and (and (and (or ?v_126 ?v_129) x_9) ?v_77) ?v_70) ?v_14) ?v_132) ?v_133) ?v_128)) (and (and (and (and (and ?v_134 (not (= ?v_41 3))) ?v_135) (= x_34 x_47)) ?v_57) ?v_93)) (and (and (and (and (and (and (and (and (and (and (and ?v_134 (= x_47 3)) ?v_135) (= x_34 ?v_41)) ?v_114) ?v_83) ?v_115) ?v_85) ?v_136) ?v_137) ?v_88) ?v_93)) (and (and (and (and (and (and (and ?v_138 x_9) ?v_77) ?v_70) ?v_128) ?v_93) ?v_94) ?v_95)) ?v_64) ?v_58) ?v_65) ?v_90) ?v_91) ?v_92)) ?v_139))) (or (or (or (or (or (or (and ?v_140 (= x_49 (ite (and (and (and ?v_141 ?v_142) ?v_143) ?v_144) 0 (ite ?v_153 1 6)))) (and (and ?v_193 ?v_152) (= x_49 (ite ?v_153 1 (ite ?v_164 2 6))))) (and (and (and ?v_163 x_12) ?v_152) (= x_49 (ite ?v_164 2 (ite ?v_176 3 6))))) (and (and (and x_11 x_12) ?v_152) (= x_49 (ite ?v_176 3 (ite ?v_164 2 x_45))))) (and (and ?v_177 x_13) (= x_49 (ite ?v_178 4 (ite ?v_194 5 6))))) (and (and ?v_193 x_13) (= x_49 (ite ?v_194 5 x_45)))) (and ?v_197 (= x_49 6)))) (or (and (and (and (and (and (not (= x_49 0)) (not (= x_49 1))) (not (= x_49 2))) (not (= x_49 3))) (not (= x_49 4))) (not (= x_49 5))) ?v_197)) (or (or ?v_152 ?v_151) ?v_163))))))))))))))))))))))))))))))))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/simple_startup_3nodes.abstract.base.smt2.expected.err000066400000000000000000000000001445011647600306260ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/simple_startup_3nodes.abstract.base.smt2.expected.out000066400000000000000000000000061445011647600306530ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LRA/simple_startup_3nodes.abstract.base.smt2.expected.time000066400000000000000000000000351445011647600310040ustar00rootroot00000000000000real 0.14 user 0.14 sys 0.00 opensmt-2.5.2/regression/QF_LRA/simple_startup_3nodes.abstract.base_simplified.0.smt2000066400000000000000000000004121445011647600306110ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun _substvar_1_ () Real) (assert (let ( (?v_39 (+ (+ _substvar_1_ (* (ite true (- 0.0 1) 0.0) 3)) 0.0)) ) (let ( (?v_178 (and false (or false (and false (or false (not (<= _substvar_1_ ?v_39))))))) ) false))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/simple_startup_3nodes.abstract.base_simplified.0.smt2.expected.err000066400000000000000000000000001445011647600331710ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/simple_startup_3nodes.abstract.base_simplified.0.smt2.expected.out000066400000000000000000000000061445011647600332160ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LRA/simple_startup_3nodes.abstract.base_simplified.0.smt2.expected.time000066400000000000000000000000351445011647600333470ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/simple_startup_3nodes.abstract.base_simplified.1.smt2000066400000000000000000000001431445011647600306130ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun v1 () Real) (assert (<= v1 (+ v1 (* (- 1) 3)))) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/simple_startup_3nodes.abstract.base_simplified.1.smt2.expected.err000066400000000000000000000000001445011647600331720ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/simple_startup_3nodes.abstract.base_simplified.1.smt2.expected.out000066400000000000000000000000061445011647600332170ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LRA/simple_startup_3nodes.abstract.base_simplified.1.smt2.expected.time000066400000000000000000000000351445011647600333500ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/small_simplified.1.smt2000066400000000000000000000005121445011647600226620ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun s0 () Real) (declare-fun s2 () Real) (declare-fun m () Real) (assert (>= m 0.0)) (assert (or (< (+ s2 (* m (- 10.0))) 0.0) (<= (+ (* (- 1.0) s0) (* m (- 10.0))) 0.0) )) (assert (or (< (+ (* s2 (- 4294967296.0)) 1.0 s0) 0.0) (< (* s2 (- 4294967296.0)) 0.0) )) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/small_simplified.1.smt2.expected.err000066400000000000000000000000001445011647600252410ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/small_simplified.1.smt2.expected.out000066400000000000000000000000041445011647600252640ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_LRA/small_simplified.1.smt2.expected.time000066400000000000000000000000351445011647600254170ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_LRA/tricky_ite.smt2000066400000000000000000000003711445011647600213570ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun x8 () Real) (declare-fun x7 () Real) (declare-fun x_1 () Bool) (assert (and (or (not (= x8 0)) x_1) (or (and (= x8 0) (= x7 (ite (not x_1) x8 1))) (and (= x8 1) (= x7 x8))) (= x7 0)) ) (check-sat) (exit) opensmt-2.5.2/regression/QF_LRA/tricky_ite.smt2.expected.err000066400000000000000000000000001445011647600237330ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_LRA/tricky_ite.smt2.expected.out000066400000000000000000000000061445011647600237600ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_LRA/tricky_ite.smt2.expected.time000066400000000000000000000000351445011647600241110ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_RDL/000077500000000000000000000000001445011647600164045ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_RDL/basic_sat.smt2000066400000000000000000000001641445011647600211440ustar00rootroot00000000000000(set-logic QF_RDL) (declare-fun b () Real) (set-info :status sat) (assert (and (< 0 b) (< b 1))) (check-sat) (exit) opensmt-2.5.2/regression/QF_RDL/basic_sat.smt2.expected.err000066400000000000000000000000001445011647600235200ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_RDL/basic_sat.smt2.expected.out000066400000000000000000000000041445011647600235430ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_RDL/basic_unsat.smt2000066400000000000000000000002161445011647600215050ustar00rootroot00000000000000(set-logic QF_RDL) (declare-fun a () Real) (declare-fun b () Real) (set-info :status unsat) (assert (and (< a b) (< b a))) (check-sat) (exit) opensmt-2.5.2/regression/QF_RDL/basic_unsat.smt2.expected.err000066400000000000000000000000001445011647600240630ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_RDL/basic_unsat.smt2.expected.out000066400000000000000000000000061445011647600241100ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_RDL/empty.smt2000066400000000000000000000001241445011647600203460ustar00rootroot00000000000000(set-option :produce-model 1) (set-info :status sat) (set-logic QF_RDL) (check-sat) opensmt-2.5.2/regression/QF_RDL/empty.smt2.expected.err000066400000000000000000000000001445011647600227260ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_RDL/empty.smt2.expected.out000066400000000000000000000000041445011647600227510ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_RDL/pure_bool.smt2000066400000000000000000000001671445011647600212050ustar00rootroot00000000000000(set-option :produce-model 1) (set-info :status sat) (set-logic QF_RDL) (declare-fun x () Bool) (assert x) (check-sat) opensmt-2.5.2/regression/QF_RDL/pure_bool.smt2.expected.err000066400000000000000000000000001445011647600235560ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_RDL/pure_bool.smt2.expected.out000066400000000000000000000000041445011647600236010ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/000077500000000000000000000000001445011647600162755ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/2018-Goel-hwbench_QF_UF_cache_coherence_three_ab_cti_max.smt2000066400000000000000000002024201445011647600314510ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_UF) (set-info :source | Generated by: Aman Goel (amangoel@umich.edu), Karem A. Sakallah (karem@umich.edu) Generated on: 2018-04-06 Generated by the tool Averroes 2 (successor of [1]) which implements safety property verification on hardware systems. This SMT problem belongs to a set of SMT problems generated by applying Averroes 2 to benchmarks derived from [2-5]. A total of 412 systems (345 from [2], 19 from [3], 26 from [4], 22 from [5]) were syntactically converted from their original formats (using [6, 7]), and given to Averroes 2 to perform property checking with abstraction (wide bit-vectors -> terms, wide operators -> UF) using SMT solvers [8, 9]. [1] Lee S., Sakallah K.A. (2014) Unbounded Scalable Verification Based on Approximate Property-Directed Reachability and Datapath Abstraction. In: Biere A., Bloem R. (eds) Computer Aided Verification. CAV 2014. Lecture Notes in Computer Science, vol 8559. Springer, Cham [2] http://fmv.jku.at/aiger/index.html#beem [3] http://www.cs.cmu.edu/~modelcheck/vcegar [4] http://www.cprover.org/hardware/v2c [5] http://github.com/aman-goel/verilogbench [6] http://www.clifford.at/yosys [7] http://github.com/chengyinwu/V3 [8] http://github.com/Z3Prover/z3 [9] http://github.com/SRI-CSL/yices2 id: cache_coherence_three query-maker: "Yices 2" query-time: 6.711000 ms query-class: abstract query-category: oneshot query-type: cti status: sat |) (set-info :license "https://creativecommons.org/licenses/by/4.0/") (set-info :category "industrial") ; (set-info :status sat) (declare-sort utt$2 0) (declare-sort utt$3 0) (declare-sort utt$29 0) (declare-sort utt$31 0) (declare-sort utt$32 0) (declare-fun Concat_32_1_31 (Bool utt$31 ) utt$32) (declare-fun Concat_32_3_29 (utt$3 utt$29 ) utt$32) (declare-fun Extract_1_0_0_32 (utt$32 ) Bool) (declare-fun Extract_3_2_0_32 (utt$32 ) utt$3) (declare-fun Sub_32_32_32 (utt$32 utt$32 ) utt$32) (declare-fun y$1 () Bool) (declare-fun y$100 () Bool) (declare-fun y$1006 () Bool) (declare-fun y$1007 () Bool) (declare-fun y$1008 () Bool) (declare-fun y$1011 () Bool) (declare-fun y$1012 () Bool) (declare-fun y$1016 () Bool) (declare-fun y$1017 () Bool) (declare-fun y$1020 () Bool) (declare-fun y$1021 () Bool) (declare-fun y$1025 () Bool) (declare-fun y$1028 () Bool) (declare-fun y$1031 () Bool) (declare-fun y$1032 () Bool) (declare-fun y$1036 () Bool) (declare-fun y$1039 () Bool) (declare-fun y$1040 () Bool) (declare-fun y$1041 () Bool) (declare-fun y$1042 () Bool) (declare-fun y$1043 () Bool) (declare-fun y$1044 () Bool) (declare-fun y$1078 () Bool) (declare-fun y$108 () Bool) (declare-fun y$1134 () Bool) (declare-fun y$1151 () Bool) (declare-fun y$1152 () Bool) (declare-fun y$1153 () Bool) (declare-fun y$1159 () Bool) (declare-fun y$116 () Bool) (declare-fun y$1161 () Bool) (declare-fun y$12 () Bool) (declare-fun y$1208 () Bool) (declare-fun y$1209 () Bool) (declare-fun y$1210 () Bool) (declare-fun y$1211 () Bool) (declare-fun y$1212 () Bool) (declare-fun y$1213 () Bool) (declare-fun y$1214 () Bool) (declare-fun y$1217 () Bool) (declare-fun y$1219 () Bool) (declare-fun y$122 () Bool) (declare-fun y$1220 () Bool) (declare-fun y$1221 () Bool) (declare-fun y$125 () Bool) (declare-fun y$14 () Bool) (declare-fun y$141 () Bool) (declare-fun y$146 () Bool) (declare-fun y$149 () Bool) (declare-fun y$157 () Bool) (declare-fun y$16 () Bool) (declare-fun y$163 () Bool) (declare-fun y$18 () Bool) (declare-fun y$180 () Bool) (declare-fun y$184 () Bool) (declare-fun y$186 () Bool) (declare-fun y$193 () Bool) (declare-fun y$195 () Bool) (declare-fun y$199 () Bool) (declare-fun y$200 () Bool) (declare-fun y$201 () Bool) (declare-fun y$214 () Bool) (declare-fun y$215 () Bool) (declare-fun y$216 () Bool) (declare-fun y$22 () Bool) (declare-fun y$221 () Bool) (declare-fun y$237 () Bool) (declare-fun y$242 () Bool) (declare-fun y$243 () Bool) (declare-fun y$245 () Bool) (declare-fun y$25 () Bool) (declare-fun y$254 () Bool) (declare-fun y$271 () Bool) (declare-fun y$273 () Bool) (declare-fun y$274 () Bool) (declare-fun y$284 () Bool) (declare-fun y$287 () Bool) (declare-fun y$288 () Bool) (declare-fun y$292 () Bool) (declare-fun y$3 () Bool) (declare-fun y$30 () Bool) (declare-fun y$301 () Bool) (declare-fun y$316 () Bool) (declare-fun y$318 () Bool) (declare-fun y$319 () Bool) (declare-fun y$33 () Bool) (declare-fun y$331 () Bool) (declare-fun y$334 () Bool) (declare-fun y$335 () Bool) (declare-fun y$339 () Bool) (declare-fun y$35 () Bool) (declare-fun y$37 () Bool) (declare-fun y$374 () Bool) (declare-fun y$376 () Bool) (declare-fun y$379 () Bool) (declare-fun y$384 () Bool) (declare-fun y$387 () Bool) (declare-fun y$39 () Bool) (declare-fun y$392 () Bool) (declare-fun y$403 () Bool) (declare-fun y$41 () Bool) (declare-fun y$43 () Bool) (declare-fun y$459 () Bool) (declare-fun y$46 () Bool) (declare-fun y$465 () Bool) (declare-fun y$471 () Bool) (declare-fun y$477 () Bool) (declare-fun y$48 () Bool) (declare-fun y$483 () Bool) (declare-fun y$487 () Bool) (declare-fun y$495 () Bool) (declare-fun y$5 () Bool) (declare-fun y$506 () Bool) (declare-fun y$510 () Bool) (declare-fun y$511 () Bool) (declare-fun y$512 () Bool) (declare-fun y$513 () Bool) (declare-fun y$518 () Bool) (declare-fun y$52 () Bool) (declare-fun y$523 () Bool) (declare-fun y$527 () utt$3) (declare-fun y$533 () Bool) (declare-fun y$54 () Bool) (declare-fun y$547 () Bool) (declare-fun y$552 () Bool) (declare-fun y$555 () Bool) (declare-fun y$56 () Bool) (declare-fun y$562 () Bool) (declare-fun y$567 () Bool) (declare-fun y$58 () Bool) (declare-fun y$584 () Bool) (declare-fun y$588 () Bool) (declare-fun y$590 () Bool) (declare-fun y$597 () Bool) (declare-fun y$599 () Bool) (declare-fun y$60 () Bool) (declare-fun y$62 () Bool) (declare-fun y$632 () Bool) (declare-fun y$64 () Bool) (declare-fun y$67 () Bool) (declare-fun y$684 () Bool) (declare-fun y$69 () Bool) (declare-fun y$690 () Bool) (declare-fun y$696 () Bool) (declare-fun y$7 () Bool) (declare-fun y$702 () Bool) (declare-fun y$708 () Bool) (declare-fun y$712 () Bool) (declare-fun y$729 () Bool) (declare-fun y$73 () Bool) (declare-fun y$733 () Bool) (declare-fun y$734 () Bool) (declare-fun y$735 () Bool) (declare-fun y$736 () Bool) (declare-fun y$740 () Bool) (declare-fun y$745 () Bool) (declare-fun y$749 () utt$3) (declare-fun y$75 () Bool) (declare-fun y$755 () Bool) (declare-fun y$769 () Bool) (declare-fun y$77 () Bool) (declare-fun y$774 () Bool) (declare-fun y$777 () Bool) (declare-fun y$784 () Bool) (declare-fun y$789 () Bool) (declare-fun y$79 () Bool) (declare-fun y$806 () Bool) (declare-fun y$810 () Bool) (declare-fun y$812 () Bool) (declare-fun y$819 () Bool) (declare-fun y$821 () Bool) (declare-fun y$854 () Bool) (declare-fun y$89 () Bool) (declare-fun y$9 () Bool) (declare-fun y$906 () Bool) (declare-fun y$912 () Bool) (declare-fun y$918 () Bool) (declare-fun y$924 () Bool) (declare-fun y$930 () Bool) (declare-fun y$934 () Bool) (declare-fun y$94 () Bool) (declare-fun y$951 () Bool) (declare-fun y$955 () Bool) (declare-fun y$956 () Bool) (declare-fun y$957 () Bool) (declare-fun y$958 () Bool) (declare-fun y$962 () Bool) (declare-fun y$967 () Bool) (declare-fun y$971 () utt$3) (declare-fun y$977 () Bool) (declare-fun y$978 () Bool) (declare-fun y$984 () Bool) (declare-fun y$987 () Bool) (declare-fun y$992 () Bool) (declare-fun y$995 () Bool) (declare-fun y$ND_inB () Bool) (declare-fun y$ND_inB_op () Bool) (declare-fun y$ND_inC () Bool) (declare-fun y$ND_inC_op () Bool) (declare-fun y$all_shared () Bool) (declare-fun y$all_shared_op () Bool) (declare-fun y$bus_arbiter.bus_ackA () Bool) (declare-fun y$bus_arbiter.bus_ackA$next () Bool) (declare-fun y$bus_arbiter.bus_ackA$next_rhs () Bool) (declare-fun y$bus_arbiter.bus_ackA$next_rhs_op () Bool) (declare-fun y$bus_arbiter.bus_ackB () Bool) (declare-fun y$bus_arbiter.bus_ackB$next () Bool) (declare-fun y$bus_arbiter.bus_ackB$next_rhs () Bool) (declare-fun y$bus_arbiter.bus_ackB$next_rhs_op () Bool) (declare-fun y$bus_arbiter.bus_ackC () Bool) (declare-fun y$bus_arbiter.bus_ackC$next () Bool) (declare-fun y$bus_arbiter.bus_ackC$next_rhs () Bool) (declare-fun y$bus_arbiter.bus_ackC$next_rhs_op () Bool) (declare-fun y$bus_arbiter.invalidate () Bool) (declare-fun y$bus_arbiter.invalidate$next () Bool) (declare-fun y$bus_arbiter.invalidate$next_rhs () Bool) (declare-fun y$bus_arbiter.invalidate$next_rhs_op () Bool) (declare-fun y$bus_arbiter.is_snoop () Bool) (declare-fun y$bus_arbiter.is_snoop$next () Bool) (declare-fun y$bus_arbiter.is_snoop$next_rhs () Bool) (declare-fun y$bus_arbiter.is_snoop$next_rhs_op () Bool) (declare-fun y$bus_arbiter.shared_snoop () utt$3) (declare-fun y$bus_arbiter.shared_snoop$next () utt$3) (declare-fun y$bus_arbiter.shared_snoop$next_rhs () utt$3) (declare-fun y$bus_arbiter.shared_snoop$next_rhs_op () utt$3) (declare-fun y$info_availA () Bool) (declare-fun y$info_availB () Bool) (declare-fun y$info_availC () Bool) (declare-fun y$is_sharedA () Bool) (declare-fun y$is_sharedA$next () Bool) (declare-fun y$is_sharedB () Bool) (declare-fun y$is_sharedB$next () Bool) (declare-fun y$is_sharedC () Bool) (declare-fun y$is_sharedC$next () Bool) (declare-fun y$master_inB () Bool) (declare-fun y$master_outB () Bool) (declare-fun y$n0s1 () Bool) (declare-fun y$n0s2 () utt$2) (declare-fun y$n0s29 () utt$29) (declare-fun y$n0s3 () utt$3) (declare-fun y$n0s31 () utt$31) (declare-fun y$n0s32 () utt$32) (declare-fun y$n1s1 () Bool) (declare-fun y$n1s2 () utt$2) (declare-fun y$n1s3 () utt$3) (declare-fun y$n1s32 () utt$32) (declare-fun y$n2s2 () utt$2) (declare-fun y$n2s3 () utt$3) (declare-fun y$n3s3 () utt$3) (declare-fun y$n4s3 () utt$3) (declare-fun y$n5s3 () utt$3) (declare-fun y$pcacheA.bus_req () Bool) (declare-fun y$pcacheA.bus_req$next () Bool) (declare-fun y$pcacheA.bus_req$next_rhs () Bool) (declare-fun y$pcacheA.bus_req$next_rhs_op () Bool) (declare-fun y$pcacheA.hit () Bool) (declare-fun y$pcacheA.hit$next () Bool) (declare-fun y$pcacheA.hit$next_rhs () Bool) (declare-fun y$pcacheA.hit$next_rhs_op () Bool) (declare-fun y$pcacheA.inv_out () Bool) (declare-fun y$pcacheA.inv_out$next () Bool) (declare-fun y$pcacheA.inv_out$next_rhs () Bool) (declare-fun y$pcacheA.inv_out$next_rhs_op () Bool) (declare-fun y$pcacheA.miss () Bool) (declare-fun y$pcacheA.miss$next () Bool) (declare-fun y$pcacheA.miss$next_rhs () Bool) (declare-fun y$pcacheA.miss$next_rhs_op () Bool) (declare-fun y$pcacheA.next_state () utt$2) (declare-fun y$pcacheA.next_state$next () utt$2) (declare-fun y$pcacheA.next_state$next_rhs () utt$2) (declare-fun y$pcacheA.next_state$next_rhs_op () utt$2) (declare-fun y$pcacheA.proc.count () utt$3) (declare-fun y$pcacheA.proc.count$next () utt$3) (declare-fun y$pcacheA.proc.count$next_rhs () utt$3) (declare-fun y$pcacheA.proc.count$next_rhs_op () utt$3) (declare-fun y$pcacheA.proc.req_enable () Bool) (declare-fun y$pcacheA.proc.valid () Bool) (declare-fun y$pcacheA.proc.valid$next () Bool) (declare-fun y$pcacheA.proc.valid$next_rhs () Bool) (declare-fun y$pcacheA.proc.valid$next_rhs_op () Bool) (declare-fun y$pcacheA.read () Bool) (declare-fun y$pcacheA.read$next () Bool) (declare-fun y$pcacheA.read$next_rhs () Bool) (declare-fun y$pcacheA.read$next_rhs_op () Bool) (declare-fun y$pcacheA.snoop_type () utt$3) (declare-fun y$pcacheA.snoop_type$next () utt$3) (declare-fun y$pcacheA.snoop_type$next_rhs () utt$3) (declare-fun y$pcacheA.snoop_type$next_rhs_op () utt$3) (declare-fun y$pcacheA.state () utt$2) (declare-fun y$pcacheA.state$next () utt$2) (declare-fun y$pcacheA.update () Bool) (declare-fun y$pcacheA.update$next () Bool) (declare-fun y$pcacheA.update$next_rhs () Bool) (declare-fun y$pcacheA.update$next_rhs_op () Bool) (declare-fun y$pcacheA.write () Bool) (declare-fun y$pcacheA.write$next () Bool) (declare-fun y$pcacheA.write$next_rhs () Bool) (declare-fun y$pcacheA.write$next_rhs_op () Bool) (declare-fun y$pcacheB.bus_req () Bool) (declare-fun y$pcacheB.bus_req$next () Bool) (declare-fun y$pcacheB.bus_req$next_rhs () Bool) (declare-fun y$pcacheB.bus_req$next_rhs_op () Bool) (declare-fun y$pcacheB.hit () Bool) (declare-fun y$pcacheB.hit$next () Bool) (declare-fun y$pcacheB.hit$next_rhs () Bool) (declare-fun y$pcacheB.hit$next_rhs_op () Bool) (declare-fun y$pcacheB.inv_out () Bool) (declare-fun y$pcacheB.inv_out$next () Bool) (declare-fun y$pcacheB.inv_out$next_rhs () Bool) (declare-fun y$pcacheB.inv_out$next_rhs_op () Bool) (declare-fun y$pcacheB.miss () Bool) (declare-fun y$pcacheB.miss$next () Bool) (declare-fun y$pcacheB.miss$next_rhs () Bool) (declare-fun y$pcacheB.miss$next_rhs_op () Bool) (declare-fun y$pcacheB.next_state () utt$2) (declare-fun y$pcacheB.next_state$next () utt$2) (declare-fun y$pcacheB.next_state$next_rhs () utt$2) (declare-fun y$pcacheB.next_state$next_rhs_op () utt$2) (declare-fun y$pcacheB.proc.count () utt$3) (declare-fun y$pcacheB.proc.count$next () utt$3) (declare-fun y$pcacheB.proc.count$next_rhs () utt$3) (declare-fun y$pcacheB.proc.count$next_rhs_op () utt$3) (declare-fun y$pcacheB.proc.req_enable () Bool) (declare-fun y$pcacheB.proc.valid () Bool) (declare-fun y$pcacheB.proc.valid$next () Bool) (declare-fun y$pcacheB.proc.valid$next_rhs () Bool) (declare-fun y$pcacheB.proc.valid$next_rhs_op () Bool) (declare-fun y$pcacheB.read () Bool) (declare-fun y$pcacheB.read$next () Bool) (declare-fun y$pcacheB.read$next_rhs () Bool) (declare-fun y$pcacheB.read$next_rhs_op () Bool) (declare-fun y$pcacheB.snoop_type () utt$3) (declare-fun y$pcacheB.snoop_type$next () utt$3) (declare-fun y$pcacheB.snoop_type$next_rhs () utt$3) (declare-fun y$pcacheB.snoop_type$next_rhs_op () utt$3) (declare-fun y$pcacheB.state () utt$2) (declare-fun y$pcacheB.state$next () utt$2) (declare-fun y$pcacheB.update () Bool) (declare-fun y$pcacheB.update$next () Bool) (declare-fun y$pcacheB.update$next_rhs () Bool) (declare-fun y$pcacheB.update$next_rhs_op () Bool) (declare-fun y$pcacheB.write () Bool) (declare-fun y$pcacheB.write$next () Bool) (declare-fun y$pcacheB.write$next_rhs () Bool) (declare-fun y$pcacheB.write$next_rhs_op () Bool) (declare-fun y$pcacheC.bus_req () Bool) (declare-fun y$pcacheC.bus_req$next () Bool) (declare-fun y$pcacheC.bus_req$next_rhs () Bool) (declare-fun y$pcacheC.bus_req$next_rhs_op () Bool) (declare-fun y$pcacheC.hit () Bool) (declare-fun y$pcacheC.hit$next () Bool) (declare-fun y$pcacheC.hit$next_rhs () Bool) (declare-fun y$pcacheC.hit$next_rhs_op () Bool) (declare-fun y$pcacheC.inv_out () Bool) (declare-fun y$pcacheC.inv_out$next () Bool) (declare-fun y$pcacheC.inv_out$next_rhs () Bool) (declare-fun y$pcacheC.inv_out$next_rhs_op () Bool) (declare-fun y$pcacheC.miss () Bool) (declare-fun y$pcacheC.miss$next () Bool) (declare-fun y$pcacheC.miss$next_rhs () Bool) (declare-fun y$pcacheC.miss$next_rhs_op () Bool) (declare-fun y$pcacheC.next_state () utt$2) (declare-fun y$pcacheC.next_state$next () utt$2) (declare-fun y$pcacheC.next_state$next_rhs () utt$2) (declare-fun y$pcacheC.next_state$next_rhs_op () utt$2) (declare-fun y$pcacheC.proc.count () utt$3) (declare-fun y$pcacheC.proc.count$next () utt$3) (declare-fun y$pcacheC.proc.count$next_rhs () utt$3) (declare-fun y$pcacheC.proc.count$next_rhs_op () utt$3) (declare-fun y$pcacheC.proc.req_enable () Bool) (declare-fun y$pcacheC.proc.valid () Bool) (declare-fun y$pcacheC.proc.valid$next () Bool) (declare-fun y$pcacheC.proc.valid$next_rhs () Bool) (declare-fun y$pcacheC.proc.valid$next_rhs_op () Bool) (declare-fun y$pcacheC.read () Bool) (declare-fun y$pcacheC.read$next () Bool) (declare-fun y$pcacheC.read$next_rhs () Bool) (declare-fun y$pcacheC.read$next_rhs_op () Bool) (declare-fun y$pcacheC.snoop_type () utt$3) (declare-fun y$pcacheC.snoop_type$next () utt$3) (declare-fun y$pcacheC.snoop_type$next_rhs () utt$3) (declare-fun y$pcacheC.snoop_type$next_rhs_op () utt$3) (declare-fun y$pcacheC.state () utt$2) (declare-fun y$pcacheC.state$next () utt$2) (declare-fun y$pcacheC.update () Bool) (declare-fun y$pcacheC.update$next () Bool) (declare-fun y$pcacheC.update$next_rhs () Bool) (declare-fun y$pcacheC.update$next_rhs_op () Bool) (declare-fun y$pcacheC.write () Bool) (declare-fun y$pcacheC.write$next () Bool) (declare-fun y$pcacheC.write$next_rhs () Bool) (declare-fun y$pcacheC.write$next_rhs_op () Bool) (declare-fun y$prop () Bool) (declare-fun y$prop$next () Bool) (declare-fun y$prop0 () Bool) (declare-fun y$prop0$next () Bool) (declare-fun y$prop0$next_op () Bool) (declare-fun y$prop0_op () Bool) (declare-fun y$s$10 () Bool) (declare-fun y$s$101 () Bool) (declare-fun y$s$101_op () Bool) (declare-fun y$s$102 () Bool) (declare-fun y$s$102_op () Bool) (declare-fun y$s$103 () Bool) (declare-fun y$s$103_op () Bool) (declare-fun y$s$104 () Bool) (declare-fun y$s$104_op () Bool) (declare-fun y$s$105 () Bool) (declare-fun y$s$105_op () Bool) (declare-fun y$s$106 () Bool) (declare-fun y$s$106_op () Bool) (declare-fun y$s$107 () Bool) (declare-fun y$s$107_op () Bool) (declare-fun y$s$108 () Bool) (declare-fun y$s$108_op () Bool) (declare-fun y$s$109 () Bool) (declare-fun y$s$109_op () Bool) (declare-fun y$s$10_op () Bool) (declare-fun y$s$110 () Bool) (declare-fun y$s$110_op () Bool) (declare-fun y$s$111 () Bool) (declare-fun y$s$111_op () Bool) (declare-fun y$s$112 () Bool) (declare-fun y$s$112_op () Bool) (declare-fun y$s$113 () Bool) (declare-fun y$s$113_op () Bool) (declare-fun y$s$114 () Bool) (declare-fun y$s$114_op () Bool) (declare-fun y$s$115 () Bool) (declare-fun y$s$115_op () Bool) (declare-fun y$s$116 () Bool) (declare-fun y$s$116_op () Bool) (declare-fun y$s$117 () Bool) (declare-fun y$s$117_op () Bool) (declare-fun y$s$118 () Bool) (declare-fun y$s$118_op () Bool) (declare-fun y$s$119 () Bool) (declare-fun y$s$119_op () Bool) (declare-fun y$s$12 () Bool) (declare-fun y$s$12$next () Bool) (declare-fun y$s$12$next_op () Bool) (declare-fun y$s$120 () Bool) (declare-fun y$s$120_op () Bool) (declare-fun y$s$121 () Bool) (declare-fun y$s$121_op () Bool) (declare-fun y$s$12_op () Bool) (declare-fun y$s$145 () Bool) (declare-fun y$s$145_op () Bool) (declare-fun y$s$146 () Bool) (declare-fun y$s$146_op () Bool) (declare-fun y$s$147 () Bool) (declare-fun y$s$147_op () Bool) (declare-fun y$s$150 () Bool) (declare-fun y$s$150_op () Bool) (declare-fun y$s$153 () Bool) (declare-fun y$s$153_op () Bool) (declare-fun y$s$154 () Bool) (declare-fun y$s$154_op () Bool) (declare-fun y$s$155 () Bool) (declare-fun y$s$155_op () Bool) (declare-fun y$s$156 () Bool) (declare-fun y$s$156_op () Bool) (declare-fun y$s$157 () utt$3) (declare-fun y$s$157_op () utt$3) (declare-fun y$s$158 () utt$3) (declare-fun y$s$158_op () utt$3) (declare-fun y$s$159 () utt$3) (declare-fun y$s$159_op () utt$3) (declare-fun y$s$160 () utt$3) (declare-fun y$s$160_op () utt$3) (declare-fun y$s$161 () Bool) (declare-fun y$s$161_op () Bool) (declare-fun y$s$162 () Bool) (declare-fun y$s$162_op () Bool) (declare-fun y$s$163 () Bool) (declare-fun y$s$163_op () Bool) (declare-fun y$s$164 () Bool) (declare-fun y$s$164_op () Bool) (declare-fun y$s$165 () utt$2) (declare-fun y$s$165_op () utt$2) (declare-fun y$s$166 () utt$2) (declare-fun y$s$166_op () utt$2) (declare-fun y$s$174 () utt$2) (declare-fun y$s$174_op () utt$2) (declare-fun y$s$175 () utt$2) (declare-fun y$s$175_op () utt$2) (declare-fun y$s$181 () utt$2) (declare-fun y$s$181_op () utt$2) (declare-fun y$s$183 () utt$2) (declare-fun y$s$183_op () utt$2) (declare-fun y$s$185 () utt$2) (declare-fun y$s$185_op () utt$2) (declare-fun y$s$186 () utt$2) (declare-fun y$s$186_op () utt$2) (declare-fun y$s$191 () utt$2) (declare-fun y$s$191_op () utt$2) (declare-fun y$s$193 () utt$2) (declare-fun y$s$193_op () utt$2) (declare-fun y$s$195 () utt$2) (declare-fun y$s$195_op () utt$2) (declare-fun y$s$197 () utt$2) (declare-fun y$s$197_op () utt$2) (declare-fun y$s$198 () utt$2) (declare-fun y$s$198_op () utt$2) (declare-fun y$s$20 () Bool) (declare-fun y$s$201 () utt$2) (declare-fun y$s$201_op () utt$2) (declare-fun y$s$203 () Bool) (declare-fun y$s$203_op () Bool) (declare-fun y$s$20_op () Bool) (declare-fun y$s$21 () utt$3) (declare-fun y$s$210 () Bool) (declare-fun y$s$210_op () Bool) (declare-fun y$s$214 () Bool) (declare-fun y$s$214_op () Bool) (declare-fun y$s$216 () Bool) (declare-fun y$s$216_op () Bool) (declare-fun y$s$218 () Bool) (declare-fun y$s$218_op () Bool) (declare-fun y$s$219 () Bool) (declare-fun y$s$219_op () Bool) (declare-fun y$s$21_op () utt$3) (declare-fun y$s$22 () utt$3) (declare-fun y$s$22_op () utt$3) (declare-fun y$s$23 () Bool) (declare-fun y$s$231 () Bool) (declare-fun y$s$231_op () Bool) (declare-fun y$s$232 () Bool) (declare-fun y$s$232_op () Bool) (declare-fun y$s$233 () utt$32) (declare-fun y$s$233_op () utt$32) (declare-fun y$s$234 () utt$32) (declare-fun y$s$234_op () utt$32) (declare-fun y$s$235 () utt$32) (declare-fun y$s$235_op () utt$32) (declare-fun y$s$238 () utt$32) (declare-fun y$s$238_op () utt$32) (declare-fun y$s$23_op () Bool) (declare-fun y$s$24 () Bool) (declare-fun y$s$240 () utt$32) (declare-fun y$s$240_op () utt$32) (declare-fun y$s$245 () utt$3) (declare-fun y$s$245_op () utt$3) (declare-fun y$s$246 () Bool) (declare-fun y$s$246_op () Bool) (declare-fun y$s$247 () utt$32) (declare-fun y$s$247_op () utt$32) (declare-fun y$s$24_op () Bool) (declare-fun y$s$25 () Bool) (declare-fun y$s$257 () utt$3) (declare-fun y$s$257_op () utt$3) (declare-fun y$s$25_op () Bool) (declare-fun y$s$26 () Bool) (declare-fun y$s$262 () utt$2) (declare-fun y$s$262_op () utt$2) (declare-fun y$s$263 () utt$2) (declare-fun y$s$263_op () utt$2) (declare-fun y$s$264 () utt$2) (declare-fun y$s$264_op () utt$2) (declare-fun y$s$265 () utt$2) (declare-fun y$s$265_op () utt$2) (declare-fun y$s$266 () utt$2) (declare-fun y$s$266_op () utt$2) (declare-fun y$s$267 () utt$2) (declare-fun y$s$267_op () utt$2) (declare-fun y$s$268 () utt$2) (declare-fun y$s$268_op () utt$2) (declare-fun y$s$269 () utt$2) (declare-fun y$s$269_op () utt$2) (declare-fun y$s$26_op () Bool) (declare-fun y$s$27 () Bool) (declare-fun y$s$270 () utt$2) (declare-fun y$s$270_op () utt$2) (declare-fun y$s$271 () utt$2) (declare-fun y$s$271_op () utt$2) (declare-fun y$s$272 () Bool) (declare-fun y$s$272_op () Bool) (declare-fun y$s$273 () Bool) (declare-fun y$s$273_op () Bool) (declare-fun y$s$274 () Bool) (declare-fun y$s$274_op () Bool) (declare-fun y$s$275 () Bool) (declare-fun y$s$275_op () Bool) (declare-fun y$s$276 () Bool) (declare-fun y$s$276_op () Bool) (declare-fun y$s$27_op () Bool) (declare-fun y$s$3 () Bool) (declare-fun y$s$321 () Bool) (declare-fun y$s$321_op () Bool) (declare-fun y$s$322 () Bool) (declare-fun y$s$322_op () Bool) (declare-fun y$s$323 () Bool) (declare-fun y$s$323_op () Bool) (declare-fun y$s$324 () Bool) (declare-fun y$s$324_op () Bool) (declare-fun y$s$325 () Bool) (declare-fun y$s$325_op () Bool) (declare-fun y$s$326 () Bool) (declare-fun y$s$326_op () Bool) (declare-fun y$s$327 () Bool) (declare-fun y$s$327_op () Bool) (declare-fun y$s$328 () Bool) (declare-fun y$s$328_op () Bool) (declare-fun y$s$329 () Bool) (declare-fun y$s$329_op () Bool) (declare-fun y$s$330 () Bool) (declare-fun y$s$330_op () Bool) (declare-fun y$s$331 () Bool) (declare-fun y$s$331_op () Bool) (declare-fun y$s$332 () Bool) (declare-fun y$s$332_op () Bool) (declare-fun y$s$333 () Bool) (declare-fun y$s$333_op () Bool) (declare-fun y$s$334 () Bool) (declare-fun y$s$334_op () Bool) (declare-fun y$s$335 () Bool) (declare-fun y$s$335_op () Bool) (declare-fun y$s$336 () Bool) (declare-fun y$s$336_op () Bool) (declare-fun y$s$337 () Bool) (declare-fun y$s$337_op () Bool) (declare-fun y$s$338 () Bool) (declare-fun y$s$338_op () Bool) (declare-fun y$s$339 () Bool) (declare-fun y$s$339_op () Bool) (declare-fun y$s$340 () Bool) (declare-fun y$s$340_op () Bool) (declare-fun y$s$341 () Bool) (declare-fun y$s$341_op () Bool) (declare-fun y$s$362 () Bool) (declare-fun y$s$362_op () Bool) (declare-fun y$s$363 () Bool) (declare-fun y$s$363_op () Bool) (declare-fun y$s$364 () Bool) (declare-fun y$s$364_op () Bool) (declare-fun y$s$365 () Bool) (declare-fun y$s$365_op () Bool) (declare-fun y$s$366 () Bool) (declare-fun y$s$366_op () Bool) (declare-fun y$s$367 () Bool) (declare-fun y$s$367_op () Bool) (declare-fun y$s$37 () utt$3) (declare-fun y$s$370 () Bool) (declare-fun y$s$370_op () Bool) (declare-fun y$s$373 () Bool) (declare-fun y$s$373_op () Bool) (declare-fun y$s$374 () Bool) (declare-fun y$s$374_op () Bool) (declare-fun y$s$375 () Bool) (declare-fun y$s$375_op () Bool) (declare-fun y$s$376 () Bool) (declare-fun y$s$376_op () Bool) (declare-fun y$s$377 () utt$3) (declare-fun y$s$377_op () utt$3) (declare-fun y$s$378 () utt$3) (declare-fun y$s$378_op () utt$3) (declare-fun y$s$379 () utt$3) (declare-fun y$s$379_op () utt$3) (declare-fun y$s$37_op () utt$3) (declare-fun y$s$380 () utt$3) (declare-fun y$s$380_op () utt$3) (declare-fun y$s$381 () Bool) (declare-fun y$s$381_op () Bool) (declare-fun y$s$382 () Bool) (declare-fun y$s$382_op () Bool) (declare-fun y$s$383 () Bool) (declare-fun y$s$383_op () Bool) (declare-fun y$s$384 () Bool) (declare-fun y$s$384_op () Bool) (declare-fun y$s$385 () utt$2) (declare-fun y$s$385_op () utt$2) (declare-fun y$s$386 () utt$2) (declare-fun y$s$386_op () utt$2) (declare-fun y$s$394 () utt$2) (declare-fun y$s$394_op () utt$2) (declare-fun y$s$395 () utt$2) (declare-fun y$s$395_op () utt$2) (declare-fun y$s$3_op () Bool) (declare-fun y$s$401 () utt$2) (declare-fun y$s$401_op () utt$2) (declare-fun y$s$403 () utt$2) (declare-fun y$s$403_op () utt$2) (declare-fun y$s$405 () utt$2) (declare-fun y$s$405_op () utt$2) (declare-fun y$s$406 () utt$2) (declare-fun y$s$406_op () utt$2) (declare-fun y$s$411 () utt$2) (declare-fun y$s$411_op () utt$2) (declare-fun y$s$413 () utt$2) (declare-fun y$s$413_op () utt$2) (declare-fun y$s$415 () utt$2) (declare-fun y$s$415_op () utt$2) (declare-fun y$s$417 () utt$2) (declare-fun y$s$417_op () utt$2) (declare-fun y$s$418 () utt$2) (declare-fun y$s$418_op () utt$2) (declare-fun y$s$42 () utt$2) (declare-fun y$s$421 () utt$2) (declare-fun y$s$421_op () utt$2) (declare-fun y$s$423 () Bool) (declare-fun y$s$423_op () Bool) (declare-fun y$s$42_op () utt$2) (declare-fun y$s$43 () utt$2) (declare-fun y$s$430 () Bool) (declare-fun y$s$430_op () Bool) (declare-fun y$s$434 () Bool) (declare-fun y$s$434_op () Bool) (declare-fun y$s$436 () Bool) (declare-fun y$s$436_op () Bool) (declare-fun y$s$438 () Bool) (declare-fun y$s$438_op () Bool) (declare-fun y$s$439 () Bool) (declare-fun y$s$439_op () Bool) (declare-fun y$s$43_op () utt$2) (declare-fun y$s$44 () utt$2) (declare-fun y$s$44_op () utt$2) (declare-fun y$s$45 () utt$2) (declare-fun y$s$451 () Bool) (declare-fun y$s$451_op () Bool) (declare-fun y$s$452 () Bool) (declare-fun y$s$452_op () Bool) (declare-fun y$s$453 () utt$32) (declare-fun y$s$453_op () utt$32) (declare-fun y$s$454 () utt$32) (declare-fun y$s$454_op () utt$32) (declare-fun y$s$455 () utt$32) (declare-fun y$s$455_op () utt$32) (declare-fun y$s$458 () utt$32) (declare-fun y$s$458_op () utt$32) (declare-fun y$s$45_op () utt$2) (declare-fun y$s$46 () utt$2) (declare-fun y$s$460 () utt$32) (declare-fun y$s$460_op () utt$32) (declare-fun y$s$465 () utt$3) (declare-fun y$s$465_op () utt$3) (declare-fun y$s$466 () Bool) (declare-fun y$s$466_op () Bool) (declare-fun y$s$467 () utt$32) (declare-fun y$s$467_op () utt$32) (declare-fun y$s$46_op () utt$2) (declare-fun y$s$47 () utt$2) (declare-fun y$s$477 () utt$3) (declare-fun y$s$477_op () utt$3) (declare-fun y$s$478 () Bool) (declare-fun y$s$478_op () Bool) (declare-fun y$s$47_op () utt$2) (declare-fun y$s$48 () utt$2) (declare-fun y$s$482 () utt$2) (declare-fun y$s$482_op () utt$2) (declare-fun y$s$483 () utt$2) (declare-fun y$s$483_op () utt$2) (declare-fun y$s$484 () utt$2) (declare-fun y$s$484_op () utt$2) (declare-fun y$s$485 () utt$2) (declare-fun y$s$485_op () utt$2) (declare-fun y$s$486 () utt$2) (declare-fun y$s$486_op () utt$2) (declare-fun y$s$487 () utt$2) (declare-fun y$s$487_op () utt$2) (declare-fun y$s$488 () utt$2) (declare-fun y$s$488_op () utt$2) (declare-fun y$s$489 () utt$2) (declare-fun y$s$489_op () utt$2) (declare-fun y$s$48_op () utt$2) (declare-fun y$s$49 () utt$2) (declare-fun y$s$490 () utt$2) (declare-fun y$s$490_op () utt$2) (declare-fun y$s$491 () utt$2) (declare-fun y$s$491_op () utt$2) (declare-fun y$s$492 () Bool) (declare-fun y$s$492_op () Bool) (declare-fun y$s$493 () Bool) (declare-fun y$s$493_op () Bool) (declare-fun y$s$494 () Bool) (declare-fun y$s$494_op () Bool) (declare-fun y$s$495 () Bool) (declare-fun y$s$495_op () Bool) (declare-fun y$s$496 () Bool) (declare-fun y$s$496_op () Bool) (declare-fun y$s$497 () Bool) (declare-fun y$s$497_op () Bool) (declare-fun y$s$498 () Bool) (declare-fun y$s$498_op () Bool) (declare-fun y$s$499 () Bool) (declare-fun y$s$499_op () Bool) (declare-fun y$s$49_op () utt$2) (declare-fun y$s$50 () utt$2) (declare-fun y$s$500 () Bool) (declare-fun y$s$500_op () Bool) (declare-fun y$s$501 () Bool) (declare-fun y$s$501_op () Bool) (declare-fun y$s$50_op () utt$2) (declare-fun y$s$51 () utt$2) (declare-fun y$s$51_op () utt$2) (declare-fun y$s$52 () Bool) (declare-fun y$s$52_op () Bool) (declare-fun y$s$53 () Bool) (declare-fun y$s$533 () Bool) (declare-fun y$s$533_op () Bool) (declare-fun y$s$534 () Bool) (declare-fun y$s$534_op () Bool) (declare-fun y$s$535 () Bool) (declare-fun y$s$535_op () Bool) (declare-fun y$s$536 () Bool) (declare-fun y$s$536_op () Bool) (declare-fun y$s$537 () Bool) (declare-fun y$s$537_op () Bool) (declare-fun y$s$538 () Bool) (declare-fun y$s$538_op () Bool) (declare-fun y$s$539 () Bool) (declare-fun y$s$539_op () Bool) (declare-fun y$s$53_op () Bool) (declare-fun y$s$54 () Bool) (declare-fun y$s$540 () Bool) (declare-fun y$s$540_op () Bool) (declare-fun y$s$541 () Bool) (declare-fun y$s$541_op () Bool) (declare-fun y$s$542 () Bool) (declare-fun y$s$542_op () Bool) (declare-fun y$s$543 () Bool) (declare-fun y$s$543_op () Bool) (declare-fun y$s$544 () Bool) (declare-fun y$s$544_op () Bool) (declare-fun y$s$545 () Bool) (declare-fun y$s$545_op () Bool) (declare-fun y$s$546 () Bool) (declare-fun y$s$546_op () Bool) (declare-fun y$s$547 () Bool) (declare-fun y$s$547_op () Bool) (declare-fun y$s$548 () Bool) (declare-fun y$s$548_op () Bool) (declare-fun y$s$549 () Bool) (declare-fun y$s$549_op () Bool) (declare-fun y$s$54_op () Bool) (declare-fun y$s$55 () Bool) (declare-fun y$s$550 () Bool) (declare-fun y$s$550_op () Bool) (declare-fun y$s$551 () Bool) (declare-fun y$s$551_op () Bool) (declare-fun y$s$55_op () Bool) (declare-fun y$s$56 () Bool) (declare-fun y$s$56_op () Bool) (declare-fun y$s$572 () Bool) (declare-fun y$s$572_op () Bool) (declare-fun y$s$573 () Bool) (declare-fun y$s$573_op () Bool) (declare-fun y$s$574 () Bool) (declare-fun y$s$574_op () Bool) (declare-fun y$s$575 () Bool) (declare-fun y$s$575_op () Bool) (declare-fun y$s$578 () Bool) (declare-fun y$s$578_op () Bool) (declare-fun y$s$579 () Bool) (declare-fun y$s$579_op () Bool) (declare-fun y$s$580 () Bool) (declare-fun y$s$580_op () Bool) (declare-fun y$s$581 () Bool) (declare-fun y$s$581_op () Bool) (declare-fun y$s$582 () utt$3) (declare-fun y$s$582_op () utt$3) (declare-fun y$s$583 () utt$3) (declare-fun y$s$583_op () utt$3) (declare-fun y$s$584 () utt$3) (declare-fun y$s$584_op () utt$3) (declare-fun y$s$585 () utt$3) (declare-fun y$s$585_op () utt$3) (declare-fun y$s$586 () Bool) (declare-fun y$s$586_op () Bool) (declare-fun y$s$587 () Bool) (declare-fun y$s$587_op () Bool) (declare-fun y$s$588 () Bool) (declare-fun y$s$588_op () Bool) (declare-fun y$s$589 () Bool) (declare-fun y$s$589_op () Bool) (declare-fun y$s$590 () utt$2) (declare-fun y$s$590_op () utt$2) (declare-fun y$s$591 () utt$2) (declare-fun y$s$591_op () utt$2) (declare-fun y$s$599 () utt$2) (declare-fun y$s$599_op () utt$2) (declare-fun y$s$600 () utt$2) (declare-fun y$s$600_op () utt$2) (declare-fun y$s$605 () utt$2) (declare-fun y$s$605_op () utt$2) (declare-fun y$s$606 () utt$2) (declare-fun y$s$606_op () utt$2) (declare-fun y$s$608 () utt$2) (declare-fun y$s$608_op () utt$2) (declare-fun y$s$610 () utt$2) (declare-fun y$s$610_op () utt$2) (declare-fun y$s$611 () utt$2) (declare-fun y$s$611_op () utt$2) (declare-fun y$s$616 () utt$2) (declare-fun y$s$616_op () utt$2) (declare-fun y$s$618 () utt$2) (declare-fun y$s$618_op () utt$2) (declare-fun y$s$619 () utt$2) (declare-fun y$s$619_op () utt$2) (declare-fun y$s$620 () utt$2) (declare-fun y$s$620_op () utt$2) (declare-fun y$s$622 () utt$2) (declare-fun y$s$622_op () utt$2) (declare-fun y$s$623 () utt$2) (declare-fun y$s$623_op () utt$2) (declare-fun y$s$626 () utt$2) (declare-fun y$s$626_op () utt$2) (declare-fun y$s$627 () Bool) (declare-fun y$s$627_op () Bool) (declare-fun y$s$628 () Bool) (declare-fun y$s$628_op () Bool) (declare-fun y$s$635 () Bool) (declare-fun y$s$635_op () Bool) (declare-fun y$s$639 () Bool) (declare-fun y$s$639_op () Bool) (declare-fun y$s$641 () Bool) (declare-fun y$s$641_op () Bool) (declare-fun y$s$643 () Bool) (declare-fun y$s$643_op () Bool) (declare-fun y$s$644 () Bool) (declare-fun y$s$644_op () Bool) (declare-fun y$s$647 () Bool) (declare-fun y$s$647_op () Bool) (declare-fun y$s$649 () Bool) (declare-fun y$s$649_op () Bool) (declare-fun y$s$650 () Bool) (declare-fun y$s$650_op () Bool) (declare-fun y$s$652 () Bool) (declare-fun y$s$652_op () Bool) (declare-fun y$s$653 () Bool) (declare-fun y$s$653_op () Bool) (declare-fun y$s$656 () Bool) (declare-fun y$s$656_op () Bool) (declare-fun y$s$657 () Bool) (declare-fun y$s$657_op () Bool) (declare-fun y$s$658 () utt$32) (declare-fun y$s$658_op () utt$32) (declare-fun y$s$659 () utt$32) (declare-fun y$s$659_op () utt$32) (declare-fun y$s$660 () utt$32) (declare-fun y$s$660_op () utt$32) (declare-fun y$s$663 () utt$32) (declare-fun y$s$663_op () utt$32) (declare-fun y$s$668 () utt$3) (declare-fun y$s$668_op () utt$3) (declare-fun y$s$669 () Bool) (declare-fun y$s$669_op () Bool) (declare-fun y$s$670 () utt$32) (declare-fun y$s$670_op () utt$32) (declare-fun y$s$671 () Bool) (declare-fun y$s$671_op () Bool) (declare-fun y$s$9 () Bool) (declare-fun y$s$9_op () Bool) (declare-fun y$w$1 () utt$32) (declare-fun y$w$1$next () utt$32) (declare-fun y$w$1$next_op () utt$32) (declare-fun y$w$10 () utt$32) (declare-fun y$w$10_op () utt$32) (declare-fun y$w$11 () utt$32) (declare-fun y$w$11_op () utt$32) (declare-fun y$w$12 () utt$32) (declare-fun y$w$12_op () utt$32) (declare-fun y$w$13 () utt$32) (declare-fun y$w$13_op () utt$32) (declare-fun y$w$14 () utt$32) (declare-fun y$w$14_op () utt$32) (declare-fun y$w$15 () utt$32) (declare-fun y$w$15_op () utt$32) (declare-fun y$w$16 () utt$3) (declare-fun y$w$17 () utt$32) (declare-fun y$w$17_op () utt$32) (declare-fun y$w$18 () utt$3) (declare-fun y$w$19 () utt$32) (declare-fun y$w$19_op () utt$32) (declare-fun y$w$1_op () utt$32) (declare-fun y$w$2 () utt$32) (declare-fun y$w$2$next () utt$32) (declare-fun y$w$2$next_op () utt$32) (declare-fun y$w$20 () utt$3) (declare-fun y$w$21 () utt$32) (declare-fun y$w$21_op () utt$32) (declare-fun y$w$22 () utt$32) (declare-fun y$w$22_op () utt$32) (declare-fun y$w$23 () utt$32) (declare-fun y$w$23_op () utt$32) (declare-fun y$w$24 () utt$32) (declare-fun y$w$24_op () utt$32) (declare-fun y$w$25 () utt$32) (declare-fun y$w$25_op () utt$32) (declare-fun y$w$26 () utt$32) (declare-fun y$w$26_op () utt$32) (declare-fun y$w$27 () utt$32) (declare-fun y$w$27_op () utt$32) (declare-fun y$w$28 () utt$32) (declare-fun y$w$28_op () utt$32) (declare-fun y$w$29 () utt$32) (declare-fun y$w$29_op () utt$32) (declare-fun y$w$2_op () utt$32) (declare-fun y$w$3 () utt$32) (declare-fun y$w$3$next () utt$32) (declare-fun y$w$3$next_op () utt$32) (declare-fun y$w$30 () utt$32) (declare-fun y$w$30_op () utt$32) (declare-fun y$w$31 () utt$32) (declare-fun y$w$31_op () utt$32) (declare-fun y$w$32 () utt$32) (declare-fun y$w$32_op () utt$32) (declare-fun y$w$33 () utt$32) (declare-fun y$w$33_op () utt$32) (declare-fun y$w$34 () utt$32) (declare-fun y$w$34_op () utt$32) (declare-fun y$w$35 () utt$32) (declare-fun y$w$35_op () utt$32) (declare-fun y$w$3_op () utt$32) (declare-fun y$w$4 () utt$32) (declare-fun y$w$4$next () utt$32) (declare-fun y$w$4$next_op () utt$32) (declare-fun y$w$4_op () utt$32) (declare-fun y$w$5 () utt$32) (declare-fun y$w$5$next () utt$32) (declare-fun y$w$5$next_op () utt$32) (declare-fun y$w$5_op () utt$32) (declare-fun y$w$6 () utt$32) (declare-fun y$w$6$next () utt$32) (declare-fun y$w$6$next_op () utt$32) (declare-fun y$w$6_op () utt$32) (declare-fun y$w$7 () utt$32) (declare-fun y$w$7_op () utt$32) (declare-fun y$w$8 () utt$32) (declare-fun y$w$8_op () utt$32) (declare-fun y$w$9 () utt$32) (declare-fun y$w$9_op () utt$32) (assert (distinct y$n0s2 y$n2s2 y$n1s2)) (assert (distinct y$n0s3 y$n5s3 y$n2s3 y$n1s3 y$n3s3 y$n4s3)) (assert (not (= y$n1s32 y$n0s32))) (assert (= y$125 (= y$n1s2 y$pcacheA.state))) (assert (= y$w$1_op (ite y$125 y$n1s32 y$n0s32))) (assert (= y$125 y$s$216_op)) (assert (= y$374 (Extract_1_0_0_32 y$w$1_op))) (assert (= y$s$216_op y$374)) (assert (= y$w$2_op (Concat_32_1_31 y$374 y$n0s31))) (assert (= y$984 (not (= y$n1s32 y$w$2_op)))) (assert (= y$376 (= y$n1s2 y$pcacheB.state))) (assert (= y$w$3_op (ite y$376 y$n1s32 y$n0s32))) (assert (= y$376 y$s$436_op)) (assert (= y$379 (Extract_1_0_0_32 y$w$3_op))) (assert (= y$s$436_op y$379)) (assert (= y$w$4_op (Concat_32_1_31 y$379 y$n0s31))) (assert (= y$987 (= y$n1s32 y$w$4_op))) (assert (= y$s$12_op (or y$984 y$987))) (assert (= y$384 (= y$n1s2 y$pcacheC.state))) (assert (= y$w$5_op (ite y$384 y$n1s32 y$n0s32))) (assert (= y$384 y$s$641_op)) (assert (= y$387 (Extract_1_0_0_32 y$w$5_op))) (assert (= y$s$641_op y$387)) (assert (= y$w$6_op (Concat_32_1_31 y$387 y$n0s31))) (assert (= y$992 (= y$n1s32 y$w$6_op))) (assert (= y$prop0_op (or y$s$12_op y$992))) (assert (= y$995 (= y$prop y$prop0_op))) (assert (= y$s$26_op (and y$pcacheC.bus_req y$pcacheC.inv_out))) (assert (= y$s$27_op (ite y$pcacheB.bus_req y$pcacheB.inv_out y$s$26_op))) (assert (= y$bus_arbiter.invalidate$next_rhs_op (ite y$pcacheA.bus_req y$pcacheA.inv_out y$s$27_op))) (assert (= y$89 (= y$bus_arbiter.invalidate$next y$bus_arbiter.invalidate$next_rhs_op))) (assert (= y$pcacheA.bus_req y$bus_arbiter.bus_ackA$next_rhs_op)) (assert (= y$94 (= y$bus_arbiter.bus_ackA$next y$bus_arbiter.bus_ackA$next_rhs_op))) (assert (= y$pcacheB.bus_req y$s$25_op)) (assert (= y$bus_arbiter.bus_ackB$next_rhs_op (and (not y$pcacheA.bus_req) y$s$25_op))) (assert (= y$100 (= y$bus_arbiter.bus_ackB$next y$bus_arbiter.bus_ackB$next_rhs_op))) (assert (= y$pcacheC.bus_req y$s$23_op)) (assert (= y$s$24_op (and (not y$pcacheB.bus_req) y$s$23_op))) (assert (= y$bus_arbiter.bus_ackC$next_rhs_op (and (not y$pcacheA.bus_req) y$s$24_op))) (assert (= y$108 (= y$bus_arbiter.bus_ackC$next y$bus_arbiter.bus_ackC$next_rhs_op))) (assert (= y$s$21_op (ite y$pcacheC.bus_req y$pcacheC.snoop_type y$n0s3))) (assert (= y$s$22_op (ite y$pcacheB.bus_req y$pcacheB.snoop_type y$s$21_op))) (assert (= y$bus_arbiter.shared_snoop$next_rhs_op (ite y$pcacheA.bus_req y$pcacheA.snoop_type y$s$22_op))) (assert (= y$116 (= y$bus_arbiter.shared_snoop$next y$bus_arbiter.shared_snoop$next_rhs_op))) (assert (= y$s$20_op (or y$pcacheB.bus_req y$s$23_op))) (assert (= y$bus_arbiter.is_snoop$next_rhs_op (or y$pcacheA.bus_req y$s$20_op))) (assert (= y$122 (= y$bus_arbiter.is_snoop$next y$bus_arbiter.is_snoop$next_rhs_op))) (assert (= y$s$110_op (and y$pcacheA.hit y$125))) (assert (= y$s$111_op (and y$pcacheA.write y$s$110_op))) (assert (= y$s$112_op (and y$pcacheA.miss y$125))) (assert (= y$s$154_op (or y$pcacheA.read y$pcacheA.write))) (assert (= y$s$113_op (and y$s$112_op y$s$154_op))) (assert (= y$33 (= y$n2s2 y$pcacheA.state))) (assert (= y$w$21_op (Concat_32_1_31 y$pcacheA.hit y$n0s31))) (assert (= y$141 (= y$n1s32 y$w$21_op))) (assert (= y$s$114_op (and y$33 y$141))) (assert (= y$w$22_op (Concat_32_1_31 y$pcacheA.read y$n0s31))) (assert (= y$146 (= y$n1s32 y$w$22_op))) (assert (= y$w$23_op (Concat_32_1_31 y$pcacheA.write y$n0s31))) (assert (= y$149 (= y$n1s32 y$w$23_op))) (assert (= y$s$153_op (or y$146 y$149))) (assert (= y$s$115_op (and y$s$114_op y$s$153_op))) (assert (= y$w$24_op (Concat_32_1_31 y$pcacheA.miss y$n0s31))) (assert (= y$157 (= y$n1s32 y$w$24_op))) (assert (= y$s$116_op (and y$33 y$157))) (assert (= y$s$117_op (and y$s$153_op y$s$116_op))) (assert (= y$163 (= y$n0s2 y$pcacheA.state))) (assert (= y$s$118_op (and y$pcacheA.miss y$163))) (assert (= y$s$119_op (and y$s$154_op y$s$118_op))) (assert (= y$s$157_op (ite y$s$119_op y$n5s3 y$n0s3))) (assert (= y$s$158_op (ite y$s$117_op y$n4s3 y$s$157_op))) (assert (= y$s$159_op (ite y$s$115_op y$n3s3 y$s$158_op))) (assert (= y$s$160_op (ite y$s$113_op y$n2s3 y$s$159_op))) (assert (= y$s$37_op (ite y$s$111_op y$n0s3 y$s$160_op))) (assert (= y$pcacheA.snoop_type$next_rhs_op (ite y$s$111_op y$n1s3 y$s$37_op))) (assert (= y$180 (= y$pcacheA.snoop_type$next y$pcacheA.snoop_type$next_rhs_op))) (assert (= y$pcacheA.bus_req$next_rhs_op (and y$pcacheA.bus_req (not y$pcacheA.update)))) (assert (= y$184 (= y$pcacheA.bus_req$next y$pcacheA.bus_req$next_rhs_op))) (assert (= y$pcacheA.proc.valid (not y$186))) (assert (= y$s$156_op (or y$pcacheA.update y$186))) (assert (= y$pcacheA.bus_req (not y$14))) (assert (= y$s$232_op (ite y$14 y$pcacheA.write y$pcacheA.inv_out))) (assert (= y$pcacheA.inv_out$next_rhs_op (and (not y$s$156_op) y$s$232_op))) (assert (= y$193 (= y$pcacheA.inv_out$next y$pcacheA.inv_out$next_rhs_op))) (assert (= y$195 (= y$pcacheA.next_state y$pcacheA.state$next))) (assert (= y$bus_arbiter.is_snoop (not y$9))) (assert (= y$s$155_op (or y$bus_arbiter.bus_ackA y$9))) (assert (= y$bus_arbiter.bus_ackA (not y$1))) (assert (= y$199 (= y$n3s3 y$bus_arbiter.shared_snoop))) (assert (= y$200 (= y$n4s3 y$bus_arbiter.shared_snoop))) (assert (= y$201 (= y$n5s3 y$bus_arbiter.shared_snoop))) (assert (= y$s$478_op (or y$199 y$200 y$201))) (assert (= y$bus_arbiter.invalidate (not y$7))) (assert (= y$7 y$s$647_op)) (assert (= y$bus_arbiter.invalidate y$s$649_op)) (assert (= y$s$650_op (or y$7 y$s$649_op))) (assert (= y$s$497_op (ite y$200 y$s$647_op y$s$650_op))) (assert (= y$s$498_op (ite y$201 y$s$647_op y$s$497_op))) (assert (= y$214 (= y$n2s3 y$bus_arbiter.shared_snoop))) (assert (= y$215 (= y$n1s3 y$bus_arbiter.shared_snoop))) (assert (= y$216 (= y$n1s2 y$pcacheA.next_state))) (assert (= y$s$147_op (or y$215 y$216))) (assert (= y$22 (= y$n0s2 y$pcacheA.next_state))) (assert (= y$12 (= y$n0s3 y$bus_arbiter.shared_snoop))) (assert (= y$s$573_op (or y$12 y$215))) (assert (= y$s$573_op (not y$221))) (assert (= y$s$108_op (and y$22 y$221))) (assert (= y$s$574_op (or y$200 y$201))) (assert (= y$s$109_op (and y$216 y$s$574_op))) (assert (= y$s$150_op (or y$s$108_op y$s$109_op))) (assert (= y$w$7_op (Concat_32_1_31 y$1 y$n0s31))) (assert (= y$s$240_op (ite y$s$150_op y$w$7_op y$n0s32))) (assert (= y$w$8_op (ite y$s$147_op y$n1s32 y$s$240_op))) (assert (= y$242 (and y$1 y$s$150_op))) (assert (= y$243 (or y$s$147_op y$242))) (assert (= y$237 (Extract_1_0_0_32 y$w$8_op))) (assert (= y$243 y$237)) (assert (= y$245 (= y$n1s2 y$pcacheB.next_state))) (assert (= y$s$367_op (or y$215 y$245))) (assert (= y$46 (= y$n0s2 y$pcacheB.next_state))) (assert (= y$s$328_op (and y$46 y$221))) (assert (= y$s$329_op (and y$s$574_op y$245))) (assert (= y$s$370_op (or y$s$328_op y$s$329_op))) (assert (= y$254 (= y$n2s2 y$pcacheA.next_state))) (assert (= y$s$363_op (or y$200 y$214))) (assert (= y$s$364_op (or y$201 y$s$363_op))) (assert (= y$s$106_op (and y$215 y$216))) (assert (= y$s$145_op (or y$s$364_op y$s$106_op))) (assert (= y$s$107_op (and y$22 y$199))) (assert (= y$s$146_op (or y$s$145_op y$s$107_op))) (assert (= y$s$238_op (ite y$s$146_op y$n1s32 y$n0s32))) (assert (= y$w$9_op (ite y$254 y$n0s32 y$s$238_op))) (assert (= y$s$146_op y$273)) (assert (= y$274 (and (not y$254) y$273))) (assert (= y$271 (Extract_1_0_0_32 y$w$9_op))) (assert (= y$274 y$271)) (assert (= y$bus_arbiter.bus_ackB (not y$3))) (assert (= y$ND_inB_op (ite y$271 y$1 y$3))) (assert (= y$w$10_op (Concat_32_1_31 y$ND_inB_op y$n0s31))) (assert (= y$s$460_op (ite y$s$370_op y$w$10_op y$n0s32))) (assert (= y$w$11_op (ite y$s$367_op y$n1s32 y$s$460_op))) (assert (= y$287 (and y$s$370_op y$ND_inB_op))) (assert (= y$288 (or y$s$367_op y$287))) (assert (= y$284 (Extract_1_0_0_32 y$w$11_op))) (assert (= y$288 y$284)) (assert (= y$s$9_op (or y$237 y$284))) (assert (= y$292 (= y$n1s2 y$pcacheC.next_state))) (assert (= y$s$572_op (or y$215 y$292))) (assert (= y$67 (= y$n0s2 y$pcacheC.next_state))) (assert (= y$s$538_op (and y$67 y$221))) (assert (= y$s$539_op (and y$s$574_op y$292))) (assert (= y$s$575_op (or y$s$538_op y$s$539_op))) (assert (= y$301 (= y$n2s2 y$pcacheB.next_state))) (assert (= y$s$362_op (or y$271 y$301))) (assert (= y$s$326_op (and y$215 y$245))) (assert (= y$s$365_op (or y$s$364_op y$s$326_op))) (assert (= y$s$327_op (and y$46 y$199))) (assert (= y$s$366_op (or y$s$365_op y$s$327_op))) (assert (= y$s$458_op (ite y$s$366_op y$n1s32 y$n0s32))) (assert (= y$w$12_op (ite y$s$362_op y$n0s32 y$s$458_op))) (assert (= y$s$366_op y$318)) (assert (= y$319 (and (not y$s$362_op) y$318))) (assert (= y$316 (Extract_1_0_0_32 y$w$12_op))) (assert (= y$319 y$316)) (assert (= y$bus_arbiter.bus_ackC (not y$5))) (assert (= y$s$671_op (ite y$316 y$ND_inB_op y$5))) (assert (= y$ND_inC_op (ite y$271 y$ND_inB_op y$s$671_op))) (assert (= y$w$13_op (Concat_32_1_31 y$ND_inC_op y$n0s31))) (assert (= y$s$663_op (ite y$s$575_op y$w$13_op y$n0s32))) (assert (= y$w$14_op (ite y$s$572_op y$n1s32 y$s$663_op))) (assert (= y$334 (and y$s$575_op y$ND_inC_op))) (assert (= y$335 (or y$s$572_op y$334))) (assert (= y$331 (Extract_1_0_0_32 y$w$14_op))) (assert (= y$335 y$331)) (assert (= y$s$10_op (or y$s$9_op y$331))) (assert (= y$s$10_op (not y$339))) (assert (= y$339 y$s$652_op)) (assert (= y$s$653_op (and y$7 y$s$652_op))) (assert (= y$215 y$s$499_op)) (assert (= y$s$500_op (ite y$214 y$s$653_op y$s$499_op))) (assert (= y$s$501_op (ite y$s$478_op y$s$498_op y$s$500_op))) (assert (= y$s$231_op (and (not y$1) y$s$501_op))) (assert (= y$s$120_op (and y$1 y$bus_arbiter.is_snoop))) (assert (= y$163 y$s$214_op)) (assert (= y$s$210_op (ite y$125 y$s$649_op y$s$214_op))) (assert (= y$s$52_op (ite y$200 y$s$210_op y$s$214_op))) (assert (= y$s$53_op (ite y$201 y$s$210_op y$s$52_op))) (assert (= y$s$54_op (and y$s$216_op y$215))) (assert (= y$s$55_op (ite y$214 y$s$214_op y$s$54_op))) (assert (= y$s$56_op (ite y$s$478_op y$s$53_op y$s$55_op))) (assert (= y$s$121_op (and y$125 y$214))) (assert (= y$s$3_op (and y$374 y$379))) (assert (= y$all_shared_op (and y$387 y$s$3_op))) (assert (= y$all_shared_op (not y$392))) (assert (= y$392 y$s$627_op)) (assert (= y$s$203_op (and y$s$121_op y$s$627_op))) (assert (= y$s$218_op (ite y$237 y$s$56_op y$s$203_op))) (assert (= y$s$219_op (ite y$s$120_op y$s$218_op y$pcacheA.update))) (assert (= y$pcacheA.update$next_rhs_op (ite y$s$155_op y$s$231_op y$s$219_op))) (assert (= y$403 (= y$pcacheA.update$next y$pcacheA.update$next_rhs_op))) (assert (= y$s$619_op (ite y$339 y$n0s2 y$n1s2))) (assert (= y$s$191_op (ite y$7 y$s$619_op y$pcacheA.state))) (assert (= y$s$193_op (ite y$bus_arbiter.invalidate y$n0s2 y$pcacheA.state))) (assert (= y$s$195_op (ite y$7 y$s$619_op y$s$193_op))) (assert (= y$s$47_op (ite y$200 y$s$191_op y$s$195_op))) (assert (= y$s$48_op (ite y$201 y$s$191_op y$s$47_op))) (assert (= y$s$197_op (ite y$339 y$n0s2 y$pcacheA.state))) (assert (= y$s$198_op (ite y$7 y$s$197_op y$pcacheA.state))) (assert (= y$s$49_op (ite y$215 y$n0s2 y$pcacheA.state))) (assert (= y$s$50_op (ite y$214 y$s$198_op y$s$49_op))) (assert (= y$s$51_op (ite y$s$478_op y$s$48_op y$s$50_op))) (assert (= y$s$201_op (ite y$1 y$pcacheA.state y$s$51_op))) (assert (= y$s$174_op (ite y$bus_arbiter.invalidate y$n2s2 y$pcacheA.state))) (assert (= y$s$605_op (ite y$7 y$n1s2 y$n2s2))) (assert (= y$s$181_op (ite y$163 y$s$605_op y$pcacheA.state))) (assert (= y$s$175_op (ite y$125 y$s$174_op y$s$181_op))) (assert (= y$s$42_op (ite y$200 y$s$175_op y$s$181_op))) (assert (= y$s$43_op (ite y$201 y$s$175_op y$s$42_op))) (assert (= y$s$183_op (ite y$125 y$n2s2 y$pcacheA.state))) (assert (= y$s$44_op (ite y$215 y$s$183_op y$pcacheA.state))) (assert (= y$s$45_op (ite y$214 y$s$181_op y$s$44_op))) (assert (= y$s$46_op (ite y$s$478_op y$s$43_op y$s$45_op))) (assert (= y$s$165_op (ite y$392 y$n0s2 y$pcacheA.state))) (assert (= y$s$166_op (ite y$s$121_op y$s$165_op y$pcacheA.next_state))) (assert (= y$s$185_op (ite y$237 y$s$46_op y$s$166_op))) (assert (= y$s$186_op (ite y$s$120_op y$s$185_op y$pcacheA.next_state))) (assert (= y$pcacheA.next_state$next_rhs_op (ite y$s$155_op y$s$201_op y$s$186_op))) (assert (= y$459 (= y$pcacheA.next_state$next y$pcacheA.next_state$next_rhs_op))) (assert (= y$s$164_op (or y$14 y$pcacheA.hit))) (assert (= y$pcacheA.hit$next_rhs_op (ite y$s$156_op y$pcacheA.hit y$s$164_op))) (assert (= y$465 (= y$pcacheA.hit$next y$pcacheA.hit$next_rhs_op))) (assert (= y$pcacheA.hit (not y$16))) (assert (= y$s$163_op (and (not y$14) y$16))) (assert (= y$pcacheA.miss$next_rhs_op (ite y$s$156_op y$pcacheA.miss y$s$163_op))) (assert (= y$471 (= y$pcacheA.miss$next y$pcacheA.miss$next_rhs_op))) (assert (= y$s$162_op (or y$14 y$pcacheA.read))) (assert (= y$pcacheA.read$next_rhs_op (and (not y$s$156_op) y$s$162_op))) (assert (= y$477 (= y$pcacheA.read$next y$pcacheA.read$next_rhs_op))) (assert (= y$s$161_op (and (not y$14) y$pcacheA.write))) (assert (= y$pcacheA.write$next_rhs_op (and (not y$s$156_op) y$s$161_op))) (assert (= y$483 (= y$pcacheA.write$next y$pcacheA.write$next_rhs_op))) (assert (= y$s$101_op (and y$bus_arbiter.is_snoop y$237))) (assert (= y$237 (not y$487))) (assert (= y$s$102_op (and y$bus_arbiter.is_snoop y$487))) (assert (= y$s$103_op (and y$214 y$s$102_op))) (assert (= y$s$104_op (and y$374 y$s$103_op))) (assert (= (not (= y$n0s3 y$bus_arbiter.shared_snoop)) y$495)) (assert (= y$s$105_op (and y$pcacheA.proc.valid y$495))) (assert (= y$s$233_op (ite y$pcacheA.bus_req y$n0s32 y$n1s32))) (assert (= y$s$234_op (ite y$s$105_op y$n0s32 y$s$233_op))) (assert (= y$s$235_op (ite y$s$104_op y$n0s32 y$s$234_op))) (assert (= y$w$15_op (ite y$s$101_op y$n0s32 y$s$235_op))) (assert (= y$pcacheA.bus_req (not y$510))) (assert (= y$511 (and (not y$s$105_op) y$510))) (assert (= y$512 (and (not y$s$104_op) y$511))) (assert (= y$513 (and (not y$s$101_op) y$512))) (assert (= y$506 (Extract_1_0_0_32 y$w$15_op))) (assert (= y$513 y$506)) (assert (= y$w$25_op (Concat_32_3_29 y$pcacheA.proc.count y$n0s29))) (assert (= y$518 (= y$n0s32 y$w$25_op))) (assert (= y$518 y$s$246_op)) (assert (= y$pcacheA.proc.valid$next_rhs_op (ite y$506 y$s$246_op y$pcacheA.proc.valid))) (assert (= y$523 (= y$pcacheA.proc.valid$next y$pcacheA.proc.valid$next_rhs_op))) (assert (= y$s$247_op (Sub_32_32_32 y$w$25_op y$n1s32))) (assert (= y$527 (Extract_3_2_0_32 y$s$247_op))) (assert (= y$s$245_op (ite y$518 y$n0s3 y$527))) (assert (= y$pcacheA.proc.count$next_rhs_op (ite y$506 y$s$245_op y$pcacheA.proc.count))) (assert (= y$533 (= y$pcacheA.proc.count$next y$pcacheA.proc.count$next_rhs_op))) (assert (= y$s$330_op (and y$pcacheB.hit y$376))) (assert (= y$s$331_op (and y$pcacheB.write y$s$330_op))) (assert (= y$s$332_op (and y$pcacheB.miss y$376))) (assert (= y$s$374_op (or y$pcacheB.read y$pcacheB.write))) (assert (= y$s$333_op (and y$s$332_op y$s$374_op))) (assert (= y$54 (= y$n2s2 y$pcacheB.state))) (assert (= y$w$26_op (Concat_32_1_31 y$pcacheB.hit y$n0s31))) (assert (= y$547 (= y$n1s32 y$w$26_op))) (assert (= y$s$334_op (and y$54 y$547))) (assert (= y$w$27_op (Concat_32_1_31 y$pcacheB.read y$n0s31))) (assert (= y$552 (= y$n1s32 y$w$27_op))) (assert (= y$w$28_op (Concat_32_1_31 y$pcacheB.write y$n0s31))) (assert (= y$555 (= y$n1s32 y$w$28_op))) (assert (= y$s$373_op (or y$552 y$555))) (assert (= y$s$335_op (and y$s$334_op y$s$373_op))) (assert (= y$w$29_op (Concat_32_1_31 y$pcacheB.miss y$n0s31))) (assert (= y$562 (= y$n1s32 y$w$29_op))) (assert (= y$s$336_op (and y$54 y$562))) (assert (= y$s$337_op (and y$s$373_op y$s$336_op))) (assert (= y$567 (= y$n0s2 y$pcacheB.state))) (assert (= y$s$338_op (and y$pcacheB.miss y$567))) (assert (= y$s$339_op (and y$s$374_op y$s$338_op))) (assert (= y$s$377_op (ite y$s$339_op y$n5s3 y$n0s3))) (assert (= y$s$378_op (ite y$s$337_op y$n4s3 y$s$377_op))) (assert (= y$s$379_op (ite y$s$335_op y$n3s3 y$s$378_op))) (assert (= y$s$380_op (ite y$s$333_op y$n2s3 y$s$379_op))) (assert (= y$s$257_op (ite y$s$331_op y$n0s3 y$s$380_op))) (assert (= y$pcacheB.snoop_type$next_rhs_op (ite y$s$331_op y$n1s3 y$s$257_op))) (assert (= y$584 (= y$pcacheB.snoop_type$next y$pcacheB.snoop_type$next_rhs_op))) (assert (= y$pcacheB.bus_req$next_rhs_op (and y$pcacheB.bus_req (not y$pcacheB.update)))) (assert (= y$588 (= y$pcacheB.bus_req$next y$pcacheB.bus_req$next_rhs_op))) (assert (= y$pcacheB.proc.valid (not y$590))) (assert (= y$s$376_op (or y$pcacheB.update y$590))) (assert (= y$pcacheB.bus_req (not y$39))) (assert (= y$s$452_op (ite y$39 y$pcacheB.write y$pcacheB.inv_out))) (assert (= y$pcacheB.inv_out$next_rhs_op (and (not y$s$376_op) y$s$452_op))) (assert (= y$597 (= y$pcacheB.inv_out$next y$pcacheB.inv_out$next_rhs_op))) (assert (= y$599 (= y$pcacheB.next_state y$pcacheB.state$next))) (assert (= y$s$375_op (or y$bus_arbiter.bus_ackB y$9))) (assert (= y$s$451_op (and (not y$3) y$s$501_op))) (assert (= y$s$340_op (and y$3 y$bus_arbiter.is_snoop))) (assert (= y$567 y$s$434_op)) (assert (= y$s$430_op (ite y$376 y$s$649_op y$s$434_op))) (assert (= y$s$272_op (ite y$200 y$s$430_op y$s$434_op))) (assert (= y$s$273_op (ite y$201 y$s$430_op y$s$272_op))) (assert (= y$s$274_op (and y$s$436_op y$215))) (assert (= y$s$275_op (ite y$214 y$s$434_op y$s$274_op))) (assert (= y$s$276_op (ite y$s$478_op y$s$273_op y$s$275_op))) (assert (= y$s$341_op (and y$376 y$214))) (assert (= y$s$423_op (and y$s$627_op y$s$341_op))) (assert (= y$s$438_op (ite y$284 y$s$276_op y$s$423_op))) (assert (= y$s$439_op (ite y$s$340_op y$s$438_op y$pcacheB.update))) (assert (= y$pcacheB.update$next_rhs_op (ite y$s$375_op y$s$451_op y$s$439_op))) (assert (= y$632 (= y$pcacheB.update$next y$pcacheB.update$next_rhs_op))) (assert (= y$s$411_op (ite y$7 y$s$619_op y$pcacheB.state))) (assert (= y$s$413_op (ite y$bus_arbiter.invalidate y$n0s2 y$pcacheB.state))) (assert (= y$s$415_op (ite y$7 y$s$619_op y$s$413_op))) (assert (= y$s$267_op (ite y$200 y$s$411_op y$s$415_op))) (assert (= y$s$268_op (ite y$201 y$s$411_op y$s$267_op))) (assert (= y$s$417_op (ite y$339 y$n0s2 y$pcacheB.state))) (assert (= y$s$418_op (ite y$7 y$s$417_op y$pcacheB.state))) (assert (= y$s$269_op (ite y$215 y$n0s2 y$pcacheB.state))) (assert (= y$s$270_op (ite y$214 y$s$418_op y$s$269_op))) (assert (= y$s$271_op (ite y$s$478_op y$s$268_op y$s$270_op))) (assert (= y$s$421_op (ite y$3 y$pcacheB.state y$s$271_op))) (assert (= y$s$394_op (ite y$bus_arbiter.invalidate y$n2s2 y$pcacheB.state))) (assert (= y$s$401_op (ite y$567 y$s$605_op y$pcacheB.state))) (assert (= y$s$395_op (ite y$376 y$s$394_op y$s$401_op))) (assert (= y$s$262_op (ite y$200 y$s$395_op y$s$401_op))) (assert (= y$s$263_op (ite y$201 y$s$395_op y$s$262_op))) (assert (= y$s$403_op (ite y$376 y$n2s2 y$pcacheB.state))) (assert (= y$s$264_op (ite y$215 y$s$403_op y$pcacheB.state))) (assert (= y$s$265_op (ite y$214 y$s$401_op y$s$264_op))) (assert (= y$s$266_op (ite y$s$478_op y$s$263_op y$s$265_op))) (assert (= y$s$385_op (ite y$392 y$n0s2 y$pcacheB.state))) (assert (= y$s$386_op (ite y$s$341_op y$s$385_op y$pcacheB.next_state))) (assert (= y$s$405_op (ite y$284 y$s$266_op y$s$386_op))) (assert (= y$s$406_op (ite y$s$340_op y$s$405_op y$pcacheB.next_state))) (assert (= y$pcacheB.next_state$next_rhs_op (ite y$s$375_op y$s$421_op y$s$406_op))) (assert (= y$684 (= y$pcacheB.next_state$next y$pcacheB.next_state$next_rhs_op))) (assert (= y$s$384_op (or y$39 y$pcacheB.hit))) (assert (= y$pcacheB.hit$next_rhs_op (ite y$s$376_op y$pcacheB.hit y$s$384_op))) (assert (= y$690 (= y$pcacheB.hit$next y$pcacheB.hit$next_rhs_op))) (assert (= y$pcacheB.hit (not y$41))) (assert (= y$s$383_op (and (not y$39) y$41))) (assert (= y$pcacheB.miss$next_rhs_op (ite y$s$376_op y$pcacheB.miss y$s$383_op))) (assert (= y$696 (= y$pcacheB.miss$next y$pcacheB.miss$next_rhs_op))) (assert (= y$s$382_op (or y$39 y$pcacheB.read))) (assert (= y$pcacheB.read$next_rhs_op (and (not y$s$376_op) y$s$382_op))) (assert (= y$702 (= y$pcacheB.read$next y$pcacheB.read$next_rhs_op))) (assert (= y$s$381_op (and (not y$39) y$pcacheB.write))) (assert (= y$pcacheB.write$next_rhs_op (and (not y$s$376_op) y$s$381_op))) (assert (= y$708 (= y$pcacheB.write$next y$pcacheB.write$next_rhs_op))) (assert (= y$s$321_op (and y$bus_arbiter.is_snoop y$284))) (assert (= y$284 (not y$712))) (assert (= y$s$322_op (and y$bus_arbiter.is_snoop y$712))) (assert (= y$s$323_op (and y$214 y$s$322_op))) (assert (= y$s$324_op (and y$379 y$s$323_op))) (assert (= y$s$325_op (and y$pcacheB.proc.valid y$495))) (assert (= y$s$453_op (ite y$pcacheB.bus_req y$n0s32 y$n1s32))) (assert (= y$s$454_op (ite y$s$325_op y$n0s32 y$s$453_op))) (assert (= y$s$455_op (ite y$s$324_op y$n0s32 y$s$454_op))) (assert (= y$w$17_op (ite y$s$321_op y$n0s32 y$s$455_op))) (assert (= y$pcacheB.bus_req (not y$733))) (assert (= y$734 (and (not y$s$325_op) y$733))) (assert (= y$735 (and (not y$s$324_op) y$734))) (assert (= y$736 (and (not y$s$321_op) y$735))) (assert (= y$729 (Extract_1_0_0_32 y$w$17_op))) (assert (= y$736 y$729)) (assert (= y$w$30_op (Concat_32_3_29 y$pcacheB.proc.count y$n0s29))) (assert (= y$740 (= y$n0s32 y$w$30_op))) (assert (= y$740 y$s$466_op)) (assert (= y$pcacheB.proc.valid$next_rhs_op (ite y$729 y$s$466_op y$pcacheB.proc.valid))) (assert (= y$745 (= y$pcacheB.proc.valid$next y$pcacheB.proc.valid$next_rhs_op))) (assert (= y$s$467_op (Sub_32_32_32 y$w$30_op y$n1s32))) (assert (= y$749 (Extract_3_2_0_32 y$s$467_op))) (assert (= y$s$465_op (ite y$740 y$n0s3 y$749))) (assert (= y$pcacheB.proc.count$next_rhs_op (ite y$729 y$s$465_op y$pcacheB.proc.count))) (assert (= y$755 (= y$pcacheB.proc.count$next y$pcacheB.proc.count$next_rhs_op))) (assert (= y$s$540_op (and y$pcacheC.hit y$384))) (assert (= y$s$541_op (and y$pcacheC.write y$s$540_op))) (assert (= y$s$542_op (and y$pcacheC.miss y$384))) (assert (= y$s$579_op (or y$pcacheC.read y$pcacheC.write))) (assert (= y$s$543_op (and y$s$542_op y$s$579_op))) (assert (= y$75 (= y$n2s2 y$pcacheC.state))) (assert (= y$w$31_op (Concat_32_1_31 y$pcacheC.hit y$n0s31))) (assert (= y$769 (= y$n1s32 y$w$31_op))) (assert (= y$s$544_op (and y$75 y$769))) (assert (= y$w$32_op (Concat_32_1_31 y$pcacheC.read y$n0s31))) (assert (= y$774 (= y$n1s32 y$w$32_op))) (assert (= y$w$33_op (Concat_32_1_31 y$pcacheC.write y$n0s31))) (assert (= y$777 (= y$n1s32 y$w$33_op))) (assert (= y$s$578_op (or y$774 y$777))) (assert (= y$s$545_op (and y$s$544_op y$s$578_op))) (assert (= y$w$34_op (Concat_32_1_31 y$pcacheC.miss y$n0s31))) (assert (= y$784 (= y$n1s32 y$w$34_op))) (assert (= y$s$546_op (and y$75 y$784))) (assert (= y$s$547_op (and y$s$578_op y$s$546_op))) (assert (= y$789 (= y$n0s2 y$pcacheC.state))) (assert (= y$s$548_op (and y$pcacheC.miss y$789))) (assert (= y$s$549_op (and y$s$579_op y$s$548_op))) (assert (= y$s$582_op (ite y$s$549_op y$n5s3 y$n0s3))) (assert (= y$s$583_op (ite y$s$547_op y$n4s3 y$s$582_op))) (assert (= y$s$584_op (ite y$s$545_op y$n3s3 y$s$583_op))) (assert (= y$s$585_op (ite y$s$543_op y$n2s3 y$s$584_op))) (assert (= y$s$477_op (ite y$s$541_op y$n0s3 y$s$585_op))) (assert (= y$pcacheC.snoop_type$next_rhs_op (ite y$s$541_op y$n1s3 y$s$477_op))) (assert (= y$806 (= y$pcacheC.snoop_type$next y$pcacheC.snoop_type$next_rhs_op))) (assert (= y$pcacheC.bus_req$next_rhs_op (and y$pcacheC.bus_req (not y$pcacheC.update)))) (assert (= y$810 (= y$pcacheC.bus_req$next y$pcacheC.bus_req$next_rhs_op))) (assert (= y$pcacheC.proc.valid (not y$812))) (assert (= y$s$581_op (or y$pcacheC.update y$812))) (assert (= y$pcacheC.bus_req (not y$60))) (assert (= y$s$657_op (ite y$60 y$pcacheC.write y$pcacheC.inv_out))) (assert (= y$pcacheC.inv_out$next_rhs_op (and (not y$s$581_op) y$s$657_op))) (assert (= y$819 (= y$pcacheC.inv_out$next y$pcacheC.inv_out$next_rhs_op))) (assert (= y$821 (= y$pcacheC.next_state y$pcacheC.state$next))) (assert (= y$s$580_op (or y$bus_arbiter.bus_ackC y$9))) (assert (= y$s$656_op (and (not y$5) y$s$501_op))) (assert (= y$s$550_op (and y$5 y$bus_arbiter.is_snoop))) (assert (= y$789 y$s$639_op)) (assert (= y$s$635_op (ite y$384 y$s$649_op y$s$639_op))) (assert (= y$s$492_op (ite y$200 y$s$635_op y$s$639_op))) (assert (= y$s$493_op (ite y$201 y$s$635_op y$s$492_op))) (assert (= y$s$494_op (and y$s$641_op y$215))) (assert (= y$s$495_op (ite y$214 y$s$639_op y$s$494_op))) (assert (= y$s$496_op (ite y$s$478_op y$s$493_op y$s$495_op))) (assert (= y$s$551_op (and y$384 y$214))) (assert (= y$s$628_op (and y$s$627_op y$s$551_op))) (assert (= y$s$643_op (ite y$331 y$s$496_op y$s$628_op))) (assert (= y$s$644_op (ite y$s$550_op y$s$643_op y$pcacheC.update))) (assert (= y$pcacheC.update$next_rhs_op (ite y$s$580_op y$s$656_op y$s$644_op))) (assert (= y$854 (= y$pcacheC.update$next y$pcacheC.update$next_rhs_op))) (assert (= y$s$616_op (ite y$7 y$s$619_op y$pcacheC.state))) (assert (= y$s$618_op (ite y$bus_arbiter.invalidate y$n0s2 y$pcacheC.state))) (assert (= y$s$620_op (ite y$7 y$s$619_op y$s$618_op))) (assert (= y$s$487_op (ite y$200 y$s$616_op y$s$620_op))) (assert (= y$s$488_op (ite y$201 y$s$616_op y$s$487_op))) (assert (= y$s$622_op (ite y$339 y$n0s2 y$pcacheC.state))) (assert (= y$s$623_op (ite y$7 y$s$622_op y$pcacheC.state))) (assert (= y$s$489_op (ite y$215 y$n0s2 y$pcacheC.state))) (assert (= y$s$490_op (ite y$214 y$s$623_op y$s$489_op))) (assert (= y$s$491_op (ite y$s$478_op y$s$488_op y$s$490_op))) (assert (= y$s$626_op (ite y$5 y$pcacheC.state y$s$491_op))) (assert (= y$s$599_op (ite y$bus_arbiter.invalidate y$n2s2 y$pcacheC.state))) (assert (= y$s$606_op (ite y$789 y$s$605_op y$pcacheC.state))) (assert (= y$s$600_op (ite y$384 y$s$599_op y$s$606_op))) (assert (= y$s$482_op (ite y$200 y$s$600_op y$s$606_op))) (assert (= y$s$483_op (ite y$201 y$s$600_op y$s$482_op))) (assert (= y$s$608_op (ite y$384 y$n2s2 y$pcacheC.state))) (assert (= y$s$484_op (ite y$215 y$s$608_op y$pcacheC.state))) (assert (= y$s$485_op (ite y$214 y$s$606_op y$s$484_op))) (assert (= y$s$486_op (ite y$s$478_op y$s$483_op y$s$485_op))) (assert (= y$s$590_op (ite y$392 y$n0s2 y$pcacheC.state))) (assert (= y$s$591_op (ite y$s$551_op y$s$590_op y$pcacheC.next_state))) (assert (= y$s$610_op (ite y$331 y$s$486_op y$s$591_op))) (assert (= y$s$611_op (ite y$s$550_op y$s$610_op y$pcacheC.next_state))) (assert (= y$pcacheC.next_state$next_rhs_op (ite y$s$580_op y$s$626_op y$s$611_op))) (assert (= y$906 (= y$pcacheC.next_state$next y$pcacheC.next_state$next_rhs_op))) (assert (= y$s$589_op (or y$60 y$pcacheC.hit))) (assert (= y$pcacheC.hit$next_rhs_op (ite y$s$581_op y$pcacheC.hit y$s$589_op))) (assert (= y$912 (= y$pcacheC.hit$next y$pcacheC.hit$next_rhs_op))) (assert (= y$pcacheC.hit (not y$62))) (assert (= y$s$588_op (and (not y$60) y$62))) (assert (= y$pcacheC.miss$next_rhs_op (ite y$s$581_op y$pcacheC.miss y$s$588_op))) (assert (= y$918 (= y$pcacheC.miss$next y$pcacheC.miss$next_rhs_op))) (assert (= y$s$587_op (or y$60 y$pcacheC.read))) (assert (= y$pcacheC.read$next_rhs_op (and (not y$s$581_op) y$s$587_op))) (assert (= y$924 (= y$pcacheC.read$next y$pcacheC.read$next_rhs_op))) (assert (= y$s$586_op (and (not y$60) y$pcacheC.write))) (assert (= y$pcacheC.write$next_rhs_op (and (not y$s$581_op) y$s$586_op))) (assert (= y$930 (= y$pcacheC.write$next y$pcacheC.write$next_rhs_op))) (assert (= y$s$533_op (and y$bus_arbiter.is_snoop y$331))) (assert (= y$331 (not y$934))) (assert (= y$s$534_op (and y$bus_arbiter.is_snoop y$934))) (assert (= y$s$535_op (and y$214 y$s$534_op))) (assert (= y$s$536_op (and y$387 y$s$535_op))) (assert (= y$s$537_op (and y$pcacheC.proc.valid y$495))) (assert (= y$s$658_op (ite y$pcacheC.bus_req y$n0s32 y$n1s32))) (assert (= y$s$659_op (ite y$s$537_op y$n0s32 y$s$658_op))) (assert (= y$s$660_op (ite y$s$536_op y$n0s32 y$s$659_op))) (assert (= y$w$19_op (ite y$s$533_op y$n0s32 y$s$660_op))) (assert (= y$pcacheC.bus_req (not y$955))) (assert (= y$956 (and (not y$s$537_op) y$955))) (assert (= y$957 (and (not y$s$536_op) y$956))) (assert (= y$958 (and (not y$s$533_op) y$957))) (assert (= y$951 (Extract_1_0_0_32 y$w$19_op))) (assert (= y$958 y$951)) (assert (= y$w$35_op (Concat_32_3_29 y$pcacheC.proc.count y$n0s29))) (assert (= y$962 (= y$n0s32 y$w$35_op))) (assert (= y$962 y$s$669_op)) (assert (= y$pcacheC.proc.valid$next_rhs_op (ite y$951 y$s$669_op y$pcacheC.proc.valid))) (assert (= y$967 (= y$pcacheC.proc.valid$next y$pcacheC.proc.valid$next_rhs_op))) (assert (= y$s$670_op (Sub_32_32_32 y$w$35_op y$n1s32))) (assert (= y$971 (Extract_3_2_0_32 y$s$670_op))) (assert (= y$s$668_op (ite y$962 y$n0s3 y$971))) (assert (= y$pcacheC.proc.count$next_rhs_op (ite y$951 y$s$668_op y$pcacheC.proc.count))) (assert (= y$977 (= y$pcacheC.proc.count$next y$pcacheC.proc.count$next_rhs_op))) (assert (= y$978 (and y$89 y$94 y$100 y$108 y$116 y$122 y$180 y$184 y$193 y$195 y$403 y$459 y$465 y$471 y$477 y$483 y$523 y$533 y$584 y$588 y$597 y$599 y$632 y$684 y$690 y$696 y$702 y$708 y$745 y$755 y$806 y$810 y$819 y$821 y$854 y$906 y$912 y$918 y$924 y$930 y$967 y$977))) (assert (= y$1008 (= y$n1s2 y$pcacheA.state$next))) (assert (= y$w$1$next_op (ite y$1008 y$n1s32 y$n0s32))) (assert (= y$1008 y$1012)) (assert (= y$1011 (Extract_1_0_0_32 y$w$1$next_op))) (assert (= y$1012 y$1011)) (assert (= y$w$2$next_op (Concat_32_1_31 y$1011 y$n0s31))) (assert (= y$1016 (not (= y$n1s32 y$w$2$next_op)))) (assert (= y$1017 (= y$n1s2 y$pcacheB.state$next))) (assert (= y$w$3$next_op (ite y$1017 y$n1s32 y$n0s32))) (assert (= y$1017 y$1021)) (assert (= y$1020 (Extract_1_0_0_32 y$w$3$next_op))) (assert (= y$1021 y$1020)) (assert (= y$w$4$next_op (Concat_32_1_31 y$1020 y$n0s31))) (assert (= y$1025 (= y$n1s32 y$w$4$next_op))) (assert (= y$s$12$next_op (or y$1016 y$1025))) (assert (= y$1028 (= y$n1s2 y$pcacheC.state$next))) (assert (= y$w$5$next_op (ite y$1028 y$n1s32 y$n0s32))) (assert (= y$1028 y$1032)) (assert (= y$1031 (Extract_1_0_0_32 y$w$5$next_op))) (assert (= y$1032 y$1031)) (assert (= y$w$6$next_op (Concat_32_1_31 y$1031 y$n0s31))) (assert (= y$1036 (= y$n1s32 y$w$6$next_op))) (assert (= y$prop0$next_op (or y$s$12$next_op y$1036))) (assert (= y$1039 (= y$prop$next y$prop0$next_op))) (assert (= y$prop$next (not y$1007))) (assert (= y$1042 (and y$prop y$995 y$978 y$1039 y$1007))) (assert y$1042) (assert (distinct y$n0s2 y$n2s2 y$n1s2)) (assert (distinct y$n0s3 y$n5s3 y$n2s3 y$n1s3 y$n3s3 y$n4s3)) (assert (not (= y$n1s32 y$n0s32))) (check-sat) (exit) 2018-Goel-hwbench_QF_UF_cache_coherence_three_ab_cti_max.smt2.expected.err000066400000000000000000000000001445011647600337470ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF2018-Goel-hwbench_QF_UF_cache_coherence_three_ab_cti_max.smt2.expected.out000066400000000000000000000000041445011647600337720ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFsat opensmt-2.5.2/regression/QF_UF/2018-Goel-hwbench_QF_UF_cache_coherence_three_ab_cti_max_delta_0.smt2000066400000000000000000000004051445011647600330400ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort u1 0) (declare-sort u2 0) (declare-fun Concat (Bool u1) u2) (declare-fun y () Bool) (declare-fun yn () u1) (declare-fun yp () Bool) (declare-fun yw () u2) (assert (= yw (Concat yp yn))) (assert (= yp (not y))) (check-sat) (exit) 2018-Goel-hwbench_QF_UF_cache_coherence_three_ab_cti_max_delta_0.smt2.expected.err000066400000000000000000000000001445011647600353370ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF2018-Goel-hwbench_QF_UF_cache_coherence_three_ab_cti_max_delta_0.smt2.expected.out000066400000000000000000000000041445011647600353620ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFsat opensmt-2.5.2/regression/QF_UF/2018-Goel-hwbench_QF_UF_h_TicTacToe_ab_reg_max_delta_0.smt2000066400000000000000000000006201445011647600307160ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort utt$2 0) (declare-fun Concat (Bool Bool) utt$2) (declare-fun y0 () utt$2) (declare-fun y1 () utt$2) (declare-fun y2 () utt$2) (declare-fun b1 () Bool) (declare-fun b2 () Bool) (declare-fun b3 () Bool) (assert (not (= y1 y2))) (assert (not b1)) (assert (= b3 (ite b2 false b1))) (assert (= y2 (Concat b3 false))) (assert (= y1 (Concat false false))) (check-sat) (exit) 2018-Goel-hwbench_QF_UF_h_TicTacToe_ab_reg_max_delta_0.smt2.expected.err000066400000000000000000000000001445011647600332160ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF2018-Goel-hwbench_QF_UF_h_TicTacToe_ab_reg_max_delta_0.smt2.expected.out000066400000000000000000000000061445011647600332430ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFunsat 2018-Goel-hwbench_QF_UF_h_traffic_light_example_ab_cti_max_simplified_0.smt2000066400000000000000000000016741445011647600344100ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF(set-logic QF_UF) (declare-sort utt$8 0) (declare-fun y$2 () Bool) (declare-fun y$Counter$next () utt$8) (declare-fun y$Counter$next_rhs_op () utt$8) (declare-fun y$n0s8 () utt$8) (declare-fun y$n1s8 () utt$8) (declare-fun y$n255s8 () utt$8) (declare-fun y$n63s8 () utt$8) (declare-fun y$n7s8 () utt$8) (declare-fun y$s$24_op () utt$8) (declare-fun y$s$28_op () utt$8) (declare-fun y$s$29_op () utt$8) (declare-fun y$s$4_op () utt$8) (declare-fun y$s$5_op () utt$8) (declare-fun y$s$6_op () utt$8) (assert (= y$s$28_op (ite y$2 y$n63s8 y$s$24_op))) (assert (= y$s$29_op (ite y$2 y$n7s8 y$s$24_op))) (assert (= y$s$4_op (ite false y$s$28_op y$s$29_op))) (assert (= y$s$6_op (ite true y$s$4_op y$s$5_op))) (assert (= y$Counter$next_rhs_op (ite false y$n0s8 y$s$6_op))) (assert (= true (= y$Counter$next y$Counter$next_rhs_op))) (assert (= false (not (= y$n255s8 y$Counter$next)))) (assert (distinct y$n0s8 y$n63s8 y$n1s8 y$n7s8 y$n255s8)) (check-sat) (exit) 2018-Goel-hwbench_QF_UF_h_traffic_light_example_ab_cti_max_simplified_0.smt2.expected.err000066400000000000000000000000001445011647600367550ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF2018-Goel-hwbench_QF_UF_h_traffic_light_example_ab_cti_max_simplified_0.smt2.expected.out000066400000000000000000000000041445011647600370000ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFsat 2018-Goel-hwbench_QF_UF_h_traffic_light_example_ab_cti_max_simplified_1.smt2000066400000000000000000000011121445011647600343740ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF(set-logic QF_UF) (declare-sort utt$8 0) (declare-fun x () Bool) (declare-fun z1 () utt$8) (declare-fun z2 () utt$8) (declare-fun y1 () utt$8) (declare-fun y2 () utt$8) (declare-fun n1 () utt$8) (declare-fun n2 () utt$8) (declare-fun n3 () utt$8) (declare-fun s1 () utt$8) (declare-fun s2 () utt$8) (declare-fun s3 () utt$8) (declare-fun s4 () utt$8) (declare-fun s6 () utt$8) (assert (= s2 (ite x n2 s1))) (assert (= s3 (ite x n3 s1))) (assert (= s4 s3)) (assert (= s6 s4)) (assert (= z2 s6)) (assert (= z1 z2)) (assert (= n1 z1)) (assert (distinct y1 n2 y2 n3 n1)) (check-sat) (exit) 2018-Goel-hwbench_QF_UF_h_traffic_light_example_ab_cti_max_simplified_1.smt2.expected.err000066400000000000000000000000001445011647600367560ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF2018-Goel-hwbench_QF_UF_h_traffic_light_example_ab_cti_max_simplified_1.smt2.expected.out000066400000000000000000000000041445011647600370010ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFsat opensmt-2.5.2/regression/QF_UF/2018-Goel-hwbench_QF_UF_loyd.1.prop1_ab_br_max_delta_0.smt2000066400000000000000000000070001445011647600305630ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort utt$8 0) (declare-fun BitWiseXor_8_8_8 (utt$8 utt$8) utt$8) (declare-fun y$n0s8 () utt$8) (declare-fun y$n1s8 () utt$8) (declare-fun y$n2s8 () utt$8) (declare-fun y$n3s8 () utt$8) (declare-fun y$n4s8 () utt$8) (declare-fun y$n5s8 () utt$8) (declare-fun y$v3_1517448500_103_op () utt$8) (declare-fun y$v3_1517448500_104_op () utt$8) (declare-fun y$v3_1517448500_105_op () utt$8) (declare-fun y$v3_1517448500_106_op () utt$8) (declare-fun y$v3_1517448500_207$next_op () utt$8) (declare-fun y$v3_1517448500_212$next_op () utt$8) (declare-fun y$v3_1517448500_217$next_op () utt$8) (declare-fun y$v3_1517448500_222$next_op () utt$8) (declare-fun y$v3_1517448500_223$next_op () utt$8) (declare-fun y$v3_1517448500_224$next_op () utt$8) (declare-fun y$v3_1517448500_225$next_op () utt$8) (declare-fun y$v3_1517448500_226$next_op () utt$8) (declare-fun y$v3_1517448500_30_op () Bool) (declare-fun y$v3_1517448500_34_op () utt$8) (declare-fun y$v3_1517448500_37_op () utt$8) (declare-fun y$v3_1517448500_41_op () utt$8) (declare-fun y$v3_1517448500_45_op () utt$8) (declare-fun y$v3_1517448500_47$next_op () utt$8) (declare-fun y$v3_1517448500_47_op () utt$8) (declare-fun y$v3_1517448500_48_op () utt$8) (declare-fun y$v3_1517448500_49_op () utt$8) (declare-fun y$v3_1517448500_50_op () utt$8) (declare-fun y$v3_1517448500_51_op () utt$8) (declare-fun y$v3_1517448500_52_op () utt$8) (declare-fun y$v3_1517448500_53_op () utt$8) (declare-fun y$v3_1517448500_71_op () utt$8) (declare-fun y$v3_1517448500_87_op () utt$8) (declare-fun y$v_a_0 () utt$8) (declare-fun y$v_a_0$next () utt$8) (declare-fun y$v_a_0$next_rhs_op () utt$8) (declare-fun y$v_a_5 () utt$8) (declare-fun y$v_a_5$next_rhs$next_op () utt$8) (assert (= true (= y$n0s8 y$v_a_0))) (assert (= true (= y$n0s8 y$v_a_5))) (assert (distinct y$n0s8 y$n1s8 y$n2s8 y$n3s8 y$n4s8 y$n5s8)) (assert (= y$v3_1517448500_47_op (BitWiseXor_8_8_8 y$n5s8 y$v_a_5))) (assert (= y$v3_1517448500_48_op (ite false y$v3_1517448500_45_op y$v3_1517448500_47_op))) (assert (= y$v3_1517448500_49_op (ite false y$v3_1517448500_41_op y$v3_1517448500_48_op))) (assert (= y$v3_1517448500_50_op (ite false y$v3_1517448500_37_op y$v3_1517448500_49_op))) (assert (= y$v3_1517448500_51_op (ite false y$v3_1517448500_34_op y$v3_1517448500_50_op))) (assert (= y$v3_1517448500_52_op (ite false y$v_a_0 y$v3_1517448500_51_op))) (assert (= y$v3_1517448500_53_op (ite false y$n0s8 y$v3_1517448500_52_op))) (assert (= y$v3_1517448500_104_op (ite false y$v3_1517448500_103_op y$v_a_0))) (assert (= y$v3_1517448500_105_op (ite false y$v3_1517448500_87_op y$v3_1517448500_104_op))) (assert (= y$v3_1517448500_106_op (ite false y$v3_1517448500_71_op y$v3_1517448500_105_op))) (assert (= y$v_a_0$next_rhs_op (ite y$v3_1517448500_30_op y$v3_1517448500_53_op y$v3_1517448500_106_op))) (assert (= true (= y$v_a_0$next y$v_a_0$next_rhs_op))) (assert (= true (= y$n5s8 y$v_a_0$next))) (assert (= (= y$n0s8 y$v3_1517448500_47$next_op) true)) (assert (= y$v3_1517448500_223$next_op (ite false y$v3_1517448500_222$next_op y$v3_1517448500_47$next_op))) (assert (= y$v3_1517448500_224$next_op (ite false y$v3_1517448500_217$next_op y$v3_1517448500_223$next_op))) (assert (= y$v3_1517448500_225$next_op (ite false y$v3_1517448500_212$next_op y$v3_1517448500_224$next_op))) (assert (= y$v3_1517448500_226$next_op (ite false y$v3_1517448500_207$next_op y$v3_1517448500_225$next_op))) (assert (= y$v_a_5$next_rhs$next_op (BitWiseXor_8_8_8 y$n5s8 y$v3_1517448500_226$next_op))) (assert (= true (not (= y$n5s8 y$v_a_5$next_rhs$next_op)))) (check-sat) (exit) 2018-Goel-hwbench_QF_UF_loyd.1.prop1_ab_br_max_delta_0.smt2.expected.err000066400000000000000000000000001445011647600330640ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF2018-Goel-hwbench_QF_UF_loyd.1.prop1_ab_br_max_delta_0.smt2.expected.out000066400000000000000000000000061445011647600331110ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFunsat opensmt-2.5.2/regression/QF_UF/2018-Goel-hwbench_QF_UF_loyd.1.prop1_ab_br_max_delta_1.smt2000066400000000000000000000007011445011647600305650ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort utt$8 0) (declare-fun Xor (utt$8 utt$8) utt$8) (declare-fun y0 () utt$8) (declare-fun y1 () utt$8) (declare-fun x () utt$8) (declare-fun y0_n () utt$8) (declare-fun b () Bool) (declare-fun bwo1 () utt$8) (declare-fun bwo2 () utt$8) (assert (distinct y0 y1 x)) (assert (= x (ite b bwo1 y0))) (assert (= y0_n y0)) (assert (= bwo1 (Xor x y0))) (assert (= bwo2 (Xor x y0_n))) (assert (not (= x bwo2))) (check-sat) (exit) 2018-Goel-hwbench_QF_UF_loyd.1.prop1_ab_br_max_delta_1.smt2.expected.err000066400000000000000000000000001445011647600330650ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF2018-Goel-hwbench_QF_UF_loyd.1.prop1_ab_br_max_delta_1.smt2.expected.out000066400000000000000000000000061445011647600331120ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFunsat opensmt-2.5.2/regression/QF_UF/NEQ004_size4.smt2000066400000000000000000000405011445011647600210710ustar00rootroot00000000000000(set-logic QF_UF) (set-info :source | CADE ATP System competition. See http://www.cs.miami.edu/~tptp/CASC for more information. This benchmark was obtained by trying to find a finite model of a first-order formula (Albert Oliveras). |) (set-info :smt-lib-version 2.0) (set-info :category "crafted") (declare-sort U 0) (declare-fun c14 () U) (declare-fun c12 () U) (declare-fun p4 (U U) Bool) (declare-fun c13 () U) (declare-fun p3 (U U) Bool) (declare-fun c15 () U) (declare-fun c17 () U) (declare-fun p6 (U U) Bool) (declare-fun p2 (U U) Bool) (declare-fun p1 (U U) Bool) (declare-fun c11 () U) (declare-fun f5 (U U) U) (declare-fun c10 () U) (declare-fun p8 (U) Bool) (declare-fun c16 () U) (declare-fun p9 (U U) Bool) (declare-fun p7 (U U) Bool) (declare-fun c_0 () U) (declare-fun c_1 () U) (declare-fun c_2 () U) (declare-fun c_3 () U) (assert (let ((?v_52 (= c_0 c_0))) (let ((?v_16 (not ?v_52)) (?v_32 (p3 c_0 c_0)) (?v_55 (= c_0 c_1))) (let ((?v_17 (not ?v_55)) (?v_33 (p3 c_0 c_1)) (?v_58 (= c_0 c_2))) (let ((?v_18 (not ?v_58)) (?v_34 (p3 c_0 c_2)) (?v_61 (= c_0 c_3))) (let ((?v_19 (not ?v_61)) (?v_35 (p3 c_0 c_3)) (?v_64 (= c_1 c_0))) (let ((?v_20 (not ?v_64)) (?v_36 (p3 c_1 c_0)) (?v_67 (= c_1 c_1))) (let ((?v_21 (not ?v_67)) (?v_37 (p3 c_1 c_1)) (?v_70 (= c_1 c_2))) (let ((?v_22 (not ?v_70)) (?v_38 (p3 c_1 c_2)) (?v_73 (= c_1 c_3))) (let ((?v_23 (not ?v_73)) (?v_39 (p3 c_1 c_3)) (?v_76 (= c_2 c_0))) (let ((?v_24 (not ?v_76)) (?v_40 (p3 c_2 c_0)) (?v_79 (= c_2 c_1))) (let ((?v_25 (not ?v_79)) (?v_41 (p3 c_2 c_1)) (?v_82 (= c_2 c_2))) (let ((?v_26 (not ?v_82)) (?v_42 (p3 c_2 c_2)) (?v_85 (= c_2 c_3))) (let ((?v_27 (not ?v_85)) (?v_43 (p3 c_2 c_3)) (?v_88 (= c_3 c_0))) (let ((?v_28 (not ?v_88)) (?v_44 (p3 c_3 c_0)) (?v_91 (= c_3 c_1))) (let ((?v_29 (not ?v_91)) (?v_45 (p3 c_3 c_1)) (?v_94 (= c_3 c_2))) (let ((?v_30 (not ?v_94)) (?v_46 (p3 c_3 c_2)) (?v_97 (= c_3 c_3))) (let ((?v_31 (not ?v_97)) (?v_47 (p3 c_3 c_3)) (?v_53 (p4 c_0 c_0))) (let ((?v_0 (not ?v_53)) (?v_56 (p4 c_0 c_1))) (let ((?v_2 (not ?v_56)) (?v_65 (p4 c_1 c_0))) (let ((?v_1 (not ?v_65)) (?v_59 (p4 c_0 c_2))) (let ((?v_5 (not ?v_59)) (?v_77 (p4 c_2 c_0))) (let ((?v_4 (not ?v_77)) (?v_62 (p4 c_0 c_3))) (let ((?v_10 (not ?v_62)) (?v_89 (p4 c_3 c_0))) (let ((?v_9 (not ?v_89)) (?v_68 (p4 c_1 c_1))) (let ((?v_3 (not ?v_68)) (?v_71 (p4 c_1 c_2))) (let ((?v_7 (not ?v_71)) (?v_80 (p4 c_2 c_1))) (let ((?v_6 (not ?v_80)) (?v_74 (p4 c_1 c_3))) (let ((?v_12 (not ?v_74)) (?v_92 (p4 c_3 c_1))) (let ((?v_11 (not ?v_92)) (?v_83 (p4 c_2 c_2))) (let ((?v_8 (not ?v_83)) (?v_86 (p4 c_2 c_3))) (let ((?v_14 (not ?v_86)) (?v_95 (p4 c_3 c_2))) (let ((?v_13 (not ?v_95)) (?v_98 (p4 c_3 c_3))) (let ((?v_15 (not ?v_98)) (?v_54 (p2 c_0 c_0)) (?v_66 (p2 c_1 c_0)) (?v_78 (p2 c_2 c_0)) (?v_90 (p2 c_3 c_0)) (?v_57 (p2 c_0 c_1)) (?v_69 (p2 c_1 c_1)) (?v_81 (p2 c_2 c_1)) (?v_93 (p2 c_3 c_1)) (?v_60 (p2 c_0 c_2)) (?v_72 (p2 c_1 c_2)) (?v_84 (p2 c_2 c_2)) (?v_96 (p2 c_3 c_2)) (?v_63 (p2 c_0 c_3)) (?v_75 (p2 c_1 c_3)) (?v_87 (p2 c_2 c_3)) (?v_99 (p2 c_3 c_3)) (?v_100 (p1 c_0 c_0)) (?v_101 (p1 c_0 c_1)) (?v_102 (p1 c_0 c_2)) (?v_103 (p1 c_0 c_3)) (?v_104 (p1 c_1 c_0)) (?v_105 (p1 c_1 c_1)) (?v_106 (p1 c_1 c_2)) (?v_107 (p1 c_1 c_3)) (?v_108 (p1 c_2 c_0)) (?v_109 (p1 c_2 c_1)) (?v_110 (p1 c_2 c_2)) (?v_111 (p1 c_2 c_3)) (?v_112 (p1 c_3 c_0)) (?v_113 (p1 c_3 c_1)) (?v_114 (p1 c_3 c_2)) (?v_115 (p1 c_3 c_3)) (?v_117 (f5 c_0 c_0)) (?v_48 (not (p8 c_0))) (?v_116 (p6 c_0 c_0)) (?v_119 (f5 c_0 c_1)) (?v_118 (p6 c_0 c_1)) (?v_121 (f5 c_0 c_2)) (?v_120 (p6 c_0 c_2)) (?v_123 (f5 c_0 c_3)) (?v_122 (p6 c_0 c_3)) (?v_125 (f5 c_1 c_0)) (?v_49 (not (p8 c_1))) (?v_124 (p6 c_1 c_0)) (?v_127 (f5 c_1 c_1)) (?v_126 (p6 c_1 c_1)) (?v_129 (f5 c_1 c_2)) (?v_128 (p6 c_1 c_2)) (?v_131 (f5 c_1 c_3)) (?v_130 (p6 c_1 c_3)) (?v_133 (f5 c_2 c_0)) (?v_50 (not (p8 c_2))) (?v_132 (p6 c_2 c_0)) (?v_135 (f5 c_2 c_1)) (?v_134 (p6 c_2 c_1)) (?v_137 (f5 c_2 c_2)) (?v_136 (p6 c_2 c_2)) (?v_139 (f5 c_2 c_3)) (?v_138 (p6 c_2 c_3)) (?v_141 (f5 c_3 c_0)) (?v_51 (not (p8 c_3))) (?v_140 (p6 c_3 c_0)) (?v_143 (f5 c_3 c_1)) (?v_142 (p6 c_3 c_1)) (?v_145 (f5 c_3 c_2)) (?v_144 (p6 c_3 c_2)) (?v_147 (f5 c_3 c_3)) (?v_146 (p6 c_3 c_3))) (let ((?v_148 (not ?v_54)) (?v_152 (not ?v_66)) (?v_156 (not ?v_78)) (?v_160 (not ?v_90)) (?v_149 (not ?v_57)) (?v_153 (not ?v_69)) (?v_157 (not ?v_81)) (?v_161 (not ?v_93)) (?v_150 (not ?v_60)) (?v_154 (not ?v_72)) (?v_158 (not ?v_84)) (?v_162 (not ?v_96)) (?v_151 (not ?v_63)) (?v_155 (not ?v_75)) (?v_159 (not ?v_87)) (?v_163 (not ?v_99)) (?v_164 (p9 c_0 c_0))) (let ((?v_212 (not ?v_164)) (?v_196 (p7 c_0 c_0))) (let ((?v_165 (not ?v_196)) (?v_166 (p9 c_0 c_1))) (let ((?v_213 (not ?v_166)) (?v_197 (p7 c_0 c_1))) (let ((?v_167 (not ?v_197)) (?v_168 (p9 c_0 c_2))) (let ((?v_214 (not ?v_168)) (?v_198 (p7 c_0 c_2))) (let ((?v_169 (not ?v_198)) (?v_170 (p9 c_0 c_3))) (let ((?v_215 (not ?v_170)) (?v_199 (p7 c_0 c_3))) (let ((?v_171 (not ?v_199)) (?v_172 (p9 c_1 c_0))) (let ((?v_216 (not ?v_172)) (?v_200 (p7 c_1 c_0))) (let ((?v_173 (not ?v_200)) (?v_174 (p9 c_1 c_1))) (let ((?v_217 (not ?v_174)) (?v_201 (p7 c_1 c_1))) (let ((?v_175 (not ?v_201)) (?v_176 (p9 c_1 c_2))) (let ((?v_218 (not ?v_176)) (?v_202 (p7 c_1 c_2))) (let ((?v_177 (not ?v_202)) (?v_178 (p9 c_1 c_3))) (let ((?v_219 (not ?v_178)) (?v_203 (p7 c_1 c_3))) (let ((?v_179 (not ?v_203)) (?v_180 (p9 c_2 c_0))) (let ((?v_220 (not ?v_180)) (?v_204 (p7 c_2 c_0))) (let ((?v_181 (not ?v_204)) (?v_182 (p9 c_2 c_1))) (let ((?v_221 (not ?v_182)) (?v_205 (p7 c_2 c_1))) (let ((?v_183 (not ?v_205)) (?v_184 (p9 c_2 c_2))) (let ((?v_222 (not ?v_184)) (?v_206 (p7 c_2 c_2))) (let ((?v_185 (not ?v_206)) (?v_186 (p9 c_2 c_3))) (let ((?v_223 (not ?v_186)) (?v_207 (p7 c_2 c_3))) (let ((?v_187 (not ?v_207)) (?v_188 (p9 c_3 c_0))) (let ((?v_224 (not ?v_188)) (?v_208 (p7 c_3 c_0))) (let ((?v_189 (not ?v_208)) (?v_190 (p9 c_3 c_1))) (let ((?v_225 (not ?v_190)) (?v_209 (p7 c_3 c_1))) (let ((?v_191 (not ?v_209)) (?v_192 (p9 c_3 c_2))) (let ((?v_226 (not ?v_192)) (?v_210 (p7 c_3 c_2))) (let ((?v_193 (not ?v_210)) (?v_194 (p9 c_3 c_3))) (let ((?v_227 (not ?v_194)) (?v_211 (p7 c_3 c_3))) (let ((?v_195 (not ?v_211))) (and (distinct c_0 c_1 c_2 c_3) (p4 c14 c12) (p4 c14 c13) (or ?v_16 ?v_32) (or ?v_17 ?v_33) (or ?v_18 ?v_34) (or ?v_19 ?v_35) (or ?v_20 ?v_36) (or ?v_21 ?v_37) (or ?v_22 ?v_38) (or ?v_23 ?v_39) (or ?v_24 ?v_40) (or ?v_25 ?v_41) (or ?v_26 ?v_42) (or ?v_27 ?v_43) (or ?v_28 ?v_44) (or ?v_29 ?v_45) (or ?v_30 ?v_46) (or ?v_31 ?v_47) (or ?v_0 ?v_0) (or ?v_2 ?v_1) (or ?v_5 ?v_4) (or ?v_10 ?v_9) (or ?v_1 ?v_2) (or ?v_3 ?v_3) (or ?v_7 ?v_6) (or ?v_12 ?v_11) (or ?v_4 ?v_5) (or ?v_6 ?v_7) (or ?v_8 ?v_8) (or ?v_14 ?v_13) (or ?v_9 ?v_10) (or ?v_11 ?v_12) (or ?v_13 ?v_14) (or ?v_15 ?v_15) (not (p6 c15 c17)) (or ?v_0 ?v_54) (or ?v_2 ?v_66) (or ?v_5 ?v_78) (or ?v_10 ?v_90) (or ?v_1 ?v_57) (or ?v_3 ?v_69) (or ?v_7 ?v_81) (or ?v_12 ?v_93) (or ?v_4 ?v_60) (or ?v_6 ?v_72) (or ?v_8 ?v_84) (or ?v_14 ?v_96) (or ?v_9 ?v_63) (or ?v_11 ?v_75) (or ?v_13 ?v_87) (or ?v_15 ?v_99) (or ?v_100 ?v_16) (or ?v_101 ?v_17) (or ?v_102 ?v_18) (or ?v_103 ?v_19) (or ?v_104 ?v_20) (or ?v_105 ?v_21) (or ?v_106 ?v_22) (or ?v_107 ?v_23) (or ?v_108 ?v_24) (or ?v_109 ?v_25) (or ?v_110 ?v_26) (or ?v_111 ?v_27) (or ?v_112 ?v_28) (or ?v_113 ?v_29) (or ?v_114 ?v_30) (or ?v_115 ?v_31) (p4 c13 c11) (or ?v_0 ?v_32) (or ?v_2 ?v_33) (or ?v_5 ?v_34) (or ?v_10 ?v_35) (or ?v_1 ?v_36) (or ?v_3 ?v_37) (or ?v_7 ?v_38) (or ?v_12 ?v_39) (or ?v_4 ?v_40) (or ?v_6 ?v_41) (or ?v_8 ?v_42) (or ?v_14 ?v_43) (or ?v_9 ?v_44) (or ?v_11 ?v_45) (or ?v_13 ?v_46) (or ?v_15 ?v_47) (or (= ?v_117 c10) ?v_48 (not ?v_116)) (or (= ?v_119 c10) ?v_48 (not ?v_118)) (or (= ?v_121 c10) ?v_48 (not ?v_120)) (or (= ?v_123 c10) ?v_48 (not ?v_122)) (or (= ?v_125 c10) ?v_49 (not ?v_124)) (or (= ?v_127 c10) ?v_49 (not ?v_126)) (or (= ?v_129 c10) ?v_49 (not ?v_128)) (or (= ?v_131 c10) ?v_49 (not ?v_130)) (or (= ?v_133 c10) ?v_50 (not ?v_132)) (or (= ?v_135 c10) ?v_50 (not ?v_134)) (or (= ?v_137 c10) ?v_50 (not ?v_136)) (or (= ?v_139 c10) ?v_50 (not ?v_138)) (or (= ?v_141 c10) ?v_51 (not ?v_140)) (or (= ?v_143 c10) ?v_51 (not ?v_142)) (or (= ?v_145 c10) ?v_51 (not ?v_144)) (or (= ?v_147 c10) ?v_51 (not ?v_146)) (p6 c15 c16) (p8 c15) (not (p4 (f5 c15 c17) (f5 c15 c16))) (or ?v_52 ?v_53 ?v_54) (or ?v_55 ?v_56 ?v_57) (or ?v_58 ?v_59 ?v_60) (or ?v_61 ?v_62 ?v_63) (or ?v_64 ?v_65 ?v_66) (or ?v_67 ?v_68 ?v_69) (or ?v_70 ?v_71 ?v_72) (or ?v_73 ?v_74 ?v_75) (or ?v_76 ?v_77 ?v_78) (or ?v_79 ?v_80 ?v_81) (or ?v_82 ?v_83 ?v_84) (or ?v_85 ?v_86 ?v_87) (or ?v_88 ?v_89 ?v_90) (or ?v_91 ?v_92 ?v_93) (or ?v_94 ?v_95 ?v_96) (or ?v_97 ?v_98 ?v_99) (p4 c12 c11) (or ?v_52 (not ?v_100) ?v_54) (or ?v_55 (not ?v_101) ?v_57) (or ?v_58 (not ?v_102) ?v_60) (or ?v_61 (not ?v_103) ?v_63) (or ?v_64 (not ?v_104) ?v_66) (or ?v_67 (not ?v_105) ?v_69) (or ?v_70 (not ?v_106) ?v_72) (or ?v_73 (not ?v_107) ?v_75) (or ?v_76 (not ?v_108) ?v_78) (or ?v_79 (not ?v_109) ?v_81) (or ?v_82 (not ?v_110) ?v_84) (or ?v_85 (not ?v_111) ?v_87) (or ?v_88 (not ?v_112) ?v_90) (or ?v_91 (not ?v_113) ?v_93) (or ?v_94 (not ?v_114) ?v_96) (or ?v_97 (not ?v_115) ?v_99) (or ?v_53 ?v_148) (or ?v_56 ?v_152) (or ?v_59 ?v_156) (or ?v_62 ?v_160) (or ?v_65 ?v_149) (or ?v_68 ?v_153) (or ?v_71 ?v_157) (or ?v_74 ?v_161) (or ?v_77 ?v_150) (or ?v_80 ?v_154) (or ?v_83 ?v_158) (or ?v_86 ?v_162) (or ?v_89 ?v_151) (or ?v_92 ?v_155) (or ?v_95 ?v_159) (or ?v_98 ?v_163) (or ?v_52 ?v_53 (not ?v_32)) (or ?v_55 ?v_56 (not ?v_33)) (or ?v_58 ?v_59 (not ?v_34)) (or ?v_61 ?v_62 (not ?v_35)) (or ?v_64 ?v_65 (not ?v_36)) (or ?v_67 ?v_68 (not ?v_37)) (or ?v_70 ?v_71 (not ?v_38)) (or ?v_73 ?v_74 (not ?v_39)) (or ?v_76 ?v_77 (not ?v_40)) (or ?v_79 ?v_80 (not ?v_41)) (or ?v_82 ?v_83 (not ?v_42)) (or ?v_85 ?v_86 (not ?v_43)) (or ?v_88 ?v_89 (not ?v_44)) (or ?v_91 ?v_92 (not ?v_45)) (or ?v_94 ?v_95 (not ?v_46)) (or ?v_97 ?v_98 (not ?v_47)) (p4 c11 c10) (or ?v_0 ?v_53 ?v_0) (or ?v_0 ?v_56 ?v_2) (or ?v_0 ?v_59 ?v_5) (or ?v_0 ?v_62 ?v_10) (or ?v_2 ?v_53 ?v_1) (or ?v_2 ?v_56 ?v_3) (or ?v_2 ?v_59 ?v_7) (or ?v_2 ?v_62 ?v_12) (or ?v_5 ?v_53 ?v_4) (or ?v_5 ?v_56 ?v_6) (or ?v_5 ?v_59 ?v_8) (or ?v_5 ?v_62 ?v_14) (or ?v_10 ?v_53 ?v_9) (or ?v_10 ?v_56 ?v_11) (or ?v_10 ?v_59 ?v_13) (or ?v_10 ?v_62 ?v_15) (or ?v_1 ?v_65 ?v_0) (or ?v_1 ?v_68 ?v_2) (or ?v_1 ?v_71 ?v_5) (or ?v_1 ?v_74 ?v_10) (or ?v_3 ?v_65 ?v_1) (or ?v_3 ?v_68 ?v_3) (or ?v_3 ?v_71 ?v_7) (or ?v_3 ?v_74 ?v_12) (or ?v_7 ?v_65 ?v_4) (or ?v_7 ?v_68 ?v_6) (or ?v_7 ?v_71 ?v_8) (or ?v_7 ?v_74 ?v_14) (or ?v_12 ?v_65 ?v_9) (or ?v_12 ?v_68 ?v_11) (or ?v_12 ?v_71 ?v_13) (or ?v_12 ?v_74 ?v_15) (or ?v_4 ?v_77 ?v_0) (or ?v_4 ?v_80 ?v_2) (or ?v_4 ?v_83 ?v_5) (or ?v_4 ?v_86 ?v_10) (or ?v_6 ?v_77 ?v_1) (or ?v_6 ?v_80 ?v_3) (or ?v_6 ?v_83 ?v_7) (or ?v_6 ?v_86 ?v_12) (or ?v_8 ?v_77 ?v_4) (or ?v_8 ?v_80 ?v_6) (or ?v_8 ?v_83 ?v_8) (or ?v_8 ?v_86 ?v_14) (or ?v_14 ?v_77 ?v_9) (or ?v_14 ?v_80 ?v_11) (or ?v_14 ?v_83 ?v_13) (or ?v_14 ?v_86 ?v_15) (or ?v_9 ?v_89 ?v_0) (or ?v_9 ?v_92 ?v_2) (or ?v_9 ?v_95 ?v_5) (or ?v_9 ?v_98 ?v_10) (or ?v_11 ?v_89 ?v_1) (or ?v_11 ?v_92 ?v_3) (or ?v_11 ?v_95 ?v_7) (or ?v_11 ?v_98 ?v_12) (or ?v_13 ?v_89 ?v_4) (or ?v_13 ?v_92 ?v_6) (or ?v_13 ?v_95 ?v_8) (or ?v_13 ?v_98 ?v_14) (or ?v_15 ?v_89 ?v_9) (or ?v_15 ?v_92 ?v_11) (or ?v_15 ?v_95 ?v_13) (or ?v_15 ?v_98 ?v_15) (or ?v_212 ?v_116 ?v_48 ?v_165 (= ?v_117 c11)) (or ?v_213 ?v_118 ?v_48 ?v_167 (= ?v_119 c11)) (or ?v_214 ?v_120 ?v_48 ?v_169 (= ?v_121 c11)) (or ?v_215 ?v_122 ?v_48 ?v_171 (= ?v_123 c11)) (or ?v_216 ?v_124 ?v_49 ?v_173 (= ?v_125 c11)) (or ?v_217 ?v_126 ?v_49 ?v_175 (= ?v_127 c11)) (or ?v_218 ?v_128 ?v_49 ?v_177 (= ?v_129 c11)) (or ?v_219 ?v_130 ?v_49 ?v_179 (= ?v_131 c11)) (or ?v_220 ?v_132 ?v_50 ?v_181 (= ?v_133 c11)) (or ?v_221 ?v_134 ?v_50 ?v_183 (= ?v_135 c11)) (or ?v_222 ?v_136 ?v_50 ?v_185 (= ?v_137 c11)) (or ?v_223 ?v_138 ?v_50 ?v_187 (= ?v_139 c11)) (or ?v_224 ?v_140 ?v_51 ?v_189 (= ?v_141 c11)) (or ?v_225 ?v_142 ?v_51 ?v_191 (= ?v_143 c11)) (or ?v_226 ?v_144 ?v_51 ?v_193 (= ?v_145 c11)) (or ?v_227 ?v_146 ?v_51 ?v_195 (= ?v_147 c11)) (or ?v_148 ?v_100) (or ?v_149 ?v_101) (or ?v_150 ?v_102) (or ?v_151 ?v_103) (or ?v_152 ?v_104) (or ?v_153 ?v_105) (or ?v_154 ?v_106) (or ?v_155 ?v_107) (or ?v_156 ?v_108) (or ?v_157 ?v_109) (or ?v_158 ?v_110) (or ?v_159 ?v_111) (or ?v_160 ?v_112) (or ?v_161 ?v_113) (or ?v_162 ?v_114) (or ?v_163 ?v_115) (or ?v_116 (= ?v_117 c13) ?v_164 ?v_48 ?v_165) (or ?v_118 (= ?v_119 c13) ?v_166 ?v_48 ?v_167) (or ?v_120 (= ?v_121 c13) ?v_168 ?v_48 ?v_169) (or ?v_122 (= ?v_123 c13) ?v_170 ?v_48 ?v_171) (or ?v_124 (= ?v_125 c13) ?v_172 ?v_49 ?v_173) (or ?v_126 (= ?v_127 c13) ?v_174 ?v_49 ?v_175) (or ?v_128 (= ?v_129 c13) ?v_176 ?v_49 ?v_177) (or ?v_130 (= ?v_131 c13) ?v_178 ?v_49 ?v_179) (or ?v_132 (= ?v_133 c13) ?v_180 ?v_50 ?v_181) (or ?v_134 (= ?v_135 c13) ?v_182 ?v_50 ?v_183) (or ?v_136 (= ?v_137 c13) ?v_184 ?v_50 ?v_185) (or ?v_138 (= ?v_139 c13) ?v_186 ?v_50 ?v_187) (or ?v_140 (= ?v_141 c13) ?v_188 ?v_51 ?v_189) (or ?v_142 (= ?v_143 c13) ?v_190 ?v_51 ?v_191) (or ?v_144 (= ?v_145 c13) ?v_192 ?v_51 ?v_193) (or ?v_146 (= ?v_147 c13) ?v_194 ?v_51 ?v_195) (or (= ?v_117 c14) ?v_196 ?v_116 ?v_48 ?v_164) (or (= ?v_119 c14) ?v_197 ?v_118 ?v_48 ?v_166) (or (= ?v_121 c14) ?v_198 ?v_120 ?v_48 ?v_168) (or (= ?v_123 c14) ?v_199 ?v_122 ?v_48 ?v_170) (or (= ?v_125 c14) ?v_200 ?v_124 ?v_49 ?v_172) (or (= ?v_127 c14) ?v_201 ?v_126 ?v_49 ?v_174) (or (= ?v_129 c14) ?v_202 ?v_128 ?v_49 ?v_176) (or (= ?v_131 c14) ?v_203 ?v_130 ?v_49 ?v_178) (or (= ?v_133 c14) ?v_204 ?v_132 ?v_50 ?v_180) (or (= ?v_135 c14) ?v_205 ?v_134 ?v_50 ?v_182) (or (= ?v_137 c14) ?v_206 ?v_136 ?v_50 ?v_184) (or (= ?v_139 c14) ?v_207 ?v_138 ?v_50 ?v_186) (or (= ?v_141 c14) ?v_208 ?v_140 ?v_51 ?v_188) (or (= ?v_143 c14) ?v_209 ?v_142 ?v_51 ?v_190) (or (= ?v_145 c14) ?v_210 ?v_144 ?v_51 ?v_192) (or (= ?v_147 c14) ?v_211 ?v_146 ?v_51 ?v_194) (or ?v_116 ?v_212 ?v_196 (= ?v_117 c12) ?v_48) (or ?v_118 ?v_213 ?v_197 (= ?v_119 c12) ?v_48) (or ?v_120 ?v_214 ?v_198 (= ?v_121 c12) ?v_48) (or ?v_122 ?v_215 ?v_199 (= ?v_123 c12) ?v_48) (or ?v_124 ?v_216 ?v_200 (= ?v_125 c12) ?v_49) (or ?v_126 ?v_217 ?v_201 (= ?v_127 c12) ?v_49) (or ?v_128 ?v_218 ?v_202 (= ?v_129 c12) ?v_49) (or ?v_130 ?v_219 ?v_203 (= ?v_131 c12) ?v_49) (or ?v_132 ?v_220 ?v_204 (= ?v_133 c12) ?v_50) (or ?v_134 ?v_221 ?v_205 (= ?v_135 c12) ?v_50) (or ?v_136 ?v_222 ?v_206 (= ?v_137 c12) ?v_50) (or ?v_138 ?v_223 ?v_207 (= ?v_139 c12) ?v_50) (or ?v_140 ?v_224 ?v_208 (= ?v_141 c12) ?v_51) (or ?v_142 ?v_225 ?v_209 (= ?v_143 c12) ?v_51) (or ?v_144 ?v_226 ?v_210 (= ?v_145 c12) ?v_51) (or ?v_146 ?v_227 ?v_211 (= ?v_147 c12) ?v_51) (or (= ?v_117 c_0) (= ?v_117 c_1) (= ?v_117 c_2) (= ?v_117 c_3)) (or (= ?v_119 c_0) (= ?v_119 c_1) (= ?v_119 c_2) (= ?v_119 c_3)) (or (= ?v_121 c_0) (= ?v_121 c_1) (= ?v_121 c_2) (= ?v_121 c_3)) (or (= ?v_123 c_0) (= ?v_123 c_1) (= ?v_123 c_2) (= ?v_123 c_3)) (or (= ?v_125 c_0) (= ?v_125 c_1) (= ?v_125 c_2) (= ?v_125 c_3)) (or (= ?v_127 c_0) (= ?v_127 c_1) (= ?v_127 c_2) (= ?v_127 c_3)) (or (= ?v_129 c_0) (= ?v_129 c_1) (= ?v_129 c_2) (= ?v_129 c_3)) (or (= ?v_131 c_0) (= ?v_131 c_1) (= ?v_131 c_2) (= ?v_131 c_3)) (or (= ?v_133 c_0) (= ?v_133 c_1) (= ?v_133 c_2) (= ?v_133 c_3)) (or (= ?v_135 c_0) (= ?v_135 c_1) (= ?v_135 c_2) (= ?v_135 c_3)) (or (= ?v_137 c_0) (= ?v_137 c_1) (= ?v_137 c_2) (= ?v_137 c_3)) (or (= ?v_139 c_0) (= ?v_139 c_1) (= ?v_139 c_2) (= ?v_139 c_3)) (or (= ?v_141 c_0) (= ?v_141 c_1) (= ?v_141 c_2) (= ?v_141 c_3)) (or (= ?v_143 c_0) (= ?v_143 c_1) (= ?v_143 c_2) (= ?v_143 c_3)) (or (= ?v_145 c_0) (= ?v_145 c_1) (= ?v_145 c_2) (= ?v_145 c_3)) (or (= ?v_147 c_0) (= ?v_147 c_1) (= ?v_147 c_2) (= ?v_147 c_3)) (or (= c14 c_0) (= c14 c_1) (= c14 c_2) (= c14 c_3)) (or (= c12 c_0) (= c12 c_1) (= c12 c_2) (= c12 c_3)) (or (= c13 c_0) (= c13 c_1) (= c13 c_2) (= c13 c_3)) (or (= c15 c_0) (= c15 c_1) (= c15 c_2) (= c15 c_3)) (or (= c17 c_0) (= c17 c_1) (= c17 c_2) (= c17 c_3)) (or (= c11 c_0) (= c11 c_1) (= c11 c_2) (= c11 c_3)) (or (= c10 c_0) (= c10 c_1) (= c10 c_2) (= c10 c_3)) (or (= c16 c_0) (= c16 c_1) (= c16 c_2) (= c16 c_3)) ) ))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/NEQ004_size4.smt2.expected.err000066400000000000000000000000001445011647600234460ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/NEQ004_size4.smt2.expected.out000066400000000000000000000000061445011647600234730ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UF/NEQ004_size4.smt2.expected.time000066400000000000000000000000351445011647600236240ustar00rootroot00000000000000real 1.99 user 1.96 sys 0.03 opensmt-2.5.2/regression/QF_UF/NEQ004_size4_writestate.smt2.expected.err000066400000000000000000000000001445011647600257210ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/NEQ004_size4_writestate.smt2.expected.out000066400000000000000000000000001445011647600257400ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/NEQ004_size4_writestate.smt2.expected.time000066400000000000000000000000351445011647600260770ustar00rootroot00000000000000real 0.02 user 0.02 sys 0.00 opensmt-2.5.2/regression/QF_UF/QF_UF-2018-Goel-hwbench-QF_UF_Heap_ab_cti_max_simplified_0.smt2000066400000000000000000000014501445011647600313210ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort u3 0) (declare-sort u4 0) (declare-sort u1 0) (declare-sort u2 0) (declare-fun Concat1 (Bool u1) u2) (declare-fun Concat2 (u3 u4) u2) (declare-fun y0 () Bool) (declare-fun y1 () Bool) (declare-fun y2 () Bool) (declare-fun n00 () u4) (declare-fun n01 () u3) (declare-fun n02 () u1) (declare-fun n03 () u2) (declare-fun n11 () u3) (declare-fun n10 () u2) (declare-fun n40 () u2) (declare-fun nitems () u3) (declare-fun w18 () u2) (declare-fun w1 () u2) (declare-fun w3 () u2) (assert (distinct n01 n11)) (assert (distinct n03 n10 n40)) (assert (= w18 (Concat2 nitems n00))) (assert (= y0 (= n03 w18))) (assert (= w1 (Concat1 y0 n02))) (assert (= w3 (Concat1 false n02))) (assert (= n03 w3)) (assert (= y1 (not (= n10 w1)))) (assert (= y2 (not (= n40 w18)))) (check-sat) (exit) QF_UF-2018-Goel-hwbench-QF_UF_Heap_ab_cti_max_simplified_0.smt2.expected.err000066400000000000000000000000001445011647600336170ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFQF_UF-2018-Goel-hwbench-QF_UF_Heap_ab_cti_max_simplified_0.smt2.expected.out000066400000000000000000000000041445011647600336420ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFsat opensmt-2.5.2/regression/QF_UF/QF_UF-2018-Goel-hwbench-QF_UF_Heap_ab_reg_max_simplified_0.smt2000066400000000000000000000010611445011647600313150ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort utt$31 0) (declare-sort utt$32 0) (declare-fun Concat (Bool utt$31) utt$32) (declare-fun b1 () Bool) (declare-fun b2 () Bool) (declare-fun b3 () Bool) (declare-fun b4 () Bool) (declare-fun b5 () Bool) (declare-fun y0 () utt$31) (declare-fun y1 () utt$32) (declare-fun y2 () utt$32) (declare-fun y3 () utt$32) (declare-fun y4 () utt$32) (assert (= b2 (= y1 y3))) (assert (= y4 (Concat b2 y0))) (assert (= b3 (= y1 y4))) (assert (= (not (= y1 y2)) b4)) (assert (not (and b1 b4))) (assert (= b5 b1)) (assert b5) (check-sat) (exit) QF_UF-2018-Goel-hwbench-QF_UF_Heap_ab_reg_max_simplified_0.smt2.expected.err000066400000000000000000000000001445011647600336150ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFQF_UF-2018-Goel-hwbench-QF_UF_Heap_ab_reg_max_simplified_0.smt2.expected.out000066400000000000000000000000041445011647600336400ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFsat opensmt-2.5.2/regression/QF_UF/QF_UF-2018-Goel-hwbench-QF_UF_eq_sdp_v2_ab_reg_max_simplified_0.smt2000066400000000000000000000001761445011647600323300ustar00rootroot00000000000000(set-logic QF_UF) (declare-fun Add (Bool Bool) Bool) (declare-fun b () Bool) (assert (not (Add false b))) (check-sat) (exit) QF_UF-2018-Goel-hwbench-QF_UF_eq_sdp_v2_ab_reg_max_simplified_0.smt2.expected.err000066400000000000000000000000001445011647600346220ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFQF_UF-2018-Goel-hwbench-QF_UF_eq_sdp_v2_ab_reg_max_simplified_0.smt2.expected.out000066400000000000000000000000041445011647600346450ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFsat opensmt-2.5.2/regression/QF_UF/QF_UF-2018-Goel-hwbench-QF_UF_mpeg_ab_cti_max.smt2000066400000000000000000002072601445011647600267570ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_UF) (set-info :source | Generated by: Aman Goel (amangoel@umich.edu), Karem A. Sakallah (karem@umich.edu) Generated on: 2018-04-06 Generated by the tool Averroes 2 (successor of [1]) which implements safety property verification on hardware systems. This SMT problem belongs to a set of SMT problems generated by applying Averroes 2 to benchmarks derived from [2-5]. A total of 412 systems (345 from [2], 19 from [3], 26 from [4], 22 from [5]) were syntactically converted from their original formats (using [6, 7]), and given to Averroes 2 to perform property checking with abstraction (wide bit-vectors -> terms, wide operators -> UF) using SMT solvers [8, 9]. [1] Lee S., Sakallah K.A. (2014) Unbounded Scalable Verification Based on Approximate Property-Directed Reachability and Datapath Abstraction. In: Biere A., Bloem R. (eds) Computer Aided Verification. CAV 2014. Lecture Notes in Computer Science, vol 8559. Springer, Cham [2] http://fmv.jku.at/aiger/index.html#beem [3] http://www.cs.cmu.edu/~modelcheck/vcegar [4] http://www.cprover.org/hardware/v2c [5] http://github.com/aman-goel/verilogbench [6] http://www.clifford.at/yosys [7] http://github.com/chengyinwu/V3 [8] http://github.com/Z3Prover/z3 [9] http://github.com/SRI-CSL/yices2 id: mpeg query-maker: "Yices 2" query-time: 7.224000 ms query-class: abstract query-category: oneshot query-type: cti |) (set-info :license "https://creativecommons.org/licenses/by/4.0/") (set-info :category "industrial") ; (declare-sort utt$2 0) (declare-sort utt$3 0) (declare-sort utt$4 0) (declare-sort utt$7 0) (declare-sort utt$8 0) (declare-sort utt$12 0) (declare-sort utt$16 0) (declare-sort utt$24 0) (declare-sort utt$28 0) (declare-sort utt$29 0) (declare-sort utt$30 0) (declare-sort utt$31 0) (declare-sort utt$32 0) (declare-fun Add_32_32_32 (utt$32 utt$32 ) utt$32) (declare-fun Concat_16_4_12 (utt$4 utt$12 ) utt$16) (declare-fun Concat_16_8_8 (utt$8 utt$8 ) utt$16) (declare-fun Concat_32_16_16 (utt$16 utt$16 ) utt$32) (declare-fun Concat_32_1_31 (Bool utt$31 ) utt$32) (declare-fun Concat_32_2_30 (utt$2 utt$30 ) utt$32) (declare-fun Concat_32_3_29 (utt$3 utt$29 ) utt$32) (declare-fun Concat_32_4_28 (utt$4 utt$28 ) utt$32) (declare-fun Concat_32_8_24 (utt$8 utt$24 ) utt$32) (declare-fun Concat_8_7_1 (utt$7 Bool ) utt$8) (declare-fun Extract_16_15_0_32 (utt$32 ) utt$16) (declare-fun Extract_1_0_0_8 (utt$8 ) Bool) (declare-fun Extract_2_1_0_32 (utt$32 ) utt$2) (declare-fun Extract_2_1_0_8 (utt$8 ) utt$2) (declare-fun Extract_3_2_0_32 (utt$32 ) utt$3) (declare-fun Extract_4_3_0_8 (utt$8 ) utt$4) (declare-fun Extract_7_7_1_8 (utt$8 ) utt$7) (declare-fun Extract_8_15_8_16 (utt$16 ) utt$8) (declare-fun Extract_8_7_0_16 (utt$16 ) utt$8) (declare-fun Gr_1_32_32 (utt$32 utt$32 ) Bool) (declare-fun Sub_16_16_16 (utt$16 utt$16 ) utt$16) (declare-fun Sub_32_32_32 (utt$32 utt$32 ) utt$32) (declare-fun y$1002 () Bool) (declare-fun y$1022 () Bool) (declare-fun y$1023 () Bool) (declare-fun y$1025 () Bool) (declare-fun y$1028 () Bool) (declare-fun y$1036 () Bool) (declare-fun y$1037 () Bool) (declare-fun y$104 () Bool) (declare-fun y$1040 () Bool) (declare-fun y$1043 () Bool) (declare-fun y$1046 () Bool) (declare-fun y$1047 () Bool) (declare-fun y$1049 () Bool) (declare-fun y$1051 () Bool) (declare-fun y$1059 () Bool) (declare-fun y$1060 () Bool) (declare-fun y$1061 () Bool) (declare-fun y$1062 () Bool) (declare-fun y$1063 () Bool) (declare-fun y$1064 () Bool) (declare-fun y$1072 () Bool) (declare-fun y$108 () Bool) (declare-fun y$1080 () Bool) (declare-fun y$1081 () Bool) (declare-fun y$1082 () Bool) (declare-fun y$1083 () Bool) (declare-fun y$1084 () Bool) (declare-fun y$1092 () Bool) (declare-fun y$1093 () Bool) (declare-fun y$1094 () Bool) (declare-fun y$1095 () Bool) (declare-fun y$1096 () Bool) (declare-fun y$11 () Bool) (declare-fun y$1115 () Bool) (declare-fun y$1121 () Bool) (declare-fun y$113 () Bool) (declare-fun y$119 () Bool) (declare-fun y$121 () utt$7) (declare-fun y$1225 () Bool) (declare-fun y$126 () Bool) (declare-fun y$129 () Bool) (declare-fun y$13 () Bool) (declare-fun y$1308 () Bool) (declare-fun y$1309 () Bool) (declare-fun y$1310 () Bool) (declare-fun y$1315 () Bool) (declare-fun y$1317 () Bool) (declare-fun y$1318 () Bool) (declare-fun y$1319 () Bool) (declare-fun y$1320 () Bool) (declare-fun y$1331 () Bool) (declare-fun y$1332 () Bool) (declare-fun y$1333 () Bool) (declare-fun y$1334 () Bool) (declare-fun y$1335 () Bool) (declare-fun y$1336 () utt$7) (declare-fun y$1340 () Bool) (declare-fun y$1342 () Bool) (declare-fun y$1343 () Bool) (declare-fun y$1349 () Bool) (declare-fun y$135 () utt$3) (declare-fun y$1353 () Bool) (declare-fun y$1354 () Bool) (declare-fun y$1355 () Bool) (declare-fun y$1361 () Bool) (declare-fun y$1362 () Bool) (declare-fun y$1363 () Bool) (declare-fun y$1364 () Bool) (declare-fun y$1365 () Bool) (declare-fun y$1371 () Bool) (declare-fun y$1375 () Bool) (declare-fun y$1376 () Bool) (declare-fun y$1377 () Bool) (declare-fun y$139 () Bool) (declare-fun y$143 () Bool) (declare-fun y$147 () Bool) (declare-fun y$149 () Bool) (declare-fun y$15 () Bool) (declare-fun y$151 () Bool) (declare-fun y$164 () Bool) (declare-fun y$167 () Bool) (declare-fun y$17 () Bool) (declare-fun y$170 () Bool) (declare-fun y$179 () Bool) (declare-fun y$19 () Bool) (declare-fun y$190 () Bool) (declare-fun y$2 () Bool) (declare-fun y$21 () Bool) (declare-fun y$211 () Bool) (declare-fun y$215 () Bool) (declare-fun y$217 () Bool) (declare-fun y$219 () Bool) (declare-fun y$221 () Bool) (declare-fun y$222 () Bool) (declare-fun y$237 () Bool) (declare-fun y$24 () Bool) (declare-fun y$243 () utt$3) (declare-fun y$255 () Bool) (declare-fun y$259 () Bool) (declare-fun y$26 () Bool) (declare-fun y$260 () Bool) (declare-fun y$261 () Bool) (declare-fun y$263 () Bool) (declare-fun y$278 () Bool) (declare-fun y$28 () Bool) (declare-fun y$280 () Bool) (declare-fun y$292 () Bool) (declare-fun y$301 () Bool) (declare-fun y$31 () Bool) (declare-fun y$320 () Bool) (declare-fun y$325 () Bool) (declare-fun y$326 () Bool) (declare-fun y$329 () Bool) (declare-fun y$332 () Bool) (declare-fun y$333 () Bool) (declare-fun y$334 () Bool) (declare-fun y$335 () Bool) (declare-fun y$34 () Bool) (declare-fun y$352 () Bool) (declare-fun y$355 () Bool) (declare-fun y$359 () Bool) (declare-fun y$36 () Bool) (declare-fun y$361 () Bool) (declare-fun y$363 () Bool) (declare-fun y$365 () Bool) (declare-fun y$367 () Bool) (declare-fun y$371 () Bool) (declare-fun y$373 () Bool) (declare-fun y$38 () Bool) (declare-fun y$4 () Bool) (declare-fun y$40 () Bool) (declare-fun y$400 () Bool) (declare-fun y$406 () utt$3) (declare-fun y$418 () Bool) (declare-fun y$42 () Bool) (declare-fun y$420 () Bool) (declare-fun y$423 () Bool) (declare-fun y$431 () utt$2) (declare-fun y$449 () Bool) (declare-fun y$45 () Bool) (declare-fun y$463 () Bool) (declare-fun y$466 () Bool) (declare-fun y$468 () Bool) (declare-fun y$47 () Bool) (declare-fun y$470 () Bool) (declare-fun y$472 () Bool) (declare-fun y$474 () Bool) (declare-fun y$481 () Bool) (declare-fun y$49 () Bool) (declare-fun y$498 () Bool) (declare-fun y$504 () Bool) (declare-fun y$512 () Bool) (declare-fun y$52 () Bool) (declare-fun y$54 () Bool) (declare-fun y$541 () Bool) (declare-fun y$542 () utt$2) (declare-fun y$544 () Bool) (declare-fun y$56 () Bool) (declare-fun y$562 () Bool) (declare-fun y$564 () Bool) (declare-fun y$568 () Bool) (declare-fun y$575 () Bool) (declare-fun y$578 () Bool) (declare-fun y$58 () Bool) (declare-fun y$580 () Bool) (declare-fun y$582 () Bool) (declare-fun y$60 () Bool) (declare-fun y$601 () Bool) (declare-fun y$614 () Bool) (declare-fun y$63 () Bool) (declare-fun y$642 () Bool) (declare-fun y$65 () Bool) (declare-fun y$665 () Bool) (declare-fun y$67 () Bool) (declare-fun y$687 () Bool) (declare-fun y$689 () utt$8) (declare-fun y$69 () Bool) (declare-fun y$693 () utt$8) (declare-fun y$699 () Bool) (declare-fun y$7 () Bool) (declare-fun y$735 () Bool) (declare-fun y$741 () utt$16) (declare-fun y$76 () Bool) (declare-fun y$773 () Bool) (declare-fun y$80 () Bool) (declare-fun y$801 () Bool) (declare-fun y$803 () Bool) (declare-fun y$805 () Bool) (declare-fun y$817 () Bool) (declare-fun y$818 () Bool) (declare-fun y$833 () Bool) (declare-fun y$834 () Bool) (declare-fun y$853 () Bool) (declare-fun y$86 () Bool) (declare-fun y$867 () Bool) (declare-fun y$869 () Bool) (declare-fun y$870 () Bool) (declare-fun y$871 () Bool) (declare-fun y$873 () Bool) (declare-fun y$877 () Bool) (declare-fun y$879 () Bool) (declare-fun y$881 () Bool) (declare-fun y$883 () Bool) (declare-fun y$9 () Bool) (declare-fun y$90 () Bool) (declare-fun y$904 () Bool) (declare-fun y$905 () Bool) (declare-fun y$906 () Bool) (declare-fun y$907 () Bool) (declare-fun y$916 () Bool) (declare-fun y$926 () Bool) (declare-fun y$927 () Bool) (declare-fun y$932 () Bool) (declare-fun y$935 () Bool) (declare-fun y$939 () Bool) (declare-fun y$940 () utt$4) (declare-fun y$942 () Bool) (declare-fun y$943 () Bool) (declare-fun y$95 () Bool) (declare-fun y$978 () Bool) (declare-fun y$99 () Bool) (declare-fun y$input_stream () Bool) (declare-fun y$input_stream$next () Bool) (declare-fun y$mod1.output_buffer () utt$8) (declare-fun y$mod1.output_buffer$next () utt$8) (declare-fun y$mod1.output_buffer$next_rhs () utt$8) (declare-fun y$mod1.output_buffer$next_rhs$next () utt$8) (declare-fun y$mod1.output_buffer$next_rhs$next_op () utt$8) (declare-fun y$mod1.output_buffer$next_rhs_op () utt$8) (declare-fun y$mod2.count_over () Bool) (declare-fun y$mod2.count_over$next () Bool) (declare-fun y$mod2.count_over$next_rhs () Bool) (declare-fun y$mod2.count_over$next_rhs_op () Bool) (declare-fun y$mod2.count_value () utt$3) (declare-fun y$mod2.count_value$next () utt$3) (declare-fun y$mod2.count_value$next_rhs () utt$3) (declare-fun y$mod2.count_value$next_rhs_op () utt$3) (declare-fun y$mod3.state () utt$3) (declare-fun y$mod3.state$next () utt$3) (declare-fun y$mod3.state$next_rhs () utt$3) (declare-fun y$mod3.state$next_rhs_op () utt$3) (declare-fun y$mod3.stop () Bool) (declare-fun y$mod3.stop$next () Bool) (declare-fun y$mod3.stop$next_rhs () Bool) (declare-fun y$mod3.stop$next_rhs_op () Bool) (declare-fun y$mod4.count () utt$3) (declare-fun y$mod4.count$next () utt$3) (declare-fun y$mod4.count$next_rhs () utt$3) (declare-fun y$mod4.count$next_rhs_op () utt$3) (declare-fun y$mod4.stop () Bool) (declare-fun y$mod4.stop$next () Bool) (declare-fun y$mod4.stop$next_rhs () Bool) (declare-fun y$mod4.stop$next_rhs_op () Bool) (declare-fun y$mod5.state () utt$3) (declare-fun y$mod5.state$next () utt$3) (declare-fun y$mod5.state$next_rhs () utt$3) (declare-fun y$mod5.state$next_rhs_op () utt$3) (declare-fun y$mod5.stop () Bool) (declare-fun y$mod5.stop$next () Bool) (declare-fun y$mod5.stop$next_rhs () Bool) (declare-fun y$mod5.stop$next_rhs_op () Bool) (declare-fun y$mod6.count () utt$3) (declare-fun y$mod6.count$next () utt$3) (declare-fun y$mod6.count$next_rhs () utt$3) (declare-fun y$mod6.count$next_rhs_op () utt$3) (declare-fun y$mod6.count1 () utt$2) (declare-fun y$mod6.count1$next () utt$2) (declare-fun y$mod6.count1$next_rhs () utt$2) (declare-fun y$mod6.count1$next_rhs_op () utt$2) (declare-fun y$mod6.flag () Bool) (declare-fun y$mod6.flag$next () Bool) (declare-fun y$mod6.flag$next_rhs () Bool) (declare-fun y$mod6.flag$next_rhs_op () Bool) (declare-fun y$mod6.stop () Bool) (declare-fun y$mod6.stop$next () Bool) (declare-fun y$mod6.stop$next_rhs () Bool) (declare-fun y$mod6.stop$next_rhs_op () Bool) (declare-fun y$mod6.stream_id_temp () utt$8) (declare-fun y$mod6.stream_id_temp$next () utt$8) (declare-fun y$mod6.stream_id_temp$next_rhs () utt$8) (declare-fun y$mod6.stream_id_temp$next_rhs_op () utt$8) (declare-fun y$mod7.NumBytes () utt$16) (declare-fun y$mod7.NumBytes$next () utt$16) (declare-fun y$mod7.NumBytes$next_rhs () utt$16) (declare-fun y$mod7.NumBytes$next_rhs_op () utt$16) (declare-fun y$mod7.done () Bool) (declare-fun y$mod7.done$next () Bool) (declare-fun y$mod7.done$next_rhs () Bool) (declare-fun y$mod7.done$next_rhs_op () Bool) (declare-fun y$mod7.module1.done () Bool) (declare-fun y$mod7.module1.done$next () Bool) (declare-fun y$mod7.module1.done$next_rhs () Bool) (declare-fun y$mod7.module1.done$next_rhs_op () Bool) (declare-fun y$mod7.module1.state () utt$2) (declare-fun y$mod7.module1.state$next () utt$2) (declare-fun y$mod7.module1.state$next_rhs () utt$2) (declare-fun y$mod7.module1.state$next_rhs_op () utt$2) (declare-fun y$mod7.module2.done () Bool) (declare-fun y$mod7.module2.done$next () Bool) (declare-fun y$mod7.module2.done$next_rhs () Bool) (declare-fun y$mod7.module2.done$next_rhs_op () Bool) (declare-fun y$mod7.module2.state () utt$4) (declare-fun y$mod7.module2.state$next () utt$4) (declare-fun y$mod7.module2.state$next_rhs () utt$4) (declare-fun y$mod7.module2.state$next_rhs_op () utt$4) (declare-fun y$mod7.module2.timeBytes () utt$4) (declare-fun y$mod7.module2.timeBytes$next () utt$4) (declare-fun y$mod7.module2.timeBytes$next_rhs () utt$4) (declare-fun y$mod7.module2.timeBytes$next_rhs_op () utt$4) (declare-fun y$mod7.packet_length () utt$16) (declare-fun y$mod7.packet_length$next () utt$16) (declare-fun y$mod7.packet_length$next_rhs () utt$16) (declare-fun y$mod7.packet_length$next_rhs_op () utt$16) (declare-fun y$mod7.state () utt$4) (declare-fun y$mod7.state$next () utt$4) (declare-fun y$mod7.state$next_rhs () utt$4) (declare-fun y$mod7.state$next_rhs_op () utt$4) (declare-fun y$mod7.stream_done () Bool) (declare-fun y$mod7.stream_id () utt$8) (declare-fun y$mod7.stream_id$next () utt$8) (declare-fun y$mod7.stream_id$next_rhs () utt$8) (declare-fun y$mod7.stream_id$next_rhs_op () utt$8) (declare-fun y$mod7.timeStampFlag () Bool) (declare-fun y$mod7.timeStampFlag$next () Bool) (declare-fun y$mod7.timeStampFlag$next_rhs () Bool) (declare-fun y$mod7.timeStampFlag$next_rhs_op () Bool) (declare-fun y$mod7.time_stamp_start () Bool) (declare-fun y$mod7.time_stamp_start$next () Bool) (declare-fun y$mod7.time_stamp_start$next_rhs () Bool) (declare-fun y$mod7.time_stamp_start$next_rhs_op () Bool) (declare-fun y$n0s1 () Bool) (declare-fun y$n0s12 () utt$12) (declare-fun y$n0s16 () utt$16) (declare-fun y$n0s2 () utt$2) (declare-fun y$n0s24 () utt$24) (declare-fun y$n0s28 () utt$28) (declare-fun y$n0s29 () utt$29) (declare-fun y$n0s3 () utt$3) (declare-fun y$n0s30 () utt$30) (declare-fun y$n0s31 () utt$31) (declare-fun y$n0s32 () utt$32) (declare-fun y$n0s4 () utt$4) (declare-fun y$n0s8 () utt$8) (declare-fun y$n10s4 () utt$4) (declare-fun y$n11s4 () utt$4) (declare-fun y$n128s8 () utt$8) (declare-fun y$n12s4 () utt$4) (declare-fun y$n131s8 () utt$8) (declare-fun y$n13s4 () utt$4) (declare-fun y$n15s4 () utt$4) (declare-fun y$n15s8 () utt$8) (declare-fun y$n185s8 () utt$8) (declare-fun y$n186s8 () utt$8) (declare-fun y$n191s8 () utt$8) (declare-fun y$n195s8 () utt$8) (declare-fun y$n1s1 () Bool) (declare-fun y$n1s2 () utt$2) (declare-fun y$n1s3 () utt$3) (declare-fun y$n1s32 () utt$32) (declare-fun y$n1s4 () utt$4) (declare-fun y$n1s8 () utt$8) (declare-fun y$n221s8 () utt$8) (declare-fun y$n255s8 () utt$8) (declare-fun y$n2s2 () utt$2) (declare-fun y$n2s3 () utt$3) (declare-fun y$n2s4 () utt$4) (declare-fun y$n3s2 () utt$2) (declare-fun y$n3s3 () utt$3) (declare-fun y$n3s4 () utt$4) (declare-fun y$n3s8 () utt$8) (declare-fun y$n4s3 () utt$3) (declare-fun y$n4s4 () utt$4) (declare-fun y$n5s3 () utt$3) (declare-fun y$n5s4 () utt$4) (declare-fun y$n67s8 () utt$8) (declare-fun y$n6s3 () utt$3) (declare-fun y$n6s4 () utt$4) (declare-fun y$n7s3 () utt$3) (declare-fun y$n7s4 () utt$4) (declare-fun y$n7s8 () utt$8) (declare-fun y$n8s4 () utt$4) (declare-fun y$n93s8 () utt$8) (declare-fun y$n9s4 () utt$4) (declare-fun y$packHeadStart () Bool) (declare-fun y$packHeadStart$next () Bool) (declare-fun y$packHeadStart$next_rhs () Bool) (declare-fun y$packHeadStart$next_rhs_op () Bool) (declare-fun y$packParseStart () Bool) (declare-fun y$packParseStart$next () Bool) (declare-fun y$packParseStart$next_rhs () Bool) (declare-fun y$packParseStart$next_rhs_op () Bool) (declare-fun y$packetStart () Bool) (declare-fun y$packetStart$next () Bool) (declare-fun y$packetStart$next_rhs () Bool) (declare-fun y$packetStart$next_rhs_op () Bool) (declare-fun y$prop () Bool) (declare-fun y$prop$next () Bool) (declare-fun y$prop0 () Bool) (declare-fun y$prop0$next () Bool) (declare-fun y$prop0$next_op () Bool) (declare-fun y$prop0_op () Bool) (declare-fun y$s$110 () utt$3) (declare-fun y$s$110_op () utt$3) (declare-fun y$s$111 () Bool) (declare-fun y$s$111_op () Bool) (declare-fun y$s$112 () utt$3) (declare-fun y$s$112_op () utt$3) (declare-fun y$s$113 () Bool) (declare-fun y$s$113_op () Bool) (declare-fun y$s$114 () utt$3) (declare-fun y$s$114_op () utt$3) (declare-fun y$s$115 () utt$3) (declare-fun y$s$115_op () utt$3) (declare-fun y$s$116 () utt$3) (declare-fun y$s$116_op () utt$3) (declare-fun y$s$117 () Bool) (declare-fun y$s$117_op () Bool) (declare-fun y$s$118 () utt$3) (declare-fun y$s$118_op () utt$3) (declare-fun y$s$119 () utt$3) (declare-fun y$s$119_op () utt$3) (declare-fun y$s$120 () utt$3) (declare-fun y$s$120_op () utt$3) (declare-fun y$s$121 () utt$3) (declare-fun y$s$121_op () utt$3) (declare-fun y$s$122 () utt$3) (declare-fun y$s$122_op () utt$3) (declare-fun y$s$123 () utt$3) (declare-fun y$s$123_op () utt$3) (declare-fun y$s$124 () Bool) (declare-fun y$s$124_op () Bool) (declare-fun y$s$125 () Bool) (declare-fun y$s$125_op () Bool) (declare-fun y$s$127 () Bool) (declare-fun y$s$127_op () Bool) (declare-fun y$s$129 () Bool) (declare-fun y$s$129_op () Bool) (declare-fun y$s$133 () utt$3) (declare-fun y$s$133_op () utt$3) (declare-fun y$s$135 () utt$3) (declare-fun y$s$135_op () utt$3) (declare-fun y$s$137 () utt$3) (declare-fun y$s$137_op () utt$3) (declare-fun y$s$139 () utt$3) (declare-fun y$s$139_op () utt$3) (declare-fun y$s$141 () utt$3) (declare-fun y$s$141_op () utt$3) (declare-fun y$s$143 () utt$3) (declare-fun y$s$143_op () utt$3) (declare-fun y$s$145 () utt$3) (declare-fun y$s$145_op () utt$3) (declare-fun y$s$158 () Bool) (declare-fun y$s$158_op () Bool) (declare-fun y$s$159 () utt$2) (declare-fun y$s$159_op () utt$2) (declare-fun y$s$160 () utt$3) (declare-fun y$s$160_op () utt$3) (declare-fun y$s$161 () Bool) (declare-fun y$s$161_op () Bool) (declare-fun y$s$162 () Bool) (declare-fun y$s$162_op () Bool) (declare-fun y$s$163 () utt$8) (declare-fun y$s$163_op () utt$8) (declare-fun y$s$164 () utt$2) (declare-fun y$s$164_op () utt$2) (declare-fun y$s$165 () Bool) (declare-fun y$s$165_op () Bool) (declare-fun y$s$166 () utt$8) (declare-fun y$s$166_op () utt$8) (declare-fun y$s$167 () Bool) (declare-fun y$s$167_op () Bool) (declare-fun y$s$17 () utt$32) (declare-fun y$s$174 () utt$32) (declare-fun y$s$174_op () utt$32) (declare-fun y$s$176 () utt$32) (declare-fun y$s$176_op () utt$32) (declare-fun y$s$177 () Bool) (declare-fun y$s$177_op () Bool) (declare-fun y$s$179 () Bool) (declare-fun y$s$179_op () Bool) (declare-fun y$s$17_op () utt$32) (declare-fun y$s$180 () Bool) (declare-fun y$s$180_op () Bool) (declare-fun y$s$183 () Bool) (declare-fun y$s$183_op () Bool) (declare-fun y$s$187 () Bool) (declare-fun y$s$187_op () Bool) (declare-fun y$s$188 () Bool) (declare-fun y$s$188_op () Bool) (declare-fun y$s$189 () Bool) (declare-fun y$s$189_op () Bool) (declare-fun y$s$190 () utt$2) (declare-fun y$s$190_op () utt$2) (declare-fun y$s$191 () utt$2) (declare-fun y$s$191_op () utt$2) (declare-fun y$s$192 () utt$2) (declare-fun y$s$192_op () utt$2) (declare-fun y$s$193 () Bool) (declare-fun y$s$193_op () Bool) (declare-fun y$s$195 () Bool) (declare-fun y$s$195_op () Bool) (declare-fun y$s$199 () Bool) (declare-fun y$s$199_op () Bool) (declare-fun y$s$200 () utt$3) (declare-fun y$s$200_op () utt$3) (declare-fun y$s$202 () utt$3) (declare-fun y$s$202_op () utt$3) (declare-fun y$s$205 () utt$3) (declare-fun y$s$206 () utt$3) (declare-fun y$s$206_op () utt$3) (declare-fun y$s$21 () utt$3) (declare-fun y$s$213 () Bool) (declare-fun y$s$213_op () Bool) (declare-fun y$s$214 () Bool) (declare-fun y$s$214_op () Bool) (declare-fun y$s$21_op () utt$3) (declare-fun y$s$22 () Bool) (declare-fun y$s$220 () Bool) (declare-fun y$s$220_op () Bool) (declare-fun y$s$222 () Bool) (declare-fun y$s$222_op () Bool) (declare-fun y$s$223 () utt$8) (declare-fun y$s$223_op () utt$8) (declare-fun y$s$225 () utt$8) (declare-fun y$s$225_op () utt$8) (declare-fun y$s$229 () utt$2) (declare-fun y$s$229_op () utt$2) (declare-fun y$s$22_op () Bool) (declare-fun y$s$23 () utt$3) (declare-fun y$s$230 () Bool) (declare-fun y$s$230_op () Bool) (declare-fun y$s$232 () Bool) (declare-fun y$s$232_op () Bool) (declare-fun y$s$233 () utt$8) (declare-fun y$s$233_op () utt$8) (declare-fun y$s$234 () utt$2) (declare-fun y$s$234_op () utt$2) (declare-fun y$s$235 () Bool) (declare-fun y$s$235_op () Bool) (declare-fun y$s$23_op () utt$3) (declare-fun y$s$24 () Bool) (declare-fun y$s$24_op () Bool) (declare-fun y$s$25 () utt$3) (declare-fun y$s$258 () utt$4) (declare-fun y$s$258_op () utt$4) (declare-fun y$s$259 () utt$4) (declare-fun y$s$259_op () utt$4) (declare-fun y$s$25_op () utt$3) (declare-fun y$s$26 () utt$3) (declare-fun y$s$260 () utt$4) (declare-fun y$s$260_op () utt$4) (declare-fun y$s$261 () utt$4) (declare-fun y$s$261_op () utt$4) (declare-fun y$s$262 () utt$4) (declare-fun y$s$262_op () utt$4) (declare-fun y$s$263 () utt$16) (declare-fun y$s$263_op () utt$16) (declare-fun y$s$264 () Bool) (declare-fun y$s$264_op () Bool) (declare-fun y$s$265 () utt$4) (declare-fun y$s$265_op () utt$4) (declare-fun y$s$266 () Bool) (declare-fun y$s$266_op () Bool) (declare-fun y$s$267 () utt$8) (declare-fun y$s$267_op () utt$8) (declare-fun y$s$268 () Bool) (declare-fun y$s$268_op () Bool) (declare-fun y$s$269 () Bool) (declare-fun y$s$269_op () Bool) (declare-fun y$s$26_op () utt$3) (declare-fun y$s$27 () utt$3) (declare-fun y$s$270 () utt$16) (declare-fun y$s$270_op () utt$16) (declare-fun y$s$271 () Bool) (declare-fun y$s$271_op () Bool) (declare-fun y$s$272 () utt$4) (declare-fun y$s$272_op () utt$4) (declare-fun y$s$273 () Bool) (declare-fun y$s$273_op () Bool) (declare-fun y$s$274 () utt$8) (declare-fun y$s$274_op () utt$8) (declare-fun y$s$275 () Bool) (declare-fun y$s$275_op () Bool) (declare-fun y$s$276 () Bool) (declare-fun y$s$276_op () Bool) (declare-fun y$s$277 () utt$16) (declare-fun y$s$277_op () utt$16) (declare-fun y$s$278 () Bool) (declare-fun y$s$278_op () Bool) (declare-fun y$s$279 () utt$4) (declare-fun y$s$279_op () utt$4) (declare-fun y$s$27_op () utt$3) (declare-fun y$s$28 () Bool) (declare-fun y$s$280 () Bool) (declare-fun y$s$280_op () Bool) (declare-fun y$s$281 () utt$8) (declare-fun y$s$281_op () utt$8) (declare-fun y$s$282 () Bool) (declare-fun y$s$282_op () Bool) (declare-fun y$s$283 () Bool) (declare-fun y$s$283_op () Bool) (declare-fun y$s$284 () utt$16) (declare-fun y$s$284_op () utt$16) (declare-fun y$s$285 () Bool) (declare-fun y$s$285_op () Bool) (declare-fun y$s$286 () utt$4) (declare-fun y$s$286_op () utt$4) (declare-fun y$s$287 () Bool) (declare-fun y$s$287_op () Bool) (declare-fun y$s$288 () Bool) (declare-fun y$s$288_op () Bool) (declare-fun y$s$289 () utt$4) (declare-fun y$s$289_op () utt$4) (declare-fun y$s$28_op () Bool) (declare-fun y$s$29 () utt$3) (declare-fun y$s$290 () Bool) (declare-fun y$s$290_op () Bool) (declare-fun y$s$291 () utt$4) (declare-fun y$s$291_op () utt$4) (declare-fun y$s$292 () utt$4) (declare-fun y$s$292_op () utt$4) (declare-fun y$s$293 () utt$4) (declare-fun y$s$293_op () utt$4) (declare-fun y$s$294 () Bool) (declare-fun y$s$294_op () Bool) (declare-fun y$s$295 () Bool) (declare-fun y$s$295_op () Bool) (declare-fun y$s$296 () Bool) (declare-fun y$s$296_op () Bool) (declare-fun y$s$297 () Bool) (declare-fun y$s$297_op () Bool) (declare-fun y$s$298 () Bool) (declare-fun y$s$298_op () Bool) (declare-fun y$s$29_op () utt$3) (declare-fun y$s$30 () utt$3) (declare-fun y$s$300 () utt$4) (declare-fun y$s$300_op () utt$4) (declare-fun y$s$301 () utt$4) (declare-fun y$s$301_op () utt$4) (declare-fun y$s$302 () utt$4) (declare-fun y$s$302_op () utt$4) (declare-fun y$s$303 () utt$4) (declare-fun y$s$303_op () utt$4) (declare-fun y$s$304 () utt$4) (declare-fun y$s$304_op () utt$4) (declare-fun y$s$305 () utt$4) (declare-fun y$s$305_op () utt$4) (declare-fun y$s$306 () utt$4) (declare-fun y$s$306_op () utt$4) (declare-fun y$s$307 () utt$4) (declare-fun y$s$307_op () utt$4) (declare-fun y$s$308 () Bool) (declare-fun y$s$308_op () Bool) (declare-fun y$s$309 () Bool) (declare-fun y$s$309_op () Bool) (declare-fun y$s$30_op () utt$3) (declare-fun y$s$31 () utt$3) (declare-fun y$s$310 () utt$16) (declare-fun y$s$310_op () utt$16) (declare-fun y$s$311 () utt$16) (declare-fun y$s$311_op () utt$16) (declare-fun y$s$312 () utt$16) (declare-fun y$s$312_op () utt$16) (declare-fun y$s$313 () utt$16) (declare-fun y$s$313_op () utt$16) (declare-fun y$s$314 () Bool) (declare-fun y$s$314_op () Bool) (declare-fun y$s$315 () Bool) (declare-fun y$s$315_op () Bool) (declare-fun y$s$316 () Bool) (declare-fun y$s$316_op () Bool) (declare-fun y$s$317 () Bool) (declare-fun y$s$317_op () Bool) (declare-fun y$s$31_op () utt$3) (declare-fun y$s$32 () utt$3) (declare-fun y$s$328 () Bool) (declare-fun y$s$328_op () Bool) (declare-fun y$s$329 () Bool) (declare-fun y$s$329_op () Bool) (declare-fun y$s$32_op () utt$3) (declare-fun y$s$33 () utt$3) (declare-fun y$s$331 () utt$4) (declare-fun y$s$331_op () utt$4) (declare-fun y$s$333 () Bool) (declare-fun y$s$333_op () Bool) (declare-fun y$s$334 () Bool) (declare-fun y$s$334_op () Bool) (declare-fun y$s$335 () Bool) (declare-fun y$s$335_op () Bool) (declare-fun y$s$337 () Bool) (declare-fun y$s$337_op () Bool) (declare-fun y$s$338 () Bool) (declare-fun y$s$338_op () Bool) (declare-fun y$s$339 () Bool) (declare-fun y$s$339_op () Bool) (declare-fun y$s$33_op () utt$3) (declare-fun y$s$34 () utt$3) (declare-fun y$s$341 () utt$8) (declare-fun y$s$341_op () utt$8) (declare-fun y$s$342 () utt$8) (declare-fun y$s$342_op () utt$8) (declare-fun y$s$343 () utt$8) (declare-fun y$s$343_op () utt$8) (declare-fun y$s$345 () utt$4) (declare-fun y$s$345_op () utt$4) (declare-fun y$s$346 () utt$4) (declare-fun y$s$346_op () utt$4) (declare-fun y$s$348 () Bool) (declare-fun y$s$348_op () Bool) (declare-fun y$s$349 () Bool) (declare-fun y$s$349_op () Bool) (declare-fun y$s$34_op () utt$3) (declare-fun y$s$351 () utt$8) (declare-fun y$s$351_op () utt$8) (declare-fun y$s$352 () utt$8) (declare-fun y$s$352_op () utt$8) (declare-fun y$s$354 () Bool) (declare-fun y$s$354_op () Bool) (declare-fun y$s$355 () Bool) (declare-fun y$s$355_op () Bool) (declare-fun y$s$357 () utt$8) (declare-fun y$s$357_op () utt$8) (declare-fun y$s$359 () Bool) (declare-fun y$s$359_op () Bool) (declare-fun y$s$361 () Bool) (declare-fun y$s$361_op () Bool) (declare-fun y$s$363 () utt$4) (declare-fun y$s$363_op () utt$4) (declare-fun y$s$365 () utt$4) (declare-fun y$s$365_op () utt$4) (declare-fun y$s$38 () utt$3) (declare-fun y$s$388 () utt$4) (declare-fun y$s$388_op () utt$4) (declare-fun y$s$389 () utt$4) (declare-fun y$s$389_op () utt$4) (declare-fun y$s$38_op () utt$3) (declare-fun y$s$390 () utt$4) (declare-fun y$s$390_op () utt$4) (declare-fun y$s$396 () Bool) (declare-fun y$s$396_op () Bool) (declare-fun y$s$398 () utt$4) (declare-fun y$s$398_op () utt$4) (declare-fun y$s$40 () Bool) (declare-fun y$s$401 () utt$4) (declare-fun y$s$401_op () utt$4) (declare-fun y$s$402 () utt$4) (declare-fun y$s$402_op () utt$4) (declare-fun y$s$403 () utt$4) (declare-fun y$s$403_op () utt$4) (declare-fun y$s$405 () utt$4) (declare-fun y$s$405_op () utt$4) (declare-fun y$s$406 () utt$4) (declare-fun y$s$406_op () utt$4) (declare-fun y$s$407 () utt$4) (declare-fun y$s$407_op () utt$4) (declare-fun y$s$409 () utt$4) (declare-fun y$s$409_op () utt$4) (declare-fun y$s$40_op () Bool) (declare-fun y$s$410 () utt$4) (declare-fun y$s$410_op () utt$4) (declare-fun y$s$412 () Bool) (declare-fun y$s$412_op () Bool) (declare-fun y$s$413 () Bool) (declare-fun y$s$413_op () Bool) (declare-fun y$s$415 () utt$16) (declare-fun y$s$415_op () utt$16) (declare-fun y$s$416 () utt$16) (declare-fun y$s$416_op () utt$16) (declare-fun y$s$418 () Bool) (declare-fun y$s$418_op () Bool) (declare-fun y$s$419 () Bool) (declare-fun y$s$419_op () Bool) (declare-fun y$s$42 () Bool) (declare-fun y$s$421 () Bool) (declare-fun y$s$421_op () Bool) (declare-fun y$s$423 () utt$16) (declare-fun y$s$423_op () utt$16) (declare-fun y$s$425 () Bool) (declare-fun y$s$425_op () Bool) (declare-fun y$s$427 () utt$4) (declare-fun y$s$427_op () utt$4) (declare-fun y$s$42_op () Bool) (declare-fun y$s$430 () utt$4) (declare-fun y$s$430_op () utt$4) (declare-fun y$s$431 () utt$4) (declare-fun y$s$431_op () utt$4) (declare-fun y$s$433 () Bool) (declare-fun y$s$433_op () Bool) (declare-fun y$s$434 () Bool) (declare-fun y$s$434_op () Bool) (declare-fun y$s$436 () Bool) (declare-fun y$s$436_op () Bool) (declare-fun y$s$437 () Bool) (declare-fun y$s$437_op () Bool) (declare-fun y$s$439 () Bool) (declare-fun y$s$439_op () Bool) (declare-fun y$s$441 () Bool) (declare-fun y$s$441_op () Bool) (declare-fun y$s$443 () utt$4) (declare-fun y$s$443_op () utt$4) (declare-fun y$s$445 () utt$16) (declare-fun y$s$445_op () utt$16) (declare-fun y$s$447 () utt$4) (declare-fun y$s$447_op () utt$4) (declare-fun y$s$449 () utt$16) (declare-fun y$s$449_op () utt$16) (declare-fun y$s$451 () Bool) (declare-fun y$s$451_op () Bool) (declare-fun y$s$455 () utt$32) (declare-fun y$s$455_op () utt$32) (declare-fun y$s$456 () utt$16) (declare-fun y$s$456_op () utt$16) (declare-fun y$s$457 () utt$32) (declare-fun y$s$457_op () utt$32) (declare-fun y$s$46 () utt$3) (declare-fun y$s$460 () Bool) (declare-fun y$s$460_op () Bool) (declare-fun y$s$461 () utt$2) (declare-fun y$s$461_op () utt$2) (declare-fun y$s$462 () Bool) (declare-fun y$s$462_op () Bool) (declare-fun y$s$463 () utt$2) (declare-fun y$s$463_op () utt$2) (declare-fun y$s$464 () utt$2) (declare-fun y$s$464_op () utt$2) (declare-fun y$s$465 () utt$2) (declare-fun y$s$465_op () utt$2) (declare-fun y$s$466 () utt$2) (declare-fun y$s$466_op () utt$2) (declare-fun y$s$467 () utt$2) (declare-fun y$s$467_op () utt$2) (declare-fun y$s$468 () utt$2) (declare-fun y$s$468_op () utt$2) (declare-fun y$s$46_op () utt$3) (declare-fun y$s$470 () Bool) (declare-fun y$s$470_op () Bool) (declare-fun y$s$471 () utt$2) (declare-fun y$s$471_op () utt$2) (declare-fun y$s$472 () utt$2) (declare-fun y$s$472_op () utt$2) (declare-fun y$s$473 () Bool) (declare-fun y$s$473_op () Bool) (declare-fun y$s$481 () Bool) (declare-fun y$s$481_op () Bool) (declare-fun y$s$482 () Bool) (declare-fun y$s$482_op () Bool) (declare-fun y$s$484 () Bool) (declare-fun y$s$484_op () Bool) (declare-fun y$s$486 () utt$2) (declare-fun y$s$486_op () utt$2) (declare-fun y$s$488 () utt$2) (declare-fun y$s$488_op () utt$2) (declare-fun y$s$490 () utt$2) (declare-fun y$s$490_op () utt$2) (declare-fun y$s$492 () Bool) (declare-fun y$s$492_op () Bool) (declare-fun y$s$494 () utt$2) (declare-fun y$s$494_op () utt$2) (declare-fun y$s$496 () utt$2) (declare-fun y$s$496_op () utt$2) (declare-fun y$s$498 () utt$2) (declare-fun y$s$498_op () utt$2) (declare-fun y$s$5 () Bool) (declare-fun y$s$50 () utt$3) (declare-fun y$s$500 () utt$2) (declare-fun y$s$500_op () utt$2) (declare-fun y$s$50_op () utt$3) (declare-fun y$s$511 () Bool) (declare-fun y$s$511_op () Bool) (declare-fun y$s$512 () utt$4) (declare-fun y$s$512_op () utt$4) (declare-fun y$s$513 () utt$4) (declare-fun y$s$513_op () utt$4) (declare-fun y$s$514 () Bool) (declare-fun y$s$514_op () Bool) (declare-fun y$s$515 () utt$4) (declare-fun y$s$515_op () utt$4) (declare-fun y$s$516 () utt$4) (declare-fun y$s$516_op () utt$4) (declare-fun y$s$517 () Bool) (declare-fun y$s$517_op () Bool) (declare-fun y$s$518 () utt$4) (declare-fun y$s$518_op () utt$4) (declare-fun y$s$519 () utt$4) (declare-fun y$s$519_op () utt$4) (declare-fun y$s$520 () utt$4) (declare-fun y$s$520_op () utt$4) (declare-fun y$s$521 () utt$4) (declare-fun y$s$521_op () utt$4) (declare-fun y$s$522 () Bool) (declare-fun y$s$522_op () Bool) (declare-fun y$s$523 () Bool) (declare-fun y$s$523_op () Bool) (declare-fun y$s$524 () Bool) (declare-fun y$s$524_op () Bool) (declare-fun y$s$525 () Bool) (declare-fun y$s$525_op () Bool) (declare-fun y$s$526 () Bool) (declare-fun y$s$526_op () Bool) (declare-fun y$s$527 () Bool) (declare-fun y$s$527_op () Bool) (declare-fun y$s$528 () Bool) (declare-fun y$s$528_op () Bool) (declare-fun y$s$529 () Bool) (declare-fun y$s$529_op () Bool) (declare-fun y$s$530 () Bool) (declare-fun y$s$530_op () Bool) (declare-fun y$s$531 () utt$4) (declare-fun y$s$531_op () utt$4) (declare-fun y$s$532 () utt$4) (declare-fun y$s$532_op () utt$4) (declare-fun y$s$533 () utt$4) (declare-fun y$s$533_op () utt$4) (declare-fun y$s$534 () utt$4) (declare-fun y$s$534_op () utt$4) (declare-fun y$s$535 () utt$4) (declare-fun y$s$535_op () utt$4) (declare-fun y$s$536 () utt$4) (declare-fun y$s$536_op () utt$4) (declare-fun y$s$537 () utt$4) (declare-fun y$s$537_op () utt$4) (declare-fun y$s$538 () utt$4) (declare-fun y$s$538_op () utt$4) (declare-fun y$s$539 () utt$4) (declare-fun y$s$539_op () utt$4) (declare-fun y$s$54 () utt$3) (declare-fun y$s$540 () utt$4) (declare-fun y$s$540_op () utt$4) (declare-fun y$s$541 () utt$4) (declare-fun y$s$541_op () utt$4) (declare-fun y$s$542 () utt$4) (declare-fun y$s$542_op () utt$4) (declare-fun y$s$543 () utt$4) (declare-fun y$s$543_op () utt$4) (declare-fun y$s$544 () utt$4) (declare-fun y$s$544_op () utt$4) (declare-fun y$s$545 () utt$4) (declare-fun y$s$545_op () utt$4) (declare-fun y$s$546 () utt$4) (declare-fun y$s$546_op () utt$4) (declare-fun y$s$549 () Bool) (declare-fun y$s$549_op () Bool) (declare-fun y$s$54_op () utt$3) (declare-fun y$s$550 () Bool) (declare-fun y$s$550_op () Bool) (declare-fun y$s$559 () Bool) (declare-fun y$s$559_op () Bool) (declare-fun y$s$561 () Bool) (declare-fun y$s$561_op () Bool) (declare-fun y$s$563 () Bool) (declare-fun y$s$563_op () Bool) (declare-fun y$s$564 () Bool) (declare-fun y$s$564_op () Bool) (declare-fun y$s$566 () utt$4) (declare-fun y$s$566_op () utt$4) (declare-fun y$s$567 () utt$4) (declare-fun y$s$567_op () utt$4) (declare-fun y$s$569 () utt$4) (declare-fun y$s$569_op () utt$4) (declare-fun y$s$570 () utt$4) (declare-fun y$s$570_op () utt$4) (declare-fun y$s$572 () utt$4) (declare-fun y$s$572_op () utt$4) (declare-fun y$s$573 () utt$4) (declare-fun y$s$573_op () utt$4) (declare-fun y$s$575 () utt$4) (declare-fun y$s$575_op () utt$4) (declare-fun y$s$576 () utt$4) (declare-fun y$s$576_op () utt$4) (declare-fun y$s$578 () utt$4) (declare-fun y$s$578_op () utt$4) (declare-fun y$s$580 () Bool) (declare-fun y$s$580_op () Bool) (declare-fun y$s$582 () utt$4) (declare-fun y$s$582_op () utt$4) (declare-fun y$s$5_op () Bool) (declare-fun y$s$6 () Bool) (declare-fun y$s$60 () Bool) (declare-fun y$s$602 () utt$4) (declare-fun y$s$602_op () utt$4) (declare-fun y$s$609 () utt$4) (declare-fun y$s$609_op () utt$4) (declare-fun y$s$60_op () Bool) (declare-fun y$s$64 () utt$3) (declare-fun y$s$64_op () utt$3) (declare-fun y$s$65 () Bool) (declare-fun y$s$65_op () Bool) (declare-fun y$s$6_op () Bool) (declare-fun y$s$7 () Bool) (declare-fun y$s$72 () utt$32) (declare-fun y$s$72_op () utt$32) (declare-fun y$s$73 () Bool) (declare-fun y$s$73_op () Bool) (declare-fun y$s$75 () Bool) (declare-fun y$s$75_op () Bool) (declare-fun y$s$79 () utt$3) (declare-fun y$s$79_op () utt$3) (declare-fun y$s$7_op () Bool) (declare-fun y$s$8 () Bool) (declare-fun y$s$81 () utt$3) (declare-fun y$s$81_op () utt$3) (declare-fun y$s$84 () utt$3) (declare-fun y$s$85 () utt$3) (declare-fun y$s$85_op () utt$3) (declare-fun y$s$86 () Bool) (declare-fun y$s$86_op () Bool) (declare-fun y$s$88 () Bool) (declare-fun y$s$88_op () Bool) (declare-fun y$s$8_op () Bool) (declare-fun y$s$9 () Bool) (declare-fun y$s$92 () Bool) (declare-fun y$s$92_op () Bool) (declare-fun y$s$9_op () Bool) (declare-fun y$stream_end () Bool) (declare-fun y$stream_end$next () Bool) (declare-fun y$stream_end$next_rhs () Bool) (declare-fun y$stream_end$next_rhs_op () Bool) (declare-fun y$sysHeadParseStart () Bool) (declare-fun y$sysHeadParseStart$next () Bool) (declare-fun y$sysHeadParseStart$next_rhs () Bool) (declare-fun y$sysHeadParseStart$next_rhs_op () Bool) (declare-fun y$sysHeadStart () Bool) (declare-fun y$sysHeadStart$next () Bool) (declare-fun y$sysHeadStart$next_rhs () Bool) (declare-fun y$sysHeadStart$next_rhs_op () Bool) (declare-fun y$w$10 () utt$32) (declare-fun y$w$10_op () utt$32) (declare-fun y$w$19 () utt$2) (declare-fun y$w$2 () utt$3) (declare-fun y$w$20 () utt$32) (declare-fun y$w$20_op () utt$32) (declare-fun y$w$21 () utt$8) (declare-fun y$w$21_op () utt$8) (declare-fun y$w$22 () utt$8) (declare-fun y$w$22_op () utt$8) (declare-fun y$w$25 () utt$16) (declare-fun y$w$26 () utt$32) (declare-fun y$w$26$next () utt$32) (declare-fun y$w$26$next_op () utt$32) (declare-fun y$w$26_op () utt$32) (declare-fun y$w$27 () utt$32) (declare-fun y$w$27$next () utt$32) (declare-fun y$w$27$next_op () utt$32) (declare-fun y$w$27_op () utt$32) (declare-fun y$w$28 () utt$32) (declare-fun y$w$28$next () utt$32) (declare-fun y$w$28$next_op () utt$32) (declare-fun y$w$28_op () utt$32) (declare-fun y$w$29 () utt$32) (declare-fun y$w$29_op () utt$32) (declare-fun y$w$30 () utt$32) (declare-fun y$w$30_op () utt$32) (declare-fun y$w$31 () utt$32) (declare-fun y$w$31_op () utt$32) (declare-fun y$w$32 () utt$7) (declare-fun y$w$32$next () utt$7) (declare-fun y$w$33 () utt$32) (declare-fun y$w$33_op () utt$32) (declare-fun y$w$34 () utt$32) (declare-fun y$w$34_op () utt$32) (declare-fun y$w$35 () utt$32) (declare-fun y$w$35_op () utt$32) (declare-fun y$w$36 () utt$32) (declare-fun y$w$36_op () utt$32) (declare-fun y$w$37 () utt$32) (declare-fun y$w$37_op () utt$32) (declare-fun y$w$38 () utt$32) (declare-fun y$w$38_op () utt$32) (declare-fun y$w$39 () Bool) (declare-fun y$w$40 () utt$32) (declare-fun y$w$40_op () utt$32) (declare-fun y$w$41 () utt$32) (declare-fun y$w$41_op () utt$32) (declare-fun y$w$42 () utt$32) (declare-fun y$w$42_op () utt$32) (declare-fun y$w$43 () utt$32) (declare-fun y$w$43_op () utt$32) (declare-fun y$w$44 () utt$32) (declare-fun y$w$44_op () utt$32) (declare-fun y$w$45 () utt$32) (declare-fun y$w$45_op () utt$32) (declare-fun y$w$46 () utt$32) (declare-fun y$w$46_op () utt$32) (declare-fun y$w$47 () utt$16) (declare-fun y$w$47_op () utt$16) (declare-fun y$w$48 () utt$2) (declare-fun y$w$49 () utt$32) (declare-fun y$w$49_op () utt$32) (declare-fun y$w$50 () utt$8) (declare-fun y$w$51 () utt$8) (declare-fun y$w$52 () utt$16) (declare-fun y$w$52_op () utt$16) (declare-fun y$w$53 () utt$32) (declare-fun y$w$53_op () utt$32) (declare-fun y$w$54 () utt$32) (declare-fun y$w$54_op () utt$32) (declare-fun y$w$55 () utt$32) (declare-fun y$w$55_op () utt$32) (declare-fun y$w$56 () utt$4) (assert (distinct y$n0s2 y$n2s2 y$n1s2 y$n3s2)) (assert (distinct y$n0s3 y$n7s3 y$n3s3 y$n2s3 y$n1s3 y$n4s3 y$n5s3 y$n6s3)) (assert (distinct y$n0s4 y$n15s4 y$n4s4 y$n5s4 y$n6s4 y$n7s4 y$n8s4 y$n2s4 y$n3s4 y$n9s4 y$n10s4 y$n11s4 y$n12s4 y$n13s4 y$n1s4)) (assert (distinct y$n255s8 y$n0s8 y$n93s8 y$n1s8 y$n221s8 y$n128s8 y$n67s8 y$n195s8 y$n7s8 y$n131s8 y$n3s8 y$n191s8 y$n186s8 y$n185s8 y$n15s8)) (assert (not (= y$n1s32 y$n0s32))) (assert (= y$w$26_op (Concat_32_1_31 y$mod3.stop y$n0s31))) (assert (= y$1025 (= y$n0s32 y$w$26_op))) (assert (= y$w$27_op (Concat_32_1_31 y$packHeadStart y$n0s31))) (assert (= y$147 (= y$n1s32 y$w$27_op))) (assert (= y$prop0_op (and y$1025 y$147))) (assert (= y$1028 (= y$prop y$prop0_op))) (assert (= y$w$28_op (Concat_32_1_31 y$mod7.done y$n0s31))) (assert (= y$76 (= y$n1s32 y$w$28_op))) (assert (= y$80 (= y$n1s32 y$w$26_op))) (assert (= y$s$5_op (and y$packHeadStart (not y$80)))) (assert (= y$packHeadStart$next_rhs_op (or y$76 y$s$5_op))) (assert (= y$86 (= y$packHeadStart$next y$packHeadStart$next_rhs_op))) (assert (= y$w$29_op (Concat_32_1_31 y$mod4.stop y$n0s31))) (assert (= y$90 (= y$n1s32 y$w$29_op))) (assert (= y$s$6_op (or y$packParseStart y$80))) (assert (= y$packParseStart$next_rhs_op (and (not y$90) y$s$6_op))) (assert (= y$95 (= y$packParseStart$next y$packParseStart$next_rhs_op))) (assert (= y$w$30_op (Concat_32_1_31 y$mod5.stop y$n0s31))) (assert (= y$99 (= y$n1s32 y$w$30_op))) (assert (= y$s$9_op (or y$sysHeadStart y$90))) (assert (= y$sysHeadStart$next_rhs_op (and (not y$99) y$s$9_op))) (assert (= y$104 (= y$sysHeadStart$next y$sysHeadStart$next_rhs_op))) (assert (= y$w$31_op (Concat_32_1_31 y$mod6.stop y$n0s31))) (assert (= y$108 (= y$n1s32 y$w$31_op))) (assert (= y$s$8_op (or y$sysHeadParseStart y$99))) (assert (= y$sysHeadParseStart$next_rhs_op (and (not y$108) y$s$8_op))) (assert (= y$113 (= y$sysHeadParseStart$next y$sysHeadParseStart$next_rhs_op))) (assert (= y$s$7_op (or y$packetStart y$108))) (assert (= y$packetStart$next_rhs_op (and (not y$76) y$s$7_op))) (assert (= y$119 (= y$packetStart$next y$packetStart$next_rhs_op))) (assert (= y$121 (Extract_7_7_1_8 y$mod1.output_buffer))) (assert (= y$mod1.output_buffer$next_rhs_op (Concat_8_7_1 y$121 y$input_stream))) (assert (= y$126 (= y$mod1.output_buffer$next y$mod1.output_buffer$next_rhs_op))) (assert (= y$129 (= y$n7s3 y$mod2.count_value))) (assert (= y$w$33_op (Concat_32_3_29 y$mod2.count_value y$n0s29))) (assert (= y$s$17_op (Add_32_32_32 y$w$33_op y$n1s32))) (assert (= y$135 (Extract_3_2_0_32 y$s$17_op))) (assert (= y$mod2.count_value$next_rhs_op (ite y$129 y$n0s3 y$135))) (assert (= y$139 (= y$mod2.count_value$next y$mod2.count_value$next_rhs_op))) (assert (= y$129 y$mod2.count_over$next_rhs_op)) (assert (= y$143 (= y$mod2.count_over$next y$mod2.count_over$next_rhs_op))) (assert (= y$149 (= y$n3s3 y$mod3.state))) (assert (= y$151 (= y$n93s8 y$mod1.output_buffer))) (assert (= y$s$40_op (or y$mod3.stop y$151))) (assert (= y$s$42_op (and y$149 y$s$40_op))) (assert (= y$s$24_op (and y$147 y$s$42_op))) (assert (= y$s$60_op (ite y$149 y$s$24_op y$mod3.stop))) (assert (= y$s$22_op (and y$147 y$s$60_op))) (assert (= y$mod3.stop$next_rhs_op (and y$147 y$s$22_op))) (assert (= y$164 (= y$mod3.stop$next y$mod3.stop$next_rhs_op))) (assert (= y$167 (= y$n2s3 y$mod3.state))) (assert (= y$s$28_op (or y$149 y$167))) (assert (= y$170 (= y$n0s8 y$mod1.output_buffer))) (assert (= y$s$143_op (ite y$170 y$n1s3 y$n0s3))) (assert (= y$s$38_op (ite y$149 y$s$143_op y$n0s3))) (assert (= y$s$27_op (ite y$147 y$s$38_op y$n0s3))) (assert (= y$179 (= y$n1s8 y$mod1.output_buffer))) (assert (= y$s$29_op (ite y$179 y$n3s3 y$n0s3))) (assert (= y$s$30_op (ite y$170 y$n1s3 y$s$29_op))) (assert (= y$s$46_op (ite y$167 y$s$30_op y$n0s3))) (assert (= y$s$26_op (ite y$147 y$s$46_op y$n0s3))) (assert (= y$s$31_op (ite y$149 y$s$27_op y$s$26_op))) (assert (= y$190 (= y$n1s3 y$mod3.state))) (assert (= y$s$139_op (ite y$170 y$n2s3 y$n0s3))) (assert (= y$s$50_op (ite y$190 y$s$139_op y$n0s3))) (assert (= y$s$25_op (ite y$147 y$s$50_op y$n0s3))) (assert (= y$9 (= y$n0s3 y$mod3.state))) (assert (= y$s$54_op (ite y$9 y$s$143_op y$n0s3))) (assert (= y$s$23_op (ite y$147 y$s$54_op y$n0s3))) (assert (= y$s$32_op (ite y$9 y$s$23_op y$mod3.state))) (assert (= y$s$33_op (ite y$190 y$s$25_op y$s$32_op))) (assert (= y$s$34_op (ite y$s$28_op y$s$31_op y$s$33_op))) (assert (= y$s$21_op (ite y$147 y$s$34_op y$n0s3))) (assert (= y$mod3.state$next_rhs_op (ite y$147 y$s$21_op y$mod3.state))) (assert (= y$211 (= y$mod3.state$next y$mod3.state$next_rhs_op))) (assert (= y$w$34_op (Concat_32_1_31 y$packParseStart y$n0s31))) (assert (= y$215 (= y$n1s32 y$w$34_op))) (assert (= y$217 (= y$n4s3 y$mod4.count))) (assert (= y$219 (= y$n5s3 y$mod4.count))) (assert (= y$221 (= y$n6s3 y$mod4.count))) (assert (= y$222 (= y$n7s3 y$mod4.count))) (assert (= y$s$75_op (or y$221 y$222))) (assert (= y$s$73_op (or y$217 y$219 y$s$75_op))) (assert (= y$s$86_op (or y$mod4.stop y$222))) (assert (= y$s$88_op (ite y$s$75_op y$s$86_op y$mod4.stop))) (assert (= y$s$92_op (ite y$s$73_op y$s$88_op y$mod4.stop))) (assert (= y$s$65_op (and y$215 y$s$92_op))) (assert (= y$mod4.stop$next_rhs_op (and y$215 y$s$65_op))) (assert (= y$237 (= y$mod4.stop$next y$mod4.stop$next_rhs_op))) (assert (= y$w$35_op (Concat_32_3_29 y$mod4.count y$n0s29))) (assert (= y$s$72_op (Add_32_32_32 y$w$35_op y$n1s32))) (assert (= y$243 (Extract_3_2_0_32 y$s$72_op))) (assert (= y$s$79_op (ite y$222 y$n0s3 y$243))) (assert (= y$s$81_op (ite y$s$75_op y$s$79_op y$243))) (assert (= y$s$85_op (ite y$s$73_op y$s$81_op y$243))) (assert (= y$s$64_op (ite y$215 y$s$85_op y$n0s3))) (assert (= y$mod4.count$next_rhs_op (ite y$215 y$s$64_op y$mod4.count))) (assert (= y$255 (= y$mod4.count$next y$mod4.count$next_rhs_op))) (assert (= y$w$36_op (Concat_32_1_31 y$sysHeadStart y$n0s31))) (assert (= y$259 (= y$n1s32 y$w$36_op))) (assert (= y$260 (= y$n7s3 y$mod5.state))) (assert (= y$261 (= y$n3s3 y$mod5.state))) (assert (= y$263 (= y$n221s8 y$mod1.output_buffer))) (assert (= y$s$127_op (or y$mod5.stop y$263))) (assert (= y$s$129_op (and y$261 y$s$127_op))) (assert (= y$s$113_op (and y$259 y$s$129_op))) (assert (= y$s$124_op (ite y$261 y$s$113_op y$mod5.stop))) (assert (= y$s$125_op (and (not y$260) y$s$124_op))) (assert (= y$s$111_op (and y$259 y$s$125_op))) (assert (= y$mod5.stop$next_rhs_op (ite y$259 y$s$111_op y$mod5.stop))) (assert (= y$278 (= y$mod5.stop$next y$mod5.stop$next_rhs_op))) (assert (= y$280 (= y$n2s3 y$mod5.state))) (assert (= y$s$117_op (or y$261 y$280))) (assert (= y$s$118_op (ite y$263 y$n7s3 y$n0s3))) (assert (= y$s$119_op (ite y$170 y$n1s3 y$s$118_op))) (assert (= y$s$133_op (ite y$261 y$s$119_op y$n0s3))) (assert (= y$s$116_op (ite y$259 y$s$133_op y$n0s3))) (assert (= y$292 (= y$n128s8 y$mod1.output_buffer))) (assert (= y$s$135_op (ite y$292 y$n3s3 y$n0s3))) (assert (= y$s$137_op (ite y$280 y$s$135_op y$n0s3))) (assert (= y$s$115_op (ite y$259 y$s$137_op y$n0s3))) (assert (= y$s$120_op (ite y$261 y$s$116_op y$s$115_op))) (assert (= y$301 (= y$n1s3 y$mod5.state))) (assert (= y$s$141_op (ite y$301 y$s$139_op y$n0s3))) (assert (= y$s$114_op (ite y$259 y$s$141_op y$n0s3))) (assert (= y$17 (= y$n0s3 y$mod5.state))) (assert (= y$s$145_op (ite y$17 y$s$143_op y$n0s3))) (assert (= y$s$112_op (ite y$259 y$s$145_op y$n0s3))) (assert (= y$s$121_op (ite y$17 y$s$112_op y$mod5.state))) (assert (= y$s$122_op (ite y$301 y$s$114_op y$s$121_op))) (assert (= y$s$123_op (ite y$s$117_op y$s$120_op y$s$122_op))) (assert (= y$s$110_op (ite y$259 y$s$123_op y$n0s3))) (assert (= y$mod5.state$next_rhs_op (ite y$259 y$s$110_op y$mod5.state))) (assert (= y$320 (= y$mod5.state$next y$mod5.state$next_rhs_op))) (assert (= y$w$37_op (Concat_32_1_31 y$sysHeadParseStart y$n0s31))) (assert (= y$325 (= y$n0s32 y$w$37_op))) (assert (= y$326 (= y$n1s32 y$w$37_op))) (assert (= y$w$38_op (Concat_32_1_31 y$mod6.flag y$n0s31))) (assert (= y$329 (= y$n0s32 y$w$38_op))) (assert (= y$s$213_op (and y$326 y$329))) (assert (= y$332 (= y$n4s3 y$mod6.count))) (assert (= y$333 (= y$n5s3 y$mod6.count))) (assert (= y$334 (= y$n6s3 y$mod6.count))) (assert (= y$335 (= y$n7s3 y$mod6.count))) (assert (= y$s$183_op (or y$334 y$335))) (assert (= y$s$179_op (or y$332 y$333 y$s$183_op))) (assert (= y$s$193_op (or y$mod6.flag y$335))) (assert (= y$s$195_op (ite y$s$183_op y$s$193_op y$mod6.flag))) (assert (= y$s$199_op (ite y$s$179_op y$s$195_op y$mod6.flag))) (assert (= y$s$161_op (and y$s$213_op y$s$199_op))) (assert (= y$mod6.flag$next_rhs_op (ite y$s$213_op y$s$161_op y$mod6.flag))) (assert (= y$w$10_op (Concat_32_1_31 y$mod6.flag$next_rhs_op y$n0s31))) (assert (= y$352 (= y$n1s32 y$w$10_op))) (assert (= y$s$214_op (and y$326 y$352))) (assert (= y$355 (Extract_1_0_0_8 y$mod1.output_buffer))) (assert (= y$w$40_op (Concat_32_1_31 y$355 y$n0s31))) (assert (= y$359 (= y$n1s32 y$w$40_op))) (assert (= y$361 (= y$n2s2 y$mod6.count1))) (assert (= y$363 (= y$n67s8 y$mod6.stream_id_temp))) (assert (= y$365 (= y$n195s8 y$mod6.stream_id_temp))) (assert (= y$367 (= y$n7s8 y$mod6.stream_id_temp))) (assert (= y$s$177_op (or y$363 y$365 y$367))) (assert (= y$371 (= y$n131s8 y$mod6.stream_id_temp))) (assert (= y$373 (= y$n3s8 y$mod6.stream_id_temp))) (assert (= y$s$187_op (or y$mod6.stop y$373))) (assert (= y$s$188_op (or y$371 y$s$187_op))) (assert (= y$s$189_op (or y$s$177_op y$s$188_op))) (assert (= y$s$220_op (and y$361 y$s$189_op))) (assert (= y$s$222_op (and y$359 y$s$220_op))) (assert (= y$s$167_op (and y$s$214_op y$s$222_op))) (assert (= y$s$230_op (ite y$361 y$s$167_op y$mod6.stop))) (assert (= y$s$232_op (and y$359 y$s$230_op))) (assert (= y$s$165_op (and y$s$214_op y$s$232_op))) (assert (= y$s$235_op (ite y$359 y$s$165_op y$mod6.stop))) (assert (= y$s$162_op (and y$s$214_op y$s$235_op))) (assert (= y$s$158_op (ite y$s$214_op y$s$162_op y$mod6.stop))) (assert (= y$mod6.stop$next_rhs_op (and (not y$325) y$s$158_op))) (assert (= y$400 (= y$mod6.stop$next y$mod6.stop$next_rhs_op))) (assert (= y$w$41_op (Concat_32_3_29 y$mod6.count y$n0s29))) (assert (= y$s$174_op (Add_32_32_32 y$w$41_op y$n1s32))) (assert (= y$406 (Extract_3_2_0_32 y$s$174_op))) (assert (= y$s$200_op (ite y$335 y$n0s3 y$406))) (assert (= y$s$202_op (ite y$s$183_op y$s$200_op y$406))) (assert (= y$s$206_op (ite y$s$179_op y$s$202_op y$406))) (assert (= y$s$160_op (ite y$s$213_op y$s$206_op y$n0s3))) (assert (= y$mod6.count$next_rhs_op (ite y$s$213_op y$s$160_op y$mod6.count))) (assert (= y$418 (= y$mod6.count$next y$mod6.count$next_rhs_op))) (assert (= y$420 (= y$mod6.flag$next_rhs_op y$mod6.flag$next))) (assert (= y$423 (= y$n1s2 y$mod6.count1))) (assert (= y$s$180_op (or y$361 y$423))) (assert (= y$w$42_op (Concat_32_2_30 y$mod6.count1 y$n0s30))) (assert (= y$s$176_op (Add_32_32_32 y$w$42_op y$n1s32))) (assert (= y$431 (Extract_2_1_0_32 y$s$176_op))) (assert (= y$s$190_op (ite y$361 y$n0s2 y$431))) (assert (= y$24 (= y$n0s2 y$mod6.count1))) (assert (= y$s$191_op (ite y$24 y$431 y$mod6.count1))) (assert (= y$s$192_op (ite y$s$180_op y$s$190_op y$s$191_op))) (assert (= y$s$229_op (ite y$359 y$s$192_op y$n0s2))) (assert (= y$s$164_op (ite y$s$214_op y$s$229_op y$n0s2))) (assert (= y$s$234_op (ite y$359 y$s$164_op y$mod6.count1))) (assert (= y$s$159_op (ite y$s$214_op y$s$234_op y$n0s2))) (assert (= y$mod6.count1$next_rhs_op (ite y$s$214_op y$s$159_op y$mod6.count1))) (assert (= y$449 (= y$mod6.count1$next y$mod6.count1$next_rhs_op))) (assert (= y$s$223_op (ite y$24 y$mod1.output_buffer y$mod6.stream_id_temp))) (assert (= y$s$225_op (ite y$359 y$s$223_op y$n0s8))) (assert (= y$s$166_op (ite y$s$214_op y$s$225_op y$n0s8))) (assert (= y$s$233_op (ite y$359 y$s$166_op y$mod6.stream_id_temp))) (assert (= y$s$163_op (ite y$s$214_op y$s$233_op y$n0s8))) (assert (= y$mod6.stream_id_temp$next_rhs_op (ite y$s$214_op y$s$163_op y$mod6.stream_id_temp))) (assert (= y$463 (= y$mod6.stream_id_temp$next y$mod6.stream_id_temp$next_rhs_op))) (assert (= y$466 (= y$n4s4 y$mod7.state))) (assert (= y$468 (= y$n5s4 y$mod7.state))) (assert (= y$470 (= y$n6s4 y$mod7.state))) (assert (= y$472 (= y$n7s4 y$mod7.state))) (assert (= y$474 (= y$n8s4 y$mod7.state))) (assert (= y$s$296_op (or y$472 y$474))) (assert (= y$s$294_op (or y$466 y$468 y$470 y$s$296_op))) (assert (= y$w$43_op (Concat_32_1_31 y$packetStart y$n0s31))) (assert (= y$481 (= y$n0s32 y$w$43_op))) (assert (= y$s$447_op (ite y$481 y$n15s4 y$mod7.state))) (assert (= y$s$262_op (ite y$474 y$s$447_op y$n0s4))) (assert (= y$w$44_op (Concat_32_16_16 y$mod7.NumBytes y$n0s16))) (assert (= y$s$329_op (Gr_1_32_32 y$w$44_op y$n1s32))) (assert (= y$s$398_op (ite y$s$329_op y$mod7.state y$n0s4))) (assert (= y$s$261_op (ite y$472 y$s$398_op y$n0s4))) (assert (= y$s$300_op (ite y$474 y$s$262_op y$s$261_op))) (assert (= y$w$45_op (Concat_32_1_31 y$mod7.module2.done y$n0s31))) (assert (= y$498 (= y$n1s32 y$w$45_op))) (assert (= y$w$46_op (Concat_32_4_28 y$mod7.module2.timeBytes y$n0s28))) (assert (= y$s$455_op (Sub_32_32_32 y$w$44_op y$w$46_op))) (assert (= y$504 (= y$n0s32 y$s$455_op))) (assert (= y$w$47_op (Concat_16_4_12 y$mod7.module2.timeBytes y$n0s12))) (assert (= y$s$456_op (Sub_16_16_16 y$mod7.NumBytes y$w$47_op))) (assert (= y$w$20_op (Concat_32_16_16 y$s$456_op y$n0s16))) (assert (= y$512 (= y$n1s32 y$w$20_op))) (assert (= y$s$328_op (Gr_1_32_32 y$w$20_op y$n1s32))) (assert (= y$s$405_op (ite y$s$328_op y$n7s4 y$mod7.state))) (assert (= y$s$406_op (ite y$504 y$n0s4 y$s$405_op))) (assert (= y$s$407_op (ite y$498 y$s$406_op y$n0s4))) (assert (= y$s$259_op (ite y$470 y$s$407_op y$n0s4))) (assert (= y$s$401_op (ite y$512 y$n0s4 y$s$259_op))) (assert (= y$s$402_op (ite y$504 y$n0s4 y$s$401_op))) (assert (= y$s$403_op (ite y$498 y$s$402_op y$n0s4))) (assert (= y$s$260_op (ite y$470 y$s$403_op y$n0s4))) (assert (= y$s$409_op (ite y$504 y$n0s4 y$s$260_op))) (assert (= y$s$410_op (ite y$498 y$s$409_op y$n0s4))) (assert (= y$s$258_op (ite y$470 y$s$410_op y$n0s4))) (assert (= y$s$427_op (ite y$498 y$s$258_op y$mod7.state))) (assert (= y$s$293_op (ite y$470 y$s$427_op y$n0s4))) (assert (= (not (= y$n255s8 y$mod1.output_buffer)) y$541)) (assert (= y$542 (Extract_2_1_0_8 y$mod1.output_buffer))) (assert (= y$544 (= y$n1s2 y$542))) (assert (= y$s$430_op (ite y$544 y$n5s4 y$n6s4))) (assert (= y$s$431_op (ite y$541 y$s$430_op y$n0s4))) (assert (= y$s$292_op (ite y$466 y$s$431_op y$n0s4))) (assert (= y$s$443_op (ite y$541 y$s$292_op y$mod7.state))) (assert (= y$s$291_op (ite y$466 y$s$443_op y$n0s4))) (assert (= y$s$301_op (ite y$468 y$n6s4 y$s$291_op))) (assert (= y$s$302_op (ite y$470 y$s$293_op y$s$301_op))) (assert (= y$s$303_op (ite y$s$296_op y$s$300_op y$s$302_op))) (assert (= y$562 (= y$n2s4 y$mod7.state))) (assert (= y$564 (= y$n3s4 y$mod7.state))) (assert (= y$s$297_op (or y$562 y$564))) (assert (= y$568 (= y$n191s8 y$mod7.stream_id))) (assert (= y$s$331_op (ite y$568 y$n7s4 y$n4s4))) (assert (= y$s$289_op (ite y$564 y$s$331_op y$n0s4))) (assert (= y$s$304_op (ite y$564 y$s$289_op y$n3s4))) (assert (= y$575 (= y$n0s4 y$mod7.state))) (assert (= y$w$49_op (Concat_32_1_31 y$mod7.module1.done y$n0s31))) (assert (= y$578 (= y$n1s32 y$w$49_op))) (assert (= y$580 (= y$n186s8 y$mod1.output_buffer))) (assert (= y$582 (= y$n185s8 y$mod1.output_buffer))) (assert (= y$s$388_op (ite y$582 y$n8s4 y$n2s4))) (assert (= y$s$389_op (ite y$580 y$n0s4 y$s$388_op))) (assert (= y$s$390_op (ite y$578 y$s$389_op y$n0s4))) (assert (= y$s$286_op (ite y$575 y$s$390_op y$n0s4))) (assert (= y$s$345_op (ite y$580 y$n8s4 y$s$286_op))) (assert (= y$s$346_op (ite y$578 y$s$345_op y$n0s4))) (assert (= y$s$279_op (ite y$575 y$s$346_op y$n0s4))) (assert (= y$s$363_op (ite y$578 y$s$279_op y$mod7.state))) (assert (= y$s$272_op (ite y$575 y$s$363_op y$n0s4))) (assert (= y$52 (= y$n15s4 y$mod7.state))) (assert (= y$601 (= y$n1s32 y$w$43_op))) (assert (= y$s$365_op (ite y$601 y$n0s4 y$mod7.state))) (assert (= y$s$265_op (ite y$52 y$s$365_op y$n0s4))) (assert (= y$s$305_op (ite y$52 y$s$265_op y$mod7.state))) (assert (= y$s$306_op (ite y$575 y$s$272_op y$s$305_op))) (assert (= y$s$307_op (ite y$s$297_op y$s$304_op y$s$306_op))) (assert (= y$mod7.state$next_rhs_op (ite y$s$294_op y$s$303_op y$s$307_op))) (assert (= y$614 (= y$mod7.state$next y$mod7.state$next_rhs_op))) (assert (= y$s$396_op (and y$mod7.done (not y$481)))) (assert (= y$s$285_op (and y$474 y$s$396_op))) (assert (= y$s$337_op (or y$mod7.done y$582))) (assert (= y$s$338_op (and (not y$580) y$s$337_op))) (assert (= y$s$339_op (and y$578 y$s$338_op))) (assert (= y$s$278_op (and y$575 y$s$339_op))) (assert (= y$s$348_op (or y$580 y$s$278_op))) (assert (= y$s$349_op (and y$578 y$s$348_op))) (assert (= y$s$271_op (and y$575 y$s$349_op))) (assert (= y$s$361_op (ite y$578 y$s$271_op y$mod7.done))) (assert (= y$s$264_op (and y$575 y$s$361_op))) (assert (= y$s$317_op (ite y$575 y$s$264_op y$mod7.done))) (assert (= y$mod7.done$next_rhs_op (ite y$474 y$s$285_op y$s$317_op))) (assert (= y$642 (= y$mod7.done$next y$mod7.done$next_rhs_op))) (assert (= y$s$333_op (or y$582 y$stream_end))) (assert (= y$s$334_op (and (not y$580) y$s$333_op))) (assert (= y$s$335_op (and y$578 y$s$334_op))) (assert (= y$s$280_op (and y$575 y$s$335_op))) (assert (= y$s$354_op (ite y$580 y$stream_end y$s$280_op))) (assert (= y$s$355_op (and y$578 y$s$354_op))) (assert (= y$s$273_op (and y$575 y$s$355_op))) (assert (= y$s$359_op (ite y$578 y$s$273_op y$stream_end))) (assert (= y$s$266_op (and y$575 y$s$359_op))) (assert (= y$stream_end$next_rhs_op (ite y$575 y$s$266_op y$stream_end))) (assert (= y$665 (= y$stream_end$next y$stream_end$next_rhs_op))) (assert (= y$s$341_op (ite y$582 y$mod7.stream_id y$mod1.output_buffer))) (assert (= y$s$342_op (ite y$580 y$n0s8 y$s$341_op))) (assert (= y$s$343_op (ite y$578 y$s$342_op y$n0s8))) (assert (= y$s$281_op (ite y$575 y$s$343_op y$n0s8))) (assert (= y$s$351_op (ite y$580 y$mod7.stream_id y$s$281_op))) (assert (= y$s$352_op (ite y$578 y$s$351_op y$n0s8))) (assert (= y$s$274_op (ite y$575 y$s$352_op y$n0s8))) (assert (= y$s$357_op (ite y$578 y$s$274_op y$mod7.stream_id))) (assert (= y$s$267_op (ite y$575 y$s$357_op y$n0s8))) (assert (= y$mod7.stream_id$next_rhs_op (ite y$575 y$s$267_op y$mod7.stream_id))) (assert (= y$687 (= y$mod7.stream_id$next y$mod7.stream_id$next_rhs_op))) (assert (= y$689 (Extract_8_7_0_16 y$mod7.packet_length))) (assert (= y$w$21_op (ite y$564 y$mod1.output_buffer y$689))) (assert (= y$693 (Extract_8_15_8_16 y$mod7.packet_length))) (assert (= y$w$22_op (ite y$562 y$mod1.output_buffer y$693))) (assert (= y$mod7.packet_length$next_rhs_op (Concat_16_8_8 y$w$21_op y$w$22_op))) (assert (= y$699 (= y$mod7.packet_length$next y$mod7.packet_length$next_rhs_op))) (assert (= y$s$298_op (or y$468 y$470))) (assert (= y$s$418_op (and y$mod7.time_stamp_start y$504))) (assert (= y$s$419_op (and y$498 y$s$418_op))) (assert (= y$s$290_op (and y$470 y$s$419_op))) (assert (= y$s$425_op (ite y$498 y$s$290_op y$mod7.time_stamp_start))) (assert (= y$s$288_op (and y$470 y$s$425_op))) (assert (= y$s$314_op (=> y$470 y$s$288_op))) (assert (= y$s$436_op (=> y$544 y$mod7.time_stamp_start))) (assert (= y$s$437_op (and y$541 y$s$436_op))) (assert (= y$s$283_op (and y$466 y$s$437_op))) (assert (= y$s$441_op (ite y$541 y$s$283_op y$mod7.time_stamp_start))) (assert (= y$s$276_op (and y$466 y$s$441_op))) (assert (= y$s$451_op (and y$mod7.time_stamp_start (not y$568)))) (assert (= y$s$269_op (and y$564 y$s$451_op))) (assert (= y$s$315_op (ite y$564 y$s$269_op y$mod7.time_stamp_start))) (assert (= y$s$316_op (ite y$466 y$s$276_op y$s$315_op))) (assert (= y$mod7.time_stamp_start$next_rhs_op (ite y$s$298_op y$s$314_op y$s$316_op))) (assert (= y$735 (= y$mod7.time_stamp_start$next y$mod7.time_stamp_start$next_rhs_op))) (assert (= y$s$295_op (or y$468 y$470 y$472))) (assert (= y$s$457_op (Sub_32_32_32 y$w$44_op y$n1s32))) (assert (= y$741 (Extract_16_15_0_32 y$s$457_op))) (assert (= y$s$449_op (ite y$s$329_op y$741 y$mod7.NumBytes))) (assert (= y$s$284_op (ite y$472 y$s$449_op y$n0s16))) (assert (= y$s$415_op (ite y$504 y$mod7.NumBytes y$s$456_op))) (assert (= y$s$416_op (ite y$498 y$s$415_op y$n0s16))) (assert (= y$s$277_op (ite y$470 y$s$416_op y$n0s16))) (assert (= y$s$423_op (ite y$498 y$s$277_op y$mod7.NumBytes))) (assert (= y$s$270_op (ite y$470 y$s$423_op y$n0s16))) (assert (= y$s$310_op (ite y$470 y$s$270_op y$741))) (assert (= y$s$311_op (ite y$472 y$s$284_op y$s$310_op))) (assert (= y$s$445_op (ite y$541 y$mod7.NumBytes y$741))) (assert (= y$s$263_op (ite y$466 y$s$445_op y$n0s16))) (assert (= y$w$52_op (Concat_16_8_8 y$mod1.output_buffer y$693))) (assert (= y$s$312_op (ite y$564 y$w$52_op y$mod7.NumBytes))) (assert (= y$s$313_op (ite y$466 y$s$263_op y$s$312_op))) (assert (= y$mod7.NumBytes$next_rhs_op (ite y$s$295_op y$s$311_op y$s$313_op))) (assert (= y$773 (= y$mod7.NumBytes$next y$mod7.NumBytes$next_rhs_op))) (assert (= y$s$412_op (and y$mod7.timeStampFlag y$504))) (assert (= y$s$413_op (and y$498 y$s$412_op))) (assert (= y$s$287_op (and y$470 y$s$413_op))) (assert (= y$s$421_op (ite y$498 y$s$287_op y$mod7.timeStampFlag))) (assert (= y$s$282_op (and y$470 y$s$421_op))) (assert (= y$s$308_op (and y$470 y$s$282_op))) (assert (= y$s$433_op (=> y$544 y$mod7.timeStampFlag))) (assert (= y$s$434_op (and y$541 y$s$433_op))) (assert (= y$s$275_op (and y$466 y$s$434_op))) (assert (= y$s$439_op (ite y$541 y$s$275_op y$mod7.timeStampFlag))) (assert (= y$s$268_op (and y$466 y$s$439_op))) (assert (= y$s$309_op (ite y$466 y$s$268_op y$mod7.timeStampFlag))) (assert (= y$mod7.timeStampFlag$next_rhs_op (ite y$s$298_op y$s$308_op y$s$309_op))) (assert (= y$801 (= y$mod7.timeStampFlag$next y$mod7.timeStampFlag$next_rhs_op))) (assert (= y$803 (= y$n2s2 y$mod7.module1.state))) (assert (= y$805 (= y$n3s2 y$mod7.module1.state))) (assert (= y$s$470_op (or y$803 y$805))) (assert (= y$s$486_op (ite y$481 y$n0s2 y$mod7.module1.state))) (assert (= y$s$468_op (ite y$805 y$s$486_op y$n0s2))) (assert (= y$w$53_op (Concat_32_8_24 y$mod1.output_buffer y$n0s24))) (assert (= y$s$481_op (Gr_1_32_32 y$w$53_op y$n1s32))) (assert (= y$817 (= y$n0s32 y$w$53_op))) (assert (= y$818 (= y$n1s32 y$w$53_op))) (assert (= y$s$494_op (ite y$818 y$n3s2 y$mod7.module1.state))) (assert (= y$s$465_op (ite y$803 y$s$494_op y$n0s2))) (assert (= y$s$490_op (ite y$817 y$n1s2 y$s$465_op))) (assert (= y$s$466_op (ite y$803 y$s$490_op y$n0s2))) (assert (= y$s$488_op (ite y$s$481_op y$n1s2 y$s$466_op))) (assert (= y$s$467_op (ite y$803 y$s$488_op y$n0s2))) (assert (= y$s$471_op (ite y$805 y$s$468_op y$s$467_op))) (assert (= y$833 (= y$n1s2 y$mod7.module1.state))) (assert (= (not (= y$n0s32 y$w$53_op)) y$834)) (assert (= y$s$498_op (ite y$817 y$n2s2 y$mod7.module1.state))) (assert (= y$s$463_op (ite y$833 y$s$498_op y$n0s2))) (assert (= y$s$496_op (ite y$834 y$n0s2 y$s$463_op))) (assert (= y$s$464_op (ite y$833 y$s$496_op y$n0s2))) (assert (= y$40 (= y$n0s2 y$mod7.module1.state))) (assert (= y$s$482_op (and y$601 y$817))) (assert (= y$s$500_op (ite y$s$482_op y$n1s2 y$mod7.module1.state))) (assert (= y$s$461_op (ite y$40 y$s$500_op y$n0s2))) (assert (= y$s$472_op (ite y$833 y$s$464_op y$s$461_op))) (assert (= y$mod7.module1.state$next_rhs_op (ite y$s$470_op y$s$471_op y$s$472_op))) (assert (= y$853 (= y$mod7.module1.state$next y$mod7.module1.state$next_rhs_op))) (assert (= y$s$484_op (and y$mod7.module1.done (not y$481)))) (assert (= y$s$462_op (and y$805 y$s$484_op))) (assert (= y$s$492_op (or y$mod7.module1.done y$818))) (assert (= y$s$460_op (and y$803 y$s$492_op))) (assert (= y$s$473_op (ite y$805 y$s$462_op y$s$460_op))) (assert (= y$mod7.module1.done$next_rhs_op (ite y$s$470_op y$s$473_op y$mod7.module1.done))) (assert (= y$867 (= y$mod7.module1.done$next y$mod7.module1.done$next_rhs_op))) (assert (= y$869 (= y$n6s4 y$mod7.module2.state))) (assert (= y$870 (= y$n7s4 y$mod7.module2.state))) (assert (= y$871 (= y$n8s4 y$mod7.module2.state))) (assert (= y$873 (= y$n9s4 y$mod7.module2.state))) (assert (= y$s$527_op (or y$871 y$873))) (assert (= y$877 (= y$n10s4 y$mod7.module2.state))) (assert (= y$879 (= y$n11s4 y$mod7.module2.state))) (assert (= y$881 (= y$n12s4 y$mod7.module2.state))) (assert (= y$883 (= y$n13s4 y$mod7.module2.state))) (assert (= y$s$526_op (or y$881 y$883))) (assert (= y$s$522_op (or y$877 y$879 y$s$526_op))) (assert (= y$s$524_op (or y$869 y$870 y$s$527_op y$s$522_op))) (assert (= y$s$531_op (ite y$883 y$n15s4 y$n13s4))) (assert (= y$s$532_op (ite y$879 y$n12s4 y$n11s4))) (assert (= y$s$533_op (ite y$s$526_op y$s$531_op y$s$532_op))) (assert (= y$s$534_op (ite y$873 y$n10s4 y$n9s4))) (assert (= y$s$535_op (ite y$870 y$n8s4 y$n7s4))) (assert (= y$s$536_op (ite y$s$527_op y$s$534_op y$s$535_op))) (assert (= y$s$537_op (ite y$s$522_op y$s$533_op y$s$536_op))) (assert (= y$904 (= y$n15s4 y$mod7.module2.state))) (assert (= y$905 (= y$n3s4 y$mod7.module2.state))) (assert (= y$906 (= y$n4s4 y$mod7.module2.state))) (assert (= y$907 (= y$n5s4 y$mod7.module2.state))) (assert (= y$s$528_op (or y$906 y$907))) (assert (= y$s$523_op (or y$904 y$905 y$s$528_op))) (assert (= y$s$538_op (ite y$907 y$n15s4 y$n5s4))) (assert (= y$w$54_op (Concat_32_1_31 y$mod7.time_stamp_start y$n0s31))) (assert (= y$916 (= y$n0s32 y$w$54_op))) (assert (= y$s$602_op (ite y$916 y$n0s4 y$mod7.module2.state))) (assert (= y$s$521_op (ite y$904 y$s$602_op y$n0s4))) (assert (= y$s$539_op (ite y$905 y$n4s4 y$s$521_op))) (assert (= y$s$540_op (ite y$s$528_op y$s$538_op y$s$539_op))) (assert (= y$926 (= y$n1s4 y$mod7.module2.state))) (assert (= y$927 (= y$n2s4 y$mod7.module2.state))) (assert (= y$s$529_op (or y$926 y$927))) (assert (= y$s$541_op (ite y$927 y$n6s4 y$n3s4))) (assert (= y$45 (= y$n0s4 y$mod7.module2.state))) (assert (= y$932 (= y$n1s32 y$w$54_op))) (assert (= y$w$55_op (Concat_32_1_31 y$mod7.timeStampFlag y$n0s31))) (assert (= y$935 (= y$n0s32 y$w$55_op))) (assert (= y$s$559_op (and y$932 y$935))) (assert (= y$939 (= y$n15s8 y$mod1.output_buffer))) (assert (= y$940 (Extract_4_3_0_8 y$mod1.output_buffer))) (assert (= y$942 (= y$n3s4 y$940))) (assert (= y$943 (= y$n2s4 y$940))) (assert (= y$s$575_op (ite y$943 y$n1s4 y$mod7.module2.state))) (assert (= y$s$576_op (ite y$s$559_op y$s$575_op y$n0s4))) (assert (= y$s$515_op (ite y$45 y$s$576_op y$n0s4))) (assert (= y$s$572_op (ite y$942 y$n2s4 y$s$515_op))) (assert (= y$s$573_op (ite y$s$559_op y$s$572_op y$n0s4))) (assert (= y$s$518_op (ite y$45 y$s$573_op y$n0s4))) (assert (= y$s$566_op (ite y$939 y$n15s4 y$s$518_op))) (assert (= y$s$567_op (ite y$s$559_op y$s$566_op y$n0s4))) (assert (= y$s$519_op (ite y$45 y$s$567_op y$n0s4))) (assert (= y$s$582_op (ite y$s$559_op y$s$519_op y$mod7.module2.state))) (assert (= y$s$512_op (ite y$45 y$s$582_op y$n0s4))) (assert (= y$s$609_op (ite y$s$559_op y$n0s4 y$s$512_op))) (assert (= y$s$520_op (ite y$45 y$s$609_op y$n0s4))) (assert (= y$s$542_op (ite y$45 y$s$520_op y$mod7.module2.state))) (assert (= y$s$543_op (ite y$s$529_op y$s$541_op y$s$542_op))) (assert (= y$s$544_op (ite y$s$523_op y$s$540_op y$s$543_op))) (assert (= y$mod7.module2.state$next_rhs_op (ite y$s$524_op y$s$537_op y$s$544_op))) (assert (= y$978 (= y$mod7.module2.state$next y$mod7.module2.state$next_rhs_op))) (assert (= y$s$525_op (or y$871 y$883 y$907))) (assert (= y$s$561_op (and y$mod7.module2.done (not y$916)))) (assert (= y$s$517_op (and y$904 y$s$561_op))) (assert (= y$s$563_op (or y$mod7.module2.done y$939))) (assert (= y$s$564_op (and y$s$559_op y$s$563_op))) (assert (= y$s$514_op (and y$45 y$s$564_op))) (assert (= y$s$580_op (ite y$s$559_op y$s$514_op y$mod7.module2.done))) (assert (= y$s$511_op (and y$45 y$s$580_op))) (assert (= y$s$549_op (ite y$45 y$s$511_op y$mod7.module2.done))) (assert (= y$s$550_op (ite y$904 y$s$517_op y$s$549_op))) (assert (= y$mod7.module2.done$next_rhs_op (or y$s$525_op y$s$550_op))) (assert (= y$1002 (= y$mod7.module2.done$next y$mod7.module2.done$next_rhs_op))) (assert (= y$s$530_op (or y$883 y$907))) (assert (= y$s$545_op (ite y$883 y$n10s4 y$n5s4))) (assert (= y$s$569_op (ite y$939 y$n1s4 y$mod7.module2.timeBytes))) (assert (= y$s$570_op (ite y$s$559_op y$s$569_op y$n0s4))) (assert (= y$s$516_op (ite y$45 y$s$570_op y$n0s4))) (assert (= y$s$578_op (ite y$s$559_op y$s$516_op y$mod7.module2.timeBytes))) (assert (= y$s$513_op (ite y$45 y$s$578_op y$n0s4))) (assert (= y$s$546_op (ite y$45 y$s$513_op y$mod7.module2.timeBytes))) (assert (= y$mod7.module2.timeBytes$next_rhs_op (ite y$s$530_op y$s$545_op y$s$546_op))) (assert (= y$1022 (= y$mod7.module2.timeBytes$next y$mod7.module2.timeBytes$next_rhs_op))) (assert (= y$1023 (and y$86 y$95 y$104 y$113 y$119 y$126 y$139 y$143 y$164 y$211 y$237 y$255 y$278 y$320 y$400 y$418 y$420 y$449 y$463 y$614 y$642 y$665 y$687 y$699 y$735 y$773 y$801 y$853 y$867 y$978 y$1002 y$1022))) (assert (= y$w$26$next_op (Concat_32_1_31 y$mod3.stop$next y$n0s31))) (assert (= (= y$n0s32 y$w$26$next_op) y$1040)) (assert (= y$w$27$next_op (Concat_32_1_31 y$packHeadStart$next y$n0s31))) (assert (= (= y$n1s32 y$w$27$next_op) y$1043)) (assert (= y$prop0$next_op (and y$1040 y$1043))) (assert (= y$1046 (= y$prop$next y$prop0$next_op))) (assert (= y$prop$next (not y$1037))) (assert (= y$mod3.stop$next (not y$1060))) (assert (= y$1061 (not (= y$n0s32 y$w$26$next_op)))) (assert (= y$1062 (and y$1060 y$1061))) (assert (= y$1062 (not y$1064))) (assert (= y$mod3.stop (not y$11))) (assert (= (not (= y$n0s32 y$w$26_op)) y$1049)) (assert (= y$1059 (and y$11 y$1049))) (assert (= y$1059 (not y$1063))) (assert (= y$1081 (not (= y$n1s32 y$w$27$next_op)))) (assert (= y$1082 (and y$packHeadStart$next y$1081))) (assert (= y$1082 (not y$1084))) (assert (= (not (= y$n1s32 y$w$27_op)) y$1051)) (assert (= y$1080 (and y$packHeadStart y$1051))) (assert (= y$1080 (not y$1083))) (assert (= y$1094 (and y$prop y$1028 y$1064 y$1063 y$1084 y$1083 y$1023 y$1046 y$1037))) (assert y$1094) (assert (distinct y$n0s2 y$n2s2 y$n1s2 y$n3s2)) (assert (distinct y$n0s3 y$n7s3 y$n3s3 y$n2s3 y$n1s3 y$n4s3 y$n5s3 y$n6s3)) (assert (distinct y$n0s4 y$n15s4 y$n4s4 y$n5s4 y$n6s4 y$n7s4 y$n8s4 y$n2s4 y$n3s4 y$n9s4 y$n10s4 y$n11s4 y$n12s4 y$n13s4 y$n1s4)) (assert (distinct y$n255s8 y$n0s8 y$n93s8 y$n1s8 y$n221s8 y$n128s8 y$n67s8 y$n195s8 y$n7s8 y$n131s8 y$n3s8 y$n191s8 y$n186s8 y$n185s8 y$n15s8)) (assert (not (= y$n1s32 y$n0s32))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/QF_UF-2018-Goel-hwbench-QF_UF_mpeg_ab_cti_max.smt2.expected.err000066400000000000000000000000001445011647600313250ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/QF_UF-2018-Goel-hwbench-QF_UF_mpeg_ab_cti_max.smt2.expected.out000066400000000000000000000000041445011647600313500ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/QF_UF-2018-Goel-hwbench-QF_UF_mpeg_ab_cti_max_delta_1.smt2000066400000000000000000000013211445011647600303360ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort u1 0) (declare-sort u2 0) (declare-fun Concat (Bool u1) u2) (declare-fun b0 () Bool) (declare-fun b1 () Bool) (declare-fun b2 () Bool) (declare-fun b3 () Bool) (declare-fun b4 () Bool) (declare-fun n01 () u1) (declare-fun n02 () u2) (declare-fun n12 () u2) (declare-fun w26 () u2) (declare-fun w27 () u2) (declare-fun w54 () u2) (assert (= n02 w54)) (assert (not (= n02 w26))) (assert (not (= n12 w27))) (assert (= b4 (not b0))) (assert (or (not b0) (not b1))) (assert (or (not b3) (not b2))) (assert (= b1 (not (= n02 w26)))) (assert (= b2 (not (= n12 w27)))) (assert (= w54 (Concat true n01))) (assert (= w26 (Concat b4 n01))) (assert (= w27 (Concat b3 n01))) (check-sat) (exit) QF_UF-2018-Goel-hwbench-QF_UF_mpeg_ab_cti_max_delta_1.smt2.expected.err000066400000000000000000000000001445011647600326370ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFQF_UF-2018-Goel-hwbench-QF_UF_mpeg_ab_cti_max_delta_1.smt2.expected.out000066400000000000000000000000061445011647600326640ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFunsat opensmt-2.5.2/regression/QF_UF/QF_UF-2018-Goel-hwbench-QF_UF_mpeg_ab_cti_max_simplified_0.smt2000066400000000000000000000006051445011647600313750ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort u1 0) (declare-sort u2 0) (declare-fun Concat (Bool u1) u2) (declare-fun y () Bool) (declare-fun mod () Bool) (declare-fun n1 () u1) (declare-fun n2 () u2) (declare-fun w2 () u2) (declare-fun w5 () u2) (assert (= w5 (Concat false n1))) (assert (= n2 w5)) (assert (= w2 (Concat mod n1))) (assert (= mod (not y))) (assert (not (= n2 w2))) (check-sat) (exit) QF_UF-2018-Goel-hwbench-QF_UF_mpeg_ab_cti_max_simplified_0.smt2.expected.err000066400000000000000000000000001445011647600336720ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFQF_UF-2018-Goel-hwbench-QF_UF_mpeg_ab_cti_max_simplified_0.smt2.expected.out000066400000000000000000000000041445011647600337150ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFsat opensmt-2.5.2/regression/QF_UF/SEQ_SEQ020_size3_delta_2.smt2000066400000000000000000000005661445011647600232040ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort U 0) (declare-fun p3 (U) Bool) (declare-fun f11 (U) U) (declare-fun f5 (U) U) (declare-fun c8 () U) (declare-fun c_0 () U) (declare-fun c_1 () U) (declare-fun c_2 () U) (assert (and (not (p3 (f11 c_1))) (p3 (f11 (f11 c_1))) (or (= (f11 (f11 c_1)) c_0) (= (f11 (f11 c_1)) (f11 c_1))) (or (= c_1 c8) (= (f11 c_1) c8)) )) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/SEQ_SEQ020_size3_delta_2.smt2.expected.err000066400000000000000000000000001445011647600255520ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/SEQ_SEQ020_size3_delta_2.smt2.expected.out000066400000000000000000000000041445011647600255750ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/SEQ_SEQ020_size3_delta_2.smt2.expected.time000066400000000000000000000000351445011647600257300ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_UF/dead_dnd007.smt2000066400000000000000000000752331445011647600210670ustar00rootroot00000000000000(set-logic QF_UF) (set-info :source | http://www.cs.bham.ac.uk/~vxs/quasigroups/benchmark/ |) (set-info :smt-lib-version 2.0) (set-info :category "crafted") ;(set-info :status unsat) (declare-sort U 0) (declare-sort I 0) (declare-fun unit () I) (declare-fun op (I I) I) (declare-fun e5 () I) (declare-fun e4 () I) (declare-fun e3 () I) (declare-fun e2 () I) (declare-fun e1 () I) (declare-fun e0 () I) (assert (let ((?v_0 (op e0 e0)) (?v_1 (op e0 e1)) (?v_2 (op e0 e2)) (?v_3 (op e0 e3)) (?v_4 (op e0 e4)) (?v_5 (op e0 e5)) (?v_6 (op e1 e0)) (?v_7 (op e1 e1)) (?v_8 (op e1 e2)) (?v_9 (op e1 e3)) (?v_10 (op e1 e4)) (?v_11 (op e1 e5)) (?v_12 (op e2 e0)) (?v_13 (op e2 e1)) (?v_14 (op e2 e2)) (?v_15 (op e2 e3)) (?v_16 (op e2 e4)) (?v_17 (op e2 e5)) (?v_18 (op e3 e0)) (?v_19 (op e3 e1)) (?v_20 (op e3 e2)) (?v_21 (op e3 e3)) (?v_22 (op e3 e4)) (?v_23 (op e3 e5)) (?v_24 (op e4 e0)) (?v_25 (op e4 e1)) (?v_26 (op e4 e2)) (?v_27 (op e4 e3)) (?v_28 (op e4 e4)) (?v_29 (op e4 e5)) (?v_30 (op e5 e0)) (?v_31 (op e5 e1)) (?v_32 (op e5 e2)) (?v_33 (op e5 e3)) (?v_34 (op e5 e4)) (?v_35 (op e5 e5))) (and (and (and (and (and (and (and (and (and (and (or (or (or (or (or (= ?v_0 e0) (= ?v_0 e1)) (= ?v_0 e2)) (= ?v_0 e3)) (= ?v_0 e4)) (= ?v_0 e5)) (or (or (or (or (or (= ?v_1 e0) (= ?v_1 e1)) (= ?v_1 e2)) (= ?v_1 e3)) (= ?v_1 e4)) (= ?v_1 e5))) (or (or (or (or (or (= ?v_2 e0) (= ?v_2 e1)) (= ?v_2 e2)) (= ?v_2 e3)) (= ?v_2 e4)) (= ?v_2 e5))) (or (or (or (or (or (= ?v_3 e0) (= ?v_3 e1)) (= ?v_3 e2)) (= ?v_3 e3)) (= ?v_3 e4)) (= ?v_3 e5))) (or (or (or (or (or (= ?v_4 e0) (= ?v_4 e1)) (= ?v_4 e2)) (= ?v_4 e3)) (= ?v_4 e4)) (= ?v_4 e5))) (or (or (or (or (or (= ?v_5 e0) (= ?v_5 e1)) (= ?v_5 e2)) (= ?v_5 e3)) (= ?v_5 e4)) (= ?v_5 e5))) (and (and (and (and (and (or (or (or (or (or (= ?v_6 e0) (= ?v_6 e1)) (= ?v_6 e2)) (= ?v_6 e3)) (= ?v_6 e4)) (= ?v_6 e5)) (or (or (or (or (or (= ?v_7 e0) (= ?v_7 e1)) (= ?v_7 e2)) (= ?v_7 e3)) (= ?v_7 e4)) (= ?v_7 e5))) (or (or (or (or (or (= ?v_8 e0) (= ?v_8 e1)) (= ?v_8 e2)) (= ?v_8 e3)) (= ?v_8 e4)) (= ?v_8 e5))) (or (or (or (or (or (= ?v_9 e0) (= ?v_9 e1)) (= ?v_9 e2)) (= ?v_9 e3)) (= ?v_9 e4)) (= ?v_9 e5))) (or (or (or (or (or (= ?v_10 e0) (= ?v_10 e1)) (= ?v_10 e2)) (= ?v_10 e3)) (= ?v_10 e4)) (= ?v_10 e5))) (or (or (or (or (or (= ?v_11 e0) (= ?v_11 e1)) (= ?v_11 e2)) (= ?v_11 e3)) (= ?v_11 e4)) (= ?v_11 e5)))) (and (and (and (and (and (or (or (or (or (or (= ?v_12 e0) (= ?v_12 e1)) (= ?v_12 e2)) (= ?v_12 e3)) (= ?v_12 e4)) (= ?v_12 e5)) (or (or (or (or (or (= ?v_13 e0) (= ?v_13 e1)) (= ?v_13 e2)) (= ?v_13 e3)) (= ?v_13 e4)) (= ?v_13 e5))) (or (or (or (or (or (= ?v_14 e0) (= ?v_14 e1)) (= ?v_14 e2)) (= ?v_14 e3)) (= ?v_14 e4)) (= ?v_14 e5))) (or (or (or (or (or (= ?v_15 e0) (= ?v_15 e1)) (= ?v_15 e2)) (= ?v_15 e3)) (= ?v_15 e4)) (= ?v_15 e5))) (or (or (or (or (or (= ?v_16 e0) (= ?v_16 e1)) (= ?v_16 e2)) (= ?v_16 e3)) (= ?v_16 e4)) (= ?v_16 e5))) (or (or (or (or (or (= ?v_17 e0) (= ?v_17 e1)) (= ?v_17 e2)) (= ?v_17 e3)) (= ?v_17 e4)) (= ?v_17 e5)))) (and (and (and (and (and (or (or (or (or (or (= ?v_18 e0) (= ?v_18 e1)) (= ?v_18 e2)) (= ?v_18 e3)) (= ?v_18 e4)) (= ?v_18 e5)) (or (or (or (or (or (= ?v_19 e0) (= ?v_19 e1)) (= ?v_19 e2)) (= ?v_19 e3)) (= ?v_19 e4)) (= ?v_19 e5))) (or (or (or (or (or (= ?v_20 e0) (= ?v_20 e1)) (= ?v_20 e2)) (= ?v_20 e3)) (= ?v_20 e4)) (= ?v_20 e5))) (or (or (or (or (or (= ?v_21 e0) (= ?v_21 e1)) (= ?v_21 e2)) (= ?v_21 e3)) (= ?v_21 e4)) (= ?v_21 e5))) (or (or (or (or (or (= ?v_22 e0) (= ?v_22 e1)) (= ?v_22 e2)) (= ?v_22 e3)) (= ?v_22 e4)) (= ?v_22 e5))) (or (or (or (or (or (= ?v_23 e0) (= ?v_23 e1)) (= ?v_23 e2)) (= ?v_23 e3)) (= ?v_23 e4)) (= ?v_23 e5)))) (and (and (and (and (and (or (or (or (or (or (= ?v_24 e0) (= ?v_24 e1)) (= ?v_24 e2)) (= ?v_24 e3)) (= ?v_24 e4)) (= ?v_24 e5)) (or (or (or (or (or (= ?v_25 e0) (= ?v_25 e1)) (= ?v_25 e2)) (= ?v_25 e3)) (= ?v_25 e4)) (= ?v_25 e5))) (or (or (or (or (or (= ?v_26 e0) (= ?v_26 e1)) (= ?v_26 e2)) (= ?v_26 e3)) (= ?v_26 e4)) (= ?v_26 e5))) (or (or (or (or (or (= ?v_27 e0) (= ?v_27 e1)) (= ?v_27 e2)) (= ?v_27 e3)) (= ?v_27 e4)) (= ?v_27 e5))) (or (or (or (or (or (= ?v_28 e0) (= ?v_28 e1)) (= ?v_28 e2)) (= ?v_28 e3)) (= ?v_28 e4)) (= ?v_28 e5))) (or (or (or (or (or (= ?v_29 e0) (= ?v_29 e1)) (= ?v_29 e2)) (= ?v_29 e3)) (= ?v_29 e4)) (= ?v_29 e5)))) (and (and (and (and (and (or (or (or (or (or (= ?v_30 e0) (= ?v_30 e1)) (= ?v_30 e2)) (= ?v_30 e3)) (= ?v_30 e4)) (= ?v_30 e5)) (or (or (or (or (or (= ?v_31 e0) (= ?v_31 e1)) (= ?v_31 e2)) (= ?v_31 e3)) (= ?v_31 e4)) (= ?v_31 e5))) (or (or (or (or (or (= ?v_32 e0) (= ?v_32 e1)) (= ?v_32 e2)) (= ?v_32 e3)) (= ?v_32 e4)) (= ?v_32 e5))) (or (or (or (or (or (= ?v_33 e0) (= ?v_33 e1)) (= ?v_33 e2)) (= ?v_33 e3)) (= ?v_33 e4)) (= ?v_33 e5))) (or (or (or (or (or (= ?v_34 e0) (= ?v_34 e1)) (= ?v_34 e2)) (= ?v_34 e3)) (= ?v_34 e4)) (= ?v_34 e5))) (or (or (or (or (or (= ?v_35 e0) (= ?v_35 e1)) (= ?v_35 e2)) (= ?v_35 e3)) (= ?v_35 e4)) (= ?v_35 e5)))))) (assert (let ((?v_1 (op e0 e0)) (?v_2 (op e0 e1)) (?v_3 (op e0 e2)) (?v_4 (op e0 e3)) (?v_5 (op e0 e4)) (?v_6 (op e0 e5)) (?v_8 (op e1 e0)) (?v_21 (op e1 e1)) (?v_22 (op e1 e2)) (?v_23 (op e1 e3)) (?v_24 (op e1 e4)) (?v_25 (op e1 e5)) (?v_9 (op e2 e0)) (?v_28 (op e2 e1)) (?v_51 (op e2 e2)) (?v_52 (op e2 e3)) (?v_53 (op e2 e4)) (?v_54 (op e2 e5)) (?v_10 (op e3 e0)) (?v_29 (op e3 e1)) (?v_58 (op e3 e2)) (?v_91 (op e3 e3)) (?v_92 (op e3 e4)) (?v_93 (op e3 e5)) (?v_11 (op e4 e0)) (?v_30 (op e4 e1)) (?v_59 (op e4 e2)) (?v_98 (op e4 e3)) (?v_141 (op e4 e4)) (?v_142 (op e4 e5)) (?v_12 (op e5 e0)) (?v_31 (op e5 e1)) (?v_60 (op e5 e2)) (?v_99 (op e5 e3)) (?v_148 (op e5 e4)) (?v_201 (op e5 e5))) (let ((?v_0 (= ?v_1 e0)) (?v_7 (= ?v_1 e1)) (?v_13 (= ?v_1 e2)) (?v_14 (= ?v_1 e3)) (?v_15 (= ?v_1 e4)) (?v_16 (= ?v_1 e5)) (?v_18 (= ?v_2 e0)) (?v_26 (= ?v_2 e1)) (?v_33 (= ?v_2 e2)) (?v_36 (= ?v_2 e3)) (?v_39 (= ?v_2 e4)) (?v_42 (= ?v_2 e5)) (?v_46 (= ?v_3 e0)) (?v_55 (= ?v_3 e1)) (?v_63 (= ?v_3 e2)) (?v_68 (= ?v_3 e3)) (?v_73 (= ?v_3 e4)) (?v_78 (= ?v_3 e5)) (?v_84 (= ?v_4 e0)) (?v_94 (= ?v_4 e1)) (?v_103 (= ?v_4 e2)) (?v_110 (= ?v_4 e3)) (?v_117 (= ?v_4 e4)) (?v_124 (= ?v_4 e5)) (?v_132 (= ?v_5 e0)) (?v_143 (= ?v_5 e1)) (?v_153 (= ?v_5 e2)) (?v_162 (= ?v_5 e3)) (?v_171 (= ?v_5 e4)) (?v_180 (= ?v_5 e5)) (?v_190 (= ?v_6 e0)) (?v_202 (= ?v_6 e1)) (?v_213 (= ?v_6 e2)) (?v_224 (= ?v_6 e3)) (?v_235 (= ?v_6 e4)) (?v_246 (= ?v_6 e5)) (?v_17 (= ?v_8 e0)) (?v_20 (= ?v_8 e1)) (?v_32 (= ?v_8 e2)) (?v_35 (= ?v_8 e3)) (?v_38 (= ?v_8 e4)) (?v_41 (= ?v_8 e5)) (?v_19 (= ?v_21 e0)) (?v_27 (= ?v_21 e1)) (?v_34 (= ?v_21 e2)) (?v_37 (= ?v_21 e3)) (?v_40 (= ?v_21 e4)) (?v_43 (= ?v_21 e5)) (?v_47 (= ?v_22 e0)) (?v_56 (= ?v_22 e1)) (?v_64 (= ?v_22 e2)) (?v_69 (= ?v_22 e3)) (?v_74 (= ?v_22 e4)) (?v_79 (= ?v_22 e5)) (?v_85 (= ?v_23 e0)) (?v_95 (= ?v_23 e1)) (?v_104 (= ?v_23 e2)) (?v_111 (= ?v_23 e3)) (?v_118 (= ?v_23 e4)) (?v_125 (= ?v_23 e5)) (?v_133 (= ?v_24 e0)) (?v_144 (= ?v_24 e1)) (?v_154 (= ?v_24 e2)) (?v_163 (= ?v_24 e3)) (?v_172 (= ?v_24 e4)) (?v_181 (= ?v_24 e5)) (?v_191 (= ?v_25 e0)) (?v_203 (= ?v_25 e1)) (?v_214 (= ?v_25 e2)) (?v_225 (= ?v_25 e3)) (?v_236 (= ?v_25 e4)) (?v_247 (= ?v_25 e5)) (?v_44 (= ?v_9 e0)) (?v_49 (= ?v_9 e1)) (?v_61 (= ?v_9 e2)) (?v_66 (= ?v_9 e3)) (?v_71 (= ?v_9 e4)) (?v_76 (= ?v_9 e5)) (?v_45 (= ?v_28 e0)) (?v_50 (= ?v_28 e1)) (?v_62 (= ?v_28 e2)) (?v_67 (= ?v_28 e3)) (?v_72 (= ?v_28 e4)) (?v_77 (= ?v_28 e5)) (?v_48 (= ?v_51 e0)) (?v_57 (= ?v_51 e1)) (?v_65 (= ?v_51 e2)) (?v_70 (= ?v_51 e3)) (?v_75 (= ?v_51 e4)) (?v_80 (= ?v_51 e5)) (?v_86 (= ?v_52 e0)) (?v_96 (= ?v_52 e1)) (?v_105 (= ?v_52 e2)) (?v_112 (= ?v_52 e3)) (?v_119 (= ?v_52 e4)) (?v_126 (= ?v_52 e5)) (?v_134 (= ?v_53 e0)) (?v_145 (= ?v_53 e1)) (?v_155 (= ?v_53 e2)) (?v_164 (= ?v_53 e3)) (?v_173 (= ?v_53 e4)) (?v_182 (= ?v_53 e5)) (?v_192 (= ?v_54 e0)) (?v_204 (= ?v_54 e1)) (?v_215 (= ?v_54 e2)) (?v_226 (= ?v_54 e3)) (?v_237 (= ?v_54 e4)) (?v_248 (= ?v_54 e5)) (?v_81 (= ?v_10 e0)) (?v_88 (= ?v_10 e1)) (?v_100 (= ?v_10 e2)) (?v_107 (= ?v_10 e3)) (?v_114 (= ?v_10 e4)) (?v_121 (= ?v_10 e5)) (?v_82 (= ?v_29 e0)) (?v_89 (= ?v_29 e1)) (?v_101 (= ?v_29 e2)) (?v_108 (= ?v_29 e3)) (?v_115 (= ?v_29 e4)) (?v_122 (= ?v_29 e5)) (?v_83 (= ?v_58 e0)) (?v_90 (= ?v_58 e1)) (?v_102 (= ?v_58 e2)) (?v_109 (= ?v_58 e3)) (?v_116 (= ?v_58 e4)) (?v_123 (= ?v_58 e5)) (?v_87 (= ?v_91 e0)) (?v_97 (= ?v_91 e1)) (?v_106 (= ?v_91 e2)) (?v_113 (= ?v_91 e3)) (?v_120 (= ?v_91 e4)) (?v_127 (= ?v_91 e5)) (?v_135 (= ?v_92 e0)) (?v_146 (= ?v_92 e1)) (?v_156 (= ?v_92 e2)) (?v_165 (= ?v_92 e3)) (?v_174 (= ?v_92 e4)) (?v_183 (= ?v_92 e5)) (?v_193 (= ?v_93 e0)) (?v_205 (= ?v_93 e1)) (?v_216 (= ?v_93 e2)) (?v_227 (= ?v_93 e3)) (?v_238 (= ?v_93 e4)) (?v_249 (= ?v_93 e5)) (?v_128 (= ?v_11 e0)) (?v_137 (= ?v_11 e1)) (?v_149 (= ?v_11 e2)) (?v_158 (= ?v_11 e3)) (?v_167 (= ?v_11 e4)) (?v_176 (= ?v_11 e5)) (?v_129 (= ?v_30 e0)) (?v_138 (= ?v_30 e1)) (?v_150 (= ?v_30 e2)) (?v_159 (= ?v_30 e3)) (?v_168 (= ?v_30 e4)) (?v_177 (= ?v_30 e5)) (?v_130 (= ?v_59 e0)) (?v_139 (= ?v_59 e1)) (?v_151 (= ?v_59 e2)) (?v_160 (= ?v_59 e3)) (?v_169 (= ?v_59 e4)) (?v_178 (= ?v_59 e5)) (?v_131 (= ?v_98 e0)) (?v_140 (= ?v_98 e1)) (?v_152 (= ?v_98 e2)) (?v_161 (= ?v_98 e3)) (?v_170 (= ?v_98 e4)) (?v_179 (= ?v_98 e5)) (?v_136 (= ?v_141 e0)) (?v_147 (= ?v_141 e1)) (?v_157 (= ?v_141 e2)) (?v_166 (= ?v_141 e3)) (?v_175 (= ?v_141 e4)) (?v_184 (= ?v_141 e5)) (?v_194 (= ?v_142 e0)) (?v_206 (= ?v_142 e1)) (?v_217 (= ?v_142 e2)) (?v_228 (= ?v_142 e3)) (?v_239 (= ?v_142 e4)) (?v_250 (= ?v_142 e5)) (?v_185 (= ?v_12 e0)) (?v_196 (= ?v_12 e1)) (?v_208 (= ?v_12 e2)) (?v_219 (= ?v_12 e3)) (?v_230 (= ?v_12 e4)) (?v_241 (= ?v_12 e5)) (?v_186 (= ?v_31 e0)) (?v_197 (= ?v_31 e1)) (?v_209 (= ?v_31 e2)) (?v_220 (= ?v_31 e3)) (?v_231 (= ?v_31 e4)) (?v_242 (= ?v_31 e5)) (?v_187 (= ?v_60 e0)) (?v_198 (= ?v_60 e1)) (?v_210 (= ?v_60 e2)) (?v_221 (= ?v_60 e3)) (?v_232 (= ?v_60 e4)) (?v_243 (= ?v_60 e5)) (?v_188 (= ?v_99 e0)) (?v_199 (= ?v_99 e1)) (?v_211 (= ?v_99 e2)) (?v_222 (= ?v_99 e3)) (?v_233 (= ?v_99 e4)) (?v_244 (= ?v_99 e5)) (?v_189 (= ?v_148 e0)) (?v_200 (= ?v_148 e1)) (?v_212 (= ?v_148 e2)) (?v_223 (= ?v_148 e3)) (?v_234 (= ?v_148 e4)) (?v_245 (= ?v_148 e5)) (?v_195 (= ?v_201 e0)) (?v_207 (= ?v_201 e1)) (?v_218 (= ?v_201 e2)) (?v_229 (= ?v_201 e3)) (?v_240 (= ?v_201 e4)) (?v_251 (= ?v_201 e5))) (and (and (and (and (and (and (and (and (and (and (and (or (or (or (or (or ?v_0 ?v_18) ?v_46) ?v_84) ?v_132) ?v_190) (or (or (or (or (or ?v_0 ?v_17) ?v_44) ?v_81) ?v_128) ?v_185)) (and (or (or (or (or (or ?v_7 ?v_26) ?v_55) ?v_94) ?v_143) ?v_202) (or (or (or (or (or ?v_7 ?v_20) ?v_49) ?v_88) ?v_137) ?v_196))) (and (or (or (or (or (or ?v_13 ?v_33) ?v_63) ?v_103) ?v_153) ?v_213) (or (or (or (or (or ?v_13 ?v_32) ?v_61) ?v_100) ?v_149) ?v_208))) (and (or (or (or (or (or ?v_14 ?v_36) ?v_68) ?v_110) ?v_162) ?v_224) (or (or (or (or (or ?v_14 ?v_35) ?v_66) ?v_107) ?v_158) ?v_219))) (and (or (or (or (or (or ?v_15 ?v_39) ?v_73) ?v_117) ?v_171) ?v_235) (or (or (or (or (or ?v_15 ?v_38) ?v_71) ?v_114) ?v_167) ?v_230))) (and (or (or (or (or (or ?v_16 ?v_42) ?v_78) ?v_124) ?v_180) ?v_246) (or (or (or (or (or ?v_16 ?v_41) ?v_76) ?v_121) ?v_176) ?v_241))) (and (and (and (and (and (and (or (or (or (or (or ?v_17 ?v_19) ?v_47) ?v_85) ?v_133) ?v_191) (or (or (or (or (or ?v_18 ?v_19) ?v_45) ?v_82) ?v_129) ?v_186)) (and (or (or (or (or (or ?v_20 ?v_27) ?v_56) ?v_95) ?v_144) ?v_203) (or (or (or (or (or ?v_26 ?v_27) ?v_50) ?v_89) ?v_138) ?v_197))) (and (or (or (or (or (or ?v_32 ?v_34) ?v_64) ?v_104) ?v_154) ?v_214) (or (or (or (or (or ?v_33 ?v_34) ?v_62) ?v_101) ?v_150) ?v_209))) (and (or (or (or (or (or ?v_35 ?v_37) ?v_69) ?v_111) ?v_163) ?v_225) (or (or (or (or (or ?v_36 ?v_37) ?v_67) ?v_108) ?v_159) ?v_220))) (and (or (or (or (or (or ?v_38 ?v_40) ?v_74) ?v_118) ?v_172) ?v_236) (or (or (or (or (or ?v_39 ?v_40) ?v_72) ?v_115) ?v_168) ?v_231))) (and (or (or (or (or (or ?v_41 ?v_43) ?v_79) ?v_125) ?v_181) ?v_247) (or (or (or (or (or ?v_42 ?v_43) ?v_77) ?v_122) ?v_177) ?v_242)))) (and (and (and (and (and (and (or (or (or (or (or ?v_44 ?v_45) ?v_48) ?v_86) ?v_134) ?v_192) (or (or (or (or (or ?v_46 ?v_47) ?v_48) ?v_83) ?v_130) ?v_187)) (and (or (or (or (or (or ?v_49 ?v_50) ?v_57) ?v_96) ?v_145) ?v_204) (or (or (or (or (or ?v_55 ?v_56) ?v_57) ?v_90) ?v_139) ?v_198))) (and (or (or (or (or (or ?v_61 ?v_62) ?v_65) ?v_105) ?v_155) ?v_215) (or (or (or (or (or ?v_63 ?v_64) ?v_65) ?v_102) ?v_151) ?v_210))) (and (or (or (or (or (or ?v_66 ?v_67) ?v_70) ?v_112) ?v_164) ?v_226) (or (or (or (or (or ?v_68 ?v_69) ?v_70) ?v_109) ?v_160) ?v_221))) (and (or (or (or (or (or ?v_71 ?v_72) ?v_75) ?v_119) ?v_173) ?v_237) (or (or (or (or (or ?v_73 ?v_74) ?v_75) ?v_116) ?v_169) ?v_232))) (and (or (or (or (or (or ?v_76 ?v_77) ?v_80) ?v_126) ?v_182) ?v_248) (or (or (or (or (or ?v_78 ?v_79) ?v_80) ?v_123) ?v_178) ?v_243)))) (and (and (and (and (and (and (or (or (or (or (or ?v_81 ?v_82) ?v_83) ?v_87) ?v_135) ?v_193) (or (or (or (or (or ?v_84 ?v_85) ?v_86) ?v_87) ?v_131) ?v_188)) (and (or (or (or (or (or ?v_88 ?v_89) ?v_90) ?v_97) ?v_146) ?v_205) (or (or (or (or (or ?v_94 ?v_95) ?v_96) ?v_97) ?v_140) ?v_199))) (and (or (or (or (or (or ?v_100 ?v_101) ?v_102) ?v_106) ?v_156) ?v_216) (or (or (or (or (or ?v_103 ?v_104) ?v_105) ?v_106) ?v_152) ?v_211))) (and (or (or (or (or (or ?v_107 ?v_108) ?v_109) ?v_113) ?v_165) ?v_227) (or (or (or (or (or ?v_110 ?v_111) ?v_112) ?v_113) ?v_161) ?v_222))) (and (or (or (or (or (or ?v_114 ?v_115) ?v_116) ?v_120) ?v_174) ?v_238) (or (or (or (or (or ?v_117 ?v_118) ?v_119) ?v_120) ?v_170) ?v_233))) (and (or (or (or (or (or ?v_121 ?v_122) ?v_123) ?v_127) ?v_183) ?v_249) (or (or (or (or (or ?v_124 ?v_125) ?v_126) ?v_127) ?v_179) ?v_244)))) (and (and (and (and (and (and (or (or (or (or (or ?v_128 ?v_129) ?v_130) ?v_131) ?v_136) ?v_194) (or (or (or (or (or ?v_132 ?v_133) ?v_134) ?v_135) ?v_136) ?v_189)) (and (or (or (or (or (or ?v_137 ?v_138) ?v_139) ?v_140) ?v_147) ?v_206) (or (or (or (or (or ?v_143 ?v_144) ?v_145) ?v_146) ?v_147) ?v_200))) (and (or (or (or (or (or ?v_149 ?v_150) ?v_151) ?v_152) ?v_157) ?v_217) (or (or (or (or (or ?v_153 ?v_154) ?v_155) ?v_156) ?v_157) ?v_212))) (and (or (or (or (or (or ?v_158 ?v_159) ?v_160) ?v_161) ?v_166) ?v_228) (or (or (or (or (or ?v_162 ?v_163) ?v_164) ?v_165) ?v_166) ?v_223))) (and (or (or (or (or (or ?v_167 ?v_168) ?v_169) ?v_170) ?v_175) ?v_239) (or (or (or (or (or ?v_171 ?v_172) ?v_173) ?v_174) ?v_175) ?v_234))) (and (or (or (or (or (or ?v_176 ?v_177) ?v_178) ?v_179) ?v_184) ?v_250) (or (or (or (or (or ?v_180 ?v_181) ?v_182) ?v_183) ?v_184) ?v_245)))) (and (and (and (and (and (and (or (or (or (or (or ?v_185 ?v_186) ?v_187) ?v_188) ?v_189) ?v_195) (or (or (or (or (or ?v_190 ?v_191) ?v_192) ?v_193) ?v_194) ?v_195)) (and (or (or (or (or (or ?v_196 ?v_197) ?v_198) ?v_199) ?v_200) ?v_207) (or (or (or (or (or ?v_202 ?v_203) ?v_204) ?v_205) ?v_206) ?v_207))) (and (or (or (or (or (or ?v_208 ?v_209) ?v_210) ?v_211) ?v_212) ?v_218) (or (or (or (or (or ?v_213 ?v_214) ?v_215) ?v_216) ?v_217) ?v_218))) (and (or (or (or (or (or ?v_219 ?v_220) ?v_221) ?v_222) ?v_223) ?v_229) (or (or (or (or (or ?v_224 ?v_225) ?v_226) ?v_227) ?v_228) ?v_229))) (and (or (or (or (or (or ?v_230 ?v_231) ?v_232) ?v_233) ?v_234) ?v_240) (or (or (or (or (or ?v_235 ?v_236) ?v_237) ?v_238) ?v_239) ?v_240))) (and (or (or (or (or (or ?v_241 ?v_242) ?v_243) ?v_244) ?v_245) ?v_251) (or (or (or (or (or ?v_246 ?v_247) ?v_248) ?v_249) ?v_250) ?v_251))))))) (assert (and (and (and (and (and (and (and (= (op unit e0) e0) (= (op e0 unit) e0)) (and (= (op unit e1) e1) (= (op e1 unit) e1))) (and (= (op unit e2) e2) (= (op e2 unit) e2))) (and (= (op unit e3) e3) (= (op e3 unit) e3))) (and (= (op unit e4) e4) (= (op e4 unit) e4))) (and (= (op unit e5) e5) (= (op e5 unit) e5))) (or (or (or (or (or (= unit e0) (= unit e1)) (= unit e2)) (= unit e3)) (= unit e4)) (= unit e5)))) (assert (let ((?v_0 (op e0 e0)) (?v_1 (op e0 e1)) (?v_4 (op e0 e2)) (?v_9 (op e0 e3)) (?v_16 (op e0 e4)) (?v_25 (op e0 e5)) (?v_2 (op e1 e0)) (?v_3 (op e1 e1)) (?v_6 (op e1 e2)) (?v_11 (op e1 e3)) (?v_18 (op e1 e4)) (?v_27 (op e1 e5)) (?v_5 (op e2 e0)) (?v_7 (op e2 e1)) (?v_8 (op e2 e2)) (?v_13 (op e2 e3)) (?v_20 (op e2 e4)) (?v_29 (op e2 e5)) (?v_10 (op e3 e0)) (?v_12 (op e3 e1)) (?v_14 (op e3 e2)) (?v_15 (op e3 e3)) (?v_22 (op e3 e4)) (?v_31 (op e3 e5)) (?v_17 (op e4 e0)) (?v_19 (op e4 e1)) (?v_21 (op e4 e2)) (?v_23 (op e4 e3)) (?v_24 (op e4 e4)) (?v_33 (op e4 e5)) (?v_26 (op e5 e0)) (?v_28 (op e5 e1)) (?v_30 (op e5 e2)) (?v_32 (op e5 e3)) (?v_34 (op e5 e4)) (?v_35 (op e5 e5))) (or (or (or (or (or (or (or (or (or (or (not (= ?v_0 ?v_0)) (not (= ?v_2 ?v_1))) (not (= ?v_5 ?v_4))) (not (= ?v_10 ?v_9))) (not (= ?v_17 ?v_16))) (not (= ?v_26 ?v_25))) (or (or (or (or (or (not (= ?v_1 ?v_2)) (not (= ?v_3 ?v_3))) (not (= ?v_7 ?v_6))) (not (= ?v_12 ?v_11))) (not (= ?v_19 ?v_18))) (not (= ?v_28 ?v_27)))) (or (or (or (or (or (not (= ?v_4 ?v_5)) (not (= ?v_6 ?v_7))) (not (= ?v_8 ?v_8))) (not (= ?v_14 ?v_13))) (not (= ?v_21 ?v_20))) (not (= ?v_30 ?v_29)))) (or (or (or (or (or (not (= ?v_9 ?v_10)) (not (= ?v_11 ?v_12))) (not (= ?v_13 ?v_14))) (not (= ?v_15 ?v_15))) (not (= ?v_23 ?v_22))) (not (= ?v_32 ?v_31)))) (or (or (or (or (or (not (= ?v_16 ?v_17)) (not (= ?v_18 ?v_19))) (not (= ?v_20 ?v_21))) (not (= ?v_22 ?v_23))) (not (= ?v_24 ?v_24))) (not (= ?v_34 ?v_33)))) (or (or (or (or (or (not (= ?v_25 ?v_26)) (not (= ?v_27 ?v_28))) (not (= ?v_29 ?v_30))) (not (= ?v_31 ?v_32))) (not (= ?v_33 ?v_34))) (not (= ?v_35 ?v_35)))))) (assert (or (or (or (or (or (and (and (and (and (and (not (= (op (op e0 e0) e0) e0)) (not (= (op (op e0 e1) e0) e1))) (not (= (op (op e0 e2) e0) e2))) (not (= (op (op e0 e3) e0) e3))) (not (= (op (op e0 e4) e0) e4))) (not (= (op (op e0 e5) e0) e5))) (and (and (and (and (and (not (= (op (op e1 e0) e1) e0)) (not (= (op (op e1 e1) e1) e1))) (not (= (op (op e1 e2) e1) e2))) (not (= (op (op e1 e3) e1) e3))) (not (= (op (op e1 e4) e1) e4))) (not (= (op (op e1 e5) e1) e5)))) (and (and (and (and (and (not (= (op (op e2 e0) e2) e0)) (not (= (op (op e2 e1) e2) e1))) (not (= (op (op e2 e2) e2) e2))) (not (= (op (op e2 e3) e2) e3))) (not (= (op (op e2 e4) e2) e4))) (not (= (op (op e2 e5) e2) e5)))) (and (and (and (and (and (not (= (op (op e3 e0) e3) e0)) (not (= (op (op e3 e1) e3) e1))) (not (= (op (op e3 e2) e3) e2))) (not (= (op (op e3 e3) e3) e3))) (not (= (op (op e3 e4) e3) e4))) (not (= (op (op e3 e5) e3) e5)))) (and (and (and (and (and (not (= (op (op e4 e0) e4) e0)) (not (= (op (op e4 e1) e4) e1))) (not (= (op (op e4 e2) e4) e2))) (not (= (op (op e4 e3) e4) e3))) (not (= (op (op e4 e4) e4) e4))) (not (= (op (op e4 e5) e4) e5)))) (and (and (and (and (and (not (= (op (op e5 e0) e5) e0)) (not (= (op (op e5 e1) e5) e1))) (not (= (op (op e5 e2) e5) e2))) (not (= (op (op e5 e3) e5) e3))) (not (= (op (op e5 e4) e5) e4))) (not (= (op (op e5 e5) e5) e5))))) (assert (let ((?v_0 (op e0 e0)) (?v_1 (op e0 e1)) (?v_2 (op e0 e2)) (?v_3 (op e0 e3)) (?v_4 (op e0 e4)) (?v_5 (op e0 e5)) (?v_6 (op e1 e0)) (?v_7 (op e1 e1)) (?v_8 (op e1 e2)) (?v_9 (op e1 e3)) (?v_10 (op e1 e4)) (?v_11 (op e1 e5)) (?v_12 (op e2 e0)) (?v_13 (op e2 e1)) (?v_14 (op e2 e2)) (?v_15 (op e2 e3)) (?v_16 (op e2 e4)) (?v_17 (op e2 e5)) (?v_18 (op e3 e0)) (?v_19 (op e3 e1)) (?v_20 (op e3 e2)) (?v_21 (op e3 e3)) (?v_22 (op e3 e4)) (?v_23 (op e3 e5)) (?v_24 (op e4 e0)) (?v_25 (op e4 e1)) (?v_26 (op e4 e2)) (?v_27 (op e4 e3)) (?v_28 (op e4 e4)) (?v_29 (op e4 e5)) (?v_30 (op e5 e0)) (?v_31 (op e5 e1)) (?v_32 (op e5 e2)) (?v_33 (op e5 e3)) (?v_34 (op e5 e4)) (?v_35 (op e5 e5))) (and (and (and (and (and (or (or (or (or (or (= (op ?v_0 ?v_0) e0) (= (op ?v_1 ?v_1) e1)) (= (op ?v_2 ?v_2) e2)) (= (op ?v_3 ?v_3) e3)) (= (op ?v_4 ?v_4) e4)) (= (op ?v_5 ?v_5) e5)) (or (or (or (or (or (= (op ?v_6 ?v_6) e0) (= (op ?v_7 ?v_7) e1)) (= (op ?v_8 ?v_8) e2)) (= (op ?v_9 ?v_9) e3)) (= (op ?v_10 ?v_10) e4)) (= (op ?v_11 ?v_11) e5))) (or (or (or (or (or (= (op ?v_12 ?v_12) e0) (= (op ?v_13 ?v_13) e1)) (= (op ?v_14 ?v_14) e2)) (= (op ?v_15 ?v_15) e3)) (= (op ?v_16 ?v_16) e4)) (= (op ?v_17 ?v_17) e5))) (or (or (or (or (or (= (op ?v_18 ?v_18) e0) (= (op ?v_19 ?v_19) e1)) (= (op ?v_20 ?v_20) e2)) (= (op ?v_21 ?v_21) e3)) (= (op ?v_22 ?v_22) e4)) (= (op ?v_23 ?v_23) e5))) (or (or (or (or (or (= (op ?v_24 ?v_24) e0) (= (op ?v_25 ?v_25) e1)) (= (op ?v_26 ?v_26) e2)) (= (op ?v_27 ?v_27) e3)) (= (op ?v_28 ?v_28) e4)) (= (op ?v_29 ?v_29) e5))) (or (or (or (or (or (= (op ?v_30 ?v_30) e0) (= (op ?v_31 ?v_31) e1)) (= (op ?v_32 ?v_32) e2)) (= (op ?v_33 ?v_33) e3)) (= (op ?v_34 ?v_34) e4)) (= (op ?v_35 ?v_35) e5))))) (assert (let ((?v_0 (op e0 e0)) (?v_6 (op e0 e1)) (?v_12 (op e0 e2)) (?v_18 (op e0 e3)) (?v_24 (op e0 e4)) (?v_30 (op e0 e5)) (?v_1 (op e1 e0)) (?v_7 (op e1 e1)) (?v_13 (op e1 e2)) (?v_19 (op e1 e3)) (?v_25 (op e1 e4)) (?v_31 (op e1 e5)) (?v_2 (op e2 e0)) (?v_8 (op e2 e1)) (?v_14 (op e2 e2)) (?v_20 (op e2 e3)) (?v_26 (op e2 e4)) (?v_32 (op e2 e5)) (?v_3 (op e3 e0)) (?v_9 (op e3 e1)) (?v_15 (op e3 e2)) (?v_21 (op e3 e3)) (?v_27 (op e3 e4)) (?v_33 (op e3 e5)) (?v_4 (op e4 e0)) (?v_10 (op e4 e1)) (?v_16 (op e4 e2)) (?v_22 (op e4 e3)) (?v_28 (op e4 e4)) (?v_34 (op e4 e5)) (?v_5 (op e5 e0)) (?v_11 (op e5 e1)) (?v_17 (op e5 e2)) (?v_23 (op e5 e3)) (?v_29 (op e5 e4)) (?v_35 (op e5 e5))) (or (or (or (or (or (and (and (and (and (and (not (= (op ?v_0 ?v_0) e0)) (not (= (op ?v_1 ?v_1) e1))) (not (= (op ?v_2 ?v_2) e2))) (not (= (op ?v_3 ?v_3) e3))) (not (= (op ?v_4 ?v_4) e4))) (not (= (op ?v_5 ?v_5) e5))) (and (and (and (and (and (not (= (op ?v_6 ?v_6) e0)) (not (= (op ?v_7 ?v_7) e1))) (not (= (op ?v_8 ?v_8) e2))) (not (= (op ?v_9 ?v_9) e3))) (not (= (op ?v_10 ?v_10) e4))) (not (= (op ?v_11 ?v_11) e5)))) (and (and (and (and (and (not (= (op ?v_12 ?v_12) e0)) (not (= (op ?v_13 ?v_13) e1))) (not (= (op ?v_14 ?v_14) e2))) (not (= (op ?v_15 ?v_15) e3))) (not (= (op ?v_16 ?v_16) e4))) (not (= (op ?v_17 ?v_17) e5)))) (and (and (and (and (and (not (= (op ?v_18 ?v_18) e0)) (not (= (op ?v_19 ?v_19) e1))) (not (= (op ?v_20 ?v_20) e2))) (not (= (op ?v_21 ?v_21) e3))) (not (= (op ?v_22 ?v_22) e4))) (not (= (op ?v_23 ?v_23) e5)))) (and (and (and (and (and (not (= (op ?v_24 ?v_24) e0)) (not (= (op ?v_25 ?v_25) e1))) (not (= (op ?v_26 ?v_26) e2))) (not (= (op ?v_27 ?v_27) e3))) (not (= (op ?v_28 ?v_28) e4))) (not (= (op ?v_29 ?v_29) e5)))) (and (and (and (and (and (not (= (op ?v_30 ?v_30) e0)) (not (= (op ?v_31 ?v_31) e1))) (not (= (op ?v_32 ?v_32) e2))) (not (= (op ?v_33 ?v_33) e3))) (not (= (op ?v_34 ?v_34) e4))) (not (= (op ?v_35 ?v_35) e5)))))) (assert (let ((?v_1 (op e0 e0)) (?v_7 (op e0 e1)) (?v_14 (op e0 e2)) (?v_21 (op e0 e3)) (?v_28 (op e0 e4)) (?v_35 (op e0 e5)) (?v_2 (op e1 e0)) (?v_9 (op e1 e1)) (?v_15 (op e1 e2)) (?v_22 (op e1 e3)) (?v_29 (op e1 e4)) (?v_36 (op e1 e5)) (?v_3 (op e2 e0)) (?v_10 (op e2 e1)) (?v_17 (op e2 e2)) (?v_23 (op e2 e3)) (?v_30 (op e2 e4)) (?v_37 (op e2 e5)) (?v_4 (op e3 e0)) (?v_11 (op e3 e1)) (?v_18 (op e3 e2)) (?v_25 (op e3 e3)) (?v_31 (op e3 e4)) (?v_38 (op e3 e5)) (?v_5 (op e4 e0)) (?v_12 (op e4 e1)) (?v_19 (op e4 e2)) (?v_26 (op e4 e3)) (?v_33 (op e4 e4)) (?v_39 (op e4 e5)) (?v_6 (op e5 e0)) (?v_13 (op e5 e1)) (?v_20 (op e5 e2)) (?v_27 (op e5 e3)) (?v_34 (op e5 e4)) (?v_41 (op e5 e5))) (let ((?v_0 (= (op e0 ?v_1) e0)) (?v_8 (= (op e1 ?v_9) e1)) (?v_16 (= (op e2 ?v_17) e2)) (?v_24 (= (op e3 ?v_25) e3)) (?v_32 (= (op e4 ?v_33) e4)) (?v_40 (= (op e5 ?v_41) e5))) (and (or (or (or (or (or (and ?v_0 (not (= e0 unit))) (and ?v_8 (not (= e1 unit)))) (and ?v_16 (not (= e2 unit)))) (and ?v_24 (not (= e3 unit)))) (and ?v_32 (not (= e4 unit)))) (and ?v_40 (not (= e5 unit)))) (or (or (or (or (or (and (and (and (and (and (or (not ?v_0) (= ?v_1 unit)) (or (not (= (op e1 ?v_2) e0)) (= ?v_2 unit))) (or (not (= (op e2 ?v_3) e0)) (= ?v_3 unit))) (or (not (= (op e3 ?v_4) e0)) (= ?v_4 unit))) (or (not (= (op e4 ?v_5) e0)) (= ?v_5 unit))) (or (not (= (op e5 ?v_6) e0)) (= ?v_6 unit))) (and (and (and (and (and (or (not (= (op e0 ?v_7) e1)) (= ?v_7 unit)) (or (not ?v_8) (= ?v_9 unit))) (or (not (= (op e2 ?v_10) e1)) (= ?v_10 unit))) (or (not (= (op e3 ?v_11) e1)) (= ?v_11 unit))) (or (not (= (op e4 ?v_12) e1)) (= ?v_12 unit))) (or (not (= (op e5 ?v_13) e1)) (= ?v_13 unit)))) (and (and (and (and (and (or (not (= (op e0 ?v_14) e2)) (= ?v_14 unit)) (or (not (= (op e1 ?v_15) e2)) (= ?v_15 unit))) (or (not ?v_16) (= ?v_17 unit))) (or (not (= (op e3 ?v_18) e2)) (= ?v_18 unit))) (or (not (= (op e4 ?v_19) e2)) (= ?v_19 unit))) (or (not (= (op e5 ?v_20) e2)) (= ?v_20 unit)))) (and (and (and (and (and (or (not (= (op e0 ?v_21) e3)) (= ?v_21 unit)) (or (not (= (op e1 ?v_22) e3)) (= ?v_22 unit))) (or (not (= (op e2 ?v_23) e3)) (= ?v_23 unit))) (or (not ?v_24) (= ?v_25 unit))) (or (not (= (op e4 ?v_26) e3)) (= ?v_26 unit))) (or (not (= (op e5 ?v_27) e3)) (= ?v_27 unit)))) (and (and (and (and (and (or (not (= (op e0 ?v_28) e4)) (= ?v_28 unit)) (or (not (= (op e1 ?v_29) e4)) (= ?v_29 unit))) (or (not (= (op e2 ?v_30) e4)) (= ?v_30 unit))) (or (not (= (op e3 ?v_31) e4)) (= ?v_31 unit))) (or (not ?v_32) (= ?v_33 unit))) (or (not (= (op e5 ?v_34) e4)) (= ?v_34 unit)))) (and (and (and (and (and (or (not (= (op e0 ?v_35) e5)) (= ?v_35 unit)) (or (not (= (op e1 ?v_36) e5)) (= ?v_36 unit))) (or (not (= (op e2 ?v_37) e5)) (= ?v_37 unit))) (or (not (= (op e3 ?v_38) e5)) (= ?v_38 unit))) (or (not (= (op e4 ?v_39) e5)) (= ?v_39 unit))) (or (not ?v_40) (= ?v_41 unit)))))))) (assert (= unit e0)) (assert (let ((?v_0 (op e0 e0)) (?v_6 (op e0 e1)) (?v_12 (op e0 e2)) (?v_18 (op e0 e3)) (?v_24 (op e0 e4)) (?v_30 (op e0 e5)) (?v_1 (op e1 e0)) (?v_7 (op e1 e1)) (?v_13 (op e1 e2)) (?v_19 (op e1 e3)) (?v_25 (op e1 e4)) (?v_31 (op e1 e5)) (?v_2 (op e2 e0)) (?v_8 (op e2 e1)) (?v_14 (op e2 e2)) (?v_20 (op e2 e3)) (?v_26 (op e2 e4)) (?v_32 (op e2 e5)) (?v_3 (op e3 e0)) (?v_9 (op e3 e1)) (?v_15 (op e3 e2)) (?v_21 (op e3 e3)) (?v_27 (op e3 e4)) (?v_33 (op e3 e5)) (?v_4 (op e4 e0)) (?v_10 (op e4 e1)) (?v_16 (op e4 e2)) (?v_22 (op e4 e3)) (?v_28 (op e4 e4)) (?v_34 (op e4 e5)) (?v_5 (op e5 e0)) (?v_11 (op e5 e1)) (?v_17 (op e5 e2)) (?v_23 (op e5 e3)) (?v_29 (op e5 e4)) (?v_35 (op e5 e5))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_1)) (not (= ?v_0 ?v_2))) (not (= ?v_0 ?v_3))) (not (= ?v_0 ?v_4))) (not (= ?v_0 ?v_5))) (not (= ?v_1 ?v_2))) (not (= ?v_1 ?v_3))) (not (= ?v_1 ?v_4))) (not (= ?v_1 ?v_5))) (not (= ?v_2 ?v_3))) (not (= ?v_2 ?v_4))) (not (= ?v_2 ?v_5))) (not (= ?v_3 ?v_4))) (not (= ?v_3 ?v_5))) (not (= ?v_4 ?v_5))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_6 ?v_7)) (not (= ?v_6 ?v_8))) (not (= ?v_6 ?v_9))) (not (= ?v_6 ?v_10))) (not (= ?v_6 ?v_11))) (not (= ?v_7 ?v_8))) (not (= ?v_7 ?v_9))) (not (= ?v_7 ?v_10))) (not (= ?v_7 ?v_11))) (not (= ?v_8 ?v_9))) (not (= ?v_8 ?v_10))) (not (= ?v_8 ?v_11))) (not (= ?v_9 ?v_10))) (not (= ?v_9 ?v_11))) (not (= ?v_10 ?v_11)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_12 ?v_13)) (not (= ?v_12 ?v_14))) (not (= ?v_12 ?v_15))) (not (= ?v_12 ?v_16))) (not (= ?v_12 ?v_17))) (not (= ?v_13 ?v_14))) (not (= ?v_13 ?v_15))) (not (= ?v_13 ?v_16))) (not (= ?v_13 ?v_17))) (not (= ?v_14 ?v_15))) (not (= ?v_14 ?v_16))) (not (= ?v_14 ?v_17))) (not (= ?v_15 ?v_16))) (not (= ?v_15 ?v_17))) (not (= ?v_16 ?v_17)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_18 ?v_19)) (not (= ?v_18 ?v_20))) (not (= ?v_18 ?v_21))) (not (= ?v_18 ?v_22))) (not (= ?v_18 ?v_23))) (not (= ?v_19 ?v_20))) (not (= ?v_19 ?v_21))) (not (= ?v_19 ?v_22))) (not (= ?v_19 ?v_23))) (not (= ?v_20 ?v_21))) (not (= ?v_20 ?v_22))) (not (= ?v_20 ?v_23))) (not (= ?v_21 ?v_22))) (not (= ?v_21 ?v_23))) (not (= ?v_22 ?v_23)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_24 ?v_25)) (not (= ?v_24 ?v_26))) (not (= ?v_24 ?v_27))) (not (= ?v_24 ?v_28))) (not (= ?v_24 ?v_29))) (not (= ?v_25 ?v_26))) (not (= ?v_25 ?v_27))) (not (= ?v_25 ?v_28))) (not (= ?v_25 ?v_29))) (not (= ?v_26 ?v_27))) (not (= ?v_26 ?v_28))) (not (= ?v_26 ?v_29))) (not (= ?v_27 ?v_28))) (not (= ?v_27 ?v_29))) (not (= ?v_28 ?v_29)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_30 ?v_31)) (not (= ?v_30 ?v_32))) (not (= ?v_30 ?v_33))) (not (= ?v_30 ?v_34))) (not (= ?v_30 ?v_35))) (not (= ?v_31 ?v_32))) (not (= ?v_31 ?v_33))) (not (= ?v_31 ?v_34))) (not (= ?v_31 ?v_35))) (not (= ?v_32 ?v_33))) (not (= ?v_32 ?v_34))) (not (= ?v_32 ?v_35))) (not (= ?v_33 ?v_34))) (not (= ?v_33 ?v_35))) (not (= ?v_34 ?v_35)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_6)) (not (= ?v_0 ?v_12))) (not (= ?v_0 ?v_18))) (not (= ?v_0 ?v_24))) (not (= ?v_0 ?v_30))) (not (= ?v_6 ?v_12))) (not (= ?v_6 ?v_18))) (not (= ?v_6 ?v_24))) (not (= ?v_6 ?v_30))) (not (= ?v_12 ?v_18))) (not (= ?v_12 ?v_24))) (not (= ?v_12 ?v_30))) (not (= ?v_18 ?v_24))) (not (= ?v_18 ?v_30))) (not (= ?v_24 ?v_30))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_1 ?v_7)) (not (= ?v_1 ?v_13))) (not (= ?v_1 ?v_19))) (not (= ?v_1 ?v_25))) (not (= ?v_1 ?v_31))) (not (= ?v_7 ?v_13))) (not (= ?v_7 ?v_19))) (not (= ?v_7 ?v_25))) (not (= ?v_7 ?v_31))) (not (= ?v_13 ?v_19))) (not (= ?v_13 ?v_25))) (not (= ?v_13 ?v_31))) (not (= ?v_19 ?v_25))) (not (= ?v_19 ?v_31))) (not (= ?v_25 ?v_31)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_2 ?v_8)) (not (= ?v_2 ?v_14))) (not (= ?v_2 ?v_20))) (not (= ?v_2 ?v_26))) (not (= ?v_2 ?v_32))) (not (= ?v_8 ?v_14))) (not (= ?v_8 ?v_20))) (not (= ?v_8 ?v_26))) (not (= ?v_8 ?v_32))) (not (= ?v_14 ?v_20))) (not (= ?v_14 ?v_26))) (not (= ?v_14 ?v_32))) (not (= ?v_20 ?v_26))) (not (= ?v_20 ?v_32))) (not (= ?v_26 ?v_32)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_3 ?v_9)) (not (= ?v_3 ?v_15))) (not (= ?v_3 ?v_21))) (not (= ?v_3 ?v_27))) (not (= ?v_3 ?v_33))) (not (= ?v_9 ?v_15))) (not (= ?v_9 ?v_21))) (not (= ?v_9 ?v_27))) (not (= ?v_9 ?v_33))) (not (= ?v_15 ?v_21))) (not (= ?v_15 ?v_27))) (not (= ?v_15 ?v_33))) (not (= ?v_21 ?v_27))) (not (= ?v_21 ?v_33))) (not (= ?v_27 ?v_33)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_4 ?v_10)) (not (= ?v_4 ?v_16))) (not (= ?v_4 ?v_22))) (not (= ?v_4 ?v_28))) (not (= ?v_4 ?v_34))) (not (= ?v_10 ?v_16))) (not (= ?v_10 ?v_22))) (not (= ?v_10 ?v_28))) (not (= ?v_10 ?v_34))) (not (= ?v_16 ?v_22))) (not (= ?v_16 ?v_28))) (not (= ?v_16 ?v_34))) (not (= ?v_22 ?v_28))) (not (= ?v_22 ?v_34))) (not (= ?v_28 ?v_34)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_5 ?v_11)) (not (= ?v_5 ?v_17))) (not (= ?v_5 ?v_23))) (not (= ?v_5 ?v_29))) (not (= ?v_5 ?v_35))) (not (= ?v_11 ?v_17))) (not (= ?v_11 ?v_23))) (not (= ?v_11 ?v_29))) (not (= ?v_11 ?v_35))) (not (= ?v_17 ?v_23))) (not (= ?v_17 ?v_29))) (not (= ?v_17 ?v_35))) (not (= ?v_23 ?v_29))) (not (= ?v_23 ?v_35))) (not (= ?v_29 ?v_35))))))) (assert (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= e0 e1)) (not (= e0 e2))) (not (= e0 e3))) (not (= e0 e4))) (not (= e0 e5))) (not (= e1 e2))) (not (= e1 e3))) (not (= e1 e4))) (not (= e1 e5))) (not (= e2 e3))) (not (= e2 e4))) (not (= e2 e5))) (not (= e3 e4))) (not (= e3 e5))) (not (= e4 e5)))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/dead_dnd007.smt2.expected.err000066400000000000000000000000001445011647600234320ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/dead_dnd007.smt2.expected.out000066400000000000000000000000061445011647600234570ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UF/dead_dnd007.smt2.expected.time000066400000000000000000000000351445011647600236100ustar00rootroot00000000000000real 0.33 user 0.33 sys 0.00 opensmt-2.5.2/regression/QF_UF/dead_dnd007_simplified_1.smt2000066400000000000000000000005211445011647600235000ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort I 0) (declare-fun op (I I) I) (declare-fun e5 () I) (declare-fun e4 () I) (declare-fun e2 () I) (declare-fun e1 () I) (declare-fun e0 () I) (assert (and (= (op e5 e2) e0) (= (op e5 e2) e2) (or (= (op e4 e0) e0) (= (op e4 e1) e0)) (= (op e4 e1) e2))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/dead_dnd007_simplified_1.smt2.expected.err000066400000000000000000000000001445011647600260570ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/dead_dnd007_simplified_1.smt2.expected.out000066400000000000000000000000041445011647600261020ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/dead_dnd007_simplified_1.smt2.expected.time000066400000000000000000000000351445011647600262350ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_UF/distinct-test.smt2000066400000000000000000000037621445011647600217120ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort U 0) (declare-fun x0 () U) (declare-fun x1 () U) (declare-fun x2 () U) (declare-fun x3 () U) (declare-fun x4 () U) (declare-fun x5 () U) (declare-fun x6 () U) (declare-fun x7 () U) (declare-fun x8 () U) (assert (and (distinct x0 x1 x2) (distinct x0 x1 x3) (distinct x0 x1 x4) (distinct x0 x1 x5) (distinct x0 x1 x6) (distinct x0 x1 x7) (distinct x0 x1 x8) (distinct x0 x2 x3) (distinct x0 x2 x4) (distinct x0 x2 x5) (distinct x0 x2 x6) (distinct x0 x2 x7) (distinct x0 x2 x8) (distinct x0 x3 x4) (distinct x0 x3 x5) (distinct x0 x3 x6) (distinct x0 x3 x7) (distinct x0 x3 x8) (distinct x0 x4 x5) (distinct x0 x4 x6) (distinct x0 x4 x7) (distinct x0 x4 x8) (distinct x0 x5 x6) (distinct x0 x5 x7) (distinct x0 x5 x8) (distinct x0 x6 x7) (distinct x0 x6 x8) (distinct x0 x7 x8) (distinct x1 x2 x3) (distinct x1 x2 x4) (distinct x1 x2 x5) (distinct x1 x2 x6) (distinct x1 x2 x7) (distinct x1 x2 x8) (distinct x1 x3 x4) (distinct x1 x3 x5) (distinct x1 x3 x6) (distinct x1 x3 x7) (distinct x1 x3 x8) (distinct x1 x4 x5) (distinct x1 x4 x6) (distinct x1 x4 x7) (distinct x1 x4 x8) (distinct x1 x5 x6) (distinct x1 x5 x7) (distinct x1 x5 x8) (distinct x1 x6 x7) (distinct x1 x6 x8) (distinct x1 x7 x8) (distinct x2 x3 x4) (distinct x2 x3 x5) (distinct x2 x3 x6) (distinct x2 x3 x7) (distinct x2 x3 x8) (distinct x2 x4 x5) (distinct x2 x4 x6) (distinct x2 x4 x7) (distinct x2 x4 x8) (distinct x2 x5 x6) (distinct x2 x5 x7) (distinct x2 x5 x8) (distinct x2 x6 x7) (distinct x2 x6 x8) (distinct x2 x7 x8) (distinct x3 x4 x5) (distinct x3 x4 x6) (distinct x3 x4 x7) (distinct x3 x4 x8) (distinct x3 x5 x6) (distinct x3 x5 x7) (distinct x3 x5 x8) (distinct x3 x6 x7) (distinct x3 x6 x8) (distinct x3 x7 x8) (distinct x4 x5 x6) (distinct x4 x5 x7) (distinct x4 x5 x8) (distinct x4 x6 x7) (distinct x4 x6 x8) (distinct x4 x7 x8) (distinct x5 x6 x7) (distinct x5 x6 x8) (distinct x5 x7 x8) (distinct x6 x7 x8))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/distinct-test.smt2.expected.err000066400000000000000000000000001445011647600242570ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/distinct-test.smt2.expected.out000066400000000000000000000000041445011647600243020ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/distinct_model_1.smt2000066400000000000000000000003401445011647600223220ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort U 0) (declare-fun c1 () U) (declare-fun c2 () U) (declare-fun c3 () U) (assert (not (= c1 c2))) (assert (not (= c1 c3))) (assert (not (= c2 c3))) (check-sat) (get-value ((distinct c1 c2 c3))) opensmt-2.5.2/regression/QF_UF/distinct_model_1.smt2.expected.err000066400000000000000000000000001445011647600247020ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/distinct_model_1.smt2.expected.out000066400000000000000000000000411445011647600247260ustar00rootroot00000000000000sat (((distinct c1 c2 c3) true)) opensmt-2.5.2/regression/QF_UF/distinct_model_2.smt2000066400000000000000000000002431445011647600223250ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort U 0) (declare-fun c1 () U) (declare-fun c2 () U) (declare-fun c3 () U) (assert (distinct c1 c2 c3)) (assert (= c2 c3)) (check-sat) opensmt-2.5.2/regression/QF_UF/distinct_model_2.smt2.expected.err000066400000000000000000000000001445011647600247030ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/distinct_model_2.smt2.expected.out000066400000000000000000000000061445011647600247300ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UF/eq_diamond45.smt2000066400000000000000000000141211445011647600213540ustar00rootroot00000000000000(set-logic QF_UF) (set-info :source | Generating minimum transitivity constraints in P-time for deciding Equality Logic, Ofer Strichman and Mirron Rozanov, SMT Workshop 2005. Translator: Leonardo de Moura. |) (set-info :smt-lib-version 2.0) (set-info :category "crafted") (set-info :status unsat) (declare-sort U 0) (declare-fun x0 () U) (declare-fun y0 () U) (declare-fun z0 () U) (declare-fun x1 () U) (declare-fun y1 () U) (declare-fun z1 () U) (declare-fun x2 () U) (declare-fun y2 () U) (declare-fun z2 () U) (declare-fun x3 () U) (declare-fun y3 () U) (declare-fun z3 () U) (declare-fun x4 () U) (declare-fun y4 () U) (declare-fun z4 () U) (declare-fun x5 () U) (declare-fun y5 () U) (declare-fun z5 () U) (declare-fun x6 () U) (declare-fun y6 () U) (declare-fun z6 () U) (declare-fun x7 () U) (declare-fun y7 () U) (declare-fun z7 () U) (declare-fun x8 () U) (declare-fun y8 () U) (declare-fun z8 () U) (declare-fun x9 () U) (declare-fun y9 () U) (declare-fun z9 () U) (declare-fun x10 () U) (declare-fun y10 () U) (declare-fun z10 () U) (declare-fun x11 () U) (declare-fun y11 () U) (declare-fun z11 () U) (declare-fun x12 () U) (declare-fun y12 () U) (declare-fun z12 () U) (declare-fun x13 () U) (declare-fun y13 () U) (declare-fun z13 () U) (declare-fun x14 () U) (declare-fun y14 () U) (declare-fun z14 () U) (declare-fun x15 () U) (declare-fun y15 () U) (declare-fun z15 () U) (declare-fun x16 () U) (declare-fun y16 () U) (declare-fun z16 () U) (declare-fun x17 () U) (declare-fun y17 () U) (declare-fun z17 () U) (declare-fun x18 () U) (declare-fun y18 () U) (declare-fun z18 () U) (declare-fun x19 () U) (declare-fun y19 () U) (declare-fun z19 () U) (declare-fun x20 () U) (declare-fun y20 () U) (declare-fun z20 () U) (declare-fun x21 () U) (declare-fun y21 () U) (declare-fun z21 () U) (declare-fun x22 () U) (declare-fun y22 () U) (declare-fun z22 () U) (declare-fun x23 () U) (declare-fun y23 () U) (declare-fun z23 () U) (declare-fun x24 () U) (declare-fun y24 () U) (declare-fun z24 () U) (declare-fun x25 () U) (declare-fun y25 () U) (declare-fun z25 () U) (declare-fun x26 () U) (declare-fun y26 () U) (declare-fun z26 () U) (declare-fun x27 () U) (declare-fun y27 () U) (declare-fun z27 () U) (declare-fun x28 () U) (declare-fun y28 () U) (declare-fun z28 () U) (declare-fun x29 () U) (declare-fun y29 () U) (declare-fun z29 () U) (declare-fun x30 () U) (declare-fun y30 () U) (declare-fun z30 () U) (declare-fun x31 () U) (declare-fun y31 () U) (declare-fun z31 () U) (declare-fun x32 () U) (declare-fun y32 () U) (declare-fun z32 () U) (declare-fun x33 () U) (declare-fun y33 () U) (declare-fun z33 () U) (declare-fun x34 () U) (declare-fun y34 () U) (declare-fun z34 () U) (declare-fun x35 () U) (declare-fun y35 () U) (declare-fun z35 () U) (declare-fun x36 () U) (declare-fun y36 () U) (declare-fun z36 () U) (declare-fun x37 () U) (declare-fun y37 () U) (declare-fun z37 () U) (declare-fun x38 () U) (declare-fun y38 () U) (declare-fun z38 () U) (declare-fun x39 () U) (declare-fun y39 () U) (declare-fun z39 () U) (declare-fun x40 () U) (declare-fun y40 () U) (declare-fun z40 () U) (declare-fun x41 () U) (declare-fun y41 () U) (declare-fun z41 () U) (declare-fun x42 () U) (declare-fun y42 () U) (declare-fun z42 () U) (declare-fun x43 () U) (declare-fun y43 () U) (declare-fun z43 () U) (declare-fun x44 () U) (declare-fun y44 () U) (declare-fun z44 () U) (assert (and (or (and (= x0 y0) (= y0 x1)) (and (= x0 z0) (= z0 x1))) (or (and (= x1 y1) (= y1 x2)) (and (= x1 z1) (= z1 x2))) (or (and (= x2 y2) (= y2 x3)) (and (= x2 z2) (= z2 x3))) (or (and (= x3 y3) (= y3 x4)) (and (= x3 z3) (= z3 x4))) (or (and (= x4 y4) (= y4 x5)) (and (= x4 z4) (= z4 x5))) (or (and (= x5 y5) (= y5 x6)) (and (= x5 z5) (= z5 x6))) (or (and (= x6 y6) (= y6 x7)) (and (= x6 z6) (= z6 x7))) (or (and (= x7 y7) (= y7 x8)) (and (= x7 z7) (= z7 x8))) (or (and (= x8 y8) (= y8 x9)) (and (= x8 z8) (= z8 x9))) (or (and (= x9 y9) (= y9 x10)) (and (= x9 z9) (= z9 x10))) (or (and (= x10 y10) (= y10 x11)) (and (= x10 z10) (= z10 x11))) (or (and (= x11 y11) (= y11 x12)) (and (= x11 z11) (= z11 x12))) (or (and (= x12 y12) (= y12 x13)) (and (= x12 z12) (= z12 x13))) (or (and (= x13 y13) (= y13 x14)) (and (= x13 z13) (= z13 x14))) (or (and (= x14 y14) (= y14 x15)) (and (= x14 z14) (= z14 x15))) (or (and (= x15 y15) (= y15 x16)) (and (= x15 z15) (= z15 x16))) (or (and (= x16 y16) (= y16 x17)) (and (= x16 z16) (= z16 x17))) (or (and (= x17 y17) (= y17 x18)) (and (= x17 z17) (= z17 x18))) (or (and (= x18 y18) (= y18 x19)) (and (= x18 z18) (= z18 x19))) (or (and (= x19 y19) (= y19 x20)) (and (= x19 z19) (= z19 x20))) (or (and (= x20 y20) (= y20 x21)) (and (= x20 z20) (= z20 x21))) (or (and (= x21 y21) (= y21 x22)) (and (= x21 z21) (= z21 x22))) (or (and (= x22 y22) (= y22 x23)) (and (= x22 z22) (= z22 x23))) (or (and (= x23 y23) (= y23 x24)) (and (= x23 z23) (= z23 x24))) (or (and (= x24 y24) (= y24 x25)) (and (= x24 z24) (= z24 x25))) (or (and (= x25 y25) (= y25 x26)) (and (= x25 z25) (= z25 x26))) (or (and (= x26 y26) (= y26 x27)) (and (= x26 z26) (= z26 x27))) (or (and (= x27 y27) (= y27 x28)) (and (= x27 z27) (= z27 x28))) (or (and (= x28 y28) (= y28 x29)) (and (= x28 z28) (= z28 x29))) (or (and (= x29 y29) (= y29 x30)) (and (= x29 z29) (= z29 x30))) (or (and (= x30 y30) (= y30 x31)) (and (= x30 z30) (= z30 x31))) (or (and (= x31 y31) (= y31 x32)) (and (= x31 z31) (= z31 x32))) (or (and (= x32 y32) (= y32 x33)) (and (= x32 z32) (= z32 x33))) (or (and (= x33 y33) (= y33 x34)) (and (= x33 z33) (= z33 x34))) (or (and (= x34 y34) (= y34 x35)) (and (= x34 z34) (= z34 x35))) (or (and (= x35 y35) (= y35 x36)) (and (= x35 z35) (= z35 x36))) (or (and (= x36 y36) (= y36 x37)) (and (= x36 z36) (= z36 x37))) (or (and (= x37 y37) (= y37 x38)) (and (= x37 z37) (= z37 x38))) (or (and (= x38 y38) (= y38 x39)) (and (= x38 z38) (= z38 x39))) (or (and (= x39 y39) (= y39 x40)) (and (= x39 z39) (= z39 x40))) (or (and (= x40 y40) (= y40 x41)) (and (= x40 z40) (= z40 x41))) (or (and (= x41 y41) (= y41 x42)) (and (= x41 z41) (= z41 x42))) (or (and (= x42 y42) (= y42 x43)) (and (= x42 z42) (= z42 x43))) (or (and (= x43 y43) (= y43 x44)) (and (= x43 z43) (= z43 x44))) (not (= x0 x44)))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/eq_diamond45.smt2.expected.err000066400000000000000000000000001445011647600237320ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/eq_diamond45.smt2.expected.out000066400000000000000000000000061445011647600237570ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UF/eq_diamond45.smt2.expected.time000066400000000000000000000000351445011647600241100ustar00rootroot00000000000000real 0.03 user 0.03 sys 0.00 opensmt-2.5.2/regression/QF_UF/get-value.smt2000066400000000000000000000002641445011647600207770ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort U 0) (declare-fun f () U) (declare-fun g () U) (declare-fun h () U) (assert (and (= f g) (not (= f h)))) (check-sat) (get-value (f g h true false)) opensmt-2.5.2/regression/QF_UF/get-value.smt2.expected.err000066400000000000000000000000001445011647600233520ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/get-value.smt2.expected.out000066400000000000000000000001061445011647600234000ustar00rootroot00000000000000sat ((f (as @2 U))(g (as @2 U))(h (as @3 U))(true true)(false false)) opensmt-2.5.2/regression/QF_UF/get-value.smt2.expected.time000066400000000000000000000000351445011647600235300ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_UF/iso_brn029.smt2000066400000000000000000002040361445011647600207770ustar00rootroot00000000000000(set-logic QF_UF) (set-info :source | http://www.cs.bham.ac.uk/~vxs/quasigroups/benchmark/ |) (set-info :smt-lib-version 2.0) (set-info :category "crafted") ;(set-info :status sat) (declare-sort U 0) (declare-sort I 0) (declare-fun op1 (I I) I) (declare-fun unit () I) (declare-fun op (I I) I) (declare-fun e5 () I) (declare-fun e4 () I) (declare-fun e3 () I) (declare-fun e2 () I) (declare-fun e1 () I) (declare-fun e0 () I) (assert (let ((?v_0 (op e0 e0)) (?v_1 (op e0 e1)) (?v_2 (op e0 e2)) (?v_3 (op e0 e3)) (?v_4 (op e0 e4)) (?v_5 (op e0 e5)) (?v_6 (op e1 e0)) (?v_7 (op e1 e1)) (?v_8 (op e1 e2)) (?v_9 (op e1 e3)) (?v_10 (op e1 e4)) (?v_11 (op e1 e5)) (?v_12 (op e2 e0)) (?v_13 (op e2 e1)) (?v_14 (op e2 e2)) (?v_15 (op e2 e3)) (?v_16 (op e2 e4)) (?v_17 (op e2 e5)) (?v_18 (op e3 e0)) (?v_19 (op e3 e1)) (?v_20 (op e3 e2)) (?v_21 (op e3 e3)) (?v_22 (op e3 e4)) (?v_23 (op e3 e5)) (?v_24 (op e4 e0)) (?v_25 (op e4 e1)) (?v_26 (op e4 e2)) (?v_27 (op e4 e3)) (?v_28 (op e4 e4)) (?v_29 (op e4 e5)) (?v_30 (op e5 e0)) (?v_31 (op e5 e1)) (?v_32 (op e5 e2)) (?v_33 (op e5 e3)) (?v_34 (op e5 e4)) (?v_35 (op e5 e5))) (and (and (and (and (and (and (and (and (and (and (or (or (or (or (or (= ?v_0 e0) (= ?v_0 e1)) (= ?v_0 e2)) (= ?v_0 e3)) (= ?v_0 e4)) (= ?v_0 e5)) (or (or (or (or (or (= ?v_1 e0) (= ?v_1 e1)) (= ?v_1 e2)) (= ?v_1 e3)) (= ?v_1 e4)) (= ?v_1 e5))) (or (or (or (or (or (= ?v_2 e0) (= ?v_2 e1)) (= ?v_2 e2)) (= ?v_2 e3)) (= ?v_2 e4)) (= ?v_2 e5))) (or (or (or (or (or (= ?v_3 e0) (= ?v_3 e1)) (= ?v_3 e2)) (= ?v_3 e3)) (= ?v_3 e4)) (= ?v_3 e5))) (or (or (or (or (or (= ?v_4 e0) (= ?v_4 e1)) (= ?v_4 e2)) (= ?v_4 e3)) (= ?v_4 e4)) (= ?v_4 e5))) (or (or (or (or (or (= ?v_5 e0) (= ?v_5 e1)) (= ?v_5 e2)) (= ?v_5 e3)) (= ?v_5 e4)) (= ?v_5 e5))) (and (and (and (and (and (or (or (or (or (or (= ?v_6 e0) (= ?v_6 e1)) (= ?v_6 e2)) (= ?v_6 e3)) (= ?v_6 e4)) (= ?v_6 e5)) (or (or (or (or (or (= ?v_7 e0) (= ?v_7 e1)) (= ?v_7 e2)) (= ?v_7 e3)) (= ?v_7 e4)) (= ?v_7 e5))) (or (or (or (or (or (= ?v_8 e0) (= ?v_8 e1)) (= ?v_8 e2)) (= ?v_8 e3)) (= ?v_8 e4)) (= ?v_8 e5))) (or (or (or (or (or (= ?v_9 e0) (= ?v_9 e1)) (= ?v_9 e2)) (= ?v_9 e3)) (= ?v_9 e4)) (= ?v_9 e5))) (or (or (or (or (or (= ?v_10 e0) (= ?v_10 e1)) (= ?v_10 e2)) (= ?v_10 e3)) (= ?v_10 e4)) (= ?v_10 e5))) (or (or (or (or (or (= ?v_11 e0) (= ?v_11 e1)) (= ?v_11 e2)) (= ?v_11 e3)) (= ?v_11 e4)) (= ?v_11 e5)))) (and (and (and (and (and (or (or (or (or (or (= ?v_12 e0) (= ?v_12 e1)) (= ?v_12 e2)) (= ?v_12 e3)) (= ?v_12 e4)) (= ?v_12 e5)) (or (or (or (or (or (= ?v_13 e0) (= ?v_13 e1)) (= ?v_13 e2)) (= ?v_13 e3)) (= ?v_13 e4)) (= ?v_13 e5))) (or (or (or (or (or (= ?v_14 e0) (= ?v_14 e1)) (= ?v_14 e2)) (= ?v_14 e3)) (= ?v_14 e4)) (= ?v_14 e5))) (or (or (or (or (or (= ?v_15 e0) (= ?v_15 e1)) (= ?v_15 e2)) (= ?v_15 e3)) (= ?v_15 e4)) (= ?v_15 e5))) (or (or (or (or (or (= ?v_16 e0) (= ?v_16 e1)) (= ?v_16 e2)) (= ?v_16 e3)) (= ?v_16 e4)) (= ?v_16 e5))) (or (or (or (or (or (= ?v_17 e0) (= ?v_17 e1)) (= ?v_17 e2)) (= ?v_17 e3)) (= ?v_17 e4)) (= ?v_17 e5)))) (and (and (and (and (and (or (or (or (or (or (= ?v_18 e0) (= ?v_18 e1)) (= ?v_18 e2)) (= ?v_18 e3)) (= ?v_18 e4)) (= ?v_18 e5)) (or (or (or (or (or (= ?v_19 e0) (= ?v_19 e1)) (= ?v_19 e2)) (= ?v_19 e3)) (= ?v_19 e4)) (= ?v_19 e5))) (or (or (or (or (or (= ?v_20 e0) (= ?v_20 e1)) (= ?v_20 e2)) (= ?v_20 e3)) (= ?v_20 e4)) (= ?v_20 e5))) (or (or (or (or (or (= ?v_21 e0) (= ?v_21 e1)) (= ?v_21 e2)) (= ?v_21 e3)) (= ?v_21 e4)) (= ?v_21 e5))) (or (or (or (or (or (= ?v_22 e0) (= ?v_22 e1)) (= ?v_22 e2)) (= ?v_22 e3)) (= ?v_22 e4)) (= ?v_22 e5))) (or (or (or (or (or (= ?v_23 e0) (= ?v_23 e1)) (= ?v_23 e2)) (= ?v_23 e3)) (= ?v_23 e4)) (= ?v_23 e5)))) (and (and (and (and (and (or (or (or (or (or (= ?v_24 e0) (= ?v_24 e1)) (= ?v_24 e2)) (= ?v_24 e3)) (= ?v_24 e4)) (= ?v_24 e5)) (or (or (or (or (or (= ?v_25 e0) (= ?v_25 e1)) (= ?v_25 e2)) (= ?v_25 e3)) (= ?v_25 e4)) (= ?v_25 e5))) (or (or (or (or (or (= ?v_26 e0) (= ?v_26 e1)) (= ?v_26 e2)) (= ?v_26 e3)) (= ?v_26 e4)) (= ?v_26 e5))) (or (or (or (or (or (= ?v_27 e0) (= ?v_27 e1)) (= ?v_27 e2)) (= ?v_27 e3)) (= ?v_27 e4)) (= ?v_27 e5))) (or (or (or (or (or (= ?v_28 e0) (= ?v_28 e1)) (= ?v_28 e2)) (= ?v_28 e3)) (= ?v_28 e4)) (= ?v_28 e5))) (or (or (or (or (or (= ?v_29 e0) (= ?v_29 e1)) (= ?v_29 e2)) (= ?v_29 e3)) (= ?v_29 e4)) (= ?v_29 e5)))) (and (and (and (and (and (or (or (or (or (or (= ?v_30 e0) (= ?v_30 e1)) (= ?v_30 e2)) (= ?v_30 e3)) (= ?v_30 e4)) (= ?v_30 e5)) (or (or (or (or (or (= ?v_31 e0) (= ?v_31 e1)) (= ?v_31 e2)) (= ?v_31 e3)) (= ?v_31 e4)) (= ?v_31 e5))) (or (or (or (or (or (= ?v_32 e0) (= ?v_32 e1)) (= ?v_32 e2)) (= ?v_32 e3)) (= ?v_32 e4)) (= ?v_32 e5))) (or (or (or (or (or (= ?v_33 e0) (= ?v_33 e1)) (= ?v_33 e2)) (= ?v_33 e3)) (= ?v_33 e4)) (= ?v_33 e5))) (or (or (or (or (or (= ?v_34 e0) (= ?v_34 e1)) (= ?v_34 e2)) (= ?v_34 e3)) (= ?v_34 e4)) (= ?v_34 e5))) (or (or (or (or (or (= ?v_35 e0) (= ?v_35 e1)) (= ?v_35 e2)) (= ?v_35 e3)) (= ?v_35 e4)) (= ?v_35 e5)))))) (assert (let ((?v_1 (op e0 e0)) (?v_2 (op e0 e1)) (?v_3 (op e0 e2)) (?v_4 (op e0 e3)) (?v_5 (op e0 e4)) (?v_6 (op e0 e5)) (?v_8 (op e1 e0)) (?v_21 (op e1 e1)) (?v_22 (op e1 e2)) (?v_23 (op e1 e3)) (?v_24 (op e1 e4)) (?v_25 (op e1 e5)) (?v_9 (op e2 e0)) (?v_28 (op e2 e1)) (?v_51 (op e2 e2)) (?v_52 (op e2 e3)) (?v_53 (op e2 e4)) (?v_54 (op e2 e5)) (?v_10 (op e3 e0)) (?v_29 (op e3 e1)) (?v_58 (op e3 e2)) (?v_91 (op e3 e3)) (?v_92 (op e3 e4)) (?v_93 (op e3 e5)) (?v_11 (op e4 e0)) (?v_30 (op e4 e1)) (?v_59 (op e4 e2)) (?v_98 (op e4 e3)) (?v_141 (op e4 e4)) (?v_142 (op e4 e5)) (?v_12 (op e5 e0)) (?v_31 (op e5 e1)) (?v_60 (op e5 e2)) (?v_99 (op e5 e3)) (?v_148 (op e5 e4)) (?v_201 (op e5 e5))) (let ((?v_0 (= ?v_1 e0)) (?v_7 (= ?v_1 e1)) (?v_13 (= ?v_1 e2)) (?v_14 (= ?v_1 e3)) (?v_15 (= ?v_1 e4)) (?v_16 (= ?v_1 e5)) (?v_18 (= ?v_2 e0)) (?v_26 (= ?v_2 e1)) (?v_33 (= ?v_2 e2)) (?v_36 (= ?v_2 e3)) (?v_39 (= ?v_2 e4)) (?v_42 (= ?v_2 e5)) (?v_46 (= ?v_3 e0)) (?v_55 (= ?v_3 e1)) (?v_63 (= ?v_3 e2)) (?v_68 (= ?v_3 e3)) (?v_73 (= ?v_3 e4)) (?v_78 (= ?v_3 e5)) (?v_84 (= ?v_4 e0)) (?v_94 (= ?v_4 e1)) (?v_103 (= ?v_4 e2)) (?v_110 (= ?v_4 e3)) (?v_117 (= ?v_4 e4)) (?v_124 (= ?v_4 e5)) (?v_132 (= ?v_5 e0)) (?v_143 (= ?v_5 e1)) (?v_153 (= ?v_5 e2)) (?v_162 (= ?v_5 e3)) (?v_171 (= ?v_5 e4)) (?v_180 (= ?v_5 e5)) (?v_190 (= ?v_6 e0)) (?v_202 (= ?v_6 e1)) (?v_213 (= ?v_6 e2)) (?v_224 (= ?v_6 e3)) (?v_235 (= ?v_6 e4)) (?v_246 (= ?v_6 e5)) (?v_17 (= ?v_8 e0)) (?v_20 (= ?v_8 e1)) (?v_32 (= ?v_8 e2)) (?v_35 (= ?v_8 e3)) (?v_38 (= ?v_8 e4)) (?v_41 (= ?v_8 e5)) (?v_19 (= ?v_21 e0)) (?v_27 (= ?v_21 e1)) (?v_34 (= ?v_21 e2)) (?v_37 (= ?v_21 e3)) (?v_40 (= ?v_21 e4)) (?v_43 (= ?v_21 e5)) (?v_47 (= ?v_22 e0)) (?v_56 (= ?v_22 e1)) (?v_64 (= ?v_22 e2)) (?v_69 (= ?v_22 e3)) (?v_74 (= ?v_22 e4)) (?v_79 (= ?v_22 e5)) (?v_85 (= ?v_23 e0)) (?v_95 (= ?v_23 e1)) (?v_104 (= ?v_23 e2)) (?v_111 (= ?v_23 e3)) (?v_118 (= ?v_23 e4)) (?v_125 (= ?v_23 e5)) (?v_133 (= ?v_24 e0)) (?v_144 (= ?v_24 e1)) (?v_154 (= ?v_24 e2)) (?v_163 (= ?v_24 e3)) (?v_172 (= ?v_24 e4)) (?v_181 (= ?v_24 e5)) (?v_191 (= ?v_25 e0)) (?v_203 (= ?v_25 e1)) (?v_214 (= ?v_25 e2)) (?v_225 (= ?v_25 e3)) (?v_236 (= ?v_25 e4)) (?v_247 (= ?v_25 e5)) (?v_44 (= ?v_9 e0)) (?v_49 (= ?v_9 e1)) (?v_61 (= ?v_9 e2)) (?v_66 (= ?v_9 e3)) (?v_71 (= ?v_9 e4)) (?v_76 (= ?v_9 e5)) (?v_45 (= ?v_28 e0)) (?v_50 (= ?v_28 e1)) (?v_62 (= ?v_28 e2)) (?v_67 (= ?v_28 e3)) (?v_72 (= ?v_28 e4)) (?v_77 (= ?v_28 e5)) (?v_48 (= ?v_51 e0)) (?v_57 (= ?v_51 e1)) (?v_65 (= ?v_51 e2)) (?v_70 (= ?v_51 e3)) (?v_75 (= ?v_51 e4)) (?v_80 (= ?v_51 e5)) (?v_86 (= ?v_52 e0)) (?v_96 (= ?v_52 e1)) (?v_105 (= ?v_52 e2)) (?v_112 (= ?v_52 e3)) (?v_119 (= ?v_52 e4)) (?v_126 (= ?v_52 e5)) (?v_134 (= ?v_53 e0)) (?v_145 (= ?v_53 e1)) (?v_155 (= ?v_53 e2)) (?v_164 (= ?v_53 e3)) (?v_173 (= ?v_53 e4)) (?v_182 (= ?v_53 e5)) (?v_192 (= ?v_54 e0)) (?v_204 (= ?v_54 e1)) (?v_215 (= ?v_54 e2)) (?v_226 (= ?v_54 e3)) (?v_237 (= ?v_54 e4)) (?v_248 (= ?v_54 e5)) (?v_81 (= ?v_10 e0)) (?v_88 (= ?v_10 e1)) (?v_100 (= ?v_10 e2)) (?v_107 (= ?v_10 e3)) (?v_114 (= ?v_10 e4)) (?v_121 (= ?v_10 e5)) (?v_82 (= ?v_29 e0)) (?v_89 (= ?v_29 e1)) (?v_101 (= ?v_29 e2)) (?v_108 (= ?v_29 e3)) (?v_115 (= ?v_29 e4)) (?v_122 (= ?v_29 e5)) (?v_83 (= ?v_58 e0)) (?v_90 (= ?v_58 e1)) (?v_102 (= ?v_58 e2)) (?v_109 (= ?v_58 e3)) (?v_116 (= ?v_58 e4)) (?v_123 (= ?v_58 e5)) (?v_87 (= ?v_91 e0)) (?v_97 (= ?v_91 e1)) (?v_106 (= ?v_91 e2)) (?v_113 (= ?v_91 e3)) (?v_120 (= ?v_91 e4)) (?v_127 (= ?v_91 e5)) (?v_135 (= ?v_92 e0)) (?v_146 (= ?v_92 e1)) (?v_156 (= ?v_92 e2)) (?v_165 (= ?v_92 e3)) (?v_174 (= ?v_92 e4)) (?v_183 (= ?v_92 e5)) (?v_193 (= ?v_93 e0)) (?v_205 (= ?v_93 e1)) (?v_216 (= ?v_93 e2)) (?v_227 (= ?v_93 e3)) (?v_238 (= ?v_93 e4)) (?v_249 (= ?v_93 e5)) (?v_128 (= ?v_11 e0)) (?v_137 (= ?v_11 e1)) (?v_149 (= ?v_11 e2)) (?v_158 (= ?v_11 e3)) (?v_167 (= ?v_11 e4)) (?v_176 (= ?v_11 e5)) (?v_129 (= ?v_30 e0)) (?v_138 (= ?v_30 e1)) (?v_150 (= ?v_30 e2)) (?v_159 (= ?v_30 e3)) (?v_168 (= ?v_30 e4)) (?v_177 (= ?v_30 e5)) (?v_130 (= ?v_59 e0)) (?v_139 (= ?v_59 e1)) (?v_151 (= ?v_59 e2)) (?v_160 (= ?v_59 e3)) (?v_169 (= ?v_59 e4)) (?v_178 (= ?v_59 e5)) (?v_131 (= ?v_98 e0)) (?v_140 (= ?v_98 e1)) (?v_152 (= ?v_98 e2)) (?v_161 (= ?v_98 e3)) (?v_170 (= ?v_98 e4)) (?v_179 (= ?v_98 e5)) (?v_136 (= ?v_141 e0)) (?v_147 (= ?v_141 e1)) (?v_157 (= ?v_141 e2)) (?v_166 (= ?v_141 e3)) (?v_175 (= ?v_141 e4)) (?v_184 (= ?v_141 e5)) (?v_194 (= ?v_142 e0)) (?v_206 (= ?v_142 e1)) (?v_217 (= ?v_142 e2)) (?v_228 (= ?v_142 e3)) (?v_239 (= ?v_142 e4)) (?v_250 (= ?v_142 e5)) (?v_185 (= ?v_12 e0)) (?v_196 (= ?v_12 e1)) (?v_208 (= ?v_12 e2)) (?v_219 (= ?v_12 e3)) (?v_230 (= ?v_12 e4)) (?v_241 (= ?v_12 e5)) (?v_186 (= ?v_31 e0)) (?v_197 (= ?v_31 e1)) (?v_209 (= ?v_31 e2)) (?v_220 (= ?v_31 e3)) (?v_231 (= ?v_31 e4)) (?v_242 (= ?v_31 e5)) (?v_187 (= ?v_60 e0)) (?v_198 (= ?v_60 e1)) (?v_210 (= ?v_60 e2)) (?v_221 (= ?v_60 e3)) (?v_232 (= ?v_60 e4)) (?v_243 (= ?v_60 e5)) (?v_188 (= ?v_99 e0)) (?v_199 (= ?v_99 e1)) (?v_211 (= ?v_99 e2)) (?v_222 (= ?v_99 e3)) (?v_233 (= ?v_99 e4)) (?v_244 (= ?v_99 e5)) (?v_189 (= ?v_148 e0)) (?v_200 (= ?v_148 e1)) (?v_212 (= ?v_148 e2)) (?v_223 (= ?v_148 e3)) (?v_234 (= ?v_148 e4)) (?v_245 (= ?v_148 e5)) (?v_195 (= ?v_201 e0)) (?v_207 (= ?v_201 e1)) (?v_218 (= ?v_201 e2)) (?v_229 (= ?v_201 e3)) (?v_240 (= ?v_201 e4)) (?v_251 (= ?v_201 e5))) (and (and (and (and (and (and (and (and (and (and (and (or (or (or (or (or ?v_0 ?v_18) ?v_46) ?v_84) ?v_132) ?v_190) (or (or (or (or (or ?v_0 ?v_17) ?v_44) ?v_81) ?v_128) ?v_185)) (and (or (or (or (or (or ?v_7 ?v_26) ?v_55) ?v_94) ?v_143) ?v_202) (or (or (or (or (or ?v_7 ?v_20) ?v_49) ?v_88) ?v_137) ?v_196))) (and (or (or (or (or (or ?v_13 ?v_33) ?v_63) ?v_103) ?v_153) ?v_213) (or (or (or (or (or ?v_13 ?v_32) ?v_61) ?v_100) ?v_149) ?v_208))) (and (or (or (or (or (or ?v_14 ?v_36) ?v_68) ?v_110) ?v_162) ?v_224) (or (or (or (or (or ?v_14 ?v_35) ?v_66) ?v_107) ?v_158) ?v_219))) (and (or (or (or (or (or ?v_15 ?v_39) ?v_73) ?v_117) ?v_171) ?v_235) (or (or (or (or (or ?v_15 ?v_38) ?v_71) ?v_114) ?v_167) ?v_230))) (and (or (or (or (or (or ?v_16 ?v_42) ?v_78) ?v_124) ?v_180) ?v_246) (or (or (or (or (or ?v_16 ?v_41) ?v_76) ?v_121) ?v_176) ?v_241))) (and (and (and (and (and (and (or (or (or (or (or ?v_17 ?v_19) ?v_47) ?v_85) ?v_133) ?v_191) (or (or (or (or (or ?v_18 ?v_19) ?v_45) ?v_82) ?v_129) ?v_186)) (and (or (or (or (or (or ?v_20 ?v_27) ?v_56) ?v_95) ?v_144) ?v_203) (or (or (or (or (or ?v_26 ?v_27) ?v_50) ?v_89) ?v_138) ?v_197))) (and (or (or (or (or (or ?v_32 ?v_34) ?v_64) ?v_104) ?v_154) ?v_214) (or (or (or (or (or ?v_33 ?v_34) ?v_62) ?v_101) ?v_150) ?v_209))) (and (or (or (or (or (or ?v_35 ?v_37) ?v_69) ?v_111) ?v_163) ?v_225) (or (or (or (or (or ?v_36 ?v_37) ?v_67) ?v_108) ?v_159) ?v_220))) (and (or (or (or (or (or ?v_38 ?v_40) ?v_74) ?v_118) ?v_172) ?v_236) (or (or (or (or (or ?v_39 ?v_40) ?v_72) ?v_115) ?v_168) ?v_231))) (and (or (or (or (or (or ?v_41 ?v_43) ?v_79) ?v_125) ?v_181) ?v_247) (or (or (or (or (or ?v_42 ?v_43) ?v_77) ?v_122) ?v_177) ?v_242)))) (and (and (and (and (and (and (or (or (or (or (or ?v_44 ?v_45) ?v_48) ?v_86) ?v_134) ?v_192) (or (or (or (or (or ?v_46 ?v_47) ?v_48) ?v_83) ?v_130) ?v_187)) (and (or (or (or (or (or ?v_49 ?v_50) ?v_57) ?v_96) ?v_145) ?v_204) (or (or (or (or (or ?v_55 ?v_56) ?v_57) ?v_90) ?v_139) ?v_198))) (and (or (or (or (or (or ?v_61 ?v_62) ?v_65) ?v_105) ?v_155) ?v_215) (or (or (or (or (or ?v_63 ?v_64) ?v_65) ?v_102) ?v_151) ?v_210))) (and (or (or (or (or (or ?v_66 ?v_67) ?v_70) ?v_112) ?v_164) ?v_226) (or (or (or (or (or ?v_68 ?v_69) ?v_70) ?v_109) ?v_160) ?v_221))) (and (or (or (or (or (or ?v_71 ?v_72) ?v_75) ?v_119) ?v_173) ?v_237) (or (or (or (or (or ?v_73 ?v_74) ?v_75) ?v_116) ?v_169) ?v_232))) (and (or (or (or (or (or ?v_76 ?v_77) ?v_80) ?v_126) ?v_182) ?v_248) (or (or (or (or (or ?v_78 ?v_79) ?v_80) ?v_123) ?v_178) ?v_243)))) (and (and (and (and (and (and (or (or (or (or (or ?v_81 ?v_82) ?v_83) ?v_87) ?v_135) ?v_193) (or (or (or (or (or ?v_84 ?v_85) ?v_86) ?v_87) ?v_131) ?v_188)) (and (or (or (or (or (or ?v_88 ?v_89) ?v_90) ?v_97) ?v_146) ?v_205) (or (or (or (or (or ?v_94 ?v_95) ?v_96) ?v_97) ?v_140) ?v_199))) (and (or (or (or (or (or ?v_100 ?v_101) ?v_102) ?v_106) ?v_156) ?v_216) (or (or (or (or (or ?v_103 ?v_104) ?v_105) ?v_106) ?v_152) ?v_211))) (and (or (or (or (or (or ?v_107 ?v_108) ?v_109) ?v_113) ?v_165) ?v_227) (or (or (or (or (or ?v_110 ?v_111) ?v_112) ?v_113) ?v_161) ?v_222))) (and (or (or (or (or (or ?v_114 ?v_115) ?v_116) ?v_120) ?v_174) ?v_238) (or (or (or (or (or ?v_117 ?v_118) ?v_119) ?v_120) ?v_170) ?v_233))) (and (or (or (or (or (or ?v_121 ?v_122) ?v_123) ?v_127) ?v_183) ?v_249) (or (or (or (or (or ?v_124 ?v_125) ?v_126) ?v_127) ?v_179) ?v_244)))) (and (and (and (and (and (and (or (or (or (or (or ?v_128 ?v_129) ?v_130) ?v_131) ?v_136) ?v_194) (or (or (or (or (or ?v_132 ?v_133) ?v_134) ?v_135) ?v_136) ?v_189)) (and (or (or (or (or (or ?v_137 ?v_138) ?v_139) ?v_140) ?v_147) ?v_206) (or (or (or (or (or ?v_143 ?v_144) ?v_145) ?v_146) ?v_147) ?v_200))) (and (or (or (or (or (or ?v_149 ?v_150) ?v_151) ?v_152) ?v_157) ?v_217) (or (or (or (or (or ?v_153 ?v_154) ?v_155) ?v_156) ?v_157) ?v_212))) (and (or (or (or (or (or ?v_158 ?v_159) ?v_160) ?v_161) ?v_166) ?v_228) (or (or (or (or (or ?v_162 ?v_163) ?v_164) ?v_165) ?v_166) ?v_223))) (and (or (or (or (or (or ?v_167 ?v_168) ?v_169) ?v_170) ?v_175) ?v_239) (or (or (or (or (or ?v_171 ?v_172) ?v_173) ?v_174) ?v_175) ?v_234))) (and (or (or (or (or (or ?v_176 ?v_177) ?v_178) ?v_179) ?v_184) ?v_250) (or (or (or (or (or ?v_180 ?v_181) ?v_182) ?v_183) ?v_184) ?v_245)))) (and (and (and (and (and (and (or (or (or (or (or ?v_185 ?v_186) ?v_187) ?v_188) ?v_189) ?v_195) (or (or (or (or (or ?v_190 ?v_191) ?v_192) ?v_193) ?v_194) ?v_195)) (and (or (or (or (or (or ?v_196 ?v_197) ?v_198) ?v_199) ?v_200) ?v_207) (or (or (or (or (or ?v_202 ?v_203) ?v_204) ?v_205) ?v_206) ?v_207))) (and (or (or (or (or (or ?v_208 ?v_209) ?v_210) ?v_211) ?v_212) ?v_218) (or (or (or (or (or ?v_213 ?v_214) ?v_215) ?v_216) ?v_217) ?v_218))) (and (or (or (or (or (or ?v_219 ?v_220) ?v_221) ?v_222) ?v_223) ?v_229) (or (or (or (or (or ?v_224 ?v_225) ?v_226) ?v_227) ?v_228) ?v_229))) (and (or (or (or (or (or ?v_230 ?v_231) ?v_232) ?v_233) ?v_234) ?v_240) (or (or (or (or (or ?v_235 ?v_236) ?v_237) ?v_238) ?v_239) ?v_240))) (and (or (or (or (or (or ?v_241 ?v_242) ?v_243) ?v_244) ?v_245) ?v_251) (or (or (or (or (or ?v_246 ?v_247) ?v_248) ?v_249) ?v_250) ?v_251))))))) (assert (and (and (and (and (and (and (and (= (op unit e0) e0) (= (op e0 unit) e0)) (and (= (op unit e1) e1) (= (op e1 unit) e1))) (and (= (op unit e2) e2) (= (op e2 unit) e2))) (and (= (op unit e3) e3) (= (op e3 unit) e3))) (and (= (op unit e4) e4) (= (op e4 unit) e4))) (and (= (op unit e5) e5) (= (op e5 unit) e5))) (or (or (or (or (or (= unit e0) (= unit e1)) (= unit e2)) (= unit e3)) (= unit e4)) (= unit e5)))) (assert (let ((?v_0 (op e0 e0)) (?v_1 (op e0 e1)) (?v_4 (op e0 e2)) (?v_9 (op e0 e3)) (?v_16 (op e0 e4)) (?v_25 (op e0 e5)) (?v_2 (op e1 e0)) (?v_3 (op e1 e1)) (?v_6 (op e1 e2)) (?v_11 (op e1 e3)) (?v_18 (op e1 e4)) (?v_27 (op e1 e5)) (?v_5 (op e2 e0)) (?v_7 (op e2 e1)) (?v_8 (op e2 e2)) (?v_13 (op e2 e3)) (?v_20 (op e2 e4)) (?v_29 (op e2 e5)) (?v_10 (op e3 e0)) (?v_12 (op e3 e1)) (?v_14 (op e3 e2)) (?v_15 (op e3 e3)) (?v_22 (op e3 e4)) (?v_31 (op e3 e5)) (?v_17 (op e4 e0)) (?v_19 (op e4 e1)) (?v_21 (op e4 e2)) (?v_23 (op e4 e3)) (?v_24 (op e4 e4)) (?v_33 (op e4 e5)) (?v_26 (op e5 e0)) (?v_28 (op e5 e1)) (?v_30 (op e5 e2)) (?v_32 (op e5 e3)) (?v_34 (op e5 e4)) (?v_35 (op e5 e5))) (or (or (or (or (or (or (or (or (or (or (not (= ?v_0 ?v_0)) (not (= ?v_2 ?v_1))) (not (= ?v_5 ?v_4))) (not (= ?v_10 ?v_9))) (not (= ?v_17 ?v_16))) (not (= ?v_26 ?v_25))) (or (or (or (or (or (not (= ?v_1 ?v_2)) (not (= ?v_3 ?v_3))) (not (= ?v_7 ?v_6))) (not (= ?v_12 ?v_11))) (not (= ?v_19 ?v_18))) (not (= ?v_28 ?v_27)))) (or (or (or (or (or (not (= ?v_4 ?v_5)) (not (= ?v_6 ?v_7))) (not (= ?v_8 ?v_8))) (not (= ?v_14 ?v_13))) (not (= ?v_21 ?v_20))) (not (= ?v_30 ?v_29)))) (or (or (or (or (or (not (= ?v_9 ?v_10)) (not (= ?v_11 ?v_12))) (not (= ?v_13 ?v_14))) (not (= ?v_15 ?v_15))) (not (= ?v_23 ?v_22))) (not (= ?v_32 ?v_31)))) (or (or (or (or (or (not (= ?v_16 ?v_17)) (not (= ?v_18 ?v_19))) (not (= ?v_20 ?v_21))) (not (= ?v_22 ?v_23))) (not (= ?v_24 ?v_24))) (not (= ?v_34 ?v_33)))) (or (or (or (or (or (not (= ?v_25 ?v_26)) (not (= ?v_27 ?v_28))) (not (= ?v_29 ?v_30))) (not (= ?v_31 ?v_32))) (not (= ?v_33 ?v_34))) (not (= ?v_35 ?v_35)))))) (assert (and (and (and (and (and (or (or (or (or (or (= (op (op e0 e0) e0) e0) (= (op (op e0 e1) e0) e1)) (= (op (op e0 e2) e0) e2)) (= (op (op e0 e3) e0) e3)) (= (op (op e0 e4) e0) e4)) (= (op (op e0 e5) e0) e5)) (or (or (or (or (or (= (op (op e1 e0) e1) e0) (= (op (op e1 e1) e1) e1)) (= (op (op e1 e2) e1) e2)) (= (op (op e1 e3) e1) e3)) (= (op (op e1 e4) e1) e4)) (= (op (op e1 e5) e1) e5))) (or (or (or (or (or (= (op (op e2 e0) e2) e0) (= (op (op e2 e1) e2) e1)) (= (op (op e2 e2) e2) e2)) (= (op (op e2 e3) e2) e3)) (= (op (op e2 e4) e2) e4)) (= (op (op e2 e5) e2) e5))) (or (or (or (or (or (= (op (op e3 e0) e3) e0) (= (op (op e3 e1) e3) e1)) (= (op (op e3 e2) e3) e2)) (= (op (op e3 e3) e3) e3)) (= (op (op e3 e4) e3) e4)) (= (op (op e3 e5) e3) e5))) (or (or (or (or (or (= (op (op e4 e0) e4) e0) (= (op (op e4 e1) e4) e1)) (= (op (op e4 e2) e4) e2)) (= (op (op e4 e3) e4) e3)) (= (op (op e4 e4) e4) e4)) (= (op (op e4 e5) e4) e5))) (or (or (or (or (or (= (op (op e5 e0) e5) e0) (= (op (op e5 e1) e5) e1)) (= (op (op e5 e2) e5) e2)) (= (op (op e5 e3) e5) e3)) (= (op (op e5 e4) e5) e4)) (= (op (op e5 e5) e5) e5)))) (assert (and (and (and (and (and (or (or (or (or (or (not (= (op (op e0 e0) e0) e0)) (not (= (op (op e1 e0) e1) e0))) (not (= (op (op e2 e0) e2) e0))) (not (= (op (op e3 e0) e3) e0))) (not (= (op (op e4 e0) e4) e0))) (not (= (op (op e5 e0) e5) e0))) (or (or (or (or (or (not (= (op (op e0 e1) e0) e1)) (not (= (op (op e1 e1) e1) e1))) (not (= (op (op e2 e1) e2) e1))) (not (= (op (op e3 e1) e3) e1))) (not (= (op (op e4 e1) e4) e1))) (not (= (op (op e5 e1) e5) e1)))) (or (or (or (or (or (not (= (op (op e0 e2) e0) e2)) (not (= (op (op e1 e2) e1) e2))) (not (= (op (op e2 e2) e2) e2))) (not (= (op (op e3 e2) e3) e2))) (not (= (op (op e4 e2) e4) e2))) (not (= (op (op e5 e2) e5) e2)))) (or (or (or (or (or (not (= (op (op e0 e3) e0) e3)) (not (= (op (op e1 e3) e1) e3))) (not (= (op (op e2 e3) e2) e3))) (not (= (op (op e3 e3) e3) e3))) (not (= (op (op e4 e3) e4) e3))) (not (= (op (op e5 e3) e5) e3)))) (or (or (or (or (or (not (= (op (op e0 e4) e0) e4)) (not (= (op (op e1 e4) e1) e4))) (not (= (op (op e2 e4) e2) e4))) (not (= (op (op e3 e4) e3) e4))) (not (= (op (op e4 e4) e4) e4))) (not (= (op (op e5 e4) e5) e4)))) (or (or (or (or (or (not (= (op (op e0 e5) e0) e5)) (not (= (op (op e1 e5) e1) e5))) (not (= (op (op e2 e5) e2) e5))) (not (= (op (op e3 e5) e3) e5))) (not (= (op (op e4 e5) e4) e5))) (not (= (op (op e5 e5) e5) e5))))) (assert (let ((?v_1 (op e0 e0)) (?v_3 (op e0 e1)) (?v_5 (op e0 e2)) (?v_7 (op e0 e3)) (?v_9 (op e0 e4)) (?v_11 (op e0 e5)) (?v_15 (op e1 e0)) (?v_22 (op e1 e1)) (?v_24 (op e1 e2)) (?v_25 (op e1 e3)) (?v_26 (op e1 e4)) (?v_27 (op e1 e5)) (?v_28 (op e2 e0)) (?v_30 (op e2 e1)) (?v_32 (op e2 e2)) (?v_33 (op e2 e3)) (?v_34 (op e2 e4)) (?v_35 (op e2 e5)) (?v_36 (op e3 e0)) (?v_38 (op e3 e1)) (?v_40 (op e3 e2)) (?v_41 (op e3 e3)) (?v_42 (op e3 e4)) (?v_43 (op e3 e5)) (?v_44 (op e4 e0)) (?v_46 (op e4 e1)) (?v_48 (op e4 e2)) (?v_49 (op e4 e3)) (?v_50 (op e4 e4)) (?v_51 (op e4 e5)) (?v_52 (op e5 e0)) (?v_54 (op e5 e1)) (?v_56 (op e5 e2)) (?v_57 (op e5 e3)) (?v_58 (op e5 e4)) (?v_59 (op e5 e5))) (let ((?v_0 (= ?v_1 e0)) (?v_12 (= ?v_1 e1)) (?v_60 (= ?v_1 e2)) (?v_90 (= ?v_1 e3)) (?v_132 (= ?v_1 e4)) (?v_186 (= ?v_1 e5)) (?v_2 (= ?v_3 e0)) (?v_14 (= ?v_3 e1)) (?v_62 (= ?v_3 e2)) (?v_92 (= ?v_3 e3)) (?v_134 (= ?v_3 e4)) (?v_188 (= ?v_3 e5)) (?v_4 (= ?v_5 e0)) (?v_16 (= ?v_5 e1)) (?v_64 (= ?v_5 e2)) (?v_94 (= ?v_5 e3)) (?v_136 (= ?v_5 e4)) (?v_190 (= ?v_5 e5)) (?v_6 (= ?v_7 e0)) (?v_17 (= ?v_7 e1)) (?v_65 (= ?v_7 e2)) (?v_96 (= ?v_7 e3)) (?v_138 (= ?v_7 e4)) (?v_192 (= ?v_7 e5)) (?v_8 (= ?v_9 e0)) (?v_18 (= ?v_9 e1)) (?v_66 (= ?v_9 e2)) (?v_97 (= ?v_9 e3)) (?v_140 (= ?v_9 e4)) (?v_194 (= ?v_9 e5)) (?v_10 (= ?v_11 e0)) (?v_19 (= ?v_11 e1)) (?v_67 (= ?v_11 e2)) (?v_98 (= ?v_11 e3)) (?v_141 (= ?v_11 e4)) (?v_196 (= ?v_11 e5)) (?v_13 (= ?v_15 e0)) (?v_20 (= ?v_15 e1)) (?v_68 (= ?v_15 e2)) (?v_99 (= ?v_15 e3)) (?v_142 (= ?v_15 e4)) (?v_197 (= ?v_15 e5)) (?v_21 (= ?v_22 e0)) (?v_23 (= ?v_22 e1)) (?v_70 (= ?v_22 e2)) (?v_101 (= ?v_22 e3)) (?v_144 (= ?v_22 e4)) (?v_199 (= ?v_22 e5)) (?v_29 (= ?v_24 e0)) (?v_31 (= ?v_24 e1)) (?v_72 (= ?v_24 e2)) (?v_103 (= ?v_24 e3)) (?v_146 (= ?v_24 e4)) (?v_201 (= ?v_24 e5)) (?v_37 (= ?v_25 e0)) (?v_39 (= ?v_25 e1)) (?v_73 (= ?v_25 e2)) (?v_105 (= ?v_25 e3)) (?v_148 (= ?v_25 e4)) (?v_203 (= ?v_25 e5)) (?v_45 (= ?v_26 e0)) (?v_47 (= ?v_26 e1)) (?v_74 (= ?v_26 e2)) (?v_106 (= ?v_26 e3)) (?v_150 (= ?v_26 e4)) (?v_205 (= ?v_26 e5)) (?v_53 (= ?v_27 e0)) (?v_55 (= ?v_27 e1)) (?v_75 (= ?v_27 e2)) (?v_107 (= ?v_27 e3)) (?v_151 (= ?v_27 e4)) (?v_207 (= ?v_27 e5)) (?v_61 (= ?v_28 e0)) (?v_63 (= ?v_28 e1)) (?v_76 (= ?v_28 e2)) (?v_108 (= ?v_28 e3)) (?v_152 (= ?v_28 e4)) (?v_208 (= ?v_28 e5)) (?v_69 (= ?v_30 e0)) (?v_71 (= ?v_30 e1)) (?v_78 (= ?v_30 e2)) (?v_110 (= ?v_30 e3)) (?v_154 (= ?v_30 e4)) (?v_210 (= ?v_30 e5)) (?v_77 (= ?v_32 e0)) (?v_79 (= ?v_32 e1)) (?v_80 (= ?v_32 e2)) (?v_112 (= ?v_32 e3)) (?v_156 (= ?v_32 e4)) (?v_212 (= ?v_32 e5)) (?v_81 (= ?v_33 e0)) (?v_82 (= ?v_33 e1)) (?v_83 (= ?v_33 e2)) (?v_114 (= ?v_33 e3)) (?v_158 (= ?v_33 e4)) (?v_214 (= ?v_33 e5)) (?v_84 (= ?v_34 e0)) (?v_85 (= ?v_34 e1)) (?v_86 (= ?v_34 e2)) (?v_115 (= ?v_34 e3)) (?v_160 (= ?v_34 e4)) (?v_216 (= ?v_34 e5)) (?v_87 (= ?v_35 e0)) (?v_88 (= ?v_35 e1)) (?v_89 (= ?v_35 e2)) (?v_116 (= ?v_35 e3)) (?v_161 (= ?v_35 e4)) (?v_218 (= ?v_35 e5)) (?v_91 (= ?v_36 e0)) (?v_93 (= ?v_36 e1)) (?v_95 (= ?v_36 e2)) (?v_117 (= ?v_36 e3)) (?v_162 (= ?v_36 e4)) (?v_219 (= ?v_36 e5)) (?v_100 (= ?v_38 e0)) (?v_102 (= ?v_38 e1)) (?v_104 (= ?v_38 e2)) (?v_119 (= ?v_38 e3)) (?v_164 (= ?v_38 e4)) (?v_221 (= ?v_38 e5)) (?v_109 (= ?v_40 e0)) (?v_111 (= ?v_40 e1)) (?v_113 (= ?v_40 e2)) (?v_121 (= ?v_40 e3)) (?v_166 (= ?v_40 e4)) (?v_223 (= ?v_40 e5)) (?v_118 (= ?v_41 e0)) (?v_120 (= ?v_41 e1)) (?v_122 (= ?v_41 e2)) (?v_123 (= ?v_41 e3)) (?v_168 (= ?v_41 e4)) (?v_225 (= ?v_41 e5)) (?v_124 (= ?v_42 e0)) (?v_125 (= ?v_42 e1)) (?v_126 (= ?v_42 e2)) (?v_127 (= ?v_42 e3)) (?v_170 (= ?v_42 e4)) (?v_227 (= ?v_42 e5)) (?v_128 (= ?v_43 e0)) (?v_129 (= ?v_43 e1)) (?v_130 (= ?v_43 e2)) (?v_131 (= ?v_43 e3)) (?v_171 (= ?v_43 e4)) (?v_229 (= ?v_43 e5)) (?v_133 (= ?v_44 e0)) (?v_135 (= ?v_44 e1)) (?v_137 (= ?v_44 e2)) (?v_139 (= ?v_44 e3)) (?v_172 (= ?v_44 e4)) (?v_230 (= ?v_44 e5)) (?v_143 (= ?v_46 e0)) (?v_145 (= ?v_46 e1)) (?v_147 (= ?v_46 e2)) (?v_149 (= ?v_46 e3)) (?v_174 (= ?v_46 e4)) (?v_232 (= ?v_46 e5)) (?v_153 (= ?v_48 e0)) (?v_155 (= ?v_48 e1)) (?v_157 (= ?v_48 e2)) (?v_159 (= ?v_48 e3)) (?v_176 (= ?v_48 e4)) (?v_234 (= ?v_48 e5)) (?v_163 (= ?v_49 e0)) (?v_165 (= ?v_49 e1)) (?v_167 (= ?v_49 e2)) (?v_169 (= ?v_49 e3)) (?v_178 (= ?v_49 e4)) (?v_236 (= ?v_49 e5)) (?v_173 (= ?v_50 e0)) (?v_175 (= ?v_50 e1)) (?v_177 (= ?v_50 e2)) (?v_179 (= ?v_50 e3)) (?v_180 (= ?v_50 e4)) (?v_238 (= ?v_50 e5)) (?v_181 (= ?v_51 e0)) (?v_182 (= ?v_51 e1)) (?v_183 (= ?v_51 e2)) (?v_184 (= ?v_51 e3)) (?v_185 (= ?v_51 e4)) (?v_240 (= ?v_51 e5)) (?v_187 (= ?v_52 e0)) (?v_189 (= ?v_52 e1)) (?v_191 (= ?v_52 e2)) (?v_193 (= ?v_52 e3)) (?v_195 (= ?v_52 e4)) (?v_241 (= ?v_52 e5)) (?v_198 (= ?v_54 e0)) (?v_200 (= ?v_54 e1)) (?v_202 (= ?v_54 e2)) (?v_204 (= ?v_54 e3)) (?v_206 (= ?v_54 e4)) (?v_243 (= ?v_54 e5)) (?v_209 (= ?v_56 e0)) (?v_211 (= ?v_56 e1)) (?v_213 (= ?v_56 e2)) (?v_215 (= ?v_56 e3)) (?v_217 (= ?v_56 e4)) (?v_245 (= ?v_56 e5)) (?v_220 (= ?v_57 e0)) (?v_222 (= ?v_57 e1)) (?v_224 (= ?v_57 e2)) (?v_226 (= ?v_57 e3)) (?v_228 (= ?v_57 e4)) (?v_247 (= ?v_57 e5)) (?v_231 (= ?v_58 e0)) (?v_233 (= ?v_58 e1)) (?v_235 (= ?v_58 e2)) (?v_237 (= ?v_58 e3)) (?v_239 (= ?v_58 e4)) (?v_249 (= ?v_58 e5)) (?v_242 (= ?v_59 e0)) (?v_244 (= ?v_59 e1)) (?v_246 (= ?v_59 e2)) (?v_248 (= ?v_59 e3)) (?v_250 (= ?v_59 e4)) (?v_251 (= ?v_59 e5))) (and (and (and (and (and (or (or (or (or (or (or (or (or (or (or (and ?v_0 (not ?v_0)) (and ?v_2 (not ?v_12))) (and ?v_4 (not ?v_60))) (and ?v_6 (not ?v_90))) (and ?v_8 (not ?v_132))) (and ?v_10 (not ?v_186))) (or (or (or (or (or (and ?v_13 (not ?v_2)) (and ?v_21 (not ?v_14))) (and ?v_29 (not ?v_62))) (and ?v_37 (not ?v_92))) (and ?v_45 (not ?v_134))) (and ?v_53 (not ?v_188)))) (or (or (or (or (or (and ?v_61 (not ?v_4)) (and ?v_69 (not ?v_16))) (and ?v_77 (not ?v_64))) (and ?v_81 (not ?v_94))) (and ?v_84 (not ?v_136))) (and ?v_87 (not ?v_190)))) (or (or (or (or (or (and ?v_91 (not ?v_6)) (and ?v_100 (not ?v_17))) (and ?v_109 (not ?v_65))) (and ?v_118 (not ?v_96))) (and ?v_124 (not ?v_138))) (and ?v_128 (not ?v_192)))) (or (or (or (or (or (and ?v_133 (not ?v_8)) (and ?v_143 (not ?v_18))) (and ?v_153 (not ?v_66))) (and ?v_163 (not ?v_97))) (and ?v_173 (not ?v_140))) (and ?v_181 (not ?v_194)))) (or (or (or (or (or (and ?v_187 (not ?v_10)) (and ?v_198 (not ?v_19))) (and ?v_209 (not ?v_67))) (and ?v_220 (not ?v_98))) (and ?v_231 (not ?v_141))) (and ?v_242 (not ?v_196)))) (or (or (or (or (or (or (or (or (or (or (and ?v_12 (not ?v_13)) (and ?v_14 (not ?v_20))) (and ?v_16 (not ?v_68))) (and ?v_17 (not ?v_99))) (and ?v_18 (not ?v_142))) (and ?v_19 (not ?v_197))) (or (or (or (or (or (and ?v_20 (not ?v_21)) (and ?v_23 (not ?v_23))) (and ?v_31 (not ?v_70))) (and ?v_39 (not ?v_101))) (and ?v_47 (not ?v_144))) (and ?v_55 (not ?v_199)))) (or (or (or (or (or (and ?v_63 (not ?v_29)) (and ?v_71 (not ?v_31))) (and ?v_79 (not ?v_72))) (and ?v_82 (not ?v_103))) (and ?v_85 (not ?v_146))) (and ?v_88 (not ?v_201)))) (or (or (or (or (or (and ?v_93 (not ?v_37)) (and ?v_102 (not ?v_39))) (and ?v_111 (not ?v_73))) (and ?v_120 (not ?v_105))) (and ?v_125 (not ?v_148))) (and ?v_129 (not ?v_203)))) (or (or (or (or (or (and ?v_135 (not ?v_45)) (and ?v_145 (not ?v_47))) (and ?v_155 (not ?v_74))) (and ?v_165 (not ?v_106))) (and ?v_175 (not ?v_150))) (and ?v_182 (not ?v_205)))) (or (or (or (or (or (and ?v_189 (not ?v_53)) (and ?v_200 (not ?v_55))) (and ?v_211 (not ?v_75))) (and ?v_222 (not ?v_107))) (and ?v_233 (not ?v_151))) (and ?v_244 (not ?v_207))))) (or (or (or (or (or (or (or (or (or (or (and ?v_60 (not ?v_61)) (and ?v_62 (not ?v_63))) (and ?v_64 (not ?v_76))) (and ?v_65 (not ?v_108))) (and ?v_66 (not ?v_152))) (and ?v_67 (not ?v_208))) (or (or (or (or (or (and ?v_68 (not ?v_69)) (and ?v_70 (not ?v_71))) (and ?v_72 (not ?v_78))) (and ?v_73 (not ?v_110))) (and ?v_74 (not ?v_154))) (and ?v_75 (not ?v_210)))) (or (or (or (or (or (and ?v_76 (not ?v_77)) (and ?v_78 (not ?v_79))) (and ?v_80 (not ?v_80))) (and ?v_83 (not ?v_112))) (and ?v_86 (not ?v_156))) (and ?v_89 (not ?v_212)))) (or (or (or (or (or (and ?v_95 (not ?v_81)) (and ?v_104 (not ?v_82))) (and ?v_113 (not ?v_83))) (and ?v_122 (not ?v_114))) (and ?v_126 (not ?v_158))) (and ?v_130 (not ?v_214)))) (or (or (or (or (or (and ?v_137 (not ?v_84)) (and ?v_147 (not ?v_85))) (and ?v_157 (not ?v_86))) (and ?v_167 (not ?v_115))) (and ?v_177 (not ?v_160))) (and ?v_183 (not ?v_216)))) (or (or (or (or (or (and ?v_191 (not ?v_87)) (and ?v_202 (not ?v_88))) (and ?v_213 (not ?v_89))) (and ?v_224 (not ?v_116))) (and ?v_235 (not ?v_161))) (and ?v_246 (not ?v_218))))) (or (or (or (or (or (or (or (or (or (or (and ?v_90 (not ?v_91)) (and ?v_92 (not ?v_93))) (and ?v_94 (not ?v_95))) (and ?v_96 (not ?v_117))) (and ?v_97 (not ?v_162))) (and ?v_98 (not ?v_219))) (or (or (or (or (or (and ?v_99 (not ?v_100)) (and ?v_101 (not ?v_102))) (and ?v_103 (not ?v_104))) (and ?v_105 (not ?v_119))) (and ?v_106 (not ?v_164))) (and ?v_107 (not ?v_221)))) (or (or (or (or (or (and ?v_108 (not ?v_109)) (and ?v_110 (not ?v_111))) (and ?v_112 (not ?v_113))) (and ?v_114 (not ?v_121))) (and ?v_115 (not ?v_166))) (and ?v_116 (not ?v_223)))) (or (or (or (or (or (and ?v_117 (not ?v_118)) (and ?v_119 (not ?v_120))) (and ?v_121 (not ?v_122))) (and ?v_123 (not ?v_123))) (and ?v_127 (not ?v_168))) (and ?v_131 (not ?v_225)))) (or (or (or (or (or (and ?v_139 (not ?v_124)) (and ?v_149 (not ?v_125))) (and ?v_159 (not ?v_126))) (and ?v_169 (not ?v_127))) (and ?v_179 (not ?v_170))) (and ?v_184 (not ?v_227)))) (or (or (or (or (or (and ?v_193 (not ?v_128)) (and ?v_204 (not ?v_129))) (and ?v_215 (not ?v_130))) (and ?v_226 (not ?v_131))) (and ?v_237 (not ?v_171))) (and ?v_248 (not ?v_229))))) (or (or (or (or (or (or (or (or (or (or (and ?v_132 (not ?v_133)) (and ?v_134 (not ?v_135))) (and ?v_136 (not ?v_137))) (and ?v_138 (not ?v_139))) (and ?v_140 (not ?v_172))) (and ?v_141 (not ?v_230))) (or (or (or (or (or (and ?v_142 (not ?v_143)) (and ?v_144 (not ?v_145))) (and ?v_146 (not ?v_147))) (and ?v_148 (not ?v_149))) (and ?v_150 (not ?v_174))) (and ?v_151 (not ?v_232)))) (or (or (or (or (or (and ?v_152 (not ?v_153)) (and ?v_154 (not ?v_155))) (and ?v_156 (not ?v_157))) (and ?v_158 (not ?v_159))) (and ?v_160 (not ?v_176))) (and ?v_161 (not ?v_234)))) (or (or (or (or (or (and ?v_162 (not ?v_163)) (and ?v_164 (not ?v_165))) (and ?v_166 (not ?v_167))) (and ?v_168 (not ?v_169))) (and ?v_170 (not ?v_178))) (and ?v_171 (not ?v_236)))) (or (or (or (or (or (and ?v_172 (not ?v_173)) (and ?v_174 (not ?v_175))) (and ?v_176 (not ?v_177))) (and ?v_178 (not ?v_179))) (and ?v_180 (not ?v_180))) (and ?v_185 (not ?v_238)))) (or (or (or (or (or (and ?v_195 (not ?v_181)) (and ?v_206 (not ?v_182))) (and ?v_217 (not ?v_183))) (and ?v_228 (not ?v_184))) (and ?v_239 (not ?v_185))) (and ?v_250 (not ?v_240))))) (or (or (or (or (or (or (or (or (or (or (and ?v_186 (not ?v_187)) (and ?v_188 (not ?v_189))) (and ?v_190 (not ?v_191))) (and ?v_192 (not ?v_193))) (and ?v_194 (not ?v_195))) (and ?v_196 (not ?v_241))) (or (or (or (or (or (and ?v_197 (not ?v_198)) (and ?v_199 (not ?v_200))) (and ?v_201 (not ?v_202))) (and ?v_203 (not ?v_204))) (and ?v_205 (not ?v_206))) (and ?v_207 (not ?v_243)))) (or (or (or (or (or (and ?v_208 (not ?v_209)) (and ?v_210 (not ?v_211))) (and ?v_212 (not ?v_213))) (and ?v_214 (not ?v_215))) (and ?v_216 (not ?v_217))) (and ?v_218 (not ?v_245)))) (or (or (or (or (or (and ?v_219 (not ?v_220)) (and ?v_221 (not ?v_222))) (and ?v_223 (not ?v_224))) (and ?v_225 (not ?v_226))) (and ?v_227 (not ?v_228))) (and ?v_229 (not ?v_247)))) (or (or (or (or (or (and ?v_230 (not ?v_231)) (and ?v_232 (not ?v_233))) (and ?v_234 (not ?v_235))) (and ?v_236 (not ?v_237))) (and ?v_238 (not ?v_239))) (and ?v_240 (not ?v_249)))) (or (or (or (or (or (and ?v_241 (not ?v_242)) (and ?v_243 (not ?v_244))) (and ?v_245 (not ?v_246))) (and ?v_247 (not ?v_248))) (and ?v_249 (not ?v_250))) (and ?v_251 (not ?v_251)))))))) (assert (let ((?v_0 (op e0 e0)) (?v_1 (op e0 e1)) (?v_2 (op e0 e2)) (?v_3 (op e0 e3)) (?v_4 (op e0 e4)) (?v_5 (op e0 e5)) (?v_6 (op e1 e0)) (?v_7 (op e1 e1)) (?v_8 (op e1 e2)) (?v_9 (op e1 e3)) (?v_10 (op e1 e4)) (?v_11 (op e1 e5)) (?v_12 (op e2 e0)) (?v_13 (op e2 e1)) (?v_14 (op e2 e2)) (?v_15 (op e2 e3)) (?v_16 (op e2 e4)) (?v_17 (op e2 e5)) (?v_18 (op e3 e0)) (?v_19 (op e3 e1)) (?v_20 (op e3 e2)) (?v_21 (op e3 e3)) (?v_22 (op e3 e4)) (?v_23 (op e3 e5)) (?v_24 (op e4 e0)) (?v_25 (op e4 e1)) (?v_26 (op e4 e2)) (?v_27 (op e4 e3)) (?v_28 (op e4 e4)) (?v_29 (op e4 e5)) (?v_30 (op e5 e0)) (?v_31 (op e5 e1)) (?v_32 (op e5 e2)) (?v_33 (op e5 e3)) (?v_34 (op e5 e4)) (?v_35 (op e5 e5))) (or (or (or (or (or (and (and (and (and (and (not (= (op ?v_0 ?v_0) e0)) (not (= (op ?v_1 ?v_1) e1))) (not (= (op ?v_2 ?v_2) e2))) (not (= (op ?v_3 ?v_3) e3))) (not (= (op ?v_4 ?v_4) e4))) (not (= (op ?v_5 ?v_5) e5))) (and (and (and (and (and (not (= (op ?v_6 ?v_6) e0)) (not (= (op ?v_7 ?v_7) e1))) (not (= (op ?v_8 ?v_8) e2))) (not (= (op ?v_9 ?v_9) e3))) (not (= (op ?v_10 ?v_10) e4))) (not (= (op ?v_11 ?v_11) e5)))) (and (and (and (and (and (not (= (op ?v_12 ?v_12) e0)) (not (= (op ?v_13 ?v_13) e1))) (not (= (op ?v_14 ?v_14) e2))) (not (= (op ?v_15 ?v_15) e3))) (not (= (op ?v_16 ?v_16) e4))) (not (= (op ?v_17 ?v_17) e5)))) (and (and (and (and (and (not (= (op ?v_18 ?v_18) e0)) (not (= (op ?v_19 ?v_19) e1))) (not (= (op ?v_20 ?v_20) e2))) (not (= (op ?v_21 ?v_21) e3))) (not (= (op ?v_22 ?v_22) e4))) (not (= (op ?v_23 ?v_23) e5)))) (and (and (and (and (and (not (= (op ?v_24 ?v_24) e0)) (not (= (op ?v_25 ?v_25) e1))) (not (= (op ?v_26 ?v_26) e2))) (not (= (op ?v_27 ?v_27) e3))) (not (= (op ?v_28 ?v_28) e4))) (not (= (op ?v_29 ?v_29) e5)))) (and (and (and (and (and (not (= (op ?v_30 ?v_30) e0)) (not (= (op ?v_31 ?v_31) e1))) (not (= (op ?v_32 ?v_32) e2))) (not (= (op ?v_33 ?v_33) e3))) (not (= (op ?v_34 ?v_34) e4))) (not (= (op ?v_35 ?v_35) e5)))))) (assert (or (or (or (or (or (and (and (and (and (and (not (= (op e0 (op e0 e0)) e0)) (not (= (op e0 (op e0 e1)) e1))) (not (= (op e0 (op e0 e2)) e2))) (not (= (op e0 (op e0 e3)) e3))) (not (= (op e0 (op e0 e4)) e4))) (not (= (op e0 (op e0 e5)) e5))) (and (and (and (and (and (not (= (op e1 (op e1 e0)) e0)) (not (= (op e1 (op e1 e1)) e1))) (not (= (op e1 (op e1 e2)) e2))) (not (= (op e1 (op e1 e3)) e3))) (not (= (op e1 (op e1 e4)) e4))) (not (= (op e1 (op e1 e5)) e5)))) (and (and (and (and (and (not (= (op e2 (op e2 e0)) e0)) (not (= (op e2 (op e2 e1)) e1))) (not (= (op e2 (op e2 e2)) e2))) (not (= (op e2 (op e2 e3)) e3))) (not (= (op e2 (op e2 e4)) e4))) (not (= (op e2 (op e2 e5)) e5)))) (and (and (and (and (and (not (= (op e3 (op e3 e0)) e0)) (not (= (op e3 (op e3 e1)) e1))) (not (= (op e3 (op e3 e2)) e2))) (not (= (op e3 (op e3 e3)) e3))) (not (= (op e3 (op e3 e4)) e4))) (not (= (op e3 (op e3 e5)) e5)))) (and (and (and (and (and (not (= (op e4 (op e4 e0)) e0)) (not (= (op e4 (op e4 e1)) e1))) (not (= (op e4 (op e4 e2)) e2))) (not (= (op e4 (op e4 e3)) e3))) (not (= (op e4 (op e4 e4)) e4))) (not (= (op e4 (op e4 e5)) e5)))) (and (and (and (and (and (not (= (op e5 (op e5 e0)) e0)) (not (= (op e5 (op e5 e1)) e1))) (not (= (op e5 (op e5 e2)) e2))) (not (= (op e5 (op e5 e3)) e3))) (not (= (op e5 (op e5 e4)) e4))) (not (= (op e5 (op e5 e5)) e5))))) (assert (let ((?v_0 (op e0 e0)) (?v_6 (op e0 e1)) (?v_12 (op e0 e2)) (?v_18 (op e0 e3)) (?v_24 (op e0 e4)) (?v_30 (op e0 e5)) (?v_1 (op e1 e0)) (?v_7 (op e1 e1)) (?v_13 (op e1 e2)) (?v_19 (op e1 e3)) (?v_25 (op e1 e4)) (?v_31 (op e1 e5)) (?v_2 (op e2 e0)) (?v_8 (op e2 e1)) (?v_14 (op e2 e2)) (?v_20 (op e2 e3)) (?v_26 (op e2 e4)) (?v_32 (op e2 e5)) (?v_3 (op e3 e0)) (?v_9 (op e3 e1)) (?v_15 (op e3 e2)) (?v_21 (op e3 e3)) (?v_27 (op e3 e4)) (?v_33 (op e3 e5)) (?v_4 (op e4 e0)) (?v_10 (op e4 e1)) (?v_16 (op e4 e2)) (?v_22 (op e4 e3)) (?v_28 (op e4 e4)) (?v_34 (op e4 e5)) (?v_5 (op e5 e0)) (?v_11 (op e5 e1)) (?v_17 (op e5 e2)) (?v_23 (op e5 e3)) (?v_29 (op e5 e4)) (?v_35 (op e5 e5))) (or (or (or (or (or (and (and (and (and (and (not (= (op ?v_0 ?v_0) e0)) (not (= (op ?v_1 ?v_1) e1))) (not (= (op ?v_2 ?v_2) e2))) (not (= (op ?v_3 ?v_3) e3))) (not (= (op ?v_4 ?v_4) e4))) (not (= (op ?v_5 ?v_5) e5))) (and (and (and (and (and (not (= (op ?v_6 ?v_6) e0)) (not (= (op ?v_7 ?v_7) e1))) (not (= (op ?v_8 ?v_8) e2))) (not (= (op ?v_9 ?v_9) e3))) (not (= (op ?v_10 ?v_10) e4))) (not (= (op ?v_11 ?v_11) e5)))) (and (and (and (and (and (not (= (op ?v_12 ?v_12) e0)) (not (= (op ?v_13 ?v_13) e1))) (not (= (op ?v_14 ?v_14) e2))) (not (= (op ?v_15 ?v_15) e3))) (not (= (op ?v_16 ?v_16) e4))) (not (= (op ?v_17 ?v_17) e5)))) (and (and (and (and (and (not (= (op ?v_18 ?v_18) e0)) (not (= (op ?v_19 ?v_19) e1))) (not (= (op ?v_20 ?v_20) e2))) (not (= (op ?v_21 ?v_21) e3))) (not (= (op ?v_22 ?v_22) e4))) (not (= (op ?v_23 ?v_23) e5)))) (and (and (and (and (and (not (= (op ?v_24 ?v_24) e0)) (not (= (op ?v_25 ?v_25) e1))) (not (= (op ?v_26 ?v_26) e2))) (not (= (op ?v_27 ?v_27) e3))) (not (= (op ?v_28 ?v_28) e4))) (not (= (op ?v_29 ?v_29) e5)))) (and (and (and (and (and (not (= (op ?v_30 ?v_30) e0)) (not (= (op ?v_31 ?v_31) e1))) (not (= (op ?v_32 ?v_32) e2))) (not (= (op ?v_33 ?v_33) e3))) (not (= (op ?v_34 ?v_34) e4))) (not (= (op ?v_35 ?v_35) e5)))))) (assert (let ((?v_2 (op e0 e0)) (?v_51 (op e0 e1)) (?v_54 (op e0 e2)) (?v_56 (op e0 e3)) (?v_58 (op e0 e4)) (?v_60 (op e0 e5)) (?v_6 (op e1 e0)) (?v_65 (op e1 e1)) (?v_68 (op e1 e2)) (?v_70 (op e1 e3)) (?v_72 (op e1 e4)) (?v_74 (op e1 e5)) (?v_12 (op e2 e0)) (?v_69 (op e2 e1)) (?v_82 (op e2 e2)) (?v_84 (op e2 e3)) (?v_86 (op e2 e4)) (?v_88 (op e2 e5)) (?v_19 (op e3 e0)) (?v_71 (op e3 e1)) (?v_85 (op e3 e2)) (?v_98 (op e3 e3)) (?v_100 (op e3 e4)) (?v_102 (op e3 e5)) (?v_28 (op e4 e0)) (?v_73 (op e4 e1)) (?v_87 (op e4 e2)) (?v_101 (op e4 e3)) (?v_114 (op e4 e4)) (?v_116 (op e4 e5)) (?v_39 (op e5 e0)) (?v_75 (op e5 e1)) (?v_89 (op e5 e2)) (?v_103 (op e5 e3)) (?v_117 (op e5 e4)) (?v_130 (op e5 e5))) (let ((?v_0 (= ?v_2 e0)) (?v_48 (= ?v_2 e1)) (?v_132 (= ?v_2 e2)) (?v_198 (= ?v_2 e3)) (?v_276 (= ?v_2 e4)) (?v_366 (= ?v_2 e5)) (?v_49 (= ?v_51 e0)) (?v_52 (= ?v_51 e1)) (?v_135 (= ?v_51 e2)) (?v_201 (= ?v_51 e3)) (?v_279 (= ?v_51 e4)) (?v_369 (= ?v_51 e5)) (?v_133 (= ?v_54 e0)) (?v_136 (= ?v_54 e1)) (?v_138 (= ?v_54 e2)) (?v_204 (= ?v_54 e3)) (?v_282 (= ?v_54 e4)) (?v_372 (= ?v_54 e5)) (?v_199 (= ?v_56 e0)) (?v_202 (= ?v_56 e1)) (?v_205 (= ?v_56 e2)) (?v_207 (= ?v_56 e3)) (?v_285 (= ?v_56 e4)) (?v_375 (= ?v_56 e5)) (?v_277 (= ?v_58 e0)) (?v_280 (= ?v_58 e1)) (?v_283 (= ?v_58 e2)) (?v_286 (= ?v_58 e3)) (?v_288 (= ?v_58 e4)) (?v_378 (= ?v_58 e5)) (?v_367 (= ?v_60 e0)) (?v_370 (= ?v_60 e1)) (?v_373 (= ?v_60 e2)) (?v_376 (= ?v_60 e3)) (?v_379 (= ?v_60 e4)) (?v_381 (= ?v_60 e5)) (?v_4 (= ?v_6 e0)) (?v_53 (= ?v_6 e1)) (?v_137 (= ?v_6 e2)) (?v_203 (= ?v_6 e3)) (?v_281 (= ?v_6 e4)) (?v_371 (= ?v_6 e5)) (?v_63 (= ?v_65 e0)) (?v_66 (= ?v_65 e1)) (?v_146 (= ?v_65 e2)) (?v_214 (= ?v_65 e3)) (?v_294 (= ?v_65 e4)) (?v_386 (= ?v_65 e5)) (?v_144 (= ?v_68 e0)) (?v_147 (= ?v_68 e1)) (?v_149 (= ?v_68 e2)) (?v_217 (= ?v_68 e3)) (?v_297 (= ?v_68 e4)) (?v_389 (= ?v_68 e5)) (?v_212 (= ?v_70 e0)) (?v_215 (= ?v_70 e1)) (?v_218 (= ?v_70 e2)) (?v_220 (= ?v_70 e3)) (?v_300 (= ?v_70 e4)) (?v_392 (= ?v_70 e5)) (?v_292 (= ?v_72 e0)) (?v_295 (= ?v_72 e1)) (?v_298 (= ?v_72 e2)) (?v_301 (= ?v_72 e3)) (?v_303 (= ?v_72 e4)) (?v_395 (= ?v_72 e5)) (?v_384 (= ?v_74 e0)) (?v_387 (= ?v_74 e1)) (?v_390 (= ?v_74 e2)) (?v_393 (= ?v_74 e3)) (?v_396 (= ?v_74 e4)) (?v_398 (= ?v_74 e5)) (?v_9 (= ?v_12 e0)) (?v_55 (= ?v_12 e1)) (?v_139 (= ?v_12 e2)) (?v_206 (= ?v_12 e3)) (?v_284 (= ?v_12 e4)) (?v_374 (= ?v_12 e5)) (?v_77 (= ?v_69 e0)) (?v_80 (= ?v_69 e1)) (?v_150 (= ?v_69 e2)) (?v_219 (= ?v_69 e3)) (?v_299 (= ?v_69 e4)) (?v_391 (= ?v_69 e5)) (?v_155 (= ?v_82 e0)) (?v_158 (= ?v_82 e1)) (?v_160 (= ?v_82 e2)) (?v_230 (= ?v_82 e3)) (?v_312 (= ?v_82 e4)) (?v_406 (= ?v_82 e5)) (?v_225 (= ?v_84 e0)) (?v_228 (= ?v_84 e1)) (?v_231 (= ?v_84 e2)) (?v_233 (= ?v_84 e3)) (?v_315 (= ?v_84 e4)) (?v_409 (= ?v_84 e5)) (?v_307 (= ?v_86 e0)) (?v_310 (= ?v_86 e1)) (?v_313 (= ?v_86 e2)) (?v_316 (= ?v_86 e3)) (?v_318 (= ?v_86 e4)) (?v_412 (= ?v_86 e5)) (?v_401 (= ?v_88 e0)) (?v_404 (= ?v_88 e1)) (?v_407 (= ?v_88 e2)) (?v_410 (= ?v_88 e3)) (?v_413 (= ?v_88 e4)) (?v_415 (= ?v_88 e5)) (?v_16 (= ?v_19 e0)) (?v_57 (= ?v_19 e1)) (?v_140 (= ?v_19 e2)) (?v_208 (= ?v_19 e3)) (?v_287 (= ?v_19 e4)) (?v_377 (= ?v_19 e5)) (?v_91 (= ?v_71 e0)) (?v_94 (= ?v_71 e1)) (?v_151 (= ?v_71 e2)) (?v_221 (= ?v_71 e3)) (?v_302 (= ?v_71 e4)) (?v_394 (= ?v_71 e5)) (?v_163 (= ?v_85 e0)) (?v_166 (= ?v_85 e1)) (?v_169 (= ?v_85 e2)) (?v_234 (= ?v_85 e3)) (?v_317 (= ?v_85 e4)) (?v_411 (= ?v_85 e5)) (?v_238 (= ?v_98 e0)) (?v_241 (= ?v_98 e1)) (?v_244 (= ?v_98 e2)) (?v_246 (= ?v_98 e3)) (?v_330 (= ?v_98 e4)) (?v_426 (= ?v_98 e5)) (?v_322 (= ?v_100 e0)) (?v_325 (= ?v_100 e1)) (?v_328 (= ?v_100 e2)) (?v_331 (= ?v_100 e3)) (?v_333 (= ?v_100 e4)) (?v_429 (= ?v_100 e5)) (?v_418 (= ?v_102 e0)) (?v_421 (= ?v_102 e1)) (?v_424 (= ?v_102 e2)) (?v_427 (= ?v_102 e3)) (?v_430 (= ?v_102 e4)) (?v_432 (= ?v_102 e5)) (?v_25 (= ?v_28 e0)) (?v_59 (= ?v_28 e1)) (?v_141 (= ?v_28 e2)) (?v_209 (= ?v_28 e3)) (?v_289 (= ?v_28 e4)) (?v_380 (= ?v_28 e5)) (?v_105 (= ?v_73 e0)) (?v_108 (= ?v_73 e1)) (?v_152 (= ?v_73 e2)) (?v_222 (= ?v_73 e3)) (?v_304 (= ?v_73 e4)) (?v_397 (= ?v_73 e5)) (?v_173 (= ?v_87 e0)) (?v_176 (= ?v_87 e1)) (?v_179 (= ?v_87 e2)) (?v_235 (= ?v_87 e3)) (?v_319 (= ?v_87 e4)) (?v_414 (= ?v_87 e5)) (?v_249 (= ?v_101 e0)) (?v_252 (= ?v_101 e1)) (?v_255 (= ?v_101 e2)) (?v_258 (= ?v_101 e3)) (?v_334 (= ?v_101 e4)) (?v_431 (= ?v_101 e5)) (?v_337 (= ?v_114 e0)) (?v_340 (= ?v_114 e1)) (?v_343 (= ?v_114 e2)) (?v_346 (= ?v_114 e3)) (?v_348 (= ?v_114 e4)) (?v_446 (= ?v_114 e5)) (?v_435 (= ?v_116 e0)) (?v_438 (= ?v_116 e1)) (?v_441 (= ?v_116 e2)) (?v_444 (= ?v_116 e3)) (?v_447 (= ?v_116 e4)) (?v_449 (= ?v_116 e5)) (?v_36 (= ?v_39 e0)) (?v_61 (= ?v_39 e1)) (?v_142 (= ?v_39 e2)) (?v_210 (= ?v_39 e3)) (?v_290 (= ?v_39 e4)) (?v_382 (= ?v_39 e5)) (?v_119 (= ?v_75 e0)) (?v_122 (= ?v_75 e1)) (?v_153 (= ?v_75 e2)) (?v_223 (= ?v_75 e3)) (?v_305 (= ?v_75 e4)) (?v_399 (= ?v_75 e5)) (?v_185 (= ?v_89 e0)) (?v_188 (= ?v_89 e1)) (?v_191 (= ?v_89 e2)) (?v_236 (= ?v_89 e3)) (?v_320 (= ?v_89 e4)) (?v_416 (= ?v_89 e5)) (?v_262 (= ?v_103 e0)) (?v_265 (= ?v_103 e1)) (?v_268 (= ?v_103 e2)) (?v_271 (= ?v_103 e3)) (?v_335 (= ?v_103 e4)) (?v_433 (= ?v_103 e5)) (?v_351 (= ?v_117 e0)) (?v_354 (= ?v_117 e1)) (?v_357 (= ?v_117 e2)) (?v_360 (= ?v_117 e3)) (?v_363 (= ?v_117 e4)) (?v_450 (= ?v_117 e5)) (?v_452 (= ?v_130 e0)) (?v_455 (= ?v_130 e1)) (?v_458 (= ?v_130 e2)) (?v_461 (= ?v_130 e3)) (?v_464 (= ?v_130 e4)) (?v_466 (= ?v_130 e5))) (let ((?v_1 (not ?v_0)) (?v_50 (not ?v_48)) (?v_134 (not ?v_132)) (?v_200 (not ?v_198)) (?v_278 (not ?v_276)) (?v_368 (not ?v_366)) (?v_5 (not ?v_49)) (?v_64 (not ?v_52)) (?v_145 (not ?v_135)) (?v_213 (not ?v_201)) (?v_293 (not ?v_279)) (?v_385 (not ?v_369)) (?v_10 (not ?v_133)) (?v_78 (not ?v_136)) (?v_156 (not ?v_138)) (?v_226 (not ?v_204)) (?v_308 (not ?v_282)) (?v_402 (not ?v_372)) (?v_17 (not ?v_199)) (?v_92 (not ?v_202)) (?v_164 (not ?v_205)) (?v_239 (not ?v_207)) (?v_323 (not ?v_285)) (?v_419 (not ?v_375)) (?v_26 (not ?v_277)) (?v_106 (not ?v_280)) (?v_174 (not ?v_283)) (?v_250 (not ?v_286)) (?v_338 (not ?v_288)) (?v_436 (not ?v_378)) (?v_37 (not ?v_367)) (?v_120 (not ?v_370)) (?v_186 (not ?v_373)) (?v_263 (not ?v_376)) (?v_352 (not ?v_379)) (?v_453 (not ?v_381)) (?v_3 (not ?v_4)) (?v_62 (not ?v_53)) (?v_143 (not ?v_137)) (?v_211 (not ?v_203)) (?v_291 (not ?v_281)) (?v_383 (not ?v_371)) (?v_7 (not ?v_63)) (?v_67 (not ?v_66)) (?v_148 (not ?v_146)) (?v_216 (not ?v_214)) (?v_296 (not ?v_294)) (?v_388 (not ?v_386)) (?v_13 (not ?v_144)) (?v_81 (not ?v_147)) (?v_159 (not ?v_149)) (?v_229 (not ?v_217)) (?v_311 (not ?v_297)) (?v_405 (not ?v_389)) (?v_20 (not ?v_212)) (?v_95 (not ?v_215)) (?v_167 (not ?v_218)) (?v_242 (not ?v_220)) (?v_326 (not ?v_300)) (?v_422 (not ?v_392)) (?v_29 (not ?v_292)) (?v_109 (not ?v_295)) (?v_177 (not ?v_298)) (?v_253 (not ?v_301)) (?v_341 (not ?v_303)) (?v_439 (not ?v_395)) (?v_40 (not ?v_384)) (?v_123 (not ?v_387)) (?v_189 (not ?v_390)) (?v_266 (not ?v_393)) (?v_355 (not ?v_396)) (?v_456 (not ?v_398)) (?v_8 (not ?v_9)) (?v_76 (not ?v_55)) (?v_154 (not ?v_139)) (?v_224 (not ?v_206)) (?v_306 (not ?v_284)) (?v_400 (not ?v_374)) (?v_11 (not ?v_77)) (?v_79 (not ?v_80)) (?v_157 (not ?v_150)) (?v_227 (not ?v_219)) (?v_309 (not ?v_299)) (?v_403 (not ?v_391)) (?v_14 (not ?v_155)) (?v_83 (not ?v_158)) (?v_161 (not ?v_160)) (?v_232 (not ?v_230)) (?v_314 (not ?v_312)) (?v_408 (not ?v_406)) (?v_22 (not ?v_225)) (?v_97 (not ?v_228)) (?v_170 (not ?v_231)) (?v_245 (not ?v_233)) (?v_329 (not ?v_315)) (?v_425 (not ?v_409)) (?v_31 (not ?v_307)) (?v_111 (not ?v_310)) (?v_180 (not ?v_313)) (?v_256 (not ?v_316)) (?v_344 (not ?v_318)) (?v_442 (not ?v_412)) (?v_42 (not ?v_401)) (?v_125 (not ?v_404)) (?v_192 (not ?v_407)) (?v_269 (not ?v_410)) (?v_358 (not ?v_413)) (?v_459 (not ?v_415)) (?v_15 (not ?v_16)) (?v_90 (not ?v_57)) (?v_162 (not ?v_140)) (?v_237 (not ?v_208)) (?v_321 (not ?v_287)) (?v_417 (not ?v_377)) (?v_18 (not ?v_91)) (?v_93 (not ?v_94)) (?v_165 (not ?v_151)) (?v_240 (not ?v_221)) (?v_324 (not ?v_302)) (?v_420 (not ?v_394)) (?v_21 (not ?v_163)) (?v_96 (not ?v_166)) (?v_168 (not ?v_169)) (?v_243 (not ?v_234)) (?v_327 (not ?v_317)) (?v_423 (not ?v_411)) (?v_23 (not ?v_238)) (?v_99 (not ?v_241)) (?v_171 (not ?v_244)) (?v_247 (not ?v_246)) (?v_332 (not ?v_330)) (?v_428 (not ?v_426)) (?v_33 (not ?v_322)) (?v_113 (not ?v_325)) (?v_182 (not ?v_328)) (?v_259 (not ?v_331)) (?v_347 (not ?v_333)) (?v_445 (not ?v_429)) (?v_44 (not ?v_418)) (?v_127 (not ?v_421)) (?v_194 (not ?v_424)) (?v_272 (not ?v_427)) (?v_361 (not ?v_430)) (?v_462 (not ?v_432)) (?v_24 (not ?v_25)) (?v_104 (not ?v_59)) (?v_172 (not ?v_141)) (?v_248 (not ?v_209)) (?v_336 (not ?v_289)) (?v_434 (not ?v_380)) (?v_27 (not ?v_105)) (?v_107 (not ?v_108)) (?v_175 (not ?v_152)) (?v_251 (not ?v_222)) (?v_339 (not ?v_304)) (?v_437 (not ?v_397)) (?v_30 (not ?v_173)) (?v_110 (not ?v_176)) (?v_178 (not ?v_179)) (?v_254 (not ?v_235)) (?v_342 (not ?v_319)) (?v_440 (not ?v_414)) (?v_32 (not ?v_249)) (?v_112 (not ?v_252)) (?v_181 (not ?v_255)) (?v_257 (not ?v_258)) (?v_345 (not ?v_334)) (?v_443 (not ?v_431)) (?v_34 (not ?v_337)) (?v_115 (not ?v_340)) (?v_183 (not ?v_343)) (?v_260 (not ?v_346)) (?v_349 (not ?v_348)) (?v_448 (not ?v_446)) (?v_46 (not ?v_435)) (?v_129 (not ?v_438)) (?v_196 (not ?v_441)) (?v_274 (not ?v_444)) (?v_364 (not ?v_447)) (?v_465 (not ?v_449)) (?v_35 (not ?v_36)) (?v_118 (not ?v_61)) (?v_184 (not ?v_142)) (?v_261 (not ?v_210)) (?v_350 (not ?v_290)) (?v_451 (not ?v_382)) (?v_38 (not ?v_119)) (?v_121 (not ?v_122)) (?v_187 (not ?v_153)) (?v_264 (not ?v_223)) (?v_353 (not ?v_305)) (?v_454 (not ?v_399)) (?v_41 (not ?v_185)) (?v_124 (not ?v_188)) (?v_190 (not ?v_191)) (?v_267 (not ?v_236)) (?v_356 (not ?v_320)) (?v_457 (not ?v_416)) (?v_43 (not ?v_262)) (?v_126 (not ?v_265)) (?v_193 (not ?v_268)) (?v_270 (not ?v_271)) (?v_359 (not ?v_335)) (?v_460 (not ?v_433)) (?v_45 (not ?v_351)) (?v_128 (not ?v_354)) (?v_195 (not ?v_357)) (?v_273 (not ?v_360)) (?v_362 (not ?v_363)) (?v_463 (not ?v_450)) (?v_47 (not ?v_452)) (?v_131 (not ?v_455)) (?v_197 (not ?v_458)) (?v_275 (not ?v_461)) (?v_365 (not ?v_464)) (?v_467 (not ?v_466))) (or (or (or (or (or (and (and (and (and (and (and (and (and (and (and (or ?v_1 (or ?v_0 ?v_1)) (or ?v_5 (or ?v_48 ?v_3))) (or ?v_10 (or ?v_132 ?v_8))) (or ?v_17 (or ?v_198 ?v_15))) (or ?v_26 (or ?v_276 ?v_24))) (or ?v_37 (or ?v_366 ?v_35))) (and (and (and (and (and (or ?v_3 (or ?v_4 ?v_5)) (or ?v_7 (or ?v_53 ?v_7))) (or ?v_13 (or ?v_137 ?v_11))) (or ?v_20 (or ?v_203 ?v_18))) (or ?v_29 (or ?v_281 ?v_27))) (or ?v_40 (or ?v_371 ?v_38)))) (and (and (and (and (and (or ?v_8 (or ?v_9 ?v_10)) (or ?v_11 (or ?v_55 ?v_13))) (or ?v_14 (or ?v_139 ?v_14))) (or ?v_22 (or ?v_206 ?v_21))) (or ?v_31 (or ?v_284 ?v_30))) (or ?v_42 (or ?v_374 ?v_41)))) (and (and (and (and (and (or ?v_15 (or ?v_16 ?v_17)) (or ?v_18 (or ?v_57 ?v_20))) (or ?v_21 (or ?v_140 ?v_22))) (or ?v_23 (or ?v_208 ?v_23))) (or ?v_33 (or ?v_287 ?v_32))) (or ?v_44 (or ?v_377 ?v_43)))) (and (and (and (and (and (or ?v_24 (or ?v_25 ?v_26)) (or ?v_27 (or ?v_59 ?v_29))) (or ?v_30 (or ?v_141 ?v_31))) (or ?v_32 (or ?v_209 ?v_33))) (or ?v_34 (or ?v_289 ?v_34))) (or ?v_46 (or ?v_380 ?v_45)))) (and (and (and (and (and (or ?v_35 (or ?v_36 ?v_37)) (or ?v_38 (or ?v_61 ?v_40))) (or ?v_41 (or ?v_142 ?v_42))) (or ?v_43 (or ?v_210 ?v_44))) (or ?v_45 (or ?v_290 ?v_46))) (or ?v_47 (or ?v_382 ?v_47)))) (and (and (and (and (and (and (and (and (and (and (or ?v_50 (or ?v_49 ?v_50)) (or ?v_64 (or ?v_52 ?v_62))) (or ?v_78 (or ?v_135 ?v_76))) (or ?v_92 (or ?v_201 ?v_90))) (or ?v_106 (or ?v_279 ?v_104))) (or ?v_120 (or ?v_369 ?v_118))) (and (and (and (and (and (or ?v_62 (or ?v_63 ?v_64)) (or ?v_67 (or ?v_66 ?v_67))) (or ?v_81 (or ?v_146 ?v_79))) (or ?v_95 (or ?v_214 ?v_93))) (or ?v_109 (or ?v_294 ?v_107))) (or ?v_123 (or ?v_386 ?v_121)))) (and (and (and (and (and (or ?v_76 (or ?v_77 ?v_78)) (or ?v_79 (or ?v_80 ?v_81))) (or ?v_83 (or ?v_150 ?v_83))) (or ?v_97 (or ?v_219 ?v_96))) (or ?v_111 (or ?v_299 ?v_110))) (or ?v_125 (or ?v_391 ?v_124)))) (and (and (and (and (and (or ?v_90 (or ?v_91 ?v_92)) (or ?v_93 (or ?v_94 ?v_95))) (or ?v_96 (or ?v_151 ?v_97))) (or ?v_99 (or ?v_221 ?v_99))) (or ?v_113 (or ?v_302 ?v_112))) (or ?v_127 (or ?v_394 ?v_126)))) (and (and (and (and (and (or ?v_104 (or ?v_105 ?v_106)) (or ?v_107 (or ?v_108 ?v_109))) (or ?v_110 (or ?v_152 ?v_111))) (or ?v_112 (or ?v_222 ?v_113))) (or ?v_115 (or ?v_304 ?v_115))) (or ?v_129 (or ?v_397 ?v_128)))) (and (and (and (and (and (or ?v_118 (or ?v_119 ?v_120)) (or ?v_121 (or ?v_122 ?v_123))) (or ?v_124 (or ?v_153 ?v_125))) (or ?v_126 (or ?v_223 ?v_127))) (or ?v_128 (or ?v_305 ?v_129))) (or ?v_131 (or ?v_399 ?v_131))))) (and (and (and (and (and (and (and (and (and (and (or ?v_134 (or ?v_133 ?v_134)) (or ?v_145 (or ?v_136 ?v_143))) (or ?v_156 (or ?v_138 ?v_154))) (or ?v_164 (or ?v_204 ?v_162))) (or ?v_174 (or ?v_282 ?v_172))) (or ?v_186 (or ?v_372 ?v_184))) (and (and (and (and (and (or ?v_143 (or ?v_144 ?v_145)) (or ?v_148 (or ?v_147 ?v_148))) (or ?v_159 (or ?v_149 ?v_157))) (or ?v_167 (or ?v_217 ?v_165))) (or ?v_177 (or ?v_297 ?v_175))) (or ?v_189 (or ?v_389 ?v_187)))) (and (and (and (and (and (or ?v_154 (or ?v_155 ?v_156)) (or ?v_157 (or ?v_158 ?v_159))) (or ?v_161 (or ?v_160 ?v_161))) (or ?v_170 (or ?v_230 ?v_168))) (or ?v_180 (or ?v_312 ?v_178))) (or ?v_192 (or ?v_406 ?v_190)))) (and (and (and (and (and (or ?v_162 (or ?v_163 ?v_164)) (or ?v_165 (or ?v_166 ?v_167))) (or ?v_168 (or ?v_169 ?v_170))) (or ?v_171 (or ?v_234 ?v_171))) (or ?v_182 (or ?v_317 ?v_181))) (or ?v_194 (or ?v_411 ?v_193)))) (and (and (and (and (and (or ?v_172 (or ?v_173 ?v_174)) (or ?v_175 (or ?v_176 ?v_177))) (or ?v_178 (or ?v_179 ?v_180))) (or ?v_181 (or ?v_235 ?v_182))) (or ?v_183 (or ?v_319 ?v_183))) (or ?v_196 (or ?v_414 ?v_195)))) (and (and (and (and (and (or ?v_184 (or ?v_185 ?v_186)) (or ?v_187 (or ?v_188 ?v_189))) (or ?v_190 (or ?v_191 ?v_192))) (or ?v_193 (or ?v_236 ?v_194))) (or ?v_195 (or ?v_320 ?v_196))) (or ?v_197 (or ?v_416 ?v_197))))) (and (and (and (and (and (and (and (and (and (and (or ?v_200 (or ?v_199 ?v_200)) (or ?v_213 (or ?v_202 ?v_211))) (or ?v_226 (or ?v_205 ?v_224))) (or ?v_239 (or ?v_207 ?v_237))) (or ?v_250 (or ?v_285 ?v_248))) (or ?v_263 (or ?v_375 ?v_261))) (and (and (and (and (and (or ?v_211 (or ?v_212 ?v_213)) (or ?v_216 (or ?v_215 ?v_216))) (or ?v_229 (or ?v_218 ?v_227))) (or ?v_242 (or ?v_220 ?v_240))) (or ?v_253 (or ?v_300 ?v_251))) (or ?v_266 (or ?v_392 ?v_264)))) (and (and (and (and (and (or ?v_224 (or ?v_225 ?v_226)) (or ?v_227 (or ?v_228 ?v_229))) (or ?v_232 (or ?v_231 ?v_232))) (or ?v_245 (or ?v_233 ?v_243))) (or ?v_256 (or ?v_315 ?v_254))) (or ?v_269 (or ?v_409 ?v_267)))) (and (and (and (and (and (or ?v_237 (or ?v_238 ?v_239)) (or ?v_240 (or ?v_241 ?v_242))) (or ?v_243 (or ?v_244 ?v_245))) (or ?v_247 (or ?v_246 ?v_247))) (or ?v_259 (or ?v_330 ?v_257))) (or ?v_272 (or ?v_426 ?v_270)))) (and (and (and (and (and (or ?v_248 (or ?v_249 ?v_250)) (or ?v_251 (or ?v_252 ?v_253))) (or ?v_254 (or ?v_255 ?v_256))) (or ?v_257 (or ?v_258 ?v_259))) (or ?v_260 (or ?v_334 ?v_260))) (or ?v_274 (or ?v_431 ?v_273)))) (and (and (and (and (and (or ?v_261 (or ?v_262 ?v_263)) (or ?v_264 (or ?v_265 ?v_266))) (or ?v_267 (or ?v_268 ?v_269))) (or ?v_270 (or ?v_271 ?v_272))) (or ?v_273 (or ?v_335 ?v_274))) (or ?v_275 (or ?v_433 ?v_275))))) (and (and (and (and (and (and (and (and (and (and (or ?v_278 (or ?v_277 ?v_278)) (or ?v_293 (or ?v_280 ?v_291))) (or ?v_308 (or ?v_283 ?v_306))) (or ?v_323 (or ?v_286 ?v_321))) (or ?v_338 (or ?v_288 ?v_336))) (or ?v_352 (or ?v_378 ?v_350))) (and (and (and (and (and (or ?v_291 (or ?v_292 ?v_293)) (or ?v_296 (or ?v_295 ?v_296))) (or ?v_311 (or ?v_298 ?v_309))) (or ?v_326 (or ?v_301 ?v_324))) (or ?v_341 (or ?v_303 ?v_339))) (or ?v_355 (or ?v_395 ?v_353)))) (and (and (and (and (and (or ?v_306 (or ?v_307 ?v_308)) (or ?v_309 (or ?v_310 ?v_311))) (or ?v_314 (or ?v_313 ?v_314))) (or ?v_329 (or ?v_316 ?v_327))) (or ?v_344 (or ?v_318 ?v_342))) (or ?v_358 (or ?v_412 ?v_356)))) (and (and (and (and (and (or ?v_321 (or ?v_322 ?v_323)) (or ?v_324 (or ?v_325 ?v_326))) (or ?v_327 (or ?v_328 ?v_329))) (or ?v_332 (or ?v_331 ?v_332))) (or ?v_347 (or ?v_333 ?v_345))) (or ?v_361 (or ?v_429 ?v_359)))) (and (and (and (and (and (or ?v_336 (or ?v_337 ?v_338)) (or ?v_339 (or ?v_340 ?v_341))) (or ?v_342 (or ?v_343 ?v_344))) (or ?v_345 (or ?v_346 ?v_347))) (or ?v_349 (or ?v_348 ?v_349))) (or ?v_364 (or ?v_446 ?v_362)))) (and (and (and (and (and (or ?v_350 (or ?v_351 ?v_352)) (or ?v_353 (or ?v_354 ?v_355))) (or ?v_356 (or ?v_357 ?v_358))) (or ?v_359 (or ?v_360 ?v_361))) (or ?v_362 (or ?v_363 ?v_364))) (or ?v_365 (or ?v_450 ?v_365))))) (and (and (and (and (and (and (and (and (and (and (or ?v_368 (or ?v_367 ?v_368)) (or ?v_385 (or ?v_370 ?v_383))) (or ?v_402 (or ?v_373 ?v_400))) (or ?v_419 (or ?v_376 ?v_417))) (or ?v_436 (or ?v_379 ?v_434))) (or ?v_453 (or ?v_381 ?v_451))) (and (and (and (and (and (or ?v_383 (or ?v_384 ?v_385)) (or ?v_388 (or ?v_387 ?v_388))) (or ?v_405 (or ?v_390 ?v_403))) (or ?v_422 (or ?v_393 ?v_420))) (or ?v_439 (or ?v_396 ?v_437))) (or ?v_456 (or ?v_398 ?v_454)))) (and (and (and (and (and (or ?v_400 (or ?v_401 ?v_402)) (or ?v_403 (or ?v_404 ?v_405))) (or ?v_408 (or ?v_407 ?v_408))) (or ?v_425 (or ?v_410 ?v_423))) (or ?v_442 (or ?v_413 ?v_440))) (or ?v_459 (or ?v_415 ?v_457)))) (and (and (and (and (and (or ?v_417 (or ?v_418 ?v_419)) (or ?v_420 (or ?v_421 ?v_422))) (or ?v_423 (or ?v_424 ?v_425))) (or ?v_428 (or ?v_427 ?v_428))) (or ?v_445 (or ?v_430 ?v_443))) (or ?v_462 (or ?v_432 ?v_460)))) (and (and (and (and (and (or ?v_434 (or ?v_435 ?v_436)) (or ?v_437 (or ?v_438 ?v_439))) (or ?v_440 (or ?v_441 ?v_442))) (or ?v_443 (or ?v_444 ?v_445))) (or ?v_448 (or ?v_447 ?v_448))) (or ?v_465 (or ?v_449 ?v_463)))) (and (and (and (and (and (or ?v_451 (or ?v_452 ?v_453)) (or ?v_454 (or ?v_455 ?v_456))) (or ?v_457 (or ?v_458 ?v_459))) (or ?v_460 (or ?v_461 ?v_462))) (or ?v_463 (or ?v_464 ?v_465))) (or ?v_467 (or ?v_466 ?v_467))))))))) (assert (let ((?v_6 (op e0 e1)) (?v_12 (op e0 e2)) (?v_18 (op e0 e3)) (?v_24 (op e0 e4)) (?v_30 (op e0 e5)) (?v_1 (op e1 e0)) (?v_13 (op e1 e2)) (?v_19 (op e1 e3)) (?v_25 (op e1 e4)) (?v_31 (op e1 e5)) (?v_2 (op e2 e0)) (?v_8 (op e2 e1)) (?v_20 (op e2 e3)) (?v_26 (op e2 e4)) (?v_32 (op e2 e5)) (?v_3 (op e3 e0)) (?v_9 (op e3 e1)) (?v_15 (op e3 e2)) (?v_27 (op e3 e4)) (?v_33 (op e3 e5)) (?v_4 (op e4 e0)) (?v_10 (op e4 e1)) (?v_16 (op e4 e2)) (?v_22 (op e4 e3)) (?v_34 (op e4 e5)) (?v_5 (op e5 e0)) (?v_11 (op e5 e1)) (?v_17 (op e5 e2)) (?v_23 (op e5 e3)) (?v_29 (op e5 e4)) (?v_0 (not (= (op e0 (op e0 e0)) e0))) (?v_7 (not (= (op e1 (op e1 e1)) e1))) (?v_14 (not (= (op e2 (op e2 e2)) e2))) (?v_21 (not (= (op e3 (op e3 e3)) e3))) (?v_28 (not (= (op e4 (op e4 e4)) e4))) (?v_35 (not (= (op e5 (op e5 e5)) e5)))) (or (or (or (or (or (and (and (and (and (and (or ?v_0 ?v_0) (or (not (= (op e1 ?v_1) e0)) (not (= (op e0 ?v_1) e1)))) (or (not (= (op e2 ?v_2) e0)) (not (= (op e0 ?v_2) e2)))) (or (not (= (op e3 ?v_3) e0)) (not (= (op e0 ?v_3) e3)))) (or (not (= (op e4 ?v_4) e0)) (not (= (op e0 ?v_4) e4)))) (or (not (= (op e5 ?v_5) e0)) (not (= (op e0 ?v_5) e5)))) (and (and (and (and (and (or (not (= (op e0 ?v_6) e1)) (not (= (op e1 ?v_6) e0))) (or ?v_7 ?v_7)) (or (not (= (op e2 ?v_8) e1)) (not (= (op e1 ?v_8) e2)))) (or (not (= (op e3 ?v_9) e1)) (not (= (op e1 ?v_9) e3)))) (or (not (= (op e4 ?v_10) e1)) (not (= (op e1 ?v_10) e4)))) (or (not (= (op e5 ?v_11) e1)) (not (= (op e1 ?v_11) e5))))) (and (and (and (and (and (or (not (= (op e0 ?v_12) e2)) (not (= (op e2 ?v_12) e0))) (or (not (= (op e1 ?v_13) e2)) (not (= (op e2 ?v_13) e1)))) (or ?v_14 ?v_14)) (or (not (= (op e3 ?v_15) e2)) (not (= (op e2 ?v_15) e3)))) (or (not (= (op e4 ?v_16) e2)) (not (= (op e2 ?v_16) e4)))) (or (not (= (op e5 ?v_17) e2)) (not (= (op e2 ?v_17) e5))))) (and (and (and (and (and (or (not (= (op e0 ?v_18) e3)) (not (= (op e3 ?v_18) e0))) (or (not (= (op e1 ?v_19) e3)) (not (= (op e3 ?v_19) e1)))) (or (not (= (op e2 ?v_20) e3)) (not (= (op e3 ?v_20) e2)))) (or ?v_21 ?v_21)) (or (not (= (op e4 ?v_22) e3)) (not (= (op e3 ?v_22) e4)))) (or (not (= (op e5 ?v_23) e3)) (not (= (op e3 ?v_23) e5))))) (and (and (and (and (and (or (not (= (op e0 ?v_24) e4)) (not (= (op e4 ?v_24) e0))) (or (not (= (op e1 ?v_25) e4)) (not (= (op e4 ?v_25) e1)))) (or (not (= (op e2 ?v_26) e4)) (not (= (op e4 ?v_26) e2)))) (or (not (= (op e3 ?v_27) e4)) (not (= (op e4 ?v_27) e3)))) (or ?v_28 ?v_28)) (or (not (= (op e5 ?v_29) e4)) (not (= (op e4 ?v_29) e5))))) (and (and (and (and (and (or (not (= (op e0 ?v_30) e5)) (not (= (op e5 ?v_30) e0))) (or (not (= (op e1 ?v_31) e5)) (not (= (op e5 ?v_31) e1)))) (or (not (= (op e2 ?v_32) e5)) (not (= (op e5 ?v_32) e2)))) (or (not (= (op e3 ?v_33) e5)) (not (= (op e5 ?v_33) e3)))) (or (not (= (op e4 ?v_34) e5)) (not (= (op e5 ?v_34) e4)))) (or ?v_35 ?v_35))))) (assert (let ((?v_0 (op e0 e0)) (?v_1 (op e0 e1)) (?v_2 (op e0 e2)) (?v_3 (op e0 e3)) (?v_4 (op e0 e4)) (?v_5 (op e0 e5)) (?v_6 (op e1 e0)) (?v_7 (op e1 e1)) (?v_8 (op e1 e2)) (?v_9 (op e1 e3)) (?v_10 (op e1 e4)) (?v_11 (op e1 e5)) (?v_12 (op e2 e0)) (?v_13 (op e2 e1)) (?v_14 (op e2 e2)) (?v_15 (op e2 e3)) (?v_16 (op e2 e4)) (?v_17 (op e2 e5)) (?v_18 (op e3 e0)) (?v_19 (op e3 e1)) (?v_20 (op e3 e2)) (?v_21 (op e3 e3)) (?v_22 (op e3 e4)) (?v_23 (op e3 e5)) (?v_24 (op e4 e0)) (?v_25 (op e4 e1)) (?v_26 (op e4 e2)) (?v_27 (op e4 e3)) (?v_28 (op e4 e4)) (?v_29 (op e4 e5)) (?v_30 (op e5 e0)) (?v_31 (op e5 e1)) (?v_32 (op e5 e2)) (?v_33 (op e5 e3)) (?v_34 (op e5 e4)) (?v_35 (op e5 e5))) (and (and (and (and (and (and (and (and (and (and (or (not (= (op e0 ?v_0) e0)) (= ?v_0 ?v_0)) (or (not (= (op e0 ?v_1) e1)) (= ?v_6 ?v_1))) (or (not (= (op e0 ?v_2) e2)) (= ?v_12 ?v_2))) (or (not (= (op e0 ?v_3) e3)) (= ?v_18 ?v_3))) (or (not (= (op e0 ?v_4) e4)) (= ?v_24 ?v_4))) (or (not (= (op e0 ?v_5) e5)) (= ?v_30 ?v_5))) (and (and (and (and (and (or (not (= (op e1 ?v_6) e0)) (= ?v_1 ?v_6)) (or (not (= (op e1 ?v_7) e1)) (= ?v_7 ?v_7))) (or (not (= (op e1 ?v_8) e2)) (= ?v_13 ?v_8))) (or (not (= (op e1 ?v_9) e3)) (= ?v_19 ?v_9))) (or (not (= (op e1 ?v_10) e4)) (= ?v_25 ?v_10))) (or (not (= (op e1 ?v_11) e5)) (= ?v_31 ?v_11)))) (and (and (and (and (and (or (not (= (op e2 ?v_12) e0)) (= ?v_2 ?v_12)) (or (not (= (op e2 ?v_13) e1)) (= ?v_8 ?v_13))) (or (not (= (op e2 ?v_14) e2)) (= ?v_14 ?v_14))) (or (not (= (op e2 ?v_15) e3)) (= ?v_20 ?v_15))) (or (not (= (op e2 ?v_16) e4)) (= ?v_26 ?v_16))) (or (not (= (op e2 ?v_17) e5)) (= ?v_32 ?v_17)))) (and (and (and (and (and (or (not (= (op e3 ?v_18) e0)) (= ?v_3 ?v_18)) (or (not (= (op e3 ?v_19) e1)) (= ?v_9 ?v_19))) (or (not (= (op e3 ?v_20) e2)) (= ?v_15 ?v_20))) (or (not (= (op e3 ?v_21) e3)) (= ?v_21 ?v_21))) (or (not (= (op e3 ?v_22) e4)) (= ?v_27 ?v_22))) (or (not (= (op e3 ?v_23) e5)) (= ?v_33 ?v_23)))) (and (and (and (and (and (or (not (= (op e4 ?v_24) e0)) (= ?v_4 ?v_24)) (or (not (= (op e4 ?v_25) e1)) (= ?v_10 ?v_25))) (or (not (= (op e4 ?v_26) e2)) (= ?v_16 ?v_26))) (or (not (= (op e4 ?v_27) e3)) (= ?v_22 ?v_27))) (or (not (= (op e4 ?v_28) e4)) (= ?v_28 ?v_28))) (or (not (= (op e4 ?v_29) e5)) (= ?v_34 ?v_29)))) (and (and (and (and (and (or (not (= (op e5 ?v_30) e0)) (= ?v_5 ?v_30)) (or (not (= (op e5 ?v_31) e1)) (= ?v_11 ?v_31))) (or (not (= (op e5 ?v_32) e2)) (= ?v_17 ?v_32))) (or (not (= (op e5 ?v_33) e3)) (= ?v_23 ?v_33))) (or (not (= (op e5 ?v_34) e4)) (= ?v_29 ?v_34))) (or (not (= (op e5 ?v_35) e5)) (= ?v_35 ?v_35)))))) (assert (let ((?v_0 (op e0 e0)) (?v_6 (op e0 e1)) (?v_12 (op e0 e2)) (?v_18 (op e0 e3)) (?v_24 (op e0 e4)) (?v_30 (op e0 e5)) (?v_1 (op e1 e0)) (?v_7 (op e1 e1)) (?v_13 (op e1 e2)) (?v_19 (op e1 e3)) (?v_25 (op e1 e4)) (?v_31 (op e1 e5)) (?v_2 (op e2 e0)) (?v_8 (op e2 e1)) (?v_14 (op e2 e2)) (?v_20 (op e2 e3)) (?v_26 (op e2 e4)) (?v_32 (op e2 e5)) (?v_3 (op e3 e0)) (?v_9 (op e3 e1)) (?v_15 (op e3 e2)) (?v_21 (op e3 e3)) (?v_27 (op e3 e4)) (?v_33 (op e3 e5)) (?v_4 (op e4 e0)) (?v_10 (op e4 e1)) (?v_16 (op e4 e2)) (?v_22 (op e4 e3)) (?v_28 (op e4 e4)) (?v_34 (op e4 e5)) (?v_5 (op e5 e0)) (?v_11 (op e5 e1)) (?v_17 (op e5 e2)) (?v_23 (op e5 e3)) (?v_29 (op e5 e4)) (?v_35 (op e5 e5))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_1)) (not (= ?v_0 ?v_2))) (not (= ?v_0 ?v_3))) (not (= ?v_0 ?v_4))) (not (= ?v_0 ?v_5))) (not (= ?v_1 ?v_2))) (not (= ?v_1 ?v_3))) (not (= ?v_1 ?v_4))) (not (= ?v_1 ?v_5))) (not (= ?v_2 ?v_3))) (not (= ?v_2 ?v_4))) (not (= ?v_2 ?v_5))) (not (= ?v_3 ?v_4))) (not (= ?v_3 ?v_5))) (not (= ?v_4 ?v_5))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_6 ?v_7)) (not (= ?v_6 ?v_8))) (not (= ?v_6 ?v_9))) (not (= ?v_6 ?v_10))) (not (= ?v_6 ?v_11))) (not (= ?v_7 ?v_8))) (not (= ?v_7 ?v_9))) (not (= ?v_7 ?v_10))) (not (= ?v_7 ?v_11))) (not (= ?v_8 ?v_9))) (not (= ?v_8 ?v_10))) (not (= ?v_8 ?v_11))) (not (= ?v_9 ?v_10))) (not (= ?v_9 ?v_11))) (not (= ?v_10 ?v_11)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_12 ?v_13)) (not (= ?v_12 ?v_14))) (not (= ?v_12 ?v_15))) (not (= ?v_12 ?v_16))) (not (= ?v_12 ?v_17))) (not (= ?v_13 ?v_14))) (not (= ?v_13 ?v_15))) (not (= ?v_13 ?v_16))) (not (= ?v_13 ?v_17))) (not (= ?v_14 ?v_15))) (not (= ?v_14 ?v_16))) (not (= ?v_14 ?v_17))) (not (= ?v_15 ?v_16))) (not (= ?v_15 ?v_17))) (not (= ?v_16 ?v_17)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_18 ?v_19)) (not (= ?v_18 ?v_20))) (not (= ?v_18 ?v_21))) (not (= ?v_18 ?v_22))) (not (= ?v_18 ?v_23))) (not (= ?v_19 ?v_20))) (not (= ?v_19 ?v_21))) (not (= ?v_19 ?v_22))) (not (= ?v_19 ?v_23))) (not (= ?v_20 ?v_21))) (not (= ?v_20 ?v_22))) (not (= ?v_20 ?v_23))) (not (= ?v_21 ?v_22))) (not (= ?v_21 ?v_23))) (not (= ?v_22 ?v_23)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_24 ?v_25)) (not (= ?v_24 ?v_26))) (not (= ?v_24 ?v_27))) (not (= ?v_24 ?v_28))) (not (= ?v_24 ?v_29))) (not (= ?v_25 ?v_26))) (not (= ?v_25 ?v_27))) (not (= ?v_25 ?v_28))) (not (= ?v_25 ?v_29))) (not (= ?v_26 ?v_27))) (not (= ?v_26 ?v_28))) (not (= ?v_26 ?v_29))) (not (= ?v_27 ?v_28))) (not (= ?v_27 ?v_29))) (not (= ?v_28 ?v_29)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_30 ?v_31)) (not (= ?v_30 ?v_32))) (not (= ?v_30 ?v_33))) (not (= ?v_30 ?v_34))) (not (= ?v_30 ?v_35))) (not (= ?v_31 ?v_32))) (not (= ?v_31 ?v_33))) (not (= ?v_31 ?v_34))) (not (= ?v_31 ?v_35))) (not (= ?v_32 ?v_33))) (not (= ?v_32 ?v_34))) (not (= ?v_32 ?v_35))) (not (= ?v_33 ?v_34))) (not (= ?v_33 ?v_35))) (not (= ?v_34 ?v_35)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_6)) (not (= ?v_0 ?v_12))) (not (= ?v_0 ?v_18))) (not (= ?v_0 ?v_24))) (not (= ?v_0 ?v_30))) (not (= ?v_6 ?v_12))) (not (= ?v_6 ?v_18))) (not (= ?v_6 ?v_24))) (not (= ?v_6 ?v_30))) (not (= ?v_12 ?v_18))) (not (= ?v_12 ?v_24))) (not (= ?v_12 ?v_30))) (not (= ?v_18 ?v_24))) (not (= ?v_18 ?v_30))) (not (= ?v_24 ?v_30))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_1 ?v_7)) (not (= ?v_1 ?v_13))) (not (= ?v_1 ?v_19))) (not (= ?v_1 ?v_25))) (not (= ?v_1 ?v_31))) (not (= ?v_7 ?v_13))) (not (= ?v_7 ?v_19))) (not (= ?v_7 ?v_25))) (not (= ?v_7 ?v_31))) (not (= ?v_13 ?v_19))) (not (= ?v_13 ?v_25))) (not (= ?v_13 ?v_31))) (not (= ?v_19 ?v_25))) (not (= ?v_19 ?v_31))) (not (= ?v_25 ?v_31)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_2 ?v_8)) (not (= ?v_2 ?v_14))) (not (= ?v_2 ?v_20))) (not (= ?v_2 ?v_26))) (not (= ?v_2 ?v_32))) (not (= ?v_8 ?v_14))) (not (= ?v_8 ?v_20))) (not (= ?v_8 ?v_26))) (not (= ?v_8 ?v_32))) (not (= ?v_14 ?v_20))) (not (= ?v_14 ?v_26))) (not (= ?v_14 ?v_32))) (not (= ?v_20 ?v_26))) (not (= ?v_20 ?v_32))) (not (= ?v_26 ?v_32)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_3 ?v_9)) (not (= ?v_3 ?v_15))) (not (= ?v_3 ?v_21))) (not (= ?v_3 ?v_27))) (not (= ?v_3 ?v_33))) (not (= ?v_9 ?v_15))) (not (= ?v_9 ?v_21))) (not (= ?v_9 ?v_27))) (not (= ?v_9 ?v_33))) (not (= ?v_15 ?v_21))) (not (= ?v_15 ?v_27))) (not (= ?v_15 ?v_33))) (not (= ?v_21 ?v_27))) (not (= ?v_21 ?v_33))) (not (= ?v_27 ?v_33)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_4 ?v_10)) (not (= ?v_4 ?v_16))) (not (= ?v_4 ?v_22))) (not (= ?v_4 ?v_28))) (not (= ?v_4 ?v_34))) (not (= ?v_10 ?v_16))) (not (= ?v_10 ?v_22))) (not (= ?v_10 ?v_28))) (not (= ?v_10 ?v_34))) (not (= ?v_16 ?v_22))) (not (= ?v_16 ?v_28))) (not (= ?v_16 ?v_34))) (not (= ?v_22 ?v_28))) (not (= ?v_22 ?v_34))) (not (= ?v_28 ?v_34)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_5 ?v_11)) (not (= ?v_5 ?v_17))) (not (= ?v_5 ?v_23))) (not (= ?v_5 ?v_29))) (not (= ?v_5 ?v_35))) (not (= ?v_11 ?v_17))) (not (= ?v_11 ?v_23))) (not (= ?v_11 ?v_29))) (not (= ?v_11 ?v_35))) (not (= ?v_17 ?v_23))) (not (= ?v_17 ?v_29))) (not (= ?v_17 ?v_35))) (not (= ?v_23 ?v_29))) (not (= ?v_23 ?v_35))) (not (= ?v_29 ?v_35))))))) (assert (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= e0 e1)) (not (= e0 e2))) (not (= e0 e3))) (not (= e0 e4))) (not (= e0 e5))) (not (= e1 e2))) (not (= e1 e3))) (not (= e1 e4))) (not (= e1 e5))) (not (= e2 e3))) (not (= e2 e4))) (not (= e2 e5))) (not (= e3 e4))) (not (= e3 e5))) (not (= e4 e5)))) (assert (and (and (and (and (= e0 (op e3 e2)) (= e1 (op e3 e5))) (= e2 (op e4 e5))) (= e3 (op e2 e5))) (= e5 (op e4 e4)))) (assert (not (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= (op e0 e0) e2) (= (op e0 e1) e0)) (= (op e0 e2) e5)) (= (op e0 e3) e1)) (= (op e0 e4) e3)) (= (op e0 e5) e4)) (= (op e1 e0) e0)) (= (op e1 e1) e1)) (= (op e1 e2) e2)) (= (op e1 e3) e3)) (= (op e1 e4) e4)) (= (op e1 e5) e5)) (= (op e2 e0) e5)) (= (op e2 e1) e2)) (= (op e2 e2) e1)) (= (op e2 e3) e4)) (= (op e2 e4) e0)) (= (op e2 e5) e3)) (= (op e3 e0) e4)) (= (op e3 e1) e3)) (= (op e3 e2) e0)) (= (op e3 e3) e5)) (= (op e3 e4) e2)) (= (op e3 e5) e1)) (= (op e4 e0) e1)) (= (op e4 e1) e4)) (= (op e4 e2) e3)) (= (op e4 e3) e0)) (= (op e4 e4) e5)) (= (op e4 e5) e2)) (= (op e5 e0) e3)) (= (op e5 e1) e5)) (= (op e5 e2) e4)) (= (op e5 e3) e2)) (= (op e5 e4) e1)) (= (op e5 e5) e0)))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/iso_brn029.smt2.expected.err000066400000000000000000000000001445011647600233470ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/iso_brn029.smt2.expected.out000066400000000000000000000000041445011647600233720ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/iso_brn029.smt2.expected.time000066400000000000000000000000351445011647600235250ustar00rootroot00000000000000real 0.97 user 0.97 sys 0.00 opensmt-2.5.2/regression/QF_UF/iso_brn029_simplified_0c.smt2000066400000000000000000000010241445011647600235560ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort I 0) (declare-fun op (I I) I) (declare-fun e5 () I) (declare-fun e4 () I) (declare-fun e3 () I) (declare-fun e2 () I) (declare-fun e1 () I) (declare-fun e0 () I) (assert (and (= (op e1 e5) e0) (= (op e3 e5) e1) (= (op e4 e5) e2) (= (op e2 e5) e3) (= (op e5 e0) e4) (= (op e1 e5) e5) )) (assert (and (not (= (op e1 e2) e1)) (and (not (= (op e2 e0) e1)) (or (not (= (op e2 e1) e1)) (or (= (op e2 e1) e1) (not (= (op e1 e2) e1))))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/iso_brn029_simplified_0c.smt2.expected.err000066400000000000000000000000001445011647600261360ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/iso_brn029_simplified_0c.smt2.expected.out000066400000000000000000000000041445011647600261610ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/iso_brn029_simplified_0c.smt2.expected.time000066400000000000000000000000351445011647600263140ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_UF/iso_brn029_simplified_1b.smt2000066400000000000000000000005361445011647600235650ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort I 0) (declare-fun op (I I) I) (declare-fun e5 () I) (declare-fun e4 () I) (declare-fun e3 () I) (declare-fun e2 () I) (declare-fun e1 () I) (declare-fun e0 () I) (assert (and (= (op e1 e5) e0) (= (op e3 e5) e1) (= (op e4 e5) e2) (= (op e2 e5) e3) (= (op e5 e0) e4) (= (op e1 e5) e5))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/iso_brn029_simplified_1b.smt2.expected.err000066400000000000000000000000001445011647600261360ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/iso_brn029_simplified_1b.smt2.expected.out000066400000000000000000000000041445011647600261610ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/iso_brn029_simplified_1b.smt2.expected.time000066400000000000000000000000351445011647600263140ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_UF/iso_brn029_simplified_2.smt2000066400000000000000000000003751445011647600234250ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort I 0) (declare-fun op (I I) I) (declare-fun e5 () I) (declare-fun e4 () I) (assert (and (= (op e4 e5) e4) (or (not (= (op e4 e5) e5)) (or (= (op e4 e5) e5) (not (= (op e5 e4) e5)))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/iso_brn029_simplified_2.smt2.expected.err000066400000000000000000000000001445011647600257750ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/iso_brn029_simplified_2.smt2.expected.out000066400000000000000000000000041445011647600260200ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/iso_brn029_simplified_2.smt2.expected.time000066400000000000000000000000351445011647600261530ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_UF/iso_brn268.smt2000066400000000000000000001044441445011647600210060ustar00rootroot00000000000000(set-logic QF_UF) (set-info :source | http://www.cs.bham.ac.uk/~vxs/quasigroups/benchmark/ |) (set-info :smt-lib-version 2.0) (set-info :category "crafted") (declare-sort U 0) (declare-sort I 0) (declare-fun op1 (I I) I) (declare-fun op (I I) I) (declare-fun e4 () I) (declare-fun e3 () I) (declare-fun e2 () I) (declare-fun e1 () I) (declare-fun e0 () I) (assert (let ((?v_0 (op e0 e0)) (?v_1 (op e0 e1)) (?v_2 (op e0 e2)) (?v_3 (op e0 e3)) (?v_4 (op e0 e4)) (?v_5 (op e1 e0)) (?v_6 (op e1 e1)) (?v_7 (op e1 e2)) (?v_8 (op e1 e3)) (?v_9 (op e1 e4)) (?v_10 (op e2 e0)) (?v_11 (op e2 e1)) (?v_12 (op e2 e2)) (?v_13 (op e2 e3)) (?v_14 (op e2 e4)) (?v_15 (op e3 e0)) (?v_16 (op e3 e1)) (?v_17 (op e3 e2)) (?v_18 (op e3 e3)) (?v_19 (op e3 e4)) (?v_20 (op e4 e0)) (?v_21 (op e4 e1)) (?v_22 (op e4 e2)) (?v_23 (op e4 e3)) (?v_24 (op e4 e4))) (and (and (and (and (and (and (and (and (or (or (or (or (= ?v_0 e0) (= ?v_0 e1)) (= ?v_0 e2)) (= ?v_0 e3)) (= ?v_0 e4)) (or (or (or (or (= ?v_1 e0) (= ?v_1 e1)) (= ?v_1 e2)) (= ?v_1 e3)) (= ?v_1 e4))) (or (or (or (or (= ?v_2 e0) (= ?v_2 e1)) (= ?v_2 e2)) (= ?v_2 e3)) (= ?v_2 e4))) (or (or (or (or (= ?v_3 e0) (= ?v_3 e1)) (= ?v_3 e2)) (= ?v_3 e3)) (= ?v_3 e4))) (or (or (or (or (= ?v_4 e0) (= ?v_4 e1)) (= ?v_4 e2)) (= ?v_4 e3)) (= ?v_4 e4))) (and (and (and (and (or (or (or (or (= ?v_5 e0) (= ?v_5 e1)) (= ?v_5 e2)) (= ?v_5 e3)) (= ?v_5 e4)) (or (or (or (or (= ?v_6 e0) (= ?v_6 e1)) (= ?v_6 e2)) (= ?v_6 e3)) (= ?v_6 e4))) (or (or (or (or (= ?v_7 e0) (= ?v_7 e1)) (= ?v_7 e2)) (= ?v_7 e3)) (= ?v_7 e4))) (or (or (or (or (= ?v_8 e0) (= ?v_8 e1)) (= ?v_8 e2)) (= ?v_8 e3)) (= ?v_8 e4))) (or (or (or (or (= ?v_9 e0) (= ?v_9 e1)) (= ?v_9 e2)) (= ?v_9 e3)) (= ?v_9 e4)))) (and (and (and (and (or (or (or (or (= ?v_10 e0) (= ?v_10 e1)) (= ?v_10 e2)) (= ?v_10 e3)) (= ?v_10 e4)) (or (or (or (or (= ?v_11 e0) (= ?v_11 e1)) (= ?v_11 e2)) (= ?v_11 e3)) (= ?v_11 e4))) (or (or (or (or (= ?v_12 e0) (= ?v_12 e1)) (= ?v_12 e2)) (= ?v_12 e3)) (= ?v_12 e4))) (or (or (or (or (= ?v_13 e0) (= ?v_13 e1)) (= ?v_13 e2)) (= ?v_13 e3)) (= ?v_13 e4))) (or (or (or (or (= ?v_14 e0) (= ?v_14 e1)) (= ?v_14 e2)) (= ?v_14 e3)) (= ?v_14 e4)))) (and (and (and (and (or (or (or (or (= ?v_15 e0) (= ?v_15 e1)) (= ?v_15 e2)) (= ?v_15 e3)) (= ?v_15 e4)) (or (or (or (or (= ?v_16 e0) (= ?v_16 e1)) (= ?v_16 e2)) (= ?v_16 e3)) (= ?v_16 e4))) (or (or (or (or (= ?v_17 e0) (= ?v_17 e1)) (= ?v_17 e2)) (= ?v_17 e3)) (= ?v_17 e4))) (or (or (or (or (= ?v_18 e0) (= ?v_18 e1)) (= ?v_18 e2)) (= ?v_18 e3)) (= ?v_18 e4))) (or (or (or (or (= ?v_19 e0) (= ?v_19 e1)) (= ?v_19 e2)) (= ?v_19 e3)) (= ?v_19 e4)))) (and (and (and (and (or (or (or (or (= ?v_20 e0) (= ?v_20 e1)) (= ?v_20 e2)) (= ?v_20 e3)) (= ?v_20 e4)) (or (or (or (or (= ?v_21 e0) (= ?v_21 e1)) (= ?v_21 e2)) (= ?v_21 e3)) (= ?v_21 e4))) (or (or (or (or (= ?v_22 e0) (= ?v_22 e1)) (= ?v_22 e2)) (= ?v_22 e3)) (= ?v_22 e4))) (or (or (or (or (= ?v_23 e0) (= ?v_23 e1)) (= ?v_23 e2)) (= ?v_23 e3)) (= ?v_23 e4))) (or (or (or (or (= ?v_24 e0) (= ?v_24 e1)) (= ?v_24 e2)) (= ?v_24 e3)) (= ?v_24 e4)))))) (assert (let ((?v_1 (op e0 e0)) (?v_2 (op e0 e1)) (?v_3 (op e0 e2)) (?v_4 (op e0 e3)) (?v_5 (op e0 e4)) (?v_7 (op e1 e0)) (?v_18 (op e1 e1)) (?v_19 (op e1 e2)) (?v_20 (op e1 e3)) (?v_21 (op e1 e4)) (?v_8 (op e2 e0)) (?v_24 (op e2 e1)) (?v_43 (op e2 e2)) (?v_44 (op e2 e3)) (?v_45 (op e2 e4)) (?v_9 (op e3 e0)) (?v_25 (op e3 e1)) (?v_49 (op e3 e2)) (?v_76 (op e3 e3)) (?v_77 (op e3 e4)) (?v_10 (op e4 e0)) (?v_26 (op e4 e1)) (?v_50 (op e4 e2)) (?v_82 (op e4 e3)) (?v_117 (op e4 e4))) (let ((?v_0 (= ?v_1 e0)) (?v_6 (= ?v_1 e1)) (?v_11 (= ?v_1 e2)) (?v_12 (= ?v_1 e3)) (?v_13 (= ?v_1 e4)) (?v_15 (= ?v_2 e0)) (?v_22 (= ?v_2 e1)) (?v_28 (= ?v_2 e2)) (?v_31 (= ?v_2 e3)) (?v_34 (= ?v_2 e4)) (?v_38 (= ?v_3 e0)) (?v_46 (= ?v_3 e1)) (?v_53 (= ?v_3 e2)) (?v_58 (= ?v_3 e3)) (?v_63 (= ?v_3 e4)) (?v_69 (= ?v_4 e0)) (?v_78 (= ?v_4 e1)) (?v_86 (= ?v_4 e2)) (?v_93 (= ?v_4 e3)) (?v_100 (= ?v_4 e4)) (?v_108 (= ?v_5 e0)) (?v_118 (= ?v_5 e1)) (?v_127 (= ?v_5 e2)) (?v_136 (= ?v_5 e3)) (?v_145 (= ?v_5 e4)) (?v_14 (= ?v_7 e0)) (?v_17 (= ?v_7 e1)) (?v_27 (= ?v_7 e2)) (?v_30 (= ?v_7 e3)) (?v_33 (= ?v_7 e4)) (?v_16 (= ?v_18 e0)) (?v_23 (= ?v_18 e1)) (?v_29 (= ?v_18 e2)) (?v_32 (= ?v_18 e3)) (?v_35 (= ?v_18 e4)) (?v_39 (= ?v_19 e0)) (?v_47 (= ?v_19 e1)) (?v_54 (= ?v_19 e2)) (?v_59 (= ?v_19 e3)) (?v_64 (= ?v_19 e4)) (?v_70 (= ?v_20 e0)) (?v_79 (= ?v_20 e1)) (?v_87 (= ?v_20 e2)) (?v_94 (= ?v_20 e3)) (?v_101 (= ?v_20 e4)) (?v_109 (= ?v_21 e0)) (?v_119 (= ?v_21 e1)) (?v_128 (= ?v_21 e2)) (?v_137 (= ?v_21 e3)) (?v_146 (= ?v_21 e4)) (?v_36 (= ?v_8 e0)) (?v_41 (= ?v_8 e1)) (?v_51 (= ?v_8 e2)) (?v_56 (= ?v_8 e3)) (?v_61 (= ?v_8 e4)) (?v_37 (= ?v_24 e0)) (?v_42 (= ?v_24 e1)) (?v_52 (= ?v_24 e2)) (?v_57 (= ?v_24 e3)) (?v_62 (= ?v_24 e4)) (?v_40 (= ?v_43 e0)) (?v_48 (= ?v_43 e1)) (?v_55 (= ?v_43 e2)) (?v_60 (= ?v_43 e3)) (?v_65 (= ?v_43 e4)) (?v_71 (= ?v_44 e0)) (?v_80 (= ?v_44 e1)) (?v_88 (= ?v_44 e2)) (?v_95 (= ?v_44 e3)) (?v_102 (= ?v_44 e4)) (?v_110 (= ?v_45 e0)) (?v_120 (= ?v_45 e1)) (?v_129 (= ?v_45 e2)) (?v_138 (= ?v_45 e3)) (?v_147 (= ?v_45 e4)) (?v_66 (= ?v_9 e0)) (?v_73 (= ?v_9 e1)) (?v_83 (= ?v_9 e2)) (?v_90 (= ?v_9 e3)) (?v_97 (= ?v_9 e4)) (?v_67 (= ?v_25 e0)) (?v_74 (= ?v_25 e1)) (?v_84 (= ?v_25 e2)) (?v_91 (= ?v_25 e3)) (?v_98 (= ?v_25 e4)) (?v_68 (= ?v_49 e0)) (?v_75 (= ?v_49 e1)) (?v_85 (= ?v_49 e2)) (?v_92 (= ?v_49 e3)) (?v_99 (= ?v_49 e4)) (?v_72 (= ?v_76 e0)) (?v_81 (= ?v_76 e1)) (?v_89 (= ?v_76 e2)) (?v_96 (= ?v_76 e3)) (?v_103 (= ?v_76 e4)) (?v_111 (= ?v_77 e0)) (?v_121 (= ?v_77 e1)) (?v_130 (= ?v_77 e2)) (?v_139 (= ?v_77 e3)) (?v_148 (= ?v_77 e4)) (?v_104 (= ?v_10 e0)) (?v_113 (= ?v_10 e1)) (?v_123 (= ?v_10 e2)) (?v_132 (= ?v_10 e3)) (?v_141 (= ?v_10 e4)) (?v_105 (= ?v_26 e0)) (?v_114 (= ?v_26 e1)) (?v_124 (= ?v_26 e2)) (?v_133 (= ?v_26 e3)) (?v_142 (= ?v_26 e4)) (?v_106 (= ?v_50 e0)) (?v_115 (= ?v_50 e1)) (?v_125 (= ?v_50 e2)) (?v_134 (= ?v_50 e3)) (?v_143 (= ?v_50 e4)) (?v_107 (= ?v_82 e0)) (?v_116 (= ?v_82 e1)) (?v_126 (= ?v_82 e2)) (?v_135 (= ?v_82 e3)) (?v_144 (= ?v_82 e4)) (?v_112 (= ?v_117 e0)) (?v_122 (= ?v_117 e1)) (?v_131 (= ?v_117 e2)) (?v_140 (= ?v_117 e3)) (?v_149 (= ?v_117 e4))) (and (and (and (and (and (and (and (and (and (or (or (or (or ?v_0 ?v_15) ?v_38) ?v_69) ?v_108) (or (or (or (or ?v_0 ?v_14) ?v_36) ?v_66) ?v_104)) (and (or (or (or (or ?v_6 ?v_22) ?v_46) ?v_78) ?v_118) (or (or (or (or ?v_6 ?v_17) ?v_41) ?v_73) ?v_113))) (and (or (or (or (or ?v_11 ?v_28) ?v_53) ?v_86) ?v_127) (or (or (or (or ?v_11 ?v_27) ?v_51) ?v_83) ?v_123))) (and (or (or (or (or ?v_12 ?v_31) ?v_58) ?v_93) ?v_136) (or (or (or (or ?v_12 ?v_30) ?v_56) ?v_90) ?v_132))) (and (or (or (or (or ?v_13 ?v_34) ?v_63) ?v_100) ?v_145) (or (or (or (or ?v_13 ?v_33) ?v_61) ?v_97) ?v_141))) (and (and (and (and (and (or (or (or (or ?v_14 ?v_16) ?v_39) ?v_70) ?v_109) (or (or (or (or ?v_15 ?v_16) ?v_37) ?v_67) ?v_105)) (and (or (or (or (or ?v_17 ?v_23) ?v_47) ?v_79) ?v_119) (or (or (or (or ?v_22 ?v_23) ?v_42) ?v_74) ?v_114))) (and (or (or (or (or ?v_27 ?v_29) ?v_54) ?v_87) ?v_128) (or (or (or (or ?v_28 ?v_29) ?v_52) ?v_84) ?v_124))) (and (or (or (or (or ?v_30 ?v_32) ?v_59) ?v_94) ?v_137) (or (or (or (or ?v_31 ?v_32) ?v_57) ?v_91) ?v_133))) (and (or (or (or (or ?v_33 ?v_35) ?v_64) ?v_101) ?v_146) (or (or (or (or ?v_34 ?v_35) ?v_62) ?v_98) ?v_142)))) (and (and (and (and (and (or (or (or (or ?v_36 ?v_37) ?v_40) ?v_71) ?v_110) (or (or (or (or ?v_38 ?v_39) ?v_40) ?v_68) ?v_106)) (and (or (or (or (or ?v_41 ?v_42) ?v_48) ?v_80) ?v_120) (or (or (or (or ?v_46 ?v_47) ?v_48) ?v_75) ?v_115))) (and (or (or (or (or ?v_51 ?v_52) ?v_55) ?v_88) ?v_129) (or (or (or (or ?v_53 ?v_54) ?v_55) ?v_85) ?v_125))) (and (or (or (or (or ?v_56 ?v_57) ?v_60) ?v_95) ?v_138) (or (or (or (or ?v_58 ?v_59) ?v_60) ?v_92) ?v_134))) (and (or (or (or (or ?v_61 ?v_62) ?v_65) ?v_102) ?v_147) (or (or (or (or ?v_63 ?v_64) ?v_65) ?v_99) ?v_143)))) (and (and (and (and (and (or (or (or (or ?v_66 ?v_67) ?v_68) ?v_72) ?v_111) (or (or (or (or ?v_69 ?v_70) ?v_71) ?v_72) ?v_107)) (and (or (or (or (or ?v_73 ?v_74) ?v_75) ?v_81) ?v_121) (or (or (or (or ?v_78 ?v_79) ?v_80) ?v_81) ?v_116))) (and (or (or (or (or ?v_83 ?v_84) ?v_85) ?v_89) ?v_130) (or (or (or (or ?v_86 ?v_87) ?v_88) ?v_89) ?v_126))) (and (or (or (or (or ?v_90 ?v_91) ?v_92) ?v_96) ?v_139) (or (or (or (or ?v_93 ?v_94) ?v_95) ?v_96) ?v_135))) (and (or (or (or (or ?v_97 ?v_98) ?v_99) ?v_103) ?v_148) (or (or (or (or ?v_100 ?v_101) ?v_102) ?v_103) ?v_144)))) (and (and (and (and (and (or (or (or (or ?v_104 ?v_105) ?v_106) ?v_107) ?v_112) (or (or (or (or ?v_108 ?v_109) ?v_110) ?v_111) ?v_112)) (and (or (or (or (or ?v_113 ?v_114) ?v_115) ?v_116) ?v_122) (or (or (or (or ?v_118 ?v_119) ?v_120) ?v_121) ?v_122))) (and (or (or (or (or ?v_123 ?v_124) ?v_125) ?v_126) ?v_131) (or (or (or (or ?v_127 ?v_128) ?v_129) ?v_130) ?v_131))) (and (or (or (or (or ?v_132 ?v_133) ?v_134) ?v_135) ?v_140) (or (or (or (or ?v_136 ?v_137) ?v_138) ?v_139) ?v_140))) (and (or (or (or (or ?v_141 ?v_142) ?v_143) ?v_144) ?v_149) (or (or (or (or ?v_145 ?v_146) ?v_147) ?v_148) ?v_149))))))) (assert (let ((?v_0 (op e0 e0)) (?v_1 (op e1 e1)) (?v_2 (op e2 e2)) (?v_3 (op e3 e3)) (?v_4 (op e4 e4))) (or (or (or (or (and (and (and (and (not (= ?v_0 e0)) (not (= ?v_1 e0))) (not (= ?v_2 e0))) (not (= ?v_3 e0))) (not (= ?v_4 e0))) (and (and (and (and (not (= ?v_0 e1)) (not (= ?v_1 e1))) (not (= ?v_2 e1))) (not (= ?v_3 e1))) (not (= ?v_4 e1)))) (and (and (and (and (not (= ?v_0 e2)) (not (= ?v_1 e2))) (not (= ?v_2 e2))) (not (= ?v_3 e2))) (not (= ?v_4 e2)))) (and (and (and (and (not (= ?v_0 e3)) (not (= ?v_1 e3))) (not (= ?v_2 e3))) (not (= ?v_3 e3))) (not (= ?v_4 e3)))) (and (and (and (and (not (= ?v_0 e4)) (not (= ?v_1 e4))) (not (= ?v_2 e4))) (not (= ?v_3 e4))) (not (= ?v_4 e4)))))) (assert (let ((?v_25 (op e0 e0)) (?v_27 (op e0 e1)) (?v_29 (op e0 e2)) (?v_31 (op e0 e3)) (?v_33 (op e0 e4)) (?v_28 (op e1 e0)) (?v_37 (op e1 e1)) (?v_39 (op e1 e2)) (?v_41 (op e1 e3)) (?v_43 (op e1 e4)) (?v_30 (op e2 e0)) (?v_40 (op e2 e1)) (?v_49 (op e2 e2)) (?v_51 (op e2 e3)) (?v_53 (op e2 e4)) (?v_32 (op e3 e0)) (?v_42 (op e3 e1)) (?v_52 (op e3 e2)) (?v_61 (op e3 e3)) (?v_63 (op e3 e4)) (?v_34 (op e4 e0)) (?v_44 (op e4 e1)) (?v_54 (op e4 e2)) (?v_64 (op e4 e3)) (?v_73 (op e4 e4))) (let ((?v_0 (= ?v_25 e0)) (?v_26 (= ?v_25 e1)) (?v_75 (= ?v_25 e2)) (?v_100 (= ?v_25 e3)) (?v_125 (= ?v_25 e4)) (?v_2 (= ?v_27 e0)) (?v_36 (= ?v_27 e1)) (?v_77 (= ?v_27 e2)) (?v_102 (= ?v_27 e3)) (?v_127 (= ?v_27 e4)) (?v_5 (= ?v_29 e0)) (?v_46 (= ?v_29 e1)) (?v_80 (= ?v_29 e2)) (?v_105 (= ?v_29 e3)) (?v_130 (= ?v_29 e4)) (?v_10 (= ?v_31 e0)) (?v_56 (= ?v_31 e1)) (?v_85 (= ?v_31 e2)) (?v_110 (= ?v_31 e3)) (?v_135 (= ?v_31 e4)) (?v_17 (= ?v_33 e0)) (?v_66 (= ?v_33 e1)) (?v_92 (= ?v_33 e2)) (?v_117 (= ?v_33 e3)) (?v_142 (= ?v_33 e4)) (?v_1 (= ?v_28 e0)) (?v_35 (= ?v_28 e1)) (?v_76 (= ?v_28 e2)) (?v_101 (= ?v_28 e3)) (?v_126 (= ?v_28 e4)) (?v_3 (= ?v_37 e0)) (?v_38 (= ?v_37 e1)) (?v_78 (= ?v_37 e2)) (?v_103 (= ?v_37 e3)) (?v_128 (= ?v_37 e4)) (?v_7 (= ?v_39 e0)) (?v_48 (= ?v_39 e1)) (?v_82 (= ?v_39 e2)) (?v_107 (= ?v_39 e3)) (?v_132 (= ?v_39 e4)) (?v_12 (= ?v_41 e0)) (?v_58 (= ?v_41 e1)) (?v_87 (= ?v_41 e2)) (?v_112 (= ?v_41 e3)) (?v_137 (= ?v_41 e4)) (?v_19 (= ?v_43 e0)) (?v_68 (= ?v_43 e1)) (?v_94 (= ?v_43 e2)) (?v_119 (= ?v_43 e3)) (?v_144 (= ?v_43 e4)) (?v_4 (= ?v_30 e0)) (?v_45 (= ?v_30 e1)) (?v_79 (= ?v_30 e2)) (?v_104 (= ?v_30 e3)) (?v_129 (= ?v_30 e4)) (?v_6 (= ?v_40 e0)) (?v_47 (= ?v_40 e1)) (?v_81 (= ?v_40 e2)) (?v_106 (= ?v_40 e3)) (?v_131 (= ?v_40 e4)) (?v_8 (= ?v_49 e0)) (?v_50 (= ?v_49 e1)) (?v_83 (= ?v_49 e2)) (?v_108 (= ?v_49 e3)) (?v_133 (= ?v_49 e4)) (?v_14 (= ?v_51 e0)) (?v_60 (= ?v_51 e1)) (?v_89 (= ?v_51 e2)) (?v_114 (= ?v_51 e3)) (?v_139 (= ?v_51 e4)) (?v_21 (= ?v_53 e0)) (?v_70 (= ?v_53 e1)) (?v_96 (= ?v_53 e2)) (?v_121 (= ?v_53 e3)) (?v_146 (= ?v_53 e4)) (?v_9 (= ?v_32 e0)) (?v_55 (= ?v_32 e1)) (?v_84 (= ?v_32 e2)) (?v_109 (= ?v_32 e3)) (?v_134 (= ?v_32 e4)) (?v_11 (= ?v_42 e0)) (?v_57 (= ?v_42 e1)) (?v_86 (= ?v_42 e2)) (?v_111 (= ?v_42 e3)) (?v_136 (= ?v_42 e4)) (?v_13 (= ?v_52 e0)) (?v_59 (= ?v_52 e1)) (?v_88 (= ?v_52 e2)) (?v_113 (= ?v_52 e3)) (?v_138 (= ?v_52 e4)) (?v_15 (= ?v_61 e0)) (?v_62 (= ?v_61 e1)) (?v_90 (= ?v_61 e2)) (?v_115 (= ?v_61 e3)) (?v_140 (= ?v_61 e4)) (?v_23 (= ?v_63 e0)) (?v_72 (= ?v_63 e1)) (?v_98 (= ?v_63 e2)) (?v_123 (= ?v_63 e3)) (?v_148 (= ?v_63 e4)) (?v_16 (= ?v_34 e0)) (?v_65 (= ?v_34 e1)) (?v_91 (= ?v_34 e2)) (?v_116 (= ?v_34 e3)) (?v_141 (= ?v_34 e4)) (?v_18 (= ?v_44 e0)) (?v_67 (= ?v_44 e1)) (?v_93 (= ?v_44 e2)) (?v_118 (= ?v_44 e3)) (?v_143 (= ?v_44 e4)) (?v_20 (= ?v_54 e0)) (?v_69 (= ?v_54 e1)) (?v_95 (= ?v_54 e2)) (?v_120 (= ?v_54 e3)) (?v_145 (= ?v_54 e4)) (?v_22 (= ?v_64 e0)) (?v_71 (= ?v_64 e1)) (?v_97 (= ?v_64 e2)) (?v_122 (= ?v_64 e3)) (?v_147 (= ?v_64 e4)) (?v_24 (= ?v_73 e0)) (?v_74 (= ?v_73 e1)) (?v_99 (= ?v_73 e2)) (?v_124 (= ?v_73 e3)) (?v_149 (= ?v_73 e4))) (and (and (and (and (or (or (or (or (or (or (or (or (and ?v_0 ?v_0) (and ?v_2 ?v_1)) (and ?v_5 ?v_4)) (and ?v_10 ?v_9)) (and ?v_17 ?v_16)) (or (or (or (or (and ?v_1 ?v_2) (and ?v_3 ?v_3)) (and ?v_7 ?v_6)) (and ?v_12 ?v_11)) (and ?v_19 ?v_18))) (or (or (or (or (and ?v_4 ?v_5) (and ?v_6 ?v_7)) (and ?v_8 ?v_8)) (and ?v_14 ?v_13)) (and ?v_21 ?v_20))) (or (or (or (or (and ?v_9 ?v_10) (and ?v_11 ?v_12)) (and ?v_13 ?v_14)) (and ?v_15 ?v_15)) (and ?v_23 ?v_22))) (or (or (or (or (and ?v_16 ?v_17) (and ?v_18 ?v_19)) (and ?v_20 ?v_21)) (and ?v_22 ?v_23)) (and ?v_24 ?v_24))) (or (or (or (or (or (or (or (or (and ?v_26 ?v_26) (and ?v_36 ?v_35)) (and ?v_46 ?v_45)) (and ?v_56 ?v_55)) (and ?v_66 ?v_65)) (or (or (or (or (and ?v_35 ?v_36) (and ?v_38 ?v_38)) (and ?v_48 ?v_47)) (and ?v_58 ?v_57)) (and ?v_68 ?v_67))) (or (or (or (or (and ?v_45 ?v_46) (and ?v_47 ?v_48)) (and ?v_50 ?v_50)) (and ?v_60 ?v_59)) (and ?v_70 ?v_69))) (or (or (or (or (and ?v_55 ?v_56) (and ?v_57 ?v_58)) (and ?v_59 ?v_60)) (and ?v_62 ?v_62)) (and ?v_72 ?v_71))) (or (or (or (or (and ?v_65 ?v_66) (and ?v_67 ?v_68)) (and ?v_69 ?v_70)) (and ?v_71 ?v_72)) (and ?v_74 ?v_74)))) (or (or (or (or (or (or (or (or (and ?v_75 ?v_75) (and ?v_77 ?v_76)) (and ?v_80 ?v_79)) (and ?v_85 ?v_84)) (and ?v_92 ?v_91)) (or (or (or (or (and ?v_76 ?v_77) (and ?v_78 ?v_78)) (and ?v_82 ?v_81)) (and ?v_87 ?v_86)) (and ?v_94 ?v_93))) (or (or (or (or (and ?v_79 ?v_80) (and ?v_81 ?v_82)) (and ?v_83 ?v_83)) (and ?v_89 ?v_88)) (and ?v_96 ?v_95))) (or (or (or (or (and ?v_84 ?v_85) (and ?v_86 ?v_87)) (and ?v_88 ?v_89)) (and ?v_90 ?v_90)) (and ?v_98 ?v_97))) (or (or (or (or (and ?v_91 ?v_92) (and ?v_93 ?v_94)) (and ?v_95 ?v_96)) (and ?v_97 ?v_98)) (and ?v_99 ?v_99)))) (or (or (or (or (or (or (or (or (and ?v_100 ?v_100) (and ?v_102 ?v_101)) (and ?v_105 ?v_104)) (and ?v_110 ?v_109)) (and ?v_117 ?v_116)) (or (or (or (or (and ?v_101 ?v_102) (and ?v_103 ?v_103)) (and ?v_107 ?v_106)) (and ?v_112 ?v_111)) (and ?v_119 ?v_118))) (or (or (or (or (and ?v_104 ?v_105) (and ?v_106 ?v_107)) (and ?v_108 ?v_108)) (and ?v_114 ?v_113)) (and ?v_121 ?v_120))) (or (or (or (or (and ?v_109 ?v_110) (and ?v_111 ?v_112)) (and ?v_113 ?v_114)) (and ?v_115 ?v_115)) (and ?v_123 ?v_122))) (or (or (or (or (and ?v_116 ?v_117) (and ?v_118 ?v_119)) (and ?v_120 ?v_121)) (and ?v_122 ?v_123)) (and ?v_124 ?v_124)))) (or (or (or (or (or (or (or (or (and ?v_125 ?v_125) (and ?v_127 ?v_126)) (and ?v_130 ?v_129)) (and ?v_135 ?v_134)) (and ?v_142 ?v_141)) (or (or (or (or (and ?v_126 ?v_127) (and ?v_128 ?v_128)) (and ?v_132 ?v_131)) (and ?v_137 ?v_136)) (and ?v_144 ?v_143))) (or (or (or (or (and ?v_129 ?v_130) (and ?v_131 ?v_132)) (and ?v_133 ?v_133)) (and ?v_139 ?v_138)) (and ?v_146 ?v_145))) (or (or (or (or (and ?v_134 ?v_135) (and ?v_136 ?v_137)) (and ?v_138 ?v_139)) (and ?v_140 ?v_140)) (and ?v_148 ?v_147))) (or (or (or (or (and ?v_141 ?v_142) (and ?v_143 ?v_144)) (and ?v_145 ?v_146)) (and ?v_147 ?v_148)) (and ?v_149 ?v_149))))))) (assert (let ((?v_0 (op e0 e0)) (?v_2 (op e0 e1)) (?v_5 (op e0 e2)) (?v_10 (op e0 e3)) (?v_17 (op e0 e4)) (?v_1 (op e1 e0)) (?v_3 (op e1 e1)) (?v_7 (op e1 e2)) (?v_12 (op e1 e3)) (?v_19 (op e1 e4)) (?v_4 (op e2 e0)) (?v_6 (op e2 e1)) (?v_8 (op e2 e2)) (?v_14 (op e2 e3)) (?v_21 (op e2 e4)) (?v_9 (op e3 e0)) (?v_11 (op e3 e1)) (?v_13 (op e3 e2)) (?v_15 (op e3 e3)) (?v_23 (op e3 e4)) (?v_16 (op e4 e0)) (?v_18 (op e4 e1)) (?v_20 (op e4 e2)) (?v_22 (op e4 e3)) (?v_24 (op e4 e4))) (and (and (and (and (or (or (or (or (not (= ?v_0 ?v_0)) (not (= ?v_2 ?v_1))) (not (= ?v_5 ?v_4))) (not (= ?v_10 ?v_9))) (not (= ?v_17 ?v_16))) (or (or (or (or (not (= ?v_1 ?v_2)) (not (= ?v_3 ?v_3))) (not (= ?v_7 ?v_6))) (not (= ?v_12 ?v_11))) (not (= ?v_19 ?v_18)))) (or (or (or (or (not (= ?v_4 ?v_5)) (not (= ?v_6 ?v_7))) (not (= ?v_8 ?v_8))) (not (= ?v_14 ?v_13))) (not (= ?v_21 ?v_20)))) (or (or (or (or (not (= ?v_9 ?v_10)) (not (= ?v_11 ?v_12))) (not (= ?v_13 ?v_14))) (not (= ?v_15 ?v_15))) (not (= ?v_23 ?v_22)))) (or (or (or (or (not (= ?v_16 ?v_17)) (not (= ?v_18 ?v_19))) (not (= ?v_20 ?v_21))) (not (= ?v_22 ?v_23))) (not (= ?v_24 ?v_24)))))) (assert (and (and (and (and (not (= (op e0 e0) e0)) (not (= (op e1 e1) e1))) (not (= (op e2 e2) e2))) (not (= (op e3 e3) e3))) (not (= (op e4 e4) e4)))) (assert (or (or (or (or (and (and (and (and (not (= (op e0 e0) e0)) (not (= (op e0 e1) e1))) (not (= (op e0 e2) e2))) (not (= (op e0 e3) e3))) (not (= (op e0 e4) e4))) (and (and (and (and (not (= (op e1 e0) e0)) (not (= (op e1 e1) e1))) (not (= (op e1 e2) e2))) (not (= (op e1 e3) e3))) (not (= (op e1 e4) e4)))) (and (and (and (and (not (= (op e2 e0) e0)) (not (= (op e2 e1) e1))) (not (= (op e2 e2) e2))) (not (= (op e2 e3) e3))) (not (= (op e2 e4) e4)))) (and (and (and (and (not (= (op e3 e0) e0)) (not (= (op e3 e1) e1))) (not (= (op e3 e2) e2))) (not (= (op e3 e3) e3))) (not (= (op e3 e4) e4)))) (and (and (and (and (not (= (op e4 e0) e0)) (not (= (op e4 e1) e1))) (not (= (op e4 e2) e2))) (not (= (op e4 e3) e3))) (not (= (op e4 e4) e4))))) (assert (or (or (or (or (and (and (and (and (not (= (op e0 (op e0 e0)) e0)) (not (= (op e0 (op e0 e1)) e1))) (not (= (op e0 (op e0 e2)) e2))) (not (= (op e0 (op e0 e3)) e3))) (not (= (op e0 (op e0 e4)) e4))) (and (and (and (and (not (= (op e1 (op e1 e0)) e0)) (not (= (op e1 (op e1 e1)) e1))) (not (= (op e1 (op e1 e2)) e2))) (not (= (op e1 (op e1 e3)) e3))) (not (= (op e1 (op e1 e4)) e4)))) (and (and (and (and (not (= (op e2 (op e2 e0)) e0)) (not (= (op e2 (op e2 e1)) e1))) (not (= (op e2 (op e2 e2)) e2))) (not (= (op e2 (op e2 e3)) e3))) (not (= (op e2 (op e2 e4)) e4)))) (and (and (and (and (not (= (op e3 (op e3 e0)) e0)) (not (= (op e3 (op e3 e1)) e1))) (not (= (op e3 (op e3 e2)) e2))) (not (= (op e3 (op e3 e3)) e3))) (not (= (op e3 (op e3 e4)) e4)))) (and (and (and (and (not (= (op e4 (op e4 e0)) e0)) (not (= (op e4 (op e4 e1)) e1))) (not (= (op e4 (op e4 e2)) e2))) (not (= (op e4 (op e4 e3)) e3))) (not (= (op e4 (op e4 e4)) e4))))) (assert (let ((?v_2 (op e0 e1)) (?v_5 (op e0 e2)) (?v_10 (op e0 e3)) (?v_17 (op e0 e4)) (?v_1 (op e1 e0)) (?v_7 (op e1 e2)) (?v_12 (op e1 e3)) (?v_19 (op e1 e4)) (?v_4 (op e2 e0)) (?v_6 (op e2 e1)) (?v_14 (op e2 e3)) (?v_21 (op e2 e4)) (?v_9 (op e3 e0)) (?v_11 (op e3 e1)) (?v_13 (op e3 e2)) (?v_23 (op e3 e4)) (?v_16 (op e4 e0)) (?v_18 (op e4 e1)) (?v_20 (op e4 e2)) (?v_22 (op e4 e3)) (?v_0 (= (op e0 e0) e0)) (?v_3 (= (op e1 e1) e1)) (?v_8 (= (op e2 e2) e2)) (?v_15 (= (op e3 e3) e3)) (?v_24 (= (op e4 e4) e4))) (or (or (or (or (or (or (or (or (and ?v_0 ?v_0) (and (= ?v_2 e0) (= ?v_1 e0))) (and (= ?v_5 e0) (= ?v_4 e0))) (and (= ?v_10 e0) (= ?v_9 e0))) (and (= ?v_17 e0) (= ?v_16 e0))) (or (or (or (or (and (= ?v_1 e1) (= ?v_2 e1)) (and ?v_3 ?v_3)) (and (= ?v_7 e1) (= ?v_6 e1))) (and (= ?v_12 e1) (= ?v_11 e1))) (and (= ?v_19 e1) (= ?v_18 e1)))) (or (or (or (or (and (= ?v_4 e2) (= ?v_5 e2)) (and (= ?v_6 e2) (= ?v_7 e2))) (and ?v_8 ?v_8)) (and (= ?v_14 e2) (= ?v_13 e2))) (and (= ?v_21 e2) (= ?v_20 e2)))) (or (or (or (or (and (= ?v_9 e3) (= ?v_10 e3)) (and (= ?v_11 e3) (= ?v_12 e3))) (and (= ?v_13 e3) (= ?v_14 e3))) (and ?v_15 ?v_15)) (and (= ?v_23 e3) (= ?v_22 e3)))) (or (or (or (or (and (= ?v_16 e4) (= ?v_17 e4)) (and (= ?v_18 e4) (= ?v_19 e4))) (and (= ?v_20 e4) (= ?v_21 e4))) (and (= ?v_22 e4) (= ?v_23 e4))) (and ?v_24 ?v_24))))) (assert (or (or (or (or (and (and (and (and (not (= (op (op e0 e0) e0) e0)) (not (= (op (op e1 e0) e1) e0))) (not (= (op (op e2 e0) e2) e0))) (not (= (op (op e3 e0) e3) e0))) (not (= (op (op e4 e0) e4) e0))) (and (and (and (and (not (= (op (op e0 e1) e0) e1)) (not (= (op (op e1 e1) e1) e1))) (not (= (op (op e2 e1) e2) e1))) (not (= (op (op e3 e1) e3) e1))) (not (= (op (op e4 e1) e4) e1)))) (and (and (and (and (not (= (op (op e0 e2) e0) e2)) (not (= (op (op e1 e2) e1) e2))) (not (= (op (op e2 e2) e2) e2))) (not (= (op (op e3 e2) e3) e2))) (not (= (op (op e4 e2) e4) e2)))) (and (and (and (and (not (= (op (op e0 e3) e0) e3)) (not (= (op (op e1 e3) e1) e3))) (not (= (op (op e2 e3) e2) e3))) (not (= (op (op e3 e3) e3) e3))) (not (= (op (op e4 e3) e4) e3)))) (and (and (and (and (not (= (op (op e0 e4) e0) e4)) (not (= (op (op e1 e4) e1) e4))) (not (= (op (op e2 e4) e2) e4))) (not (= (op (op e3 e4) e3) e4))) (not (= (op (op e4 e4) e4) e4))))) (assert (or (or (or (or (and (and (and (and (not (= (op e0 e0) e0)) (not (= (op e1 e0) e1))) (not (= (op e2 e0) e2))) (not (= (op e3 e0) e3))) (not (= (op e4 e0) e4))) (and (and (and (and (not (= (op e0 e1) e0)) (not (= (op e1 e1) e1))) (not (= (op e2 e1) e2))) (not (= (op e3 e1) e3))) (not (= (op e4 e1) e4)))) (and (and (and (and (not (= (op e0 e2) e0)) (not (= (op e1 e2) e1))) (not (= (op e2 e2) e2))) (not (= (op e3 e2) e3))) (not (= (op e4 e2) e4)))) (and (and (and (and (not (= (op e0 e3) e0)) (not (= (op e1 e3) e1))) (not (= (op e2 e3) e2))) (not (= (op e3 e3) e3))) (not (= (op e4 e3) e4)))) (and (and (and (and (not (= (op e0 e4) e0)) (not (= (op e1 e4) e1))) (not (= (op e2 e4) e2))) (not (= (op e3 e4) e3))) (not (= (op e4 e4) e4))))) (assert (let ((?v_25 (op e0 e0)) (?v_27 (op e0 e1)) (?v_29 (op e0 e2)) (?v_31 (op e0 e3)) (?v_33 (op e0 e4)) (?v_28 (op e1 e0)) (?v_37 (op e1 e1)) (?v_39 (op e1 e2)) (?v_41 (op e1 e3)) (?v_43 (op e1 e4)) (?v_30 (op e2 e0)) (?v_40 (op e2 e1)) (?v_49 (op e2 e2)) (?v_51 (op e2 e3)) (?v_53 (op e2 e4)) (?v_32 (op e3 e0)) (?v_42 (op e3 e1)) (?v_52 (op e3 e2)) (?v_61 (op e3 e3)) (?v_63 (op e3 e4)) (?v_34 (op e4 e0)) (?v_44 (op e4 e1)) (?v_54 (op e4 e2)) (?v_64 (op e4 e3)) (?v_73 (op e4 e4))) (let ((?v_0 (= ?v_25 e0)) (?v_26 (= ?v_25 e1)) (?v_75 (= ?v_25 e2)) (?v_100 (= ?v_25 e3)) (?v_125 (= ?v_25 e4)) (?v_2 (= ?v_27 e0)) (?v_36 (= ?v_27 e1)) (?v_77 (= ?v_27 e2)) (?v_102 (= ?v_27 e3)) (?v_127 (= ?v_27 e4)) (?v_5 (= ?v_29 e0)) (?v_46 (= ?v_29 e1)) (?v_80 (= ?v_29 e2)) (?v_105 (= ?v_29 e3)) (?v_130 (= ?v_29 e4)) (?v_10 (= ?v_31 e0)) (?v_56 (= ?v_31 e1)) (?v_85 (= ?v_31 e2)) (?v_110 (= ?v_31 e3)) (?v_135 (= ?v_31 e4)) (?v_17 (= ?v_33 e0)) (?v_66 (= ?v_33 e1)) (?v_92 (= ?v_33 e2)) (?v_117 (= ?v_33 e3)) (?v_142 (= ?v_33 e4)) (?v_1 (= ?v_28 e0)) (?v_35 (= ?v_28 e1)) (?v_76 (= ?v_28 e2)) (?v_101 (= ?v_28 e3)) (?v_126 (= ?v_28 e4)) (?v_3 (= ?v_37 e0)) (?v_38 (= ?v_37 e1)) (?v_78 (= ?v_37 e2)) (?v_103 (= ?v_37 e3)) (?v_128 (= ?v_37 e4)) (?v_7 (= ?v_39 e0)) (?v_48 (= ?v_39 e1)) (?v_82 (= ?v_39 e2)) (?v_107 (= ?v_39 e3)) (?v_132 (= ?v_39 e4)) (?v_12 (= ?v_41 e0)) (?v_58 (= ?v_41 e1)) (?v_87 (= ?v_41 e2)) (?v_112 (= ?v_41 e3)) (?v_137 (= ?v_41 e4)) (?v_19 (= ?v_43 e0)) (?v_68 (= ?v_43 e1)) (?v_94 (= ?v_43 e2)) (?v_119 (= ?v_43 e3)) (?v_144 (= ?v_43 e4)) (?v_4 (= ?v_30 e0)) (?v_45 (= ?v_30 e1)) (?v_79 (= ?v_30 e2)) (?v_104 (= ?v_30 e3)) (?v_129 (= ?v_30 e4)) (?v_6 (= ?v_40 e0)) (?v_47 (= ?v_40 e1)) (?v_81 (= ?v_40 e2)) (?v_106 (= ?v_40 e3)) (?v_131 (= ?v_40 e4)) (?v_8 (= ?v_49 e0)) (?v_50 (= ?v_49 e1)) (?v_83 (= ?v_49 e2)) (?v_108 (= ?v_49 e3)) (?v_133 (= ?v_49 e4)) (?v_14 (= ?v_51 e0)) (?v_60 (= ?v_51 e1)) (?v_89 (= ?v_51 e2)) (?v_114 (= ?v_51 e3)) (?v_139 (= ?v_51 e4)) (?v_21 (= ?v_53 e0)) (?v_70 (= ?v_53 e1)) (?v_96 (= ?v_53 e2)) (?v_121 (= ?v_53 e3)) (?v_146 (= ?v_53 e4)) (?v_9 (= ?v_32 e0)) (?v_55 (= ?v_32 e1)) (?v_84 (= ?v_32 e2)) (?v_109 (= ?v_32 e3)) (?v_134 (= ?v_32 e4)) (?v_11 (= ?v_42 e0)) (?v_57 (= ?v_42 e1)) (?v_86 (= ?v_42 e2)) (?v_111 (= ?v_42 e3)) (?v_136 (= ?v_42 e4)) (?v_13 (= ?v_52 e0)) (?v_59 (= ?v_52 e1)) (?v_88 (= ?v_52 e2)) (?v_113 (= ?v_52 e3)) (?v_138 (= ?v_52 e4)) (?v_15 (= ?v_61 e0)) (?v_62 (= ?v_61 e1)) (?v_90 (= ?v_61 e2)) (?v_115 (= ?v_61 e3)) (?v_140 (= ?v_61 e4)) (?v_23 (= ?v_63 e0)) (?v_72 (= ?v_63 e1)) (?v_98 (= ?v_63 e2)) (?v_123 (= ?v_63 e3)) (?v_148 (= ?v_63 e4)) (?v_16 (= ?v_34 e0)) (?v_65 (= ?v_34 e1)) (?v_91 (= ?v_34 e2)) (?v_116 (= ?v_34 e3)) (?v_141 (= ?v_34 e4)) (?v_18 (= ?v_44 e0)) (?v_67 (= ?v_44 e1)) (?v_93 (= ?v_44 e2)) (?v_118 (= ?v_44 e3)) (?v_143 (= ?v_44 e4)) (?v_20 (= ?v_54 e0)) (?v_69 (= ?v_54 e1)) (?v_95 (= ?v_54 e2)) (?v_120 (= ?v_54 e3)) (?v_145 (= ?v_54 e4)) (?v_22 (= ?v_64 e0)) (?v_71 (= ?v_64 e1)) (?v_97 (= ?v_64 e2)) (?v_122 (= ?v_64 e3)) (?v_147 (= ?v_64 e4)) (?v_24 (= ?v_73 e0)) (?v_74 (= ?v_73 e1)) (?v_99 (= ?v_73 e2)) (?v_124 (= ?v_73 e3)) (?v_149 (= ?v_73 e4))) (and (and (and (and (or (or (or (or (or (or (or (or (and ?v_0 (not ?v_0)) (and ?v_2 (not ?v_1))) (and ?v_5 (not ?v_4))) (and ?v_10 (not ?v_9))) (and ?v_17 (not ?v_16))) (or (or (or (or (and ?v_1 (not ?v_2)) (and ?v_3 (not ?v_3))) (and ?v_7 (not ?v_6))) (and ?v_12 (not ?v_11))) (and ?v_19 (not ?v_18)))) (or (or (or (or (and ?v_4 (not ?v_5)) (and ?v_6 (not ?v_7))) (and ?v_8 (not ?v_8))) (and ?v_14 (not ?v_13))) (and ?v_21 (not ?v_20)))) (or (or (or (or (and ?v_9 (not ?v_10)) (and ?v_11 (not ?v_12))) (and ?v_13 (not ?v_14))) (and ?v_15 (not ?v_15))) (and ?v_23 (not ?v_22)))) (or (or (or (or (and ?v_16 (not ?v_17)) (and ?v_18 (not ?v_19))) (and ?v_20 (not ?v_21))) (and ?v_22 (not ?v_23))) (and ?v_24 (not ?v_24)))) (or (or (or (or (or (or (or (or (and ?v_26 (not ?v_26)) (and ?v_36 (not ?v_35))) (and ?v_46 (not ?v_45))) (and ?v_56 (not ?v_55))) (and ?v_66 (not ?v_65))) (or (or (or (or (and ?v_35 (not ?v_36)) (and ?v_38 (not ?v_38))) (and ?v_48 (not ?v_47))) (and ?v_58 (not ?v_57))) (and ?v_68 (not ?v_67)))) (or (or (or (or (and ?v_45 (not ?v_46)) (and ?v_47 (not ?v_48))) (and ?v_50 (not ?v_50))) (and ?v_60 (not ?v_59))) (and ?v_70 (not ?v_69)))) (or (or (or (or (and ?v_55 (not ?v_56)) (and ?v_57 (not ?v_58))) (and ?v_59 (not ?v_60))) (and ?v_62 (not ?v_62))) (and ?v_72 (not ?v_71)))) (or (or (or (or (and ?v_65 (not ?v_66)) (and ?v_67 (not ?v_68))) (and ?v_69 (not ?v_70))) (and ?v_71 (not ?v_72))) (and ?v_74 (not ?v_74))))) (or (or (or (or (or (or (or (or (and ?v_75 (not ?v_75)) (and ?v_77 (not ?v_76))) (and ?v_80 (not ?v_79))) (and ?v_85 (not ?v_84))) (and ?v_92 (not ?v_91))) (or (or (or (or (and ?v_76 (not ?v_77)) (and ?v_78 (not ?v_78))) (and ?v_82 (not ?v_81))) (and ?v_87 (not ?v_86))) (and ?v_94 (not ?v_93)))) (or (or (or (or (and ?v_79 (not ?v_80)) (and ?v_81 (not ?v_82))) (and ?v_83 (not ?v_83))) (and ?v_89 (not ?v_88))) (and ?v_96 (not ?v_95)))) (or (or (or (or (and ?v_84 (not ?v_85)) (and ?v_86 (not ?v_87))) (and ?v_88 (not ?v_89))) (and ?v_90 (not ?v_90))) (and ?v_98 (not ?v_97)))) (or (or (or (or (and ?v_91 (not ?v_92)) (and ?v_93 (not ?v_94))) (and ?v_95 (not ?v_96))) (and ?v_97 (not ?v_98))) (and ?v_99 (not ?v_99))))) (or (or (or (or (or (or (or (or (and ?v_100 (not ?v_100)) (and ?v_102 (not ?v_101))) (and ?v_105 (not ?v_104))) (and ?v_110 (not ?v_109))) (and ?v_117 (not ?v_116))) (or (or (or (or (and ?v_101 (not ?v_102)) (and ?v_103 (not ?v_103))) (and ?v_107 (not ?v_106))) (and ?v_112 (not ?v_111))) (and ?v_119 (not ?v_118)))) (or (or (or (or (and ?v_104 (not ?v_105)) (and ?v_106 (not ?v_107))) (and ?v_108 (not ?v_108))) (and ?v_114 (not ?v_113))) (and ?v_121 (not ?v_120)))) (or (or (or (or (and ?v_109 (not ?v_110)) (and ?v_111 (not ?v_112))) (and ?v_113 (not ?v_114))) (and ?v_115 (not ?v_115))) (and ?v_123 (not ?v_122)))) (or (or (or (or (and ?v_116 (not ?v_117)) (and ?v_118 (not ?v_119))) (and ?v_120 (not ?v_121))) (and ?v_122 (not ?v_123))) (and ?v_124 (not ?v_124))))) (or (or (or (or (or (or (or (or (and ?v_125 (not ?v_125)) (and ?v_127 (not ?v_126))) (and ?v_130 (not ?v_129))) (and ?v_135 (not ?v_134))) (and ?v_142 (not ?v_141))) (or (or (or (or (and ?v_126 (not ?v_127)) (and ?v_128 (not ?v_128))) (and ?v_132 (not ?v_131))) (and ?v_137 (not ?v_136))) (and ?v_144 (not ?v_143)))) (or (or (or (or (and ?v_129 (not ?v_130)) (and ?v_131 (not ?v_132))) (and ?v_133 (not ?v_133))) (and ?v_139 (not ?v_138))) (and ?v_146 (not ?v_145)))) (or (or (or (or (and ?v_134 (not ?v_135)) (and ?v_136 (not ?v_137))) (and ?v_138 (not ?v_139))) (and ?v_140 (not ?v_140))) (and ?v_148 (not ?v_147)))) (or (or (or (or (and ?v_141 (not ?v_142)) (and ?v_143 (not ?v_144))) (and ?v_145 (not ?v_146))) (and ?v_147 (not ?v_148))) (and ?v_149 (not ?v_149)))))))) (assert (let ((?v_0 (op e0 e0)) (?v_1 (op e1 e1)) (?v_2 (op e2 e2)) (?v_3 (op e3 e3)) (?v_4 (op e4 e4))) (and (and (and (and (not (= (op ?v_0 ?v_0) e0)) (not (= (op ?v_1 ?v_1) e1))) (not (= (op ?v_2 ?v_2) e2))) (not (= (op ?v_3 ?v_3) e3))) (not (= (op ?v_4 ?v_4) e4))))) (assert (or (or (or (or (and (and (and (and (not (= (op (op e0 e0) e0) e0)) (not (= (op (op e1 e0) e0) e1))) (not (= (op (op e2 e0) e0) e2))) (not (= (op (op e3 e0) e0) e3))) (not (= (op (op e4 e0) e0) e4))) (and (and (and (and (not (= (op (op e0 e1) e1) e0)) (not (= (op (op e1 e1) e1) e1))) (not (= (op (op e2 e1) e1) e2))) (not (= (op (op e3 e1) e1) e3))) (not (= (op (op e4 e1) e1) e4)))) (and (and (and (and (not (= (op (op e0 e2) e2) e0)) (not (= (op (op e1 e2) e2) e1))) (not (= (op (op e2 e2) e2) e2))) (not (= (op (op e3 e2) e2) e3))) (not (= (op (op e4 e2) e2) e4)))) (and (and (and (and (not (= (op (op e0 e3) e3) e0)) (not (= (op (op e1 e3) e3) e1))) (not (= (op (op e2 e3) e3) e2))) (not (= (op (op e3 e3) e3) e3))) (not (= (op (op e4 e3) e3) e4)))) (and (and (and (and (not (= (op (op e0 e4) e4) e0)) (not (= (op (op e1 e4) e4) e1))) (not (= (op (op e2 e4) e4) e2))) (not (= (op (op e3 e4) e4) e3))) (not (= (op (op e4 e4) e4) e4))))) (assert (or (or (or (or (and (and (and (and (not (= (op e0 (op e0 e0)) e0)) (not (= (op e1 (op e0 e1)) e0))) (not (= (op e2 (op e0 e2)) e0))) (not (= (op e3 (op e0 e3)) e0))) (not (= (op e4 (op e0 e4)) e0))) (and (and (and (and (not (= (op e0 (op e1 e0)) e1)) (not (= (op e1 (op e1 e1)) e1))) (not (= (op e2 (op e1 e2)) e1))) (not (= (op e3 (op e1 e3)) e1))) (not (= (op e4 (op e1 e4)) e1)))) (and (and (and (and (not (= (op e0 (op e2 e0)) e2)) (not (= (op e1 (op e2 e1)) e2))) (not (= (op e2 (op e2 e2)) e2))) (not (= (op e3 (op e2 e3)) e2))) (not (= (op e4 (op e2 e4)) e2)))) (and (and (and (and (not (= (op e0 (op e3 e0)) e3)) (not (= (op e1 (op e3 e1)) e3))) (not (= (op e2 (op e3 e2)) e3))) (not (= (op e3 (op e3 e3)) e3))) (not (= (op e4 (op e3 e4)) e3)))) (and (and (and (and (not (= (op e0 (op e4 e0)) e4)) (not (= (op e1 (op e4 e1)) e4))) (not (= (op e2 (op e4 e2)) e4))) (not (= (op e3 (op e4 e3)) e4))) (not (= (op e4 (op e4 e4)) e4))))) (assert (let ((?v_0 (op e0 e0)) (?v_5 (op e0 e1)) (?v_10 (op e0 e2)) (?v_15 (op e0 e3)) (?v_20 (op e0 e4)) (?v_1 (op e1 e0)) (?v_6 (op e1 e1)) (?v_11 (op e1 e2)) (?v_16 (op e1 e3)) (?v_21 (op e1 e4)) (?v_2 (op e2 e0)) (?v_7 (op e2 e1)) (?v_12 (op e2 e2)) (?v_17 (op e2 e3)) (?v_22 (op e2 e4)) (?v_3 (op e3 e0)) (?v_8 (op e3 e1)) (?v_13 (op e3 e2)) (?v_18 (op e3 e3)) (?v_23 (op e3 e4)) (?v_4 (op e4 e0)) (?v_9 (op e4 e1)) (?v_14 (op e4 e2)) (?v_19 (op e4 e3)) (?v_24 (op e4 e4))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_1)) (not (= ?v_0 ?v_2))) (not (= ?v_0 ?v_3))) (not (= ?v_0 ?v_4))) (not (= ?v_1 ?v_2))) (not (= ?v_1 ?v_3))) (not (= ?v_1 ?v_4))) (not (= ?v_2 ?v_3))) (not (= ?v_2 ?v_4))) (not (= ?v_3 ?v_4))) (and (and (and (and (and (and (and (and (and (not (= ?v_5 ?v_6)) (not (= ?v_5 ?v_7))) (not (= ?v_5 ?v_8))) (not (= ?v_5 ?v_9))) (not (= ?v_6 ?v_7))) (not (= ?v_6 ?v_8))) (not (= ?v_6 ?v_9))) (not (= ?v_7 ?v_8))) (not (= ?v_7 ?v_9))) (not (= ?v_8 ?v_9)))) (and (and (and (and (and (and (and (and (and (not (= ?v_10 ?v_11)) (not (= ?v_10 ?v_12))) (not (= ?v_10 ?v_13))) (not (= ?v_10 ?v_14))) (not (= ?v_11 ?v_12))) (not (= ?v_11 ?v_13))) (not (= ?v_11 ?v_14))) (not (= ?v_12 ?v_13))) (not (= ?v_12 ?v_14))) (not (= ?v_13 ?v_14)))) (and (and (and (and (and (and (and (and (and (not (= ?v_15 ?v_16)) (not (= ?v_15 ?v_17))) (not (= ?v_15 ?v_18))) (not (= ?v_15 ?v_19))) (not (= ?v_16 ?v_17))) (not (= ?v_16 ?v_18))) (not (= ?v_16 ?v_19))) (not (= ?v_17 ?v_18))) (not (= ?v_17 ?v_19))) (not (= ?v_18 ?v_19)))) (and (and (and (and (and (and (and (and (and (not (= ?v_20 ?v_21)) (not (= ?v_20 ?v_22))) (not (= ?v_20 ?v_23))) (not (= ?v_20 ?v_24))) (not (= ?v_21 ?v_22))) (not (= ?v_21 ?v_23))) (not (= ?v_21 ?v_24))) (not (= ?v_22 ?v_23))) (not (= ?v_22 ?v_24))) (not (= ?v_23 ?v_24)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_5)) (not (= ?v_0 ?v_10))) (not (= ?v_0 ?v_15))) (not (= ?v_0 ?v_20))) (not (= ?v_5 ?v_10))) (not (= ?v_5 ?v_15))) (not (= ?v_5 ?v_20))) (not (= ?v_10 ?v_15))) (not (= ?v_10 ?v_20))) (not (= ?v_15 ?v_20))) (and (and (and (and (and (and (and (and (and (not (= ?v_1 ?v_6)) (not (= ?v_1 ?v_11))) (not (= ?v_1 ?v_16))) (not (= ?v_1 ?v_21))) (not (= ?v_6 ?v_11))) (not (= ?v_6 ?v_16))) (not (= ?v_6 ?v_21))) (not (= ?v_11 ?v_16))) (not (= ?v_11 ?v_21))) (not (= ?v_16 ?v_21)))) (and (and (and (and (and (and (and (and (and (not (= ?v_2 ?v_7)) (not (= ?v_2 ?v_12))) (not (= ?v_2 ?v_17))) (not (= ?v_2 ?v_22))) (not (= ?v_7 ?v_12))) (not (= ?v_7 ?v_17))) (not (= ?v_7 ?v_22))) (not (= ?v_12 ?v_17))) (not (= ?v_12 ?v_22))) (not (= ?v_17 ?v_22)))) (and (and (and (and (and (and (and (and (and (not (= ?v_3 ?v_8)) (not (= ?v_3 ?v_13))) (not (= ?v_3 ?v_18))) (not (= ?v_3 ?v_23))) (not (= ?v_8 ?v_13))) (not (= ?v_8 ?v_18))) (not (= ?v_8 ?v_23))) (not (= ?v_13 ?v_18))) (not (= ?v_13 ?v_23))) (not (= ?v_18 ?v_23)))) (and (and (and (and (and (and (and (and (and (not (= ?v_4 ?v_9)) (not (= ?v_4 ?v_14))) (not (= ?v_4 ?v_19))) (not (= ?v_4 ?v_24))) (not (= ?v_9 ?v_14))) (not (= ?v_9 ?v_19))) (not (= ?v_9 ?v_24))) (not (= ?v_14 ?v_19))) (not (= ?v_14 ?v_24))) (not (= ?v_19 ?v_24))))))) (assert (and (and (and (and (and (and (and (and (and (not (= e0 e1)) (not (= e0 e2))) (not (= e0 e3))) (not (= e0 e4))) (not (= e1 e2))) (not (= e1 e3))) (not (= e1 e4))) (not (= e2 e3))) (not (= e2 e4))) (not (= e3 e4)))) (assert (and (and (and (= e0 (op e4 e4)) (= e1 (op e0 e0))) (= e2 (op e3 e3))) (= e4 (op e2 e2)))) (assert (not (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= (op e0 e0) e1) (= (op e0 e1) e0)) (= (op e0 e2) e2)) (= (op e0 e3) e4)) (= (op e0 e4) e3)) (= (op e1 e0) e4)) (= (op e1 e1) e2)) (= (op e1 e2) e0)) (= (op e1 e3) e3)) (= (op e1 e4) e1)) (= (op e2 e0) e3)) (= (op e2 e1) e1)) (= (op e2 e2) e4)) (= (op e2 e3) e0)) (= (op e2 e4) e2)) (= (op e3 e0) e0)) (= (op e3 e1) e3)) (= (op e3 e2) e1)) (= (op e3 e3) e2)) (= (op e3 e4) e4)) (= (op e4 e0) e2)) (= (op e4 e1) e4)) (= (op e4 e2) e3)) (= (op e4 e3) e1)) (= (op e4 e4) e0)))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/iso_brn268.smt2.expected.err000066400000000000000000000000001445011647600233540ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/iso_brn268.smt2.expected.out000066400000000000000000000000041445011647600233770ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/iso_brn268.smt2.expected.time000066400000000000000000000000351445011647600235320ustar00rootroot00000000000000real 0.31 user 0.30 sys 0.00 opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.0.smt2000066400000000000000000000361231445011647600233470ustar00rootroot00000000000000(set-logic QF_UF) (set-info :source | http://www.cs.bham.ac.uk/~vxs/quasigroups/benchmark/ |) (set-info :smt-lib-version 2.0) (set-info :category "crafted") (declare-sort U 0) (declare-sort I 0) (declare-fun op1 (I I) I) (declare-fun op (I I) I) (declare-fun e4 () I) (declare-fun e3 () I) (declare-fun e2 () I) (declare-fun e1 () I) (declare-fun e0 () I) (assert (let ((?v_1 (op e0 e0)) (?v_2 (op e0 e1)) (?v_3 (op e0 e2)) (?v_4 (op e0 e3)) (?v_5 (op e0 e4)) (?v_7 (op e1 e0)) (?v_18 (op e1 e1)) (?v_19 (op e1 e2)) (?v_20 (op e1 e3)) (?v_21 (op e1 e4)) (?v_8 (op e2 e0)) (?v_24 (op e2 e1)) (?v_43 (op e2 e2)) (?v_44 (op e2 e3)) (?v_45 (op e2 e4)) (?v_9 (op e3 e0)) (?v_25 (op e3 e1)) (?v_49 (op e3 e2)) (?v_76 (op e3 e3)) (?v_77 (op e3 e4)) (?v_10 (op e4 e0)) (?v_26 (op e4 e1)) (?v_50 (op e4 e2)) (?v_82 (op e4 e3)) (?v_117 (op e4 e4))) (let ((?v_0 (= ?v_1 e0)) (?v_6 (= ?v_1 e1)) (?v_11 (= ?v_1 e2)) (?v_12 (= ?v_1 e3)) (?v_13 (= ?v_1 e4)) (?v_15 (= ?v_2 e0)) (?v_22 (= ?v_2 e1)) (?v_28 (= ?v_2 e2)) (?v_31 (= ?v_2 e3)) (?v_34 (= ?v_2 e4)) (?v_38 (= ?v_3 e0)) (?v_46 (= ?v_3 e1)) (?v_53 (= ?v_3 e2)) (?v_58 (= ?v_3 e3)) (?v_63 (= ?v_3 e4)) (?v_69 (= ?v_4 e0)) (?v_78 (= ?v_4 e1)) (?v_86 (= ?v_4 e2)) (?v_93 (= ?v_4 e3)) (?v_100 (= ?v_4 e4)) (?v_108 (= ?v_5 e0)) (?v_118 (= ?v_5 e1)) (?v_127 (= ?v_5 e2)) (?v_136 (= ?v_5 e3)) (?v_145 (= ?v_5 e4)) (?v_14 (= ?v_7 e0)) (?v_17 (= ?v_7 e1)) (?v_27 (= ?v_7 e2)) (?v_30 (= ?v_7 e3)) (?v_33 (= ?v_7 e4)) (?v_16 (= ?v_18 e0)) (?v_23 (= ?v_18 e1)) (?v_29 (= ?v_18 e2)) (?v_32 (= ?v_18 e3)) (?v_35 (= ?v_18 e4)) (?v_39 (= ?v_19 e0)) (?v_47 (= ?v_19 e1)) (?v_54 (= ?v_19 e2)) (?v_59 (= ?v_19 e3)) (?v_64 (= ?v_19 e4)) (?v_70 (= ?v_20 e0)) (?v_79 (= ?v_20 e1)) (?v_87 (= ?v_20 e2)) (?v_94 (= ?v_20 e3)) (?v_101 (= ?v_20 e4)) (?v_109 (= ?v_21 e0)) (?v_119 (= ?v_21 e1)) (?v_128 (= ?v_21 e2)) (?v_137 (= ?v_21 e3)) (?v_146 (= ?v_21 e4)) (?v_36 (= ?v_8 e0)) (?v_41 (= ?v_8 e1)) (?v_51 (= ?v_8 e2)) (?v_56 (= ?v_8 e3)) (?v_61 (= ?v_8 e4)) (?v_37 (= ?v_24 e0)) (?v_42 (= ?v_24 e1)) (?v_52 (= ?v_24 e2)) (?v_57 (= ?v_24 e3)) (?v_62 (= ?v_24 e4)) (?v_40 (= ?v_43 e0)) (?v_48 (= ?v_43 e1)) (?v_55 (= ?v_43 e2)) (?v_60 (= ?v_43 e3)) (?v_65 (= ?v_43 e4)) (?v_71 (= ?v_44 e0)) (?v_80 (= ?v_44 e1)) (?v_88 (= ?v_44 e2)) (?v_95 (= ?v_44 e3)) (?v_102 (= ?v_44 e4)) (?v_110 (= ?v_45 e0)) (?v_120 (= ?v_45 e1)) (?v_129 (= ?v_45 e2)) (?v_138 (= ?v_45 e3)) (?v_147 (= ?v_45 e4)) (?v_66 (= ?v_9 e0)) (?v_73 (= ?v_9 e1)) (?v_83 (= ?v_9 e2)) (?v_90 (= ?v_9 e3)) (?v_97 (= ?v_9 e4)) (?v_67 (= ?v_25 e0)) (?v_74 (= ?v_25 e1)) (?v_84 (= ?v_25 e2)) (?v_91 (= ?v_25 e3)) (?v_98 (= ?v_25 e4)) (?v_68 (= ?v_49 e0)) (?v_75 (= ?v_49 e1)) (?v_85 (= ?v_49 e2)) (?v_92 (= ?v_49 e3)) (?v_99 (= ?v_49 e4)) (?v_72 (= ?v_76 e0)) (?v_81 (= ?v_76 e1)) (?v_89 (= ?v_76 e2)) (?v_96 (= ?v_76 e3)) (?v_103 (= ?v_76 e4)) (?v_111 (= ?v_77 e0)) (?v_121 (= ?v_77 e1)) (?v_130 (= ?v_77 e2)) (?v_139 (= ?v_77 e3)) (?v_148 (= ?v_77 e4)) (?v_104 (= ?v_10 e0)) (?v_113 (= ?v_10 e1)) (?v_123 (= ?v_10 e2)) (?v_132 (= ?v_10 e3)) (?v_141 (= ?v_10 e4)) (?v_105 (= ?v_26 e0)) (?v_114 (= ?v_26 e1)) (?v_124 (= ?v_26 e2)) (?v_133 (= ?v_26 e3)) (?v_142 (= ?v_26 e4)) (?v_106 (= ?v_50 e0)) (?v_115 (= ?v_50 e1)) (?v_125 (= ?v_50 e2)) (?v_134 (= ?v_50 e3)) (?v_143 (= ?v_50 e4)) (?v_107 (= ?v_82 e0)) (?v_116 (= ?v_82 e1)) (?v_126 (= ?v_82 e2)) (?v_135 (= ?v_82 e3)) (?v_144 (= ?v_82 e4)) (?v_112 (= ?v_117 e0)) (?v_122 (= ?v_117 e1)) (?v_131 (= ?v_117 e2)) (?v_140 (= ?v_117 e3)) (?v_149 (= ?v_117 e4))) (and (and (and (and (and (and (and (and (and (or (or (or (or ?v_0 ?v_15) ?v_38) ?v_69) ?v_108) (or (or (or (or ?v_0 ?v_14) ?v_36) ?v_66) ?v_104)) (and (or (or (or (or ?v_6 ?v_22) ?v_46) ?v_78) ?v_118) (or (or (or (or ?v_6 ?v_17) ?v_41) ?v_73) ?v_113))) (and (or (or (or (or ?v_11 ?v_28) ?v_53) ?v_86) ?v_127) (or (or (or (or ?v_11 ?v_27) ?v_51) ?v_83) ?v_123))) (and (or (or (or (or ?v_12 ?v_31) ?v_58) ?v_93) ?v_136) (or (or (or (or ?v_12 ?v_30) ?v_56) ?v_90) ?v_132))) (and (or (or (or (or ?v_13 ?v_34) ?v_63) ?v_100) ?v_145) (or (or (or (or ?v_13 ?v_33) ?v_61) ?v_97) ?v_141))) (and (and (and (and (and (or (or (or (or ?v_14 ?v_16) ?v_39) ?v_70) ?v_109) (or (or (or (or ?v_15 ?v_16) ?v_37) ?v_67) ?v_105)) (and (or (or (or (or ?v_17 ?v_23) ?v_47) ?v_79) ?v_119) (or (or (or (or ?v_22 ?v_23) ?v_42) ?v_74) ?v_114))) (and (or (or (or (or ?v_27 ?v_29) ?v_54) ?v_87) ?v_128) (or (or (or (or ?v_28 ?v_29) ?v_52) ?v_84) ?v_124))) (and (or (or (or (or ?v_30 ?v_32) ?v_59) ?v_94) ?v_137) (or (or (or (or ?v_31 ?v_32) ?v_57) ?v_91) ?v_133))) (and (or (or (or (or ?v_33 ?v_35) ?v_64) ?v_101) ?v_146) (or (or (or (or ?v_34 ?v_35) ?v_62) ?v_98) ?v_142)))) (and (and (and (and (and (or (or (or (or ?v_36 ?v_37) ?v_40) ?v_71) ?v_110) (or (or (or (or ?v_38 ?v_39) ?v_40) ?v_68) ?v_106)) (and (or (or (or (or ?v_41 ?v_42) ?v_48) ?v_80) ?v_120) (or (or (or (or ?v_46 ?v_47) ?v_48) ?v_75) ?v_115))) (and (or (or (or (or ?v_51 ?v_52) ?v_55) ?v_88) ?v_129) (or (or (or (or ?v_53 ?v_54) ?v_55) ?v_85) ?v_125))) (and (or (or (or (or ?v_56 ?v_57) ?v_60) ?v_95) ?v_138) (or (or (or (or ?v_58 ?v_59) ?v_60) ?v_92) ?v_134))) (and (or (or (or (or ?v_61 ?v_62) ?v_65) ?v_102) ?v_147) (or (or (or (or ?v_63 ?v_64) ?v_65) ?v_99) ?v_143)))) (and (and (and (and (and (or (or (or (or ?v_66 ?v_67) ?v_68) ?v_72) ?v_111) (or (or (or (or ?v_69 ?v_70) ?v_71) ?v_72) ?v_107)) (and (or (or (or (or ?v_73 ?v_74) ?v_75) ?v_81) ?v_121) (or (or (or (or ?v_78 ?v_79) ?v_80) ?v_81) ?v_116))) (and (or (or (or (or ?v_83 ?v_84) ?v_85) ?v_89) ?v_130) (or (or (or (or ?v_86 ?v_87) ?v_88) ?v_89) ?v_126))) (and (or (or (or (or ?v_90 ?v_91) ?v_92) ?v_96) ?v_139) (or (or (or (or ?v_93 ?v_94) ?v_95) ?v_96) ?v_135))) (and (or (or (or (or ?v_97 ?v_98) ?v_99) ?v_103) ?v_148) (or (or (or (or ?v_100 ?v_101) ?v_102) ?v_103) ?v_144)))) (and (and (and (and (and (or (or (or (or ?v_104 ?v_105) ?v_106) ?v_107) ?v_112) (or (or (or (or ?v_108 ?v_109) ?v_110) ?v_111) ?v_112)) (and (or (or (or (or ?v_113 ?v_114) ?v_115) ?v_116) ?v_122) (or (or (or (or ?v_118 ?v_119) ?v_120) ?v_121) ?v_122))) (and (or (or (or (or ?v_123 ?v_124) ?v_125) ?v_126) ?v_131) (or (or (or (or ?v_127 ?v_128) ?v_129) ?v_130) ?v_131))) (and (or (or (or (or ?v_132 ?v_133) ?v_134) ?v_135) ?v_140) (or (or (or (or ?v_136 ?v_137) ?v_138) ?v_139) ?v_140))) (and (or (or (or (or ?v_141 ?v_142) ?v_143) ?v_144) ?v_149) (or (or (or (or ?v_145 ?v_146) ?v_147) ?v_148) ?v_149))))))) (assert (let ((?v_0 (op e0 e0)) (?v_1 (op e1 e1)) (?v_2 (op e2 e2)) (?v_3 (op e3 e3)) (?v_4 (op e4 e4))) (or (or (or (or (and (and (and (and (not (= ?v_0 e0)) (not (= ?v_1 e0))) (not (= ?v_2 e0))) (not (= ?v_3 e0))) (not (= ?v_4 e0))) (and (and (and (and (not (= ?v_0 e1)) (not (= ?v_1 e1))) (not (= ?v_2 e1))) (not (= ?v_3 e1))) (not (= ?v_4 e1)))) (and (and (and (and (not (= ?v_0 e2)) (not (= ?v_1 e2))) (not (= ?v_2 e2))) (not (= ?v_3 e2))) (not (= ?v_4 e2)))) (and (and (and (and (not (= ?v_0 e3)) (not (= ?v_1 e3))) (not (= ?v_2 e3))) (not (= ?v_3 e3))) (not (= ?v_4 e3)))) (and (and (and (and (not (= ?v_0 e4)) (not (= ?v_1 e4))) (not (= ?v_2 e4))) (not (= ?v_3 e4))) (not (= ?v_4 e4)))))) (assert (let ((?v_25 (op e0 e0)) (?v_27 (op e0 e1)) (?v_29 (op e0 e2)) (?v_31 (op e0 e3)) (?v_33 (op e0 e4)) (?v_28 (op e1 e0)) (?v_37 (op e1 e1)) (?v_39 (op e1 e2)) (?v_41 (op e1 e3)) (?v_43 (op e1 e4)) (?v_30 (op e2 e0)) (?v_40 (op e2 e1)) (?v_49 (op e2 e2)) (?v_51 (op e2 e3)) (?v_53 (op e2 e4)) (?v_32 (op e3 e0)) (?v_42 (op e3 e1)) (?v_52 (op e3 e2)) (?v_61 (op e3 e3)) (?v_63 (op e3 e4)) (?v_34 (op e4 e0)) (?v_44 (op e4 e1)) (?v_54 (op e4 e2)) (?v_64 (op e4 e3)) (?v_73 (op e4 e4))) (let ((?v_0 (= ?v_25 e0)) (?v_26 (= ?v_25 e1)) (?v_75 (= ?v_25 e2)) (?v_100 (= ?v_25 e3)) (?v_125 (= ?v_25 e4)) (?v_2 (= ?v_27 e0)) (?v_36 (= ?v_27 e1)) (?v_77 (= ?v_27 e2)) (?v_102 (= ?v_27 e3)) (?v_127 (= ?v_27 e4)) (?v_5 (= ?v_29 e0)) (?v_46 (= ?v_29 e1)) (?v_80 (= ?v_29 e2)) (?v_105 (= ?v_29 e3)) (?v_130 (= ?v_29 e4)) (?v_10 (= ?v_31 e0)) (?v_56 (= ?v_31 e1)) (?v_85 (= ?v_31 e2)) (?v_110 (= ?v_31 e3)) (?v_135 (= ?v_31 e4)) (?v_17 (= ?v_33 e0)) (?v_66 (= ?v_33 e1)) (?v_92 (= ?v_33 e2)) (?v_117 (= ?v_33 e3)) (?v_142 (= ?v_33 e4)) (?v_1 (= ?v_28 e0)) (?v_35 (= ?v_28 e1)) (?v_76 (= ?v_28 e2)) (?v_101 (= ?v_28 e3)) (?v_126 (= ?v_28 e4)) (?v_3 (= ?v_37 e0)) (?v_38 (= ?v_37 e1)) (?v_78 (= ?v_37 e2)) (?v_103 (= ?v_37 e3)) (?v_128 (= ?v_37 e4)) (?v_7 (= ?v_39 e0)) (?v_48 (= ?v_39 e1)) (?v_82 (= ?v_39 e2)) (?v_107 (= ?v_39 e3)) (?v_132 (= ?v_39 e4)) (?v_12 (= ?v_41 e0)) (?v_58 (= ?v_41 e1)) (?v_87 (= ?v_41 e2)) (?v_112 (= ?v_41 e3)) (?v_137 (= ?v_41 e4)) (?v_19 (= ?v_43 e0)) (?v_68 (= ?v_43 e1)) (?v_94 (= ?v_43 e2)) (?v_119 (= ?v_43 e3)) (?v_144 (= ?v_43 e4)) (?v_4 (= ?v_30 e0)) (?v_45 (= ?v_30 e1)) (?v_79 (= ?v_30 e2)) (?v_104 (= ?v_30 e3)) (?v_129 (= ?v_30 e4)) (?v_6 (= ?v_40 e0)) (?v_47 (= ?v_40 e1)) (?v_81 (= ?v_40 e2)) (?v_106 (= ?v_40 e3)) (?v_131 (= ?v_40 e4)) (?v_8 (= ?v_49 e0)) (?v_50 (= ?v_49 e1)) (?v_83 (= ?v_49 e2)) (?v_108 (= ?v_49 e3)) (?v_133 (= ?v_49 e4)) (?v_14 (= ?v_51 e0)) (?v_60 (= ?v_51 e1)) (?v_89 (= ?v_51 e2)) (?v_114 (= ?v_51 e3)) (?v_139 (= ?v_51 e4)) (?v_21 (= ?v_53 e0)) (?v_70 (= ?v_53 e1)) (?v_96 (= ?v_53 e2)) (?v_121 (= ?v_53 e3)) (?v_146 (= ?v_53 e4)) (?v_9 (= ?v_32 e0)) (?v_55 (= ?v_32 e1)) (?v_84 (= ?v_32 e2)) (?v_109 (= ?v_32 e3)) (?v_134 (= ?v_32 e4)) (?v_11 (= ?v_42 e0)) (?v_57 (= ?v_42 e1)) (?v_86 (= ?v_42 e2)) (?v_111 (= ?v_42 e3)) (?v_136 (= ?v_42 e4)) (?v_13 (= ?v_52 e0)) (?v_59 (= ?v_52 e1)) (?v_88 (= ?v_52 e2)) (?v_113 (= ?v_52 e3)) (?v_138 (= ?v_52 e4)) (?v_15 (= ?v_61 e0)) (?v_62 (= ?v_61 e1)) (?v_90 (= ?v_61 e2)) (?v_115 (= ?v_61 e3)) (?v_140 (= ?v_61 e4)) (?v_23 (= ?v_63 e0)) (?v_72 (= ?v_63 e1)) (?v_98 (= ?v_63 e2)) (?v_123 (= ?v_63 e3)) (?v_148 (= ?v_63 e4)) (?v_16 (= ?v_34 e0)) (?v_65 (= ?v_34 e1)) (?v_91 (= ?v_34 e2)) (?v_116 (= ?v_34 e3)) (?v_141 (= ?v_34 e4)) (?v_18 (= ?v_44 e0)) (?v_67 (= ?v_44 e1)) (?v_93 (= ?v_44 e2)) (?v_118 (= ?v_44 e3)) (?v_143 (= ?v_44 e4)) (?v_20 (= ?v_54 e0)) (?v_69 (= ?v_54 e1)) (?v_95 (= ?v_54 e2)) (?v_120 (= ?v_54 e3)) (?v_145 (= ?v_54 e4)) (?v_22 (= ?v_64 e0)) (?v_71 (= ?v_64 e1)) (?v_97 (= ?v_64 e2)) (?v_122 (= ?v_64 e3)) (?v_147 (= ?v_64 e4)) (?v_24 (= ?v_73 e0)) (?v_74 (= ?v_73 e1)) (?v_99 (= ?v_73 e2)) (?v_124 (= ?v_73 e3)) (?v_149 (= ?v_73 e4))) (and (and (and (and (or (or (or (or (or (or (or (or (and ?v_0 ?v_0) (and ?v_2 ?v_1)) (and ?v_5 ?v_4)) (and ?v_10 ?v_9)) (and ?v_17 ?v_16)) (or (or (or (or (and ?v_1 ?v_2) (and ?v_3 ?v_3)) (and ?v_7 ?v_6)) (and ?v_12 ?v_11)) (and ?v_19 ?v_18))) (or (or (or (or (and ?v_4 ?v_5) (and ?v_6 ?v_7)) (and ?v_8 ?v_8)) (and ?v_14 ?v_13)) (and ?v_21 ?v_20))) (or (or (or (or (and ?v_9 ?v_10) (and ?v_11 ?v_12)) (and ?v_13 ?v_14)) (and ?v_15 ?v_15)) (and ?v_23 ?v_22))) (or (or (or (or (and ?v_16 ?v_17) (and ?v_18 ?v_19)) (and ?v_20 ?v_21)) (and ?v_22 ?v_23)) (and ?v_24 ?v_24))) (or (or (or (or (or (or (or (or (and ?v_26 ?v_26) (and ?v_36 ?v_35)) (and ?v_46 ?v_45)) (and ?v_56 ?v_55)) (and ?v_66 ?v_65)) (or (or (or (or (and ?v_35 ?v_36) (and ?v_38 ?v_38)) (and ?v_48 ?v_47)) (and ?v_58 ?v_57)) (and ?v_68 ?v_67))) (or (or (or (or (and ?v_45 ?v_46) (and ?v_47 ?v_48)) (and ?v_50 ?v_50)) (and ?v_60 ?v_59)) (and ?v_70 ?v_69))) (or (or (or (or (and ?v_55 ?v_56) (and ?v_57 ?v_58)) (and ?v_59 ?v_60)) (and ?v_62 ?v_62)) (and ?v_72 ?v_71))) (or (or (or (or (and ?v_65 ?v_66) (and ?v_67 ?v_68)) (and ?v_69 ?v_70)) (and ?v_71 ?v_72)) (and ?v_74 ?v_74)))) (or (or (or (or (or (or (or (or (and ?v_75 ?v_75) (and ?v_77 ?v_76)) (and ?v_80 ?v_79)) (and ?v_85 ?v_84)) (and ?v_92 ?v_91)) (or (or (or (or (and ?v_76 ?v_77) (and ?v_78 ?v_78)) (and ?v_82 ?v_81)) (and ?v_87 ?v_86)) (and ?v_94 ?v_93))) (or (or (or (or (and ?v_79 ?v_80) (and ?v_81 ?v_82)) (and ?v_83 ?v_83)) (and ?v_89 ?v_88)) (and ?v_96 ?v_95))) (or (or (or (or (and ?v_84 ?v_85) (and ?v_86 ?v_87)) (and ?v_88 ?v_89)) (and ?v_90 ?v_90)) (and ?v_98 ?v_97))) (or (or (or (or (and ?v_91 ?v_92) (and ?v_93 ?v_94)) (and ?v_95 ?v_96)) (and ?v_97 ?v_98)) (and ?v_99 ?v_99)))) (or (or (or (or (or (or (or (or (and ?v_100 ?v_100) (and ?v_102 ?v_101)) (and ?v_105 ?v_104)) (and ?v_110 ?v_109)) (and ?v_117 ?v_116)) (or (or (or (or (and ?v_101 ?v_102) (and ?v_103 ?v_103)) (and ?v_107 ?v_106)) (and ?v_112 ?v_111)) (and ?v_119 ?v_118))) (or (or (or (or (and ?v_104 ?v_105) (and ?v_106 ?v_107)) (and ?v_108 ?v_108)) (and ?v_114 ?v_113)) (and ?v_121 ?v_120))) (or (or (or (or (and ?v_109 ?v_110) (and ?v_111 ?v_112)) (and ?v_113 ?v_114)) (and ?v_115 ?v_115)) (and ?v_123 ?v_122))) (or (or (or (or (and ?v_116 ?v_117) (and ?v_118 ?v_119)) (and ?v_120 ?v_121)) (and ?v_122 ?v_123)) (and ?v_124 ?v_124)))) (or (or (or (or (or (or (or (or (and ?v_125 ?v_125) (and ?v_127 ?v_126)) (and ?v_130 ?v_129)) (and ?v_135 ?v_134)) (and ?v_142 ?v_141)) (or (or (or (or (and ?v_126 ?v_127) (and ?v_128 ?v_128)) (and ?v_132 ?v_131)) (and ?v_137 ?v_136)) (and ?v_144 ?v_143))) (or (or (or (or (and ?v_129 ?v_130) (and ?v_131 ?v_132)) (and ?v_133 ?v_133)) (and ?v_139 ?v_138)) (and ?v_146 ?v_145))) (or (or (or (or (and ?v_134 ?v_135) (and ?v_136 ?v_137)) (and ?v_138 ?v_139)) (and ?v_140 ?v_140)) (and ?v_148 ?v_147))) (or (or (or (or (and ?v_141 ?v_142) (and ?v_143 ?v_144)) (and ?v_145 ?v_146)) (and ?v_147 ?v_148)) (and ?v_149 ?v_149))))))) (assert (let ((?v_0 (op e0 e0)) (?v_2 (op e0 e1)) (?v_5 (op e0 e2)) (?v_10 (op e0 e3)) (?v_17 (op e0 e4)) (?v_1 (op e1 e0)) (?v_3 (op e1 e1)) (?v_7 (op e1 e2)) (?v_12 (op e1 e3)) (?v_19 (op e1 e4)) (?v_4 (op e2 e0)) (?v_6 (op e2 e1)) (?v_8 (op e2 e2)) (?v_14 (op e2 e3)) (?v_21 (op e2 e4)) (?v_9 (op e3 e0)) (?v_11 (op e3 e1)) (?v_13 (op e3 e2)) (?v_15 (op e3 e3)) (?v_23 (op e3 e4)) (?v_16 (op e4 e0)) (?v_18 (op e4 e1)) (?v_20 (op e4 e2)) (?v_22 (op e4 e3)) (?v_24 (op e4 e4))) (and (and (and (and (or false (not false)) (or false (not (= ?v_19 ?v_18)))) (or false (not false))) (or false (not false))) (or (or false (not false)) false)))) (assert (and (and (and (and (not false) (not false)) (not false)) (not false)) (not false))) (assert (or (or (or (or (and (and (and (and (not false) (not false)) (not false)) (not (= (op e0 e3) e3))) (not (= (op e0 e4) e4))) (and (and (and (and (not false) (not false)) (not false)) (not (= (op e1 e3) e3))) (not (= (op e1 e4) e4)))) (and (and (and (and (not false) (not false)) (not false)) (not (= (op e2 e3) e3))) (not (= (op e2 e4) e4)))) (and (and (and (and (not false) (not false)) (not false)) (not (= (op e3 e3) e3))) (not (= (op e3 e4) e4)))) (and (and (and (and (not false) (not false)) (not false)) (not (= (op e4 e3) e3))) (not (= (op e4 e4) e4))))) (assert (let ((?v_2 (op e0 e1)) (?v_5 (op e0 e2)) (?v_10 (op e0 e3)) (?v_17 (op e0 e4)) (?v_1 (op e1 e0)) (?v_7 (op e1 e2)) (?v_12 (op e1 e3)) (?v_19 (op e1 e4)) (?v_4 (op e2 e0)) (?v_6 (op e2 e1)) (?v_14 (op e2 e3)) (?v_21 (op e2 e4)) (?v_9 (op e3 e0)) (?v_11 (op e3 e1)) (?v_13 (op e3 e2)) (?v_23 (op e3 e4)) (?v_16 (op e4 e0)) (?v_18 (op e4 e1)) (?v_20 (op e4 e2)) (?v_22 (op e4 e3)) (?v_0 false) (?v_3 false) (?v_8 false) (?v_15 (= (op e3 e3) e3)) (?v_24 false)) (or (or (or false (or (or (or (or false (and (= ?v_6 e2) (= ?v_7 e2))) false) false) false)) (or (or (or (or (and (= ?v_9 e3) (= ?v_10 e3)) (and (= ?v_11 e3) (= ?v_12 e3))) (and (= ?v_13 e3) (= ?v_14 e3))) (and ?v_15 ?v_15)) (and (= ?v_23 e3) (= ?v_22 e3)))) (or (or (or (or false (and (= ?v_18 e4) (= ?v_19 e4))) false) (and (= ?v_22 e4) (= ?v_23 e4))) false)))) (assert (and (and (and (= e0 (op e4 e4)) (= e1 (op e0 e0))) (= e2 (op e3 e3))) (= e4 (op e2 e2)))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.0.smt2.expected.err000066400000000000000000000000001445011647600257170ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.0.smt2.expected.out000066400000000000000000000000041445011647600257420ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.0.smt2.expected.time000066400000000000000000000000351445011647600260750ustar00rootroot00000000000000real 0.14 user 0.14 sys 0.00 opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.0b-edit.smt2000066400000000000000000000021001445011647600244200ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort I 0) (declare-fun op (I I) I) (declare-fun e4 () I) (declare-fun e3 () I) (declare-fun e2 () I) (declare-fun e1 () I) (declare-fun e0 () I) (assert (or (or (or (or (and (= (op e3 e0) e3) (= (op e0 e3) e3)) (and (= (op e3 e1) e3) (= (op e1 e3) e3))) (and (= (op e3 e2) e3) (= (op e2 e3) e3))) (= (op e3 e3) e3)) (and (= (op e3 e4) e3) (= (op e4 e3) e3)))) (assert (or (or (and (= (op e2 e1) e2) (= (op e1 e2) e2)) (or (or (or (or (and (= (op e3 e0) e3) (= (op e0 e3) e3)) (and (= (op e3 e1) e3) (= (op e1 e3) e3))) (and (= (op e3 e2) e3) (= (op e2 e3) e3))) (= (op e3 e3) e3)) (and (= (op e3 e4) e3) (= (op e4 e3) e3)))) (or (= (op e4 e1) e4) (= (op e3 e4) e4)))) (assert (and (= (op e2 e1) e0) (= (op e4 e4) e0) (= (op e3 e4) e1) (= (op e4 e1) e2) (not (= (op e1 e4) (op e4 e1))) (= (op e3 e3) e2) (= e1 (op e0 e0)) (= e4 (op e2 e2)))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.0b-edit.smt2.expected.err000066400000000000000000000000001445011647600270040ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.0b-edit.smt2.expected.out000066400000000000000000000000041445011647600270270ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.0b-edit.smt2.expected.time000066400000000000000000000000351445011647600271620ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.0b-edit2.smt2000066400000000000000000000020731445011647600245130ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort I 0) (declare-fun op (I I) I) (declare-fun e4 () I) (declare-fun e3 () I) (declare-fun e2 () I) (declare-fun e1 () I) (declare-fun e0 () I) (assert (or (or (or (and (= (op e3 e0) e3) (= (op e0 e3) e3)) (and (= (op e3 e1) e3) (= (op e1 e3) e3))) (and (= (op e3 e2) e3) (= (op e2 e3) e3))) (= (op e3 e3) e3) (and (= (op e3 e4) e3) (= (op e4 e3) e3)))) (assert (or (or (and (= (op e2 e1) e2) (= (op e1 e2) e2)) (or (or (or (or (and (= (op e3 e0) e3) (= (op e0 e3) e3)) (and (= (op e3 e1) e3) (= (op e1 e3) e3))) (and (= (op e3 e2) e3) (= (op e2 e3) e3))) (= (op e3 e3) e3)) (and (= (op e3 e4) e3) (= (op e4 e3) e3)))) (or (= (op e4 e1) e4) (= (op e3 e4) e4)))) (assert (and (= (op e2 e1) e0) (= (op e4 e4) e0) (= (op e3 e4) e1) (= (op e4 e1) e2) (not (= (op e1 e4) (op e4 e1))) (= (op e3 e3) e2) (= e1 (op e0 e0)) (= e4 (op e2 e2)))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.0b-edit2.smt2.expected.err000066400000000000000000000000001445011647600270660ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.0b-edit2.smt2.expected.out000066400000000000000000000000041445011647600271110ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.0b-edit2.smt2.expected.time000066400000000000000000000000351445011647600272440ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.0b.smt2000066400000000000000000000152461445011647600235140ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort I 0) (declare-fun op (I I) I) (declare-fun e4 () I) (declare-fun e3 () I) (declare-fun e2 () I) (declare-fun e1 () I) (declare-fun e0 () I) (assert (let ((?v_1 (op e0 e0)) (?v_2 (op e0 e1)) (?v_3 (op e0 e2)) (?v_4 (op e0 e3)) (?v_5 (op e0 e4)) (?v_7 (op e1 e0)) (?v_18 (op e1 e1)) (?v_19 (op e1 e2)) (?v_20 (op e1 e3)) (?v_21 (op e1 e4)) (?v_8 (op e2 e0)) (?v_24 (op e2 e1)) (?v_43 (op e2 e2)) (?v_44 (op e2 e3)) (?v_45 (op e2 e4)) (?v_9 (op e3 e0)) (?v_25 (op e3 e1)) (?v_49 (op e3 e2)) (?v_76 (op e3 e3)) (?v_77 (op e3 e4)) (?v_10 (op e4 e0)) (?v_26 (op e4 e1)) (?v_50 (op e4 e2)) (?v_82 (op e4 e3)) (?v_117 (op e4 e4))) (let ((?v_0 false) (?v_6 true) (?v_11 false) (?v_12 false) (?v_13 false) (?v_15 false) (?v_22 false) (?v_28 false) (?v_31 false) (?v_34 true) (?v_38 false) (?v_46 false) (?v_53 false) (?v_58 true) (?v_63 false) (?v_69 true) (?v_78 false) (?v_86 false) (?v_93 false) (?v_100 false) (?v_108 false) (?v_118 false) (?v_127 true) (?v_136 false) (?v_145 false) (?v_14 true) (?v_17 false) (?v_27 false) (?v_30 false) (?v_33 false) (?v_16 false) (?v_23 true) (?v_29 false) (?v_32 false) (?v_35 false) (?v_39 false) (?v_47 false) (?v_54 true) (?v_59 false) (?v_64 false) (?v_70 false) (?v_79 false) (?v_87 false) (?v_94 true) (?v_101 false) (?v_109 false) (?v_119 false) (?v_128 false) (?v_137 false) (?v_146 true) (?v_36 false) (?v_41 false) (?v_51 true) (?v_56 false) (?v_61 false) (?v_37 (= ?v_24 e0)) (?v_42 false) (?v_52 false) (?v_57 false) (?v_62 false) (?v_40 false) (?v_48 false) (?v_55 false) (?v_60 false) (?v_65 true) (?v_71 false) (?v_80 true) (?v_88 false) (?v_95 false) (?v_102 false) (?v_110 false) (?v_120 false) (?v_129 false) (?v_138 true) (?v_147 false) (?v_66 false) (?v_73 false) (?v_83 false) (?v_90 false) (?v_97 true) (?v_67 false) (?v_74 false) (?v_84 false) (?v_91 true) (?v_98 false) (?v_68 true) (?v_75 false) (?v_85 false) (?v_92 false) (?v_99 false) (?v_72 false) (?v_81 false) (?v_89 true) (?v_96 false) (?v_103 false) (?v_111 false) (?v_121 (= ?v_77 e1)) (?v_130 false) (?v_139 false) (?v_148 false) (?v_104 false) (?v_113 false) (?v_123 false) (?v_132 true) (?v_141 false) (?v_105 false) (?v_114 false) (?v_124 (= ?v_26 e2)) (?v_133 false) (?v_142 false) (?v_106 false) (?v_115 true) (?v_125 false) (?v_134 false) (?v_143 false) (?v_107 false) (?v_116 false) (?v_126 false) (?v_135 false) (?v_144 true) (?v_112 (= ?v_117 e0)) (?v_122 false) (?v_131 false) (?v_140 true) (?v_149 false)) (and (and (and true (and (and (and (and (and (or (or (or (or false ?v_37) false) false) false) true) true) true) true) true)) true) (and (and (and (and (and true (or false ?v_112)) (and true (or (or false ?v_121) false))) (and (or (or (or (or false ?v_124) false) false) false) true)) true) true))))) (assert (let ((?v_25 (op e0 e0)) (?v_27 (op e0 e1)) (?v_29 (op e0 e2)) (?v_31 (op e0 e3)) (?v_33 (op e0 e4)) (?v_28 (op e1 e0)) (?v_37 (op e1 e1)) (?v_39 (op e1 e2)) (?v_41 (op e1 e3)) (?v_43 (op e1 e4)) (?v_30 (op e2 e0)) (?v_40 (op e2 e1)) (?v_49 (op e2 e2)) (?v_51 (op e2 e3)) (?v_53 (op e2 e4)) (?v_32 (op e3 e0)) (?v_42 (op e3 e1)) (?v_52 (op e3 e2)) (?v_61 (op e3 e3)) (?v_63 (op e3 e4)) (?v_34 (op e4 e0)) (?v_44 (op e4 e1)) (?v_54 (op e4 e2)) (?v_64 (op e4 e3)) (?v_73 (op e4 e4))) (let ((?v_0 false) (?v_26 false) (?v_75 false) (?v_100 false) (?v_125 false) (?v_2 false) (?v_36 false) (?v_77 false) (?v_102 false) (?v_127 false) (?v_5 false) (?v_46 false) (?v_80 false) (?v_105 false) (?v_130 false) (?v_10 false) (?v_56 false) (?v_85 false) (?v_110 (= ?v_31 e3)) (?v_135 false) (?v_17 false) (?v_66 false) (?v_92 false) (?v_117 false) (?v_142 false) (?v_1 false) (?v_35 false) (?v_76 false) (?v_101 false) (?v_126 false) (?v_3 false) (?v_38 true) (?v_78 false) (?v_103 false) (?v_128 false) (?v_7 false) (?v_48 false) (?v_82 false) (?v_107 false) (?v_132 false) (?v_12 false) (?v_58 false) (?v_87 false) (?v_112 (= ?v_41 e3)) (?v_137 false) (?v_19 false) (?v_68 false) (?v_94 false) (?v_119 false) (?v_144 false) (?v_4 false) (?v_45 false) (?v_79 false) (?v_104 false) (?v_129 false) (?v_6 false) (?v_47 false) (?v_81 false) (?v_106 false) (?v_131 false) (?v_8 false) (?v_50 false) (?v_83 false) (?v_108 false) (?v_133 true) (?v_14 false) (?v_60 false) (?v_89 false) (?v_114 (= ?v_51 e3)) (?v_139 false) (?v_21 false) (?v_70 false) (?v_96 false) (?v_121 false) (?v_146 false) (?v_9 false) (?v_55 false) (?v_84 false) (?v_109 (= ?v_32 e3)) (?v_134 false) (?v_11 false) (?v_57 false) (?v_86 false) (?v_111 (= ?v_42 e3)) (?v_136 false) (?v_13 false) (?v_59 false) (?v_88 false) (?v_113 (= ?v_52 e3)) (?v_138 false) (?v_15 false) (?v_62 false) (?v_90 (= ?v_61 e2)) (?v_115 (= ?v_61 e3)) (?v_140 false) (?v_23 false) (?v_72 false) (?v_98 false) (?v_123 (= ?v_63 e3)) (?v_148 false) (?v_16 false) (?v_65 false) (?v_91 false) (?v_116 false) (?v_141 false) (?v_18 false) (?v_67 false) (?v_93 false) (?v_118 false) (?v_143 false) (?v_20 false) (?v_69 false) (?v_95 false) (?v_120 false) (?v_145 false) (?v_22 false) (?v_71 false) (?v_97 false) (?v_122 (= ?v_64 e3)) (?v_147 false) (?v_24 true) (?v_74 false) (?v_99 false) (?v_124 false) (?v_149 false)) (and (and (and true (or (or false (or (or false (and ?v_90 ?v_90)) false)) false)) (or (or false (or (or (or (or (and ?v_109 ?v_110) (and ?v_111 ?v_112)) (and ?v_113 ?v_114)) (and ?v_115 ?v_115)) (and ?v_123 ?v_122))) false)) true)))) (assert (let ((?v_0 (op e0 e0)) (?v_2 (op e0 e1)) (?v_5 (op e0 e2)) (?v_10 (op e0 e3)) (?v_17 (op e0 e4)) (?v_1 (op e1 e0)) (?v_3 (op e1 e1)) (?v_7 (op e1 e2)) (?v_12 (op e1 e3)) (?v_19 (op e1 e4)) (?v_4 (op e2 e0)) (?v_6 (op e2 e1)) (?v_8 (op e2 e2)) (?v_14 (op e2 e3)) (?v_21 (op e2 e4)) (?v_9 (op e3 e0)) (?v_11 (op e3 e1)) (?v_13 (op e3 e2)) (?v_15 (op e3 e3)) (?v_23 (op e3 e4)) (?v_16 (op e4 e0)) (?v_18 (op e4 e1)) (?v_20 (op e4 e2)) (?v_22 (op e4 e3)) (?v_24 (op e4 e4))) (and (and (and (and true (or false (not (= ?v_19 ?v_18)))) true) true) true))) (assert (let ((?v_2 (op e0 e1)) (?v_5 (op e0 e2)) (?v_10 (op e0 e3)) (?v_17 (op e0 e4)) (?v_1 (op e1 e0)) (?v_7 (op e1 e2)) (?v_12 (op e1 e3)) (?v_19 (op e1 e4)) (?v_4 (op e2 e0)) (?v_6 (op e2 e1)) (?v_14 (op e2 e3)) (?v_21 (op e2 e4)) (?v_9 (op e3 e0)) (?v_11 (op e3 e1)) (?v_13 (op e3 e2)) (?v_23 (op e3 e4)) (?v_16 (op e4 e0)) (?v_18 (op e4 e1)) (?v_20 (op e4 e2)) (?v_22 (op e4 e3)) (?v_0 false) (?v_3 false) (?v_8 false) (?v_15 (= (op e3 e3) e3)) (?v_24 false)) (or (or (or false (or (or (or (or false (and (= ?v_6 e2) (= ?v_7 e2))) false) false) false)) (or (or (or (or (and (= ?v_9 e3) (= ?v_10 e3)) (and (= ?v_11 e3) (= ?v_12 e3))) (and (= ?v_13 e3) (= ?v_14 e3))) (and ?v_15 ?v_15)) (and (= ?v_23 e3) (= ?v_22 e3)))) (or (or (or (or false (and (= ?v_18 e4) true)) false) (and true (= ?v_23 e4))) false)))) (assert (and (and (and true (= e1 (op e0 e0))) true) (= e4 (op e2 e2)))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.0b.smt2.expected.err000066400000000000000000000000001445011647600260610ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.0b.smt2.expected.out000066400000000000000000000000041445011647600261040ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.0b.smt2.expected.time000066400000000000000000000000351445011647600262370ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.1-edit.smt2000066400000000000000000000332101445011647600242650ustar00rootroot00000000000000(set-logic QF_UF) (set-info :source | http://www.cs.bham.ac.uk/~vxs/quasigroups/benchmark/ |) (set-info :smt-lib-version 2.0) (set-info :category "crafted") (declare-sort U 0) (declare-sort I 0) (declare-fun op1 (I I) I) (declare-fun op (I I) I) (declare-fun e4 () I) (declare-fun e3 () I) (declare-fun e2 () I) (declare-fun e1 () I) (declare-fun e0 () I) (assert (let ((?v_1 (op e0 e0)) (?v_2 (op e0 e1)) (?v_3 (op e0 e2)) (?v_4 (op e0 e3)) (?v_5 (op e0 e4)) (?v_7 (op e1 e0)) (?v_18 (op e1 e1)) (?v_19 (op e1 e2)) (?v_20 (op e1 e3)) (?v_21 (op e1 e4)) (?v_8 (op e2 e0)) (?v_24 (op e2 e1)) (?v_43 (op e2 e2)) (?v_44 (op e2 e3)) (?v_45 (op e2 e4)) (?v_9 (op e3 e0)) (?v_25 (op e3 e1)) (?v_49 (op e3 e2)) (?v_76 (op e3 e3)) (?v_77 (op e3 e4)) (?v_10 (op e4 e0)) (?v_26 (op e4 e1)) (?v_50 (op e4 e2)) (?v_82 (op e4 e3)) (?v_117 (op e4 e4))) (let ((?v_0 (= ?v_1 e0)) (?v_6 (= ?v_1 e1)) (?v_11 (= ?v_1 e2)) (?v_12 (= ?v_1 e3)) (?v_13 (= ?v_1 e4)) (?v_15 (= ?v_2 e0)) (?v_22 (= ?v_2 e1)) (?v_28 (= ?v_2 e2)) (?v_31 (= ?v_2 e3)) (?v_34 (= ?v_2 e4)) (?v_38 (= ?v_3 e0)) (?v_46 (= ?v_3 e1)) (?v_53 (= ?v_3 e2)) (?v_58 (= ?v_3 e3)) (?v_63 (= ?v_3 e4)) (?v_69 (= ?v_4 e0)) (?v_78 (= ?v_4 e1)) (?v_86 (= ?v_4 e2)) (?v_93 (= ?v_4 e3)) (?v_100 (= ?v_4 e4)) (?v_108 (= ?v_5 e0)) (?v_118 (= ?v_5 e1)) (?v_127 (= ?v_5 e2)) (?v_136 (= ?v_5 e3)) (?v_145 (= ?v_5 e4)) (?v_14 (= ?v_7 e0)) (?v_17 (= ?v_7 e1)) (?v_27 (= ?v_7 e2)) (?v_30 (= ?v_7 e3)) (?v_33 (= ?v_7 e4)) (?v_16 (= ?v_18 e0)) (?v_23 (= ?v_18 e1)) (?v_29 (= ?v_18 e2)) (?v_32 (= ?v_18 e3)) (?v_35 (= ?v_18 e4)) (?v_39 (= ?v_19 e0)) (?v_47 (= ?v_19 e1)) (?v_54 (= ?v_19 e2)) (?v_59 (= ?v_19 e3)) (?v_64 (= ?v_19 e4)) (?v_70 (= ?v_20 e0)) (?v_79 (= ?v_20 e1)) (?v_87 (= ?v_20 e2)) (?v_94 (= ?v_20 e3)) (?v_101 (= ?v_20 e4)) (?v_109 (= ?v_21 e0)) (?v_119 (= ?v_21 e1)) (?v_128 (= ?v_21 e2)) (?v_137 (= ?v_21 e3)) (?v_146 (= ?v_21 e4)) (?v_36 (= ?v_8 e0)) (?v_41 (= ?v_8 e1)) (?v_51 (= ?v_8 e2)) (?v_56 (= ?v_8 e3)) (?v_61 (= ?v_8 e4)) (?v_37 (= ?v_24 e0)) (?v_42 (= ?v_24 e1)) (?v_52 (= ?v_24 e2)) (?v_57 (= ?v_24 e3)) (?v_62 (= ?v_24 e4)) (?v_40 (= ?v_43 e0)) (?v_48 (= ?v_43 e1)) (?v_55 (= ?v_43 e2)) (?v_60 (= ?v_43 e3)) (?v_65 (= ?v_43 e4)) (?v_71 (= ?v_44 e0)) (?v_80 (= ?v_44 e1)) (?v_88 (= ?v_44 e2)) (?v_95 (= ?v_44 e3)) (?v_102 (= ?v_44 e4)) (?v_110 (= ?v_45 e0)) (?v_120 (= ?v_45 e1)) (?v_129 (= ?v_45 e2)) (?v_138 (= ?v_45 e3)) (?v_147 (= ?v_45 e4)) (?v_66 (= ?v_9 e0)) (?v_73 (= ?v_9 e1)) (?v_83 (= ?v_9 e2)) (?v_90 (= ?v_9 e3)) (?v_97 (= ?v_9 e4)) (?v_67 (= ?v_25 e0)) (?v_74 (= ?v_25 e1)) (?v_84 (= ?v_25 e2)) (?v_91 (= ?v_25 e3)) (?v_98 (= ?v_25 e4)) (?v_68 (= ?v_49 e0)) (?v_75 (= ?v_49 e1)) (?v_85 (= ?v_49 e2)) (?v_92 (= ?v_49 e3)) (?v_99 (= ?v_49 e4)) (?v_72 (= ?v_76 e0)) (?v_81 (= ?v_76 e1)) (?v_89 (= ?v_76 e2)) (?v_96 (= ?v_76 e3)) (?v_103 (= ?v_76 e4)) (?v_111 (= ?v_77 e0)) (?v_121 (= ?v_77 e1)) (?v_130 (= ?v_77 e2)) (?v_139 (= ?v_77 e3)) (?v_148 (= ?v_77 e4)) (?v_104 (= ?v_10 e0)) (?v_113 (= ?v_10 e1)) (?v_123 (= ?v_10 e2)) (?v_132 (= ?v_10 e3)) (?v_141 (= ?v_10 e4)) (?v_105 (= ?v_26 e0)) (?v_114 (= ?v_26 e1)) (?v_124 (= ?v_26 e2)) (?v_133 (= ?v_26 e3)) (?v_142 (= ?v_26 e4)) (?v_106 (= ?v_50 e0)) (?v_115 (= ?v_50 e1)) (?v_125 (= ?v_50 e2)) (?v_134 (= ?v_50 e3)) (?v_143 (= ?v_50 e4)) (?v_107 (= ?v_82 e0)) (?v_116 (= ?v_82 e1)) (?v_126 (= ?v_82 e2)) (?v_135 (= ?v_82 e3)) (?v_144 (= ?v_82 e4)) (?v_112 (= ?v_117 e0)) (?v_122 (= ?v_117 e1)) (?v_131 (= ?v_117 e2)) (?v_140 (= ?v_117 e3)) (?v_149 (= ?v_117 e4))) (and (and (and (and (and (and (and (and (and (or (or (or (or ?v_0 ?v_15) ?v_38) ?v_69) ?v_108) (or (or (or (or ?v_0 ?v_14) ?v_36) ?v_66) ?v_104)) (and (or (or (or (or ?v_6 ?v_22) ?v_46) ?v_78) ?v_118) (or (or (or (or ?v_6 ?v_17) ?v_41) ?v_73) ?v_113))) (and (or (or (or (or ?v_11 ?v_28) ?v_53) ?v_86) ?v_127) (or (or (or (or ?v_11 ?v_27) ?v_51) ?v_83) ?v_123))) (and (or (or (or (or ?v_12 ?v_31) ?v_58) ?v_93) ?v_136) (or (or (or (or ?v_12 ?v_30) ?v_56) ?v_90) ?v_132))) (and (or (or (or (or ?v_13 ?v_34) ?v_63) ?v_100) ?v_145) (or (or (or (or ?v_13 ?v_33) ?v_61) ?v_97) ?v_141))) (and (and (and (and (and (or (or (or (or ?v_14 ?v_16) ?v_39) ?v_70) ?v_109) (or (or (or (or ?v_15 ?v_16) ?v_37) ?v_67) ?v_105)) (and (or (or (or (or ?v_17 ?v_23) ?v_47) ?v_79) ?v_119) (or (or (or (or ?v_22 ?v_23) ?v_42) ?v_74) ?v_114))) (and (or (or (or (or ?v_27 ?v_29) ?v_54) ?v_87) ?v_128) (or (or (or (or ?v_28 ?v_29) ?v_52) ?v_84) ?v_124))) (and (or (or (or (or ?v_30 ?v_32) ?v_59) ?v_94) ?v_137) (or (or (or (or ?v_31 ?v_32) ?v_57) ?v_91) ?v_133))) (and (or (or (or (or ?v_33 ?v_35) ?v_64) ?v_101) ?v_146) (or (or (or (or ?v_34 ?v_35) ?v_62) ?v_98) ?v_142)))) (and (and (and (and (and (or (or (or (or ?v_36 ?v_37) ?v_40) ?v_71) ?v_110) (or (or (or (or ?v_38 ?v_39) ?v_40) ?v_68) ?v_106)) (and (or (or (or (or ?v_41 ?v_42) ?v_48) ?v_80) ?v_120) (or (or (or (or ?v_46 ?v_47) ?v_48) ?v_75) ?v_115))) (and (or (or (or (or ?v_51 ?v_52) ?v_55) ?v_88) ?v_129) (or (or (or (or ?v_53 ?v_54) ?v_55) ?v_85) ?v_125))) (and (or (or (or (or ?v_56 ?v_57) ?v_60) ?v_95) ?v_138) (or (or (or (or ?v_58 ?v_59) ?v_60) ?v_92) ?v_134))) (and (or (or (or (or ?v_61 ?v_62) ?v_65) ?v_102) ?v_147) (or (or (or (or ?v_63 ?v_64) ?v_65) ?v_99) ?v_143)))) (and (and (and (and (and (or (or (or (or ?v_66 ?v_67) ?v_68) ?v_72) ?v_111) (or (or (or (or ?v_69 ?v_70) ?v_71) ?v_72) ?v_107)) (and (or (or (or (or ?v_73 ?v_74) ?v_75) ?v_81) ?v_121) (or (or (or (or ?v_78 ?v_79) ?v_80) ?v_81) ?v_116))) (and (or (or (or (or ?v_83 ?v_84) ?v_85) ?v_89) ?v_130) (or (or (or (or ?v_86 ?v_87) ?v_88) ?v_89) ?v_126))) (and (or (or (or (or ?v_90 ?v_91) ?v_92) ?v_96) ?v_139) (or (or (or (or ?v_93 ?v_94) ?v_95) ?v_96) ?v_135))) (and (or (or (or (or ?v_97 ?v_98) ?v_99) ?v_103) ?v_148) (or (or (or (or ?v_100 ?v_101) ?v_102) ?v_103) ?v_144)))) (and (and (and (and (and (or (or (or (or ?v_104 ?v_105) ?v_106) ?v_107) ?v_112) (or (or (or (or ?v_108 ?v_109) ?v_110) ?v_111) ?v_112)) (and (or (or (or (or ?v_113 ?v_114) ?v_115) ?v_116) ?v_122) (or (or (or (or ?v_118 ?v_119) ?v_120) ?v_121) ?v_122))) (and (or (or (or (or ?v_123 ?v_124) ?v_125) ?v_126) ?v_131) (or (or (or (or ?v_127 ?v_128) ?v_129) ?v_130) ?v_131))) (and (or (or (or (or ?v_132 ?v_133) ?v_134) ?v_135) ?v_140) (or (or (or (or ?v_136 ?v_137) ?v_138) ?v_139) ?v_140))) (and (or (or (or (or ?v_141 ?v_142) ?v_143) ?v_144) ?v_149) (or (or (or (or ?v_145 ?v_146) ?v_147) ?v_148) ?v_149))))))) (assert (let ((?v_0 (op e0 e0)) (?v_1 (op e1 e1)) (?v_2 (op e2 e2)) (?v_3 (op e3 e3)) (?v_4 (op e4 e4))) (or (or (or (or (and (and (and (and (not (= ?v_0 e0)) (not (= ?v_1 e0))) (not (= ?v_2 e0))) (not (= ?v_3 e0))) (not (= ?v_4 e0))) (and (and (and (and (not (= ?v_0 e1)) (not (= ?v_1 e1))) (not (= ?v_2 e1))) (not (= ?v_3 e1))) (not (= ?v_4 e1)))) (and (and (and (and (not (= ?v_0 e2)) (not (= ?v_1 e2))) (not (= ?v_2 e2))) (not (= ?v_3 e2))) (not (= ?v_4 e2)))) (and (and (and (and (not (= ?v_0 e3)) (not (= ?v_1 e3))) (not (= ?v_2 e3))) (not (= ?v_3 e3))) (not (= ?v_4 e3)))) (and (and (and (and (not (= ?v_0 e4)) (not (= ?v_1 e4))) (not (= ?v_2 e4))) (not (= ?v_3 e4))) (not (= ?v_4 e4)))))) (assert (let ((?v_25 (op e0 e0)) (?v_27 (op e0 e1)) (?v_29 (op e0 e2)) (?v_31 (op e0 e3)) (?v_33 (op e0 e4)) (?v_28 (op e1 e0)) (?v_37 (op e1 e1)) (?v_39 (op e1 e2)) (?v_41 (op e1 e3)) (?v_43 (op e1 e4)) (?v_30 (op e2 e0)) (?v_40 (op e2 e1)) (?v_49 (op e2 e2)) (?v_51 (op e2 e3)) (?v_53 (op e2 e4)) (?v_32 (op e3 e0)) (?v_42 (op e3 e1)) (?v_52 (op e3 e2)) (?v_61 (op e3 e3)) (?v_63 (op e3 e4)) (?v_34 (op e4 e0)) (?v_44 (op e4 e1)) (?v_54 (op e4 e2)) (?v_64 (op e4 e3)) (?v_73 (op e4 e4))) (let ((?v_0 (= ?v_25 e0)) (?v_26 (= ?v_25 e1)) (?v_75 (= ?v_25 e2)) (?v_100 (= ?v_25 e3)) (?v_125 (= ?v_25 e4)) (?v_2 (= ?v_27 e0)) (?v_36 (= ?v_27 e1)) (?v_77 (= ?v_27 e2)) (?v_102 (= ?v_27 e3)) (?v_127 (= ?v_27 e4)) (?v_5 (= ?v_29 e0)) (?v_46 (= ?v_29 e1)) (?v_80 (= ?v_29 e2)) (?v_105 (= ?v_29 e3)) (?v_130 (= ?v_29 e4)) (?v_10 (= ?v_31 e0)) (?v_56 (= ?v_31 e1)) (?v_85 (= ?v_31 e2)) (?v_110 (= ?v_31 e3)) (?v_135 (= ?v_31 e4)) (?v_17 (= ?v_33 e0)) (?v_66 (= ?v_33 e1)) (?v_92 (= ?v_33 e2)) (?v_117 (= ?v_33 e3)) (?v_142 (= ?v_33 e4)) (?v_1 (= ?v_28 e0)) (?v_35 (= ?v_28 e1)) (?v_76 (= ?v_28 e2)) (?v_101 (= ?v_28 e3)) (?v_126 (= ?v_28 e4)) (?v_3 (= ?v_37 e0)) (?v_38 (= ?v_37 e1)) (?v_78 (= ?v_37 e2)) (?v_103 (= ?v_37 e3)) (?v_128 (= ?v_37 e4)) (?v_7 (= ?v_39 e0)) (?v_48 (= ?v_39 e1)) (?v_82 (= ?v_39 e2)) (?v_107 (= ?v_39 e3)) (?v_132 (= ?v_39 e4)) (?v_12 (= ?v_41 e0)) (?v_58 (= ?v_41 e1)) (?v_87 (= ?v_41 e2)) (?v_112 (= ?v_41 e3)) (?v_137 (= ?v_41 e4)) (?v_19 (= ?v_43 e0)) (?v_68 (= ?v_43 e1)) (?v_94 (= ?v_43 e2)) (?v_119 (= ?v_43 e3)) (?v_144 (= ?v_43 e4)) (?v_4 (= ?v_30 e0)) (?v_45 (= ?v_30 e1)) (?v_79 (= ?v_30 e2)) (?v_104 (= ?v_30 e3)) (?v_129 (= ?v_30 e4)) (?v_6 (= ?v_40 e0)) (?v_47 (= ?v_40 e1)) (?v_81 (= ?v_40 e2)) (?v_106 (= ?v_40 e3)) (?v_131 (= ?v_40 e4)) (?v_8 (= ?v_49 e0)) (?v_50 (= ?v_49 e1)) (?v_83 (= ?v_49 e2)) (?v_108 (= ?v_49 e3)) (?v_133 (= ?v_49 e4)) (?v_14 (= ?v_51 e0)) (?v_60 (= ?v_51 e1)) (?v_89 (= ?v_51 e2)) (?v_114 (= ?v_51 e3)) (?v_139 (= ?v_51 e4)) (?v_21 (= ?v_53 e0)) (?v_70 (= ?v_53 e1)) (?v_96 (= ?v_53 e2)) (?v_121 (= ?v_53 e3)) (?v_146 (= ?v_53 e4)) (?v_9 (= ?v_32 e0)) (?v_55 (= ?v_32 e1)) (?v_84 (= ?v_32 e2)) (?v_109 (= ?v_32 e3)) (?v_134 (= ?v_32 e4)) (?v_11 (= ?v_42 e0)) (?v_57 (= ?v_42 e1)) (?v_86 (= ?v_42 e2)) (?v_111 (= ?v_42 e3)) (?v_136 (= ?v_42 e4)) (?v_13 (= ?v_52 e0)) (?v_59 (= ?v_52 e1)) (?v_88 (= ?v_52 e2)) (?v_113 (= ?v_52 e3)) (?v_138 (= ?v_52 e4)) (?v_15 (= ?v_61 e0)) (?v_62 (= ?v_61 e1)) (?v_90 (= ?v_61 e2)) (?v_115 (= ?v_61 e3)) (?v_140 (= ?v_61 e4)) (?v_23 (= ?v_63 e0)) (?v_72 (= ?v_63 e1)) (?v_98 (= ?v_63 e2)) (?v_123 (= ?v_63 e3)) (?v_148 (= ?v_63 e4)) (?v_16 (= ?v_34 e0)) (?v_65 (= ?v_34 e1)) (?v_91 (= ?v_34 e2)) (?v_116 (= ?v_34 e3)) (?v_141 (= ?v_34 e4)) (?v_18 (= ?v_44 e0)) (?v_67 (= ?v_44 e1)) (?v_93 (= ?v_44 e2)) (?v_118 (= ?v_44 e3)) (?v_143 (= ?v_44 e4)) (?v_20 (= ?v_54 e0)) (?v_69 (= ?v_54 e1)) (?v_95 (= ?v_54 e2)) (?v_120 (= ?v_54 e3)) (?v_145 (= ?v_54 e4)) (?v_22 (= ?v_64 e0)) (?v_71 (= ?v_64 e1)) (?v_97 (= ?v_64 e2)) (?v_122 (= ?v_64 e3)) (?v_147 (= ?v_64 e4)) (?v_24 (= ?v_73 e0)) (?v_74 (= ?v_73 e1)) (?v_99 (= ?v_73 e2)) (?v_124 (= ?v_73 e3)) (?v_149 (= ?v_73 e4))) (and (and (and (and (or (or (or (or (or (or (or (or (and ?v_0 ?v_0) (and ?v_2 ?v_1)) (and ?v_5 ?v_4)) (and ?v_10 ?v_9)) (and ?v_17 ?v_16)) (or (or (or (or (and ?v_1 ?v_2) (and ?v_3 ?v_3)) (and ?v_7 ?v_6)) (and ?v_12 ?v_11)) (and ?v_19 ?v_18))) (or (or (or (or (and ?v_4 ?v_5) (and ?v_6 ?v_7)) (and ?v_8 ?v_8)) (and ?v_14 ?v_13)) (and ?v_21 ?v_20))) (or (or (or (or (and ?v_9 ?v_10) (and ?v_11 ?v_12)) (and ?v_13 ?v_14)) (and ?v_15 ?v_15)) (and ?v_23 ?v_22))) (or (or (or (or (and ?v_16 ?v_17) (and ?v_18 ?v_19)) (and ?v_20 ?v_21)) (and ?v_22 ?v_23)) (and ?v_24 ?v_24))) (or (or (or (or (or (or (or (or (and ?v_26 ?v_26) (and ?v_36 ?v_35)) (and ?v_46 ?v_45)) (and ?v_56 ?v_55)) (and ?v_66 ?v_65)) (or (or (or (or (and ?v_35 ?v_36) (and ?v_38 ?v_38)) (and ?v_48 ?v_47)) (and ?v_58 ?v_57)) (and ?v_68 ?v_67))) (or (or (or (or (and ?v_45 ?v_46) (and ?v_47 ?v_48)) (and ?v_50 ?v_50)) (and ?v_60 ?v_59)) (and ?v_70 ?v_69))) (or (or (or (or (and ?v_55 ?v_56) (and ?v_57 ?v_58)) (and ?v_59 ?v_60)) (and ?v_62 ?v_62)) (and ?v_72 ?v_71))) (or (or (or (or (and ?v_65 ?v_66) (and ?v_67 ?v_68)) (and ?v_69 ?v_70)) (and ?v_71 ?v_72)) (and ?v_74 ?v_74)))) (or (or (or (or (or (or (or (or (and ?v_75 ?v_75) (and ?v_77 ?v_76)) (and ?v_80 ?v_79)) (and ?v_85 ?v_84)) (and ?v_92 ?v_91)) (or (or (or (or (and ?v_76 ?v_77) (and ?v_78 ?v_78)) (and ?v_82 ?v_81)) (and ?v_87 ?v_86)) (and ?v_94 ?v_93))) (or (or (or (or (and ?v_79 ?v_80) (and ?v_81 ?v_82)) (and ?v_83 ?v_83)) (and ?v_89 ?v_88)) (and ?v_96 ?v_95))) (or (or (or (or (and ?v_84 ?v_85) (and ?v_86 ?v_87)) (and ?v_88 ?v_89)) (and ?v_90 ?v_90)) (and ?v_98 ?v_97))) (or (or (or (or (and ?v_91 ?v_92) (and ?v_93 ?v_94)) (and ?v_95 ?v_96)) (and ?v_97 ?v_98)) (and ?v_99 ?v_99)))) (or (or (or (or (or (or (or (or (and ?v_100 ?v_100) (and ?v_102 ?v_101)) (and ?v_105 ?v_104)) (and ?v_110 ?v_109)) (and ?v_117 ?v_116)) (or (or (or (or (and ?v_101 ?v_102) (and ?v_103 ?v_103)) (and ?v_107 ?v_106)) (and ?v_112 ?v_111)) (and ?v_119 ?v_118))) (or (or (or (or (and ?v_104 ?v_105) (and ?v_106 ?v_107)) (and ?v_108 ?v_108)) (and ?v_114 ?v_113)) (and ?v_121 ?v_120))) (or (or (or (or (and ?v_109 ?v_110) (and ?v_111 ?v_112)) (and ?v_113 ?v_114)) (and ?v_115 ?v_115)) (and ?v_123 ?v_122))) (or (or (or (or (and ?v_116 ?v_117) (and ?v_118 ?v_119)) (and ?v_120 ?v_121)) (and ?v_122 ?v_123)) (and ?v_124 ?v_124)))) (or (or (or (or (or (or (or (or (and ?v_125 ?v_125) (and ?v_127 ?v_126)) (and ?v_130 ?v_129)) (and ?v_135 ?v_134)) (and ?v_142 ?v_141)) (or (or (or (or (and ?v_126 ?v_127) (and ?v_128 ?v_128)) (and ?v_132 ?v_131)) (and ?v_137 ?v_136)) (and ?v_144 ?v_143))) (or (or (or (or (and ?v_129 ?v_130) (and ?v_131 ?v_132)) (and ?v_133 ?v_133)) (and ?v_139 ?v_138)) (and ?v_146 ?v_145))) (or (or (or (or (and ?v_134 ?v_135) (and ?v_136 ?v_137)) (and ?v_138 ?v_139)) (and ?v_140 ?v_140)) (and ?v_148 ?v_147))) (or (or (or (or (and ?v_141 ?v_142) (and ?v_143 ?v_144)) (and ?v_145 ?v_146)) (and ?v_147 ?v_148)) (and ?v_149 ?v_149))))))) (assert (let ( (?v_10 (op e0 e3)) (?v_17 (op e0 e4)) (?v_7 (op e1 e2)) (?v_12 (op e1 e3)) (?v_19 (op e1 e4)) (?v_14 (op e2 e3)) (?v_21 (op e2 e4)) (?v_9 (op e3 e0)) (?v_11 (op e3 e1)) (?v_13 (op e3 e2)) (?v_23 (op e3 e4)) (?v_18 (op e4 e1)) (?v_22 (op e4 e3)) (?v_15 (= (op e3 e3) e3)) ) (or (or (or (or (or (or (and (= ?v_9 e3) (= ?v_10 e3)) (and (= ?v_11 e3) (= ?v_12 e3))) (and (= ?v_13 e3) (= ?v_14 e3))) ?v_15) (and (= ?v_23 e3) (= ?v_22 e3)))) (or (or (or (or (and (= ?v_18 e4) (= ?v_19 e4)))) (and (= ?v_22 e4) (= ?v_23 e4))))))) (assert (and (= e0 (op e4 e4)) (= e1 (op e0 e0)) (= e2 (op e3 e3)) (= e4 (op e2 e2)) (not (= (op e1 e4) (op e4 e1))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.1-edit.smt2.expected.err000066400000000000000000000000001445011647600266430ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.1-edit.smt2.expected.out000066400000000000000000000000041445011647600266660ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.1-edit.smt2.expected.time000066400000000000000000000000351445011647600270210ustar00rootroot00000000000000real 0.07 user 0.07 sys 0.00 opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.1.smt2000066400000000000000000000345561445011647600233600ustar00rootroot00000000000000(set-logic QF_UF) (set-info :source | http://www.cs.bham.ac.uk/~vxs/quasigroups/benchmark/ |) (set-info :smt-lib-version 2.0) (set-info :category "crafted") (declare-sort U 0) (declare-sort I 0) (declare-fun op1 (I I) I) (declare-fun op (I I) I) (declare-fun e4 () I) (declare-fun e3 () I) (declare-fun e2 () I) (declare-fun e1 () I) (declare-fun e0 () I) (assert (let ((?v_1 (op e0 e0)) (?v_2 (op e0 e1)) (?v_3 (op e0 e2)) (?v_4 (op e0 e3)) (?v_5 (op e0 e4)) (?v_7 (op e1 e0)) (?v_18 (op e1 e1)) (?v_19 (op e1 e2)) (?v_20 (op e1 e3)) (?v_21 (op e1 e4)) (?v_8 (op e2 e0)) (?v_24 (op e2 e1)) (?v_43 (op e2 e2)) (?v_44 (op e2 e3)) (?v_45 (op e2 e4)) (?v_9 (op e3 e0)) (?v_25 (op e3 e1)) (?v_49 (op e3 e2)) (?v_76 (op e3 e3)) (?v_77 (op e3 e4)) (?v_10 (op e4 e0)) (?v_26 (op e4 e1)) (?v_50 (op e4 e2)) (?v_82 (op e4 e3)) (?v_117 (op e4 e4))) (let ((?v_0 (= ?v_1 e0)) (?v_6 (= ?v_1 e1)) (?v_11 (= ?v_1 e2)) (?v_12 (= ?v_1 e3)) (?v_13 (= ?v_1 e4)) (?v_15 (= ?v_2 e0)) (?v_22 (= ?v_2 e1)) (?v_28 (= ?v_2 e2)) (?v_31 (= ?v_2 e3)) (?v_34 (= ?v_2 e4)) (?v_38 (= ?v_3 e0)) (?v_46 (= ?v_3 e1)) (?v_53 (= ?v_3 e2)) (?v_58 (= ?v_3 e3)) (?v_63 (= ?v_3 e4)) (?v_69 (= ?v_4 e0)) (?v_78 (= ?v_4 e1)) (?v_86 (= ?v_4 e2)) (?v_93 (= ?v_4 e3)) (?v_100 (= ?v_4 e4)) (?v_108 (= ?v_5 e0)) (?v_118 (= ?v_5 e1)) (?v_127 (= ?v_5 e2)) (?v_136 (= ?v_5 e3)) (?v_145 (= ?v_5 e4)) (?v_14 (= ?v_7 e0)) (?v_17 (= ?v_7 e1)) (?v_27 (= ?v_7 e2)) (?v_30 (= ?v_7 e3)) (?v_33 (= ?v_7 e4)) (?v_16 (= ?v_18 e0)) (?v_23 (= ?v_18 e1)) (?v_29 (= ?v_18 e2)) (?v_32 (= ?v_18 e3)) (?v_35 (= ?v_18 e4)) (?v_39 (= ?v_19 e0)) (?v_47 (= ?v_19 e1)) (?v_54 (= ?v_19 e2)) (?v_59 (= ?v_19 e3)) (?v_64 (= ?v_19 e4)) (?v_70 (= ?v_20 e0)) (?v_79 (= ?v_20 e1)) (?v_87 (= ?v_20 e2)) (?v_94 (= ?v_20 e3)) (?v_101 (= ?v_20 e4)) (?v_109 (= ?v_21 e0)) (?v_119 (= ?v_21 e1)) (?v_128 (= ?v_21 e2)) (?v_137 (= ?v_21 e3)) (?v_146 (= ?v_21 e4)) (?v_36 (= ?v_8 e0)) (?v_41 (= ?v_8 e1)) (?v_51 (= ?v_8 e2)) (?v_56 (= ?v_8 e3)) (?v_61 (= ?v_8 e4)) (?v_37 (= ?v_24 e0)) (?v_42 (= ?v_24 e1)) (?v_52 (= ?v_24 e2)) (?v_57 (= ?v_24 e3)) (?v_62 (= ?v_24 e4)) (?v_40 (= ?v_43 e0)) (?v_48 (= ?v_43 e1)) (?v_55 (= ?v_43 e2)) (?v_60 (= ?v_43 e3)) (?v_65 (= ?v_43 e4)) (?v_71 (= ?v_44 e0)) (?v_80 (= ?v_44 e1)) (?v_88 (= ?v_44 e2)) (?v_95 (= ?v_44 e3)) (?v_102 (= ?v_44 e4)) (?v_110 (= ?v_45 e0)) (?v_120 (= ?v_45 e1)) (?v_129 (= ?v_45 e2)) (?v_138 (= ?v_45 e3)) (?v_147 (= ?v_45 e4)) (?v_66 (= ?v_9 e0)) (?v_73 (= ?v_9 e1)) (?v_83 (= ?v_9 e2)) (?v_90 (= ?v_9 e3)) (?v_97 (= ?v_9 e4)) (?v_67 (= ?v_25 e0)) (?v_74 (= ?v_25 e1)) (?v_84 (= ?v_25 e2)) (?v_91 (= ?v_25 e3)) (?v_98 (= ?v_25 e4)) (?v_68 (= ?v_49 e0)) (?v_75 (= ?v_49 e1)) (?v_85 (= ?v_49 e2)) (?v_92 (= ?v_49 e3)) (?v_99 (= ?v_49 e4)) (?v_72 (= ?v_76 e0)) (?v_81 (= ?v_76 e1)) (?v_89 (= ?v_76 e2)) (?v_96 (= ?v_76 e3)) (?v_103 (= ?v_76 e4)) (?v_111 (= ?v_77 e0)) (?v_121 (= ?v_77 e1)) (?v_130 (= ?v_77 e2)) (?v_139 (= ?v_77 e3)) (?v_148 (= ?v_77 e4)) (?v_104 (= ?v_10 e0)) (?v_113 (= ?v_10 e1)) (?v_123 (= ?v_10 e2)) (?v_132 (= ?v_10 e3)) (?v_141 (= ?v_10 e4)) (?v_105 (= ?v_26 e0)) (?v_114 (= ?v_26 e1)) (?v_124 (= ?v_26 e2)) (?v_133 (= ?v_26 e3)) (?v_142 (= ?v_26 e4)) (?v_106 (= ?v_50 e0)) (?v_115 (= ?v_50 e1)) (?v_125 (= ?v_50 e2)) (?v_134 (= ?v_50 e3)) (?v_143 (= ?v_50 e4)) (?v_107 (= ?v_82 e0)) (?v_116 (= ?v_82 e1)) (?v_126 (= ?v_82 e2)) (?v_135 (= ?v_82 e3)) (?v_144 (= ?v_82 e4)) (?v_112 (= ?v_117 e0)) (?v_122 (= ?v_117 e1)) (?v_131 (= ?v_117 e2)) (?v_140 (= ?v_117 e3)) (?v_149 (= ?v_117 e4))) (and (and (and (and (and (and (and (and (and (or (or (or (or ?v_0 ?v_15) ?v_38) ?v_69) ?v_108) (or (or (or (or ?v_0 ?v_14) ?v_36) ?v_66) ?v_104)) (and (or (or (or (or ?v_6 ?v_22) ?v_46) ?v_78) ?v_118) (or (or (or (or ?v_6 ?v_17) ?v_41) ?v_73) ?v_113))) (and (or (or (or (or ?v_11 ?v_28) ?v_53) ?v_86) ?v_127) (or (or (or (or ?v_11 ?v_27) ?v_51) ?v_83) ?v_123))) (and (or (or (or (or ?v_12 ?v_31) ?v_58) ?v_93) ?v_136) (or (or (or (or ?v_12 ?v_30) ?v_56) ?v_90) ?v_132))) (and (or (or (or (or ?v_13 ?v_34) ?v_63) ?v_100) ?v_145) (or (or (or (or ?v_13 ?v_33) ?v_61) ?v_97) ?v_141))) (and (and (and (and (and (or (or (or (or ?v_14 ?v_16) ?v_39) ?v_70) ?v_109) (or (or (or (or ?v_15 ?v_16) ?v_37) ?v_67) ?v_105)) (and (or (or (or (or ?v_17 ?v_23) ?v_47) ?v_79) ?v_119) (or (or (or (or ?v_22 ?v_23) ?v_42) ?v_74) ?v_114))) (and (or (or (or (or ?v_27 ?v_29) ?v_54) ?v_87) ?v_128) (or (or (or (or ?v_28 ?v_29) ?v_52) ?v_84) ?v_124))) (and (or (or (or (or ?v_30 ?v_32) ?v_59) ?v_94) ?v_137) (or (or (or (or ?v_31 ?v_32) ?v_57) ?v_91) ?v_133))) (and (or (or (or (or ?v_33 ?v_35) ?v_64) ?v_101) ?v_146) (or (or (or (or ?v_34 ?v_35) ?v_62) ?v_98) ?v_142)))) (and (and (and (and (and (or (or (or (or ?v_36 ?v_37) ?v_40) ?v_71) ?v_110) (or (or (or (or ?v_38 ?v_39) ?v_40) ?v_68) ?v_106)) (and (or (or (or (or ?v_41 ?v_42) ?v_48) ?v_80) ?v_120) (or (or (or (or ?v_46 ?v_47) ?v_48) ?v_75) ?v_115))) (and (or (or (or (or ?v_51 ?v_52) ?v_55) ?v_88) ?v_129) (or (or (or (or ?v_53 ?v_54) ?v_55) ?v_85) ?v_125))) (and (or (or (or (or ?v_56 ?v_57) ?v_60) ?v_95) ?v_138) (or (or (or (or ?v_58 ?v_59) ?v_60) ?v_92) ?v_134))) (and (or (or (or (or ?v_61 ?v_62) ?v_65) ?v_102) ?v_147) (or (or (or (or ?v_63 ?v_64) ?v_65) ?v_99) ?v_143)))) (and (and (and (and (and (or (or (or (or ?v_66 ?v_67) ?v_68) ?v_72) ?v_111) (or (or (or (or ?v_69 ?v_70) ?v_71) ?v_72) ?v_107)) (and (or (or (or (or ?v_73 ?v_74) ?v_75) ?v_81) ?v_121) (or (or (or (or ?v_78 ?v_79) ?v_80) ?v_81) ?v_116))) (and (or (or (or (or ?v_83 ?v_84) ?v_85) ?v_89) ?v_130) (or (or (or (or ?v_86 ?v_87) ?v_88) ?v_89) ?v_126))) (and (or (or (or (or ?v_90 ?v_91) ?v_92) ?v_96) ?v_139) (or (or (or (or ?v_93 ?v_94) ?v_95) ?v_96) ?v_135))) (and (or (or (or (or ?v_97 ?v_98) ?v_99) ?v_103) ?v_148) (or (or (or (or ?v_100 ?v_101) ?v_102) ?v_103) ?v_144)))) (and (and (and (and (and (or (or (or (or ?v_104 ?v_105) ?v_106) ?v_107) ?v_112) (or (or (or (or ?v_108 ?v_109) ?v_110) ?v_111) ?v_112)) (and (or (or (or (or ?v_113 ?v_114) ?v_115) ?v_116) ?v_122) (or (or (or (or ?v_118 ?v_119) ?v_120) ?v_121) ?v_122))) (and (or (or (or (or ?v_123 ?v_124) ?v_125) ?v_126) ?v_131) (or (or (or (or ?v_127 ?v_128) ?v_129) ?v_130) ?v_131))) (and (or (or (or (or ?v_132 ?v_133) ?v_134) ?v_135) ?v_140) (or (or (or (or ?v_136 ?v_137) ?v_138) ?v_139) ?v_140))) (and (or (or (or (or ?v_141 ?v_142) ?v_143) ?v_144) ?v_149) (or (or (or (or ?v_145 ?v_146) ?v_147) ?v_148) ?v_149))))))) (assert (let ((?v_0 (op e0 e0)) (?v_1 (op e1 e1)) (?v_2 (op e2 e2)) (?v_3 (op e3 e3)) (?v_4 (op e4 e4))) (or (or (or (or (and (and (and (and (not (= ?v_0 e0)) (not (= ?v_1 e0))) (not (= ?v_2 e0))) (not (= ?v_3 e0))) (not (= ?v_4 e0))) (and (and (and (and (not (= ?v_0 e1)) (not (= ?v_1 e1))) (not (= ?v_2 e1))) (not (= ?v_3 e1))) (not (= ?v_4 e1)))) (and (and (and (and (not (= ?v_0 e2)) (not (= ?v_1 e2))) (not (= ?v_2 e2))) (not (= ?v_3 e2))) (not (= ?v_4 e2)))) (and (and (and (and (not (= ?v_0 e3)) (not (= ?v_1 e3))) (not (= ?v_2 e3))) (not (= ?v_3 e3))) (not (= ?v_4 e3)))) (and (and (and (and (not (= ?v_0 e4)) (not (= ?v_1 e4))) (not (= ?v_2 e4))) (not (= ?v_3 e4))) (not (= ?v_4 e4)))))) (assert (let ((?v_25 (op e0 e0)) (?v_27 (op e0 e1)) (?v_29 (op e0 e2)) (?v_31 (op e0 e3)) (?v_33 (op e0 e4)) (?v_28 (op e1 e0)) (?v_37 (op e1 e1)) (?v_39 (op e1 e2)) (?v_41 (op e1 e3)) (?v_43 (op e1 e4)) (?v_30 (op e2 e0)) (?v_40 (op e2 e1)) (?v_49 (op e2 e2)) (?v_51 (op e2 e3)) (?v_53 (op e2 e4)) (?v_32 (op e3 e0)) (?v_42 (op e3 e1)) (?v_52 (op e3 e2)) (?v_61 (op e3 e3)) (?v_63 (op e3 e4)) (?v_34 (op e4 e0)) (?v_44 (op e4 e1)) (?v_54 (op e4 e2)) (?v_64 (op e4 e3)) (?v_73 (op e4 e4))) (let ((?v_0 (= ?v_25 e0)) (?v_26 (= ?v_25 e1)) (?v_75 (= ?v_25 e2)) (?v_100 (= ?v_25 e3)) (?v_125 (= ?v_25 e4)) (?v_2 (= ?v_27 e0)) (?v_36 (= ?v_27 e1)) (?v_77 (= ?v_27 e2)) (?v_102 (= ?v_27 e3)) (?v_127 (= ?v_27 e4)) (?v_5 (= ?v_29 e0)) (?v_46 (= ?v_29 e1)) (?v_80 (= ?v_29 e2)) (?v_105 (= ?v_29 e3)) (?v_130 (= ?v_29 e4)) (?v_10 (= ?v_31 e0)) (?v_56 (= ?v_31 e1)) (?v_85 (= ?v_31 e2)) (?v_110 (= ?v_31 e3)) (?v_135 (= ?v_31 e4)) (?v_17 (= ?v_33 e0)) (?v_66 (= ?v_33 e1)) (?v_92 (= ?v_33 e2)) (?v_117 (= ?v_33 e3)) (?v_142 (= ?v_33 e4)) (?v_1 (= ?v_28 e0)) (?v_35 (= ?v_28 e1)) (?v_76 (= ?v_28 e2)) (?v_101 (= ?v_28 e3)) (?v_126 (= ?v_28 e4)) (?v_3 (= ?v_37 e0)) (?v_38 (= ?v_37 e1)) (?v_78 (= ?v_37 e2)) (?v_103 (= ?v_37 e3)) (?v_128 (= ?v_37 e4)) (?v_7 (= ?v_39 e0)) (?v_48 (= ?v_39 e1)) (?v_82 (= ?v_39 e2)) (?v_107 (= ?v_39 e3)) (?v_132 (= ?v_39 e4)) (?v_12 (= ?v_41 e0)) (?v_58 (= ?v_41 e1)) (?v_87 (= ?v_41 e2)) (?v_112 (= ?v_41 e3)) (?v_137 (= ?v_41 e4)) (?v_19 (= ?v_43 e0)) (?v_68 (= ?v_43 e1)) (?v_94 (= ?v_43 e2)) (?v_119 (= ?v_43 e3)) (?v_144 (= ?v_43 e4)) (?v_4 (= ?v_30 e0)) (?v_45 (= ?v_30 e1)) (?v_79 (= ?v_30 e2)) (?v_104 (= ?v_30 e3)) (?v_129 (= ?v_30 e4)) (?v_6 (= ?v_40 e0)) (?v_47 (= ?v_40 e1)) (?v_81 (= ?v_40 e2)) (?v_106 (= ?v_40 e3)) (?v_131 (= ?v_40 e4)) (?v_8 (= ?v_49 e0)) (?v_50 (= ?v_49 e1)) (?v_83 (= ?v_49 e2)) (?v_108 (= ?v_49 e3)) (?v_133 (= ?v_49 e4)) (?v_14 (= ?v_51 e0)) (?v_60 (= ?v_51 e1)) (?v_89 (= ?v_51 e2)) (?v_114 (= ?v_51 e3)) (?v_139 (= ?v_51 e4)) (?v_21 (= ?v_53 e0)) (?v_70 (= ?v_53 e1)) (?v_96 (= ?v_53 e2)) (?v_121 (= ?v_53 e3)) (?v_146 (= ?v_53 e4)) (?v_9 (= ?v_32 e0)) (?v_55 (= ?v_32 e1)) (?v_84 (= ?v_32 e2)) (?v_109 (= ?v_32 e3)) (?v_134 (= ?v_32 e4)) (?v_11 (= ?v_42 e0)) (?v_57 (= ?v_42 e1)) (?v_86 (= ?v_42 e2)) (?v_111 (= ?v_42 e3)) (?v_136 (= ?v_42 e4)) (?v_13 (= ?v_52 e0)) (?v_59 (= ?v_52 e1)) (?v_88 (= ?v_52 e2)) (?v_113 (= ?v_52 e3)) (?v_138 (= ?v_52 e4)) (?v_15 (= ?v_61 e0)) (?v_62 (= ?v_61 e1)) (?v_90 (= ?v_61 e2)) (?v_115 (= ?v_61 e3)) (?v_140 (= ?v_61 e4)) (?v_23 (= ?v_63 e0)) (?v_72 (= ?v_63 e1)) (?v_98 (= ?v_63 e2)) (?v_123 (= ?v_63 e3)) (?v_148 (= ?v_63 e4)) (?v_16 (= ?v_34 e0)) (?v_65 (= ?v_34 e1)) (?v_91 (= ?v_34 e2)) (?v_116 (= ?v_34 e3)) (?v_141 (= ?v_34 e4)) (?v_18 (= ?v_44 e0)) (?v_67 (= ?v_44 e1)) (?v_93 (= ?v_44 e2)) (?v_118 (= ?v_44 e3)) (?v_143 (= ?v_44 e4)) (?v_20 (= ?v_54 e0)) (?v_69 (= ?v_54 e1)) (?v_95 (= ?v_54 e2)) (?v_120 (= ?v_54 e3)) (?v_145 (= ?v_54 e4)) (?v_22 (= ?v_64 e0)) (?v_71 (= ?v_64 e1)) (?v_97 (= ?v_64 e2)) (?v_122 (= ?v_64 e3)) (?v_147 (= ?v_64 e4)) (?v_24 (= ?v_73 e0)) (?v_74 (= ?v_73 e1)) (?v_99 (= ?v_73 e2)) (?v_124 (= ?v_73 e3)) (?v_149 (= ?v_73 e4))) (and (and (and (and (or (or (or (or (or (or (or (or (and ?v_0 ?v_0) (and ?v_2 ?v_1)) (and ?v_5 ?v_4)) (and ?v_10 ?v_9)) (and ?v_17 ?v_16)) (or (or (or (or (and ?v_1 ?v_2) (and ?v_3 ?v_3)) (and ?v_7 ?v_6)) (and ?v_12 ?v_11)) (and ?v_19 ?v_18))) (or (or (or (or (and ?v_4 ?v_5) (and ?v_6 ?v_7)) (and ?v_8 ?v_8)) (and ?v_14 ?v_13)) (and ?v_21 ?v_20))) (or (or (or (or (and ?v_9 ?v_10) (and ?v_11 ?v_12)) (and ?v_13 ?v_14)) (and ?v_15 ?v_15)) (and ?v_23 ?v_22))) (or (or (or (or (and ?v_16 ?v_17) (and ?v_18 ?v_19)) (and ?v_20 ?v_21)) (and ?v_22 ?v_23)) (and ?v_24 ?v_24))) (or (or (or (or (or (or (or (or (and ?v_26 ?v_26) (and ?v_36 ?v_35)) (and ?v_46 ?v_45)) (and ?v_56 ?v_55)) (and ?v_66 ?v_65)) (or (or (or (or (and ?v_35 ?v_36) (and ?v_38 ?v_38)) (and ?v_48 ?v_47)) (and ?v_58 ?v_57)) (and ?v_68 ?v_67))) (or (or (or (or (and ?v_45 ?v_46) (and ?v_47 ?v_48)) (and ?v_50 ?v_50)) (and ?v_60 ?v_59)) (and ?v_70 ?v_69))) (or (or (or (or (and ?v_55 ?v_56) (and ?v_57 ?v_58)) (and ?v_59 ?v_60)) (and ?v_62 ?v_62)) (and ?v_72 ?v_71))) (or (or (or (or (and ?v_65 ?v_66) (and ?v_67 ?v_68)) (and ?v_69 ?v_70)) (and ?v_71 ?v_72)) (and ?v_74 ?v_74)))) (or (or (or (or (or (or (or (or (and ?v_75 ?v_75) (and ?v_77 ?v_76)) (and ?v_80 ?v_79)) (and ?v_85 ?v_84)) (and ?v_92 ?v_91)) (or (or (or (or (and ?v_76 ?v_77) (and ?v_78 ?v_78)) (and ?v_82 ?v_81)) (and ?v_87 ?v_86)) (and ?v_94 ?v_93))) (or (or (or (or (and ?v_79 ?v_80) (and ?v_81 ?v_82)) (and ?v_83 ?v_83)) (and ?v_89 ?v_88)) (and ?v_96 ?v_95))) (or (or (or (or (and ?v_84 ?v_85) (and ?v_86 ?v_87)) (and ?v_88 ?v_89)) (and ?v_90 ?v_90)) (and ?v_98 ?v_97))) (or (or (or (or (and ?v_91 ?v_92) (and ?v_93 ?v_94)) (and ?v_95 ?v_96)) (and ?v_97 ?v_98)) (and ?v_99 ?v_99)))) (or (or (or (or (or (or (or (or (and ?v_100 ?v_100) (and ?v_102 ?v_101)) (and ?v_105 ?v_104)) (and ?v_110 ?v_109)) (and ?v_117 ?v_116)) (or (or (or (or (and ?v_101 ?v_102) (and ?v_103 ?v_103)) (and ?v_107 ?v_106)) (and ?v_112 ?v_111)) (and ?v_119 ?v_118))) (or (or (or (or (and ?v_104 ?v_105) (and ?v_106 ?v_107)) (and ?v_108 ?v_108)) (and ?v_114 ?v_113)) (and ?v_121 ?v_120))) (or (or (or (or (and ?v_109 ?v_110) (and ?v_111 ?v_112)) (and ?v_113 ?v_114)) (and ?v_115 ?v_115)) (and ?v_123 ?v_122))) (or (or (or (or (and ?v_116 ?v_117) (and ?v_118 ?v_119)) (and ?v_120 ?v_121)) (and ?v_122 ?v_123)) (and ?v_124 ?v_124)))) (or (or (or (or (or (or (or (or (and ?v_125 ?v_125) (and ?v_127 ?v_126)) (and ?v_130 ?v_129)) (and ?v_135 ?v_134)) (and ?v_142 ?v_141)) (or (or (or (or (and ?v_126 ?v_127) (and ?v_128 ?v_128)) (and ?v_132 ?v_131)) (and ?v_137 ?v_136)) (and ?v_144 ?v_143))) (or (or (or (or (and ?v_129 ?v_130) (and ?v_131 ?v_132)) (and ?v_133 ?v_133)) (and ?v_139 ?v_138)) (and ?v_146 ?v_145))) (or (or (or (or (and ?v_134 ?v_135) (and ?v_136 ?v_137)) (and ?v_138 ?v_139)) (and ?v_140 ?v_140)) (and ?v_148 ?v_147))) (or (or (or (or (and ?v_141 ?v_142) (and ?v_143 ?v_144)) (and ?v_145 ?v_146)) (and ?v_147 ?v_148)) (and ?v_149 ?v_149))))))) (assert (let ((?v_0 (op e0 e0)) (?v_2 (op e0 e1)) (?v_5 (op e0 e2)) (?v_10 (op e0 e3)) (?v_17 (op e0 e4)) (?v_1 (op e1 e0)) (?v_3 (op e1 e1)) (?v_7 (op e1 e2)) (?v_12 (op e1 e3)) (?v_19 (op e1 e4)) (?v_4 (op e2 e0)) (?v_6 (op e2 e1)) (?v_8 (op e2 e2)) (?v_14 (op e2 e3)) (?v_21 (op e2 e4)) (?v_9 (op e3 e0)) (?v_11 (op e3 e1)) (?v_13 (op e3 e2)) (?v_15 (op e3 e3)) (?v_23 (op e3 e4)) (?v_16 (op e4 e0)) (?v_18 (op e4 e1)) (?v_20 (op e4 e2)) (?v_22 (op e4 e3)) (?v_24 (op e4 e4))) (and (and (and (and (or false (not false)) (or false (not (= ?v_19 ?v_18)))) (or false (not false))) (or false (not false))) (or (or false (not false)) false)))) (assert (let ((?v_2 (op e0 e1)) (?v_5 (op e0 e2)) (?v_10 (op e0 e3)) (?v_17 (op e0 e4)) (?v_1 (op e1 e0)) (?v_7 (op e1 e2)) (?v_12 (op e1 e3)) (?v_19 (op e1 e4)) (?v_4 (op e2 e0)) (?v_6 (op e2 e1)) (?v_14 (op e2 e3)) (?v_21 (op e2 e4)) (?v_9 (op e3 e0)) (?v_11 (op e3 e1)) (?v_13 (op e3 e2)) (?v_23 (op e3 e4)) (?v_16 (op e4 e0)) (?v_18 (op e4 e1)) (?v_20 (op e4 e2)) (?v_22 (op e4 e3)) (?v_0 false) (?v_3 false) (?v_8 false) (?v_15 (= (op e3 e3) e3)) (?v_24 false)) (or (or false (or (or (or (or (and (= ?v_9 e3) (= ?v_10 e3)) (and (= ?v_11 e3) (= ?v_12 e3))) (and (= ?v_13 e3) (= ?v_14 e3))) (and ?v_15 ?v_15)) (and (= ?v_23 e3) (= ?v_22 e3)))) (or (or (or (or false (and (= ?v_18 e4) (= ?v_19 e4))) false) (and (= ?v_22 e4) (= ?v_23 e4))) false)))) (assert (and (and (and (= e0 (op e4 e4)) (= e1 (op e0 e0))) (= e2 (op e3 e3))) (= e4 (op e2 e2)))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.1.smt2.expected.err000066400000000000000000000000001445011647600257200ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.1.smt2.expected.out000066400000000000000000000000041445011647600257430ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.1.smt2.expected.time000066400000000000000000000000351445011647600260760ustar00rootroot00000000000000real 0.18 user 0.18 sys 0.00 opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.1b.smt2000066400000000000000000000000311445011647600234770ustar00rootroot00000000000000(set-logic QF_UF) (exit) opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.1b.smt2.expected.err000066400000000000000000000000001445011647600260620ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.1b.smt2.expected.out000066400000000000000000000000001445011647600261010ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/iso_brn268_simplified.1b.smt2.expected.time000066400000000000000000000000351445011647600262400ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_UF/issue185.smt2000066400000000000000000000002121445011647600204650ustar00rootroot00000000000000(set-logic QF_UF) (declare-fun f (Bool) Bool) (declare-fun v7 () Bool) (declare-fun v8 () Bool) (assert (f (= v7 v8))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/issue185.smt2.expected.err000066400000000000000000000000001445011647600230470ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/issue185.smt2.expected.out000066400000000000000000000000041445011647600230720ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/issue185b.smt2000066400000000000000000000003271445011647600206360ustar00rootroot00000000000000(set-logic QF_UF) (declare-fun uf7 (Bool Bool Bool Bool Bool Bool Bool) Bool) (declare-fun v7 () Bool) (declare-fun v8 () Bool) (assert (uf7 true true true (not (distinct v7 v8)) true true true)) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/issue185b.smt2.expected.err000066400000000000000000000000001445011647600232110ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/issue185b.smt2.expected.out000066400000000000000000000000041445011647600232340ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/issue185c.smt2000066400000000000000000000005771445011647600206460ustar00rootroot00000000000000(set-logic QF_UF) (declare-fun uf7 (Bool Bool Bool Bool Bool Bool Bool) Bool) (declare-fun v0 () Bool) (declare-fun v2 () Bool) (declare-fun v7 () Bool) (declare-fun v11 () Bool) (declare-fun v13 () Bool) (declare-fun v16 () Bool) (declare-fun v17 () Bool) (declare-fun v19 () Bool) (assert (uf7 v2 v19 (= v11 (not v17)) v13 (=> v16 v0) v7 v17)) (check-sat) (assert v16) (check-sat) opensmt-2.5.2/regression/QF_UF/issue185c.smt2.expected.err000066400000000000000000000000001445011647600232120ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/issue185c.smt2.expected.out000066400000000000000000000000101445011647600232320ustar00rootroot00000000000000sat sat opensmt-2.5.2/regression/QF_UF/issue188.smt2000066400000000000000000000013141445011647600204740ustar00rootroot00000000000000(set-logic QF_UF) (declare-fun uf3 (Bool Bool Bool) Bool) (declare-fun v0 () Bool) (declare-fun v1 () Bool) (declare-fun v2 () Bool) (declare-fun v3 () Bool) (declare-fun v4 () Bool) (declare-fun v5 () Bool) (push 1) (declare-fun v6 () Bool) (declare-fun v7 () Bool) (push 1) (declare-fun v8 () Bool) (assert v0) (push 1) (declare-sort S0 0) (declare-fun v9 () Bool) (declare-fun v10 () Bool) (declare-fun v11 () Bool) (assert v6) (assert (distinct v10 (not v3))) (assert (uf3 v8 (not v3) (distinct v10 (not v3)))) (declare-fun S0-0 () S0) (push 1) (push 1) (assert (not v7)) (check-sat) (declare-sort S1 0) (declare-fun v12 () Bool) (assert (=> v1 v7)) (assert (uf3 v11 v2 v10)) (assert (not (not v3))) (check-sat) opensmt-2.5.2/regression/QF_UF/issue188.smt2.expected.err000066400000000000000000000000001445011647600230520ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/issue188.smt2.expected.out000066400000000000000000000000101445011647600230720ustar00rootroot00000000000000sat sat opensmt-2.5.2/regression/QF_UF/issue190.smt2000066400000000000000000000007211445011647600204660ustar00rootroot00000000000000(set-logic QF_UF) (declare-fun uf3 (Bool) Bool) (declare-fun uf7 (Bool Bool Bool Bool) Bool) (declare-fun v0 () Bool) (declare-fun v1 () Bool) (declare-fun v2 () Bool) (declare-fun v3 () Bool) (declare-fun v4 () Bool) (declare-fun v5 () Bool) (declare-fun v6 () Bool) (declare-fun v7 () Bool) (assert (= v6 v1)) (push 1) (assert (uf7 true (uf7 v3 v5 v4 v5) (or v3 (= (not v5) (uf3 v7))) (= (not v5) (uf3 v7)) ) ) (check-sat) (pop 1) (check-sat) opensmt-2.5.2/regression/QF_UF/issue190.smt2.expected.err000066400000000000000000000000001445011647600230430ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/issue190.smt2.expected.out000066400000000000000000000000101445011647600230630ustar00rootroot00000000000000sat sat opensmt-2.5.2/regression/QF_UF/issue190b.smt2000066400000000000000000000012721445011647600206320ustar00rootroot00000000000000(set-logic QF_UF) (declare-fun uf4 (Bool Bool Bool Bool) Bool) (declare-fun uf7 (Bool Bool Bool Bool Bool Bool Bool) Bool) (declare-fun v3 () Bool) (declare-fun v8 () Bool) (declare-fun v11 () Bool) (declare-fun v17 () Bool) (check-sat) (check-sat) (assert (uf7 (=> v3 v11) true true true true v8 true)) (push 1) (declare-sort S2 0) (declare-sort S3 0) (assert (= v3 v17)) (declare-sort S4 0) (push 1) (assert false) (check-sat) (pop 1) (check-sat) (check-sat) (pop 1) (push 1) (declare-sort S2 0) (assert (uf4 (= (=> v3 v11) (not v8)) true true true)) (check-sat) (declare-sort S2 0) (declare-sort S3 0) (declare-sort S4 0) (declare-sort S2 0) (check-sat) (pop 1) (assert (=> v3 v11)) (check-sat) opensmt-2.5.2/regression/QF_UF/issue190b.smt2.expected.err000066400000000000000000000000001445011647600232050ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/issue190b.smt2.expected.out000066400000000000000000000003261445011647600232370ustar00rootroot00000000000000sat sat unsat sat sat (error "sort S2 already declared") sat (error "sort S2 already declared") (error "sort S3 already declared") (error "sort S4 already declared") (error "sort S2 already declared") sat sat opensmt-2.5.2/regression/QF_UF/issue193.smt2000066400000000000000000000003251445011647600204710ustar00rootroot00000000000000(set-logic QF_UF) (declare-fun f (Bool) Bool) (declare-fun g (Bool Bool) Bool) (declare-fun P () Bool) (declare-fun Q () Bool) (push 1) (assert (g (= P Q) Q)) (check-sat) (assert (f P)) (pop 1) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/issue193.smt2.expected.err000066400000000000000000000000001445011647600230460ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/issue193.smt2.expected.out000066400000000000000000000000101445011647600230660ustar00rootroot00000000000000sat sat opensmt-2.5.2/regression/QF_UF/issue193b.smt2000066400000000000000000000013301445011647600206300ustar00rootroot00000000000000(set-logic QF_UF) (declare-fun uf3 (Bool Bool Bool) Bool) (declare-fun uf4 (Bool Bool Bool Bool) Bool) (declare-fun uf5 (Bool Bool Bool Bool Bool) Bool) (declare-fun uf6 (Bool Bool Bool Bool Bool Bool) Bool) (declare-fun v0 () Bool) (declare-fun v4 () Bool) (push 1) (assert (uf5 v0 false v4 true false)) (check-sat) (check-sat) (assert false) (check-sat) (pop 1) (check-sat) (declare-fun v18 () Bool) (declare-fun v20 () Bool) (assert (uf4 v4 false true true)) (push 1) (assert (uf3 v18 (=> v0 (uf4 v4 false true true)) false)) (check-sat) (assert (uf5 v20 true false true true)) (assert v4) (check-sat) (check-sat) (assert false) (check-sat) (pop 1) (check-sat) (assert (uf6 true v18 (=> v18 v20) true true true)) (check-sat) opensmt-2.5.2/regression/QF_UF/issue193b.smt2.expected.err000066400000000000000000000000001445011647600232100ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/issue193b.smt2.expected.out000066400000000000000000000000541445011647600232400ustar00rootroot00000000000000sat sat unsat sat sat sat sat unsat sat sat opensmt-2.5.2/regression/QF_UF/issue199.smt2000066400000000000000000000007121445011647600204770ustar00rootroot00000000000000(set-logic QF_UF) (declare-fun uf5 (Bool Bool Bool Bool Bool) Bool) (declare-fun uf6 (Bool Bool Bool Bool Bool Bool) Bool) (declare-fun v0 () Bool) (declare-fun v1 () Bool) (declare-fun v2 () Bool) (push 1) (assert (=> v0 v1)) (push 1) (assert (uf5 (distinct (=> v2 (=> v0 v1)) v0) true v2 (=> v2 (=> v0 v1)) true)) (check-sat) (pop 1) (assert false) (check-sat) (pop 1) (assert (uf6 v0 v2 (=> v0 v1) true true v0)) (push 1) (assert (xor v1 v0)) (check-sat) opensmt-2.5.2/regression/QF_UF/issue199.smt2.expected.err000066400000000000000000000000001445011647600230540ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/issue199.smt2.expected.out000066400000000000000000000000161445011647600231020ustar00rootroot00000000000000sat unsat sat opensmt-2.5.2/regression/QF_UF/issue226.smt2000066400000000000000000000003121445011647600204620ustar00rootroot00000000000000(set-logic QF_UF) (set-info :status unsat) (declare-fun uf6 (Bool) Bool) (declare-fun x () Bool) (declare-fun z () Bool) (assert (uf6 x)) (assert (not (uf6 z))) (assert (not (uf6 (not z)))) (check-sat) opensmt-2.5.2/regression/QF_UF/issue226.smt2.expected.err000066400000000000000000000000001445011647600230430ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/issue226.smt2.expected.out000066400000000000000000000000061445011647600230700ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UF/issue226b.smt2000066400000000000000000000004761445011647600206370ustar00rootroot00000000000000(set-logic QF_UF) (set-info :status unsat) (declare-fun uf6 (Bool) Bool) (declare-fun x () Bool) (declare-fun y () Bool) (declare-fun z () Bool) (assert (uf6 x)) (assert (not (uf6 (or y z)))) (assert (not (uf6 (or y (not z))))) (assert (not (uf6 (or (not y) z)))) (assert (not (uf6 (or (not y) (not z))))) (check-sat) opensmt-2.5.2/regression/QF_UF/issue226b.smt2.expected.err000066400000000000000000000000001445011647600232050ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/issue226b.smt2.expected.out000066400000000000000000000000061445011647600232320ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UF/let-example.smt2000066400000000000000000000004261445011647600213230ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort U 0) (declare-fun v0 () U) (declare-fun v1 () U) (declare-fun b0 () Bool) (assert (and (let ((?e0 (= v0 v1))) (let ((?d1 (not b0))) (or ?e0 ?d1))) (let ((?e0 (distinct v0 v1))) (let ((?d1 b0)) (or ?e0 ?d1))))) (check-sat) opensmt-2.5.2/regression/QF_UF/let-example.smt2.expected.err000066400000000000000000000000001445011647600236760ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/let-example.smt2.expected.out000066400000000000000000000000041445011647600237210ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/let-example.smt2.expected.time000066400000000000000000000000741445011647600240570ustar00rootroot00000000000000Command terminated by signal 6 real 0.20 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_UF/let-example2.smt2000066400000000000000000000002051445011647600214000ustar00rootroot00000000000000(set-logic QF_UF) (assert (or (let ((a true) (b (let ((a false)) (not a)))) (and a b)) (let ((a true)) (not a)))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/let-example2.smt2.expected.err000066400000000000000000000000001445011647600237600ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/let-example2.smt2.expected.out000066400000000000000000000000041445011647600240030ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/let-example2.smt2.expected.time000066400000000000000000000000351445011647600241360ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_UF/looping.smt2000066400000000000000000000314121445011647600205540ustar00rootroot00000000000000(set-logic QF_UF) (set-info :source | http://www.cs.bham.ac.uk/~vxs/quasigroups/benchmark/ |) (set-info :smt-lib-version 2.0) (set-info :category "crafted") (declare-sort U 0) (declare-sort I 0) (declare-fun op1 (I I) I) (declare-fun op (I I) I) (declare-fun e4 () I) (declare-fun e3 () I) (declare-fun e2 () I) (declare-fun e1 () I) (declare-fun e0 () I) (assert (let ((?v_1 (op e0 e0)) (?v_2 (op e0 e1)) (?v_3 (op e0 e2)) (?v_4 (op e0 e3)) (?v_5 (op e0 e4)) (?v_7 (op e1 e0)) (?v_18 (op e1 e1)) (?v_19 (op e1 e2)) (?v_20 (op e1 e3)) (?v_21 (op e1 e4)) (?v_8 (op e2 e0)) (?v_24 (op e2 e1)) (?v_43 (op e2 e2)) (?v_44 (op e2 e3)) (?v_45 (op e2 e4)) (?v_9 (op e3 e0)) (?v_25 (op e3 e1)) (?v_49 (op e3 e2)) (?v_76 (op e3 e3)) (?v_77 (op e3 e4)) (?v_10 (op e4 e0)) (?v_26 (op e4 e1)) (?v_50 (op e4 e2)) (?v_82 (op e4 e3)) (?v_117 (op e4 e4))) (let ((?v_0 (= ?v_1 e0)) (?v_6 (= ?v_1 e1)) (?v_11 (= ?v_1 e2)) (?v_12 (= ?v_1 e3)) (?v_13 (= ?v_1 e4)) (?v_15 (= ?v_2 e0)) (?v_22 (= ?v_2 e1)) (?v_28 (= ?v_2 e2)) (?v_31 (= ?v_2 e3)) (?v_34 (= ?v_2 e4)) (?v_38 (= ?v_3 e0)) (?v_46 (= ?v_3 e1)) (?v_53 (= ?v_3 e2)) (?v_58 (= ?v_3 e3)) (?v_63 (= ?v_3 e4)) (?v_69 (= ?v_4 e0)) (?v_78 (= ?v_4 e1)) (?v_86 (= ?v_4 e2)) (?v_93 (= ?v_4 e3)) (?v_100 (= ?v_4 e4)) (?v_108 (= ?v_5 e0)) (?v_118 (= ?v_5 e1)) (?v_127 (= ?v_5 e2)) (?v_136 (= ?v_5 e3)) (?v_145 (= ?v_5 e4)) (?v_14 (= ?v_7 e0)) (?v_17 (= ?v_7 e1)) (?v_27 (= ?v_7 e2)) (?v_30 (= ?v_7 e3)) (?v_33 (= ?v_7 e4)) (?v_16 (= ?v_18 e0)) (?v_23 (= ?v_18 e1)) (?v_29 (= ?v_18 e2)) (?v_32 (= ?v_18 e3)) (?v_35 (= ?v_18 e4)) (?v_39 (= ?v_19 e0)) (?v_47 (= ?v_19 e1)) (?v_54 (= ?v_19 e2)) (?v_59 (= ?v_19 e3)) (?v_64 (= ?v_19 e4)) (?v_70 (= ?v_20 e0)) (?v_79 (= ?v_20 e1)) (?v_87 (= ?v_20 e2)) (?v_94 (= ?v_20 e3)) (?v_101 (= ?v_20 e4)) (?v_109 (= ?v_21 e0)) (?v_119 (= ?v_21 e1)) (?v_128 (= ?v_21 e2)) (?v_137 (= ?v_21 e3)) (?v_146 (= ?v_21 e4)) (?v_36 (= ?v_8 e0)) (?v_41 (= ?v_8 e1)) (?v_51 (= ?v_8 e2)) (?v_56 (= ?v_8 e3)) (?v_61 (= ?v_8 e4)) (?v_37 (= ?v_24 e0)) (?v_42 (= ?v_24 e1)) (?v_52 (= ?v_24 e2)) (?v_57 (= ?v_24 e3)) (?v_62 (= ?v_24 e4)) (?v_40 (= ?v_43 e0)) (?v_48 (= ?v_43 e1)) (?v_55 (= ?v_43 e2)) (?v_60 (= ?v_43 e3)) (?v_65 (= ?v_43 e4)) (?v_71 (= ?v_44 e0)) (?v_80 (= ?v_44 e1)) (?v_88 (= ?v_44 e2)) (?v_95 (= ?v_44 e3)) (?v_102 (= ?v_44 e4)) (?v_110 (= ?v_45 e0)) (?v_120 (= ?v_45 e1)) (?v_129 (= ?v_45 e2)) (?v_138 (= ?v_45 e3)) (?v_147 (= ?v_45 e4)) (?v_66 (= ?v_9 e0)) (?v_73 (= ?v_9 e1)) (?v_83 (= ?v_9 e2)) (?v_90 (= ?v_9 e3)) (?v_97 (= ?v_9 e4)) (?v_67 (= ?v_25 e0)) (?v_74 (= ?v_25 e1)) (?v_84 (= ?v_25 e2)) (?v_91 (= ?v_25 e3)) (?v_98 (= ?v_25 e4)) (?v_68 (= ?v_49 e0)) (?v_75 (= ?v_49 e1)) (?v_85 (= ?v_49 e2)) (?v_92 (= ?v_49 e3)) (?v_99 (= ?v_49 e4)) (?v_72 (= ?v_76 e0)) (?v_81 (= ?v_76 e1)) (?v_89 (= ?v_76 e2)) (?v_96 (= ?v_76 e3)) (?v_103 (= ?v_76 e4)) (?v_111 (= ?v_77 e0)) (?v_121 (= ?v_77 e1)) (?v_130 (= ?v_77 e2)) (?v_139 (= ?v_77 e3)) (?v_148 (= ?v_77 e4)) (?v_104 (= ?v_10 e0)) (?v_113 (= ?v_10 e1)) (?v_123 (= ?v_10 e2)) (?v_132 (= ?v_10 e3)) (?v_141 (= ?v_10 e4)) (?v_105 (= ?v_26 e0)) (?v_114 (= ?v_26 e1)) (?v_124 (= ?v_26 e2)) (?v_133 (= ?v_26 e3)) (?v_142 (= ?v_26 e4)) (?v_106 (= ?v_50 e0)) (?v_115 (= ?v_50 e1)) (?v_125 (= ?v_50 e2)) (?v_134 (= ?v_50 e3)) (?v_143 (= ?v_50 e4)) (?v_107 (= ?v_82 e0)) (?v_116 (= ?v_82 e1)) (?v_126 (= ?v_82 e2)) (?v_135 (= ?v_82 e3)) (?v_144 (= ?v_82 e4)) (?v_112 (= ?v_117 e0)) (?v_122 (= ?v_117 e1)) (?v_131 (= ?v_117 e2)) (?v_140 (= ?v_117 e3)) (?v_149 (= ?v_117 e4))) (and (and (and (and (and (and (and (and (and (or (or (or (or ?v_0 ?v_15) ?v_38) ?v_69) ?v_108) (or (or (or (or ?v_0 ?v_14) ?v_36) ?v_66) ?v_104)) (and (or (or (or (or ?v_6 ?v_22) ?v_46) ?v_78) ?v_118) (or (or (or (or ?v_6 ?v_17) ?v_41) ?v_73) ?v_113))) (and (or (or (or (or ?v_11 ?v_28) ?v_53) ?v_86) ?v_127) (or (or (or (or ?v_11 ?v_27) ?v_51) ?v_83) ?v_123))) (and (or (or (or (or ?v_12 ?v_31) ?v_58) ?v_93) ?v_136) (or (or (or (or ?v_12 ?v_30) ?v_56) ?v_90) ?v_132))) (and (or (or (or (or ?v_13 ?v_34) ?v_63) ?v_100) ?v_145) (or (or (or (or ?v_13 ?v_33) ?v_61) ?v_97) ?v_141))) (and (and (and (and (and (or (or (or (or ?v_14 ?v_16) ?v_39) ?v_70) ?v_109) (or (or (or (or ?v_15 ?v_16) ?v_37) ?v_67) ?v_105)) (and (or (or (or (or ?v_17 ?v_23) ?v_47) ?v_79) ?v_119) (or (or (or (or ?v_22 ?v_23) ?v_42) ?v_74) ?v_114))) (and (or (or (or (or ?v_27 ?v_29) ?v_54) ?v_87) ?v_128) (or (or (or (or ?v_28 ?v_29) ?v_52) ?v_84) ?v_124))) (and (or (or (or (or ?v_30 ?v_32) ?v_59) ?v_94) ?v_137) (or (or (or (or ?v_31 ?v_32) ?v_57) ?v_91) ?v_133))) (and (or (or (or (or ?v_33 ?v_35) ?v_64) ?v_101) ?v_146) (or (or (or (or ?v_34 ?v_35) ?v_62) ?v_98) ?v_142)))) (and (and (and (and (and (or (or (or (or ?v_36 ?v_37) ?v_40) ?v_71) ?v_110) (or (or (or (or ?v_38 ?v_39) ?v_40) ?v_68) ?v_106)) (and (or (or (or (or ?v_41 ?v_42) ?v_48) ?v_80) ?v_120) (or (or (or (or ?v_46 ?v_47) ?v_48) ?v_75) ?v_115))) (and (or (or (or (or ?v_51 ?v_52) ?v_55) ?v_88) ?v_129) (or (or (or (or ?v_53 ?v_54) ?v_55) ?v_85) ?v_125))) (and (or (or (or (or ?v_56 ?v_57) ?v_60) ?v_95) ?v_138) (or (or (or (or ?v_58 ?v_59) ?v_60) ?v_92) ?v_134))) (and (or (or (or (or ?v_61 ?v_62) ?v_65) ?v_102) ?v_147) (or (or (or (or ?v_63 ?v_64) ?v_65) ?v_99) ?v_143)))) (and (and (and (and (and (or (or (or (or ?v_66 ?v_67) ?v_68) ?v_72) ?v_111) (or (or (or (or ?v_69 ?v_70) ?v_71) ?v_72) ?v_107)) (and (or (or (or (or ?v_73 ?v_74) ?v_75) ?v_81) ?v_121) (or (or (or (or ?v_78 ?v_79) ?v_80) ?v_81) ?v_116))) (and (or (or (or (or ?v_83 ?v_84) ?v_85) ?v_89) ?v_130) (or (or (or (or ?v_86 ?v_87) ?v_88) ?v_89) ?v_126))) (and (or (or (or (or ?v_90 ?v_91) ?v_92) ?v_96) ?v_139) (or (or (or (or ?v_93 ?v_94) ?v_95) ?v_96) ?v_135))) (and (or (or (or (or ?v_97 ?v_98) ?v_99) ?v_103) ?v_148) (or (or (or (or ?v_100 ?v_101) ?v_102) ?v_103) ?v_144)))) (and (and (and (and (and (or (or (or (or ?v_104 ?v_105) ?v_106) ?v_107) ?v_112) (or (or (or (or ?v_108 ?v_109) ?v_110) ?v_111) ?v_112)) (and (or (or (or (or ?v_113 ?v_114) ?v_115) ?v_116) ?v_122) (or (or (or (or ?v_118 ?v_119) ?v_120) ?v_121) ?v_122))) (and (or (or (or (or ?v_123 ?v_124) ?v_125) ?v_126) ?v_131) (or (or (or (or ?v_127 ?v_128) ?v_129) ?v_130) ?v_131))) (and (or (or (or (or ?v_132 ?v_133) ?v_134) ?v_135) ?v_140) (or (or (or (or ?v_136 ?v_137) ?v_138) ?v_139) ?v_140))) (and (or (or (or (or ?v_141 ?v_142) ?v_143) ?v_144) ?v_149) (or (or (or (or ?v_145 ?v_146) ?v_147) ?v_148) ?v_149))))))) (assert (let ((?v_0 (op e0 e0)) (?v_1 (op e1 e1)) (?v_2 (op e2 e2)) (?v_3 (op e3 e3)) (?v_4 (op e4 e4))) (or (or (or (or (and (and (and (and (not (= ?v_0 e0)) (not (= ?v_1 e0))) (not (= ?v_2 e0))) (not (= ?v_3 e0))) (not (= ?v_4 e0))) (and (and (and (and (not (= ?v_0 e1)) (not (= ?v_1 e1))) (not (= ?v_2 e1))) (not (= ?v_3 e1))) (not (= ?v_4 e1)))) (and (and (and (and (not (= ?v_0 e2)) (not (= ?v_1 e2))) (not (= ?v_2 e2))) (not (= ?v_3 e2))) (not (= ?v_4 e2)))) (and (and (and (and (not (= ?v_0 e3)) (not (= ?v_1 e3))) (not (= ?v_2 e3))) (not (= ?v_3 e3))) (not (= ?v_4 e3)))) (and (and (and (and (not (= ?v_0 e4)) (not (= ?v_1 e4))) (not (= ?v_2 e4))) (not (= ?v_3 e4))) (not (= ?v_4 e4)))))) (assert (let ((?v_25 (op e0 e0)) (?v_27 (op e0 e1)) (?v_29 (op e0 e2)) (?v_31 (op e0 e3)) (?v_33 (op e0 e4)) (?v_28 (op e1 e0)) (?v_37 (op e1 e1)) (?v_39 (op e1 e2)) (?v_41 (op e1 e3)) (?v_43 (op e1 e4)) (?v_30 (op e2 e0)) (?v_40 (op e2 e1)) (?v_49 (op e2 e2)) (?v_51 (op e2 e3)) (?v_53 (op e2 e4)) (?v_32 (op e3 e0)) (?v_42 (op e3 e1)) (?v_52 (op e3 e2)) (?v_61 (op e3 e3)) (?v_63 (op e3 e4)) (?v_34 (op e4 e0)) (?v_44 (op e4 e1)) (?v_54 (op e4 e2)) (?v_64 (op e4 e3)) (?v_73 (op e4 e4))) (let ((?v_0 false) (?v_26 false) (?v_75 false) (?v_100 false) (?v_125 false) (?v_2 false) (?v_36 false) (?v_77 false) (?v_102 false) (?v_127 false) (?v_5 false) (?v_46 false) (?v_80 false) (?v_105 false) (?v_130 false) (?v_10 false) (?v_56 false) (?v_85 false) (?v_110 false) (?v_135 false) (?v_17 false) (?v_66 false) (?v_92 false) (?v_117 false) (?v_142 false) (?v_1 false) (?v_35 false) (?v_76 false) (?v_101 false) (?v_126 false) (?v_3 false) (?v_38 false) (?v_78 false) (?v_103 false) (?v_128 false) (?v_7 false) (?v_48 false) (?v_82 false) (?v_107 false) (?v_132 false) (?v_12 false) (?v_58 false) (?v_87 false) (?v_112 false) (?v_137 false) (?v_19 false) (?v_68 false) (?v_94 false) (?v_119 false) (?v_144 false) (?v_4 false) (?v_45 false) (?v_79 false) (?v_104 false) (?v_129 false) (?v_6 false) (?v_47 false) (?v_81 false) (?v_106 false) (?v_131 false) (?v_8 false) (?v_50 false) (?v_83 false) (?v_108 false) (?v_133 false) (?v_14 false) (?v_60 false) (?v_89 false) (?v_114 false) (?v_139 false) (?v_21 false) (?v_70 false) (?v_96 false) (?v_121 false) (?v_146 false) (?v_9 false) (?v_55 false) (?v_84 false) (?v_109 false) (?v_134 false) (?v_11 false) (?v_57 false) (?v_86 false) (?v_111 false) (?v_136 false) (?v_13 false) (?v_59 false) (?v_88 false) (?v_113 false) (?v_138 false) (?v_15 false) (?v_62 false) (?v_90 false) (?v_115 false) (?v_140 false) (?v_23 false) (?v_72 false) (?v_98 false) (?v_123 false) (?v_148 false) (?v_16 false) (?v_65 false) (?v_91 false) (?v_116 false) (?v_141 false) (?v_18 (= ?v_44 e0)) (?v_67 (= ?v_44 e1)) (?v_93 (= ?v_44 e2)) (?v_118 (= ?v_44 e3)) (?v_143 (= ?v_44 e4)) (?v_20 (= ?v_54 e0)) (?v_69 (= ?v_54 e1)) (?v_95 (= ?v_54 e2)) (?v_120 (= ?v_54 e3)) (?v_145 (= ?v_54 e4)) (?v_22 (= ?v_64 e0)) (?v_71 (= ?v_64 e1)) (?v_97 (= ?v_64 e2)) (?v_122 (= ?v_64 e3)) (?v_147 (= ?v_64 e4)) (?v_24 (= ?v_73 e0)) (?v_74 (= ?v_73 e1)) (?v_99 (= ?v_73 e2)) (?v_124 (= ?v_73 e3)) (?v_149 (= ?v_73 e4))) (and (and (and (and (or (or (or (or (or (or (or (or (and false false) (and false false)) (and false false)) (and false false)) (and false false)) (or (or (or (or (and false false) (and false false)) (and false false)) (and false false)) (and false ?v_18))) (or (or (or (or (and false false) (and false false)) (and false false)) (and false false)) (and false ?v_20))) (or (or (or (or (and false false) (and false false)) (and false false)) (and false false)) (and false ?v_22))) (or (or (or (or (and false false) (and ?v_18 false)) (and ?v_20 false)) (and ?v_22 false)) (and ?v_24 ?v_24))) (or (or (or (or (or (or (or (or (and false false) (and false false)) (and false false)) (and false false)) (and false false)) (or (or (or (or (and false false) (and false false)) (and false false)) (and false false)) (and false ?v_67))) (or (or (or (or (and false false) (and false false)) (and false false)) (and false false)) (and false ?v_69))) (or (or (or (or (and false false) (and false false)) (and false false)) (and false false)) (and false ?v_71))) (or (or (or (or (and false false) (and ?v_67 false)) (and ?v_69 false)) (and ?v_71 false)) (and ?v_74 ?v_74)))) (or (or (or (or (or (or (or (or (and false false) (and false false)) (and false false)) (and false false)) (and false false)) (or (or (or (or (and false false) (and false false)) (and false false)) (and false false)) (and false ?v_93))) (or (or (or (or (and false false) (and false false)) (and false false)) (and false false)) (and false ?v_95))) (or (or (or (or (and false false) (and false false)) (and false false)) (and false false)) (and false ?v_97))) (or (or (or (or (and false false) (and ?v_93 false)) (and ?v_95 false)) (and ?v_97 false)) (and ?v_99 ?v_99)))) (or (or (or (or (or (or (or (or (and false false) (and false false)) (and false false)) (and false false)) (and false false)) (or (or (or (or (and false false) (and false false)) (and false false)) (and false false)) (and false ?v_118))) (or (or (or (or (and false false) (and false false)) (and false false)) (and false false)) (and false ?v_120))) (or (or (or (or (and false false) (and false false)) (and false false)) (and false false)) (and false ?v_122))) (or (or (or (or (and false false) (and ?v_118 false)) (and ?v_120 false)) (and ?v_122 false)) (and ?v_124 ?v_124)))) (or (or (or (or (or (or (or (or (and false false) (and false false)) (and false false)) (and false false)) (and false ?v_141)) (or (or (or (or (and false false) (and false false)) (and false false)) (and false false)) (and false ?v_143))) (or (or (or (or (and false false) (and false false)) (and false false)) (and false false)) (and false ?v_145))) (or (or (or (or (and false false) (and false false)) (and false false)) (and false false)) (and false ?v_147))) (or (or (or (or (and ?v_141 false) (and ?v_143 false)) (and ?v_145 false)) (and ?v_147 false)) (and ?v_149 ?v_149))))))) (assert (let ((?v_10 (op e0 e3)) (?v_17 (op e0 e4)) (?v_7 (op e1 e2)) (?v_12 (op e1 e3)) (?v_19 (op e1 e4)) (?v_14 (op e2 e3)) (?v_21 (op e2 e4)) (?v_9 (op e3 e0)) (?v_11 (op e3 e1)) (?v_13 (op e3 e2)) (?v_23 (op e3 e4)) (?v_18 (op e4 e1)) (?v_22 (op e4 e3)) (?v_15 (= (op e3 e3) e3))) (or (or (or (or (or (or (and (= ?v_9 e3) (= ?v_10 e3)) (and (= ?v_11 e3) (= ?v_12 e3))) (and (= ?v_13 e3) (= ?v_14 e3))) ?v_15) (and (= ?v_23 e3) (= ?v_22 e3)))) (or (or (or (or (and (= ?v_18 e4) (= ?v_19 e4)))) (and (= ?v_22 e4) (= ?v_23 e4))))))) (assert (and (= e0 (op e4 e4)) (= e1 (op e0 e0)) (= e2 (op e3 e3)) (= e4 (op e2 e2)) (not (= (op e1 e4) (op e4 e1))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/looping.smt2.expected.err000066400000000000000000000000001445011647600231300ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/looping.smt2.expected.out000066400000000000000000000000061445011647600231550ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UF/looping.smt2.expected.time000066400000000000000000000000351445011647600233060ustar00rootroot00000000000000real 0.01 user 0.01 sys 0.00 opensmt-2.5.2/regression/QF_UF/looping2.smt2000066400000000000000000000006301445011647600206340ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort U 0) (declare-fun a1 () U) (declare-fun b1 () U) (declare-fun c1 () U) (declare-fun a2 () U) (declare-fun b2 () U) (declare-fun c2 () U) (declare-fun start () U) (declare-fun f (U) U) (declare-fun g (U) U) (declare-fun h (U U) U) (assert (and (= a1 (f b1)) (= b1 (f c1)) (= c1 (f a1)) (= a2 (g b2)) (= b2 (g c2)) (= c2 (g a2)) (= start (h b1 a2)) )) (check-sat) opensmt-2.5.2/regression/QF_UF/looping2.smt2.expected.err000066400000000000000000000000001445011647600232120ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/looping2.smt2.expected.out000066400000000000000000000000041445011647600232350ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/looping2.smt2.expected.time000066400000000000000000000000351445011647600233700ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_UF/looping3.smt2000066400000000000000000000006751445011647600206460ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort U 0) (declare-fun a1 () U) (declare-fun b1 () U) (declare-fun c1 () U) (declare-fun a2 () U) (declare-fun b2 () U) (declare-fun c2 () U) (declare-fun start () U) (declare-fun f (U) U) (declare-fun g (U) U) (declare-fun h (U U) U) (declare-fun h2 (U U U) U) (assert (and (= a1 (f b1)) (= b1 (h c1 c2)) (= c1 (f a1)) (= a2 (g b2)) (= b2 (g c2)) (= c2 (h2 a1 b1 a2)) (= start (h b1 a2)) )) (check-sat) opensmt-2.5.2/regression/QF_UF/looping3.smt2.expected.err000066400000000000000000000000001445011647600232130ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/looping3.smt2.expected.out000066400000000000000000000000041445011647600232360ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/looping3.smt2.expected.time000066400000000000000000000000351445011647600233710ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_UF/mixed_uf_bool1.smt2000066400000000000000000000003541445011647600220020ustar00rootroot00000000000000(set-logic QF_UF) (declare-fun c () Bool) (declare-fun d () Bool) (declare-sort U 0) (declare-fun f (Bool) U) (assert (not (= (f (not (and (or c d) (or c (not d)) (or (not c) d) (or (not c) (not d))))) (f true)))) (check-sat) opensmt-2.5.2/regression/QF_UF/mixed_uf_bool1.smt2.expected.err000066400000000000000000000000001445011647600243550ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/mixed_uf_bool1.smt2.expected.out000066400000000000000000000000061445011647600244020ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UF/mixed_uf_bool2.smt2000066400000000000000000000003501445011647600217770ustar00rootroot00000000000000(set-logic QF_UF) (declare-fun c () Bool) (declare-fun d () Bool) (declare-sort U 0) (declare-fun f (Bool) U) (assert (not (= (f (and (or c d) (or c (not d)) (or (not c) d) (or (not c) (not d)))) (f false)))) (check-sat) opensmt-2.5.2/regression/QF_UF/mixed_uf_bool2.smt2.expected.err000066400000000000000000000000001445011647600243560ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/mixed_uf_bool2.smt2.expected.out000066400000000000000000000000061445011647600244030ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UF/mixed_uf_bool3.smt2000066400000000000000000000003361445011647600220040ustar00rootroot00000000000000(set-logic QF_UF) (declare-fun c () Bool) (declare-fun d () Bool) (declare-sort U 0) (declare-fun f (Bool) U) (assert (not (= (f (and (or c (not d)) (or (not c) d) (or (not c) (not d)))) (f false)))) (check-sat) opensmt-2.5.2/regression/QF_UF/mixed_uf_bool3.smt2.expected.err000066400000000000000000000000001445011647600243570ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/mixed_uf_bool3.smt2.expected.out000066400000000000000000000000041445011647600244020ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/mixed_uf_bool4.smt2000066400000000000000000000002761445011647600220100ustar00rootroot00000000000000(set-logic QF_UF) (set-info :status unsat) (declare-sort U 0) (declare-fun b () U) (declare-fun f (Bool) U) (assert (= b (f (not (= b (f true)))))) (assert (not (= b (f true)))) (check-sat) opensmt-2.5.2/regression/QF_UF/mixed_uf_bool4.smt2.expected.err000066400000000000000000000000001445011647600243600ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/mixed_uf_bool4.smt2.expected.out000066400000000000000000000000061445011647600244050ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UF/negated_distinct_sat.smt2000066400000000000000000000003051445011647600232610ustar00rootroot00000000000000(set-logic QF_UF) (set-info :status sat) (declare-sort U 0) (declare-fun a () U) (declare-fun b () U) (declare-fun c () U) (assert (not (distinct a b c))) (assert (not (= a b))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/negated_distinct_sat.smt2.expected.err000066400000000000000000000000001445011647600256400ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/negated_distinct_sat.smt2.expected.out000066400000000000000000000000041445011647600256630ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/negated_distinct_unsat.smt2000066400000000000000000000003651445011647600236320ustar00rootroot00000000000000(set-logic QF_UF) (set-info :status unsat) (declare-sort U 0) (declare-fun a () U) (declare-fun b () U) (declare-fun c () U) (assert (not (distinct a b c))) (assert (not (= a b))) (assert (not (= a c))) (assert (not (= b c))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/negated_distinct_unsat.smt2.expected.err000066400000000000000000000000001445011647600262030ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/negated_distinct_unsat.smt2.expected.out000066400000000000000000000000061445011647600262300ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UF/php_3_3_40_sat.smt2000066400000000000000000002125251445011647600215200ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort U 0) (declare-fun x_0_0 () Bool) (declare-fun x_0_1 () Bool) (declare-fun x_0_2 () Bool) (declare-fun x_1_0 () Bool) (declare-fun x_1_1 () Bool) (declare-fun x_1_2 () Bool) (declare-fun x_2_0 () Bool) (declare-fun x_2_1 () Bool) (declare-fun x_2_2 () Bool) (declare-fun x_3_0 () Bool) (declare-fun x_3_1 () Bool) (declare-fun x_3_2 () Bool) (declare-fun x_4_0 () Bool) (declare-fun x_4_1 () Bool) (declare-fun x_4_2 () Bool) (declare-fun x_5_0 () Bool) (declare-fun x_5_1 () Bool) (declare-fun x_5_2 () Bool) (declare-fun x_6_0 () Bool) (declare-fun x_6_1 () Bool) (declare-fun x_6_2 () Bool) (declare-fun x_7_0 () Bool) (declare-fun x_7_1 () Bool) (declare-fun x_7_2 () Bool) (declare-fun x_8_0 () Bool) (declare-fun x_8_1 () Bool) (declare-fun x_8_2 () Bool) (declare-fun x_9_0 () Bool) (declare-fun x_9_1 () Bool) (declare-fun x_9_2 () Bool) (declare-fun x_10_0 () Bool) (declare-fun x_10_1 () Bool) (declare-fun x_10_2 () Bool) (declare-fun x_11_0 () Bool) (declare-fun x_11_1 () Bool) (declare-fun x_11_2 () Bool) (declare-fun x_12_0 () Bool) (declare-fun x_12_1 () Bool) (declare-fun x_12_2 () Bool) (declare-fun x_13_0 () Bool) (declare-fun x_13_1 () Bool) (declare-fun x_13_2 () Bool) (declare-fun x_14_0 () Bool) (declare-fun x_14_1 () Bool) (declare-fun x_14_2 () Bool) (declare-fun x_15_0 () Bool) (declare-fun x_15_1 () Bool) (declare-fun x_15_2 () Bool) (declare-fun x_16_0 () Bool) (declare-fun x_16_1 () Bool) (declare-fun x_16_2 () Bool) (declare-fun x_17_0 () Bool) (declare-fun x_17_1 () Bool) (declare-fun x_17_2 () Bool) (declare-fun x_18_0 () Bool) (declare-fun x_18_1 () Bool) (declare-fun x_18_2 () Bool) (declare-fun x_19_0 () Bool) (declare-fun x_19_1 () Bool) (declare-fun x_19_2 () Bool) (declare-fun x_20_0 () Bool) (declare-fun x_20_1 () Bool) (declare-fun x_20_2 () Bool) (declare-fun x_21_0 () Bool) (declare-fun x_21_1 () Bool) (declare-fun x_21_2 () Bool) (declare-fun x_22_0 () Bool) (declare-fun x_22_1 () Bool) (declare-fun x_22_2 () Bool) (declare-fun x_23_0 () Bool) (declare-fun x_23_1 () Bool) (declare-fun x_23_2 () Bool) (declare-fun x_24_0 () Bool) (declare-fun x_24_1 () Bool) (declare-fun x_24_2 () Bool) (declare-fun x_25_0 () Bool) (declare-fun x_25_1 () Bool) (declare-fun x_25_2 () Bool) (declare-fun x_26_0 () Bool) (declare-fun x_26_1 () Bool) (declare-fun x_26_2 () Bool) (declare-fun x_27_0 () Bool) (declare-fun x_27_1 () Bool) (declare-fun x_27_2 () Bool) (declare-fun x_28_0 () Bool) (declare-fun x_28_1 () Bool) (declare-fun x_28_2 () Bool) (declare-fun x_29_0 () Bool) (declare-fun x_29_1 () Bool) (declare-fun x_29_2 () Bool) (declare-fun x_30_0 () Bool) (declare-fun x_30_1 () Bool) (declare-fun x_30_2 () Bool) (declare-fun x_31_0 () Bool) (declare-fun x_31_1 () Bool) (declare-fun x_31_2 () Bool) (declare-fun x_32_0 () Bool) (declare-fun x_32_1 () Bool) (declare-fun x_32_2 () Bool) (declare-fun x_33_0 () Bool) (declare-fun x_33_1 () Bool) (declare-fun x_33_2 () Bool) (declare-fun x_34_0 () Bool) (declare-fun x_34_1 () Bool) (declare-fun x_34_2 () Bool) (declare-fun x_35_0 () Bool) (declare-fun x_35_1 () Bool) (declare-fun x_35_2 () Bool) (declare-fun x_36_0 () Bool) (declare-fun x_36_1 () Bool) (declare-fun x_36_2 () Bool) (declare-fun x_37_0 () Bool) (declare-fun x_37_1 () Bool) (declare-fun x_37_2 () Bool) (declare-fun x_38_0 () Bool) (declare-fun x_38_1 () Bool) (declare-fun x_38_2 () Bool) (declare-fun x_39_0 () Bool) (declare-fun x_39_1 () Bool) (declare-fun x_39_2 () Bool) (declare-fun a_0_0 () U) (declare-fun a_0_1 () U) (declare-fun a_0_2 () U) (declare-fun a_0_3 () U) (declare-fun a_0_4 () U) (declare-fun a_0_5 () U) (declare-fun a_0_6 () U) (declare-fun a_0_7 () U) (declare-fun a_0_8 () U) (declare-fun a_0_9 () U) (declare-fun a_0_10 () U) (declare-fun a_0_11 () U) (declare-fun a_0_12 () U) (declare-fun a_0_13 () U) (declare-fun a_0_14 () U) (declare-fun a_0_15 () U) (declare-fun a_0_16 () U) (declare-fun a_0_17 () U) (declare-fun a_0_18 () U) (declare-fun a_0_19 () U) (declare-fun a_0_20 () U) (declare-fun a_0_21 () U) (declare-fun a_0_22 () U) (declare-fun a_0_23 () U) (declare-fun a_0_24 () U) (declare-fun a_0_25 () U) (declare-fun a_0_26 () U) (declare-fun a_0_27 () U) (declare-fun a_0_28 () U) (declare-fun a_0_29 () U) (declare-fun a_0_30 () U) (declare-fun a_0_31 () U) (declare-fun a_0_32 () U) (declare-fun a_0_33 () U) (declare-fun a_0_34 () U) (declare-fun a_0_35 () U) (declare-fun a_0_36 () U) (declare-fun a_0_37 () U) (declare-fun a_0_38 () U) (declare-fun a_0_39 () U) (declare-fun a_1_0 () U) (declare-fun a_1_1 () U) (declare-fun a_1_2 () U) (declare-fun a_1_3 () U) (declare-fun a_1_4 () U) (declare-fun a_1_5 () U) (declare-fun a_1_6 () U) (declare-fun a_1_7 () U) (declare-fun a_1_8 () U) (declare-fun a_1_9 () U) (declare-fun a_1_10 () U) (declare-fun a_1_11 () U) (declare-fun a_1_12 () U) (declare-fun a_1_13 () U) (declare-fun a_1_14 () U) (declare-fun a_1_15 () U) (declare-fun a_1_16 () U) (declare-fun a_1_17 () U) (declare-fun a_1_18 () U) (declare-fun a_1_19 () U) (declare-fun a_1_20 () U) (declare-fun a_1_21 () U) (declare-fun a_1_22 () U) (declare-fun a_1_23 () U) (declare-fun a_1_24 () U) (declare-fun a_1_25 () U) (declare-fun a_1_26 () U) (declare-fun a_1_27 () U) (declare-fun a_1_28 () U) (declare-fun a_1_29 () U) (declare-fun a_1_30 () U) (declare-fun a_1_31 () U) (declare-fun a_1_32 () U) (declare-fun a_1_33 () U) (declare-fun a_1_34 () U) (declare-fun a_1_35 () U) (declare-fun a_1_36 () U) (declare-fun a_1_37 () U) (declare-fun a_1_38 () U) (declare-fun a_1_39 () U) (declare-fun a_2_0 () U) (declare-fun a_2_1 () U) (declare-fun a_2_2 () U) (declare-fun a_2_3 () U) (declare-fun a_2_4 () U) (declare-fun a_2_5 () U) (declare-fun a_2_6 () U) (declare-fun a_2_7 () U) (declare-fun a_2_8 () U) (declare-fun a_2_9 () U) (declare-fun a_2_10 () U) (declare-fun a_2_11 () U) (declare-fun a_2_12 () U) (declare-fun a_2_13 () U) (declare-fun a_2_14 () U) (declare-fun a_2_15 () U) (declare-fun a_2_16 () U) (declare-fun a_2_17 () U) (declare-fun a_2_18 () U) (declare-fun a_2_19 () U) (declare-fun a_2_20 () U) (declare-fun a_2_21 () U) (declare-fun a_2_22 () U) (declare-fun a_2_23 () U) (declare-fun a_2_24 () U) (declare-fun a_2_25 () U) (declare-fun a_2_26 () U) (declare-fun a_2_27 () U) (declare-fun a_2_28 () U) (declare-fun a_2_29 () U) (declare-fun a_2_30 () U) (declare-fun a_2_31 () U) (declare-fun a_2_32 () U) (declare-fun a_2_33 () U) (declare-fun a_2_34 () U) (declare-fun a_2_35 () U) (declare-fun a_2_36 () U) (declare-fun a_2_37 () U) (declare-fun a_2_38 () U) (declare-fun a_2_39 () U) (declare-fun a_3_0 () U) (declare-fun a_3_1 () U) (declare-fun a_3_2 () U) (declare-fun a_3_3 () U) (declare-fun a_3_4 () U) (declare-fun a_3_5 () U) (declare-fun a_3_6 () U) (declare-fun a_3_7 () U) (declare-fun a_3_8 () U) (declare-fun a_3_9 () U) (declare-fun a_3_10 () U) (declare-fun a_3_11 () U) (declare-fun a_3_12 () U) (declare-fun a_3_13 () U) (declare-fun a_3_14 () U) (declare-fun a_3_15 () U) (declare-fun a_3_16 () U) (declare-fun a_3_17 () U) (declare-fun a_3_18 () U) (declare-fun a_3_19 () U) (declare-fun a_3_20 () U) (declare-fun a_3_21 () U) (declare-fun a_3_22 () U) (declare-fun a_3_23 () U) (declare-fun a_3_24 () U) (declare-fun a_3_25 () U) (declare-fun a_3_26 () U) (declare-fun a_3_27 () U) (declare-fun a_3_28 () U) (declare-fun a_3_29 () U) (declare-fun a_3_30 () U) (declare-fun a_3_31 () U) (declare-fun a_3_32 () U) (declare-fun a_3_33 () U) (declare-fun a_3_34 () U) (declare-fun a_3_35 () U) (declare-fun a_3_36 () U) (declare-fun a_3_37 () U) (declare-fun a_3_38 () U) (declare-fun a_3_39 () U) (declare-fun a_4_0 () U) (declare-fun a_4_1 () U) (declare-fun a_4_2 () U) (declare-fun a_4_3 () U) (declare-fun a_4_4 () U) (declare-fun a_4_5 () U) (declare-fun a_4_6 () U) (declare-fun a_4_7 () U) (declare-fun a_4_8 () U) (declare-fun a_4_9 () U) (declare-fun a_4_10 () U) (declare-fun a_4_11 () U) (declare-fun a_4_12 () U) (declare-fun a_4_13 () U) (declare-fun a_4_14 () U) (declare-fun a_4_15 () U) (declare-fun a_4_16 () U) (declare-fun a_4_17 () U) (declare-fun a_4_18 () U) (declare-fun a_4_19 () U) (declare-fun a_4_20 () U) (declare-fun a_4_21 () U) (declare-fun a_4_22 () U) (declare-fun a_4_23 () U) (declare-fun a_4_24 () U) (declare-fun a_4_25 () U) (declare-fun a_4_26 () U) (declare-fun a_4_27 () U) (declare-fun a_4_28 () U) (declare-fun a_4_29 () U) (declare-fun a_4_30 () U) (declare-fun a_4_31 () U) (declare-fun a_4_32 () U) (declare-fun a_4_33 () U) (declare-fun a_4_34 () U) (declare-fun a_4_35 () U) (declare-fun a_4_36 () U) (declare-fun a_4_37 () U) (declare-fun a_4_38 () U) (declare-fun a_4_39 () U) (declare-fun a_5_0 () U) (declare-fun a_5_1 () U) (declare-fun a_5_2 () U) (declare-fun a_5_3 () U) (declare-fun a_5_4 () U) (declare-fun a_5_5 () U) (declare-fun a_5_6 () U) (declare-fun a_5_7 () U) (declare-fun a_5_8 () U) (declare-fun a_5_9 () U) (declare-fun a_5_10 () U) (declare-fun a_5_11 () U) (declare-fun a_5_12 () U) (declare-fun a_5_13 () U) (declare-fun a_5_14 () U) (declare-fun a_5_15 () U) (declare-fun a_5_16 () U) (declare-fun a_5_17 () U) (declare-fun a_5_18 () U) (declare-fun a_5_19 () U) (declare-fun a_5_20 () U) (declare-fun a_5_21 () U) (declare-fun a_5_22 () U) (declare-fun a_5_23 () U) (declare-fun a_5_24 () U) (declare-fun a_5_25 () U) (declare-fun a_5_26 () U) (declare-fun a_5_27 () U) (declare-fun a_5_28 () U) (declare-fun a_5_29 () U) (declare-fun a_5_30 () U) (declare-fun a_5_31 () U) (declare-fun a_5_32 () U) (declare-fun a_5_33 () U) (declare-fun a_5_34 () U) (declare-fun a_5_35 () U) (declare-fun a_5_36 () U) (declare-fun a_5_37 () U) (declare-fun a_5_38 () U) (declare-fun a_5_39 () U) (declare-fun a_6_0 () U) (declare-fun a_6_1 () U) (declare-fun a_6_2 () U) (declare-fun a_6_3 () U) (declare-fun a_6_4 () U) (declare-fun a_6_5 () U) (declare-fun a_6_6 () U) (declare-fun a_6_7 () U) (declare-fun a_6_8 () U) (declare-fun a_6_9 () U) (declare-fun a_6_10 () U) (declare-fun a_6_11 () U) (declare-fun a_6_12 () U) (declare-fun a_6_13 () U) (declare-fun a_6_14 () U) (declare-fun a_6_15 () U) (declare-fun a_6_16 () U) (declare-fun a_6_17 () U) (declare-fun a_6_18 () U) (declare-fun a_6_19 () U) (declare-fun a_6_20 () U) (declare-fun a_6_21 () U) (declare-fun a_6_22 () U) (declare-fun a_6_23 () U) (declare-fun a_6_24 () U) (declare-fun a_6_25 () U) (declare-fun a_6_26 () U) (declare-fun a_6_27 () U) (declare-fun a_6_28 () U) (declare-fun a_6_29 () U) (declare-fun a_6_30 () U) (declare-fun a_6_31 () U) (declare-fun a_6_32 () U) (declare-fun a_6_33 () U) (declare-fun a_6_34 () U) (declare-fun a_6_35 () U) (declare-fun a_6_36 () U) (declare-fun a_6_37 () U) (declare-fun a_6_38 () U) (declare-fun a_6_39 () U) (declare-fun a_7_0 () U) (declare-fun a_7_1 () U) (declare-fun a_7_2 () U) (declare-fun a_7_3 () U) (declare-fun a_7_4 () U) (declare-fun a_7_5 () U) (declare-fun a_7_6 () U) (declare-fun a_7_7 () U) (declare-fun a_7_8 () U) (declare-fun a_7_9 () U) (declare-fun a_7_10 () U) (declare-fun a_7_11 () U) (declare-fun a_7_12 () U) (declare-fun a_7_13 () U) (declare-fun a_7_14 () U) (declare-fun a_7_15 () U) (declare-fun a_7_16 () U) (declare-fun a_7_17 () U) (declare-fun a_7_18 () U) (declare-fun a_7_19 () U) (declare-fun a_7_20 () U) (declare-fun a_7_21 () U) (declare-fun a_7_22 () U) (declare-fun a_7_23 () U) (declare-fun a_7_24 () U) (declare-fun a_7_25 () U) (declare-fun a_7_26 () U) (declare-fun a_7_27 () U) (declare-fun a_7_28 () U) (declare-fun a_7_29 () U) (declare-fun a_7_30 () U) (declare-fun a_7_31 () U) (declare-fun a_7_32 () U) (declare-fun a_7_33 () U) (declare-fun a_7_34 () U) (declare-fun a_7_35 () U) (declare-fun a_7_36 () U) (declare-fun a_7_37 () U) (declare-fun a_7_38 () U) (declare-fun a_7_39 () U) (declare-fun a_8_0 () U) (declare-fun a_8_1 () U) (declare-fun a_8_2 () U) (declare-fun a_8_3 () U) (declare-fun a_8_4 () U) (declare-fun a_8_5 () U) (declare-fun a_8_6 () U) (declare-fun a_8_7 () U) (declare-fun a_8_8 () U) (declare-fun a_8_9 () U) (declare-fun a_8_10 () U) (declare-fun a_8_11 () U) (declare-fun a_8_12 () U) (declare-fun a_8_13 () U) (declare-fun a_8_14 () U) (declare-fun a_8_15 () U) (declare-fun a_8_16 () U) (declare-fun a_8_17 () U) (declare-fun a_8_18 () U) (declare-fun a_8_19 () U) (declare-fun a_8_20 () U) (declare-fun a_8_21 () U) (declare-fun a_8_22 () U) (declare-fun a_8_23 () U) (declare-fun a_8_24 () U) (declare-fun a_8_25 () U) (declare-fun a_8_26 () U) (declare-fun a_8_27 () U) (declare-fun a_8_28 () U) (declare-fun a_8_29 () U) (declare-fun a_8_30 () U) (declare-fun a_8_31 () U) (declare-fun a_8_32 () U) (declare-fun a_8_33 () U) (declare-fun a_8_34 () U) (declare-fun a_8_35 () U) (declare-fun a_8_36 () U) (declare-fun a_8_37 () U) (declare-fun a_8_38 () U) (declare-fun a_8_39 () U) (declare-fun a_9_0 () U) (declare-fun a_9_1 () U) (declare-fun a_9_2 () U) (declare-fun a_9_3 () U) (declare-fun a_9_4 () U) (declare-fun a_9_5 () U) (declare-fun a_9_6 () U) (declare-fun a_9_7 () U) (declare-fun a_9_8 () U) (declare-fun a_9_9 () U) (declare-fun a_9_10 () U) (declare-fun a_9_11 () U) (declare-fun a_9_12 () U) (declare-fun a_9_13 () U) (declare-fun a_9_14 () U) (declare-fun a_9_15 () U) (declare-fun a_9_16 () U) (declare-fun a_9_17 () U) (declare-fun a_9_18 () U) (declare-fun a_9_19 () U) (declare-fun a_9_20 () U) (declare-fun a_9_21 () U) (declare-fun a_9_22 () U) (declare-fun a_9_23 () U) (declare-fun a_9_24 () U) (declare-fun a_9_25 () U) (declare-fun a_9_26 () U) (declare-fun a_9_27 () U) (declare-fun a_9_28 () U) (declare-fun a_9_29 () U) (declare-fun a_9_30 () U) (declare-fun a_9_31 () U) (declare-fun a_9_32 () U) (declare-fun a_9_33 () U) (declare-fun a_9_34 () U) (declare-fun a_9_35 () U) (declare-fun a_9_36 () U) (declare-fun a_9_37 () U) (declare-fun a_9_38 () U) (declare-fun a_9_39 () U) (declare-fun a_10_0 () U) (declare-fun a_10_1 () U) (declare-fun a_10_2 () U) (declare-fun a_10_3 () U) (declare-fun a_10_4 () U) (declare-fun a_10_5 () U) (declare-fun a_10_6 () U) (declare-fun a_10_7 () U) (declare-fun a_10_8 () U) (declare-fun a_10_9 () U) (declare-fun a_10_10 () U) (declare-fun a_10_11 () U) (declare-fun a_10_12 () U) (declare-fun a_10_13 () U) (declare-fun a_10_14 () U) (declare-fun a_10_15 () U) (declare-fun a_10_16 () U) (declare-fun a_10_17 () U) (declare-fun a_10_18 () U) (declare-fun a_10_19 () U) (declare-fun a_10_20 () U) (declare-fun a_10_21 () U) (declare-fun a_10_22 () U) (declare-fun a_10_23 () U) (declare-fun a_10_24 () U) (declare-fun a_10_25 () U) (declare-fun a_10_26 () U) (declare-fun a_10_27 () U) (declare-fun a_10_28 () U) (declare-fun a_10_29 () U) (declare-fun a_10_30 () U) (declare-fun a_10_31 () U) (declare-fun a_10_32 () U) (declare-fun a_10_33 () U) (declare-fun a_10_34 () U) (declare-fun a_10_35 () U) (declare-fun a_10_36 () U) (declare-fun a_10_37 () U) (declare-fun a_10_38 () U) (declare-fun a_10_39 () U) (declare-fun a_11_0 () U) (declare-fun a_11_1 () U) (declare-fun a_11_2 () U) (declare-fun a_11_3 () U) (declare-fun a_11_4 () U) (declare-fun a_11_5 () U) (declare-fun a_11_6 () U) (declare-fun a_11_7 () U) (declare-fun a_11_8 () U) (declare-fun a_11_9 () U) (declare-fun a_11_10 () U) (declare-fun a_11_11 () U) (declare-fun a_11_12 () U) (declare-fun a_11_13 () U) (declare-fun a_11_14 () U) (declare-fun a_11_15 () U) (declare-fun a_11_16 () U) (declare-fun a_11_17 () U) (declare-fun a_11_18 () U) (declare-fun a_11_19 () U) (declare-fun a_11_20 () U) (declare-fun a_11_21 () U) (declare-fun a_11_22 () U) (declare-fun a_11_23 () U) (declare-fun a_11_24 () U) (declare-fun a_11_25 () U) (declare-fun a_11_26 () U) (declare-fun a_11_27 () U) (declare-fun a_11_28 () U) (declare-fun a_11_29 () U) (declare-fun a_11_30 () U) (declare-fun a_11_31 () U) (declare-fun a_11_32 () U) (declare-fun a_11_33 () U) (declare-fun a_11_34 () U) (declare-fun a_11_35 () U) (declare-fun a_11_36 () U) (declare-fun a_11_37 () U) (declare-fun a_11_38 () U) (declare-fun a_11_39 () U) (declare-fun a_12_0 () U) (declare-fun a_12_1 () U) (declare-fun a_12_2 () U) (declare-fun a_12_3 () U) (declare-fun a_12_4 () U) (declare-fun a_12_5 () U) (declare-fun a_12_6 () U) (declare-fun a_12_7 () U) (declare-fun a_12_8 () U) (declare-fun a_12_9 () U) (declare-fun a_12_10 () U) (declare-fun a_12_11 () U) (declare-fun a_12_12 () U) (declare-fun a_12_13 () U) (declare-fun a_12_14 () U) (declare-fun a_12_15 () U) (declare-fun a_12_16 () U) (declare-fun a_12_17 () U) (declare-fun a_12_18 () U) (declare-fun a_12_19 () U) (declare-fun a_12_20 () U) (declare-fun a_12_21 () U) (declare-fun a_12_22 () U) (declare-fun a_12_23 () U) (declare-fun a_12_24 () U) (declare-fun a_12_25 () U) (declare-fun a_12_26 () U) (declare-fun a_12_27 () U) (declare-fun a_12_28 () U) (declare-fun a_12_29 () U) (declare-fun a_12_30 () U) (declare-fun a_12_31 () U) (declare-fun a_12_32 () U) (declare-fun a_12_33 () U) (declare-fun a_12_34 () U) (declare-fun a_12_35 () U) (declare-fun a_12_36 () U) (declare-fun a_12_37 () U) (declare-fun a_12_38 () U) (declare-fun a_12_39 () U) (declare-fun a_13_0 () U) (declare-fun a_13_1 () U) (declare-fun a_13_2 () U) (declare-fun a_13_3 () U) (declare-fun a_13_4 () U) (declare-fun a_13_5 () U) (declare-fun a_13_6 () U) (declare-fun a_13_7 () U) (declare-fun a_13_8 () U) (declare-fun a_13_9 () U) (declare-fun a_13_10 () U) (declare-fun a_13_11 () U) (declare-fun a_13_12 () U) (declare-fun a_13_13 () U) (declare-fun a_13_14 () U) (declare-fun a_13_15 () U) (declare-fun a_13_16 () U) (declare-fun a_13_17 () U) (declare-fun a_13_18 () U) (declare-fun a_13_19 () U) (declare-fun a_13_20 () U) (declare-fun a_13_21 () U) (declare-fun a_13_22 () U) (declare-fun a_13_23 () U) (declare-fun a_13_24 () U) (declare-fun a_13_25 () U) (declare-fun a_13_26 () U) (declare-fun a_13_27 () U) (declare-fun a_13_28 () U) (declare-fun a_13_29 () U) (declare-fun a_13_30 () U) (declare-fun a_13_31 () U) (declare-fun a_13_32 () U) (declare-fun a_13_33 () U) (declare-fun a_13_34 () U) (declare-fun a_13_35 () U) (declare-fun a_13_36 () U) (declare-fun a_13_37 () U) (declare-fun a_13_38 () U) (declare-fun a_13_39 () U) (declare-fun a_14_0 () U) (declare-fun a_14_1 () U) (declare-fun a_14_2 () U) (declare-fun a_14_3 () U) (declare-fun a_14_4 () U) (declare-fun a_14_5 () U) (declare-fun a_14_6 () U) (declare-fun a_14_7 () U) (declare-fun a_14_8 () U) (declare-fun a_14_9 () U) (declare-fun a_14_10 () U) (declare-fun a_14_11 () U) (declare-fun a_14_12 () U) (declare-fun a_14_13 () U) (declare-fun a_14_14 () U) (declare-fun a_14_15 () U) (declare-fun a_14_16 () U) (declare-fun a_14_17 () U) (declare-fun a_14_18 () U) (declare-fun a_14_19 () U) (declare-fun a_14_20 () U) (declare-fun a_14_21 () U) (declare-fun a_14_22 () U) (declare-fun a_14_23 () U) (declare-fun a_14_24 () U) (declare-fun a_14_25 () U) (declare-fun a_14_26 () U) (declare-fun a_14_27 () U) (declare-fun a_14_28 () U) (declare-fun a_14_29 () U) (declare-fun a_14_30 () U) (declare-fun a_14_31 () U) (declare-fun a_14_32 () U) (declare-fun a_14_33 () U) (declare-fun a_14_34 () U) (declare-fun a_14_35 () U) (declare-fun a_14_36 () U) (declare-fun a_14_37 () U) (declare-fun a_14_38 () U) (declare-fun a_14_39 () U) (declare-fun a_15_0 () U) (declare-fun a_15_1 () U) (declare-fun a_15_2 () U) (declare-fun a_15_3 () U) (declare-fun a_15_4 () U) (declare-fun a_15_5 () U) (declare-fun a_15_6 () U) (declare-fun a_15_7 () U) (declare-fun a_15_8 () U) (declare-fun a_15_9 () U) (declare-fun a_15_10 () U) (declare-fun a_15_11 () U) (declare-fun a_15_12 () U) (declare-fun a_15_13 () U) (declare-fun a_15_14 () U) (declare-fun a_15_15 () U) (declare-fun a_15_16 () U) (declare-fun a_15_17 () U) (declare-fun a_15_18 () U) (declare-fun a_15_19 () U) (declare-fun a_15_20 () U) (declare-fun a_15_21 () U) (declare-fun a_15_22 () U) (declare-fun a_15_23 () U) (declare-fun a_15_24 () U) (declare-fun a_15_25 () U) (declare-fun a_15_26 () U) (declare-fun a_15_27 () U) (declare-fun a_15_28 () U) (declare-fun a_15_29 () U) (declare-fun a_15_30 () U) (declare-fun a_15_31 () U) (declare-fun a_15_32 () U) (declare-fun a_15_33 () U) (declare-fun a_15_34 () U) (declare-fun a_15_35 () U) (declare-fun a_15_36 () U) (declare-fun a_15_37 () U) (declare-fun a_15_38 () U) (declare-fun a_15_39 () U) (declare-fun a_16_0 () U) (declare-fun a_16_1 () U) (declare-fun a_16_2 () U) (declare-fun a_16_3 () U) (declare-fun a_16_4 () U) (declare-fun a_16_5 () U) (declare-fun a_16_6 () U) (declare-fun a_16_7 () U) (declare-fun a_16_8 () U) (declare-fun a_16_9 () U) (declare-fun a_16_10 () U) (declare-fun a_16_11 () U) (declare-fun a_16_12 () U) (declare-fun a_16_13 () U) (declare-fun a_16_14 () U) (declare-fun a_16_15 () U) (declare-fun a_16_16 () U) (declare-fun a_16_17 () U) (declare-fun a_16_18 () U) (declare-fun a_16_19 () U) (declare-fun a_16_20 () U) (declare-fun a_16_21 () U) (declare-fun a_16_22 () U) (declare-fun a_16_23 () U) (declare-fun a_16_24 () U) (declare-fun a_16_25 () U) (declare-fun a_16_26 () U) (declare-fun a_16_27 () U) (declare-fun a_16_28 () U) (declare-fun a_16_29 () U) (declare-fun a_16_30 () U) (declare-fun a_16_31 () U) (declare-fun a_16_32 () U) (declare-fun a_16_33 () U) (declare-fun a_16_34 () U) (declare-fun a_16_35 () U) (declare-fun a_16_36 () U) (declare-fun a_16_37 () U) (declare-fun a_16_38 () U) (declare-fun a_16_39 () U) (declare-fun a_17_0 () U) (declare-fun a_17_1 () U) (declare-fun a_17_2 () U) (declare-fun a_17_3 () U) (declare-fun a_17_4 () U) (declare-fun a_17_5 () U) (declare-fun a_17_6 () U) (declare-fun a_17_7 () U) (declare-fun a_17_8 () U) (declare-fun a_17_9 () U) (declare-fun a_17_10 () U) (declare-fun a_17_11 () U) (declare-fun a_17_12 () U) (declare-fun a_17_13 () U) (declare-fun a_17_14 () U) (declare-fun a_17_15 () U) (declare-fun a_17_16 () U) (declare-fun a_17_17 () U) (declare-fun a_17_18 () U) (declare-fun a_17_19 () U) (declare-fun a_17_20 () U) (declare-fun a_17_21 () U) (declare-fun a_17_22 () U) (declare-fun a_17_23 () U) (declare-fun a_17_24 () U) (declare-fun a_17_25 () U) (declare-fun a_17_26 () U) (declare-fun a_17_27 () U) (declare-fun a_17_28 () U) (declare-fun a_17_29 () U) (declare-fun a_17_30 () U) (declare-fun a_17_31 () U) (declare-fun a_17_32 () U) (declare-fun a_17_33 () U) (declare-fun a_17_34 () U) (declare-fun a_17_35 () U) (declare-fun a_17_36 () U) (declare-fun a_17_37 () U) (declare-fun a_17_38 () U) (declare-fun a_17_39 () U) (declare-fun a_18_0 () U) (declare-fun a_18_1 () U) (declare-fun a_18_2 () U) (declare-fun a_18_3 () U) (declare-fun a_18_4 () U) (declare-fun a_18_5 () U) (declare-fun a_18_6 () U) (declare-fun a_18_7 () U) (declare-fun a_18_8 () U) (declare-fun a_18_9 () U) (declare-fun a_18_10 () U) (declare-fun a_18_11 () U) (declare-fun a_18_12 () U) (declare-fun a_18_13 () U) (declare-fun a_18_14 () U) (declare-fun a_18_15 () U) (declare-fun a_18_16 () U) (declare-fun a_18_17 () U) (declare-fun a_18_18 () U) (declare-fun a_18_19 () U) (declare-fun a_18_20 () U) (declare-fun a_18_21 () U) (declare-fun a_18_22 () U) (declare-fun a_18_23 () U) (declare-fun a_18_24 () U) (declare-fun a_18_25 () U) (declare-fun a_18_26 () U) (declare-fun a_18_27 () U) (declare-fun a_18_28 () U) (declare-fun a_18_29 () U) (declare-fun a_18_30 () U) (declare-fun a_18_31 () U) (declare-fun a_18_32 () U) (declare-fun a_18_33 () U) (declare-fun a_18_34 () U) (declare-fun a_18_35 () U) (declare-fun a_18_36 () U) (declare-fun a_18_37 () U) (declare-fun a_18_38 () U) (declare-fun a_18_39 () U) (declare-fun a_19_0 () U) (declare-fun a_19_1 () U) (declare-fun a_19_2 () U) (declare-fun a_19_3 () U) (declare-fun a_19_4 () U) (declare-fun a_19_5 () U) (declare-fun a_19_6 () U) (declare-fun a_19_7 () U) (declare-fun a_19_8 () U) (declare-fun a_19_9 () U) (declare-fun a_19_10 () U) (declare-fun a_19_11 () U) (declare-fun a_19_12 () U) (declare-fun a_19_13 () U) (declare-fun a_19_14 () U) (declare-fun a_19_15 () U) (declare-fun a_19_16 () U) (declare-fun a_19_17 () U) (declare-fun a_19_18 () U) (declare-fun a_19_19 () U) (declare-fun a_19_20 () U) (declare-fun a_19_21 () U) (declare-fun a_19_22 () U) (declare-fun a_19_23 () U) (declare-fun a_19_24 () U) (declare-fun a_19_25 () U) (declare-fun a_19_26 () U) (declare-fun a_19_27 () U) (declare-fun a_19_28 () U) (declare-fun a_19_29 () U) (declare-fun a_19_30 () U) (declare-fun a_19_31 () U) (declare-fun a_19_32 () U) (declare-fun a_19_33 () U) (declare-fun a_19_34 () U) (declare-fun a_19_35 () U) (declare-fun a_19_36 () U) (declare-fun a_19_37 () U) (declare-fun a_19_38 () U) (declare-fun a_19_39 () U) (declare-fun a_20_0 () U) (declare-fun a_20_1 () U) (declare-fun a_20_2 () U) (declare-fun a_20_3 () U) (declare-fun a_20_4 () U) (declare-fun a_20_5 () U) (declare-fun a_20_6 () U) (declare-fun a_20_7 () U) (declare-fun a_20_8 () U) (declare-fun a_20_9 () U) (declare-fun a_20_10 () U) (declare-fun a_20_11 () U) (declare-fun a_20_12 () U) (declare-fun a_20_13 () U) (declare-fun a_20_14 () U) (declare-fun a_20_15 () U) (declare-fun a_20_16 () U) (declare-fun a_20_17 () U) (declare-fun a_20_18 () U) (declare-fun a_20_19 () U) (declare-fun a_20_20 () U) (declare-fun a_20_21 () U) (declare-fun a_20_22 () U) (declare-fun a_20_23 () U) (declare-fun a_20_24 () U) (declare-fun a_20_25 () U) (declare-fun a_20_26 () U) (declare-fun a_20_27 () U) (declare-fun a_20_28 () U) (declare-fun a_20_29 () U) (declare-fun a_20_30 () U) (declare-fun a_20_31 () U) (declare-fun a_20_32 () U) (declare-fun a_20_33 () U) (declare-fun a_20_34 () U) (declare-fun a_20_35 () U) (declare-fun a_20_36 () U) (declare-fun a_20_37 () U) (declare-fun a_20_38 () U) (declare-fun a_20_39 () U) (declare-fun a_21_0 () U) (declare-fun a_21_1 () U) (declare-fun a_21_2 () U) (declare-fun a_21_3 () U) (declare-fun a_21_4 () U) (declare-fun a_21_5 () U) (declare-fun a_21_6 () U) (declare-fun a_21_7 () U) (declare-fun a_21_8 () U) (declare-fun a_21_9 () U) (declare-fun a_21_10 () U) (declare-fun a_21_11 () U) (declare-fun a_21_12 () U) (declare-fun a_21_13 () U) (declare-fun a_21_14 () U) (declare-fun a_21_15 () U) (declare-fun a_21_16 () U) (declare-fun a_21_17 () U) (declare-fun a_21_18 () U) (declare-fun a_21_19 () U) (declare-fun a_21_20 () U) (declare-fun a_21_21 () U) (declare-fun a_21_22 () U) (declare-fun a_21_23 () U) (declare-fun a_21_24 () U) (declare-fun a_21_25 () U) (declare-fun a_21_26 () U) (declare-fun a_21_27 () U) (declare-fun a_21_28 () U) (declare-fun a_21_29 () U) (declare-fun a_21_30 () U) (declare-fun a_21_31 () U) (declare-fun a_21_32 () U) (declare-fun a_21_33 () U) (declare-fun a_21_34 () U) (declare-fun a_21_35 () U) (declare-fun a_21_36 () U) (declare-fun a_21_37 () U) (declare-fun a_21_38 () U) (declare-fun a_21_39 () U) (declare-fun a_22_0 () U) (declare-fun a_22_1 () U) (declare-fun a_22_2 () U) (declare-fun a_22_3 () U) (declare-fun a_22_4 () U) (declare-fun a_22_5 () U) (declare-fun a_22_6 () U) (declare-fun a_22_7 () U) (declare-fun a_22_8 () U) (declare-fun a_22_9 () U) (declare-fun a_22_10 () U) (declare-fun a_22_11 () U) (declare-fun a_22_12 () U) (declare-fun a_22_13 () U) (declare-fun a_22_14 () U) (declare-fun a_22_15 () U) (declare-fun a_22_16 () U) (declare-fun a_22_17 () U) (declare-fun a_22_18 () U) (declare-fun a_22_19 () U) (declare-fun a_22_20 () U) (declare-fun a_22_21 () U) (declare-fun a_22_22 () U) (declare-fun a_22_23 () U) (declare-fun a_22_24 () U) (declare-fun a_22_25 () U) (declare-fun a_22_26 () U) (declare-fun a_22_27 () U) (declare-fun a_22_28 () U) (declare-fun a_22_29 () U) (declare-fun a_22_30 () U) (declare-fun a_22_31 () U) (declare-fun a_22_32 () U) (declare-fun a_22_33 () U) (declare-fun a_22_34 () U) (declare-fun a_22_35 () U) (declare-fun a_22_36 () U) (declare-fun a_22_37 () U) (declare-fun a_22_38 () U) (declare-fun a_22_39 () U) (declare-fun a_23_0 () U) (declare-fun a_23_1 () U) (declare-fun a_23_2 () U) (declare-fun a_23_3 () U) (declare-fun a_23_4 () U) (declare-fun a_23_5 () U) (declare-fun a_23_6 () U) (declare-fun a_23_7 () U) (declare-fun a_23_8 () U) (declare-fun a_23_9 () U) (declare-fun a_23_10 () U) (declare-fun a_23_11 () U) (declare-fun a_23_12 () U) (declare-fun a_23_13 () U) (declare-fun a_23_14 () U) (declare-fun a_23_15 () U) (declare-fun a_23_16 () U) (declare-fun a_23_17 () U) (declare-fun a_23_18 () U) (declare-fun a_23_19 () U) (declare-fun a_23_20 () U) (declare-fun a_23_21 () U) (declare-fun a_23_22 () U) (declare-fun a_23_23 () U) (declare-fun a_23_24 () U) (declare-fun a_23_25 () U) (declare-fun a_23_26 () U) (declare-fun a_23_27 () U) (declare-fun a_23_28 () U) (declare-fun a_23_29 () U) (declare-fun a_23_30 () U) (declare-fun a_23_31 () U) (declare-fun a_23_32 () U) (declare-fun a_23_33 () U) (declare-fun a_23_34 () U) (declare-fun a_23_35 () U) (declare-fun a_23_36 () U) (declare-fun a_23_37 () U) (declare-fun a_23_38 () U) (declare-fun a_23_39 () U) (declare-fun a_24_0 () U) (declare-fun a_24_1 () U) (declare-fun a_24_2 () U) (declare-fun a_24_3 () U) (declare-fun a_24_4 () U) (declare-fun a_24_5 () U) (declare-fun a_24_6 () U) (declare-fun a_24_7 () U) (declare-fun a_24_8 () U) (declare-fun a_24_9 () U) (declare-fun a_24_10 () U) (declare-fun a_24_11 () U) (declare-fun a_24_12 () U) (declare-fun a_24_13 () U) (declare-fun a_24_14 () U) (declare-fun a_24_15 () U) (declare-fun a_24_16 () U) (declare-fun a_24_17 () U) (declare-fun a_24_18 () U) (declare-fun a_24_19 () U) (declare-fun a_24_20 () U) (declare-fun a_24_21 () U) (declare-fun a_24_22 () U) (declare-fun a_24_23 () U) (declare-fun a_24_24 () U) (declare-fun a_24_25 () U) (declare-fun a_24_26 () U) (declare-fun a_24_27 () U) (declare-fun a_24_28 () U) (declare-fun a_24_29 () U) (declare-fun a_24_30 () U) (declare-fun a_24_31 () U) (declare-fun a_24_32 () U) (declare-fun a_24_33 () U) (declare-fun a_24_34 () U) (declare-fun a_24_35 () U) (declare-fun a_24_36 () U) (declare-fun a_24_37 () U) (declare-fun a_24_38 () U) (declare-fun a_24_39 () U) (declare-fun a_25_0 () U) (declare-fun a_25_1 () U) (declare-fun a_25_2 () U) (declare-fun a_25_3 () U) (declare-fun a_25_4 () U) (declare-fun a_25_5 () U) (declare-fun a_25_6 () U) (declare-fun a_25_7 () U) (declare-fun a_25_8 () U) (declare-fun a_25_9 () U) (declare-fun a_25_10 () U) (declare-fun a_25_11 () U) (declare-fun a_25_12 () U) (declare-fun a_25_13 () U) (declare-fun a_25_14 () U) (declare-fun a_25_15 () U) (declare-fun a_25_16 () U) (declare-fun a_25_17 () U) (declare-fun a_25_18 () U) (declare-fun a_25_19 () U) (declare-fun a_25_20 () U) (declare-fun a_25_21 () U) (declare-fun a_25_22 () U) (declare-fun a_25_23 () U) (declare-fun a_25_24 () U) (declare-fun a_25_25 () U) (declare-fun a_25_26 () U) (declare-fun a_25_27 () U) (declare-fun a_25_28 () U) (declare-fun a_25_29 () U) (declare-fun a_25_30 () U) (declare-fun a_25_31 () U) (declare-fun a_25_32 () U) (declare-fun a_25_33 () U) (declare-fun a_25_34 () U) (declare-fun a_25_35 () U) (declare-fun a_25_36 () U) (declare-fun a_25_37 () U) (declare-fun a_25_38 () U) (declare-fun a_25_39 () U) (declare-fun a_26_0 () U) (declare-fun a_26_1 () U) (declare-fun a_26_2 () U) (declare-fun a_26_3 () U) (declare-fun a_26_4 () U) (declare-fun a_26_5 () U) (declare-fun a_26_6 () U) (declare-fun a_26_7 () U) (declare-fun a_26_8 () U) (declare-fun a_26_9 () U) (declare-fun a_26_10 () U) (declare-fun a_26_11 () U) (declare-fun a_26_12 () U) (declare-fun a_26_13 () U) (declare-fun a_26_14 () U) (declare-fun a_26_15 () U) (declare-fun a_26_16 () U) (declare-fun a_26_17 () U) (declare-fun a_26_18 () U) (declare-fun a_26_19 () U) (declare-fun a_26_20 () U) (declare-fun a_26_21 () U) (declare-fun a_26_22 () U) (declare-fun a_26_23 () U) (declare-fun a_26_24 () U) (declare-fun a_26_25 () U) (declare-fun a_26_26 () U) (declare-fun a_26_27 () U) (declare-fun a_26_28 () U) (declare-fun a_26_29 () U) (declare-fun a_26_30 () U) (declare-fun a_26_31 () U) (declare-fun a_26_32 () U) (declare-fun a_26_33 () U) (declare-fun a_26_34 () U) (declare-fun a_26_35 () U) (declare-fun a_26_36 () U) (declare-fun a_26_37 () U) (declare-fun a_26_38 () U) (declare-fun a_26_39 () U) (declare-fun a_27_0 () U) (declare-fun a_27_1 () U) (declare-fun a_27_2 () U) (declare-fun a_27_3 () U) (declare-fun a_27_4 () U) (declare-fun a_27_5 () U) (declare-fun a_27_6 () U) (declare-fun a_27_7 () U) (declare-fun a_27_8 () U) (declare-fun a_27_9 () U) (declare-fun a_27_10 () U) (declare-fun a_27_11 () U) (declare-fun a_27_12 () U) (declare-fun a_27_13 () U) (declare-fun a_27_14 () U) (declare-fun a_27_15 () U) (declare-fun a_27_16 () U) (declare-fun a_27_17 () U) (declare-fun a_27_18 () U) (declare-fun a_27_19 () U) (declare-fun a_27_20 () U) (declare-fun a_27_21 () U) (declare-fun a_27_22 () U) (declare-fun a_27_23 () U) (declare-fun a_27_24 () U) (declare-fun a_27_25 () U) (declare-fun a_27_26 () U) (declare-fun a_27_27 () U) (declare-fun a_27_28 () U) (declare-fun a_27_29 () U) (declare-fun a_27_30 () U) (declare-fun a_27_31 () U) (declare-fun a_27_32 () U) (declare-fun a_27_33 () U) (declare-fun a_27_34 () U) (declare-fun a_27_35 () U) (declare-fun a_27_36 () U) (declare-fun a_27_37 () U) (declare-fun a_27_38 () U) (declare-fun a_27_39 () U) (declare-fun a_28_0 () U) (declare-fun a_28_1 () U) (declare-fun a_28_2 () U) (declare-fun a_28_3 () U) (declare-fun a_28_4 () U) (declare-fun a_28_5 () U) (declare-fun a_28_6 () U) (declare-fun a_28_7 () U) (declare-fun a_28_8 () U) (declare-fun a_28_9 () U) (declare-fun a_28_10 () U) (declare-fun a_28_11 () U) (declare-fun a_28_12 () U) (declare-fun a_28_13 () U) (declare-fun a_28_14 () U) (declare-fun a_28_15 () U) (declare-fun a_28_16 () U) (declare-fun a_28_17 () U) (declare-fun a_28_18 () U) (declare-fun a_28_19 () U) (declare-fun a_28_20 () U) (declare-fun a_28_21 () U) (declare-fun a_28_22 () U) (declare-fun a_28_23 () U) (declare-fun a_28_24 () U) (declare-fun a_28_25 () U) (declare-fun a_28_26 () U) (declare-fun a_28_27 () U) (declare-fun a_28_28 () U) (declare-fun a_28_29 () U) (declare-fun a_28_30 () U) (declare-fun a_28_31 () U) (declare-fun a_28_32 () U) (declare-fun a_28_33 () U) (declare-fun a_28_34 () U) (declare-fun a_28_35 () U) (declare-fun a_28_36 () U) (declare-fun a_28_37 () U) (declare-fun a_28_38 () U) (declare-fun a_28_39 () U) (declare-fun a_29_0 () U) (declare-fun a_29_1 () U) (declare-fun a_29_2 () U) (declare-fun a_29_3 () U) (declare-fun a_29_4 () U) (declare-fun a_29_5 () U) (declare-fun a_29_6 () U) (declare-fun a_29_7 () U) (declare-fun a_29_8 () U) (declare-fun a_29_9 () U) (declare-fun a_29_10 () U) (declare-fun a_29_11 () U) (declare-fun a_29_12 () U) (declare-fun a_29_13 () U) (declare-fun a_29_14 () U) (declare-fun a_29_15 () U) (declare-fun a_29_16 () U) (declare-fun a_29_17 () U) (declare-fun a_29_18 () U) (declare-fun a_29_19 () U) (declare-fun a_29_20 () U) (declare-fun a_29_21 () U) (declare-fun a_29_22 () U) (declare-fun a_29_23 () U) (declare-fun a_29_24 () U) (declare-fun a_29_25 () U) (declare-fun a_29_26 () U) (declare-fun a_29_27 () U) (declare-fun a_29_28 () U) (declare-fun a_29_29 () U) (declare-fun a_29_30 () U) (declare-fun a_29_31 () U) (declare-fun a_29_32 () U) (declare-fun a_29_33 () U) (declare-fun a_29_34 () U) (declare-fun a_29_35 () U) (declare-fun a_29_36 () U) (declare-fun a_29_37 () U) (declare-fun a_29_38 () U) (declare-fun a_29_39 () U) (declare-fun a_30_0 () U) (declare-fun a_30_1 () U) (declare-fun a_30_2 () U) (declare-fun a_30_3 () U) (declare-fun a_30_4 () U) (declare-fun a_30_5 () U) (declare-fun a_30_6 () U) (declare-fun a_30_7 () U) (declare-fun a_30_8 () U) (declare-fun a_30_9 () U) (declare-fun a_30_10 () U) (declare-fun a_30_11 () U) (declare-fun a_30_12 () U) (declare-fun a_30_13 () U) (declare-fun a_30_14 () U) (declare-fun a_30_15 () U) (declare-fun a_30_16 () U) (declare-fun a_30_17 () U) (declare-fun a_30_18 () U) (declare-fun a_30_19 () U) (declare-fun a_30_20 () U) (declare-fun a_30_21 () U) (declare-fun a_30_22 () U) (declare-fun a_30_23 () U) (declare-fun a_30_24 () U) (declare-fun a_30_25 () U) (declare-fun a_30_26 () U) (declare-fun a_30_27 () U) (declare-fun a_30_28 () U) (declare-fun a_30_29 () U) (declare-fun a_30_30 () U) (declare-fun a_30_31 () U) (declare-fun a_30_32 () U) (declare-fun a_30_33 () U) (declare-fun a_30_34 () U) (declare-fun a_30_35 () U) (declare-fun a_30_36 () U) (declare-fun a_30_37 () U) (declare-fun a_30_38 () U) (declare-fun a_30_39 () U) (declare-fun a_31_0 () U) (declare-fun a_31_1 () U) (declare-fun a_31_2 () U) (declare-fun a_31_3 () U) (declare-fun a_31_4 () U) (declare-fun a_31_5 () U) (declare-fun a_31_6 () U) (declare-fun a_31_7 () U) (declare-fun a_31_8 () U) (declare-fun a_31_9 () U) (declare-fun a_31_10 () U) (declare-fun a_31_11 () U) (declare-fun a_31_12 () U) (declare-fun a_31_13 () U) (declare-fun a_31_14 () U) (declare-fun a_31_15 () U) (declare-fun a_31_16 () U) (declare-fun a_31_17 () U) (declare-fun a_31_18 () U) (declare-fun a_31_19 () U) (declare-fun a_31_20 () U) (declare-fun a_31_21 () U) (declare-fun a_31_22 () U) (declare-fun a_31_23 () U) (declare-fun a_31_24 () U) (declare-fun a_31_25 () U) (declare-fun a_31_26 () U) (declare-fun a_31_27 () U) (declare-fun a_31_28 () U) (declare-fun a_31_29 () U) (declare-fun a_31_30 () U) (declare-fun a_31_31 () U) (declare-fun a_31_32 () U) (declare-fun a_31_33 () U) (declare-fun a_31_34 () U) (declare-fun a_31_35 () U) (declare-fun a_31_36 () U) (declare-fun a_31_37 () U) (declare-fun a_31_38 () U) (declare-fun a_31_39 () U) (declare-fun a_32_0 () U) (declare-fun a_32_1 () U) (declare-fun a_32_2 () U) (declare-fun a_32_3 () U) (declare-fun a_32_4 () U) (declare-fun a_32_5 () U) (declare-fun a_32_6 () U) (declare-fun a_32_7 () U) (declare-fun a_32_8 () U) (declare-fun a_32_9 () U) (declare-fun a_32_10 () U) (declare-fun a_32_11 () U) (declare-fun a_32_12 () U) (declare-fun a_32_13 () U) (declare-fun a_32_14 () U) (declare-fun a_32_15 () U) (declare-fun a_32_16 () U) (declare-fun a_32_17 () U) (declare-fun a_32_18 () U) (declare-fun a_32_19 () U) (declare-fun a_32_20 () U) (declare-fun a_32_21 () U) (declare-fun a_32_22 () U) (declare-fun a_32_23 () U) (declare-fun a_32_24 () U) (declare-fun a_32_25 () U) (declare-fun a_32_26 () U) (declare-fun a_32_27 () U) (declare-fun a_32_28 () U) (declare-fun a_32_29 () U) (declare-fun a_32_30 () U) (declare-fun a_32_31 () U) (declare-fun a_32_32 () U) (declare-fun a_32_33 () U) (declare-fun a_32_34 () U) (declare-fun a_32_35 () U) (declare-fun a_32_36 () U) (declare-fun a_32_37 () U) (declare-fun a_32_38 () U) (declare-fun a_32_39 () U) (declare-fun a_33_0 () U) (declare-fun a_33_1 () U) (declare-fun a_33_2 () U) (declare-fun a_33_3 () U) (declare-fun a_33_4 () U) (declare-fun a_33_5 () U) (declare-fun a_33_6 () U) (declare-fun a_33_7 () U) (declare-fun a_33_8 () U) (declare-fun a_33_9 () U) (declare-fun a_33_10 () U) (declare-fun a_33_11 () U) (declare-fun a_33_12 () U) (declare-fun a_33_13 () U) (declare-fun a_33_14 () U) (declare-fun a_33_15 () U) (declare-fun a_33_16 () U) (declare-fun a_33_17 () U) (declare-fun a_33_18 () U) (declare-fun a_33_19 () U) (declare-fun a_33_20 () U) (declare-fun a_33_21 () U) (declare-fun a_33_22 () U) (declare-fun a_33_23 () U) (declare-fun a_33_24 () U) (declare-fun a_33_25 () U) (declare-fun a_33_26 () U) (declare-fun a_33_27 () U) (declare-fun a_33_28 () U) (declare-fun a_33_29 () U) (declare-fun a_33_30 () U) (declare-fun a_33_31 () U) (declare-fun a_33_32 () U) (declare-fun a_33_33 () U) (declare-fun a_33_34 () U) (declare-fun a_33_35 () U) (declare-fun a_33_36 () U) (declare-fun a_33_37 () U) (declare-fun a_33_38 () U) (declare-fun a_33_39 () U) (declare-fun a_34_0 () U) (declare-fun a_34_1 () U) (declare-fun a_34_2 () U) (declare-fun a_34_3 () U) (declare-fun a_34_4 () U) (declare-fun a_34_5 () U) (declare-fun a_34_6 () U) (declare-fun a_34_7 () U) (declare-fun a_34_8 () U) (declare-fun a_34_9 () U) (declare-fun a_34_10 () U) (declare-fun a_34_11 () U) (declare-fun a_34_12 () U) (declare-fun a_34_13 () U) (declare-fun a_34_14 () U) (declare-fun a_34_15 () U) (declare-fun a_34_16 () U) (declare-fun a_34_17 () U) (declare-fun a_34_18 () U) (declare-fun a_34_19 () U) (declare-fun a_34_20 () U) (declare-fun a_34_21 () U) (declare-fun a_34_22 () U) (declare-fun a_34_23 () U) (declare-fun a_34_24 () U) (declare-fun a_34_25 () U) (declare-fun a_34_26 () U) (declare-fun a_34_27 () U) (declare-fun a_34_28 () U) (declare-fun a_34_29 () U) (declare-fun a_34_30 () U) (declare-fun a_34_31 () U) (declare-fun a_34_32 () U) (declare-fun a_34_33 () U) (declare-fun a_34_34 () U) (declare-fun a_34_35 () U) (declare-fun a_34_36 () U) (declare-fun a_34_37 () U) (declare-fun a_34_38 () U) (declare-fun a_34_39 () U) (declare-fun a_35_0 () U) (declare-fun a_35_1 () U) (declare-fun a_35_2 () U) (declare-fun a_35_3 () U) (declare-fun a_35_4 () U) (declare-fun a_35_5 () U) (declare-fun a_35_6 () U) (declare-fun a_35_7 () U) (declare-fun a_35_8 () U) (declare-fun a_35_9 () U) (declare-fun a_35_10 () U) (declare-fun a_35_11 () U) (declare-fun a_35_12 () U) (declare-fun a_35_13 () U) (declare-fun a_35_14 () U) (declare-fun a_35_15 () U) (declare-fun a_35_16 () U) (declare-fun a_35_17 () U) (declare-fun a_35_18 () U) (declare-fun a_35_19 () U) (declare-fun a_35_20 () U) (declare-fun a_35_21 () U) (declare-fun a_35_22 () U) (declare-fun a_35_23 () U) (declare-fun a_35_24 () U) (declare-fun a_35_25 () U) (declare-fun a_35_26 () U) (declare-fun a_35_27 () U) (declare-fun a_35_28 () U) (declare-fun a_35_29 () U) (declare-fun a_35_30 () U) (declare-fun a_35_31 () U) (declare-fun a_35_32 () U) (declare-fun a_35_33 () U) (declare-fun a_35_34 () U) (declare-fun a_35_35 () U) (declare-fun a_35_36 () U) (declare-fun a_35_37 () U) (declare-fun a_35_38 () U) (declare-fun a_35_39 () U) (declare-fun a_36_0 () U) (declare-fun a_36_1 () U) (declare-fun a_36_2 () U) (declare-fun a_36_3 () U) (declare-fun a_36_4 () U) (declare-fun a_36_5 () U) (declare-fun a_36_6 () U) (declare-fun a_36_7 () U) (declare-fun a_36_8 () U) (declare-fun a_36_9 () U) (declare-fun a_36_10 () U) (declare-fun a_36_11 () U) (declare-fun a_36_12 () U) (declare-fun a_36_13 () U) (declare-fun a_36_14 () U) (declare-fun a_36_15 () U) (declare-fun a_36_16 () U) (declare-fun a_36_17 () U) (declare-fun a_36_18 () U) (declare-fun a_36_19 () U) (declare-fun a_36_20 () U) (declare-fun a_36_21 () U) (declare-fun a_36_22 () U) (declare-fun a_36_23 () U) (declare-fun a_36_24 () U) (declare-fun a_36_25 () U) (declare-fun a_36_26 () U) (declare-fun a_36_27 () U) (declare-fun a_36_28 () U) (declare-fun a_36_29 () U) (declare-fun a_36_30 () U) (declare-fun a_36_31 () U) (declare-fun a_36_32 () U) (declare-fun a_36_33 () U) (declare-fun a_36_34 () U) (declare-fun a_36_35 () U) (declare-fun a_36_36 () U) (declare-fun a_36_37 () U) (declare-fun a_36_38 () U) (declare-fun a_36_39 () U) (declare-fun a_37_0 () U) (declare-fun a_37_1 () U) (declare-fun a_37_2 () U) (declare-fun a_37_3 () U) (declare-fun a_37_4 () U) (declare-fun a_37_5 () U) (declare-fun a_37_6 () U) (declare-fun a_37_7 () U) (declare-fun a_37_8 () U) (declare-fun a_37_9 () U) (declare-fun a_37_10 () U) (declare-fun a_37_11 () U) (declare-fun a_37_12 () U) (declare-fun a_37_13 () U) (declare-fun a_37_14 () U) (declare-fun a_37_15 () U) (declare-fun a_37_16 () U) (declare-fun a_37_17 () U) (declare-fun a_37_18 () U) (declare-fun a_37_19 () U) (declare-fun a_37_20 () U) (declare-fun a_37_21 () U) (declare-fun a_37_22 () U) (declare-fun a_37_23 () U) (declare-fun a_37_24 () U) (declare-fun a_37_25 () U) (declare-fun a_37_26 () U) (declare-fun a_37_27 () U) (declare-fun a_37_28 () U) (declare-fun a_37_29 () U) (declare-fun a_37_30 () U) (declare-fun a_37_31 () U) (declare-fun a_37_32 () U) (declare-fun a_37_33 () U) (declare-fun a_37_34 () U) (declare-fun a_37_35 () U) (declare-fun a_37_36 () U) (declare-fun a_37_37 () U) (declare-fun a_37_38 () U) (declare-fun a_37_39 () U) (declare-fun a_38_0 () U) (declare-fun a_38_1 () U) (declare-fun a_38_2 () U) (declare-fun a_38_3 () U) (declare-fun a_38_4 () U) (declare-fun a_38_5 () U) (declare-fun a_38_6 () U) (declare-fun a_38_7 () U) (declare-fun a_38_8 () U) (declare-fun a_38_9 () U) (declare-fun a_38_10 () U) (declare-fun a_38_11 () U) (declare-fun a_38_12 () U) (declare-fun a_38_13 () U) (declare-fun a_38_14 () U) (declare-fun a_38_15 () U) (declare-fun a_38_16 () U) (declare-fun a_38_17 () U) (declare-fun a_38_18 () U) (declare-fun a_38_19 () U) (declare-fun a_38_20 () U) (declare-fun a_38_21 () U) (declare-fun a_38_22 () U) (declare-fun a_38_23 () U) (declare-fun a_38_24 () U) (declare-fun a_38_25 () U) (declare-fun a_38_26 () U) (declare-fun a_38_27 () U) (declare-fun a_38_28 () U) (declare-fun a_38_29 () U) (declare-fun a_38_30 () U) (declare-fun a_38_31 () U) (declare-fun a_38_32 () U) (declare-fun a_38_33 () U) (declare-fun a_38_34 () U) (declare-fun a_38_35 () U) (declare-fun a_38_36 () U) (declare-fun a_38_37 () U) (declare-fun a_38_38 () U) (declare-fun a_38_39 () U) (declare-fun a_39_0 () U) (declare-fun a_39_1 () U) (declare-fun a_39_2 () U) (declare-fun a_39_3 () U) (declare-fun a_39_4 () U) (declare-fun a_39_5 () U) (declare-fun a_39_6 () U) (declare-fun a_39_7 () U) (declare-fun a_39_8 () U) (declare-fun a_39_9 () U) (declare-fun a_39_10 () U) (declare-fun a_39_11 () U) (declare-fun a_39_12 () U) (declare-fun a_39_13 () U) (declare-fun a_39_14 () U) (declare-fun a_39_15 () U) (declare-fun a_39_16 () U) (declare-fun a_39_17 () U) (declare-fun a_39_18 () U) (declare-fun a_39_19 () U) (declare-fun a_39_20 () U) (declare-fun a_39_21 () U) (declare-fun a_39_22 () U) (declare-fun a_39_23 () U) (declare-fun a_39_24 () U) (declare-fun a_39_25 () U) (declare-fun a_39_26 () U) (declare-fun a_39_27 () U) (declare-fun a_39_28 () U) (declare-fun a_39_29 () U) (declare-fun a_39_30 () U) (declare-fun a_39_31 () U) (declare-fun a_39_32 () U) (declare-fun a_39_33 () U) (declare-fun a_39_34 () U) (declare-fun a_39_35 () U) (declare-fun a_39_36 () U) (declare-fun a_39_37 () U) (declare-fun a_39_38 () U) (declare-fun a_39_39 () U) (assert (or (or (and (or (not x_0_0) (not x_0_1) (not x_0_2)) (or x_0_0 (not x_0_1) (not x_0_2)) (or (not x_0_0) x_0_1 (not x_0_2)) (or x_0_0 x_0_1 (not x_0_2)) (or (not x_0_0) (not x_0_1) x_0_2) (or x_0_0 (not x_0_1) x_0_2) (or (not x_0_0) x_0_1 x_0_2) (or x_0_0 x_0_1 x_0_2))) (distinct a_0_0 a_0_1 a_0_2 a_0_3 a_0_4 a_0_5 a_0_6 a_0_7 a_0_8 a_0_9 a_0_10 a_0_11 a_0_12 a_0_13 a_0_14 a_0_15 a_0_16 a_0_17 a_0_18 a_0_19 a_0_20 a_0_21 a_0_22 a_0_23 a_0_24 a_0_25 a_0_26 a_0_27 a_0_28 a_0_29 a_0_30 a_0_31 a_0_32 a_0_33 a_0_34 a_0_35 a_0_36 a_0_37 a_0_38 a_0_39))) (assert (or (or (and (or (not x_1_0) (not x_1_1) (not x_1_2)) (or x_1_0 (not x_1_1) (not x_1_2)) (or (not x_1_0) x_1_1 (not x_1_2)) (or x_1_0 x_1_1 (not x_1_2)) (or (not x_1_0) (not x_1_1) x_1_2) (or x_1_0 (not x_1_1) x_1_2) (or (not x_1_0) x_1_1 x_1_2) (or x_1_0 x_1_1 x_1_2))) (distinct a_1_0 a_1_1 a_1_2 a_1_3 a_1_4 a_1_5 a_1_6 a_1_7 a_1_8 a_1_9 a_1_10 a_1_11 a_1_12 a_1_13 a_1_14 a_1_15 a_1_16 a_1_17 a_1_18 a_1_19 a_1_20 a_1_21 a_1_22 a_1_23 a_1_24 a_1_25 a_1_26 a_1_27 a_1_28 a_1_29 a_1_30 a_1_31 a_1_32 a_1_33 a_1_34 a_1_35 a_1_36 a_1_37 a_1_38 a_1_39))) (assert (or (or (and (or (not x_2_0) (not x_2_1) (not x_2_2)) (or x_2_0 (not x_2_1) (not x_2_2)) (or (not x_2_0) x_2_1 (not x_2_2)) (or x_2_0 x_2_1 (not x_2_2)) (or (not x_2_0) (not x_2_1) x_2_2) (or x_2_0 (not x_2_1) x_2_2) (or (not x_2_0) x_2_1 x_2_2) (or x_2_0 x_2_1 x_2_2))) (distinct a_2_0 a_2_1 a_2_2 a_2_3 a_2_4 a_2_5 a_2_6 a_2_7 a_2_8 a_2_9 a_2_10 a_2_11 a_2_12 a_2_13 a_2_14 a_2_15 a_2_16 a_2_17 a_2_18 a_2_19 a_2_20 a_2_21 a_2_22 a_2_23 a_2_24 a_2_25 a_2_26 a_2_27 a_2_28 a_2_29 a_2_30 a_2_31 a_2_32 a_2_33 a_2_34 a_2_35 a_2_36 a_2_37 a_2_38 a_2_39))) (assert (or (or (and (or (not x_3_0) (not x_3_1) (not x_3_2)) (or x_3_0 (not x_3_1) (not x_3_2)) (or (not x_3_0) x_3_1 (not x_3_2)) (or x_3_0 x_3_1 (not x_3_2)) (or (not x_3_0) (not x_3_1) x_3_2) (or x_3_0 (not x_3_1) x_3_2) (or (not x_3_0) x_3_1 x_3_2) (or x_3_0 x_3_1 x_3_2))) (distinct a_3_0 a_3_1 a_3_2 a_3_3 a_3_4 a_3_5 a_3_6 a_3_7 a_3_8 a_3_9 a_3_10 a_3_11 a_3_12 a_3_13 a_3_14 a_3_15 a_3_16 a_3_17 a_3_18 a_3_19 a_3_20 a_3_21 a_3_22 a_3_23 a_3_24 a_3_25 a_3_26 a_3_27 a_3_28 a_3_29 a_3_30 a_3_31 a_3_32 a_3_33 a_3_34 a_3_35 a_3_36 a_3_37 a_3_38 a_3_39))) (assert (or (or (and (or (not x_4_0) (not x_4_1) (not x_4_2)) (or x_4_0 (not x_4_1) (not x_4_2)) (or (not x_4_0) x_4_1 (not x_4_2)) (or x_4_0 x_4_1 (not x_4_2)) (or (not x_4_0) (not x_4_1) x_4_2) (or x_4_0 (not x_4_1) x_4_2) (or (not x_4_0) x_4_1 x_4_2) (or x_4_0 x_4_1 x_4_2))) (distinct a_4_0 a_4_1 a_4_2 a_4_3 a_4_4 a_4_5 a_4_6 a_4_7 a_4_8 a_4_9 a_4_10 a_4_11 a_4_12 a_4_13 a_4_14 a_4_15 a_4_16 a_4_17 a_4_18 a_4_19 a_4_20 a_4_21 a_4_22 a_4_23 a_4_24 a_4_25 a_4_26 a_4_27 a_4_28 a_4_29 a_4_30 a_4_31 a_4_32 a_4_33 a_4_34 a_4_35 a_4_36 a_4_37 a_4_38 a_4_39))) (assert (or (or (and (or (not x_5_0) (not x_5_1) (not x_5_2)) (or x_5_0 (not x_5_1) (not x_5_2)) (or (not x_5_0) x_5_1 (not x_5_2)) (or x_5_0 x_5_1 (not x_5_2)) (or (not x_5_0) (not x_5_1) x_5_2) (or x_5_0 (not x_5_1) x_5_2) (or (not x_5_0) x_5_1 x_5_2) (or x_5_0 x_5_1 x_5_2))) (distinct a_5_0 a_5_1 a_5_2 a_5_3 a_5_4 a_5_5 a_5_6 a_5_7 a_5_8 a_5_9 a_5_10 a_5_11 a_5_12 a_5_13 a_5_14 a_5_15 a_5_16 a_5_17 a_5_18 a_5_19 a_5_20 a_5_21 a_5_22 a_5_23 a_5_24 a_5_25 a_5_26 a_5_27 a_5_28 a_5_29 a_5_30 a_5_31 a_5_32 a_5_33 a_5_34 a_5_35 a_5_36 a_5_37 a_5_38 a_5_39))) (assert (or (or (and (or (not x_6_0) (not x_6_1) (not x_6_2)) (or x_6_0 (not x_6_1) (not x_6_2)) (or (not x_6_0) x_6_1 (not x_6_2)) (or x_6_0 x_6_1 (not x_6_2)) (or (not x_6_0) (not x_6_1) x_6_2) (or x_6_0 (not x_6_1) x_6_2) (or (not x_6_0) x_6_1 x_6_2) (or x_6_0 x_6_1 x_6_2))) (distinct a_6_0 a_6_1 a_6_2 a_6_3 a_6_4 a_6_5 a_6_6 a_6_7 a_6_8 a_6_9 a_6_10 a_6_11 a_6_12 a_6_13 a_6_14 a_6_15 a_6_16 a_6_17 a_6_18 a_6_19 a_6_20 a_6_21 a_6_22 a_6_23 a_6_24 a_6_25 a_6_26 a_6_27 a_6_28 a_6_29 a_6_30 a_6_31 a_6_32 a_6_33 a_6_34 a_6_35 a_6_36 a_6_37 a_6_38 a_6_39))) (assert (or (or (and (or (not x_7_0) (not x_7_1) (not x_7_2)) (or x_7_0 (not x_7_1) (not x_7_2)) (or (not x_7_0) x_7_1 (not x_7_2)) (or x_7_0 x_7_1 (not x_7_2)) (or (not x_7_0) (not x_7_1) x_7_2) (or x_7_0 (not x_7_1) x_7_2) (or (not x_7_0) x_7_1 x_7_2) (or x_7_0 x_7_1 x_7_2))) (distinct a_7_0 a_7_1 a_7_2 a_7_3 a_7_4 a_7_5 a_7_6 a_7_7 a_7_8 a_7_9 a_7_10 a_7_11 a_7_12 a_7_13 a_7_14 a_7_15 a_7_16 a_7_17 a_7_18 a_7_19 a_7_20 a_7_21 a_7_22 a_7_23 a_7_24 a_7_25 a_7_26 a_7_27 a_7_28 a_7_29 a_7_30 a_7_31 a_7_32 a_7_33 a_7_34 a_7_35 a_7_36 a_7_37 a_7_38 a_7_39))) (assert (or (or (and (or (not x_8_0) (not x_8_1) (not x_8_2)) (or x_8_0 (not x_8_1) (not x_8_2)) (or (not x_8_0) x_8_1 (not x_8_2)) (or x_8_0 x_8_1 (not x_8_2)) (or (not x_8_0) (not x_8_1) x_8_2) (or x_8_0 (not x_8_1) x_8_2) (or (not x_8_0) x_8_1 x_8_2) (or x_8_0 x_8_1 x_8_2))) (distinct a_8_0 a_8_1 a_8_2 a_8_3 a_8_4 a_8_5 a_8_6 a_8_7 a_8_8 a_8_9 a_8_10 a_8_11 a_8_12 a_8_13 a_8_14 a_8_15 a_8_16 a_8_17 a_8_18 a_8_19 a_8_20 a_8_21 a_8_22 a_8_23 a_8_24 a_8_25 a_8_26 a_8_27 a_8_28 a_8_29 a_8_30 a_8_31 a_8_32 a_8_33 a_8_34 a_8_35 a_8_36 a_8_37 a_8_38 a_8_39))) (assert (or (or (and (or (not x_9_0) (not x_9_1) (not x_9_2)) (or x_9_0 (not x_9_1) (not x_9_2)) (or (not x_9_0) x_9_1 (not x_9_2)) (or x_9_0 x_9_1 (not x_9_2)) (or (not x_9_0) (not x_9_1) x_9_2) (or x_9_0 (not x_9_1) x_9_2) (or (not x_9_0) x_9_1 x_9_2) (or x_9_0 x_9_1 x_9_2))) (distinct a_9_0 a_9_1 a_9_2 a_9_3 a_9_4 a_9_5 a_9_6 a_9_7 a_9_8 a_9_9 a_9_10 a_9_11 a_9_12 a_9_13 a_9_14 a_9_15 a_9_16 a_9_17 a_9_18 a_9_19 a_9_20 a_9_21 a_9_22 a_9_23 a_9_24 a_9_25 a_9_26 a_9_27 a_9_28 a_9_29 a_9_30 a_9_31 a_9_32 a_9_33 a_9_34 a_9_35 a_9_36 a_9_37 a_9_38 a_9_39))) (assert (or (or (and (or (not x_10_0) (not x_10_1) (not x_10_2)) (or x_10_0 (not x_10_1) (not x_10_2)) (or (not x_10_0) x_10_1 (not x_10_2)) (or x_10_0 x_10_1 (not x_10_2)) (or (not x_10_0) (not x_10_1) x_10_2) (or x_10_0 (not x_10_1) x_10_2) (or (not x_10_0) x_10_1 x_10_2) (or x_10_0 x_10_1 x_10_2))) (distinct a_10_0 a_10_1 a_10_2 a_10_3 a_10_4 a_10_5 a_10_6 a_10_7 a_10_8 a_10_9 a_10_10 a_10_11 a_10_12 a_10_13 a_10_14 a_10_15 a_10_16 a_10_17 a_10_18 a_10_19 a_10_20 a_10_21 a_10_22 a_10_23 a_10_24 a_10_25 a_10_26 a_10_27 a_10_28 a_10_29 a_10_30 a_10_31 a_10_32 a_10_33 a_10_34 a_10_35 a_10_36 a_10_37 a_10_38 a_10_39))) (assert (or (or (and (or (not x_11_0) (not x_11_1) (not x_11_2)) (or x_11_0 (not x_11_1) (not x_11_2)) (or (not x_11_0) x_11_1 (not x_11_2)) (or x_11_0 x_11_1 (not x_11_2)) (or (not x_11_0) (not x_11_1) x_11_2) (or x_11_0 (not x_11_1) x_11_2) (or (not x_11_0) x_11_1 x_11_2) (or x_11_0 x_11_1 x_11_2))) (distinct a_11_0 a_11_1 a_11_2 a_11_3 a_11_4 a_11_5 a_11_6 a_11_7 a_11_8 a_11_9 a_11_10 a_11_11 a_11_12 a_11_13 a_11_14 a_11_15 a_11_16 a_11_17 a_11_18 a_11_19 a_11_20 a_11_21 a_11_22 a_11_23 a_11_24 a_11_25 a_11_26 a_11_27 a_11_28 a_11_29 a_11_30 a_11_31 a_11_32 a_11_33 a_11_34 a_11_35 a_11_36 a_11_37 a_11_38 a_11_39))) (assert (or (or (and (or (not x_12_0) (not x_12_1) (not x_12_2)) (or x_12_0 (not x_12_1) (not x_12_2)) (or (not x_12_0) x_12_1 (not x_12_2)) (or x_12_0 x_12_1 (not x_12_2)) (or (not x_12_0) (not x_12_1) x_12_2) (or x_12_0 (not x_12_1) x_12_2) (or (not x_12_0) x_12_1 x_12_2) (or x_12_0 x_12_1 x_12_2))) (distinct a_12_0 a_12_1 a_12_2 a_12_3 a_12_4 a_12_5 a_12_6 a_12_7 a_12_8 a_12_9 a_12_10 a_12_11 a_12_12 a_12_13 a_12_14 a_12_15 a_12_16 a_12_17 a_12_18 a_12_19 a_12_20 a_12_21 a_12_22 a_12_23 a_12_24 a_12_25 a_12_26 a_12_27 a_12_28 a_12_29 a_12_30 a_12_31 a_12_32 a_12_33 a_12_34 a_12_35 a_12_36 a_12_37 a_12_38 a_12_39))) (assert (or (or (and (or (not x_13_0) (not x_13_1) (not x_13_2)) (or x_13_0 (not x_13_1) (not x_13_2)) (or (not x_13_0) x_13_1 (not x_13_2)) (or x_13_0 x_13_1 (not x_13_2)) (or (not x_13_0) (not x_13_1) x_13_2) (or x_13_0 (not x_13_1) x_13_2) (or (not x_13_0) x_13_1 x_13_2) (or x_13_0 x_13_1 x_13_2))) (distinct a_13_0 a_13_1 a_13_2 a_13_3 a_13_4 a_13_5 a_13_6 a_13_7 a_13_8 a_13_9 a_13_10 a_13_11 a_13_12 a_13_13 a_13_14 a_13_15 a_13_16 a_13_17 a_13_18 a_13_19 a_13_20 a_13_21 a_13_22 a_13_23 a_13_24 a_13_25 a_13_26 a_13_27 a_13_28 a_13_29 a_13_30 a_13_31 a_13_32 a_13_33 a_13_34 a_13_35 a_13_36 a_13_37 a_13_38 a_13_39))) (assert (or (or (and (or (not x_14_0) (not x_14_1) (not x_14_2)) (or x_14_0 (not x_14_1) (not x_14_2)) (or (not x_14_0) x_14_1 (not x_14_2)) (or x_14_0 x_14_1 (not x_14_2)) (or (not x_14_0) (not x_14_1) x_14_2) (or x_14_0 (not x_14_1) x_14_2) (or (not x_14_0) x_14_1 x_14_2) (or x_14_0 x_14_1 x_14_2))) (distinct a_14_0 a_14_1 a_14_2 a_14_3 a_14_4 a_14_5 a_14_6 a_14_7 a_14_8 a_14_9 a_14_10 a_14_11 a_14_12 a_14_13 a_14_14 a_14_15 a_14_16 a_14_17 a_14_18 a_14_19 a_14_20 a_14_21 a_14_22 a_14_23 a_14_24 a_14_25 a_14_26 a_14_27 a_14_28 a_14_29 a_14_30 a_14_31 a_14_32 a_14_33 a_14_34 a_14_35 a_14_36 a_14_37 a_14_38 a_14_39))) (assert (or (or (and (or (not x_15_0) (not x_15_1) (not x_15_2)) (or x_15_0 (not x_15_1) (not x_15_2)) (or (not x_15_0) x_15_1 (not x_15_2)) (or x_15_0 x_15_1 (not x_15_2)) (or (not x_15_0) (not x_15_1) x_15_2) (or x_15_0 (not x_15_1) x_15_2) (or (not x_15_0) x_15_1 x_15_2) (or x_15_0 x_15_1 x_15_2))) (distinct a_15_0 a_15_1 a_15_2 a_15_3 a_15_4 a_15_5 a_15_6 a_15_7 a_15_8 a_15_9 a_15_10 a_15_11 a_15_12 a_15_13 a_15_14 a_15_15 a_15_16 a_15_17 a_15_18 a_15_19 a_15_20 a_15_21 a_15_22 a_15_23 a_15_24 a_15_25 a_15_26 a_15_27 a_15_28 a_15_29 a_15_30 a_15_31 a_15_32 a_15_33 a_15_34 a_15_35 a_15_36 a_15_37 a_15_38 a_15_39))) (assert (or (or (and (or (not x_16_0) (not x_16_1) (not x_16_2)) (or x_16_0 (not x_16_1) (not x_16_2)) (or (not x_16_0) x_16_1 (not x_16_2)) (or x_16_0 x_16_1 (not x_16_2)) (or (not x_16_0) (not x_16_1) x_16_2) (or x_16_0 (not x_16_1) x_16_2) (or (not x_16_0) x_16_1 x_16_2) (or x_16_0 x_16_1 x_16_2))) (distinct a_16_0 a_16_1 a_16_2 a_16_3 a_16_4 a_16_5 a_16_6 a_16_7 a_16_8 a_16_9 a_16_10 a_16_11 a_16_12 a_16_13 a_16_14 a_16_15 a_16_16 a_16_17 a_16_18 a_16_19 a_16_20 a_16_21 a_16_22 a_16_23 a_16_24 a_16_25 a_16_26 a_16_27 a_16_28 a_16_29 a_16_30 a_16_31 a_16_32 a_16_33 a_16_34 a_16_35 a_16_36 a_16_37 a_16_38 a_16_39))) (assert (or (or (and (or (not x_17_0) (not x_17_1) (not x_17_2)) (or x_17_0 (not x_17_1) (not x_17_2)) (or (not x_17_0) x_17_1 (not x_17_2)) (or x_17_0 x_17_1 (not x_17_2)) (or (not x_17_0) (not x_17_1) x_17_2) (or x_17_0 (not x_17_1) x_17_2) (or (not x_17_0) x_17_1 x_17_2) (or x_17_0 x_17_1 x_17_2))) (distinct a_17_0 a_17_1 a_17_2 a_17_3 a_17_4 a_17_5 a_17_6 a_17_7 a_17_8 a_17_9 a_17_10 a_17_11 a_17_12 a_17_13 a_17_14 a_17_15 a_17_16 a_17_17 a_17_18 a_17_19 a_17_20 a_17_21 a_17_22 a_17_23 a_17_24 a_17_25 a_17_26 a_17_27 a_17_28 a_17_29 a_17_30 a_17_31 a_17_32 a_17_33 a_17_34 a_17_35 a_17_36 a_17_37 a_17_38 a_17_39))) (assert (or (or (and (or (not x_18_0) (not x_18_1) (not x_18_2)) (or x_18_0 (not x_18_1) (not x_18_2)) (or (not x_18_0) x_18_1 (not x_18_2)) (or x_18_0 x_18_1 (not x_18_2)) (or (not x_18_0) (not x_18_1) x_18_2) (or x_18_0 (not x_18_1) x_18_2) (or (not x_18_0) x_18_1 x_18_2) (or x_18_0 x_18_1 x_18_2))) (distinct a_18_0 a_18_1 a_18_2 a_18_3 a_18_4 a_18_5 a_18_6 a_18_7 a_18_8 a_18_9 a_18_10 a_18_11 a_18_12 a_18_13 a_18_14 a_18_15 a_18_16 a_18_17 a_18_18 a_18_19 a_18_20 a_18_21 a_18_22 a_18_23 a_18_24 a_18_25 a_18_26 a_18_27 a_18_28 a_18_29 a_18_30 a_18_31 a_18_32 a_18_33 a_18_34 a_18_35 a_18_36 a_18_37 a_18_38 a_18_39))) (assert (or (or (and (or (not x_19_0) (not x_19_1) (not x_19_2)) (or x_19_0 (not x_19_1) (not x_19_2)) (or (not x_19_0) x_19_1 (not x_19_2)) (or x_19_0 x_19_1 (not x_19_2)) (or (not x_19_0) (not x_19_1) x_19_2) (or x_19_0 (not x_19_1) x_19_2) (or (not x_19_0) x_19_1 x_19_2) (or x_19_0 x_19_1 x_19_2))) (distinct a_19_0 a_19_1 a_19_2 a_19_3 a_19_4 a_19_5 a_19_6 a_19_7 a_19_8 a_19_9 a_19_10 a_19_11 a_19_12 a_19_13 a_19_14 a_19_15 a_19_16 a_19_17 a_19_18 a_19_19 a_19_20 a_19_21 a_19_22 a_19_23 a_19_24 a_19_25 a_19_26 a_19_27 a_19_28 a_19_29 a_19_30 a_19_31 a_19_32 a_19_33 a_19_34 a_19_35 a_19_36 a_19_37 a_19_38 a_19_39))) (assert (or (or (and (or (not x_20_0) (not x_20_1) (not x_20_2)) (or x_20_0 (not x_20_1) (not x_20_2)) (or (not x_20_0) x_20_1 (not x_20_2)) (or x_20_0 x_20_1 (not x_20_2)) (or (not x_20_0) (not x_20_1) x_20_2) (or x_20_0 (not x_20_1) x_20_2) (or (not x_20_0) x_20_1 x_20_2) (or x_20_0 x_20_1 x_20_2))) (distinct a_20_0 a_20_1 a_20_2 a_20_3 a_20_4 a_20_5 a_20_6 a_20_7 a_20_8 a_20_9 a_20_10 a_20_11 a_20_12 a_20_13 a_20_14 a_20_15 a_20_16 a_20_17 a_20_18 a_20_19 a_20_20 a_20_21 a_20_22 a_20_23 a_20_24 a_20_25 a_20_26 a_20_27 a_20_28 a_20_29 a_20_30 a_20_31 a_20_32 a_20_33 a_20_34 a_20_35 a_20_36 a_20_37 a_20_38 a_20_39))) (assert (or (or (and (or (not x_21_0) (not x_21_1) (not x_21_2)) (or x_21_0 (not x_21_1) (not x_21_2)) (or (not x_21_0) x_21_1 (not x_21_2)) (or x_21_0 x_21_1 (not x_21_2)) (or (not x_21_0) (not x_21_1) x_21_2) (or x_21_0 (not x_21_1) x_21_2) (or (not x_21_0) x_21_1 x_21_2) (or x_21_0 x_21_1 x_21_2))) (distinct a_21_0 a_21_1 a_21_2 a_21_3 a_21_4 a_21_5 a_21_6 a_21_7 a_21_8 a_21_9 a_21_10 a_21_11 a_21_12 a_21_13 a_21_14 a_21_15 a_21_16 a_21_17 a_21_18 a_21_19 a_21_20 a_21_21 a_21_22 a_21_23 a_21_24 a_21_25 a_21_26 a_21_27 a_21_28 a_21_29 a_21_30 a_21_31 a_21_32 a_21_33 a_21_34 a_21_35 a_21_36 a_21_37 a_21_38 a_21_39))) (assert (or (or (and (or (not x_22_0) (not x_22_1) (not x_22_2)) (or x_22_0 (not x_22_1) (not x_22_2)) (or (not x_22_0) x_22_1 (not x_22_2)) (or x_22_0 x_22_1 (not x_22_2)) (or (not x_22_0) (not x_22_1) x_22_2) (or x_22_0 (not x_22_1) x_22_2) (or (not x_22_0) x_22_1 x_22_2) (or x_22_0 x_22_1 x_22_2))) (distinct a_22_0 a_22_1 a_22_2 a_22_3 a_22_4 a_22_5 a_22_6 a_22_7 a_22_8 a_22_9 a_22_10 a_22_11 a_22_12 a_22_13 a_22_14 a_22_15 a_22_16 a_22_17 a_22_18 a_22_19 a_22_20 a_22_21 a_22_22 a_22_23 a_22_24 a_22_25 a_22_26 a_22_27 a_22_28 a_22_29 a_22_30 a_22_31 a_22_32 a_22_33 a_22_34 a_22_35 a_22_36 a_22_37 a_22_38 a_22_39))) (assert (or (or (and (or (not x_23_0) (not x_23_1) (not x_23_2)) (or x_23_0 (not x_23_1) (not x_23_2)) (or (not x_23_0) x_23_1 (not x_23_2)) (or x_23_0 x_23_1 (not x_23_2)) (or (not x_23_0) (not x_23_1) x_23_2) (or x_23_0 (not x_23_1) x_23_2) (or (not x_23_0) x_23_1 x_23_2) (or x_23_0 x_23_1 x_23_2))) (distinct a_23_0 a_23_1 a_23_2 a_23_3 a_23_4 a_23_5 a_23_6 a_23_7 a_23_8 a_23_9 a_23_10 a_23_11 a_23_12 a_23_13 a_23_14 a_23_15 a_23_16 a_23_17 a_23_18 a_23_19 a_23_20 a_23_21 a_23_22 a_23_23 a_23_24 a_23_25 a_23_26 a_23_27 a_23_28 a_23_29 a_23_30 a_23_31 a_23_32 a_23_33 a_23_34 a_23_35 a_23_36 a_23_37 a_23_38 a_23_39))) (assert (or (or (and (or (not x_24_0) (not x_24_1) (not x_24_2)) (or x_24_0 (not x_24_1) (not x_24_2)) (or (not x_24_0) x_24_1 (not x_24_2)) (or x_24_0 x_24_1 (not x_24_2)) (or (not x_24_0) (not x_24_1) x_24_2) (or x_24_0 (not x_24_1) x_24_2) (or (not x_24_0) x_24_1 x_24_2) (or x_24_0 x_24_1 x_24_2))) (distinct a_24_0 a_24_1 a_24_2 a_24_3 a_24_4 a_24_5 a_24_6 a_24_7 a_24_8 a_24_9 a_24_10 a_24_11 a_24_12 a_24_13 a_24_14 a_24_15 a_24_16 a_24_17 a_24_18 a_24_19 a_24_20 a_24_21 a_24_22 a_24_23 a_24_24 a_24_25 a_24_26 a_24_27 a_24_28 a_24_29 a_24_30 a_24_31 a_24_32 a_24_33 a_24_34 a_24_35 a_24_36 a_24_37 a_24_38 a_24_39))) (assert (or (or (and (or (not x_25_0) (not x_25_1) (not x_25_2)) (or x_25_0 (not x_25_1) (not x_25_2)) (or (not x_25_0) x_25_1 (not x_25_2)) (or x_25_0 x_25_1 (not x_25_2)) (or (not x_25_0) (not x_25_1) x_25_2) (or x_25_0 (not x_25_1) x_25_2) (or (not x_25_0) x_25_1 x_25_2) (or x_25_0 x_25_1 x_25_2))) (distinct a_25_0 a_25_1 a_25_2 a_25_3 a_25_4 a_25_5 a_25_6 a_25_7 a_25_8 a_25_9 a_25_10 a_25_11 a_25_12 a_25_13 a_25_14 a_25_15 a_25_16 a_25_17 a_25_18 a_25_19 a_25_20 a_25_21 a_25_22 a_25_23 a_25_24 a_25_25 a_25_26 a_25_27 a_25_28 a_25_29 a_25_30 a_25_31 a_25_32 a_25_33 a_25_34 a_25_35 a_25_36 a_25_37 a_25_38 a_25_39))) (assert (or (or (and (or (not x_26_0) (not x_26_1) (not x_26_2)) (or x_26_0 (not x_26_1) (not x_26_2)) (or (not x_26_0) x_26_1 (not x_26_2)) (or x_26_0 x_26_1 (not x_26_2)) (or (not x_26_0) (not x_26_1) x_26_2) (or x_26_0 (not x_26_1) x_26_2) (or (not x_26_0) x_26_1 x_26_2) (or x_26_0 x_26_1 x_26_2))) (distinct a_26_0 a_26_1 a_26_2 a_26_3 a_26_4 a_26_5 a_26_6 a_26_7 a_26_8 a_26_9 a_26_10 a_26_11 a_26_12 a_26_13 a_26_14 a_26_15 a_26_16 a_26_17 a_26_18 a_26_19 a_26_20 a_26_21 a_26_22 a_26_23 a_26_24 a_26_25 a_26_26 a_26_27 a_26_28 a_26_29 a_26_30 a_26_31 a_26_32 a_26_33 a_26_34 a_26_35 a_26_36 a_26_37 a_26_38 a_26_39))) (assert (or (or (and (or (not x_27_0) (not x_27_1) (not x_27_2)) (or x_27_0 (not x_27_1) (not x_27_2)) (or (not x_27_0) x_27_1 (not x_27_2)) (or x_27_0 x_27_1 (not x_27_2)) (or (not x_27_0) (not x_27_1) x_27_2) (or x_27_0 (not x_27_1) x_27_2) (or (not x_27_0) x_27_1 x_27_2) (or x_27_0 x_27_1 x_27_2))) (distinct a_27_0 a_27_1 a_27_2 a_27_3 a_27_4 a_27_5 a_27_6 a_27_7 a_27_8 a_27_9 a_27_10 a_27_11 a_27_12 a_27_13 a_27_14 a_27_15 a_27_16 a_27_17 a_27_18 a_27_19 a_27_20 a_27_21 a_27_22 a_27_23 a_27_24 a_27_25 a_27_26 a_27_27 a_27_28 a_27_29 a_27_30 a_27_31 a_27_32 a_27_33 a_27_34 a_27_35 a_27_36 a_27_37 a_27_38 a_27_39))) (assert (or (or (and (or (not x_28_0) (not x_28_1) (not x_28_2)) (or x_28_0 (not x_28_1) (not x_28_2)) (or (not x_28_0) x_28_1 (not x_28_2)) (or x_28_0 x_28_1 (not x_28_2)) (or (not x_28_0) (not x_28_1) x_28_2) (or x_28_0 (not x_28_1) x_28_2) (or (not x_28_0) x_28_1 x_28_2) (or x_28_0 x_28_1 x_28_2))) (distinct a_28_0 a_28_1 a_28_2 a_28_3 a_28_4 a_28_5 a_28_6 a_28_7 a_28_8 a_28_9 a_28_10 a_28_11 a_28_12 a_28_13 a_28_14 a_28_15 a_28_16 a_28_17 a_28_18 a_28_19 a_28_20 a_28_21 a_28_22 a_28_23 a_28_24 a_28_25 a_28_26 a_28_27 a_28_28 a_28_29 a_28_30 a_28_31 a_28_32 a_28_33 a_28_34 a_28_35 a_28_36 a_28_37 a_28_38 a_28_39))) (assert (or (or (and (or (not x_29_0) (not x_29_1) (not x_29_2)) (or x_29_0 (not x_29_1) (not x_29_2)) (or (not x_29_0) x_29_1 (not x_29_2)) (or x_29_0 x_29_1 (not x_29_2)) (or (not x_29_0) (not x_29_1) x_29_2) (or x_29_0 (not x_29_1) x_29_2) (or (not x_29_0) x_29_1 x_29_2) (or x_29_0 x_29_1 x_29_2))) (distinct a_29_0 a_29_1 a_29_2 a_29_3 a_29_4 a_29_5 a_29_6 a_29_7 a_29_8 a_29_9 a_29_10 a_29_11 a_29_12 a_29_13 a_29_14 a_29_15 a_29_16 a_29_17 a_29_18 a_29_19 a_29_20 a_29_21 a_29_22 a_29_23 a_29_24 a_29_25 a_29_26 a_29_27 a_29_28 a_29_29 a_29_30 a_29_31 a_29_32 a_29_33 a_29_34 a_29_35 a_29_36 a_29_37 a_29_38 a_29_39))) (assert (or (or (and (or (not x_30_0) (not x_30_1) (not x_30_2)) (or x_30_0 (not x_30_1) (not x_30_2)) (or (not x_30_0) x_30_1 (not x_30_2)) (or x_30_0 x_30_1 (not x_30_2)) (or (not x_30_0) (not x_30_1) x_30_2) (or x_30_0 (not x_30_1) x_30_2) (or (not x_30_0) x_30_1 x_30_2) (or x_30_0 x_30_1 x_30_2))) (distinct a_30_0 a_30_1 a_30_2 a_30_3 a_30_4 a_30_5 a_30_6 a_30_7 a_30_8 a_30_9 a_30_10 a_30_11 a_30_12 a_30_13 a_30_14 a_30_15 a_30_16 a_30_17 a_30_18 a_30_19 a_30_20 a_30_21 a_30_22 a_30_23 a_30_24 a_30_25 a_30_26 a_30_27 a_30_28 a_30_29 a_30_30 a_30_31 a_30_32 a_30_33 a_30_34 a_30_35 a_30_36 a_30_37 a_30_38 a_30_39))) (assert (or (or (and (or (not x_31_0) (not x_31_1) (not x_31_2)) (or x_31_0 (not x_31_1) (not x_31_2)) (or (not x_31_0) x_31_1 (not x_31_2)) (or x_31_0 x_31_1 (not x_31_2)) (or (not x_31_0) (not x_31_1) x_31_2) (or x_31_0 (not x_31_1) x_31_2) (or (not x_31_0) x_31_1 x_31_2) (or x_31_0 x_31_1 x_31_2))) (distinct a_31_0 a_31_1 a_31_2 a_31_3 a_31_4 a_31_5 a_31_6 a_31_7 a_31_8 a_31_9 a_31_10 a_31_11 a_31_12 a_31_13 a_31_14 a_31_15 a_31_16 a_31_17 a_31_18 a_31_19 a_31_20 a_31_21 a_31_22 a_31_23 a_31_24 a_31_25 a_31_26 a_31_27 a_31_28 a_31_29 a_31_30 a_31_31 a_31_32 a_31_33 a_31_34 a_31_35 a_31_36 a_31_37 a_31_38 a_31_39))) (assert (or (or (and (or (not x_32_0) (not x_32_1) (not x_32_2)) (or x_32_0 (not x_32_1) (not x_32_2)) (or (not x_32_0) x_32_1 (not x_32_2)) (or x_32_0 x_32_1 (not x_32_2)) (or (not x_32_0) (not x_32_1) x_32_2) (or x_32_0 (not x_32_1) x_32_2) (or (not x_32_0) x_32_1 x_32_2) (or x_32_0 x_32_1 x_32_2))) (distinct a_32_0 a_32_1 a_32_2 a_32_3 a_32_4 a_32_5 a_32_6 a_32_7 a_32_8 a_32_9 a_32_10 a_32_11 a_32_12 a_32_13 a_32_14 a_32_15 a_32_16 a_32_17 a_32_18 a_32_19 a_32_20 a_32_21 a_32_22 a_32_23 a_32_24 a_32_25 a_32_26 a_32_27 a_32_28 a_32_29 a_32_30 a_32_31 a_32_32 a_32_33 a_32_34 a_32_35 a_32_36 a_32_37 a_32_38 a_32_39))) (assert (or (or (and (or (not x_33_0) (not x_33_1) (not x_33_2)) (or x_33_0 (not x_33_1) (not x_33_2)) (or (not x_33_0) x_33_1 (not x_33_2)) (or x_33_0 x_33_1 (not x_33_2)) (or (not x_33_0) (not x_33_1) x_33_2) (or x_33_0 (not x_33_1) x_33_2) (or (not x_33_0) x_33_1 x_33_2) (or x_33_0 x_33_1 x_33_2))) (distinct a_33_0 a_33_1 a_33_2 a_33_3 a_33_4 a_33_5 a_33_6 a_33_7 a_33_8 a_33_9 a_33_10 a_33_11 a_33_12 a_33_13 a_33_14 a_33_15 a_33_16 a_33_17 a_33_18 a_33_19 a_33_20 a_33_21 a_33_22 a_33_23 a_33_24 a_33_25 a_33_26 a_33_27 a_33_28 a_33_29 a_33_30 a_33_31 a_33_32 a_33_33 a_33_34 a_33_35 a_33_36 a_33_37 a_33_38 a_33_39))) (assert (or (or (and (or (not x_34_0) (not x_34_1) (not x_34_2)) (or x_34_0 (not x_34_1) (not x_34_2)) (or (not x_34_0) x_34_1 (not x_34_2)) (or x_34_0 x_34_1 (not x_34_2)) (or (not x_34_0) (not x_34_1) x_34_2) (or x_34_0 (not x_34_1) x_34_2) (or (not x_34_0) x_34_1 x_34_2) (or x_34_0 x_34_1 x_34_2))) (distinct a_34_0 a_34_1 a_34_2 a_34_3 a_34_4 a_34_5 a_34_6 a_34_7 a_34_8 a_34_9 a_34_10 a_34_11 a_34_12 a_34_13 a_34_14 a_34_15 a_34_16 a_34_17 a_34_18 a_34_19 a_34_20 a_34_21 a_34_22 a_34_23 a_34_24 a_34_25 a_34_26 a_34_27 a_34_28 a_34_29 a_34_30 a_34_31 a_34_32 a_34_33 a_34_34 a_34_35 a_34_36 a_34_37 a_34_38 a_34_39))) (assert (or (or (and (or (not x_35_0) (not x_35_1) (not x_35_2)) (or x_35_0 (not x_35_1) (not x_35_2)) (or (not x_35_0) x_35_1 (not x_35_2)) (or x_35_0 x_35_1 (not x_35_2)) (or (not x_35_0) (not x_35_1) x_35_2) (or x_35_0 (not x_35_1) x_35_2) (or (not x_35_0) x_35_1 x_35_2) (or x_35_0 x_35_1 x_35_2))) (distinct a_35_0 a_35_1 a_35_2 a_35_3 a_35_4 a_35_5 a_35_6 a_35_7 a_35_8 a_35_9 a_35_10 a_35_11 a_35_12 a_35_13 a_35_14 a_35_15 a_35_16 a_35_17 a_35_18 a_35_19 a_35_20 a_35_21 a_35_22 a_35_23 a_35_24 a_35_25 a_35_26 a_35_27 a_35_28 a_35_29 a_35_30 a_35_31 a_35_32 a_35_33 a_35_34 a_35_35 a_35_36 a_35_37 a_35_38 a_35_39))) (assert (or (or (and (or (not x_36_0) (not x_36_1) (not x_36_2)) (or x_36_0 (not x_36_1) (not x_36_2)) (or (not x_36_0) x_36_1 (not x_36_2)) (or x_36_0 x_36_1 (not x_36_2)) (or (not x_36_0) (not x_36_1) x_36_2) (or x_36_0 (not x_36_1) x_36_2) (or (not x_36_0) x_36_1 x_36_2) (or x_36_0 x_36_1 x_36_2))) (distinct a_36_0 a_36_1 a_36_2 a_36_3 a_36_4 a_36_5 a_36_6 a_36_7 a_36_8 a_36_9 a_36_10 a_36_11 a_36_12 a_36_13 a_36_14 a_36_15 a_36_16 a_36_17 a_36_18 a_36_19 a_36_20 a_36_21 a_36_22 a_36_23 a_36_24 a_36_25 a_36_26 a_36_27 a_36_28 a_36_29 a_36_30 a_36_31 a_36_32 a_36_33 a_36_34 a_36_35 a_36_36 a_36_37 a_36_38 a_36_39))) (assert (or (or (and (or (not x_37_0) (not x_37_1) (not x_37_2)) (or x_37_0 (not x_37_1) (not x_37_2)) (or (not x_37_0) x_37_1 (not x_37_2)) (or x_37_0 x_37_1 (not x_37_2)) (or (not x_37_0) (not x_37_1) x_37_2) (or x_37_0 (not x_37_1) x_37_2) (or (not x_37_0) x_37_1 x_37_2) (or x_37_0 x_37_1 x_37_2))) (distinct a_37_0 a_37_1 a_37_2 a_37_3 a_37_4 a_37_5 a_37_6 a_37_7 a_37_8 a_37_9 a_37_10 a_37_11 a_37_12 a_37_13 a_37_14 a_37_15 a_37_16 a_37_17 a_37_18 a_37_19 a_37_20 a_37_21 a_37_22 a_37_23 a_37_24 a_37_25 a_37_26 a_37_27 a_37_28 a_37_29 a_37_30 a_37_31 a_37_32 a_37_33 a_37_34 a_37_35 a_37_36 a_37_37 a_37_38 a_37_39))) (assert (or (or (and (or (not x_38_0) (not x_38_1) (not x_38_2)) (or x_38_0 (not x_38_1) (not x_38_2)) (or (not x_38_0) x_38_1 (not x_38_2)) (or x_38_0 x_38_1 (not x_38_2)) (or (not x_38_0) (not x_38_1) x_38_2) (or x_38_0 (not x_38_1) x_38_2) (or (not x_38_0) x_38_1 x_38_2) (or x_38_0 x_38_1 x_38_2))) (distinct a_38_0 a_38_1 a_38_2 a_38_3 a_38_4 a_38_5 a_38_6 a_38_7 a_38_8 a_38_9 a_38_10 a_38_11 a_38_12 a_38_13 a_38_14 a_38_15 a_38_16 a_38_17 a_38_18 a_38_19 a_38_20 a_38_21 a_38_22 a_38_23 a_38_24 a_38_25 a_38_26 a_38_27 a_38_28 a_38_29 a_38_30 a_38_31 a_38_32 a_38_33 a_38_34 a_38_35 a_38_36 a_38_37 a_38_38 a_38_39))) (assert (or (or (and (or (not x_39_0) (not x_39_1) (not x_39_2)) (or x_39_0 (not x_39_1) (not x_39_2)) (or (not x_39_0) x_39_1 (not x_39_2)) (or x_39_0 x_39_1 (not x_39_2)) (or (not x_39_0) (not x_39_1) x_39_2) (or x_39_0 (not x_39_1) x_39_2) (or (not x_39_0) x_39_1 x_39_2) (or x_39_0 x_39_1 x_39_2))) (distinct a_39_0 a_39_1 a_39_2 a_39_3 a_39_4 a_39_5 a_39_6 a_39_7 a_39_8 a_39_9 a_39_10 a_39_11 a_39_12 a_39_13 a_39_14 a_39_15 a_39_16 a_39_17 a_39_18 a_39_19 a_39_20 a_39_21 a_39_22 a_39_23 a_39_24 a_39_25 a_39_26 a_39_27 a_39_28 a_39_29 a_39_30 a_39_31 a_39_32 a_39_33 a_39_34 a_39_35 a_39_36 a_39_37 a_39_38 a_39_39))) (assert (and (= a_0_0 a_1_0) (= a_1_0 a_2_0) (= a_2_0 a_3_0) (= a_3_0 a_4_0) (= a_4_0 a_5_0) (= a_5_0 a_6_0) (= a_6_0 a_7_0) (= a_7_0 a_8_0) (= a_8_0 a_9_0) (= a_9_0 a_10_0) (= a_10_0 a_11_0) (= a_11_0 a_12_0) (= a_12_0 a_13_0) (= a_13_0 a_14_0) (= a_14_0 a_15_0) (= a_15_0 a_16_0) (= a_16_0 a_17_0) (= a_17_0 a_18_0) (= a_18_0 a_19_0) (= a_19_0 a_20_0) (= a_20_0 a_21_0) (= a_21_0 a_22_0) (= a_22_0 a_23_0) (= a_23_0 a_24_0) (= a_24_0 a_25_0) (= a_25_0 a_26_0) (= a_26_0 a_27_0) (= a_27_0 a_28_0) (= a_28_0 a_29_0) (= a_29_0 a_30_0) (= a_30_0 a_31_0) (= a_31_0 a_32_0) (= a_32_0 a_33_0) (= a_33_0 a_34_0) (= a_34_0 a_35_0) (= a_35_0 a_36_0) (= a_36_0 a_37_0) (= a_37_0 a_38_0) (= a_38_0 a_39_0))) (check-sat) opensmt-2.5.2/regression/QF_UF/php_3_3_40_sat.smt2.expected.err000066400000000000000000000000001445011647600240660ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/php_3_3_40_sat.smt2.expected.out000066400000000000000000000000041445011647600241110ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/php_3_3_40_unsat.smt2000066400000000000000000002125571445011647600220700ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort U 0) (declare-fun x_0_0 () Bool) (declare-fun x_0_1 () Bool) (declare-fun x_0_2 () Bool) (declare-fun x_1_0 () Bool) (declare-fun x_1_1 () Bool) (declare-fun x_1_2 () Bool) (declare-fun x_2_0 () Bool) (declare-fun x_2_1 () Bool) (declare-fun x_2_2 () Bool) (declare-fun x_3_0 () Bool) (declare-fun x_3_1 () Bool) (declare-fun x_3_2 () Bool) (declare-fun x_4_0 () Bool) (declare-fun x_4_1 () Bool) (declare-fun x_4_2 () Bool) (declare-fun x_5_0 () Bool) (declare-fun x_5_1 () Bool) (declare-fun x_5_2 () Bool) (declare-fun x_6_0 () Bool) (declare-fun x_6_1 () Bool) (declare-fun x_6_2 () Bool) (declare-fun x_7_0 () Bool) (declare-fun x_7_1 () Bool) (declare-fun x_7_2 () Bool) (declare-fun x_8_0 () Bool) (declare-fun x_8_1 () Bool) (declare-fun x_8_2 () Bool) (declare-fun x_9_0 () Bool) (declare-fun x_9_1 () Bool) (declare-fun x_9_2 () Bool) (declare-fun x_10_0 () Bool) (declare-fun x_10_1 () Bool) (declare-fun x_10_2 () Bool) (declare-fun x_11_0 () Bool) (declare-fun x_11_1 () Bool) (declare-fun x_11_2 () Bool) (declare-fun x_12_0 () Bool) (declare-fun x_12_1 () Bool) (declare-fun x_12_2 () Bool) (declare-fun x_13_0 () Bool) (declare-fun x_13_1 () Bool) (declare-fun x_13_2 () Bool) (declare-fun x_14_0 () Bool) (declare-fun x_14_1 () Bool) (declare-fun x_14_2 () Bool) (declare-fun x_15_0 () Bool) (declare-fun x_15_1 () Bool) (declare-fun x_15_2 () Bool) (declare-fun x_16_0 () Bool) (declare-fun x_16_1 () Bool) (declare-fun x_16_2 () Bool) (declare-fun x_17_0 () Bool) (declare-fun x_17_1 () Bool) (declare-fun x_17_2 () Bool) (declare-fun x_18_0 () Bool) (declare-fun x_18_1 () Bool) (declare-fun x_18_2 () Bool) (declare-fun x_19_0 () Bool) (declare-fun x_19_1 () Bool) (declare-fun x_19_2 () Bool) (declare-fun x_20_0 () Bool) (declare-fun x_20_1 () Bool) (declare-fun x_20_2 () Bool) (declare-fun x_21_0 () Bool) (declare-fun x_21_1 () Bool) (declare-fun x_21_2 () Bool) (declare-fun x_22_0 () Bool) (declare-fun x_22_1 () Bool) (declare-fun x_22_2 () Bool) (declare-fun x_23_0 () Bool) (declare-fun x_23_1 () Bool) (declare-fun x_23_2 () Bool) (declare-fun x_24_0 () Bool) (declare-fun x_24_1 () Bool) (declare-fun x_24_2 () Bool) (declare-fun x_25_0 () Bool) (declare-fun x_25_1 () Bool) (declare-fun x_25_2 () Bool) (declare-fun x_26_0 () Bool) (declare-fun x_26_1 () Bool) (declare-fun x_26_2 () Bool) (declare-fun x_27_0 () Bool) (declare-fun x_27_1 () Bool) (declare-fun x_27_2 () Bool) (declare-fun x_28_0 () Bool) (declare-fun x_28_1 () Bool) (declare-fun x_28_2 () Bool) (declare-fun x_29_0 () Bool) (declare-fun x_29_1 () Bool) (declare-fun x_29_2 () Bool) (declare-fun x_30_0 () Bool) (declare-fun x_30_1 () Bool) (declare-fun x_30_2 () Bool) (declare-fun x_31_0 () Bool) (declare-fun x_31_1 () Bool) (declare-fun x_31_2 () Bool) (declare-fun x_32_0 () Bool) (declare-fun x_32_1 () Bool) (declare-fun x_32_2 () Bool) (declare-fun x_33_0 () Bool) (declare-fun x_33_1 () Bool) (declare-fun x_33_2 () Bool) (declare-fun x_34_0 () Bool) (declare-fun x_34_1 () Bool) (declare-fun x_34_2 () Bool) (declare-fun x_35_0 () Bool) (declare-fun x_35_1 () Bool) (declare-fun x_35_2 () Bool) (declare-fun x_36_0 () Bool) (declare-fun x_36_1 () Bool) (declare-fun x_36_2 () Bool) (declare-fun x_37_0 () Bool) (declare-fun x_37_1 () Bool) (declare-fun x_37_2 () Bool) (declare-fun x_38_0 () Bool) (declare-fun x_38_1 () Bool) (declare-fun x_38_2 () Bool) (declare-fun x_39_0 () Bool) (declare-fun x_39_1 () Bool) (declare-fun x_39_2 () Bool) (declare-fun a_0_0 () U) (declare-fun a_0_1 () U) (declare-fun a_0_2 () U) (declare-fun a_0_3 () U) (declare-fun a_0_4 () U) (declare-fun a_0_5 () U) (declare-fun a_0_6 () U) (declare-fun a_0_7 () U) (declare-fun a_0_8 () U) (declare-fun a_0_9 () U) (declare-fun a_0_10 () U) (declare-fun a_0_11 () U) (declare-fun a_0_12 () U) (declare-fun a_0_13 () U) (declare-fun a_0_14 () U) (declare-fun a_0_15 () U) (declare-fun a_0_16 () U) (declare-fun a_0_17 () U) (declare-fun a_0_18 () U) (declare-fun a_0_19 () U) (declare-fun a_0_20 () U) (declare-fun a_0_21 () U) (declare-fun a_0_22 () U) (declare-fun a_0_23 () U) (declare-fun a_0_24 () U) (declare-fun a_0_25 () U) (declare-fun a_0_26 () U) (declare-fun a_0_27 () U) (declare-fun a_0_28 () U) (declare-fun a_0_29 () U) (declare-fun a_0_30 () U) (declare-fun a_0_31 () U) (declare-fun a_0_32 () U) (declare-fun a_0_33 () U) (declare-fun a_0_34 () U) (declare-fun a_0_35 () U) (declare-fun a_0_36 () U) (declare-fun a_0_37 () U) (declare-fun a_0_38 () U) (declare-fun a_0_39 () U) (declare-fun a_1_0 () U) (declare-fun a_1_1 () U) (declare-fun a_1_2 () U) (declare-fun a_1_3 () U) (declare-fun a_1_4 () U) (declare-fun a_1_5 () U) (declare-fun a_1_6 () U) (declare-fun a_1_7 () U) (declare-fun a_1_8 () U) (declare-fun a_1_9 () U) (declare-fun a_1_10 () U) (declare-fun a_1_11 () U) (declare-fun a_1_12 () U) (declare-fun a_1_13 () U) (declare-fun a_1_14 () U) (declare-fun a_1_15 () U) (declare-fun a_1_16 () U) (declare-fun a_1_17 () U) (declare-fun a_1_18 () U) (declare-fun a_1_19 () U) (declare-fun a_1_20 () U) (declare-fun a_1_21 () U) (declare-fun a_1_22 () U) (declare-fun a_1_23 () U) (declare-fun a_1_24 () U) (declare-fun a_1_25 () U) (declare-fun a_1_26 () U) (declare-fun a_1_27 () U) (declare-fun a_1_28 () U) (declare-fun a_1_29 () U) (declare-fun a_1_30 () U) (declare-fun a_1_31 () U) (declare-fun a_1_32 () U) (declare-fun a_1_33 () U) (declare-fun a_1_34 () U) (declare-fun a_1_35 () U) (declare-fun a_1_36 () U) (declare-fun a_1_37 () U) (declare-fun a_1_38 () U) (declare-fun a_1_39 () U) (declare-fun a_2_0 () U) (declare-fun a_2_1 () U) (declare-fun a_2_2 () U) (declare-fun a_2_3 () U) (declare-fun a_2_4 () U) (declare-fun a_2_5 () U) (declare-fun a_2_6 () U) (declare-fun a_2_7 () U) (declare-fun a_2_8 () U) (declare-fun a_2_9 () U) (declare-fun a_2_10 () U) (declare-fun a_2_11 () U) (declare-fun a_2_12 () U) (declare-fun a_2_13 () U) (declare-fun a_2_14 () U) (declare-fun a_2_15 () U) (declare-fun a_2_16 () U) (declare-fun a_2_17 () U) (declare-fun a_2_18 () U) (declare-fun a_2_19 () U) (declare-fun a_2_20 () U) (declare-fun a_2_21 () U) (declare-fun a_2_22 () U) (declare-fun a_2_23 () U) (declare-fun a_2_24 () U) (declare-fun a_2_25 () U) (declare-fun a_2_26 () U) (declare-fun a_2_27 () U) (declare-fun a_2_28 () U) (declare-fun a_2_29 () U) (declare-fun a_2_30 () U) (declare-fun a_2_31 () U) (declare-fun a_2_32 () U) (declare-fun a_2_33 () U) (declare-fun a_2_34 () U) (declare-fun a_2_35 () U) (declare-fun a_2_36 () U) (declare-fun a_2_37 () U) (declare-fun a_2_38 () U) (declare-fun a_2_39 () U) (declare-fun a_3_0 () U) (declare-fun a_3_1 () U) (declare-fun a_3_2 () U) (declare-fun a_3_3 () U) (declare-fun a_3_4 () U) (declare-fun a_3_5 () U) (declare-fun a_3_6 () U) (declare-fun a_3_7 () U) (declare-fun a_3_8 () U) (declare-fun a_3_9 () U) (declare-fun a_3_10 () U) (declare-fun a_3_11 () U) (declare-fun a_3_12 () U) (declare-fun a_3_13 () U) (declare-fun a_3_14 () U) (declare-fun a_3_15 () U) (declare-fun a_3_16 () U) (declare-fun a_3_17 () U) (declare-fun a_3_18 () U) (declare-fun a_3_19 () U) (declare-fun a_3_20 () U) (declare-fun a_3_21 () U) (declare-fun a_3_22 () U) (declare-fun a_3_23 () U) (declare-fun a_3_24 () U) (declare-fun a_3_25 () U) (declare-fun a_3_26 () U) (declare-fun a_3_27 () U) (declare-fun a_3_28 () U) (declare-fun a_3_29 () U) (declare-fun a_3_30 () U) (declare-fun a_3_31 () U) (declare-fun a_3_32 () U) (declare-fun a_3_33 () U) (declare-fun a_3_34 () U) (declare-fun a_3_35 () U) (declare-fun a_3_36 () U) (declare-fun a_3_37 () U) (declare-fun a_3_38 () U) (declare-fun a_3_39 () U) (declare-fun a_4_0 () U) (declare-fun a_4_1 () U) (declare-fun a_4_2 () U) (declare-fun a_4_3 () U) (declare-fun a_4_4 () U) (declare-fun a_4_5 () U) (declare-fun a_4_6 () U) (declare-fun a_4_7 () U) (declare-fun a_4_8 () U) (declare-fun a_4_9 () U) (declare-fun a_4_10 () U) (declare-fun a_4_11 () U) (declare-fun a_4_12 () U) (declare-fun a_4_13 () U) (declare-fun a_4_14 () U) (declare-fun a_4_15 () U) (declare-fun a_4_16 () U) (declare-fun a_4_17 () U) (declare-fun a_4_18 () U) (declare-fun a_4_19 () U) (declare-fun a_4_20 () U) (declare-fun a_4_21 () U) (declare-fun a_4_22 () U) (declare-fun a_4_23 () U) (declare-fun a_4_24 () U) (declare-fun a_4_25 () U) (declare-fun a_4_26 () U) (declare-fun a_4_27 () U) (declare-fun a_4_28 () U) (declare-fun a_4_29 () U) (declare-fun a_4_30 () U) (declare-fun a_4_31 () U) (declare-fun a_4_32 () U) (declare-fun a_4_33 () U) (declare-fun a_4_34 () U) (declare-fun a_4_35 () U) (declare-fun a_4_36 () U) (declare-fun a_4_37 () U) (declare-fun a_4_38 () U) (declare-fun a_4_39 () U) (declare-fun a_5_0 () U) (declare-fun a_5_1 () U) (declare-fun a_5_2 () U) (declare-fun a_5_3 () U) (declare-fun a_5_4 () U) (declare-fun a_5_5 () U) (declare-fun a_5_6 () U) (declare-fun a_5_7 () U) (declare-fun a_5_8 () U) (declare-fun a_5_9 () U) (declare-fun a_5_10 () U) (declare-fun a_5_11 () U) (declare-fun a_5_12 () U) (declare-fun a_5_13 () U) (declare-fun a_5_14 () U) (declare-fun a_5_15 () U) (declare-fun a_5_16 () U) (declare-fun a_5_17 () U) (declare-fun a_5_18 () U) (declare-fun a_5_19 () U) (declare-fun a_5_20 () U) (declare-fun a_5_21 () U) (declare-fun a_5_22 () U) (declare-fun a_5_23 () U) (declare-fun a_5_24 () U) (declare-fun a_5_25 () U) (declare-fun a_5_26 () U) (declare-fun a_5_27 () U) (declare-fun a_5_28 () U) (declare-fun a_5_29 () U) (declare-fun a_5_30 () U) (declare-fun a_5_31 () U) (declare-fun a_5_32 () U) (declare-fun a_5_33 () U) (declare-fun a_5_34 () U) (declare-fun a_5_35 () U) (declare-fun a_5_36 () U) (declare-fun a_5_37 () U) (declare-fun a_5_38 () U) (declare-fun a_5_39 () U) (declare-fun a_6_0 () U) (declare-fun a_6_1 () U) (declare-fun a_6_2 () U) (declare-fun a_6_3 () U) (declare-fun a_6_4 () U) (declare-fun a_6_5 () U) (declare-fun a_6_6 () U) (declare-fun a_6_7 () U) (declare-fun a_6_8 () U) (declare-fun a_6_9 () U) (declare-fun a_6_10 () U) (declare-fun a_6_11 () U) (declare-fun a_6_12 () U) (declare-fun a_6_13 () U) (declare-fun a_6_14 () U) (declare-fun a_6_15 () U) (declare-fun a_6_16 () U) (declare-fun a_6_17 () U) (declare-fun a_6_18 () U) (declare-fun a_6_19 () U) (declare-fun a_6_20 () U) (declare-fun a_6_21 () U) (declare-fun a_6_22 () U) (declare-fun a_6_23 () U) (declare-fun a_6_24 () U) (declare-fun a_6_25 () U) (declare-fun a_6_26 () U) (declare-fun a_6_27 () U) (declare-fun a_6_28 () U) (declare-fun a_6_29 () U) (declare-fun a_6_30 () U) (declare-fun a_6_31 () U) (declare-fun a_6_32 () U) (declare-fun a_6_33 () U) (declare-fun a_6_34 () U) (declare-fun a_6_35 () U) (declare-fun a_6_36 () U) (declare-fun a_6_37 () U) (declare-fun a_6_38 () U) (declare-fun a_6_39 () U) (declare-fun a_7_0 () U) (declare-fun a_7_1 () U) (declare-fun a_7_2 () U) (declare-fun a_7_3 () U) (declare-fun a_7_4 () U) (declare-fun a_7_5 () U) (declare-fun a_7_6 () U) (declare-fun a_7_7 () U) (declare-fun a_7_8 () U) (declare-fun a_7_9 () U) (declare-fun a_7_10 () U) (declare-fun a_7_11 () U) (declare-fun a_7_12 () U) (declare-fun a_7_13 () U) (declare-fun a_7_14 () U) (declare-fun a_7_15 () U) (declare-fun a_7_16 () U) (declare-fun a_7_17 () U) (declare-fun a_7_18 () U) (declare-fun a_7_19 () U) (declare-fun a_7_20 () U) (declare-fun a_7_21 () U) (declare-fun a_7_22 () U) (declare-fun a_7_23 () U) (declare-fun a_7_24 () U) (declare-fun a_7_25 () U) (declare-fun a_7_26 () U) (declare-fun a_7_27 () U) (declare-fun a_7_28 () U) (declare-fun a_7_29 () U) (declare-fun a_7_30 () U) (declare-fun a_7_31 () U) (declare-fun a_7_32 () U) (declare-fun a_7_33 () U) (declare-fun a_7_34 () U) (declare-fun a_7_35 () U) (declare-fun a_7_36 () U) (declare-fun a_7_37 () U) (declare-fun a_7_38 () U) (declare-fun a_7_39 () U) (declare-fun a_8_0 () U) (declare-fun a_8_1 () U) (declare-fun a_8_2 () U) (declare-fun a_8_3 () U) (declare-fun a_8_4 () U) (declare-fun a_8_5 () U) (declare-fun a_8_6 () U) (declare-fun a_8_7 () U) (declare-fun a_8_8 () U) (declare-fun a_8_9 () U) (declare-fun a_8_10 () U) (declare-fun a_8_11 () U) (declare-fun a_8_12 () U) (declare-fun a_8_13 () U) (declare-fun a_8_14 () U) (declare-fun a_8_15 () U) (declare-fun a_8_16 () U) (declare-fun a_8_17 () U) (declare-fun a_8_18 () U) (declare-fun a_8_19 () U) (declare-fun a_8_20 () U) (declare-fun a_8_21 () U) (declare-fun a_8_22 () U) (declare-fun a_8_23 () U) (declare-fun a_8_24 () U) (declare-fun a_8_25 () U) (declare-fun a_8_26 () U) (declare-fun a_8_27 () U) (declare-fun a_8_28 () U) (declare-fun a_8_29 () U) (declare-fun a_8_30 () U) (declare-fun a_8_31 () U) (declare-fun a_8_32 () U) (declare-fun a_8_33 () U) (declare-fun a_8_34 () U) (declare-fun a_8_35 () U) (declare-fun a_8_36 () U) (declare-fun a_8_37 () U) (declare-fun a_8_38 () U) (declare-fun a_8_39 () U) (declare-fun a_9_0 () U) (declare-fun a_9_1 () U) (declare-fun a_9_2 () U) (declare-fun a_9_3 () U) (declare-fun a_9_4 () U) (declare-fun a_9_5 () U) (declare-fun a_9_6 () U) (declare-fun a_9_7 () U) (declare-fun a_9_8 () U) (declare-fun a_9_9 () U) (declare-fun a_9_10 () U) (declare-fun a_9_11 () U) (declare-fun a_9_12 () U) (declare-fun a_9_13 () U) (declare-fun a_9_14 () U) (declare-fun a_9_15 () U) (declare-fun a_9_16 () U) (declare-fun a_9_17 () U) (declare-fun a_9_18 () U) (declare-fun a_9_19 () U) (declare-fun a_9_20 () U) (declare-fun a_9_21 () U) (declare-fun a_9_22 () U) (declare-fun a_9_23 () U) (declare-fun a_9_24 () U) (declare-fun a_9_25 () U) (declare-fun a_9_26 () U) (declare-fun a_9_27 () U) (declare-fun a_9_28 () U) (declare-fun a_9_29 () U) (declare-fun a_9_30 () U) (declare-fun a_9_31 () U) (declare-fun a_9_32 () U) (declare-fun a_9_33 () U) (declare-fun a_9_34 () U) (declare-fun a_9_35 () U) (declare-fun a_9_36 () U) (declare-fun a_9_37 () U) (declare-fun a_9_38 () U) (declare-fun a_9_39 () U) (declare-fun a_10_0 () U) (declare-fun a_10_1 () U) (declare-fun a_10_2 () U) (declare-fun a_10_3 () U) (declare-fun a_10_4 () U) (declare-fun a_10_5 () U) (declare-fun a_10_6 () U) (declare-fun a_10_7 () U) (declare-fun a_10_8 () U) (declare-fun a_10_9 () U) (declare-fun a_10_10 () U) (declare-fun a_10_11 () U) (declare-fun a_10_12 () U) (declare-fun a_10_13 () U) (declare-fun a_10_14 () U) (declare-fun a_10_15 () U) (declare-fun a_10_16 () U) (declare-fun a_10_17 () U) (declare-fun a_10_18 () U) (declare-fun a_10_19 () U) (declare-fun a_10_20 () U) (declare-fun a_10_21 () U) (declare-fun a_10_22 () U) (declare-fun a_10_23 () U) (declare-fun a_10_24 () U) (declare-fun a_10_25 () U) (declare-fun a_10_26 () U) (declare-fun a_10_27 () U) (declare-fun a_10_28 () U) (declare-fun a_10_29 () U) (declare-fun a_10_30 () U) (declare-fun a_10_31 () U) (declare-fun a_10_32 () U) (declare-fun a_10_33 () U) (declare-fun a_10_34 () U) (declare-fun a_10_35 () U) (declare-fun a_10_36 () U) (declare-fun a_10_37 () U) (declare-fun a_10_38 () U) (declare-fun a_10_39 () U) (declare-fun a_11_0 () U) (declare-fun a_11_1 () U) (declare-fun a_11_2 () U) (declare-fun a_11_3 () U) (declare-fun a_11_4 () U) (declare-fun a_11_5 () U) (declare-fun a_11_6 () U) (declare-fun a_11_7 () U) (declare-fun a_11_8 () U) (declare-fun a_11_9 () U) (declare-fun a_11_10 () U) (declare-fun a_11_11 () U) (declare-fun a_11_12 () U) (declare-fun a_11_13 () U) (declare-fun a_11_14 () U) (declare-fun a_11_15 () U) (declare-fun a_11_16 () U) (declare-fun a_11_17 () U) (declare-fun a_11_18 () U) (declare-fun a_11_19 () U) (declare-fun a_11_20 () U) (declare-fun a_11_21 () U) (declare-fun a_11_22 () U) (declare-fun a_11_23 () U) (declare-fun a_11_24 () U) (declare-fun a_11_25 () U) (declare-fun a_11_26 () U) (declare-fun a_11_27 () U) (declare-fun a_11_28 () U) (declare-fun a_11_29 () U) (declare-fun a_11_30 () U) (declare-fun a_11_31 () U) (declare-fun a_11_32 () U) (declare-fun a_11_33 () U) (declare-fun a_11_34 () U) (declare-fun a_11_35 () U) (declare-fun a_11_36 () U) (declare-fun a_11_37 () U) (declare-fun a_11_38 () U) (declare-fun a_11_39 () U) (declare-fun a_12_0 () U) (declare-fun a_12_1 () U) (declare-fun a_12_2 () U) (declare-fun a_12_3 () U) (declare-fun a_12_4 () U) (declare-fun a_12_5 () U) (declare-fun a_12_6 () U) (declare-fun a_12_7 () U) (declare-fun a_12_8 () U) (declare-fun a_12_9 () U) (declare-fun a_12_10 () U) (declare-fun a_12_11 () U) (declare-fun a_12_12 () U) (declare-fun a_12_13 () U) (declare-fun a_12_14 () U) (declare-fun a_12_15 () U) (declare-fun a_12_16 () U) (declare-fun a_12_17 () U) (declare-fun a_12_18 () U) (declare-fun a_12_19 () U) (declare-fun a_12_20 () U) (declare-fun a_12_21 () U) (declare-fun a_12_22 () U) (declare-fun a_12_23 () U) (declare-fun a_12_24 () U) (declare-fun a_12_25 () U) (declare-fun a_12_26 () U) (declare-fun a_12_27 () U) (declare-fun a_12_28 () U) (declare-fun a_12_29 () U) (declare-fun a_12_30 () U) (declare-fun a_12_31 () U) (declare-fun a_12_32 () U) (declare-fun a_12_33 () U) (declare-fun a_12_34 () U) (declare-fun a_12_35 () U) (declare-fun a_12_36 () U) (declare-fun a_12_37 () U) (declare-fun a_12_38 () U) (declare-fun a_12_39 () U) (declare-fun a_13_0 () U) (declare-fun a_13_1 () U) (declare-fun a_13_2 () U) (declare-fun a_13_3 () U) (declare-fun a_13_4 () U) (declare-fun a_13_5 () U) (declare-fun a_13_6 () U) (declare-fun a_13_7 () U) (declare-fun a_13_8 () U) (declare-fun a_13_9 () U) (declare-fun a_13_10 () U) (declare-fun a_13_11 () U) (declare-fun a_13_12 () U) (declare-fun a_13_13 () U) (declare-fun a_13_14 () U) (declare-fun a_13_15 () U) (declare-fun a_13_16 () U) (declare-fun a_13_17 () U) (declare-fun a_13_18 () U) (declare-fun a_13_19 () U) (declare-fun a_13_20 () U) (declare-fun a_13_21 () U) (declare-fun a_13_22 () U) (declare-fun a_13_23 () U) (declare-fun a_13_24 () U) (declare-fun a_13_25 () U) (declare-fun a_13_26 () U) (declare-fun a_13_27 () U) (declare-fun a_13_28 () U) (declare-fun a_13_29 () U) (declare-fun a_13_30 () U) (declare-fun a_13_31 () U) (declare-fun a_13_32 () U) (declare-fun a_13_33 () U) (declare-fun a_13_34 () U) (declare-fun a_13_35 () U) (declare-fun a_13_36 () U) (declare-fun a_13_37 () U) (declare-fun a_13_38 () U) (declare-fun a_13_39 () U) (declare-fun a_14_0 () U) (declare-fun a_14_1 () U) (declare-fun a_14_2 () U) (declare-fun a_14_3 () U) (declare-fun a_14_4 () U) (declare-fun a_14_5 () U) (declare-fun a_14_6 () U) (declare-fun a_14_7 () U) (declare-fun a_14_8 () U) (declare-fun a_14_9 () U) (declare-fun a_14_10 () U) (declare-fun a_14_11 () U) (declare-fun a_14_12 () U) (declare-fun a_14_13 () U) (declare-fun a_14_14 () U) (declare-fun a_14_15 () U) (declare-fun a_14_16 () U) (declare-fun a_14_17 () U) (declare-fun a_14_18 () U) (declare-fun a_14_19 () U) (declare-fun a_14_20 () U) (declare-fun a_14_21 () U) (declare-fun a_14_22 () U) (declare-fun a_14_23 () U) (declare-fun a_14_24 () U) (declare-fun a_14_25 () U) (declare-fun a_14_26 () U) (declare-fun a_14_27 () U) (declare-fun a_14_28 () U) (declare-fun a_14_29 () U) (declare-fun a_14_30 () U) (declare-fun a_14_31 () U) (declare-fun a_14_32 () U) (declare-fun a_14_33 () U) (declare-fun a_14_34 () U) (declare-fun a_14_35 () U) (declare-fun a_14_36 () U) (declare-fun a_14_37 () U) (declare-fun a_14_38 () U) (declare-fun a_14_39 () U) (declare-fun a_15_0 () U) (declare-fun a_15_1 () U) (declare-fun a_15_2 () U) (declare-fun a_15_3 () U) (declare-fun a_15_4 () U) (declare-fun a_15_5 () U) (declare-fun a_15_6 () U) (declare-fun a_15_7 () U) (declare-fun a_15_8 () U) (declare-fun a_15_9 () U) (declare-fun a_15_10 () U) (declare-fun a_15_11 () U) (declare-fun a_15_12 () U) (declare-fun a_15_13 () U) (declare-fun a_15_14 () U) (declare-fun a_15_15 () U) (declare-fun a_15_16 () U) (declare-fun a_15_17 () U) (declare-fun a_15_18 () U) (declare-fun a_15_19 () U) (declare-fun a_15_20 () U) (declare-fun a_15_21 () U) (declare-fun a_15_22 () U) (declare-fun a_15_23 () U) (declare-fun a_15_24 () U) (declare-fun a_15_25 () U) (declare-fun a_15_26 () U) (declare-fun a_15_27 () U) (declare-fun a_15_28 () U) (declare-fun a_15_29 () U) (declare-fun a_15_30 () U) (declare-fun a_15_31 () U) (declare-fun a_15_32 () U) (declare-fun a_15_33 () U) (declare-fun a_15_34 () U) (declare-fun a_15_35 () U) (declare-fun a_15_36 () U) (declare-fun a_15_37 () U) (declare-fun a_15_38 () U) (declare-fun a_15_39 () U) (declare-fun a_16_0 () U) (declare-fun a_16_1 () U) (declare-fun a_16_2 () U) (declare-fun a_16_3 () U) (declare-fun a_16_4 () U) (declare-fun a_16_5 () U) (declare-fun a_16_6 () U) (declare-fun a_16_7 () U) (declare-fun a_16_8 () U) (declare-fun a_16_9 () U) (declare-fun a_16_10 () U) (declare-fun a_16_11 () U) (declare-fun a_16_12 () U) (declare-fun a_16_13 () U) (declare-fun a_16_14 () U) (declare-fun a_16_15 () U) (declare-fun a_16_16 () U) (declare-fun a_16_17 () U) (declare-fun a_16_18 () U) (declare-fun a_16_19 () U) (declare-fun a_16_20 () U) (declare-fun a_16_21 () U) (declare-fun a_16_22 () U) (declare-fun a_16_23 () U) (declare-fun a_16_24 () U) (declare-fun a_16_25 () U) (declare-fun a_16_26 () U) (declare-fun a_16_27 () U) (declare-fun a_16_28 () U) (declare-fun a_16_29 () U) (declare-fun a_16_30 () U) (declare-fun a_16_31 () U) (declare-fun a_16_32 () U) (declare-fun a_16_33 () U) (declare-fun a_16_34 () U) (declare-fun a_16_35 () U) (declare-fun a_16_36 () U) (declare-fun a_16_37 () U) (declare-fun a_16_38 () U) (declare-fun a_16_39 () U) (declare-fun a_17_0 () U) (declare-fun a_17_1 () U) (declare-fun a_17_2 () U) (declare-fun a_17_3 () U) (declare-fun a_17_4 () U) (declare-fun a_17_5 () U) (declare-fun a_17_6 () U) (declare-fun a_17_7 () U) (declare-fun a_17_8 () U) (declare-fun a_17_9 () U) (declare-fun a_17_10 () U) (declare-fun a_17_11 () U) (declare-fun a_17_12 () U) (declare-fun a_17_13 () U) (declare-fun a_17_14 () U) (declare-fun a_17_15 () U) (declare-fun a_17_16 () U) (declare-fun a_17_17 () U) (declare-fun a_17_18 () U) (declare-fun a_17_19 () U) (declare-fun a_17_20 () U) (declare-fun a_17_21 () U) (declare-fun a_17_22 () U) (declare-fun a_17_23 () U) (declare-fun a_17_24 () U) (declare-fun a_17_25 () U) (declare-fun a_17_26 () U) (declare-fun a_17_27 () U) (declare-fun a_17_28 () U) (declare-fun a_17_29 () U) (declare-fun a_17_30 () U) (declare-fun a_17_31 () U) (declare-fun a_17_32 () U) (declare-fun a_17_33 () U) (declare-fun a_17_34 () U) (declare-fun a_17_35 () U) (declare-fun a_17_36 () U) (declare-fun a_17_37 () U) (declare-fun a_17_38 () U) (declare-fun a_17_39 () U) (declare-fun a_18_0 () U) (declare-fun a_18_1 () U) (declare-fun a_18_2 () U) (declare-fun a_18_3 () U) (declare-fun a_18_4 () U) (declare-fun a_18_5 () U) (declare-fun a_18_6 () U) (declare-fun a_18_7 () U) (declare-fun a_18_8 () U) (declare-fun a_18_9 () U) (declare-fun a_18_10 () U) (declare-fun a_18_11 () U) (declare-fun a_18_12 () U) (declare-fun a_18_13 () U) (declare-fun a_18_14 () U) (declare-fun a_18_15 () U) (declare-fun a_18_16 () U) (declare-fun a_18_17 () U) (declare-fun a_18_18 () U) (declare-fun a_18_19 () U) (declare-fun a_18_20 () U) (declare-fun a_18_21 () U) (declare-fun a_18_22 () U) (declare-fun a_18_23 () U) (declare-fun a_18_24 () U) (declare-fun a_18_25 () U) (declare-fun a_18_26 () U) (declare-fun a_18_27 () U) (declare-fun a_18_28 () U) (declare-fun a_18_29 () U) (declare-fun a_18_30 () U) (declare-fun a_18_31 () U) (declare-fun a_18_32 () U) (declare-fun a_18_33 () U) (declare-fun a_18_34 () U) (declare-fun a_18_35 () U) (declare-fun a_18_36 () U) (declare-fun a_18_37 () U) (declare-fun a_18_38 () U) (declare-fun a_18_39 () U) (declare-fun a_19_0 () U) (declare-fun a_19_1 () U) (declare-fun a_19_2 () U) (declare-fun a_19_3 () U) (declare-fun a_19_4 () U) (declare-fun a_19_5 () U) (declare-fun a_19_6 () U) (declare-fun a_19_7 () U) (declare-fun a_19_8 () U) (declare-fun a_19_9 () U) (declare-fun a_19_10 () U) (declare-fun a_19_11 () U) (declare-fun a_19_12 () U) (declare-fun a_19_13 () U) (declare-fun a_19_14 () U) (declare-fun a_19_15 () U) (declare-fun a_19_16 () U) (declare-fun a_19_17 () U) (declare-fun a_19_18 () U) (declare-fun a_19_19 () U) (declare-fun a_19_20 () U) (declare-fun a_19_21 () U) (declare-fun a_19_22 () U) (declare-fun a_19_23 () U) (declare-fun a_19_24 () U) (declare-fun a_19_25 () U) (declare-fun a_19_26 () U) (declare-fun a_19_27 () U) (declare-fun a_19_28 () U) (declare-fun a_19_29 () U) (declare-fun a_19_30 () U) (declare-fun a_19_31 () U) (declare-fun a_19_32 () U) (declare-fun a_19_33 () U) (declare-fun a_19_34 () U) (declare-fun a_19_35 () U) (declare-fun a_19_36 () U) (declare-fun a_19_37 () U) (declare-fun a_19_38 () U) (declare-fun a_19_39 () U) (declare-fun a_20_0 () U) (declare-fun a_20_1 () U) (declare-fun a_20_2 () U) (declare-fun a_20_3 () U) (declare-fun a_20_4 () U) (declare-fun a_20_5 () U) (declare-fun a_20_6 () U) (declare-fun a_20_7 () U) (declare-fun a_20_8 () U) (declare-fun a_20_9 () U) (declare-fun a_20_10 () U) (declare-fun a_20_11 () U) (declare-fun a_20_12 () U) (declare-fun a_20_13 () U) (declare-fun a_20_14 () U) (declare-fun a_20_15 () U) (declare-fun a_20_16 () U) (declare-fun a_20_17 () U) (declare-fun a_20_18 () U) (declare-fun a_20_19 () U) (declare-fun a_20_20 () U) (declare-fun a_20_21 () U) (declare-fun a_20_22 () U) (declare-fun a_20_23 () U) (declare-fun a_20_24 () U) (declare-fun a_20_25 () U) (declare-fun a_20_26 () U) (declare-fun a_20_27 () U) (declare-fun a_20_28 () U) (declare-fun a_20_29 () U) (declare-fun a_20_30 () U) (declare-fun a_20_31 () U) (declare-fun a_20_32 () U) (declare-fun a_20_33 () U) (declare-fun a_20_34 () U) (declare-fun a_20_35 () U) (declare-fun a_20_36 () U) (declare-fun a_20_37 () U) (declare-fun a_20_38 () U) (declare-fun a_20_39 () U) (declare-fun a_21_0 () U) (declare-fun a_21_1 () U) (declare-fun a_21_2 () U) (declare-fun a_21_3 () U) (declare-fun a_21_4 () U) (declare-fun a_21_5 () U) (declare-fun a_21_6 () U) (declare-fun a_21_7 () U) (declare-fun a_21_8 () U) (declare-fun a_21_9 () U) (declare-fun a_21_10 () U) (declare-fun a_21_11 () U) (declare-fun a_21_12 () U) (declare-fun a_21_13 () U) (declare-fun a_21_14 () U) (declare-fun a_21_15 () U) (declare-fun a_21_16 () U) (declare-fun a_21_17 () U) (declare-fun a_21_18 () U) (declare-fun a_21_19 () U) (declare-fun a_21_20 () U) (declare-fun a_21_21 () U) (declare-fun a_21_22 () U) (declare-fun a_21_23 () U) (declare-fun a_21_24 () U) (declare-fun a_21_25 () U) (declare-fun a_21_26 () U) (declare-fun a_21_27 () U) (declare-fun a_21_28 () U) (declare-fun a_21_29 () U) (declare-fun a_21_30 () U) (declare-fun a_21_31 () U) (declare-fun a_21_32 () U) (declare-fun a_21_33 () U) (declare-fun a_21_34 () U) (declare-fun a_21_35 () U) (declare-fun a_21_36 () U) (declare-fun a_21_37 () U) (declare-fun a_21_38 () U) (declare-fun a_21_39 () U) (declare-fun a_22_0 () U) (declare-fun a_22_1 () U) (declare-fun a_22_2 () U) (declare-fun a_22_3 () U) (declare-fun a_22_4 () U) (declare-fun a_22_5 () U) (declare-fun a_22_6 () U) (declare-fun a_22_7 () U) (declare-fun a_22_8 () U) (declare-fun a_22_9 () U) (declare-fun a_22_10 () U) (declare-fun a_22_11 () U) (declare-fun a_22_12 () U) (declare-fun a_22_13 () U) (declare-fun a_22_14 () U) (declare-fun a_22_15 () U) (declare-fun a_22_16 () U) (declare-fun a_22_17 () U) (declare-fun a_22_18 () U) (declare-fun a_22_19 () U) (declare-fun a_22_20 () U) (declare-fun a_22_21 () U) (declare-fun a_22_22 () U) (declare-fun a_22_23 () U) (declare-fun a_22_24 () U) (declare-fun a_22_25 () U) (declare-fun a_22_26 () U) (declare-fun a_22_27 () U) (declare-fun a_22_28 () U) (declare-fun a_22_29 () U) (declare-fun a_22_30 () U) (declare-fun a_22_31 () U) (declare-fun a_22_32 () U) (declare-fun a_22_33 () U) (declare-fun a_22_34 () U) (declare-fun a_22_35 () U) (declare-fun a_22_36 () U) (declare-fun a_22_37 () U) (declare-fun a_22_38 () U) (declare-fun a_22_39 () U) (declare-fun a_23_0 () U) (declare-fun a_23_1 () U) (declare-fun a_23_2 () U) (declare-fun a_23_3 () U) (declare-fun a_23_4 () U) (declare-fun a_23_5 () U) (declare-fun a_23_6 () U) (declare-fun a_23_7 () U) (declare-fun a_23_8 () U) (declare-fun a_23_9 () U) (declare-fun a_23_10 () U) (declare-fun a_23_11 () U) (declare-fun a_23_12 () U) (declare-fun a_23_13 () U) (declare-fun a_23_14 () U) (declare-fun a_23_15 () U) (declare-fun a_23_16 () U) (declare-fun a_23_17 () U) (declare-fun a_23_18 () U) (declare-fun a_23_19 () U) (declare-fun a_23_20 () U) (declare-fun a_23_21 () U) (declare-fun a_23_22 () U) (declare-fun a_23_23 () U) (declare-fun a_23_24 () U) (declare-fun a_23_25 () U) (declare-fun a_23_26 () U) (declare-fun a_23_27 () U) (declare-fun a_23_28 () U) (declare-fun a_23_29 () U) (declare-fun a_23_30 () U) (declare-fun a_23_31 () U) (declare-fun a_23_32 () U) (declare-fun a_23_33 () U) (declare-fun a_23_34 () U) (declare-fun a_23_35 () U) (declare-fun a_23_36 () U) (declare-fun a_23_37 () U) (declare-fun a_23_38 () U) (declare-fun a_23_39 () U) (declare-fun a_24_0 () U) (declare-fun a_24_1 () U) (declare-fun a_24_2 () U) (declare-fun a_24_3 () U) (declare-fun a_24_4 () U) (declare-fun a_24_5 () U) (declare-fun a_24_6 () U) (declare-fun a_24_7 () U) (declare-fun a_24_8 () U) (declare-fun a_24_9 () U) (declare-fun a_24_10 () U) (declare-fun a_24_11 () U) (declare-fun a_24_12 () U) (declare-fun a_24_13 () U) (declare-fun a_24_14 () U) (declare-fun a_24_15 () U) (declare-fun a_24_16 () U) (declare-fun a_24_17 () U) (declare-fun a_24_18 () U) (declare-fun a_24_19 () U) (declare-fun a_24_20 () U) (declare-fun a_24_21 () U) (declare-fun a_24_22 () U) (declare-fun a_24_23 () U) (declare-fun a_24_24 () U) (declare-fun a_24_25 () U) (declare-fun a_24_26 () U) (declare-fun a_24_27 () U) (declare-fun a_24_28 () U) (declare-fun a_24_29 () U) (declare-fun a_24_30 () U) (declare-fun a_24_31 () U) (declare-fun a_24_32 () U) (declare-fun a_24_33 () U) (declare-fun a_24_34 () U) (declare-fun a_24_35 () U) (declare-fun a_24_36 () U) (declare-fun a_24_37 () U) (declare-fun a_24_38 () U) (declare-fun a_24_39 () U) (declare-fun a_25_0 () U) (declare-fun a_25_1 () U) (declare-fun a_25_2 () U) (declare-fun a_25_3 () U) (declare-fun a_25_4 () U) (declare-fun a_25_5 () U) (declare-fun a_25_6 () U) (declare-fun a_25_7 () U) (declare-fun a_25_8 () U) (declare-fun a_25_9 () U) (declare-fun a_25_10 () U) (declare-fun a_25_11 () U) (declare-fun a_25_12 () U) (declare-fun a_25_13 () U) (declare-fun a_25_14 () U) (declare-fun a_25_15 () U) (declare-fun a_25_16 () U) (declare-fun a_25_17 () U) (declare-fun a_25_18 () U) (declare-fun a_25_19 () U) (declare-fun a_25_20 () U) (declare-fun a_25_21 () U) (declare-fun a_25_22 () U) (declare-fun a_25_23 () U) (declare-fun a_25_24 () U) (declare-fun a_25_25 () U) (declare-fun a_25_26 () U) (declare-fun a_25_27 () U) (declare-fun a_25_28 () U) (declare-fun a_25_29 () U) (declare-fun a_25_30 () U) (declare-fun a_25_31 () U) (declare-fun a_25_32 () U) (declare-fun a_25_33 () U) (declare-fun a_25_34 () U) (declare-fun a_25_35 () U) (declare-fun a_25_36 () U) (declare-fun a_25_37 () U) (declare-fun a_25_38 () U) (declare-fun a_25_39 () U) (declare-fun a_26_0 () U) (declare-fun a_26_1 () U) (declare-fun a_26_2 () U) (declare-fun a_26_3 () U) (declare-fun a_26_4 () U) (declare-fun a_26_5 () U) (declare-fun a_26_6 () U) (declare-fun a_26_7 () U) (declare-fun a_26_8 () U) (declare-fun a_26_9 () U) (declare-fun a_26_10 () U) (declare-fun a_26_11 () U) (declare-fun a_26_12 () U) (declare-fun a_26_13 () U) (declare-fun a_26_14 () U) (declare-fun a_26_15 () U) (declare-fun a_26_16 () U) (declare-fun a_26_17 () U) (declare-fun a_26_18 () U) (declare-fun a_26_19 () U) (declare-fun a_26_20 () U) (declare-fun a_26_21 () U) (declare-fun a_26_22 () U) (declare-fun a_26_23 () U) (declare-fun a_26_24 () U) (declare-fun a_26_25 () U) (declare-fun a_26_26 () U) (declare-fun a_26_27 () U) (declare-fun a_26_28 () U) (declare-fun a_26_29 () U) (declare-fun a_26_30 () U) (declare-fun a_26_31 () U) (declare-fun a_26_32 () U) (declare-fun a_26_33 () U) (declare-fun a_26_34 () U) (declare-fun a_26_35 () U) (declare-fun a_26_36 () U) (declare-fun a_26_37 () U) (declare-fun a_26_38 () U) (declare-fun a_26_39 () U) (declare-fun a_27_0 () U) (declare-fun a_27_1 () U) (declare-fun a_27_2 () U) (declare-fun a_27_3 () U) (declare-fun a_27_4 () U) (declare-fun a_27_5 () U) (declare-fun a_27_6 () U) (declare-fun a_27_7 () U) (declare-fun a_27_8 () U) (declare-fun a_27_9 () U) (declare-fun a_27_10 () U) (declare-fun a_27_11 () U) (declare-fun a_27_12 () U) (declare-fun a_27_13 () U) (declare-fun a_27_14 () U) (declare-fun a_27_15 () U) (declare-fun a_27_16 () U) (declare-fun a_27_17 () U) (declare-fun a_27_18 () U) (declare-fun a_27_19 () U) (declare-fun a_27_20 () U) (declare-fun a_27_21 () U) (declare-fun a_27_22 () U) (declare-fun a_27_23 () U) (declare-fun a_27_24 () U) (declare-fun a_27_25 () U) (declare-fun a_27_26 () U) (declare-fun a_27_27 () U) (declare-fun a_27_28 () U) (declare-fun a_27_29 () U) (declare-fun a_27_30 () U) (declare-fun a_27_31 () U) (declare-fun a_27_32 () U) (declare-fun a_27_33 () U) (declare-fun a_27_34 () U) (declare-fun a_27_35 () U) (declare-fun a_27_36 () U) (declare-fun a_27_37 () U) (declare-fun a_27_38 () U) (declare-fun a_27_39 () U) (declare-fun a_28_0 () U) (declare-fun a_28_1 () U) (declare-fun a_28_2 () U) (declare-fun a_28_3 () U) (declare-fun a_28_4 () U) (declare-fun a_28_5 () U) (declare-fun a_28_6 () U) (declare-fun a_28_7 () U) (declare-fun a_28_8 () U) (declare-fun a_28_9 () U) (declare-fun a_28_10 () U) (declare-fun a_28_11 () U) (declare-fun a_28_12 () U) (declare-fun a_28_13 () U) (declare-fun a_28_14 () U) (declare-fun a_28_15 () U) (declare-fun a_28_16 () U) (declare-fun a_28_17 () U) (declare-fun a_28_18 () U) (declare-fun a_28_19 () U) (declare-fun a_28_20 () U) (declare-fun a_28_21 () U) (declare-fun a_28_22 () U) (declare-fun a_28_23 () U) (declare-fun a_28_24 () U) (declare-fun a_28_25 () U) (declare-fun a_28_26 () U) (declare-fun a_28_27 () U) (declare-fun a_28_28 () U) (declare-fun a_28_29 () U) (declare-fun a_28_30 () U) (declare-fun a_28_31 () U) (declare-fun a_28_32 () U) (declare-fun a_28_33 () U) (declare-fun a_28_34 () U) (declare-fun a_28_35 () U) (declare-fun a_28_36 () U) (declare-fun a_28_37 () U) (declare-fun a_28_38 () U) (declare-fun a_28_39 () U) (declare-fun a_29_0 () U) (declare-fun a_29_1 () U) (declare-fun a_29_2 () U) (declare-fun a_29_3 () U) (declare-fun a_29_4 () U) (declare-fun a_29_5 () U) (declare-fun a_29_6 () U) (declare-fun a_29_7 () U) (declare-fun a_29_8 () U) (declare-fun a_29_9 () U) (declare-fun a_29_10 () U) (declare-fun a_29_11 () U) (declare-fun a_29_12 () U) (declare-fun a_29_13 () U) (declare-fun a_29_14 () U) (declare-fun a_29_15 () U) (declare-fun a_29_16 () U) (declare-fun a_29_17 () U) (declare-fun a_29_18 () U) (declare-fun a_29_19 () U) (declare-fun a_29_20 () U) (declare-fun a_29_21 () U) (declare-fun a_29_22 () U) (declare-fun a_29_23 () U) (declare-fun a_29_24 () U) (declare-fun a_29_25 () U) (declare-fun a_29_26 () U) (declare-fun a_29_27 () U) (declare-fun a_29_28 () U) (declare-fun a_29_29 () U) (declare-fun a_29_30 () U) (declare-fun a_29_31 () U) (declare-fun a_29_32 () U) (declare-fun a_29_33 () U) (declare-fun a_29_34 () U) (declare-fun a_29_35 () U) (declare-fun a_29_36 () U) (declare-fun a_29_37 () U) (declare-fun a_29_38 () U) (declare-fun a_29_39 () U) (declare-fun a_30_0 () U) (declare-fun a_30_1 () U) (declare-fun a_30_2 () U) (declare-fun a_30_3 () U) (declare-fun a_30_4 () U) (declare-fun a_30_5 () U) (declare-fun a_30_6 () U) (declare-fun a_30_7 () U) (declare-fun a_30_8 () U) (declare-fun a_30_9 () U) (declare-fun a_30_10 () U) (declare-fun a_30_11 () U) (declare-fun a_30_12 () U) (declare-fun a_30_13 () U) (declare-fun a_30_14 () U) (declare-fun a_30_15 () U) (declare-fun a_30_16 () U) (declare-fun a_30_17 () U) (declare-fun a_30_18 () U) (declare-fun a_30_19 () U) (declare-fun a_30_20 () U) (declare-fun a_30_21 () U) (declare-fun a_30_22 () U) (declare-fun a_30_23 () U) (declare-fun a_30_24 () U) (declare-fun a_30_25 () U) (declare-fun a_30_26 () U) (declare-fun a_30_27 () U) (declare-fun a_30_28 () U) (declare-fun a_30_29 () U) (declare-fun a_30_30 () U) (declare-fun a_30_31 () U) (declare-fun a_30_32 () U) (declare-fun a_30_33 () U) (declare-fun a_30_34 () U) (declare-fun a_30_35 () U) (declare-fun a_30_36 () U) (declare-fun a_30_37 () U) (declare-fun a_30_38 () U) (declare-fun a_30_39 () U) (declare-fun a_31_0 () U) (declare-fun a_31_1 () U) (declare-fun a_31_2 () U) (declare-fun a_31_3 () U) (declare-fun a_31_4 () U) (declare-fun a_31_5 () U) (declare-fun a_31_6 () U) (declare-fun a_31_7 () U) (declare-fun a_31_8 () U) (declare-fun a_31_9 () U) (declare-fun a_31_10 () U) (declare-fun a_31_11 () U) (declare-fun a_31_12 () U) (declare-fun a_31_13 () U) (declare-fun a_31_14 () U) (declare-fun a_31_15 () U) (declare-fun a_31_16 () U) (declare-fun a_31_17 () U) (declare-fun a_31_18 () U) (declare-fun a_31_19 () U) (declare-fun a_31_20 () U) (declare-fun a_31_21 () U) (declare-fun a_31_22 () U) (declare-fun a_31_23 () U) (declare-fun a_31_24 () U) (declare-fun a_31_25 () U) (declare-fun a_31_26 () U) (declare-fun a_31_27 () U) (declare-fun a_31_28 () U) (declare-fun a_31_29 () U) (declare-fun a_31_30 () U) (declare-fun a_31_31 () U) (declare-fun a_31_32 () U) (declare-fun a_31_33 () U) (declare-fun a_31_34 () U) (declare-fun a_31_35 () U) (declare-fun a_31_36 () U) (declare-fun a_31_37 () U) (declare-fun a_31_38 () U) (declare-fun a_31_39 () U) (declare-fun a_32_0 () U) (declare-fun a_32_1 () U) (declare-fun a_32_2 () U) (declare-fun a_32_3 () U) (declare-fun a_32_4 () U) (declare-fun a_32_5 () U) (declare-fun a_32_6 () U) (declare-fun a_32_7 () U) (declare-fun a_32_8 () U) (declare-fun a_32_9 () U) (declare-fun a_32_10 () U) (declare-fun a_32_11 () U) (declare-fun a_32_12 () U) (declare-fun a_32_13 () U) (declare-fun a_32_14 () U) (declare-fun a_32_15 () U) (declare-fun a_32_16 () U) (declare-fun a_32_17 () U) (declare-fun a_32_18 () U) (declare-fun a_32_19 () U) (declare-fun a_32_20 () U) (declare-fun a_32_21 () U) (declare-fun a_32_22 () U) (declare-fun a_32_23 () U) (declare-fun a_32_24 () U) (declare-fun a_32_25 () U) (declare-fun a_32_26 () U) (declare-fun a_32_27 () U) (declare-fun a_32_28 () U) (declare-fun a_32_29 () U) (declare-fun a_32_30 () U) (declare-fun a_32_31 () U) (declare-fun a_32_32 () U) (declare-fun a_32_33 () U) (declare-fun a_32_34 () U) (declare-fun a_32_35 () U) (declare-fun a_32_36 () U) (declare-fun a_32_37 () U) (declare-fun a_32_38 () U) (declare-fun a_32_39 () U) (declare-fun a_33_0 () U) (declare-fun a_33_1 () U) (declare-fun a_33_2 () U) (declare-fun a_33_3 () U) (declare-fun a_33_4 () U) (declare-fun a_33_5 () U) (declare-fun a_33_6 () U) (declare-fun a_33_7 () U) (declare-fun a_33_8 () U) (declare-fun a_33_9 () U) (declare-fun a_33_10 () U) (declare-fun a_33_11 () U) (declare-fun a_33_12 () U) (declare-fun a_33_13 () U) (declare-fun a_33_14 () U) (declare-fun a_33_15 () U) (declare-fun a_33_16 () U) (declare-fun a_33_17 () U) (declare-fun a_33_18 () U) (declare-fun a_33_19 () U) (declare-fun a_33_20 () U) (declare-fun a_33_21 () U) (declare-fun a_33_22 () U) (declare-fun a_33_23 () U) (declare-fun a_33_24 () U) (declare-fun a_33_25 () U) (declare-fun a_33_26 () U) (declare-fun a_33_27 () U) (declare-fun a_33_28 () U) (declare-fun a_33_29 () U) (declare-fun a_33_30 () U) (declare-fun a_33_31 () U) (declare-fun a_33_32 () U) (declare-fun a_33_33 () U) (declare-fun a_33_34 () U) (declare-fun a_33_35 () U) (declare-fun a_33_36 () U) (declare-fun a_33_37 () U) (declare-fun a_33_38 () U) (declare-fun a_33_39 () U) (declare-fun a_34_0 () U) (declare-fun a_34_1 () U) (declare-fun a_34_2 () U) (declare-fun a_34_3 () U) (declare-fun a_34_4 () U) (declare-fun a_34_5 () U) (declare-fun a_34_6 () U) (declare-fun a_34_7 () U) (declare-fun a_34_8 () U) (declare-fun a_34_9 () U) (declare-fun a_34_10 () U) (declare-fun a_34_11 () U) (declare-fun a_34_12 () U) (declare-fun a_34_13 () U) (declare-fun a_34_14 () U) (declare-fun a_34_15 () U) (declare-fun a_34_16 () U) (declare-fun a_34_17 () U) (declare-fun a_34_18 () U) (declare-fun a_34_19 () U) (declare-fun a_34_20 () U) (declare-fun a_34_21 () U) (declare-fun a_34_22 () U) (declare-fun a_34_23 () U) (declare-fun a_34_24 () U) (declare-fun a_34_25 () U) (declare-fun a_34_26 () U) (declare-fun a_34_27 () U) (declare-fun a_34_28 () U) (declare-fun a_34_29 () U) (declare-fun a_34_30 () U) (declare-fun a_34_31 () U) (declare-fun a_34_32 () U) (declare-fun a_34_33 () U) (declare-fun a_34_34 () U) (declare-fun a_34_35 () U) (declare-fun a_34_36 () U) (declare-fun a_34_37 () U) (declare-fun a_34_38 () U) (declare-fun a_34_39 () U) (declare-fun a_35_0 () U) (declare-fun a_35_1 () U) (declare-fun a_35_2 () U) (declare-fun a_35_3 () U) (declare-fun a_35_4 () U) (declare-fun a_35_5 () U) (declare-fun a_35_6 () U) (declare-fun a_35_7 () U) (declare-fun a_35_8 () U) (declare-fun a_35_9 () U) (declare-fun a_35_10 () U) (declare-fun a_35_11 () U) (declare-fun a_35_12 () U) (declare-fun a_35_13 () U) (declare-fun a_35_14 () U) (declare-fun a_35_15 () U) (declare-fun a_35_16 () U) (declare-fun a_35_17 () U) (declare-fun a_35_18 () U) (declare-fun a_35_19 () U) (declare-fun a_35_20 () U) (declare-fun a_35_21 () U) (declare-fun a_35_22 () U) (declare-fun a_35_23 () U) (declare-fun a_35_24 () U) (declare-fun a_35_25 () U) (declare-fun a_35_26 () U) (declare-fun a_35_27 () U) (declare-fun a_35_28 () U) (declare-fun a_35_29 () U) (declare-fun a_35_30 () U) (declare-fun a_35_31 () U) (declare-fun a_35_32 () U) (declare-fun a_35_33 () U) (declare-fun a_35_34 () U) (declare-fun a_35_35 () U) (declare-fun a_35_36 () U) (declare-fun a_35_37 () U) (declare-fun a_35_38 () U) (declare-fun a_35_39 () U) (declare-fun a_36_0 () U) (declare-fun a_36_1 () U) (declare-fun a_36_2 () U) (declare-fun a_36_3 () U) (declare-fun a_36_4 () U) (declare-fun a_36_5 () U) (declare-fun a_36_6 () U) (declare-fun a_36_7 () U) (declare-fun a_36_8 () U) (declare-fun a_36_9 () U) (declare-fun a_36_10 () U) (declare-fun a_36_11 () U) (declare-fun a_36_12 () U) (declare-fun a_36_13 () U) (declare-fun a_36_14 () U) (declare-fun a_36_15 () U) (declare-fun a_36_16 () U) (declare-fun a_36_17 () U) (declare-fun a_36_18 () U) (declare-fun a_36_19 () U) (declare-fun a_36_20 () U) (declare-fun a_36_21 () U) (declare-fun a_36_22 () U) (declare-fun a_36_23 () U) (declare-fun a_36_24 () U) (declare-fun a_36_25 () U) (declare-fun a_36_26 () U) (declare-fun a_36_27 () U) (declare-fun a_36_28 () U) (declare-fun a_36_29 () U) (declare-fun a_36_30 () U) (declare-fun a_36_31 () U) (declare-fun a_36_32 () U) (declare-fun a_36_33 () U) (declare-fun a_36_34 () U) (declare-fun a_36_35 () U) (declare-fun a_36_36 () U) (declare-fun a_36_37 () U) (declare-fun a_36_38 () U) (declare-fun a_36_39 () U) (declare-fun a_37_0 () U) (declare-fun a_37_1 () U) (declare-fun a_37_2 () U) (declare-fun a_37_3 () U) (declare-fun a_37_4 () U) (declare-fun a_37_5 () U) (declare-fun a_37_6 () U) (declare-fun a_37_7 () U) (declare-fun a_37_8 () U) (declare-fun a_37_9 () U) (declare-fun a_37_10 () U) (declare-fun a_37_11 () U) (declare-fun a_37_12 () U) (declare-fun a_37_13 () U) (declare-fun a_37_14 () U) (declare-fun a_37_15 () U) (declare-fun a_37_16 () U) (declare-fun a_37_17 () U) (declare-fun a_37_18 () U) (declare-fun a_37_19 () U) (declare-fun a_37_20 () U) (declare-fun a_37_21 () U) (declare-fun a_37_22 () U) (declare-fun a_37_23 () U) (declare-fun a_37_24 () U) (declare-fun a_37_25 () U) (declare-fun a_37_26 () U) (declare-fun a_37_27 () U) (declare-fun a_37_28 () U) (declare-fun a_37_29 () U) (declare-fun a_37_30 () U) (declare-fun a_37_31 () U) (declare-fun a_37_32 () U) (declare-fun a_37_33 () U) (declare-fun a_37_34 () U) (declare-fun a_37_35 () U) (declare-fun a_37_36 () U) (declare-fun a_37_37 () U) (declare-fun a_37_38 () U) (declare-fun a_37_39 () U) (declare-fun a_38_0 () U) (declare-fun a_38_1 () U) (declare-fun a_38_2 () U) (declare-fun a_38_3 () U) (declare-fun a_38_4 () U) (declare-fun a_38_5 () U) (declare-fun a_38_6 () U) (declare-fun a_38_7 () U) (declare-fun a_38_8 () U) (declare-fun a_38_9 () U) (declare-fun a_38_10 () U) (declare-fun a_38_11 () U) (declare-fun a_38_12 () U) (declare-fun a_38_13 () U) (declare-fun a_38_14 () U) (declare-fun a_38_15 () U) (declare-fun a_38_16 () U) (declare-fun a_38_17 () U) (declare-fun a_38_18 () U) (declare-fun a_38_19 () U) (declare-fun a_38_20 () U) (declare-fun a_38_21 () U) (declare-fun a_38_22 () U) (declare-fun a_38_23 () U) (declare-fun a_38_24 () U) (declare-fun a_38_25 () U) (declare-fun a_38_26 () U) (declare-fun a_38_27 () U) (declare-fun a_38_28 () U) (declare-fun a_38_29 () U) (declare-fun a_38_30 () U) (declare-fun a_38_31 () U) (declare-fun a_38_32 () U) (declare-fun a_38_33 () U) (declare-fun a_38_34 () U) (declare-fun a_38_35 () U) (declare-fun a_38_36 () U) (declare-fun a_38_37 () U) (declare-fun a_38_38 () U) (declare-fun a_38_39 () U) (declare-fun a_39_0 () U) (declare-fun a_39_1 () U) (declare-fun a_39_2 () U) (declare-fun a_39_3 () U) (declare-fun a_39_4 () U) (declare-fun a_39_5 () U) (declare-fun a_39_6 () U) (declare-fun a_39_7 () U) (declare-fun a_39_8 () U) (declare-fun a_39_9 () U) (declare-fun a_39_10 () U) (declare-fun a_39_11 () U) (declare-fun a_39_12 () U) (declare-fun a_39_13 () U) (declare-fun a_39_14 () U) (declare-fun a_39_15 () U) (declare-fun a_39_16 () U) (declare-fun a_39_17 () U) (declare-fun a_39_18 () U) (declare-fun a_39_19 () U) (declare-fun a_39_20 () U) (declare-fun a_39_21 () U) (declare-fun a_39_22 () U) (declare-fun a_39_23 () U) (declare-fun a_39_24 () U) (declare-fun a_39_25 () U) (declare-fun a_39_26 () U) (declare-fun a_39_27 () U) (declare-fun a_39_28 () U) (declare-fun a_39_29 () U) (declare-fun a_39_30 () U) (declare-fun a_39_31 () U) (declare-fun a_39_32 () U) (declare-fun a_39_33 () U) (declare-fun a_39_34 () U) (declare-fun a_39_35 () U) (declare-fun a_39_36 () U) (declare-fun a_39_37 () U) (declare-fun a_39_38 () U) (declare-fun a_39_39 () U) (assert (or (or (and (or (not x_0_0) (not x_0_1) (not x_0_2)) (or x_0_0 (not x_0_1) (not x_0_2)) (or (not x_0_0) x_0_1 (not x_0_2)) (or x_0_0 x_0_1 (not x_0_2)) (or (not x_0_0) (not x_0_1) x_0_2) (or x_0_0 (not x_0_1) x_0_2) (or (not x_0_0) x_0_1 x_0_2) (or x_0_0 x_0_1 x_0_2))) (distinct a_0_0 a_0_1 a_0_2 a_0_3 a_0_4 a_0_5 a_0_6 a_0_7 a_0_8 a_0_9 a_0_10 a_0_11 a_0_12 a_0_13 a_0_14 a_0_15 a_0_16 a_0_17 a_0_18 a_0_19 a_0_20 a_0_21 a_0_22 a_0_23 a_0_24 a_0_25 a_0_26 a_0_27 a_0_28 a_0_29 a_0_30 a_0_31 a_0_32 a_0_33 a_0_34 a_0_35 a_0_36 a_0_37 a_0_38 a_0_39))) (assert (or (or (and (or (not x_1_0) (not x_1_1) (not x_1_2)) (or x_1_0 (not x_1_1) (not x_1_2)) (or (not x_1_0) x_1_1 (not x_1_2)) (or x_1_0 x_1_1 (not x_1_2)) (or (not x_1_0) (not x_1_1) x_1_2) (or x_1_0 (not x_1_1) x_1_2) (or (not x_1_0) x_1_1 x_1_2) (or x_1_0 x_1_1 x_1_2))) (distinct a_1_0 a_1_1 a_1_2 a_1_3 a_1_4 a_1_5 a_1_6 a_1_7 a_1_8 a_1_9 a_1_10 a_1_11 a_1_12 a_1_13 a_1_14 a_1_15 a_1_16 a_1_17 a_1_18 a_1_19 a_1_20 a_1_21 a_1_22 a_1_23 a_1_24 a_1_25 a_1_26 a_1_27 a_1_28 a_1_29 a_1_30 a_1_31 a_1_32 a_1_33 a_1_34 a_1_35 a_1_36 a_1_37 a_1_38 a_1_39))) (assert (or (or (and (or (not x_2_0) (not x_2_1) (not x_2_2)) (or x_2_0 (not x_2_1) (not x_2_2)) (or (not x_2_0) x_2_1 (not x_2_2)) (or x_2_0 x_2_1 (not x_2_2)) (or (not x_2_0) (not x_2_1) x_2_2) (or x_2_0 (not x_2_1) x_2_2) (or (not x_2_0) x_2_1 x_2_2) (or x_2_0 x_2_1 x_2_2))) (distinct a_2_0 a_2_1 a_2_2 a_2_3 a_2_4 a_2_5 a_2_6 a_2_7 a_2_8 a_2_9 a_2_10 a_2_11 a_2_12 a_2_13 a_2_14 a_2_15 a_2_16 a_2_17 a_2_18 a_2_19 a_2_20 a_2_21 a_2_22 a_2_23 a_2_24 a_2_25 a_2_26 a_2_27 a_2_28 a_2_29 a_2_30 a_2_31 a_2_32 a_2_33 a_2_34 a_2_35 a_2_36 a_2_37 a_2_38 a_2_39))) (assert (or (or (and (or (not x_3_0) (not x_3_1) (not x_3_2)) (or x_3_0 (not x_3_1) (not x_3_2)) (or (not x_3_0) x_3_1 (not x_3_2)) (or x_3_0 x_3_1 (not x_3_2)) (or (not x_3_0) (not x_3_1) x_3_2) (or x_3_0 (not x_3_1) x_3_2) (or (not x_3_0) x_3_1 x_3_2) (or x_3_0 x_3_1 x_3_2))) (distinct a_3_0 a_3_1 a_3_2 a_3_3 a_3_4 a_3_5 a_3_6 a_3_7 a_3_8 a_3_9 a_3_10 a_3_11 a_3_12 a_3_13 a_3_14 a_3_15 a_3_16 a_3_17 a_3_18 a_3_19 a_3_20 a_3_21 a_3_22 a_3_23 a_3_24 a_3_25 a_3_26 a_3_27 a_3_28 a_3_29 a_3_30 a_3_31 a_3_32 a_3_33 a_3_34 a_3_35 a_3_36 a_3_37 a_3_38 a_3_39))) (assert (or (or (and (or (not x_4_0) (not x_4_1) (not x_4_2)) (or x_4_0 (not x_4_1) (not x_4_2)) (or (not x_4_0) x_4_1 (not x_4_2)) (or x_4_0 x_4_1 (not x_4_2)) (or (not x_4_0) (not x_4_1) x_4_2) (or x_4_0 (not x_4_1) x_4_2) (or (not x_4_0) x_4_1 x_4_2) (or x_4_0 x_4_1 x_4_2))) (distinct a_4_0 a_4_1 a_4_2 a_4_3 a_4_4 a_4_5 a_4_6 a_4_7 a_4_8 a_4_9 a_4_10 a_4_11 a_4_12 a_4_13 a_4_14 a_4_15 a_4_16 a_4_17 a_4_18 a_4_19 a_4_20 a_4_21 a_4_22 a_4_23 a_4_24 a_4_25 a_4_26 a_4_27 a_4_28 a_4_29 a_4_30 a_4_31 a_4_32 a_4_33 a_4_34 a_4_35 a_4_36 a_4_37 a_4_38 a_4_39))) (assert (or (or (and (or (not x_5_0) (not x_5_1) (not x_5_2)) (or x_5_0 (not x_5_1) (not x_5_2)) (or (not x_5_0) x_5_1 (not x_5_2)) (or x_5_0 x_5_1 (not x_5_2)) (or (not x_5_0) (not x_5_1) x_5_2) (or x_5_0 (not x_5_1) x_5_2) (or (not x_5_0) x_5_1 x_5_2) (or x_5_0 x_5_1 x_5_2))) (distinct a_5_0 a_5_1 a_5_2 a_5_3 a_5_4 a_5_5 a_5_6 a_5_7 a_5_8 a_5_9 a_5_10 a_5_11 a_5_12 a_5_13 a_5_14 a_5_15 a_5_16 a_5_17 a_5_18 a_5_19 a_5_20 a_5_21 a_5_22 a_5_23 a_5_24 a_5_25 a_5_26 a_5_27 a_5_28 a_5_29 a_5_30 a_5_31 a_5_32 a_5_33 a_5_34 a_5_35 a_5_36 a_5_37 a_5_38 a_5_39))) (assert (or (or (and (or (not x_6_0) (not x_6_1) (not x_6_2)) (or x_6_0 (not x_6_1) (not x_6_2)) (or (not x_6_0) x_6_1 (not x_6_2)) (or x_6_0 x_6_1 (not x_6_2)) (or (not x_6_0) (not x_6_1) x_6_2) (or x_6_0 (not x_6_1) x_6_2) (or (not x_6_0) x_6_1 x_6_2) (or x_6_0 x_6_1 x_6_2))) (distinct a_6_0 a_6_1 a_6_2 a_6_3 a_6_4 a_6_5 a_6_6 a_6_7 a_6_8 a_6_9 a_6_10 a_6_11 a_6_12 a_6_13 a_6_14 a_6_15 a_6_16 a_6_17 a_6_18 a_6_19 a_6_20 a_6_21 a_6_22 a_6_23 a_6_24 a_6_25 a_6_26 a_6_27 a_6_28 a_6_29 a_6_30 a_6_31 a_6_32 a_6_33 a_6_34 a_6_35 a_6_36 a_6_37 a_6_38 a_6_39))) (assert (or (or (and (or (not x_7_0) (not x_7_1) (not x_7_2)) (or x_7_0 (not x_7_1) (not x_7_2)) (or (not x_7_0) x_7_1 (not x_7_2)) (or x_7_0 x_7_1 (not x_7_2)) (or (not x_7_0) (not x_7_1) x_7_2) (or x_7_0 (not x_7_1) x_7_2) (or (not x_7_0) x_7_1 x_7_2) (or x_7_0 x_7_1 x_7_2))) (distinct a_7_0 a_7_1 a_7_2 a_7_3 a_7_4 a_7_5 a_7_6 a_7_7 a_7_8 a_7_9 a_7_10 a_7_11 a_7_12 a_7_13 a_7_14 a_7_15 a_7_16 a_7_17 a_7_18 a_7_19 a_7_20 a_7_21 a_7_22 a_7_23 a_7_24 a_7_25 a_7_26 a_7_27 a_7_28 a_7_29 a_7_30 a_7_31 a_7_32 a_7_33 a_7_34 a_7_35 a_7_36 a_7_37 a_7_38 a_7_39))) (assert (or (or (and (or (not x_8_0) (not x_8_1) (not x_8_2)) (or x_8_0 (not x_8_1) (not x_8_2)) (or (not x_8_0) x_8_1 (not x_8_2)) (or x_8_0 x_8_1 (not x_8_2)) (or (not x_8_0) (not x_8_1) x_8_2) (or x_8_0 (not x_8_1) x_8_2) (or (not x_8_0) x_8_1 x_8_2) (or x_8_0 x_8_1 x_8_2))) (distinct a_8_0 a_8_1 a_8_2 a_8_3 a_8_4 a_8_5 a_8_6 a_8_7 a_8_8 a_8_9 a_8_10 a_8_11 a_8_12 a_8_13 a_8_14 a_8_15 a_8_16 a_8_17 a_8_18 a_8_19 a_8_20 a_8_21 a_8_22 a_8_23 a_8_24 a_8_25 a_8_26 a_8_27 a_8_28 a_8_29 a_8_30 a_8_31 a_8_32 a_8_33 a_8_34 a_8_35 a_8_36 a_8_37 a_8_38 a_8_39))) (assert (or (or (and (or (not x_9_0) (not x_9_1) (not x_9_2)) (or x_9_0 (not x_9_1) (not x_9_2)) (or (not x_9_0) x_9_1 (not x_9_2)) (or x_9_0 x_9_1 (not x_9_2)) (or (not x_9_0) (not x_9_1) x_9_2) (or x_9_0 (not x_9_1) x_9_2) (or (not x_9_0) x_9_1 x_9_2) (or x_9_0 x_9_1 x_9_2))) (distinct a_9_0 a_9_1 a_9_2 a_9_3 a_9_4 a_9_5 a_9_6 a_9_7 a_9_8 a_9_9 a_9_10 a_9_11 a_9_12 a_9_13 a_9_14 a_9_15 a_9_16 a_9_17 a_9_18 a_9_19 a_9_20 a_9_21 a_9_22 a_9_23 a_9_24 a_9_25 a_9_26 a_9_27 a_9_28 a_9_29 a_9_30 a_9_31 a_9_32 a_9_33 a_9_34 a_9_35 a_9_36 a_9_37 a_9_38 a_9_39))) (assert (or (or (and (or (not x_10_0) (not x_10_1) (not x_10_2)) (or x_10_0 (not x_10_1) (not x_10_2)) (or (not x_10_0) x_10_1 (not x_10_2)) (or x_10_0 x_10_1 (not x_10_2)) (or (not x_10_0) (not x_10_1) x_10_2) (or x_10_0 (not x_10_1) x_10_2) (or (not x_10_0) x_10_1 x_10_2) (or x_10_0 x_10_1 x_10_2))) (distinct a_10_0 a_10_1 a_10_2 a_10_3 a_10_4 a_10_5 a_10_6 a_10_7 a_10_8 a_10_9 a_10_10 a_10_11 a_10_12 a_10_13 a_10_14 a_10_15 a_10_16 a_10_17 a_10_18 a_10_19 a_10_20 a_10_21 a_10_22 a_10_23 a_10_24 a_10_25 a_10_26 a_10_27 a_10_28 a_10_29 a_10_30 a_10_31 a_10_32 a_10_33 a_10_34 a_10_35 a_10_36 a_10_37 a_10_38 a_10_39))) (assert (or (or (and (or (not x_11_0) (not x_11_1) (not x_11_2)) (or x_11_0 (not x_11_1) (not x_11_2)) (or (not x_11_0) x_11_1 (not x_11_2)) (or x_11_0 x_11_1 (not x_11_2)) (or (not x_11_0) (not x_11_1) x_11_2) (or x_11_0 (not x_11_1) x_11_2) (or (not x_11_0) x_11_1 x_11_2) (or x_11_0 x_11_1 x_11_2))) (distinct a_11_0 a_11_1 a_11_2 a_11_3 a_11_4 a_11_5 a_11_6 a_11_7 a_11_8 a_11_9 a_11_10 a_11_11 a_11_12 a_11_13 a_11_14 a_11_15 a_11_16 a_11_17 a_11_18 a_11_19 a_11_20 a_11_21 a_11_22 a_11_23 a_11_24 a_11_25 a_11_26 a_11_27 a_11_28 a_11_29 a_11_30 a_11_31 a_11_32 a_11_33 a_11_34 a_11_35 a_11_36 a_11_37 a_11_38 a_11_39))) (assert (or (or (and (or (not x_12_0) (not x_12_1) (not x_12_2)) (or x_12_0 (not x_12_1) (not x_12_2)) (or (not x_12_0) x_12_1 (not x_12_2)) (or x_12_0 x_12_1 (not x_12_2)) (or (not x_12_0) (not x_12_1) x_12_2) (or x_12_0 (not x_12_1) x_12_2) (or (not x_12_0) x_12_1 x_12_2) (or x_12_0 x_12_1 x_12_2))) (distinct a_12_0 a_12_1 a_12_2 a_12_3 a_12_4 a_12_5 a_12_6 a_12_7 a_12_8 a_12_9 a_12_10 a_12_11 a_12_12 a_12_13 a_12_14 a_12_15 a_12_16 a_12_17 a_12_18 a_12_19 a_12_20 a_12_21 a_12_22 a_12_23 a_12_24 a_12_25 a_12_26 a_12_27 a_12_28 a_12_29 a_12_30 a_12_31 a_12_32 a_12_33 a_12_34 a_12_35 a_12_36 a_12_37 a_12_38 a_12_39))) (assert (or (or (and (or (not x_13_0) (not x_13_1) (not x_13_2)) (or x_13_0 (not x_13_1) (not x_13_2)) (or (not x_13_0) x_13_1 (not x_13_2)) (or x_13_0 x_13_1 (not x_13_2)) (or (not x_13_0) (not x_13_1) x_13_2) (or x_13_0 (not x_13_1) x_13_2) (or (not x_13_0) x_13_1 x_13_2) (or x_13_0 x_13_1 x_13_2))) (distinct a_13_0 a_13_1 a_13_2 a_13_3 a_13_4 a_13_5 a_13_6 a_13_7 a_13_8 a_13_9 a_13_10 a_13_11 a_13_12 a_13_13 a_13_14 a_13_15 a_13_16 a_13_17 a_13_18 a_13_19 a_13_20 a_13_21 a_13_22 a_13_23 a_13_24 a_13_25 a_13_26 a_13_27 a_13_28 a_13_29 a_13_30 a_13_31 a_13_32 a_13_33 a_13_34 a_13_35 a_13_36 a_13_37 a_13_38 a_13_39))) (assert (or (or (and (or (not x_14_0) (not x_14_1) (not x_14_2)) (or x_14_0 (not x_14_1) (not x_14_2)) (or (not x_14_0) x_14_1 (not x_14_2)) (or x_14_0 x_14_1 (not x_14_2)) (or (not x_14_0) (not x_14_1) x_14_2) (or x_14_0 (not x_14_1) x_14_2) (or (not x_14_0) x_14_1 x_14_2) (or x_14_0 x_14_1 x_14_2))) (distinct a_14_0 a_14_1 a_14_2 a_14_3 a_14_4 a_14_5 a_14_6 a_14_7 a_14_8 a_14_9 a_14_10 a_14_11 a_14_12 a_14_13 a_14_14 a_14_15 a_14_16 a_14_17 a_14_18 a_14_19 a_14_20 a_14_21 a_14_22 a_14_23 a_14_24 a_14_25 a_14_26 a_14_27 a_14_28 a_14_29 a_14_30 a_14_31 a_14_32 a_14_33 a_14_34 a_14_35 a_14_36 a_14_37 a_14_38 a_14_39))) (assert (or (or (and (or (not x_15_0) (not x_15_1) (not x_15_2)) (or x_15_0 (not x_15_1) (not x_15_2)) (or (not x_15_0) x_15_1 (not x_15_2)) (or x_15_0 x_15_1 (not x_15_2)) (or (not x_15_0) (not x_15_1) x_15_2) (or x_15_0 (not x_15_1) x_15_2) (or (not x_15_0) x_15_1 x_15_2) (or x_15_0 x_15_1 x_15_2))) (distinct a_15_0 a_15_1 a_15_2 a_15_3 a_15_4 a_15_5 a_15_6 a_15_7 a_15_8 a_15_9 a_15_10 a_15_11 a_15_12 a_15_13 a_15_14 a_15_15 a_15_16 a_15_17 a_15_18 a_15_19 a_15_20 a_15_21 a_15_22 a_15_23 a_15_24 a_15_25 a_15_26 a_15_27 a_15_28 a_15_29 a_15_30 a_15_31 a_15_32 a_15_33 a_15_34 a_15_35 a_15_36 a_15_37 a_15_38 a_15_39))) (assert (or (or (and (or (not x_16_0) (not x_16_1) (not x_16_2)) (or x_16_0 (not x_16_1) (not x_16_2)) (or (not x_16_0) x_16_1 (not x_16_2)) (or x_16_0 x_16_1 (not x_16_2)) (or (not x_16_0) (not x_16_1) x_16_2) (or x_16_0 (not x_16_1) x_16_2) (or (not x_16_0) x_16_1 x_16_2) (or x_16_0 x_16_1 x_16_2))) (distinct a_16_0 a_16_1 a_16_2 a_16_3 a_16_4 a_16_5 a_16_6 a_16_7 a_16_8 a_16_9 a_16_10 a_16_11 a_16_12 a_16_13 a_16_14 a_16_15 a_16_16 a_16_17 a_16_18 a_16_19 a_16_20 a_16_21 a_16_22 a_16_23 a_16_24 a_16_25 a_16_26 a_16_27 a_16_28 a_16_29 a_16_30 a_16_31 a_16_32 a_16_33 a_16_34 a_16_35 a_16_36 a_16_37 a_16_38 a_16_39))) (assert (or (or (and (or (not x_17_0) (not x_17_1) (not x_17_2)) (or x_17_0 (not x_17_1) (not x_17_2)) (or (not x_17_0) x_17_1 (not x_17_2)) (or x_17_0 x_17_1 (not x_17_2)) (or (not x_17_0) (not x_17_1) x_17_2) (or x_17_0 (not x_17_1) x_17_2) (or (not x_17_0) x_17_1 x_17_2) (or x_17_0 x_17_1 x_17_2))) (distinct a_17_0 a_17_1 a_17_2 a_17_3 a_17_4 a_17_5 a_17_6 a_17_7 a_17_8 a_17_9 a_17_10 a_17_11 a_17_12 a_17_13 a_17_14 a_17_15 a_17_16 a_17_17 a_17_18 a_17_19 a_17_20 a_17_21 a_17_22 a_17_23 a_17_24 a_17_25 a_17_26 a_17_27 a_17_28 a_17_29 a_17_30 a_17_31 a_17_32 a_17_33 a_17_34 a_17_35 a_17_36 a_17_37 a_17_38 a_17_39))) (assert (or (or (and (or (not x_18_0) (not x_18_1) (not x_18_2)) (or x_18_0 (not x_18_1) (not x_18_2)) (or (not x_18_0) x_18_1 (not x_18_2)) (or x_18_0 x_18_1 (not x_18_2)) (or (not x_18_0) (not x_18_1) x_18_2) (or x_18_0 (not x_18_1) x_18_2) (or (not x_18_0) x_18_1 x_18_2) (or x_18_0 x_18_1 x_18_2))) (distinct a_18_0 a_18_1 a_18_2 a_18_3 a_18_4 a_18_5 a_18_6 a_18_7 a_18_8 a_18_9 a_18_10 a_18_11 a_18_12 a_18_13 a_18_14 a_18_15 a_18_16 a_18_17 a_18_18 a_18_19 a_18_20 a_18_21 a_18_22 a_18_23 a_18_24 a_18_25 a_18_26 a_18_27 a_18_28 a_18_29 a_18_30 a_18_31 a_18_32 a_18_33 a_18_34 a_18_35 a_18_36 a_18_37 a_18_38 a_18_39))) (assert (or (or (and (or (not x_19_0) (not x_19_1) (not x_19_2)) (or x_19_0 (not x_19_1) (not x_19_2)) (or (not x_19_0) x_19_1 (not x_19_2)) (or x_19_0 x_19_1 (not x_19_2)) (or (not x_19_0) (not x_19_1) x_19_2) (or x_19_0 (not x_19_1) x_19_2) (or (not x_19_0) x_19_1 x_19_2) (or x_19_0 x_19_1 x_19_2))) (distinct a_19_0 a_19_1 a_19_2 a_19_3 a_19_4 a_19_5 a_19_6 a_19_7 a_19_8 a_19_9 a_19_10 a_19_11 a_19_12 a_19_13 a_19_14 a_19_15 a_19_16 a_19_17 a_19_18 a_19_19 a_19_20 a_19_21 a_19_22 a_19_23 a_19_24 a_19_25 a_19_26 a_19_27 a_19_28 a_19_29 a_19_30 a_19_31 a_19_32 a_19_33 a_19_34 a_19_35 a_19_36 a_19_37 a_19_38 a_19_39))) (assert (or (or (and (or (not x_20_0) (not x_20_1) (not x_20_2)) (or x_20_0 (not x_20_1) (not x_20_2)) (or (not x_20_0) x_20_1 (not x_20_2)) (or x_20_0 x_20_1 (not x_20_2)) (or (not x_20_0) (not x_20_1) x_20_2) (or x_20_0 (not x_20_1) x_20_2) (or (not x_20_0) x_20_1 x_20_2) (or x_20_0 x_20_1 x_20_2))) (distinct a_20_0 a_20_1 a_20_2 a_20_3 a_20_4 a_20_5 a_20_6 a_20_7 a_20_8 a_20_9 a_20_10 a_20_11 a_20_12 a_20_13 a_20_14 a_20_15 a_20_16 a_20_17 a_20_18 a_20_19 a_20_20 a_20_21 a_20_22 a_20_23 a_20_24 a_20_25 a_20_26 a_20_27 a_20_28 a_20_29 a_20_30 a_20_31 a_20_32 a_20_33 a_20_34 a_20_35 a_20_36 a_20_37 a_20_38 a_20_39))) (assert (or (or (and (or (not x_21_0) (not x_21_1) (not x_21_2)) (or x_21_0 (not x_21_1) (not x_21_2)) (or (not x_21_0) x_21_1 (not x_21_2)) (or x_21_0 x_21_1 (not x_21_2)) (or (not x_21_0) (not x_21_1) x_21_2) (or x_21_0 (not x_21_1) x_21_2) (or (not x_21_0) x_21_1 x_21_2) (or x_21_0 x_21_1 x_21_2))) (distinct a_21_0 a_21_1 a_21_2 a_21_3 a_21_4 a_21_5 a_21_6 a_21_7 a_21_8 a_21_9 a_21_10 a_21_11 a_21_12 a_21_13 a_21_14 a_21_15 a_21_16 a_21_17 a_21_18 a_21_19 a_21_20 a_21_21 a_21_22 a_21_23 a_21_24 a_21_25 a_21_26 a_21_27 a_21_28 a_21_29 a_21_30 a_21_31 a_21_32 a_21_33 a_21_34 a_21_35 a_21_36 a_21_37 a_21_38 a_21_39))) (assert (or (or (and (or (not x_22_0) (not x_22_1) (not x_22_2)) (or x_22_0 (not x_22_1) (not x_22_2)) (or (not x_22_0) x_22_1 (not x_22_2)) (or x_22_0 x_22_1 (not x_22_2)) (or (not x_22_0) (not x_22_1) x_22_2) (or x_22_0 (not x_22_1) x_22_2) (or (not x_22_0) x_22_1 x_22_2) (or x_22_0 x_22_1 x_22_2))) (distinct a_22_0 a_22_1 a_22_2 a_22_3 a_22_4 a_22_5 a_22_6 a_22_7 a_22_8 a_22_9 a_22_10 a_22_11 a_22_12 a_22_13 a_22_14 a_22_15 a_22_16 a_22_17 a_22_18 a_22_19 a_22_20 a_22_21 a_22_22 a_22_23 a_22_24 a_22_25 a_22_26 a_22_27 a_22_28 a_22_29 a_22_30 a_22_31 a_22_32 a_22_33 a_22_34 a_22_35 a_22_36 a_22_37 a_22_38 a_22_39))) (assert (or (or (and (or (not x_23_0) (not x_23_1) (not x_23_2)) (or x_23_0 (not x_23_1) (not x_23_2)) (or (not x_23_0) x_23_1 (not x_23_2)) (or x_23_0 x_23_1 (not x_23_2)) (or (not x_23_0) (not x_23_1) x_23_2) (or x_23_0 (not x_23_1) x_23_2) (or (not x_23_0) x_23_1 x_23_2) (or x_23_0 x_23_1 x_23_2))) (distinct a_23_0 a_23_1 a_23_2 a_23_3 a_23_4 a_23_5 a_23_6 a_23_7 a_23_8 a_23_9 a_23_10 a_23_11 a_23_12 a_23_13 a_23_14 a_23_15 a_23_16 a_23_17 a_23_18 a_23_19 a_23_20 a_23_21 a_23_22 a_23_23 a_23_24 a_23_25 a_23_26 a_23_27 a_23_28 a_23_29 a_23_30 a_23_31 a_23_32 a_23_33 a_23_34 a_23_35 a_23_36 a_23_37 a_23_38 a_23_39))) (assert (or (or (and (or (not x_24_0) (not x_24_1) (not x_24_2)) (or x_24_0 (not x_24_1) (not x_24_2)) (or (not x_24_0) x_24_1 (not x_24_2)) (or x_24_0 x_24_1 (not x_24_2)) (or (not x_24_0) (not x_24_1) x_24_2) (or x_24_0 (not x_24_1) x_24_2) (or (not x_24_0) x_24_1 x_24_2) (or x_24_0 x_24_1 x_24_2))) (distinct a_24_0 a_24_1 a_24_2 a_24_3 a_24_4 a_24_5 a_24_6 a_24_7 a_24_8 a_24_9 a_24_10 a_24_11 a_24_12 a_24_13 a_24_14 a_24_15 a_24_16 a_24_17 a_24_18 a_24_19 a_24_20 a_24_21 a_24_22 a_24_23 a_24_24 a_24_25 a_24_26 a_24_27 a_24_28 a_24_29 a_24_30 a_24_31 a_24_32 a_24_33 a_24_34 a_24_35 a_24_36 a_24_37 a_24_38 a_24_39))) (assert (or (or (and (or (not x_25_0) (not x_25_1) (not x_25_2)) (or x_25_0 (not x_25_1) (not x_25_2)) (or (not x_25_0) x_25_1 (not x_25_2)) (or x_25_0 x_25_1 (not x_25_2)) (or (not x_25_0) (not x_25_1) x_25_2) (or x_25_0 (not x_25_1) x_25_2) (or (not x_25_0) x_25_1 x_25_2) (or x_25_0 x_25_1 x_25_2))) (distinct a_25_0 a_25_1 a_25_2 a_25_3 a_25_4 a_25_5 a_25_6 a_25_7 a_25_8 a_25_9 a_25_10 a_25_11 a_25_12 a_25_13 a_25_14 a_25_15 a_25_16 a_25_17 a_25_18 a_25_19 a_25_20 a_25_21 a_25_22 a_25_23 a_25_24 a_25_25 a_25_26 a_25_27 a_25_28 a_25_29 a_25_30 a_25_31 a_25_32 a_25_33 a_25_34 a_25_35 a_25_36 a_25_37 a_25_38 a_25_39))) (assert (or (or (and (or (not x_26_0) (not x_26_1) (not x_26_2)) (or x_26_0 (not x_26_1) (not x_26_2)) (or (not x_26_0) x_26_1 (not x_26_2)) (or x_26_0 x_26_1 (not x_26_2)) (or (not x_26_0) (not x_26_1) x_26_2) (or x_26_0 (not x_26_1) x_26_2) (or (not x_26_0) x_26_1 x_26_2) (or x_26_0 x_26_1 x_26_2))) (distinct a_26_0 a_26_1 a_26_2 a_26_3 a_26_4 a_26_5 a_26_6 a_26_7 a_26_8 a_26_9 a_26_10 a_26_11 a_26_12 a_26_13 a_26_14 a_26_15 a_26_16 a_26_17 a_26_18 a_26_19 a_26_20 a_26_21 a_26_22 a_26_23 a_26_24 a_26_25 a_26_26 a_26_27 a_26_28 a_26_29 a_26_30 a_26_31 a_26_32 a_26_33 a_26_34 a_26_35 a_26_36 a_26_37 a_26_38 a_26_39))) (assert (or (or (and (or (not x_27_0) (not x_27_1) (not x_27_2)) (or x_27_0 (not x_27_1) (not x_27_2)) (or (not x_27_0) x_27_1 (not x_27_2)) (or x_27_0 x_27_1 (not x_27_2)) (or (not x_27_0) (not x_27_1) x_27_2) (or x_27_0 (not x_27_1) x_27_2) (or (not x_27_0) x_27_1 x_27_2) (or x_27_0 x_27_1 x_27_2))) (distinct a_27_0 a_27_1 a_27_2 a_27_3 a_27_4 a_27_5 a_27_6 a_27_7 a_27_8 a_27_9 a_27_10 a_27_11 a_27_12 a_27_13 a_27_14 a_27_15 a_27_16 a_27_17 a_27_18 a_27_19 a_27_20 a_27_21 a_27_22 a_27_23 a_27_24 a_27_25 a_27_26 a_27_27 a_27_28 a_27_29 a_27_30 a_27_31 a_27_32 a_27_33 a_27_34 a_27_35 a_27_36 a_27_37 a_27_38 a_27_39))) (assert (or (or (and (or (not x_28_0) (not x_28_1) (not x_28_2)) (or x_28_0 (not x_28_1) (not x_28_2)) (or (not x_28_0) x_28_1 (not x_28_2)) (or x_28_0 x_28_1 (not x_28_2)) (or (not x_28_0) (not x_28_1) x_28_2) (or x_28_0 (not x_28_1) x_28_2) (or (not x_28_0) x_28_1 x_28_2) (or x_28_0 x_28_1 x_28_2))) (distinct a_28_0 a_28_1 a_28_2 a_28_3 a_28_4 a_28_5 a_28_6 a_28_7 a_28_8 a_28_9 a_28_10 a_28_11 a_28_12 a_28_13 a_28_14 a_28_15 a_28_16 a_28_17 a_28_18 a_28_19 a_28_20 a_28_21 a_28_22 a_28_23 a_28_24 a_28_25 a_28_26 a_28_27 a_28_28 a_28_29 a_28_30 a_28_31 a_28_32 a_28_33 a_28_34 a_28_35 a_28_36 a_28_37 a_28_38 a_28_39))) (assert (or (or (and (or (not x_29_0) (not x_29_1) (not x_29_2)) (or x_29_0 (not x_29_1) (not x_29_2)) (or (not x_29_0) x_29_1 (not x_29_2)) (or x_29_0 x_29_1 (not x_29_2)) (or (not x_29_0) (not x_29_1) x_29_2) (or x_29_0 (not x_29_1) x_29_2) (or (not x_29_0) x_29_1 x_29_2) (or x_29_0 x_29_1 x_29_2))) (distinct a_29_0 a_29_1 a_29_2 a_29_3 a_29_4 a_29_5 a_29_6 a_29_7 a_29_8 a_29_9 a_29_10 a_29_11 a_29_12 a_29_13 a_29_14 a_29_15 a_29_16 a_29_17 a_29_18 a_29_19 a_29_20 a_29_21 a_29_22 a_29_23 a_29_24 a_29_25 a_29_26 a_29_27 a_29_28 a_29_29 a_29_30 a_29_31 a_29_32 a_29_33 a_29_34 a_29_35 a_29_36 a_29_37 a_29_38 a_29_39))) (assert (or (or (and (or (not x_30_0) (not x_30_1) (not x_30_2)) (or x_30_0 (not x_30_1) (not x_30_2)) (or (not x_30_0) x_30_1 (not x_30_2)) (or x_30_0 x_30_1 (not x_30_2)) (or (not x_30_0) (not x_30_1) x_30_2) (or x_30_0 (not x_30_1) x_30_2) (or (not x_30_0) x_30_1 x_30_2) (or x_30_0 x_30_1 x_30_2))) (distinct a_30_0 a_30_1 a_30_2 a_30_3 a_30_4 a_30_5 a_30_6 a_30_7 a_30_8 a_30_9 a_30_10 a_30_11 a_30_12 a_30_13 a_30_14 a_30_15 a_30_16 a_30_17 a_30_18 a_30_19 a_30_20 a_30_21 a_30_22 a_30_23 a_30_24 a_30_25 a_30_26 a_30_27 a_30_28 a_30_29 a_30_30 a_30_31 a_30_32 a_30_33 a_30_34 a_30_35 a_30_36 a_30_37 a_30_38 a_30_39))) (assert (or (or (and (or (not x_31_0) (not x_31_1) (not x_31_2)) (or x_31_0 (not x_31_1) (not x_31_2)) (or (not x_31_0) x_31_1 (not x_31_2)) (or x_31_0 x_31_1 (not x_31_2)) (or (not x_31_0) (not x_31_1) x_31_2) (or x_31_0 (not x_31_1) x_31_2) (or (not x_31_0) x_31_1 x_31_2) (or x_31_0 x_31_1 x_31_2))) (distinct a_31_0 a_31_1 a_31_2 a_31_3 a_31_4 a_31_5 a_31_6 a_31_7 a_31_8 a_31_9 a_31_10 a_31_11 a_31_12 a_31_13 a_31_14 a_31_15 a_31_16 a_31_17 a_31_18 a_31_19 a_31_20 a_31_21 a_31_22 a_31_23 a_31_24 a_31_25 a_31_26 a_31_27 a_31_28 a_31_29 a_31_30 a_31_31 a_31_32 a_31_33 a_31_34 a_31_35 a_31_36 a_31_37 a_31_38 a_31_39))) (assert (or (or (and (or (not x_32_0) (not x_32_1) (not x_32_2)) (or x_32_0 (not x_32_1) (not x_32_2)) (or (not x_32_0) x_32_1 (not x_32_2)) (or x_32_0 x_32_1 (not x_32_2)) (or (not x_32_0) (not x_32_1) x_32_2) (or x_32_0 (not x_32_1) x_32_2) (or (not x_32_0) x_32_1 x_32_2) (or x_32_0 x_32_1 x_32_2))) (distinct a_32_0 a_32_1 a_32_2 a_32_3 a_32_4 a_32_5 a_32_6 a_32_7 a_32_8 a_32_9 a_32_10 a_32_11 a_32_12 a_32_13 a_32_14 a_32_15 a_32_16 a_32_17 a_32_18 a_32_19 a_32_20 a_32_21 a_32_22 a_32_23 a_32_24 a_32_25 a_32_26 a_32_27 a_32_28 a_32_29 a_32_30 a_32_31 a_32_32 a_32_33 a_32_34 a_32_35 a_32_36 a_32_37 a_32_38 a_32_39))) (assert (or (or (and (or (not x_33_0) (not x_33_1) (not x_33_2)) (or x_33_0 (not x_33_1) (not x_33_2)) (or (not x_33_0) x_33_1 (not x_33_2)) (or x_33_0 x_33_1 (not x_33_2)) (or (not x_33_0) (not x_33_1) x_33_2) (or x_33_0 (not x_33_1) x_33_2) (or (not x_33_0) x_33_1 x_33_2) (or x_33_0 x_33_1 x_33_2))) (distinct a_33_0 a_33_1 a_33_2 a_33_3 a_33_4 a_33_5 a_33_6 a_33_7 a_33_8 a_33_9 a_33_10 a_33_11 a_33_12 a_33_13 a_33_14 a_33_15 a_33_16 a_33_17 a_33_18 a_33_19 a_33_20 a_33_21 a_33_22 a_33_23 a_33_24 a_33_25 a_33_26 a_33_27 a_33_28 a_33_29 a_33_30 a_33_31 a_33_32 a_33_33 a_33_34 a_33_35 a_33_36 a_33_37 a_33_38 a_33_39))) (assert (or (or (and (or (not x_34_0) (not x_34_1) (not x_34_2)) (or x_34_0 (not x_34_1) (not x_34_2)) (or (not x_34_0) x_34_1 (not x_34_2)) (or x_34_0 x_34_1 (not x_34_2)) (or (not x_34_0) (not x_34_1) x_34_2) (or x_34_0 (not x_34_1) x_34_2) (or (not x_34_0) x_34_1 x_34_2) (or x_34_0 x_34_1 x_34_2))) (distinct a_34_0 a_34_1 a_34_2 a_34_3 a_34_4 a_34_5 a_34_6 a_34_7 a_34_8 a_34_9 a_34_10 a_34_11 a_34_12 a_34_13 a_34_14 a_34_15 a_34_16 a_34_17 a_34_18 a_34_19 a_34_20 a_34_21 a_34_22 a_34_23 a_34_24 a_34_25 a_34_26 a_34_27 a_34_28 a_34_29 a_34_30 a_34_31 a_34_32 a_34_33 a_34_34 a_34_35 a_34_36 a_34_37 a_34_38 a_34_39))) (assert (or (or (and (or (not x_35_0) (not x_35_1) (not x_35_2)) (or x_35_0 (not x_35_1) (not x_35_2)) (or (not x_35_0) x_35_1 (not x_35_2)) (or x_35_0 x_35_1 (not x_35_2)) (or (not x_35_0) (not x_35_1) x_35_2) (or x_35_0 (not x_35_1) x_35_2) (or (not x_35_0) x_35_1 x_35_2) (or x_35_0 x_35_1 x_35_2))) (distinct a_35_0 a_35_1 a_35_2 a_35_3 a_35_4 a_35_5 a_35_6 a_35_7 a_35_8 a_35_9 a_35_10 a_35_11 a_35_12 a_35_13 a_35_14 a_35_15 a_35_16 a_35_17 a_35_18 a_35_19 a_35_20 a_35_21 a_35_22 a_35_23 a_35_24 a_35_25 a_35_26 a_35_27 a_35_28 a_35_29 a_35_30 a_35_31 a_35_32 a_35_33 a_35_34 a_35_35 a_35_36 a_35_37 a_35_38 a_35_39))) (assert (or (or (and (or (not x_36_0) (not x_36_1) (not x_36_2)) (or x_36_0 (not x_36_1) (not x_36_2)) (or (not x_36_0) x_36_1 (not x_36_2)) (or x_36_0 x_36_1 (not x_36_2)) (or (not x_36_0) (not x_36_1) x_36_2) (or x_36_0 (not x_36_1) x_36_2) (or (not x_36_0) x_36_1 x_36_2) (or x_36_0 x_36_1 x_36_2))) (distinct a_36_0 a_36_1 a_36_2 a_36_3 a_36_4 a_36_5 a_36_6 a_36_7 a_36_8 a_36_9 a_36_10 a_36_11 a_36_12 a_36_13 a_36_14 a_36_15 a_36_16 a_36_17 a_36_18 a_36_19 a_36_20 a_36_21 a_36_22 a_36_23 a_36_24 a_36_25 a_36_26 a_36_27 a_36_28 a_36_29 a_36_30 a_36_31 a_36_32 a_36_33 a_36_34 a_36_35 a_36_36 a_36_37 a_36_38 a_36_39))) (assert (or (or (and (or (not x_37_0) (not x_37_1) (not x_37_2)) (or x_37_0 (not x_37_1) (not x_37_2)) (or (not x_37_0) x_37_1 (not x_37_2)) (or x_37_0 x_37_1 (not x_37_2)) (or (not x_37_0) (not x_37_1) x_37_2) (or x_37_0 (not x_37_1) x_37_2) (or (not x_37_0) x_37_1 x_37_2) (or x_37_0 x_37_1 x_37_2))) (distinct a_37_0 a_37_1 a_37_2 a_37_3 a_37_4 a_37_5 a_37_6 a_37_7 a_37_8 a_37_9 a_37_10 a_37_11 a_37_12 a_37_13 a_37_14 a_37_15 a_37_16 a_37_17 a_37_18 a_37_19 a_37_20 a_37_21 a_37_22 a_37_23 a_37_24 a_37_25 a_37_26 a_37_27 a_37_28 a_37_29 a_37_30 a_37_31 a_37_32 a_37_33 a_37_34 a_37_35 a_37_36 a_37_37 a_37_38 a_37_39))) (assert (or (or (and (or (not x_38_0) (not x_38_1) (not x_38_2)) (or x_38_0 (not x_38_1) (not x_38_2)) (or (not x_38_0) x_38_1 (not x_38_2)) (or x_38_0 x_38_1 (not x_38_2)) (or (not x_38_0) (not x_38_1) x_38_2) (or x_38_0 (not x_38_1) x_38_2) (or (not x_38_0) x_38_1 x_38_2) (or x_38_0 x_38_1 x_38_2))) (distinct a_38_0 a_38_1 a_38_2 a_38_3 a_38_4 a_38_5 a_38_6 a_38_7 a_38_8 a_38_9 a_38_10 a_38_11 a_38_12 a_38_13 a_38_14 a_38_15 a_38_16 a_38_17 a_38_18 a_38_19 a_38_20 a_38_21 a_38_22 a_38_23 a_38_24 a_38_25 a_38_26 a_38_27 a_38_28 a_38_29 a_38_30 a_38_31 a_38_32 a_38_33 a_38_34 a_38_35 a_38_36 a_38_37 a_38_38 a_38_39))) (assert (or (or (and (or (not x_39_0) (not x_39_1) (not x_39_2)) (or x_39_0 (not x_39_1) (not x_39_2)) (or (not x_39_0) x_39_1 (not x_39_2)) (or x_39_0 x_39_1 (not x_39_2)) (or (not x_39_0) (not x_39_1) x_39_2) (or x_39_0 (not x_39_1) x_39_2) (or (not x_39_0) x_39_1 x_39_2) (or x_39_0 x_39_1 x_39_2))) (distinct a_39_0 a_39_1 a_39_2 a_39_3 a_39_4 a_39_5 a_39_6 a_39_7 a_39_8 a_39_9 a_39_10 a_39_11 a_39_12 a_39_13 a_39_14 a_39_15 a_39_16 a_39_17 a_39_18 a_39_19 a_39_20 a_39_21 a_39_22 a_39_23 a_39_24 a_39_25 a_39_26 a_39_27 a_39_28 a_39_29 a_39_30 a_39_31 a_39_32 a_39_33 a_39_34 a_39_35 a_39_36 a_39_37 a_39_38 a_39_39))) (assert (and (= a_0_0 a_1_0) (= a_1_0 a_2_0) (= a_2_0 a_3_0) (= a_3_0 a_4_0) (= a_4_0 a_5_0) (= a_5_0 a_6_0) (= a_6_0 a_7_0) (= a_7_0 a_8_0) (= a_8_0 a_9_0) (= a_9_0 a_10_0) (= a_10_0 a_11_0) (= a_11_0 a_12_0) (= a_12_0 a_13_0) (= a_13_0 a_14_0) (= a_14_0 a_15_0) (= a_15_0 a_16_0) (= a_16_0 a_17_0) (= a_17_0 a_18_0) (= a_18_0 a_19_0) (= a_19_0 a_20_0) (= a_20_0 a_21_0) (= a_21_0 a_22_0) (= a_22_0 a_23_0) (= a_23_0 a_24_0) (= a_24_0 a_25_0) (= a_25_0 a_26_0) (= a_26_0 a_27_0) (= a_27_0 a_28_0) (= a_28_0 a_29_0) (= a_29_0 a_30_0) (= a_30_0 a_31_0) (= a_31_0 a_32_0) (= a_32_0 a_33_0) (= a_33_0 a_34_0) (= a_34_0 a_35_0) (= a_35_0 a_36_0) (= a_36_0 a_37_0) (= a_37_0 a_38_0) (= a_38_0 a_39_0))) (assert (= a_39_0 a_0_1)) (check-sat) opensmt-2.5.2/regression/QF_UF/php_3_3_40_unsat.smt2.expected.err000066400000000000000000000000001445011647600244310ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/php_3_3_40_unsat.smt2.expected.out000066400000000000000000000000061445011647600244560ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UF/simplified.smt2000066400000000000000000000142551445011647600212400ustar00rootroot00000000000000(set-logic QF_UF) (set-info :source | CADE ATP System competition. See http://www.cs.miami.edu/~tptp/CASC for more information. This benchmark was obtained by trying to find a finite model of a first-order formula (Albert Oliveras). |) (set-info :smt-lib-version 2.0) (set-info :category "crafted") (set-info :status unsat) (declare-sort U 0) (declare-fun c14 () U) (declare-fun c12 () U) (declare-fun p4 (U U) Bool) (declare-fun c13 () U) (declare-fun p3 (U U) Bool) (declare-fun c15 () U) (declare-fun c17 () U) (declare-fun p6 (U U) Bool) (declare-fun p2 (U U) Bool) (declare-fun p1 (U U) Bool) (declare-fun c11 () U) (declare-fun f5 (U U) U) (declare-fun c10 () U) (declare-fun p8 (U) Bool) (declare-fun c16 () U) (declare-fun p9 (U U) Bool) (declare-fun p7 (U U) Bool) (declare-fun c_0 () U) (declare-fun c_1 () U) (declare-fun c_2 () U) (declare-fun c_3 () U) (declare-fun b0 () Bool) (assert (let ((?v_52 (= c_0 c_0))) (let ((?v_16 (not ?v_52)) (?v_32 (p3 c_0 c_0)) (?v_55 (= c_0 c_1))) (let ((?v_17 (not ?v_55)) (?v_33 (p3 c_0 c_1)) (?v_58 (= c_0 c_2))) (let ((?v_18 (not ?v_58)) (?v_34 (p3 c_0 c_2)) (?v_61 (= c_0 c_3))) (let ((?v_19 (not ?v_61)) (?v_35 (p3 c_0 c_3)) (?v_64 (= c_1 c_0))) (let ((?v_20 (not ?v_64)) (?v_36 (p3 c_1 c_0)) (?v_67 (= c_1 c_1))) (let ((?v_21 (not ?v_67)) (?v_37 (p3 c_1 c_1)) (?v_70 (= c_1 c_2))) (let ((?v_22 (not ?v_70)) (?v_38 (p3 c_1 c_2)) (?v_73 (= c_1 c_3))) (let ((?v_23 (not ?v_73)) (?v_39 (p3 c_1 c_3)) (?v_76 (= c_2 c_0))) (let ((?v_24 (not ?v_76)) (?v_40 (p3 c_2 c_0)) (?v_79 (= c_2 c_1))) (let ((?v_25 (not ?v_79)) (?v_41 (p3 c_2 c_1)) (?v_82 (= c_2 c_2))) (let ((?v_26 (not ?v_82)) (?v_42 (p3 c_2 c_2)) (?v_85 (= c_2 c_3))) (let ((?v_27 (not ?v_85)) (?v_43 (p3 c_2 c_3)) (?v_88 (= c_3 c_0))) (let ((?v_28 (not ?v_88)) (?v_44 (p3 c_3 c_0)) (?v_91 (= c_3 c_1))) (let ((?v_29 (not ?v_91)) (?v_45 (p3 c_3 c_1)) (?v_94 (= c_3 c_2))) (let ((?v_30 (not ?v_94)) (?v_46 (p3 c_3 c_2)) (?v_97 (= c_3 c_3))) (let ((?v_31 (not ?v_97)) (?v_47 (p3 c_3 c_3)) (?v_53 (p4 c_0 c_0))) (let ((?v_0 (not ?v_53)) (?v_56 (p4 c_0 c_1))) (let ((?v_2 (not ?v_56)) (?v_65 (p4 c_1 c_0))) (let ((?v_1 (not ?v_65)) (?v_59 (p4 c_0 c_2))) (let ((?v_5 (not ?v_59)) (?v_77 (p4 c_2 c_0))) (let ((?v_4 (not ?v_77)) (?v_62 (p4 c_0 c_3))) (let ((?v_10 (not ?v_62)) (?v_89 (p4 c_3 c_0))) (let ((?v_9 (not ?v_89)) (?v_68 (p4 c_1 c_1))) (let ((?v_3 (not ?v_68)) (?v_71 (p4 c_1 c_2))) (let ((?v_7 (not ?v_71)) (?v_80 (p4 c_2 c_1))) (let ((?v_6 (not ?v_80)) (?v_74 (p4 c_1 c_3))) (let ((?v_12 (not ?v_74)) (?v_92 (p4 c_3 c_1))) (let ((?v_11 (not ?v_92)) (?v_83 (p4 c_2 c_2))) (let ((?v_8 (not ?v_83)) (?v_86 (p4 c_2 c_3))) (let ((?v_14 (not ?v_86)) (?v_95 (p4 c_3 c_2))) (let ((?v_13 (not ?v_95)) (?v_98 (p4 c_3 c_3))) (let ((?v_15 (not ?v_98)) (?v_54 (p2 c_0 c_0)) (?v_66 (p2 c_1 c_0)) (?v_78 (p2 c_2 c_0)) (?v_90 (p2 c_3 c_0)) (?v_57 (p2 c_0 c_1)) (?v_69 (p2 c_1 c_1)) (?v_81 (p2 c_2 c_1)) (?v_93 (p2 c_3 c_1)) (?v_60 (p2 c_0 c_2)) (?v_72 (p2 c_1 c_2)) (?v_84 (p2 c_2 c_2)) (?v_96 (p2 c_3 c_2)) (?v_63 (p2 c_0 c_3)) (?v_75 (p2 c_1 c_3)) (?v_87 (p2 c_2 c_3)) (?v_99 (p2 c_3 c_3)) (?v_100 (p1 c_0 c_0)) (?v_101 (p1 c_0 c_1)) (?v_102 (p1 c_0 c_2)) (?v_103 (p1 c_0 c_3)) (?v_104 (p1 c_1 c_0)) (?v_105 (p1 c_1 c_1)) (?v_106 (p1 c_1 c_2)) (?v_107 (p1 c_1 c_3)) (?v_108 (p1 c_2 c_0)) (?v_109 (p1 c_2 c_1)) (?v_110 (p1 c_2 c_2)) (?v_111 (p1 c_2 c_3)) (?v_112 (p1 c_3 c_0)) (?v_113 (p1 c_3 c_1)) (?v_114 (p1 c_3 c_2)) (?v_115 (p1 c_3 c_3)) (?v_117 (f5 c_0 c_0)) (?v_48 (not (p8 c_0))) (?v_116 (p6 c_0 c_0)) (?v_119 (f5 c_0 c_1)) (?v_118 (p6 c_0 c_1)) (?v_121 (f5 c_0 c_2)) (?v_120 (p6 c_0 c_2)) (?v_123 (f5 c_0 c_3)) (?v_122 (p6 c_0 c_3)) (?v_125 (f5 c_1 c_0)) (?v_49 (not (p8 c_1))) (?v_124 (p6 c_1 c_0)) (?v_127 (f5 c_1 c_1)) (?v_126 (p6 c_1 c_1)) (?v_129 (f5 c_1 c_2)) (?v_128 (p6 c_1 c_2)) (?v_131 (f5 c_1 c_3)) (?v_130 (p6 c_1 c_3)) (?v_133 (f5 c_2 c_0)) (?v_50 (not (p8 c_2))) (?v_132 (p6 c_2 c_0)) (?v_135 (f5 c_2 c_1)) (?v_134 (p6 c_2 c_1)) (?v_137 (f5 c_2 c_2)) (?v_136 (p6 c_2 c_2)) (?v_139 (f5 c_2 c_3)) (?v_138 (p6 c_2 c_3)) (?v_141 (f5 c_3 c_0)) (?v_51 (not (p8 c_3))) (?v_140 (p6 c_3 c_0)) (?v_143 (f5 c_3 c_1)) (?v_142 (p6 c_3 c_1)) (?v_145 (f5 c_3 c_2)) (?v_144 (p6 c_3 c_2)) (?v_147 (f5 c_3 c_3)) (?v_146 (p6 c_3 c_3))) (let ((?v_148 (not ?v_54)) (?v_152 (not ?v_66)) (?v_156 (not ?v_78)) (?v_160 (not ?v_90)) (?v_149 (not ?v_57)) (?v_153 (not ?v_69)) (?v_157 (not ?v_81)) (?v_161 (not ?v_93)) (?v_150 (not ?v_60)) (?v_154 (not ?v_72)) (?v_158 (not ?v_84)) (?v_162 (not ?v_96)) (?v_151 (not ?v_63)) (?v_155 (not ?v_75)) (?v_159 (not ?v_87)) (?v_163 (not ?v_99)) (?v_164 (p9 c_0 c_0))) (let ((?v_212 (not ?v_164)) (?v_196 (p7 c_0 c_0))) (let ((?v_165 (not ?v_196)) (?v_166 (p9 c_0 c_1))) (let ((?v_213 (not ?v_166)) (?v_197 (p7 c_0 c_1))) (let ((?v_167 (not ?v_197)) (?v_168 (p9 c_0 c_2))) (let ((?v_214 (not ?v_168)) (?v_198 (p7 c_0 c_2))) (let ((?v_169 (not ?v_198)) (?v_170 (p9 c_0 c_3))) (let ((?v_215 (not ?v_170)) (?v_199 (p7 c_0 c_3))) (let ((?v_171 (not ?v_199)) (?v_172 (p9 c_1 c_0))) (let ((?v_216 (not ?v_172)) (?v_200 (p7 c_1 c_0))) (let ((?v_173 (not ?v_200)) (?v_174 (p9 c_1 c_1))) (let ((?v_217 (not ?v_174)) (?v_201 (p7 c_1 c_1))) (let ((?v_175 (not ?v_201)) (?v_176 (p9 c_1 c_2))) (let ((?v_218 (not ?v_176)) (?v_202 (p7 c_1 c_2))) (let ((?v_177 (not ?v_202)) (?v_178 (p9 c_1 c_3))) (let ((?v_219 (not ?v_178)) (?v_203 (p7 c_1 c_3))) (let ((?v_179 (not ?v_203)) (?v_180 (p9 c_2 c_0))) (let ((?v_220 (not ?v_180)) (?v_204 (p7 c_2 c_0))) (let ((?v_181 (not ?v_204)) (?v_182 (p9 c_2 c_1))) (let ((?v_221 (not ?v_182)) (?v_205 (p7 c_2 c_1))) (let ((?v_183 (not ?v_205)) (?v_184 (p9 c_2 c_2))) (let ((?v_222 (not ?v_184)) (?v_206 (p7 c_2 c_2))) (let ((?v_185 (not ?v_206)) (?v_186 (p9 c_2 c_3))) (let ((?v_223 (not ?v_186)) (?v_207 (p7 c_2 c_3))) (let ((?v_187 (not ?v_207)) (?v_188 (p9 c_3 c_0))) (let ((?v_224 (not ?v_188)) (?v_208 (p7 c_3 c_0))) (let ((?v_189 (not ?v_208)) (?v_190 (p9 c_3 c_1))) (let ((?v_225 (not ?v_190)) (?v_209 (p7 c_3 c_1))) (let ((?v_191 (not ?v_209)) (?v_192 (p9 c_3 c_2))) (let ((?v_226 (not ?v_192)) (?v_210 (p7 c_3 c_2))) (let ((?v_193 (not ?v_210)) (?v_194 (p9 c_3 c_3))) (let ((?v_227 (not ?v_194)) (?v_211 (p7 c_3 c_3))) (let ((?v_195 (not ?v_211))) (or (?v_52 b0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/simplified.smt2.expected.err000066400000000000000000000000001445011647600236060ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/simplified.smt2.expected.out000066400000000000000000000002001445011647600236270ustar00rootroot00000000000000(error "Unknown symbol `?v_52 Bool'") (error "assertion returns an unknown sort") sat (error "check status which says unsat") opensmt-2.5.2/regression/QF_UF/simplified.smt2.expected.time000066400000000000000000000000351445011647600237640ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_UF/strength2_sat_simplified.smt2000066400000000000000000000007071445011647600241040ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort U 0) (declare-fun z1 () U) (declare-fun z2 () U) (declare-fun z3 () U) (declare-fun z4 () U) (declare-fun w1 () U) (declare-fun w2 () U) (declare-fun w3 () U) (declare-fun w4 () U) (assert (not (or (not (and (= w1 w3) (= w4 w2))) (= z1 z2)))) (assert (and (not (= z3 z4)) (or (not (and (= w1 w3) (= w4 w2))) (= z1 z2)))) (check-sat) opensmt-2.5.2/regression/QF_UF/strength2_sat_simplified.smt2.expected.err000066400000000000000000000000001445011647600264550ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/strength2_sat_simplified.smt2.expected.out000066400000000000000000000000061445011647600265020ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UF/strength2_sat_simplified.smt2.expected.time000066400000000000000000000000351445011647600266330ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/QF_UF/test-tl-ite-sat.smt2000066400000000000000000000003141445011647600220420ustar00rootroot00000000000000(set-logic QF_UF) (declare-fun c () Bool) (declare-fun b () Bool) (declare-fun a () Bool) (set-info :status sat) (assert (ite c (and (ite (or b (not c)) a (not a)) (or (not c) b)) (and a c))) (check-sat) opensmt-2.5.2/regression/QF_UF/test-tl-ite-sat.smt2.expected.err000066400000000000000000000000001445011647600244210ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/test-tl-ite-sat.smt2.expected.out000066400000000000000000000000041445011647600244440ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/test-tl-ite-unsat.smt2000066400000000000000000000002421445011647600224050ustar00rootroot00000000000000(set-logic QF_UF) (declare-fun c () Bool) (declare-fun a () Bool) (set-info :status unsat) (assert (ite c (and (ite c a (not a)) (not c)) (and a c))) (check-sat) opensmt-2.5.2/regression/QF_UF/test-tl-ite-unsat.smt2.expected.err000066400000000000000000000000001445011647600247640ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/test-tl-ite-unsat.smt2.expected.out000066400000000000000000000000061445011647600250110ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UF/test_uf_ite.smt2000066400000000000000000000033541445011647600214230ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_UF) (set-info :source | Generated by: Aman Goel (amangoel@umich.edu), Karem A. Sakallah (karem@umich.edu) Generated on: 2018-04-06 Generated by the tool Averroes 2 (successor of [1]) which implements safety property verification on hardware systems. This SMT problem belongs to a set of SMT problems generated by applying Averroes 2 to benchmarks derived from [2-5]. A total of 412 systems (345 from [2], 19 from [3], 26 from [4], 22 from [5]) were syntactically converted from their original formats (using [6, 7]), and given to Averroes 2 to perform property checking with abstraction (wide bit-vectors -> terms, wide operators -> UF) using SMT solvers [8, 9]. [1] Lee S., Sakallah K.A. (2014) Unbounded Scalable Verification Based on Approximate Property-Directed Reachability and Datapath Abstraction. In: Biere A., Bloem R. (eds) Computer Aided Verification. CAV 2014. Lecture Notes in Computer Science, vol 8559. Springer, Cham [2] http://fmv.jku.at/aiger/index.html#beem [3] http://www.cs.cmu.edu/~modelcheck/vcegar [4] http://www.cprover.org/hardware/v2c [5] http://github.com/aman-goel/verilogbench [6] http://www.clifford.at/yosys [7] http://github.com/chengyinwu/V3 [8] http://github.com/Z3Prover/z3 [9] http://github.com/SRI-CSL/yices2 id: cache_coherence_three query-maker: "Yices 2" query-time: 6.711000 ms query-class: abstract query-category: oneshot query-type: cti status: sat |) (set-info :license "https://creativecommons.org/licenses/by/4.0/") (set-info :category "industrial") ; (set-info :status sat) (declare-sort utt 0) (declare-fun Extract (utt ) Bool) (declare-fun y () utt) (declare-fun z () utt) (declare-fun x () utt) (assert ( Extract (ite (or (= x z) (= x y)) y z))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UF/test_uf_ite.smt2.expected.err000066400000000000000000000000001445011647600237730ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/test_uf_ite.smt2.expected.out000066400000000000000000000000041445011647600240160ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/uf_bool_test_sat.smt2000066400000000000000000000004341445011647600224400ustar00rootroot00000000000000(set-logic QF_UF) (set-info :status sat) (declare-fun p (Bool) Bool) (declare-fun a () Bool) (declare-fun b () Bool) (declare-fun c () Bool) (assert (or (not c) (= (p a) true))) (assert (or (not c) (= (p b) false))) (assert (or c (= a b))) (assert (or (not c) (= a b))) (check-sat) opensmt-2.5.2/regression/QF_UF/uf_bool_test_sat.smt2.expected.err000066400000000000000000000000001445011647600250140ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/uf_bool_test_sat.smt2.expected.out000066400000000000000000000000041445011647600250370ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UF/uf_bool_test_unsat.smt2000066400000000000000000000004041445011647600230000ustar00rootroot00000000000000(set-logic QF_UF) (set-info :status unsat) (declare-fun p (Bool) Bool) (declare-fun a () Bool) (declare-fun b () Bool) (declare-fun c () Bool) (assert (= (p a) true)) (assert (= (p b) false)) (assert (or c (= a b))) (assert (or (not c) (= a b))) (check-sat) opensmt-2.5.2/regression/QF_UF/uf_bool_test_unsat.smt2.expected.err000066400000000000000000000000001445011647600253570ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UF/uf_bool_test_unsat.smt2.expected.out000066400000000000000000000000061445011647600254040ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UFIDL/000077500000000000000000000000001445011647600166265ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFIDL/smtlib.877473.smt2000066400000000000000000000007771445011647600215240ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_UFIDL) (set-info :source |Benchmarks from the paper: "Extending Sledgehammer with SMT Solvers" by Jasmin Blanchette, Sascha Bohme, and Lawrence C. Paulson, CADE 2011. Translated to SMT2 by Andrew Reynolds and Morgan Deters.|) (set-info :category "industrial") (set-info :status unsat) (declare-sort S1 0) (declare-fun f1 () S1) (declare-fun f2 () S1) (declare-fun f3 () Int) (assert (not (= f1 f2))) (assert (not (=> (not (<= 0 f3)) (< f3 0)))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UFIDL/smtlib.877473.smt2.expected.err000066400000000000000000000000001445011647600240660ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFIDL/smtlib.877473.smt2.expected.out000066400000000000000000000000061445011647600241130ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UFLIA/000077500000000000000000000000001445011647600166235ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLIA/issue626.smt2000066400000000000000000000002341445011647600210170ustar00rootroot00000000000000(set-logic QF_UFLIA) (set-info :status unsat) (declare-fun t () Int) (declare-fun u (Int Int) Int) (assert (and (> 0 t) (= t (mod (u 0 0) 2)))) (check-sat) opensmt-2.5.2/regression/QF_UFLIA/issue626.smt2.expected.err000066400000000000000000000000001445011647600233750ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLIA/issue626.smt2.expected.out000066400000000000000000000000061445011647600234220ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UFLIA/mbtc_regression.smt2000066400000000000000000000001671445011647600226230ustar00rootroot00000000000000(set-logic QF_UFLIA) (set-info :status sat) (declare-fun x (Int) Int) (assert (= 1 (+ (* 2 (x 1)) (x 0)))) (check-sat) opensmt-2.5.2/regression/QF_UFLIA/mbtc_regression.smt2.expected.err000066400000000000000000000000001445011647600251740ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLIA/mbtc_regression.smt2.expected.out000066400000000000000000000000041445011647600252170ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UFLRA/000077500000000000000000000000001445011647600166345ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLRA/euf_unsat.smt2000066400000000000000000000002711445011647600214340ustar00rootroot00000000000000(set-info :status unsat) (set-logic QF_UFLRA) (declare-fun x () Real) (declare-fun f (Real) Real) (assert (>= x 0)) (assert (= x (f x))) (assert (distinct (f (f x)) (f x))) (check-sat) opensmt-2.5.2/regression/QF_UFLRA/euf_unsat.smt2.expected.err000066400000000000000000000000001445011647600240110ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLRA/euf_unsat.smt2.expected.out000066400000000000000000000000061445011647600240360ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UFLRA/lra_unsat.smt2000066400000000000000000000003221445011647600214300ustar00rootroot00000000000000(set-info :status unsat) (set-logic QF_UFLRA) (declare-fun x () Real) (declare-fun f (Real) Real) (assert (>= (f x) 0)) (assert (> x 1)) (assert (>= (f (f x)) 0)) (assert (< (+ (f x) (f (f x))) 0)) (check-sat) opensmt-2.5.2/regression/QF_UFLRA/lra_unsat.smt2.expected.err000066400000000000000000000000001445011647600240100ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLRA/lra_unsat.smt2.expected.out000066400000000000000000000000061445011647600240350ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UFLRA/purify_test_1.smt2000066400000000000000000000002021445011647600222320ustar00rootroot00000000000000(set-info :status sat) (set-logic QF_UFLRA) (declare-fun x () Real) (declare-fun f (Real) Real) (assert (>= x (f x))) (check-sat) opensmt-2.5.2/regression/QF_UFLRA/purify_test_1.smt2.expected.err000066400000000000000000000000001445011647600246150ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLRA/purify_test_1.smt2.expected.out000066400000000000000000000000041445011647600246400ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UFLRA/purify_test_2.smt2000066400000000000000000000002101445011647600222320ustar00rootroot00000000000000(set-info :status sat) (set-logic QF_UFLRA) (declare-fun x () Real) (declare-fun f (Real) Real) (assert (>= (+ x (f x)) 0)) (check-sat) opensmt-2.5.2/regression/QF_UFLRA/purify_test_2.smt2.expected.err000066400000000000000000000000001445011647600246160ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLRA/purify_test_2.smt2.expected.out000066400000000000000000000000041445011647600246410ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UFLRA/purify_test_3.smt2000066400000000000000000000001641445011647600222430ustar00rootroot00000000000000(set-info :status sat) (set-logic QF_UFLRA) (declare-fun f (Real Real) Real) (assert (< (f 0.0 0.0) 0)) (check-sat) opensmt-2.5.2/regression/QF_UFLRA/purify_test_3.smt2.expected.err000066400000000000000000000000001445011647600246170ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLRA/purify_test_3.smt2.expected.out000066400000000000000000000000041445011647600246420ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UFLRA/purify_test_4.smt2000066400000000000000000000002641445011647600222450ustar00rootroot00000000000000(set-info :status sat) (set-logic QF_UFLRA) (declare-fun f (Real) Real) (declare-fun g (Real Real) Real) (assert (and (< 0 (g 0.0 0.0)) (< 0 (f (- (f (g 0.0 0.0))))))) (check-sat) opensmt-2.5.2/regression/QF_UFLRA/purify_test_4.smt2.expected.err000066400000000000000000000000001445011647600246200ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLRA/purify_test_4.smt2.expected.out000066400000000000000000000000041445011647600246430ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UFLRA/regression_1.smt2000066400000000000000000000002201445011647600220350ustar00rootroot00000000000000(set-logic QF_UFLRA) (set-info :status unsat) (declare-fun f (Real Real) Real) (assert (and (< 0 (f 0.0 0.0)) (= 0.0 (f 0.0 0.0)))) (check-sat) opensmt-2.5.2/regression/QF_UFLRA/regression_1.smt2.expected.err000066400000000000000000000000001445011647600244200ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLRA/regression_1.smt2.expected.out000066400000000000000000000000061445011647600244450ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UFLRA/regression_10.smt2000066400000000000000000000003361445011647600221250ustar00rootroot00000000000000(set-logic QF_UFLRA) (set-info :status sat) (declare-const x Bool) (declare-fun D () Real) (declare-fun A () Real) (declare-fun s (Real) Real) (assert (or x (and (= D A) (and (distinct D A) (= 0.0 (s 0.0)))))) (check-sat) opensmt-2.5.2/regression/QF_UFLRA/regression_10.smt2.expected.err000066400000000000000000000000001445011647600245000ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLRA/regression_10.smt2.expected.out000066400000000000000000000000041445011647600245230ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UFLRA/regression_11.smt2000066400000000000000000000003151445011647600221230ustar00rootroot00000000000000(set-logic QF_UFLRA) (set-info :status sat) (declare-fun b () Real) (declare-fun f (Real) Real) (declare-fun a () Real) (assert (or (= b 0.0) (and (= a b) (and (distinct a b) (= 0.0 (f b)))))) (check-sat) opensmt-2.5.2/regression/QF_UFLRA/regression_11.smt2.expected.err000066400000000000000000000000001445011647600245010ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLRA/regression_11.smt2.expected.out000066400000000000000000000000041445011647600245240ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UFLRA/regression_12.smt2000066400000000000000000000002461445011647600221270ustar00rootroot00000000000000(set-logic QF_UFLRA) (set-info :status sat) (declare-fun f (Real) Real) (declare-fun x () Real) (assert (and (>= (f 1.0) 0) (< (- x) 0) (= (f x) (- 1)))) (check-sat) opensmt-2.5.2/regression/QF_UFLRA/regression_12.smt2.expected.err000066400000000000000000000000001445011647600245020ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLRA/regression_12.smt2.expected.out000066400000000000000000000000041445011647600245250ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UFLRA/regression_2.smt2000066400000000000000000000003771445011647600220530ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_UFLRA) (set-info :status unsat) (declare-fun f3 (Real) Real) (declare-fun f4 () Real) (declare-fun f5 () Real) (assert (= (f3 f4) (- 1))) (assert (not (=> (= f5 f4) (not (= (f3 f5) 1.0))))) (check-sat) (exit) opensmt-2.5.2/regression/QF_UFLRA/regression_2.smt2.expected.err000066400000000000000000000000001445011647600244210ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLRA/regression_2.smt2.expected.out000066400000000000000000000000061445011647600244460ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UFLRA/regression_3.smt2000066400000000000000000000002431445011647600220440ustar00rootroot00000000000000(set-logic QF_UFLRA) (set-info :status unsat) (declare-fun f (Real) Real) (declare-fun x () Real) (assert (and (= 0.0 x) (= 1 (f x)) (= 0.0 (f 0.0)))) (check-sat) opensmt-2.5.2/regression/QF_UFLRA/regression_3.smt2.expected.err000066400000000000000000000000001445011647600244220ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLRA/regression_3.smt2.expected.out000066400000000000000000000000061445011647600244470ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UFLRA/regression_4.smt2000066400000000000000000000002461445011647600220500ustar00rootroot00000000000000(set-logic QF_UFLRA) (set-info :status unsat) (declare-fun f1 (Real) Real) (declare-fun x () Real) (assert (and (= 0.0 x) (> (f1 x) 1) (= 0.0 (f1 0.0)))) (check-sat) opensmt-2.5.2/regression/QF_UFLRA/regression_4.smt2.expected.err000066400000000000000000000000001445011647600244230ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLRA/regression_4.smt2.expected.out000066400000000000000000000000061445011647600244500ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UFLRA/regression_5.smt2000066400000000000000000000002201445011647600220410ustar00rootroot00000000000000(set-logic QF_UFLRA) (set-info :status unsat) (declare-fun f (Real Real) Real) (assert (and (< (f 0.0 0.0) 0) (= 1.0 (f 0.0 0.0)))) (check-sat) opensmt-2.5.2/regression/QF_UFLRA/regression_5.smt2.expected.err000066400000000000000000000000001445011647600244240ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLRA/regression_5.smt2.expected.out000066400000000000000000000000061445011647600244510ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UFLRA/regression_6.smt2000066400000000000000000000002731445011647600220520ustar00rootroot00000000000000(set-logic QF_UFLRA) (set-info :status unsat) (declare-fun f (Real Real) Real) (declare-fun x () Real) (assert (and (distinct x 0) (= 0 (f 0.0 0.0)) (= (f 0.0 0.0) (* 2 x)))) (check-sat) opensmt-2.5.2/regression/QF_UFLRA/regression_6.smt2.expected.err000066400000000000000000000000001445011647600244250ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLRA/regression_6.smt2.expected.out000066400000000000000000000000061445011647600244520ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/QF_UFLRA/regression_7.smt2000066400000000000000000000002231445011647600220460ustar00rootroot00000000000000(set-logic QF_UFLRA) (set-info :status sat) (declare-fun A () Real) (declare-fun c (Real) Real) (assert (and (= (c 0.0) A) (= A 1.0))) (check-sat) opensmt-2.5.2/regression/QF_UFLRA/regression_7.smt2.expected.err000066400000000000000000000000001445011647600244260ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLRA/regression_7.smt2.expected.out000066400000000000000000000000041445011647600244510ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UFLRA/regression_8.smt2000066400000000000000000000004541445011647600220550ustar00rootroot00000000000000(set-logic QF_UFLRA) (set-info :status sat) (declare-const x Bool) (declare-fun x1 () Real) (declare-fun x2 () Real) (declare-fun f (Real) Real) (declare-fun P () Bool) (assert (let ((?v_75 (= (f 1.0) (f 1.0)))) (and (< x1 1) (or x P) (= (f x2) (f 0.0)) (or (= 0.0 x2) (= x1 (f 1.0)))))) (check-sat) opensmt-2.5.2/regression/QF_UFLRA/regression_8.smt2.expected.err000066400000000000000000000000001445011647600244270ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLRA/regression_8.smt2.expected.out000066400000000000000000000000041445011647600244520ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UFLRA/regression_9.smt2000066400000000000000000000003421445011647600220520ustar00rootroot00000000000000(set-logic QF_UFLRA) (set-info :status sat) (declare-fun x () Real) (declare-fun f (Real) Real) (declare-fun g (Real Real) Real) (assert (and (not (= x 1)) (= 1.0 (f 0.0)) (< 0 (g 0.0 0.0)) (= (f x) (g 0.0 0.0)))) (check-sat) opensmt-2.5.2/regression/QF_UFLRA/regression_9.smt2.expected.err000066400000000000000000000000001445011647600244300ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLRA/regression_9.smt2.expected.out000066400000000000000000000000041445011647600244530ustar00rootroot00000000000000sat opensmt-2.5.2/regression/QF_UFLRA/substitutions.smt2000066400000000000000000000002501445011647600223770ustar00rootroot00000000000000(set-logic QF_UFLRA) (declare-fun f (Real) Real) (declare-fun x () Real) (assert (= x (f x))) (assert (= x (f (+ x 1.0)))) (assert (= (f x) (f (+ x 1.0)))) (check-sat) opensmt-2.5.2/regression/QF_UFLRA/substitutions.smt2.expected.err000066400000000000000000000000001445011647600247570ustar00rootroot00000000000000opensmt-2.5.2/regression/QF_UFLRA/substitutions.smt2.expected.out000066400000000000000000000000041445011647600250020ustar00rootroot00000000000000sat opensmt-2.5.2/regression/add-instance.sh000077500000000000000000000017231445011647600202710ustar00rootroot00000000000000#!/bin/bash usage="Usage: $0 [-h] -b [instance [instance [...]]]" while [ $# -gt 0 ]; do case $1 in -h|--help) echo "${usage}" exit 1 ;; -b|--binary) osmt=$2 ;; -*) echo "Error: invalid option '$1'" exit 1 ;; *) break esac shift; shift done if [ -z ${osmt} ]; then echo "Error: opensmt not specified. Use -b " exit 1 fi echo "Adding as follows:" echo " - osmt: ${osmt} ($(date -r ${osmt}))" echo " - files: $@" echo "Is this ok?" read -p "y/N? " if [[ ${REPLY} != y ]]; then echo "Aborting." exit 1 fi while [ $# -gt 0 ]; do echo $1; if [[ -a $1 ]]; then sh -c "ulimit -St 60; ${osmt} $1 > $1.expected.out 2> $1.expected.err.tmp"; grep -v '^;' $1.expected.err.tmp > $1.expected.err; rm $1.expected.err.tmp else echo "File does not exist" fi; shift; done opensmt-2.5.2/regression/divmod/000077500000000000000000000000001445011647600166575ustar00rootroot00000000000000opensmt-2.5.2/regression/divmod/div_1.smt2000066400000000000000000000001461445011647600204710ustar00rootroot00000000000000(set-logic QF_LIA) (set-info :status sat) (declare-fun x () Int) (assert (= 0 (div x 2))) (check-sat) opensmt-2.5.2/regression/divmod/div_1.smt2.expected.err000066400000000000000000000000001445011647600230450ustar00rootroot00000000000000opensmt-2.5.2/regression/divmod/div_1.smt2.expected.out000066400000000000000000000000041445011647600230700ustar00rootroot00000000000000sat opensmt-2.5.2/regression/divmod/div_2.smt2000066400000000000000000000002641445011647600204730ustar00rootroot00000000000000(set-logic QF_LIA) (set-info :status sat) (declare-fun x () Int) (declare-fun b () Bool) (assert (or b (= x 5))) (assert (or (not b) (= x 5))) (assert (= 2 (div x 2))) (check-sat) opensmt-2.5.2/regression/divmod/div_2.smt2.expected.err000066400000000000000000000000001445011647600230460ustar00rootroot00000000000000opensmt-2.5.2/regression/divmod/div_2.smt2.expected.out000066400000000000000000000000041445011647600230710ustar00rootroot00000000000000sat opensmt-2.5.2/regression/divmod/div_3.smt2000066400000000000000000000002661445011647600204760ustar00rootroot00000000000000(set-logic QF_LIA) (set-info :status unsat) (declare-fun x () Int) (declare-fun b () Bool) (assert (or b (= x 5))) (assert (or (not b) (= x 5))) (assert (= 1 (div x 2))) (check-sat) opensmt-2.5.2/regression/divmod/div_3.smt2.expected.err000066400000000000000000000000001445011647600230470ustar00rootroot00000000000000opensmt-2.5.2/regression/divmod/div_3.smt2.expected.out000066400000000000000000000000061445011647600230740ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/divmod/mod_1.smt2000066400000000000000000000001461445011647600204660ustar00rootroot00000000000000(set-logic QF_LIA) (set-info :status sat) (declare-fun x () Int) (assert (= 0 (mod x 2))) (check-sat) opensmt-2.5.2/regression/divmod/mod_1.smt2.expected.err000066400000000000000000000000001445011647600230420ustar00rootroot00000000000000opensmt-2.5.2/regression/divmod/mod_1.smt2.expected.out000066400000000000000000000000041445011647600230650ustar00rootroot00000000000000sat opensmt-2.5.2/regression/divmod/mod_2.smt2000066400000000000000000000002641445011647600204700ustar00rootroot00000000000000(set-logic QF_LIA) (set-info :status sat) (declare-fun x () Int) (declare-fun b () Bool) (assert (or b (= x 5))) (assert (or (not b) (= x 5))) (assert (= 1 (mod x 2))) (check-sat) opensmt-2.5.2/regression/divmod/mod_2.smt2.expected.err000066400000000000000000000000001445011647600230430ustar00rootroot00000000000000opensmt-2.5.2/regression/divmod/mod_2.smt2.expected.out000066400000000000000000000000041445011647600230660ustar00rootroot00000000000000sat opensmt-2.5.2/regression/divmod/mod_3.smt2000066400000000000000000000002661445011647600204730ustar00rootroot00000000000000(set-logic QF_LIA) (set-info :status unsat) (declare-fun x () Int) (declare-fun b () Bool) (assert (or b (= x 5))) (assert (or (not b) (= x 5))) (assert (= 0 (mod x 2))) (check-sat) opensmt-2.5.2/regression/divmod/mod_3.smt2.expected.err000066400000000000000000000000001445011647600230440ustar00rootroot00000000000000opensmt-2.5.2/regression/divmod/mod_3.smt2.expected.out000066400000000000000000000000061445011647600230710ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/divmod/mod_4.smt2000066400000000000000000000002541445011647600204710ustar00rootroot00000000000000(set-logic QF_LIA) (set-info :status unsat) (declare-fun x () Int) (assert (not (= 0 (mod x 3)))) (assert (not (= 1 (mod x 3)))) (assert (not (= 2 (mod x 3)))) (check-sat) opensmt-2.5.2/regression/divmod/mod_4.smt2.expected.err000066400000000000000000000000001445011647600230450ustar00rootroot00000000000000opensmt-2.5.2/regression/divmod/mod_4.smt2.expected.out000066400000000000000000000000061445011647600230720ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/divmod/nested-div.smt2000066400000000000000000000002121445011647600215230ustar00rootroot00000000000000(set-logic QF_LIA) (set-info :status unsat) (declare-fun a () Int) (assert (>= a 0)) (assert (< (div a 2) (div (div a 2) 2))) (check-sat) opensmt-2.5.2/regression/divmod/nested-div.smt2.expected.err000066400000000000000000000000001445011647600241050ustar00rootroot00000000000000opensmt-2.5.2/regression/divmod/nested-div.smt2.expected.out000066400000000000000000000000061445011647600241320ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/divmod/nested-mod.smt2000066400000000000000000000001761445011647600215310ustar00rootroot00000000000000(set-logic QF_LIA) (set-info :status unsat) (declare-fun a () Int) (assert (not (= (mod a 2) (mod (mod a 2) 2)))) (check-sat) opensmt-2.5.2/regression/divmod/nested-mod.smt2.expected.err000066400000000000000000000000001445011647600241020ustar00rootroot00000000000000opensmt-2.5.2/regression/divmod/nested-mod.smt2.expected.out000066400000000000000000000000061445011647600241270ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/generic/000077500000000000000000000000001445011647600170115ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/ambiguous-symbol-negative.smt2000066400000000000000000000001161445011647600247140ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun a () Int) (declare-fun a () Bool) (assert a) opensmt-2.5.2/regression/generic/ambiguous-symbol-negative.smt2.expected.err000066400000000000000000000000001445011647600272730ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/ambiguous-symbol-negative.smt2.expected.out000066400000000000000000000001161445011647600273220ustar00rootroot00000000000000(error "Ambiguous symbol: `a'") (error "assertion returns an unknown sort") opensmt-2.5.2/regression/generic/ambiguous-symbol-positive.smt2000066400000000000000000000001751445011647600247610ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun a () Int) (declare-fun a () Bool) (assert (as a Bool)) (assert (> (as a Int) 0)) (check-sat) opensmt-2.5.2/regression/generic/ambiguous-symbol-positive.smt2.expected.err000066400000000000000000000000001445011647600273330ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/ambiguous-symbol-positive.smt2.expected.out000066400000000000000000000000041445011647600273560ustar00rootroot00000000000000sat opensmt-2.5.2/regression/generic/antti-simplification-on-sep7.smt2000066400000000000000000000002721445011647600252360ustar00rootroot00000000000000(set-logic QF_UF) (define-fun mod2 ((ti1 Bool) (to1 Bool)) Bool (= ti1 to1)) (declare-fun i1 () Bool) (declare-fun o1 () Bool) (assert (mod2 i1 o1)) (assert (not (= i1 o1))) (check-sat) opensmt-2.5.2/regression/generic/antti-simplification-on-sep7.smt2.expected.err000066400000000000000000000000001445011647600276120ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/antti-simplification-on-sep7.smt2.expected.out000066400000000000000000000000061445011647600276370ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/generic/antti-simplification-on-sep7.smt2.expected.time000066400000000000000000000000351445011647600277700ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/generic/boolean-distinct.smt2000066400000000000000000000002141445011647600230530ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun _substvar_29_ () Bool) (check-sat) (check-sat) (assert (or (distinct true true) _substvar_29_)) (check-sat) opensmt-2.5.2/regression/generic/boolean-distinct.smt2.expected.err000066400000000000000000000000001445011647600254330ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/boolean-distinct.smt2.expected.out000066400000000000000000000000141445011647600254570ustar00rootroot00000000000000sat sat sat opensmt-2.5.2/regression/generic/boolean-vars-with-digit-only-names.smt2000066400000000000000000000003351445011647600263400ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun |1| () Bool) (declare-fun |123| () Bool) (declare-fun x () Int) (declare-fun y () Int) (assert (as |123| Bool)) (assert (not (as |1| Bool))) (assert (= x 123)) (assert (= y 1)) (check-sat) opensmt-2.5.2/regression/generic/boolean-vars-with-digit-only-names.smt2.expected.err000066400000000000000000000000001445011647600307140ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/boolean-vars-with-digit-only-names.smt2.expected.out000066400000000000000000000000041445011647600307370ustar00rootroot00000000000000sat opensmt-2.5.2/regression/generic/chainable-equalities.smt2000066400000000000000000000001541445011647600236710ustar00rootroot00000000000000(set-logic QF_UF) (declare-fun x () Bool) (declare-fun y () Bool) (assert (= x y (= x false))) (check-sat) opensmt-2.5.2/regression/generic/chainable-equalities.smt2.expected.err000066400000000000000000000000001445011647600262460ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/chainable-equalities.smt2.expected.out000066400000000000000000000000061445011647600262730ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/generic/check-sat-after-unsat.smt2000066400000000000000000000002411445011647600237060ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun v4 () Bool) (declare-fun i0 () Real) (assert (< i0 71)) (check-sat) (assert (xor (and (< i0 71) v4) v4)) (check-sat) (check-sat) opensmt-2.5.2/regression/generic/check-sat-after-unsat.smt2.expected.err000066400000000000000000000000001445011647600262660ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/check-sat-after-unsat.smt2.expected.out000066400000000000000000000000201445011647600263070ustar00rootroot00000000000000sat unsat unsat opensmt-2.5.2/regression/generic/check-status-incremental-ok.smt2000066400000000000000000000003211445011647600251200ustar00rootroot00000000000000(set-logic QF_UF) (set-info :status sat) (check-sat) (set-info :status unsat) (push 1) (assert false) (check-sat) (pop 1) (set-info :status sat) (check-sat) (set-info :status unsat) (assert false) (check-sat) opensmt-2.5.2/regression/generic/check-status-incremental-ok.smt2.expected.err000066400000000000000000000000001445011647600275010ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/check-status-incremental-ok.smt2.expected.out000066400000000000000000000000241445011647600275260ustar00rootroot00000000000000sat unsat sat unsat opensmt-2.5.2/regression/generic/check-status-incremental-unknown.smt2000066400000000000000000000005141445011647600262120ustar00rootroot00000000000000(set-logic QF_UF) (set-info :status sat) (check-sat) (set-info :status unsat) (push 1) (assert false) (check-sat) (pop 1) (set-info :status sat) (check-sat) (set-info :status unknown) (assert true) (check-sat) (set-info :status unsat) (push 1) (assert false) (check-sat) (pop 1) (set-info :status unsat) (assert false) (check-sat) opensmt-2.5.2/regression/generic/check-status-incremental-unknown.smt2.expected.err000066400000000000000000000000001445011647600305670ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/check-status-incremental-unknown.smt2.expected.out000066400000000000000000000000361445011647600306170ustar00rootroot00000000000000sat unsat sat sat unsat unsat opensmt-2.5.2/regression/generic/check-status-incremental-wrong.smt2000066400000000000000000000003171445011647600256500ustar00rootroot00000000000000(set-logic QF_UF) (set-info :status sat) (check-sat) (set-info :status unsat) (push 1) (assert false) (check-sat) (pop 1) (set-info :status sat) (check-sat) (set-info :status sat) (assert false) (check-sat) opensmt-2.5.2/regression/generic/check-status-incremental-wrong.smt2.expected.err000066400000000000000000000000001445011647600302240ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/check-status-incremental-wrong.smt2.expected.out000066400000000000000000000000721445011647600302540ustar00rootroot00000000000000sat unsat sat unsat (error "check status which says sat") opensmt-2.5.2/regression/generic/check-status-sat-ok.smt2000066400000000000000000000001051445011647600234060ustar00rootroot00000000000000(set-logic QF_UF) (set-info :status sat) (assert true) (check-sat) opensmt-2.5.2/regression/generic/check-status-sat-ok.smt2.expected.err000066400000000000000000000000001445011647600257670ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/check-status-sat-ok.smt2.expected.out000066400000000000000000000000041445011647600260120ustar00rootroot00000000000000sat opensmt-2.5.2/regression/generic/check-status-sat-wrong.smt2000066400000000000000000000001061445011647600241320ustar00rootroot00000000000000(set-logic QF_UF) (set-info :status sat) (assert false) (check-sat) opensmt-2.5.2/regression/generic/check-status-sat-wrong.smt2.expected.err000066400000000000000000000000001445011647600265120ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/check-status-sat-wrong.smt2.expected.out000066400000000000000000000000541445011647600265420ustar00rootroot00000000000000unsat (error "check status which says sat") opensmt-2.5.2/regression/generic/check-status-unknown-sat.smt2000066400000000000000000000001111445011647600244710ustar00rootroot00000000000000(set-logic QF_UF) (set-info :status unknown) (assert true) (check-sat) opensmt-2.5.2/regression/generic/check-status-unknown-sat.smt2.expected.err000066400000000000000000000000001445011647600270550ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/check-status-unknown-sat.smt2.expected.out000066400000000000000000000000041445011647600271000ustar00rootroot00000000000000sat opensmt-2.5.2/regression/generic/check-status-unknown-unsat.smt2000066400000000000000000000001121445011647600250350ustar00rootroot00000000000000(set-logic QF_UF) (set-info :status unknown) (assert false) (check-sat) opensmt-2.5.2/regression/generic/check-status-unknown-unsat.smt2.expected.err000066400000000000000000000000001445011647600274200ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/check-status-unknown-unsat.smt2.expected.out000066400000000000000000000000061445011647600274450ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/generic/check-status-unsat-ok.smt2000066400000000000000000000001101445011647600237450ustar00rootroot00000000000000(set-logic QF_UF) (set-info :status unsat) (assert false) (check-sat) opensmt-2.5.2/regression/generic/check-status-unsat-ok.smt2.expected.err000066400000000000000000000000001445011647600263320ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/check-status-unsat-ok.smt2.expected.out000066400000000000000000000000061445011647600263570ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/generic/check-status-unsat-wrong.smt2000066400000000000000000000001071445011647600244760ustar00rootroot00000000000000(set-logic QF_UF) (set-info :status unsat) (assert true) (check-sat) opensmt-2.5.2/regression/generic/check-status-unsat-wrong.smt2.expected.err000066400000000000000000000000001445011647600270550ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/check-status-unsat-wrong.smt2.expected.out000066400000000000000000000000541445011647600271050ustar00rootroot00000000000000sat (error "check status which says unsat") opensmt-2.5.2/regression/generic/define-fun-same-name-different-sort.smt2000066400000000000000000000003411445011647600264300ustar00rootroot00000000000000(set-logic QF_LIA) (set-info :status sat) (define-fun f1 ((A Bool)) Bool (not A)) (define-fun f2 ((A Int)) Int (+ A 1)) (declare-fun b () Bool) (declare-fun x () Int) (assert (and (f1 b) (> (f2 x) 0))) (check-sat) (exit) opensmt-2.5.2/regression/generic/define-fun-same-name-different-sort.smt2.expected.err000066400000000000000000000000001445011647600310070ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/define-fun-same-name-different-sort.smt2.expected.out000066400000000000000000000000041445011647600310320ustar00rootroot00000000000000sat opensmt-2.5.2/regression/generic/define-fun.smt2000066400000000000000000000001541445011647600216400ustar00rootroot00000000000000(define-fun foo ((a integer) (b real) (c frobbozian)) ((_ bv0 1 2 3 4) q q1 q2 q3) (let ((x 1) (y 2)) bar)) opensmt-2.5.2/regression/generic/define-fun.smt2.expected.err000066400000000000000000000000001445011647600242150ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/define-fun.smt2.expected.out000066400000000000000000000000701445011647600242430ustar00rootroot00000000000000(error "Illegal command before set-logic: define-fun") opensmt-2.5.2/regression/generic/define-fun.smt2.expected.time000066400000000000000000000000351445011647600243730ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/generic/define-fun2.smt2000066400000000000000000000002171445011647600217220ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun a () Real) (declare-fun b () Real) (define-fun foo () Real (+ a b 1)) (assert (> foo foo)) (check-sat) opensmt-2.5.2/regression/generic/define-fun2.smt2.expected.err000066400000000000000000000000001445011647600242770ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/define-fun2.smt2.expected.out000066400000000000000000000000061445011647600243240ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/generic/define-fun2.smt2.expected.time000066400000000000000000000000351445011647600244550ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/generic/error.smt2000066400000000000000000000000371445011647600207510ustar00rootroot00000000000000(assert foo) (set-logic AB_CD) opensmt-2.5.2/regression/generic/error.smt2.expected.err000066400000000000000000000000001445011647600233260ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/error.smt2.expected.out000066400000000000000000000001231445011647600233530ustar00rootroot00000000000000(error "Illegal command before set-logic: assert") (error "unknown logic AB_CD") opensmt-2.5.2/regression/generic/error.smt2.expected.time000066400000000000000000000000751445011647600235100ustar00rootroot00000000000000Command terminated by signal 11 real 0.19 user 0.00 sys 0.00 opensmt-2.5.2/regression/generic/foo000066400000000000000000000000001445011647600175050ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/foo.expected.err000066400000000000000000000000001445011647600220740ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/foo.expected.out000066400000000000000000000000001445011647600221130ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/foo.expected.time000066400000000000000000000001031445011647600222460ustar00rootroot00000000000000Command exited with non-zero status 1 real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/generic/integer-var-with-numeric-name.smt2000066400000000000000000000002231445011647600253670ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun |1| () Int) (declare-fun |2| () Int) (assert (= |1| 2)) (assert (= (as |2| Int) 1)) (assert (< 1 |1|)) (check-sat) opensmt-2.5.2/regression/generic/integer-var-with-numeric-name.smt2.expected.err000066400000000000000000000000001445011647600277470ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/integer-var-with-numeric-name.smt2.expected.out000066400000000000000000000000041445011647600277720ustar00rootroot00000000000000sat opensmt-2.5.2/regression/generic/issue_613.smt2000066400000000000000000000021231445011647600213370ustar00rootroot00000000000000(set-logic QF_LIA) (set-info :status unsat) (define-fun state ((A Bool) (B Bool) (C Bool) (D Bool) (E Int) (F Int) (G Int)) Bool (or (or (or (or (or (or (or (and (and (and (= A true) (= B true)) (not (= D true))) (>= E 1)) (and (and (and (= A true) (= D true)) (and (not (= B true)) (not (= C true)))) (>= E 1))) (and (and (= A true) (and (not (= B true)) (not (= D true)))) (>= E 1))) (and (and (and (= B true) (= D true)) (and (not (= A true)) (not (= C true)))) (>= E 1))) (and (= B true) (and (and (not (= A true)) (not (= C true))) (not (= D true))))) (and (and (= B true) (and (not (= A true)) (not (= D true)))) (>= E 1))) (and (and (= D true) (and (and (not (= A true)) (not (= B true))) (not (= C true)))) (>= E 1))) (and (and (and (not (= A true)) (not (= B true))) (not (= D true))) (>= E 1)))) (declare-fun A () Bool) (declare-fun B () Bool) (declare-fun C () Int) (declare-fun D () Int) (declare-fun E () Int) (declare-fun F () Bool) (declare-fun G () Bool) (assert (and (and (= A true) (not G) (not F) (not B)) (not (state B A G F C D E)) ) ) (check-sat) (exit) opensmt-2.5.2/regression/generic/issue_613.smt2.expected.err000066400000000000000000000000001445011647600237160ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/issue_613.smt2.expected.out000066400000000000000000000000061445011647600237430ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/generic/issue_617.smt2000066400000000000000000000004661445011647600213530ustar00rootroot00000000000000(set-option :produce-models true) (set-logic QF_LIA) (declare-const x Int) (define-fun f () Bool (= x 1)) (assert (= x 1)) (check-sat) (get-value (f)) (get-value ((+ (* 2 x) 1))) (get-value ((+ 1 1))) (get-value ((!(+ x 1) :named test))) (get-value ((let ((y 0)) y))) (get-value ((let ((y 1) (z 2)) (+ y z)))) opensmt-2.5.2/regression/generic/issue_617.smt2.expected.err000066400000000000000000000000001445011647600237220ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/issue_617.smt2.expected.out000066400000000000000000000002061445011647600237510ustar00rootroot00000000000000sat ((f true)) (((+ (* 2 x) 1) 3)) (((+ 1 1) 2)) (((!(+ x 1) :named test) 2)) (((let ((y 0)) y) 0)) (((let ((y 1) (z 2)) (+ y z)) 3)) opensmt-2.5.2/regression/generic/let-overload.smt2000066400000000000000000000001331445011647600222120ustar00rootroot00000000000000(set-logic QF_UF) (set-info :status sat) (assert (let ((l false) (l true)) l)) (check-sat) opensmt-2.5.2/regression/generic/let-overload.smt2.expected.err000066400000000000000000000000001445011647600245720ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/let-overload.smt2.expected.out000066400000000000000000000000041445011647600246150ustar00rootroot00000000000000sat opensmt-2.5.2/regression/generic/let-overload2.smt2000066400000000000000000000001351445011647600222760ustar00rootroot00000000000000(set-logic QF_UF) (set-info :status unsat) (assert (let ((l true) (l false)) l)) (check-sat) opensmt-2.5.2/regression/generic/let-overload2.smt2.expected.err000066400000000000000000000000001445011647600246540ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/let-overload2.smt2.expected.out000066400000000000000000000000061445011647600247010ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/generic/let_shadowed.smt2000066400000000000000000000002001445011647600222520ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun x () Real) (assert (>= x 0)) (assert (let ((l1 (< x 0))) (let ((l1 true)) l1))) (check-sat) opensmt-2.5.2/regression/generic/let_shadowed.smt2.expected.err000066400000000000000000000000001445011647600246370ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/let_shadowed.smt2.expected.out000066400000000000000000000000041445011647600246620ustar00rootroot00000000000000sat opensmt-2.5.2/regression/generic/let_shadowing_var.smt2000066400000000000000000000001501445011647600233130ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun x () Real) (assert (>= x 0)) (assert (let ((x (< x 0))) x)) (check-sat) opensmt-2.5.2/regression/generic/let_shadowing_var.smt2.expected.err000066400000000000000000000000001445011647600256740ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/let_shadowing_var.smt2.expected.out000066400000000000000000000000061445011647600257210ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/generic/lookahead-lra-split.smt2000066400000000000000000000025421445011647600234570ustar00rootroot00000000000000(set-logic QF_LRA) (set-info :source | Clock Synchronization. Bruno Dutertre (bruno@csl.sri.com) |) (set-info :smt-lib-version 2.0) (set-info :category "industrial") (set-info :status unsat) (set-option :split-type lookahead) (set-option :split-num 20) (set-option :split-asap true) (set-option :split-format smt2) (set-option :split-format-length "brief") (set-option :output-dir "splits_here") (set-option :sat_split_test_cube_and_conquer true) (declare-fun x_0 () Real) (declare-fun x_1 () Real) (declare-fun x_2 () Real) (declare-fun x_3 () Real) (declare-fun x_4 () Real) (declare-fun x_5 () Real) (declare-fun x_6 () Real) (declare-fun x_7 () Real) (declare-fun x_8 () Real) (assert (let ((?v_0 (+ x_0 (/ 999 1000))) (?v_1 (+ x_0 (/ 1001 1000))) (?v_2 (not (<= (- 1 1) (+ (+ (+ x_6 x_7) (* (* (+ x_8 x_5) 2) (/ 1 999))) (/ 2335 666)))))) (and (and (and (and (and (and (and (and (and (and (and (and (and (not (<= x_4 0)) (not (<= x_5 0))) (not (<= x_6 0))) (not (< x_7 (+ x_6 (* (* (+ (* (* x_5 1) (/ 1 2)) 1) 1001) (/ 1 999)))))) (< x_8 (- (* (* (- (- x_5 x_7) 1) 999) (/ 1 2)) 1))) (not (< x_8 (* (* (+ (+ (+ x_4 x_6) x_7) (/ 1501 1000)) 1001) (/ 1 999))))) (= x_0 0)) (<= ?v_0 x_1)) (<= x_1 ?v_1)) (<= ?v_0 x_2)) (<= x_2 ?v_1)) (<= ?v_0 x_3)) (<= x_3 ?v_1)) (or (or (or (or (or (or (or (or ?v_2 ?v_2) ?v_2) ?v_2) ?v_2) ?v_2) ?v_2) ?v_2) ?v_2)))) (check-sat) (exit) opensmt-2.5.2/regression/generic/lookahead-lra-split.smt2.expected.err000066400000000000000000000000001445011647600260310ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/lookahead-lra-split.smt2.expected.out000066400000000000000000000000061445011647600260560ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/generic/lookahead-lra-split.smt2.expected.time000066400000000000000000000000351445011647600262070ustar00rootroot00000000000000real 0.01 user 0.01 sys 0.00 opensmt-2.5.2/regression/generic/lookahead-lra-split2.smt2000066400000000000000000000040661445011647600235440ustar00rootroot00000000000000(set-logic QF_LRA) (set-info :source | TLP-GP automated DTP to SMT-LIB encoding for planning by F.Maris and P.Regnier, IRIT - Universite Paul Sabatier, Toulouse |) (set-info :smt-lib-version 2.0) (set-info :category "industrial") (set-info :status unknown) (declare-fun St_spy_variable () Real) (declare-fun t_Init_0 () Real) (declare-fun t_Goal_7 () Real) (declare-fun t_C_N1_3 () Real) (declare-fun t_B_N1_2 () Real) (declare-fun t_A_N1_1 () Real) (declare-fun t_A_N2_4 () Real) (declare-fun t_B_N2_5 () Real) (declare-fun t_C_N2_6 () Real) (assert (let ((?v_2 (- t_Goal_7 t_C_N1_3)) (?v_1 (- t_Goal_7 t_B_N1_2)) (?v_0 (- t_Goal_7 t_A_N1_1)) (?v_3 (- t_Goal_7 t_A_N2_4)) (?v_4 (- t_Goal_7 t_B_N2_5)) (?v_13 (- t_Goal_7 t_C_N2_6)) (?v_8 (- t_B_N1_2 t_A_N1_1))) (let ((?v_7 (< ?v_8 5)) (?v_6 (- t_C_N1_3 t_B_N1_2))) (let ((?v_5 (< ?v_6 4)) (?v_10 (- t_B_N2_5 t_A_N2_4))) (let ((?v_9 (< ?v_10 5)) (?v_12 (- t_C_N2_6 t_B_N2_5))) (let ((?v_11 (< ?v_12 4)) (?v_17 (- t_A_N2_4 t_C_N1_3)) (?v_14 (- t_A_N2_4 t_A_N1_1))) (let ((?v_23 (< ?v_14 5)) (?v_15 (> ?v_8 1))) (let ((?v_22 (or ?v_23 ?v_15)) (?v_16 (< ?v_0 6)) (?v_18 (< (- t_C_N1_3 t_A_N1_1) 4))) (let ((?v_21 (or (< ?v_17 1) ?v_18)) (?v_19 (> ?v_10 1))) (let ((?v_24 (or (< ?v_10 1) ?v_19)) (?v_20 (< ?v_3 6)) (?v_26 (- t_C_N2_6 t_A_N2_4))) (let ((?v_25 (< ?v_26 4))) (and (= St_spy_variable (+ 1 t_Init_0)) (>= t_Goal_7 t_Init_0) (>= (- t_C_N1_3 t_Init_0) 0) (>= ?v_2 1) (>= (- t_B_N1_2 t_Init_0) 0) (>= ?v_1 4) (>= (- t_A_N1_1 t_Init_0) 0) (>= ?v_0 5) (>= (- t_A_N2_4 t_Init_0) 0) (>= ?v_3 5) (>= (- t_B_N2_5 t_Init_0) 0) (>= ?v_4 4) (>= (- t_C_N2_6 t_Init_0) 0) (>= ?v_13 1) ?v_7 (>= ?v_0 6) ?v_5 (>= ?v_1 5) (>= ?v_2 2) ?v_9 (>= ?v_3 6) ?v_11 (>= ?v_4 5) ?v_5 ?v_5 (>= ?v_6 0) (>= ?v_17 1) ?v_7 ?v_7 (>= ?v_8 0) (>= (- t_A_N2_4 t_B_N1_2) 4) (>= ?v_14 5) ?v_9 (>= ?v_10 0) ?v_11 (>= ?v_12 0) (>= ?v_13 2) ?v_22 (or ?v_16 ?v_15) (or ?v_18 (< ?v_2 2)) (or ?v_15 ?v_16) ?v_21 ?v_24 (or ?v_20 ?v_19) (or ?v_25 (< ?v_13 2)) (or ?v_19 ?v_20) (or ?v_15 (< ?v_8 1)) ?v_21 ?v_22 (or ?v_15 ?v_23) ?v_24 (or ?v_25 (> ?v_26 4)))))))))))))) (check-sat) (exit) opensmt-2.5.2/regression/generic/lookahead-lra-split2.smt2.expected.err000066400000000000000000000000001445011647600261130ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/lookahead-lra-split2.smt2.expected.out000066400000000000000000000000041445011647600261360ustar00rootroot00000000000000sat opensmt-2.5.2/regression/generic/lookahead-lra-split2.smt2.expected.time000066400000000000000000000000351445011647600262710ustar00rootroot00000000000000real 0.03 user 0.03 sys 0.00 opensmt-2.5.2/regression/generic/multi_push.smt2000066400000000000000000000001211445011647600220030ustar00rootroot00000000000000(set-logic QF_UF) (declare-fun v19 () Bool) (push 4) (pop 1) (pop 1) (check-sat) opensmt-2.5.2/regression/generic/multi_push.smt2.expected.err000066400000000000000000000000001445011647600243660ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/multi_push.smt2.expected.out000066400000000000000000000000041445011647600244110ustar00rootroot00000000000000sat opensmt-2.5.2/regression/generic/options.smt2000066400000000000000000000002241445011647600213110ustar00rootroot00000000000000(set-option :print-success true) (set-option :foo bar) (get-option :foo) (get-option :print-success) ; should fail (set-option :print-success quux) opensmt-2.5.2/regression/generic/options.smt2.expected.err000066400000000000000000000000001445011647600236700ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/options.smt2.expected.out000066400000000000000000000000751445011647600237230ustar00rootroot00000000000000Syntax error: expecting either 'true' or 'false', got 'quux' opensmt-2.5.2/regression/generic/options.smt2.expected.time000066400000000000000000000000351445011647600240460ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/generic/pop.smt2000066400000000000000000000000101445011647600204050ustar00rootroot00000000000000(pop 1) opensmt-2.5.2/regression/generic/pop.smt2.expected.err000066400000000000000000000000001445011647600227730ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/pop.smt2.expected.out000066400000000000000000000000611445011647600230210ustar00rootroot00000000000000(error "Illegal command before set-logic: pop") opensmt-2.5.2/regression/generic/post-logic.smt2000066400000000000000000000000741445011647600217010ustar00rootroot00000000000000(set-logic AB_CD) (declare-sort U 0) (declare-fun c15 () U) opensmt-2.5.2/regression/generic/post-logic.smt2.expected.err000066400000000000000000000000001445011647600242550ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/post-logic.smt2.expected.out000066400000000000000000000002221445011647600243020ustar00rootroot00000000000000(error "unknown logic AB_CD") (error "illegal command before set-logic: declare-sort") (error "Illegal command before set-logic: declare-fun") opensmt-2.5.2/regression/generic/post-logic.smt2.expected.time000066400000000000000000000000351445011647600244330ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/generic/pre-logic.smt2000066400000000000000000000020501445011647600214760ustar00rootroot00000000000000; set-option test suite (set-option :print-success true) (set-option :my-option quux) (set-option :my-option-2 "Longer story") (set-option :verbosity 3) (set-option :diagnostic-output-channel "/dev/null") (set-option :foo-option) (set-option :bar-option 0) (set-option :pi 3.1415926535879323) (set-option :hex #xdeafbeef) (set-option :bin #b1010101) (set-option :sexprs ( foo "string" #b1010 #xfeb 1.23 2 ( () bar ( :keyword ) ) )) ; get-option test suite (get-option :print-success) (get-option :my-option) (get-option :my-option-2) (get-option :verbosity) (get-option :diagnostic-output-channel) (get-option :foo-option) (get-option :bar-option) (get-option :pi) (get-option :hex) (get-option :bin) (get-option :sexprs) (get-option :non-existing-option) ; set-info test suite (set-info :foo) (set-info :interactive-mode true) (set-info :error-behavior commit-adultery) (set-info :name "OpenSMT") (set-info :authors "Muumi-peikko") ; get-info test suite (get-info :foo) (get-info :error-behavior) (get-info :name) (get-info :authors) (exit) (set-logic foo) opensmt-2.5.2/regression/generic/pre-logic.smt2.expected.err000066400000000000000000000000001445011647600240560ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/pre-logic.smt2.expected.out000066400000000000000000000006731445011647600241150ustar00rootroot00000000000000success success success success success success success success success success success true quux Longer story 3 /dev/null (error "No value for attr :foo-option") 0 3.14159 3736059631 85 ( foo string 10 4075 1.23 2 ( ( ) bar ( :keyword ) ) ) (error "No value for attr :non-existing-option") success success success success success (error "no value for info :foo") :error-behavior commit-adultery :name OpenSMT :authors Muumi-peikko success opensmt-2.5.2/regression/generic/pre-logic.smt2.expected.time000066400000000000000000000000351445011647600242340ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/generic/push.smt2000066400000000000000000000000111445011647600205670ustar00rootroot00000000000000(push 1) opensmt-2.5.2/regression/generic/push.smt2.expected.err000066400000000000000000000000001445011647600231540ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/push.smt2.expected.out000066400000000000000000000000621445011647600232030ustar00rootroot00000000000000(error "Illegal command before set-logic: push") opensmt-2.5.2/regression/generic/push_negative_value.smt2000066400000000000000000000001021445011647600236460ustar00rootroot00000000000000(set-logic QF_UF) (declare-fun v19 () Bool) (push -1) (check-sat) opensmt-2.5.2/regression/generic/push_negative_value.smt2.expected.err000066400000000000000000000000001445011647600262320ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/push_negative_value.smt2.expected.out000066400000000000000000000000721445011647600262620ustar00rootroot00000000000000(error "Incorrect push command, value is negative.") sat opensmt-2.5.2/regression/generic/random-seed.smt2000077500000000000000000000000361445011647600220200ustar00rootroot00000000000000(set-option :random-seed 202) opensmt-2.5.2/regression/generic/random-seed.smt2.expected.err000066400000000000000000000000001445011647600243730ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/random-seed.smt2.expected.out000066400000000000000000000000001445011647600244120ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/random-seed.smt2.expected.time000066400000000000000000000000351445011647600245510ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/generic/sep7.smt2000066400000000000000000000100221445011647600204710ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort U 0) (declare-fun e () U) (declare-fun f () U) (declare-fun d () U) (declare-fun d_p () U) (declare-fun g_ex_1 (U) Bool) (declare-fun g_ex_2 (U) Bool) (declare-fun g_ex_3 (U) Bool) (declare-fun g_ex_4 (U) Bool) (declare-fun g_ex_5 (U) Bool) (declare-fun g_ex_6 (U) Bool) (declare-fun g_ex_7 (U) Bool) (declare-fun g_ex_8 (U) Bool) (declare-fun g_ex_9 (U) Bool) (declare-fun g_ex_10 (U) Bool) (declare-fun g_ex_11 (U) Bool) (declare-fun g_ex_12 (U) Bool) (declare-fun g_ex_13 (U) Bool) (declare-fun g_ex_14 (U) Bool) (declare-fun g_ex_15 (U) Bool) (declare-fun g_ex_16 (U) Bool) (declare-fun g_ex_17 (U) Bool) (declare-fun g_ex_18 (U) Bool) (declare-fun g_ex_19 (U) Bool) (declare-fun g_ex_20 (U) Bool) (declare-fun g_ex_21 (U) Bool) (declare-fun g_ex_22 (U) Bool) (declare-fun g_ex_23 (U) Bool) (declare-fun g_ex_24 (U) Bool) (declare-fun g_ex_25 (U) Bool) (declare-fun g_ex_26 (U) Bool) (declare-fun g_ex_27 (U) Bool) (declare-fun g_ex_28 (U) Bool) (declare-fun g_ex_29 (U) Bool) (declare-fun g_ex_30 (U) Bool) (declare-fun g_ex_31 (U) Bool) (declare-fun g_ex_32 (U) Bool) (declare-fun mul (U U) U) (declare-fun gi (Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool ) U) (declare-fun o1 () Bool) (declare-fun o2 () Bool) (declare-fun o3 () Bool) (declare-fun o4 () Bool) (declare-fun o5 () Bool) (declare-fun o6 () Bool) (declare-fun o7 () Bool) (declare-fun o8 () Bool) (declare-fun o9 () Bool) (declare-fun o10 () Bool) (declare-fun o11 () Bool) (declare-fun o12 () Bool) (declare-fun o13 () Bool) (declare-fun o14 () Bool) (declare-fun o15 () Bool) (declare-fun o16 () Bool) (declare-fun o17 () Bool) (declare-fun o18 () Bool) (declare-fun o19 () Bool) (declare-fun o20 () Bool) (declare-fun o21 () Bool) (declare-fun o22 () Bool) (declare-fun o23 () Bool) (declare-fun o24 () Bool) (declare-fun o25 () Bool) (declare-fun o26 () Bool) (declare-fun o27 () Bool) (declare-fun o28 () Bool) (declare-fun o29 () Bool) (declare-fun o30 () Bool) (declare-fun o31 () Bool) (declare-fun o32 () Bool) (define-fun mod2 ((i1 Bool) (i2 Bool) (i3 Bool) (i4 Bool) (i5 Bool) (i6 Bool) (i7 Bool) (i8 Bool) (i9 Bool) (i10 Bool) (i11 Bool) (i12 Bool) (i13 Bool) (i14 Bool) (i15 Bool) (i16 Bool) (i17 Bool) (i18 Bool) (i19 Bool) (i20 Bool) (i21 Bool) (i22 Bool) (i23 Bool) (i24 Bool) (i25 Bool) (i26 Bool) (i27 Bool) (i28 Bool) (i29 Bool) (i30 Bool) (i31 Bool) (i32 Bool) (o1 Bool) (o2 Bool) (o3 Bool) (o4 Bool) (o5 Bool) (o6 Bool) (o7 Bool) (o8 Bool) (o9 Bool) (o10 Bool) (o11 Bool) (o12 Bool) (o13 Bool) (o14 Bool) (o15 Bool) (o16 Bool) (o17 Bool) (o18 Bool) (o19 Bool) (o20 Bool) (o21 Bool) (o22 Bool) (o23 Bool) (o24 Bool) (o25 Bool) (o26 Bool) (o27 Bool) (o28 Bool) (o29 Bool) (o30 Bool) (o31 Bool) (o32 Bool)) Bool (and (= i1 o1) (= o2 false) (= o3 false) (= o4 false) (= o5 false) (= o6 false) (= o7 false) (= o8 false) (= o9 false) (= o10 false) (= o11 false) (= o12 false) (= o13 false) (= o14 false) (= o15 false) (= o16 false) (= o17 false) (= o18 false) (= o19 false) (= o20 false) (= o21 false) (= o22 false) (= o23 false) (= o24 false) (= o25 false) (= o26 false) (= o27 false) (= o28 false) (= o29 false) (= o30 false) (= o31 false) (= o32 false))) (assert (and (= (mul e (gi o1 o2 o3 o4 o5 o6 o7 o8 o9 o10 o11 o12 o13 o14 o15 o16 o17 o18 o19 o20 o21 o22 o23 o24 o25 o26 o27 o28 o29 o30 o31 o32 )) d) (mod2 (g_ex_1 f)(g_ex_2 f)(g_ex_3 f)(g_ex_4 f)(g_ex_5 f)(g_ex_6 f)(g_ex_7 f)(g_ex_8 f)(g_ex_9 f)(g_ex_10 f)(g_ex_11 f)(g_ex_12 f)(g_ex_13 f)(g_ex_14 f)(g_ex_15 f)(g_ex_16 f)(g_ex_17 f)(g_ex_18 f)(g_ex_19 f)(g_ex_20 f)(g_ex_21 f)(g_ex_22 f)(g_ex_23 f)(g_ex_24 f)(g_ex_25 f)(g_ex_26 f)(g_ex_27 f)(g_ex_28 f)(g_ex_29 f)(g_ex_30 f)(g_ex_31 f)(g_ex_32 f) o1 o2 o3 o4 o5 o6 o7 o8 o9 o10 o11 o12 o13 o14 o15 o16 o17 o18 o19 o20 o21 o22 o23 o24 o25 o26 o27 o28 o29 o30 o31 o32 ) (= (mul e (gi o1 o2 o3 o4 o5 o6 o7 o8 o9 o10 o11 o12 o13 o14 o15 o16 o17 o18 o19 o20 o21 o22 o23 o24 o25 o26 o27 o28 o29 o30 o31 o32 )) d_p) )) (assert (not(= d d_p) )) (check-sat)opensmt-2.5.2/regression/generic/sep7.smt2.expected.err000066400000000000000000000000001445011647600230530ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/sep7.smt2.expected.out000066400000000000000000000000061445011647600231000ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/generic/sep7.smt2.expected.time000066400000000000000000000000351445011647600232310ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/generic/simple.smt2000066400000000000000000000006571445011647600211210ustar00rootroot00000000000000; This is an example (set-info :bar "foo \"bar quux") (set-info :quux "bar quux frobboz") (set-info :frobboz (foo :bar (quux bar))) (set-logic AB_CD) (declare-fun f () a) (set-info :quux "bar quux frob\\boz\"") (declare-fun _foo () b) (declare-fun - () ..foo) (declare-fun |bar "this is internal" quux| () ||) (declare-fun q () (_ foo 1 2 3 4)) (declare-fun q1 () ((_ foo 1 2 3 4) (_ bar 4 3 2 1) (_ quux 1 2 3 4))) opensmt-2.5.2/regression/generic/simple.smt2.expected.err000066400000000000000000000000001445011647600234660ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/simple.smt2.expected.out000066400000000000000000000005651445011647600235250ustar00rootroot00000000000000(error "unknown logic AB_CD") (error "Illegal command before set-logic: declare-fun") (error "Illegal command before set-logic: declare-fun") (error "Illegal command before set-logic: declare-fun") (error "Illegal command before set-logic: declare-fun") (error "Illegal command before set-logic: declare-fun") (error "Illegal command before set-logic: declare-fun") opensmt-2.5.2/regression/generic/simple.smt2.expected.time000066400000000000000000000000351445011647600236440ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/generic/simple2.smt2000066400000000000000000000000731445011647600211730ustar00rootroot00000000000000(set-info :bar "foo" ) (set-info :quux "bar quux frobbo") opensmt-2.5.2/regression/generic/simple2.smt2.expected.err000066400000000000000000000000001445011647600235500ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/simple2.smt2.expected.out000066400000000000000000000000001445011647600235670ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/simple2.smt2.expected.time000066400000000000000000000000351445011647600237260ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/generic/sort_same_name_different_arity.smt2000066400000000000000000000000701445011647600260470ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort U 0) (declare-sort U 1) opensmt-2.5.2/regression/generic/sort_same_name_different_arity.smt2.expected.err000066400000000000000000000000001445011647600304270ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/sort_same_name_different_arity.smt2.expected.out000066400000000000000000000000431445011647600304550ustar00rootroot00000000000000(error "sort U already declared") opensmt-2.5.2/regression/generic/sort_with_arguments.smt2000066400000000000000000000002321445011647600237240ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort U 1) (declare-sort V 0) (declare-sort W 0) (declare-fun a () (U V)) (declare-fun b () (U W)) (assert (= a b)) (check-sat) opensmt-2.5.2/regression/generic/sort_with_arguments.smt2.expected.err000066400000000000000000000000001445011647600263040ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/sort_with_arguments.smt2.expected.out000066400000000000000000000001331445011647600263320ustar00rootroot00000000000000(error "Unknown symbol `= (U V) (U W)'") (error "assertion returns an unknown sort") sat opensmt-2.5.2/regression/generic/test-dump-query.smt2000066400000000000000000000003531445011647600227060ustar00rootroot00000000000000(set-option :dump-query true) (set-option :dump-query-name "dump") (set-option :output-dir "/tmp/") (set-option :time-queries true) (set-logic QF_LRA) (declare-fun x () Real) (declare-fun y () Real) (assert (> x y)) (check-sat) (exit) opensmt-2.5.2/regression/generic/test-dump-query.smt2.expected.err000066400000000000000000000000001445011647600252620ustar00rootroot00000000000000opensmt-2.5.2/regression/generic/test-dump-query.smt2.expected.out000066400000000000000000000000601445011647600253070ustar00rootroot00000000000000; QF_LRA solver query time so far: 0.000000 sat opensmt-2.5.2/regression/generic/test-dump-query.smt2.expected.time000066400000000000000000000000351445011647600254400ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/incremental/000077500000000000000000000000001445011647600176765ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/QF_UF_brp2.3.prop2_ab_min_max.smt2000066400000000000000000010276311445011647600257200ustar00rootroot00000000000000(set-info :smt-lib-version 2.6) (set-logic QF_UF) (set-info :source | Generated by: Aman Goel (amangoel@umich.edu), Karem A. Sakallah (karem@umich.edu) Generated on: 2018-04-06 Generated by the tool Averroes 2 (successor of [1]) which implements safety property verification on hardware systems. This SMT problem belongs to a set of SMT problems generated by applying Averroes 2 to benchmarks derived from [2-5]. A total of 412 systems (345 from [2], 19 from [3], 26 from [4], 22 from [5]) were syntactically converted from their original formats (using [6, 7]), and given to Averroes 2 to perform property checking with abstraction (wide bit-vectors -> terms, wide operators -> UF) using SMT solvers [8, 9]. [1] Lee S., Sakallah K.A. (2014) Unbounded Scalable Verification Based on Approximate Property-Directed Reachability and Datapath Abstraction. In: Biere A., Bloem R. (eds) Computer Aided Verification. CAV 2014. Lecture Notes in Computer Science, vol 8559. Springer, Cham [2] http://fmv.jku.at/aiger/index.html#beem [3] http://www.cs.cmu.edu/~modelcheck/vcegar [4] http://www.cprover.org/hardware/v2c [5] http://github.com/aman-goel/verilogbench [6] http://www.clifford.at/yosys [7] http://github.com/chengyinwu/V3 [8] http://github.com/Z3Prover/z3 [9] http://github.com/SRI-CSL/yices2 id: brp2.3.prop2 query-maker: "Z3" query-time: 5.949000 ms query-class: abstract query-category: assume query-type: mus_min status: sat |) (set-info :license "https://creativecommons.org/licenses/by/4.0/") (set-info :category "industrial") ; (set-info :status sat) (declare-sort utt8 0) (declare-sort utt16 0) (declare-sort utt32 0) (declare-sort utt24 0) (declare-fun z$n3s8 () utt8) (declare-fun z$n1s8 () utt8) (declare-fun z$n0s8 () utt8) (declare-fun z$n28s16 () utt16) (declare-fun z$n2s16 () utt16) (declare-fun z$n63s16 () utt16) (declare-fun z$n32s16 () utt16) (declare-fun z$n29s16 () utt16) (declare-fun z$n1s16 () utt16) (declare-fun z$n5s16 () utt16) (declare-fun z$n31s16 () utt16) (declare-fun z$n30s16 () utt16) (declare-fun z$n3s16 () utt16) (declare-fun z$n0s16 () utt16) (declare-fun z$n1835008s32 () utt32) (declare-fun z$n4293132287s32 () utt32) (declare-fun z$n4294901788s32 () utt32) (declare-fun z$n65533s32 () utt32) (declare-fun z$n4294836223s32 () utt32) (declare-fun z$n4294901762s32 () utt32) (declare-fun z$n2097152s32 () utt32) (declare-fun z$n32s32 () utt32) (declare-fun z$n28s32 () utt32) (declare-fun z$n65503s32 () utt32) (declare-fun z$n65507s32 () utt32) (declare-fun z$n1900544s32 () utt32) (declare-fun z$n4294901792s32 () utt32) (declare-fun z$n131072s32 () utt32) (declare-fun z$n65534s32 () utt32) (declare-fun z$n29s32 () utt32) (declare-fun z$n65536s32 () utt32) (declare-fun z$n65506s32 () utt32) (declare-fun z$n4294901759s32 () utt32) (declare-fun z$n4293001215s32 () utt32) (declare-fun z$n4294901761s32 () utt32) (declare-fun z$n4294901789s32 () utt32) (declare-fun z$n4292935679s32 () utt32) (declare-fun z$n2031616s32 () utt32) (declare-fun z$n4294901790s32 () utt32) (declare-fun z$n65504s32 () utt32) (declare-fun z$n65505s32 () utt32) (declare-fun z$n4294901791s32 () utt32) (declare-fun z$n4292870143s32 () utt32) (declare-fun z$n4294770687s32 () utt32) (declare-fun z$n65530s32 () utt32) (declare-fun z$n1966080s32 () utt32) (declare-fun z$n4294901765s32 () utt32) (declare-fun z$n4294967295s32 () utt32) (declare-fun z$n4293066751s32 () utt32) (declare-fun z$n31s32 () utt32) (declare-fun z$n196608s32 () utt32) (declare-fun z$n65532s32 () utt32) (declare-fun z$n4294901763s32 () utt32) (declare-fun z$n4294901760s32 () utt32) (declare-fun z$n65535s32 () utt32) (declare-fun z$n327680s32 () utt32) (declare-fun z$n4294639615s32 () utt32) (declare-fun z$n6s32 () utt32) (declare-fun z$n3s32 () utt32) (declare-fun z$n5s32 () utt32) (declare-fun z$n30s32 () utt32) (declare-fun z$n2s32 () utt32) (declare-fun z$n4s32 () utt32) (declare-fun z$n0s32 () utt32) (declare-fun z$n1s32 () utt32) (declare-fun z$n16s32 () utt32) (declare-fun v_rc () utt8) (declare-fun v_X () utt16) (declare-fun v_n () utt16) (declare-fun v_i () utt8) (declare-fun BitWiseXor_16_16_16 (utt16 utt16) utt16) (declare-fun v_SYNC () utt16) (declare-fun z$94 () utt16) (declare-fun z$96 () utt16) (declare-fun v_V () utt16) (declare-fun v_Z () utt16) (declare-fun v_W () utt16) (declare-fun Concat_32_16_16 (utt16 utt16) utt32) (declare-fun z$116 () utt32) (declare-fun ShiftR_32_32_32 (utt32 utt32) utt32) (declare-fun z$2243 () utt32) (declare-fun BitWiseNot_32_32 (utt32) utt32) (declare-fun z$118 () utt32) (declare-fun z$121 () utt32) (declare-fun z$123 () utt32) (declare-fun z$125 () utt32) (declare-fun z$127 () utt32) (declare-fun Add_32_32_32 (utt32 utt32) utt32) (declare-fun z$855 () utt32) (declare-fun v_U () utt16) (declare-fun z$881 () utt32) (declare-fun z$239 () utt32) (declare-fun z$173 () utt32) (declare-fun z$181 () utt32) (declare-fun z$175 () utt32) (declare-fun z$177 () utt32) (declare-fun z$179 () utt32) (declare-fun z$183 () utt32) (declare-fun z$271 () utt32) (declare-fun z$279 () utt32) (declare-fun z$273 () utt32) (declare-fun z$275 () utt32) (declare-fun z$277 () utt32) (declare-fun z$281 () utt32) (declare-fun z$845 () utt32) (declare-fun v_maxtime () utt16) (declare-fun z$101 () utt16) (declare-fun z$131 () utt32) (declare-fun z$133 () utt32) (declare-fun z$135 () utt32) (declare-fun z$137 () utt32) (declare-fun z$139 () utt32) (declare-fun z$141 () utt32) (declare-fun z$188 () utt32) (declare-fun z$190 () utt32) (declare-fun z$148 () utt32) (declare-fun z$150 () utt32) (declare-fun z$206 () utt32) (declare-fun z$214 () utt32) (declare-fun z$208 () utt32) (declare-fun z$210 () utt32) (declare-fun z$212 () utt32) (declare-fun z$901 () utt32) (declare-fun z$889 () utt32) (declare-fun z$241 () utt32) (declare-fun z$243 () utt32) (declare-fun z$245 () utt32) (declare-fun z$247 () utt32) (declare-fun z$249 () utt32) (declare-fun z$826 () utt32) (declare-fun z$286 () utt32) (declare-fun z$288 () utt32) (declare-fun z$216 () utt32) (declare-fun z$883 () utt32) (declare-fun z$885 () utt32) (declare-fun z$887 () utt32) (declare-fun z$891 () utt32) (declare-fun z$87 () utt16) (declare-fun z$89 () utt16) (declare-fun v_n$next () utt16) (declare-fun v_SYNC$next () utt16) (declare-fun z$103 () utt16) (declare-fun v_maxtime$next () utt16) (declare-fun Extract_16_15_0_32 (utt32) utt16) (declare-fun z$152 () utt16) (declare-fun z$154 () utt16) (declare-fun z$156 () utt16) (declare-fun z$158 () utt16) (declare-fun z$160 () utt16) (declare-fun z$162 () utt16) (declare-fun z$164 () utt16) (declare-fun z$166 () utt16) (declare-fun v_X$next () utt16) (declare-fun z$192 () utt16) (declare-fun z$194 () utt16) (declare-fun z$196 () utt16) (declare-fun z$198 () utt16) (declare-fun v_U$next () utt16) (declare-fun z$221 () utt32) (declare-fun z$223 () utt32) (declare-fun z$225 () utt16) (declare-fun z$227 () utt16) (declare-fun z$229 () utt16) (declare-fun z$231 () utt16) (declare-fun v_V$next () utt16) (declare-fun z$254 () utt32) (declare-fun z$256 () utt32) (declare-fun z$258 () utt16) (declare-fun z$260 () utt16) (declare-fun z$262 () utt16) (declare-fun z$264 () utt16) (declare-fun v_W$next () utt16) (declare-fun z$290 () utt16) (declare-fun z$292 () utt16) (declare-fun z$294 () utt16) (declare-fun z$296 () utt16) (declare-fun z$298 () utt16) (declare-fun v_Z$next () utt16) (declare-fun Concat_32_8_24 (utt8 utt24) utt32) (declare-fun z$n0s24 () utt24) (declare-fun z$348 () utt32) (declare-fun z$350 () utt32) (declare-fun Extract_8_7_0_32 (utt32) utt8) (declare-fun z$352 () utt8) (declare-fun z$354 () utt8) (declare-fun z$356 () utt8) (declare-fun v_i$next () utt8) (declare-fun z$360 () utt32) (declare-fun z$362 () utt32) (declare-fun z$364 () utt8) (declare-fun z$367 () utt8) (declare-fun z$369 () utt8) (declare-fun z$371 () utt8) (declare-fun z$373 () utt8) (declare-fun v_rc$next () utt8) (declare-fun z$911 () utt32) (declare-fun v_triple_Receiver () utt8) (declare-fun z$310 () utt32) (declare-fun BitWiseAnd_32_32_32 (utt32 utt32) utt32) (declare-fun z$950 () utt32) (declare-fun z$386 () utt32) (declare-fun z$388 () utt32) (declare-fun z$390 () utt32) (declare-fun z$392 () utt32) (declare-fun z$394 () utt32) (declare-fun z$396 () utt32) (declare-fun Extract_24_31_8_32 (utt32) utt24) (declare-fun z$399 () utt24) (declare-fun z$400 () utt24) (declare-fun z$401 () utt24) (declare-fun z$398 () utt24) (declare-fun z$405 () utt8) (declare-fun z$406 () utt8) (declare-fun z$407 () utt8) (declare-fun z$404 () utt8) (declare-fun z$312 () utt32) (declare-fun z$1147 () utt24) (declare-fun z$314 () utt8) (declare-fun v_exp_ab () utt8) (declare-fun z$1236 () utt32) (declare-fun z$2118 () utt32) (declare-fun z$2120 () utt32) (declare-fun z$2122 () utt32) (declare-fun z$2124 () utt32) (declare-fun z$2126 () utt32) (declare-fun z$2128 () utt32) (declare-fun z$2130 () utt16) (declare-fun z$2134 () utt32) (declare-fun z$2136 () utt32) (declare-fun z$2138 () utt32) (declare-fun z$2140 () utt32) (declare-fun z$2142 () utt32) (declare-fun z$2144 () utt32) (declare-fun z$2531 () utt16) (declare-fun z$2565 () utt16) (declare-fun z$2546 () utt32) (declare-fun z$2548 () utt32) (declare-fun z$2550 () utt32) (declare-fun z$2552 () utt32) (declare-fun z$2554 () utt32) (declare-fun z$2556 () utt32) (declare-fun z$7867 () utt8) (declare-fun z$7868 () utt8) (declare-fun z$7869 () utt8) (declare-fun z$7866 () utt8) (declare-fun z$2595 () utt32) (declare-fun z$6852 () utt32) (declare-fun z$6864 () utt32) (declare-fun z$2421 () utt16) (declare-fun z$3325 () utt16) (declare-fun z$3329 () utt32) (declare-fun z$3331 () utt32) (declare-fun z$3333 () utt32) (declare-fun z$3335 () utt32) (declare-fun z$3337 () utt32) (declare-fun z$3339 () utt32) (declare-fun z$3344 () utt32) (declare-fun z$3346 () utt32) (declare-fun z$3307 () utt32) (declare-fun z$2768 () utt32) (declare-fun z$2775 () utt32) (declare-fun z$2777 () utt32) (declare-fun z$2779 () utt32) (declare-fun z$2781 () utt32) (declare-fun z$2783 () utt32) (declare-fun z$6858 () utt32) (declare-fun z$6860 () utt32) (declare-fun z$6862 () utt32) (declare-fun z$6866 () utt32) (declare-fun z$6868 () utt32) (declare-fun z$5663 () utt32) (declare-fun z$5665 () utt32) (declare-fun z$3491 () utt32) (declare-fun z$5445 () utt32) (declare-fun z$5459 () utt32) (declare-fun z$3591 () utt16) (declare-fun z$2250 () utt32) (declare-fun z$2275 () utt32) (declare-fun z$2245 () utt32) (declare-fun z$2246 () utt32) (declare-fun z$2689 () utt32) (declare-fun z$2696 () utt32) (declare-fun z$2698 () utt32) (declare-fun z$2700 () utt32) (declare-fun z$2702 () utt32) (declare-fun z$2704 () utt32) (declare-fun z$5830 () utt32) (declare-fun a_dk () Bool) (declare-fun z$5 () Bool) (declare-fun a_file_req () Bool) (declare-fun z$9 () Bool) (declare-fun a_idle_Sender () Bool) (declare-fun z$19 () Bool) (declare-fun a_nok_SClient () Bool) (declare-fun z$35 () Bool) (declare-fun a_send_req () Bool) (declare-fun z$41 () Bool) (declare-fun a_error () Bool) (declare-fun z$2648 () Bool) (declare-fun z$2649 () Bool) (declare-fun a_next_frame () Bool) (declare-fun z$31 () Bool) (declare-fun a_success () Bool) (declare-fun z$47 () Bool) (declare-fun a_wait_ack () Bool) (declare-fun z$51 () Bool) (declare-fun dve_invalid () Bool) (declare-fun z$53 () Bool) (declare-fun a_init_state () Bool) (declare-fun z$3007 () Bool) (declare-fun z$3008 () Bool) (declare-fun a_new_file () Bool) (declare-fun z$2996 () Bool) (declare-fun z$2997 () Bool) (declare-fun a_BAD_K () Bool) (declare-fun z$1 () Bool) (declare-fun z$3446 () Bool) (declare-fun z$3447 () Bool) (declare-fun a_start_L () Bool) (declare-fun z$45 () Bool) (declare-fun z$1055 () Bool) (declare-fun z$2363 () Bool) (declare-fun a_in_transit_K () Bool) (declare-fun a_idle_Receiver () Bool) (declare-fun z$7057 () Bool) (declare-fun z$7058 () Bool) (declare-fun z$77 () Bool) (declare-fun z$7877 () Bool) (declare-fun z$7946 () Bool) (declare-fun z$7947 () Bool) (declare-fun a_first_safe_frame () Bool) (declare-fun z$8027 () Bool) (declare-fun z$8028 () Bool) (declare-fun a_start_K () Bool) (declare-fun z$43 () Bool) (declare-fun z$8469 () Bool) (declare-fun z$8470 () Bool) (declare-fun z$2373 () Bool) (declare-fun z$2369 () Bool) (declare-fun z$2371 () Bool) (declare-fun z$9006 () Bool) (declare-fun z$9007 () Bool) (declare-fun z$3774 () Bool) (declare-fun z$3775 () Bool) (declare-fun z$3783 () Bool) (declare-fun z$3784 () Bool) (declare-fun a_BAD_L () Bool) (declare-fun z$9487 () Bool) (declare-fun z$9488 () Bool) (declare-fun z$11 () Bool) (declare-fun a_frame_received () Bool) (declare-fun z$13 () Bool) (declare-fun a_frame_reported () Bool) (declare-fun z$15 () Bool) (declare-fun z$2659 () Bool) (declare-fun z$7446 () Bool) (declare-fun z$9654 () Bool) (declare-fun z$9655 () Bool) (declare-fun z$9920 () Bool) (declare-fun z$9921 () Bool) (declare-fun z$5352 () Bool) (declare-fun z$7249 () Bool) (declare-fun z$9055 () Bool) (declare-fun z$10160 () Bool) (declare-fun z$10161 () Bool) (declare-fun z$17 () Bool) (declare-fun z$2465 () Bool) (declare-fun z$10171 () Bool) (declare-fun z$10172 () Bool) (declare-fun Extract_1_15_15_16 (utt16) Bool) (declare-fun z$114 () Bool) (declare-fun GrEq_1_32_32 (utt32 utt32) Bool) (declare-fun z$857 () Bool) (declare-fun z$859 () Bool) (declare-fun z$2160 () Bool) (declare-fun z$7112 () Bool) (declare-fun z$10295 () Bool) (declare-fun z$10296 () Bool) (declare-fun z$6792 () Bool) (declare-fun z$10499 () Bool) (declare-fun z$10500 () Bool) (declare-fun z$21 () Bool) (declare-fun z$2501 () Bool) (declare-fun z$10638 () Bool) (declare-fun z$10639 () Bool) (declare-fun z$237 () Bool) (declare-fun z$2167 () Bool) (declare-fun z$10646 () Bool) (declare-fun z$10647 () Bool) (declare-fun z$10846 () Bool) (declare-fun z$10847 () Bool) (declare-fun z$5307 () Bool) (declare-fun z$5308 () Bool) (declare-fun z$10873 () Bool) (declare-fun z$10874 () Bool) (declare-fun z$2745 () Bool) (declare-fun z$10902 () Bool) (declare-fun z$10903 () Bool) (declare-fun z$56 () Bool) (declare-fun z$8873 () Bool) (declare-fun z$11707 () Bool) (declare-fun z$11708 () Bool) (declare-fun z$11085 () Bool) (declare-fun z$11719 () Bool) (declare-fun z$11720 () Bool) (declare-fun z$11730 () Bool) (declare-fun z$11731 () Bool) (declare-fun z$11763 () Bool) (declare-fun z$11764 () Bool) (declare-fun z$62 () Bool) (declare-fun z$6802 () Bool) (declare-fun z$11774 () Bool) (declare-fun z$11775 () Bool) (declare-fun z$2670 () Bool) (declare-fun z$8811 () Bool) (declare-fun z$11786 () Bool) (declare-fun z$11787 () Bool) (declare-fun z$10193 () Bool) (declare-fun z$11809 () Bool) (declare-fun z$11810 () Bool) (declare-fun z$11838 () Bool) (declare-fun z$11839 () Bool) (declare-fun z$171 () Bool) (declare-fun z$2165 () Bool) (declare-fun z$5770 () Bool) (declare-fun z$7424 () Bool) (declare-fun z$11846 () Bool) (declare-fun z$11847 () Bool) (declare-fun z$11859 () Bool) (declare-fun z$11860 () Bool) (declare-fun z$11865 () Bool) (declare-fun z$11875 () Bool) (declare-fun z$11876 () Bool) (declare-fun z$11891 () Bool) (declare-fun z$11892 () Bool) (declare-fun z$11899 () Bool) (declare-fun z$11900 () Bool) (declare-fun z$11973 () Bool) (declare-fun z$11974 () Bool) (declare-fun z$11981 () Bool) (declare-fun z$11982 () Bool) (declare-fun z$12343 () Bool) (declare-fun z$12344 () Bool) (declare-fun z$10445 () Bool) (declare-fun z$12351 () Bool) (declare-fun z$12352 () Bool) (declare-fun z$12363 () Bool) (declare-fun z$12364 () Bool) (declare-fun z$2746 () Bool) (declare-fun z$12377 () Bool) (declare-fun z$12378 () Bool) (declare-fun z$9036 () Bool) (declare-fun z$9037 () Bool) (declare-fun z$6976 () Bool) (declare-fun z$6977 () Bool) (declare-fun z$12430 () Bool) (declare-fun z$12431 () Bool) (declare-fun z$988 () Bool) (declare-fun z$990 () Bool) (declare-fun z$2760 () Bool) (declare-fun z$13626 () Bool) (declare-fun z$13627 () Bool) (declare-fun z$66 () Bool) (declare-fun z$5421 () Bool) (declare-fun z$13639 () Bool) (declare-fun z$13640 () Bool) (declare-fun z$269 () Bool) (declare-fun z$5399 () Bool) (declare-fun z$13653 () Bool) (declare-fun z$13654 () Bool) (declare-fun z$866 () Bool) (declare-fun z$868 () Bool) (declare-fun z$11259 () Bool) (declare-fun z$13676 () Bool) (declare-fun z$13677 () Bool) (declare-fun z$4289 () Bool) (declare-fun z$129 () Bool) (declare-fun z$185 () Bool) (declare-fun z$187 () Bool) (declare-fun z$11347 () Bool) (declare-fun z$13745 () Bool) (declare-fun z$13746 () Bool) (declare-fun z$3216 () Bool) (declare-fun z$13784 () Bool) (declare-fun z$13785 () Bool) (declare-fun z$13793 () Bool) (declare-fun z$13794 () Bool) (declare-fun z$13833 () Bool) (declare-fun z$13834 () Bool) (declare-fun z$13841 () Bool) (declare-fun z$13842 () Bool) (declare-fun z$13865 () Bool) (declare-fun z$13866 () Bool) (declare-fun z$13873 () Bool) (declare-fun z$13874 () Bool) (declare-fun z$13881 () Bool) (declare-fun z$13882 () Bool) (declare-fun z$13895 () Bool) (declare-fun z$13896 () Bool) (declare-fun z$2911 () Bool) (declare-fun z$13999 () Bool) (declare-fun z$14000 () Bool) (declare-fun z$14032 () Bool) (declare-fun z$14033 () Bool) (declare-fun z$10905 () Bool) (declare-fun z$14040 () Bool) (declare-fun z$14041 () Bool) (declare-fun z$14051 () Bool) (declare-fun z$14052 () Bool) (declare-fun z$14100 () Bool) (declare-fun z$14101 () Bool) (declare-fun z$14111 () Bool) (declare-fun z$14112 () Bool) (declare-fun z$4649 () Bool) (declare-fun z$14122 () Bool) (declare-fun z$14123 () Bool) (declare-fun z$14130 () Bool) (declare-fun z$14131 () Bool) (declare-fun z$9345 () Bool) (declare-fun z$14155 () Bool) (declare-fun z$14156 () Bool) (declare-fun z$143 () Bool) (declare-fun z$145 () Bool) (declare-fun z$11346 () Bool) (declare-fun z$14163 () Bool) (declare-fun z$14164 () Bool) (declare-fun z$14174 () Bool) (declare-fun z$14175 () Bool) (declare-fun z$14185 () Bool) (declare-fun z$14186 () Bool) (declare-fun z$204 () Bool) (declare-fun z$2166 () Bool) (declare-fun z$5786 () Bool) (declare-fun z$14222 () Bool) (declare-fun z$14223 () Bool) (declare-fun z$9675 () Bool) (declare-fun z$14233 () Bool) (declare-fun z$14234 () Bool) (declare-fun z$6049 () Bool) (declare-fun z$14245 () Bool) (declare-fun z$14246 () Bool) (declare-fun z$903 () Bool) (declare-fun z$905 () Bool) (declare-fun z$14254 () Bool) (declare-fun z$14255 () Bool) (declare-fun z$14262 () Bool) (declare-fun z$14263 () Bool) (declare-fun z$58 () Bool) (declare-fun z$14320 () Bool) (declare-fun z$14321 () Bool) (declare-fun z$14328 () Bool) (declare-fun z$14329 () Bool) (declare-fun z$14336 () Bool) (declare-fun z$14337 () Bool) (declare-fun z$14375 () Bool) (declare-fun z$14376 () Bool) (declare-fun z$14408 () Bool) (declare-fun z$14409 () Bool) (declare-fun z$14416 () Bool) (declare-fun z$14417 () Bool) (declare-fun z$14443 () Bool) (declare-fun z$14444 () Bool) (declare-fun z$14459 () Bool) (declare-fun z$14460 () Bool) (declare-fun z$14496 () Bool) (declare-fun z$14497 () Bool) (declare-fun z$14504 () Bool) (declare-fun z$14505 () Bool) (declare-fun z$14512 () Bool) (declare-fun z$14513 () Bool) (declare-fun z$14520 () Bool) (declare-fun z$14521 () Bool) (declare-fun z$12194 () Bool) (declare-fun z$14768 () Bool) (declare-fun z$14769 () Bool) (declare-fun z$5341 () Bool) (declare-fun z$5342 () Bool) (declare-fun z$7285 () Bool) (declare-fun z$7286 () Bool) (declare-fun z$11269 () Bool) (declare-fun z$12471 () Bool) (declare-fun z$12472 () Bool) (declare-fun z$13031 () Bool) (declare-fun z$14965 () Bool) (declare-fun z$14975 () Bool) (declare-fun z$14976 () Bool) (declare-fun z$13629 () Bool) (declare-fun z$14994 () Bool) (declare-fun z$14995 () Bool) (declare-fun z$15118 () Bool) (declare-fun z$15119 () Bool) (declare-fun z$15129 () Bool) (declare-fun z$15130 () Bool) (declare-fun z$15245 () Bool) (declare-fun z$15246 () Bool) (declare-fun z$12438 () Bool) (declare-fun z$12439 () Bool) (declare-fun z$15461 () Bool) (declare-fun z$15462 () Bool) (declare-fun z$15469 () Bool) (declare-fun z$15470 () Bool) (declare-fun z$15599 () Bool) (declare-fun z$15600 () Bool) (declare-fun z$15607 () Bool) (declare-fun z$15608 () Bool) (declare-fun z$75 () Bool) (declare-fun z$5192 () Bool) (declare-fun z$8822 () Bool) (declare-fun z$16011 () Bool) (declare-fun z$16012 () Bool) (declare-fun z$16025 () Bool) (declare-fun z$16026 () Bool) (declare-fun z$16033 () Bool) (declare-fun z$16034 () Bool) (declare-fun z$16041 () Bool) (declare-fun z$16042 () Bool) (declare-fun z$13040 () Bool) (declare-fun z$16049 () Bool) (declare-fun z$16050 () Bool) (declare-fun z$16057 () Bool) (declare-fun z$16058 () Bool) (declare-fun z$14636 () Bool) (declare-fun z$16077 () Bool) (declare-fun z$16078 () Bool) (declare-fun z$16086 () Bool) (declare-fun z$16087 () Bool) (declare-fun z$16100 () Bool) (declare-fun z$16101 () Bool) (declare-fun z$16114 () Bool) (declare-fun z$16115 () Bool) (declare-fun z$16125 () Bool) (declare-fun z$16126 () Bool) (declare-fun z$16146 () Bool) (declare-fun z$16147 () Bool) (declare-fun z$16154 () Bool) (declare-fun z$16155 () Bool) (declare-fun z$16162 () Bool) (declare-fun z$16163 () Bool) (declare-fun z$6784 () Bool) (declare-fun z$16244 () Bool) (declare-fun z$16245 () Bool) (declare-fun z$8447 () Bool) (declare-fun z$8448 () Bool) (declare-fun z$16274 () Bool) (declare-fun z$16275 () Bool) (declare-fun z$16282 () Bool) (declare-fun z$16283 () Bool) (declare-fun z$10862 () Bool) (declare-fun z$10863 () Bool) (declare-fun z$11752 () Bool) (declare-fun z$11753 () Bool) (declare-fun z$16322 () Bool) (declare-fun z$16323 () Bool) (declare-fun z$16330 () Bool) (declare-fun z$16331 () Bool) (declare-fun z$16338 () Bool) (declare-fun z$16339 () Bool) (declare-fun z$16367 () Bool) (declare-fun z$16368 () Bool) (declare-fun z$16375 () Bool) (declare-fun z$16376 () Bool) (declare-fun z$16383 () Bool) (declare-fun z$16384 () Bool) (declare-fun z$12275 () Bool) (declare-fun z$16414 () Bool) (declare-fun z$16415 () Bool) (declare-fun z$16422 () Bool) (declare-fun z$16423 () Bool) (declare-fun z$16430 () Bool) (declare-fun z$16431 () Bool) (declare-fun z$16438 () Bool) (declare-fun z$16439 () Bool) (declare-fun z$5378 () Bool) (declare-fun z$10031 () Bool) (declare-fun z$16467 () Bool) (declare-fun z$16468 () Bool) (declare-fun z$2168 () Bool) (declare-fun z$10032 () Bool) (declare-fun z$16480 () Bool) (declare-fun z$16481 () Bool) (declare-fun z$283 () Bool) (declare-fun z$285 () Bool) (declare-fun z$16492 () Bool) (declare-fun z$16493 () Bool) (declare-fun z$5593 () Bool) (declare-fun z$16503 () Bool) (declare-fun z$16504 () Bool) (declare-fun z$16518 () Bool) (declare-fun z$16519 () Bool) (declare-fun z$16526 () Bool) (declare-fun z$16527 () Bool) (declare-fun z$16570 () Bool) (declare-fun z$16571 () Bool) (declare-fun z$5361 () Bool) (declare-fun z$16612 () Bool) (declare-fun z$16613 () Bool) (declare-fun z$16620 () Bool) (declare-fun z$16621 () Bool) (declare-fun z$16631 () Bool) (declare-fun z$16632 () Bool) (declare-fun z$16645 () Bool) (declare-fun z$16646 () Bool) (declare-fun z$16653 () Bool) (declare-fun z$16654 () Bool) (declare-fun z$16669 () Bool) (declare-fun z$16670 () Bool) (declare-fun z$16684 () Bool) (declare-fun z$16685 () Bool) (declare-fun z$7436 () Bool) (declare-fun z$16704 () Bool) (declare-fun z$16705 () Bool) (declare-fun z$10915 () Bool) (declare-fun z$16716 () Bool) (declare-fun z$16717 () Bool) (declare-fun z$16741 () Bool) (declare-fun z$16742 () Bool) (declare-fun z$4471 () Bool) (declare-fun z$9561 () Bool) (declare-fun z$16752 () Bool) (declare-fun z$16753 () Bool) (declare-fun z$16765 () Bool) (declare-fun z$16766 () Bool) (declare-fun z$16787 () Bool) (declare-fun z$16788 () Bool) (declare-fun z$16818 () Bool) (declare-fun z$16819 () Bool) (declare-fun z$991 () Bool) (declare-fun z$2210 () Bool) (declare-fun z$16826 () Bool) (declare-fun z$16827 () Bool) (declare-fun z$16834 () Bool) (declare-fun z$16835 () Bool) (declare-fun a_in_transit_L () Bool) (declare-fun z$16848 () Bool) (declare-fun z$16849 () Bool) (declare-fun z$16856 () Bool) (declare-fun z$16857 () Bool) (declare-fun z$16871 () Bool) (declare-fun z$16872 () Bool) (declare-fun z$16879 () Bool) (declare-fun z$16880 () Bool) (declare-fun z$16887 () Bool) (declare-fun z$16888 () Bool) (declare-fun z$16895 () Bool) (declare-fun z$16896 () Bool) (declare-fun z$16932 () Bool) (declare-fun z$16933 () Bool) (declare-fun z$9233 () Bool) (declare-fun z$16940 () Bool) (declare-fun z$16941 () Bool) (declare-fun z$2658 () Bool) (declare-fun z$16949 () Bool) (declare-fun z$16950 () Bool) (declare-fun z$16975 () Bool) (declare-fun z$16976 () Bool) (declare-fun z$16983 () Bool) (declare-fun z$16984 () Bool) (declare-fun z$60 () Bool) (declare-fun z$1006 () Bool) (declare-fun z$2213 () Bool) (declare-fun z$17032 () Bool) (declare-fun z$17033 () Bool) (declare-fun z$17041 () Bool) (declare-fun z$17042 () Bool) (declare-fun z$17055 () Bool) (declare-fun z$17056 () Bool) (declare-fun z$17063 () Bool) (declare-fun z$17064 () Bool) (declare-fun z$17077 () Bool) (declare-fun z$17078 () Bool) (declare-fun z$17085 () Bool) (declare-fun z$17086 () Bool) (declare-fun z$17093 () Bool) (declare-fun z$17094 () Bool) (declare-fun z$17101 () Bool) (declare-fun z$17102 () Bool) (declare-fun z$17112 () Bool) (declare-fun z$17113 () Bool) (declare-fun z$17140 () Bool) (declare-fun z$17141 () Bool) (declare-fun z$17148 () Bool) (declare-fun z$17149 () Bool) (declare-fun z$12541 () Bool) (declare-fun z$17162 () Bool) (declare-fun z$17163 () Bool) (declare-fun z$17170 () Bool) (declare-fun z$17171 () Bool) (declare-fun z$17178 () Bool) (declare-fun z$17179 () Bool) (declare-fun z$3 () Bool) (declare-fun z$17211 () Bool) (declare-fun z$17212 () Bool) (declare-fun z$17219 () Bool) (declare-fun z$17220 () Bool) (declare-fun z$17241 () Bool) (declare-fun z$17242 () Bool) (declare-fun z$17249 () Bool) (declare-fun z$17250 () Bool) (declare-fun z$17257 () Bool) (declare-fun z$17258 () Bool) (declare-fun z$17268 () Bool) (declare-fun z$17269 () Bool) (declare-fun z$3053 () Bool) (declare-fun z$17276 () Bool) (declare-fun z$17277 () Bool) (declare-fun z$17308 () Bool) (declare-fun z$17309 () Bool) (declare-fun z$17324 () Bool) (declare-fun z$17325 () Bool) (declare-fun z$17332 () Bool) (declare-fun z$17333 () Bool) (declare-fun z$17351 () Bool) (declare-fun z$17352 () Bool) (declare-fun z$17371 () Bool) (declare-fun z$17372 () Bool) (declare-fun z$17379 () Bool) (declare-fun z$17380 () Bool) (declare-fun z$17393 () Bool) (declare-fun z$17394 () Bool) (declare-fun z$12067 () Bool) (declare-fun z$17401 () Bool) (declare-fun z$17402 () Bool) (declare-fun z$17414 () Bool) (declare-fun z$17415 () Bool) (declare-fun z$6815 () Bool) (declare-fun z$7317 () Bool) (declare-fun z$7318 () Bool) (declare-fun z$7432 () Bool) (declare-fun z$7433 () Bool) (declare-fun z$8497 () Bool) (declare-fun z$8498 () Bool) (declare-fun z$7320 () Bool) (declare-fun z$8558 () Bool) (declare-fun z$8559 () Bool) (declare-fun z$8563 () Bool) (declare-fun z$8606 () Bool) (declare-fun z$8607 () Bool) (declare-fun z$9471 () Bool) (declare-fun z$9472 () Bool) (declare-fun z$10394 () Bool) (declare-fun z$10395 () Bool) (declare-fun z$10805 () Bool) (declare-fun z$10806 () Bool) (declare-fun z$14092 () Bool) (declare-fun z$14093 () Bool) (declare-fun z$9057 () Bool) (declare-fun z$13374 () Bool) (declare-fun z$13375 () Bool) (declare-fun z$3286 () Bool) (declare-fun z$14558 () Bool) (declare-fun z$14559 () Bool) (declare-fun z$879 () Bool) (declare-fun z$979 () Bool) (declare-fun z$980 () Bool) (declare-fun z$2068 () Bool) (declare-fun z$2070 () Bool) (declare-fun z$2072 () Bool) (declare-fun prop () Bool) (declare-fun z$2073 () Bool) (declare-fun z$91 () Bool) (declare-fun z$98 () Bool) (declare-fun z$105 () Bool) (declare-fun f00 () Bool) (declare-fun f11 () Bool) (declare-fun f13 () Bool) (declare-fun f14 () Bool) (declare-fun f17 () Bool) (declare-fun f18 () Bool) (declare-fun f25 () Bool) (declare-fun z$168 () Bool) (declare-fun f15 () Bool) (declare-fun z$200 () Bool) (declare-fun z$218 () Bool) (declare-fun z$220 () Bool) (declare-fun f21 () Bool) (declare-fun f23 () Bool) (declare-fun z$233 () Bool) (declare-fun z$251 () Bool) (declare-fun z$253 () Bool) (declare-fun f19 () Bool) (declare-fun f20 () Bool) (declare-fun z$266 () Bool) (declare-fun f24 () Bool) (declare-fun z$300 () Bool) (declare-fun f04 () Bool) (declare-fun z$358 () Bool) (declare-fun f16 () Bool) (declare-fun z$375 () Bool) (declare-fun a_time () Bool) (declare-fun a_time$next () Bool) (declare-fun z$432 () Bool) (declare-fun f01 () Bool) (declare-fun z$434 () Bool) (declare-fun z$435 () Bool) (declare-fun z$437 () Bool) (declare-fun z$438 () Bool) (declare-fun z$439 () Bool) (declare-fun z$441 () Bool) (declare-fun a_first_safe_frame$next () Bool) (declare-fun z$442 () Bool) (declare-fun z$444 () Bool) (declare-fun z$446 () Bool) (declare-fun z$447 () Bool) (declare-fun z$448 () Bool) (declare-fun z$449 () Bool) (declare-fun z$451 () Bool) (declare-fun z$452 () Bool) (declare-fun z$453 () Bool) (declare-fun f22 () Bool) (declare-fun z$456 () Bool) (declare-fun z$457 () Bool) (declare-fun f26 () Bool) (declare-fun z$460 () Bool) (declare-fun z$461 () Bool) (declare-fun f27 () Bool) (declare-fun z$464 () Bool) (declare-fun z$465 () Bool) (declare-fun f28 () Bool) (declare-fun z$468 () Bool) (declare-fun z$469 () Bool) (declare-fun f29 () Bool) (declare-fun z$472 () Bool) (declare-fun z$473 () Bool) (declare-fun f30 () Bool) (declare-fun z$476 () Bool) (declare-fun z$477 () Bool) (declare-fun f31 () Bool) (declare-fun z$480 () Bool) (declare-fun z$481 () Bool) (declare-fun a_frame_received$next () Bool) (declare-fun z$483 () Bool) (declare-fun z$485 () Bool) (declare-fun z$486 () Bool) (declare-fun z$488 () Bool) (declare-fun z$489 () Bool) (declare-fun z$491 () Bool) (declare-fun z$492 () Bool) (declare-fun z$494 () Bool) (declare-fun z$495 () Bool) (declare-fun z$496 () Bool) (declare-fun z$498 () Bool) (declare-fun z$499 () Bool) (declare-fun z$500 () Bool) (declare-fun z$502 () Bool) (declare-fun z$503 () Bool) (declare-fun z$504 () Bool) (declare-fun z$506 () Bool) (declare-fun z$507 () Bool) (declare-fun z$508 () Bool) (declare-fun z$510 () Bool) (declare-fun z$511 () Bool) (declare-fun z$512 () Bool) (declare-fun z$514 () Bool) (declare-fun a_frame_reported$next () Bool) (declare-fun z$515 () Bool) (declare-fun f02 () Bool) (declare-fun z$518 () Bool) (declare-fun z$519 () Bool) (declare-fun z$521 () Bool) (declare-fun z$523 () Bool) (declare-fun z$524 () Bool) (declare-fun z$526 () Bool) (declare-fun z$527 () Bool) (declare-fun z$528 () Bool) (declare-fun z$530 () Bool) (declare-fun z$531 () Bool) (declare-fun z$532 () Bool) (declare-fun z$534 () Bool) (declare-fun z$535 () Bool) (declare-fun z$536 () Bool) (declare-fun z$538 () Bool) (declare-fun f32 () Bool) (declare-fun z$540 () Bool) (declare-fun z$541 () Bool) (declare-fun a_idle_Receiver$next () Bool) (declare-fun z$543 () Bool) (declare-fun z$545 () Bool) (declare-fun z$547 () Bool) (declare-fun z$548 () Bool) (declare-fun z$550 () Bool) (declare-fun z$551 () Bool) (declare-fun z$553 () Bool) (declare-fun z$554 () Bool) (declare-fun a_new_file$next () Bool) (declare-fun z$555 () Bool) (declare-fun z$557 () Bool) (declare-fun z$558 () Bool) (declare-fun z$560 () Bool) (declare-fun z$561 () Bool) (declare-fun z$562 () Bool) (declare-fun z$563 () Bool) (declare-fun z$565 () Bool) (declare-fun z$566 () Bool) (declare-fun z$567 () Bool) (declare-fun z$569 () Bool) (declare-fun z$570 () Bool) (declare-fun a_next_frame$next () Bool) (declare-fun z$572 () Bool) (declare-fun z$574 () Bool) (declare-fun z$575 () Bool) (declare-fun z$577 () Bool) (declare-fun z$578 () Bool) (declare-fun z$580 () Bool) (declare-fun z$581 () Bool) (declare-fun z$583 () Bool) (declare-fun z$584 () Bool) (declare-fun z$585 () Bool) (declare-fun z$587 () Bool) (declare-fun z$588 () Bool) (declare-fun z$589 () Bool) (declare-fun a_wait_ack$next () Bool) (declare-fun z$591 () Bool) (declare-fun z$593 () Bool) (declare-fun f12 () Bool) (declare-fun z$596 () Bool) (declare-fun z$597 () Bool) (declare-fun z$599 () Bool) (declare-fun z$600 () Bool) (declare-fun z$602 () Bool) (declare-fun a_success$next () Bool) (declare-fun z$603 () Bool) (declare-fun f05 () Bool) (declare-fun z$605 () Bool) (declare-fun z$606 () Bool) (declare-fun z$608 () Bool) (declare-fun z$609 () Bool) (declare-fun z$611 () Bool) (declare-fun z$612 () Bool) (declare-fun z$613 () Bool) (declare-fun z$615 () Bool) (declare-fun a_error$next () Bool) (declare-fun z$616 () Bool) (declare-fun z$27 () Bool) (declare-fun f03 () Bool) (declare-fun z$618 () Bool) (declare-fun z$619 () Bool) (declare-fun z$621 () Bool) (declare-fun a_init_state$next () Bool) (declare-fun z$622 () Bool) (declare-fun z$624 () Bool) (declare-fun z$626 () Bool) (declare-fun z$627 () Bool) (declare-fun z$628 () Bool) (declare-fun z$630 () Bool) (declare-fun z$631 () Bool) (declare-fun z$633 () Bool) (declare-fun z$634 () Bool) (declare-fun z$636 () Bool) (declare-fun a_idle_Sender$next () Bool) (declare-fun z$637 () Bool) (declare-fun f06 () Bool) (declare-fun z$640 () Bool) (declare-fun z$641 () Bool) (declare-fun z$643 () Bool) (declare-fun z$644 () Bool) (declare-fun z$646 () Bool) (declare-fun z$647 () Bool) (declare-fun z$649 () Bool) (declare-fun z$650 () Bool) (declare-fun z$651 () Bool) (declare-fun z$653 () Bool) (declare-fun z$654 () Bool) (declare-fun z$655 () Bool) (declare-fun z$657 () Bool) (declare-fun z$659 () Bool) (declare-fun a_in_transit_K$next () Bool) (declare-fun z$661 () Bool) (declare-fun z$663 () Bool) (declare-fun z$665 () Bool) (declare-fun z$666 () Bool) (declare-fun z$668 () Bool) (declare-fun z$670 () Bool) (declare-fun z$671 () Bool) (declare-fun z$673 () Bool) (declare-fun z$674 () Bool) (declare-fun z$675 () Bool) (declare-fun z$677 () Bool) (declare-fun z$678 () Bool) (declare-fun a_start_K$next () Bool) (declare-fun z$679 () Bool) (declare-fun z$681 () Bool) (declare-fun z$683 () Bool) (declare-fun z$684 () Bool) (declare-fun z$685 () Bool) (declare-fun z$687 () Bool) (declare-fun a_BAD_K$next () Bool) (declare-fun z$688 () Bool) (declare-fun f07 () Bool) (declare-fun z$691 () Bool) (declare-fun z$692 () Bool) (declare-fun z$694 () Bool) (declare-fun z$695 () Bool) (declare-fun z$697 () Bool) (declare-fun z$698 () Bool) (declare-fun z$700 () Bool) (declare-fun z$701 () Bool) (declare-fun z$703 () Bool) (declare-fun z$704 () Bool) (declare-fun z$706 () Bool) (declare-fun a_in_transit_L$next () Bool) (declare-fun z$708 () Bool) (declare-fun z$710 () Bool) (declare-fun z$712 () Bool) (declare-fun z$713 () Bool) (declare-fun z$715 () Bool) (declare-fun z$717 () Bool) (declare-fun z$718 () Bool) (declare-fun z$720 () Bool) (declare-fun z$721 () Bool) (declare-fun a_start_L$next () Bool) (declare-fun z$722 () Bool) (declare-fun z$724 () Bool) (declare-fun z$726 () Bool) (declare-fun z$727 () Bool) (declare-fun z$728 () Bool) (declare-fun z$730 () Bool) (declare-fun a_BAD_L$next () Bool) (declare-fun z$731 () Bool) (declare-fun a_ok_SClient () Bool) (declare-fun z$39 () Bool) (declare-fun f08 () Bool) (declare-fun z$734 () Bool) (declare-fun z$735 () Bool) (declare-fun z$737 () Bool) (declare-fun z$738 () Bool) (declare-fun z$740 () Bool) (declare-fun z$741 () Bool) (declare-fun a_ok_SClient$next () Bool) (declare-fun z$742 () Bool) (declare-fun f09 () Bool) (declare-fun z$745 () Bool) (declare-fun z$746 () Bool) (declare-fun z$748 () Bool) (declare-fun z$749 () Bool) (declare-fun z$751 () Bool) (declare-fun a_dk$next () Bool) (declare-fun z$752 () Bool) (declare-fun f10 () Bool) (declare-fun z$755 () Bool) (declare-fun z$756 () Bool) (declare-fun z$758 () Bool) (declare-fun z$759 () Bool) (declare-fun z$761 () Bool) (declare-fun a_nok_SClient$next () Bool) (declare-fun z$762 () Bool) (declare-fun z$764 () Bool) (declare-fun z$766 () Bool) (declare-fun z$767 () Bool) (declare-fun z$768 () Bool) (declare-fun z$770 () Bool) (declare-fun z$771 () Bool) (declare-fun z$772 () Bool) (declare-fun z$774 () Bool) (declare-fun z$775 () Bool) (declare-fun a_send_req$next () Bool) (declare-fun z$777 () Bool) (declare-fun z$779 () Bool) (declare-fun z$781 () Bool) (declare-fun z$782 () Bool) (declare-fun z$784 () Bool) (declare-fun z$786 () Bool) (declare-fun a_file_req$next () Bool) (declare-fun z$788 () Bool) (declare-fun a_ok_RClient () Bool) (declare-fun z$790 () Bool) (declare-fun z$792 () Bool) (declare-fun z$793 () Bool) (declare-fun z$794 () Bool) (declare-fun z$796 () Bool) (declare-fun z$797 () Bool) (declare-fun z$799 () Bool) (declare-fun a_ok_RClient$next () Bool) (declare-fun z$800 () Bool) (declare-fun a_inc () Bool) (declare-fun z$802 () Bool) (declare-fun z$804 () Bool) (declare-fun z$805 () Bool) (declare-fun z$807 () Bool) (declare-fun z$808 () Bool) (declare-fun z$809 () Bool) (declare-fun z$811 () Bool) (declare-fun z$812 () Bool) (declare-fun a_inc$next () Bool) (declare-fun z$814 () Bool) (declare-fun a_nok_RClient () Bool) (declare-fun z$816 () Bool) (declare-fun z$818 () Bool) (declare-fun z$820 () Bool) (declare-fun z$821 () Bool) (declare-fun z$823 () Bool) (declare-fun a_nok_RClient$next () Bool) (declare-fun z$824 () Bool) (declare-fun z$49 () Bool) (declare-fun z$828 () Bool) (declare-fun z$830 () Bool) (declare-fun z$831 () Bool) (declare-fun z$833 () Bool) (declare-fun z$834 () Bool) (declare-fun z$836 () Bool) (declare-fun z$837 () Bool) (declare-fun z$839 () Bool) (declare-fun z$841 () Bool) (declare-fun z$842 () Bool) (declare-fun z$847 () Bool) (declare-fun z$849 () Bool) (declare-fun z$850 () Bool) (declare-fun z$852 () Bool) (declare-fun z$853 () Bool) (declare-fun z$860 () Bool) (declare-fun z$862 () Bool) (declare-fun z$863 () Bool) (declare-fun z$869 () Bool) (declare-fun z$871 () Bool) (declare-fun z$872 () Bool) (declare-fun z$874 () Bool) (declare-fun z$876 () Bool) (declare-fun z$877 () Bool) (declare-fun z$893 () Bool) (declare-fun z$895 () Bool) (declare-fun z$896 () Bool) (declare-fun z$898 () Bool) (declare-fun z$899 () Bool) (declare-fun z$906 () Bool) (declare-fun z$908 () Bool) (declare-fun z$909 () Bool) (declare-fun z$913 () Bool) (declare-fun z$915 () Bool) (declare-fun z$916 () Bool) (declare-fun z$918 () Bool) (declare-fun z$919 () Bool) (declare-fun z$921 () Bool) (declare-fun z$923 () Bool) (declare-fun z$924 () Bool) (declare-fun z$925 () Bool) (declare-fun z$927 () Bool) (declare-fun z$928 () Bool) (declare-fun z$929 () Bool) (declare-fun z$931 () Bool) (declare-fun z$932 () Bool) (declare-fun z$933 () Bool) (declare-fun z$935 () Bool) (declare-fun z$936 () Bool) (declare-fun z$938 () Bool) (declare-fun z$940 () Bool) (declare-fun z$941 () Bool) (declare-fun z$943 () Bool) (declare-fun z$944 () Bool) (declare-fun z$946 () Bool) (declare-fun z$947 () Bool) (declare-fun z$949 () Bool) (declare-fun z$952 () Bool) (declare-fun z$953 () Bool) (declare-fun z$955 () Bool) (declare-fun z$957 () Bool) (declare-fun z$958 () Bool) (declare-fun z$960 () Bool) (declare-fun z$961 () Bool) (declare-fun z$963 () Bool) (declare-fun z$965 () Bool) (declare-fun z$966 () Bool) (declare-fun z$384 () Bool) (declare-fun z$968 () Bool) (declare-fun z$970 () Bool) (declare-fun z$971 () Bool) (declare-fun z$973 () Bool) (declare-fun z$974 () Bool) (declare-fun z$976 () Bool) (declare-fun z$977 () Bool) (declare-fun z$982 () Bool) (declare-fun z$983 () Bool) (declare-fun z$985 () Bool) (declare-fun z$986 () Bool) (declare-fun z$993 () Bool) (declare-fun z$995 () Bool) (declare-fun z$997 () Bool) (declare-fun z$998 () Bool) (declare-fun z$1000 () Bool) (declare-fun z$1001 () Bool) (declare-fun z$1003 () Bool) (declare-fun z$1005 () Bool) (declare-fun z$1008 () Bool) (declare-fun z$1010 () Bool) (declare-fun z$1012 () Bool) (declare-fun z$1013 () Bool) (declare-fun z$1015 () Bool) (declare-fun z$1016 () Bool) (declare-fun z$1018 () Bool) (declare-fun z$1020 () Bool) (declare-fun z$1021 () Bool) (declare-fun z$1023 () Bool) (declare-fun z$1025 () Bool) (declare-fun z$1026 () Bool) (declare-fun z$1028 () Bool) (declare-fun z$1030 () Bool) (declare-fun z$1031 () Bool) (declare-fun z$1033 () Bool) (declare-fun z$1035 () Bool) (declare-fun z$1036 () Bool) (declare-fun z$1038 () Bool) (declare-fun z$1039 () Bool) (declare-fun z$1041 () Bool) (declare-fun z$403 () Bool) (declare-fun z$409 () Bool) (declare-fun z$410 () Bool) (declare-fun z$1043 () Bool) (declare-fun z$1045 () Bool) (declare-fun z$1046 () Bool) (declare-fun z$1048 () Bool) (declare-fun z$1049 () Bool) (declare-fun z$1051 () Bool) (declare-fun z$1053 () Bool) (declare-fun z$1056 () Bool) (declare-fun z$1058 () Bool) (declare-fun z$1060 () Bool) (declare-fun z$1062 () Bool) (declare-fun z$1063 () Bool) (declare-fun z$1065 () Bool) (declare-fun z$1066 () Bool) (declare-fun z$1068 () Bool) (declare-fun z$1070 () Bool) (declare-fun z$1072 () Bool) (declare-fun z$1073 () Bool) (declare-fun z$1075 () Bool) (declare-fun z$1076 () Bool) (declare-fun z$1078 () Bool) (declare-fun z$1080 () Bool) (declare-fun z$1081 () Bool) (declare-fun z$1083 () Bool) (declare-fun z$1084 () Bool) (declare-fun z$1086 () Bool) (declare-fun z$1088 () Bool) (declare-fun z$1089 () Bool) (declare-fun z$1091 () Bool) (declare-fun z$1092 () Bool) (declare-fun z$1094 () Bool) (declare-fun z$1097 () Bool) (declare-fun z$1099 () Bool) (declare-fun z$1100 () Bool) (declare-fun z$1102 () Bool) (declare-fun z$1104 () Bool) (declare-fun z$1105 () Bool) (declare-fun z$1107 () Bool) (declare-fun z$1108 () Bool) (declare-fun z$1110 () Bool) (declare-fun z$1112 () Bool) (declare-fun z$1114 () Bool) (declare-fun z$1115 () Bool) (declare-fun z$1117 () Bool) (declare-fun z$1118 () Bool) (declare-fun z$29 () Bool) (declare-fun z$1120 () Bool) (declare-fun z$1122 () Bool) (declare-fun z$1124 () Bool) (declare-fun z$1125 () Bool) (declare-fun z$1127 () Bool) (declare-fun z$1128 () Bool) (declare-fun z$1130 () Bool) (declare-fun z$1132 () Bool) (declare-fun z$1134 () Bool) (declare-fun z$1136 () Bool) (declare-fun z$1137 () Bool) (declare-fun z$1139 () Bool) (declare-fun z$1140 () Bool) (declare-fun z$1142 () Bool) (declare-fun z$1143 () Bool) (declare-fun z$1145 () Bool) (declare-fun z$1149 () Bool) (declare-fun z$1150 () Bool) (declare-fun z$1151 () Bool) (declare-fun z$1153 () Bool) (declare-fun z$1154 () Bool) (declare-fun z$1156 () Bool) (declare-fun z$1157 () Bool) (declare-fun z$1159 () Bool) (declare-fun z$1160 () Bool) (declare-fun z$1162 () Bool) (declare-fun z$1164 () Bool) (declare-fun z$1166 () Bool) (declare-fun z$1167 () Bool) (declare-fun z$1169 () Bool) (declare-fun z$1170 () Bool) (declare-fun z$1172 () Bool) (declare-fun z$1174 () Bool) (declare-fun z$1175 () Bool) (declare-fun z$1177 () Bool) (declare-fun z$1178 () Bool) (declare-fun z$1180 () Bool) (declare-fun z$1182 () Bool) (declare-fun z$1183 () Bool) (declare-fun z$1185 () Bool) (declare-fun z$1186 () Bool) (declare-fun z$1188 () Bool) (declare-fun z$1190 () Bool) (declare-fun z$1192 () Bool) (declare-fun z$1194 () Bool) (declare-fun z$1195 () Bool) (declare-fun z$1197 () Bool) (declare-fun z$1198 () Bool) (declare-fun z$1200 () Bool) (declare-fun z$1201 () Bool) (declare-fun z$37 () Bool) (declare-fun z$1203 () Bool) (declare-fun z$1205 () Bool) (declare-fun z$1207 () Bool) (declare-fun z$1209 () Bool) (declare-fun z$1210 () Bool) (declare-fun z$1212 () Bool) (declare-fun z$1213 () Bool) (declare-fun z$1215 () Bool) (declare-fun z$1217 () Bool) (declare-fun z$1219 () Bool) (declare-fun z$1220 () Bool) (declare-fun z$1222 () Bool) (declare-fun z$1223 () Bool) (declare-fun z$1225 () Bool) (declare-fun z$1227 () Bool) (declare-fun z$1229 () Bool) (declare-fun z$1230 () Bool) (declare-fun z$1232 () Bool) (declare-fun z$1233 () Bool) (declare-fun z$1238 () Bool) (declare-fun z$1239 () Bool) (declare-fun z$1241 () Bool) (declare-fun z$1243 () Bool) (declare-fun z$1244 () Bool) (declare-fun z$1246 () Bool) (declare-fun z$1247 () Bool) (declare-fun z$1249 () Bool) (declare-fun z$1250 () Bool) (declare-fun z$1252 () Bool) (declare-fun z$1254 () Bool) (declare-fun z$1255 () Bool) (declare-fun z$1257 () Bool) (declare-fun z$1258 () Bool) (declare-fun z$1260 () Bool) (declare-fun z$1262 () Bool) (declare-fun z$1263 () Bool) (declare-fun z$1265 () Bool) (declare-fun z$1266 () Bool) (declare-fun z$1268 () Bool) (declare-fun z$1270 () Bool) (declare-fun z$1271 () Bool) (declare-fun z$1273 () Bool) (declare-fun z$1275 () Bool) (declare-fun z$1276 () Bool) (declare-fun z$1278 () Bool) (declare-fun z$1279 () Bool) (declare-fun z$1281 () Bool) (declare-fun z$1282 () Bool) (declare-fun z$1284 () Bool) (declare-fun z$1285 () Bool) (declare-fun z$1286 () Bool) (declare-fun z$1288 () Bool) (declare-fun z$1289 () Bool) (declare-fun z$1290 () Bool) (declare-fun z$1292 () Bool) (declare-fun z$1293 () Bool) (declare-fun z$1294 () Bool) (declare-fun z$1296 () Bool) (declare-fun z$1297 () Bool) (declare-fun z$1298 () Bool) (declare-fun z$1300 () Bool) (declare-fun z$1301 () Bool) (declare-fun z$1302 () Bool) (declare-fun z$1304 () Bool) (declare-fun z$1305 () Bool) (declare-fun z$1306 () Bool) (declare-fun z$1308 () Bool) (declare-fun z$1309 () Bool) (declare-fun z$1310 () Bool) (declare-fun z$1312 () Bool) (declare-fun z$1313 () Bool) (declare-fun z$1314 () Bool) (declare-fun z$1316 () Bool) (declare-fun z$1317 () Bool) (declare-fun z$1318 () Bool) (declare-fun z$1320 () Bool) (declare-fun z$1321 () Bool) (declare-fun z$1322 () Bool) (declare-fun z$1324 () Bool) (declare-fun z$1325 () Bool) (declare-fun z$1326 () Bool) (declare-fun z$1328 () Bool) (declare-fun z$1329 () Bool) (declare-fun z$1330 () Bool) (declare-fun z$1332 () Bool) (declare-fun z$1333 () Bool) (declare-fun z$1334 () Bool) (declare-fun z$1336 () Bool) (declare-fun z$1337 () Bool) (declare-fun z$1338 () Bool) (declare-fun z$1340 () Bool) (declare-fun z$1341 () Bool) (declare-fun z$1342 () Bool) (declare-fun z$1344 () Bool) (declare-fun z$1345 () Bool) (declare-fun z$1346 () Bool) (declare-fun z$1348 () Bool) (declare-fun z$1349 () Bool) (declare-fun z$1350 () Bool) (declare-fun z$1352 () Bool) (declare-fun z$1353 () Bool) (declare-fun z$1354 () Bool) (declare-fun z$1356 () Bool) (declare-fun z$1357 () Bool) (declare-fun z$1358 () Bool) (declare-fun z$1360 () Bool) (declare-fun z$1361 () Bool) (declare-fun z$1362 () Bool) (declare-fun z$1364 () Bool) (declare-fun z$1365 () Bool) (declare-fun z$1366 () Bool) (declare-fun z$1368 () Bool) (declare-fun z$1369 () Bool) (declare-fun z$1370 () Bool) (declare-fun z$1372 () Bool) (declare-fun z$1373 () Bool) (declare-fun z$1374 () Bool) (declare-fun z$1376 () Bool) (declare-fun z$1377 () Bool) (declare-fun z$1378 () Bool) (declare-fun z$1380 () Bool) (declare-fun z$1381 () Bool) (declare-fun z$1382 () Bool) (declare-fun z$1384 () Bool) (declare-fun z$1385 () Bool) (declare-fun z$1386 () Bool) (declare-fun z$1388 () Bool) (declare-fun z$1389 () Bool) (declare-fun z$1390 () Bool) (declare-fun z$1392 () Bool) (declare-fun z$1393 () Bool) (declare-fun z$1394 () Bool) (declare-fun z$1396 () Bool) (declare-fun z$1397 () Bool) (declare-fun z$1398 () Bool) (declare-fun z$1400 () Bool) (declare-fun z$1401 () Bool) (declare-fun z$1402 () Bool) (declare-fun z$1404 () Bool) (declare-fun z$1405 () Bool) (declare-fun z$1406 () Bool) (declare-fun z$1408 () Bool) (declare-fun z$1409 () Bool) (declare-fun z$1411 () Bool) (declare-fun z$1413 () Bool) (declare-fun z$1414 () Bool) (declare-fun z$1416 () Bool) (declare-fun z$1417 () Bool) (declare-fun z$1419 () Bool) (declare-fun z$1420 () Bool) (declare-fun z$1421 () Bool) (declare-fun z$1423 () Bool) (declare-fun z$1424 () Bool) (declare-fun z$1426 () Bool) (declare-fun z$1427 () Bool) (declare-fun z$1428 () Bool) (declare-fun z$1430 () Bool) (declare-fun z$1431 () Bool) (declare-fun z$1433 () Bool) (declare-fun z$1434 () Bool) (declare-fun z$1435 () Bool) (declare-fun z$1437 () Bool) (declare-fun z$1438 () Bool) (declare-fun z$1440 () Bool) (declare-fun z$1441 () Bool) (declare-fun z$1442 () Bool) (declare-fun z$1444 () Bool) (declare-fun z$1445 () Bool) (declare-fun z$1447 () Bool) (declare-fun z$1448 () Bool) (declare-fun z$1449 () Bool) (declare-fun z$1451 () Bool) (declare-fun z$1452 () Bool) (declare-fun z$1454 () Bool) (declare-fun z$1455 () Bool) (declare-fun z$1456 () Bool) (declare-fun z$1458 () Bool) (declare-fun z$1459 () Bool) (declare-fun z$1461 () Bool) (declare-fun z$1462 () Bool) (declare-fun z$1463 () Bool) (declare-fun z$1465 () Bool) (declare-fun z$1466 () Bool) (declare-fun z$1468 () Bool) (declare-fun z$1469 () Bool) (declare-fun z$1470 () Bool) (declare-fun z$1472 () Bool) (declare-fun z$1473 () Bool) (declare-fun z$1475 () Bool) (declare-fun z$1476 () Bool) (declare-fun z$1477 () Bool) (declare-fun z$1479 () Bool) (declare-fun z$1480 () Bool) (declare-fun z$1482 () Bool) (declare-fun z$1483 () Bool) (declare-fun z$1484 () Bool) (declare-fun z$1486 () Bool) (declare-fun z$1487 () Bool) (declare-fun z$1489 () Bool) (declare-fun z$1490 () Bool) (declare-fun z$1491 () Bool) (declare-fun z$1493 () Bool) (declare-fun z$1494 () Bool) (declare-fun z$1496 () Bool) (declare-fun z$1497 () Bool) (declare-fun z$1498 () Bool) (declare-fun z$1500 () Bool) (declare-fun z$1501 () Bool) (declare-fun z$1503 () Bool) (declare-fun z$1504 () Bool) (declare-fun z$1505 () Bool) (declare-fun z$1507 () Bool) (declare-fun z$1508 () Bool) (declare-fun z$1510 () Bool) (declare-fun z$1511 () Bool) (declare-fun z$1512 () Bool) (declare-fun z$1514 () Bool) (declare-fun z$1515 () Bool) (declare-fun z$1517 () Bool) (declare-fun z$1518 () Bool) (declare-fun z$1519 () Bool) (declare-fun z$1521 () Bool) (declare-fun z$1522 () Bool) (declare-fun z$1524 () Bool) (declare-fun z$1525 () Bool) (declare-fun z$1526 () Bool) (declare-fun z$1528 () Bool) (declare-fun z$1529 () Bool) (declare-fun z$1531 () Bool) (declare-fun z$1532 () Bool) (declare-fun z$1533 () Bool) (declare-fun z$1535 () Bool) (declare-fun z$1536 () Bool) (declare-fun z$1538 () Bool) (declare-fun z$1539 () Bool) (declare-fun z$1540 () Bool) (declare-fun z$1542 () Bool) (declare-fun z$1543 () Bool) (declare-fun z$1545 () Bool) (declare-fun z$1546 () Bool) (declare-fun z$1547 () Bool) (declare-fun z$1549 () Bool) (declare-fun z$1550 () Bool) (declare-fun z$1552 () Bool) (declare-fun z$1553 () Bool) (declare-fun z$1554 () Bool) (declare-fun z$1556 () Bool) (declare-fun z$1557 () Bool) (declare-fun z$1559 () Bool) (declare-fun z$1560 () Bool) (declare-fun z$1561 () Bool) (declare-fun z$1563 () Bool) (declare-fun z$1564 () Bool) (declare-fun z$1566 () Bool) (declare-fun z$1567 () Bool) (declare-fun z$1568 () Bool) (declare-fun z$1570 () Bool) (declare-fun z$1571 () Bool) (declare-fun z$1573 () Bool) (declare-fun z$1574 () Bool) (declare-fun z$1575 () Bool) (declare-fun z$1577 () Bool) (declare-fun z$1578 () Bool) (declare-fun z$1580 () Bool) (declare-fun z$1581 () Bool) (declare-fun z$1582 () Bool) (declare-fun z$1584 () Bool) (declare-fun z$1585 () Bool) (declare-fun z$1587 () Bool) (declare-fun z$1588 () Bool) (declare-fun z$1589 () Bool) (declare-fun z$1591 () Bool) (declare-fun z$1592 () Bool) (declare-fun z$1594 () Bool) (declare-fun z$1595 () Bool) (declare-fun z$1596 () Bool) (declare-fun z$1598 () Bool) (declare-fun z$1599 () Bool) (declare-fun z$1601 () Bool) (declare-fun z$1602 () Bool) (declare-fun z$1603 () Bool) (declare-fun z$1605 () Bool) (declare-fun z$1606 () Bool) (declare-fun z$1608 () Bool) (declare-fun z$1609 () Bool) (declare-fun z$1610 () Bool) (declare-fun z$1612 () Bool) (declare-fun z$1613 () Bool) (declare-fun z$1615 () Bool) (declare-fun z$1616 () Bool) (declare-fun z$1617 () Bool) (declare-fun z$1619 () Bool) (declare-fun z$1620 () Bool) (declare-fun z$1622 () Bool) (declare-fun z$1623 () Bool) (declare-fun z$1624 () Bool) (declare-fun z$1626 () Bool) (declare-fun z$1627 () Bool) (declare-fun z$1629 () Bool) (declare-fun z$1630 () Bool) (declare-fun z$1631 () Bool) (declare-fun z$1633 () Bool) (declare-fun z$1635 () Bool) (declare-fun z$1636 () Bool) (declare-fun z$1638 () Bool) (declare-fun z$1639 () Bool) (declare-fun z$1641 () Bool) (declare-fun z$1642 () Bool) (declare-fun z$1644 () Bool) (declare-fun z$1645 () Bool) (declare-fun z$1646 () Bool) (declare-fun z$1647 () Bool) (declare-fun z$1649 () Bool) (declare-fun z$1650 () Bool) (declare-fun z$1652 () Bool) (declare-fun z$1653 () Bool) (declare-fun z$1655 () Bool) (declare-fun z$1656 () Bool) (declare-fun z$1657 () Bool) (declare-fun z$1658 () Bool) (declare-fun z$1660 () Bool) (declare-fun z$1661 () Bool) (declare-fun z$1663 () Bool) (declare-fun z$1664 () Bool) (declare-fun z$1666 () Bool) (declare-fun z$1667 () Bool) (declare-fun z$1668 () Bool) (declare-fun z$1670 () Bool) (declare-fun z$1671 () Bool) (declare-fun z$1673 () Bool) (declare-fun z$1674 () Bool) (declare-fun z$1676 () Bool) (declare-fun z$1678 () Bool) (declare-fun z$1679 () Bool) (declare-fun z$1681 () Bool) (declare-fun z$1682 () Bool) (declare-fun z$1684 () Bool) (declare-fun z$1685 () Bool) (declare-fun z$1687 () Bool) (declare-fun z$1688 () Bool) (declare-fun z$1689 () Bool) (declare-fun z$1690 () Bool) (declare-fun z$1692 () Bool) (declare-fun z$1693 () Bool) (declare-fun z$1695 () Bool) (declare-fun z$1696 () Bool) (declare-fun z$1698 () Bool) (declare-fun z$1699 () Bool) (declare-fun z$7 () Bool) (declare-fun z$1700 () Bool) (declare-fun z$1701 () Bool) (declare-fun z$1703 () Bool) (declare-fun z$1704 () Bool) (declare-fun z$1706 () Bool) (declare-fun z$1707 () Bool) (declare-fun z$1709 () Bool) (declare-fun z$1710 () Bool) (declare-fun z$1711 () Bool) (declare-fun z$1712 () Bool) (declare-fun z$1714 () Bool) (declare-fun z$1715 () Bool) (declare-fun z$1717 () Bool) (declare-fun z$1718 () Bool) (declare-fun z$1720 () Bool) (declare-fun z$1721 () Bool) (declare-fun z$1722 () Bool) (declare-fun z$1724 () Bool) (declare-fun z$1725 () Bool) (declare-fun z$1727 () Bool) (declare-fun z$1728 () Bool) (declare-fun z$1730 () Bool) (declare-fun z$1732 () Bool) (declare-fun z$1733 () Bool) (declare-fun z$1735 () Bool) (declare-fun z$1736 () Bool) (declare-fun z$1738 () Bool) (declare-fun z$1739 () Bool) (declare-fun z$1741 () Bool) (declare-fun z$1742 () Bool) (declare-fun z$1743 () Bool) (declare-fun z$1745 () Bool) (declare-fun z$1746 () Bool) (declare-fun z$1748 () Bool) (declare-fun z$1749 () Bool) (declare-fun z$1751 () Bool) (declare-fun z$1753 () Bool) (declare-fun z$23 () Bool) (declare-fun z$1754 () Bool) (declare-fun z$1756 () Bool) (declare-fun z$1757 () Bool) (declare-fun z$1759 () Bool) (declare-fun z$1760 () Bool) (declare-fun z$1762 () Bool) (declare-fun z$1763 () Bool) (declare-fun z$1764 () Bool) (declare-fun z$1766 () Bool) (declare-fun z$1767 () Bool) (declare-fun z$1769 () Bool) (declare-fun z$1770 () Bool) (declare-fun z$1772 () Bool) (declare-fun z$1774 () Bool) (declare-fun z$1775 () Bool) (declare-fun z$1777 () Bool) (declare-fun z$1778 () Bool) (declare-fun z$1780 () Bool) (declare-fun z$1781 () Bool) (declare-fun z$1783 () Bool) (declare-fun z$1784 () Bool) (declare-fun z$1785 () Bool) (declare-fun z$1786 () Bool) (declare-fun z$1788 () Bool) (declare-fun z$1789 () Bool) (declare-fun z$1791 () Bool) (declare-fun z$1792 () Bool) (declare-fun z$1794 () Bool) (declare-fun z$1795 () Bool) (declare-fun z$1796 () Bool) (declare-fun z$1797 () Bool) (declare-fun z$1799 () Bool) (declare-fun z$1800 () Bool) (declare-fun z$1802 () Bool) (declare-fun z$1803 () Bool) (declare-fun z$1805 () Bool) (declare-fun z$1806 () Bool) (declare-fun z$1807 () Bool) (declare-fun z$1809 () Bool) (declare-fun z$1810 () Bool) (declare-fun z$1812 () Bool) (declare-fun z$1813 () Bool) (declare-fun z$1815 () Bool) (declare-fun z$1817 () Bool) (declare-fun z$25 () Bool) (declare-fun z$1818 () Bool) (declare-fun z$1820 () Bool) (declare-fun z$1821 () Bool) (declare-fun z$1823 () Bool) (declare-fun z$1824 () Bool) (declare-fun z$1826 () Bool) (declare-fun z$1827 () Bool) (declare-fun z$1828 () Bool) (declare-fun z$33 () Bool) (declare-fun z$1830 () Bool) (declare-fun z$1831 () Bool) (declare-fun z$1833 () Bool) (declare-fun z$1834 () Bool) (declare-fun z$1836 () Bool) (declare-fun z$1838 () Bool) (declare-fun z$1840 () Bool) (declare-fun z$1841 () Bool) (declare-fun z$1842 () Bool) (declare-fun z$1843 () Bool) (declare-fun z$1845 () Bool) (declare-fun z$1846 () Bool) (declare-fun z$1848 () Bool) (declare-fun z$1849 () Bool) (declare-fun z$1851 () Bool) (declare-fun z$1852 () Bool) (declare-fun z$1853 () Bool) (declare-fun z$1854 () Bool) (declare-fun z$1855 () Bool) (declare-fun z$1857 () Bool) (declare-fun z$1858 () Bool) (declare-fun z$1860 () Bool) (declare-fun z$1861 () Bool) (declare-fun z$1863 () Bool) (declare-fun z$1864 () Bool) (declare-fun z$1865 () Bool) (declare-fun z$1866 () Bool) (declare-fun z$1867 () Bool) (declare-fun z$1869 () Bool) (declare-fun z$1870 () Bool) (declare-fun z$1872 () Bool) (declare-fun z$1873 () Bool) (declare-fun z$1875 () Bool) (declare-fun z$1876 () Bool) (declare-fun z$1877 () Bool) (declare-fun z$1879 () Bool) (declare-fun z$1880 () Bool) (declare-fun z$1882 () Bool) (declare-fun z$1883 () Bool) (declare-fun z$1885 () Bool) (declare-fun z$1887 () Bool) (declare-fun z$1888 () Bool) (declare-fun z$1889 () Bool) (declare-fun z$1890 () Bool) (declare-fun z$1892 () Bool) (declare-fun z$1893 () Bool) (declare-fun z$1895 () Bool) (declare-fun z$1896 () Bool) (declare-fun z$1898 () Bool) (declare-fun z$1899 () Bool) (declare-fun z$1900 () Bool) (declare-fun z$1901 () Bool) (declare-fun z$1902 () Bool) (declare-fun z$1904 () Bool) (declare-fun z$1905 () Bool) (declare-fun z$1907 () Bool) (declare-fun z$1908 () Bool) (declare-fun z$1910 () Bool) (declare-fun z$1911 () Bool) (declare-fun z$1912 () Bool) (declare-fun z$1913 () Bool) (declare-fun z$1914 () Bool) (declare-fun z$1916 () Bool) (declare-fun z$1917 () Bool) (declare-fun z$1919 () Bool) (declare-fun z$1920 () Bool) (declare-fun z$1922 () Bool) (declare-fun z$1923 () Bool) (declare-fun z$1924 () Bool) (declare-fun z$1925 () Bool) (declare-fun z$1927 () Bool) (declare-fun z$1928 () Bool) (declare-fun z$1930 () Bool) (declare-fun z$1931 () Bool) (declare-fun z$1933 () Bool) (declare-fun z$1934 () Bool) (declare-fun z$1935 () Bool) (declare-fun z$1937 () Bool) (declare-fun z$1938 () Bool) (declare-fun z$1939 () Bool) (declare-fun z$1941 () Bool) (declare-fun z$1942 () Bool) (declare-fun z$1944 () Bool) (declare-fun z$1946 () Bool) (declare-fun z$1947 () Bool) (declare-fun z$1948 () Bool) (declare-fun z$1950 () Bool) (declare-fun z$1951 () Bool) (declare-fun z$1953 () Bool) (declare-fun z$1954 () Bool) (declare-fun z$1956 () Bool) (declare-fun z$1957 () Bool) (declare-fun z$1958 () Bool) (declare-fun z$1960 () Bool) (declare-fun z$1961 () Bool) (declare-fun z$1962 () Bool) (declare-fun z$1964 () Bool) (declare-fun z$1965 () Bool) (declare-fun z$1967 () Bool) (declare-fun z$1969 () Bool) (declare-fun z$1970 () Bool) (declare-fun z$1971 () Bool) (declare-fun z$1973 () Bool) (declare-fun z$1974 () Bool) (declare-fun z$1976 () Bool) (declare-fun z$1977 () Bool) (declare-fun z$1979 () Bool) (declare-fun z$1980 () Bool) (declare-fun z$1981 () Bool) (declare-fun z$1983 () Bool) (declare-fun z$1984 () Bool) (declare-fun z$1985 () Bool) (declare-fun z$1987 () Bool) (declare-fun z$1988 () Bool) (declare-fun z$1990 () Bool) (declare-fun z$1992 () Bool) (declare-fun z$1993 () Bool) (declare-fun z$1994 () Bool) (declare-fun z$1996 () Bool) (declare-fun z$1997 () Bool) (declare-fun z$1999 () Bool) (declare-fun z$2000 () Bool) (declare-fun z$2002 () Bool) (declare-fun z$2003 () Bool) (declare-fun z$2004 () Bool) (declare-fun z$2005 () Bool) (declare-fun z$2006 () Bool) (declare-fun z$2008 () Bool) (declare-fun z$2009 () Bool) (declare-fun z$2011 () Bool) (declare-fun z$2012 () Bool) (declare-fun z$2014 () Bool) (declare-fun z$2015 () Bool) (declare-fun z$2016 () Bool) (declare-fun z$2017 () Bool) (declare-fun z$2018 () Bool) (declare-fun z$2020 () Bool) (declare-fun z$2021 () Bool) (declare-fun z$2023 () Bool) (declare-fun z$2024 () Bool) (declare-fun z$2026 () Bool) (declare-fun z$2027 () Bool) (declare-fun z$2028 () Bool) (declare-fun z$2030 () Bool) (declare-fun z$2031 () Bool) (declare-fun z$2032 () Bool) (declare-fun z$2034 () Bool) (declare-fun z$2035 () Bool) (declare-fun z$2037 () Bool) (declare-fun z$2039 () Bool) (declare-fun z$2040 () Bool) (declare-fun z$2041 () Bool) (declare-fun z$2043 () Bool) (declare-fun z$2044 () Bool) (declare-fun z$2046 () Bool) (declare-fun z$2047 () Bool) (declare-fun z$2049 () Bool) (declare-fun z$2050 () Bool) (declare-fun z$2051 () Bool) (declare-fun z$2053 () Bool) (declare-fun z$2054 () Bool) (declare-fun z$2055 () Bool) (declare-fun z$2057 () Bool) (declare-fun z$2058 () Bool) (declare-fun z$2060 () Bool) (declare-fun z$2062 () Bool) (declare-fun z$2064 () Bool) (declare-fun dve_invalid$next () Bool) (declare-fun z$2065 () Bool) (declare-fun z$2115 () Bool) (declare-fun z$2116 () Bool) (declare-fun z$2132 () Bool) (declare-fun z$2146 () Bool) (declare-fun z$2147 () Bool) (declare-fun z$2149 () Bool) (declare-fun z$2151 () Bool) (declare-fun z$2153 () Bool) (declare-fun prop$next () Bool) (declare-fun z$2154 () Bool) (declare-fun z$2466 () Bool) (declare-fun z$2593 () Bool) (declare-fun z$4224 () Bool) (declare-fun z$4226 () Bool) (declare-fun z$64 () Bool) (declare-fun z$4225 () Bool) (declare-fun z$4234 () Bool) (declare-fun z$5291 () Bool) (declare-fun z$5293 () Bool) (declare-fun z$5292 () Bool) (declare-fun z$5297 () Bool) (declare-fun z$2360 () Bool) (declare-fun z$7528 () Bool) (declare-fun z$7530 () Bool) (declare-fun z$2381 () Bool) (declare-fun z$7529 () Bool) (declare-fun z$7537 () Bool) (declare-fun z$7542 () Bool) (declare-fun z$2361 () Bool) (declare-fun z$7587 () Bool) (declare-fun z$7590 () Bool) (declare-fun z$7588 () Bool) (declare-fun z$2382 () Bool) (declare-fun z$7589 () Bool) (declare-fun z$7595 () Bool) (declare-fun z$7599 () Bool) (declare-fun z$7540 () Bool) (declare-fun z$7615 () Bool) (declare-fun z$7617 () Bool) (declare-fun z$7594 () Bool) (declare-fun z$7533 () Bool) (declare-fun z$2352 () Bool) (declare-fun z$7614 () Bool) (declare-fun z$7616 () Bool) (declare-fun z$7627 () Bool) (declare-fun z$2353 () Bool) (declare-fun z$7664 () Bool) (declare-fun z$7666 () Bool) (declare-fun z$7622 () Bool) (declare-fun z$7665 () Bool) (declare-fun z$7671 () Bool) (declare-fun z$2469 () Bool) (declare-fun z$2511 () Bool) (declare-fun z$7740 () Bool) (declare-fun z$7738 () Bool) (declare-fun z$2496 () Bool) (declare-fun z$7815 () Bool) (declare-fun z$7817 () Bool) (declare-fun z$4216 () Bool) (declare-fun z$2589 () Bool) (declare-fun z$7816 () Bool) (declare-fun z$7826 () Bool) (declare-fun z$7821 () Bool) (declare-fun z$2472 () Bool) (declare-fun z$7865 () Bool) (declare-fun z$7873 () Bool) (declare-fun z$7830 () Bool) (declare-fun z$2564 () Bool) (declare-fun z$2544 () Bool) (declare-fun z$7871 () Bool) (declare-fun z$7872 () Bool) (declare-fun z$7878 () Bool) (declare-fun z$2529 () Bool) (declare-fun z$8676 () Bool) (declare-fun z$8678 () Bool) (declare-fun z$2621 () Bool) (declare-fun z$2540 () Bool) (declare-fun z$8677 () Bool) (declare-fun z$8686 () Bool) (declare-fun z$8723 () Bool) (declare-fun z$8726 () Bool) (declare-fun z$2561 () Bool) (declare-fun z$2563 () Bool) (declare-fun z$8724 () Bool) (declare-fun z$8725 () Bool) (declare-fun z$8728 () Bool) (declare-fun z$8767 () Bool) (declare-fun z$8769 () Bool) (declare-fun z$6850 () Bool) (declare-fun z$7323 () Bool) (declare-fun z$8768 () Bool) (declare-fun z$8771 () Bool) (declare-fun z$2666 () Bool) (declare-fun z$8806 () Bool) (declare-fun z$8808 () Bool) (declare-fun z$2652 () Bool) (declare-fun z$8807 () Bool) (declare-fun z$8812 () Bool) (declare-fun z$7677 () Bool) (declare-fun z$8863 () Bool) (declare-fun z$8865 () Bool) (declare-fun z$7678 () Bool) (declare-fun z$8864 () Bool) (declare-fun z$8868 () Bool) (declare-fun z$8916 () Bool) (declare-fun z$8969 () Bool) (declare-fun z$8972 () Bool) (declare-fun z$8970 () Bool) (declare-fun z$8971 () Bool) (declare-fun z$8977 () Bool) (declare-fun z$2366 () Bool) (declare-fun z$10957 () Bool) (declare-fun z$10959 () Bool) (declare-fun z$2350 () Bool) (declare-fun z$10956 () Bool) (declare-fun z$10958 () Bool) (declare-fun z$10985 () Bool) (declare-fun z$10983 () Bool) (declare-fun z$10965 () Bool) (declare-fun z$4214 () Bool) (declare-fun z$2348 () Bool) (declare-fun z$11068 () Bool) (declare-fun z$11070 () Bool) (declare-fun z$10962 () Bool) (declare-fun z$2364 () Bool) (declare-fun z$11069 () Bool) (declare-fun z$11080 () Bool) (declare-fun z$8820 () Bool) (declare-fun z$3249 () Bool) (declare-fun z$11132 () Bool) (declare-fun z$11134 () Bool) (declare-fun z$8823 () Bool) (declare-fun z$3327 () Bool) (declare-fun z$3341 () Bool) (declare-fun z$3343 () Bool) (declare-fun z$3366 () Bool) (declare-fun z$11133 () Bool) (declare-fun z$11139 () Bool) (declare-fun z$11138 () Bool) (declare-fun z$11201 () Bool) (declare-fun z$11203 () Bool) (declare-fun z$11075 () Bool) (declare-fun z$11143 () Bool) (declare-fun z$11200 () Bool) (declare-fun z$11202 () Bool) (declare-fun z$3262 () Bool) (declare-fun z$11254 () Bool) (declare-fun z$11256 () Bool) (declare-fun z$3379 () Bool) (declare-fun z$11255 () Bool) (declare-fun z$11260 () Bool) (declare-fun z$11263 () Bool) (declare-fun z$11295 () Bool) (declare-fun z$11297 () Bool) (declare-fun z$11296 () Bool) (declare-fun z$11304 () Bool) (declare-fun z$5223 () Bool) (declare-fun z$3403 () Bool) (declare-fun z$11320 () Bool) (declare-fun z$11322 () Bool) (declare-fun z$5217 () Bool) (declare-fun z$11321 () Bool) (declare-fun z$11332 () Bool) (declare-fun z$5205 () Bool) (declare-fun z$5198 () Bool) (declare-fun z$11385 () Bool) (declare-fun z$11386 () Bool) (declare-fun z$3375 () Bool) (declare-fun z$11410 () Bool) (declare-fun z$11412 () Bool) (declare-fun z$3258 () Bool) (declare-fun z$11409 () Bool) (declare-fun z$11411 () Bool) (declare-fun z$11418 () Bool) (declare-fun z$11460 () Bool) (declare-fun z$11463 () Bool) (declare-fun z$11461 () Bool) (declare-fun z$11462 () Bool) (declare-fun z$11469 () Bool) (declare-fun z$11496 () Bool) (declare-fun z$11497 () Bool) (declare-fun z$2354 () Bool) (declare-fun z$11540 () Bool) (declare-fun z$11542 () Bool) (declare-fun z$2372 () Bool) (declare-fun z$11541 () Bool) (declare-fun z$11548 () Bool) (declare-fun z$11590 () Bool) (declare-fun z$11591 () Bool) (declare-fun z$11593 () Bool) (declare-fun z$2356 () Bool) (declare-fun z$11589 () Bool) (declare-fun z$11592 () Bool) (declare-fun z$11091 () Bool) (declare-fun z$11623 () Bool) (declare-fun z$11625 () Bool) (declare-fun z$11090 () Bool) (declare-fun z$11622 () Bool) (declare-fun z$11624 () Bool) (declare-fun z$4472 () Bool) (declare-fun z$4550 () Bool) (declare-fun z$12103 () Bool) (declare-fun z$12104 () Bool) (declare-fun z$11335 () Bool) (declare-fun z$12130 () Bool) (declare-fun z$12131 () Bool) (declare-fun z$12156 () Bool) (declare-fun z$12157 () Bool) (declare-fun z$3279 () Bool) (declare-fun z$12190 () Bool) (declare-fun z$12191 () Bool) (declare-fun z$12198 () Bool) (declare-fun z$3399 () Bool) (declare-fun z$3315 () Bool) (declare-fun z$12216 () Bool) (declare-fun z$12218 () Bool) (declare-fun z$3282 () Bool) (declare-fun z$12215 () Bool) (declare-fun z$12217 () Bool) (declare-fun z$7349 () Bool) (declare-fun z$2766 () Bool) (declare-fun z$5467 () Bool) (declare-fun z$2788 () Bool) (declare-fun z$12245 () Bool) (declare-fun z$12247 () Bool) (declare-fun z$7337 () Bool) (declare-fun z$12244 () Bool) (declare-fun z$12246 () Bool) (declare-fun z$6804 () Bool) (declare-fun z$12270 () Bool) (declare-fun z$12272 () Bool) (declare-fun z$6870 () Bool) (declare-fun z$6896 () Bool) (declare-fun z$12271 () Bool) (declare-fun z$12276 () Bool) (declare-fun z$5469 () Bool) (declare-fun z$5738 () Bool) (declare-fun z$12979 () Bool) (declare-fun z$12981 () Bool) (declare-fun z$5653 () Bool) (declare-fun z$12978 () Bool) (declare-fun z$12980 () Bool) (declare-fun z$10412 () Bool) (declare-fun z$5600 () Bool) (declare-fun z$13026 () Bool) (declare-fun z$13028 () Bool) (declare-fun z$10423 () Bool) (declare-fun z$5685 () Bool) (declare-fun z$3493 () Bool) (declare-fun z$13027 () Bool) (declare-fun z$13033 () Bool) (declare-fun z$2805 () Bool) (declare-fun z$2785 () Bool) (declare-fun z$2787 () Bool) (declare-fun z$13077 () Bool) (declare-fun z$13078 () Bool) (declare-fun z$11270 () Bool) (declare-fun z$13124 () Bool) (declare-fun z$13126 () Bool) (declare-fun z$13123 () Bool) (declare-fun z$13125 () Bool) (declare-fun z$13164 () Bool) (declare-fun z$13166 () Bool) (declare-fun z$6997 () Bool) (declare-fun z$13165 () Bool) (declare-fun z$13168 () Bool) (declare-fun z$2758 () Bool) (declare-fun z$13192 () Bool) (declare-fun z$13194 () Bool) (declare-fun z$2803 () Bool) (declare-fun z$13193 () Bool) (declare-fun z$13196 () Bool) (declare-fun z$2757 () Bool) (declare-fun z$13220 () Bool) (declare-fun z$13222 () Bool) (declare-fun z$2802 () Bool) (declare-fun z$8825 () Bool) (declare-fun z$13221 () Bool) (declare-fun z$13224 () Bool) (declare-fun z$8821 () Bool) (declare-fun z$13249 () Bool) (declare-fun z$13251 () Bool) (declare-fun z$2791 () Bool) (declare-fun z$8824 () Bool) (declare-fun z$13250 () Bool) (declare-fun z$13253 () Bool) (declare-fun z$12984 () Bool) (declare-fun z$13274 () Bool) (declare-fun z$13276 () Bool) (declare-fun z$12987 () Bool) (declare-fun z$13273 () Bool) (declare-fun z$13275 () Bool) (declare-fun z$13306 () Bool) (declare-fun z$13308 () Bool) (declare-fun z$2767 () Bool) (declare-fun z$13307 () Bool) (declare-fun z$13310 () Bool) (declare-fun z$4684 () Bool) (declare-fun z$4859 () Bool) (declare-fun z$13420 () Bool) (declare-fun z$13422 () Bool) (declare-fun z$11349 () Bool) (declare-fun z$13421 () Bool) (declare-fun z$13425 () Bool) (declare-fun z$13447 () Bool) (declare-fun z$13448 () Bool) (declare-fun z$5592 () Bool) (declare-fun z$3054 () Bool) (declare-fun z$13497 () Bool) (declare-fun z$13498 () Bool) (declare-fun z$13542 () Bool) (declare-fun z$13543 () Bool) (declare-fun z$13579 () Bool) (declare-fun z$13580 () Bool) (declare-fun z$14595 () Bool) (declare-fun z$14597 () Bool) (declare-fun z$13036 () Bool) (declare-fun z$14596 () Bool) (declare-fun z$14599 () Bool) (declare-fun z$4844 () Bool) (declare-fun z$13041 () Bool) (declare-fun z$14627 () Bool) (declare-fun z$14629 () Bool) (declare-fun z$4669 () Bool) (declare-fun z$14626 () Bool) (declare-fun z$14628 () Bool) (declare-fun z$5377 () Bool) (declare-fun z$13642 () Bool) (declare-fun z$14660 () Bool) (declare-fun z$14662 () Bool) (declare-fun z$5503 () Bool) (declare-fun z$13645 () Bool) (declare-fun z$14661 () Bool) (declare-fun z$14666 () Bool) (declare-fun z$14632 () Bool) (declare-fun z$14693 () Bool) (declare-fun z$14694 () Bool) (declare-fun z$14728 () Bool) (declare-fun z$14729 () Bool) (declare-fun z$14756 () Bool) (declare-fun z$14757 () Bool) (declare-fun z$14860 () Bool) (declare-fun z$14862 () Bool) (declare-fun z$7344 () Bool) (declare-fun z$6894 () Bool) (declare-fun z$14861 () Bool) (declare-fun z$14867 () Bool) (declare-fun z$6803 () Bool) (declare-fun z$8832 () Bool) (declare-fun z$14891 () Bool) (declare-fun z$14893 () Bool) (declare-fun z$6895 () Bool) (declare-fun z$8834 () Bool) (declare-fun z$14892 () Bool) (declare-fun z$14896 () Bool) (declare-fun z$12280 () Bool) (declare-fun z$8835 () Bool) (declare-fun z$14928 () Bool) (declare-fun z$14930 () Bool) (declare-fun z$8833 () Bool) (declare-fun z$14927 () Bool) (declare-fun z$14929 () Bool) (declare-fun z$14962 () Bool) (declare-fun z$15039 () Bool) (declare-fun z$15041 () Bool) (declare-fun z$14964 () Bool) (declare-fun z$15040 () Bool) (declare-fun z$15047 () Bool) (declare-fun z$13082 () Bool) (declare-fun z$15102 () Bool) (declare-fun z$15103 () Bool) (declare-fun z$12226 () Bool) (declare-fun z$15165 () Bool) (declare-fun z$15167 () Bool) (declare-fun z$12222 () Bool) (declare-fun z$15166 () Bool) (declare-fun z$15170 () Bool) (declare-fun z$2231 () Bool) (declare-fun z$15193 () Bool) (declare-fun z$15194 () Bool) (declare-fun z$9028 () Bool) (declare-fun z$9027 () Bool) (declare-fun z$2164 () Bool) (declare-fun z$15330 () Bool) (declare-fun z$15332 () Bool) (declare-fun z$3503 () Bool) (declare-fun z$15331 () Bool) (declare-fun z$15334 () Bool) (declare-fun z$5045 () Bool) (declare-fun z$5148 () Bool) (declare-fun z$15402 () Bool) (declare-fun z$15404 () Bool) (declare-fun z$15403 () Bool) (declare-fun z$15406 () Bool) (declare-fun z$15538 () Bool) (declare-fun z$15536 () Bool) (declare-fun z$15664 () Bool) (declare-fun z$15701 () Bool) (declare-fun z$15703 () Bool) (declare-fun z$15665 () Bool) (declare-fun z$15702 () Bool) (declare-fun z$15706 () Bool) (declare-fun z$3529 () Bool) (declare-fun z$15756 () Bool) (declare-fun z$15758 () Bool) (declare-fun z$3602 () Bool) (declare-fun z$4215 () Bool) (declare-fun z$15757 () Bool) (declare-fun z$15767 () Bool) (declare-fun z$11325 () Bool) (declare-fun z$15824 () Bool) (declare-fun z$15826 () Bool) (declare-fun z$15823 () Bool) (declare-fun z$15825 () Bool) (declare-fun z$15851 () Bool) (declare-fun z$15852 () Bool) (declare-fun z$15905 () Bool) (declare-fun z$15907 () Bool) (declare-fun z$15906 () Bool) (declare-fun z$15909 () Bool) (declare-fun z$15958 () Bool) (declare-fun z$15960 () Bool) (declare-fun z$15959 () Bool) (declare-fun z$15962 () Bool) (declare-fun z$5199 () Bool) (declare-fun z$15994 () Bool) (declare-fun z$15995 () Bool) (declare-fun z$17451 () Bool) (declare-fun z$17452 () Bool) (declare-fun z$17465 () Bool) (declare-fun z$17466 () Bool) (declare-fun z$17479 () Bool) (declare-fun z$17480 () Bool) (declare-fun z$17487 () Bool) (declare-fun z$17488 () Bool) (declare-fun z$17495 () Bool) (declare-fun z$17496 () Bool) (declare-fun z$17503 () Bool) (declare-fun z$17504 () Bool) (declare-fun z$17521 () Bool) (declare-fun z$17522 () Bool) (declare-fun z$6813 () Bool) (declare-fun z$17538 () Bool) (declare-fun z$17539 () Bool) (declare-fun z$17549 () Bool) (declare-fun z$17550 () Bool) (declare-fun z$17560 () Bool) (declare-fun z$17561 () Bool) (declare-fun z$8939 () Bool) (declare-fun z$17571 () Bool) (declare-fun z$17572 () Bool) (declare-fun z$17583 () Bool) (declare-fun z$17584 () Bool) (declare-fun z$17587 () Bool) (declare-fun z$17596 () Bool) (declare-fun z$17597 () Bool) (declare-fun z$13049 () Bool) (declare-fun z$18120 () Bool) (declare-fun z$18121 () Bool) (declare-fun z$18154 () Bool) (declare-fun z$18156 () Bool) (declare-fun z$18155 () Bool) (declare-fun z$18158 () Bool) (declare-fun z$18167 () Bool) (declare-fun z$18168 () Bool) (declare-fun z$18175 () Bool) (declare-fun z$18176 () Bool) (declare-fun z$18210 () Bool) (declare-fun z$18211 () Bool) (declare-fun z$3370 () Bool) (declare-fun z$18239 () Bool) (declare-fun z$18241 () Bool) (declare-fun z$3253 () Bool) (declare-fun z$18238 () Bool) (declare-fun z$18240 () Bool) (declare-fun z$11149 () Bool) (declare-fun z$18285 () Bool) (declare-fun z$18287 () Bool) (declare-fun z$11148 () Bool) (declare-fun z$18284 () Bool) (declare-fun z$18286 () Bool) (declare-fun z$18299 () Bool) (declare-fun z$18300 () Bool) (declare-fun z$18307 () Bool) (declare-fun z$18308 () Bool) (declare-fun z$18321 () Bool) (declare-fun z$18322 () Bool) (declare-fun z$18332 () Bool) (declare-fun z$18333 () Bool) (declare-fun z$18346 () Bool) (declare-fun z$18347 () Bool) (declare-fun z$18354 () Bool) (declare-fun z$18355 () Bool) (declare-fun z$18399 () Bool) (declare-fun z$18401 () Bool) (declare-fun z$18400 () Bool) (declare-fun z$18403 () Bool) (declare-fun z$18436 () Bool) (declare-fun z$18437 () Bool) (declare-fun z$18444 () Bool) (declare-fun z$18445 () Bool) (declare-fun z$18455 () Bool) (declare-fun z$18456 () Bool) (declare-fun z$8634 () Bool) (declare-fun z$18466 () Bool) (declare-fun z$18467 () Bool) (declare-fun z$8165 () Bool) (declare-fun z$18478 () Bool) (declare-fun z$18479 () Bool) (declare-fun z$18486 () Bool) (declare-fun z$18487 () Bool) (declare-fun z$7310 () Bool) (declare-fun z$18504 () Bool) (declare-fun z$18505 () Bool) (declare-fun z$18512 () Bool) (declare-fun z$18513 () Bool) (declare-fun z$18523 () Bool) (declare-fun z$18524 () Bool) (declare-fun z$18548 () Bool) (declare-fun z$18549 () Bool) (declare-fun z$18556 () Bool) (declare-fun z$18557 () Bool) (declare-fun z$18570 () Bool) (declare-fun z$18571 () Bool) (declare-fun z$18578 () Bool) (declare-fun z$18579 () Bool) (declare-fun z$5583 () Bool) (declare-fun z$18586 () Bool) (declare-fun z$18587 () Bool) (declare-fun z$18616 () Bool) (declare-fun z$18617 () Bool) (declare-fun z$18627 () Bool) (declare-fun z$18628 () Bool) (declare-fun z$18638 () Bool) (declare-fun z$18639 () Bool) (declare-fun z$18646 () Bool) (declare-fun z$18647 () Bool) (declare-fun z$18657 () Bool) (declare-fun z$18658 () Bool) (declare-fun z$18668 () Bool) (declare-fun z$18669 () Bool) (declare-fun z$11819 () Bool) (declare-fun z$18679 () Bool) (declare-fun z$18680 () Bool) (declare-fun z$6047 () Bool) (declare-fun z$18690 () Bool) (declare-fun z$18691 () Bool) (declare-fun z$18705 () Bool) (declare-fun z$18706 () Bool) (declare-fun z$18713 () Bool) (declare-fun z$18714 () Bool) (declare-fun z$18727 () Bool) (declare-fun z$18728 () Bool) (declare-fun z$18735 () Bool) (declare-fun z$18736 () Bool) (declare-fun z$18746 () Bool) (declare-fun z$18747 () Bool) (declare-fun z$18760 () Bool) (declare-fun z$18761 () Bool) (declare-fun z$9269 () Bool) (declare-fun z$9270 () Bool) (declare-fun z$18773 () Bool) (declare-fun z$18774 () Bool) (declare-fun z$13903 () Bool) (declare-fun z$13904 () Bool) (declare-fun z$13911 () Bool) (declare-fun z$13912 () Bool) (declare-fun z$18791 () Bool) (declare-fun z$18792 () Bool) (declare-fun z$18840 () Bool) (declare-fun z$18841 () Bool) (declare-fun z$18881 () Bool) (declare-fun z$18882 () Bool) (declare-fun z$18889 () Bool) (declare-fun z$18890 () Bool) (declare-fun z$18903 () Bool) (declare-fun z$18904 () Bool) (declare-fun z$18911 () Bool) (declare-fun z$18912 () Bool) (declare-fun z$18919 () Bool) (declare-fun z$18920 () Bool) (declare-fun z$11275 () Bool) (declare-fun z$19161 () Bool) (declare-fun z$19162 () Bool) (declare-fun z$19184 () Bool) (declare-fun z$19185 () Bool) (declare-fun z$19195 () Bool) (declare-fun z$19196 () Bool) (declare-fun z$19203 () Bool) (declare-fun z$19204 () Bool) (declare-fun z$19211 () Bool) (declare-fun z$19212 () Bool) (declare-fun z$19219 () Bool) (declare-fun z$19220 () Bool) (declare-fun z$19230 () Bool) (declare-fun z$19231 () Bool) (declare-fun z$10017 () Bool) (declare-fun z$19241 () Bool) (declare-fun z$19250 () Bool) (declare-fun z$19251 () Bool) (declare-fun z$19263 () Bool) (declare-fun z$19264 () Bool) (declare-fun z$5401 () Bool) (declare-fun z$19274 () Bool) (declare-fun z$19275 () Bool) (declare-fun z$19285 () Bool) (declare-fun z$19286 () Bool) (declare-fun z$11337 () Bool) (declare-fun z$19310 () Bool) (declare-fun z$19311 () Bool) (declare-fun z$16456 () Bool) (declare-fun z$19319 () Bool) (declare-fun z$19320 () Bool) (declare-fun z$19331 () Bool) (declare-fun z$19332 () Bool) (declare-fun z$19339 () Bool) (declare-fun z$19340 () Bool) (declare-fun z$19378 () Bool) (declare-fun z$19379 () Bool) (declare-fun z$9049 () Bool) (declare-fun z$19386 () Bool) (declare-fun z$19387 () Bool) (declare-fun z$19397 () Bool) (declare-fun z$19398 () Bool) (declare-fun z$19408 () Bool) (declare-fun z$19409 () Bool) (declare-fun z$19422 () Bool) (declare-fun z$19423 () Bool) (declare-fun z$19430 () Bool) (declare-fun z$19431 () Bool) (declare-fun z$19438 () Bool) (declare-fun z$19439 () Bool) (declare-fun z$19446 () Bool) (declare-fun z$19447 () Bool) (declare-fun z$19490 () Bool) (declare-fun z$19491 () Bool) (declare-fun z$19613 () Bool) (declare-fun z$19614 () Bool) (declare-fun z$19635 () Bool) (declare-fun z$19636 () Bool) (declare-fun z$12678 () Bool) (declare-fun z$19646 () Bool) (declare-fun z$19647 () Bool) (declare-fun z$19654 () Bool) (declare-fun z$19655 () Bool) (declare-fun z$19662 () Bool) (declare-fun z$19663 () Bool) (declare-fun z$12679 () Bool) (declare-fun z$19670 () Bool) (declare-fun z$19671 () Bool) (declare-fun z$19685 () Bool) (declare-fun z$19686 () Bool) (declare-fun z$19693 () Bool) (declare-fun z$19694 () Bool) (declare-fun z$5657 () Bool) (declare-fun z$19704 () Bool) (declare-fun z$19705 () Bool) (declare-fun z$19722 () Bool) (declare-fun z$19723 () Bool) (declare-fun z$12076 () Bool) (declare-fun z$19737 () Bool) (declare-fun z$19738 () Bool) (declare-fun z$19745 () Bool) (declare-fun z$19746 () Bool) (declare-fun z$12052 () Bool) (declare-fun z$19759 () Bool) (declare-fun z$19760 () Bool) (declare-fun z$19768 () Bool) (declare-fun z$19769 () Bool) (declare-fun z$19776 () Bool) (declare-fun z$19777 () Bool) (declare-fun z$19784 () Bool) (declare-fun z$19785 () Bool) (declare-fun z$19795 () Bool) (declare-fun z$19796 () Bool) (declare-fun z$19809 () Bool) (declare-fun z$19810 () Bool) (declare-fun z$14059 () Bool) (declare-fun z$14060 () Bool) (declare-fun z$14067 () Bool) (declare-fun z$14068 () Bool) (declare-fun z$19827 () Bool) (declare-fun z$19828 () Bool) (declare-fun z$19853 () Bool) (declare-fun z$19854 () Bool) (declare-fun z$19861 () Bool) (declare-fun z$19862 () Bool) (declare-fun z$19872 () Bool) (declare-fun z$19873 () Bool) (declare-fun z$19885 () Bool) (declare-fun z$19886 () Bool) (declare-fun z$19896 () Bool) (declare-fun z$19897 () Bool) (declare-fun z$19904 () Bool) (declare-fun z$19905 () Bool) (declare-fun z$19921 () Bool) (declare-fun z$19922 () Bool) (declare-fun z$19929 () Bool) (declare-fun z$19930 () Bool) (declare-fun z$19940 () Bool) (declare-fun z$19941 () Bool) (declare-fun z$19965 () Bool) (declare-fun z$19966 () Bool) (declare-fun z$19973 () Bool) (declare-fun z$19974 () Bool) (declare-fun z$19984 () Bool) (declare-fun z$19985 () Bool) (declare-fun z$19998 () Bool) (declare-fun z$19999 () Bool) (declare-fun z$20006 () Bool) (declare-fun z$20007 () Bool) (declare-fun z$20014 () Bool) (declare-fun z$20015 () Bool) (declare-fun z$20025 () Bool) (declare-fun z$20026 () Bool) (declare-fun z$20033 () Bool) (declare-fun z$20034 () Bool) (declare-fun z$6275 () Bool) (declare-fun z$20044 () Bool) (declare-fun z$20045 () Bool) (declare-fun z$20066 () Bool) (declare-fun z$20067 () Bool) (declare-fun z$20054 () Bool) (declare-fun z$20074 () Bool) (declare-fun z$20075 () Bool) (declare-fun z$7030 () Bool) (declare-fun z$20083 () Bool) (declare-fun z$20084 () Bool) (declare-fun z$7500 () Bool) (declare-fun z$13048 () Bool) (declare-fun z$20098 () Bool) (declare-fun z$20099 () Bool) (declare-fun z$14273 () Bool) (declare-fun z$20108 () Bool) (declare-fun z$20109 () Bool) (declare-fun z$20126 () Bool) (declare-fun z$20127 () Bool) (declare-fun z$20134 () Bool) (declare-fun z$20135 () Bool) (declare-fun z$20142 () Bool) (declare-fun z$20143 () Bool) (declare-fun z$20156 () Bool) (declare-fun z$20157 () Bool) (declare-fun z$2276 () Bool) (declare-fun z$20047 () Bool) (declare-fun z$20164 () Bool) (declare-fun z$20165 () Bool) (declare-fun z$20185 () Bool) (declare-fun z$20186 () Bool) (declare-fun z$20207 () Bool) (declare-fun z$20208 () Bool) (declare-fun z$20218 () Bool) (declare-fun z$20219 () Bool) (declare-fun z$20229 () Bool) (declare-fun z$20230 () Bool) (declare-fun z$20237 () Bool) (declare-fun z$20238 () Bool) (declare-fun z$20245 () Bool) (declare-fun z$20246 () Bool) (declare-fun z$20253 () Bool) (declare-fun z$20254 () Bool) (declare-fun z$20264 () Bool) (declare-fun z$20265 () Bool) (declare-fun z$20278 () Bool) (declare-fun z$20279 () Bool) (declare-fun z$14272 () Bool) (declare-fun z$20286 () Bool) (declare-fun z$20287 () Bool) (declare-fun z$20301 () Bool) (declare-fun z$20302 () Bool) (declare-fun z$20309 () Bool) (declare-fun z$20310 () Bool) (declare-fun z$20323 () Bool) (declare-fun z$20324 () Bool) (declare-fun z$20331 () Bool) (declare-fun z$20332 () Bool) (declare-fun z$20348 () Bool) (declare-fun z$20349 () Bool) (declare-fun z$20356 () Bool) (declare-fun z$20357 () Bool) (declare-fun z$20364 () Bool) (declare-fun z$20365 () Bool) (declare-fun z$20372 () Bool) (declare-fun z$20373 () Bool) (declare-fun z$20380 () Bool) (declare-fun z$20381 () Bool) (declare-fun z$20391 () Bool) (declare-fun z$20392 () Bool) (declare-fun z$20416 () Bool) (declare-fun z$20417 () Bool) (declare-fun z$20427 () Bool) (declare-fun z$20428 () Bool) (declare-fun z$9550 () Bool) (declare-fun z$20438 () Bool) (declare-fun z$20439 () Bool) (declare-fun z$20450 () Bool) (declare-fun z$20451 () Bool) (declare-fun z$20464 () Bool) (declare-fun z$20465 () Bool) (declare-fun z$20472 () Bool) (declare-fun z$20473 () Bool) (declare-fun z$5784 () Bool) (declare-fun z$20483 () Bool) (declare-fun z$20484 () Bool) (declare-fun z$9562 () Bool) (declare-fun z$20495 () Bool) (declare-fun z$20496 () Bool) (declare-fun z$20510 () Bool) (declare-fun z$20511 () Bool) (declare-fun z$20518 () Bool) (declare-fun z$20519 () Bool) (declare-fun z$20526 () Bool) (declare-fun z$20527 () Bool) (declare-fun z$2251 () Bool) (declare-fun z$2892 () Bool) (declare-fun z$20534 () Bool) (declare-fun z$20535 () Bool) (declare-fun z$20545 () Bool) (declare-fun z$20546 () Bool) (declare-fun z$20562 () Bool) (declare-fun z$20563 () Bool) (declare-fun z$20570 () Bool) (declare-fun z$20571 () Bool) (declare-fun z$20578 () Bool) (declare-fun z$20579 () Bool) (declare-fun z$20589 () Bool) (declare-fun z$20590 () Bool) (declare-fun z$20609 () Bool) (declare-fun z$20610 () Bool) (declare-fun z$20617 () Bool) (declare-fun z$20618 () Bool) (declare-fun z$20625 () Bool) (declare-fun z$20626 () Bool) (declare-fun z$20633 () Bool) (declare-fun z$20634 () Bool) (declare-fun z$20644 () Bool) (declare-fun z$20645 () Bool) (declare-fun z$20658 () Bool) (declare-fun z$20659 () Bool) (declare-fun z$20666 () Bool) (declare-fun z$20667 () Bool) (declare-fun z$20698 () Bool) (declare-fun z$20699 () Bool) (declare-fun z$20706 () Bool) (declare-fun z$20707 () Bool) (declare-fun z$20714 () Bool) (declare-fun z$20715 () Bool) (declare-fun z$20722 () Bool) (declare-fun z$20723 () Bool) (declare-fun z$20730 () Bool) (declare-fun z$20731 () Bool) (declare-fun z$20738 () Bool) (declare-fun z$20739 () Bool) (declare-fun z$20758 () Bool) (declare-fun z$20759 () Bool) (declare-fun z$20766 () Bool) (declare-fun z$20767 () Bool) (declare-fun z$20774 () Bool) (declare-fun z$20775 () Bool) (declare-fun z$20782 () Bool) (declare-fun z$20783 () Bool) (declare-fun z$20804 () Bool) (declare-fun z$20805 () Bool) (declare-fun z$20812 () Bool) (declare-fun z$20813 () Bool) (declare-fun z$20823 () Bool) (declare-fun z$20824 () Bool) (declare-fun z$20831 () Bool) (declare-fun z$20832 () Bool) (declare-fun z$20853 () Bool) (declare-fun z$20854 () Bool) (declare-fun z$20861 () Bool) (declare-fun z$20862 () Bool) (declare-fun z$20869 () Bool) (declare-fun z$20870 () Bool) (declare-fun z$20883 () Bool) (declare-fun z$20884 () Bool) (declare-fun z$20891 () Bool) (declare-fun z$20892 () Bool) (declare-fun z$20899 () Bool) (declare-fun z$20900 () Bool) (declare-fun z$20907 () Bool) (declare-fun z$20908 () Bool) (declare-fun z$20929 () Bool) (declare-fun z$20930 () Bool) (declare-fun z$20937 () Bool) (declare-fun z$20938 () Bool) (declare-fun z$20945 () Bool) (declare-fun z$20946 () Bool) (declare-fun z$20953 () Bool) (declare-fun z$20954 () Bool) (declare-fun z$20971 () Bool) (declare-fun z$20972 () Bool) (declare-fun z$20979 () Bool) (declare-fun z$20980 () Bool) (declare-fun z$20990 () Bool) (declare-fun z$20991 () Bool) (declare-fun z$21004 () Bool) (declare-fun z$21005 () Bool) (declare-fun z$21015 () Bool) (declare-fun z$21016 () Bool) (declare-fun z$21029 () Bool) (declare-fun z$21030 () Bool) (declare-fun z$21037 () Bool) (declare-fun z$21038 () Bool) (declare-fun z$21045 () Bool) (declare-fun z$21046 () Bool) (declare-fun z$21053 () Bool) (declare-fun z$21054 () Bool) (declare-fun z$21073 () Bool) (declare-fun z$21074 () Bool) (declare-fun z$21081 () Bool) (declare-fun z$21082 () Bool) (declare-fun z$21089 () Bool) (declare-fun z$21090 () Bool) (declare-fun z$21097 () Bool) (declare-fun z$21098 () Bool) (declare-fun z$21118 () Bool) (declare-fun z$21119 () Bool) (declare-fun z$21126 () Bool) (declare-fun z$21127 () Bool) (declare-fun z$21134 () Bool) (declare-fun z$21135 () Bool) (declare-fun z$21152 () Bool) (declare-fun z$21153 () Bool) (declare-fun z$21160 () Bool) (declare-fun z$21161 () Bool) (declare-fun z$21174 () Bool) (declare-fun z$21175 () Bool) (declare-fun z$21182 () Bool) (declare-fun z$21183 () Bool) (declare-fun z$9293 () Bool) (declare-fun z$12941 () Bool) (declare-fun z$21200 () Bool) (declare-fun z$21201 () Bool) (declare-fun z$21213 () Bool) (declare-fun z$21214 () Bool) (declare-fun z$21221 () Bool) (declare-fun z$21222 () Bool) (declare-fun z$21232 () Bool) (declare-fun z$21233 () Bool) (declare-fun z$21240 () Bool) (declare-fun z$21241 () Bool) (declare-fun z$21257 () Bool) (declare-fun z$21258 () Bool) (declare-fun z$21265 () Bool) (declare-fun z$21266 () Bool) (declare-fun z$21281 () Bool) (declare-fun z$21282 () Bool) (declare-fun z$21289 () Bool) (declare-fun z$21290 () Bool) (declare-fun z$21297 () Bool) (declare-fun z$21298 () Bool) (declare-fun z$21315 () Bool) (declare-fun z$21316 () Bool) (declare-fun z$21326 () Bool) (declare-fun z$21327 () Bool) (declare-fun z$21340 () Bool) (declare-fun z$21341 () Bool) (declare-fun z$21353 () Bool) (declare-fun z$21354 () Bool) (declare-fun z$21364 () Bool) (declare-fun z$21365 () Bool) (declare-fun z$21372 () Bool) (declare-fun z$21373 () Bool) (declare-fun z$21383 () Bool) (declare-fun z$21384 () Bool) (declare-fun z$21404 () Bool) (declare-fun z$21405 () Bool) (declare-fun z$21415 () Bool) (declare-fun z$21416 () Bool) (declare-fun z$21426 () Bool) (declare-fun z$21427 () Bool) (declare-fun z$21439 () Bool) (declare-fun z$21440 () Bool) (declare-fun z$21447 () Bool) (declare-fun z$21448 () Bool) (declare-fun z$21468 () Bool) (declare-fun z$21469 () Bool) (declare-fun z$21476 () Bool) (declare-fun z$21477 () Bool) (declare-fun z$21484 () Bool) (declare-fun z$21485 () Bool) (declare-fun z$21492 () Bool) (declare-fun z$21493 () Bool) (declare-fun z$21508 () Bool) (declare-fun z$21509 () Bool) (declare-fun z$21516 () Bool) (declare-fun z$21517 () Bool) (declare-fun z$21527 () Bool) (declare-fun z$21528 () Bool) (declare-fun z$21538 () Bool) (declare-fun z$21539 () Bool) (declare-fun z$21552 () Bool) (declare-fun z$21553 () Bool) (declare-fun z$21560 () Bool) (declare-fun z$21561 () Bool) (declare-fun z$17182 () Bool) (declare-fun z$21571 () Bool) (declare-fun z$21572 () Bool) (declare-fun z$21583 () Bool) (declare-fun z$21584 () Bool) (declare-fun z$6996 () Bool) (declare-fun z$21594 () Bool) (declare-fun z$21595 () Bool) (declare-fun z$21606 () Bool) (declare-fun z$21607 () Bool) (declare-fun z$21620 () Bool) (declare-fun z$21621 () Bool) (declare-fun z$21628 () Bool) (declare-fun z$21629 () Bool) (declare-fun z$21642 () Bool) (declare-fun z$21643 () Bool) (declare-fun z$21650 () Bool) (declare-fun z$21651 () Bool) (declare-fun z$21664 () Bool) (declare-fun z$21665 () Bool) (declare-fun z$21672 () Bool) (declare-fun z$21673 () Bool) (declare-fun z$13520 () Bool) (declare-fun z$21683 () Bool) (declare-fun z$21684 () Bool) (declare-fun z$21695 () Bool) (declare-fun z$21696 () Bool) (declare-fun z$21706 () Bool) (declare-fun z$21707 () Bool) (declare-fun z$21725 () Bool) (declare-fun z$21726 () Bool) (declare-fun z$21739 () Bool) (declare-fun z$21740 () Bool) (declare-fun z$21747 () Bool) (declare-fun z$21748 () Bool) (declare-fun z$21761 () Bool) (declare-fun z$21762 () Bool) (declare-fun z$21769 () Bool) (declare-fun z$21770 () Bool) (declare-fun z$21777 () Bool) (declare-fun z$21778 () Bool) (declare-fun z$21800 () Bool) (declare-fun z$21801 () Bool) (declare-fun z$21808 () Bool) (declare-fun z$21809 () Bool) (declare-fun z$21816 () Bool) (declare-fun z$21817 () Bool) (declare-fun z$21824 () Bool) (declare-fun z$21825 () Bool) (declare-fun z$21832 () Bool) (declare-fun z$21833 () Bool) (declare-fun z$21843 () Bool) (declare-fun z$21844 () Bool) (declare-fun z$21854 () Bool) (declare-fun z$21855 () Bool) (declare-fun z$2679 () Bool) (declare-fun z$21862 () Bool) (declare-fun z$21863 () Bool) (declare-fun z$16915 () Bool) (declare-fun z$21874 () Bool) (declare-fun z$21875 () Bool) (declare-fun z$6273 () Bool) (declare-fun z$21886 () Bool) (declare-fun z$21887 () Bool) (declare-fun z$21898 () Bool) (declare-fun z$21899 () Bool) (declare-fun z$21909 () Bool) (declare-fun z$21910 () Bool) (declare-fun z$21920 () Bool) (declare-fun z$21921 () Bool) (declare-fun z$5783 () Bool) (declare-fun z$21931 () Bool) (declare-fun z$21932 () Bool) (declare-fun z$21948 () Bool) (declare-fun z$21949 () Bool) (declare-fun z$21956 () Bool) (declare-fun z$21957 () Bool) (declare-fun z$21969 () Bool) (declare-fun z$21970 () Bool) (declare-fun z$21983 () Bool) (declare-fun z$21984 () Bool) (declare-fun z$21999 () Bool) (declare-fun p$0 () Bool) (declare-fun p$1 () Bool) (declare-fun p$2 () Bool) (declare-fun p$3 () Bool) (declare-fun p$4 () Bool) (declare-fun p$5 () Bool) (declare-fun p$6 () Bool) (declare-fun z$2180 () Bool) (declare-fun p$7 () Bool) (declare-fun z$2186 () Bool) (declare-fun p$8 () Bool) (declare-fun p$9 () Bool) (declare-fun p$10 () Bool) (declare-fun z$2712 () Bool) (declare-fun p$11 () Bool) (declare-fun p$12 () Bool) (declare-fun p$13 () Bool) (declare-fun z$2687 () Bool) (declare-fun z$5839 () Bool) (declare-fun p$14 () Bool) (declare-fun z$7440 () Bool) (declare-fun p$15 () Bool) (declare-fun z$9563 () Bool) (assert (and (distinct z$n0s8 z$n1s8 z$n3s8) true)) (assert (and (distinct z$n0s16 z$n3s16 z$n30s16 z$n31s16 z$n5s16 z$n1s16 z$n29s16 z$n32s16 z$n63s16 z$n2s16 z$n28s16) true)) (assert (and (distinct z$n16s32 z$n1s32 z$n0s32 z$n4s32 z$n2s32 z$n30s32 z$n5s32 z$n3s32 z$n6s32 z$n4294639615s32 z$n327680s32 z$n65535s32 z$n4294901760s32 z$n4294901763s32 z$n65532s32 z$n196608s32 z$n31s32 z$n4293066751s32 z$n4294967295s32 z$n4294901765s32 z$n1966080s32 z$n65530s32 z$n4294770687s32 z$n4292870143s32 z$n4294901791s32 z$n65505s32 z$n65504s32 z$n4294901790s32 z$n2031616s32 z$n4292935679s32 z$n4294901789s32 z$n4294901761s32 z$n4293001215s32 z$n4294901759s32 z$n65506s32 z$n65536s32 z$n29s32 z$n65534s32 z$n131072s32 z$n4294901792s32 z$n1900544s32 z$n65507s32 z$n65503s32 z$n28s32 z$n32s32 z$n2097152s32 z$n4294901762s32 z$n4294836223s32 z$n65533s32 z$n4294901788s32 z$n4293132287s32 z$n1835008s32) true)) (assert (let (($x239 (not a_dk))) (= z$5 $x239))) (assert (let (($x246 (not a_file_req))) (= z$9 $x246))) (assert (let (($x266 (not a_idle_Sender))) (= z$19 $x266))) (assert (let (($x297 (not a_nok_SClient))) (= z$35 $x297))) (assert (let (($x309 (not a_send_req))) (= z$41 $x309))) (assert (= z$2648 (and z$5 a_error z$9 z$19 z$35 z$41))) (assert (= z$2649 (not z$2648))) (assert (let (($x289 (not a_next_frame))) (= z$31 $x289))) (assert (let (($x321 (not a_success))) (= z$47 $x321))) (assert (let (($x329 (not a_wait_ack))) (= z$51 $x329))) (assert (= z$53 (not dve_invalid))) (assert (= z$3007 (and a_file_req z$19 a_init_state z$31 z$47 z$51 z$53))) (assert (= z$3008 (not z$3007))) (assert (= z$2996 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53))) (assert (= z$2997 (not z$2996))) (assert (let (($x231 (not a_BAD_K))) (= z$1 $x231))) (assert (= z$3446 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53))) (assert (= z$3447 (not z$3446))) (assert (let (($x317 (not a_start_L))) (= z$45 $x317))) (assert (let (($x2070 (= z$n3s8 v_rc))) (= z$1055 $x2070))) (assert (= z$2363 (and (distinct v_X z$n0s16) true))) (assert (let (($x18307 (and a_file_req a_idle_Receiver a_in_transit_K z$45 a_wait_ack z$53 z$1055 z$2363))) (= z$7057 $x18307))) (assert (= z$7058 (not z$7057))) (assert (let (($x371 (= v_n z$n0s16))) (= z$77 $x371))) (assert (let (($x17707 (= v_i z$n3s8))) (= z$7877 $x17707))) (assert (= z$7946 (and z$1 a_file_req a_wait_ack z$53 z$1055 z$2363 z$7877))) (assert (= z$7947 (not z$7946))) (assert (let (($x29850 (and a_file_req a_first_safe_frame a_wait_ack z$53 z$1055 z$2363 z$7877))) (= z$8027 $x29850))) (assert (= z$8028 (not z$8027))) (assert (let (($x313 (not a_start_K))) (= z$43 $x313))) (assert (= z$8469 (and a_file_req z$43 a_wait_ack z$53 z$1055 z$2363))) (assert (= z$8470 (not z$8469))) (assert (let ((?x84 (BitWiseXor_16_16_16 z$n30s16 v_SYNC))) (= z$94 ?x84))) (assert (let ((?x389 (BitWiseXor_16_16_16 z$n30s16 z$94))) (= z$96 ?x389))) (assert (= z$2373 (and (distinct z$96 z$n30s16) true))) (assert (= z$2369 (and (distinct z$94 z$n0s16) true))) (assert (= z$2371 (and (distinct v_SYNC z$n30s16) true))) (assert (let (($x75455 (and z$19 a_init_state a_new_file z$31 a_send_req z$47 z$51 z$53))) (= z$9006 $x75455))) (assert (= z$9007 (not z$9006))) (assert (let (($x6448 (and z$1 z$19 a_init_state z$31 a_send_req z$47 z$51 z$53))) (= z$3774 $x6448))) (assert (= z$3775 (not z$3774))) (assert (= z$3783 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$2363))) (assert (= z$3784 (not z$3783))) (assert (let (($x47841 (and a_BAD_L z$19 a_init_state a_new_file z$31 z$47 z$51 z$53))) (= z$9487 $x47841))) (assert (= z$9488 (not z$9487))) (assert (let (($x250 (not a_first_safe_frame))) (= z$11 $x250))) (assert (let (($x254 (not a_frame_received))) (= z$13 $x254))) (assert (let (($x258 (not a_frame_reported))) (= z$15 $x258))) (assert (= z$2659 (and (distinct v_V z$n0s16) true))) (assert (let (($x77949 (= v_X v_V))) (= z$7446 $x77949))) (assert (let (($x59991 (and a_file_req z$11 z$13 z$15 a_new_file a_wait_ack z$53 z$1055 z$2659 z$7446))) (= z$9654 $x59991))) (assert (= z$9655 (not z$9654))) (assert (let (($x43403 (and z$11 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53))) (= z$9920 $x43403))) (assert (= z$9921 (not z$9920))) (assert (= z$5352 (and (distinct v_Z z$n0s16) true))) (assert (= z$7249 (and (distinct v_W v_Z) true))) (assert (let (($x80750 (= v_X v_Z))) (= z$9055 $x80750))) (assert (let (($x61979 (and a_BAD_K a_file_req a_new_file z$31 z$53 z$1055 z$5352 z$7249 z$9055))) (= z$10160 $x61979))) (assert (= z$10161 (not z$10160))) (assert (let (($x262 (not a_idle_Receiver))) (= z$17 $x262))) (assert (let ((?x59 (Concat_32_16_16 z$n0s16 v_X))) (= z$116 ?x59))) (assert (let ((?x75 (ShiftR_32_32_32 z$116 z$n16s32))) (= z$2243 ?x75))) (assert (let (($x48692 (= z$n5s32 z$2243))) (= z$2465 $x48692))) (assert (let (($x75651 (and a_BAD_K a_file_req z$17 a_new_file z$31 z$53 z$1055 z$2465 z$7249))) (= z$10171 $x75651))) (assert (= z$10172 (not z$10171))) (assert (let (($x55 (Extract_1_15_15_16 v_X))) (= z$114 $x55))) (assert (let ((?x63 (BitWiseNot_32_32 z$116))) (= z$118 ?x63))) (assert (let ((?x67 (ShiftR_32_32_32 z$118 z$n16s32))) (= z$121 ?x67))) (assert (let ((?x71 (BitWiseNot_32_32 z$121))) (= z$123 ?x71))) (assert (let ((?x75 (ShiftR_32_32_32 z$116 z$n16s32))) (= z$125 ?x75))) (assert (let ((?x79 (ite z$114 z$123 z$125))) (= z$127 ?x79))) (assert (let ((?x1512 (Add_32_32_32 z$n1s32 z$127))) (= z$855 ?x1512))) (assert (let (($x1516 (GrEq_1_32_32 z$n0s32 z$855))) (= z$857 $x1516))) (assert (= z$859 (not z$857))) (assert (let (($x83999 (not z$114))) (= z$2160 $x83999))) (assert (= z$7112 (and (distinct v_X v_W) true))) (assert (let (($x46192 (and a_BAD_K a_file_req a_new_file a_wait_ack z$53 z$859 z$1055 z$2160 z$2465 z$7112))) (= z$10295 $x46192))) (assert (= z$10296 (not z$10295))) (assert (= z$6792 (and (distinct v_W v_V) true))) (assert (let (($x75881 (and a_BAD_K a_file_req a_new_file a_wait_ack z$53 z$1055 z$2465 z$6792 z$7112))) (= z$10499 $x75881))) (assert (= z$10500 (not z$10499))) (assert (let (($x270 (not a_in_transit_K))) (= z$21 $x270))) (assert (let (($x12358 (= z$125 z$n5s32))) (= z$2501 $x12358))) (assert (let (($x38498 (and a_file_req z$21 a_new_file a_start_L a_wait_ack z$53 z$1055 z$2501))) (= z$10638 $x38498))) (assert (= z$10639 (not z$10638))) (assert (let (($x1394 (Extract_1_15_15_16 v_W))) (= z$237 $x1394))) (assert (let (($x35590 (not z$237))) (= z$2167 $x35590))) (assert (let (($x31997 (and a_BAD_K z$19 a_init_state a_new_file z$31 a_start_L z$47 z$51 z$53 z$2167 z$6792))) (= z$10646 $x31997))) (assert (= z$10647 (not z$10646))) (assert (let (($x75943 (and a_BAD_K a_file_req a_new_file z$31 z$53 z$1055 z$2501))) (= z$10846 $x75943))) (assert (= z$10847 (not z$10846))) (assert (let (($x7188 (and a_BAD_K a_file_req a_new_file z$31 z$53 z$1055 z$2363))) (= z$5307 $x7188))) (assert (= z$5308 (not z$5307))) (assert (= z$10873 (and z$19 a_init_state z$31 z$43 z$47 z$51 z$53))) (assert (= z$10874 (not z$10873))) (assert (= z$2745 (and (distinct v_X v_U) true))) (assert (= z$10902 (and z$1 a_file_req a_wait_ack z$53 z$1055 z$2745))) (assert (= z$10903 (not z$10902))) (assert (let (($x332 (= v_SYNC z$n0s16))) (= z$56 $x332))) (assert (let ((?x92 (Concat_32_16_16 z$n0s16 z$94))) (= z$881 ?x92))) (assert (let (($x83832 (= z$881 z$n0s32))) (= z$8873 $x83832))) (assert (= z$11707 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$8873))) (assert (= z$11708 (not z$11707))) (assert (let (($x9950 (= v_X z$n30s16))) (= z$11085 $x9950))) (assert (= z$11719 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$11085))) (assert (= z$11720 (not z$11719))) (assert (let (($x38920 (and z$11 z$19 a_init_state a_new_file z$31 a_send_req z$47 z$51 z$53))) (= z$11730 $x38920))) (assert (= z$11731 (not z$11730))) (assert (= z$11763 (and z$19 a_init_state z$31 z$43 z$47 z$51 z$53 z$2363))) (assert (= z$11764 (not z$11763))) (assert (let (($x344 (= v_W z$n0s16))) (= z$62 $x344))) (assert (let ((?x1398 (Concat_32_16_16 z$n0s16 v_W))) (= z$239 ?x1398))) (assert (= z$6802 (and (distinct z$239 z$n0s32) true))) (assert (let (($x75647 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$62 z$6802))) (= z$11774 $x75647))) (assert (= z$11775 (not z$11774))) (assert (= z$2670 (and (distinct z$125 z$n0s32) true))) (assert (let (($x41861 (= z$116 z$n0s32))) (= z$8811 $x41861))) (assert (let (($x79341 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$2670 z$8811))) (= z$11786 $x79341))) (assert (= z$11787 (not z$11786))) (assert (= z$10193 (and (distinct v_U v_W) true))) (assert (let (($x74940 (and a_file_req a_new_file a_wait_ack z$53 z$859 z$1055 z$2160 z$2465 z$10193))) (= z$11809 $x74940))) (assert (= z$11810 (not z$11809))) (assert (let (($x17352 (and a_file_req a_new_file z$31 a_start_K z$53 z$1055 z$2501 z$7249))) (= z$11838 $x17352))) (assert (= z$11839 (not z$11838))) (assert (let (($x1581 (Extract_1_15_15_16 v_U))) (= z$171 $x1581))) (assert (let (($x80872 (not z$171))) (= z$2165 $x80872))) (assert (= z$5770 (and (distinct v_Z v_V) true))) (assert (let (($x74974 (= v_V v_W))) (= z$7424 $x74974))) (assert (let (($x8573 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2165 z$5770 z$7424))) (= z$11846 $x8573))) (assert (= z$11847 (not z$11846))) (assert (let (($x8476 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2165 z$7249))) (= z$11859 $x8476))) (assert (= z$11860 (not z$11859))) (assert (let ((?x1585 (Concat_32_16_16 z$n0s16 v_U))) (= z$173 ?x1585))) (assert (let ((?x1601 (ShiftR_32_32_32 z$173 z$n16s32))) (= z$181 ?x1601))) (assert (let ((?x1589 (BitWiseNot_32_32 z$173))) (= z$175 ?x1589))) (assert (let ((?x1593 (ShiftR_32_32_32 z$175 z$n16s32))) (= z$177 ?x1593))) (assert (let ((?x1597 (BitWiseNot_32_32 z$177))) (= z$179 ?x1597))) (assert (let (($x82416 (= z$181 z$179))) (= z$11865 $x82416))) (assert (let (($x55549 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$7249 z$11865))) (= z$11875 $x55549))) (assert (= z$11876 (not z$11875))) (assert (let (($x33124 (and a_file_req a_new_file z$31 a_start_K z$53 z$114 z$1055 z$7249))) (= z$11891 $x33124))) (assert (= z$11892 (not z$11891))) (assert (let (($x46681 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$7249))) (= z$11899 $x46681))) (assert (= z$11900 (not z$11899))) (assert (let (($x78806 (and a_file_req a_new_file a_wait_ack z$53 z$1055 z$2465 z$6792 z$10193))) (= z$11973 $x78806))) (assert (= z$11974 (not z$11973))) (assert (let (($x42394 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$6792 z$10193))) (= z$11981 $x42394))) (assert (= z$11982 (not z$11981))) (assert (= z$12343 (and a_file_req a_new_file a_wait_ack z$53 z$114 z$1055))) (assert (= z$12344 (not z$12343))) (assert (let (($x74774 (= v_U v_W))) (= z$10445 $x74774))) (assert (let (($x69107 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$237 z$10445))) (= z$12351 $x69107))) (assert (= z$12352 (not z$12351))) (assert (let (($x70518 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$171))) (= z$12363 $x70518))) (assert (= z$12364 (not z$12363))) (assert (= z$2746 (and (distinct v_U z$n0s16) true))) (assert (let (($x68142 (and a_file_req a_in_transit_K a_new_file a_wait_ack z$53 z$1055 z$2746))) (= z$12377 $x68142))) (assert (= z$12378 (not z$12377))) (assert (let (($x23075 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363))) (= z$9036 $x23075))) (assert (= z$9037 (not z$9036))) (assert (= z$6976 (and a_file_req a_new_file a_wait_ack z$53 z$1055 z$2363))) (assert (= z$6977 (not z$6976))) (assert (let (($x68725 (and z$1 z$5 z$19 a_init_state z$31 z$35 z$47 z$51 z$53 z$2363))) (= z$12430 $x68725))) (assert (= z$12431 (not z$12430))) (assert (let ((?x1605 (ite z$171 z$179 z$181))) (= z$183 ?x1605))) (assert (let (($x1886 (GrEq_1_32_32 z$n0s32 z$183))) (= z$988 $x1886))) (assert (let (($x1890 (not z$988))) (= z$990 $x1890))) (assert (= z$2760 (and (distinct z$181 z$n2s32) true))) (assert (let (($x46505 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$990 z$2165 z$2760 z$11085))) (= z$13626 $x46505))) (assert (= z$13627 (not z$13626))) (assert (let (($x351 (= v_Z z$n0s16))) (= z$66 $x351))) (assert (let ((?x1466 (Concat_32_16_16 z$n0s16 v_Z))) (= z$271 ?x1466))) (assert (let ((?x1482 (ShiftR_32_32_32 z$271 z$n16s32))) (= z$279 ?x1482))) (assert (= z$5421 (and (distinct z$271 z$279) true))) (assert (let (($x38287 (and z$11 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$66 z$5421))) (= z$13639 $x38287))) (assert (= z$13640 (not z$13639))) (assert (let (($x1462 (Extract_1_15_15_16 v_Z))) (= z$269 $x1462))) (assert (let ((?x1470 (BitWiseNot_32_32 z$271))) (= z$273 ?x1470))) (assert (let ((?x1474 (ShiftR_32_32_32 z$273 z$n16s32))) (= z$275 ?x1474))) (assert (let ((?x1478 (BitWiseNot_32_32 z$275))) (= z$277 ?x1478))) (assert (let ((?x1486 (ite z$269 z$277 z$279))) (= z$281 ?x1486))) (assert (let ((?x1490 (Add_32_32_32 z$n1s32 z$281))) (= z$845 ?x1490))) (assert (= z$5399 (and (distinct z$845 z$n1s32) true))) (assert (let (($x60638 (and z$11 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$66 z$5399))) (= z$13653 $x60638))) (assert (= z$13654 (not z$13653))) (assert (let (($x1534 (GrEq_1_32_32 z$n5s32 z$855))) (= z$866 $x1534))) (assert (= z$868 (not z$866))) (assert (let (($x31634 (= z$855 z$n1s32))) (= z$11259 $x31634))) (assert (let (($x79746 (and a_file_req a_new_file a_wait_ack z$53 z$868 z$1055 z$2363 z$11259))) (= z$13676 $x79746))) (assert (= z$13677 (not z$13676))) (assert (let (($x82851 (= z$123 z$n5s32))) (= z$4289 $x82851))) (assert (let ((?x403 (BitWiseXor_16_16_16 z$n31s16 v_maxtime))) (= z$101 ?x403))) (assert (let (($x407 (Extract_1_15_15_16 z$101))) (= z$129 $x407))) (assert (let ((?x411 (Concat_32_16_16 z$n0s16 z$101))) (= z$131 ?x411))) (assert (let ((?x415 (BitWiseNot_32_32 z$131))) (= z$133 ?x415))) (assert (let ((?x419 (ShiftR_32_32_32 z$133 z$n16s32))) (= z$135 ?x419))) (assert (let ((?x423 (BitWiseNot_32_32 z$135))) (= z$137 ?x423))) (assert (let ((?x427 (ShiftR_32_32_32 z$131 z$n16s32))) (= z$139 ?x427))) (assert (let ((?x431 (ite z$129 z$137 z$139))) (= z$141 ?x431))) (assert (let (($x1681 (GrEq_1_32_32 z$183 z$141))) (= z$185 $x1681))) (assert (let (($x8848 (not z$185))) (= z$187 $x8848))) (assert (let ((?x7554 (ite z$187 z$n1s32 z$n0s32))) (= z$188 ?x7554))) (assert (let ((?x8593 (Add_32_32_32 z$183 z$188))) (= z$190 ?x8593))) (assert (let (($x10305 (= z$190 z$n1s32))) (= z$11347 $x10305))) (assert (let (($x77350 (and a_file_req z$13 z$15 a_new_file z$45 a_wait_ack z$53 z$114 z$1055 z$4289 z$11259 z$11347))) (= z$13745 $x77350))) (assert (= z$13746 (not z$13745))) (assert (let (($x81171 (= z$181 z$n5s32))) (= z$3216 $x81171))) (assert (let (($x42295 (and a_file_req z$13 z$15 a_new_file z$45 a_wait_ack z$53 z$1055 z$3216))) (= z$13784 $x42295))) (assert (= z$13785 (not z$13784))) (assert (let (($x39721 (and a_file_req z$13 z$15 a_new_file z$45 a_wait_ack z$53 z$1055 z$2363 z$2745 z$11347))) (= z$13793 $x39721))) (assert (= z$13794 (not z$13793))) (assert (let (($x46164 (and a_file_req z$13 z$15 a_new_file z$45 a_wait_ack z$53 z$1055 z$2746))) (= z$13833 $x46164))) (assert (= z$13834 (not z$13833))) (assert (let (($x61550 (and a_file_req z$13 z$15 a_new_file z$45 a_wait_ack z$53 z$1055 z$2363 z$2745))) (= z$13841 $x61550))) (assert (= z$13842 (not z$13841))) (assert (let (($x46540 (and a_file_req z$11 z$13 z$15 a_new_file z$31 a_start_K z$45 z$53 z$1055))) (= z$13865 $x46540))) (assert (= z$13866 (not z$13865))) (assert (let (($x17927 (and a_BAD_K a_file_req z$11 z$13 z$15 a_new_file z$31 z$45 z$53 z$1055 z$2501))) (= z$13873 $x17927))) (assert (= z$13874 (not z$13873))) (assert (let (($x62073 (and a_BAD_K z$11 z$13 z$15 z$19 a_init_state a_new_file z$31 z$45 z$47 z$51 z$53 z$2165))) (= z$13881 $x62073))) (assert (= z$13882 (not z$13881))) (assert (let (($x76540 (and a_BAD_K a_file_req z$11 z$13 z$15 a_new_file z$31 z$45 z$53 z$114 z$1055))) (= z$13895 $x76540))) (assert (= z$13896 (not z$13895))) (assert (= z$2911 (and (distinct z$181 z$n5s32) true))) (assert (let (($x21613 (and a_BAD_K a_BAD_L a_file_req a_new_file z$31 z$53 z$1055 z$2165 z$2911))) (= z$13999 $x21613))) (assert (= z$14000 (not z$13999))) (assert (let (($x81165 (and a_BAD_K a_BAD_L a_file_req a_new_file z$31 z$53 z$1055))) (= z$14032 $x81165))) (assert (= z$14033 (not z$14032))) (assert (let (($x80479 (= v_U v_X))) (= z$10905 $x80479))) (assert (let (($x12759 (and a_BAD_K a_BAD_L a_file_req a_new_file z$31 z$53 z$1055 z$2746 z$10905))) (= z$14040 $x12759))) (assert (= z$14041 (not z$14040))) (assert (let (($x55155 (and a_BAD_K a_BAD_L a_file_req a_new_file z$31 z$53 z$1055 z$2363))) (= z$14051 $x55155))) (assert (= z$14052 (not z$14051))) (assert (let (($x81347 (and a_file_req a_new_file a_wait_ack z$53 z$1055 z$2165 z$2746 z$2911))) (= z$14100 $x81347))) (assert (= z$14101 (not z$14100))) (assert (let (($x36131 (and a_file_req a_new_file a_wait_ack z$53 z$171 z$1055 z$3216))) (= z$14111 $x36131))) (assert (= z$14112 (not z$14111))) (assert (= z$4649 (and (distinct z$179 z$n5s32) true))) (assert (let (($x75175 (and a_file_req a_new_file a_wait_ack z$53 z$171 z$1055 z$4649))) (= z$14122 $x75175))) (assert (= z$14123 (not z$14122))) (assert (let (($x45723 (and a_file_req a_new_file a_wait_ack z$53 z$114 z$1055 z$4289 z$11259))) (= z$14130 $x45723))) (assert (= z$14131 (not z$14130))) (assert (= z$9345 (and (distinct v_V v_U) true))) (assert (let (($x11642 (and a_file_req z$13 z$15 a_new_file a_wait_ack z$53 z$1055 z$2746 z$9345))) (= z$14155 $x11642))) (assert (= z$14156 (not z$14155))) (assert (let (($x435 (GrEq_1_32_32 z$127 z$141))) (= z$143 $x435))) (assert (let (($x439 (not z$143))) (= z$145 $x439))) (assert (let ((?x442 (ite z$145 z$n1s32 z$n0s32))) (= z$148 ?x442))) (assert (let ((?x446 (Add_32_32_32 z$127 z$148))) (= z$150 ?x446))) (assert (let (($x48618 (= z$150 z$n1s32))) (= z$11346 $x48618))) (assert (let (($x77977 (and a_file_req a_idle_Receiver a_wait_ack z$53 z$114 z$1055 z$9345 z$11346))) (= z$14163 $x77977))) (assert (= z$14164 (not z$14163))) (assert (let (($x14474 (and a_file_req z$13 z$15 a_new_file a_wait_ack z$53 z$114 z$1055 z$2745 z$9345))) (= z$14174 $x14474))) (assert (= z$14175 (not z$14174))) (assert (let (($x38 (and a_file_req z$13 z$15 a_new_file a_wait_ack z$53 z$1055 z$2465 z$2745 z$9345))) (= z$14185 $x38))) (assert (= z$14186 (not z$14185))) (assert (let (($x1631 (Extract_1_15_15_16 v_V))) (= z$204 $x1631))) (assert (let (($x81899 (not z$204))) (= z$2166 $x81899))) (assert (let ((?x1635 (Concat_32_16_16 z$n0s16 v_V))) (= z$206 ?x1635))) (assert (let ((?x1651 (ShiftR_32_32_32 z$206 z$n16s32))) (= z$214 ?x1651))) (assert (= z$5786 (and (distinct z$214 z$n5s32) true))) (assert (let (($x82643 (and a_file_req z$13 z$15 z$21 a_new_file z$31 a_start_K z$53 z$1055 z$2166 z$2659 z$5786))) (= z$14222 $x82643))) (assert (= z$14223 (not z$14222))) (assert (let ((?x1639 (BitWiseNot_32_32 z$206))) (= z$208 ?x1639))) (assert (let ((?x1643 (ShiftR_32_32_32 z$208 z$n16s32))) (= z$210 ?x1643))) (assert (let ((?x1647 (BitWiseNot_32_32 z$210))) (= z$212 ?x1647))) (assert (let (($x82111 (= z$214 z$212))) (= z$9675 $x82111))) (assert (let (($x79471 (and a_file_req z$13 z$15 z$21 a_new_file z$31 a_start_K z$53 z$1055 z$5786 z$9675))) (= z$14233 $x79471))) (assert (= z$14234 (not z$14233))) (assert (= z$6049 (and (distinct z$212 z$n5s32) true))) (assert (let (($x10787 (and a_file_req z$13 z$15 z$21 a_new_file z$31 a_start_K z$53 z$204 z$1055 z$6049))) (= z$14245 $x10787))) (assert (= z$14246 (not z$14245))) (assert (let ((?x1609 (Add_32_32_32 z$n1s32 z$183))) (= z$901 ?x1609))) (assert (let (($x1613 (GrEq_1_32_32 z$n2s32 z$901))) (= z$903 $x1613))) (assert (let (($x1617 (not z$903))) (= z$905 $x1617))) (assert (let (($x57926 (and a_BAD_K a_file_req z$11 z$13 z$15 a_new_file z$31 z$53 z$114 z$905 z$1055 z$4289 z$9345 z$10905))) (= z$14254 $x57926))) (assert (= z$14255 (not z$14254))) (assert (let (($x61576 (and a_BAD_K z$11 z$13 z$15 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$171 z$905 z$9345))) (= z$14262 $x61576))) (assert (= z$14263 (not z$14262))) (assert (let (($x336 (= v_U z$n0s16))) (= z$58 $x336))) (assert (let (($x71761 (and a_file_req z$11 z$13 z$15 z$21 a_new_file z$31 a_start_K z$53 z$58 z$1055 z$2659))) (= z$14320 $x71761))) (assert (= z$14321 (not z$14320))) (assert (let (($x35297 (and a_BAD_K a_file_req z$11 z$13 z$15 a_new_file a_wait_ack z$53 z$114 z$1055 z$9345))) (= z$14328 $x35297))) (assert (= z$14329 (not z$14328))) (assert (let (($x30374 (and a_BAD_K z$11 z$13 z$15 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$171 z$9345))) (= z$14336 $x30374))) (assert (= z$14337 (not z$14336))) (assert (let (($x46462 (and a_file_req z$13 z$15 z$21 a_new_file a_start_L a_wait_ack z$53 z$1055 z$2659))) (= z$14375 $x46462))) (assert (= z$14376 (not z$14375))) (assert (let (($x29749 (and a_BAD_K a_file_req z$13 z$15 a_new_file z$31 z$53 z$1055))) (= z$14408 $x29749))) (assert (= z$14409 (not z$14408))) (assert (let (($x70588 (and a_BAD_K a_file_req z$13 z$15 a_new_file z$31 z$53 z$1055 z$2659 z$7446))) (= z$14416 $x70588))) (assert (= z$14417 (not z$14416))) (assert (let (($x78266 (and z$19 a_init_state a_new_file z$31 a_start_K z$47 z$51 z$53 z$62 z$6802))) (= z$14443 $x78266))) (assert (= z$14444 (not z$14443))) (assert (let (($x34327 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2670 z$8811))) (= z$14459 $x34327))) (assert (= z$14460 (not z$14459))) (assert (let (($x74538 (and z$1 a_file_req z$31 a_start_K a_start_L z$53 z$1055 z$2501))) (= z$14496 $x74538))) (assert (= z$14497 (not z$14496))) (assert (let (($x36642 (and z$1 z$19 a_init_state z$31 a_start_L z$47 z$51 z$53 z$2165))) (= z$14504 $x36642))) (assert (= z$14505 (not z$14504))) (assert (let (($x20447 (and z$1 z$19 a_init_state z$31 a_start_L z$47 z$51 z$53 z$2165 z$2363))) (= z$14512 $x20447))) (assert (= z$14513 (not z$14512))) (assert (let (($x31657 (and z$1 z$19 a_init_state z$31 a_start_L z$47 z$51 z$53 z$2165 z$11085))) (= z$14520 $x31657))) (assert (= z$14521 (not z$14520))) (assert (let ((?x108 (ShiftR_32_32_32 z$881 z$n16s32))) (= z$889 ?x108))) (assert (let (($x33679 (= z$150 z$889))) (= z$12194 $x33679))) (assert (let (($x24505 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$2363 z$12194))) (= z$14768 $x24505))) (assert (= z$14769 (not z$14768))) (assert (= z$5341 (and z$1 a_file_req z$21 a_wait_ack z$53 z$1055))) (assert (= z$5342 (not z$5341))) (assert (let (($x19695 (and a_file_req a_first_safe_frame z$43 a_wait_ack z$53 z$5352))) (= z$7285 $x19695))) (assert (= z$7286 (not z$7285))) (assert (let (($x80718 (= z$901 z$n1s32))) (= z$11269 $x80718))) (assert (= z$12471 (and a_file_req a_in_transit_K z$53 z$905 z$2746 z$11269))) (assert (= z$12472 (not z$12471))) (assert (let (($x33560 (= z$190 z$n2s32))) (= z$13031 $x33560))) (assert (let (($x83830 (= z$889 z$n2s32))) (= z$14965 $x83830))) (assert (let (($x27630 (and z$1 z$5 z$19 a_init_state z$31 z$35 z$47 z$51 z$53 z$187 z$10905 z$13031 z$14965))) (= z$14975 $x27630))) (assert (= z$14976 (not z$14975))) (assert (let (($x79409 (= z$181 z$n2s32))) (= z$13629 $x79409))) (assert (let (($x69616 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$13629 z$14965))) (= z$14994 $x69616))) (assert (= z$14995 (not z$14994))) (assert (let (($x50364 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$58 z$187 z$13031))) (= z$15118 $x50364))) (assert (= z$15119 (not z$15118))) (assert (let (($x70456 (and z$1 z$19 a_init_state z$31 a_send_req z$47 z$51 z$53 z$8811 z$12194))) (= z$15129 $x70456))) (assert (= z$15130 (not z$15129))) (assert (let (($x73656 (and z$1 z$19 a_init_state z$31 a_send_req z$47 z$51 z$53 z$145 z$2160 z$12194))) (= z$15245 $x73656))) (assert (= z$15246 (not z$15245))) (assert (let (($x51104 (and z$1 z$5 z$19 a_init_state z$31 z$35 z$47 z$51 z$53 z$11085))) (= z$12438 $x51104))) (assert (= z$12439 (not z$12438))) (assert (= z$15461 (and z$1 a_file_req a_wait_ack z$53 z$1055 z$2746 z$5770))) (assert (= z$15462 (not z$15461))) (assert (= z$15469 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$5770))) (assert (= z$15470 (not z$15469))) (assert (let (($x45987 (and z$1 a_file_req a_wait_ack z$53 z$1055 z$2501 z$9345 z$11346))) (= z$15599 $x45987))) (assert (= z$15600 (not z$15599))) (assert (let (($x31697 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$9345 z$11347))) (= z$15607 $x31697))) (assert (= z$15608 (not z$15607))) (assert (let (($x367 (= v_maxtime z$n0s16))) (= z$75 $x367))) (assert (= z$5192 (and (distinct z$125 z$n1s32) true))) (assert (let (($x77520 (= z$181 z$n0s32))) (= z$8822 $x77520))) (assert (let (($x28310 (and z$1 z$19 a_init_state z$31 z$41 z$47 z$51 z$53 z$187 z$5192 z$8822))) (= z$16011 $x28310))) (assert (= z$16012 (not z$16011))) (assert (let (($x63473 (and z$1 a_file_req a_wait_ack z$53 z$143 z$1055 z$2160 z$2501))) (= z$16025 $x63473))) (assert (= z$16026 (not z$16025))) (assert (let (($x75848 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$185 z$2165))) (= z$16033 $x75848))) (assert (= z$16034 (not z$16033))) (assert (= z$16041 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$58))) (assert (= z$16042 (not z$16041))) (assert (let (($x51696 (= z$901 z$n2s32))) (= z$13040 $x51696))) (assert (let (($x24089 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$2165 z$12194 z$13031 z$13040))) (= z$16049 $x24089))) (assert (= z$16050 (not z$16049))) (assert (= z$16057 (and z$1 a_error a_start_K z$53 z$2165 z$11085 z$13629))) (assert (= z$16058 (not z$16057))) (assert (let (($x81984 (= z$181 z$n1s32))) (= z$14636 $x81984))) (assert (let (($x80099 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$990 z$2363 z$14636))) (= z$16077 $x80099))) (assert (= z$16078 (not z$16077))) (assert (let (($x40829 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$12194 z$14636))) (= z$16086 $x40829))) (assert (= z$16087 (not z$16086))) (assert (let (($x76587 (and z$1 z$19 a_init_state z$31 z$41 z$47 z$51 z$53 z$988 z$2165 z$14636))) (= z$16100 $x76587))) (assert (= z$16101 (not z$16100))) (assert (let (($x82894 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$171 z$187))) (= z$16114 $x82894))) (assert (= z$16115 (not z$16114))) (assert (= z$16125 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$14636))) (assert (= z$16126 (not z$16125))) (assert (let (($x70742 (and z$1 a_file_req a_wait_ack z$53 z$114 z$1055 z$4289 z$5192))) (= z$16146 $x70742))) (assert (= z$16147 (not z$16146))) (assert (= z$16154 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$171))) (assert (= z$16155 (not z$16154))) (assert (let (($x69079 (and z$19 a_in_transit_K a_init_state z$31 z$47 z$51 z$53 z$2363))) (= z$16162 $x69079))) (assert (= z$16163 (not z$16162))) (assert (= z$6784 (and (distinct v_W z$n0s16) true))) (assert (= z$16244 (and a_file_req z$17 a_new_file z$31 z$53 z$6784 z$7877))) (assert (= z$16245 (not z$16244))) (assert (let (($x33905 (and a_BAD_K a_file_req a_new_file z$31 z$53 z$1055 z$2363 z$7877))) (= z$8447 $x33905))) (assert (= z$8448 (not z$8447))) (assert (let (($x32838 (and a_file_req z$21 a_new_file z$31 a_start_K z$53 z$1055 z$6784))) (= z$16274 $x32838))) (assert (= z$16275 (not z$16274))) (assert (let (($x37486 (and a_BAD_K a_file_req a_new_file a_wait_ack z$53 z$1055 z$2363))) (= z$16282 $x37486))) (assert (= z$16283 (not z$16282))) (assert (let (($x35298 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53))) (= z$10862 $x35298))) (assert (= z$10863 (not z$10862))) (assert (let (($x81587 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363))) (= z$11752 $x81587))) (assert (= z$11753 (not z$11752))) (assert (let (($x80397 (and a_file_req z$11 z$21 a_new_file a_wait_ack z$53 z$1055 z$2363))) (= z$16322 $x80397))) (assert (= z$16323 (not z$16322))) (assert (let (($x59740 (and z$11 z$19 z$21 a_init_state a_new_file z$31 z$47 z$51 z$53))) (= z$16330 $x59740))) (assert (= z$16331 (not z$16330))) (assert (let (($x48543 (and z$11 z$19 z$21 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363))) (= z$16338 $x48543))) (assert (= z$16339 (not z$16338))) (assert (let (($x52398 (and a_file_req a_new_file z$43 a_wait_ack z$53 z$1055 z$6784))) (= z$16367 $x52398))) (assert (= z$16368 (not z$16367))) (assert (let (($x82819 (and z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53 z$6784))) (= z$16375 $x82819))) (assert (= z$16376 (not z$16375))) (assert (let (($x45180 (and z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53 z$2363))) (= z$16383 $x45180))) (assert (= z$16384 (not z$16383))) (assert (let ((?x1402 (BitWiseNot_32_32 z$239))) (= z$241 ?x1402))) (assert (let ((?x1406 (ShiftR_32_32_32 z$241 z$n16s32))) (= z$243 ?x1406))) (assert (let ((?x1410 (BitWiseNot_32_32 z$243))) (= z$245 ?x1410))) (assert (let ((?x1414 (ShiftR_32_32_32 z$239 z$n16s32))) (= z$247 ?x1414))) (assert (let ((?x1418 (ite z$237 z$245 z$247))) (= z$249 ?x1418))) (assert (let ((?x1422 (Add_32_32_32 z$n1s32 z$249))) (= z$826 ?x1422))) (assert (let (($x27022 (= z$826 z$n0s32))) (= z$12275 $x27022))) (assert (let (($x60628 (and a_file_req z$17 a_in_transit_K a_new_file z$31 z$53 z$1055 z$12275))) (= z$16414 $x60628))) (assert (= z$16415 (not z$16414))) (assert (let (($x68852 (and a_file_req z$17 a_in_transit_K a_new_file a_wait_ack z$53 z$1055 z$2746))) (= z$16422 $x68852))) (assert (= z$16423 (not z$16422))) (assert (let (($x44657 (and z$17 z$19 a_init_state a_new_file z$31 a_start_K z$47 z$51 z$53))) (= z$16430 $x44657))) (assert (= z$16431 (not z$16430))) (assert (let (($x69432 (and z$17 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363))) (= z$16438 $x69432))) (assert (= z$16439 (not z$16438))) (assert (= z$5378 (and (distinct z$279 z$n0s32) true))) (assert (let (($x77267 (= z$271 z$n0s32))) (= z$10031 $x77267))) (assert (let (($x17469 (and z$19 a_in_transit_K a_init_state z$31 z$47 z$51 z$53 z$5378 z$10031))) (= z$16467 $x17469))) (assert (= z$16468 (not z$16467))) (assert (let (($x80757 (not z$269))) (= z$2168 $x80757))) (assert (let (($x82297 (= z$279 z$n0s32))) (= z$10032 $x82297))) (assert (let (($x51125 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$2168 z$5399 z$10032))) (= z$16480 $x51125))) (assert (= z$16481 (not z$16480))) (assert (let (($x1723 (GrEq_1_32_32 z$281 z$141))) (= z$283 $x1723))) (assert (let (($x19006 (not z$283))) (= z$285 $x19006))) (assert (let (($x51901 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$285 z$2168 z$2363 z$5192 z$10032))) (= z$16492 $x51901))) (assert (= z$16493 (not z$16492))) (assert (let ((?x10677 (ite z$285 z$n1s32 z$n0s32))) (= z$286 ?x10677))) (assert (let ((?x6340 (Add_32_32_32 z$281 z$286))) (= z$288 ?x6340))) (assert (= z$5593 (and (distinct z$288 z$n0s32) true))) (assert (let (($x26589 (and z$19 a_in_transit_K a_init_state z$31 z$47 z$51 z$53 z$283 z$2168 z$5593 z$10032))) (= z$16503 $x26589))) (assert (= z$16504 (not z$16503))) (assert (let (($x42056 (and z$19 a_init_state a_new_file z$31 a_start_K z$45 z$47 z$51 z$53))) (= z$16518 $x42056))) (assert (= z$16519 (not z$16518))) (assert (let (($x79291 (and z$19 a_init_state a_new_file z$31 z$45 z$47 z$51 z$53 z$2363))) (= z$16526 $x79291))) (assert (= z$16527 (not z$16526))) (assert (let (($x70180 (and a_file_req a_in_transit_K a_new_file z$31 z$53 z$1055 z$2166 z$5352 z$5786))) (= z$16570 $x70180))) (assert (= z$16571 (not z$16570))) (assert (= z$5361 (and (distinct v_Z v_U) true))) (assert (let (($x29628 (and a_BAD_L a_file_req a_new_file a_wait_ack z$53 z$114 z$1055 z$5361))) (= z$16612 $x29628))) (assert (= z$16613 (not z$16612))) (assert (let (($x16861 (and a_BAD_L z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$171 z$5361))) (= z$16620 $x16861))) (assert (= z$16621 (not z$16620))) (assert (let (($x35699 (and z$19 a_in_transit_K a_init_state z$31 a_start_L z$47 z$51 z$53 z$2165 z$13629))) (= z$16631 $x35699))) (assert (= z$16632 (not z$16631))) (assert (let (($x48199 (and a_BAD_L a_file_req a_new_file a_wait_ack z$53 z$1055 z$2501 z$5361))) (= z$16645 $x48199))) (assert (= z$16646 (not z$16645))) (assert (let (($x37847 (and a_BAD_L z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$5361))) (= z$16653 $x37847))) (assert (= z$16654 (not z$16653))) (assert (let (($x69577 (and z$1 a_BAD_L z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$66 z$2746 z$12194 z$13629))) (= z$16669 $x69577))) (assert (= z$16670 (not z$16669))) (assert (let (($x77944 (and z$19 a_in_transit_K a_init_state z$31 z$47 z$51 z$53 z$14636))) (= z$16684 $x77944))) (assert (= z$16685 (not z$16684))) (assert (let (($x81622 (= z$214 z$n5s32))) (= z$7436 $x81622))) (assert (let (($x80086 (and a_file_req a_in_transit_K a_new_file z$31 z$53 z$204 z$1055 z$5352 z$7436))) (= z$16704 $x80086))) (assert (= z$16705 (not z$16704))) (assert (let (($x80588 (= z$212 z$n5s32))) (= z$10915 $x80588))) (assert (let (($x76261 (and a_file_req a_in_transit_K a_new_file z$31 z$53 z$1055 z$5352 z$7436 z$10915))) (= z$16716 $x76261))) (assert (= z$16717 (not z$16716))) (assert (let (($x75063 (and a_file_req a_in_transit_K a_new_file z$31 z$53 z$1055 z$5352 z$6784 z$6792 z$7436))) (= z$16741 $x75063))) (assert (= z$16742 (not z$16741))) (assert (= z$4471 (and (distinct z$123 z$n5s32) true))) (assert (let (($x50297 (= z$206 z$n0s32))) (= z$9561 $x50297))) (assert (let (($x78371 (and a_file_req z$13 z$15 a_new_file a_wait_ack z$53 z$1055 z$4471 z$5352 z$9561))) (= z$16752 $x78371))) (assert (= z$16753 (not z$16752))) (assert (let (($x55244 (and a_file_req a_in_transit_K a_new_file z$31 z$53 z$204 z$1055 z$5352 z$6049))) (= z$16765 $x55244))) (assert (= z$16766 (not z$16765))) (assert (let (($x43517 (and a_file_req a_in_transit_K a_new_file z$31 z$53 z$1055 z$6784 z$6792))) (= z$16787 $x43517))) (assert (= z$16788 (not z$16787))) (assert (let (($x52144 (and a_file_req z$13 z$15 a_new_file a_wait_ack z$53 z$1055 z$5352 z$5770))) (= z$16818 $x52144))) (assert (= z$16819 (not z$16818))) (assert (let (($x1893 (GrEq_1_32_32 z$n2s32 z$183))) (= z$991 $x1893))) (assert (let (($x31017 (not z$991))) (= z$2210 $x31017))) (assert (let (($x70712 (and a_file_req a_new_file a_wait_ack z$53 z$1055 z$2160 z$2210 z$2465 z$5361))) (= z$16826 $x70712))) (assert (= z$16827 (not z$16826))) (assert (let (($x61768 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2165 z$2210 z$5361))) (= z$16834 $x61768))) (assert (= z$16835 (not z$16834))) (assert (let (($x26453 (and a_file_req a_in_transit_L a_new_file a_wait_ack z$53 z$1055 z$2465 z$5361 z$5770))) (= z$16848 $x26453))) (assert (= z$16849 (not z$16848))) (assert (let (($x47539 (and z$19 a_init_state a_new_file z$31 a_start_L z$47 z$51 z$53 z$2165 z$5361 z$5770))) (= z$16856 $x47539))) (assert (= z$16857 (not z$16856))) (assert (let (($x73080 (and a_file_req a_new_file a_wait_ack z$53 z$114 z$1055 z$4289 z$5361 z$5770))) (= z$16871 $x73080))) (assert (= z$16872 (not z$16871))) (assert (let (($x32252 (and z$19 a_in_transit_L a_init_state a_new_file z$31 z$47 z$51 z$53 z$5361 z$5770))) (= z$16879 $x32252))) (assert (= z$16880 (not z$16879))) (assert (let (($x50192 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363 z$5361 z$5770))) (= z$16887 $x50192))) (assert (= z$16888 (not z$16887))) (assert (let (($x70496 (and z$19 a_in_transit_K a_init_state a_new_file z$31 z$47 z$51 z$53 z$66 z$2659 z$2746 z$12194 z$13629))) (= z$16895 $x70496))) (assert (= z$16896 (not z$16895))) (assert (let (($x69890 (and a_file_req a_new_file a_wait_ack z$53 z$1055 z$2160 z$2465 z$5352 z$5361))) (= z$16932 $x69890))) (assert (= z$16933 (not z$16932))) (assert (let (($x77748 (= v_V v_Z))) (= z$9233 $x77748))) (assert (let (($x73342 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2165 z$2659 z$9233 z$9345))) (= z$16940 $x73342))) (assert (= z$16941 (not z$16940))) (assert (= z$2658 (and (distinct v_X v_V) true))) (assert (let (($x80117 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2165 z$2363 z$2658 z$9233 z$9345))) (= z$16949 $x80117))) (assert (= z$16950 (not z$16949))) (assert (let (($x31773 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$171 z$9233 z$9345))) (= z$16975 $x31773))) (assert (= z$16976 (not z$16975))) (assert (let (($x24286 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363 z$2658 z$9233 z$9345))) (= z$16983 $x24286))) (assert (= z$16984 (not z$16983))) (assert (let (($x340 (= v_V z$n0s16))) (= z$60 $x340))) (assert (let ((?x1655 (ite z$204 z$212 z$214))) (= z$216 ?x1655))) (assert (let (($x1926 (GrEq_1_32_32 z$n2s32 z$216))) (= z$1006 $x1926))) (assert (let (($x35964 (not z$1006))) (= z$2213 $x35964))) (assert (let (($x76857 (and a_file_req a_new_file a_wait_ack z$53 z$60 z$1055 z$2213 z$10905 z$12275))) (= z$17032 $x76857))) (assert (= z$17033 (not z$17032))) (assert (let (($x16868 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$60 z$2213 z$12275))) (= z$17041 $x16868))) (assert (= z$17042 (not z$17041))) (assert (let (($x23374 (and a_file_req a_in_transit_K a_new_file a_wait_ack z$53 z$60 z$1055 z$2213))) (= z$17055 $x23374))) (assert (= z$17056 (not z$17055))) (assert (let (($x76194 (and z$19 a_init_state a_new_file z$31 a_start_K z$47 z$51 z$53 z$60 z$2213))) (= z$17063 $x76194))) (assert (= z$17064 (not z$17063))) (assert (let (($x39845 (and a_file_req a_new_file a_wait_ack z$53 z$66 z$143 z$1055 z$2160 z$2501))) (= z$17077 $x39845))) (assert (= z$17078 (not z$17077))) (assert (let (($x69881 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$66 z$185))) (= z$17085 $x69881))) (assert (= z$17086 (not z$17085))) (assert (let (($x41260 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2659 z$7446 z$9233 z$9345))) (= z$17093 $x41260))) (assert (= z$17094 (not z$17093))) (assert (let (($x83137 (and z$1 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$5361 z$12194 z$13629))) (= z$17101 $x83137))) (assert (= z$17102 (not z$17101))) (assert (let (($x79055 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$5352 z$5361 z$9055 z$12194))) (= z$17112 $x79055))) (assert (= z$17113 (not z$17112))) (assert (let (($x46439 (and a_file_req a_new_file a_wait_ack z$53 z$1055 z$2465 z$6792 z$7249))) (= z$17140 $x46439))) (assert (= z$17141 (not z$17140))) (assert (let (($x62939 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2165 z$6792 z$7249))) (= z$17148 $x62939))) (assert (= z$17149 (not z$17148))) (assert (let (($x82849 (= v_U v_Z))) (= z$12541 $x82849))) (assert (let (($x10840 (and a_file_req a_in_transit_K a_new_file a_wait_ack z$53 z$1055 z$5352 z$6792 z$7249 z$12541))) (= z$17162 $x10840))) (assert (= z$17163 (not z$17162))) (assert (let (($x78445 (and z$19 a_init_state a_new_file z$31 a_start_K z$47 z$51 z$53 z$6792 z$7249))) (= z$17170 $x78445))) (assert (= z$17171 (not z$17170))) (assert (let (($x31833 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363 z$6792 z$7249))) (= z$17178 $x31833))) (assert (= z$17179 (not z$17178))) (assert (let (($x235 (not a_BAD_L))) (= z$3 $x235))) (assert (let (($x21851 (and z$3 a_file_req z$11 z$13 z$15 a_in_transit_K a_new_file z$31 z$53 z$66 z$1055 z$2659))) (= z$17211 $x21851))) (assert (= z$17212 (not z$17211))) (assert (let (($x49769 (and a_file_req a_in_transit_L a_new_file a_wait_ack z$53 z$114 z$1055 z$5770 z$9055))) (= z$17219 $x49769))) (assert (= z$17220 (not z$17219))) (assert (let (($x31299 (and z$3 a_file_req z$11 a_new_file a_wait_ack z$53 z$1055 z$2465 z$5770))) (= z$17241 $x31299))) (assert (= z$17242 (not z$17241))) (assert (let (($x42403 (and z$3 z$11 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$5770))) (= z$17249 $x42403))) (assert (= z$17250 (not z$17249))) (assert (let (($x71535 (and z$3 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363 z$5192))) (= z$17257 $x71535))) (assert (= z$17258 (not z$17257))) (assert (let (($x24334 (and z$19 a_in_transit_L a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363 z$5770))) (= z$17268 $x24334))) (assert (= z$17269 (not z$17268))) (assert (let (($x82786 (= z$173 z$116))) (= z$3053 $x82786))) (assert (let (($x51022 (and z$3 z$11 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$58 z$145 z$2363 z$2659 z$3053))) (= z$17276 $x51022))) (assert (= z$17277 (not z$17276))) (assert (= z$17308 (and a_BAD_L a_file_req a_in_transit_K z$31 z$53 z$1055))) (assert (= z$17309 (not z$17308))) (assert (let (($x57616 (and a_BAD_L z$19 a_in_transit_K a_init_state z$31 z$47 z$51 z$53 z$12541))) (= z$17324 $x57616))) (assert (= z$17325 (not z$17324))) (assert (let (($x14885 (and a_BAD_L z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363))) (= z$17332 $x14885))) (assert (= z$17333 (not z$17332))) (assert (let (($x70860 (and z$1 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$58 z$3053 z$12194))) (= z$17351 $x70860))) (assert (= z$17352 (not z$17351))) (assert (let (($x70930 (and a_file_req a_new_file a_wait_ack z$53 z$114 z$1055 z$4289 z$5192))) (= z$17371 $x70930))) (assert (= z$17372 (not z$17371))) (assert (let (($x57722 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$269))) (= z$17379 $x57722))) (assert (= z$17380 (not z$17379))) (assert (let (($x52894 (and a_file_req a_new_file a_wait_ack z$53 z$1055 z$2465 z$12541))) (= z$17393 $x52894))) (assert (= z$17394 (not z$17393))) (assert (let (($x81133 (= v_U v_V))) (= z$12067 $x81133))) (assert (let (($x27759 (and z$19 a_in_transit_L a_init_state a_new_file z$31 z$47 z$51 z$53 z$12067))) (= z$17401 $x27759))) (assert (= z$17402 (not z$17401))) (assert (let (($x25640 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363 z$12194))) (= z$17414 $x25640))) (assert (= z$17415 (not z$17414))) (assert (= z$6815 (and (distinct z$247 z$n5s32) true))) (assert (let (($x27957 (and a_file_req a_in_transit_K a_new_file z$31 z$53 z$1055 z$2167 z$6784 z$6815))) (= z$7317 $x27957))) (assert (= z$7318 (not z$7317))) (assert (let (($x18936 (and z$1 a_file_req a_new_file a_wait_ack z$53 z$1055 z$2167 z$6784 z$6792))) (= z$7432 $x18936))) (assert (= z$7433 (not z$7432))) (assert (let (($x37051 (and z$1 a_file_req a_new_file a_wait_ack z$53 z$1055 z$2167 z$6784 z$7249))) (= z$8497 $x37051))) (assert (= z$8498 (not z$8497))) (assert (let (($x34714 (= z$247 z$n5s32))) (= z$7320 $x34714))) (assert (let (($x26042 (and a_file_req a_in_transit_K a_new_file z$31 z$53 z$1055 z$7249 z$7320))) (= z$8558 $x26042))) (assert (= z$8559 (not z$8558))) (assert (let (($x36608 (= z$245 z$247))) (= z$8563 $x36608))) (assert (let (($x16625 (and a_file_req a_in_transit_K a_new_file z$31 z$53 z$1055 z$6784 z$7249 z$8563))) (= z$8606 $x16625))) (assert (= z$8607 (not z$8606))) (assert (= z$9471 (and a_BAD_L a_file_req a_wait_ack z$53 z$1055))) (assert (= z$9472 (not z$9471))) (assert (let (($x22692 (and a_BAD_K a_file_req a_new_file z$31 z$53 z$1055 z$6792 z$7320))) (= z$10394 $x22692))) (assert (= z$10395 (not z$10394))) (assert (let (($x24869 (and a_BAD_K a_file_req a_new_file a_wait_ack z$53 z$1055 z$7320))) (= z$10805 $x24869))) (assert (= z$10806 (not z$10805))) (assert (let (($x39446 (and a_file_req a_in_transit_K a_new_file a_wait_ack z$53 z$2745 z$2746))) (= z$14092 $x39446))) (assert (= z$14093 (not z$14092))) (assert (let (($x77504 (= z$271 z$116))) (= z$9057 $x77504))) (assert (= z$13374 (and a_file_req z$31 z$43 z$53 z$2465 z$4289 z$9057))) (assert (= z$13375 (not z$13374))) (assert (= z$3286 (and (distinct z$150 z$855) true))) (assert (= z$14558 (and z$1 a_file_req z$21 z$31 z$53 z$285 z$3286 z$9055))) (assert (= z$14559 (not z$14558))) (assert (let (($x88 (Extract_1_15_15_16 z$94))) (= z$879 $x88))) (assert (let ((?x96 (BitWiseNot_32_32 z$881))) (= z$883 ?x96))) (assert (let ((?x100 (ShiftR_32_32_32 z$883 z$n16s32))) (= z$885 ?x100))) (assert (let ((?x104 (BitWiseNot_32_32 z$885))) (= z$887 ?x104))) (assert (let ((?x112 (ite z$879 z$887 z$889))) (= z$891 ?x112))) (assert (let (($x116 (= z$127 z$891))) (= z$979 $x116))) (assert (= z$980 (and a_error z$979))) (assert (= z$2068 (and a_new_file z$980))) (assert (= z$2070 (and z$53 z$2068))) (assert (= z$2072 (not z$2070))) (assert (= z$2073 (= prop z$2072))) (assert (let ((?x1815 (BitWiseXor_16_16_16 z$n3s16 v_n))) (= z$87 ?x1815))) (assert (let ((?x6530 (BitWiseXor_16_16_16 z$n3s16 z$87))) (= z$89 ?x6530))) (assert (let (($x6772 (= v_n$next z$89))) (= z$91 $x6772))) (assert (let (($x393 (= v_SYNC$next z$96))) (= z$98 $x393))) (assert (let ((?x4749 (BitWiseXor_16_16_16 z$n31s16 z$101))) (= z$103 ?x4749))) (assert (let (($x8768 (= v_maxtime$next z$103))) (= z$105 $x8768))) (assert (let ((?x450 (Extract_16_15_0_32 z$150))) (= z$152 ?x450))) (assert (let ((?x454 (ite f00 z$152 v_X))) (= z$154 ?x454))) (assert (let ((?x458 (ite f11 z$n0s16 z$154))) (= z$156 ?x458))) (assert (let ((?x462 (ite f13 z$n0s16 z$156))) (= z$158 ?x462))) (assert (let ((?x466 (ite f14 z$n0s16 z$158))) (= z$160 ?x466))) (assert (let ((?x470 (ite f17 z$n0s16 z$160))) (= z$162 ?x470))) (assert (let ((?x474 (ite f18 z$n0s16 z$162))) (= z$164 ?x474))) (assert (let ((?x478 (ite f25 z$n0s16 z$164))) (= z$166 ?x478))) (assert (let (($x482 (= v_X$next z$166))) (= z$168 $x482))) (assert (let ((?x5654 (Extract_16_15_0_32 z$190))) (= z$192 ?x5654))) (assert (let ((?x9490 (ite f00 z$192 v_U))) (= z$194 ?x9490))) (assert (let ((?x5610 (ite f15 z$n0s16 z$194))) (= z$196 ?x5610))) (assert (let ((?x9450 (ite f17 z$n0s16 z$196))) (= z$198 ?x9450))) (assert (let (($x7774 (= v_U$next z$198))) (= z$200 $x7774))) (assert (let (($x1695 (GrEq_1_32_32 z$216 z$141))) (= z$218 $x1695))) (assert (let (($x7317 (not z$218))) (= z$220 $x7317))) (assert (let ((?x5853 (ite z$220 z$n1s32 z$n0s32))) (= z$221 ?x5853))) (assert (let ((?x7820 (Add_32_32_32 z$216 z$221))) (= z$223 ?x7820))) (assert (let ((?x4589 (Extract_16_15_0_32 z$223))) (= z$225 ?x4589))) (assert (let ((?x7233 (ite f00 z$225 v_V))) (= z$227 ?x7233))) (assert (let ((?x4613 (ite f21 z$n0s16 z$227))) (= z$229 ?x4613))) (assert (let ((?x8576 (ite f23 z$n0s16 z$229))) (= z$231 ?x8576))) (assert (let (($x4848 (= v_V$next z$231))) (= z$233 $x4848))) (assert (let (($x1709 (GrEq_1_32_32 z$249 z$141))) (= z$251 $x1709))) (assert (let (($x8426 (not z$251))) (= z$253 $x8426))) (assert (let ((?x17399 (ite z$253 z$n1s32 z$n0s32))) (= z$254 ?x17399))) (assert (let ((?x11129 (Add_32_32_32 z$249 z$254))) (= z$256 ?x11129))) (assert (let ((?x10996 (Extract_16_15_0_32 z$256))) (= z$258 ?x10996))) (assert (let ((?x7136 (ite f00 z$258 v_W))) (= z$260 ?x7136))) (assert (let ((?x5196 (ite f19 z$n0s16 z$260))) (= z$262 ?x5196))) (assert (let ((?x9963 (ite f20 z$n0s16 z$262))) (= z$264 ?x9963))) (assert (let (($x21092 (= v_W$next z$264))) (= z$266 $x21092))) (assert (let ((?x12445 (Extract_16_15_0_32 z$288))) (= z$290 ?x12445))) (assert (let ((?x11760 (ite f00 z$290 v_Z))) (= z$292 ?x11760))) (assert (let ((?x18623 (ite f19 z$n0s16 z$292))) (= z$294 ?x18623))) (assert (let ((?x6179 (ite f23 z$n0s16 z$294))) (= z$296 ?x6179))) (assert (let ((?x16750 (ite f24 z$n0s16 z$296))) (= z$298 ?x16750))) (assert (let (($x5992 (= v_Z$next z$298))) (= z$300 $x5992))) (assert (let ((?x1811 (Concat_32_8_24 v_i z$n0s24))) (= z$348 ?x1811))) (assert (let ((?x7318 (Add_32_32_32 z$n1s32 z$348))) (= z$350 ?x7318))) (assert (let ((?x6614 (Extract_8_7_0_32 z$350))) (= z$352 ?x6614))) (assert (let ((?x7140 (ite f04 z$352 v_i))) (= z$354 ?x7140))) (assert (let ((?x4890 (ite f11 z$n1s8 z$354))) (= z$356 ?x4890))) (assert (let (($x6077 (= v_i$next z$356))) (= z$358 $x6077))) (assert (let ((?x2161 (Concat_32_8_24 v_rc z$n0s24))) (= z$360 ?x2161))) (assert (let ((?x7443 (Add_32_32_32 z$n1s32 z$360))) (= z$362 ?x7443))) (assert (let ((?x6774 (Extract_8_7_0_32 z$362))) (= z$364 ?x6774))) (assert (let ((?x6750 (ite f15 z$n0s8 v_rc))) (= z$367 ?x6750))) (assert (let ((?x5686 (ite f16 z$n0s8 z$367))) (= z$369 ?x5686))) (assert (let ((?x7502 (ite f17 z$364 z$369))) (= z$371 ?x7502))) (assert (let ((?x5744 (ite f18 z$364 z$371))) (= z$373 ?x5744))) (assert (let (($x6231 (= v_rc$next z$373))) (= z$375 $x6231))) (assert (= z$432 (= a_time$next a_time))) (assert (let (($x491 (not f01))) (= z$434 $x491))) (assert (= z$435 (and a_first_safe_frame z$434))) (assert (= z$437 (not z$435))) (assert (let (($x502 (not f19))) (= z$438 $x502))) (assert (= z$439 (and z$437 z$438))) (assert (= z$441 (not z$439))) (assert (= z$442 (= a_first_safe_frame$next z$441))) (assert (= z$444 (and z$13 z$434))) (assert (= z$446 (not z$444))) (assert (= z$447 (not z$446))) (assert (let (($x527 (not f20))) (= z$448 $x527))) (assert (= z$449 (and z$447 z$448))) (assert (= z$451 (not z$449))) (assert (let (($x538 (not f21))) (= z$452 $x538))) (assert (= z$453 (and z$451 z$452))) (assert (let (($x546 (not f22))) (= z$456 $x546))) (assert (= z$457 (and z$453 z$456))) (assert (let (($x554 (not f26))) (= z$460 $x554))) (assert (= z$461 (and z$457 z$460))) (assert (let (($x562 (not f27))) (= z$464 $x562))) (assert (= z$465 (and z$461 z$464))) (assert (let (($x570 (not f28))) (= z$468 $x570))) (assert (= z$469 (and z$465 z$468))) (assert (let (($x578 (not f29))) (= z$472 $x578))) (assert (= z$473 (and z$469 z$472))) (assert (let (($x586 (not f30))) (= z$476 $x586))) (assert (= z$477 (and z$473 z$476))) (assert (let (($x594 (not f31))) (= z$480 $x594))) (assert (= z$481 (and z$477 z$480))) (assert (= z$483 (= a_frame_received$next z$481))) (assert (let (($x606 (not f23))) (= z$485 $x606))) (assert (= z$486 (and a_frame_reported z$485))) (assert (let (($x614 (not f24))) (= z$488 $x614))) (assert (= z$489 (and z$486 z$488))) (assert (= z$491 (not z$489))) (assert (= z$492 (and z$491 z$460))) (assert (= z$494 (not z$492))) (assert (= z$495 (not z$494))) (assert (= z$496 (and z$495 z$464))) (assert (= z$498 (not z$496))) (assert (= z$499 (not z$498))) (assert (= z$500 (and z$499 z$468))) (assert (= z$502 (not z$500))) (assert (= z$503 (not z$502))) (assert (= z$504 (and z$503 z$472))) (assert (= z$506 (not z$504))) (assert (= z$507 (not z$506))) (assert (= z$508 (and z$507 z$476))) (assert (= z$510 (not z$508))) (assert (= z$511 (not z$510))) (assert (= z$512 (and z$511 z$480))) (assert (= z$514 (not z$512))) (assert (= z$515 (= a_frame_reported$next z$514))) (assert (let (($x686 (not f02))) (= z$518 $x686))) (assert (= z$519 (and a_idle_Receiver z$518))) (assert (= z$521 (and z$519 z$448))) (assert (= z$523 (not z$521))) (assert (= z$524 (and z$523 z$452))) (assert (= z$526 (not z$524))) (assert (= z$527 (not z$526))) (assert (= z$528 (and z$527 z$456))) (assert (= z$530 (not z$528))) (assert (= z$531 (not z$530))) (assert (= z$532 (and z$531 z$485))) (assert (= z$534 (not z$532))) (assert (= z$535 (not z$534))) (assert (= z$536 (and z$535 z$488))) (assert (= z$538 (not z$536))) (assert (let (($x738 (not f32))) (= z$540 $x738))) (assert (= z$541 (and z$538 z$540))) (assert (= z$543 (= a_idle_Receiver$next z$541))) (assert (= z$545 (and a_new_file z$518))) (assert (= z$547 (not z$545))) (assert (= z$548 (and z$547 z$438))) (assert (= z$550 (not z$548))) (assert (= z$551 (and z$550 z$540))) (assert (= z$553 (not z$551))) (assert (let (($x769 (not z$553))) (= z$554 $x769))) (assert (= z$555 (= a_new_file$next z$554))) (assert (let (($x777 (not f04))) (= z$557 $x777))) (assert (= z$558 (and z$31 z$557))) (assert (= z$560 (not z$558))) (assert (= z$561 (not z$560))) (assert (let (($x790 (not f11))) (= z$562 $x790))) (assert (= z$563 (and z$561 z$562))) (assert (= z$565 (not z$563))) (assert (let (($x801 (not f15))) (= z$566 $x801))) (assert (= z$567 (and z$565 z$566))) (assert (let (($x809 (not f16))) (= z$569 $x809))) (assert (= z$570 (and z$567 z$569))) (assert (= z$572 (= a_next_frame$next z$570))) (assert (let (($x820 (not f13))) (= z$574 $x820))) (assert (= z$575 (and a_wait_ack z$574))) (assert (let (($x827 (not f14))) (= z$577 $x827))) (assert (= z$578 (and z$575 z$577))) (assert (= z$580 (not z$578))) (assert (= z$581 (and z$580 z$566))) (assert (= z$583 (not z$581))) (assert (= z$584 (not z$583))) (assert (= z$585 (and z$584 z$569))) (assert (= z$587 (not z$585))) (assert (let (($x854 (not f25))) (= z$588 $x854))) (assert (= z$589 (and z$587 z$588))) (assert (= z$591 (= a_wait_ack$next z$589))) (assert (= z$593 (and a_success z$557))) (assert (let (($x870 (not f12))) (= z$596 $x870))) (assert (= z$597 (and z$593 z$596))) (assert (= z$599 (not z$597))) (assert (= z$600 (and z$599 z$588))) (assert (= z$602 (not z$600))) (assert (= z$603 (= a_success$next z$602))) (assert (let (($x891 (not f05))) (= z$605 $x891))) (assert (= z$606 (and a_error z$605))) (assert (= z$608 (not z$606))) (assert (= z$609 (and z$608 z$574))) (assert (= z$611 (not z$609))) (assert (= z$612 (not z$611))) (assert (= z$613 (and z$612 z$577))) (assert (= z$615 (not z$613))) (assert (= z$616 (= a_error$next z$615))) (assert (let (($x282 (not a_init_state))) (= z$27 $x282))) (assert (let (($x923 (not f03))) (= z$618 $x923))) (assert (= z$619 (and z$27 z$618))) (assert (let (($x930 (not z$619))) (= z$621 $x930))) (assert (= z$622 (= a_init_state$next z$621))) (assert (= z$624 (and z$19 z$618))) (assert (= z$626 (not z$624))) (assert (= z$627 (not z$626))) (assert (= z$628 (and z$627 z$605))) (assert (= z$630 (not z$628))) (assert (= z$631 (and z$630 z$562))) (assert (= z$633 (not z$631))) (assert (= z$634 (and z$633 z$596))) (assert (= z$636 (not z$634))) (assert (= z$637 (= a_idle_Sender$next z$636))) (assert (let (($x973 (not f06))) (= z$640 $x973))) (assert (= z$641 (and a_in_transit_K z$640))) (assert (= z$643 (not z$641))) (assert (= z$644 (and z$643 z$566))) (assert (= z$646 (not z$644))) (assert (= z$647 (and z$646 z$569))) (assert (= z$649 (not z$647))) (assert (let (($x997 (not f17))) (= z$650 $x997))) (assert (= z$651 (and z$649 z$650))) (assert (= z$653 (not z$651))) (assert (let (($x1007 (not f18))) (= z$654 $x1007))) (assert (= z$655 (and z$653 z$654))) (assert (= z$657 (and z$655 z$438))) (assert (= z$659 (and z$657 z$448))) (assert (= z$661 (= a_in_transit_K$next z$659))) (assert (= z$663 (and a_start_K z$640))) (assert (= z$665 (not z$663))) (assert (= z$666 (and z$665 z$566))) (assert (= z$668 (and z$666 z$650))) (assert (= z$670 (not z$668))) (assert (= z$671 (and z$670 z$438))) (assert (= z$673 (not z$671))) (assert (= z$674 (not z$673))) (assert (= z$675 (and z$674 z$448))) (assert (= z$677 (not z$675))) (assert (let (($x1061 (not z$677))) (= z$678 $x1061))) (assert (= z$679 (= a_start_K$next z$678))) (assert (= z$681 (and z$1 z$569))) (assert (= z$683 (not z$681))) (assert (= z$684 (not z$683))) (assert (= z$685 (and z$684 z$654))) (assert (= z$687 (not z$685))) (assert (= z$688 (= a_BAD_K$next z$687))) (assert (let (($x1090 (not f07))) (= z$691 $x1090))) (assert (= z$692 (and a_in_transit_L z$691))) (assert (= z$694 (not z$692))) (assert (= z$695 (and z$694 z$452))) (assert (= z$697 (not z$695))) (assert (= z$698 (and z$697 z$456))) (assert (= z$700 (not z$698))) (assert (= z$701 (and z$700 z$485))) (assert (= z$703 (not z$701))) (assert (= z$704 (and z$703 z$488))) (assert (= z$706 (and z$704 z$588))) (assert (= z$708 (= a_in_transit_L$next z$706))) (assert (= z$710 (and a_start_L z$691))) (assert (= z$712 (not z$710))) (assert (= z$713 (and z$712 z$452))) (assert (= z$715 (and z$713 z$485))) (assert (= z$717 (not z$715))) (assert (= z$718 (and z$717 z$588))) (assert (= z$720 (not z$718))) (assert (let (($x1158 (not z$720))) (= z$721 $x1158))) (assert (= z$722 (= a_start_L$next z$721))) (assert (= z$724 (and z$3 z$456))) (assert (= z$726 (not z$724))) (assert (= z$727 (not z$726))) (assert (= z$728 (and z$727 z$488))) (assert (= z$730 (not z$728))) (assert (= z$731 (= a_BAD_L$next z$730))) (assert (let (($x305 (not a_ok_SClient))) (= z$39 $x305))) (assert (let (($x1187 (not f08))) (= z$734 $x1187))) (assert (= z$735 (and z$39 z$734))) (assert (= z$737 (not z$735))) (assert (= z$738 (and z$737 z$596))) (assert (= z$740 (not z$738))) (assert (let (($x1204 (not z$740))) (= z$741 $x1204))) (assert (= z$742 (= a_ok_SClient$next z$741))) (assert (let (($x1212 (not f09))) (= z$745 $x1212))) (assert (= z$746 (and a_dk z$745))) (assert (= z$748 (not z$746))) (assert (= z$749 (and z$748 z$574))) (assert (= z$751 (not z$749))) (assert (= z$752 (= a_dk$next z$751))) (assert (let (($x1234 (not f10))) (= z$755 $x1234))) (assert (= z$756 (and a_nok_SClient z$755))) (assert (= z$758 (not z$756))) (assert (= z$759 (and z$758 z$577))) (assert (= z$761 (not z$759))) (assert (= z$762 (= a_nok_SClient$next z$761))) (assert (= z$764 (and z$41 z$734))) (assert (= z$766 (not z$764))) (assert (= z$767 (not z$766))) (assert (= z$768 (and z$767 z$745))) (assert (= z$770 (not z$768))) (assert (= z$771 (not z$770))) (assert (= z$772 (and z$771 z$755))) (assert (= z$774 (not z$772))) (assert (= z$775 (and z$774 z$562))) (assert (= z$777 (= a_send_req$next z$775))) (assert (= z$779 (and z$9 z$562))) (assert (= z$781 (not z$779))) (assert (= z$782 (and z$781 z$596))) (assert (= z$784 (and z$782 z$574))) (assert (= z$786 (and z$784 z$577))) (assert (= z$788 (= a_file_req$next z$786))) (assert (= z$790 (and a_ok_RClient z$464))) (assert (= z$792 (not z$790))) (assert (= z$793 (not z$792))) (assert (= z$794 (and z$793 z$468))) (assert (= z$796 (not z$794))) (assert (= z$797 (and z$796 z$476))) (assert (let (($x1334 (not z$797))) (= z$799 $x1334))) (assert (= z$800 (= a_ok_RClient$next z$799))) (assert (= z$802 (and a_inc z$464))) (assert (= z$804 (not z$802))) (assert (= z$805 (and z$804 z$476))) (assert (= z$807 (not z$805))) (assert (= z$808 (not z$807))) (assert (= z$809 (and z$808 z$480))) (assert (= z$811 (not z$809))) (assert (= z$812 (and z$811 z$540))) (assert (= z$814 (= a_inc$next z$812))) (assert (= z$816 (and a_nok_RClient z$468))) (assert (= z$818 (and z$816 z$480))) (assert (= z$820 (not z$818))) (assert (= z$821 (and z$820 z$540))) (assert (= z$823 (not z$821))) (assert (= z$824 (= a_nok_RClient$next z$823))) (assert (= z$49 (not a_time))) (assert (let (($x1426 (GrEq_1_32_32 z$n0s32 z$826))) (= z$828 $x1426))) (assert (let (($x1430 (not z$828))) (= z$830 $x1430))) (assert (= z$831 (and a_first_safe_frame z$830))) (assert (= z$833 (not z$831))) (assert (= z$834 (and a_frame_received z$830))) (assert (= z$836 (not z$834))) (assert (= z$837 (and z$833 z$836))) (assert (= z$839 (and a_frame_reported z$830))) (assert (= z$841 (not z$839))) (assert (= z$842 (and z$837 z$841))) (assert (let (($x1494 (GrEq_1_32_32 z$n30s32 z$845))) (= z$847 $x1494))) (assert (= z$849 (not z$847))) (assert (= z$850 (and a_idle_Receiver z$849))) (assert (= z$852 (not z$850))) (assert (= z$853 (and z$842 z$852))) (assert (= z$860 (and a_next_frame z$859))) (assert (= z$862 (not z$860))) (assert (= z$863 (and z$853 z$862))) (assert (= z$869 (and a_wait_ack z$868))) (assert (= z$871 (not z$869))) (assert (= z$872 (and z$863 z$871))) (assert (= z$874 (and a_success z$859))) (assert (= z$876 (not z$874))) (assert (= z$877 (and z$872 z$876))) (assert (let (($x1563 (GrEq_1_32_32 z$891 z$855))) (= z$893 $x1563))) (assert (let (($x1567 (not z$893))) (= z$895 $x1567))) (assert (= z$896 (and a_error z$895))) (assert (= z$898 (not z$896))) (assert (= z$899 (and z$877 z$898))) (assert (= z$906 (and a_in_transit_K z$905))) (assert (= z$908 (not z$906))) (assert (= z$909 (and z$899 z$908))) (assert (let ((?x1659 (Add_32_32_32 z$n1s32 z$216))) (= z$911 ?x1659))) (assert (let (($x1663 (GrEq_1_32_32 z$n2s32 z$911))) (= z$913 $x1663))) (assert (let (($x1667 (not z$913))) (= z$915 $x1667))) (assert (= z$916 (and a_in_transit_L z$915))) (assert (= z$918 (not z$916))) (assert (= z$919 (and z$909 z$918))) (assert (= z$921 (and z$143 z$185))) (assert (= z$923 (not z$921))) (assert (= z$924 (not z$923))) (assert (= z$925 (and z$924 z$218))) (assert (= z$927 (not z$925))) (assert (= z$928 (not z$927))) (assert (= z$929 (and z$928 z$251))) (assert (= z$931 (not z$929))) (assert (= z$932 (not z$931))) (assert (= z$933 (and z$932 z$283))) (assert (= z$935 (not z$933))) (assert (= z$936 (and z$919 z$935))) (assert (= z$938 (and z$49 z$936))) (assert (= z$940 (not z$938))) (assert (= z$941 (and f00 z$940))) (assert (= z$943 (not z$941))) (assert (= z$944 (and z$11 f01))) (assert (= z$946 (not z$944))) (assert (= z$947 (and z$943 z$946))) (assert (let (($x1763 (= z$n30s32 z$281))) (= z$949 $x1763))) (assert (let ((?x1767 (Concat_32_8_24 v_triple_Receiver z$n0s24))) (= z$310 ?x1767))) (assert (let ((?x1771 (BitWiseAnd_32_32_32 z$n2s32 z$310))) (= z$950 ?x1771))) (assert (let (($x1775 (= z$n2s32 z$950))) (= z$952 $x1775))) (assert (= z$953 (and z$949 z$952))) (assert (= z$955 (and a_idle_Receiver z$953))) (assert (= z$957 (not z$955))) (assert (= z$958 (and f02 z$957))) (assert (= z$960 (not z$958))) (assert (= z$961 (and z$947 z$960))) (assert (= z$963 (and a_init_state f03))) (assert (= z$965 (not z$963))) (assert (= z$966 (and z$961 z$965))) (assert (let (($x1819 (Extract_1_15_15_16 z$87))) (= z$384 $x1819))) (assert (let ((?x1823 (Concat_32_16_16 z$n0s16 z$87))) (= z$386 ?x1823))) (assert (let ((?x1827 (BitWiseNot_32_32 z$386))) (= z$388 ?x1827))) (assert (let ((?x1831 (ShiftR_32_32_32 z$388 z$n16s32))) (= z$390 ?x1831))) (assert (let ((?x1835 (BitWiseNot_32_32 z$390))) (= z$392 ?x1835))) (assert (let ((?x1839 (ShiftR_32_32_32 z$386 z$n16s32))) (= z$394 ?x1839))) (assert (let ((?x1843 (ite z$384 z$392 z$394))) (= z$396 ?x1843))) (assert (let (($x1847 (GrEq_1_32_32 z$348 z$396))) (= z$968 $x1847))) (assert (= z$970 (not z$968))) (assert (= z$971 (and a_success z$970))) (assert (= z$973 (not z$971))) (assert (= z$974 (and f04 z$973))) (assert (= z$976 (not z$974))) (assert (= z$977 (and z$966 z$976))) (assert (let (($x1872 (not z$980))) (= z$982 $x1872))) (assert (= z$983 (and f05 z$982))) (assert (= z$985 (not z$983))) (assert (= z$986 (and z$977 z$985))) (assert (= z$993 (and z$990 z$991))) (assert (= z$995 (and a_in_transit_K z$993))) (assert (= z$997 (not z$995))) (assert (= z$998 (and f06 z$997))) (assert (= z$1000 (not z$998))) (assert (= z$1001 (and z$986 z$1000))) (assert (let (($x1919 (GrEq_1_32_32 z$n0s32 z$216))) (= z$1003 $x1919))) (assert (let (($x1923 (not z$1003))) (= z$1005 $x1923))) (assert (= z$1008 (and z$1005 z$1006))) (assert (= z$1010 (and a_in_transit_L z$1008))) (assert (= z$1012 (not z$1010))) (assert (= z$1013 (and f07 z$1012))) (assert (= z$1015 (not z$1013))) (assert (= z$1016 (and z$1001 z$1015))) (assert (= z$1018 (and a_ok_SClient f08))) (assert (= z$1020 (not z$1018))) (assert (= z$1021 (and z$1016 z$1020))) (assert (= z$1023 (and z$5 f09))) (assert (= z$1025 (not z$1023))) (assert (= z$1026 (and z$1021 z$1025))) (assert (= z$1028 (and z$35 f10))) (assert (= z$1030 (not z$1028))) (assert (= z$1031 (and z$1026 z$1030))) (assert (= z$1033 (and a_idle_Sender a_send_req))) (assert (= z$1035 (not z$1033))) (assert (= z$1036 (and f11 z$1035))) (assert (= z$1038 (not z$1036))) (assert (= z$1039 (and z$1031 z$1038))) (assert (= z$1041 (and a_success a_file_req))) (assert (let ((?x2007 (Extract_24_31_8_32 z$392))) (= z$399 ?x2007))) (assert (let ((?x2010 (Extract_24_31_8_32 z$394))) (= z$400 ?x2010))) (assert (let ((?x2013 (ite z$384 z$399 z$400))) (= z$401 ?x2013))) (assert (let ((?x2016 (Extract_24_31_8_32 z$396))) (= z$398 ?x2016))) (assert (= z$398 z$401)) (assert (let (($x2021 (= z$n0s24 z$398))) (= z$403 $x2021))) (assert (let ((?x2024 (Extract_8_7_0_32 z$392))) (= z$405 ?x2024))) (assert (let ((?x2027 (Extract_8_7_0_32 z$394))) (= z$406 ?x2027))) (assert (let ((?x2030 (ite z$384 z$405 z$406))) (= z$407 ?x2030))) (assert (let ((?x2033 (Extract_8_7_0_32 z$396))) (= z$404 ?x2033))) (assert (= z$404 z$407)) (assert (let (($x2038 (= v_i z$404))) (= z$409 $x2038))) (assert (= z$410 (and z$403 z$409))) (assert (= z$1043 (and z$1041 z$410))) (assert (= z$1045 (not z$1043))) (assert (= z$1046 (and f12 z$1045))) (assert (= z$1048 (not z$1046))) (assert (= z$1049 (and z$1039 z$1048))) (assert (= z$1051 (and a_wait_ack a_file_req))) (assert (let (($x2067 (= z$n5s32 z$127))) (= z$1053 $x2067))) (assert (= z$1056 (and z$1053 z$1055))) (assert (= z$1058 (and z$410 z$1056))) (assert (= z$1060 (and z$1051 z$1058))) (assert (= z$1062 (not z$1060))) (assert (= z$1063 (and f13 z$1062))) (assert (= z$1065 (not z$1063))) (assert (= z$1066 (and z$1049 z$1065))) (assert (= z$1068 (and z$970 z$1056))) (assert (= z$1070 (and z$1051 z$1068))) (assert (= z$1072 (not z$1070))) (assert (= z$1073 (and f14 z$1072))) (assert (= z$1075 (not z$1073))) (assert (= z$1076 (and z$1066 z$1075))) (assert (= z$1078 (and a_next_frame z$43))) (assert (= z$1080 (not z$1078))) (assert (= z$1081 (and f15 z$1080))) (assert (= z$1083 (not z$1081))) (assert (= z$1084 (and z$1076 z$1083))) (assert (= z$1086 (and a_next_frame a_in_transit_K))) (assert (= z$1088 (not z$1086))) (assert (= z$1089 (and f16 z$1088))) (assert (= z$1091 (not z$1089))) (assert (= z$1092 (and z$1084 z$1091))) (assert (= z$1094 (and a_wait_ack z$43))) (assert (let (($x2165 (GrEq_1_32_32 z$360 z$n3s32))) (= z$1097 $x2165))) (assert (= z$1099 (not z$1097))) (assert (= z$1100 (and z$1053 z$1099))) (assert (= z$1102 (and z$1094 z$1100))) (assert (= z$1104 (not z$1102))) (assert (= z$1105 (and f17 z$1104))) (assert (= z$1107 (not z$1105))) (assert (= z$1108 (and z$1092 z$1107))) (assert (= z$1110 (and a_wait_ack a_in_transit_K))) (assert (= z$1112 (and z$1110 z$1100))) (assert (= z$1114 (not z$1112))) (assert (= z$1115 (and f18 z$1114))) (assert (= z$1117 (not z$1115))) (assert (= z$1118 (and z$1108 z$1117))) (assert (let (($x285 (not a_new_file))) (= z$29 $x285))) (assert (= z$1120 (and z$29 a_in_transit_K))) (assert (= z$1122 (and z$1120 z$993))) (assert (= z$1124 (not z$1122))) (assert (= z$1125 (and f19 z$1124))) (assert (= z$1127 (not z$1125))) (assert (= z$1128 (and z$1118 z$1127))) (assert (= z$1130 (and a_idle_Receiver a_in_transit_K))) (assert (= z$1132 (and z$1130 z$993))) (assert (let (($x2246 (GrEq_1_32_32 z$281 z$n30s32))) (= z$1134 $x2246))) (assert (= z$1136 (not z$1134))) (assert (= z$1137 (and z$1132 z$1136))) (assert (= z$1139 (not z$1137))) (assert (= z$1140 (and f20 z$1139))) (assert (= z$1142 (not z$1140))) (assert (= z$1143 (and z$1128 z$1142))) (assert (= z$1145 (and a_frame_received z$45))) (assert (let ((?x2275 (BitWiseAnd_32_32_32 z$n1s32 z$310))) (= z$312 ?x2275))) (assert (let ((?x2279 (Extract_24_31_8_32 z$312))) (= z$1147 ?x2279))) (assert (let (($x2283 (= z$n0s24 z$1147))) (= z$1149 $x2283))) (assert (let ((?x2286 (Extract_8_7_0_32 z$312))) (= z$314 ?x2286))) (assert (let (($x2290 (= v_exp_ab z$314))) (= z$1150 $x2290))) (assert (= z$1151 (and z$1149 z$1150))) (assert (let (($x2297 (not z$1151))) (= z$1153 $x2297))) (assert (= z$1154 (and z$1145 z$1153))) (assert (= z$1156 (not z$1154))) (assert (= z$1157 (and f21 z$1156))) (assert (= z$1159 (not z$1157))) (assert (= z$1160 (and z$1143 z$1159))) (assert (= z$1162 (and a_frame_received a_in_transit_L))) (assert (= z$1164 (and z$1162 z$1153))) (assert (= z$1166 (not z$1164))) (assert (= z$1167 (and f22 z$1166))) (assert (= z$1169 (not z$1167))) (assert (= z$1170 (and z$1160 z$1169))) (assert (= z$1172 (and a_frame_reported z$45))) (assert (= z$1174 (not z$1172))) (assert (= z$1175 (and f23 z$1174))) (assert (= z$1177 (not z$1175))) (assert (= z$1178 (and z$1170 z$1177))) (assert (= z$1180 (and a_frame_reported a_in_transit_L))) (assert (= z$1182 (not z$1180))) (assert (= z$1183 (and f24 z$1182))) (assert (= z$1185 (not z$1183))) (assert (= z$1186 (and z$1178 z$1185))) (assert (= z$1188 (and a_wait_ack a_in_transit_L))) (assert (= z$1190 (and z$1188 z$1008))) (assert (let (($x2384 (GrEq_1_32_32 z$127 z$n5s32))) (= z$1192 $x2384))) (assert (= z$1194 (not z$1192))) (assert (= z$1195 (and z$1190 z$1194))) (assert (= z$1197 (not z$1195))) (assert (= z$1198 (and f25 z$1197))) (assert (= z$1200 (not z$1198))) (assert (= z$1201 (and z$1186 z$1200))) (assert (let (($x301 (not a_ok_RClient))) (= z$37 $x301))) (assert (= z$1203 (and a_frame_received z$37))) (assert (= z$1205 (and z$952 z$1151))) (assert (= z$1207 (and z$1203 z$1205))) (assert (= z$1209 (not z$1207))) (assert (= z$1210 (and f26 z$1209))) (assert (= z$1212 (not z$1210))) (assert (= z$1213 (and z$1201 z$1212))) (assert (= z$1215 (and a_frame_received a_inc))) (assert (= z$1217 (and z$1215 z$1205))) (assert (= z$1219 (not z$1217))) (assert (= z$1220 (and f27 z$1219))) (assert (= z$1222 (not z$1220))) (assert (= z$1223 (and z$1213 z$1222))) (assert (= z$1225 (and a_frame_received a_nok_RClient))) (assert (= z$1227 (and z$1225 z$1205))) (assert (= z$1229 (not z$1227))) (assert (= z$1230 (and f28 z$1229))) (assert (= z$1232 (not z$1230))) (assert (= z$1233 (and z$1223 z$1232))) (assert (let ((?x2479 (BitWiseAnd_32_32_32 z$n6s32 z$310))) (= z$1236 ?x2479))) (assert (let (($x2483 (= z$n0s32 z$1236))) (= z$1238 $x2483))) (assert (= z$1239 (and z$1151 z$1238))) (assert (= z$1241 (and z$1215 z$1239))) (assert (= z$1243 (not z$1241))) (assert (= z$1244 (and f29 z$1243))) (assert (= z$1246 (not z$1244))) (assert (= z$1247 (and z$1233 z$1246))) (assert (let (($x2508 (= z$n4s32 z$1236))) (= z$1249 $x2508))) (assert (= z$1250 (and z$1151 z$1249))) (assert (= z$1252 (and z$1203 z$1250))) (assert (= z$1254 (not z$1252))) (assert (= z$1255 (and f30 z$1254))) (assert (= z$1257 (not z$1255))) (assert (= z$1258 (and z$1247 z$1257))) (assert (= z$1260 (and z$1225 z$1250))) (assert (= z$1262 (not z$1260))) (assert (= z$1263 (and f31 z$1262))) (assert (= z$1265 (not z$1263))) (assert (= z$1266 (and z$1258 z$1265))) (assert (= z$1268 (and a_idle_Receiver a_inc))) (assert (let (($x2555 (= z$n0s32 z$950))) (= z$1270 $x2555))) (assert (= z$1271 (and z$949 z$1270))) (assert (= z$1273 (and z$1268 z$1271))) (assert (= z$1275 (not z$1273))) (assert (= z$1276 (and f32 z$1275))) (assert (= z$1278 (not z$1276))) (assert (= z$1279 (and z$1266 z$1278))) (assert (let (($x2580 (not f00))) (= z$1281 $x2580))) (assert (= z$1282 (and z$1281 z$434))) (assert (= z$1284 (not z$1282))) (assert (let (($x2590 (not z$1284))) (= z$1285 $x2590))) (assert (= z$1286 (and z$518 z$1285))) (assert (= z$1288 (not z$1286))) (assert (let (($x2600 (not z$1288))) (= z$1289 $x2600))) (assert (= z$1290 (and z$618 z$1289))) (assert (= z$1292 (not z$1290))) (assert (let (($x2610 (not z$1292))) (= z$1293 $x2610))) (assert (= z$1294 (and z$557 z$1293))) (assert (= z$1296 (not z$1294))) (assert (let (($x2620 (not z$1296))) (= z$1297 $x2620))) (assert (= z$1298 (and z$605 z$1297))) (assert (= z$1300 (not z$1298))) (assert (let (($x2630 (not z$1300))) (= z$1301 $x2630))) (assert (= z$1302 (and z$640 z$1301))) (assert (= z$1304 (not z$1302))) (assert (let (($x2640 (not z$1304))) (= z$1305 $x2640))) (assert (= z$1306 (and z$691 z$1305))) (assert (= z$1308 (not z$1306))) (assert (let (($x2650 (not z$1308))) (= z$1309 $x2650))) (assert (= z$1310 (and z$734 z$1309))) (assert (= z$1312 (not z$1310))) (assert (let (($x2660 (not z$1312))) (= z$1313 $x2660))) (assert (= z$1314 (and z$745 z$1313))) (assert (= z$1316 (not z$1314))) (assert (let (($x2670 (not z$1316))) (= z$1317 $x2670))) (assert (= z$1318 (and z$755 z$1317))) (assert (= z$1320 (not z$1318))) (assert (let (($x2680 (not z$1320))) (= z$1321 $x2680))) (assert (= z$1322 (and z$562 z$1321))) (assert (= z$1324 (not z$1322))) (assert (let (($x2690 (not z$1324))) (= z$1325 $x2690))) (assert (= z$1326 (and z$596 z$1325))) (assert (= z$1328 (not z$1326))) (assert (let (($x2700 (not z$1328))) (= z$1329 $x2700))) (assert (= z$1330 (and z$574 z$1329))) (assert (= z$1332 (not z$1330))) (assert (let (($x2710 (not z$1332))) (= z$1333 $x2710))) (assert (= z$1334 (and z$577 z$1333))) (assert (= z$1336 (not z$1334))) (assert (let (($x2720 (not z$1336))) (= z$1337 $x2720))) (assert (= z$1338 (and z$566 z$1337))) (assert (= z$1340 (not z$1338))) (assert (let (($x2730 (not z$1340))) (= z$1341 $x2730))) (assert (= z$1342 (and z$569 z$1341))) (assert (= z$1344 (not z$1342))) (assert (let (($x2740 (not z$1344))) (= z$1345 $x2740))) (assert (= z$1346 (and z$650 z$1345))) (assert (= z$1348 (not z$1346))) (assert (let (($x2750 (not z$1348))) (= z$1349 $x2750))) (assert (= z$1350 (and z$654 z$1349))) (assert (= z$1352 (not z$1350))) (assert (let (($x2760 (not z$1352))) (= z$1353 $x2760))) (assert (= z$1354 (and z$438 z$1353))) (assert (= z$1356 (not z$1354))) (assert (let (($x2770 (not z$1356))) (= z$1357 $x2770))) (assert (= z$1358 (and z$448 z$1357))) (assert (= z$1360 (not z$1358))) (assert (let (($x2780 (not z$1360))) (= z$1361 $x2780))) (assert (= z$1362 (and z$452 z$1361))) (assert (= z$1364 (not z$1362))) (assert (let (($x2790 (not z$1364))) (= z$1365 $x2790))) (assert (= z$1366 (and z$456 z$1365))) (assert (= z$1368 (not z$1366))) (assert (let (($x2800 (not z$1368))) (= z$1369 $x2800))) (assert (= z$1370 (and z$485 z$1369))) (assert (= z$1372 (not z$1370))) (assert (let (($x2810 (not z$1372))) (= z$1373 $x2810))) (assert (= z$1374 (and z$488 z$1373))) (assert (= z$1376 (not z$1374))) (assert (let (($x2820 (not z$1376))) (= z$1377 $x2820))) (assert (= z$1378 (and z$588 z$1377))) (assert (= z$1380 (not z$1378))) (assert (let (($x2830 (not z$1380))) (= z$1381 $x2830))) (assert (= z$1382 (and z$460 z$1381))) (assert (= z$1384 (not z$1382))) (assert (let (($x2840 (not z$1384))) (= z$1385 $x2840))) (assert (= z$1386 (and z$464 z$1385))) (assert (= z$1388 (not z$1386))) (assert (let (($x2850 (not z$1388))) (= z$1389 $x2850))) (assert (= z$1390 (and z$468 z$1389))) (assert (= z$1392 (not z$1390))) (assert (let (($x2860 (not z$1392))) (= z$1393 $x2860))) (assert (= z$1394 (and z$472 z$1393))) (assert (= z$1396 (not z$1394))) (assert (let (($x2870 (not z$1396))) (= z$1397 $x2870))) (assert (= z$1398 (and z$476 z$1397))) (assert (= z$1400 (not z$1398))) (assert (let (($x2880 (not z$1400))) (= z$1401 $x2880))) (assert (= z$1402 (and z$480 z$1401))) (assert (= z$1404 (not z$1402))) (assert (let (($x2890 (not z$1404))) (= z$1405 $x2890))) (assert (= z$1406 (and z$540 z$1405))) (assert (= z$1408 (not z$1406))) (assert (= z$1409 (and z$1279 z$1408))) (assert (= z$1411 (and f00 f01))) (assert (= z$1413 (not z$1411))) (assert (= z$1414 (and f02 z$1284))) (assert (= z$1416 (not z$1414))) (assert (= z$1417 (and z$1413 z$1416))) (assert (= z$1419 (not z$1417))) (assert (= z$1420 (not z$1419))) (assert (= z$1421 (and f03 z$1288))) (assert (= z$1423 (not z$1421))) (assert (= z$1424 (and z$1420 z$1423))) (assert (= z$1426 (not z$1424))) (assert (= z$1427 (not z$1426))) (assert (= z$1428 (and f04 z$1292))) (assert (= z$1430 (not z$1428))) (assert (= z$1431 (and z$1427 z$1430))) (assert (= z$1433 (not z$1431))) (assert (= z$1434 (not z$1433))) (assert (= z$1435 (and f05 z$1296))) (assert (= z$1437 (not z$1435))) (assert (= z$1438 (and z$1434 z$1437))) (assert (= z$1440 (not z$1438))) (assert (= z$1441 (not z$1440))) (assert (= z$1442 (and f06 z$1300))) (assert (= z$1444 (not z$1442))) (assert (= z$1445 (and z$1441 z$1444))) (assert (= z$1447 (not z$1445))) (assert (= z$1448 (not z$1447))) (assert (= z$1449 (and f07 z$1304))) (assert (= z$1451 (not z$1449))) (assert (= z$1452 (and z$1448 z$1451))) (assert (= z$1454 (not z$1452))) (assert (= z$1455 (not z$1454))) (assert (= z$1456 (and f08 z$1308))) (assert (= z$1458 (not z$1456))) (assert (= z$1459 (and z$1455 z$1458))) (assert (= z$1461 (not z$1459))) (assert (= z$1462 (not z$1461))) (assert (= z$1463 (and f09 z$1312))) (assert (= z$1465 (not z$1463))) (assert (= z$1466 (and z$1462 z$1465))) (assert (= z$1468 (not z$1466))) (assert (= z$1469 (not z$1468))) (assert (= z$1470 (and f10 z$1316))) (assert (= z$1472 (not z$1470))) (assert (= z$1473 (and z$1469 z$1472))) (assert (= z$1475 (not z$1473))) (assert (= z$1476 (not z$1475))) (assert (= z$1477 (and f11 z$1320))) (assert (= z$1479 (not z$1477))) (assert (= z$1480 (and z$1476 z$1479))) (assert (= z$1482 (not z$1480))) (assert (= z$1483 (not z$1482))) (assert (= z$1484 (and f12 z$1324))) (assert (= z$1486 (not z$1484))) (assert (= z$1487 (and z$1483 z$1486))) (assert (= z$1489 (not z$1487))) (assert (= z$1490 (not z$1489))) (assert (= z$1491 (and f13 z$1328))) (assert (= z$1493 (not z$1491))) (assert (= z$1494 (and z$1490 z$1493))) (assert (= z$1496 (not z$1494))) (assert (= z$1497 (not z$1496))) (assert (= z$1498 (and f14 z$1332))) (assert (= z$1500 (not z$1498))) (assert (= z$1501 (and z$1497 z$1500))) (assert (= z$1503 (not z$1501))) (assert (= z$1504 (not z$1503))) (assert (= z$1505 (and f15 z$1336))) (assert (= z$1507 (not z$1505))) (assert (= z$1508 (and z$1504 z$1507))) (assert (= z$1510 (not z$1508))) (assert (= z$1511 (not z$1510))) (assert (= z$1512 (and f16 z$1340))) (assert (= z$1514 (not z$1512))) (assert (= z$1515 (and z$1511 z$1514))) (assert (= z$1517 (not z$1515))) (assert (= z$1518 (not z$1517))) (assert (= z$1519 (and f17 z$1344))) (assert (= z$1521 (not z$1519))) (assert (= z$1522 (and z$1518 z$1521))) (assert (= z$1524 (not z$1522))) (assert (= z$1525 (not z$1524))) (assert (= z$1526 (and f18 z$1348))) (assert (= z$1528 (not z$1526))) (assert (= z$1529 (and z$1525 z$1528))) (assert (= z$1531 (not z$1529))) (assert (= z$1532 (not z$1531))) (assert (= z$1533 (and f19 z$1352))) (assert (= z$1535 (not z$1533))) (assert (= z$1536 (and z$1532 z$1535))) (assert (= z$1538 (not z$1536))) (assert (= z$1539 (not z$1538))) (assert (= z$1540 (and f20 z$1356))) (assert (= z$1542 (not z$1540))) (assert (= z$1543 (and z$1539 z$1542))) (assert (= z$1545 (not z$1543))) (assert (= z$1546 (not z$1545))) (assert (= z$1547 (and f21 z$1360))) (assert (= z$1549 (not z$1547))) (assert (= z$1550 (and z$1546 z$1549))) (assert (= z$1552 (not z$1550))) (assert (= z$1553 (not z$1552))) (assert (= z$1554 (and f22 z$1364))) (assert (= z$1556 (not z$1554))) (assert (= z$1557 (and z$1553 z$1556))) (assert (= z$1559 (not z$1557))) (assert (= z$1560 (not z$1559))) (assert (= z$1561 (and f23 z$1368))) (assert (= z$1563 (not z$1561))) (assert (= z$1564 (and z$1560 z$1563))) (assert (= z$1566 (not z$1564))) (assert (= z$1567 (not z$1566))) (assert (= z$1568 (and f24 z$1372))) (assert (= z$1570 (not z$1568))) (assert (= z$1571 (and z$1567 z$1570))) (assert (= z$1573 (not z$1571))) (assert (= z$1574 (not z$1573))) (assert (= z$1575 (and f25 z$1376))) (assert (= z$1577 (not z$1575))) (assert (= z$1578 (and z$1574 z$1577))) (assert (= z$1580 (not z$1578))) (assert (= z$1581 (not z$1580))) (assert (= z$1582 (and f26 z$1380))) (assert (= z$1584 (not z$1582))) (assert (= z$1585 (and z$1581 z$1584))) (assert (= z$1587 (not z$1585))) (assert (= z$1588 (not z$1587))) (assert (= z$1589 (and f27 z$1384))) (assert (= z$1591 (not z$1589))) (assert (= z$1592 (and z$1588 z$1591))) (assert (= z$1594 (not z$1592))) (assert (= z$1595 (not z$1594))) (assert (= z$1596 (and f28 z$1388))) (assert (= z$1598 (not z$1596))) (assert (= z$1599 (and z$1595 z$1598))) (assert (= z$1601 (not z$1599))) (assert (= z$1602 (not z$1601))) (assert (= z$1603 (and f29 z$1392))) (assert (= z$1605 (not z$1603))) (assert (= z$1606 (and z$1602 z$1605))) (assert (= z$1608 (not z$1606))) (assert (= z$1609 (not z$1608))) (assert (= z$1610 (and f30 z$1396))) (assert (= z$1612 (not z$1610))) (assert (= z$1613 (and z$1609 z$1612))) (assert (= z$1615 (not z$1613))) (assert (= z$1616 (not z$1615))) (assert (= z$1617 (and f31 z$1400))) (assert (= z$1619 (not z$1617))) (assert (= z$1620 (and z$1616 z$1619))) (assert (= z$1622 (not z$1620))) (assert (= z$1623 (not z$1622))) (assert (= z$1624 (and f32 z$1404))) (assert (= z$1626 (not z$1624))) (assert (= z$1627 (and z$1623 z$1626))) (assert (= z$1629 (not z$1627))) (assert (= z$1630 (not z$1629))) (assert (= z$1631 (and z$1409 z$1630))) (assert (= z$1633 (and a_first_safe_frame a_frame_received))) (assert (= z$1635 (not z$1633))) (assert (= z$1636 (and z$11 z$13))) (assert (= z$1638 (not z$1636))) (assert (= z$1639 (and a_frame_reported z$1638))) (assert (= z$1641 (not z$1639))) (assert (= z$1642 (and z$1635 z$1641))) (assert (= z$1644 (not z$1642))) (assert (= z$1645 (not z$1644))) (assert (let (($x3473 (not z$1638))) (= z$1646 $x3473))) (assert (= z$1647 (and z$15 z$1646))) (assert (= z$1649 (not z$1647))) (assert (= z$1650 (and a_idle_Receiver z$1649))) (assert (= z$1652 (not z$1650))) (assert (= z$1653 (and z$1645 z$1652))) (assert (= z$1655 (not z$1653))) (assert (= z$1656 (not z$1655))) (assert (let (($x3500 (not z$1649))) (= z$1657 $x3500))) (assert (= z$1658 (and z$17 z$1657))) (assert (= z$1660 (not z$1658))) (assert (= z$1661 (and z$29 z$1660))) (assert (= z$1663 (not z$1661))) (assert (= z$1664 (and z$1656 z$1663))) (assert (= z$1666 (not z$1664))) (assert (= z$1667 (not z$1666))) (assert (= z$1668 (and z$49 z$1667))) (assert (let (($x3531 (not z$1660))) (= z$1670 $x3531))) (assert (= z$1671 (and a_new_file z$1670))) (assert (= z$1673 (not z$1671))) (assert (= z$1674 (and z$1668 z$1673))) (assert (= z$1676 (and a_next_frame a_wait_ack))) (assert (= z$1678 (not z$1676))) (assert (= z$1679 (and z$31 z$51))) (assert (= z$1681 (not z$1679))) (assert (= z$1682 (and a_success z$1681))) (assert (= z$1684 (not z$1682))) (assert (= z$1685 (and z$1678 z$1684))) (assert (= z$1687 (not z$1685))) (assert (= z$1688 (not z$1687))) (assert (let (($x3576 (not z$1681))) (= z$1689 $x3576))) (assert (= z$1690 (and z$47 z$1689))) (assert (= z$1692 (not z$1690))) (assert (= z$1693 (and a_error z$1692))) (assert (= z$1695 (not z$1693))) (assert (= z$1696 (and z$1688 z$1695))) (assert (= z$1698 (not z$1696))) (assert (= z$1699 (not z$1698))) (assert (let (($x242 (not a_error))) (= z$7 $x242))) (assert (let (($x3603 (not z$1692))) (= z$1700 $x3603))) (assert (= z$1701 (and z$7 z$1700))) (assert (= z$1703 (not z$1701))) (assert (= z$1704 (and z$27 z$1703))) (assert (= z$1706 (not z$1704))) (assert (= z$1707 (and z$1699 z$1706))) (assert (= z$1709 (not z$1707))) (assert (= z$1710 (not z$1709))) (assert (let (($x3630 (not z$1703))) (= z$1711 $x3630))) (assert (= z$1712 (and a_init_state z$1711))) (assert (= z$1714 (not z$1712))) (assert (= z$1715 (and a_idle_Sender z$1714))) (assert (= z$1717 (not z$1715))) (assert (= z$1718 (and z$1710 z$1717))) (assert (= z$1720 (not z$1718))) (assert (= z$1721 (not z$1720))) (assert (= z$1722 (and z$1674 z$1721))) (assert (let (($x3661 (not z$1714))) (= z$1724 $x3661))) (assert (= z$1725 (and z$19 z$1724))) (assert (= z$1727 (not z$1725))) (assert (= z$1728 (and z$1722 z$1727))) (assert (= z$1730 (and a_in_transit_K z$43))) (assert (= z$1732 (not z$1730))) (assert (= z$1733 (and z$21 a_start_K))) (assert (= z$1735 (not z$1733))) (assert (= z$1736 (and a_BAD_K z$1735))) (assert (= z$1738 (not z$1736))) (assert (= z$1739 (and z$1732 z$1738))) (assert (= z$1741 (not z$1739))) (assert (= z$1742 (not z$1741))) (assert (= z$1743 (and z$1728 z$1742))) (assert (let (($x3710 (not z$1735))) (= z$1745 $x3710))) (assert (= z$1746 (and z$1 z$1745))) (assert (= z$1748 (not z$1746))) (assert (= z$1749 (and z$1743 z$1748))) (assert (= z$1751 (and a_in_transit_L z$45))) (assert (= z$1753 (not z$1751))) (assert (let (($x274 (not a_in_transit_L))) (= z$23 $x274))) (assert (= z$1754 (and z$23 a_start_L))) (assert (= z$1756 (not z$1754))) (assert (= z$1757 (and a_BAD_L z$1756))) (assert (= z$1759 (not z$1757))) (assert (= z$1760 (and z$1753 z$1759))) (assert (= z$1762 (not z$1760))) (assert (= z$1763 (not z$1762))) (assert (= z$1764 (and z$1749 z$1763))) (assert (let (($x3759 (not z$1756))) (= z$1766 $x3759))) (assert (= z$1767 (and z$3 z$1766))) (assert (= z$1769 (not z$1767))) (assert (= z$1770 (and z$1764 z$1769))) (assert (= z$1772 (and z$39 a_dk))) (assert (= z$1774 (not z$1772))) (assert (= z$1775 (and a_ok_SClient z$5))) (assert (= z$1777 (not z$1775))) (assert (= z$1778 (and a_nok_SClient z$1777))) (assert (= z$1780 (not z$1778))) (assert (= z$1781 (and z$1774 z$1780))) (assert (= z$1783 (not z$1781))) (assert (= z$1784 (not z$1783))) (assert (let (($x3804 (not z$1777))) (= z$1785 $x3804))) (assert (= z$1786 (and z$35 z$1785))) (assert (= z$1788 (not z$1786))) (assert (= z$1789 (and a_send_req z$1788))) (assert (= z$1791 (not z$1789))) (assert (= z$1792 (and z$1784 z$1791))) (assert (= z$1794 (not z$1792))) (assert (= z$1795 (not z$1794))) (assert (let (($x3831 (not z$1788))) (= z$1796 $x3831))) (assert (= z$1797 (and z$41 z$1796))) (assert (= z$1799 (not z$1797))) (assert (= z$1800 (and a_file_req z$1799))) (assert (= z$1802 (not z$1800))) (assert (= z$1803 (and z$1795 z$1802))) (assert (= z$1805 (not z$1803))) (assert (= z$1806 (not z$1805))) (assert (= z$1807 (and z$1770 z$1806))) (assert (let (($x3862 (not z$1799))) (= z$1809 $x3862))) (assert (= z$1810 (and z$9 z$1809))) (assert (= z$1812 (not z$1810))) (assert (= z$1813 (and z$1807 z$1812))) (assert (= z$1815 (and z$37 a_inc))) (assert (= z$1817 (not z$1815))) (assert (let (($x278 (not a_inc))) (= z$25 $x278))) (assert (= z$1818 (and a_ok_RClient z$25))) (assert (= z$1820 (not z$1818))) (assert (= z$1821 (and a_nok_RClient z$1820))) (assert (= z$1823 (not z$1821))) (assert (= z$1824 (and z$1817 z$1823))) (assert (= z$1826 (not z$1824))) (assert (= z$1827 (not z$1826))) (assert (= z$1828 (and z$1813 z$1827))) (assert (let (($x293 (not a_nok_RClient))) (= z$33 $x293))) (assert (let (($x3911 (not z$1820))) (= z$1830 $x3911))) (assert (= z$1831 (and z$33 z$1830))) (assert (= z$1833 (not z$1831))) (assert (= z$1834 (and z$1828 z$1833))) (assert (= z$1836 (and z$1631 z$1834))) (assert (= z$1838 (and z$441 z$481))) (assert (= z$1840 (not z$1838))) (assert (let (($x3936 (not z$441))) (= z$1841 $x3936))) (assert (let (($x3939 (not z$481))) (= z$1842 $x3939))) (assert (= z$1843 (and z$1841 z$1842))) (assert (= z$1845 (not z$1843))) (assert (= z$1846 (and z$514 z$1845))) (assert (= z$1848 (not z$1846))) (assert (= z$1849 (and z$1840 z$1848))) (assert (= z$1851 (not z$1849))) (assert (= z$1852 (not z$1851))) (assert (let (($x3966 (not z$514))) (= z$1853 $x3966))) (assert (let (($x3969 (not z$1845))) (= z$1854 $x3969))) (assert (= z$1855 (and z$1853 z$1854))) (assert (= z$1857 (not z$1855))) (assert (= z$1858 (and z$541 z$1857))) (assert (= z$1860 (not z$1858))) (assert (= z$1861 (and z$1852 z$1860))) (assert (= z$1863 (not z$1861))) (assert (= z$1864 (not z$1863))) (assert (let (($x3996 (not z$541))) (= z$1865 $x3996))) (assert (let (($x3999 (not z$1857))) (= z$1866 $x3999))) (assert (= z$1867 (and z$1865 z$1866))) (assert (= z$1869 (not z$1867))) (assert (= z$1870 (and z$553 z$1869))) (assert (= z$1872 (not z$1870))) (assert (= z$1873 (and z$1864 z$1872))) (assert (= z$1875 (not z$1873))) (assert (= z$1876 (not z$1875))) (assert (= z$1877 (and z$49 z$1876))) (assert (let (($x4030 (not z$1869))) (= z$1879 $x4030))) (assert (= z$1880 (and z$554 z$1879))) (assert (= z$1882 (not z$1880))) (assert (= z$1883 (and z$1877 z$1882))) (assert (= z$1885 (and z$570 z$589))) (assert (= z$1887 (not z$1885))) (assert (let (($x4051 (not z$570))) (= z$1888 $x4051))) (assert (let (($x4054 (not z$589))) (= z$1889 $x4054))) (assert (= z$1890 (and z$1888 z$1889))) (assert (= z$1892 (not z$1890))) (assert (= z$1893 (and z$602 z$1892))) (assert (= z$1895 (not z$1893))) (assert (= z$1896 (and z$1887 z$1895))) (assert (= z$1898 (not z$1896))) (assert (= z$1899 (not z$1898))) (assert (let (($x4081 (not z$602))) (= z$1900 $x4081))) (assert (let (($x4084 (not z$1892))) (= z$1901 $x4084))) (assert (= z$1902 (and z$1900 z$1901))) (assert (= z$1904 (not z$1902))) (assert (= z$1905 (and z$615 z$1904))) (assert (= z$1907 (not z$1905))) (assert (= z$1908 (and z$1899 z$1907))) (assert (= z$1910 (not z$1908))) (assert (= z$1911 (not z$1910))) (assert (let (($x4111 (not z$615))) (= z$1912 $x4111))) (assert (let (($x4114 (not z$1904))) (= z$1913 $x4114))) (assert (= z$1914 (and z$1912 z$1913))) (assert (= z$1916 (not z$1914))) (assert (= z$1917 (and z$619 z$1916))) (assert (= z$1919 (not z$1917))) (assert (= z$1920 (and z$1911 z$1919))) (assert (= z$1922 (not z$1920))) (assert (= z$1923 (not z$1922))) (assert (let (($x4141 (not z$1916))) (= z$1924 $x4141))) (assert (= z$1925 (and z$621 z$1924))) (assert (= z$1927 (not z$1925))) (assert (= z$1928 (and z$636 z$1927))) (assert (= z$1930 (not z$1928))) (assert (= z$1931 (and z$1923 z$1930))) (assert (= z$1933 (not z$1931))) (assert (= z$1934 (not z$1933))) (assert (= z$1935 (and z$1883 z$1934))) (assert (let (($x4172 (not z$636))) (= z$1937 $x4172))) (assert (let (($x4175 (not z$1927))) (= z$1938 $x4175))) (assert (= z$1939 (and z$1937 z$1938))) (assert (= z$1941 (not z$1939))) (assert (= z$1942 (and z$1935 z$1941))) (assert (= z$1944 (and z$659 z$677))) (assert (= z$1946 (not z$1944))) (assert (let (($x4196 (not z$659))) (= z$1947 $x4196))) (assert (= z$1948 (and z$1947 z$678))) (assert (= z$1950 (not z$1948))) (assert (= z$1951 (and z$687 z$1950))) (assert (= z$1953 (not z$1951))) (assert (= z$1954 (and z$1946 z$1953))) (assert (= z$1956 (not z$1954))) (assert (= z$1957 (not z$1956))) (assert (= z$1958 (and z$1942 z$1957))) (assert (let (($x4227 (not z$687))) (= z$1960 $x4227))) (assert (let (($x4230 (not z$1950))) (= z$1961 $x4230))) (assert (= z$1962 (and z$1960 z$1961))) (assert (= z$1964 (not z$1962))) (assert (= z$1965 (and z$1958 z$1964))) (assert (= z$1967 (and z$706 z$720))) (assert (= z$1969 (not z$1967))) (assert (let (($x4251 (not z$706))) (= z$1970 $x4251))) (assert (= z$1971 (and z$1970 z$721))) (assert (= z$1973 (not z$1971))) (assert (= z$1974 (and z$730 z$1973))) (assert (= z$1976 (not z$1974))) (assert (= z$1977 (and z$1969 z$1976))) (assert (= z$1979 (not z$1977))) (assert (= z$1980 (not z$1979))) (assert (= z$1981 (and z$1965 z$1980))) (assert (let (($x4282 (not z$730))) (= z$1983 $x4282))) (assert (let (($x4285 (not z$1973))) (= z$1984 $x4285))) (assert (= z$1985 (and z$1983 z$1984))) (assert (= z$1987 (not z$1985))) (assert (= z$1988 (and z$1981 z$1987))) (assert (= z$1990 (and z$740 z$751))) (assert (= z$1992 (not z$1990))) (assert (let (($x4306 (not z$751))) (= z$1993 $x4306))) (assert (= z$1994 (and z$741 z$1993))) (assert (= z$1996 (not z$1994))) (assert (= z$1997 (and z$761 z$1996))) (assert (= z$1999 (not z$1997))) (assert (= z$2000 (and z$1992 z$1999))) (assert (= z$2002 (not z$2000))) (assert (= z$2003 (not z$2002))) (assert (let (($x4333 (not z$761))) (= z$2004 $x4333))) (assert (let (($x4336 (not z$1996))) (= z$2005 $x4336))) (assert (= z$2006 (and z$2004 z$2005))) (assert (= z$2008 (not z$2006))) (assert (= z$2009 (and z$775 z$2008))) (assert (= z$2011 (not z$2009))) (assert (= z$2012 (and z$2003 z$2011))) (assert (= z$2014 (not z$2012))) (assert (= z$2015 (not z$2014))) (assert (let (($x4363 (not z$775))) (= z$2016 $x4363))) (assert (let (($x4366 (not z$2008))) (= z$2017 $x4366))) (assert (= z$2018 (and z$2016 z$2017))) (assert (= z$2020 (not z$2018))) (assert (= z$2021 (and z$786 z$2020))) (assert (= z$2023 (not z$2021))) (assert (= z$2024 (and z$2015 z$2023))) (assert (= z$2026 (not z$2024))) (assert (= z$2027 (not z$2026))) (assert (= z$2028 (and z$1988 z$2027))) (assert (let (($x4397 (not z$786))) (= z$2030 $x4397))) (assert (let (($x4400 (not z$2020))) (= z$2031 $x4400))) (assert (= z$2032 (and z$2030 z$2031))) (assert (= z$2034 (not z$2032))) (assert (= z$2035 (and z$2028 z$2034))) (assert (= z$2037 (and z$797 z$812))) (assert (= z$2039 (not z$2037))) (assert (let (($x4421 (not z$812))) (= z$2040 $x4421))) (assert (= z$2041 (and z$799 z$2040))) (assert (= z$2043 (not z$2041))) (assert (= z$2044 (and z$823 z$2043))) (assert (= z$2046 (not z$2044))) (assert (= z$2047 (and z$2039 z$2046))) (assert (= z$2049 (not z$2047))) (assert (= z$2050 (not z$2049))) (assert (= z$2051 (and z$2035 z$2050))) (assert (let (($x4452 (not z$823))) (= z$2053 $x4452))) (assert (let (($x4455 (not z$2043))) (= z$2054 $x4455))) (assert (= z$2055 (and z$2053 z$2054))) (assert (= z$2057 (not z$2055))) (assert (= z$2058 (and z$2051 z$2057))) (assert (= z$2060 (and z$1836 z$2058))) (assert (= z$2062 (and z$2060 z$53))) (assert (= z$2064 (not z$2062))) (assert (= z$2065 (= dve_invalid$next z$2064))) (assert (= z$2115 (not dve_invalid$next))) (assert (let (($x145 (Extract_1_15_15_16 v_X$next))) (= z$2116 $x145))) (assert (let ((?x149 (Concat_32_16_16 z$n0s16 v_X$next))) (= z$2118 ?x149))) (assert (let ((?x153 (BitWiseNot_32_32 z$2118))) (= z$2120 ?x153))) (assert (let ((?x157 (ShiftR_32_32_32 z$2120 z$n16s32))) (= z$2122 ?x157))) (assert (let ((?x161 (BitWiseNot_32_32 z$2122))) (= z$2124 ?x161))) (assert (let ((?x165 (ShiftR_32_32_32 z$2118 z$n16s32))) (= z$2126 ?x165))) (assert (let ((?x169 (ite z$2116 z$2124 z$2126))) (= z$2128 ?x169))) (assert (let ((?x174 (BitWiseXor_16_16_16 z$n30s16 v_SYNC$next))) (= z$2130 ?x174))) (assert (let (($x178 (Extract_1_15_15_16 z$2130))) (= z$2132 $x178))) (assert (let ((?x182 (Concat_32_16_16 z$n0s16 z$2130))) (= z$2134 ?x182))) (assert (let ((?x186 (BitWiseNot_32_32 z$2134))) (= z$2136 ?x186))) (assert (let ((?x190 (ShiftR_32_32_32 z$2136 z$n16s32))) (= z$2138 ?x190))) (assert (let ((?x194 (BitWiseNot_32_32 z$2138))) (= z$2140 ?x194))) (assert (let ((?x198 (ShiftR_32_32_32 z$2134 z$n16s32))) (= z$2142 ?x198))) (assert (let ((?x202 (ite z$2132 z$2140 z$2142))) (= z$2144 ?x202))) (assert (let (($x206 (= z$2128 z$2144))) (= z$2146 $x206))) (assert (= z$2147 (and a_error$next z$2146))) (assert (= z$2149 (and a_new_file$next z$2147))) (assert (= z$2151 (and z$2115 z$2149))) (assert (= z$2153 (not z$2151))) (assert (= z$2154 (= prop$next z$2153))) (assert (let (($x7333 (= v_X$next z$n0s16))) (= z$2466 $x7333))) (assert (let (($x5679 (= z$2126 z$n5s32))) (= z$2593 $x5679))) (assert (= z$4224 (and z$2466 z$2593))) (assert (= z$4226 (not z$4224))) (assert (let (($x347 (= v_X z$n0s16))) (= z$64 $x347))) (assert (= z$4225 (and z$64 z$2501))) (assert (= z$4234 (not z$4225))) (assert (= z$5291 (and z$2116 z$2466))) (assert (= z$5293 (not z$5291))) (assert (= z$5292 (and z$114 z$64))) (assert (= z$5297 (not z$5292))) (assert (= z$2360 (and (distinct z$2118 z$2126) true))) (assert (= z$7528 (and z$2360 z$2466))) (assert (= z$7530 (not z$7528))) (assert (= z$2381 (and (distinct z$116 z$125) true))) (assert (= z$7529 (and z$2381 z$64))) (assert (= z$7537 (not z$7529))) (assert (let (($x15021 (= z$2142 z$2118))) (= z$7542 $x15021))) (assert (= z$2361 (and (distinct z$2118 z$2134) true))) (assert (= z$7587 (and z$7542 z$2361))) (assert (= z$7590 (not z$7587))) (assert (let (($x13482 (= z$889 z$116))) (= z$7588 $x13482))) (assert (= z$2382 (and (distinct z$116 z$881) true))) (assert (= z$7589 (and z$7588 z$2382))) (assert (= z$7595 (not z$7589))) (assert (let (($x18077 (= z$116 z$881))) (= z$7599 $x18077))) (assert (let (($x22502 (= z$116 z$125))) (= z$7540 $x22502))) (assert (= z$7615 (and z$7599 z$7540 z$2369))) (assert (= z$7617 (not z$7615))) (assert (let (($x25104 (= z$2118 z$2134))) (= z$7594 $x25104))) (assert (let (($x13655 (= z$2118 z$2126))) (= z$7533 $x13655))) (assert (= z$2352 (and (distinct z$2130 z$n0s16) true))) (assert (= z$7614 (and z$7594 z$7533 z$2352))) (assert (= z$7616 (not z$7614))) (assert (let (($x27413 (= z$2130 z$n0s16))) (= z$7627 $x27413))) (assert (= z$2353 (and (distinct v_SYNC$next z$n30s16) true))) (assert (= z$7664 (and z$7627 z$2353))) (assert (= z$7666 (not z$7664))) (assert (let (($x22249 (= z$94 z$n0s16))) (= z$7622 $x22249))) (assert (= z$7665 (and z$7622 z$2371))) (assert (= z$7671 (not z$7665))) (assert (= z$2469 (and (distinct z$2118 z$n5s32) true))) (assert (= z$2511 (and (distinct z$116 z$n5s32) true))) (assert (let ((?x7975 (BitWiseXor_16_16_16 z$n3s16 v_n$next))) (= z$2531 ?x7975))) (assert (let ((?x5968 (BitWiseXor_16_16_16 z$n3s16 z$2531))) (= z$2565 ?x5968))) (assert (let (($x13067 (= v_n$next z$2565))) (= z$7740 $x13067))) (assert (let (($x34116 (= v_n z$89))) (= z$7738 $x34116))) (assert (= z$2496 (and (distinct z$87 z$n3s16) true))) (assert (= z$7815 (and z$77 z$2496))) (assert (= z$7817 (not z$7815))) (assert (let (($x17754 (= v_n$next z$n0s16))) (= z$4216 $x17754))) (assert (= z$2589 (and (distinct z$2531 z$n3s16) true))) (assert (= z$7816 (and z$4216 z$2589))) (assert (= z$7826 (not z$7816))) (assert (let (($x5321 (= z$87 z$n3s16))) (= z$7821 $x5321))) (assert (= z$2472 (and (distinct v_i z$n3s8) true))) (assert (= z$7865 (and z$7821 z$2472 z$409))) (assert (= z$7873 (not z$7865))) (assert (let (($x9283 (= z$2531 z$n3s16))) (= z$7830 $x9283))) (assert (= z$2564 (and (distinct v_i$next z$n3s8) true))) (assert (let (($x7969 (Extract_1_15_15_16 z$2531))) (= z$2544 $x7969))) (assert (let ((?x7882 (Concat_32_16_16 z$n0s16 z$2531))) (= z$2546 ?x7882))) (assert (let ((?x7903 (BitWiseNot_32_32 z$2546))) (= z$2548 ?x7903))) (assert (let ((?x6546 (ShiftR_32_32_32 z$2548 z$n16s32))) (= z$2550 ?x6546))) (assert (let ((?x7797 (BitWiseNot_32_32 z$2550))) (= z$2552 ?x7797))) (assert (let ((?x6224 (ShiftR_32_32_32 z$2546 z$n16s32))) (= z$2554 ?x6224))) (assert (let ((?x5966 (ite z$2544 z$2552 z$2554))) (= z$2556 ?x5966))) (assert (let ((?x10322 (Extract_8_7_0_32 z$2552))) (= z$7867 ?x10322))) (assert (let ((?x37128 (Extract_8_7_0_32 z$2554))) (= z$7868 ?x37128))) (assert (let ((?x9203 (ite z$2544 z$7867 z$7868))) (= z$7869 ?x9203))) (assert (let ((?x5089 (Extract_8_7_0_32 z$2556))) (= z$7866 ?x5089))) (assert (= z$7866 z$7869)) (assert (let (($x18176 (= v_i$next z$7866))) (= z$7871 $x18176))) (assert (= z$7872 (and z$7830 z$2564 z$7871))) (assert (= z$7878 (not z$7872))) (assert (= z$2529 (and (distinct z$360 z$394) true))) (assert (= z$8676 (and z$7821 z$2529 z$1055))) (assert (= z$8678 (not z$8676))) (assert (let ((?x6449 (Concat_32_8_24 v_rc$next z$n0s24))) (= z$2595 ?x6449))) (assert (= z$2621 (and (distinct z$2595 z$2554) true))) (assert (let (($x6777 (= z$n3s8 v_rc$next))) (= z$2540 $x6777))) (assert (= z$8677 (and z$7830 z$2621 z$2540))) (assert (= z$8686 (not z$8677))) (assert (= z$8723 (and z$1194 z$1053))) (assert (= z$8726 (not z$8723))) (assert (let (($x6995 (GrEq_1_32_32 z$2128 z$n5s32))) (= z$2561 $x6995))) (assert (= z$2563 (not z$2561))) (assert (let (($x13340 (= z$n5s32 z$2128))) (= z$8724 $x13340))) (assert (= z$8725 (and z$2563 z$8724))) (assert (= z$8728 (not z$8725))) (assert (= z$8767 (and z$237 z$7320))) (assert (= z$8769 (not z$8767))) (assert (let (($x20140 (Extract_1_15_15_16 v_W$next))) (= z$6850 $x20140))) (assert (let ((?x12038 (Concat_32_16_16 z$n0s16 v_W$next))) (= z$6852 ?x12038))) (assert (let ((?x17803 (ShiftR_32_32_32 z$6852 z$n16s32))) (= z$6864 ?x17803))) (assert (let (($x19326 (= z$6864 z$n5s32))) (= z$7323 $x19326))) (assert (= z$8768 (and z$6850 z$7323))) (assert (= z$8771 (not z$8768))) (assert (= z$2666 (and (distinct z$116 z$n0s32) true))) (assert (= z$8806 (and z$2666 z$7540))) (assert (= z$8808 (not z$8806))) (assert (= z$2652 (and (distinct z$2118 z$n0s32) true))) (assert (= z$8807 (and z$2652 z$7533))) (assert (= z$8812 (not z$8807))) (assert (let (($x54932 (= z$96 z$n30s16))) (= z$7677 $x54932))) (assert (= z$8863 (and z$2369 z$7677))) (assert (= z$8865 (not z$8863))) (assert (let ((?x4961 (BitWiseXor_16_16_16 z$n30s16 z$2130))) (= z$2421 ?x4961))) (assert (let (($x18658 (= z$2421 z$n30s16))) (= z$7678 $x18658))) (assert (= z$8864 (and z$2352 z$7678))) (assert (= z$8868 (not z$8864))) (assert (let (($x15406 (= z$2140 z$2118))) (= z$8916 $x15406))) (assert (= z$8969 (and z$2146 z$8916))) (assert (= z$8972 (not z$8969))) (assert (let (($x46980 (= z$887 z$116))) (= z$8970 $x46980))) (assert (= z$8971 (and z$979 z$8970))) (assert (= z$8977 (not z$8971))) (assert (= z$2366 (and (distinct v_X z$94) true))) (assert (= z$10957 (and z$7599 z$2366))) (assert (= z$10959 (not z$10957))) (assert (= z$2350 (and (distinct v_X$next z$2130) true))) (assert (= z$10956 (and z$7594 z$2350))) (assert (= z$10958 (not z$10956))) (assert (let (($x61538 (= v_SYNC z$96))) (= z$10985 $x61538))) (assert (let (($x78126 (= v_SYNC$next z$2421))) (= z$10983 $x78126))) (assert (let (($x75468 (= v_X$next z$2130))) (= z$10965 $x75468))) (assert (let (($x55065 (= v_SYNC$next z$n0s16))) (= z$4214 $x55065))) (assert (= z$2348 (and (distinct v_X$next z$n30s16) true))) (assert (= z$11068 (and z$10965 z$4214 z$2348))) (assert (= z$11070 (not z$11068))) (assert (let (($x30262 (= v_X z$94))) (= z$10962 $x30262))) (assert (= z$2364 (and (distinct v_X z$n30s16) true))) (assert (= z$11069 (and z$10962 z$56 z$2364))) (assert (= z$11080 (not z$11069))) (assert (let (($x76639 (= z$125 z$n0s32))) (= z$8820 $x76639))) (assert (= z$3249 (and (distinct z$150 z$n0s32) true))) (assert (= z$11132 (and z$8820 z$3249 z$143))) (assert (= z$11134 (not z$11132))) (assert (let (($x62007 (= z$2126 z$n0s32))) (= z$8823 $x62007))) (assert (let ((?x7505 (BitWiseXor_16_16_16 z$n31s16 v_maxtime$next))) (= z$3325 ?x7505))) (assert (let (($x7125 (Extract_1_15_15_16 z$3325))) (= z$3327 $x7125))) (assert (let ((?x5824 (Concat_32_16_16 z$n0s16 z$3325))) (= z$3329 ?x5824))) (assert (let ((?x6779 (BitWiseNot_32_32 z$3329))) (= z$3331 ?x6779))) (assert (let ((?x9224 (ShiftR_32_32_32 z$3331 z$n16s32))) (= z$3333 ?x9224))) (assert (let ((?x6268 (BitWiseNot_32_32 z$3333))) (= z$3335 ?x6268))) (assert (let ((?x7165 (ShiftR_32_32_32 z$3329 z$n16s32))) (= z$3337 ?x7165))) (assert (let ((?x5465 (ite z$3327 z$3335 z$3337))) (= z$3339 ?x5465))) (assert (let (($x9469 (GrEq_1_32_32 z$2128 z$3339))) (= z$3341 $x9469))) (assert (let (($x9529 (not z$3341))) (= z$3343 $x9529))) (assert (let ((?x6852 (ite z$3343 z$n1s32 z$n0s32))) (= z$3344 ?x6852))) (assert (let ((?x6116 (Add_32_32_32 z$2128 z$3344))) (= z$3346 ?x6116))) (assert (= z$3366 (and (distinct z$3346 z$n0s32) true))) (assert (= z$11133 (and z$8823 z$3366 z$3341))) (assert (= z$11139 (not z$11133))) (assert (let (($x79272 (= z$150 z$n0s32))) (= z$11138 $x79272))) (assert (= z$11201 (and z$11085 z$11138))) (assert (= z$11203 (not z$11201))) (assert (let (($x61677 (= v_X$next z$n30s16))) (= z$11075 $x61677))) (assert (let (($x51413 (= z$3346 z$n0s32))) (= z$11143 $x51413))) (assert (= z$11200 (and z$11075 z$11143))) (assert (= z$11202 (not z$11200))) (assert (= z$3262 (and (distinct z$855 z$n1s32) true))) (assert (= z$11254 (and z$8820 z$3262))) (assert (= z$11256 (not z$11254))) (assert (let ((?x9294 (Add_32_32_32 z$n1s32 z$2128))) (= z$3307 ?x9294))) (assert (= z$3379 (and (distinct z$3307 z$n1s32) true))) (assert (= z$11255 (and z$8823 z$3379))) (assert (= z$11260 (not z$11255))) (assert (let (($x59765 (= z$3307 z$n1s32))) (= z$11263 $x59765))) (assert (= z$11295 (and z$11075 z$11263))) (assert (= z$11297 (not z$11295))) (assert (= z$11296 (and z$11085 z$11259))) (assert (= z$11304 (not z$11296))) (assert (= z$5223 (and (distinct z$3346 z$2126) true))) (assert (= z$3403 (and (distinct z$3346 z$3307) true))) (assert (= z$11320 (and z$11075 z$5223 z$3403))) (assert (= z$11322 (not z$11320))) (assert (= z$5217 (and (distinct z$150 z$125) true))) (assert (= z$11321 (and z$11085 z$5217 z$3286))) (assert (= z$11332 (not z$11321))) (assert (= z$5205 (and (distinct z$2126 z$3307) true))) (assert (= z$5198 (and (distinct z$125 z$855) true))) (assert (= z$11385 (and z$11138 z$11075 z$168))) (assert (= z$11386 (not z$11385))) (assert (= z$3375 (and (distinct z$3346 z$n1s32) true))) (assert (= z$11410 (and z$8823 z$3375 z$3343))) (assert (= z$11412 (not z$11410))) (assert (= z$3258 (and (distinct z$150 z$n1s32) true))) (assert (= z$11409 (and z$8820 z$3258 z$145))) (assert (= z$11411 (not z$11409))) (assert (let (($x45205 (= z$2126 z$n1s32))) (= z$11418 $x45205))) (assert (= z$11460 (and z$11075 z$11418))) (assert (= z$11463 (not z$11460))) (assert (let (($x77994 (= z$125 z$n1s32))) (= z$11461 $x77994))) (assert (= z$11462 (and z$11085 z$11461))) (assert (= z$11469 (not z$11462))) (assert (= z$11496 (and z$11346 z$11075 z$168))) (assert (= z$11497 (not z$11496))) (assert (= z$2354 (and (distinct z$2130 z$n30s16) true))) (assert (= z$11540 (and z$4214 z$2354))) (assert (= z$11542 (not z$11540))) (assert (= z$2372 (and (distinct z$94 z$n30s16) true))) (assert (= z$11541 (and z$56 z$2372))) (assert (= z$11548 (not z$11541))) (assert (let (($x19774 (= z$889 z$125))) (= z$11590 $x19774))) (assert (= z$11591 (and z$11590 z$2382))) (assert (= z$11593 (not z$11591))) (assert (let (($x31514 (= z$2142 z$2126))) (= z$2356 $x31514))) (assert (= z$11589 (and z$2356 z$2361))) (assert (= z$11592 (not z$11589))) (assert (let (($x21607 (= z$94 z$n30s16))) (= z$11091 $x21607))) (assert (= z$11623 (and z$11091 z$879))) (assert (= z$11625 (not z$11623))) (assert (let (($x45643 (= z$2130 z$n30s16))) (= z$11090 $x45643))) (assert (= z$11622 (and z$11090 z$2132))) (assert (= z$11624 (not z$11622))) (assert (= z$4472 (and (distinct z$123 z$889) true))) (assert (= z$4550 (and (distinct z$2124 z$2142) true))) (assert (= z$12103 (and z$11259 z$11075 z$168))) (assert (= z$12104 (not z$12103))) (assert (let (($x44064 (= z$125 z$150))) (= z$11335 $x44064))) (assert (= z$12130 (and z$11335 z$11091 z$11075 z$893 z$168))) (assert (= z$12131 (not z$12130))) (assert (= z$12156 (and z$11091 z$11075 z$893 z$168 z$143))) (assert (= z$12157 (not z$12156))) (assert (= z$3279 (and (distinct z$889 z$150) true))) (assert (= z$12190 (and z$11091 z$11075 z$3279 z$893 z$168))) (assert (= z$12191 (not z$12190))) (assert (let (($x28534 (= z$3346 z$2142))) (= z$12198 $x28534))) (assert (= z$3399 (and (distinct z$2142 z$3307) true))) (assert (let (($x7429 (GrEq_1_32_32 z$2144 z$3307))) (= z$3315 $x7429))) (assert (= z$12216 (and z$12198 z$3399 z$3315))) (assert (= z$12218 (not z$12216))) (assert (= z$3282 (and (distinct z$889 z$855) true))) (assert (= z$12215 (and z$12194 z$3282 z$893))) (assert (= z$12217 (not z$12215))) (assert (let (($x9529 (not z$3341))) (= z$7349 $x9529))) (assert (let (($x6741 (Extract_1_15_15_16 v_U$next))) (= z$2766 $x6741))) (assert (let ((?x5353 (Concat_32_16_16 z$n0s16 v_U$next))) (= z$2768 ?x5353))) (assert (let ((?x9419 (BitWiseNot_32_32 z$2768))) (= z$2775 ?x9419))) (assert (let ((?x9423 (ShiftR_32_32_32 z$2775 z$n16s32))) (= z$2777 ?x9423))) (assert (let ((?x9429 (BitWiseNot_32_32 z$2777))) (= z$2779 ?x9429))) (assert (let ((?x8762 (ShiftR_32_32_32 z$2768 z$n16s32))) (= z$2781 ?x8762))) (assert (let ((?x9425 (ite z$2766 z$2779 z$2781))) (= z$2783 ?x9425))) (assert (let (($x12286 (GrEq_1_32_32 z$2783 z$3339))) (= z$5467 $x12286))) (assert (let (($x9431 (GrEq_1_32_32 z$n2s32 z$2783))) (= z$2788 $x9431))) (assert (= z$12245 (and z$12198 z$11090 z$7349 z$5467 z$2788))) (assert (= z$12247 (not z$12245))) (assert (let (($x439 (not z$143))) (= z$7337 $x439))) (assert (= z$12244 (and z$12194 z$11091 z$7337 z$185 z$991))) (assert (= z$12246 (not z$12244))) (assert (= z$6804 (and (distinct z$826 z$n0s32) true))) (assert (= z$12270 (and z$828 z$6804))) (assert (= z$12272 (not z$12270))) (assert (let ((?x34748 (BitWiseNot_32_32 z$6852))) (= z$6858 ?x34748))) (assert (let ((?x15407 (ShiftR_32_32_32 z$6858 z$n16s32))) (= z$6860 ?x15407))) (assert (let ((?x21449 (BitWiseNot_32_32 z$6860))) (= z$6862 ?x21449))) (assert (let ((?x5297 (ite z$6850 z$6862 z$6864))) (= z$6866 ?x5297))) (assert (let ((?x20065 (Add_32_32_32 z$n1s32 z$6866))) (= z$6868 ?x20065))) (assert (let (($x19646 (GrEq_1_32_32 z$n0s32 z$6868))) (= z$6870 $x19646))) (assert (= z$6896 (and (distinct z$6868 z$n0s32) true))) (assert (= z$12271 (and z$6870 z$6896))) (assert (= z$12276 (not z$12271))) (assert (let (($x20835 (not z$5467))) (= z$5469 $x20835))) (assert (let ((?x20457 (ite z$5469 z$n1s32 z$n0s32))) (= z$5663 ?x20457))) (assert (let ((?x20828 (Add_32_32_32 z$2783 z$5663))) (= z$5665 ?x20828))) (assert (let ((?x7368 (Add_32_32_32 z$n1s32 z$2783))) (= z$3491 ?x7368))) (assert (= z$5738 (and (distinct z$5665 z$3491) true))) (assert (= z$12979 (and z$5738 z$5469))) (assert (= z$12981 (not z$12979))) (assert (= z$5653 (and (distinct z$190 z$901) true))) (assert (= z$12978 (and z$5653 z$187))) (assert (= z$12980 (not z$12978))) (assert (= z$10412 (and (distinct z$190 z$n2s32) true))) (assert (= z$5600 (and (distinct z$190 z$n1s32) true))) (assert (= z$13026 (and z$10412 z$5600 z$903 z$187))) (assert (= z$13028 (not z$13026))) (assert (= z$10423 (and (distinct z$5665 z$n2s32) true))) (assert (= z$5685 (and (distinct z$5665 z$n1s32) true))) (assert (let (($x4679 (GrEq_1_32_32 z$n2s32 z$3491))) (= z$3493 $x4679))) (assert (= z$13027 (and z$10423 z$5685 z$3493 z$5469))) (assert (= z$13033 (not z$13027))) (assert (= z$2805 (and (distinct z$2781 z$n2s32) true))) (assert (let (($x6878 (GrEq_1_32_32 z$n0s32 z$2783))) (= z$2785 $x6878))) (assert (let (($x4959 (not z$2785))) (= z$2787 $x4959))) (assert (= z$13077 (and f00 z$13031 z$2805 z$2787 z$200))) (assert (= z$13078 (not z$13077))) (assert (let (($x77012 (= z$3491 z$n1s32))) (= z$11270 $x77012))) (assert (= z$13124 (and z$2787 z$11270))) (assert (= z$13126 (not z$13124))) (assert (= z$13123 (and z$990 z$11269))) (assert (= z$13125 (not z$13123))) (assert (= z$13164 (and z$2210 z$988))) (assert (= z$13166 (not z$13164))) (assert (let (($x8863 (not z$2788))) (= z$6997 $x8863))) (assert (= z$13165 (and z$6997 z$2785))) (assert (= z$13168 (not z$13165))) (assert (= z$2758 (and (distinct z$181 z$n0s32) true))) (assert (= z$13192 (and z$2758 z$11269))) (assert (= z$13194 (not z$13192))) (assert (= z$2803 (and (distinct z$2781 z$n0s32) true))) (assert (= z$13193 (and z$2803 z$11270))) (assert (= z$13196 (not z$13193))) (assert (= z$2757 (and (distinct z$173 z$n0s32) true))) (assert (= z$13220 (and z$2757 z$8822))) (assert (= z$13222 (not z$13220))) (assert (= z$2802 (and (distinct z$2768 z$n0s32) true))) (assert (let (($x82982 (= z$2781 z$n0s32))) (= z$8825 $x82982))) (assert (= z$13221 (and z$2802 z$8825))) (assert (= z$13224 (not z$13221))) (assert (let (($x71613 (= z$173 z$n0s32))) (= z$8821 $x71613))) (assert (= z$13249 (and z$2746 z$8821))) (assert (= z$13251 (not z$13249))) (assert (= z$2791 (and (distinct v_U$next z$n0s16) true))) (assert (let (($x41692 (= z$2768 z$n0s32))) (= z$8824 $x41692))) (assert (= z$13250 (and z$2791 z$8824))) (assert (= z$13253 (not z$13250))) (assert (let (($x47828 (= z$3491 z$5665))) (= z$12984 $x47828))) (assert (= z$13274 (and z$12984 z$5467))) (assert (= z$13276 (not z$13274))) (assert (let (($x57539 (= z$190 z$901))) (= z$12987 $x57539))) (assert (= z$13273 (and z$12987 z$185))) (assert (= z$13275 (not z$13273))) (assert (= z$13306 (and z$12194 z$11091 z$2165 z$145 z$185 z$903))) (assert (= z$13308 (not z$13306))) (assert (let (($x6353 (not z$2766))) (= z$2767 $x6353))) (assert (= z$13307 (and z$12198 z$11090 z$2767 z$3343 z$5467 z$3493))) (assert (= z$13310 (not z$13307))) (assert (= z$4684 (and (distinct z$181 z$179) true))) (assert (= z$4859 (and (distinct z$2781 z$2779) true))) (assert (= z$13420 (and z$171 z$11347))) (assert (= z$13422 (not z$13420))) (assert (let (($x78617 (= z$5665 z$n1s32))) (= z$11349 $x78617))) (assert (= z$13421 (and z$2766 z$11349))) (assert (= z$13425 (not z$13421))) (assert (= z$13447 (and z$200 z$171 z$566 z$650 z$2767))) (assert (= z$13448 (not z$13447))) (assert (= z$5592 (and (distinct z$190 z$n0s32) true))) (assert (let (($x8841 (= v_U$next z$n0s16))) (= z$3054 $x8841))) (assert (= z$13497 (and z$5592 z$3054 z$200 z$185 z$566 z$650))) (assert (= z$13498 (not z$13497))) (assert (= z$13542 (and z$13031 z$3054 z$200 z$650 z$566))) (assert (= z$13543 (not z$13542))) (assert (= z$13579 (and z$12198 z$11346 z$11090 z$168))) (assert (= z$13580 (not z$13579))) (assert (= z$14595 (and z$13031 z$988))) (assert (= z$14597 (not z$14595))) (assert (let (($x38297 (= z$5665 z$n2s32))) (= z$13036 $x38297))) (assert (= z$14596 (and z$13036 z$2785))) (assert (= z$14599 (not z$14596))) (assert (= z$4844 (and (distinct z$2781 z$n1s32) true))) (assert (let (($x82441 (= z$3491 z$n2s32))) (= z$13041 $x82441))) (assert (= z$14627 (and z$4844 z$13041))) (assert (= z$14629 (not z$14627))) (assert (= z$4669 (and (distinct z$181 z$n1s32) true))) (assert (= z$14626 (and z$4669 z$13040))) (assert (= z$14628 (not z$14626))) (assert (= z$5377 (and (distinct z$271 z$n0s32) true))) (assert (let (($x25102 (= z$271 z$279))) (= z$13642 $x25102))) (assert (= z$14660 (and z$5377 z$13642))) (assert (= z$14662 (not z$14660))) (assert (let ((?x18245 (Concat_32_16_16 z$n0s16 v_Z$next))) (= z$5445 ?x18245))) (assert (= z$5503 (and (distinct z$5445 z$n0s32) true))) (assert (let ((?x16815 (ShiftR_32_32_32 z$5445 z$n16s32))) (= z$5459 ?x16815))) (assert (let (($x16504 (= z$5445 z$5459))) (= z$13645 $x16504))) (assert (= z$14661 (and z$5503 z$13645))) (assert (= z$14666 (not z$14661))) (assert (let (($x29020 (= z$2781 z$n1s32))) (= z$14632 $x29020))) (assert (= z$14693 (and z$14632 z$988 z$200 z$185))) (assert (= z$14694 (not z$14693))) (assert (= z$14728 (and z$14632 z$5600 z$200 z$185))) (assert (= z$14729 (not z$14728))) (assert (= z$14756 (and z$12198 z$11138 z$11090 z$168))) (assert (= z$14757 (not z$14756))) (assert (= z$14860 (and z$62 z$6802))) (assert (= z$14862 (not z$14860))) (assert (let (($x17439 (= v_W$next z$n0s16))) (= z$7344 $x17439))) (assert (= z$6894 (and (distinct z$6852 z$n0s32) true))) (assert (= z$14861 (and z$7344 z$6894))) (assert (= z$14867 (not z$14861))) (assert (= z$6803 (and (distinct z$247 z$n0s32) true))) (assert (let (($x42423 (= z$239 z$n0s32))) (= z$8832 $x42423))) (assert (= z$14891 (and z$6803 z$8832))) (assert (= z$14893 (not z$14891))) (assert (= z$6895 (and (distinct z$6864 z$n0s32) true))) (assert (let (($x57827 (= z$6852 z$n0s32))) (= z$8834 $x57827))) (assert (= z$14892 (and z$6895 z$8834))) (assert (= z$14896 (not z$14892))) (assert (let (($x36260 (= z$6868 z$n0s32))) (= z$12280 $x36260))) (assert (let (($x21030 (= z$6864 z$n0s32))) (= z$8835 $x21030))) (assert (= z$14928 (and z$12280 z$8835))) (assert (= z$14930 (not z$14928))) (assert (let (($x77485 (= z$247 z$n0s32))) (= z$8833 $x77485))) (assert (= z$14927 (and z$12275 z$8833))) (assert (= z$14929 (not z$14927))) (assert (let (($x43684 (= z$2126 z$n2s32))) (= z$14962 $x43684))) (assert (= z$15039 (and z$11075 z$14962))) (assert (= z$15041 (not z$15039))) (assert (let (($x59514 (= z$125 z$n2s32))) (= z$14964 $x59514))) (assert (= z$15040 (and z$11085 z$14964))) (assert (= z$15047 (not z$15040))) (assert (let (($x74751 (= z$2781 z$n2s32))) (= z$13082 $x74751))) (assert (= z$15102 (and z$13082 z$11347 z$200))) (assert (= z$15103 (not z$15102))) (assert (let (($x76288 (= z$855 z$889))) (= z$12226 $x76288))) (assert (= z$15165 (and z$12226 z$11091 z$5217 z$143))) (assert (= z$15167 (not z$15165))) (assert (let (($x79911 (= z$2142 z$3307))) (= z$12222 $x79911))) (assert (= z$15166 (and z$12222 z$11090 z$5223 z$3341))) (assert (= z$15170 (not z$15166))) (assert (let (($x5988 (not z$2116))) (= z$2231 $x5988))) (assert (let (($x34058 (and z$12198 z$11090 z$1281 z$2231 z$105 z$143 z$168 z$3343))) (= z$15193 $x34058))) (assert (= z$15194 (not z$15193))) (assert (= z$9028 (and (distinct z$123 z$125) true))) (assert (= z$9027 (and (distinct z$2124 z$2126) true))) (assert (let (($x7038 (not z$129))) (= z$2164 $x7038))) (assert (= z$15330 (and z$114 z$7337 z$2164))) (assert (= z$15332 (not z$15330))) (assert (let (($x70362 (not z$3327))) (= z$3503 $x70362))) (assert (= z$15331 (and z$2116 z$7349 z$3503))) (assert (= z$15334 (not z$15331))) (assert (= z$5045 (and (distinct z$137 z$139) true))) (assert (= z$5148 (and (distinct z$3335 z$3337) true))) (assert (= z$15402 (and z$114 z$12194))) (assert (= z$15404 (not z$15402))) (assert (= z$15403 (and z$2116 z$12198))) (assert (= z$15406 (not z$15403))) (assert (let ((?x9455 (BitWiseXor_16_16_16 z$n31s16 z$3325))) (= z$3591 ?x9455))) (assert (let (($x46603 (= v_maxtime$next z$3591))) (= z$15538 $x46603))) (assert (let (($x71698 (= v_maxtime z$103))) (= z$15536 $x71698))) (assert (let (($x36745 (= z$103 z$n0s16))) (= z$15664 $x36745))) (assert (= z$15701 (and z$129 z$15664))) (assert (= z$15703 (not z$15701))) (assert (let (($x22265 (= z$3591 z$n0s16))) (= z$15665 $x22265))) (assert (= z$15702 (and z$3327 z$15665))) (assert (= z$15706 (not z$15702))) (assert (= z$3529 (and (distinct z$101 z$n31s16) true))) (assert (= z$15756 (and z$3529 z$75))) (assert (= z$15758 (not z$15756))) (assert (= z$3602 (and (distinct z$3325 z$n31s16) true))) (assert (let (($x37515 (= v_maxtime$next z$n0s16))) (= z$4215 $x37515))) (assert (= z$15757 (and z$3602 z$4215))) (assert (= z$15767 (not z$15757))) (assert (let (($x34110 (= z$2126 z$3346))) (= z$11325 $x34110))) (assert (= z$15824 (and z$11325 z$3343))) (assert (= z$15826 (not z$15824))) (assert (= z$15823 (and z$11335 z$145))) (assert (= z$15825 (not z$15823))) (assert (let (($x80227 (and f00 z$12226 z$12198 z$11091 z$11090 z$3343 z$168 z$145))) (= z$15851 $x80227))) (assert (= z$15852 (not z$15851))) (assert (= z$15905 (and z$11347 z$4669 z$185))) (assert (= z$15907 (not z$15905))) (assert (= z$15906 (and z$11349 z$4844 z$5467))) (assert (= z$15909 (not z$15906))) (assert (= z$15958 (and z$145 z$3286))) (assert (= z$15960 (not z$15958))) (assert (= z$15959 (and z$3343 z$3403))) (assert (= z$15962 (not z$15959))) (assert (= z$5199 (and (distinct z$2126 z$n1s32) true))) (assert (let (($x37673 (and f00 z$562 z$574 z$577 z$588 z$650 z$654 z$11346 z$5199 z$168))) (= z$15994 $x37673))) (assert (= z$15995 (not z$15994))) (assert (let (($x82125 (and z$1 z$19 a_init_state z$31 a_start_K z$47 z$51 z$53 z$2165 z$2210 z$14636))) (= z$17451 $x82125))) (assert (= z$17452 (not z$17451))) (assert (let (($x79346 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$187 z$5192 z$8822))) (= z$17465 $x79346))) (assert (= z$17466 (not z$17465))) (assert (let (($x33127 (and z$1 z$19 a_init_state z$31 a_send_req z$47 z$51 z$53 z$185))) (= z$17479 $x33127))) (assert (= z$17480 (not z$17479))) (assert (let (($x43606 (and z$1 z$19 a_init_state z$31 a_send_req a_start_K z$47 z$51 z$53 z$58))) (= z$17487 $x43606))) (assert (= z$17488 (not z$17487))) (assert (let (($x77522 (and z$1 z$5 z$19 a_init_state z$31 z$35 a_start_K z$47 z$51 z$53 z$13040))) (= z$17495 $x77522))) (assert (= z$17496 (not z$17495))) (assert (let (($x27242 (and z$1 z$19 a_init_state z$31 a_send_req a_start_K z$47 z$51 z$53 z$2165 z$11085 z$13629))) (= z$17503 $x27242))) (assert (= z$17504 (not z$17503))) (assert (let (($x63458 (and z$19 a_in_transit_K a_init_state z$31 z$41 z$47 z$51 z$53 z$2165 z$13629))) (= z$17521 $x63458))) (assert (= z$17522 (not z$17521))) (assert (= z$6813 (and (distinct z$826 z$n1s32) true))) (assert (let (($x39472 (and z$1 a_file_req a_wait_ack z$53 z$1055 z$2167 z$6813 z$8833))) (= z$17538 $x39472))) (assert (= z$17539 (not z$17538))) (assert (let (($x24572 (and z$1 a_file_req a_wait_ack z$53 z$253 z$1055 z$2167 z$8832 z$13629))) (= z$17549 $x24572))) (assert (= z$17550 (not z$17549))) (assert (let (($x54830 (and z$1 a_file_req a_wait_ack z$53 z$253 z$1055 z$2167 z$2381 z$5192 z$8833))) (= z$17560 $x54830))) (assert (= z$17561 (not z$17560))) (assert (let (($x76933 (= z$245 z$n0s32))) (= z$8939 $x76933))) (assert (let (($x77200 (and a_file_req a_in_transit_K a_wait_ack z$53 z$1055 z$8832 z$8939))) (= z$17571 $x77200))) (assert (= z$17572 (not z$17571))) (assert (let (($x70390 (and z$1 a_file_req a_wait_ack z$53 z$237 z$253 z$1055 z$2381 z$5192 z$8939))) (= z$17583 $x70390))) (assert (= z$17584 (not z$17583))) (assert (let (($x80658 (= z$826 z$190))) (= z$17587 $x80658))) (assert (let (($x37922 (and z$1 a_file_req a_wait_ack z$53 z$237 z$1055 z$5600 z$8939 z$17587))) (= z$17596 $x37922))) (assert (= z$17597 (not z$17596))) (assert (let (($x78449 (= z$150 z$n2s32))) (= z$13049 $x78449))) (assert (= z$18120 (and z$13049 z$12198 z$11090 z$168))) (assert (= z$18121 (not z$18120))) (assert (= z$18154 (and z$114 z$11461))) (assert (= z$18156 (not z$18154))) (assert (= z$18155 (and z$2116 z$11418))) (assert (= z$18158 (not z$18155))) (assert (let (($x72408 (and z$1 z$19 a_init_state z$31 a_start_K z$47 z$51 z$53 z$2165 z$12194 z$13040))) (= z$18167 $x72408))) (assert (= z$18168 (not z$18167))) (assert (let (($x19455 (and z$1 z$19 a_init_state z$31 a_start_K z$47 z$51 z$53 z$2165 z$11085 z$13629))) (= z$18175 $x19455))) (assert (= z$18176 (not z$18175))) (assert (= z$18210 (and f00 z$566 z$650 z$11347 z$3054 z$200))) (assert (= z$18211 (not z$18210))) (assert (= z$3370 (and (distinct z$3346 z$n2s32) true))) (assert (= z$18239 (and z$11418 z$3343 z$3370))) (assert (= z$18241 (not z$18239))) (assert (= z$3253 (and (distinct z$150 z$n2s32) true))) (assert (= z$18238 (and z$11461 z$145 z$3253))) (assert (= z$18240 (not z$18238))) (assert (let (($x57475 (= z$5665 z$n0s32))) (= z$11149 $x57475))) (assert (= z$18285 (and z$11149 z$2803))) (assert (= z$18287 (not z$18285))) (assert (let (($x40332 (= z$190 z$n0s32))) (= z$11148 $x40332))) (assert (= z$18284 (and z$11148 z$2758))) (assert (= z$18286 (not z$18284))) (assert (let (($x36302 (and z$1 z$19 a_init_state z$31 a_start_K z$47 z$51 z$53 z$187 z$8822 z$12194))) (= z$18299 $x36302))) (assert (= z$18300 (not z$18299))) (assert (let (($x18346 (and z$1 z$19 a_init_state z$31 a_start_K z$47 z$51 z$53 z$2165 z$11085))) (= z$18307 $x18346))) (assert (= z$18308 (not z$18307))) (assert (let (($x46199 (and z$1 z$19 a_init_state z$31 a_start_K z$47 z$51 z$53 z$58 z$2758 z$12194))) (= z$18321 $x46199))) (assert (= z$18322 (not z$18321))) (assert (= z$18332 (and z$1 a_start_K z$51 z$53 z$185 z$5592 z$8822))) (assert (= z$18333 (not z$18332))) (assert (let (($x67915 (and z$1 z$19 a_init_state z$31 z$47 z$51 z$53 z$58 z$171))) (= z$18346 $x67915))) (assert (= z$18347 (not z$18346))) (assert (let (($x42764 (and z$1 z$19 a_init_state z$31 a_start_K z$47 z$51 z$53 z$58 z$171))) (= z$18354 $x42764))) (assert (= z$18355 (not z$18354))) (assert (= z$18399 (and z$171 z$991))) (assert (= z$18401 (not z$18399))) (assert (= z$18400 (and z$2766 z$2788))) (assert (= z$18403 (not z$18400))) (assert (let (($x26980 (and a_file_req a_new_file z$31 z$45 z$53 z$6784 z$7112 z$7877))) (= z$18436 $x26980))) (assert (= z$18437 (not z$18436))) (assert (let (($x40139 (and a_BAD_K a_file_req a_new_file z$31 z$45 z$53 z$1055 z$2167 z$6784 z$6815 z$7877))) (= z$18444 $x40139))) (assert (= z$18445 (not z$18444))) (assert (let (($x13505 (and a_BAD_K a_file_req a_new_file z$31 z$45 z$53 z$1055 z$7877 z$8563))) (= z$18455 $x13505))) (assert (= z$18456 (not z$18455))) (assert (let (($x81644 (= z$118 z$241))) (= z$8634 $x81644))) (assert (let (($x53259 (and a_file_req a_new_file z$31 a_start_K z$45 z$53 z$1055 z$4471 z$6784 z$7877 z$8634 z$8832))) (= z$18466 $x53259))) (assert (= z$18467 (not z$18466))) (assert (= z$8165 (and (distinct z$245 z$n5s32) true))) (assert (let (($x25672 (and a_BAD_K a_file_req a_new_file z$31 z$45 z$53 z$237 z$1055 z$7877 z$8165))) (= z$18478 $x25672))) (assert (= z$18479 (not z$18478))) (assert (let (($x21775 (and a_BAD_K a_file_req a_new_file z$31 z$45 z$53 z$1055 z$2160 z$2465 z$7112 z$7877 z$11138))) (= z$18486 $x21775))) (assert (= z$18487 (not z$18486))) (assert (let (($x16882 (= v_W v_X))) (= z$7310 $x16882))) (assert (let (($x60608 (and z$3 a_file_req a_in_transit_K a_new_file z$31 z$53 z$2465 z$6792 z$7310 z$7877))) (= z$18504 $x60608))) (assert (= z$18505 (not z$18504))) (assert (let (($x11331 (and a_BAD_K a_file_req a_new_file z$45 a_wait_ack z$53 z$1055 z$6792 z$7320 z$7877))) (= z$18512 $x11331))) (assert (= z$18513 (not z$18512))) (assert (let (($x49994 (and a_BAD_K a_file_req a_new_file z$31 z$45 z$53 z$1055 z$2746 z$6784 z$7877 z$10193))) (= z$18523 $x49994))) (assert (= z$18524 (not z$18523))) (assert (let (($x66857 (and a_file_req z$11 z$13 z$15 a_in_transit_K a_new_file z$45 z$53 z$2465 z$5352 z$7877))) (= z$18548 $x66857))) (assert (= z$18549 (not z$18548))) (assert (let (($x45435 (and a_BAD_K a_file_req a_new_file z$31 z$45 z$53 z$1055 z$5352 z$7320 z$7877))) (= z$18556 $x45435))) (assert (= z$18557 (not z$18556))) (assert (let (($x68710 (and a_file_req z$11 z$13 z$15 a_in_transit_K a_new_file z$45 a_wait_ack z$53 z$114 z$7877))) (= z$18570 $x68710))) (assert (= z$18571 (not z$18570))) (assert (let (($x83726 (and a_file_req z$11 z$13 z$15 z$21 a_new_file z$45 a_wait_ack z$53 z$1055 z$5352 z$7877))) (= z$18578 $x83726))) (assert (= z$18579 (not z$18578))) (assert (= z$5583 (and (distinct v_X v_Z) true))) (assert (let (($x60993 (and a_file_req z$11 z$13 z$15 z$21 a_new_file z$45 a_wait_ack z$53 z$1055 z$2465 z$5583 z$7877))) (= z$18586 $x60993))) (assert (= z$18587 (not z$18586))) (assert (let (($x73945 (and a_file_req z$13 z$15 a_new_file z$31 z$45 z$53 z$114 z$7249 z$7310))) (= z$18616 $x73945))) (assert (= z$18617 (not z$18616))) (assert (let (($x79657 (and a_file_req a_idle_Receiver a_in_transit_K z$45 a_wait_ack z$53 z$2465))) (= z$18627 $x79657))) (assert (= z$18628 (not z$18627))) (assert (let (($x73745 (and a_file_req a_idle_Receiver a_in_transit_K z$45 a_wait_ack z$53 z$2363 z$5583))) (= z$18638 $x73745))) (assert (= z$18639 (not z$18638))) (assert (let (($x15228 (and a_BAD_K a_file_req a_idle_Receiver z$31 z$45 z$53 z$1055 z$2168))) (= z$18646 $x15228))) (assert (= z$18647 (not z$18646))) (assert (let (($x37390 (and a_BAD_K a_file_req z$11 z$13 z$15 a_new_file z$31 z$45 z$53 z$285 z$1055))) (= z$18657 $x37390))) (assert (= z$18658 (not z$18657))) (assert (let (($x10332 (and a_file_req z$11 z$13 z$15 a_new_file z$45 a_wait_ack z$53 z$1055 z$2165 z$2746))) (= z$18668 $x10332))) (assert (= z$18669 (not z$18668))) (assert (let (($x81211 (= z$277 z$279))) (= z$11819 $x81211))) (assert (let (($x73626 (and a_file_req z$11 z$13 z$15 z$21 a_new_file z$45 a_wait_ack z$53 z$1055 z$11819))) (= z$18679 $x73626))) (assert (= z$18680 (not z$18679))) (assert (= z$6047 (and (distinct z$277 z$n5s32) true))) (assert (let (($x39343 (and a_BAD_K a_file_req z$11 z$13 z$15 a_new_file z$45 a_wait_ack z$53 z$1055 z$6047))) (= z$18690 $x39343))) (assert (= z$18691 (not z$18690))) (assert (let (($x40796 (and z$1 a_file_req z$11 z$13 z$15 a_new_file z$45 a_wait_ack z$53 z$5352 z$7249 z$7424 z$9055))) (= z$18705 $x40796))) (assert (= z$18706 (not z$18705))) (assert (let (($x74498 (and a_file_req z$11 z$13 z$15 z$21 a_new_file z$45 a_wait_ack z$53 z$1055 z$5770 z$7424))) (= z$18713 $x74498))) (assert (= z$18714 (not z$18713))) (assert (let (($x77452 (and z$1 a_file_req a_idle_Receiver z$45 a_wait_ack z$53 z$5352 z$5770 z$9055))) (= z$18727 $x77452))) (assert (= z$18728 (not z$18727))) (assert (let (($x23471 (and a_file_req z$11 z$13 z$15 z$21 a_new_file z$31 a_start_K z$45 z$53 z$1055 z$5770))) (= z$18735 $x23471))) (assert (= z$18736 (not z$18735))) (assert (let (($x81797 (and a_file_req z$11 z$13 z$15 a_new_file z$45 a_wait_ack z$53 z$1055 z$2746 z$4649))) (= z$18746 $x81797))) (assert (= z$18747 (not z$18746))) (assert (let (($x71313 (and a_file_req z$11 z$13 z$15 a_in_transit_K a_new_file z$45 a_wait_ack z$53 z$5192 z$5352 z$9055))) (= z$18760 $x71313))) (assert (= z$18761 (not z$18760))) (assert (let (($x27430 (and a_BAD_K a_file_req z$11 z$13 z$15 a_new_file z$31 z$45 z$53 z$1055))) (= z$9269 $x27430))) (assert (= z$9270 (not z$9269))) (assert (let (($x73005 (and a_BAD_K a_file_req z$11 z$13 z$15 a_new_file z$31 z$45 z$53 z$1055 z$2363))) (= z$18773 $x73005))) (assert (= z$18774 (not z$18773))) (assert (let (($x68692 (and a_BAD_K z$11 z$13 z$15 z$19 a_init_state a_new_file z$31 z$45 z$47 z$51 z$53))) (= z$13903 $x68692))) (assert (= z$13904 (not z$13903))) (assert (let (($x38567 (and a_BAD_K z$11 z$13 z$15 z$19 a_init_state a_new_file z$31 z$45 z$47 z$51 z$53 z$2363))) (= z$13911 $x38567))) (assert (= z$13912 (not z$13911))) (assert (let (($x33519 (and a_BAD_K z$11 z$13 z$15 z$19 a_init_state a_new_file z$31 z$45 z$47 z$51 z$53 z$2363 z$12194))) (= z$18791 $x33519))) (assert (= z$18792 (not z$18791))) (assert (let (($x29286 (and a_BAD_L a_file_req a_new_file a_wait_ack z$53 z$2363 z$5583 z$6784))) (= z$18840 $x29286))) (assert (= z$18841 (not z$18840))) (assert (let (($x14433 (and a_BAD_L a_file_req a_new_file a_wait_ack z$53 z$5352 z$6802 z$7249 z$9055))) (= z$18881 $x14433))) (assert (= z$18882 (not z$18881))) (assert (let (($x19713 (and a_BAD_K a_BAD_L a_file_req a_new_file z$31 z$53 z$1055 z$6802 z$7249))) (= z$18889 $x19713))) (assert (= z$18890 (not z$18889))) (assert (let (($x23134 (and a_BAD_L a_file_req a_new_file a_wait_ack z$53 z$5352 z$6784 z$7249 z$9055))) (= z$18903 $x23134))) (assert (= z$18904 (not z$18903))) (assert (let (($x82579 (and a_BAD_K a_BAD_L a_file_req a_new_file z$31 z$53 z$1055 z$6784 z$7249))) (= z$18911 $x82579))) (assert (= z$18912 (not z$18911))) (assert (let (($x71946 (and a_BAD_K a_BAD_L a_file_req a_new_file z$31 z$53 z$1055 z$2363 z$7112 z$7249))) (= z$18919 $x71946))) (assert (= z$18920 (not z$18919))) (assert (let (($x82474 (= z$826 z$n1s32))) (= z$11275 $x82474))) (assert (let (($x49827 (and a_BAD_L a_file_req a_in_transit_K a_new_file z$53 z$62 z$2465 z$5352 z$11275))) (= z$19161 $x49827))) (assert (= z$19162 (not z$19161))) (assert (let (($x41780 (and a_file_req z$21 a_new_file a_wait_ack z$53 z$1055 z$5352))) (= z$19184 $x41780))) (assert (= z$19185 (not z$19184))) (assert (let (($x66074 (and a_BAD_L a_file_req a_in_transit_K a_new_file z$31 z$53 z$2363 z$5352 z$11275))) (= z$19195 $x66074))) (assert (= z$19196 (not z$19195))) (assert (let (($x83902 (and a_BAD_K a_BAD_L a_file_req a_new_file a_wait_ack z$53 z$62 z$1055 z$5352))) (= z$19203 $x83902))) (assert (= z$19204 (not z$19203))) (assert (let (($x41288 (and a_BAD_K a_BAD_L a_file_req a_new_file a_wait_ack z$53 z$1055 z$2465 z$7249))) (= z$19211 $x41288))) (assert (= z$19212 (not z$19211))) (assert (let (($x38706 (and a_BAD_K a_BAD_L z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2167 z$7249))) (= z$19219 $x38706))) (assert (= z$19220 (not z$19219))) (assert (let (($x69309 (and a_BAD_K a_BAD_L z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$7249 z$8563))) (= z$19230 $x69309))) (assert (= z$19231 (not z$19230))) (assert (let (($x83067 (= z$275 z$121))) (= z$10017 $x83067))) (assert (let (($x64165 (= z$123 z$279))) (= z$19241 $x64165))) (assert (let (($x12318 (and a_BAD_L a_file_req z$21 a_new_file a_wait_ack z$53 z$1055 z$10017 z$19241))) (= z$19250 $x12318))) (assert (= z$19251 (not z$19250))) (assert (let (($x49125 (and a_BAD_L a_file_req z$21 a_new_file a_wait_ack z$53 z$1055 z$11819))) (= z$19263 $x49125))) (assert (= z$19264 (not z$19263))) (assert (= z$5401 (and (distinct z$279 z$n5s32) true))) (assert (let (($x78644 (and a_BAD_L a_file_req z$21 a_new_file a_wait_ack z$53 z$1055 z$2168 z$5352 z$5401))) (= z$19274 $x78644))) (assert (= z$19275 (not z$19274))) (assert (let (($x34059 (and a_BAD_K a_BAD_L a_file_req a_new_file a_wait_ack z$53 z$269 z$285 z$1055))) (= z$19285 $x34059))) (assert (= z$19286 (not z$19285))) (assert (let (($x83839 (= z$150 z$855))) (= z$11337 $x83839))) (assert (let (($x63046 (and a_BAD_L a_file_req a_in_transit_K a_new_file z$31 z$53 z$143 z$9055 z$11337))) (= z$19310 $x63046))) (assert (= z$19311 (not z$19310))) (assert (let (($x82160 (= z$288 z$845))) (= z$16456 $x82160))) (assert (let (($x55540 (and a_BAD_L a_file_req z$21 a_new_file a_wait_ack z$53 z$283 z$1055 z$16456))) (= z$19319 $x55540))) (assert (= z$19320 (not z$19319))) (assert (let (($x80359 (and a_BAD_L a_file_req z$21 a_new_file a_wait_ack z$53 z$269 z$1055 z$6047))) (= z$19331 $x80359))) (assert (= z$19332 (not z$19331))) (assert (let (($x5823 (and a_BAD_L a_file_req a_new_file a_wait_ack z$53 z$114 z$1055 z$4289 z$5583 z$11337))) (= z$19339 $x5823))) (assert (= z$19340 (not z$19339))) (assert (let (($x38423 (and a_BAD_L a_file_req a_in_transit_K a_new_file a_wait_ack z$53 z$2465 z$9055))) (= z$19378 $x38423))) (assert (= z$19379 (not z$19378))) (assert (let (($x79418 (= z$279 z$n5s32))) (= z$9049 $x79418))) (assert (let (($x19471 (and a_BAD_L a_file_req z$21 a_new_file a_wait_ack z$53 z$1055 z$9049))) (= z$19386 $x19471))) (assert (= z$19387 (not z$19386))) (assert (let (($x38468 (and a_BAD_L a_file_req z$21 a_new_file a_wait_ack z$53 z$1055 z$5352 z$10031))) (= z$19397 $x38468))) (assert (= z$19398 (not z$19397))) (assert (let (($x24093 (and a_BAD_L a_file_req z$21 a_new_file a_wait_ack z$53 z$269 z$1055 z$10032))) (= z$19408 $x24093))) (assert (= z$19409 (not z$19408))) (assert (let (($x60758 (and a_BAD_L a_file_req a_in_transit_K a_new_file a_wait_ack z$53 z$5192 z$5352 z$9055))) (= z$19422 $x60758))) (assert (= z$19423 (not z$19422))) (assert (let (($x67528 (and a_BAD_L a_file_req z$21 a_new_file a_wait_ack z$53 z$1055 z$5352))) (= z$19430 $x67528))) (assert (= z$19431 (not z$19430))) (assert (let (($x19584 (and a_BAD_K a_BAD_L a_file_req a_new_file a_wait_ack z$53 z$1055 z$2363 z$5583))) (= z$19438 $x19584))) (assert (= z$19439 (not z$19438))) (assert (let (($x31054 (and a_BAD_K a_BAD_L z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$11819))) (= z$19446 $x31054))) (assert (= z$19447 (not z$19446))) (assert (let (($x72861 (and a_file_req z$13 z$21 a_new_file z$31 a_start_K a_start_L z$53 z$1055))) (= z$19490 $x72861))) (assert (= z$19491 (not z$19490))) (assert (let (($x31498 (and a_file_req z$21 a_new_file a_start_L a_wait_ack z$53 z$1055))) (= z$19613 $x31498))) (assert (= z$19614 (not z$19613))) (assert (let (($x33485 (and a_BAD_L a_file_req a_in_transit_K a_new_file a_wait_ack z$53 z$66 z$2659 z$3262))) (= z$19635 $x33485))) (assert (= z$19636 (not z$19635))) (assert (let (($x82693 (= z$288 z$n0s32))) (= z$12678 $x82693))) (assert (let (($x44375 (and a_BAD_L a_file_req a_in_transit_K a_new_file a_wait_ack z$53 z$2363 z$2659 z$12678))) (= z$19646 $x44375))) (assert (= z$19647 (not z$19646))) (assert (let (($x73591 (and a_BAD_K a_BAD_L a_file_req a_new_file a_wait_ack z$53 z$1055 z$2659 z$11138))) (= z$19654 $x73591))) (assert (= z$19655 (not z$19654))) (assert (let (($x71574 (and a_BAD_L a_file_req a_new_file a_wait_ack z$53 z$1055 z$5352 z$5770 z$9055 z$11259))) (= z$19662 $x71574))) (assert (= z$19663 (not z$19662))) (assert (let (($x78467 (= z$845 z$n1s32))) (= z$12679 $x78467))) (assert (let (($x42531 (and a_BAD_K a_BAD_L z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$5770 z$12679))) (= z$19670 $x42531))) (assert (= z$19671 (not z$19670))) (assert (let (($x50058 (and a_BAD_K a_BAD_L a_file_req a_new_file a_wait_ack z$53 z$1055 z$2465 z$5770))) (= z$19685 $x50058))) (assert (= z$19686 (not z$19685))) (assert (let (($x81602 (and a_BAD_K a_BAD_L z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2168 z$5770))) (= z$19693 $x81602))) (assert (= z$19694 (not z$19693))) (assert (= z$5657 (and (distinct z$288 z$845) true))) (assert (let (($x60974 (and a_BAD_K a_BAD_L z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$285 z$5657))) (= z$19704 $x60974))) (assert (= z$19705 (not z$19704))) (assert (let (($x30313 (and a_BAD_L a_file_req a_new_file a_wait_ack z$53 z$1055 z$2165 z$2746 z$2911))) (= z$19722 $x30313))) (assert (= z$19723 (not z$19722))) (assert (let (($x14323 (= z$911 z$n1s32))) (= z$12076 $x14323))) (assert (let (($x22857 (and a_file_req a_in_transit_K a_new_file z$31 z$53 z$60 z$1005 z$12076))) (= z$19737 $x22857))) (assert (= z$19738 (not z$19737))) (assert (let (($x27981 (and a_BAD_L a_file_req a_new_file a_wait_ack z$53 z$60 z$1005 z$1055))) (= z$19745 $x27981))) (assert (= z$19746 (not z$19745))) (assert (let (($x81366 (= z$223 z$n0s32))) (= z$12052 $x81366))) (assert (let (($x76777 (and a_BAD_L a_file_req a_in_transit_K z$31 z$53 z$2746 z$12052))) (= z$19759 $x76777))) (assert (= z$19760 (not z$19759))) (assert (let (($x55379 (and a_BAD_L a_file_req a_new_file a_wait_ack z$53 z$143 z$1055 z$2746))) (= z$19768 $x55379))) (assert (= z$19769 (not z$19768))) (assert (let (($x24820 (and a_BAD_K a_BAD_L a_file_req a_new_file a_wait_ack z$53 z$1055 z$2465))) (= z$19776 $x24820))) (assert (= z$19777 (not z$19776))) (assert (let (($x51242 (and a_BAD_K a_BAD_L z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2168))) (= z$19784 $x51242))) (assert (= z$19785 (not z$19784))) (assert (let (($x35089 (and a_BAD_K a_BAD_L z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$285))) (= z$19795 $x35089))) (assert (= z$19796 (not z$19795))) (assert (let (($x18106 (and a_BAD_K a_BAD_L a_file_req a_new_file a_wait_ack z$53 z$1055 z$5192 z$5352 z$9055))) (= z$19809 $x18106))) (assert (= z$19810 (not z$19809))) (assert (let (($x77516 (and a_BAD_K a_BAD_L z$19 a_init_state a_new_file z$31 z$47 z$51 z$53))) (= z$14059 $x77516))) (assert (= z$14060 (not z$14059))) (assert (let (($x57836 (and a_BAD_K a_BAD_L z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363))) (= z$14067 $x57836))) (assert (= z$14068 (not z$14067))) (assert (let (($x66845 (and a_BAD_K a_BAD_L z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363 z$12194))) (= z$19827 $x66845))) (assert (= z$19828 (not z$19827))) (assert (let (($x29399 (and z$3 a_file_req z$11 z$13 z$15 a_in_transit_K a_new_file z$31 z$53 z$2363 z$2659 z$6792))) (= z$19853 $x29399))) (assert (= z$19854 (not z$19853))) (assert (let (($x39497 (and a_file_req a_idle_Receiver z$21 a_in_transit_L a_wait_ack z$53 z$1055 z$2659 z$6792))) (= z$19861 $x39497))) (assert (= z$19862 (not z$19861))) (assert (let (($x26358 (and a_BAD_K a_file_req z$13 z$15 a_in_transit_L a_new_file z$31 z$53 z$1055 z$2165 z$2659 z$2746 z$2911))) (= z$19872 $x26358))) (assert (= z$19873 (not z$19872))) (assert (let (($x36616 (and a_BAD_K a_file_req z$13 z$15 a_in_transit_L a_new_file z$31 z$53 z$171 z$1055 z$2659 z$3216))) (= z$19885 $x36616))) (assert (= z$19886 (not z$19885))) (assert (let (($x25718 (and a_BAD_K a_file_req a_new_file a_wait_ack z$53 z$171 z$1055 z$4649))) (= z$19896 $x25718))) (assert (= z$19897 (not z$19896))) (assert (let (($x23517 (and a_file_req z$11 z$13 z$15 a_new_file a_wait_ack z$53 z$143 z$1055 z$2160 z$2465 z$2658 z$11337))) (= z$19904 $x23517))) (assert (= z$19905 (not z$19904))) (assert (let (($x81341 (and a_file_req a_in_transit_K a_new_file a_start_L a_wait_ack z$53 z$2363 z$2658 z$2659))) (= z$19921 $x81341))) (assert (= z$19922 (not z$19921))) (assert (let (($x63772 (and a_BAD_K a_file_req a_new_file a_start_L a_wait_ack z$53 z$1055 z$9675))) (= z$19929 $x63772))) (assert (= z$19930 (not z$19929))) (assert (let (($x63152 (and a_BAD_K a_file_req z$13 z$15 a_in_transit_L a_new_file z$31 z$53 z$1055 z$2166 z$2659 z$5786))) (= z$19940 $x63152))) (assert (= z$19941 (not z$19940))) (assert (let (($x76974 (and z$1 a_file_req z$13 a_new_file z$31 a_start_K a_start_L z$53 z$2465 z$5770 z$7446))) (= z$19965 $x76974))) (assert (= z$19966 (not z$19965))) (assert (let (($x81537 (and a_BAD_K a_file_req z$13 z$15 a_in_transit_L a_new_file z$31 z$53 z$1055 z$5770 z$7436))) (= z$19973 $x81537))) (assert (= z$19974 (not z$19973))) (assert (let (($x45198 (and a_BAD_K a_file_req z$11 z$13 z$15 a_new_file a_wait_ack z$53 z$1055 z$2659 z$5770 z$6049))) (= z$19984 $x45198))) (assert (= z$19985 (not z$19984))) (assert (let (($x16713 (and a_file_req a_new_file a_start_K a_start_L a_wait_ack z$53 z$2659 z$5770 z$7446))) (= z$19998 $x16713))) (assert (= z$19999 (not z$19998))) (assert (let (($x73773 (and a_file_req z$11 z$21 a_new_file a_start_L a_wait_ack z$53 z$1055 z$2659 z$5770))) (= z$20006 $x73773))) (assert (= z$20007 (not z$20006))) (assert (let (($x26245 (and a_file_req z$11 z$21 a_new_file a_start_L a_wait_ack z$53 z$1055 z$2465 z$2658 z$5770))) (= z$20014 $x26245))) (assert (= z$20015 (not z$20014))) (assert (let (($x51318 (and a_BAD_K a_file_req z$11 a_new_file a_start_L a_wait_ack z$53 z$114 z$1055 z$2658 z$5770))) (= z$20025 $x51318))) (assert (= z$20026 (not z$20025))) (assert (let (($x32413 (and a_BAD_K z$11 z$13 z$15 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$5770 z$9675))) (= z$20033 $x32413))) (assert (= z$20034 (not z$20033))) (assert (= z$6275 (and (distinct z$223 z$911) true))) (assert (let (($x8372 (and a_BAD_K z$11 z$13 z$15 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$220 z$5770 z$6275))) (= z$20044 $x8372))) (assert (= z$20045 (not z$20044))) (assert (let (($x59363 (and a_BAD_K a_file_req a_new_file a_wait_ack z$53 z$1055 z$2165 z$2746 z$2911))) (= z$20066 $x59363))) (assert (= z$20067 (not z$20066))) (assert (let (($x82974 (= z$911 z$150))) (= z$20054 $x82974))) (assert (let (($x36212 (and a_file_req a_new_file a_wait_ack z$53 z$145 z$913 z$1055 z$2465 z$3253 z$20054))) (= z$20074 $x36212))) (assert (= z$20075 (not z$20074))) (assert (= z$7030 (and (distinct z$223 z$n2s32) true))) (assert (let (($x66423 (and a_BAD_K z$11 z$13 z$15 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$220 z$913 z$5770 z$7030))) (= z$20083 $x66423))) (assert (= z$20084 (not z$20083))) (assert (let (($x80892 (= z$206 z$116))) (= z$7500 $x80892))) (assert (let (($x40553 (= z$855 z$n2s32))) (= z$13048 $x40553))) (assert (let (($x25402 (and a_file_req z$11 z$13 z$15 a_new_file a_wait_ack z$53 z$1006 z$1055 z$2160 z$2465 z$7500 z$13048))) (= z$20098 $x25402))) (assert (= z$20099 (not z$20098))) (assert (let (($x84106 (= z$911 z$n2s32))) (= z$14273 $x84106))) (assert (let (($x45052 (and a_BAD_K z$11 z$13 z$15 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$1006 z$2166 z$5770 z$14273))) (= z$20108 $x45052))) (assert (= z$20109 (not z$20108))) (assert (let (($x18931 (and a_BAD_K a_file_req a_new_file a_wait_ack z$53 z$1055 z$5352 z$14636))) (= z$20126 $x18931))) (assert (= z$20127 (not z$20126))) (assert (let (($x26310 (and a_file_req z$11 z$13 z$15 a_new_file a_wait_ack z$53 z$1055 z$2160 z$2465 z$5770 z$13048))) (= z$20134 $x26310))) (assert (= z$20135 (not z$20134))) (assert (let (($x49608 (and a_BAD_K z$11 z$13 z$15 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2166 z$5770 z$14273))) (= z$20142 $x49608))) (assert (= z$20143 (not z$20142))) (assert (let (($x62741 (and a_file_req a_new_file a_wait_ack z$53 z$143 z$1055 z$2160 z$2465 z$11337))) (= z$20156 $x62741))) (assert (= z$20157 (not z$20156))) (assert (let ((?x1651 (ShiftR_32_32_32 z$206 z$n16s32))) (= z$2250 ?x1651))) (assert (let ((?x42366 (Add_32_32_32 z$n1s32 z$2250))) (= z$2275 ?x42366))) (assert (let (($x46309 (GrEq_1_32_32 z$n2s32 z$2275))) (= z$2276 $x46309))) (assert (let (($x50002 (= z$223 z$911))) (= z$20047 $x50002))) (assert (let (($x27510 (and a_BAD_K z$11 z$13 z$15 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2166 z$2276 z$5770 z$20047))) (= z$20164 $x27510))) (assert (= z$20165 (not z$20164))) (assert (let (($x74439 (and a_file_req a_in_transit_K a_new_file z$31 z$53 z$60 z$2465 z$5352 z$6784))) (= z$20185 $x74439))) (assert (= z$20186 (not z$20185))) (assert (let (($x60204 (and a_file_req a_in_transit_L a_new_file a_wait_ack z$53 z$60 z$3262 z$5352))) (= z$20207 $x60204))) (assert (= z$20208 (not z$20207))) (assert (let (($x42704 (and z$3 a_file_req z$13 z$15 a_new_file a_start_K z$53 z$60 z$114 z$859 z$5352 z$8820))) (= z$20218 $x42704))) (assert (= z$20219 (not z$20218))) (assert (let (($x78056 (and z$1 a_file_req z$13 z$15 a_new_file z$31 a_start_K z$53 z$60 z$2363 z$5352))) (= z$20229 $x78056))) (assert (= z$20230 (not z$20229))) (assert (let (($x68876 (and a_BAD_K a_file_req z$13 z$15 a_new_file z$31 z$53 z$60 z$1055 z$5352 z$6784))) (= z$20237 $x68876))) (assert (= z$20238 (not z$20237))) (assert (let (($x40790 (and a_file_req z$11 z$13 z$15 z$21 a_new_file a_start_L a_wait_ack z$53 z$1055 z$2465 z$5770 z$6792))) (= z$20245 $x40790))) (assert (= z$20246 (not z$20245))) (assert (let (($x82922 (and a_BAD_K z$11 z$13 z$15 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2166 z$5770 z$6792))) (= z$20253 $x82922))) (assert (= z$20254 (not z$20253))) (assert (let (($x74811 (and a_BAD_K z$11 z$13 z$15 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$204 z$220 z$5770))) (= z$20264 $x74811))) (assert (= z$20265 (not z$20264))) (assert (let (($x56240 (and a_file_req a_new_file a_wait_ack z$53 z$114 z$1055 z$4289 z$13048 z$13049))) (= z$20278 $x56240))) (assert (= z$20279 (not z$20278))) (assert (let (($x84050 (= z$223 z$n2s32))) (= z$14272 $x84050))) (assert (let (($x55243 (and a_BAD_K z$11 z$13 z$15 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$5770 z$14272 z$14273))) (= z$20286 $x55243))) (assert (= z$20287 (not z$20286))) (assert (let (($x13290 (and a_file_req a_new_file a_wait_ack z$53 z$114 z$1055 z$4289 z$11337))) (= z$20301 $x13290))) (assert (= z$20302 (not z$20301))) (assert (let (($x63471 (and a_BAD_K z$11 z$13 z$15 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$204 z$5770 z$20047))) (= z$20309 $x63471))) (assert (= z$20310 (not z$20309))) (assert (let (($x36314 (and a_BAD_K a_file_req z$11 z$13 z$15 a_new_file a_wait_ack z$53 z$1055 z$2659 z$5770 z$6792 z$7446))) (= z$20323 $x36314))) (assert (= z$20324 (not z$20323))) (assert (let (($x56489 (and a_BAD_K z$11 z$13 z$15 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$5770 z$6792))) (= z$20331 $x56489))) (assert (= z$20332 (not z$20331))) (assert (let (($x79694 (and a_BAD_K a_file_req z$13 z$15 a_new_file a_wait_ack z$53 z$60 z$1055 z$5352))) (= z$20348 $x79694))) (assert (= z$20349 (not z$20348))) (assert (let (($x45578 (and a_BAD_K a_file_req z$11 z$13 z$15 a_new_file a_wait_ack z$53 z$1055 z$2659 z$5770 z$7446))) (= z$20356 $x45578))) (assert (= z$20357 (not z$20356))) (assert (let (($x76832 (and a_BAD_K z$11 z$13 z$15 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$5770))) (= z$20364 $x76832))) (assert (= z$20365 (not z$20364))) (assert (let (($x31915 (and a_BAD_K z$11 z$13 z$15 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363 z$5770))) (= z$20372 $x31915))) (assert (= z$20373 (not z$20372))) (assert (let (($x77611 (and a_BAD_K z$11 z$13 z$15 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$66 z$2363 z$2659 z$12194))) (= z$20380 $x77611))) (assert (= z$20381 (not z$20380))) (assert (let (($x59784 (and a_BAD_K z$11 z$13 z$15 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363 z$5770 z$12194))) (= z$20391 $x59784))) (assert (= z$20392 (not z$20391))) (assert (let (($x39058 (and a_file_req z$11 z$21 a_new_file a_start_L a_wait_ack z$53 z$1055 z$2166 z$2659 z$5786))) (= z$20416 $x39058))) (assert (= z$20417 (not z$20416))) (assert (let (($x77075 (and a_BAD_K a_file_req a_new_file a_start_L a_wait_ack z$53 z$204 z$1055 z$4471 z$9561))) (= z$20427 $x77075))) (assert (= z$20428 (not z$20427))) (assert (let (($x80632 (= z$210 z$121))) (= z$9550 $x80632))) (assert (let (($x13145 (and a_BAD_K a_file_req a_new_file a_start_L a_wait_ack z$53 z$204 z$1055 z$4471 z$9550))) (= z$20438 $x13145))) (assert (= z$20439 (not z$20438))) (assert (let (($x45928 (and a_file_req z$11 z$21 a_new_file a_start_L a_wait_ack z$53 z$204 z$1055 z$6049))) (= z$20450 $x45928))) (assert (= z$20451 (not z$20450))) (assert (let (($x83086 (and a_file_req z$17 a_new_file a_wait_ack z$53 z$2465 z$6784 z$6792))) (= z$20464 $x83086))) (assert (= z$20465 (not z$20464))) (assert (let (($x66446 (and a_file_req z$21 a_new_file a_start_L a_wait_ack z$53 z$1055 z$2166 z$2659 z$6784 z$6792))) (= z$20472 $x66446))) (assert (= z$20473 (not z$20472))) (assert (= z$5784 (and (distinct z$911 z$n1s32) true))) (assert (let (($x26074 (and a_file_req z$21 a_new_file a_start_L a_wait_ack z$53 z$1055 z$5784 z$8820 z$9561))) (= z$20483 $x26074))) (assert (= z$20484 (not z$20483))) (assert (let (($x79238 (= z$214 z$n0s32))) (= z$9562 $x79238))) (assert (let (($x33503 (and a_BAD_K a_file_req a_new_file z$31 a_start_L z$53 z$1055 z$5784 z$6784 z$9562))) (= z$20495 $x33503))) (assert (= z$20496 (not z$20495))) (assert (let (($x52752 (and a_file_req z$17 a_in_transit_K a_new_file a_start_L a_wait_ack z$53 z$2659 z$7446))) (= z$20510 $x52752))) (assert (= z$20511 (not z$20510))) (assert (let (($x56134 (and a_BAD_K a_file_req z$17 a_new_file a_start_L a_wait_ack z$53 z$1055 z$2659))) (= z$20518 $x56134))) (assert (= z$20519 (not z$20518))) (assert (let (($x83944 (and a_BAD_K a_file_req z$17 a_new_file a_start_L a_wait_ack z$53 z$1055 z$2363 z$2658))) (= z$20526 $x83944))) (assert (= z$20527 (not z$20526))) (assert (let ((?x411 (Concat_32_16_16 z$n0s16 z$101))) (= z$2245 ?x411))) (assert (let ((?x74604 (ShiftR_32_32_32 z$2245 z$n16s32))) (= z$2246 ?x74604))) (assert (let (($x75796 (GrEq_1_32_32 z$2250 z$2246))) (= z$2251 $x75796))) (assert (= z$2892 (not z$2251))) (assert (let (($x68887 (and a_BAD_K z$17 z$19 a_init_state a_new_file z$31 a_start_L z$47 z$51 z$53 z$2166 z$2892 z$6275))) (= z$20534 $x68887))) (assert (= z$20535 (not z$20534))) (assert (let (($x44291 (and a_BAD_K z$17 z$19 a_init_state a_new_file z$31 a_start_L z$47 z$51 z$53 z$913 z$7030 z$20047))) (= z$20545 $x44291))) (assert (= z$20546 (not z$20545))) (assert (let (($x43585 (and a_BAD_K a_file_req z$17 a_new_file z$31 a_start_L z$53 z$187 z$1055 z$2746 z$6784))) (= z$20562 $x43585))) (assert (= z$20563 (not z$20562))) (assert (let (($x60541 (and a_file_req z$17 a_new_file a_start_L a_wait_ack z$53 z$145 z$1055 z$2465 z$13048))) (= z$20570 $x60541))) (assert (= z$20571 (not z$20570))) (assert (let (($x68727 (and a_BAD_K z$17 z$19 a_init_state a_new_file z$31 a_start_L z$47 z$51 z$53 z$220 z$14273))) (= z$20578 $x68727))) (assert (= z$20579 (not z$20578))) (assert (let (($x27376 (and a_BAD_K z$17 z$19 a_init_state a_new_file z$31 a_start_L z$47 z$51 z$53 z$14272 z$14273))) (= z$20589 $x27376))) (assert (= z$20590 (not z$20589))) (assert (let (($x75965 (and a_file_req z$17 a_in_transit_K a_new_file a_wait_ack z$53 z$2363 z$5352))) (= z$20609 $x75965))) (assert (= z$20610 (not z$20609))) (assert (let (($x29794 (and a_BAD_K a_file_req z$17 a_new_file a_wait_ack z$53 z$1055 z$5352))) (= z$20617 $x29794))) (assert (= z$20618 (not z$20617))) (assert (let (($x72106 (and a_BAD_K a_file_req a_new_file a_start_L a_wait_ack z$53 z$1055 z$2465 z$5770))) (= z$20625 $x72106))) (assert (= z$20626 (not z$20625))) (assert (let (($x31526 (and a_BAD_K z$19 a_init_state a_new_file z$31 a_start_L z$47 z$51 z$53 z$2166 z$5770))) (= z$20633 $x31526))) (assert (= z$20634 (not z$20633))) (assert (let (($x60046 (and a_BAD_K z$19 a_init_state a_new_file z$31 a_start_L z$47 z$51 z$53 z$5770 z$9675))) (= z$20644 $x60046))) (assert (= z$20645 (not z$20644))) (assert (let (($x28642 (and a_BAD_K a_file_req a_new_file a_wait_ack z$53 z$1055 z$2659 z$5770 z$7446))) (= z$20658 $x28642))) (assert (= z$20659 (not z$20658))) (assert (let (($x44253 (and a_BAD_K z$19 a_init_state a_new_file z$31 a_start_L z$47 z$51 z$53 z$5770))) (= z$20666 $x44253))) (assert (= z$20667 (not z$20666))) (assert (let (($x63002 (and a_file_req z$17 a_new_file a_wait_ack z$53 z$2363 z$6784))) (= z$20698 $x63002))) (assert (= z$20699 (not z$20698))) (assert (let (($x70361 (and a_BAD_K a_file_req z$17 a_new_file z$31 z$53 z$1055 z$6784))) (= z$20706 $x70361))) (assert (= z$20707 (not z$20706))) (assert (let (($x44378 (and a_BAD_K a_file_req z$17 a_new_file z$31 z$53 z$1055 z$2659 z$7446))) (= z$20714 $x44378))) (assert (= z$20715 (not z$20714))) (assert (let (($x78317 (and a_BAD_K z$17 z$19 a_init_state a_new_file z$31 a_start_L z$47 z$51 z$53))) (= z$20722 $x78317))) (assert (= z$20723 (not z$20722))) (assert (let (($x60257 (and a_BAD_K z$17 z$19 a_init_state a_new_file z$31 a_start_L z$47 z$51 z$53 z$2363))) (= z$20730 $x60257))) (assert (= z$20731 (not z$20730))) (assert (let (($x78296 (and a_BAD_K z$17 z$19 a_init_state a_new_file z$31 a_start_L z$47 z$51 z$53 z$2363 z$12194))) (= z$20738 $x78296))) (assert (= z$20739 (not z$20738))) (assert (let (($x31867 (and a_BAD_K a_file_req a_new_file z$45 a_wait_ack z$53 z$1055 z$2363))) (= z$20758 $x31867))) (assert (= z$20759 (not z$20758))) (assert (let (($x38111 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$45 z$47 z$51 z$53))) (= z$20766 $x38111))) (assert (= z$20767 (not z$20766))) (assert (let (($x53221 (and a_BAD_K z$17 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363))) (= z$20774 $x53221))) (assert (= z$20775 (not z$20774))) (assert (let (($x17317 (and a_BAD_K z$17 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363 z$12194))) (= z$20782 $x17317))) (assert (= z$20783 (not z$20782))) (assert (let (($x34050 (and a_file_req z$11 z$13 z$21 a_new_file z$45 a_wait_ack z$53 z$1055 z$2363 z$7112))) (= z$20804 $x34050))) (assert (= z$20805 (not z$20804))) (assert (let (($x18315 (and z$11 z$13 z$19 z$21 a_init_state a_new_file z$31 z$45 z$47 z$51 z$53 z$237 z$253))) (= z$20812 $x18315))) (assert (= z$20813 (not z$20812))) (assert (let (($x78991 (and z$11 z$13 z$19 z$21 a_init_state a_new_file z$31 z$45 z$47 z$51 z$53 z$10193))) (= z$20823 $x78991))) (assert (= z$20824 (not z$20823))) (assert (let (($x27172 (and z$11 z$13 z$19 z$21 a_init_state a_new_file z$31 z$45 z$47 z$51 z$53 z$253 z$2363 z$12275))) (= z$20831 $x27172))) (assert (= z$20832 (not z$20831))) (assert (let (($x32637 (and a_file_req z$11 a_new_file z$43 a_wait_ack z$53 z$1055))) (= z$20853 $x32637))) (assert (= z$20854 (not z$20853))) (assert (let (($x74599 (and a_file_req z$11 z$13 a_new_file z$43 a_wait_ack z$53 z$114 z$1055))) (= z$20861 $x74599))) (assert (= z$20862 (not z$20861))) (assert (let (($x73847 (and z$11 z$13 z$19 a_init_state a_new_file z$31 z$43 z$45 z$47 z$51 z$53 z$237))) (= z$20869 $x73847))) (assert (= z$20870 (not z$20869))) (assert (let (($x63076 (and a_file_req z$11 z$13 a_new_file z$43 z$45 a_wait_ack z$53 z$1055))) (= z$20883 $x63076))) (assert (= z$20884 (not z$20883))) (assert (let (($x38455 (and z$11 z$13 z$19 a_init_state a_new_file z$31 z$43 z$45 z$47 z$51 z$53))) (= z$20891 $x38455))) (assert (= z$20892 (not z$20891))) (assert (let (($x74101 (and z$11 z$13 z$19 a_init_state a_new_file z$31 z$43 z$45 z$47 z$51 z$53 z$2363))) (= z$20899 $x74101))) (assert (= z$20900 (not z$20899))) (assert (let (($x75430 (and z$11 z$13 z$19 a_init_state a_new_file z$31 z$43 z$45 z$47 z$51 z$53 z$2363 z$12194))) (= z$20907 $x75430))) (assert (= z$20908 (not z$20907))) (assert (let (($x79256 (and a_BAD_L a_file_req z$11 z$13 a_new_file z$43 a_wait_ack z$53 z$1055))) (= z$20929 $x79256))) (assert (= z$20930 (not z$20929))) (assert (let (($x20489 (and a_BAD_L z$11 z$13 z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53))) (= z$20937 $x20489))) (assert (= z$20938 (not z$20937))) (assert (let (($x58106 (and a_BAD_L z$11 z$13 z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53 z$2363))) (= z$20945 $x58106))) (assert (= z$20946 (not z$20945))) (assert (let (($x33897 (and a_BAD_L z$11 z$13 z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53 z$2363 z$12194))) (= z$20953 $x33897))) (assert (= z$20954 (not z$20953))) (assert (let (($x59446 (and z$11 z$13 z$19 z$21 a_init_state a_new_file z$31 z$47 z$51 z$53 z$5770 z$9345))) (= z$20971 $x59446))) (assert (= z$20972 (not z$20971))) (assert (let (($x72195 (and z$11 z$13 z$19 z$21 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363 z$5770 z$9675))) (= z$20979 $x72195))) (assert (= z$20980 (not z$20979))) (assert (let (($x65752 (and z$11 z$13 z$19 z$21 a_init_state a_new_file z$31 z$47 z$51 z$53 z$204 z$1006 z$2363 z$5770))) (= z$20990 $x65752))) (assert (= z$20991 (not z$20990))) (assert (let (($x66565 (and z$11 z$13 z$15 z$19 z$21 a_init_state a_new_file z$31 z$47 z$51 z$53 z$5770 z$6792))) (= z$21004 $x66565))) (assert (= z$21005 (not z$21004))) (assert (let (($x46621 (and z$11 z$13 z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53 z$204 z$5770))) (= z$21015 $x46621))) (assert (= z$21016 (not z$21015))) (assert (let (($x81712 (and a_file_req z$11 z$13 a_new_file z$43 a_wait_ack z$53 z$1055 z$7436 z$7500))) (= z$21029 $x81712))) (assert (= z$21030 (not z$21029))) (assert (let (($x57009 (and z$11 z$13 z$19 z$21 a_init_state a_new_file z$31 z$47 z$51 z$53 z$5770))) (= z$21037 $x57009))) (assert (= z$21038 (not z$21037))) (assert (let (($x26831 (and z$11 z$13 z$19 z$21 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363 z$5770))) (= z$21045 $x26831))) (assert (= z$21046 (not z$21045))) (assert (let (($x34606 (and z$11 z$13 z$19 z$21 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363 z$5770 z$12194))) (= z$21053 $x34606))) (assert (= z$21054 (not z$21053))) (assert (let (($x34576 (and a_file_req a_new_file z$43 a_wait_ack z$53 z$1055 z$2465 z$2659 z$9233))) (= z$21073 $x34576))) (assert (= z$21074 (not z$21073))) (assert (let (($x26393 (and z$11 z$13 z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53 z$2659))) (= z$21081 $x26393))) (assert (= z$21082 (not z$21081))) (assert (let (($x46590 (and z$11 z$13 z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53 z$2363 z$2658))) (= z$21089 $x46590))) (assert (= z$21090 (not z$21089))) (assert (let (($x39567 (and z$11 z$13 z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53 z$2363 z$5583 z$12194))) (= z$21097 $x39567))) (assert (= z$21098 (not z$21097))) (assert (let (($x37481 (and a_file_req a_new_file z$43 a_wait_ack z$53 z$1055 z$2465 z$6784))) (= z$21118 $x37481))) (assert (= z$21119 (not z$21118))) (assert (let (($x18199 (and z$11 z$13 z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53 z$6784))) (= z$21126 $x18199))) (assert (= z$21127 (not z$21126))) (assert (let (($x72142 (and z$11 z$13 z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53 z$2659 z$6792 z$7446))) (= z$21134 $x72142))) (assert (= z$21135 (not z$21134))) (assert (let (($x66662 (and a_file_req z$13 a_new_file z$43 a_wait_ack z$53 z$1055 z$2210 z$3216))) (= z$21152 $x66662))) (assert (= z$21153 (not z$21152))) (assert (let (($x40624 (and z$11 z$13 z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53 z$2210))) (= z$21160 $x40624))) (assert (= z$21161 (not z$21160))) (assert (let (($x44792 (and a_file_req z$11 z$13 a_new_file z$43 a_wait_ack z$53 z$60 z$1055 z$2213))) (= z$21174 $x44792))) (assert (= z$21175 (not z$21174))) (assert (let (($x56320 (and z$11 z$13 z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53 z$2213))) (= z$21182 $x56320))) (assert (= z$21183 (not z$21182))) (assert (let (($x77556 (= z$208 z$273))) (= z$9293 $x77556))) (assert (let (($x38311 (= z$277 z$n0s32))) (= z$12941 $x38311))) (assert (let (($x73670 (and a_file_req a_in_transit_K a_new_file a_wait_ack z$53 z$1055 z$9293 z$9561 z$12941))) (= z$21200 $x73670))) (assert (= z$21201 (not z$21200))) (assert (let (($x55557 (and a_file_req a_in_transit_K a_new_file a_wait_ack z$53 z$60 z$1005 z$1055))) (= z$21213 $x55557))) (assert (= z$21214 (not z$21213))) (assert (let (($x40585 (and a_file_req z$11 z$13 a_new_file z$43 a_wait_ack z$53 z$60 z$1005 z$1055))) (= z$21221 $x40585))) (assert (= z$21222 (not z$21221))) (assert (let (($x28458 (and z$11 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$1005))) (= z$21232 $x28458))) (assert (= z$21233 (not z$21232))) (assert (let (($x67519 (and z$11 z$13 z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53 z$1005))) (= z$21240 $x67519))) (assert (= z$21241 (not z$21240))) (assert (let (($x81597 (and z$1 a_file_req z$11 a_new_file a_wait_ack z$53 z$1055 z$2165 z$3216))) (= z$21257 $x81597))) (assert (= z$21258 (not z$21257))) (assert (let (($x4939 (and a_file_req z$11 z$13 a_new_file z$43 a_wait_ack z$53 z$1055 z$2501))) (= z$21265 $x4939))) (assert (= z$21266 (not z$21265))) (assert (let (($x62891 (and z$11 z$13 z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53))) (= z$21281 $x62891))) (assert (= z$21282 (not z$21281))) (assert (let (($x43272 (and z$11 z$13 z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53 z$2659 z$7446))) (= z$21289 $x43272))) (assert (= z$21290 (not z$21289))) (assert (let (($x31451 (and z$11 z$13 z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53 z$5352 z$9055 z$12194))) (= z$21297 $x31451))) (assert (= z$21298 (not z$21297))) (assert (let (($x41729 (and z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53 z$2165 z$6784))) (= z$21315 $x41729))) (assert (= z$21316 (not z$21315))) (assert (let (($x27820 (and z$17 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$171 z$187))) (= z$21326 $x27820))) (assert (= z$21327 (not z$21326))) (assert (let (($x31038 (and a_file_req z$17 a_new_file z$43 a_wait_ack z$53 z$1055 z$6784))) (= z$21340 $x31038))) (assert (= z$21341 (not z$21340))) (assert (let (($x74324 (and z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53 z$2659 z$6784 z$7446))) (= z$21353 $x74324))) (assert (= z$21354 (not z$21353))) (assert (let (($x69569 (and z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53 z$2363 z$6784))) (= z$21364 $x69569))) (assert (= z$21365 (not z$21364))) (assert (let (($x57621 (and z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53 z$2659 z$6784 z$7446 z$12194))) (= z$21372 $x57621))) (assert (= z$21373 (not z$21372))) (assert (let (($x40894 (and z$19 a_init_state a_new_file z$31 z$43 z$47 z$51 z$53 z$2363 z$6784 z$12194))) (= z$21383 $x40894))) (assert (= z$21384 (not z$21383))) (assert (let (($x38650 (and a_BAD_K a_file_req a_new_file a_wait_ack z$53 z$1055 z$2501 z$6792 z$9345 z$10905))) (= z$21404 $x38650))) (assert (= z$21405 (not z$21404))) (assert (let (($x55406 (and a_file_req a_new_file a_wait_ack z$53 z$1055 z$2465 z$2658 z$2745))) (= z$21415 $x55406))) (assert (= z$21416 (not z$21415))) (assert (let (($x73358 (and a_file_req a_new_file a_wait_ack z$53 z$1055 z$2160 z$7436 z$7446 z$11259))) (= z$21426 $x73358))) (assert (= z$21427 (not z$21426))) (assert (let (($x82663 (and a_BAD_K a_file_req a_new_file a_wait_ack z$53 z$114 z$1055 z$2658 z$4289))) (= z$21439 $x82663))) (assert (= z$21440 (not z$21439))) (assert (let (($x47488 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2166 z$6792 z$12076))) (= z$21447 $x47488))) (assert (= z$21448 (not z$21447))) (assert (let (($x44838 (and z$1 a_file_req z$13 z$15 a_new_file z$31 a_start_K z$53 z$60 z$2746))) (= z$21468 $x44838))) (assert (= z$21469 (not z$21468))) (assert (let (($x70417 (and a_BAD_K a_file_req a_new_file z$31 z$53 z$60 z$1055 z$2746 z$6784))) (= z$21476 $x70417))) (assert (= z$21477 (not z$21476))) (assert (let (($x5295 (and a_file_req a_new_file a_wait_ack z$53 z$143 z$1055 z$2465 z$7446 z$9345))) (= z$21484 $x5295))) (assert (= z$21485 (not z$21484))) (assert (let (($x29070 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$218 z$2168 z$6792 z$9345))) (= z$21492 $x29070))) (assert (= z$21493 (not z$21492))) (assert (let (($x71465 (and a_BAD_K a_file_req a_new_file a_wait_ack z$53 z$145 z$1055 z$2465 z$9345 z$10905))) (= z$21508 $x71465))) (assert (= z$21509 (not z$21508))) (assert (let (($x70663 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$187 z$218 z$2168))) (= z$21516 $x70663))) (assert (= z$21517 (not z$21516))) (assert (let (($x14735 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$6792 z$11819))) (= z$21527 $x14735))) (assert (= z$21528 (not z$21527))) (assert (let (($x66033 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$187 z$11819))) (= z$21538 $x66033))) (assert (= z$21539 (not z$21538))) (assert (let (($x15854 (and a_BAD_K a_file_req a_new_file a_wait_ack z$53 z$1055 z$2160 z$2465 z$9345 z$10905))) (= z$21552 $x15854))) (assert (= z$21553 (not z$21552))) (assert (let (($x24157 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$11819))) (= z$21560 $x24157))) (assert (= z$21561 (not z$21560))) (assert (let (($x82065 (= z$911 z$n0s32))) (= z$17182 $x82065))) (assert (let (($x25814 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$220 z$913 z$17182))) (= z$21571 $x25814))) (assert (= z$21572 (not z$21571))) (assert (let (($x57326 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$220 z$5657))) (= z$21583 $x57326))) (assert (= z$21584 (not z$21583))) (assert (= z$6996 (and (distinct z$845 z$n2s32) true))) (assert (let (($x21585 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$220 z$913 z$6996))) (= z$21594 $x21585))) (assert (= z$21595 (not z$21594))) (assert (let (($x76691 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$1006 z$2166 z$14273))) (= z$21606 $x76691))) (assert (= z$21607 (not z$21606))) (assert (let (($x76923 (and a_file_req a_new_file a_wait_ack z$53 z$1003 z$1055 z$2465 z$13048))) (= z$21620 $x76923))) (assert (= z$21621 (not z$21620))) (assert (let (($x79715 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$1003 z$2168 z$14273))) (= z$21628 $x79715))) (assert (= z$21629 (not z$21628))) (assert (let (($x60561 (and a_file_req a_new_file a_wait_ack z$53 z$1055 z$2465 z$2760 z$13048))) (= z$21642 $x60561))) (assert (= z$21643 (not z$21642))) (assert (let (($x36686 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2168 z$2760 z$14273))) (= z$21650 $x36686))) (assert (= z$21651 (not z$21650))) (assert (let (($x81786 (and a_file_req a_new_file a_wait_ack z$53 z$991 z$1055 z$2465 z$13048))) (= z$21664 $x81786))) (assert (= z$21665 (not z$21664))) (assert (let (($x46661 (and z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$913 z$2165 z$2166 z$2659 z$9233 z$13629))) (= z$21672 $x46661))) (assert (= z$21673 (not z$21672))) (assert (let (($x78860 (= z$288 z$n2s32))) (= z$13520 $x78860))) (assert (let (($x50756 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$10031 z$13520))) (= z$21683 $x50756))) (assert (= z$21684 (not z$21683))) (assert (let (($x20483 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$5593 z$10031))) (= z$21695 $x20483))) (assert (= z$21696 (not z$21695))) (assert (let (($x76563 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$5593 z$10032))) (= z$21706 $x76563))) (assert (= z$21707 (not z$21706))) (assert (let (($x55240 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$12679))) (= z$21725 $x55240))) (assert (= z$21726 (not z$21725))) (assert (let (($x59494 (and a_file_req a_new_file a_wait_ack z$53 z$114 z$991 z$1055 z$4289))) (= z$21739 $x59494))) (assert (= z$21740 (not z$21739))) (assert (let (($x50789 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$269 z$991))) (= z$21747 $x50789))) (assert (= z$21748 (not z$21747))) (assert (let (($x16465 (and a_BAD_K a_file_req a_new_file a_wait_ack z$53 z$114 z$1055 z$4289 z$9345))) (= z$21761 $x16465))) (assert (= z$21762 (not z$21761))) (assert (let (($x14666 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$269 z$9345))) (= z$21769 $x14666))) (assert (= z$21770 (not z$21769))) (assert (let (($x76337 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2165 z$2363 z$5192 z$9345))) (= z$21777 $x76337))) (assert (= z$21778 (not z$21777))) (assert (let (($x71788 (and a_BAD_K a_file_req a_new_file z$31 z$53 z$1055 z$2746))) (= z$21800 $x71788))) (assert (= z$21801 (not z$21800))) (assert (let (($x24973 (and a_BAD_K a_file_req z$13 z$15 a_new_file z$31 z$53 z$60 z$1055 z$2746))) (= z$21808 $x24973))) (assert (= z$21809 (not z$21808))) (assert (let (($x60101 (and a_file_req a_new_file a_wait_ack z$53 z$1055 z$2465 z$13629))) (= z$21816 $x60101))) (assert (= z$21817 (not z$21816))) (assert (let (($x36693 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$9345 z$13629))) (= z$21824 $x36693))) (assert (= z$21825 (not z$21824))) (assert (let (($x42932 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363 z$5192 z$9345))) (= z$21832 $x42932))) (assert (= z$21833 (not z$21832))) (assert (let (($x16370 (and z$11 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$62 z$237))) (= z$21843 $x16370))) (assert (= z$21844 (not z$21843))) (assert (let (($x45210 (and z$11 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$143 z$3258 z$11461))) (= z$21854 $x45210))) (assert (= z$21855 (not z$21854))) (assert (= z$2679 (and (distinct z$889 z$n2s32) true))) (assert (let (($x46331 (and z$19 z$21 a_init_state a_new_file z$31 z$47 z$51 z$53 z$913 z$2168 z$2363 z$2679 z$9057 z$12194 z$12226))) (= z$21862 $x46331))) (assert (= z$21863 (not z$21862))) (assert (let (($x83767 (= z$212 z$279))) (= z$16915 $x83767))) (assert (let (($x75217 (and z$19 z$21 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363 z$5352 z$12194 z$16915))) (= z$21874 $x75217))) (assert (= z$21875 (not z$21874))) (assert (= z$6273 (and (distinct z$223 z$845) true))) (assert (let (($x46873 (and z$19 z$21 a_init_state a_new_file z$31 z$47 z$51 z$53 z$220 z$2363 z$5352 z$6273 z$12194))) (= z$21886 $x46873))) (assert (= z$21887 (not z$21886))) (assert (let (($x61402 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$913 z$2166 z$2213 z$2363 z$12194 z$20047))) (= z$21898 $x61402))) (assert (= z$21899 (not z$21898))) (assert (let (($x80440 (and z$11 z$19 z$21 a_init_state a_new_file z$31 z$47 z$51 z$53 z$145 z$218 z$2168 z$2276 z$2363 z$12194))) (= z$21909 $x80440))) (assert (= z$21910 (not z$21909))) (assert (let (($x61083 (and z$19 z$21 a_init_state a_new_file z$31 z$47 z$51 z$53 z$913 z$2363 z$5352 z$7030 z$12194 z$20047))) (= z$21920 $x61083))) (assert (= z$21921 (not z$21920))) (assert (= z$5783 (and (distinct z$214 z$n1s32) true))) (assert (let (($x24295 (and z$19 z$21 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363 z$5352 z$5783 z$12194 z$14273))) (= z$21931 $x24295))) (assert (= z$21932 (not z$21931))) (assert (let (($x15216 (and z$11 z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$2363 z$8822))) (= z$21948 $x15216))) (assert (= z$21949 (not z$21948))) (assert (let (($x59447 (and a_BAD_K z$19 a_init_state a_new_file z$31 z$47 z$51 z$53 z$220 z$2168 z$2363 z$12194 z$14273))) (= z$21956 $x59447))) (assert (= z$21957 (not z$21956))) (assert (let (($x77956 (and z$11 z$19 z$21 a_init_state a_new_file z$31 z$47 z$51 z$53 z$66 z$2363 z$12194))) (= z$21969 $x77956))) (assert (= z$21970 (not z$21969))) (assert (let (($x24606 (and z$19 a_in_transit_K a_init_state a_new_file z$31 z$47 z$51 z$53 z$14636))) (= z$21983 $x24606))) (assert (= z$21984 (not z$21983))) (assert (let (($x46264 (and z$2649 z$3008 z$2997 z$3447 z$7058 z$77 z$7947 z$8028 z$8470 z$2373 z$2369 z$2371 z$9007 z$3775 z$3784 z$9488 z$9655 z$9921 z$10161 z$10172 z$10296 z$10500 z$10639 z$10647 z$10847 z$5308 z$10874 z$10903 z$56 z$11708 z$11720 z$11731 z$11764 z$11775 z$11787 z$11810 z$11839 z$11847 z$11860 z$11876 z$11892 z$11900 z$11974 z$11982 z$12344 z$12352 z$12364 z$12378 z$9037 z$6977 z$12431 z$13627 z$13640 z$13654 z$13677 z$13746 z$13785 z$13794 z$13834 z$13842 z$13866 z$13874 z$13882 z$13896 z$14000 z$14033 z$14041 z$14052 z$14101 z$14112 z$14123 z$14131 z$14156 z$14164 z$14175 z$14186 z$14223 z$14234 z$14246 z$14255 z$14263 z$14321 z$14329 z$14337 z$14376 z$14409 z$14417 z$14444 z$14460 z$14497 z$14505 z$14513 z$14521 z$14769 z$5342 z$7286 z$12472 z$14976 z$14995 z$15119 z$15130 z$15246 z$12439 z$15462 z$15470 z$15600 z$15608 z$75 z$16012 z$16026 z$16034 z$16042 z$16050 z$16058 z$16078 z$16087 z$16101 z$16115 z$16126 z$16147 z$16155 z$16163 z$16245 z$8448 z$16275 z$16283 z$10863 z$11753 z$16323 z$16331 z$16339 z$16368 z$16376 z$16384 z$16415 z$16423 z$16431 z$16439 z$16468 z$16481 z$16493 z$16504 z$16519 z$16527 z$16571 z$16613 z$16621 z$16632 z$16646 z$16654 z$16670 z$16685 z$16705 z$16717 z$16742 z$16753 z$16766 z$16788 z$16819 z$16827 z$16835 z$16849 z$16857 z$16872 z$16880 z$16888 z$16896 z$16933 z$16941 z$16950 z$16976 z$16984 z$17033 z$17042 z$17056 z$17064 z$17078 z$17086 z$17094 z$17102 z$17113 z$17141 z$17149 z$17163 z$17171 z$17179 z$17212 z$17220 z$17242 z$17250 z$17258 z$17269 z$17277 z$17309 z$17325 z$17333 z$17352 z$17372 z$17380 z$17394 z$17402 z$17415 z$7318 z$7433 z$8498 z$8559 z$8607 z$9472 z$10395 z$10806 z$14093 z$13375 z$14559 z$2073 prop z$91 z$98 z$105 z$168 z$200 z$233 z$266 z$300 z$358 z$375 z$432 z$442 z$483 z$515 z$543 z$555 z$572 z$591 z$603 z$616 z$622 z$637 z$661 z$679 z$688 z$708 z$722 z$731 z$742 z$752 z$762 z$777 z$788 z$800 z$814 z$824 z$2065 z$2154 z$4226 z$4234 z$5293 z$5297 z$7530 z$7537 z$7590 z$7595 z$7617 z$7616 z$7666 z$7671 z$2469 z$2511 z$7740 z$7738 z$7817 z$7826 z$7873 z$7878 z$8678 z$8686 z$8726 z$8728 z$8769 z$8771 z$8808 z$8812 z$8865 z$8868 z$8972 z$8977 z$10959 z$10958 z$10985 z$10983 z$11070 z$11080 z$11134 z$11139 z$11203 z$11202 z$11256 z$11260 z$11297 z$11304 z$11322 z$11332 z$5205 z$5198 z$11386 z$11412 z$11411 z$11463 z$11469 z$11497 z$11542 z$11548 z$11593 z$11592 z$11625 z$11624 z$4472 z$4550 z$12104 z$12131 z$12157 z$12191 z$12218 z$12217 z$12247 z$12246 z$12272 z$12276 z$12981 z$12980 z$13028 z$13033 z$13078 z$13126 z$13125 z$13166 z$13168 z$13194 z$13196 z$13222 z$13224 z$13251 z$13253 z$13276 z$13275 z$13308 z$13310 z$4684 z$4859 z$13422 z$13425 z$13448 z$13498 z$13543 z$13580 z$14597 z$14599 z$14629 z$14628 z$14662 z$14666 z$14694 z$14729 z$14757 z$14862 z$14867 z$14893 z$14896 z$14930 z$14929 z$15041 z$15047 z$15103 z$15167 z$15170 z$15194 z$9028 z$9027 z$15332 z$15334 z$5045 z$5148 z$15404 z$15406 z$15538 z$15536 z$15703 z$15706 z$15758 z$15767 z$15826 z$15825 z$15852 z$15907 z$15909 z$15960 z$15962 z$15995 z$17452 z$17466 z$17480 z$17488 z$17496 z$17504 z$17522 z$17539 z$17550 z$17561 z$17572 z$17584 z$17597 z$18121 z$18156 z$18158 z$18168 z$18176 z$18211 z$18241 z$18240 z$18287 z$18286 z$18300 z$18308 z$18322 z$18333 z$18347 z$18355 z$18401 z$18403 z$18437 z$18445 z$18456 z$18467 z$18479 z$18487 z$18505 z$18513 z$18524 z$18549 z$18557 z$18571 z$18579 z$18587 z$18617 z$18628 z$18639 z$18647 z$18658 z$18669 z$18680 z$18691 z$18706 z$18714 z$18728 z$18736 z$18747 z$18761 z$9270 z$18774 z$13904 z$13912 z$18792 z$18841 z$18882 z$18890 z$18904 z$18912 z$18920 z$19162 z$19185 z$19196 z$19204 z$19212 z$19220 z$19231 z$19251 z$19264 z$19275 z$19286 z$19311 z$19320 z$19332 z$19340 z$19379 z$19387 z$19398 z$19409 z$19423 z$19431 z$19439 z$19447 z$19491 z$19614 z$19636 z$19647 z$19655 z$19663 z$19671 z$19686 z$19694 z$19705 z$19723 z$19738 z$19746 z$19760 z$19769 z$19777 z$19785 z$19796 z$19810 z$14060 z$14068 z$19828 z$19854 z$19862 z$19873 z$19886 z$19897 z$19905 z$19922 z$19930 z$19941 z$19966 z$19974 z$19985 z$19999 z$20007 z$20015 z$20026 z$20034 z$20045 z$20067 z$20075 z$20084 z$20099 z$20109 z$20127 z$20135 z$20143 z$20157 z$20165 z$20186 z$20208 z$20219 z$20230 z$20238 z$20246 z$20254 z$20265 z$20279 z$20287 z$20302 z$20310 z$20324 z$20332 z$20349 z$20357 z$20365 z$20373 z$20381 z$20392 z$20417 z$20428 z$20439 z$20451 z$20465 z$20473 z$20484 z$20496 z$20511 z$20519 z$20527 z$20535 z$20546 z$20563 z$20571 z$20579 z$20590 z$20610 z$20618 z$20626 z$20634 z$20645 z$20659 z$20667 z$20699 z$20707 z$20715 z$20723 z$20731 z$20739 z$20759 z$20767 z$20775 z$20783 z$20805 z$20813 z$20824 z$20832 z$20854 z$20862 z$20870 z$20884 z$20892 z$20900 z$20908 z$20930 z$20938 z$20946 z$20954 z$20972 z$20980 z$20991 z$21005 z$21016 z$21030 z$21038 z$21046 z$21054 z$21074 z$21082 z$21090 z$21098 z$21119 z$21127 z$21135 z$21153 z$21161 z$21175 z$21183 z$21201 z$21214 z$21222 z$21233 z$21241 z$21258 z$21266 z$9921 z$21282 z$21290 z$21298 z$21316 z$21327 z$21341 z$21354 z$21365 z$21373 z$21384 z$21405 z$21416 z$21427 z$21440 z$21448 z$21469 z$21477 z$21485 z$21493 z$21509 z$21517 z$21528 z$21539 z$21553 z$21561 z$21572 z$21584 z$21595 z$21607 z$21621 z$21629 z$21643 z$21651 z$21665 z$21673 z$21684 z$21696 z$21707 z$21726 z$21740 z$21748 z$21762 z$21770 z$21778 z$21801 z$21809 z$21817 z$21825 z$21833 z$21844 z$21855 z$21863 z$21875 z$21887 z$21899 z$21910 z$21921 z$21932 z$21949 z$21957 z$21970 z$21984))) (= z$21999 $x46264))) (assert z$21999) (assert (=> p$0 a_new_file$next)) (assert (=> p$1 a_wait_ack$next)) (assert (=> p$2 a_in_transit_K$next)) (assert (=> p$3 a_start_K$next)) (assert (=> p$4 a_start_L$next)) (assert (=> p$5 a_file_req$next)) (assert (let (($x140 (= z$2115 (not dve_invalid$next)))) (=> p$6 $x140))) (assert (=> p$6 z$2115)) (assert (=> p$7 (= z$2180 (not a_next_frame$next)))) (assert (=> p$7 z$2180)) (assert (=> p$8 (= z$2186 (not a_BAD_K$next)))) (assert (=> p$8 z$2186)) (assert (let (($x6777 (= z$n3s8 v_rc$next))) (let (($x5776 (= z$2540 $x6777))) (=> p$9 $x5776)))) (assert (=> p$9 z$2540)) (assert (let ((?x149 (Concat_32_16_16 z$n0s16 v_X$next))) (let (($x150 (= z$2118 ?x149))) (=> p$10 $x150)))) (assert (let (($x4614 (= z$2652 (and (distinct z$2118 z$n0s32) true)))) (=> p$10 $x4614))) (assert (=> p$10 z$2652)) (assert (=> p$11 (= z$2712 (and (distinct v_V$next z$n0s16) true)))) (assert (=> p$11 z$2712)) (assert (let (($x8318 (= z$2791 (and (distinct v_U$next z$n0s16) true)))) (=> p$12 $x8318))) (assert (=> p$12 z$2791)) (assert (let ((?x174 (BitWiseXor_16_16_16 z$n30s16 v_SYNC$next))) (let (($x175 (= z$2130 ?x174))) (=> p$13 $x175)))) (assert (let ((?x182 (Concat_32_16_16 z$n0s16 z$2130))) (let (($x183 (= z$2134 ?x182))) (=> p$13 $x183)))) (assert (=> p$13 (= z$2687 (Extract_1_15_15_16 v_V$next)))) (assert (let ((?x7947 (Concat_32_16_16 z$n0s16 v_V$next))) (let (($x7707 (= z$2689 ?x7947))) (=> p$13 $x7707)))) (assert (let ((?x6261 (BitWiseNot_32_32 z$2689))) (let (($x5788 (= z$2696 ?x6261))) (=> p$13 $x5788)))) (assert (let ((?x6281 (ShiftR_32_32_32 z$2696 z$n16s32))) (let (($x6054 (= z$2698 ?x6281))) (=> p$13 $x6054)))) (assert (let ((?x7913 (BitWiseNot_32_32 z$2698))) (let (($x8432 (= z$2700 ?x7913))) (=> p$13 $x8432)))) (assert (let ((?x7806 (ShiftR_32_32_32 z$2689 z$n16s32))) (let (($x6896 (= z$2702 ?x7806))) (=> p$13 $x6896)))) (assert (let ((?x6375 (ite z$2687 z$2700 z$2702))) (let (($x7129 (= z$2704 ?x6375))) (=> p$13 $x7129)))) (assert (let ((?x8568 (Add_32_32_32 z$n1s32 z$2704))) (let (($x20167 (= z$5830 ?x8568))) (=> p$13 $x20167)))) (assert (=> p$13 (= z$5839 (and (distinct z$2134 z$5830) true)))) (assert (=> p$13 z$5839)) (assert (let ((?x7947 (Concat_32_16_16 z$n0s16 v_V$next))) (let (($x7707 (= z$2689 ?x7947))) (=> p$14 $x7707)))) (assert (let ((?x7806 (ShiftR_32_32_32 z$2689 z$n16s32))) (let (($x6896 (= z$2702 ?x7806))) (=> p$14 $x6896)))) (assert (=> p$14 (= z$7440 (= z$2702 z$n5s32)))) (assert (=> p$14 z$7440)) (assert (let ((?x7947 (Concat_32_16_16 z$n0s16 v_V$next))) (let (($x7707 (= z$2689 ?x7947))) (=> p$15 $x7707)))) (assert (=> p$15 (= z$9563 (= z$2689 z$n0s32)))) (assert (=> p$15 z$9563)) (check-sat) (assert p$7) (assert p$6) (assert p$10) (assert p$15) (assert p$5) (assert p$4) (assert p$3) (assert p$11) (assert p$2) (assert p$1) (assert p$13) (assert p$0) (assert p$14) (assert p$8) (set-info :status sat) (check-sat) (exit) opensmt-2.5.2/regression/incremental/QF_UF_brp2.3.prop2_ab_min_max.smt2.expected.err000066400000000000000000000000001445011647600302630ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/QF_UF_brp2.3.prop2_ab_min_max.smt2.expected.out000066400000000000000000000000101445011647600303030ustar00rootroot00000000000000sat sat opensmt-2.5.2/regression/incremental/bmwlin_20_5_1.inter.bmc_k100_2_simplified.smt2000066400000000000000000000002321445011647600300000ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun t6 () Bool) (declare-fun t7 () Bool) (assert (or (not t6) (not t7))) ;(push 1) (assert (and t7 t6)) (check-sat) (exit) opensmt-2.5.2/regression/incremental/bmwlin_20_5_1.inter.bmc_k100_2_simplified.smt2.expected.err000066400000000000000000000000001445011647600323600ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/bmwlin_20_5_1.inter.bmc_k100_2_simplified.smt2.expected.out000066400000000000000000000000061445011647600324050ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/incremental/bmwlin_20_5_1.inter.bmc_k100_2_simplified.smt2.expected.time000066400000000000000000000000351445011647600325360ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/incremental/bmwlin_20_5_1.inter.bmc_k100_2_simplified_2.smt2000066400000000000000000000002541445011647600302250ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun t6 () Bool) (declare-fun t7 () Bool) (assert (or (not t6) (not t7))) (push 1) (assert (and t7 t6)) (check-sat) (pop 1) (check-sat) (exit) opensmt-2.5.2/regression/incremental/bmwlin_20_5_1.inter.bmc_k100_2_simplified_2.smt2.expected.err000066400000000000000000000000001445011647600326010ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/bmwlin_20_5_1.inter.bmc_k100_2_simplified_2.smt2.expected.out000066400000000000000000000000121445011647600326230ustar00rootroot00000000000000unsat sat opensmt-2.5.2/regression/incremental/bmwlin_20_5_1.inter.bmc_k100_2_simplified_2.smt2.expected.time000066400000000000000000000000351445011647600327570ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/incremental/cpachecker-induction.32_simple.smt2000066400000000000000000000103631445011647600263660ustar00rootroot00000000000000(set-logic QF_LRA) (set-info :source |CPAchecker with k-induction on SV-COMP14 program using MathSAT5, submitted by Philipp Wendler, http://cpachecker.sosy-lab.org|) (set-info :smt-lib-version 2.0) (set-info :category "industrial") (define-fun _1 () Bool true) (declare-fun busy@1 () Real) (declare-fun __ADDRESS_OF_virtio_rng_driver () Real) (declare-fun |main::tmp___1@3| () Real) (declare-fun ldv_mutex@1 () Real) (declare-fun |main::__cil_tmp10@1| () Real) (declare-fun |main::tmp___1@2| () Real) (declare-fun |main::__cil_tmp10@3| () Real) (declare-fun __ADDRESS_OF_have_data () Real) (declare-fun |main::ldv_s_virtio_rng_driver_virtio_driver@1| () Real) (declare-fun |main::__cil_tmp10@2| () Real) (declare-fun |main::tmp___0@2| () Real) (define-fun _7 () Real 0) (define-fun _36 () Real (- 1)) (define-fun _46 () Real __ADDRESS_OF_have_data) (define-fun _72 () Real (- 40)) (define-fun _73 () Bool (<= _46 _72)) (define-fun _74 () Bool (not _73)) (define-fun _81 () Real __ADDRESS_OF_virtio_rng_driver) (define-fun _89 () Real (* (- 1) _81)) (define-fun _105 () Real 1) (define-fun _169 () Real |main::tmp___1@3|) (define-fun _170 () Bool (= _169 _7)) (define-fun _176 () Real |main::__cil_tmp10@3|) (define-fun _179 () Bool (= _176 _7)) (define-fun _182 () Bool (not _179)) (define-fun _191 () Real |main::__cil_tmp10@2|) (define-fun _196 () Real |main::tmp___1@2|) (define-fun _237 () Bool (= _196 _7)) (define-fun _239 () Bool (not _237)) (define-fun _240 () Real |main::ldv_s_virtio_rng_driver_virtio_driver@1|) (define-fun _241 () Bool (= _240 _7)) (define-fun _242 () Real (ite _241 _105 _7)) (define-fun _243 () Bool (= _191 _242)) (define-fun _244 () Bool (and _237 _243)) (define-fun _245 () Bool (= _191 _7)) (define-fun _247 () Bool (and _244 _245)) (define-fun _250 () Real |main::__cil_tmp10@1|) (define-fun _251 () Bool (= _191 _250)) (define-fun _252 () Bool (and _239 _251)) (define-fun _253 () Bool (or _247 _252)) (define-fun _254 () Real |main::tmp___0@2|) (define-fun _255 () Bool (= _254 _7)) (define-fun _257 () Bool (and _253 _255)) (define-fun _263 () Real ldv_mutex@1) (define-fun _264 () Bool (= _263 _105)) (define-fun _267 () Bool (not _264)) (define-fun _270 () Real busy@1) (define-fun _271 () Bool (= _270 _7)) (define-fun _273 () Bool (and _257 _271)) (define-fun _274 () Bool (not _271)) (define-fun _275 () Bool (and _257 _274)) (define-fun _276 () Bool (<= _46 _7)) (define-fun _277 () Bool (not _276)) (define-fun _279 () Bool (and _275 _277)) (define-fun _280 () Bool (or _273 _279)) (define-fun _281 () Bool (and _170 _280)) (define-fun _283 () Bool (= _176 _242)) (define-fun _284 () Bool (and _281 _283)) (define-fun _300 () Real (+ _46 _89)) (define-fun _301 () Bool (<= _300 _72)) (define-fun _302 () Bool (and _74 _301)) (define-fun _315 () Bool (and _182 _302)) (define-fun _317 () Bool (and _267 _315)) (define-fun _318 () Bool (not _317)) (define-fun _319 () Bool (not _284)) (define-fun _320 () Bool (or _318 _319)) (define-fun _321 () Bool (not _320)) (declare-fun |main::__cil_tmp10@4| () Real) (declare-fun |main::tmp___0@3| () Real) (declare-fun |main::tmp___1@4| () Real) (define-fun _173 () Bool (not _170)) (define-fun _184 () Real |main::tmp___0@3|) (define-fun _185 () Bool (= _184 _7)) (define-fun _192 () Bool (= _176 _191)) (define-fun _282 () Bool (and _173 _280)) (define-fun _285 () Bool (and _179 _284)) (define-fun _296 () Bool (and _192 _282)) (define-fun _297 () Bool (or _285 _296)) (define-fun _298 () Bool (and _185 _297)) (define-fun _312 () Bool (and _271 _298)) (define-fun _313 () Bool (and _274 _298)) (define-fun _314 () Bool (or _312 _313)) (define-fun _329 () Real |main::tmp___1@4|) (define-fun _330 () Bool (= _329 _7)) (define-fun _363 () Bool (and _314 _330)) (define-fun _365 () Real |main::__cil_tmp10@4|) (define-fun _366 () Bool (= _242 _365)) (define-fun _367 () Bool (and _363 _366)) (define-fun _368 () Bool (= _365 _7)) (define-fun _371 () Bool (not _368)) (define-fun _402 () Bool (and _302 _371)) (define-fun _404 () Bool (and _267 _402)) (define-fun _405 () Bool (not _404)) (define-fun _406 () Bool (not _367)) (define-fun _407 () Bool (or _405 _406)) (define-fun _408 () Bool (not _407)) (push 1) (assert _1) (push 1) (assert _321) ;(set-info :status sat) (check-sat) (pop 1) (push 1) (assert _408) ;(set-info :status sat) (check-sat) opensmt-2.5.2/regression/incremental/cpachecker-induction.32_simple.smt2.expected.err000066400000000000000000000000001445011647600307400ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/cpachecker-induction.32_simple.smt2.expected.out000066400000000000000000000000101445011647600307600ustar00rootroot00000000000000sat sat opensmt-2.5.2/regression/incremental/cpachecker-induction.32_simple.smt2.expected.time000066400000000000000000000000351445011647600311160ustar00rootroot00000000000000real 0.03 user 0.03 sys 0.00 opensmt-2.5.2/regression/incremental/cpachecker-induction.32_simple2.smt2000066400000000000000000000103361445011647600264500ustar00rootroot00000000000000(set-logic QF_LRA) (set-info :source |CPAchecker with k-induction on SV-COMP14 program using MathSAT5, submitted by Philipp Wendler, http://cpachecker.sosy-lab.org|) (set-info :smt-lib-version 2.0) (set-info :category "industrial") (define-fun _1 () Bool true) (declare-fun busy@1 () Real) (declare-fun __ADDRESS_OF_virtio_rng_driver () Real) (declare-fun |main::tmp___1@3| () Real) (declare-fun ldv_mutex@1 () Real) (declare-fun |main::__cil_tmp10@1| () Real) (declare-fun |main::tmp___1@2| () Real) (declare-fun |main::__cil_tmp10@3| () Real) (declare-fun __ADDRESS_OF_have_data () Real) (declare-fun |main::ldv_s_virtio_rng_driver_virtio_driver@1| () Real) (declare-fun |main::__cil_tmp10@2| () Real) (declare-fun |main::tmp___0@2| () Real) (define-fun _7 () Real 0) (define-fun _36 () Real (- 1)) (define-fun _46 () Real __ADDRESS_OF_have_data) (define-fun _72 () Real (- 40)) (define-fun _73 () Bool (<= _46 _72)) (define-fun _74 () Bool (not _73)) (define-fun _81 () Real __ADDRESS_OF_virtio_rng_driver) (define-fun _89 () Real (* (- 1) _81)) (define-fun _105 () Real 1) (define-fun _169 () Real |main::tmp___1@3|) (define-fun _170 () Bool (= _169 _7)) (define-fun _176 () Real |main::__cil_tmp10@3|) (define-fun _179 () Bool (= _176 _7)) (define-fun _182 () Bool (not _179)) (define-fun _191 () Real |main::__cil_tmp10@2|) (define-fun _196 () Real |main::tmp___1@2|) (define-fun _237 () Bool (= _196 _7)) (define-fun _239 () Bool (not _237)) (define-fun _240 () Real |main::ldv_s_virtio_rng_driver_virtio_driver@1|) (define-fun _241 () Bool (= _240 _7)) (define-fun _242 () Real (ite _241 _105 _7)) (define-fun _243 () Bool (= _191 _242)) (define-fun _244 () Bool (and _237 _243)) (define-fun _245 () Bool (= _191 _7)) (define-fun _247 () Bool (and _244 _245)) (define-fun _250 () Real |main::__cil_tmp10@1|) (define-fun _251 () Bool (= _191 _250)) (define-fun _252 () Bool (and _239 _251)) (define-fun _253 () Bool (or _247 _252)) (define-fun _254 () Real |main::tmp___0@2|) (define-fun _255 () Bool (= _254 _7)) (define-fun _257 () Bool (and _253 _255)) (define-fun _263 () Real ldv_mutex@1) (define-fun _264 () Bool (= _263 _105)) (define-fun _267 () Bool (not _264)) (define-fun _270 () Real busy@1) (define-fun _271 () Bool (= _270 _7)) (define-fun _273 () Bool (and _257 _271)) (define-fun _274 () Bool (not _271)) (define-fun _275 () Bool (and _257 _274)) (define-fun _276 () Bool (<= _46 _7)) (define-fun _277 () Bool (not _276)) (define-fun _279 () Bool (and _275 _277)) (define-fun _280 () Bool (or _273 _279)) (define-fun _281 () Bool (and _170 _280)) (define-fun _283 () Bool (= _176 _242)) (define-fun _284 () Bool (and _281 _283)) (define-fun _300 () Real (+ _46 _89)) (define-fun _301 () Bool (<= _300 _72)) (define-fun _302 () Bool (and _74 _301)) (define-fun _315 () Bool (and _182 _302)) (define-fun _317 () Bool (and _267 _315)) (define-fun _318 () Bool (not _317)) (define-fun _319 () Bool (not _284)) (define-fun _320 () Bool (or _318 _319)) (define-fun _321 () Bool (not _320)) (declare-fun |main::__cil_tmp10@4| () Real) (declare-fun |main::tmp___0@3| () Real) (declare-fun |main::tmp___1@4| () Real) (define-fun _173 () Bool (not _170)) (define-fun _184 () Real |main::tmp___0@3|) (define-fun _185 () Bool (= _184 _7)) (define-fun _192 () Bool (= _176 _191)) (define-fun _282 () Bool (and _173 _280)) (define-fun _285 () Bool (and _179 _284)) (define-fun _296 () Bool (and _192 _282)) (define-fun _297 () Bool (or _285 _296)) (define-fun _298 () Bool (and _185 _297)) (define-fun _312 () Bool (and _271 _298)) (define-fun _313 () Bool (and _274 _298)) (define-fun _314 () Bool (or _312 _313)) (define-fun _329 () Real |main::tmp___1@4|) (define-fun _330 () Bool (= _329 _7)) (define-fun _363 () Bool (and _314 _330)) (define-fun _365 () Real |main::__cil_tmp10@4|) (define-fun _366 () Bool (= _242 _365)) (define-fun _367 () Bool (and _363 _366)) (define-fun _368 () Bool (= _365 _7)) (define-fun _371 () Bool (not _368)) (define-fun _402 () Bool (and _302 _371)) (define-fun _404 () Bool (and _267 _402)) (define-fun _405 () Bool (not _404)) (define-fun _406 () Bool (not _367)) (define-fun _407 () Bool (or _405 _406)) (define-fun _408 () Bool (not _407)) (push 1) (assert _321) ;(set-info :status sat) (check-sat) (pop 1) (push 1) (assert _408) ;(set-info :status sat) (check-sat) opensmt-2.5.2/regression/incremental/cpachecker-induction.32_simple2.smt2.expected.err000066400000000000000000000000001445011647600310220ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/cpachecker-induction.32_simple2.smt2.expected.out000066400000000000000000000000101445011647600310420ustar00rootroot00000000000000sat sat opensmt-2.5.2/regression/incremental/cpachecker-induction.32_simple2.smt2.expected.time000066400000000000000000000000351445011647600312000ustar00rootroot00000000000000real 0.03 user 0.03 sys 0.00 opensmt-2.5.2/regression/incremental/cpachecker-induction.32_simple_simplified_0.smt2000066400000000000000000000076001445011647600310120ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun busy@1 () Real) (declare-fun __ADDRESS_OF_virtio_rng_driver () Real) (declare-fun |main::tmp___1@3| () Real) (declare-fun ldv_mutex@1 () Real) (declare-fun |main::__cil_tmp10@1| () Real) (declare-fun |main::tmp___1@2| () Real) (declare-fun |main::__cil_tmp10@3| () Real) (declare-fun __ADDRESS_OF_have_data () Real) (declare-fun |main::ldv_s_virtio_rng_driver_virtio_driver@1| () Real) (declare-fun |main::__cil_tmp10@2| () Real) (declare-fun |main::tmp___0@2| () Real) (define-fun _7 () Real 0) (define-fun _46 () Real __ADDRESS_OF_have_data) (define-fun _72 () Real (- 40)) (define-fun _73 () Bool (<= _46 _72)) (define-fun _74 () Bool (not _73)) (define-fun _81 () Real __ADDRESS_OF_virtio_rng_driver) (define-fun _89 () Real (* (- 1) _81)) (define-fun _105 () Real 1) (define-fun _169 () Real |main::tmp___1@3|) (define-fun _170 () Bool (= _169 _7)) (define-fun _176 () Real |main::__cil_tmp10@3|) (define-fun _179 () Bool (= _176 _7)) (define-fun _182 () Bool (not _179)) (define-fun _191 () Real |main::__cil_tmp10@2|) (define-fun _196 () Real |main::tmp___1@2|) (define-fun _237 () Bool (= _196 _7)) (define-fun _239 () Bool (not _237)) (define-fun _240 () Real |main::ldv_s_virtio_rng_driver_virtio_driver@1|) (define-fun _241 () Bool (= _240 _7)) (define-fun _242 () Real (ite _241 _105 _7)) (define-fun _243 () Bool (= _191 _242)) (define-fun _244 () Bool (and _237 _243)) (define-fun _245 () Bool (= _191 _7)) (define-fun _247 () Bool (and _244 _245)) (define-fun _250 () Real |main::__cil_tmp10@1|) (define-fun _251 () Bool (= _191 _250)) (define-fun _252 () Bool (and _239 _251)) (define-fun _253 () Bool (or _247 _252)) (define-fun _254 () Real |main::tmp___0@2|) (define-fun _255 () Bool (= _254 _7)) (define-fun _257 () Bool (and _253 _255)) (define-fun _263 () Real ldv_mutex@1) (define-fun _264 () Bool (= _263 _105)) (define-fun _267 () Bool (not _264)) (define-fun _270 () Real busy@1) (define-fun _271 () Bool (= _270 _7)) (define-fun _273 () Bool (and _257 _271)) (define-fun _274 () Bool (not _271)) (define-fun _275 () Bool (and _257 _274)) (define-fun _276 () Bool (<= _46 _7)) (define-fun _277 () Bool (not _276)) (define-fun _279 () Bool (and _275 _277)) (define-fun _280 () Bool (or _273 _279)) (define-fun _281 () Bool (and _170 _280)) (define-fun _283 () Bool (= _176 _242)) (define-fun _284 () Bool (and _281 _283)) (define-fun _300 () Real (+ _46 _89)) (define-fun _301 () Bool (<= _300 _72)) (define-fun _302 () Bool (and _74 _301)) (define-fun _315 () Bool (and _182 _302)) (define-fun _317 () Bool (and _267 _315)) (define-fun _318 () Bool (not _317)) (define-fun _319 () Bool (not _284)) (define-fun _320 () Bool (or _318 _319)) (define-fun _321 () Bool (not _320)) (declare-fun |main::__cil_tmp10@4| () Real) (declare-fun |main::tmp___0@3| () Real) (declare-fun |main::tmp___1@4| () Real) (define-fun _173 () Bool (not _170)) (define-fun _184 () Real |main::tmp___0@3|) (define-fun _185 () Bool (= _184 _7)) (define-fun _192 () Bool (= _176 _191)) (define-fun _282 () Bool (and _173 _280)) (define-fun _285 () Bool (and _179 _284)) (define-fun _296 () Bool (and _192 _282)) (define-fun _297 () Bool (or _285 _296)) (define-fun _298 () Bool (and _185 _297)) (define-fun _312 () Bool (and _271 _298)) (define-fun _313 () Bool (and _274 _298)) (define-fun _314 () Bool (or _312 _313)) (define-fun _329 () Real |main::tmp___1@4|) (define-fun _330 () Bool (= _329 _7)) (define-fun _363 () Bool (and _314 _330)) (define-fun _365 () Real |main::__cil_tmp10@4|) (define-fun _366 () Bool (= _242 _365)) (define-fun _367 () Bool (and _363 _366)) (define-fun _368 () Bool (= _365 _7)) (define-fun _371 () Bool (not _368)) (define-fun _402 () Bool (and _302 _371)) (define-fun _404 () Bool (and _267 _402)) (define-fun _405 () Bool (not _404)) (define-fun _406 () Bool (not _367)) (define-fun _407 () Bool (or _405 _406)) (define-fun _408 () Bool (not _407)) (push 1) (assert (and _321 _408)) (check-sat) opensmt-2.5.2/regression/incremental/cpachecker-induction.32_simple_simplified_0.smt2.expected.err000066400000000000000000000000001445011647600333640ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/cpachecker-induction.32_simple_simplified_0.smt2.expected.out000066400000000000000000000000061445011647600334110ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/incremental/cpachecker-induction.32_simple_simplified_0.smt2.expected.time000066400000000000000000000000351445011647600335420ustar00rootroot00000000000000real 0.01 user 0.01 sys 0.00 opensmt-2.5.2/regression/incremental/defined_global.smt2000066400000000000000000000004271445011647600234260ustar00rootroot00000000000000(set-logic QF_UF) (set-option :global-declarations true) (declare-sort U 0) (declare-fun x () U) (declare-fun f (U) U) (push 1) (define-fun a1 () Bool (not (= x (f x)))) (assert a1) (set-info :status sat) (check-sat) (pop 1) (assert a1) (set-info :status sat) (check-sat) (exit) opensmt-2.5.2/regression/incremental/defined_global.smt2.expected.err000066400000000000000000000000001445011647600260000ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/defined_global.smt2.expected.out000066400000000000000000000000101445011647600260200ustar00rootroot00000000000000sat sat opensmt-2.5.2/regression/incremental/defined_multiple.smt2000066400000000000000000000004211445011647600240130ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort U 0) (declare-fun x () U) (declare-fun f (U) U) (push 1) (define-fun a1 () Bool (not (= x (f x)))) (assert a1) (set-info :status sat) (check-sat) (pop 1) (define-fun a1 () Bool false) (assert a1) (set-info :status unsat) (check-sat) (exit) opensmt-2.5.2/regression/incremental/defined_multiple.smt2.expected.err000066400000000000000000000000001445011647600263730ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/defined_multiple.smt2.expected.out000066400000000000000000000000121445011647600264150ustar00rootroot00000000000000sat unsat opensmt-2.5.2/regression/incremental/double_unsat.smt2000066400000000000000000000001011445011647600231610ustar00rootroot00000000000000(set-logic QF_LRA) (assert false) (check-sat) (check-sat) (exit) opensmt-2.5.2/regression/incremental/double_unsat.smt2.expected.err000066400000000000000000000000001445011647600255460ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/double_unsat.smt2.expected.out000066400000000000000000000000141445011647600255720ustar00rootroot00000000000000unsat unsat opensmt-2.5.2/regression/incremental/double_unsat.smt2.expected.time000066400000000000000000000000351445011647600257240ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/incremental/inc_test.smt2000066400000000000000000000006371445011647600223230ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun x () Bool) (declare-fun y () Bool) (declare-fun z () Bool) (declare-fun a () Bool) (assert (or y x)) (assert (or a z)) (push 1) (assert (or y (not x))) (assert (or (not a) z)) (push 1) (assert (or (not z) (not y))) (check-sat) (pop 1) (assert true) (check-sat) (pop 1) (assert (or z y)) (assert (or (not z) y)) (assert (or (not y) (not a))) (assert (or (not y) (not z))) (check-sat) opensmt-2.5.2/regression/incremental/inc_test.smt2.expected.err000066400000000000000000000000001445011647600246720ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/inc_test.smt2.expected.out000066400000000000000000000000201445011647600247130ustar00rootroot00000000000000unsat sat unsat opensmt-2.5.2/regression/incremental/issue140.smt2000066400000000000000000000002561445011647600220650ustar00rootroot00000000000000(set-logic QF_LRA) (assert false) (push 1) (check-sat) (pop 1) (check-sat) (check-sat) (check-sat) (check-sat) (check-sat) (check-sat) (assert false) (check-sat) (check-sat) opensmt-2.5.2/regression/incremental/issue140.smt2.expected.err000066400000000000000000000000001445011647600244370ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue140.smt2.expected.out000066400000000000000000000000661445011647600244720ustar00rootroot00000000000000unsat unsat unsat unsat unsat unsat unsat unsat unsat opensmt-2.5.2/regression/incremental/issue140b.smt2000066400000000000000000000001601445011647600222210ustar00rootroot00000000000000(set-logic QF_UF) (check-sat) (assert false) (push 1) (check-sat) (pop 1) (check-sat) (assert true) (check-sat) opensmt-2.5.2/regression/incremental/issue140b.smt2.expected.err000066400000000000000000000000001445011647600246010ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue140b.smt2.expected.out000066400000000000000000000000261445011647600246300ustar00rootroot00000000000000sat unsat unsat unsat opensmt-2.5.2/regression/incremental/issue143.smt2000066400000000000000000000002771445011647600220730ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun v1 () Bool) (declare-fun v4 () Bool) (declare-fun v12 () Bool) (check-sat) (assert (xor v12 v4)) (assert (= v12 (and v1 v4))) (check-sat) (push 1) (check-sat) opensmt-2.5.2/regression/incremental/issue143.smt2.expected.err000066400000000000000000000000001445011647600244420ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue143.smt2.expected.out000066400000000000000000000000141445011647600244660ustar00rootroot00000000000000sat sat sat opensmt-2.5.2/regression/incremental/issue143b.smt2000066400000000000000000000003151445011647600222260ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun v2 () Bool) (declare-fun v3 () Bool) (declare-fun v9 () Bool) (assert (xor v3 v2)) (check-sat) (assert (= (distinct v9 v2) v3)) (push 1) (check-sat) (check-sat) (check-sat) opensmt-2.5.2/regression/incremental/issue143b.smt2.expected.err000066400000000000000000000000001445011647600246040ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue143b.smt2.expected.out000066400000000000000000000000201445011647600246250ustar00rootroot00000000000000sat sat sat sat opensmt-2.5.2/regression/incremental/issue143c.smt2000066400000000000000000000004241445011647600222300ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun v0 () Bool) (declare-fun v1 () Bool) (declare-fun v2 () Bool) (check-sat) (check-sat) (assert (xor v1 v0)) (check-sat) (check-sat) (assert (= (distinct v0 v2) v1)) (push 1) (check-sat) (check-sat) (pop 1) (check-sat) (assert false) (check-sat) opensmt-2.5.2/regression/incremental/issue143c.smt2.expected.err000066400000000000000000000000001445011647600246050ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue143c.smt2.expected.out000066400000000000000000000000421445011647600246320ustar00rootroot00000000000000sat sat sat sat sat sat sat unsat opensmt-2.5.2/regression/incremental/issue144.smt2000066400000000000000000000005201445011647600220630ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun v3 () Bool) (declare-fun v8 () Bool) (declare-fun v9 () Bool) (declare-fun v11 () Bool) (check-sat) (assert v11) (assert (distinct (= v8 v3) v9)) (check-sat) (declare-fun r14 () Real) (assert (distinct (>= r14 0.0) v9)) (assert (distinct (>= r14 0.0) (= v8 v3))) (push 1) (check-sat) (pop 1) (check-sat) opensmt-2.5.2/regression/incremental/issue144.smt2.expected.err000066400000000000000000000000001445011647600244430ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue144.smt2.expected.out000066400000000000000000000000241445011647600244700ustar00rootroot00000000000000sat sat unsat unsat opensmt-2.5.2/regression/incremental/issue144b.smt2000066400000000000000000000006211445011647600222270ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun v0 () Bool) (declare-fun v1 () Bool) (declare-fun v3 () Bool) (declare-fun v4 () Bool) (declare-fun v5 () Bool) (declare-fun v11 () Bool) (assert (distinct v5 (= v5 v0))) (assert v1) (assert (distinct v3 v11)) (assert (distinct v4 (xor v0 (distinct v3 v11)))) (assert v4) (push 1) (assert false) (check-sat) (pop 1) (push 1) (check-sat) (check-sat) (pop 1) (check-sat) opensmt-2.5.2/regression/incremental/issue144b.smt2.expected.err000066400000000000000000000000001445011647600246050ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue144b.smt2.expected.out000066400000000000000000000000301445011647600246270ustar00rootroot00000000000000unsat unsat unsat unsat opensmt-2.5.2/regression/incremental/issue144c.smt2000066400000000000000000000005721445011647600222350ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun _substvar_38_ () Bool) (declare-fun v2 () Bool) (declare-fun v3 () Bool) (declare-fun v4 () Bool) (declare-fun v5 () Bool) (assert (distinct v2 v4)) (assert (xor v5 v4)) (assert (= (and v3 (xor v5 (distinct v2 v4))) _substvar_38_)) (assert v3) (check-sat) (assert (distinct v4 (and (distinct v2 v4) v4))) (push 1) (check-sat) (pop 1) (check-sat) opensmt-2.5.2/regression/incremental/issue144c.smt2.expected.err000066400000000000000000000000001445011647600246060ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue144c.smt2.expected.out000066400000000000000000000000201445011647600246270ustar00rootroot00000000000000sat unsat unsat opensmt-2.5.2/regression/incremental/issue144d.smt2000066400000000000000000000003301445011647600222260ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun a () Bool) (declare-fun b () Bool) (assert (=> a b)) (check-sat) (push 1) (assert (=> a (not b))) (assert (=> (not a) (not b))) (assert (=> (not a) b)) (check-sat) (pop 1) (check-sat) opensmt-2.5.2/regression/incremental/issue144d.smt2.expected.err000066400000000000000000000000001445011647600246070ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue144d.smt2.expected.out000066400000000000000000000000161445011647600246350ustar00rootroot00000000000000sat unsat sat opensmt-2.5.2/regression/incremental/issue144e.smt2000066400000000000000000000005171445011647600222360ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun a () Bool) (declare-fun b () Bool) (assert (=> a b)) (check-sat) (push 1) (assert (=> a (not b))) (assert (=> (not a) (not b))) (assert (=> (not a) b)) (check-sat) (pop 1) (check-sat) (assert (=> a (not b))) (assert (=> (not a) (not b))) (assert (=> (not a) b)) (push 1) (check-sat) (pop 1) (check-sat) opensmt-2.5.2/regression/incremental/issue144e.smt2.expected.err000066400000000000000000000000001445011647600246100ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue144e.smt2.expected.out000066400000000000000000000000321445011647600246340ustar00rootroot00000000000000sat unsat sat unsat unsat opensmt-2.5.2/regression/incremental/issue152.smt2000066400000000000000000000002041445011647600220610ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun r11 () Real) (check-sat) (check-sat) (assert (> r11 0.0)) (push 1) (assert (> 0.0 r11)) (check-sat) opensmt-2.5.2/regression/incremental/issue152.smt2.expected.err000066400000000000000000000000001445011647600244420ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue152.smt2.expected.out000066400000000000000000000000161445011647600244700ustar00rootroot00000000000000sat sat unsat opensmt-2.5.2/regression/incremental/issue203.smt2000066400000000000000000000017211445011647600220630ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun v0 () Bool) (declare-fun v1 () Bool) (declare-fun v2 () Bool) (declare-fun v3 () Bool) (declare-fun v4 () Bool) (declare-fun v5 () Bool) (declare-fun v6 () Bool) (declare-fun v7 () Bool) (declare-fun v8 () Bool) (declare-fun v9 () Bool) (declare-fun r0 () Real) (declare-fun r4 () Real) (declare-fun r7 () Real) (declare-fun r8 () Real) (declare-fun r9 () Real) (declare-fun r10 () Real) (declare-fun r11 () Real) (declare-fun r14 () Real) (declare-fun r15 () Real) (declare-fun v10 () Bool) (assert v0) (declare-fun v11 () Bool) (declare-fun r17 () Real) (declare-fun r18 () Real) (declare-fun v13 () Bool) (assert (< 0.175 r0)) (push 3) (push 4) (declare-fun r21 () Real) (assert (not (< 0.175 r0))) (declare-fun v21 () Bool) (assert (=> (not (< 0.175 r0)) (< 0.175 r0))) (assert (= (+ 3157.0 r15) (- r10))) (push 4) (declare-fun v22 () Bool) (push 2) (assert v11) (assert (=> v21 (< r15 (+ (+ r18 0.994) r17)))) (push 1) (pop 12) (check-sat) opensmt-2.5.2/regression/incremental/issue203.smt2.expected.err000066400000000000000000000000001445011647600244370ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue203.smt2.expected.out000066400000000000000000000000041445011647600244620ustar00rootroot00000000000000sat opensmt-2.5.2/regression/incremental/issue272.smt2000066400000000000000000000001751445011647600220730ustar00rootroot00000000000000(set-option :produce-interpolants true) (set-logic QF_LRA) (push 1) (push 1) (assert false) (check-sat) (pop 1) (check-sat) opensmt-2.5.2/regression/incremental/issue272.smt2.expected.err000066400000000000000000000000001445011647600244450ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue272.smt2.expected.out000066400000000000000000000000121445011647600244670ustar00rootroot00000000000000unsat sat opensmt-2.5.2/regression/incremental/issue272b.smt2000066400000000000000000000026441445011647600222400ustar00rootroot00000000000000(set-option :produce-interpolants true) (set-logic QF_LRA) (declare-fun |x#0| () Real) (declare-fun |x#0##0| () Real) (declare-fun |x#0##1| () Real) (declare-fun |ts::x0##0| () Real) (declare-fun |ts::x0##1| () Real) (declare-fun |ts::x0##2| () Real) (assert (let ((?def206 (and (<= 0 (* (- 1) |ts::x0##1|)) (<= 0 |ts::x0##1|) ))) (let ((?def198 (and (<= (- 10) (* (- 1) |ts::x0##0|)) (<= 10 |ts::x0##0|) ))) (let ((?def204 (not ?def198))) (let ((?def207 (or ?def204 ?def206))) (let ((?def202 (and (<= (- 1) (+ |ts::x0##0| (* (- 1) |ts::x0##1|))) (<= 1 (+ (* (- 1) |ts::x0##0|) |ts::x0##1|)) ))) (let ((?def203 (or ?def198 ?def202))) (let ((?def208 (and ?def203 ?def207))) (let ((?def167 (and (<= 0 |ts::x0##2|) (<= 0 (* (- 1) |ts::x0##2|)) ))) (let ((?def154 (and (<= (- 10) (* (- 1) |ts::x0##1|)) (<= 10 |ts::x0##1|) ))) (let ((?def164 (not ?def154))) (let ((?def168 (or ?def164 ?def167))) (let ((?def162 (and (<= (- 1) (+ |ts::x0##1| (* (- 1) |ts::x0##2|))) (<= 1 (+ (* (- 1) |ts::x0##1|) |ts::x0##2|)) ))) (let ((?def163 (or ?def154 ?def162))) (let ((?def169 (and ?def163 ?def168))) (let ((?def209 (and ?def169 ?def208))) ?def209 )))))))))))))))) (push 1) (assert (let ((?def0 true)) ?def0 )) (push 1) (assert (let ((?def174 (and (<= 0 |ts::x0##0|) (<= 0 (* (- 1) |ts::x0##0|)) ))) (let ((?def137 (not (<= (- 10) (* (- 1) |ts::x0##2|))))) (let ((?def175 (and ?def137 ?def174))) ?def175 )))) (check-sat) (pop 1) (check-sat) (exit) opensmt-2.5.2/regression/incremental/issue272b.smt2.expected.err000066400000000000000000000000001445011647600246070ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue272b.smt2.expected.out000066400000000000000000000000121445011647600246310ustar00rootroot00000000000000unsat sat opensmt-2.5.2/regression/incremental/issue74.smt2000066400000000000000000000006171445011647600220140ustar00rootroot00000000000000(set-logic QF_LRA) (push 1) (check-sat) (pop 1) (push 1) (check-sat) (pop 1) (check-sat) (assert false) (check-sat) (check-sat) (push 1) (check-sat) (push 1) (push 1) (check-sat) (check-sat) (pop 1) (assert true) (check-sat) (push 1) (check-sat) (push 1) (check-sat) (assert true) (check-sat) (assert true) (check-sat) (push 1) (check-sat) (push 1) (check-sat) (assert true) (check-sat) (check-sat) opensmt-2.5.2/regression/incremental/issue74.smt2.expected.err000066400000000000000000000000001445011647600243650ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue74.smt2.expected.out000066400000000000000000000001401445011647600244110ustar00rootroot00000000000000sat sat sat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat opensmt-2.5.2/regression/incremental/issue75.smt2000066400000000000000000000004371445011647600220150ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun r2 () Real) (declare-fun v7 () Bool) (declare-fun v19 () Bool) (assert (xor v7 v19)) (assert (< r2 0.0)) (assert (distinct true (not (<= 0.0 r2)))) (push 1) (check-sat) (check-sat) (push 1) (check-sat) (check-sat) (check-sat) (pop 1) (push 1) (check-sat) opensmt-2.5.2/regression/incremental/issue75.smt2.expected.err000066400000000000000000000000001445011647600243660ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue75.smt2.expected.out000066400000000000000000000000441445011647600244150ustar00rootroot00000000000000unsat unsat unsat unsat unsat unsat opensmt-2.5.2/regression/incremental/issue76.smt2000066400000000000000000000007221445011647600220130ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun v1 () Bool) (declare-fun v4 () Bool) (declare-fun v5 () Bool) (assert v4) (check-sat) (assert v1) (check-sat) (declare-fun r12 () Real) (assert (not v5)) (assert v5) (check-sat) (push 1) (check-sat) (pop 1) (assert true) (check-sat) (push 1) (assert (= 0.0 r12)) (check-sat) (pop 1) (assert true) (check-sat) (check-sat) (push 1) (check-sat) (check-sat) (check-sat) (check-sat) (check-sat) (check-sat) (check-sat) (pop 1) (check-sat) opensmt-2.5.2/regression/incremental/issue76.smt2.expected.err000066400000000000000000000000001445011647600243670ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue76.smt2.expected.out000066400000000000000000000001341445011647600244160ustar00rootroot00000000000000sat sat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat opensmt-2.5.2/regression/incremental/issue79.smt2000066400000000000000000000004071445011647600220160ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun _substvar_32_ () Bool) (declare-fun v0 () Bool) (declare-fun v2 () Bool) (assert (or v2 v0)) (assert (distinct (or _substvar_32_ (or v2 v0)) (or v2 v0))) (check-sat) (push 1) (check-sat) (check-sat) (check-sat) (pop 1) (check-sat) opensmt-2.5.2/regression/incremental/issue79.smt2.expected.err000066400000000000000000000000001445011647600243720ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue79.smt2.expected.out000066400000000000000000000000361445011647600244220ustar00rootroot00000000000000unsat unsat unsat unsat unsat opensmt-2.5.2/regression/incremental/issue87.smt2000066400000000000000000000045701445011647600220220ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun v4 () Bool) (declare-fun v7 () Bool) (check-sat) (assert (=> v4 v7)) (check-sat) (assert false) (push 1) (check-sat) (pop 1) (assert true) (check-sat) (push 1) (check-sat) (assert true) (check-sat) (push 1) (check-sat) (pop 1) (check-sat) (push 1) (check-sat) (pop 1) (assert true) (push 1) (check-sat) (pop 1) (push 1) (check-sat) (push 1) (check-sat) (push 1) (check-sat) (pop 1) (pop 1) (check-sat) (push 1) (push 1) (push 1) (check-sat) (check-sat) (check-sat) (check-sat) (check-sat) (push 1) (check-sat) (check-sat) (check-sat) (check-sat) (pop 1) (pop 1) (check-sat) (check-sat) (check-sat) (pop 1) (check-sat) (pop 1) (check-sat) (pop 1) (push 1) (push 1) (push 1) (check-sat) (check-sat) (pop 1) (pop 1) (check-sat) (pop 1) (check-sat) (push 1) (check-sat) (push 1) (push 1) (push 1) (check-sat) (pop 1) (push 1) (push 1) (check-sat) (pop 1) (push 1) (push 1) (check-sat) (push 1) (push 1) (push 1) (push 1) (check-sat) (pop 1) (check-sat) (pop 1) (check-sat) (check-sat) (pop 1) (check-sat) (pop 1) (pop 1) (pop 1) (pop 1) (pop 1) (check-sat) (push 1) (check-sat) (push 1) (push 1) (check-sat) (check-sat) (pop 1) (pop 1) (push 1) (check-sat) (check-sat) (pop 1) (pop 1) (pop 1) (push 1) (check-sat) (check-sat) (push 1) (push 1) (check-sat) (check-sat) (check-sat) (pop 1) (check-sat) (pop 1) (check-sat) (pop 1) (push 1) (push 1) (check-sat) (check-sat) (pop 1) (check-sat) (check-sat) (check-sat) (pop 1) (pop 1) (check-sat) (check-sat) (check-sat) (check-sat) (check-sat) (check-sat) (push 1) (check-sat) (check-sat) (push 1) (push 1) (push 1) (check-sat) (pop 1) (check-sat) (push 1) (check-sat) (pop 1) (check-sat) (pop 1) (check-sat) (push 1) (check-sat) (pop 1) (pop 1) (pop 1) (push 1) (check-sat) (check-sat) (push 1) (check-sat) (pop 1) (check-sat) (check-sat) (pop 1) (pop 1) (assert true) (check-sat) (push 1) (check-sat) (check-sat) (check-sat) (check-sat) (push 1) (check-sat) (push 1) (check-sat) (check-sat) (push 1) (check-sat) (check-sat) (check-sat) (push 1) (check-sat) (push 1) (check-sat) (push 1) (push 1) (check-sat) (check-sat) (check-sat) (check-sat) (push 1) (push 1) (check-sat) (push 1) (check-sat) (push 1) (check-sat) (check-sat) (push 1) (check-sat) (check-sat) (push 1) (push 1) (check-sat) (check-sat) (pop 1) (check-sat) (push 1) (check-sat) (assert true) (check-sat) (push 1) (check-sat) (check-sat) (check-sat) (check-sat) (pop 1) (check-sat) opensmt-2.5.2/regression/incremental/issue87.smt2.expected.err000066400000000000000000000000001445011647600243710ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue87.smt2.expected.out000066400000000000000000000012261445011647600244230ustar00rootroot00000000000000sat sat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat unsat opensmt-2.5.2/regression/incremental/issue89.smt2000066400000000000000000000006121445011647600220150ustar00rootroot00000000000000(set-logic QF_LIA) (declare-fun v16 () Bool) (declare-fun i0 () Int) (declare-fun i9 () Int) (assert v16) (push 1) (assert (not v16)) (check-sat) (assert (= 0 i0)) (check-sat) (push 1) (check-sat) (pop 1) (check-sat) (pop 1) (check-sat) (check-sat) (check-sat) (check-sat) (check-sat) (check-sat) (check-sat) (check-sat) (check-sat) (check-sat) (check-sat) (assert (not (= i9 i0))) (check-sat) opensmt-2.5.2/regression/incremental/issue89.smt2.expected.err000066400000000000000000000000001445011647600243730ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue89.smt2.expected.out000066400000000000000000000001101445011647600244140ustar00rootroot00000000000000unsat unsat unsat unsat sat sat sat sat sat sat sat sat sat sat sat sat opensmt-2.5.2/regression/incremental/issue92.smt2000066400000000000000000000006651445011647600220170ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun v6 () Bool) (declare-fun v7 () Bool) (declare-fun v13 () Bool) (declare-fun v15 () Bool) (assert (=> (=> v15 v6) (= v13 v7))) (check-sat) (check-sat) (push 1) (check-sat) (pop 1) (assert (= v15 (= v13 v7))) (check-sat) (push 1) (check-sat) (pop 1) (assert (distinct true v15)) (push 1) (check-sat) (pop 1) (push 1) (check-sat) (pop 1) (push 1) (check-sat) (pop 1) (push 1) (check-sat) (pop 1) (check-sat) opensmt-2.5.2/regression/incremental/issue92.smt2.expected.err000066400000000000000000000000001445011647600243650ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue92.smt2.expected.out000066400000000000000000000000621445011647600244140ustar00rootroot00000000000000sat sat sat sat sat unsat unsat unsat unsat unsat opensmt-2.5.2/regression/incremental/issue92b.smt2000066400000000000000000000005651445011647600221600ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun r14 () Real) (push 1) (check-sat) (pop 1) (declare-fun v12 () Bool) (assert (or (<= 582095008.0 r14) v12)) (assert (and (=> v12 (<= 582095008.0 r14)) (not (<= 582095008.0 r14)))) (push 1) (check-sat) (push 1) (push 1) (push 1) (push 1) (push 1) (check-sat) (pop 1) (pop 1) (pop 1) (check-sat) (pop 1) (check-sat) (pop 1) (pop 1) (check-sat) opensmt-2.5.2/regression/incremental/issue92b.smt2.expected.err000066400000000000000000000000001445011647600245270ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/issue92b.smt2.expected.out000066400000000000000000000000421445011647600245540ustar00rootroot00000000000000sat unsat unsat unsat unsat unsat opensmt-2.5.2/regression/incremental/lra_push_test.smt2000066400000000000000000000002031445011647600233540ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun r () Real) (declare-fun b () Bool) (check-sat) (assert (or (not b) (= 0.0 r))) (check-sat) (exit) opensmt-2.5.2/regression/incremental/lra_push_test.smt2.expected.err000066400000000000000000000000001445011647600257360ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/lra_push_test.smt2.expected.out000066400000000000000000000000101445011647600257560ustar00rootroot00000000000000sat sat opensmt-2.5.2/regression/incremental/lra_push_test.smt2.expected.time000066400000000000000000000000351445011647600261140ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/incremental/pop_beyond_stack.smt2000066400000000000000000000000501445011647600240230ustar00rootroot00000000000000(set-logic QF_LRA) (check-sat) (pop 1) opensmt-2.5.2/regression/incremental/pop_beyond_stack.smt2.expected.err000066400000000000000000000000001445011647600264050ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/pop_beyond_stack.smt2.expected.out000066400000000000000000000000721445011647600264350ustar00rootroot00000000000000sat (error "Attempt to pop beyond the top of the stack") opensmt-2.5.2/regression/incremental/pop_beyond_stack.smt2.expected.time000066400000000000000000000000351445011647600265630ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/incremental/push_test.smt2000066400000000000000000000006511445011647600225250ustar00rootroot00000000000000(set-logic QF_UF) (declare-fun x () Bool) (declare-fun y () Bool) (declare-fun z () Bool) (assert (or x y z)) (assert (or x y (not z))) (check-sat) (push 1) (assert (or x (not y) z)) (assert (or x (not y) (not z))) (assert (or (not x) y z)) (assert (or (not x) y (not z))) (push 1) (assert (or (not x) (not y) z)) (assert (or (not x) (not y) (not z))) (check-sat) (pop 1) (assert (or (not x) (not y) z)) (check-sat) (exit) opensmt-2.5.2/regression/incremental/push_test.smt2.expected.err000066400000000000000000000000001445011647600251000ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/push_test.smt2.expected.out000066400000000000000000000000161445011647600251260ustar00rootroot00000000000000sat unsat sat opensmt-2.5.2/regression/incremental/push_test.smt2.expected.time000066400000000000000000000000351445011647600252560ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/incremental/push_test2.smt2000066400000000000000000000001011445011647600225750ustar00rootroot00000000000000(set-logic QF_LRA) (check-sat) (assert false) (check-sat) (exit) opensmt-2.5.2/regression/incremental/push_test2.smt2.expected.err000066400000000000000000000000001445011647600251620ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/push_test2.smt2.expected.out000066400000000000000000000000121445011647600252040ustar00rootroot00000000000000sat unsat opensmt-2.5.2/regression/incremental/push_test2.smt2.expected.time000066400000000000000000000000351445011647600253400ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/incremental/push_test3.smt2000066400000000000000000000001241445011647600226030ustar00rootroot00000000000000(set-logic QF_UF) (assert false) (push 1) (assert false) (pop 1) (check-sat) (exit) opensmt-2.5.2/regression/incremental/push_test3.smt2.expected.err000066400000000000000000000000001445011647600251630ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/push_test3.smt2.expected.out000066400000000000000000000000061445011647600252100ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/incremental/push_test3.smt2.expected.time000066400000000000000000000000351445011647600253410ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/incremental/sequence.smt2000066400000000000000000000003001445011647600223060ustar00rootroot00000000000000(set-logic QF_UF) (declare-fun x () Bool) (assert x) (check-sat) (push 1) (assert (not x)) (check-sat) (pop 1) (check-sat) (declare-fun y () Bool) (assert (or (not x) y)) (push 1) (check-sat) opensmt-2.5.2/regression/incremental/sequence.smt2.expected.err000066400000000000000000000000001445011647600246720ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/sequence.smt2.expected.out000066400000000000000000000000221445011647600247150ustar00rootroot00000000000000sat unsat sat sat opensmt-2.5.2/regression/incremental/sequence.smt2.expected.time000066400000000000000000000000351445011647600250500ustar00rootroot00000000000000real 0.00 user 0.00 sys 0.00 opensmt-2.5.2/regression/incremental/substitution_regression.smt2000066400000000000000000000003131445011647600255160ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun b () Real) (define-fun _2 () Real b) (declare-fun a () Real) (set-info :status sat) (check-sat) (assert (and (= a b) (distinct b 0.0))) (set-info :status sat) (check-sat) opensmt-2.5.2/regression/incremental/substitution_regression.smt2.expected.err000066400000000000000000000000001445011647600300760ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/substitution_regression.smt2.expected.out000066400000000000000000000000101445011647600301160ustar00rootroot00000000000000sat sat opensmt-2.5.2/regression/incremental/top_level_distinct.smt2000066400000000000000000000003101445011647600243710ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort U 0) (declare-fun x0 () U) (declare-fun x1 () U) (declare-fun x2 () U) (push 1) (assert (distinct x0 x1 x2)) (check-sat) (pop 1) (assert (= x0 x1)) (check-sat) (exit) opensmt-2.5.2/regression/incremental/top_level_distinct.smt2.expected.err000066400000000000000000000000001445011647600267540ustar00rootroot00000000000000opensmt-2.5.2/regression/incremental/top_level_distinct.smt2.expected.out000066400000000000000000000000101445011647600267740ustar00rootroot00000000000000sat sat opensmt-2.5.2/regression/linkage/000077500000000000000000000000001445011647600170075ustar00rootroot00000000000000opensmt-2.5.2/regression/linkage/test.cc000066400000000000000000000013261445011647600202770ustar00rootroot00000000000000#include #include int main(int argc, char** argv) { SMTConfig c; UFTheory uftheory(c); THandler thandler(c, uftheory); SimpSMTSolver solver(c, thandler); MainSolver mainSolver(thandler, c, &solver); Logic& logic = thandler.getLogic(); PTRef v = logic.mkBoolVar("a"); PTRef v_neg = logic.mkNot(v); vec args; args.push(v); args.push(v_neg); PTRef a = logic.mkAnd(args); mainSolver.push(a); sstat r = mainSolver.check(); if (r == s_True) printf("sat\n"); else if (r == s_False) printf("unsat\n"); else if (r == s_Undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/regression/linkage/test_c.c000066400000000000000000000011471445011647600204370ustar00rootroot00000000000000#include #include #include int main(int argc, char** argv) { osmt_context ctx = osmt_mk_context(qf_uf); osmt_expr* args = (osmt_expr*)malloc(2*sizeof(osmt_expr)); args[0] = osmt_mk_bool_var(ctx, "a"); args[1] = osmt_mk_not(ctx, args[0]); osmt_expr a = osmt_mk_and(ctx, args, 2); osmt_push(ctx, a); osmt_result r = osmt_check(ctx); if (r == l_true) printf("sat\n"); else if (r == l_false) printf("unsat\n"); else if (r == l_undef) printf("unknown\n"); else printf("error\n"); return 0; } opensmt-2.5.2/regression/lookahead/000077500000000000000000000000001445011647600173245ustar00rootroot00000000000000opensmt-2.5.2/regression/lookahead/iso_brn_sk003_eufexps.smt2000066400000000000000000001134501445011647600242510ustar00rootroot00000000000000(set-option :pure-lookahead true) (set-logic QF_UF) (set-info :source | http://www.cs.bham.ac.uk/~vxs/quasigroups/benchmark/ |) (set-info :smt-lib-version 2.0) (set-info :category "crafted") (set-info :status unsat) (declare-sort U 0) (declare-sort I 0) (declare-fun op1 (I I) I) (declare-fun op (I I) I) (declare-fun e6 () I) (declare-fun e5 () I) (declare-fun e4 () I) (declare-fun e3 () I) (declare-fun e2 () I) (declare-fun e1 () I) (declare-fun e0 () I) (declare-fun skc1 (I) I) (assert(! (let ((?v_0 (op e0 e0)) (?v_1 (op e0 e1)) (?v_2 (op e0 e2)) (?v_3 (op e0 e3)) (?v_4 (op e0 e4)) (?v_5 (op e0 e5)) (?v_6 (op e0 e6)) (?v_7 (op e1 e0)) (?v_8 (op e1 e1)) (?v_9 (op e1 e2)) (?v_10 (op e1 e3)) (?v_11 (op e1 e4)) (?v_12 (op e1 e5)) (?v_13 (op e1 e6)) (?v_14 (op e2 e0)) (?v_15 (op e2 e1)) (?v_16 (op e2 e2)) (?v_17 (op e2 e3)) (?v_18 (op e2 e4)) (?v_19 (op e2 e5)) (?v_20 (op e2 e6)) (?v_21 (op e3 e0)) (?v_22 (op e3 e1)) (?v_23 (op e3 e2)) (?v_24 (op e3 e3)) (?v_25 (op e3 e4)) (?v_26 (op e3 e5)) (?v_27 (op e3 e6)) (?v_28 (op e4 e0)) (?v_29 (op e4 e1)) (?v_30 (op e4 e2)) (?v_31 (op e4 e3)) (?v_32 (op e4 e4)) (?v_33 (op e4 e5)) (?v_34 (op e4 e6)) (?v_35 (op e5 e0)) (?v_36 (op e5 e1)) (?v_37 (op e5 e2)) (?v_38 (op e5 e3)) (?v_39 (op e5 e4)) (?v_40 (op e5 e5)) (?v_41 (op e5 e6)) (?v_42 (op e6 e0)) (?v_43 (op e6 e1)) (?v_44 (op e6 e2)) (?v_45 (op e6 e3)) (?v_46 (op e6 e4)) (?v_47 (op e6 e5)) (?v_48 (op e6 e6))) (and (and (and (and (and (and (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_0 e0) (= ?v_0 e1)) (= ?v_0 e2)) (= ?v_0 e3)) (= ?v_0 e4)) (= ?v_0 e5)) (= ?v_0 e6)) (or (or (or (or (or (or (= ?v_1 e0) (= ?v_1 e1)) (= ?v_1 e2)) (= ?v_1 e3)) (= ?v_1 e4)) (= ?v_1 e5)) (= ?v_1 e6))) (or (or (or (or (or (or (= ?v_2 e0) (= ?v_2 e1)) (= ?v_2 e2)) (= ?v_2 e3)) (= ?v_2 e4)) (= ?v_2 e5)) (= ?v_2 e6))) (or (or (or (or (or (or (= ?v_3 e0) (= ?v_3 e1)) (= ?v_3 e2)) (= ?v_3 e3)) (= ?v_3 e4)) (= ?v_3 e5)) (= ?v_3 e6))) (or (or (or (or (or (or (= ?v_4 e0) (= ?v_4 e1)) (= ?v_4 e2)) (= ?v_4 e3)) (= ?v_4 e4)) (= ?v_4 e5)) (= ?v_4 e6))) (or (or (or (or (or (or (= ?v_5 e0) (= ?v_5 e1)) (= ?v_5 e2)) (= ?v_5 e3)) (= ?v_5 e4)) (= ?v_5 e5)) (= ?v_5 e6))) (or (or (or (or (or (or (= ?v_6 e0) (= ?v_6 e1)) (= ?v_6 e2)) (= ?v_6 e3)) (= ?v_6 e4)) (= ?v_6 e5)) (= ?v_6 e6))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_7 e0) (= ?v_7 e1)) (= ?v_7 e2)) (= ?v_7 e3)) (= ?v_7 e4)) (= ?v_7 e5)) (= ?v_7 e6)) (or (or (or (or (or (or (= ?v_8 e0) (= ?v_8 e1)) (= ?v_8 e2)) (= ?v_8 e3)) (= ?v_8 e4)) (= ?v_8 e5)) (= ?v_8 e6))) (or (or (or (or (or (or (= ?v_9 e0) (= ?v_9 e1)) (= ?v_9 e2)) (= ?v_9 e3)) (= ?v_9 e4)) (= ?v_9 e5)) (= ?v_9 e6))) (or (or (or (or (or (or (= ?v_10 e0) (= ?v_10 e1)) (= ?v_10 e2)) (= ?v_10 e3)) (= ?v_10 e4)) (= ?v_10 e5)) (= ?v_10 e6))) (or (or (or (or (or (or (= ?v_11 e0) (= ?v_11 e1)) (= ?v_11 e2)) (= ?v_11 e3)) (= ?v_11 e4)) (= ?v_11 e5)) (= ?v_11 e6))) (or (or (or (or (or (or (= ?v_12 e0) (= ?v_12 e1)) (= ?v_12 e2)) (= ?v_12 e3)) (= ?v_12 e4)) (= ?v_12 e5)) (= ?v_12 e6))) (or (or (or (or (or (or (= ?v_13 e0) (= ?v_13 e1)) (= ?v_13 e2)) (= ?v_13 e3)) (= ?v_13 e4)) (= ?v_13 e5)) (= ?v_13 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_14 e0) (= ?v_14 e1)) (= ?v_14 e2)) (= ?v_14 e3)) (= ?v_14 e4)) (= ?v_14 e5)) (= ?v_14 e6)) (or (or (or (or (or (or (= ?v_15 e0) (= ?v_15 e1)) (= ?v_15 e2)) (= ?v_15 e3)) (= ?v_15 e4)) (= ?v_15 e5)) (= ?v_15 e6))) (or (or (or (or (or (or (= ?v_16 e0) (= ?v_16 e1)) (= ?v_16 e2)) (= ?v_16 e3)) (= ?v_16 e4)) (= ?v_16 e5)) (= ?v_16 e6))) (or (or (or (or (or (or (= ?v_17 e0) (= ?v_17 e1)) (= ?v_17 e2)) (= ?v_17 e3)) (= ?v_17 e4)) (= ?v_17 e5)) (= ?v_17 e6))) (or (or (or (or (or (or (= ?v_18 e0) (= ?v_18 e1)) (= ?v_18 e2)) (= ?v_18 e3)) (= ?v_18 e4)) (= ?v_18 e5)) (= ?v_18 e6))) (or (or (or (or (or (or (= ?v_19 e0) (= ?v_19 e1)) (= ?v_19 e2)) (= ?v_19 e3)) (= ?v_19 e4)) (= ?v_19 e5)) (= ?v_19 e6))) (or (or (or (or (or (or (= ?v_20 e0) (= ?v_20 e1)) (= ?v_20 e2)) (= ?v_20 e3)) (= ?v_20 e4)) (= ?v_20 e5)) (= ?v_20 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_21 e0) (= ?v_21 e1)) (= ?v_21 e2)) (= ?v_21 e3)) (= ?v_21 e4)) (= ?v_21 e5)) (= ?v_21 e6)) (or (or (or (or (or (or (= ?v_22 e0) (= ?v_22 e1)) (= ?v_22 e2)) (= ?v_22 e3)) (= ?v_22 e4)) (= ?v_22 e5)) (= ?v_22 e6))) (or (or (or (or (or (or (= ?v_23 e0) (= ?v_23 e1)) (= ?v_23 e2)) (= ?v_23 e3)) (= ?v_23 e4)) (= ?v_23 e5)) (= ?v_23 e6))) (or (or (or (or (or (or (= ?v_24 e0) (= ?v_24 e1)) (= ?v_24 e2)) (= ?v_24 e3)) (= ?v_24 e4)) (= ?v_24 e5)) (= ?v_24 e6))) (or (or (or (or (or (or (= ?v_25 e0) (= ?v_25 e1)) (= ?v_25 e2)) (= ?v_25 e3)) (= ?v_25 e4)) (= ?v_25 e5)) (= ?v_25 e6))) (or (or (or (or (or (or (= ?v_26 e0) (= ?v_26 e1)) (= ?v_26 e2)) (= ?v_26 e3)) (= ?v_26 e4)) (= ?v_26 e5)) (= ?v_26 e6))) (or (or (or (or (or (or (= ?v_27 e0) (= ?v_27 e1)) (= ?v_27 e2)) (= ?v_27 e3)) (= ?v_27 e4)) (= ?v_27 e5)) (= ?v_27 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_28 e0) (= ?v_28 e1)) (= ?v_28 e2)) (= ?v_28 e3)) (= ?v_28 e4)) (= ?v_28 e5)) (= ?v_28 e6)) (or (or (or (or (or (or (= ?v_29 e0) (= ?v_29 e1)) (= ?v_29 e2)) (= ?v_29 e3)) (= ?v_29 e4)) (= ?v_29 e5)) (= ?v_29 e6))) (or (or (or (or (or (or (= ?v_30 e0) (= ?v_30 e1)) (= ?v_30 e2)) (= ?v_30 e3)) (= ?v_30 e4)) (= ?v_30 e5)) (= ?v_30 e6))) (or (or (or (or (or (or (= ?v_31 e0) (= ?v_31 e1)) (= ?v_31 e2)) (= ?v_31 e3)) (= ?v_31 e4)) (= ?v_31 e5)) (= ?v_31 e6))) (or (or (or (or (or (or (= ?v_32 e0) (= ?v_32 e1)) (= ?v_32 e2)) (= ?v_32 e3)) (= ?v_32 e4)) (= ?v_32 e5)) (= ?v_32 e6))) (or (or (or (or (or (or (= ?v_33 e0) (= ?v_33 e1)) (= ?v_33 e2)) (= ?v_33 e3)) (= ?v_33 e4)) (= ?v_33 e5)) (= ?v_33 e6))) (or (or (or (or (or (or (= ?v_34 e0) (= ?v_34 e1)) (= ?v_34 e2)) (= ?v_34 e3)) (= ?v_34 e4)) (= ?v_34 e5)) (= ?v_34 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_35 e0) (= ?v_35 e1)) (= ?v_35 e2)) (= ?v_35 e3)) (= ?v_35 e4)) (= ?v_35 e5)) (= ?v_35 e6)) (or (or (or (or (or (or (= ?v_36 e0) (= ?v_36 e1)) (= ?v_36 e2)) (= ?v_36 e3)) (= ?v_36 e4)) (= ?v_36 e5)) (= ?v_36 e6))) (or (or (or (or (or (or (= ?v_37 e0) (= ?v_37 e1)) (= ?v_37 e2)) (= ?v_37 e3)) (= ?v_37 e4)) (= ?v_37 e5)) (= ?v_37 e6))) (or (or (or (or (or (or (= ?v_38 e0) (= ?v_38 e1)) (= ?v_38 e2)) (= ?v_38 e3)) (= ?v_38 e4)) (= ?v_38 e5)) (= ?v_38 e6))) (or (or (or (or (or (or (= ?v_39 e0) (= ?v_39 e1)) (= ?v_39 e2)) (= ?v_39 e3)) (= ?v_39 e4)) (= ?v_39 e5)) (= ?v_39 e6))) (or (or (or (or (or (or (= ?v_40 e0) (= ?v_40 e1)) (= ?v_40 e2)) (= ?v_40 e3)) (= ?v_40 e4)) (= ?v_40 e5)) (= ?v_40 e6))) (or (or (or (or (or (or (= ?v_41 e0) (= ?v_41 e1)) (= ?v_41 e2)) (= ?v_41 e3)) (= ?v_41 e4)) (= ?v_41 e5)) (= ?v_41 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_42 e0) (= ?v_42 e1)) (= ?v_42 e2)) (= ?v_42 e3)) (= ?v_42 e4)) (= ?v_42 e5)) (= ?v_42 e6)) (or (or (or (or (or (or (= ?v_43 e0) (= ?v_43 e1)) (= ?v_43 e2)) (= ?v_43 e3)) (= ?v_43 e4)) (= ?v_43 e5)) (= ?v_43 e6))) (or (or (or (or (or (or (= ?v_44 e0) (= ?v_44 e1)) (= ?v_44 e2)) (= ?v_44 e3)) (= ?v_44 e4)) (= ?v_44 e5)) (= ?v_44 e6))) (or (or (or (or (or (or (= ?v_45 e0) (= ?v_45 e1)) (= ?v_45 e2)) (= ?v_45 e3)) (= ?v_45 e4)) (= ?v_45 e5)) (= ?v_45 e6))) (or (or (or (or (or (or (= ?v_46 e0) (= ?v_46 e1)) (= ?v_46 e2)) (= ?v_46 e3)) (= ?v_46 e4)) (= ?v_46 e5)) (= ?v_46 e6))) (or (or (or (or (or (or (= ?v_47 e0) (= ?v_47 e1)) (= ?v_47 e2)) (= ?v_47 e3)) (= ?v_47 e4)) (= ?v_47 e5)) (= ?v_47 e6))) (or (or (or (or (or (or (= ?v_48 e0) (= ?v_48 e1)) (= ?v_48 e2)) (= ?v_48 e3)) (= ?v_48 e4)) (= ?v_48 e5)) (= ?v_48 e6))))) :named WoCGwwVnZQddqqKNwFA)) (assert(! (let ((?v_1 (op e0 e0)) (?v_2 (op e0 e1)) (?v_3 (op e0 e2)) (?v_4 (op e0 e3)) (?v_5 (op e0 e4)) (?v_6 (op e0 e5)) (?v_7 (op e0 e6)) (?v_9 (op e1 e0)) (?v_24 (op e1 e1)) (?v_25 (op e1 e2)) (?v_26 (op e1 e3)) (?v_27 (op e1 e4)) (?v_28 (op e1 e5)) (?v_29 (op e1 e6)) (?v_10 (op e2 e0)) (?v_32 (op e2 e1)) (?v_59 (op e2 e2)) (?v_60 (op e2 e3)) (?v_61 (op e2 e4)) (?v_62 (op e2 e5)) (?v_63 (op e2 e6)) (?v_11 (op e3 e0)) (?v_33 (op e3 e1)) (?v_67 (op e3 e2)) (?v_106 (op e3 e3)) (?v_107 (op e3 e4)) (?v_108 (op e3 e5)) (?v_109 (op e3 e6)) (?v_12 (op e4 e0)) (?v_34 (op e4 e1)) (?v_68 (op e4 e2)) (?v_114 (op e4 e3)) (?v_165 (op e4 e4)) (?v_166 (op e4 e5)) (?v_167 (op e4 e6)) (?v_13 (op e5 e0)) (?v_35 (op e5 e1)) (?v_69 (op e5 e2)) (?v_115 (op e5 e3)) (?v_173 (op e5 e4)) (?v_236 (op e5 e5)) (?v_237 (op e5 e6)) (?v_14 (op e6 e0)) (?v_36 (op e6 e1)) (?v_70 (op e6 e2)) (?v_116 (op e6 e3)) (?v_174 (op e6 e4)) (?v_244 (op e6 e5)) (?v_319 (op e6 e6))) (let ((?v_0 (= ?v_1 e0)) (?v_8 (= ?v_1 e1)) (?v_15 (= ?v_1 e2)) (?v_16 (= ?v_1 e3)) (?v_17 (= ?v_1 e4)) (?v_18 (= ?v_1 e5)) (?v_19 (= ?v_1 e6)) (?v_21 (= ?v_2 e0)) (?v_30 (= ?v_2 e1)) (?v_38 (= ?v_2 e2)) (?v_41 (= ?v_2 e3)) (?v_44 (= ?v_2 e4)) (?v_47 (= ?v_2 e5)) (?v_50 (= ?v_2 e6)) (?v_54 (= ?v_3 e0)) (?v_64 (= ?v_3 e1)) (?v_73 (= ?v_3 e2)) (?v_78 (= ?v_3 e3)) (?v_83 (= ?v_3 e4)) (?v_88 (= ?v_3 e5)) (?v_93 (= ?v_3 e6)) (?v_99 (= ?v_4 e0)) (?v_110 (= ?v_4 e1)) (?v_120 (= ?v_4 e2)) (?v_127 (= ?v_4 e3)) (?v_134 (= ?v_4 e4)) (?v_141 (= ?v_4 e5)) (?v_148 (= ?v_4 e6)) (?v_156 (= ?v_5 e0)) (?v_168 (= ?v_5 e1)) (?v_179 (= ?v_5 e2)) (?v_188 (= ?v_5 e3)) (?v_197 (= ?v_5 e4)) (?v_206 (= ?v_5 e5)) (?v_215 (= ?v_5 e6)) (?v_225 (= ?v_6 e0)) (?v_238 (= ?v_6 e1)) (?v_250 (= ?v_6 e2)) (?v_261 (= ?v_6 e3)) (?v_272 (= ?v_6 e4)) (?v_283 (= ?v_6 e5)) (?v_294 (= ?v_6 e6)) (?v_306 (= ?v_7 e0)) (?v_320 (= ?v_7 e1)) (?v_333 (= ?v_7 e2)) (?v_346 (= ?v_7 e3)) (?v_359 (= ?v_7 e4)) (?v_372 (= ?v_7 e5)) (?v_385 (= ?v_7 e6)) (?v_20 (= ?v_9 e0)) (?v_23 (= ?v_9 e1)) (?v_37 (= ?v_9 e2)) (?v_40 (= ?v_9 e3)) (?v_43 (= ?v_9 e4)) (?v_46 (= ?v_9 e5)) (?v_49 (= ?v_9 e6)) (?v_22 (= ?v_24 e0)) (?v_31 (= ?v_24 e1)) (?v_39 (= ?v_24 e2)) (?v_42 (= ?v_24 e3)) (?v_45 (= ?v_24 e4)) (?v_48 (= ?v_24 e5)) (?v_51 (= ?v_24 e6)) (?v_55 (= ?v_25 e0)) (?v_65 (= ?v_25 e1)) (?v_74 (= ?v_25 e2)) (?v_79 (= ?v_25 e3)) (?v_84 (= ?v_25 e4)) (?v_89 (= ?v_25 e5)) (?v_94 (= ?v_25 e6)) (?v_100 (= ?v_26 e0)) (?v_111 (= ?v_26 e1)) (?v_121 (= ?v_26 e2)) (?v_128 (= ?v_26 e3)) (?v_135 (= ?v_26 e4)) (?v_142 (= ?v_26 e5)) (?v_149 (= ?v_26 e6)) (?v_157 (= ?v_27 e0)) (?v_169 (= ?v_27 e1)) (?v_180 (= ?v_27 e2)) (?v_189 (= ?v_27 e3)) (?v_198 (= ?v_27 e4)) (?v_207 (= ?v_27 e5)) (?v_216 (= ?v_27 e6)) (?v_226 (= ?v_28 e0)) (?v_239 (= ?v_28 e1)) (?v_251 (= ?v_28 e2)) (?v_262 (= ?v_28 e3)) (?v_273 (= ?v_28 e4)) (?v_284 (= ?v_28 e5)) (?v_295 (= ?v_28 e6)) (?v_307 (= ?v_29 e0)) (?v_321 (= ?v_29 e1)) (?v_334 (= ?v_29 e2)) (?v_347 (= ?v_29 e3)) (?v_360 (= ?v_29 e4)) (?v_373 (= ?v_29 e5)) (?v_386 (= ?v_29 e6)) (?v_52 (= ?v_10 e0)) (?v_57 (= ?v_10 e1)) (?v_71 (= ?v_10 e2)) (?v_76 (= ?v_10 e3)) (?v_81 (= ?v_10 e4)) (?v_86 (= ?v_10 e5)) (?v_91 (= ?v_10 e6)) (?v_53 (= ?v_32 e0)) (?v_58 (= ?v_32 e1)) (?v_72 (= ?v_32 e2)) (?v_77 (= ?v_32 e3)) (?v_82 (= ?v_32 e4)) (?v_87 (= ?v_32 e5)) (?v_92 (= ?v_32 e6)) (?v_56 (= ?v_59 e0)) (?v_66 (= ?v_59 e1)) (?v_75 (= ?v_59 e2)) (?v_80 (= ?v_59 e3)) (?v_85 (= ?v_59 e4)) (?v_90 (= ?v_59 e5)) (?v_95 (= ?v_59 e6)) (?v_101 (= ?v_60 e0)) (?v_112 (= ?v_60 e1)) (?v_122 (= ?v_60 e2)) (?v_129 (= ?v_60 e3)) (?v_136 (= ?v_60 e4)) (?v_143 (= ?v_60 e5)) (?v_150 (= ?v_60 e6)) (?v_158 (= ?v_61 e0)) (?v_170 (= ?v_61 e1)) (?v_181 (= ?v_61 e2)) (?v_190 (= ?v_61 e3)) (?v_199 (= ?v_61 e4)) (?v_208 (= ?v_61 e5)) (?v_217 (= ?v_61 e6)) (?v_227 (= ?v_62 e0)) (?v_240 (= ?v_62 e1)) (?v_252 (= ?v_62 e2)) (?v_263 (= ?v_62 e3)) (?v_274 (= ?v_62 e4)) (?v_285 (= ?v_62 e5)) (?v_296 (= ?v_62 e6)) (?v_308 (= ?v_63 e0)) (?v_322 (= ?v_63 e1)) (?v_335 (= ?v_63 e2)) (?v_348 (= ?v_63 e3)) (?v_361 (= ?v_63 e4)) (?v_374 (= ?v_63 e5)) (?v_387 (= ?v_63 e6)) (?v_96 (= ?v_11 e0)) (?v_103 (= ?v_11 e1)) (?v_117 (= ?v_11 e2)) (?v_124 (= ?v_11 e3)) (?v_131 (= ?v_11 e4)) (?v_138 (= ?v_11 e5)) (?v_145 (= ?v_11 e6)) (?v_97 (= ?v_33 e0)) (?v_104 (= ?v_33 e1)) (?v_118 (= ?v_33 e2)) (?v_125 (= ?v_33 e3)) (?v_132 (= ?v_33 e4)) (?v_139 (= ?v_33 e5)) (?v_146 (= ?v_33 e6)) (?v_98 (= ?v_67 e0)) (?v_105 (= ?v_67 e1)) (?v_119 (= ?v_67 e2)) (?v_126 (= ?v_67 e3)) (?v_133 (= ?v_67 e4)) (?v_140 (= ?v_67 e5)) (?v_147 (= ?v_67 e6)) (?v_102 (= ?v_106 e0)) (?v_113 (= ?v_106 e1)) (?v_123 (= ?v_106 e2)) (?v_130 (= ?v_106 e3)) (?v_137 (= ?v_106 e4)) (?v_144 (= ?v_106 e5)) (?v_151 (= ?v_106 e6)) (?v_159 (= ?v_107 e0)) (?v_171 (= ?v_107 e1)) (?v_182 (= ?v_107 e2)) (?v_191 (= ?v_107 e3)) (?v_200 (= ?v_107 e4)) (?v_209 (= ?v_107 e5)) (?v_218 (= ?v_107 e6)) (?v_228 (= ?v_108 e0)) (?v_241 (= ?v_108 e1)) (?v_253 (= ?v_108 e2)) (?v_264 (= ?v_108 e3)) (?v_275 (= ?v_108 e4)) (?v_286 (= ?v_108 e5)) (?v_297 (= ?v_108 e6)) (?v_309 (= ?v_109 e0)) (?v_323 (= ?v_109 e1)) (?v_336 (= ?v_109 e2)) (?v_349 (= ?v_109 e3)) (?v_362 (= ?v_109 e4)) (?v_375 (= ?v_109 e5)) (?v_388 (= ?v_109 e6)) (?v_152 (= ?v_12 e0)) (?v_161 (= ?v_12 e1)) (?v_175 (= ?v_12 e2)) (?v_184 (= ?v_12 e3)) (?v_193 (= ?v_12 e4)) (?v_202 (= ?v_12 e5)) (?v_211 (= ?v_12 e6)) (?v_153 (= ?v_34 e0)) (?v_162 (= ?v_34 e1)) (?v_176 (= ?v_34 e2)) (?v_185 (= ?v_34 e3)) (?v_194 (= ?v_34 e4)) (?v_203 (= ?v_34 e5)) (?v_212 (= ?v_34 e6)) (?v_154 (= ?v_68 e0)) (?v_163 (= ?v_68 e1)) (?v_177 (= ?v_68 e2)) (?v_186 (= ?v_68 e3)) (?v_195 (= ?v_68 e4)) (?v_204 (= ?v_68 e5)) (?v_213 (= ?v_68 e6)) (?v_155 (= ?v_114 e0)) (?v_164 (= ?v_114 e1)) (?v_178 (= ?v_114 e2)) (?v_187 (= ?v_114 e3)) (?v_196 (= ?v_114 e4)) (?v_205 (= ?v_114 e5)) (?v_214 (= ?v_114 e6)) (?v_160 (= ?v_165 e0)) (?v_172 (= ?v_165 e1)) (?v_183 (= ?v_165 e2)) (?v_192 (= ?v_165 e3)) (?v_201 (= ?v_165 e4)) (?v_210 (= ?v_165 e5)) (?v_219 (= ?v_165 e6)) (?v_229 (= ?v_166 e0)) (?v_242 (= ?v_166 e1)) (?v_254 (= ?v_166 e2)) (?v_265 (= ?v_166 e3)) (?v_276 (= ?v_166 e4)) (?v_287 (= ?v_166 e5)) (?v_298 (= ?v_166 e6)) (?v_310 (= ?v_167 e0)) (?v_324 (= ?v_167 e1)) (?v_337 (= ?v_167 e2)) (?v_350 (= ?v_167 e3)) (?v_363 (= ?v_167 e4)) (?v_376 (= ?v_167 e5)) (?v_389 (= ?v_167 e6)) (?v_220 (= ?v_13 e0)) (?v_231 (= ?v_13 e1)) (?v_245 (= ?v_13 e2)) (?v_256 (= ?v_13 e3)) (?v_267 (= ?v_13 e4)) (?v_278 (= ?v_13 e5)) (?v_289 (= ?v_13 e6)) (?v_221 (= ?v_35 e0)) (?v_232 (= ?v_35 e1)) (?v_246 (= ?v_35 e2)) (?v_257 (= ?v_35 e3)) (?v_268 (= ?v_35 e4)) (?v_279 (= ?v_35 e5)) (?v_290 (= ?v_35 e6)) (?v_222 (= ?v_69 e0)) (?v_233 (= ?v_69 e1)) (?v_247 (= ?v_69 e2)) (?v_258 (= ?v_69 e3)) (?v_269 (= ?v_69 e4)) (?v_280 (= ?v_69 e5)) (?v_291 (= ?v_69 e6)) (?v_223 (= ?v_115 e0)) (?v_234 (= ?v_115 e1)) (?v_248 (= ?v_115 e2)) (?v_259 (= ?v_115 e3)) (?v_270 (= ?v_115 e4)) (?v_281 (= ?v_115 e5)) (?v_292 (= ?v_115 e6)) (?v_224 (= ?v_173 e0)) (?v_235 (= ?v_173 e1)) (?v_249 (= ?v_173 e2)) (?v_260 (= ?v_173 e3)) (?v_271 (= ?v_173 e4)) (?v_282 (= ?v_173 e5)) (?v_293 (= ?v_173 e6)) (?v_230 (= ?v_236 e0)) (?v_243 (= ?v_236 e1)) (?v_255 (= ?v_236 e2)) (?v_266 (= ?v_236 e3)) (?v_277 (= ?v_236 e4)) (?v_288 (= ?v_236 e5)) (?v_299 (= ?v_236 e6)) (?v_311 (= ?v_237 e0)) (?v_325 (= ?v_237 e1)) (?v_338 (= ?v_237 e2)) (?v_351 (= ?v_237 e3)) (?v_364 (= ?v_237 e4)) (?v_377 (= ?v_237 e5)) (?v_390 (= ?v_237 e6)) (?v_300 (= ?v_14 e0)) (?v_313 (= ?v_14 e1)) (?v_327 (= ?v_14 e2)) (?v_340 (= ?v_14 e3)) (?v_353 (= ?v_14 e4)) (?v_366 (= ?v_14 e5)) (?v_379 (= ?v_14 e6)) (?v_301 (= ?v_36 e0)) (?v_314 (= ?v_36 e1)) (?v_328 (= ?v_36 e2)) (?v_341 (= ?v_36 e3)) (?v_354 (= ?v_36 e4)) (?v_367 (= ?v_36 e5)) (?v_380 (= ?v_36 e6)) (?v_302 (= ?v_70 e0)) (?v_315 (= ?v_70 e1)) (?v_329 (= ?v_70 e2)) (?v_342 (= ?v_70 e3)) (?v_355 (= ?v_70 e4)) (?v_368 (= ?v_70 e5)) (?v_381 (= ?v_70 e6)) (?v_303 (= ?v_116 e0)) (?v_316 (= ?v_116 e1)) (?v_330 (= ?v_116 e2)) (?v_343 (= ?v_116 e3)) (?v_356 (= ?v_116 e4)) (?v_369 (= ?v_116 e5)) (?v_382 (= ?v_116 e6)) (?v_304 (= ?v_174 e0)) (?v_317 (= ?v_174 e1)) (?v_331 (= ?v_174 e2)) (?v_344 (= ?v_174 e3)) (?v_357 (= ?v_174 e4)) (?v_370 (= ?v_174 e5)) (?v_383 (= ?v_174 e6)) (?v_305 (= ?v_244 e0)) (?v_318 (= ?v_244 e1)) (?v_332 (= ?v_244 e2)) (?v_345 (= ?v_244 e3)) (?v_358 (= ?v_244 e4)) (?v_371 (= ?v_244 e5)) (?v_384 (= ?v_244 e6)) (?v_312 (= ?v_319 e0)) (?v_326 (= ?v_319 e1)) (?v_339 (= ?v_319 e2)) (?v_352 (= ?v_319 e3)) (?v_365 (= ?v_319 e4)) (?v_378 (= ?v_319 e5)) (?v_391 (= ?v_319 e6))) (and (and (and (and (and (and (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_0 ?v_21) ?v_54) ?v_99) ?v_156) ?v_225) ?v_306) (or (or (or (or (or (or ?v_0 ?v_20) ?v_52) ?v_96) ?v_152) ?v_220) ?v_300)) (and (or (or (or (or (or (or ?v_8 ?v_30) ?v_64) ?v_110) ?v_168) ?v_238) ?v_320) (or (or (or (or (or (or ?v_8 ?v_23) ?v_57) ?v_103) ?v_161) ?v_231) ?v_313))) (and (or (or (or (or (or (or ?v_15 ?v_38) ?v_73) ?v_120) ?v_179) ?v_250) ?v_333) (or (or (or (or (or (or ?v_15 ?v_37) ?v_71) ?v_117) ?v_175) ?v_245) ?v_327))) (and (or (or (or (or (or (or ?v_16 ?v_41) ?v_78) ?v_127) ?v_188) ?v_261) ?v_346) (or (or (or (or (or (or ?v_16 ?v_40) ?v_76) ?v_124) ?v_184) ?v_256) ?v_340))) (and (or (or (or (or (or (or ?v_17 ?v_44) ?v_83) ?v_134) ?v_197) ?v_272) ?v_359) (or (or (or (or (or (or ?v_17 ?v_43) ?v_81) ?v_131) ?v_193) ?v_267) ?v_353))) (and (or (or (or (or (or (or ?v_18 ?v_47) ?v_88) ?v_141) ?v_206) ?v_283) ?v_372) (or (or (or (or (or (or ?v_18 ?v_46) ?v_86) ?v_138) ?v_202) ?v_278) ?v_366))) (and (or (or (or (or (or (or ?v_19 ?v_50) ?v_93) ?v_148) ?v_215) ?v_294) ?v_385) (or (or (or (or (or (or ?v_19 ?v_49) ?v_91) ?v_145) ?v_211) ?v_289) ?v_379))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_20 ?v_22) ?v_55) ?v_100) ?v_157) ?v_226) ?v_307) (or (or (or (or (or (or ?v_21 ?v_22) ?v_53) ?v_97) ?v_153) ?v_221) ?v_301)) (and (or (or (or (or (or (or ?v_23 ?v_31) ?v_65) ?v_111) ?v_169) ?v_239) ?v_321) (or (or (or (or (or (or ?v_30 ?v_31) ?v_58) ?v_104) ?v_162) ?v_232) ?v_314))) (and (or (or (or (or (or (or ?v_37 ?v_39) ?v_74) ?v_121) ?v_180) ?v_251) ?v_334) (or (or (or (or (or (or ?v_38 ?v_39) ?v_72) ?v_118) ?v_176) ?v_246) ?v_328))) (and (or (or (or (or (or (or ?v_40 ?v_42) ?v_79) ?v_128) ?v_189) ?v_262) ?v_347) (or (or (or (or (or (or ?v_41 ?v_42) ?v_77) ?v_125) ?v_185) ?v_257) ?v_341))) (and (or (or (or (or (or (or ?v_43 ?v_45) ?v_84) ?v_135) ?v_198) ?v_273) ?v_360) (or (or (or (or (or (or ?v_44 ?v_45) ?v_82) ?v_132) ?v_194) ?v_268) ?v_354))) (and (or (or (or (or (or (or ?v_46 ?v_48) ?v_89) ?v_142) ?v_207) ?v_284) ?v_373) (or (or (or (or (or (or ?v_47 ?v_48) ?v_87) ?v_139) ?v_203) ?v_279) ?v_367))) (and (or (or (or (or (or (or ?v_49 ?v_51) ?v_94) ?v_149) ?v_216) ?v_295) ?v_386) (or (or (or (or (or (or ?v_50 ?v_51) ?v_92) ?v_146) ?v_212) ?v_290) ?v_380)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_52 ?v_53) ?v_56) ?v_101) ?v_158) ?v_227) ?v_308) (or (or (or (or (or (or ?v_54 ?v_55) ?v_56) ?v_98) ?v_154) ?v_222) ?v_302)) (and (or (or (or (or (or (or ?v_57 ?v_58) ?v_66) ?v_112) ?v_170) ?v_240) ?v_322) (or (or (or (or (or (or ?v_64 ?v_65) ?v_66) ?v_105) ?v_163) ?v_233) ?v_315))) (and (or (or (or (or (or (or ?v_71 ?v_72) ?v_75) ?v_122) ?v_181) ?v_252) ?v_335) (or (or (or (or (or (or ?v_73 ?v_74) ?v_75) ?v_119) ?v_177) ?v_247) ?v_329))) (and (or (or (or (or (or (or ?v_76 ?v_77) ?v_80) ?v_129) ?v_190) ?v_263) ?v_348) (or (or (or (or (or (or ?v_78 ?v_79) ?v_80) ?v_126) ?v_186) ?v_258) ?v_342))) (and (or (or (or (or (or (or ?v_81 ?v_82) ?v_85) ?v_136) ?v_199) ?v_274) ?v_361) (or (or (or (or (or (or ?v_83 ?v_84) ?v_85) ?v_133) ?v_195) ?v_269) ?v_355))) (and (or (or (or (or (or (or ?v_86 ?v_87) ?v_90) ?v_143) ?v_208) ?v_285) ?v_374) (or (or (or (or (or (or ?v_88 ?v_89) ?v_90) ?v_140) ?v_204) ?v_280) ?v_368))) (and (or (or (or (or (or (or ?v_91 ?v_92) ?v_95) ?v_150) ?v_217) ?v_296) ?v_387) (or (or (or (or (or (or ?v_93 ?v_94) ?v_95) ?v_147) ?v_213) ?v_291) ?v_381)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_96 ?v_97) ?v_98) ?v_102) ?v_159) ?v_228) ?v_309) (or (or (or (or (or (or ?v_99 ?v_100) ?v_101) ?v_102) ?v_155) ?v_223) ?v_303)) (and (or (or (or (or (or (or ?v_103 ?v_104) ?v_105) ?v_113) ?v_171) ?v_241) ?v_323) (or (or (or (or (or (or ?v_110 ?v_111) ?v_112) ?v_113) ?v_164) ?v_234) ?v_316))) (and (or (or (or (or (or (or ?v_117 ?v_118) ?v_119) ?v_123) ?v_182) ?v_253) ?v_336) (or (or (or (or (or (or ?v_120 ?v_121) ?v_122) ?v_123) ?v_178) ?v_248) ?v_330))) (and (or (or (or (or (or (or ?v_124 ?v_125) ?v_126) ?v_130) ?v_191) ?v_264) ?v_349) (or (or (or (or (or (or ?v_127 ?v_128) ?v_129) ?v_130) ?v_187) ?v_259) ?v_343))) (and (or (or (or (or (or (or ?v_131 ?v_132) ?v_133) ?v_137) ?v_200) ?v_275) ?v_362) (or (or (or (or (or (or ?v_134 ?v_135) ?v_136) ?v_137) ?v_196) ?v_270) ?v_356))) (and (or (or (or (or (or (or ?v_138 ?v_139) ?v_140) ?v_144) ?v_209) ?v_286) ?v_375) (or (or (or (or (or (or ?v_141 ?v_142) ?v_143) ?v_144) ?v_205) ?v_281) ?v_369))) (and (or (or (or (or (or (or ?v_145 ?v_146) ?v_147) ?v_151) ?v_218) ?v_297) ?v_388) (or (or (or (or (or (or ?v_148 ?v_149) ?v_150) ?v_151) ?v_214) ?v_292) ?v_382)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_152 ?v_153) ?v_154) ?v_155) ?v_160) ?v_229) ?v_310) (or (or (or (or (or (or ?v_156 ?v_157) ?v_158) ?v_159) ?v_160) ?v_224) ?v_304)) (and (or (or (or (or (or (or ?v_161 ?v_162) ?v_163) ?v_164) ?v_172) ?v_242) ?v_324) (or (or (or (or (or (or ?v_168 ?v_169) ?v_170) ?v_171) ?v_172) ?v_235) ?v_317))) (and (or (or (or (or (or (or ?v_175 ?v_176) ?v_177) ?v_178) ?v_183) ?v_254) ?v_337) (or (or (or (or (or (or ?v_179 ?v_180) ?v_181) ?v_182) ?v_183) ?v_249) ?v_331))) (and (or (or (or (or (or (or ?v_184 ?v_185) ?v_186) ?v_187) ?v_192) ?v_265) ?v_350) (or (or (or (or (or (or ?v_188 ?v_189) ?v_190) ?v_191) ?v_192) ?v_260) ?v_344))) (and (or (or (or (or (or (or ?v_193 ?v_194) ?v_195) ?v_196) ?v_201) ?v_276) ?v_363) (or (or (or (or (or (or ?v_197 ?v_198) ?v_199) ?v_200) ?v_201) ?v_271) ?v_357))) (and (or (or (or (or (or (or ?v_202 ?v_203) ?v_204) ?v_205) ?v_210) ?v_287) ?v_376) (or (or (or (or (or (or ?v_206 ?v_207) ?v_208) ?v_209) ?v_210) ?v_282) ?v_370))) (and (or (or (or (or (or (or ?v_211 ?v_212) ?v_213) ?v_214) ?v_219) ?v_298) ?v_389) (or (or (or (or (or (or ?v_215 ?v_216) ?v_217) ?v_218) ?v_219) ?v_293) ?v_383)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_220 ?v_221) ?v_222) ?v_223) ?v_224) ?v_230) ?v_311) (or (or (or (or (or (or ?v_225 ?v_226) ?v_227) ?v_228) ?v_229) ?v_230) ?v_305)) (and (or (or (or (or (or (or ?v_231 ?v_232) ?v_233) ?v_234) ?v_235) ?v_243) ?v_325) (or (or (or (or (or (or ?v_238 ?v_239) ?v_240) ?v_241) ?v_242) ?v_243) ?v_318))) (and (or (or (or (or (or (or ?v_245 ?v_246) ?v_247) ?v_248) ?v_249) ?v_255) ?v_338) (or (or (or (or (or (or ?v_250 ?v_251) ?v_252) ?v_253) ?v_254) ?v_255) ?v_332))) (and (or (or (or (or (or (or ?v_256 ?v_257) ?v_258) ?v_259) ?v_260) ?v_266) ?v_351) (or (or (or (or (or (or ?v_261 ?v_262) ?v_263) ?v_264) ?v_265) ?v_266) ?v_345))) (and (or (or (or (or (or (or ?v_267 ?v_268) ?v_269) ?v_270) ?v_271) ?v_277) ?v_364) (or (or (or (or (or (or ?v_272 ?v_273) ?v_274) ?v_275) ?v_276) ?v_277) ?v_358))) (and (or (or (or (or (or (or ?v_278 ?v_279) ?v_280) ?v_281) ?v_282) ?v_288) ?v_377) (or (or (or (or (or (or ?v_283 ?v_284) ?v_285) ?v_286) ?v_287) ?v_288) ?v_371))) (and (or (or (or (or (or (or ?v_289 ?v_290) ?v_291) ?v_292) ?v_293) ?v_299) ?v_390) (or (or (or (or (or (or ?v_294 ?v_295) ?v_296) ?v_297) ?v_298) ?v_299) ?v_384)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_300 ?v_301) ?v_302) ?v_303) ?v_304) ?v_305) ?v_312) (or (or (or (or (or (or ?v_306 ?v_307) ?v_308) ?v_309) ?v_310) ?v_311) ?v_312)) (and (or (or (or (or (or (or ?v_313 ?v_314) ?v_315) ?v_316) ?v_317) ?v_318) ?v_326) (or (or (or (or (or (or ?v_320 ?v_321) ?v_322) ?v_323) ?v_324) ?v_325) ?v_326))) (and (or (or (or (or (or (or ?v_327 ?v_328) ?v_329) ?v_330) ?v_331) ?v_332) ?v_339) (or (or (or (or (or (or ?v_333 ?v_334) ?v_335) ?v_336) ?v_337) ?v_338) ?v_339))) (and (or (or (or (or (or (or ?v_340 ?v_341) ?v_342) ?v_343) ?v_344) ?v_345) ?v_352) (or (or (or (or (or (or ?v_346 ?v_347) ?v_348) ?v_349) ?v_350) ?v_351) ?v_352))) (and (or (or (or (or (or (or ?v_353 ?v_354) ?v_355) ?v_356) ?v_357) ?v_358) ?v_365) (or (or (or (or (or (or ?v_359 ?v_360) ?v_361) ?v_362) ?v_363) ?v_364) ?v_365))) (and (or (or (or (or (or (or ?v_366 ?v_367) ?v_368) ?v_369) ?v_370) ?v_371) ?v_378) (or (or (or (or (or (or ?v_372 ?v_373) ?v_374) ?v_375) ?v_376) ?v_377) ?v_378))) (and (or (or (or (or (or (or ?v_379 ?v_380) ?v_381) ?v_382) ?v_383) ?v_384) ?v_391) (or (or (or (or (or (or ?v_385 ?v_386) ?v_387) ?v_388) ?v_389) ?v_390) ?v_391)))))) :named XyvMcrKEdQw)) (assert(! (and (and (and (and (and (and (and (and (and (and (and (and (= (op (op (op e0 e0) e0) e0) e0) (= (op (op (op e0 e1) e1) e1) e0)) (= (op (op (op e0 e2) e2) e2) e0)) (= (op (op (op e0 e3) e3) e3) e0)) (= (op (op (op e0 e4) e4) e4) e0)) (= (op (op (op e0 e5) e5) e5) e0)) (= (op (op (op e0 e6) e6) e6) e0)) (and (and (and (and (and (and (= (op (op (op e1 e0) e0) e0) e1) (= (op (op (op e1 e1) e1) e1) e1)) (= (op (op (op e1 e2) e2) e2) e1)) (= (op (op (op e1 e3) e3) e3) e1)) (= (op (op (op e1 e4) e4) e4) e1)) (= (op (op (op e1 e5) e5) e5) e1)) (= (op (op (op e1 e6) e6) e6) e1))) (and (and (and (and (and (and (= (op (op (op e2 e0) e0) e0) e2) (= (op (op (op e2 e1) e1) e1) e2)) (= (op (op (op e2 e2) e2) e2) e2)) (= (op (op (op e2 e3) e3) e3) e2)) (= (op (op (op e2 e4) e4) e4) e2)) (= (op (op (op e2 e5) e5) e5) e2)) (= (op (op (op e2 e6) e6) e6) e2))) (and (and (and (and (and (and (= (op (op (op e3 e0) e0) e0) e3) (= (op (op (op e3 e1) e1) e1) e3)) (= (op (op (op e3 e2) e2) e2) e3)) (= (op (op (op e3 e3) e3) e3) e3)) (= (op (op (op e3 e4) e4) e4) e3)) (= (op (op (op e3 e5) e5) e5) e3)) (= (op (op (op e3 e6) e6) e6) e3))) (and (and (and (and (and (and (= (op (op (op e4 e0) e0) e0) e4) (= (op (op (op e4 e1) e1) e1) e4)) (= (op (op (op e4 e2) e2) e2) e4)) (= (op (op (op e4 e3) e3) e3) e4)) (= (op (op (op e4 e4) e4) e4) e4)) (= (op (op (op e4 e5) e5) e5) e4)) (= (op (op (op e4 e6) e6) e6) e4))) (and (and (and (and (and (and (= (op (op (op e5 e0) e0) e0) e5) (= (op (op (op e5 e1) e1) e1) e5)) (= (op (op (op e5 e2) e2) e2) e5)) (= (op (op (op e5 e3) e3) e3) e5)) (= (op (op (op e5 e4) e4) e4) e5)) (= (op (op (op e5 e5) e5) e5) e5)) (= (op (op (op e5 e6) e6) e6) e5))) (and (and (and (and (and (and (= (op (op (op e6 e0) e0) e0) e6) (= (op (op (op e6 e1) e1) e1) e6)) (= (op (op (op e6 e2) e2) e2) e6)) (= (op (op (op e6 e3) e3) e3) e6)) (= (op (op (op e6 e4) e4) e4) e6)) (= (op (op (op e6 e5) e5) e5) e6)) (= (op (op (op e6 e6) e6) e6) e6))) :named tyIyyobDwxthvNS)) (assert(! (and (and (and (and (and (and (not (= (op e0 e0) e0)) (not (= (op e1 e1) e1))) (not (= (op e2 e2) e2))) (not (= (op e3 e3) e3))) (not (= (op e4 e4) e4))) (not (= (op e5 e5) e5))) (not (= (op e6 e6) e6))) :named RVEhNeqTomZduOEUV)) (assert(! (let ((?v_0 (skc1 e0)) (?v_1 (skc1 e1)) (?v_2 (skc1 e2)) (?v_3 (skc1 e3)) (?v_4 (skc1 e4)) (?v_5 (skc1 e5)) (?v_6 (skc1 e6))) (and (and (and (and (and (and (and (= (op e0 ?v_0) ?v_0) (= (op e1 ?v_1) ?v_1)) (= (op e2 ?v_2) ?v_2)) (= (op e3 ?v_3) ?v_3)) (= (op e4 ?v_4) ?v_4)) (= (op e5 ?v_5) ?v_5)) (= (op e6 ?v_6) ?v_6)) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_0 e0) (= ?v_0 e1)) (= ?v_0 e2)) (= ?v_0 e3)) (= ?v_0 e4)) (= ?v_0 e5)) (= ?v_0 e6)) (or (or (or (or (or (or (= ?v_1 e0) (= ?v_1 e1)) (= ?v_1 e2)) (= ?v_1 e3)) (= ?v_1 e4)) (= ?v_1 e5)) (= ?v_1 e6))) (or (or (or (or (or (or (= ?v_2 e0) (= ?v_2 e1)) (= ?v_2 e2)) (= ?v_2 e3)) (= ?v_2 e4)) (= ?v_2 e5)) (= ?v_2 e6))) (or (or (or (or (or (or (= ?v_3 e0) (= ?v_3 e1)) (= ?v_3 e2)) (= ?v_3 e3)) (= ?v_3 e4)) (= ?v_3 e5)) (= ?v_3 e6))) (or (or (or (or (or (or (= ?v_4 e0) (= ?v_4 e1)) (= ?v_4 e2)) (= ?v_4 e3)) (= ?v_4 e4)) (= ?v_4 e5)) (= ?v_4 e6))) (or (or (or (or (or (or (= ?v_5 e0) (= ?v_5 e1)) (= ?v_5 e2)) (= ?v_5 e3)) (= ?v_5 e4)) (= ?v_5 e5)) (= ?v_5 e6))) (or (or (or (or (or (or (= ?v_6 e0) (= ?v_6 e1)) (= ?v_6 e2)) (= ?v_6 e3)) (= ?v_6 e4)) (= ?v_6 e5)) (= ?v_6 e6))))) :named tocqokFIDgPbRcH)) (assert(! (let ((?v_0 (op e0 e0)) (?v_7 (op e0 e1)) (?v_14 (op e0 e2)) (?v_21 (op e0 e3)) (?v_28 (op e0 e4)) (?v_35 (op e0 e5)) (?v_42 (op e0 e6)) (?v_1 (op e1 e0)) (?v_8 (op e1 e1)) (?v_15 (op e1 e2)) (?v_22 (op e1 e3)) (?v_29 (op e1 e4)) (?v_36 (op e1 e5)) (?v_43 (op e1 e6)) (?v_2 (op e2 e0)) (?v_9 (op e2 e1)) (?v_16 (op e2 e2)) (?v_23 (op e2 e3)) (?v_30 (op e2 e4)) (?v_37 (op e2 e5)) (?v_44 (op e2 e6)) (?v_3 (op e3 e0)) (?v_10 (op e3 e1)) (?v_17 (op e3 e2)) (?v_24 (op e3 e3)) (?v_31 (op e3 e4)) (?v_38 (op e3 e5)) (?v_45 (op e3 e6)) (?v_4 (op e4 e0)) (?v_11 (op e4 e1)) (?v_18 (op e4 e2)) (?v_25 (op e4 e3)) (?v_32 (op e4 e4)) (?v_39 (op e4 e5)) (?v_46 (op e4 e6)) (?v_5 (op e5 e0)) (?v_12 (op e5 e1)) (?v_19 (op e5 e2)) (?v_26 (op e5 e3)) (?v_33 (op e5 e4)) (?v_40 (op e5 e5)) (?v_47 (op e5 e6)) (?v_6 (op e6 e0)) (?v_13 (op e6 e1)) (?v_20 (op e6 e2)) (?v_27 (op e6 e3)) (?v_34 (op e6 e4)) (?v_41 (op e6 e5)) (?v_48 (op e6 e6))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_1)) (not (= ?v_0 ?v_2))) (not (= ?v_0 ?v_3))) (not (= ?v_0 ?v_4))) (not (= ?v_0 ?v_5))) (not (= ?v_0 ?v_6))) (not (= ?v_1 ?v_2))) (not (= ?v_1 ?v_3))) (not (= ?v_1 ?v_4))) (not (= ?v_1 ?v_5))) (not (= ?v_1 ?v_6))) (not (= ?v_2 ?v_3))) (not (= ?v_2 ?v_4))) (not (= ?v_2 ?v_5))) (not (= ?v_2 ?v_6))) (not (= ?v_3 ?v_4))) (not (= ?v_3 ?v_5))) (not (= ?v_3 ?v_6))) (not (= ?v_4 ?v_5))) (not (= ?v_4 ?v_6))) (not (= ?v_5 ?v_6))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_7 ?v_8)) (not (= ?v_7 ?v_9))) (not (= ?v_7 ?v_10))) (not (= ?v_7 ?v_11))) (not (= ?v_7 ?v_12))) (not (= ?v_7 ?v_13))) (not (= ?v_8 ?v_9))) (not (= ?v_8 ?v_10))) (not (= ?v_8 ?v_11))) (not (= ?v_8 ?v_12))) (not (= ?v_8 ?v_13))) (not (= ?v_9 ?v_10))) (not (= ?v_9 ?v_11))) (not (= ?v_9 ?v_12))) (not (= ?v_9 ?v_13))) (not (= ?v_10 ?v_11))) (not (= ?v_10 ?v_12))) (not (= ?v_10 ?v_13))) (not (= ?v_11 ?v_12))) (not (= ?v_11 ?v_13))) (not (= ?v_12 ?v_13)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_14 ?v_15)) (not (= ?v_14 ?v_16))) (not (= ?v_14 ?v_17))) (not (= ?v_14 ?v_18))) (not (= ?v_14 ?v_19))) (not (= ?v_14 ?v_20))) (not (= ?v_15 ?v_16))) (not (= ?v_15 ?v_17))) (not (= ?v_15 ?v_18))) (not (= ?v_15 ?v_19))) (not (= ?v_15 ?v_20))) (not (= ?v_16 ?v_17))) (not (= ?v_16 ?v_18))) (not (= ?v_16 ?v_19))) (not (= ?v_16 ?v_20))) (not (= ?v_17 ?v_18))) (not (= ?v_17 ?v_19))) (not (= ?v_17 ?v_20))) (not (= ?v_18 ?v_19))) (not (= ?v_18 ?v_20))) (not (= ?v_19 ?v_20)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_21 ?v_22)) (not (= ?v_21 ?v_23))) (not (= ?v_21 ?v_24))) (not (= ?v_21 ?v_25))) (not (= ?v_21 ?v_26))) (not (= ?v_21 ?v_27))) (not (= ?v_22 ?v_23))) (not (= ?v_22 ?v_24))) (not (= ?v_22 ?v_25))) (not (= ?v_22 ?v_26))) (not (= ?v_22 ?v_27))) (not (= ?v_23 ?v_24))) (not (= ?v_23 ?v_25))) (not (= ?v_23 ?v_26))) (not (= ?v_23 ?v_27))) (not (= ?v_24 ?v_25))) (not (= ?v_24 ?v_26))) (not (= ?v_24 ?v_27))) (not (= ?v_25 ?v_26))) (not (= ?v_25 ?v_27))) (not (= ?v_26 ?v_27)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_28 ?v_29)) (not (= ?v_28 ?v_30))) (not (= ?v_28 ?v_31))) (not (= ?v_28 ?v_32))) (not (= ?v_28 ?v_33))) (not (= ?v_28 ?v_34))) (not (= ?v_29 ?v_30))) (not (= ?v_29 ?v_31))) (not (= ?v_29 ?v_32))) (not (= ?v_29 ?v_33))) (not (= ?v_29 ?v_34))) (not (= ?v_30 ?v_31))) (not (= ?v_30 ?v_32))) (not (= ?v_30 ?v_33))) (not (= ?v_30 ?v_34))) (not (= ?v_31 ?v_32))) (not (= ?v_31 ?v_33))) (not (= ?v_31 ?v_34))) (not (= ?v_32 ?v_33))) (not (= ?v_32 ?v_34))) (not (= ?v_33 ?v_34)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_35 ?v_36)) (not (= ?v_35 ?v_37))) (not (= ?v_35 ?v_38))) (not (= ?v_35 ?v_39))) (not (= ?v_35 ?v_40))) (not (= ?v_35 ?v_41))) (not (= ?v_36 ?v_37))) (not (= ?v_36 ?v_38))) (not (= ?v_36 ?v_39))) (not (= ?v_36 ?v_40))) (not (= ?v_36 ?v_41))) (not (= ?v_37 ?v_38))) (not (= ?v_37 ?v_39))) (not (= ?v_37 ?v_40))) (not (= ?v_37 ?v_41))) (not (= ?v_38 ?v_39))) (not (= ?v_38 ?v_40))) (not (= ?v_38 ?v_41))) (not (= ?v_39 ?v_40))) (not (= ?v_39 ?v_41))) (not (= ?v_40 ?v_41)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_42 ?v_43)) (not (= ?v_42 ?v_44))) (not (= ?v_42 ?v_45))) (not (= ?v_42 ?v_46))) (not (= ?v_42 ?v_47))) (not (= ?v_42 ?v_48))) (not (= ?v_43 ?v_44))) (not (= ?v_43 ?v_45))) (not (= ?v_43 ?v_46))) (not (= ?v_43 ?v_47))) (not (= ?v_43 ?v_48))) (not (= ?v_44 ?v_45))) (not (= ?v_44 ?v_46))) (not (= ?v_44 ?v_47))) (not (= ?v_44 ?v_48))) (not (= ?v_45 ?v_46))) (not (= ?v_45 ?v_47))) (not (= ?v_45 ?v_48))) (not (= ?v_46 ?v_47))) (not (= ?v_46 ?v_48))) (not (= ?v_47 ?v_48)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_7)) (not (= ?v_0 ?v_14))) (not (= ?v_0 ?v_21))) (not (= ?v_0 ?v_28))) (not (= ?v_0 ?v_35))) (not (= ?v_0 ?v_42))) (not (= ?v_7 ?v_14))) (not (= ?v_7 ?v_21))) (not (= ?v_7 ?v_28))) (not (= ?v_7 ?v_35))) (not (= ?v_7 ?v_42))) (not (= ?v_14 ?v_21))) (not (= ?v_14 ?v_28))) (not (= ?v_14 ?v_35))) (not (= ?v_14 ?v_42))) (not (= ?v_21 ?v_28))) (not (= ?v_21 ?v_35))) (not (= ?v_21 ?v_42))) (not (= ?v_28 ?v_35))) (not (= ?v_28 ?v_42))) (not (= ?v_35 ?v_42))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_1 ?v_8)) (not (= ?v_1 ?v_15))) (not (= ?v_1 ?v_22))) (not (= ?v_1 ?v_29))) (not (= ?v_1 ?v_36))) (not (= ?v_1 ?v_43))) (not (= ?v_8 ?v_15))) (not (= ?v_8 ?v_22))) (not (= ?v_8 ?v_29))) (not (= ?v_8 ?v_36))) (not (= ?v_8 ?v_43))) (not (= ?v_15 ?v_22))) (not (= ?v_15 ?v_29))) (not (= ?v_15 ?v_36))) (not (= ?v_15 ?v_43))) (not (= ?v_22 ?v_29))) (not (= ?v_22 ?v_36))) (not (= ?v_22 ?v_43))) (not (= ?v_29 ?v_36))) (not (= ?v_29 ?v_43))) (not (= ?v_36 ?v_43)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_2 ?v_9)) (not (= ?v_2 ?v_16))) (not (= ?v_2 ?v_23))) (not (= ?v_2 ?v_30))) (not (= ?v_2 ?v_37))) (not (= ?v_2 ?v_44))) (not (= ?v_9 ?v_16))) (not (= ?v_9 ?v_23))) (not (= ?v_9 ?v_30))) (not (= ?v_9 ?v_37))) (not (= ?v_9 ?v_44))) (not (= ?v_16 ?v_23))) (not (= ?v_16 ?v_30))) (not (= ?v_16 ?v_37))) (not (= ?v_16 ?v_44))) (not (= ?v_23 ?v_30))) (not (= ?v_23 ?v_37))) (not (= ?v_23 ?v_44))) (not (= ?v_30 ?v_37))) (not (= ?v_30 ?v_44))) (not (= ?v_37 ?v_44)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_3 ?v_10)) (not (= ?v_3 ?v_17))) (not (= ?v_3 ?v_24))) (not (= ?v_3 ?v_31))) (not (= ?v_3 ?v_38))) (not (= ?v_3 ?v_45))) (not (= ?v_10 ?v_17))) (not (= ?v_10 ?v_24))) (not (= ?v_10 ?v_31))) (not (= ?v_10 ?v_38))) (not (= ?v_10 ?v_45))) (not (= ?v_17 ?v_24))) (not (= ?v_17 ?v_31))) (not (= ?v_17 ?v_38))) (not (= ?v_17 ?v_45))) (not (= ?v_24 ?v_31))) (not (= ?v_24 ?v_38))) (not (= ?v_24 ?v_45))) (not (= ?v_31 ?v_38))) (not (= ?v_31 ?v_45))) (not (= ?v_38 ?v_45)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_4 ?v_11)) (not (= ?v_4 ?v_18))) (not (= ?v_4 ?v_25))) (not (= ?v_4 ?v_32))) (not (= ?v_4 ?v_39))) (not (= ?v_4 ?v_46))) (not (= ?v_11 ?v_18))) (not (= ?v_11 ?v_25))) (not (= ?v_11 ?v_32))) (not (= ?v_11 ?v_39))) (not (= ?v_11 ?v_46))) (not (= ?v_18 ?v_25))) (not (= ?v_18 ?v_32))) (not (= ?v_18 ?v_39))) (not (= ?v_18 ?v_46))) (not (= ?v_25 ?v_32))) (not (= ?v_25 ?v_39))) (not (= ?v_25 ?v_46))) (not (= ?v_32 ?v_39))) (not (= ?v_32 ?v_46))) (not (= ?v_39 ?v_46)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_5 ?v_12)) (not (= ?v_5 ?v_19))) (not (= ?v_5 ?v_26))) (not (= ?v_5 ?v_33))) (not (= ?v_5 ?v_40))) (not (= ?v_5 ?v_47))) (not (= ?v_12 ?v_19))) (not (= ?v_12 ?v_26))) (not (= ?v_12 ?v_33))) (not (= ?v_12 ?v_40))) (not (= ?v_12 ?v_47))) (not (= ?v_19 ?v_26))) (not (= ?v_19 ?v_33))) (not (= ?v_19 ?v_40))) (not (= ?v_19 ?v_47))) (not (= ?v_26 ?v_33))) (not (= ?v_26 ?v_40))) (not (= ?v_26 ?v_47))) (not (= ?v_33 ?v_40))) (not (= ?v_33 ?v_47))) (not (= ?v_40 ?v_47)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_6 ?v_13)) (not (= ?v_6 ?v_20))) (not (= ?v_6 ?v_27))) (not (= ?v_6 ?v_34))) (not (= ?v_6 ?v_41))) (not (= ?v_6 ?v_48))) (not (= ?v_13 ?v_20))) (not (= ?v_13 ?v_27))) (not (= ?v_13 ?v_34))) (not (= ?v_13 ?v_41))) (not (= ?v_13 ?v_48))) (not (= ?v_20 ?v_27))) (not (= ?v_20 ?v_34))) (not (= ?v_20 ?v_41))) (not (= ?v_20 ?v_48))) (not (= ?v_27 ?v_34))) (not (= ?v_27 ?v_41))) (not (= ?v_27 ?v_48))) (not (= ?v_34 ?v_41))) (not (= ?v_34 ?v_48))) (not (= ?v_41 ?v_48)))))) :named jFvGvghHoYAULY)) (assert(! (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= e0 e1)) (not (= e0 e2))) (not (= e0 e3))) (not (= e0 e4))) (not (= e0 e5))) (not (= e0 e6))) (not (= e1 e2))) (not (= e1 e3))) (not (= e1 e4))) (not (= e1 e5))) (not (= e1 e6))) (not (= e2 e3))) (not (= e2 e4))) (not (= e2 e5))) (not (= e2 e6))) (not (= e3 e4))) (not (= e3 e5))) (not (= e3 e6))) (not (= e4 e5))) (not (= e4 e6))) (not (= e5 e6))) :named qAKbTMXUQMBOw)) (assert(! (and (and (and (and (and (= e0 (op e6 e6)) (= e1 (op e2 e2))) (= e2 (op e5 e6))) (= e3 (op e0 e0))) (= e4 (op e1 e5))) (= e5 (op e3 e6))) :named RrARoYIhGXaGFdb)) (assert(! (not (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= (op e0 e0) e3) (= (op e0 e1) e5)) (= (op e0 e2) e0)) (= (op e0 e3) e6)) (= (op e0 e4) e4)) (= (op e0 e5) e2)) (= (op e0 e6) e1)) (= (op e1 e0) e2)) (= (op e1 e1) e0)) (= (op e1 e2) e3)) (= (op e1 e3) e5)) (= (op e1 e4) e1)) (= (op e1 e5) e4)) (= (op e1 e6) e6)) (= (op e2 e0) e6)) (= (op e2 e1) e4)) (= (op e2 e2) e1)) (= (op e2 e3) e2)) (= (op e2 e4) e0)) (= (op e2 e5) e5)) (= (op e2 e6) e3)) (= (op e3 e0) e4)) (= (op e3 e1) e3)) (= (op e3 e2) e2)) (= (op e3 e3) e0)) (= (op e3 e4) e6)) (= (op e3 e5) e1)) (= (op e3 e6) e5)) (= (op e4 e0) e0)) (= (op e4 e1) e6)) (= (op e4 e2) e5)) (= (op e4 e3) e1)) (= (op e4 e4) e2)) (= (op e4 e5) e3)) (= (op e4 e6) e4)) (= (op e5 e0) e5)) (= (op e5 e1) e1)) (= (op e5 e2) e6)) (= (op e5 e3) e4)) (= (op e5 e4) e3)) (= (op e5 e5) e0)) (= (op e5 e6) e2)) (= (op e6 e0) e1)) (= (op e6 e1) e2)) (= (op e6 e2) e4)) (= (op e6 e3) e3)) (= (op e6 e4) e5)) (= (op e6 e5) e6)) (= (op e6 e6) e0))) :named aEhGXBdtsekb)) (check-sat) opensmt-2.5.2/regression/lookahead/iso_brn_sk003_eufexps.smt2.expected.err000066400000000000000000000000001445011647600266220ustar00rootroot00000000000000opensmt-2.5.2/regression/lookahead/iso_brn_sk003_eufexps.smt2.expected.out000066400000000000000000000000061445011647600266470ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/lookahead/iso_brn_sk004_eufexps.smt2000066400000000000000000001142441445011647600242540ustar00rootroot00000000000000(set-option :pure-lookahead true) (set-logic QF_UF) (set-info :source | http://www.cs.bham.ac.uk/~vxs/quasigroups/benchmark/ |) (set-info :smt-lib-version 2.0) (set-info :category "crafted") (set-info :status unsat) (declare-sort U 0) (declare-sort I 0) (declare-fun op1 (I I) I) (declare-fun op (I I) I) (declare-fun e6 () I) (declare-fun e5 () I) (declare-fun e4 () I) (declare-fun e3 () I) (declare-fun e2 () I) (declare-fun e1 () I) (declare-fun e0 () I) (declare-fun skc1 (I) I) (declare-fun skc2 () I) (declare-fun skc3 () I) (assert(! (let ((?v_0 (op e0 e0)) (?v_1 (op e0 e1)) (?v_2 (op e0 e2)) (?v_3 (op e0 e3)) (?v_4 (op e0 e4)) (?v_5 (op e0 e5)) (?v_6 (op e0 e6)) (?v_7 (op e1 e0)) (?v_8 (op e1 e1)) (?v_9 (op e1 e2)) (?v_10 (op e1 e3)) (?v_11 (op e1 e4)) (?v_12 (op e1 e5)) (?v_13 (op e1 e6)) (?v_14 (op e2 e0)) (?v_15 (op e2 e1)) (?v_16 (op e2 e2)) (?v_17 (op e2 e3)) (?v_18 (op e2 e4)) (?v_19 (op e2 e5)) (?v_20 (op e2 e6)) (?v_21 (op e3 e0)) (?v_22 (op e3 e1)) (?v_23 (op e3 e2)) (?v_24 (op e3 e3)) (?v_25 (op e3 e4)) (?v_26 (op e3 e5)) (?v_27 (op e3 e6)) (?v_28 (op e4 e0)) (?v_29 (op e4 e1)) (?v_30 (op e4 e2)) (?v_31 (op e4 e3)) (?v_32 (op e4 e4)) (?v_33 (op e4 e5)) (?v_34 (op e4 e6)) (?v_35 (op e5 e0)) (?v_36 (op e5 e1)) (?v_37 (op e5 e2)) (?v_38 (op e5 e3)) (?v_39 (op e5 e4)) (?v_40 (op e5 e5)) (?v_41 (op e5 e6)) (?v_42 (op e6 e0)) (?v_43 (op e6 e1)) (?v_44 (op e6 e2)) (?v_45 (op e6 e3)) (?v_46 (op e6 e4)) (?v_47 (op e6 e5)) (?v_48 (op e6 e6))) (and (and (and (and (and (and (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_0 e0) (= ?v_0 e1)) (= ?v_0 e2)) (= ?v_0 e3)) (= ?v_0 e4)) (= ?v_0 e5)) (= ?v_0 e6)) (or (or (or (or (or (or (= ?v_1 e0) (= ?v_1 e1)) (= ?v_1 e2)) (= ?v_1 e3)) (= ?v_1 e4)) (= ?v_1 e5)) (= ?v_1 e6))) (or (or (or (or (or (or (= ?v_2 e0) (= ?v_2 e1)) (= ?v_2 e2)) (= ?v_2 e3)) (= ?v_2 e4)) (= ?v_2 e5)) (= ?v_2 e6))) (or (or (or (or (or (or (= ?v_3 e0) (= ?v_3 e1)) (= ?v_3 e2)) (= ?v_3 e3)) (= ?v_3 e4)) (= ?v_3 e5)) (= ?v_3 e6))) (or (or (or (or (or (or (= ?v_4 e0) (= ?v_4 e1)) (= ?v_4 e2)) (= ?v_4 e3)) (= ?v_4 e4)) (= ?v_4 e5)) (= ?v_4 e6))) (or (or (or (or (or (or (= ?v_5 e0) (= ?v_5 e1)) (= ?v_5 e2)) (= ?v_5 e3)) (= ?v_5 e4)) (= ?v_5 e5)) (= ?v_5 e6))) (or (or (or (or (or (or (= ?v_6 e0) (= ?v_6 e1)) (= ?v_6 e2)) (= ?v_6 e3)) (= ?v_6 e4)) (= ?v_6 e5)) (= ?v_6 e6))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_7 e0) (= ?v_7 e1)) (= ?v_7 e2)) (= ?v_7 e3)) (= ?v_7 e4)) (= ?v_7 e5)) (= ?v_7 e6)) (or (or (or (or (or (or (= ?v_8 e0) (= ?v_8 e1)) (= ?v_8 e2)) (= ?v_8 e3)) (= ?v_8 e4)) (= ?v_8 e5)) (= ?v_8 e6))) (or (or (or (or (or (or (= ?v_9 e0) (= ?v_9 e1)) (= ?v_9 e2)) (= ?v_9 e3)) (= ?v_9 e4)) (= ?v_9 e5)) (= ?v_9 e6))) (or (or (or (or (or (or (= ?v_10 e0) (= ?v_10 e1)) (= ?v_10 e2)) (= ?v_10 e3)) (= ?v_10 e4)) (= ?v_10 e5)) (= ?v_10 e6))) (or (or (or (or (or (or (= ?v_11 e0) (= ?v_11 e1)) (= ?v_11 e2)) (= ?v_11 e3)) (= ?v_11 e4)) (= ?v_11 e5)) (= ?v_11 e6))) (or (or (or (or (or (or (= ?v_12 e0) (= ?v_12 e1)) (= ?v_12 e2)) (= ?v_12 e3)) (= ?v_12 e4)) (= ?v_12 e5)) (= ?v_12 e6))) (or (or (or (or (or (or (= ?v_13 e0) (= ?v_13 e1)) (= ?v_13 e2)) (= ?v_13 e3)) (= ?v_13 e4)) (= ?v_13 e5)) (= ?v_13 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_14 e0) (= ?v_14 e1)) (= ?v_14 e2)) (= ?v_14 e3)) (= ?v_14 e4)) (= ?v_14 e5)) (= ?v_14 e6)) (or (or (or (or (or (or (= ?v_15 e0) (= ?v_15 e1)) (= ?v_15 e2)) (= ?v_15 e3)) (= ?v_15 e4)) (= ?v_15 e5)) (= ?v_15 e6))) (or (or (or (or (or (or (= ?v_16 e0) (= ?v_16 e1)) (= ?v_16 e2)) (= ?v_16 e3)) (= ?v_16 e4)) (= ?v_16 e5)) (= ?v_16 e6))) (or (or (or (or (or (or (= ?v_17 e0) (= ?v_17 e1)) (= ?v_17 e2)) (= ?v_17 e3)) (= ?v_17 e4)) (= ?v_17 e5)) (= ?v_17 e6))) (or (or (or (or (or (or (= ?v_18 e0) (= ?v_18 e1)) (= ?v_18 e2)) (= ?v_18 e3)) (= ?v_18 e4)) (= ?v_18 e5)) (= ?v_18 e6))) (or (or (or (or (or (or (= ?v_19 e0) (= ?v_19 e1)) (= ?v_19 e2)) (= ?v_19 e3)) (= ?v_19 e4)) (= ?v_19 e5)) (= ?v_19 e6))) (or (or (or (or (or (or (= ?v_20 e0) (= ?v_20 e1)) (= ?v_20 e2)) (= ?v_20 e3)) (= ?v_20 e4)) (= ?v_20 e5)) (= ?v_20 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_21 e0) (= ?v_21 e1)) (= ?v_21 e2)) (= ?v_21 e3)) (= ?v_21 e4)) (= ?v_21 e5)) (= ?v_21 e6)) (or (or (or (or (or (or (= ?v_22 e0) (= ?v_22 e1)) (= ?v_22 e2)) (= ?v_22 e3)) (= ?v_22 e4)) (= ?v_22 e5)) (= ?v_22 e6))) (or (or (or (or (or (or (= ?v_23 e0) (= ?v_23 e1)) (= ?v_23 e2)) (= ?v_23 e3)) (= ?v_23 e4)) (= ?v_23 e5)) (= ?v_23 e6))) (or (or (or (or (or (or (= ?v_24 e0) (= ?v_24 e1)) (= ?v_24 e2)) (= ?v_24 e3)) (= ?v_24 e4)) (= ?v_24 e5)) (= ?v_24 e6))) (or (or (or (or (or (or (= ?v_25 e0) (= ?v_25 e1)) (= ?v_25 e2)) (= ?v_25 e3)) (= ?v_25 e4)) (= ?v_25 e5)) (= ?v_25 e6))) (or (or (or (or (or (or (= ?v_26 e0) (= ?v_26 e1)) (= ?v_26 e2)) (= ?v_26 e3)) (= ?v_26 e4)) (= ?v_26 e5)) (= ?v_26 e6))) (or (or (or (or (or (or (= ?v_27 e0) (= ?v_27 e1)) (= ?v_27 e2)) (= ?v_27 e3)) (= ?v_27 e4)) (= ?v_27 e5)) (= ?v_27 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_28 e0) (= ?v_28 e1)) (= ?v_28 e2)) (= ?v_28 e3)) (= ?v_28 e4)) (= ?v_28 e5)) (= ?v_28 e6)) (or (or (or (or (or (or (= ?v_29 e0) (= ?v_29 e1)) (= ?v_29 e2)) (= ?v_29 e3)) (= ?v_29 e4)) (= ?v_29 e5)) (= ?v_29 e6))) (or (or (or (or (or (or (= ?v_30 e0) (= ?v_30 e1)) (= ?v_30 e2)) (= ?v_30 e3)) (= ?v_30 e4)) (= ?v_30 e5)) (= ?v_30 e6))) (or (or (or (or (or (or (= ?v_31 e0) (= ?v_31 e1)) (= ?v_31 e2)) (= ?v_31 e3)) (= ?v_31 e4)) (= ?v_31 e5)) (= ?v_31 e6))) (or (or (or (or (or (or (= ?v_32 e0) (= ?v_32 e1)) (= ?v_32 e2)) (= ?v_32 e3)) (= ?v_32 e4)) (= ?v_32 e5)) (= ?v_32 e6))) (or (or (or (or (or (or (= ?v_33 e0) (= ?v_33 e1)) (= ?v_33 e2)) (= ?v_33 e3)) (= ?v_33 e4)) (= ?v_33 e5)) (= ?v_33 e6))) (or (or (or (or (or (or (= ?v_34 e0) (= ?v_34 e1)) (= ?v_34 e2)) (= ?v_34 e3)) (= ?v_34 e4)) (= ?v_34 e5)) (= ?v_34 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_35 e0) (= ?v_35 e1)) (= ?v_35 e2)) (= ?v_35 e3)) (= ?v_35 e4)) (= ?v_35 e5)) (= ?v_35 e6)) (or (or (or (or (or (or (= ?v_36 e0) (= ?v_36 e1)) (= ?v_36 e2)) (= ?v_36 e3)) (= ?v_36 e4)) (= ?v_36 e5)) (= ?v_36 e6))) (or (or (or (or (or (or (= ?v_37 e0) (= ?v_37 e1)) (= ?v_37 e2)) (= ?v_37 e3)) (= ?v_37 e4)) (= ?v_37 e5)) (= ?v_37 e6))) (or (or (or (or (or (or (= ?v_38 e0) (= ?v_38 e1)) (= ?v_38 e2)) (= ?v_38 e3)) (= ?v_38 e4)) (= ?v_38 e5)) (= ?v_38 e6))) (or (or (or (or (or (or (= ?v_39 e0) (= ?v_39 e1)) (= ?v_39 e2)) (= ?v_39 e3)) (= ?v_39 e4)) (= ?v_39 e5)) (= ?v_39 e6))) (or (or (or (or (or (or (= ?v_40 e0) (= ?v_40 e1)) (= ?v_40 e2)) (= ?v_40 e3)) (= ?v_40 e4)) (= ?v_40 e5)) (= ?v_40 e6))) (or (or (or (or (or (or (= ?v_41 e0) (= ?v_41 e1)) (= ?v_41 e2)) (= ?v_41 e3)) (= ?v_41 e4)) (= ?v_41 e5)) (= ?v_41 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_42 e0) (= ?v_42 e1)) (= ?v_42 e2)) (= ?v_42 e3)) (= ?v_42 e4)) (= ?v_42 e5)) (= ?v_42 e6)) (or (or (or (or (or (or (= ?v_43 e0) (= ?v_43 e1)) (= ?v_43 e2)) (= ?v_43 e3)) (= ?v_43 e4)) (= ?v_43 e5)) (= ?v_43 e6))) (or (or (or (or (or (or (= ?v_44 e0) (= ?v_44 e1)) (= ?v_44 e2)) (= ?v_44 e3)) (= ?v_44 e4)) (= ?v_44 e5)) (= ?v_44 e6))) (or (or (or (or (or (or (= ?v_45 e0) (= ?v_45 e1)) (= ?v_45 e2)) (= ?v_45 e3)) (= ?v_45 e4)) (= ?v_45 e5)) (= ?v_45 e6))) (or (or (or (or (or (or (= ?v_46 e0) (= ?v_46 e1)) (= ?v_46 e2)) (= ?v_46 e3)) (= ?v_46 e4)) (= ?v_46 e5)) (= ?v_46 e6))) (or (or (or (or (or (or (= ?v_47 e0) (= ?v_47 e1)) (= ?v_47 e2)) (= ?v_47 e3)) (= ?v_47 e4)) (= ?v_47 e5)) (= ?v_47 e6))) (or (or (or (or (or (or (= ?v_48 e0) (= ?v_48 e1)) (= ?v_48 e2)) (= ?v_48 e3)) (= ?v_48 e4)) (= ?v_48 e5)) (= ?v_48 e6))))) :named GPOAwhwjgbuUOKkUnXW)) (assert(! (let ((?v_1 (op e0 e0)) (?v_2 (op e0 e1)) (?v_3 (op e0 e2)) (?v_4 (op e0 e3)) (?v_5 (op e0 e4)) (?v_6 (op e0 e5)) (?v_7 (op e0 e6)) (?v_9 (op e1 e0)) (?v_24 (op e1 e1)) (?v_25 (op e1 e2)) (?v_26 (op e1 e3)) (?v_27 (op e1 e4)) (?v_28 (op e1 e5)) (?v_29 (op e1 e6)) (?v_10 (op e2 e0)) (?v_32 (op e2 e1)) (?v_59 (op e2 e2)) (?v_60 (op e2 e3)) (?v_61 (op e2 e4)) (?v_62 (op e2 e5)) (?v_63 (op e2 e6)) (?v_11 (op e3 e0)) (?v_33 (op e3 e1)) (?v_67 (op e3 e2)) (?v_106 (op e3 e3)) (?v_107 (op e3 e4)) (?v_108 (op e3 e5)) (?v_109 (op e3 e6)) (?v_12 (op e4 e0)) (?v_34 (op e4 e1)) (?v_68 (op e4 e2)) (?v_114 (op e4 e3)) (?v_165 (op e4 e4)) (?v_166 (op e4 e5)) (?v_167 (op e4 e6)) (?v_13 (op e5 e0)) (?v_35 (op e5 e1)) (?v_69 (op e5 e2)) (?v_115 (op e5 e3)) (?v_173 (op e5 e4)) (?v_236 (op e5 e5)) (?v_237 (op e5 e6)) (?v_14 (op e6 e0)) (?v_36 (op e6 e1)) (?v_70 (op e6 e2)) (?v_116 (op e6 e3)) (?v_174 (op e6 e4)) (?v_244 (op e6 e5)) (?v_319 (op e6 e6))) (let ((?v_0 (= ?v_1 e0)) (?v_8 (= ?v_1 e1)) (?v_15 (= ?v_1 e2)) (?v_16 (= ?v_1 e3)) (?v_17 (= ?v_1 e4)) (?v_18 (= ?v_1 e5)) (?v_19 (= ?v_1 e6)) (?v_21 (= ?v_2 e0)) (?v_30 (= ?v_2 e1)) (?v_38 (= ?v_2 e2)) (?v_41 (= ?v_2 e3)) (?v_44 (= ?v_2 e4)) (?v_47 (= ?v_2 e5)) (?v_50 (= ?v_2 e6)) (?v_54 (= ?v_3 e0)) (?v_64 (= ?v_3 e1)) (?v_73 (= ?v_3 e2)) (?v_78 (= ?v_3 e3)) (?v_83 (= ?v_3 e4)) (?v_88 (= ?v_3 e5)) (?v_93 (= ?v_3 e6)) (?v_99 (= ?v_4 e0)) (?v_110 (= ?v_4 e1)) (?v_120 (= ?v_4 e2)) (?v_127 (= ?v_4 e3)) (?v_134 (= ?v_4 e4)) (?v_141 (= ?v_4 e5)) (?v_148 (= ?v_4 e6)) (?v_156 (= ?v_5 e0)) (?v_168 (= ?v_5 e1)) (?v_179 (= ?v_5 e2)) (?v_188 (= ?v_5 e3)) (?v_197 (= ?v_5 e4)) (?v_206 (= ?v_5 e5)) (?v_215 (= ?v_5 e6)) (?v_225 (= ?v_6 e0)) (?v_238 (= ?v_6 e1)) (?v_250 (= ?v_6 e2)) (?v_261 (= ?v_6 e3)) (?v_272 (= ?v_6 e4)) (?v_283 (= ?v_6 e5)) (?v_294 (= ?v_6 e6)) (?v_306 (= ?v_7 e0)) (?v_320 (= ?v_7 e1)) (?v_333 (= ?v_7 e2)) (?v_346 (= ?v_7 e3)) (?v_359 (= ?v_7 e4)) (?v_372 (= ?v_7 e5)) (?v_385 (= ?v_7 e6)) (?v_20 (= ?v_9 e0)) (?v_23 (= ?v_9 e1)) (?v_37 (= ?v_9 e2)) (?v_40 (= ?v_9 e3)) (?v_43 (= ?v_9 e4)) (?v_46 (= ?v_9 e5)) (?v_49 (= ?v_9 e6)) (?v_22 (= ?v_24 e0)) (?v_31 (= ?v_24 e1)) (?v_39 (= ?v_24 e2)) (?v_42 (= ?v_24 e3)) (?v_45 (= ?v_24 e4)) (?v_48 (= ?v_24 e5)) (?v_51 (= ?v_24 e6)) (?v_55 (= ?v_25 e0)) (?v_65 (= ?v_25 e1)) (?v_74 (= ?v_25 e2)) (?v_79 (= ?v_25 e3)) (?v_84 (= ?v_25 e4)) (?v_89 (= ?v_25 e5)) (?v_94 (= ?v_25 e6)) (?v_100 (= ?v_26 e0)) (?v_111 (= ?v_26 e1)) (?v_121 (= ?v_26 e2)) (?v_128 (= ?v_26 e3)) (?v_135 (= ?v_26 e4)) (?v_142 (= ?v_26 e5)) (?v_149 (= ?v_26 e6)) (?v_157 (= ?v_27 e0)) (?v_169 (= ?v_27 e1)) (?v_180 (= ?v_27 e2)) (?v_189 (= ?v_27 e3)) (?v_198 (= ?v_27 e4)) (?v_207 (= ?v_27 e5)) (?v_216 (= ?v_27 e6)) (?v_226 (= ?v_28 e0)) (?v_239 (= ?v_28 e1)) (?v_251 (= ?v_28 e2)) (?v_262 (= ?v_28 e3)) (?v_273 (= ?v_28 e4)) (?v_284 (= ?v_28 e5)) (?v_295 (= ?v_28 e6)) (?v_307 (= ?v_29 e0)) (?v_321 (= ?v_29 e1)) (?v_334 (= ?v_29 e2)) (?v_347 (= ?v_29 e3)) (?v_360 (= ?v_29 e4)) (?v_373 (= ?v_29 e5)) (?v_386 (= ?v_29 e6)) (?v_52 (= ?v_10 e0)) (?v_57 (= ?v_10 e1)) (?v_71 (= ?v_10 e2)) (?v_76 (= ?v_10 e3)) (?v_81 (= ?v_10 e4)) (?v_86 (= ?v_10 e5)) (?v_91 (= ?v_10 e6)) (?v_53 (= ?v_32 e0)) (?v_58 (= ?v_32 e1)) (?v_72 (= ?v_32 e2)) (?v_77 (= ?v_32 e3)) (?v_82 (= ?v_32 e4)) (?v_87 (= ?v_32 e5)) (?v_92 (= ?v_32 e6)) (?v_56 (= ?v_59 e0)) (?v_66 (= ?v_59 e1)) (?v_75 (= ?v_59 e2)) (?v_80 (= ?v_59 e3)) (?v_85 (= ?v_59 e4)) (?v_90 (= ?v_59 e5)) (?v_95 (= ?v_59 e6)) (?v_101 (= ?v_60 e0)) (?v_112 (= ?v_60 e1)) (?v_122 (= ?v_60 e2)) (?v_129 (= ?v_60 e3)) (?v_136 (= ?v_60 e4)) (?v_143 (= ?v_60 e5)) (?v_150 (= ?v_60 e6)) (?v_158 (= ?v_61 e0)) (?v_170 (= ?v_61 e1)) (?v_181 (= ?v_61 e2)) (?v_190 (= ?v_61 e3)) (?v_199 (= ?v_61 e4)) (?v_208 (= ?v_61 e5)) (?v_217 (= ?v_61 e6)) (?v_227 (= ?v_62 e0)) (?v_240 (= ?v_62 e1)) (?v_252 (= ?v_62 e2)) (?v_263 (= ?v_62 e3)) (?v_274 (= ?v_62 e4)) (?v_285 (= ?v_62 e5)) (?v_296 (= ?v_62 e6)) (?v_308 (= ?v_63 e0)) (?v_322 (= ?v_63 e1)) (?v_335 (= ?v_63 e2)) (?v_348 (= ?v_63 e3)) (?v_361 (= ?v_63 e4)) (?v_374 (= ?v_63 e5)) (?v_387 (= ?v_63 e6)) (?v_96 (= ?v_11 e0)) (?v_103 (= ?v_11 e1)) (?v_117 (= ?v_11 e2)) (?v_124 (= ?v_11 e3)) (?v_131 (= ?v_11 e4)) (?v_138 (= ?v_11 e5)) (?v_145 (= ?v_11 e6)) (?v_97 (= ?v_33 e0)) (?v_104 (= ?v_33 e1)) (?v_118 (= ?v_33 e2)) (?v_125 (= ?v_33 e3)) (?v_132 (= ?v_33 e4)) (?v_139 (= ?v_33 e5)) (?v_146 (= ?v_33 e6)) (?v_98 (= ?v_67 e0)) (?v_105 (= ?v_67 e1)) (?v_119 (= ?v_67 e2)) (?v_126 (= ?v_67 e3)) (?v_133 (= ?v_67 e4)) (?v_140 (= ?v_67 e5)) (?v_147 (= ?v_67 e6)) (?v_102 (= ?v_106 e0)) (?v_113 (= ?v_106 e1)) (?v_123 (= ?v_106 e2)) (?v_130 (= ?v_106 e3)) (?v_137 (= ?v_106 e4)) (?v_144 (= ?v_106 e5)) (?v_151 (= ?v_106 e6)) (?v_159 (= ?v_107 e0)) (?v_171 (= ?v_107 e1)) (?v_182 (= ?v_107 e2)) (?v_191 (= ?v_107 e3)) (?v_200 (= ?v_107 e4)) (?v_209 (= ?v_107 e5)) (?v_218 (= ?v_107 e6)) (?v_228 (= ?v_108 e0)) (?v_241 (= ?v_108 e1)) (?v_253 (= ?v_108 e2)) (?v_264 (= ?v_108 e3)) (?v_275 (= ?v_108 e4)) (?v_286 (= ?v_108 e5)) (?v_297 (= ?v_108 e6)) (?v_309 (= ?v_109 e0)) (?v_323 (= ?v_109 e1)) (?v_336 (= ?v_109 e2)) (?v_349 (= ?v_109 e3)) (?v_362 (= ?v_109 e4)) (?v_375 (= ?v_109 e5)) (?v_388 (= ?v_109 e6)) (?v_152 (= ?v_12 e0)) (?v_161 (= ?v_12 e1)) (?v_175 (= ?v_12 e2)) (?v_184 (= ?v_12 e3)) (?v_193 (= ?v_12 e4)) (?v_202 (= ?v_12 e5)) (?v_211 (= ?v_12 e6)) (?v_153 (= ?v_34 e0)) (?v_162 (= ?v_34 e1)) (?v_176 (= ?v_34 e2)) (?v_185 (= ?v_34 e3)) (?v_194 (= ?v_34 e4)) (?v_203 (= ?v_34 e5)) (?v_212 (= ?v_34 e6)) (?v_154 (= ?v_68 e0)) (?v_163 (= ?v_68 e1)) (?v_177 (= ?v_68 e2)) (?v_186 (= ?v_68 e3)) (?v_195 (= ?v_68 e4)) (?v_204 (= ?v_68 e5)) (?v_213 (= ?v_68 e6)) (?v_155 (= ?v_114 e0)) (?v_164 (= ?v_114 e1)) (?v_178 (= ?v_114 e2)) (?v_187 (= ?v_114 e3)) (?v_196 (= ?v_114 e4)) (?v_205 (= ?v_114 e5)) (?v_214 (= ?v_114 e6)) (?v_160 (= ?v_165 e0)) (?v_172 (= ?v_165 e1)) (?v_183 (= ?v_165 e2)) (?v_192 (= ?v_165 e3)) (?v_201 (= ?v_165 e4)) (?v_210 (= ?v_165 e5)) (?v_219 (= ?v_165 e6)) (?v_229 (= ?v_166 e0)) (?v_242 (= ?v_166 e1)) (?v_254 (= ?v_166 e2)) (?v_265 (= ?v_166 e3)) (?v_276 (= ?v_166 e4)) (?v_287 (= ?v_166 e5)) (?v_298 (= ?v_166 e6)) (?v_310 (= ?v_167 e0)) (?v_324 (= ?v_167 e1)) (?v_337 (= ?v_167 e2)) (?v_350 (= ?v_167 e3)) (?v_363 (= ?v_167 e4)) (?v_376 (= ?v_167 e5)) (?v_389 (= ?v_167 e6)) (?v_220 (= ?v_13 e0)) (?v_231 (= ?v_13 e1)) (?v_245 (= ?v_13 e2)) (?v_256 (= ?v_13 e3)) (?v_267 (= ?v_13 e4)) (?v_278 (= ?v_13 e5)) (?v_289 (= ?v_13 e6)) (?v_221 (= ?v_35 e0)) (?v_232 (= ?v_35 e1)) (?v_246 (= ?v_35 e2)) (?v_257 (= ?v_35 e3)) (?v_268 (= ?v_35 e4)) (?v_279 (= ?v_35 e5)) (?v_290 (= ?v_35 e6)) (?v_222 (= ?v_69 e0)) (?v_233 (= ?v_69 e1)) (?v_247 (= ?v_69 e2)) (?v_258 (= ?v_69 e3)) (?v_269 (= ?v_69 e4)) (?v_280 (= ?v_69 e5)) (?v_291 (= ?v_69 e6)) (?v_223 (= ?v_115 e0)) (?v_234 (= ?v_115 e1)) (?v_248 (= ?v_115 e2)) (?v_259 (= ?v_115 e3)) (?v_270 (= ?v_115 e4)) (?v_281 (= ?v_115 e5)) (?v_292 (= ?v_115 e6)) (?v_224 (= ?v_173 e0)) (?v_235 (= ?v_173 e1)) (?v_249 (= ?v_173 e2)) (?v_260 (= ?v_173 e3)) (?v_271 (= ?v_173 e4)) (?v_282 (= ?v_173 e5)) (?v_293 (= ?v_173 e6)) (?v_230 (= ?v_236 e0)) (?v_243 (= ?v_236 e1)) (?v_255 (= ?v_236 e2)) (?v_266 (= ?v_236 e3)) (?v_277 (= ?v_236 e4)) (?v_288 (= ?v_236 e5)) (?v_299 (= ?v_236 e6)) (?v_311 (= ?v_237 e0)) (?v_325 (= ?v_237 e1)) (?v_338 (= ?v_237 e2)) (?v_351 (= ?v_237 e3)) (?v_364 (= ?v_237 e4)) (?v_377 (= ?v_237 e5)) (?v_390 (= ?v_237 e6)) (?v_300 (= ?v_14 e0)) (?v_313 (= ?v_14 e1)) (?v_327 (= ?v_14 e2)) (?v_340 (= ?v_14 e3)) (?v_353 (= ?v_14 e4)) (?v_366 (= ?v_14 e5)) (?v_379 (= ?v_14 e6)) (?v_301 (= ?v_36 e0)) (?v_314 (= ?v_36 e1)) (?v_328 (= ?v_36 e2)) (?v_341 (= ?v_36 e3)) (?v_354 (= ?v_36 e4)) (?v_367 (= ?v_36 e5)) (?v_380 (= ?v_36 e6)) (?v_302 (= ?v_70 e0)) (?v_315 (= ?v_70 e1)) (?v_329 (= ?v_70 e2)) (?v_342 (= ?v_70 e3)) (?v_355 (= ?v_70 e4)) (?v_368 (= ?v_70 e5)) (?v_381 (= ?v_70 e6)) (?v_303 (= ?v_116 e0)) (?v_316 (= ?v_116 e1)) (?v_330 (= ?v_116 e2)) (?v_343 (= ?v_116 e3)) (?v_356 (= ?v_116 e4)) (?v_369 (= ?v_116 e5)) (?v_382 (= ?v_116 e6)) (?v_304 (= ?v_174 e0)) (?v_317 (= ?v_174 e1)) (?v_331 (= ?v_174 e2)) (?v_344 (= ?v_174 e3)) (?v_357 (= ?v_174 e4)) (?v_370 (= ?v_174 e5)) (?v_383 (= ?v_174 e6)) (?v_305 (= ?v_244 e0)) (?v_318 (= ?v_244 e1)) (?v_332 (= ?v_244 e2)) (?v_345 (= ?v_244 e3)) (?v_358 (= ?v_244 e4)) (?v_371 (= ?v_244 e5)) (?v_384 (= ?v_244 e6)) (?v_312 (= ?v_319 e0)) (?v_326 (= ?v_319 e1)) (?v_339 (= ?v_319 e2)) (?v_352 (= ?v_319 e3)) (?v_365 (= ?v_319 e4)) (?v_378 (= ?v_319 e5)) (?v_391 (= ?v_319 e6))) (and (and (and (and (and (and (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_0 ?v_21) ?v_54) ?v_99) ?v_156) ?v_225) ?v_306) (or (or (or (or (or (or ?v_0 ?v_20) ?v_52) ?v_96) ?v_152) ?v_220) ?v_300)) (and (or (or (or (or (or (or ?v_8 ?v_30) ?v_64) ?v_110) ?v_168) ?v_238) ?v_320) (or (or (or (or (or (or ?v_8 ?v_23) ?v_57) ?v_103) ?v_161) ?v_231) ?v_313))) (and (or (or (or (or (or (or ?v_15 ?v_38) ?v_73) ?v_120) ?v_179) ?v_250) ?v_333) (or (or (or (or (or (or ?v_15 ?v_37) ?v_71) ?v_117) ?v_175) ?v_245) ?v_327))) (and (or (or (or (or (or (or ?v_16 ?v_41) ?v_78) ?v_127) ?v_188) ?v_261) ?v_346) (or (or (or (or (or (or ?v_16 ?v_40) ?v_76) ?v_124) ?v_184) ?v_256) ?v_340))) (and (or (or (or (or (or (or ?v_17 ?v_44) ?v_83) ?v_134) ?v_197) ?v_272) ?v_359) (or (or (or (or (or (or ?v_17 ?v_43) ?v_81) ?v_131) ?v_193) ?v_267) ?v_353))) (and (or (or (or (or (or (or ?v_18 ?v_47) ?v_88) ?v_141) ?v_206) ?v_283) ?v_372) (or (or (or (or (or (or ?v_18 ?v_46) ?v_86) ?v_138) ?v_202) ?v_278) ?v_366))) (and (or (or (or (or (or (or ?v_19 ?v_50) ?v_93) ?v_148) ?v_215) ?v_294) ?v_385) (or (or (or (or (or (or ?v_19 ?v_49) ?v_91) ?v_145) ?v_211) ?v_289) ?v_379))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_20 ?v_22) ?v_55) ?v_100) ?v_157) ?v_226) ?v_307) (or (or (or (or (or (or ?v_21 ?v_22) ?v_53) ?v_97) ?v_153) ?v_221) ?v_301)) (and (or (or (or (or (or (or ?v_23 ?v_31) ?v_65) ?v_111) ?v_169) ?v_239) ?v_321) (or (or (or (or (or (or ?v_30 ?v_31) ?v_58) ?v_104) ?v_162) ?v_232) ?v_314))) (and (or (or (or (or (or (or ?v_37 ?v_39) ?v_74) ?v_121) ?v_180) ?v_251) ?v_334) (or (or (or (or (or (or ?v_38 ?v_39) ?v_72) ?v_118) ?v_176) ?v_246) ?v_328))) (and (or (or (or (or (or (or ?v_40 ?v_42) ?v_79) ?v_128) ?v_189) ?v_262) ?v_347) (or (or (or (or (or (or ?v_41 ?v_42) ?v_77) ?v_125) ?v_185) ?v_257) ?v_341))) (and (or (or (or (or (or (or ?v_43 ?v_45) ?v_84) ?v_135) ?v_198) ?v_273) ?v_360) (or (or (or (or (or (or ?v_44 ?v_45) ?v_82) ?v_132) ?v_194) ?v_268) ?v_354))) (and (or (or (or (or (or (or ?v_46 ?v_48) ?v_89) ?v_142) ?v_207) ?v_284) ?v_373) (or (or (or (or (or (or ?v_47 ?v_48) ?v_87) ?v_139) ?v_203) ?v_279) ?v_367))) (and (or (or (or (or (or (or ?v_49 ?v_51) ?v_94) ?v_149) ?v_216) ?v_295) ?v_386) (or (or (or (or (or (or ?v_50 ?v_51) ?v_92) ?v_146) ?v_212) ?v_290) ?v_380)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_52 ?v_53) ?v_56) ?v_101) ?v_158) ?v_227) ?v_308) (or (or (or (or (or (or ?v_54 ?v_55) ?v_56) ?v_98) ?v_154) ?v_222) ?v_302)) (and (or (or (or (or (or (or ?v_57 ?v_58) ?v_66) ?v_112) ?v_170) ?v_240) ?v_322) (or (or (or (or (or (or ?v_64 ?v_65) ?v_66) ?v_105) ?v_163) ?v_233) ?v_315))) (and (or (or (or (or (or (or ?v_71 ?v_72) ?v_75) ?v_122) ?v_181) ?v_252) ?v_335) (or (or (or (or (or (or ?v_73 ?v_74) ?v_75) ?v_119) ?v_177) ?v_247) ?v_329))) (and (or (or (or (or (or (or ?v_76 ?v_77) ?v_80) ?v_129) ?v_190) ?v_263) ?v_348) (or (or (or (or (or (or ?v_78 ?v_79) ?v_80) ?v_126) ?v_186) ?v_258) ?v_342))) (and (or (or (or (or (or (or ?v_81 ?v_82) ?v_85) ?v_136) ?v_199) ?v_274) ?v_361) (or (or (or (or (or (or ?v_83 ?v_84) ?v_85) ?v_133) ?v_195) ?v_269) ?v_355))) (and (or (or (or (or (or (or ?v_86 ?v_87) ?v_90) ?v_143) ?v_208) ?v_285) ?v_374) (or (or (or (or (or (or ?v_88 ?v_89) ?v_90) ?v_140) ?v_204) ?v_280) ?v_368))) (and (or (or (or (or (or (or ?v_91 ?v_92) ?v_95) ?v_150) ?v_217) ?v_296) ?v_387) (or (or (or (or (or (or ?v_93 ?v_94) ?v_95) ?v_147) ?v_213) ?v_291) ?v_381)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_96 ?v_97) ?v_98) ?v_102) ?v_159) ?v_228) ?v_309) (or (or (or (or (or (or ?v_99 ?v_100) ?v_101) ?v_102) ?v_155) ?v_223) ?v_303)) (and (or (or (or (or (or (or ?v_103 ?v_104) ?v_105) ?v_113) ?v_171) ?v_241) ?v_323) (or (or (or (or (or (or ?v_110 ?v_111) ?v_112) ?v_113) ?v_164) ?v_234) ?v_316))) (and (or (or (or (or (or (or ?v_117 ?v_118) ?v_119) ?v_123) ?v_182) ?v_253) ?v_336) (or (or (or (or (or (or ?v_120 ?v_121) ?v_122) ?v_123) ?v_178) ?v_248) ?v_330))) (and (or (or (or (or (or (or ?v_124 ?v_125) ?v_126) ?v_130) ?v_191) ?v_264) ?v_349) (or (or (or (or (or (or ?v_127 ?v_128) ?v_129) ?v_130) ?v_187) ?v_259) ?v_343))) (and (or (or (or (or (or (or ?v_131 ?v_132) ?v_133) ?v_137) ?v_200) ?v_275) ?v_362) (or (or (or (or (or (or ?v_134 ?v_135) ?v_136) ?v_137) ?v_196) ?v_270) ?v_356))) (and (or (or (or (or (or (or ?v_138 ?v_139) ?v_140) ?v_144) ?v_209) ?v_286) ?v_375) (or (or (or (or (or (or ?v_141 ?v_142) ?v_143) ?v_144) ?v_205) ?v_281) ?v_369))) (and (or (or (or (or (or (or ?v_145 ?v_146) ?v_147) ?v_151) ?v_218) ?v_297) ?v_388) (or (or (or (or (or (or ?v_148 ?v_149) ?v_150) ?v_151) ?v_214) ?v_292) ?v_382)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_152 ?v_153) ?v_154) ?v_155) ?v_160) ?v_229) ?v_310) (or (or (or (or (or (or ?v_156 ?v_157) ?v_158) ?v_159) ?v_160) ?v_224) ?v_304)) (and (or (or (or (or (or (or ?v_161 ?v_162) ?v_163) ?v_164) ?v_172) ?v_242) ?v_324) (or (or (or (or (or (or ?v_168 ?v_169) ?v_170) ?v_171) ?v_172) ?v_235) ?v_317))) (and (or (or (or (or (or (or ?v_175 ?v_176) ?v_177) ?v_178) ?v_183) ?v_254) ?v_337) (or (or (or (or (or (or ?v_179 ?v_180) ?v_181) ?v_182) ?v_183) ?v_249) ?v_331))) (and (or (or (or (or (or (or ?v_184 ?v_185) ?v_186) ?v_187) ?v_192) ?v_265) ?v_350) (or (or (or (or (or (or ?v_188 ?v_189) ?v_190) ?v_191) ?v_192) ?v_260) ?v_344))) (and (or (or (or (or (or (or ?v_193 ?v_194) ?v_195) ?v_196) ?v_201) ?v_276) ?v_363) (or (or (or (or (or (or ?v_197 ?v_198) ?v_199) ?v_200) ?v_201) ?v_271) ?v_357))) (and (or (or (or (or (or (or ?v_202 ?v_203) ?v_204) ?v_205) ?v_210) ?v_287) ?v_376) (or (or (or (or (or (or ?v_206 ?v_207) ?v_208) ?v_209) ?v_210) ?v_282) ?v_370))) (and (or (or (or (or (or (or ?v_211 ?v_212) ?v_213) ?v_214) ?v_219) ?v_298) ?v_389) (or (or (or (or (or (or ?v_215 ?v_216) ?v_217) ?v_218) ?v_219) ?v_293) ?v_383)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_220 ?v_221) ?v_222) ?v_223) ?v_224) ?v_230) ?v_311) (or (or (or (or (or (or ?v_225 ?v_226) ?v_227) ?v_228) ?v_229) ?v_230) ?v_305)) (and (or (or (or (or (or (or ?v_231 ?v_232) ?v_233) ?v_234) ?v_235) ?v_243) ?v_325) (or (or (or (or (or (or ?v_238 ?v_239) ?v_240) ?v_241) ?v_242) ?v_243) ?v_318))) (and (or (or (or (or (or (or ?v_245 ?v_246) ?v_247) ?v_248) ?v_249) ?v_255) ?v_338) (or (or (or (or (or (or ?v_250 ?v_251) ?v_252) ?v_253) ?v_254) ?v_255) ?v_332))) (and (or (or (or (or (or (or ?v_256 ?v_257) ?v_258) ?v_259) ?v_260) ?v_266) ?v_351) (or (or (or (or (or (or ?v_261 ?v_262) ?v_263) ?v_264) ?v_265) ?v_266) ?v_345))) (and (or (or (or (or (or (or ?v_267 ?v_268) ?v_269) ?v_270) ?v_271) ?v_277) ?v_364) (or (or (or (or (or (or ?v_272 ?v_273) ?v_274) ?v_275) ?v_276) ?v_277) ?v_358))) (and (or (or (or (or (or (or ?v_278 ?v_279) ?v_280) ?v_281) ?v_282) ?v_288) ?v_377) (or (or (or (or (or (or ?v_283 ?v_284) ?v_285) ?v_286) ?v_287) ?v_288) ?v_371))) (and (or (or (or (or (or (or ?v_289 ?v_290) ?v_291) ?v_292) ?v_293) ?v_299) ?v_390) (or (or (or (or (or (or ?v_294 ?v_295) ?v_296) ?v_297) ?v_298) ?v_299) ?v_384)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_300 ?v_301) ?v_302) ?v_303) ?v_304) ?v_305) ?v_312) (or (or (or (or (or (or ?v_306 ?v_307) ?v_308) ?v_309) ?v_310) ?v_311) ?v_312)) (and (or (or (or (or (or (or ?v_313 ?v_314) ?v_315) ?v_316) ?v_317) ?v_318) ?v_326) (or (or (or (or (or (or ?v_320 ?v_321) ?v_322) ?v_323) ?v_324) ?v_325) ?v_326))) (and (or (or (or (or (or (or ?v_327 ?v_328) ?v_329) ?v_330) ?v_331) ?v_332) ?v_339) (or (or (or (or (or (or ?v_333 ?v_334) ?v_335) ?v_336) ?v_337) ?v_338) ?v_339))) (and (or (or (or (or (or (or ?v_340 ?v_341) ?v_342) ?v_343) ?v_344) ?v_345) ?v_352) (or (or (or (or (or (or ?v_346 ?v_347) ?v_348) ?v_349) ?v_350) ?v_351) ?v_352))) (and (or (or (or (or (or (or ?v_353 ?v_354) ?v_355) ?v_356) ?v_357) ?v_358) ?v_365) (or (or (or (or (or (or ?v_359 ?v_360) ?v_361) ?v_362) ?v_363) ?v_364) ?v_365))) (and (or (or (or (or (or (or ?v_366 ?v_367) ?v_368) ?v_369) ?v_370) ?v_371) ?v_378) (or (or (or (or (or (or ?v_372 ?v_373) ?v_374) ?v_375) ?v_376) ?v_377) ?v_378))) (and (or (or (or (or (or (or ?v_379 ?v_380) ?v_381) ?v_382) ?v_383) ?v_384) ?v_391) (or (or (or (or (or (or ?v_385 ?v_386) ?v_387) ?v_388) ?v_389) ?v_390) ?v_391)))))) :named EBtGYzVTOGramdAeE)) (assert(! (and (and (and (and (and (and (and (and (and (and (and (and (= (op (op (op e0 e0) e0) e0) e0) (= (op (op (op e0 e1) e1) e1) e0)) (= (op (op (op e0 e2) e2) e2) e0)) (= (op (op (op e0 e3) e3) e3) e0)) (= (op (op (op e0 e4) e4) e4) e0)) (= (op (op (op e0 e5) e5) e5) e0)) (= (op (op (op e0 e6) e6) e6) e0)) (and (and (and (and (and (and (= (op (op (op e1 e0) e0) e0) e1) (= (op (op (op e1 e1) e1) e1) e1)) (= (op (op (op e1 e2) e2) e2) e1)) (= (op (op (op e1 e3) e3) e3) e1)) (= (op (op (op e1 e4) e4) e4) e1)) (= (op (op (op e1 e5) e5) e5) e1)) (= (op (op (op e1 e6) e6) e6) e1))) (and (and (and (and (and (and (= (op (op (op e2 e0) e0) e0) e2) (= (op (op (op e2 e1) e1) e1) e2)) (= (op (op (op e2 e2) e2) e2) e2)) (= (op (op (op e2 e3) e3) e3) e2)) (= (op (op (op e2 e4) e4) e4) e2)) (= (op (op (op e2 e5) e5) e5) e2)) (= (op (op (op e2 e6) e6) e6) e2))) (and (and (and (and (and (and (= (op (op (op e3 e0) e0) e0) e3) (= (op (op (op e3 e1) e1) e1) e3)) (= (op (op (op e3 e2) e2) e2) e3)) (= (op (op (op e3 e3) e3) e3) e3)) (= (op (op (op e3 e4) e4) e4) e3)) (= (op (op (op e3 e5) e5) e5) e3)) (= (op (op (op e3 e6) e6) e6) e3))) (and (and (and (and (and (and (= (op (op (op e4 e0) e0) e0) e4) (= (op (op (op e4 e1) e1) e1) e4)) (= (op (op (op e4 e2) e2) e2) e4)) (= (op (op (op e4 e3) e3) e3) e4)) (= (op (op (op e4 e4) e4) e4) e4)) (= (op (op (op e4 e5) e5) e5) e4)) (= (op (op (op e4 e6) e6) e6) e4))) (and (and (and (and (and (and (= (op (op (op e5 e0) e0) e0) e5) (= (op (op (op e5 e1) e1) e1) e5)) (= (op (op (op e5 e2) e2) e2) e5)) (= (op (op (op e5 e3) e3) e3) e5)) (= (op (op (op e5 e4) e4) e4) e5)) (= (op (op (op e5 e5) e5) e5) e5)) (= (op (op (op e5 e6) e6) e6) e5))) (and (and (and (and (and (and (= (op (op (op e6 e0) e0) e0) e6) (= (op (op (op e6 e1) e1) e1) e6)) (= (op (op (op e6 e2) e2) e2) e6)) (= (op (op (op e6 e3) e3) e3) e6)) (= (op (op (op e6 e4) e4) e4) e6)) (= (op (op (op e6 e5) e5) e5) e6)) (= (op (op (op e6 e6) e6) e6) e6))) :named ioixWwpvtaEC)) (assert(! (and (and (and (and (and (and (not (= (op e0 e0) e0)) (not (= (op e1 e1) e1))) (not (= (op e2 e2) e2))) (not (= (op e3 e3) e3))) (not (= (op e4 e4) e4))) (not (= (op e5 e5) e5))) (not (= (op e6 e6) e6))) :named koUeyLLuLGCz)) (assert(! (let ((?v_0 (skc1 e0)) (?v_1 (skc1 e1)) (?v_2 (skc1 e2)) (?v_3 (skc1 e3)) (?v_4 (skc1 e4)) (?v_5 (skc1 e5)) (?v_6 (skc1 e6))) (and (and (and (and (and (and (and (= (op e0 ?v_0) ?v_0) (= (op e1 ?v_1) ?v_1)) (= (op e2 ?v_2) ?v_2)) (= (op e3 ?v_3) ?v_3)) (= (op e4 ?v_4) ?v_4)) (= (op e5 ?v_5) ?v_5)) (= (op e6 ?v_6) ?v_6)) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_0 e0) (= ?v_0 e1)) (= ?v_0 e2)) (= ?v_0 e3)) (= ?v_0 e4)) (= ?v_0 e5)) (= ?v_0 e6)) (or (or (or (or (or (or (= ?v_1 e0) (= ?v_1 e1)) (= ?v_1 e2)) (= ?v_1 e3)) (= ?v_1 e4)) (= ?v_1 e5)) (= ?v_1 e6))) (or (or (or (or (or (or (= ?v_2 e0) (= ?v_2 e1)) (= ?v_2 e2)) (= ?v_2 e3)) (= ?v_2 e4)) (= ?v_2 e5)) (= ?v_2 e6))) (or (or (or (or (or (or (= ?v_3 e0) (= ?v_3 e1)) (= ?v_3 e2)) (= ?v_3 e3)) (= ?v_3 e4)) (= ?v_3 e5)) (= ?v_3 e6))) (or (or (or (or (or (or (= ?v_4 e0) (= ?v_4 e1)) (= ?v_4 e2)) (= ?v_4 e3)) (= ?v_4 e4)) (= ?v_4 e5)) (= ?v_4 e6))) (or (or (or (or (or (or (= ?v_5 e0) (= ?v_5 e1)) (= ?v_5 e2)) (= ?v_5 e3)) (= ?v_5 e4)) (= ?v_5 e5)) (= ?v_5 e6))) (or (or (or (or (or (or (= ?v_6 e0) (= ?v_6 e1)) (= ?v_6 e2)) (= ?v_6 e3)) (= ?v_6 e4)) (= ?v_6 e5)) (= ?v_6 e6))))) :named RQzAFmfjYurAVQO)) (assert(! (and (and (and (= (op skc2 skc3) skc2) (= (op skc3 skc2) skc2)) (or (or (or (or (or (or (= skc2 e0) (= skc2 e1)) (= skc2 e2)) (= skc2 e3)) (= skc2 e4)) (= skc2 e5)) (= skc2 e6))) (or (or (or (or (or (or (= skc3 e0) (= skc3 e1)) (= skc3 e2)) (= skc3 e3)) (= skc3 e4)) (= skc3 e5)) (= skc3 e6))) :named qPwPmsghkmIAoprVYIK)) (assert(! (let ((?v_0 (op e0 e0)) (?v_7 (op e0 e1)) (?v_14 (op e0 e2)) (?v_21 (op e0 e3)) (?v_28 (op e0 e4)) (?v_35 (op e0 e5)) (?v_42 (op e0 e6)) (?v_1 (op e1 e0)) (?v_8 (op e1 e1)) (?v_15 (op e1 e2)) (?v_22 (op e1 e3)) (?v_29 (op e1 e4)) (?v_36 (op e1 e5)) (?v_43 (op e1 e6)) (?v_2 (op e2 e0)) (?v_9 (op e2 e1)) (?v_16 (op e2 e2)) (?v_23 (op e2 e3)) (?v_30 (op e2 e4)) (?v_37 (op e2 e5)) (?v_44 (op e2 e6)) (?v_3 (op e3 e0)) (?v_10 (op e3 e1)) (?v_17 (op e3 e2)) (?v_24 (op e3 e3)) (?v_31 (op e3 e4)) (?v_38 (op e3 e5)) (?v_45 (op e3 e6)) (?v_4 (op e4 e0)) (?v_11 (op e4 e1)) (?v_18 (op e4 e2)) (?v_25 (op e4 e3)) (?v_32 (op e4 e4)) (?v_39 (op e4 e5)) (?v_46 (op e4 e6)) (?v_5 (op e5 e0)) (?v_12 (op e5 e1)) (?v_19 (op e5 e2)) (?v_26 (op e5 e3)) (?v_33 (op e5 e4)) (?v_40 (op e5 e5)) (?v_47 (op e5 e6)) (?v_6 (op e6 e0)) (?v_13 (op e6 e1)) (?v_20 (op e6 e2)) (?v_27 (op e6 e3)) (?v_34 (op e6 e4)) (?v_41 (op e6 e5)) (?v_48 (op e6 e6))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_1)) (not (= ?v_0 ?v_2))) (not (= ?v_0 ?v_3))) (not (= ?v_0 ?v_4))) (not (= ?v_0 ?v_5))) (not (= ?v_0 ?v_6))) (not (= ?v_1 ?v_2))) (not (= ?v_1 ?v_3))) (not (= ?v_1 ?v_4))) (not (= ?v_1 ?v_5))) (not (= ?v_1 ?v_6))) (not (= ?v_2 ?v_3))) (not (= ?v_2 ?v_4))) (not (= ?v_2 ?v_5))) (not (= ?v_2 ?v_6))) (not (= ?v_3 ?v_4))) (not (= ?v_3 ?v_5))) (not (= ?v_3 ?v_6))) (not (= ?v_4 ?v_5))) (not (= ?v_4 ?v_6))) (not (= ?v_5 ?v_6))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_7 ?v_8)) (not (= ?v_7 ?v_9))) (not (= ?v_7 ?v_10))) (not (= ?v_7 ?v_11))) (not (= ?v_7 ?v_12))) (not (= ?v_7 ?v_13))) (not (= ?v_8 ?v_9))) (not (= ?v_8 ?v_10))) (not (= ?v_8 ?v_11))) (not (= ?v_8 ?v_12))) (not (= ?v_8 ?v_13))) (not (= ?v_9 ?v_10))) (not (= ?v_9 ?v_11))) (not (= ?v_9 ?v_12))) (not (= ?v_9 ?v_13))) (not (= ?v_10 ?v_11))) (not (= ?v_10 ?v_12))) (not (= ?v_10 ?v_13))) (not (= ?v_11 ?v_12))) (not (= ?v_11 ?v_13))) (not (= ?v_12 ?v_13)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_14 ?v_15)) (not (= ?v_14 ?v_16))) (not (= ?v_14 ?v_17))) (not (= ?v_14 ?v_18))) (not (= ?v_14 ?v_19))) (not (= ?v_14 ?v_20))) (not (= ?v_15 ?v_16))) (not (= ?v_15 ?v_17))) (not (= ?v_15 ?v_18))) (not (= ?v_15 ?v_19))) (not (= ?v_15 ?v_20))) (not (= ?v_16 ?v_17))) (not (= ?v_16 ?v_18))) (not (= ?v_16 ?v_19))) (not (= ?v_16 ?v_20))) (not (= ?v_17 ?v_18))) (not (= ?v_17 ?v_19))) (not (= ?v_17 ?v_20))) (not (= ?v_18 ?v_19))) (not (= ?v_18 ?v_20))) (not (= ?v_19 ?v_20)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_21 ?v_22)) (not (= ?v_21 ?v_23))) (not (= ?v_21 ?v_24))) (not (= ?v_21 ?v_25))) (not (= ?v_21 ?v_26))) (not (= ?v_21 ?v_27))) (not (= ?v_22 ?v_23))) (not (= ?v_22 ?v_24))) (not (= ?v_22 ?v_25))) (not (= ?v_22 ?v_26))) (not (= ?v_22 ?v_27))) (not (= ?v_23 ?v_24))) (not (= ?v_23 ?v_25))) (not (= ?v_23 ?v_26))) (not (= ?v_23 ?v_27))) (not (= ?v_24 ?v_25))) (not (= ?v_24 ?v_26))) (not (= ?v_24 ?v_27))) (not (= ?v_25 ?v_26))) (not (= ?v_25 ?v_27))) (not (= ?v_26 ?v_27)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_28 ?v_29)) (not (= ?v_28 ?v_30))) (not (= ?v_28 ?v_31))) (not (= ?v_28 ?v_32))) (not (= ?v_28 ?v_33))) (not (= ?v_28 ?v_34))) (not (= ?v_29 ?v_30))) (not (= ?v_29 ?v_31))) (not (= ?v_29 ?v_32))) (not (= ?v_29 ?v_33))) (not (= ?v_29 ?v_34))) (not (= ?v_30 ?v_31))) (not (= ?v_30 ?v_32))) (not (= ?v_30 ?v_33))) (not (= ?v_30 ?v_34))) (not (= ?v_31 ?v_32))) (not (= ?v_31 ?v_33))) (not (= ?v_31 ?v_34))) (not (= ?v_32 ?v_33))) (not (= ?v_32 ?v_34))) (not (= ?v_33 ?v_34)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_35 ?v_36)) (not (= ?v_35 ?v_37))) (not (= ?v_35 ?v_38))) (not (= ?v_35 ?v_39))) (not (= ?v_35 ?v_40))) (not (= ?v_35 ?v_41))) (not (= ?v_36 ?v_37))) (not (= ?v_36 ?v_38))) (not (= ?v_36 ?v_39))) (not (= ?v_36 ?v_40))) (not (= ?v_36 ?v_41))) (not (= ?v_37 ?v_38))) (not (= ?v_37 ?v_39))) (not (= ?v_37 ?v_40))) (not (= ?v_37 ?v_41))) (not (= ?v_38 ?v_39))) (not (= ?v_38 ?v_40))) (not (= ?v_38 ?v_41))) (not (= ?v_39 ?v_40))) (not (= ?v_39 ?v_41))) (not (= ?v_40 ?v_41)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_42 ?v_43)) (not (= ?v_42 ?v_44))) (not (= ?v_42 ?v_45))) (not (= ?v_42 ?v_46))) (not (= ?v_42 ?v_47))) (not (= ?v_42 ?v_48))) (not (= ?v_43 ?v_44))) (not (= ?v_43 ?v_45))) (not (= ?v_43 ?v_46))) (not (= ?v_43 ?v_47))) (not (= ?v_43 ?v_48))) (not (= ?v_44 ?v_45))) (not (= ?v_44 ?v_46))) (not (= ?v_44 ?v_47))) (not (= ?v_44 ?v_48))) (not (= ?v_45 ?v_46))) (not (= ?v_45 ?v_47))) (not (= ?v_45 ?v_48))) (not (= ?v_46 ?v_47))) (not (= ?v_46 ?v_48))) (not (= ?v_47 ?v_48)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_7)) (not (= ?v_0 ?v_14))) (not (= ?v_0 ?v_21))) (not (= ?v_0 ?v_28))) (not (= ?v_0 ?v_35))) (not (= ?v_0 ?v_42))) (not (= ?v_7 ?v_14))) (not (= ?v_7 ?v_21))) (not (= ?v_7 ?v_28))) (not (= ?v_7 ?v_35))) (not (= ?v_7 ?v_42))) (not (= ?v_14 ?v_21))) (not (= ?v_14 ?v_28))) (not (= ?v_14 ?v_35))) (not (= ?v_14 ?v_42))) (not (= ?v_21 ?v_28))) (not (= ?v_21 ?v_35))) (not (= ?v_21 ?v_42))) (not (= ?v_28 ?v_35))) (not (= ?v_28 ?v_42))) (not (= ?v_35 ?v_42))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_1 ?v_8)) (not (= ?v_1 ?v_15))) (not (= ?v_1 ?v_22))) (not (= ?v_1 ?v_29))) (not (= ?v_1 ?v_36))) (not (= ?v_1 ?v_43))) (not (= ?v_8 ?v_15))) (not (= ?v_8 ?v_22))) (not (= ?v_8 ?v_29))) (not (= ?v_8 ?v_36))) (not (= ?v_8 ?v_43))) (not (= ?v_15 ?v_22))) (not (= ?v_15 ?v_29))) (not (= ?v_15 ?v_36))) (not (= ?v_15 ?v_43))) (not (= ?v_22 ?v_29))) (not (= ?v_22 ?v_36))) (not (= ?v_22 ?v_43))) (not (= ?v_29 ?v_36))) (not (= ?v_29 ?v_43))) (not (= ?v_36 ?v_43)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_2 ?v_9)) (not (= ?v_2 ?v_16))) (not (= ?v_2 ?v_23))) (not (= ?v_2 ?v_30))) (not (= ?v_2 ?v_37))) (not (= ?v_2 ?v_44))) (not (= ?v_9 ?v_16))) (not (= ?v_9 ?v_23))) (not (= ?v_9 ?v_30))) (not (= ?v_9 ?v_37))) (not (= ?v_9 ?v_44))) (not (= ?v_16 ?v_23))) (not (= ?v_16 ?v_30))) (not (= ?v_16 ?v_37))) (not (= ?v_16 ?v_44))) (not (= ?v_23 ?v_30))) (not (= ?v_23 ?v_37))) (not (= ?v_23 ?v_44))) (not (= ?v_30 ?v_37))) (not (= ?v_30 ?v_44))) (not (= ?v_37 ?v_44)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_3 ?v_10)) (not (= ?v_3 ?v_17))) (not (= ?v_3 ?v_24))) (not (= ?v_3 ?v_31))) (not (= ?v_3 ?v_38))) (not (= ?v_3 ?v_45))) (not (= ?v_10 ?v_17))) (not (= ?v_10 ?v_24))) (not (= ?v_10 ?v_31))) (not (= ?v_10 ?v_38))) (not (= ?v_10 ?v_45))) (not (= ?v_17 ?v_24))) (not (= ?v_17 ?v_31))) (not (= ?v_17 ?v_38))) (not (= ?v_17 ?v_45))) (not (= ?v_24 ?v_31))) (not (= ?v_24 ?v_38))) (not (= ?v_24 ?v_45))) (not (= ?v_31 ?v_38))) (not (= ?v_31 ?v_45))) (not (= ?v_38 ?v_45)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_4 ?v_11)) (not (= ?v_4 ?v_18))) (not (= ?v_4 ?v_25))) (not (= ?v_4 ?v_32))) (not (= ?v_4 ?v_39))) (not (= ?v_4 ?v_46))) (not (= ?v_11 ?v_18))) (not (= ?v_11 ?v_25))) (not (= ?v_11 ?v_32))) (not (= ?v_11 ?v_39))) (not (= ?v_11 ?v_46))) (not (= ?v_18 ?v_25))) (not (= ?v_18 ?v_32))) (not (= ?v_18 ?v_39))) (not (= ?v_18 ?v_46))) (not (= ?v_25 ?v_32))) (not (= ?v_25 ?v_39))) (not (= ?v_25 ?v_46))) (not (= ?v_32 ?v_39))) (not (= ?v_32 ?v_46))) (not (= ?v_39 ?v_46)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_5 ?v_12)) (not (= ?v_5 ?v_19))) (not (= ?v_5 ?v_26))) (not (= ?v_5 ?v_33))) (not (= ?v_5 ?v_40))) (not (= ?v_5 ?v_47))) (not (= ?v_12 ?v_19))) (not (= ?v_12 ?v_26))) (not (= ?v_12 ?v_33))) (not (= ?v_12 ?v_40))) (not (= ?v_12 ?v_47))) (not (= ?v_19 ?v_26))) (not (= ?v_19 ?v_33))) (not (= ?v_19 ?v_40))) (not (= ?v_19 ?v_47))) (not (= ?v_26 ?v_33))) (not (= ?v_26 ?v_40))) (not (= ?v_26 ?v_47))) (not (= ?v_33 ?v_40))) (not (= ?v_33 ?v_47))) (not (= ?v_40 ?v_47)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_6 ?v_13)) (not (= ?v_6 ?v_20))) (not (= ?v_6 ?v_27))) (not (= ?v_6 ?v_34))) (not (= ?v_6 ?v_41))) (not (= ?v_6 ?v_48))) (not (= ?v_13 ?v_20))) (not (= ?v_13 ?v_27))) (not (= ?v_13 ?v_34))) (not (= ?v_13 ?v_41))) (not (= ?v_13 ?v_48))) (not (= ?v_20 ?v_27))) (not (= ?v_20 ?v_34))) (not (= ?v_20 ?v_41))) (not (= ?v_20 ?v_48))) (not (= ?v_27 ?v_34))) (not (= ?v_27 ?v_41))) (not (= ?v_27 ?v_48))) (not (= ?v_34 ?v_41))) (not (= ?v_34 ?v_48))) (not (= ?v_41 ?v_48)))))) :named jbxovCkiTkdQhRxuO)) (assert(! (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= e0 e1)) (not (= e0 e2))) (not (= e0 e3))) (not (= e0 e4))) (not (= e0 e5))) (not (= e0 e6))) (not (= e1 e2))) (not (= e1 e3))) (not (= e1 e4))) (not (= e1 e5))) (not (= e1 e6))) (not (= e2 e3))) (not (= e2 e4))) (not (= e2 e5))) (not (= e2 e6))) (not (= e3 e4))) (not (= e3 e5))) (not (= e3 e6))) (not (= e4 e5))) (not (= e4 e6))) (not (= e5 e6))) :named LkUluySFGcGIlT)) (assert(! (and (and (and (and (and (= e0 (op e3 e3)) (= e1 (op e0 e6))) (= e2 (op e0 e5))) (= e4 (op e5 e3))) (= e5 (op e1 e3))) (= e6 (op e0 e3))) :named PmWqevubyHT)) (assert(! (not (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= (op e0 e0) e3) (= (op e0 e1) e5)) (= (op e0 e2) e0)) (= (op e0 e3) e6)) (= (op e0 e4) e4)) (= (op e0 e5) e2)) (= (op e0 e6) e1)) (= (op e1 e0) e2)) (= (op e1 e1) e0)) (= (op e1 e2) e3)) (= (op e1 e3) e5)) (= (op e1 e4) e1)) (= (op e1 e5) e4)) (= (op e1 e6) e6)) (= (op e2 e0) e6)) (= (op e2 e1) e4)) (= (op e2 e2) e1)) (= (op e2 e3) e2)) (= (op e2 e4) e0)) (= (op e2 e5) e5)) (= (op e2 e6) e3)) (= (op e3 e0) e4)) (= (op e3 e1) e3)) (= (op e3 e2) e2)) (= (op e3 e3) e0)) (= (op e3 e4) e6)) (= (op e3 e5) e1)) (= (op e3 e6) e5)) (= (op e4 e0) e0)) (= (op e4 e1) e6)) (= (op e4 e2) e5)) (= (op e4 e3) e1)) (= (op e4 e4) e2)) (= (op e4 e5) e3)) (= (op e4 e6) e4)) (= (op e5 e0) e5)) (= (op e5 e1) e1)) (= (op e5 e2) e6)) (= (op e5 e3) e4)) (= (op e5 e4) e3)) (= (op e5 e5) e0)) (= (op e5 e6) e2)) (= (op e6 e0) e1)) (= (op e6 e1) e2)) (= (op e6 e2) e4)) (= (op e6 e3) e3)) (= (op e6 e4) e5)) (= (op e6 e5) e6)) (= (op e6 e6) e0))) :named RqLGTXHgpY)) (check-sat) opensmt-2.5.2/regression/lookahead/iso_brn_sk004_eufexps.smt2.expected.err000066400000000000000000000000001445011647600266230ustar00rootroot00000000000000opensmt-2.5.2/regression/lookahead/iso_brn_sk004_eufexps.smt2.expected.out000066400000000000000000000000061445011647600266500ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/lookahead/iso_brn_sk005_eufexps.smt2000066400000000000000000001217361445011647600242610ustar00rootroot00000000000000(set-option :pure-lookahead true) (set-logic QF_UF) (set-info :source | http://www.cs.bham.ac.uk/~vxs/quasigroups/benchmark/ |) (set-info :smt-lib-version 2.0) (set-info :category "crafted") (set-info :status unsat) (declare-sort U 0) (declare-sort I 0) (declare-fun op1 (I I) I) (declare-fun op (I I) I) (declare-fun e6 () I) (declare-fun e5 () I) (declare-fun e4 () I) (declare-fun e3 () I) (declare-fun e2 () I) (declare-fun e1 () I) (declare-fun e0 () I) (declare-fun skc1 (I) I) (assert(! (let ((?v_0 (op e0 e0)) (?v_1 (op e0 e1)) (?v_2 (op e0 e2)) (?v_3 (op e0 e3)) (?v_4 (op e0 e4)) (?v_5 (op e0 e5)) (?v_6 (op e0 e6)) (?v_7 (op e1 e0)) (?v_8 (op e1 e1)) (?v_9 (op e1 e2)) (?v_10 (op e1 e3)) (?v_11 (op e1 e4)) (?v_12 (op e1 e5)) (?v_13 (op e1 e6)) (?v_14 (op e2 e0)) (?v_15 (op e2 e1)) (?v_16 (op e2 e2)) (?v_17 (op e2 e3)) (?v_18 (op e2 e4)) (?v_19 (op e2 e5)) (?v_20 (op e2 e6)) (?v_21 (op e3 e0)) (?v_22 (op e3 e1)) (?v_23 (op e3 e2)) (?v_24 (op e3 e3)) (?v_25 (op e3 e4)) (?v_26 (op e3 e5)) (?v_27 (op e3 e6)) (?v_28 (op e4 e0)) (?v_29 (op e4 e1)) (?v_30 (op e4 e2)) (?v_31 (op e4 e3)) (?v_32 (op e4 e4)) (?v_33 (op e4 e5)) (?v_34 (op e4 e6)) (?v_35 (op e5 e0)) (?v_36 (op e5 e1)) (?v_37 (op e5 e2)) (?v_38 (op e5 e3)) (?v_39 (op e5 e4)) (?v_40 (op e5 e5)) (?v_41 (op e5 e6)) (?v_42 (op e6 e0)) (?v_43 (op e6 e1)) (?v_44 (op e6 e2)) (?v_45 (op e6 e3)) (?v_46 (op e6 e4)) (?v_47 (op e6 e5)) (?v_48 (op e6 e6))) (and (and (and (and (and (and (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_0 e0) (= ?v_0 e1)) (= ?v_0 e2)) (= ?v_0 e3)) (= ?v_0 e4)) (= ?v_0 e5)) (= ?v_0 e6)) (or (or (or (or (or (or (= ?v_1 e0) (= ?v_1 e1)) (= ?v_1 e2)) (= ?v_1 e3)) (= ?v_1 e4)) (= ?v_1 e5)) (= ?v_1 e6))) (or (or (or (or (or (or (= ?v_2 e0) (= ?v_2 e1)) (= ?v_2 e2)) (= ?v_2 e3)) (= ?v_2 e4)) (= ?v_2 e5)) (= ?v_2 e6))) (or (or (or (or (or (or (= ?v_3 e0) (= ?v_3 e1)) (= ?v_3 e2)) (= ?v_3 e3)) (= ?v_3 e4)) (= ?v_3 e5)) (= ?v_3 e6))) (or (or (or (or (or (or (= ?v_4 e0) (= ?v_4 e1)) (= ?v_4 e2)) (= ?v_4 e3)) (= ?v_4 e4)) (= ?v_4 e5)) (= ?v_4 e6))) (or (or (or (or (or (or (= ?v_5 e0) (= ?v_5 e1)) (= ?v_5 e2)) (= ?v_5 e3)) (= ?v_5 e4)) (= ?v_5 e5)) (= ?v_5 e6))) (or (or (or (or (or (or (= ?v_6 e0) (= ?v_6 e1)) (= ?v_6 e2)) (= ?v_6 e3)) (= ?v_6 e4)) (= ?v_6 e5)) (= ?v_6 e6))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_7 e0) (= ?v_7 e1)) (= ?v_7 e2)) (= ?v_7 e3)) (= ?v_7 e4)) (= ?v_7 e5)) (= ?v_7 e6)) (or (or (or (or (or (or (= ?v_8 e0) (= ?v_8 e1)) (= ?v_8 e2)) (= ?v_8 e3)) (= ?v_8 e4)) (= ?v_8 e5)) (= ?v_8 e6))) (or (or (or (or (or (or (= ?v_9 e0) (= ?v_9 e1)) (= ?v_9 e2)) (= ?v_9 e3)) (= ?v_9 e4)) (= ?v_9 e5)) (= ?v_9 e6))) (or (or (or (or (or (or (= ?v_10 e0) (= ?v_10 e1)) (= ?v_10 e2)) (= ?v_10 e3)) (= ?v_10 e4)) (= ?v_10 e5)) (= ?v_10 e6))) (or (or (or (or (or (or (= ?v_11 e0) (= ?v_11 e1)) (= ?v_11 e2)) (= ?v_11 e3)) (= ?v_11 e4)) (= ?v_11 e5)) (= ?v_11 e6))) (or (or (or (or (or (or (= ?v_12 e0) (= ?v_12 e1)) (= ?v_12 e2)) (= ?v_12 e3)) (= ?v_12 e4)) (= ?v_12 e5)) (= ?v_12 e6))) (or (or (or (or (or (or (= ?v_13 e0) (= ?v_13 e1)) (= ?v_13 e2)) (= ?v_13 e3)) (= ?v_13 e4)) (= ?v_13 e5)) (= ?v_13 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_14 e0) (= ?v_14 e1)) (= ?v_14 e2)) (= ?v_14 e3)) (= ?v_14 e4)) (= ?v_14 e5)) (= ?v_14 e6)) (or (or (or (or (or (or (= ?v_15 e0) (= ?v_15 e1)) (= ?v_15 e2)) (= ?v_15 e3)) (= ?v_15 e4)) (= ?v_15 e5)) (= ?v_15 e6))) (or (or (or (or (or (or (= ?v_16 e0) (= ?v_16 e1)) (= ?v_16 e2)) (= ?v_16 e3)) (= ?v_16 e4)) (= ?v_16 e5)) (= ?v_16 e6))) (or (or (or (or (or (or (= ?v_17 e0) (= ?v_17 e1)) (= ?v_17 e2)) (= ?v_17 e3)) (= ?v_17 e4)) (= ?v_17 e5)) (= ?v_17 e6))) (or (or (or (or (or (or (= ?v_18 e0) (= ?v_18 e1)) (= ?v_18 e2)) (= ?v_18 e3)) (= ?v_18 e4)) (= ?v_18 e5)) (= ?v_18 e6))) (or (or (or (or (or (or (= ?v_19 e0) (= ?v_19 e1)) (= ?v_19 e2)) (= ?v_19 e3)) (= ?v_19 e4)) (= ?v_19 e5)) (= ?v_19 e6))) (or (or (or (or (or (or (= ?v_20 e0) (= ?v_20 e1)) (= ?v_20 e2)) (= ?v_20 e3)) (= ?v_20 e4)) (= ?v_20 e5)) (= ?v_20 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_21 e0) (= ?v_21 e1)) (= ?v_21 e2)) (= ?v_21 e3)) (= ?v_21 e4)) (= ?v_21 e5)) (= ?v_21 e6)) (or (or (or (or (or (or (= ?v_22 e0) (= ?v_22 e1)) (= ?v_22 e2)) (= ?v_22 e3)) (= ?v_22 e4)) (= ?v_22 e5)) (= ?v_22 e6))) (or (or (or (or (or (or (= ?v_23 e0) (= ?v_23 e1)) (= ?v_23 e2)) (= ?v_23 e3)) (= ?v_23 e4)) (= ?v_23 e5)) (= ?v_23 e6))) (or (or (or (or (or (or (= ?v_24 e0) (= ?v_24 e1)) (= ?v_24 e2)) (= ?v_24 e3)) (= ?v_24 e4)) (= ?v_24 e5)) (= ?v_24 e6))) (or (or (or (or (or (or (= ?v_25 e0) (= ?v_25 e1)) (= ?v_25 e2)) (= ?v_25 e3)) (= ?v_25 e4)) (= ?v_25 e5)) (= ?v_25 e6))) (or (or (or (or (or (or (= ?v_26 e0) (= ?v_26 e1)) (= ?v_26 e2)) (= ?v_26 e3)) (= ?v_26 e4)) (= ?v_26 e5)) (= ?v_26 e6))) (or (or (or (or (or (or (= ?v_27 e0) (= ?v_27 e1)) (= ?v_27 e2)) (= ?v_27 e3)) (= ?v_27 e4)) (= ?v_27 e5)) (= ?v_27 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_28 e0) (= ?v_28 e1)) (= ?v_28 e2)) (= ?v_28 e3)) (= ?v_28 e4)) (= ?v_28 e5)) (= ?v_28 e6)) (or (or (or (or (or (or (= ?v_29 e0) (= ?v_29 e1)) (= ?v_29 e2)) (= ?v_29 e3)) (= ?v_29 e4)) (= ?v_29 e5)) (= ?v_29 e6))) (or (or (or (or (or (or (= ?v_30 e0) (= ?v_30 e1)) (= ?v_30 e2)) (= ?v_30 e3)) (= ?v_30 e4)) (= ?v_30 e5)) (= ?v_30 e6))) (or (or (or (or (or (or (= ?v_31 e0) (= ?v_31 e1)) (= ?v_31 e2)) (= ?v_31 e3)) (= ?v_31 e4)) (= ?v_31 e5)) (= ?v_31 e6))) (or (or (or (or (or (or (= ?v_32 e0) (= ?v_32 e1)) (= ?v_32 e2)) (= ?v_32 e3)) (= ?v_32 e4)) (= ?v_32 e5)) (= ?v_32 e6))) (or (or (or (or (or (or (= ?v_33 e0) (= ?v_33 e1)) (= ?v_33 e2)) (= ?v_33 e3)) (= ?v_33 e4)) (= ?v_33 e5)) (= ?v_33 e6))) (or (or (or (or (or (or (= ?v_34 e0) (= ?v_34 e1)) (= ?v_34 e2)) (= ?v_34 e3)) (= ?v_34 e4)) (= ?v_34 e5)) (= ?v_34 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_35 e0) (= ?v_35 e1)) (= ?v_35 e2)) (= ?v_35 e3)) (= ?v_35 e4)) (= ?v_35 e5)) (= ?v_35 e6)) (or (or (or (or (or (or (= ?v_36 e0) (= ?v_36 e1)) (= ?v_36 e2)) (= ?v_36 e3)) (= ?v_36 e4)) (= ?v_36 e5)) (= ?v_36 e6))) (or (or (or (or (or (or (= ?v_37 e0) (= ?v_37 e1)) (= ?v_37 e2)) (= ?v_37 e3)) (= ?v_37 e4)) (= ?v_37 e5)) (= ?v_37 e6))) (or (or (or (or (or (or (= ?v_38 e0) (= ?v_38 e1)) (= ?v_38 e2)) (= ?v_38 e3)) (= ?v_38 e4)) (= ?v_38 e5)) (= ?v_38 e6))) (or (or (or (or (or (or (= ?v_39 e0) (= ?v_39 e1)) (= ?v_39 e2)) (= ?v_39 e3)) (= ?v_39 e4)) (= ?v_39 e5)) (= ?v_39 e6))) (or (or (or (or (or (or (= ?v_40 e0) (= ?v_40 e1)) (= ?v_40 e2)) (= ?v_40 e3)) (= ?v_40 e4)) (= ?v_40 e5)) (= ?v_40 e6))) (or (or (or (or (or (or (= ?v_41 e0) (= ?v_41 e1)) (= ?v_41 e2)) (= ?v_41 e3)) (= ?v_41 e4)) (= ?v_41 e5)) (= ?v_41 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_42 e0) (= ?v_42 e1)) (= ?v_42 e2)) (= ?v_42 e3)) (= ?v_42 e4)) (= ?v_42 e5)) (= ?v_42 e6)) (or (or (or (or (or (or (= ?v_43 e0) (= ?v_43 e1)) (= ?v_43 e2)) (= ?v_43 e3)) (= ?v_43 e4)) (= ?v_43 e5)) (= ?v_43 e6))) (or (or (or (or (or (or (= ?v_44 e0) (= ?v_44 e1)) (= ?v_44 e2)) (= ?v_44 e3)) (= ?v_44 e4)) (= ?v_44 e5)) (= ?v_44 e6))) (or (or (or (or (or (or (= ?v_45 e0) (= ?v_45 e1)) (= ?v_45 e2)) (= ?v_45 e3)) (= ?v_45 e4)) (= ?v_45 e5)) (= ?v_45 e6))) (or (or (or (or (or (or (= ?v_46 e0) (= ?v_46 e1)) (= ?v_46 e2)) (= ?v_46 e3)) (= ?v_46 e4)) (= ?v_46 e5)) (= ?v_46 e6))) (or (or (or (or (or (or (= ?v_47 e0) (= ?v_47 e1)) (= ?v_47 e2)) (= ?v_47 e3)) (= ?v_47 e4)) (= ?v_47 e5)) (= ?v_47 e6))) (or (or (or (or (or (or (= ?v_48 e0) (= ?v_48 e1)) (= ?v_48 e2)) (= ?v_48 e3)) (= ?v_48 e4)) (= ?v_48 e5)) (= ?v_48 e6))))) :named mebtLDBcwEeb)) (assert(! (let ((?v_1 (op e0 e0)) (?v_2 (op e0 e1)) (?v_3 (op e0 e2)) (?v_4 (op e0 e3)) (?v_5 (op e0 e4)) (?v_6 (op e0 e5)) (?v_7 (op e0 e6)) (?v_9 (op e1 e0)) (?v_24 (op e1 e1)) (?v_25 (op e1 e2)) (?v_26 (op e1 e3)) (?v_27 (op e1 e4)) (?v_28 (op e1 e5)) (?v_29 (op e1 e6)) (?v_10 (op e2 e0)) (?v_32 (op e2 e1)) (?v_59 (op e2 e2)) (?v_60 (op e2 e3)) (?v_61 (op e2 e4)) (?v_62 (op e2 e5)) (?v_63 (op e2 e6)) (?v_11 (op e3 e0)) (?v_33 (op e3 e1)) (?v_67 (op e3 e2)) (?v_106 (op e3 e3)) (?v_107 (op e3 e4)) (?v_108 (op e3 e5)) (?v_109 (op e3 e6)) (?v_12 (op e4 e0)) (?v_34 (op e4 e1)) (?v_68 (op e4 e2)) (?v_114 (op e4 e3)) (?v_165 (op e4 e4)) (?v_166 (op e4 e5)) (?v_167 (op e4 e6)) (?v_13 (op e5 e0)) (?v_35 (op e5 e1)) (?v_69 (op e5 e2)) (?v_115 (op e5 e3)) (?v_173 (op e5 e4)) (?v_236 (op e5 e5)) (?v_237 (op e5 e6)) (?v_14 (op e6 e0)) (?v_36 (op e6 e1)) (?v_70 (op e6 e2)) (?v_116 (op e6 e3)) (?v_174 (op e6 e4)) (?v_244 (op e6 e5)) (?v_319 (op e6 e6))) (let ((?v_0 (= ?v_1 e0)) (?v_8 (= ?v_1 e1)) (?v_15 (= ?v_1 e2)) (?v_16 (= ?v_1 e3)) (?v_17 (= ?v_1 e4)) (?v_18 (= ?v_1 e5)) (?v_19 (= ?v_1 e6)) (?v_21 (= ?v_2 e0)) (?v_30 (= ?v_2 e1)) (?v_38 (= ?v_2 e2)) (?v_41 (= ?v_2 e3)) (?v_44 (= ?v_2 e4)) (?v_47 (= ?v_2 e5)) (?v_50 (= ?v_2 e6)) (?v_54 (= ?v_3 e0)) (?v_64 (= ?v_3 e1)) (?v_73 (= ?v_3 e2)) (?v_78 (= ?v_3 e3)) (?v_83 (= ?v_3 e4)) (?v_88 (= ?v_3 e5)) (?v_93 (= ?v_3 e6)) (?v_99 (= ?v_4 e0)) (?v_110 (= ?v_4 e1)) (?v_120 (= ?v_4 e2)) (?v_127 (= ?v_4 e3)) (?v_134 (= ?v_4 e4)) (?v_141 (= ?v_4 e5)) (?v_148 (= ?v_4 e6)) (?v_156 (= ?v_5 e0)) (?v_168 (= ?v_5 e1)) (?v_179 (= ?v_5 e2)) (?v_188 (= ?v_5 e3)) (?v_197 (= ?v_5 e4)) (?v_206 (= ?v_5 e5)) (?v_215 (= ?v_5 e6)) (?v_225 (= ?v_6 e0)) (?v_238 (= ?v_6 e1)) (?v_250 (= ?v_6 e2)) (?v_261 (= ?v_6 e3)) (?v_272 (= ?v_6 e4)) (?v_283 (= ?v_6 e5)) (?v_294 (= ?v_6 e6)) (?v_306 (= ?v_7 e0)) (?v_320 (= ?v_7 e1)) (?v_333 (= ?v_7 e2)) (?v_346 (= ?v_7 e3)) (?v_359 (= ?v_7 e4)) (?v_372 (= ?v_7 e5)) (?v_385 (= ?v_7 e6)) (?v_20 (= ?v_9 e0)) (?v_23 (= ?v_9 e1)) (?v_37 (= ?v_9 e2)) (?v_40 (= ?v_9 e3)) (?v_43 (= ?v_9 e4)) (?v_46 (= ?v_9 e5)) (?v_49 (= ?v_9 e6)) (?v_22 (= ?v_24 e0)) (?v_31 (= ?v_24 e1)) (?v_39 (= ?v_24 e2)) (?v_42 (= ?v_24 e3)) (?v_45 (= ?v_24 e4)) (?v_48 (= ?v_24 e5)) (?v_51 (= ?v_24 e6)) (?v_55 (= ?v_25 e0)) (?v_65 (= ?v_25 e1)) (?v_74 (= ?v_25 e2)) (?v_79 (= ?v_25 e3)) (?v_84 (= ?v_25 e4)) (?v_89 (= ?v_25 e5)) (?v_94 (= ?v_25 e6)) (?v_100 (= ?v_26 e0)) (?v_111 (= ?v_26 e1)) (?v_121 (= ?v_26 e2)) (?v_128 (= ?v_26 e3)) (?v_135 (= ?v_26 e4)) (?v_142 (= ?v_26 e5)) (?v_149 (= ?v_26 e6)) (?v_157 (= ?v_27 e0)) (?v_169 (= ?v_27 e1)) (?v_180 (= ?v_27 e2)) (?v_189 (= ?v_27 e3)) (?v_198 (= ?v_27 e4)) (?v_207 (= ?v_27 e5)) (?v_216 (= ?v_27 e6)) (?v_226 (= ?v_28 e0)) (?v_239 (= ?v_28 e1)) (?v_251 (= ?v_28 e2)) (?v_262 (= ?v_28 e3)) (?v_273 (= ?v_28 e4)) (?v_284 (= ?v_28 e5)) (?v_295 (= ?v_28 e6)) (?v_307 (= ?v_29 e0)) (?v_321 (= ?v_29 e1)) (?v_334 (= ?v_29 e2)) (?v_347 (= ?v_29 e3)) (?v_360 (= ?v_29 e4)) (?v_373 (= ?v_29 e5)) (?v_386 (= ?v_29 e6)) (?v_52 (= ?v_10 e0)) (?v_57 (= ?v_10 e1)) (?v_71 (= ?v_10 e2)) (?v_76 (= ?v_10 e3)) (?v_81 (= ?v_10 e4)) (?v_86 (= ?v_10 e5)) (?v_91 (= ?v_10 e6)) (?v_53 (= ?v_32 e0)) (?v_58 (= ?v_32 e1)) (?v_72 (= ?v_32 e2)) (?v_77 (= ?v_32 e3)) (?v_82 (= ?v_32 e4)) (?v_87 (= ?v_32 e5)) (?v_92 (= ?v_32 e6)) (?v_56 (= ?v_59 e0)) (?v_66 (= ?v_59 e1)) (?v_75 (= ?v_59 e2)) (?v_80 (= ?v_59 e3)) (?v_85 (= ?v_59 e4)) (?v_90 (= ?v_59 e5)) (?v_95 (= ?v_59 e6)) (?v_101 (= ?v_60 e0)) (?v_112 (= ?v_60 e1)) (?v_122 (= ?v_60 e2)) (?v_129 (= ?v_60 e3)) (?v_136 (= ?v_60 e4)) (?v_143 (= ?v_60 e5)) (?v_150 (= ?v_60 e6)) (?v_158 (= ?v_61 e0)) (?v_170 (= ?v_61 e1)) (?v_181 (= ?v_61 e2)) (?v_190 (= ?v_61 e3)) (?v_199 (= ?v_61 e4)) (?v_208 (= ?v_61 e5)) (?v_217 (= ?v_61 e6)) (?v_227 (= ?v_62 e0)) (?v_240 (= ?v_62 e1)) (?v_252 (= ?v_62 e2)) (?v_263 (= ?v_62 e3)) (?v_274 (= ?v_62 e4)) (?v_285 (= ?v_62 e5)) (?v_296 (= ?v_62 e6)) (?v_308 (= ?v_63 e0)) (?v_322 (= ?v_63 e1)) (?v_335 (= ?v_63 e2)) (?v_348 (= ?v_63 e3)) (?v_361 (= ?v_63 e4)) (?v_374 (= ?v_63 e5)) (?v_387 (= ?v_63 e6)) (?v_96 (= ?v_11 e0)) (?v_103 (= ?v_11 e1)) (?v_117 (= ?v_11 e2)) (?v_124 (= ?v_11 e3)) (?v_131 (= ?v_11 e4)) (?v_138 (= ?v_11 e5)) (?v_145 (= ?v_11 e6)) (?v_97 (= ?v_33 e0)) (?v_104 (= ?v_33 e1)) (?v_118 (= ?v_33 e2)) (?v_125 (= ?v_33 e3)) (?v_132 (= ?v_33 e4)) (?v_139 (= ?v_33 e5)) (?v_146 (= ?v_33 e6)) (?v_98 (= ?v_67 e0)) (?v_105 (= ?v_67 e1)) (?v_119 (= ?v_67 e2)) (?v_126 (= ?v_67 e3)) (?v_133 (= ?v_67 e4)) (?v_140 (= ?v_67 e5)) (?v_147 (= ?v_67 e6)) (?v_102 (= ?v_106 e0)) (?v_113 (= ?v_106 e1)) (?v_123 (= ?v_106 e2)) (?v_130 (= ?v_106 e3)) (?v_137 (= ?v_106 e4)) (?v_144 (= ?v_106 e5)) (?v_151 (= ?v_106 e6)) (?v_159 (= ?v_107 e0)) (?v_171 (= ?v_107 e1)) (?v_182 (= ?v_107 e2)) (?v_191 (= ?v_107 e3)) (?v_200 (= ?v_107 e4)) (?v_209 (= ?v_107 e5)) (?v_218 (= ?v_107 e6)) (?v_228 (= ?v_108 e0)) (?v_241 (= ?v_108 e1)) (?v_253 (= ?v_108 e2)) (?v_264 (= ?v_108 e3)) (?v_275 (= ?v_108 e4)) (?v_286 (= ?v_108 e5)) (?v_297 (= ?v_108 e6)) (?v_309 (= ?v_109 e0)) (?v_323 (= ?v_109 e1)) (?v_336 (= ?v_109 e2)) (?v_349 (= ?v_109 e3)) (?v_362 (= ?v_109 e4)) (?v_375 (= ?v_109 e5)) (?v_388 (= ?v_109 e6)) (?v_152 (= ?v_12 e0)) (?v_161 (= ?v_12 e1)) (?v_175 (= ?v_12 e2)) (?v_184 (= ?v_12 e3)) (?v_193 (= ?v_12 e4)) (?v_202 (= ?v_12 e5)) (?v_211 (= ?v_12 e6)) (?v_153 (= ?v_34 e0)) (?v_162 (= ?v_34 e1)) (?v_176 (= ?v_34 e2)) (?v_185 (= ?v_34 e3)) (?v_194 (= ?v_34 e4)) (?v_203 (= ?v_34 e5)) (?v_212 (= ?v_34 e6)) (?v_154 (= ?v_68 e0)) (?v_163 (= ?v_68 e1)) (?v_177 (= ?v_68 e2)) (?v_186 (= ?v_68 e3)) (?v_195 (= ?v_68 e4)) (?v_204 (= ?v_68 e5)) (?v_213 (= ?v_68 e6)) (?v_155 (= ?v_114 e0)) (?v_164 (= ?v_114 e1)) (?v_178 (= ?v_114 e2)) (?v_187 (= ?v_114 e3)) (?v_196 (= ?v_114 e4)) (?v_205 (= ?v_114 e5)) (?v_214 (= ?v_114 e6)) (?v_160 (= ?v_165 e0)) (?v_172 (= ?v_165 e1)) (?v_183 (= ?v_165 e2)) (?v_192 (= ?v_165 e3)) (?v_201 (= ?v_165 e4)) (?v_210 (= ?v_165 e5)) (?v_219 (= ?v_165 e6)) (?v_229 (= ?v_166 e0)) (?v_242 (= ?v_166 e1)) (?v_254 (= ?v_166 e2)) (?v_265 (= ?v_166 e3)) (?v_276 (= ?v_166 e4)) (?v_287 (= ?v_166 e5)) (?v_298 (= ?v_166 e6)) (?v_310 (= ?v_167 e0)) (?v_324 (= ?v_167 e1)) (?v_337 (= ?v_167 e2)) (?v_350 (= ?v_167 e3)) (?v_363 (= ?v_167 e4)) (?v_376 (= ?v_167 e5)) (?v_389 (= ?v_167 e6)) (?v_220 (= ?v_13 e0)) (?v_231 (= ?v_13 e1)) (?v_245 (= ?v_13 e2)) (?v_256 (= ?v_13 e3)) (?v_267 (= ?v_13 e4)) (?v_278 (= ?v_13 e5)) (?v_289 (= ?v_13 e6)) (?v_221 (= ?v_35 e0)) (?v_232 (= ?v_35 e1)) (?v_246 (= ?v_35 e2)) (?v_257 (= ?v_35 e3)) (?v_268 (= ?v_35 e4)) (?v_279 (= ?v_35 e5)) (?v_290 (= ?v_35 e6)) (?v_222 (= ?v_69 e0)) (?v_233 (= ?v_69 e1)) (?v_247 (= ?v_69 e2)) (?v_258 (= ?v_69 e3)) (?v_269 (= ?v_69 e4)) (?v_280 (= ?v_69 e5)) (?v_291 (= ?v_69 e6)) (?v_223 (= ?v_115 e0)) (?v_234 (= ?v_115 e1)) (?v_248 (= ?v_115 e2)) (?v_259 (= ?v_115 e3)) (?v_270 (= ?v_115 e4)) (?v_281 (= ?v_115 e5)) (?v_292 (= ?v_115 e6)) (?v_224 (= ?v_173 e0)) (?v_235 (= ?v_173 e1)) (?v_249 (= ?v_173 e2)) (?v_260 (= ?v_173 e3)) (?v_271 (= ?v_173 e4)) (?v_282 (= ?v_173 e5)) (?v_293 (= ?v_173 e6)) (?v_230 (= ?v_236 e0)) (?v_243 (= ?v_236 e1)) (?v_255 (= ?v_236 e2)) (?v_266 (= ?v_236 e3)) (?v_277 (= ?v_236 e4)) (?v_288 (= ?v_236 e5)) (?v_299 (= ?v_236 e6)) (?v_311 (= ?v_237 e0)) (?v_325 (= ?v_237 e1)) (?v_338 (= ?v_237 e2)) (?v_351 (= ?v_237 e3)) (?v_364 (= ?v_237 e4)) (?v_377 (= ?v_237 e5)) (?v_390 (= ?v_237 e6)) (?v_300 (= ?v_14 e0)) (?v_313 (= ?v_14 e1)) (?v_327 (= ?v_14 e2)) (?v_340 (= ?v_14 e3)) (?v_353 (= ?v_14 e4)) (?v_366 (= ?v_14 e5)) (?v_379 (= ?v_14 e6)) (?v_301 (= ?v_36 e0)) (?v_314 (= ?v_36 e1)) (?v_328 (= ?v_36 e2)) (?v_341 (= ?v_36 e3)) (?v_354 (= ?v_36 e4)) (?v_367 (= ?v_36 e5)) (?v_380 (= ?v_36 e6)) (?v_302 (= ?v_70 e0)) (?v_315 (= ?v_70 e1)) (?v_329 (= ?v_70 e2)) (?v_342 (= ?v_70 e3)) (?v_355 (= ?v_70 e4)) (?v_368 (= ?v_70 e5)) (?v_381 (= ?v_70 e6)) (?v_303 (= ?v_116 e0)) (?v_316 (= ?v_116 e1)) (?v_330 (= ?v_116 e2)) (?v_343 (= ?v_116 e3)) (?v_356 (= ?v_116 e4)) (?v_369 (= ?v_116 e5)) (?v_382 (= ?v_116 e6)) (?v_304 (= ?v_174 e0)) (?v_317 (= ?v_174 e1)) (?v_331 (= ?v_174 e2)) (?v_344 (= ?v_174 e3)) (?v_357 (= ?v_174 e4)) (?v_370 (= ?v_174 e5)) (?v_383 (= ?v_174 e6)) (?v_305 (= ?v_244 e0)) (?v_318 (= ?v_244 e1)) (?v_332 (= ?v_244 e2)) (?v_345 (= ?v_244 e3)) (?v_358 (= ?v_244 e4)) (?v_371 (= ?v_244 e5)) (?v_384 (= ?v_244 e6)) (?v_312 (= ?v_319 e0)) (?v_326 (= ?v_319 e1)) (?v_339 (= ?v_319 e2)) (?v_352 (= ?v_319 e3)) (?v_365 (= ?v_319 e4)) (?v_378 (= ?v_319 e5)) (?v_391 (= ?v_319 e6))) (and (and (and (and (and (and (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_0 ?v_21) ?v_54) ?v_99) ?v_156) ?v_225) ?v_306) (or (or (or (or (or (or ?v_0 ?v_20) ?v_52) ?v_96) ?v_152) ?v_220) ?v_300)) (and (or (or (or (or (or (or ?v_8 ?v_30) ?v_64) ?v_110) ?v_168) ?v_238) ?v_320) (or (or (or (or (or (or ?v_8 ?v_23) ?v_57) ?v_103) ?v_161) ?v_231) ?v_313))) (and (or (or (or (or (or (or ?v_15 ?v_38) ?v_73) ?v_120) ?v_179) ?v_250) ?v_333) (or (or (or (or (or (or ?v_15 ?v_37) ?v_71) ?v_117) ?v_175) ?v_245) ?v_327))) (and (or (or (or (or (or (or ?v_16 ?v_41) ?v_78) ?v_127) ?v_188) ?v_261) ?v_346) (or (or (or (or (or (or ?v_16 ?v_40) ?v_76) ?v_124) ?v_184) ?v_256) ?v_340))) (and (or (or (or (or (or (or ?v_17 ?v_44) ?v_83) ?v_134) ?v_197) ?v_272) ?v_359) (or (or (or (or (or (or ?v_17 ?v_43) ?v_81) ?v_131) ?v_193) ?v_267) ?v_353))) (and (or (or (or (or (or (or ?v_18 ?v_47) ?v_88) ?v_141) ?v_206) ?v_283) ?v_372) (or (or (or (or (or (or ?v_18 ?v_46) ?v_86) ?v_138) ?v_202) ?v_278) ?v_366))) (and (or (or (or (or (or (or ?v_19 ?v_50) ?v_93) ?v_148) ?v_215) ?v_294) ?v_385) (or (or (or (or (or (or ?v_19 ?v_49) ?v_91) ?v_145) ?v_211) ?v_289) ?v_379))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_20 ?v_22) ?v_55) ?v_100) ?v_157) ?v_226) ?v_307) (or (or (or (or (or (or ?v_21 ?v_22) ?v_53) ?v_97) ?v_153) ?v_221) ?v_301)) (and (or (or (or (or (or (or ?v_23 ?v_31) ?v_65) ?v_111) ?v_169) ?v_239) ?v_321) (or (or (or (or (or (or ?v_30 ?v_31) ?v_58) ?v_104) ?v_162) ?v_232) ?v_314))) (and (or (or (or (or (or (or ?v_37 ?v_39) ?v_74) ?v_121) ?v_180) ?v_251) ?v_334) (or (or (or (or (or (or ?v_38 ?v_39) ?v_72) ?v_118) ?v_176) ?v_246) ?v_328))) (and (or (or (or (or (or (or ?v_40 ?v_42) ?v_79) ?v_128) ?v_189) ?v_262) ?v_347) (or (or (or (or (or (or ?v_41 ?v_42) ?v_77) ?v_125) ?v_185) ?v_257) ?v_341))) (and (or (or (or (or (or (or ?v_43 ?v_45) ?v_84) ?v_135) ?v_198) ?v_273) ?v_360) (or (or (or (or (or (or ?v_44 ?v_45) ?v_82) ?v_132) ?v_194) ?v_268) ?v_354))) (and (or (or (or (or (or (or ?v_46 ?v_48) ?v_89) ?v_142) ?v_207) ?v_284) ?v_373) (or (or (or (or (or (or ?v_47 ?v_48) ?v_87) ?v_139) ?v_203) ?v_279) ?v_367))) (and (or (or (or (or (or (or ?v_49 ?v_51) ?v_94) ?v_149) ?v_216) ?v_295) ?v_386) (or (or (or (or (or (or ?v_50 ?v_51) ?v_92) ?v_146) ?v_212) ?v_290) ?v_380)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_52 ?v_53) ?v_56) ?v_101) ?v_158) ?v_227) ?v_308) (or (or (or (or (or (or ?v_54 ?v_55) ?v_56) ?v_98) ?v_154) ?v_222) ?v_302)) (and (or (or (or (or (or (or ?v_57 ?v_58) ?v_66) ?v_112) ?v_170) ?v_240) ?v_322) (or (or (or (or (or (or ?v_64 ?v_65) ?v_66) ?v_105) ?v_163) ?v_233) ?v_315))) (and (or (or (or (or (or (or ?v_71 ?v_72) ?v_75) ?v_122) ?v_181) ?v_252) ?v_335) (or (or (or (or (or (or ?v_73 ?v_74) ?v_75) ?v_119) ?v_177) ?v_247) ?v_329))) (and (or (or (or (or (or (or ?v_76 ?v_77) ?v_80) ?v_129) ?v_190) ?v_263) ?v_348) (or (or (or (or (or (or ?v_78 ?v_79) ?v_80) ?v_126) ?v_186) ?v_258) ?v_342))) (and (or (or (or (or (or (or ?v_81 ?v_82) ?v_85) ?v_136) ?v_199) ?v_274) ?v_361) (or (or (or (or (or (or ?v_83 ?v_84) ?v_85) ?v_133) ?v_195) ?v_269) ?v_355))) (and (or (or (or (or (or (or ?v_86 ?v_87) ?v_90) ?v_143) ?v_208) ?v_285) ?v_374) (or (or (or (or (or (or ?v_88 ?v_89) ?v_90) ?v_140) ?v_204) ?v_280) ?v_368))) (and (or (or (or (or (or (or ?v_91 ?v_92) ?v_95) ?v_150) ?v_217) ?v_296) ?v_387) (or (or (or (or (or (or ?v_93 ?v_94) ?v_95) ?v_147) ?v_213) ?v_291) ?v_381)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_96 ?v_97) ?v_98) ?v_102) ?v_159) ?v_228) ?v_309) (or (or (or (or (or (or ?v_99 ?v_100) ?v_101) ?v_102) ?v_155) ?v_223) ?v_303)) (and (or (or (or (or (or (or ?v_103 ?v_104) ?v_105) ?v_113) ?v_171) ?v_241) ?v_323) (or (or (or (or (or (or ?v_110 ?v_111) ?v_112) ?v_113) ?v_164) ?v_234) ?v_316))) (and (or (or (or (or (or (or ?v_117 ?v_118) ?v_119) ?v_123) ?v_182) ?v_253) ?v_336) (or (or (or (or (or (or ?v_120 ?v_121) ?v_122) ?v_123) ?v_178) ?v_248) ?v_330))) (and (or (or (or (or (or (or ?v_124 ?v_125) ?v_126) ?v_130) ?v_191) ?v_264) ?v_349) (or (or (or (or (or (or ?v_127 ?v_128) ?v_129) ?v_130) ?v_187) ?v_259) ?v_343))) (and (or (or (or (or (or (or ?v_131 ?v_132) ?v_133) ?v_137) ?v_200) ?v_275) ?v_362) (or (or (or (or (or (or ?v_134 ?v_135) ?v_136) ?v_137) ?v_196) ?v_270) ?v_356))) (and (or (or (or (or (or (or ?v_138 ?v_139) ?v_140) ?v_144) ?v_209) ?v_286) ?v_375) (or (or (or (or (or (or ?v_141 ?v_142) ?v_143) ?v_144) ?v_205) ?v_281) ?v_369))) (and (or (or (or (or (or (or ?v_145 ?v_146) ?v_147) ?v_151) ?v_218) ?v_297) ?v_388) (or (or (or (or (or (or ?v_148 ?v_149) ?v_150) ?v_151) ?v_214) ?v_292) ?v_382)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_152 ?v_153) ?v_154) ?v_155) ?v_160) ?v_229) ?v_310) (or (or (or (or (or (or ?v_156 ?v_157) ?v_158) ?v_159) ?v_160) ?v_224) ?v_304)) (and (or (or (or (or (or (or ?v_161 ?v_162) ?v_163) ?v_164) ?v_172) ?v_242) ?v_324) (or (or (or (or (or (or ?v_168 ?v_169) ?v_170) ?v_171) ?v_172) ?v_235) ?v_317))) (and (or (or (or (or (or (or ?v_175 ?v_176) ?v_177) ?v_178) ?v_183) ?v_254) ?v_337) (or (or (or (or (or (or ?v_179 ?v_180) ?v_181) ?v_182) ?v_183) ?v_249) ?v_331))) (and (or (or (or (or (or (or ?v_184 ?v_185) ?v_186) ?v_187) ?v_192) ?v_265) ?v_350) (or (or (or (or (or (or ?v_188 ?v_189) ?v_190) ?v_191) ?v_192) ?v_260) ?v_344))) (and (or (or (or (or (or (or ?v_193 ?v_194) ?v_195) ?v_196) ?v_201) ?v_276) ?v_363) (or (or (or (or (or (or ?v_197 ?v_198) ?v_199) ?v_200) ?v_201) ?v_271) ?v_357))) (and (or (or (or (or (or (or ?v_202 ?v_203) ?v_204) ?v_205) ?v_210) ?v_287) ?v_376) (or (or (or (or (or (or ?v_206 ?v_207) ?v_208) ?v_209) ?v_210) ?v_282) ?v_370))) (and (or (or (or (or (or (or ?v_211 ?v_212) ?v_213) ?v_214) ?v_219) ?v_298) ?v_389) (or (or (or (or (or (or ?v_215 ?v_216) ?v_217) ?v_218) ?v_219) ?v_293) ?v_383)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_220 ?v_221) ?v_222) ?v_223) ?v_224) ?v_230) ?v_311) (or (or (or (or (or (or ?v_225 ?v_226) ?v_227) ?v_228) ?v_229) ?v_230) ?v_305)) (and (or (or (or (or (or (or ?v_231 ?v_232) ?v_233) ?v_234) ?v_235) ?v_243) ?v_325) (or (or (or (or (or (or ?v_238 ?v_239) ?v_240) ?v_241) ?v_242) ?v_243) ?v_318))) (and (or (or (or (or (or (or ?v_245 ?v_246) ?v_247) ?v_248) ?v_249) ?v_255) ?v_338) (or (or (or (or (or (or ?v_250 ?v_251) ?v_252) ?v_253) ?v_254) ?v_255) ?v_332))) (and (or (or (or (or (or (or ?v_256 ?v_257) ?v_258) ?v_259) ?v_260) ?v_266) ?v_351) (or (or (or (or (or (or ?v_261 ?v_262) ?v_263) ?v_264) ?v_265) ?v_266) ?v_345))) (and (or (or (or (or (or (or ?v_267 ?v_268) ?v_269) ?v_270) ?v_271) ?v_277) ?v_364) (or (or (or (or (or (or ?v_272 ?v_273) ?v_274) ?v_275) ?v_276) ?v_277) ?v_358))) (and (or (or (or (or (or (or ?v_278 ?v_279) ?v_280) ?v_281) ?v_282) ?v_288) ?v_377) (or (or (or (or (or (or ?v_283 ?v_284) ?v_285) ?v_286) ?v_287) ?v_288) ?v_371))) (and (or (or (or (or (or (or ?v_289 ?v_290) ?v_291) ?v_292) ?v_293) ?v_299) ?v_390) (or (or (or (or (or (or ?v_294 ?v_295) ?v_296) ?v_297) ?v_298) ?v_299) ?v_384)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_300 ?v_301) ?v_302) ?v_303) ?v_304) ?v_305) ?v_312) (or (or (or (or (or (or ?v_306 ?v_307) ?v_308) ?v_309) ?v_310) ?v_311) ?v_312)) (and (or (or (or (or (or (or ?v_313 ?v_314) ?v_315) ?v_316) ?v_317) ?v_318) ?v_326) (or (or (or (or (or (or ?v_320 ?v_321) ?v_322) ?v_323) ?v_324) ?v_325) ?v_326))) (and (or (or (or (or (or (or ?v_327 ?v_328) ?v_329) ?v_330) ?v_331) ?v_332) ?v_339) (or (or (or (or (or (or ?v_333 ?v_334) ?v_335) ?v_336) ?v_337) ?v_338) ?v_339))) (and (or (or (or (or (or (or ?v_340 ?v_341) ?v_342) ?v_343) ?v_344) ?v_345) ?v_352) (or (or (or (or (or (or ?v_346 ?v_347) ?v_348) ?v_349) ?v_350) ?v_351) ?v_352))) (and (or (or (or (or (or (or ?v_353 ?v_354) ?v_355) ?v_356) ?v_357) ?v_358) ?v_365) (or (or (or (or (or (or ?v_359 ?v_360) ?v_361) ?v_362) ?v_363) ?v_364) ?v_365))) (and (or (or (or (or (or (or ?v_366 ?v_367) ?v_368) ?v_369) ?v_370) ?v_371) ?v_378) (or (or (or (or (or (or ?v_372 ?v_373) ?v_374) ?v_375) ?v_376) ?v_377) ?v_378))) (and (or (or (or (or (or (or ?v_379 ?v_380) ?v_381) ?v_382) ?v_383) ?v_384) ?v_391) (or (or (or (or (or (or ?v_385 ?v_386) ?v_387) ?v_388) ?v_389) ?v_390) ?v_391)))))) :named dEPoQfurjVTsXMrT)) (assert(! (and (and (and (and (and (and (and (and (and (and (and (and (= (op (op (op e0 e0) e0) e0) e0) (= (op (op (op e0 e1) e1) e1) e0)) (= (op (op (op e0 e2) e2) e2) e0)) (= (op (op (op e0 e3) e3) e3) e0)) (= (op (op (op e0 e4) e4) e4) e0)) (= (op (op (op e0 e5) e5) e5) e0)) (= (op (op (op e0 e6) e6) e6) e0)) (and (and (and (and (and (and (= (op (op (op e1 e0) e0) e0) e1) (= (op (op (op e1 e1) e1) e1) e1)) (= (op (op (op e1 e2) e2) e2) e1)) (= (op (op (op e1 e3) e3) e3) e1)) (= (op (op (op e1 e4) e4) e4) e1)) (= (op (op (op e1 e5) e5) e5) e1)) (= (op (op (op e1 e6) e6) e6) e1))) (and (and (and (and (and (and (= (op (op (op e2 e0) e0) e0) e2) (= (op (op (op e2 e1) e1) e1) e2)) (= (op (op (op e2 e2) e2) e2) e2)) (= (op (op (op e2 e3) e3) e3) e2)) (= (op (op (op e2 e4) e4) e4) e2)) (= (op (op (op e2 e5) e5) e5) e2)) (= (op (op (op e2 e6) e6) e6) e2))) (and (and (and (and (and (and (= (op (op (op e3 e0) e0) e0) e3) (= (op (op (op e3 e1) e1) e1) e3)) (= (op (op (op e3 e2) e2) e2) e3)) (= (op (op (op e3 e3) e3) e3) e3)) (= (op (op (op e3 e4) e4) e4) e3)) (= (op (op (op e3 e5) e5) e5) e3)) (= (op (op (op e3 e6) e6) e6) e3))) (and (and (and (and (and (and (= (op (op (op e4 e0) e0) e0) e4) (= (op (op (op e4 e1) e1) e1) e4)) (= (op (op (op e4 e2) e2) e2) e4)) (= (op (op (op e4 e3) e3) e3) e4)) (= (op (op (op e4 e4) e4) e4) e4)) (= (op (op (op e4 e5) e5) e5) e4)) (= (op (op (op e4 e6) e6) e6) e4))) (and (and (and (and (and (and (= (op (op (op e5 e0) e0) e0) e5) (= (op (op (op e5 e1) e1) e1) e5)) (= (op (op (op e5 e2) e2) e2) e5)) (= (op (op (op e5 e3) e3) e3) e5)) (= (op (op (op e5 e4) e4) e4) e5)) (= (op (op (op e5 e5) e5) e5) e5)) (= (op (op (op e5 e6) e6) e6) e5))) (and (and (and (and (and (and (= (op (op (op e6 e0) e0) e0) e6) (= (op (op (op e6 e1) e1) e1) e6)) (= (op (op (op e6 e2) e2) e2) e6)) (= (op (op (op e6 e3) e3) e3) e6)) (= (op (op (op e6 e4) e4) e4) e6)) (= (op (op (op e6 e5) e5) e5) e6)) (= (op (op (op e6 e6) e6) e6) e6))) :named XFXyjtTmNk)) (assert(! (and (and (and (and (and (and (not (= (op e0 e0) e0)) (not (= (op e1 e1) e1))) (not (= (op e2 e2) e2))) (not (= (op e3 e3) e3))) (not (= (op e4 e4) e4))) (not (= (op e5 e5) e5))) (not (= (op e6 e6) e6))) :named ArZkcpQDMGMHRGo)) (assert(! (let ((?v_0 (skc1 e0)) (?v_1 (skc1 e1)) (?v_2 (skc1 e2)) (?v_3 (skc1 e3)) (?v_4 (skc1 e4)) (?v_5 (skc1 e5)) (?v_6 (skc1 e6))) (and (and (and (and (and (and (and (= (op e0 ?v_0) ?v_0) (= (op e1 ?v_1) ?v_1)) (= (op e2 ?v_2) ?v_2)) (= (op e3 ?v_3) ?v_3)) (= (op e4 ?v_4) ?v_4)) (= (op e5 ?v_5) ?v_5)) (= (op e6 ?v_6) ?v_6)) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_0 e0) (= ?v_0 e1)) (= ?v_0 e2)) (= ?v_0 e3)) (= ?v_0 e4)) (= ?v_0 e5)) (= ?v_0 e6)) (or (or (or (or (or (or (= ?v_1 e0) (= ?v_1 e1)) (= ?v_1 e2)) (= ?v_1 e3)) (= ?v_1 e4)) (= ?v_1 e5)) (= ?v_1 e6))) (or (or (or (or (or (or (= ?v_2 e0) (= ?v_2 e1)) (= ?v_2 e2)) (= ?v_2 e3)) (= ?v_2 e4)) (= ?v_2 e5)) (= ?v_2 e6))) (or (or (or (or (or (or (= ?v_3 e0) (= ?v_3 e1)) (= ?v_3 e2)) (= ?v_3 e3)) (= ?v_3 e4)) (= ?v_3 e5)) (= ?v_3 e6))) (or (or (or (or (or (or (= ?v_4 e0) (= ?v_4 e1)) (= ?v_4 e2)) (= ?v_4 e3)) (= ?v_4 e4)) (= ?v_4 e5)) (= ?v_4 e6))) (or (or (or (or (or (or (= ?v_5 e0) (= ?v_5 e1)) (= ?v_5 e2)) (= ?v_5 e3)) (= ?v_5 e4)) (= ?v_5 e5)) (= ?v_5 e6))) (or (or (or (or (or (or (= ?v_6 e0) (= ?v_6 e1)) (= ?v_6 e2)) (= ?v_6 e3)) (= ?v_6 e4)) (= ?v_6 e5)) (= ?v_6 e6))))) :named GrgZIoxhpyhmgsorI)) (assert(! (let ((?v_2 (op e0 e1)) (?v_5 (op e0 e2)) (?v_10 (op e0 e3)) (?v_17 (op e0 e4)) (?v_26 (op e0 e5)) (?v_37 (op e0 e6)) (?v_1 (op e1 e0)) (?v_7 (op e1 e2)) (?v_12 (op e1 e3)) (?v_19 (op e1 e4)) (?v_28 (op e1 e5)) (?v_39 (op e1 e6)) (?v_4 (op e2 e0)) (?v_6 (op e2 e1)) (?v_14 (op e2 e3)) (?v_21 (op e2 e4)) (?v_30 (op e2 e5)) (?v_41 (op e2 e6)) (?v_9 (op e3 e0)) (?v_11 (op e3 e1)) (?v_13 (op e3 e2)) (?v_23 (op e3 e4)) (?v_32 (op e3 e5)) (?v_43 (op e3 e6)) (?v_16 (op e4 e0)) (?v_18 (op e4 e1)) (?v_20 (op e4 e2)) (?v_22 (op e4 e3)) (?v_34 (op e4 e5)) (?v_45 (op e4 e6)) (?v_25 (op e5 e0)) (?v_27 (op e5 e1)) (?v_29 (op e5 e2)) (?v_31 (op e5 e3)) (?v_33 (op e5 e4)) (?v_47 (op e5 e6)) (?v_36 (op e6 e0)) (?v_38 (op e6 e1)) (?v_40 (op e6 e2)) (?v_42 (op e6 e3)) (?v_44 (op e6 e4)) (?v_46 (op e6 e5)) (?v_0 (not (= (op e0 e0) e0))) (?v_3 (not (= (op e1 e1) e1))) (?v_8 (not (= (op e2 e2) e2))) (?v_15 (not (= (op e3 e3) e3))) (?v_24 (not (= (op e4 e4) e4))) (?v_35 (not (= (op e5 e5) e5))) (?v_48 (not (= (op e6 e6) e6)))) (and (and (and (and (and (and (and (and (and (and (and (and (or ?v_0 ?v_0) (or (not (= ?v_2 e0)) (not (= ?v_1 e0)))) (or (not (= ?v_5 e0)) (not (= ?v_4 e0)))) (or (not (= ?v_10 e0)) (not (= ?v_9 e0)))) (or (not (= ?v_17 e0)) (not (= ?v_16 e0)))) (or (not (= ?v_26 e0)) (not (= ?v_25 e0)))) (or (not (= ?v_37 e0)) (not (= ?v_36 e0)))) (and (and (and (and (and (and (or (not (= ?v_1 e1)) (not (= ?v_2 e1))) (or ?v_3 ?v_3)) (or (not (= ?v_7 e1)) (not (= ?v_6 e1)))) (or (not (= ?v_12 e1)) (not (= ?v_11 e1)))) (or (not (= ?v_19 e1)) (not (= ?v_18 e1)))) (or (not (= ?v_28 e1)) (not (= ?v_27 e1)))) (or (not (= ?v_39 e1)) (not (= ?v_38 e1))))) (and (and (and (and (and (and (or (not (= ?v_4 e2)) (not (= ?v_5 e2))) (or (not (= ?v_6 e2)) (not (= ?v_7 e2)))) (or ?v_8 ?v_8)) (or (not (= ?v_14 e2)) (not (= ?v_13 e2)))) (or (not (= ?v_21 e2)) (not (= ?v_20 e2)))) (or (not (= ?v_30 e2)) (not (= ?v_29 e2)))) (or (not (= ?v_41 e2)) (not (= ?v_40 e2))))) (and (and (and (and (and (and (or (not (= ?v_9 e3)) (not (= ?v_10 e3))) (or (not (= ?v_11 e3)) (not (= ?v_12 e3)))) (or (not (= ?v_13 e3)) (not (= ?v_14 e3)))) (or ?v_15 ?v_15)) (or (not (= ?v_23 e3)) (not (= ?v_22 e3)))) (or (not (= ?v_32 e3)) (not (= ?v_31 e3)))) (or (not (= ?v_43 e3)) (not (= ?v_42 e3))))) (and (and (and (and (and (and (or (not (= ?v_16 e4)) (not (= ?v_17 e4))) (or (not (= ?v_18 e4)) (not (= ?v_19 e4)))) (or (not (= ?v_20 e4)) (not (= ?v_21 e4)))) (or (not (= ?v_22 e4)) (not (= ?v_23 e4)))) (or ?v_24 ?v_24)) (or (not (= ?v_34 e4)) (not (= ?v_33 e4)))) (or (not (= ?v_45 e4)) (not (= ?v_44 e4))))) (and (and (and (and (and (and (or (not (= ?v_25 e5)) (not (= ?v_26 e5))) (or (not (= ?v_27 e5)) (not (= ?v_28 e5)))) (or (not (= ?v_29 e5)) (not (= ?v_30 e5)))) (or (not (= ?v_31 e5)) (not (= ?v_32 e5)))) (or (not (= ?v_33 e5)) (not (= ?v_34 e5)))) (or ?v_35 ?v_35)) (or (not (= ?v_47 e5)) (not (= ?v_46 e5))))) (and (and (and (and (and (and (or (not (= ?v_36 e6)) (not (= ?v_37 e6))) (or (not (= ?v_38 e6)) (not (= ?v_39 e6)))) (or (not (= ?v_40 e6)) (not (= ?v_41 e6)))) (or (not (= ?v_42 e6)) (not (= ?v_43 e6)))) (or (not (= ?v_44 e6)) (not (= ?v_45 e6)))) (or (not (= ?v_46 e6)) (not (= ?v_47 e6)))) (or ?v_48 ?v_48)))) :named tXLRFdgSNIDfMWBiMh)) (assert(! (let ((?v_0 (op e0 e0)) (?v_7 (op e0 e1)) (?v_14 (op e0 e2)) (?v_21 (op e0 e3)) (?v_28 (op e0 e4)) (?v_35 (op e0 e5)) (?v_42 (op e0 e6)) (?v_1 (op e1 e0)) (?v_8 (op e1 e1)) (?v_15 (op e1 e2)) (?v_22 (op e1 e3)) (?v_29 (op e1 e4)) (?v_36 (op e1 e5)) (?v_43 (op e1 e6)) (?v_2 (op e2 e0)) (?v_9 (op e2 e1)) (?v_16 (op e2 e2)) (?v_23 (op e2 e3)) (?v_30 (op e2 e4)) (?v_37 (op e2 e5)) (?v_44 (op e2 e6)) (?v_3 (op e3 e0)) (?v_10 (op e3 e1)) (?v_17 (op e3 e2)) (?v_24 (op e3 e3)) (?v_31 (op e3 e4)) (?v_38 (op e3 e5)) (?v_45 (op e3 e6)) (?v_4 (op e4 e0)) (?v_11 (op e4 e1)) (?v_18 (op e4 e2)) (?v_25 (op e4 e3)) (?v_32 (op e4 e4)) (?v_39 (op e4 e5)) (?v_46 (op e4 e6)) (?v_5 (op e5 e0)) (?v_12 (op e5 e1)) (?v_19 (op e5 e2)) (?v_26 (op e5 e3)) (?v_33 (op e5 e4)) (?v_40 (op e5 e5)) (?v_47 (op e5 e6)) (?v_6 (op e6 e0)) (?v_13 (op e6 e1)) (?v_20 (op e6 e2)) (?v_27 (op e6 e3)) (?v_34 (op e6 e4)) (?v_41 (op e6 e5)) (?v_48 (op e6 e6))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_1)) (not (= ?v_0 ?v_2))) (not (= ?v_0 ?v_3))) (not (= ?v_0 ?v_4))) (not (= ?v_0 ?v_5))) (not (= ?v_0 ?v_6))) (not (= ?v_1 ?v_2))) (not (= ?v_1 ?v_3))) (not (= ?v_1 ?v_4))) (not (= ?v_1 ?v_5))) (not (= ?v_1 ?v_6))) (not (= ?v_2 ?v_3))) (not (= ?v_2 ?v_4))) (not (= ?v_2 ?v_5))) (not (= ?v_2 ?v_6))) (not (= ?v_3 ?v_4))) (not (= ?v_3 ?v_5))) (not (= ?v_3 ?v_6))) (not (= ?v_4 ?v_5))) (not (= ?v_4 ?v_6))) (not (= ?v_5 ?v_6))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_7 ?v_8)) (not (= ?v_7 ?v_9))) (not (= ?v_7 ?v_10))) (not (= ?v_7 ?v_11))) (not (= ?v_7 ?v_12))) (not (= ?v_7 ?v_13))) (not (= ?v_8 ?v_9))) (not (= ?v_8 ?v_10))) (not (= ?v_8 ?v_11))) (not (= ?v_8 ?v_12))) (not (= ?v_8 ?v_13))) (not (= ?v_9 ?v_10))) (not (= ?v_9 ?v_11))) (not (= ?v_9 ?v_12))) (not (= ?v_9 ?v_13))) (not (= ?v_10 ?v_11))) (not (= ?v_10 ?v_12))) (not (= ?v_10 ?v_13))) (not (= ?v_11 ?v_12))) (not (= ?v_11 ?v_13))) (not (= ?v_12 ?v_13)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_14 ?v_15)) (not (= ?v_14 ?v_16))) (not (= ?v_14 ?v_17))) (not (= ?v_14 ?v_18))) (not (= ?v_14 ?v_19))) (not (= ?v_14 ?v_20))) (not (= ?v_15 ?v_16))) (not (= ?v_15 ?v_17))) (not (= ?v_15 ?v_18))) (not (= ?v_15 ?v_19))) (not (= ?v_15 ?v_20))) (not (= ?v_16 ?v_17))) (not (= ?v_16 ?v_18))) (not (= ?v_16 ?v_19))) (not (= ?v_16 ?v_20))) (not (= ?v_17 ?v_18))) (not (= ?v_17 ?v_19))) (not (= ?v_17 ?v_20))) (not (= ?v_18 ?v_19))) (not (= ?v_18 ?v_20))) (not (= ?v_19 ?v_20)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_21 ?v_22)) (not (= ?v_21 ?v_23))) (not (= ?v_21 ?v_24))) (not (= ?v_21 ?v_25))) (not (= ?v_21 ?v_26))) (not (= ?v_21 ?v_27))) (not (= ?v_22 ?v_23))) (not (= ?v_22 ?v_24))) (not (= ?v_22 ?v_25))) (not (= ?v_22 ?v_26))) (not (= ?v_22 ?v_27))) (not (= ?v_23 ?v_24))) (not (= ?v_23 ?v_25))) (not (= ?v_23 ?v_26))) (not (= ?v_23 ?v_27))) (not (= ?v_24 ?v_25))) (not (= ?v_24 ?v_26))) (not (= ?v_24 ?v_27))) (not (= ?v_25 ?v_26))) (not (= ?v_25 ?v_27))) (not (= ?v_26 ?v_27)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_28 ?v_29)) (not (= ?v_28 ?v_30))) (not (= ?v_28 ?v_31))) (not (= ?v_28 ?v_32))) (not (= ?v_28 ?v_33))) (not (= ?v_28 ?v_34))) (not (= ?v_29 ?v_30))) (not (= ?v_29 ?v_31))) (not (= ?v_29 ?v_32))) (not (= ?v_29 ?v_33))) (not (= ?v_29 ?v_34))) (not (= ?v_30 ?v_31))) (not (= ?v_30 ?v_32))) (not (= ?v_30 ?v_33))) (not (= ?v_30 ?v_34))) (not (= ?v_31 ?v_32))) (not (= ?v_31 ?v_33))) (not (= ?v_31 ?v_34))) (not (= ?v_32 ?v_33))) (not (= ?v_32 ?v_34))) (not (= ?v_33 ?v_34)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_35 ?v_36)) (not (= ?v_35 ?v_37))) (not (= ?v_35 ?v_38))) (not (= ?v_35 ?v_39))) (not (= ?v_35 ?v_40))) (not (= ?v_35 ?v_41))) (not (= ?v_36 ?v_37))) (not (= ?v_36 ?v_38))) (not (= ?v_36 ?v_39))) (not (= ?v_36 ?v_40))) (not (= ?v_36 ?v_41))) (not (= ?v_37 ?v_38))) (not (= ?v_37 ?v_39))) (not (= ?v_37 ?v_40))) (not (= ?v_37 ?v_41))) (not (= ?v_38 ?v_39))) (not (= ?v_38 ?v_40))) (not (= ?v_38 ?v_41))) (not (= ?v_39 ?v_40))) (not (= ?v_39 ?v_41))) (not (= ?v_40 ?v_41)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_42 ?v_43)) (not (= ?v_42 ?v_44))) (not (= ?v_42 ?v_45))) (not (= ?v_42 ?v_46))) (not (= ?v_42 ?v_47))) (not (= ?v_42 ?v_48))) (not (= ?v_43 ?v_44))) (not (= ?v_43 ?v_45))) (not (= ?v_43 ?v_46))) (not (= ?v_43 ?v_47))) (not (= ?v_43 ?v_48))) (not (= ?v_44 ?v_45))) (not (= ?v_44 ?v_46))) (not (= ?v_44 ?v_47))) (not (= ?v_44 ?v_48))) (not (= ?v_45 ?v_46))) (not (= ?v_45 ?v_47))) (not (= ?v_45 ?v_48))) (not (= ?v_46 ?v_47))) (not (= ?v_46 ?v_48))) (not (= ?v_47 ?v_48)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_7)) (not (= ?v_0 ?v_14))) (not (= ?v_0 ?v_21))) (not (= ?v_0 ?v_28))) (not (= ?v_0 ?v_35))) (not (= ?v_0 ?v_42))) (not (= ?v_7 ?v_14))) (not (= ?v_7 ?v_21))) (not (= ?v_7 ?v_28))) (not (= ?v_7 ?v_35))) (not (= ?v_7 ?v_42))) (not (= ?v_14 ?v_21))) (not (= ?v_14 ?v_28))) (not (= ?v_14 ?v_35))) (not (= ?v_14 ?v_42))) (not (= ?v_21 ?v_28))) (not (= ?v_21 ?v_35))) (not (= ?v_21 ?v_42))) (not (= ?v_28 ?v_35))) (not (= ?v_28 ?v_42))) (not (= ?v_35 ?v_42))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_1 ?v_8)) (not (= ?v_1 ?v_15))) (not (= ?v_1 ?v_22))) (not (= ?v_1 ?v_29))) (not (= ?v_1 ?v_36))) (not (= ?v_1 ?v_43))) (not (= ?v_8 ?v_15))) (not (= ?v_8 ?v_22))) (not (= ?v_8 ?v_29))) (not (= ?v_8 ?v_36))) (not (= ?v_8 ?v_43))) (not (= ?v_15 ?v_22))) (not (= ?v_15 ?v_29))) (not (= ?v_15 ?v_36))) (not (= ?v_15 ?v_43))) (not (= ?v_22 ?v_29))) (not (= ?v_22 ?v_36))) (not (= ?v_22 ?v_43))) (not (= ?v_29 ?v_36))) (not (= ?v_29 ?v_43))) (not (= ?v_36 ?v_43)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_2 ?v_9)) (not (= ?v_2 ?v_16))) (not (= ?v_2 ?v_23))) (not (= ?v_2 ?v_30))) (not (= ?v_2 ?v_37))) (not (= ?v_2 ?v_44))) (not (= ?v_9 ?v_16))) (not (= ?v_9 ?v_23))) (not (= ?v_9 ?v_30))) (not (= ?v_9 ?v_37))) (not (= ?v_9 ?v_44))) (not (= ?v_16 ?v_23))) (not (= ?v_16 ?v_30))) (not (= ?v_16 ?v_37))) (not (= ?v_16 ?v_44))) (not (= ?v_23 ?v_30))) (not (= ?v_23 ?v_37))) (not (= ?v_23 ?v_44))) (not (= ?v_30 ?v_37))) (not (= ?v_30 ?v_44))) (not (= ?v_37 ?v_44)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_3 ?v_10)) (not (= ?v_3 ?v_17))) (not (= ?v_3 ?v_24))) (not (= ?v_3 ?v_31))) (not (= ?v_3 ?v_38))) (not (= ?v_3 ?v_45))) (not (= ?v_10 ?v_17))) (not (= ?v_10 ?v_24))) (not (= ?v_10 ?v_31))) (not (= ?v_10 ?v_38))) (not (= ?v_10 ?v_45))) (not (= ?v_17 ?v_24))) (not (= ?v_17 ?v_31))) (not (= ?v_17 ?v_38))) (not (= ?v_17 ?v_45))) (not (= ?v_24 ?v_31))) (not (= ?v_24 ?v_38))) (not (= ?v_24 ?v_45))) (not (= ?v_31 ?v_38))) (not (= ?v_31 ?v_45))) (not (= ?v_38 ?v_45)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_4 ?v_11)) (not (= ?v_4 ?v_18))) (not (= ?v_4 ?v_25))) (not (= ?v_4 ?v_32))) (not (= ?v_4 ?v_39))) (not (= ?v_4 ?v_46))) (not (= ?v_11 ?v_18))) (not (= ?v_11 ?v_25))) (not (= ?v_11 ?v_32))) (not (= ?v_11 ?v_39))) (not (= ?v_11 ?v_46))) (not (= ?v_18 ?v_25))) (not (= ?v_18 ?v_32))) (not (= ?v_18 ?v_39))) (not (= ?v_18 ?v_46))) (not (= ?v_25 ?v_32))) (not (= ?v_25 ?v_39))) (not (= ?v_25 ?v_46))) (not (= ?v_32 ?v_39))) (not (= ?v_32 ?v_46))) (not (= ?v_39 ?v_46)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_5 ?v_12)) (not (= ?v_5 ?v_19))) (not (= ?v_5 ?v_26))) (not (= ?v_5 ?v_33))) (not (= ?v_5 ?v_40))) (not (= ?v_5 ?v_47))) (not (= ?v_12 ?v_19))) (not (= ?v_12 ?v_26))) (not (= ?v_12 ?v_33))) (not (= ?v_12 ?v_40))) (not (= ?v_12 ?v_47))) (not (= ?v_19 ?v_26))) (not (= ?v_19 ?v_33))) (not (= ?v_19 ?v_40))) (not (= ?v_19 ?v_47))) (not (= ?v_26 ?v_33))) (not (= ?v_26 ?v_40))) (not (= ?v_26 ?v_47))) (not (= ?v_33 ?v_40))) (not (= ?v_33 ?v_47))) (not (= ?v_40 ?v_47)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_6 ?v_13)) (not (= ?v_6 ?v_20))) (not (= ?v_6 ?v_27))) (not (= ?v_6 ?v_34))) (not (= ?v_6 ?v_41))) (not (= ?v_6 ?v_48))) (not (= ?v_13 ?v_20))) (not (= ?v_13 ?v_27))) (not (= ?v_13 ?v_34))) (not (= ?v_13 ?v_41))) (not (= ?v_13 ?v_48))) (not (= ?v_20 ?v_27))) (not (= ?v_20 ?v_34))) (not (= ?v_20 ?v_41))) (not (= ?v_20 ?v_48))) (not (= ?v_27 ?v_34))) (not (= ?v_27 ?v_41))) (not (= ?v_27 ?v_48))) (not (= ?v_34 ?v_41))) (not (= ?v_34 ?v_48))) (not (= ?v_41 ?v_48)))))) :named jrcYXtZWNHWn)) (assert(! (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= e0 e1)) (not (= e0 e2))) (not (= e0 e3))) (not (= e0 e4))) (not (= e0 e5))) (not (= e0 e6))) (not (= e1 e2))) (not (= e1 e3))) (not (= e1 e4))) (not (= e1 e5))) (not (= e1 e6))) (not (= e2 e3))) (not (= e2 e4))) (not (= e2 e5))) (not (= e2 e6))) (not (= e3 e4))) (not (= e3 e5))) (not (= e3 e6))) (not (= e4 e5))) (not (= e4 e6))) (not (= e5 e6))) :named CXYdZVsdvgDTTwXCVLY)) (assert(! (and (and (and (and (and (= e1 (op e0 e6)) (= e2 (op e0 e0))) (= e3 (op e2 e6))) (= e4 (op e2 e0))) (= e5 (op e0 e1))) (= e6 (op e2 e4))) :named vIKjLfKqbVFbSpdqLQ)) (assert(! (not (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= (op e0 e0) e2) (= (op e0 e1) e5)) (= (op e0 e2) e3)) (= (op e0 e3) e6)) (= (op e0 e4) e4)) (= (op e0 e5) e0)) (= (op e0 e6) e1)) (= (op e1 e0) e5)) (= (op e1 e1) e0)) (= (op e1 e2) e1)) (= (op e1 e3) e4)) (= (op e1 e4) e2)) (= (op e1 e5) e3)) (= (op e1 e6) e6)) (= (op e2 e0) e4)) (= (op e2 e1) e2)) (= (op e2 e2) e0)) (= (op e2 e3) e1)) (= (op e2 e4) e6)) (= (op e2 e5) e5)) (= (op e2 e6) e3)) (= (op e3 e0) e1)) (= (op e3 e1) e6)) (= (op e3 e2) e2)) (= (op e3 e3) e0)) (= (op e3 e4) e3)) (= (op e3 e5) e4)) (= (op e3 e6) e5)) (= (op e4 e0) e0)) (= (op e4 e1) e3)) (= (op e4 e2) e6)) (= (op e4 e3) e2)) (= (op e4 e4) e5)) (= (op e4 e5) e1)) (= (op e4 e6) e4)) (= (op e5 e0) e3)) (= (op e5 e1) e1)) (= (op e5 e2) e4)) (= (op e5 e3) e5)) (= (op e5 e4) e0)) (= (op e5 e5) e6)) (= (op e5 e6) e2)) (= (op e6 e0) e6)) (= (op e6 e1) e4)) (= (op e6 e2) e5)) (= (op e6 e3) e3)) (= (op e6 e4) e1)) (= (op e6 e5) e2)) (= (op e6 e6) e0))) :named uwdonyGDksUV)) (check-sat) opensmt-2.5.2/regression/lookahead/iso_brn_sk005_eufexps.smt2.expected.err000066400000000000000000000000001445011647600266240ustar00rootroot00000000000000opensmt-2.5.2/regression/lookahead/iso_brn_sk005_eufexps.smt2.expected.out000066400000000000000000000000061445011647600266510ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/model/000077500000000000000000000000001445011647600164755ustar00rootroot00000000000000opensmt-2.5.2/regression/model/issue123.smt2000066400000000000000000000002411445011647600206570ustar00rootroot00000000000000(set-option :produce-model 1) (set-logic QF_UF) (declare-fun b () Bool) (declare-fun c () Bool) (assert (= b c )) (assert (not b)) (check-sat) (get-value (b c)) opensmt-2.5.2/regression/model/issue123.smt2.expected.err000066400000000000000000000000001445011647600232370ustar00rootroot00000000000000opensmt-2.5.2/regression/model/issue123.smt2.expected.out000066400000000000000000000000311445011647600232620ustar00rootroot00000000000000sat ((b false)(c false)) opensmt-2.5.2/regression/model/issue296a.smt2000066400000000000000000000001411445011647600210320ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun a () Real) (assert (= a (/ 1 2))) (check-sat) (get-model) (exit) opensmt-2.5.2/regression/model/issue296a.smt2.expected.err000066400000000000000000000000001445011647600234130ustar00rootroot00000000000000opensmt-2.5.2/regression/model/issue296a.smt2.expected.out000066400000000000000000000000551445011647600234440ustar00rootroot00000000000000sat ( (define-fun a () Real (/ 1 2)) ) opensmt-2.5.2/regression/model/issue296b.smt2000066400000000000000000000001451445011647600210370ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun a () Real) (assert (= a (/ 1 2))) (check-sat) (get-value (a)) (exit) opensmt-2.5.2/regression/model/issue296b.smt2.expected.err000066400000000000000000000000001445011647600234140ustar00rootroot00000000000000opensmt-2.5.2/regression/model/issue296b.smt2.expected.out000066400000000000000000000000221445011647600234370ustar00rootroot00000000000000sat ((a (/ 1 2))) opensmt-2.5.2/regression/model/issue296c.smt2000066400000000000000000000001371445011647600210410ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun a () Real) (assert (= a (- 1))) (check-sat) (get-model) (exit) opensmt-2.5.2/regression/model/issue296c.smt2.expected.err000066400000000000000000000000001445011647600234150ustar00rootroot00000000000000opensmt-2.5.2/regression/model/issue296c.smt2.expected.out000066400000000000000000000000531445011647600234440ustar00rootroot00000000000000sat ( (define-fun a () Real (- 1)) ) opensmt-2.5.2/regression/model/issue296d.smt2000066400000000000000000000001431445011647600210370ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun a () Real) (assert (= a (- 1))) (check-sat) (get-value (a)) (exit) opensmt-2.5.2/regression/model/issue296d.smt2.expected.err000066400000000000000000000000001445011647600234160ustar00rootroot00000000000000opensmt-2.5.2/regression/model/issue296d.smt2.expected.out000066400000000000000000000000201445011647600234370ustar00rootroot00000000000000sat ((a (- 1))) opensmt-2.5.2/regression/model/subst_incremental.smt2000066400000000000000000000003771445011647600230340ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun x () Real) (declare-fun y () Real) (declare-fun z () Real) (declare-fun a () Bool) (declare-fun b () Bool) (assert (=> a b)) ;(assert (=> a (not b))) (check-sat) (push 1) (assert (not a)) (check-sat) (get-value (a)) (exit) opensmt-2.5.2/regression/model/subst_incremental.smt2.expected.err000066400000000000000000000000001445011647600254020ustar00rootroot00000000000000opensmt-2.5.2/regression/model/subst_incremental.smt2.expected.out000066400000000000000000000000241445011647600254270ustar00rootroot00000000000000sat sat ((a false)) opensmt-2.5.2/regression/picky/000077500000000000000000000000001445011647600165145ustar00rootroot00000000000000opensmt-2.5.2/regression/picky/iso_brn_sk003_eufexps.smt2000066400000000000000000001134701445011647600234430ustar00rootroot00000000000000(set-option :picky true) (set-option :picky_w 10) (set-logic QF_UF) (set-info :source | http://www.cs.bham.ac.uk/~vxs/quasigroups/benchmark/ |) (set-info :smt-lib-version 2.0) (set-info :category "crafted") (set-info :status unsat) (declare-sort U 0) (declare-sort I 0) (declare-fun op1 (I I) I) (declare-fun op (I I) I) (declare-fun e6 () I) (declare-fun e5 () I) (declare-fun e4 () I) (declare-fun e3 () I) (declare-fun e2 () I) (declare-fun e1 () I) (declare-fun e0 () I) (declare-fun skc1 (I) I) (assert(! (let ((?v_0 (op e0 e0)) (?v_1 (op e0 e1)) (?v_2 (op e0 e2)) (?v_3 (op e0 e3)) (?v_4 (op e0 e4)) (?v_5 (op e0 e5)) (?v_6 (op e0 e6)) (?v_7 (op e1 e0)) (?v_8 (op e1 e1)) (?v_9 (op e1 e2)) (?v_10 (op e1 e3)) (?v_11 (op e1 e4)) (?v_12 (op e1 e5)) (?v_13 (op e1 e6)) (?v_14 (op e2 e0)) (?v_15 (op e2 e1)) (?v_16 (op e2 e2)) (?v_17 (op e2 e3)) (?v_18 (op e2 e4)) (?v_19 (op e2 e5)) (?v_20 (op e2 e6)) (?v_21 (op e3 e0)) (?v_22 (op e3 e1)) (?v_23 (op e3 e2)) (?v_24 (op e3 e3)) (?v_25 (op e3 e4)) (?v_26 (op e3 e5)) (?v_27 (op e3 e6)) (?v_28 (op e4 e0)) (?v_29 (op e4 e1)) (?v_30 (op e4 e2)) (?v_31 (op e4 e3)) (?v_32 (op e4 e4)) (?v_33 (op e4 e5)) (?v_34 (op e4 e6)) (?v_35 (op e5 e0)) (?v_36 (op e5 e1)) (?v_37 (op e5 e2)) (?v_38 (op e5 e3)) (?v_39 (op e5 e4)) (?v_40 (op e5 e5)) (?v_41 (op e5 e6)) (?v_42 (op e6 e0)) (?v_43 (op e6 e1)) (?v_44 (op e6 e2)) (?v_45 (op e6 e3)) (?v_46 (op e6 e4)) (?v_47 (op e6 e5)) (?v_48 (op e6 e6))) (and (and (and (and (and (and (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_0 e0) (= ?v_0 e1)) (= ?v_0 e2)) (= ?v_0 e3)) (= ?v_0 e4)) (= ?v_0 e5)) (= ?v_0 e6)) (or (or (or (or (or (or (= ?v_1 e0) (= ?v_1 e1)) (= ?v_1 e2)) (= ?v_1 e3)) (= ?v_1 e4)) (= ?v_1 e5)) (= ?v_1 e6))) (or (or (or (or (or (or (= ?v_2 e0) (= ?v_2 e1)) (= ?v_2 e2)) (= ?v_2 e3)) (= ?v_2 e4)) (= ?v_2 e5)) (= ?v_2 e6))) (or (or (or (or (or (or (= ?v_3 e0) (= ?v_3 e1)) (= ?v_3 e2)) (= ?v_3 e3)) (= ?v_3 e4)) (= ?v_3 e5)) (= ?v_3 e6))) (or (or (or (or (or (or (= ?v_4 e0) (= ?v_4 e1)) (= ?v_4 e2)) (= ?v_4 e3)) (= ?v_4 e4)) (= ?v_4 e5)) (= ?v_4 e6))) (or (or (or (or (or (or (= ?v_5 e0) (= ?v_5 e1)) (= ?v_5 e2)) (= ?v_5 e3)) (= ?v_5 e4)) (= ?v_5 e5)) (= ?v_5 e6))) (or (or (or (or (or (or (= ?v_6 e0) (= ?v_6 e1)) (= ?v_6 e2)) (= ?v_6 e3)) (= ?v_6 e4)) (= ?v_6 e5)) (= ?v_6 e6))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_7 e0) (= ?v_7 e1)) (= ?v_7 e2)) (= ?v_7 e3)) (= ?v_7 e4)) (= ?v_7 e5)) (= ?v_7 e6)) (or (or (or (or (or (or (= ?v_8 e0) (= ?v_8 e1)) (= ?v_8 e2)) (= ?v_8 e3)) (= ?v_8 e4)) (= ?v_8 e5)) (= ?v_8 e6))) (or (or (or (or (or (or (= ?v_9 e0) (= ?v_9 e1)) (= ?v_9 e2)) (= ?v_9 e3)) (= ?v_9 e4)) (= ?v_9 e5)) (= ?v_9 e6))) (or (or (or (or (or (or (= ?v_10 e0) (= ?v_10 e1)) (= ?v_10 e2)) (= ?v_10 e3)) (= ?v_10 e4)) (= ?v_10 e5)) (= ?v_10 e6))) (or (or (or (or (or (or (= ?v_11 e0) (= ?v_11 e1)) (= ?v_11 e2)) (= ?v_11 e3)) (= ?v_11 e4)) (= ?v_11 e5)) (= ?v_11 e6))) (or (or (or (or (or (or (= ?v_12 e0) (= ?v_12 e1)) (= ?v_12 e2)) (= ?v_12 e3)) (= ?v_12 e4)) (= ?v_12 e5)) (= ?v_12 e6))) (or (or (or (or (or (or (= ?v_13 e0) (= ?v_13 e1)) (= ?v_13 e2)) (= ?v_13 e3)) (= ?v_13 e4)) (= ?v_13 e5)) (= ?v_13 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_14 e0) (= ?v_14 e1)) (= ?v_14 e2)) (= ?v_14 e3)) (= ?v_14 e4)) (= ?v_14 e5)) (= ?v_14 e6)) (or (or (or (or (or (or (= ?v_15 e0) (= ?v_15 e1)) (= ?v_15 e2)) (= ?v_15 e3)) (= ?v_15 e4)) (= ?v_15 e5)) (= ?v_15 e6))) (or (or (or (or (or (or (= ?v_16 e0) (= ?v_16 e1)) (= ?v_16 e2)) (= ?v_16 e3)) (= ?v_16 e4)) (= ?v_16 e5)) (= ?v_16 e6))) (or (or (or (or (or (or (= ?v_17 e0) (= ?v_17 e1)) (= ?v_17 e2)) (= ?v_17 e3)) (= ?v_17 e4)) (= ?v_17 e5)) (= ?v_17 e6))) (or (or (or (or (or (or (= ?v_18 e0) (= ?v_18 e1)) (= ?v_18 e2)) (= ?v_18 e3)) (= ?v_18 e4)) (= ?v_18 e5)) (= ?v_18 e6))) (or (or (or (or (or (or (= ?v_19 e0) (= ?v_19 e1)) (= ?v_19 e2)) (= ?v_19 e3)) (= ?v_19 e4)) (= ?v_19 e5)) (= ?v_19 e6))) (or (or (or (or (or (or (= ?v_20 e0) (= ?v_20 e1)) (= ?v_20 e2)) (= ?v_20 e3)) (= ?v_20 e4)) (= ?v_20 e5)) (= ?v_20 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_21 e0) (= ?v_21 e1)) (= ?v_21 e2)) (= ?v_21 e3)) (= ?v_21 e4)) (= ?v_21 e5)) (= ?v_21 e6)) (or (or (or (or (or (or (= ?v_22 e0) (= ?v_22 e1)) (= ?v_22 e2)) (= ?v_22 e3)) (= ?v_22 e4)) (= ?v_22 e5)) (= ?v_22 e6))) (or (or (or (or (or (or (= ?v_23 e0) (= ?v_23 e1)) (= ?v_23 e2)) (= ?v_23 e3)) (= ?v_23 e4)) (= ?v_23 e5)) (= ?v_23 e6))) (or (or (or (or (or (or (= ?v_24 e0) (= ?v_24 e1)) (= ?v_24 e2)) (= ?v_24 e3)) (= ?v_24 e4)) (= ?v_24 e5)) (= ?v_24 e6))) (or (or (or (or (or (or (= ?v_25 e0) (= ?v_25 e1)) (= ?v_25 e2)) (= ?v_25 e3)) (= ?v_25 e4)) (= ?v_25 e5)) (= ?v_25 e6))) (or (or (or (or (or (or (= ?v_26 e0) (= ?v_26 e1)) (= ?v_26 e2)) (= ?v_26 e3)) (= ?v_26 e4)) (= ?v_26 e5)) (= ?v_26 e6))) (or (or (or (or (or (or (= ?v_27 e0) (= ?v_27 e1)) (= ?v_27 e2)) (= ?v_27 e3)) (= ?v_27 e4)) (= ?v_27 e5)) (= ?v_27 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_28 e0) (= ?v_28 e1)) (= ?v_28 e2)) (= ?v_28 e3)) (= ?v_28 e4)) (= ?v_28 e5)) (= ?v_28 e6)) (or (or (or (or (or (or (= ?v_29 e0) (= ?v_29 e1)) (= ?v_29 e2)) (= ?v_29 e3)) (= ?v_29 e4)) (= ?v_29 e5)) (= ?v_29 e6))) (or (or (or (or (or (or (= ?v_30 e0) (= ?v_30 e1)) (= ?v_30 e2)) (= ?v_30 e3)) (= ?v_30 e4)) (= ?v_30 e5)) (= ?v_30 e6))) (or (or (or (or (or (or (= ?v_31 e0) (= ?v_31 e1)) (= ?v_31 e2)) (= ?v_31 e3)) (= ?v_31 e4)) (= ?v_31 e5)) (= ?v_31 e6))) (or (or (or (or (or (or (= ?v_32 e0) (= ?v_32 e1)) (= ?v_32 e2)) (= ?v_32 e3)) (= ?v_32 e4)) (= ?v_32 e5)) (= ?v_32 e6))) (or (or (or (or (or (or (= ?v_33 e0) (= ?v_33 e1)) (= ?v_33 e2)) (= ?v_33 e3)) (= ?v_33 e4)) (= ?v_33 e5)) (= ?v_33 e6))) (or (or (or (or (or (or (= ?v_34 e0) (= ?v_34 e1)) (= ?v_34 e2)) (= ?v_34 e3)) (= ?v_34 e4)) (= ?v_34 e5)) (= ?v_34 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_35 e0) (= ?v_35 e1)) (= ?v_35 e2)) (= ?v_35 e3)) (= ?v_35 e4)) (= ?v_35 e5)) (= ?v_35 e6)) (or (or (or (or (or (or (= ?v_36 e0) (= ?v_36 e1)) (= ?v_36 e2)) (= ?v_36 e3)) (= ?v_36 e4)) (= ?v_36 e5)) (= ?v_36 e6))) (or (or (or (or (or (or (= ?v_37 e0) (= ?v_37 e1)) (= ?v_37 e2)) (= ?v_37 e3)) (= ?v_37 e4)) (= ?v_37 e5)) (= ?v_37 e6))) (or (or (or (or (or (or (= ?v_38 e0) (= ?v_38 e1)) (= ?v_38 e2)) (= ?v_38 e3)) (= ?v_38 e4)) (= ?v_38 e5)) (= ?v_38 e6))) (or (or (or (or (or (or (= ?v_39 e0) (= ?v_39 e1)) (= ?v_39 e2)) (= ?v_39 e3)) (= ?v_39 e4)) (= ?v_39 e5)) (= ?v_39 e6))) (or (or (or (or (or (or (= ?v_40 e0) (= ?v_40 e1)) (= ?v_40 e2)) (= ?v_40 e3)) (= ?v_40 e4)) (= ?v_40 e5)) (= ?v_40 e6))) (or (or (or (or (or (or (= ?v_41 e0) (= ?v_41 e1)) (= ?v_41 e2)) (= ?v_41 e3)) (= ?v_41 e4)) (= ?v_41 e5)) (= ?v_41 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_42 e0) (= ?v_42 e1)) (= ?v_42 e2)) (= ?v_42 e3)) (= ?v_42 e4)) (= ?v_42 e5)) (= ?v_42 e6)) (or (or (or (or (or (or (= ?v_43 e0) (= ?v_43 e1)) (= ?v_43 e2)) (= ?v_43 e3)) (= ?v_43 e4)) (= ?v_43 e5)) (= ?v_43 e6))) (or (or (or (or (or (or (= ?v_44 e0) (= ?v_44 e1)) (= ?v_44 e2)) (= ?v_44 e3)) (= ?v_44 e4)) (= ?v_44 e5)) (= ?v_44 e6))) (or (or (or (or (or (or (= ?v_45 e0) (= ?v_45 e1)) (= ?v_45 e2)) (= ?v_45 e3)) (= ?v_45 e4)) (= ?v_45 e5)) (= ?v_45 e6))) (or (or (or (or (or (or (= ?v_46 e0) (= ?v_46 e1)) (= ?v_46 e2)) (= ?v_46 e3)) (= ?v_46 e4)) (= ?v_46 e5)) (= ?v_46 e6))) (or (or (or (or (or (or (= ?v_47 e0) (= ?v_47 e1)) (= ?v_47 e2)) (= ?v_47 e3)) (= ?v_47 e4)) (= ?v_47 e5)) (= ?v_47 e6))) (or (or (or (or (or (or (= ?v_48 e0) (= ?v_48 e1)) (= ?v_48 e2)) (= ?v_48 e3)) (= ?v_48 e4)) (= ?v_48 e5)) (= ?v_48 e6))))) :named WoCGwwVnZQddqqKNwFA)) (assert(! (let ((?v_1 (op e0 e0)) (?v_2 (op e0 e1)) (?v_3 (op e0 e2)) (?v_4 (op e0 e3)) (?v_5 (op e0 e4)) (?v_6 (op e0 e5)) (?v_7 (op e0 e6)) (?v_9 (op e1 e0)) (?v_24 (op e1 e1)) (?v_25 (op e1 e2)) (?v_26 (op e1 e3)) (?v_27 (op e1 e4)) (?v_28 (op e1 e5)) (?v_29 (op e1 e6)) (?v_10 (op e2 e0)) (?v_32 (op e2 e1)) (?v_59 (op e2 e2)) (?v_60 (op e2 e3)) (?v_61 (op e2 e4)) (?v_62 (op e2 e5)) (?v_63 (op e2 e6)) (?v_11 (op e3 e0)) (?v_33 (op e3 e1)) (?v_67 (op e3 e2)) (?v_106 (op e3 e3)) (?v_107 (op e3 e4)) (?v_108 (op e3 e5)) (?v_109 (op e3 e6)) (?v_12 (op e4 e0)) (?v_34 (op e4 e1)) (?v_68 (op e4 e2)) (?v_114 (op e4 e3)) (?v_165 (op e4 e4)) (?v_166 (op e4 e5)) (?v_167 (op e4 e6)) (?v_13 (op e5 e0)) (?v_35 (op e5 e1)) (?v_69 (op e5 e2)) (?v_115 (op e5 e3)) (?v_173 (op e5 e4)) (?v_236 (op e5 e5)) (?v_237 (op e5 e6)) (?v_14 (op e6 e0)) (?v_36 (op e6 e1)) (?v_70 (op e6 e2)) (?v_116 (op e6 e3)) (?v_174 (op e6 e4)) (?v_244 (op e6 e5)) (?v_319 (op e6 e6))) (let ((?v_0 (= ?v_1 e0)) (?v_8 (= ?v_1 e1)) (?v_15 (= ?v_1 e2)) (?v_16 (= ?v_1 e3)) (?v_17 (= ?v_1 e4)) (?v_18 (= ?v_1 e5)) (?v_19 (= ?v_1 e6)) (?v_21 (= ?v_2 e0)) (?v_30 (= ?v_2 e1)) (?v_38 (= ?v_2 e2)) (?v_41 (= ?v_2 e3)) (?v_44 (= ?v_2 e4)) (?v_47 (= ?v_2 e5)) (?v_50 (= ?v_2 e6)) (?v_54 (= ?v_3 e0)) (?v_64 (= ?v_3 e1)) (?v_73 (= ?v_3 e2)) (?v_78 (= ?v_3 e3)) (?v_83 (= ?v_3 e4)) (?v_88 (= ?v_3 e5)) (?v_93 (= ?v_3 e6)) (?v_99 (= ?v_4 e0)) (?v_110 (= ?v_4 e1)) (?v_120 (= ?v_4 e2)) (?v_127 (= ?v_4 e3)) (?v_134 (= ?v_4 e4)) (?v_141 (= ?v_4 e5)) (?v_148 (= ?v_4 e6)) (?v_156 (= ?v_5 e0)) (?v_168 (= ?v_5 e1)) (?v_179 (= ?v_5 e2)) (?v_188 (= ?v_5 e3)) (?v_197 (= ?v_5 e4)) (?v_206 (= ?v_5 e5)) (?v_215 (= ?v_5 e6)) (?v_225 (= ?v_6 e0)) (?v_238 (= ?v_6 e1)) (?v_250 (= ?v_6 e2)) (?v_261 (= ?v_6 e3)) (?v_272 (= ?v_6 e4)) (?v_283 (= ?v_6 e5)) (?v_294 (= ?v_6 e6)) (?v_306 (= ?v_7 e0)) (?v_320 (= ?v_7 e1)) (?v_333 (= ?v_7 e2)) (?v_346 (= ?v_7 e3)) (?v_359 (= ?v_7 e4)) (?v_372 (= ?v_7 e5)) (?v_385 (= ?v_7 e6)) (?v_20 (= ?v_9 e0)) (?v_23 (= ?v_9 e1)) (?v_37 (= ?v_9 e2)) (?v_40 (= ?v_9 e3)) (?v_43 (= ?v_9 e4)) (?v_46 (= ?v_9 e5)) (?v_49 (= ?v_9 e6)) (?v_22 (= ?v_24 e0)) (?v_31 (= ?v_24 e1)) (?v_39 (= ?v_24 e2)) (?v_42 (= ?v_24 e3)) (?v_45 (= ?v_24 e4)) (?v_48 (= ?v_24 e5)) (?v_51 (= ?v_24 e6)) (?v_55 (= ?v_25 e0)) (?v_65 (= ?v_25 e1)) (?v_74 (= ?v_25 e2)) (?v_79 (= ?v_25 e3)) (?v_84 (= ?v_25 e4)) (?v_89 (= ?v_25 e5)) (?v_94 (= ?v_25 e6)) (?v_100 (= ?v_26 e0)) (?v_111 (= ?v_26 e1)) (?v_121 (= ?v_26 e2)) (?v_128 (= ?v_26 e3)) (?v_135 (= ?v_26 e4)) (?v_142 (= ?v_26 e5)) (?v_149 (= ?v_26 e6)) (?v_157 (= ?v_27 e0)) (?v_169 (= ?v_27 e1)) (?v_180 (= ?v_27 e2)) (?v_189 (= ?v_27 e3)) (?v_198 (= ?v_27 e4)) (?v_207 (= ?v_27 e5)) (?v_216 (= ?v_27 e6)) (?v_226 (= ?v_28 e0)) (?v_239 (= ?v_28 e1)) (?v_251 (= ?v_28 e2)) (?v_262 (= ?v_28 e3)) (?v_273 (= ?v_28 e4)) (?v_284 (= ?v_28 e5)) (?v_295 (= ?v_28 e6)) (?v_307 (= ?v_29 e0)) (?v_321 (= ?v_29 e1)) (?v_334 (= ?v_29 e2)) (?v_347 (= ?v_29 e3)) (?v_360 (= ?v_29 e4)) (?v_373 (= ?v_29 e5)) (?v_386 (= ?v_29 e6)) (?v_52 (= ?v_10 e0)) (?v_57 (= ?v_10 e1)) (?v_71 (= ?v_10 e2)) (?v_76 (= ?v_10 e3)) (?v_81 (= ?v_10 e4)) (?v_86 (= ?v_10 e5)) (?v_91 (= ?v_10 e6)) (?v_53 (= ?v_32 e0)) (?v_58 (= ?v_32 e1)) (?v_72 (= ?v_32 e2)) (?v_77 (= ?v_32 e3)) (?v_82 (= ?v_32 e4)) (?v_87 (= ?v_32 e5)) (?v_92 (= ?v_32 e6)) (?v_56 (= ?v_59 e0)) (?v_66 (= ?v_59 e1)) (?v_75 (= ?v_59 e2)) (?v_80 (= ?v_59 e3)) (?v_85 (= ?v_59 e4)) (?v_90 (= ?v_59 e5)) (?v_95 (= ?v_59 e6)) (?v_101 (= ?v_60 e0)) (?v_112 (= ?v_60 e1)) (?v_122 (= ?v_60 e2)) (?v_129 (= ?v_60 e3)) (?v_136 (= ?v_60 e4)) (?v_143 (= ?v_60 e5)) (?v_150 (= ?v_60 e6)) (?v_158 (= ?v_61 e0)) (?v_170 (= ?v_61 e1)) (?v_181 (= ?v_61 e2)) (?v_190 (= ?v_61 e3)) (?v_199 (= ?v_61 e4)) (?v_208 (= ?v_61 e5)) (?v_217 (= ?v_61 e6)) (?v_227 (= ?v_62 e0)) (?v_240 (= ?v_62 e1)) (?v_252 (= ?v_62 e2)) (?v_263 (= ?v_62 e3)) (?v_274 (= ?v_62 e4)) (?v_285 (= ?v_62 e5)) (?v_296 (= ?v_62 e6)) (?v_308 (= ?v_63 e0)) (?v_322 (= ?v_63 e1)) (?v_335 (= ?v_63 e2)) (?v_348 (= ?v_63 e3)) (?v_361 (= ?v_63 e4)) (?v_374 (= ?v_63 e5)) (?v_387 (= ?v_63 e6)) (?v_96 (= ?v_11 e0)) (?v_103 (= ?v_11 e1)) (?v_117 (= ?v_11 e2)) (?v_124 (= ?v_11 e3)) (?v_131 (= ?v_11 e4)) (?v_138 (= ?v_11 e5)) (?v_145 (= ?v_11 e6)) (?v_97 (= ?v_33 e0)) (?v_104 (= ?v_33 e1)) (?v_118 (= ?v_33 e2)) (?v_125 (= ?v_33 e3)) (?v_132 (= ?v_33 e4)) (?v_139 (= ?v_33 e5)) (?v_146 (= ?v_33 e6)) (?v_98 (= ?v_67 e0)) (?v_105 (= ?v_67 e1)) (?v_119 (= ?v_67 e2)) (?v_126 (= ?v_67 e3)) (?v_133 (= ?v_67 e4)) (?v_140 (= ?v_67 e5)) (?v_147 (= ?v_67 e6)) (?v_102 (= ?v_106 e0)) (?v_113 (= ?v_106 e1)) (?v_123 (= ?v_106 e2)) (?v_130 (= ?v_106 e3)) (?v_137 (= ?v_106 e4)) (?v_144 (= ?v_106 e5)) (?v_151 (= ?v_106 e6)) (?v_159 (= ?v_107 e0)) (?v_171 (= ?v_107 e1)) (?v_182 (= ?v_107 e2)) (?v_191 (= ?v_107 e3)) (?v_200 (= ?v_107 e4)) (?v_209 (= ?v_107 e5)) (?v_218 (= ?v_107 e6)) (?v_228 (= ?v_108 e0)) (?v_241 (= ?v_108 e1)) (?v_253 (= ?v_108 e2)) (?v_264 (= ?v_108 e3)) (?v_275 (= ?v_108 e4)) (?v_286 (= ?v_108 e5)) (?v_297 (= ?v_108 e6)) (?v_309 (= ?v_109 e0)) (?v_323 (= ?v_109 e1)) (?v_336 (= ?v_109 e2)) (?v_349 (= ?v_109 e3)) (?v_362 (= ?v_109 e4)) (?v_375 (= ?v_109 e5)) (?v_388 (= ?v_109 e6)) (?v_152 (= ?v_12 e0)) (?v_161 (= ?v_12 e1)) (?v_175 (= ?v_12 e2)) (?v_184 (= ?v_12 e3)) (?v_193 (= ?v_12 e4)) (?v_202 (= ?v_12 e5)) (?v_211 (= ?v_12 e6)) (?v_153 (= ?v_34 e0)) (?v_162 (= ?v_34 e1)) (?v_176 (= ?v_34 e2)) (?v_185 (= ?v_34 e3)) (?v_194 (= ?v_34 e4)) (?v_203 (= ?v_34 e5)) (?v_212 (= ?v_34 e6)) (?v_154 (= ?v_68 e0)) (?v_163 (= ?v_68 e1)) (?v_177 (= ?v_68 e2)) (?v_186 (= ?v_68 e3)) (?v_195 (= ?v_68 e4)) (?v_204 (= ?v_68 e5)) (?v_213 (= ?v_68 e6)) (?v_155 (= ?v_114 e0)) (?v_164 (= ?v_114 e1)) (?v_178 (= ?v_114 e2)) (?v_187 (= ?v_114 e3)) (?v_196 (= ?v_114 e4)) (?v_205 (= ?v_114 e5)) (?v_214 (= ?v_114 e6)) (?v_160 (= ?v_165 e0)) (?v_172 (= ?v_165 e1)) (?v_183 (= ?v_165 e2)) (?v_192 (= ?v_165 e3)) (?v_201 (= ?v_165 e4)) (?v_210 (= ?v_165 e5)) (?v_219 (= ?v_165 e6)) (?v_229 (= ?v_166 e0)) (?v_242 (= ?v_166 e1)) (?v_254 (= ?v_166 e2)) (?v_265 (= ?v_166 e3)) (?v_276 (= ?v_166 e4)) (?v_287 (= ?v_166 e5)) (?v_298 (= ?v_166 e6)) (?v_310 (= ?v_167 e0)) (?v_324 (= ?v_167 e1)) (?v_337 (= ?v_167 e2)) (?v_350 (= ?v_167 e3)) (?v_363 (= ?v_167 e4)) (?v_376 (= ?v_167 e5)) (?v_389 (= ?v_167 e6)) (?v_220 (= ?v_13 e0)) (?v_231 (= ?v_13 e1)) (?v_245 (= ?v_13 e2)) (?v_256 (= ?v_13 e3)) (?v_267 (= ?v_13 e4)) (?v_278 (= ?v_13 e5)) (?v_289 (= ?v_13 e6)) (?v_221 (= ?v_35 e0)) (?v_232 (= ?v_35 e1)) (?v_246 (= ?v_35 e2)) (?v_257 (= ?v_35 e3)) (?v_268 (= ?v_35 e4)) (?v_279 (= ?v_35 e5)) (?v_290 (= ?v_35 e6)) (?v_222 (= ?v_69 e0)) (?v_233 (= ?v_69 e1)) (?v_247 (= ?v_69 e2)) (?v_258 (= ?v_69 e3)) (?v_269 (= ?v_69 e4)) (?v_280 (= ?v_69 e5)) (?v_291 (= ?v_69 e6)) (?v_223 (= ?v_115 e0)) (?v_234 (= ?v_115 e1)) (?v_248 (= ?v_115 e2)) (?v_259 (= ?v_115 e3)) (?v_270 (= ?v_115 e4)) (?v_281 (= ?v_115 e5)) (?v_292 (= ?v_115 e6)) (?v_224 (= ?v_173 e0)) (?v_235 (= ?v_173 e1)) (?v_249 (= ?v_173 e2)) (?v_260 (= ?v_173 e3)) (?v_271 (= ?v_173 e4)) (?v_282 (= ?v_173 e5)) (?v_293 (= ?v_173 e6)) (?v_230 (= ?v_236 e0)) (?v_243 (= ?v_236 e1)) (?v_255 (= ?v_236 e2)) (?v_266 (= ?v_236 e3)) (?v_277 (= ?v_236 e4)) (?v_288 (= ?v_236 e5)) (?v_299 (= ?v_236 e6)) (?v_311 (= ?v_237 e0)) (?v_325 (= ?v_237 e1)) (?v_338 (= ?v_237 e2)) (?v_351 (= ?v_237 e3)) (?v_364 (= ?v_237 e4)) (?v_377 (= ?v_237 e5)) (?v_390 (= ?v_237 e6)) (?v_300 (= ?v_14 e0)) (?v_313 (= ?v_14 e1)) (?v_327 (= ?v_14 e2)) (?v_340 (= ?v_14 e3)) (?v_353 (= ?v_14 e4)) (?v_366 (= ?v_14 e5)) (?v_379 (= ?v_14 e6)) (?v_301 (= ?v_36 e0)) (?v_314 (= ?v_36 e1)) (?v_328 (= ?v_36 e2)) (?v_341 (= ?v_36 e3)) (?v_354 (= ?v_36 e4)) (?v_367 (= ?v_36 e5)) (?v_380 (= ?v_36 e6)) (?v_302 (= ?v_70 e0)) (?v_315 (= ?v_70 e1)) (?v_329 (= ?v_70 e2)) (?v_342 (= ?v_70 e3)) (?v_355 (= ?v_70 e4)) (?v_368 (= ?v_70 e5)) (?v_381 (= ?v_70 e6)) (?v_303 (= ?v_116 e0)) (?v_316 (= ?v_116 e1)) (?v_330 (= ?v_116 e2)) (?v_343 (= ?v_116 e3)) (?v_356 (= ?v_116 e4)) (?v_369 (= ?v_116 e5)) (?v_382 (= ?v_116 e6)) (?v_304 (= ?v_174 e0)) (?v_317 (= ?v_174 e1)) (?v_331 (= ?v_174 e2)) (?v_344 (= ?v_174 e3)) (?v_357 (= ?v_174 e4)) (?v_370 (= ?v_174 e5)) (?v_383 (= ?v_174 e6)) (?v_305 (= ?v_244 e0)) (?v_318 (= ?v_244 e1)) (?v_332 (= ?v_244 e2)) (?v_345 (= ?v_244 e3)) (?v_358 (= ?v_244 e4)) (?v_371 (= ?v_244 e5)) (?v_384 (= ?v_244 e6)) (?v_312 (= ?v_319 e0)) (?v_326 (= ?v_319 e1)) (?v_339 (= ?v_319 e2)) (?v_352 (= ?v_319 e3)) (?v_365 (= ?v_319 e4)) (?v_378 (= ?v_319 e5)) (?v_391 (= ?v_319 e6))) (and (and (and (and (and (and (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_0 ?v_21) ?v_54) ?v_99) ?v_156) ?v_225) ?v_306) (or (or (or (or (or (or ?v_0 ?v_20) ?v_52) ?v_96) ?v_152) ?v_220) ?v_300)) (and (or (or (or (or (or (or ?v_8 ?v_30) ?v_64) ?v_110) ?v_168) ?v_238) ?v_320) (or (or (or (or (or (or ?v_8 ?v_23) ?v_57) ?v_103) ?v_161) ?v_231) ?v_313))) (and (or (or (or (or (or (or ?v_15 ?v_38) ?v_73) ?v_120) ?v_179) ?v_250) ?v_333) (or (or (or (or (or (or ?v_15 ?v_37) ?v_71) ?v_117) ?v_175) ?v_245) ?v_327))) (and (or (or (or (or (or (or ?v_16 ?v_41) ?v_78) ?v_127) ?v_188) ?v_261) ?v_346) (or (or (or (or (or (or ?v_16 ?v_40) ?v_76) ?v_124) ?v_184) ?v_256) ?v_340))) (and (or (or (or (or (or (or ?v_17 ?v_44) ?v_83) ?v_134) ?v_197) ?v_272) ?v_359) (or (or (or (or (or (or ?v_17 ?v_43) ?v_81) ?v_131) ?v_193) ?v_267) ?v_353))) (and (or (or (or (or (or (or ?v_18 ?v_47) ?v_88) ?v_141) ?v_206) ?v_283) ?v_372) (or (or (or (or (or (or ?v_18 ?v_46) ?v_86) ?v_138) ?v_202) ?v_278) ?v_366))) (and (or (or (or (or (or (or ?v_19 ?v_50) ?v_93) ?v_148) ?v_215) ?v_294) ?v_385) (or (or (or (or (or (or ?v_19 ?v_49) ?v_91) ?v_145) ?v_211) ?v_289) ?v_379))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_20 ?v_22) ?v_55) ?v_100) ?v_157) ?v_226) ?v_307) (or (or (or (or (or (or ?v_21 ?v_22) ?v_53) ?v_97) ?v_153) ?v_221) ?v_301)) (and (or (or (or (or (or (or ?v_23 ?v_31) ?v_65) ?v_111) ?v_169) ?v_239) ?v_321) (or (or (or (or (or (or ?v_30 ?v_31) ?v_58) ?v_104) ?v_162) ?v_232) ?v_314))) (and (or (or (or (or (or (or ?v_37 ?v_39) ?v_74) ?v_121) ?v_180) ?v_251) ?v_334) (or (or (or (or (or (or ?v_38 ?v_39) ?v_72) ?v_118) ?v_176) ?v_246) ?v_328))) (and (or (or (or (or (or (or ?v_40 ?v_42) ?v_79) ?v_128) ?v_189) ?v_262) ?v_347) (or (or (or (or (or (or ?v_41 ?v_42) ?v_77) ?v_125) ?v_185) ?v_257) ?v_341))) (and (or (or (or (or (or (or ?v_43 ?v_45) ?v_84) ?v_135) ?v_198) ?v_273) ?v_360) (or (or (or (or (or (or ?v_44 ?v_45) ?v_82) ?v_132) ?v_194) ?v_268) ?v_354))) (and (or (or (or (or (or (or ?v_46 ?v_48) ?v_89) ?v_142) ?v_207) ?v_284) ?v_373) (or (or (or (or (or (or ?v_47 ?v_48) ?v_87) ?v_139) ?v_203) ?v_279) ?v_367))) (and (or (or (or (or (or (or ?v_49 ?v_51) ?v_94) ?v_149) ?v_216) ?v_295) ?v_386) (or (or (or (or (or (or ?v_50 ?v_51) ?v_92) ?v_146) ?v_212) ?v_290) ?v_380)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_52 ?v_53) ?v_56) ?v_101) ?v_158) ?v_227) ?v_308) (or (or (or (or (or (or ?v_54 ?v_55) ?v_56) ?v_98) ?v_154) ?v_222) ?v_302)) (and (or (or (or (or (or (or ?v_57 ?v_58) ?v_66) ?v_112) ?v_170) ?v_240) ?v_322) (or (or (or (or (or (or ?v_64 ?v_65) ?v_66) ?v_105) ?v_163) ?v_233) ?v_315))) (and (or (or (or (or (or (or ?v_71 ?v_72) ?v_75) ?v_122) ?v_181) ?v_252) ?v_335) (or (or (or (or (or (or ?v_73 ?v_74) ?v_75) ?v_119) ?v_177) ?v_247) ?v_329))) (and (or (or (or (or (or (or ?v_76 ?v_77) ?v_80) ?v_129) ?v_190) ?v_263) ?v_348) (or (or (or (or (or (or ?v_78 ?v_79) ?v_80) ?v_126) ?v_186) ?v_258) ?v_342))) (and (or (or (or (or (or (or ?v_81 ?v_82) ?v_85) ?v_136) ?v_199) ?v_274) ?v_361) (or (or (or (or (or (or ?v_83 ?v_84) ?v_85) ?v_133) ?v_195) ?v_269) ?v_355))) (and (or (or (or (or (or (or ?v_86 ?v_87) ?v_90) ?v_143) ?v_208) ?v_285) ?v_374) (or (or (or (or (or (or ?v_88 ?v_89) ?v_90) ?v_140) ?v_204) ?v_280) ?v_368))) (and (or (or (or (or (or (or ?v_91 ?v_92) ?v_95) ?v_150) ?v_217) ?v_296) ?v_387) (or (or (or (or (or (or ?v_93 ?v_94) ?v_95) ?v_147) ?v_213) ?v_291) ?v_381)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_96 ?v_97) ?v_98) ?v_102) ?v_159) ?v_228) ?v_309) (or (or (or (or (or (or ?v_99 ?v_100) ?v_101) ?v_102) ?v_155) ?v_223) ?v_303)) (and (or (or (or (or (or (or ?v_103 ?v_104) ?v_105) ?v_113) ?v_171) ?v_241) ?v_323) (or (or (or (or (or (or ?v_110 ?v_111) ?v_112) ?v_113) ?v_164) ?v_234) ?v_316))) (and (or (or (or (or (or (or ?v_117 ?v_118) ?v_119) ?v_123) ?v_182) ?v_253) ?v_336) (or (or (or (or (or (or ?v_120 ?v_121) ?v_122) ?v_123) ?v_178) ?v_248) ?v_330))) (and (or (or (or (or (or (or ?v_124 ?v_125) ?v_126) ?v_130) ?v_191) ?v_264) ?v_349) (or (or (or (or (or (or ?v_127 ?v_128) ?v_129) ?v_130) ?v_187) ?v_259) ?v_343))) (and (or (or (or (or (or (or ?v_131 ?v_132) ?v_133) ?v_137) ?v_200) ?v_275) ?v_362) (or (or (or (or (or (or ?v_134 ?v_135) ?v_136) ?v_137) ?v_196) ?v_270) ?v_356))) (and (or (or (or (or (or (or ?v_138 ?v_139) ?v_140) ?v_144) ?v_209) ?v_286) ?v_375) (or (or (or (or (or (or ?v_141 ?v_142) ?v_143) ?v_144) ?v_205) ?v_281) ?v_369))) (and (or (or (or (or (or (or ?v_145 ?v_146) ?v_147) ?v_151) ?v_218) ?v_297) ?v_388) (or (or (or (or (or (or ?v_148 ?v_149) ?v_150) ?v_151) ?v_214) ?v_292) ?v_382)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_152 ?v_153) ?v_154) ?v_155) ?v_160) ?v_229) ?v_310) (or (or (or (or (or (or ?v_156 ?v_157) ?v_158) ?v_159) ?v_160) ?v_224) ?v_304)) (and (or (or (or (or (or (or ?v_161 ?v_162) ?v_163) ?v_164) ?v_172) ?v_242) ?v_324) (or (or (or (or (or (or ?v_168 ?v_169) ?v_170) ?v_171) ?v_172) ?v_235) ?v_317))) (and (or (or (or (or (or (or ?v_175 ?v_176) ?v_177) ?v_178) ?v_183) ?v_254) ?v_337) (or (or (or (or (or (or ?v_179 ?v_180) ?v_181) ?v_182) ?v_183) ?v_249) ?v_331))) (and (or (or (or (or (or (or ?v_184 ?v_185) ?v_186) ?v_187) ?v_192) ?v_265) ?v_350) (or (or (or (or (or (or ?v_188 ?v_189) ?v_190) ?v_191) ?v_192) ?v_260) ?v_344))) (and (or (or (or (or (or (or ?v_193 ?v_194) ?v_195) ?v_196) ?v_201) ?v_276) ?v_363) (or (or (or (or (or (or ?v_197 ?v_198) ?v_199) ?v_200) ?v_201) ?v_271) ?v_357))) (and (or (or (or (or (or (or ?v_202 ?v_203) ?v_204) ?v_205) ?v_210) ?v_287) ?v_376) (or (or (or (or (or (or ?v_206 ?v_207) ?v_208) ?v_209) ?v_210) ?v_282) ?v_370))) (and (or (or (or (or (or (or ?v_211 ?v_212) ?v_213) ?v_214) ?v_219) ?v_298) ?v_389) (or (or (or (or (or (or ?v_215 ?v_216) ?v_217) ?v_218) ?v_219) ?v_293) ?v_383)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_220 ?v_221) ?v_222) ?v_223) ?v_224) ?v_230) ?v_311) (or (or (or (or (or (or ?v_225 ?v_226) ?v_227) ?v_228) ?v_229) ?v_230) ?v_305)) (and (or (or (or (or (or (or ?v_231 ?v_232) ?v_233) ?v_234) ?v_235) ?v_243) ?v_325) (or (or (or (or (or (or ?v_238 ?v_239) ?v_240) ?v_241) ?v_242) ?v_243) ?v_318))) (and (or (or (or (or (or (or ?v_245 ?v_246) ?v_247) ?v_248) ?v_249) ?v_255) ?v_338) (or (or (or (or (or (or ?v_250 ?v_251) ?v_252) ?v_253) ?v_254) ?v_255) ?v_332))) (and (or (or (or (or (or (or ?v_256 ?v_257) ?v_258) ?v_259) ?v_260) ?v_266) ?v_351) (or (or (or (or (or (or ?v_261 ?v_262) ?v_263) ?v_264) ?v_265) ?v_266) ?v_345))) (and (or (or (or (or (or (or ?v_267 ?v_268) ?v_269) ?v_270) ?v_271) ?v_277) ?v_364) (or (or (or (or (or (or ?v_272 ?v_273) ?v_274) ?v_275) ?v_276) ?v_277) ?v_358))) (and (or (or (or (or (or (or ?v_278 ?v_279) ?v_280) ?v_281) ?v_282) ?v_288) ?v_377) (or (or (or (or (or (or ?v_283 ?v_284) ?v_285) ?v_286) ?v_287) ?v_288) ?v_371))) (and (or (or (or (or (or (or ?v_289 ?v_290) ?v_291) ?v_292) ?v_293) ?v_299) ?v_390) (or (or (or (or (or (or ?v_294 ?v_295) ?v_296) ?v_297) ?v_298) ?v_299) ?v_384)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_300 ?v_301) ?v_302) ?v_303) ?v_304) ?v_305) ?v_312) (or (or (or (or (or (or ?v_306 ?v_307) ?v_308) ?v_309) ?v_310) ?v_311) ?v_312)) (and (or (or (or (or (or (or ?v_313 ?v_314) ?v_315) ?v_316) ?v_317) ?v_318) ?v_326) (or (or (or (or (or (or ?v_320 ?v_321) ?v_322) ?v_323) ?v_324) ?v_325) ?v_326))) (and (or (or (or (or (or (or ?v_327 ?v_328) ?v_329) ?v_330) ?v_331) ?v_332) ?v_339) (or (or (or (or (or (or ?v_333 ?v_334) ?v_335) ?v_336) ?v_337) ?v_338) ?v_339))) (and (or (or (or (or (or (or ?v_340 ?v_341) ?v_342) ?v_343) ?v_344) ?v_345) ?v_352) (or (or (or (or (or (or ?v_346 ?v_347) ?v_348) ?v_349) ?v_350) ?v_351) ?v_352))) (and (or (or (or (or (or (or ?v_353 ?v_354) ?v_355) ?v_356) ?v_357) ?v_358) ?v_365) (or (or (or (or (or (or ?v_359 ?v_360) ?v_361) ?v_362) ?v_363) ?v_364) ?v_365))) (and (or (or (or (or (or (or ?v_366 ?v_367) ?v_368) ?v_369) ?v_370) ?v_371) ?v_378) (or (or (or (or (or (or ?v_372 ?v_373) ?v_374) ?v_375) ?v_376) ?v_377) ?v_378))) (and (or (or (or (or (or (or ?v_379 ?v_380) ?v_381) ?v_382) ?v_383) ?v_384) ?v_391) (or (or (or (or (or (or ?v_385 ?v_386) ?v_387) ?v_388) ?v_389) ?v_390) ?v_391)))))) :named XyvMcrKEdQw)) (assert(! (and (and (and (and (and (and (and (and (and (and (and (and (= (op (op (op e0 e0) e0) e0) e0) (= (op (op (op e0 e1) e1) e1) e0)) (= (op (op (op e0 e2) e2) e2) e0)) (= (op (op (op e0 e3) e3) e3) e0)) (= (op (op (op e0 e4) e4) e4) e0)) (= (op (op (op e0 e5) e5) e5) e0)) (= (op (op (op e0 e6) e6) e6) e0)) (and (and (and (and (and (and (= (op (op (op e1 e0) e0) e0) e1) (= (op (op (op e1 e1) e1) e1) e1)) (= (op (op (op e1 e2) e2) e2) e1)) (= (op (op (op e1 e3) e3) e3) e1)) (= (op (op (op e1 e4) e4) e4) e1)) (= (op (op (op e1 e5) e5) e5) e1)) (= (op (op (op e1 e6) e6) e6) e1))) (and (and (and (and (and (and (= (op (op (op e2 e0) e0) e0) e2) (= (op (op (op e2 e1) e1) e1) e2)) (= (op (op (op e2 e2) e2) e2) e2)) (= (op (op (op e2 e3) e3) e3) e2)) (= (op (op (op e2 e4) e4) e4) e2)) (= (op (op (op e2 e5) e5) e5) e2)) (= (op (op (op e2 e6) e6) e6) e2))) (and (and (and (and (and (and (= (op (op (op e3 e0) e0) e0) e3) (= (op (op (op e3 e1) e1) e1) e3)) (= (op (op (op e3 e2) e2) e2) e3)) (= (op (op (op e3 e3) e3) e3) e3)) (= (op (op (op e3 e4) e4) e4) e3)) (= (op (op (op e3 e5) e5) e5) e3)) (= (op (op (op e3 e6) e6) e6) e3))) (and (and (and (and (and (and (= (op (op (op e4 e0) e0) e0) e4) (= (op (op (op e4 e1) e1) e1) e4)) (= (op (op (op e4 e2) e2) e2) e4)) (= (op (op (op e4 e3) e3) e3) e4)) (= (op (op (op e4 e4) e4) e4) e4)) (= (op (op (op e4 e5) e5) e5) e4)) (= (op (op (op e4 e6) e6) e6) e4))) (and (and (and (and (and (and (= (op (op (op e5 e0) e0) e0) e5) (= (op (op (op e5 e1) e1) e1) e5)) (= (op (op (op e5 e2) e2) e2) e5)) (= (op (op (op e5 e3) e3) e3) e5)) (= (op (op (op e5 e4) e4) e4) e5)) (= (op (op (op e5 e5) e5) e5) e5)) (= (op (op (op e5 e6) e6) e6) e5))) (and (and (and (and (and (and (= (op (op (op e6 e0) e0) e0) e6) (= (op (op (op e6 e1) e1) e1) e6)) (= (op (op (op e6 e2) e2) e2) e6)) (= (op (op (op e6 e3) e3) e3) e6)) (= (op (op (op e6 e4) e4) e4) e6)) (= (op (op (op e6 e5) e5) e5) e6)) (= (op (op (op e6 e6) e6) e6) e6))) :named tyIyyobDwxthvNS)) (assert(! (and (and (and (and (and (and (not (= (op e0 e0) e0)) (not (= (op e1 e1) e1))) (not (= (op e2 e2) e2))) (not (= (op e3 e3) e3))) (not (= (op e4 e4) e4))) (not (= (op e5 e5) e5))) (not (= (op e6 e6) e6))) :named RVEhNeqTomZduOEUV)) (assert(! (let ((?v_0 (skc1 e0)) (?v_1 (skc1 e1)) (?v_2 (skc1 e2)) (?v_3 (skc1 e3)) (?v_4 (skc1 e4)) (?v_5 (skc1 e5)) (?v_6 (skc1 e6))) (and (and (and (and (and (and (and (= (op e0 ?v_0) ?v_0) (= (op e1 ?v_1) ?v_1)) (= (op e2 ?v_2) ?v_2)) (= (op e3 ?v_3) ?v_3)) (= (op e4 ?v_4) ?v_4)) (= (op e5 ?v_5) ?v_5)) (= (op e6 ?v_6) ?v_6)) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_0 e0) (= ?v_0 e1)) (= ?v_0 e2)) (= ?v_0 e3)) (= ?v_0 e4)) (= ?v_0 e5)) (= ?v_0 e6)) (or (or (or (or (or (or (= ?v_1 e0) (= ?v_1 e1)) (= ?v_1 e2)) (= ?v_1 e3)) (= ?v_1 e4)) (= ?v_1 e5)) (= ?v_1 e6))) (or (or (or (or (or (or (= ?v_2 e0) (= ?v_2 e1)) (= ?v_2 e2)) (= ?v_2 e3)) (= ?v_2 e4)) (= ?v_2 e5)) (= ?v_2 e6))) (or (or (or (or (or (or (= ?v_3 e0) (= ?v_3 e1)) (= ?v_3 e2)) (= ?v_3 e3)) (= ?v_3 e4)) (= ?v_3 e5)) (= ?v_3 e6))) (or (or (or (or (or (or (= ?v_4 e0) (= ?v_4 e1)) (= ?v_4 e2)) (= ?v_4 e3)) (= ?v_4 e4)) (= ?v_4 e5)) (= ?v_4 e6))) (or (or (or (or (or (or (= ?v_5 e0) (= ?v_5 e1)) (= ?v_5 e2)) (= ?v_5 e3)) (= ?v_5 e4)) (= ?v_5 e5)) (= ?v_5 e6))) (or (or (or (or (or (or (= ?v_6 e0) (= ?v_6 e1)) (= ?v_6 e2)) (= ?v_6 e3)) (= ?v_6 e4)) (= ?v_6 e5)) (= ?v_6 e6))))) :named tocqokFIDgPbRcH)) (assert(! (let ((?v_0 (op e0 e0)) (?v_7 (op e0 e1)) (?v_14 (op e0 e2)) (?v_21 (op e0 e3)) (?v_28 (op e0 e4)) (?v_35 (op e0 e5)) (?v_42 (op e0 e6)) (?v_1 (op e1 e0)) (?v_8 (op e1 e1)) (?v_15 (op e1 e2)) (?v_22 (op e1 e3)) (?v_29 (op e1 e4)) (?v_36 (op e1 e5)) (?v_43 (op e1 e6)) (?v_2 (op e2 e0)) (?v_9 (op e2 e1)) (?v_16 (op e2 e2)) (?v_23 (op e2 e3)) (?v_30 (op e2 e4)) (?v_37 (op e2 e5)) (?v_44 (op e2 e6)) (?v_3 (op e3 e0)) (?v_10 (op e3 e1)) (?v_17 (op e3 e2)) (?v_24 (op e3 e3)) (?v_31 (op e3 e4)) (?v_38 (op e3 e5)) (?v_45 (op e3 e6)) (?v_4 (op e4 e0)) (?v_11 (op e4 e1)) (?v_18 (op e4 e2)) (?v_25 (op e4 e3)) (?v_32 (op e4 e4)) (?v_39 (op e4 e5)) (?v_46 (op e4 e6)) (?v_5 (op e5 e0)) (?v_12 (op e5 e1)) (?v_19 (op e5 e2)) (?v_26 (op e5 e3)) (?v_33 (op e5 e4)) (?v_40 (op e5 e5)) (?v_47 (op e5 e6)) (?v_6 (op e6 e0)) (?v_13 (op e6 e1)) (?v_20 (op e6 e2)) (?v_27 (op e6 e3)) (?v_34 (op e6 e4)) (?v_41 (op e6 e5)) (?v_48 (op e6 e6))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_1)) (not (= ?v_0 ?v_2))) (not (= ?v_0 ?v_3))) (not (= ?v_0 ?v_4))) (not (= ?v_0 ?v_5))) (not (= ?v_0 ?v_6))) (not (= ?v_1 ?v_2))) (not (= ?v_1 ?v_3))) (not (= ?v_1 ?v_4))) (not (= ?v_1 ?v_5))) (not (= ?v_1 ?v_6))) (not (= ?v_2 ?v_3))) (not (= ?v_2 ?v_4))) (not (= ?v_2 ?v_5))) (not (= ?v_2 ?v_6))) (not (= ?v_3 ?v_4))) (not (= ?v_3 ?v_5))) (not (= ?v_3 ?v_6))) (not (= ?v_4 ?v_5))) (not (= ?v_4 ?v_6))) (not (= ?v_5 ?v_6))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_7 ?v_8)) (not (= ?v_7 ?v_9))) (not (= ?v_7 ?v_10))) (not (= ?v_7 ?v_11))) (not (= ?v_7 ?v_12))) (not (= ?v_7 ?v_13))) (not (= ?v_8 ?v_9))) (not (= ?v_8 ?v_10))) (not (= ?v_8 ?v_11))) (not (= ?v_8 ?v_12))) (not (= ?v_8 ?v_13))) (not (= ?v_9 ?v_10))) (not (= ?v_9 ?v_11))) (not (= ?v_9 ?v_12))) (not (= ?v_9 ?v_13))) (not (= ?v_10 ?v_11))) (not (= ?v_10 ?v_12))) (not (= ?v_10 ?v_13))) (not (= ?v_11 ?v_12))) (not (= ?v_11 ?v_13))) (not (= ?v_12 ?v_13)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_14 ?v_15)) (not (= ?v_14 ?v_16))) (not (= ?v_14 ?v_17))) (not (= ?v_14 ?v_18))) (not (= ?v_14 ?v_19))) (not (= ?v_14 ?v_20))) (not (= ?v_15 ?v_16))) (not (= ?v_15 ?v_17))) (not (= ?v_15 ?v_18))) (not (= ?v_15 ?v_19))) (not (= ?v_15 ?v_20))) (not (= ?v_16 ?v_17))) (not (= ?v_16 ?v_18))) (not (= ?v_16 ?v_19))) (not (= ?v_16 ?v_20))) (not (= ?v_17 ?v_18))) (not (= ?v_17 ?v_19))) (not (= ?v_17 ?v_20))) (not (= ?v_18 ?v_19))) (not (= ?v_18 ?v_20))) (not (= ?v_19 ?v_20)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_21 ?v_22)) (not (= ?v_21 ?v_23))) (not (= ?v_21 ?v_24))) (not (= ?v_21 ?v_25))) (not (= ?v_21 ?v_26))) (not (= ?v_21 ?v_27))) (not (= ?v_22 ?v_23))) (not (= ?v_22 ?v_24))) (not (= ?v_22 ?v_25))) (not (= ?v_22 ?v_26))) (not (= ?v_22 ?v_27))) (not (= ?v_23 ?v_24))) (not (= ?v_23 ?v_25))) (not (= ?v_23 ?v_26))) (not (= ?v_23 ?v_27))) (not (= ?v_24 ?v_25))) (not (= ?v_24 ?v_26))) (not (= ?v_24 ?v_27))) (not (= ?v_25 ?v_26))) (not (= ?v_25 ?v_27))) (not (= ?v_26 ?v_27)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_28 ?v_29)) (not (= ?v_28 ?v_30))) (not (= ?v_28 ?v_31))) (not (= ?v_28 ?v_32))) (not (= ?v_28 ?v_33))) (not (= ?v_28 ?v_34))) (not (= ?v_29 ?v_30))) (not (= ?v_29 ?v_31))) (not (= ?v_29 ?v_32))) (not (= ?v_29 ?v_33))) (not (= ?v_29 ?v_34))) (not (= ?v_30 ?v_31))) (not (= ?v_30 ?v_32))) (not (= ?v_30 ?v_33))) (not (= ?v_30 ?v_34))) (not (= ?v_31 ?v_32))) (not (= ?v_31 ?v_33))) (not (= ?v_31 ?v_34))) (not (= ?v_32 ?v_33))) (not (= ?v_32 ?v_34))) (not (= ?v_33 ?v_34)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_35 ?v_36)) (not (= ?v_35 ?v_37))) (not (= ?v_35 ?v_38))) (not (= ?v_35 ?v_39))) (not (= ?v_35 ?v_40))) (not (= ?v_35 ?v_41))) (not (= ?v_36 ?v_37))) (not (= ?v_36 ?v_38))) (not (= ?v_36 ?v_39))) (not (= ?v_36 ?v_40))) (not (= ?v_36 ?v_41))) (not (= ?v_37 ?v_38))) (not (= ?v_37 ?v_39))) (not (= ?v_37 ?v_40))) (not (= ?v_37 ?v_41))) (not (= ?v_38 ?v_39))) (not (= ?v_38 ?v_40))) (not (= ?v_38 ?v_41))) (not (= ?v_39 ?v_40))) (not (= ?v_39 ?v_41))) (not (= ?v_40 ?v_41)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_42 ?v_43)) (not (= ?v_42 ?v_44))) (not (= ?v_42 ?v_45))) (not (= ?v_42 ?v_46))) (not (= ?v_42 ?v_47))) (not (= ?v_42 ?v_48))) (not (= ?v_43 ?v_44))) (not (= ?v_43 ?v_45))) (not (= ?v_43 ?v_46))) (not (= ?v_43 ?v_47))) (not (= ?v_43 ?v_48))) (not (= ?v_44 ?v_45))) (not (= ?v_44 ?v_46))) (not (= ?v_44 ?v_47))) (not (= ?v_44 ?v_48))) (not (= ?v_45 ?v_46))) (not (= ?v_45 ?v_47))) (not (= ?v_45 ?v_48))) (not (= ?v_46 ?v_47))) (not (= ?v_46 ?v_48))) (not (= ?v_47 ?v_48)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_7)) (not (= ?v_0 ?v_14))) (not (= ?v_0 ?v_21))) (not (= ?v_0 ?v_28))) (not (= ?v_0 ?v_35))) (not (= ?v_0 ?v_42))) (not (= ?v_7 ?v_14))) (not (= ?v_7 ?v_21))) (not (= ?v_7 ?v_28))) (not (= ?v_7 ?v_35))) (not (= ?v_7 ?v_42))) (not (= ?v_14 ?v_21))) (not (= ?v_14 ?v_28))) (not (= ?v_14 ?v_35))) (not (= ?v_14 ?v_42))) (not (= ?v_21 ?v_28))) (not (= ?v_21 ?v_35))) (not (= ?v_21 ?v_42))) (not (= ?v_28 ?v_35))) (not (= ?v_28 ?v_42))) (not (= ?v_35 ?v_42))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_1 ?v_8)) (not (= ?v_1 ?v_15))) (not (= ?v_1 ?v_22))) (not (= ?v_1 ?v_29))) (not (= ?v_1 ?v_36))) (not (= ?v_1 ?v_43))) (not (= ?v_8 ?v_15))) (not (= ?v_8 ?v_22))) (not (= ?v_8 ?v_29))) (not (= ?v_8 ?v_36))) (not (= ?v_8 ?v_43))) (not (= ?v_15 ?v_22))) (not (= ?v_15 ?v_29))) (not (= ?v_15 ?v_36))) (not (= ?v_15 ?v_43))) (not (= ?v_22 ?v_29))) (not (= ?v_22 ?v_36))) (not (= ?v_22 ?v_43))) (not (= ?v_29 ?v_36))) (not (= ?v_29 ?v_43))) (not (= ?v_36 ?v_43)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_2 ?v_9)) (not (= ?v_2 ?v_16))) (not (= ?v_2 ?v_23))) (not (= ?v_2 ?v_30))) (not (= ?v_2 ?v_37))) (not (= ?v_2 ?v_44))) (not (= ?v_9 ?v_16))) (not (= ?v_9 ?v_23))) (not (= ?v_9 ?v_30))) (not (= ?v_9 ?v_37))) (not (= ?v_9 ?v_44))) (not (= ?v_16 ?v_23))) (not (= ?v_16 ?v_30))) (not (= ?v_16 ?v_37))) (not (= ?v_16 ?v_44))) (not (= ?v_23 ?v_30))) (not (= ?v_23 ?v_37))) (not (= ?v_23 ?v_44))) (not (= ?v_30 ?v_37))) (not (= ?v_30 ?v_44))) (not (= ?v_37 ?v_44)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_3 ?v_10)) (not (= ?v_3 ?v_17))) (not (= ?v_3 ?v_24))) (not (= ?v_3 ?v_31))) (not (= ?v_3 ?v_38))) (not (= ?v_3 ?v_45))) (not (= ?v_10 ?v_17))) (not (= ?v_10 ?v_24))) (not (= ?v_10 ?v_31))) (not (= ?v_10 ?v_38))) (not (= ?v_10 ?v_45))) (not (= ?v_17 ?v_24))) (not (= ?v_17 ?v_31))) (not (= ?v_17 ?v_38))) (not (= ?v_17 ?v_45))) (not (= ?v_24 ?v_31))) (not (= ?v_24 ?v_38))) (not (= ?v_24 ?v_45))) (not (= ?v_31 ?v_38))) (not (= ?v_31 ?v_45))) (not (= ?v_38 ?v_45)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_4 ?v_11)) (not (= ?v_4 ?v_18))) (not (= ?v_4 ?v_25))) (not (= ?v_4 ?v_32))) (not (= ?v_4 ?v_39))) (not (= ?v_4 ?v_46))) (not (= ?v_11 ?v_18))) (not (= ?v_11 ?v_25))) (not (= ?v_11 ?v_32))) (not (= ?v_11 ?v_39))) (not (= ?v_11 ?v_46))) (not (= ?v_18 ?v_25))) (not (= ?v_18 ?v_32))) (not (= ?v_18 ?v_39))) (not (= ?v_18 ?v_46))) (not (= ?v_25 ?v_32))) (not (= ?v_25 ?v_39))) (not (= ?v_25 ?v_46))) (not (= ?v_32 ?v_39))) (not (= ?v_32 ?v_46))) (not (= ?v_39 ?v_46)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_5 ?v_12)) (not (= ?v_5 ?v_19))) (not (= ?v_5 ?v_26))) (not (= ?v_5 ?v_33))) (not (= ?v_5 ?v_40))) (not (= ?v_5 ?v_47))) (not (= ?v_12 ?v_19))) (not (= ?v_12 ?v_26))) (not (= ?v_12 ?v_33))) (not (= ?v_12 ?v_40))) (not (= ?v_12 ?v_47))) (not (= ?v_19 ?v_26))) (not (= ?v_19 ?v_33))) (not (= ?v_19 ?v_40))) (not (= ?v_19 ?v_47))) (not (= ?v_26 ?v_33))) (not (= ?v_26 ?v_40))) (not (= ?v_26 ?v_47))) (not (= ?v_33 ?v_40))) (not (= ?v_33 ?v_47))) (not (= ?v_40 ?v_47)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_6 ?v_13)) (not (= ?v_6 ?v_20))) (not (= ?v_6 ?v_27))) (not (= ?v_6 ?v_34))) (not (= ?v_6 ?v_41))) (not (= ?v_6 ?v_48))) (not (= ?v_13 ?v_20))) (not (= ?v_13 ?v_27))) (not (= ?v_13 ?v_34))) (not (= ?v_13 ?v_41))) (not (= ?v_13 ?v_48))) (not (= ?v_20 ?v_27))) (not (= ?v_20 ?v_34))) (not (= ?v_20 ?v_41))) (not (= ?v_20 ?v_48))) (not (= ?v_27 ?v_34))) (not (= ?v_27 ?v_41))) (not (= ?v_27 ?v_48))) (not (= ?v_34 ?v_41))) (not (= ?v_34 ?v_48))) (not (= ?v_41 ?v_48)))))) :named jFvGvghHoYAULY)) (assert(! (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= e0 e1)) (not (= e0 e2))) (not (= e0 e3))) (not (= e0 e4))) (not (= e0 e5))) (not (= e0 e6))) (not (= e1 e2))) (not (= e1 e3))) (not (= e1 e4))) (not (= e1 e5))) (not (= e1 e6))) (not (= e2 e3))) (not (= e2 e4))) (not (= e2 e5))) (not (= e2 e6))) (not (= e3 e4))) (not (= e3 e5))) (not (= e3 e6))) (not (= e4 e5))) (not (= e4 e6))) (not (= e5 e6))) :named qAKbTMXUQMBOw)) (assert(! (and (and (and (and (and (= e0 (op e6 e6)) (= e1 (op e2 e2))) (= e2 (op e5 e6))) (= e3 (op e0 e0))) (= e4 (op e1 e5))) (= e5 (op e3 e6))) :named RrARoYIhGXaGFdb)) (assert(! (not (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= (op e0 e0) e3) (= (op e0 e1) e5)) (= (op e0 e2) e0)) (= (op e0 e3) e6)) (= (op e0 e4) e4)) (= (op e0 e5) e2)) (= (op e0 e6) e1)) (= (op e1 e0) e2)) (= (op e1 e1) e0)) (= (op e1 e2) e3)) (= (op e1 e3) e5)) (= (op e1 e4) e1)) (= (op e1 e5) e4)) (= (op e1 e6) e6)) (= (op e2 e0) e6)) (= (op e2 e1) e4)) (= (op e2 e2) e1)) (= (op e2 e3) e2)) (= (op e2 e4) e0)) (= (op e2 e5) e5)) (= (op e2 e6) e3)) (= (op e3 e0) e4)) (= (op e3 e1) e3)) (= (op e3 e2) e2)) (= (op e3 e3) e0)) (= (op e3 e4) e6)) (= (op e3 e5) e1)) (= (op e3 e6) e5)) (= (op e4 e0) e0)) (= (op e4 e1) e6)) (= (op e4 e2) e5)) (= (op e4 e3) e1)) (= (op e4 e4) e2)) (= (op e4 e5) e3)) (= (op e4 e6) e4)) (= (op e5 e0) e5)) (= (op e5 e1) e1)) (= (op e5 e2) e6)) (= (op e5 e3) e4)) (= (op e5 e4) e3)) (= (op e5 e5) e0)) (= (op e5 e6) e2)) (= (op e6 e0) e1)) (= (op e6 e1) e2)) (= (op e6 e2) e4)) (= (op e6 e3) e3)) (= (op e6 e4) e5)) (= (op e6 e5) e6)) (= (op e6 e6) e0))) :named aEhGXBdtsekb)) (check-sat) opensmt-2.5.2/regression/picky/iso_brn_sk003_eufexps.smt2.expected.err000066400000000000000000000000001445011647600260120ustar00rootroot00000000000000opensmt-2.5.2/regression/picky/iso_brn_sk003_eufexps.smt2.expected.out000066400000000000000000000000061445011647600260370ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/picky/iso_brn_sk004_eufexps.smt2000066400000000000000000001142641445011647600234460ustar00rootroot00000000000000(set-option :picky true) (set-option :picky_w 10) (set-logic QF_UF) (set-info :source | http://www.cs.bham.ac.uk/~vxs/quasigroups/benchmark/ |) (set-info :smt-lib-version 2.0) (set-info :category "crafted") (set-info :status unsat) (declare-sort U 0) (declare-sort I 0) (declare-fun op1 (I I) I) (declare-fun op (I I) I) (declare-fun e6 () I) (declare-fun e5 () I) (declare-fun e4 () I) (declare-fun e3 () I) (declare-fun e2 () I) (declare-fun e1 () I) (declare-fun e0 () I) (declare-fun skc1 (I) I) (declare-fun skc2 () I) (declare-fun skc3 () I) (assert(! (let ((?v_0 (op e0 e0)) (?v_1 (op e0 e1)) (?v_2 (op e0 e2)) (?v_3 (op e0 e3)) (?v_4 (op e0 e4)) (?v_5 (op e0 e5)) (?v_6 (op e0 e6)) (?v_7 (op e1 e0)) (?v_8 (op e1 e1)) (?v_9 (op e1 e2)) (?v_10 (op e1 e3)) (?v_11 (op e1 e4)) (?v_12 (op e1 e5)) (?v_13 (op e1 e6)) (?v_14 (op e2 e0)) (?v_15 (op e2 e1)) (?v_16 (op e2 e2)) (?v_17 (op e2 e3)) (?v_18 (op e2 e4)) (?v_19 (op e2 e5)) (?v_20 (op e2 e6)) (?v_21 (op e3 e0)) (?v_22 (op e3 e1)) (?v_23 (op e3 e2)) (?v_24 (op e3 e3)) (?v_25 (op e3 e4)) (?v_26 (op e3 e5)) (?v_27 (op e3 e6)) (?v_28 (op e4 e0)) (?v_29 (op e4 e1)) (?v_30 (op e4 e2)) (?v_31 (op e4 e3)) (?v_32 (op e4 e4)) (?v_33 (op e4 e5)) (?v_34 (op e4 e6)) (?v_35 (op e5 e0)) (?v_36 (op e5 e1)) (?v_37 (op e5 e2)) (?v_38 (op e5 e3)) (?v_39 (op e5 e4)) (?v_40 (op e5 e5)) (?v_41 (op e5 e6)) (?v_42 (op e6 e0)) (?v_43 (op e6 e1)) (?v_44 (op e6 e2)) (?v_45 (op e6 e3)) (?v_46 (op e6 e4)) (?v_47 (op e6 e5)) (?v_48 (op e6 e6))) (and (and (and (and (and (and (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_0 e0) (= ?v_0 e1)) (= ?v_0 e2)) (= ?v_0 e3)) (= ?v_0 e4)) (= ?v_0 e5)) (= ?v_0 e6)) (or (or (or (or (or (or (= ?v_1 e0) (= ?v_1 e1)) (= ?v_1 e2)) (= ?v_1 e3)) (= ?v_1 e4)) (= ?v_1 e5)) (= ?v_1 e6))) (or (or (or (or (or (or (= ?v_2 e0) (= ?v_2 e1)) (= ?v_2 e2)) (= ?v_2 e3)) (= ?v_2 e4)) (= ?v_2 e5)) (= ?v_2 e6))) (or (or (or (or (or (or (= ?v_3 e0) (= ?v_3 e1)) (= ?v_3 e2)) (= ?v_3 e3)) (= ?v_3 e4)) (= ?v_3 e5)) (= ?v_3 e6))) (or (or (or (or (or (or (= ?v_4 e0) (= ?v_4 e1)) (= ?v_4 e2)) (= ?v_4 e3)) (= ?v_4 e4)) (= ?v_4 e5)) (= ?v_4 e6))) (or (or (or (or (or (or (= ?v_5 e0) (= ?v_5 e1)) (= ?v_5 e2)) (= ?v_5 e3)) (= ?v_5 e4)) (= ?v_5 e5)) (= ?v_5 e6))) (or (or (or (or (or (or (= ?v_6 e0) (= ?v_6 e1)) (= ?v_6 e2)) (= ?v_6 e3)) (= ?v_6 e4)) (= ?v_6 e5)) (= ?v_6 e6))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_7 e0) (= ?v_7 e1)) (= ?v_7 e2)) (= ?v_7 e3)) (= ?v_7 e4)) (= ?v_7 e5)) (= ?v_7 e6)) (or (or (or (or (or (or (= ?v_8 e0) (= ?v_8 e1)) (= ?v_8 e2)) (= ?v_8 e3)) (= ?v_8 e4)) (= ?v_8 e5)) (= ?v_8 e6))) (or (or (or (or (or (or (= ?v_9 e0) (= ?v_9 e1)) (= ?v_9 e2)) (= ?v_9 e3)) (= ?v_9 e4)) (= ?v_9 e5)) (= ?v_9 e6))) (or (or (or (or (or (or (= ?v_10 e0) (= ?v_10 e1)) (= ?v_10 e2)) (= ?v_10 e3)) (= ?v_10 e4)) (= ?v_10 e5)) (= ?v_10 e6))) (or (or (or (or (or (or (= ?v_11 e0) (= ?v_11 e1)) (= ?v_11 e2)) (= ?v_11 e3)) (= ?v_11 e4)) (= ?v_11 e5)) (= ?v_11 e6))) (or (or (or (or (or (or (= ?v_12 e0) (= ?v_12 e1)) (= ?v_12 e2)) (= ?v_12 e3)) (= ?v_12 e4)) (= ?v_12 e5)) (= ?v_12 e6))) (or (or (or (or (or (or (= ?v_13 e0) (= ?v_13 e1)) (= ?v_13 e2)) (= ?v_13 e3)) (= ?v_13 e4)) (= ?v_13 e5)) (= ?v_13 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_14 e0) (= ?v_14 e1)) (= ?v_14 e2)) (= ?v_14 e3)) (= ?v_14 e4)) (= ?v_14 e5)) (= ?v_14 e6)) (or (or (or (or (or (or (= ?v_15 e0) (= ?v_15 e1)) (= ?v_15 e2)) (= ?v_15 e3)) (= ?v_15 e4)) (= ?v_15 e5)) (= ?v_15 e6))) (or (or (or (or (or (or (= ?v_16 e0) (= ?v_16 e1)) (= ?v_16 e2)) (= ?v_16 e3)) (= ?v_16 e4)) (= ?v_16 e5)) (= ?v_16 e6))) (or (or (or (or (or (or (= ?v_17 e0) (= ?v_17 e1)) (= ?v_17 e2)) (= ?v_17 e3)) (= ?v_17 e4)) (= ?v_17 e5)) (= ?v_17 e6))) (or (or (or (or (or (or (= ?v_18 e0) (= ?v_18 e1)) (= ?v_18 e2)) (= ?v_18 e3)) (= ?v_18 e4)) (= ?v_18 e5)) (= ?v_18 e6))) (or (or (or (or (or (or (= ?v_19 e0) (= ?v_19 e1)) (= ?v_19 e2)) (= ?v_19 e3)) (= ?v_19 e4)) (= ?v_19 e5)) (= ?v_19 e6))) (or (or (or (or (or (or (= ?v_20 e0) (= ?v_20 e1)) (= ?v_20 e2)) (= ?v_20 e3)) (= ?v_20 e4)) (= ?v_20 e5)) (= ?v_20 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_21 e0) (= ?v_21 e1)) (= ?v_21 e2)) (= ?v_21 e3)) (= ?v_21 e4)) (= ?v_21 e5)) (= ?v_21 e6)) (or (or (or (or (or (or (= ?v_22 e0) (= ?v_22 e1)) (= ?v_22 e2)) (= ?v_22 e3)) (= ?v_22 e4)) (= ?v_22 e5)) (= ?v_22 e6))) (or (or (or (or (or (or (= ?v_23 e0) (= ?v_23 e1)) (= ?v_23 e2)) (= ?v_23 e3)) (= ?v_23 e4)) (= ?v_23 e5)) (= ?v_23 e6))) (or (or (or (or (or (or (= ?v_24 e0) (= ?v_24 e1)) (= ?v_24 e2)) (= ?v_24 e3)) (= ?v_24 e4)) (= ?v_24 e5)) (= ?v_24 e6))) (or (or (or (or (or (or (= ?v_25 e0) (= ?v_25 e1)) (= ?v_25 e2)) (= ?v_25 e3)) (= ?v_25 e4)) (= ?v_25 e5)) (= ?v_25 e6))) (or (or (or (or (or (or (= ?v_26 e0) (= ?v_26 e1)) (= ?v_26 e2)) (= ?v_26 e3)) (= ?v_26 e4)) (= ?v_26 e5)) (= ?v_26 e6))) (or (or (or (or (or (or (= ?v_27 e0) (= ?v_27 e1)) (= ?v_27 e2)) (= ?v_27 e3)) (= ?v_27 e4)) (= ?v_27 e5)) (= ?v_27 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_28 e0) (= ?v_28 e1)) (= ?v_28 e2)) (= ?v_28 e3)) (= ?v_28 e4)) (= ?v_28 e5)) (= ?v_28 e6)) (or (or (or (or (or (or (= ?v_29 e0) (= ?v_29 e1)) (= ?v_29 e2)) (= ?v_29 e3)) (= ?v_29 e4)) (= ?v_29 e5)) (= ?v_29 e6))) (or (or (or (or (or (or (= ?v_30 e0) (= ?v_30 e1)) (= ?v_30 e2)) (= ?v_30 e3)) (= ?v_30 e4)) (= ?v_30 e5)) (= ?v_30 e6))) (or (or (or (or (or (or (= ?v_31 e0) (= ?v_31 e1)) (= ?v_31 e2)) (= ?v_31 e3)) (= ?v_31 e4)) (= ?v_31 e5)) (= ?v_31 e6))) (or (or (or (or (or (or (= ?v_32 e0) (= ?v_32 e1)) (= ?v_32 e2)) (= ?v_32 e3)) (= ?v_32 e4)) (= ?v_32 e5)) (= ?v_32 e6))) (or (or (or (or (or (or (= ?v_33 e0) (= ?v_33 e1)) (= ?v_33 e2)) (= ?v_33 e3)) (= ?v_33 e4)) (= ?v_33 e5)) (= ?v_33 e6))) (or (or (or (or (or (or (= ?v_34 e0) (= ?v_34 e1)) (= ?v_34 e2)) (= ?v_34 e3)) (= ?v_34 e4)) (= ?v_34 e5)) (= ?v_34 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_35 e0) (= ?v_35 e1)) (= ?v_35 e2)) (= ?v_35 e3)) (= ?v_35 e4)) (= ?v_35 e5)) (= ?v_35 e6)) (or (or (or (or (or (or (= ?v_36 e0) (= ?v_36 e1)) (= ?v_36 e2)) (= ?v_36 e3)) (= ?v_36 e4)) (= ?v_36 e5)) (= ?v_36 e6))) (or (or (or (or (or (or (= ?v_37 e0) (= ?v_37 e1)) (= ?v_37 e2)) (= ?v_37 e3)) (= ?v_37 e4)) (= ?v_37 e5)) (= ?v_37 e6))) (or (or (or (or (or (or (= ?v_38 e0) (= ?v_38 e1)) (= ?v_38 e2)) (= ?v_38 e3)) (= ?v_38 e4)) (= ?v_38 e5)) (= ?v_38 e6))) (or (or (or (or (or (or (= ?v_39 e0) (= ?v_39 e1)) (= ?v_39 e2)) (= ?v_39 e3)) (= ?v_39 e4)) (= ?v_39 e5)) (= ?v_39 e6))) (or (or (or (or (or (or (= ?v_40 e0) (= ?v_40 e1)) (= ?v_40 e2)) (= ?v_40 e3)) (= ?v_40 e4)) (= ?v_40 e5)) (= ?v_40 e6))) (or (or (or (or (or (or (= ?v_41 e0) (= ?v_41 e1)) (= ?v_41 e2)) (= ?v_41 e3)) (= ?v_41 e4)) (= ?v_41 e5)) (= ?v_41 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_42 e0) (= ?v_42 e1)) (= ?v_42 e2)) (= ?v_42 e3)) (= ?v_42 e4)) (= ?v_42 e5)) (= ?v_42 e6)) (or (or (or (or (or (or (= ?v_43 e0) (= ?v_43 e1)) (= ?v_43 e2)) (= ?v_43 e3)) (= ?v_43 e4)) (= ?v_43 e5)) (= ?v_43 e6))) (or (or (or (or (or (or (= ?v_44 e0) (= ?v_44 e1)) (= ?v_44 e2)) (= ?v_44 e3)) (= ?v_44 e4)) (= ?v_44 e5)) (= ?v_44 e6))) (or (or (or (or (or (or (= ?v_45 e0) (= ?v_45 e1)) (= ?v_45 e2)) (= ?v_45 e3)) (= ?v_45 e4)) (= ?v_45 e5)) (= ?v_45 e6))) (or (or (or (or (or (or (= ?v_46 e0) (= ?v_46 e1)) (= ?v_46 e2)) (= ?v_46 e3)) (= ?v_46 e4)) (= ?v_46 e5)) (= ?v_46 e6))) (or (or (or (or (or (or (= ?v_47 e0) (= ?v_47 e1)) (= ?v_47 e2)) (= ?v_47 e3)) (= ?v_47 e4)) (= ?v_47 e5)) (= ?v_47 e6))) (or (or (or (or (or (or (= ?v_48 e0) (= ?v_48 e1)) (= ?v_48 e2)) (= ?v_48 e3)) (= ?v_48 e4)) (= ?v_48 e5)) (= ?v_48 e6))))) :named GPOAwhwjgbuUOKkUnXW)) (assert(! (let ((?v_1 (op e0 e0)) (?v_2 (op e0 e1)) (?v_3 (op e0 e2)) (?v_4 (op e0 e3)) (?v_5 (op e0 e4)) (?v_6 (op e0 e5)) (?v_7 (op e0 e6)) (?v_9 (op e1 e0)) (?v_24 (op e1 e1)) (?v_25 (op e1 e2)) (?v_26 (op e1 e3)) (?v_27 (op e1 e4)) (?v_28 (op e1 e5)) (?v_29 (op e1 e6)) (?v_10 (op e2 e0)) (?v_32 (op e2 e1)) (?v_59 (op e2 e2)) (?v_60 (op e2 e3)) (?v_61 (op e2 e4)) (?v_62 (op e2 e5)) (?v_63 (op e2 e6)) (?v_11 (op e3 e0)) (?v_33 (op e3 e1)) (?v_67 (op e3 e2)) (?v_106 (op e3 e3)) (?v_107 (op e3 e4)) (?v_108 (op e3 e5)) (?v_109 (op e3 e6)) (?v_12 (op e4 e0)) (?v_34 (op e4 e1)) (?v_68 (op e4 e2)) (?v_114 (op e4 e3)) (?v_165 (op e4 e4)) (?v_166 (op e4 e5)) (?v_167 (op e4 e6)) (?v_13 (op e5 e0)) (?v_35 (op e5 e1)) (?v_69 (op e5 e2)) (?v_115 (op e5 e3)) (?v_173 (op e5 e4)) (?v_236 (op e5 e5)) (?v_237 (op e5 e6)) (?v_14 (op e6 e0)) (?v_36 (op e6 e1)) (?v_70 (op e6 e2)) (?v_116 (op e6 e3)) (?v_174 (op e6 e4)) (?v_244 (op e6 e5)) (?v_319 (op e6 e6))) (let ((?v_0 (= ?v_1 e0)) (?v_8 (= ?v_1 e1)) (?v_15 (= ?v_1 e2)) (?v_16 (= ?v_1 e3)) (?v_17 (= ?v_1 e4)) (?v_18 (= ?v_1 e5)) (?v_19 (= ?v_1 e6)) (?v_21 (= ?v_2 e0)) (?v_30 (= ?v_2 e1)) (?v_38 (= ?v_2 e2)) (?v_41 (= ?v_2 e3)) (?v_44 (= ?v_2 e4)) (?v_47 (= ?v_2 e5)) (?v_50 (= ?v_2 e6)) (?v_54 (= ?v_3 e0)) (?v_64 (= ?v_3 e1)) (?v_73 (= ?v_3 e2)) (?v_78 (= ?v_3 e3)) (?v_83 (= ?v_3 e4)) (?v_88 (= ?v_3 e5)) (?v_93 (= ?v_3 e6)) (?v_99 (= ?v_4 e0)) (?v_110 (= ?v_4 e1)) (?v_120 (= ?v_4 e2)) (?v_127 (= ?v_4 e3)) (?v_134 (= ?v_4 e4)) (?v_141 (= ?v_4 e5)) (?v_148 (= ?v_4 e6)) (?v_156 (= ?v_5 e0)) (?v_168 (= ?v_5 e1)) (?v_179 (= ?v_5 e2)) (?v_188 (= ?v_5 e3)) (?v_197 (= ?v_5 e4)) (?v_206 (= ?v_5 e5)) (?v_215 (= ?v_5 e6)) (?v_225 (= ?v_6 e0)) (?v_238 (= ?v_6 e1)) (?v_250 (= ?v_6 e2)) (?v_261 (= ?v_6 e3)) (?v_272 (= ?v_6 e4)) (?v_283 (= ?v_6 e5)) (?v_294 (= ?v_6 e6)) (?v_306 (= ?v_7 e0)) (?v_320 (= ?v_7 e1)) (?v_333 (= ?v_7 e2)) (?v_346 (= ?v_7 e3)) (?v_359 (= ?v_7 e4)) (?v_372 (= ?v_7 e5)) (?v_385 (= ?v_7 e6)) (?v_20 (= ?v_9 e0)) (?v_23 (= ?v_9 e1)) (?v_37 (= ?v_9 e2)) (?v_40 (= ?v_9 e3)) (?v_43 (= ?v_9 e4)) (?v_46 (= ?v_9 e5)) (?v_49 (= ?v_9 e6)) (?v_22 (= ?v_24 e0)) (?v_31 (= ?v_24 e1)) (?v_39 (= ?v_24 e2)) (?v_42 (= ?v_24 e3)) (?v_45 (= ?v_24 e4)) (?v_48 (= ?v_24 e5)) (?v_51 (= ?v_24 e6)) (?v_55 (= ?v_25 e0)) (?v_65 (= ?v_25 e1)) (?v_74 (= ?v_25 e2)) (?v_79 (= ?v_25 e3)) (?v_84 (= ?v_25 e4)) (?v_89 (= ?v_25 e5)) (?v_94 (= ?v_25 e6)) (?v_100 (= ?v_26 e0)) (?v_111 (= ?v_26 e1)) (?v_121 (= ?v_26 e2)) (?v_128 (= ?v_26 e3)) (?v_135 (= ?v_26 e4)) (?v_142 (= ?v_26 e5)) (?v_149 (= ?v_26 e6)) (?v_157 (= ?v_27 e0)) (?v_169 (= ?v_27 e1)) (?v_180 (= ?v_27 e2)) (?v_189 (= ?v_27 e3)) (?v_198 (= ?v_27 e4)) (?v_207 (= ?v_27 e5)) (?v_216 (= ?v_27 e6)) (?v_226 (= ?v_28 e0)) (?v_239 (= ?v_28 e1)) (?v_251 (= ?v_28 e2)) (?v_262 (= ?v_28 e3)) (?v_273 (= ?v_28 e4)) (?v_284 (= ?v_28 e5)) (?v_295 (= ?v_28 e6)) (?v_307 (= ?v_29 e0)) (?v_321 (= ?v_29 e1)) (?v_334 (= ?v_29 e2)) (?v_347 (= ?v_29 e3)) (?v_360 (= ?v_29 e4)) (?v_373 (= ?v_29 e5)) (?v_386 (= ?v_29 e6)) (?v_52 (= ?v_10 e0)) (?v_57 (= ?v_10 e1)) (?v_71 (= ?v_10 e2)) (?v_76 (= ?v_10 e3)) (?v_81 (= ?v_10 e4)) (?v_86 (= ?v_10 e5)) (?v_91 (= ?v_10 e6)) (?v_53 (= ?v_32 e0)) (?v_58 (= ?v_32 e1)) (?v_72 (= ?v_32 e2)) (?v_77 (= ?v_32 e3)) (?v_82 (= ?v_32 e4)) (?v_87 (= ?v_32 e5)) (?v_92 (= ?v_32 e6)) (?v_56 (= ?v_59 e0)) (?v_66 (= ?v_59 e1)) (?v_75 (= ?v_59 e2)) (?v_80 (= ?v_59 e3)) (?v_85 (= ?v_59 e4)) (?v_90 (= ?v_59 e5)) (?v_95 (= ?v_59 e6)) (?v_101 (= ?v_60 e0)) (?v_112 (= ?v_60 e1)) (?v_122 (= ?v_60 e2)) (?v_129 (= ?v_60 e3)) (?v_136 (= ?v_60 e4)) (?v_143 (= ?v_60 e5)) (?v_150 (= ?v_60 e6)) (?v_158 (= ?v_61 e0)) (?v_170 (= ?v_61 e1)) (?v_181 (= ?v_61 e2)) (?v_190 (= ?v_61 e3)) (?v_199 (= ?v_61 e4)) (?v_208 (= ?v_61 e5)) (?v_217 (= ?v_61 e6)) (?v_227 (= ?v_62 e0)) (?v_240 (= ?v_62 e1)) (?v_252 (= ?v_62 e2)) (?v_263 (= ?v_62 e3)) (?v_274 (= ?v_62 e4)) (?v_285 (= ?v_62 e5)) (?v_296 (= ?v_62 e6)) (?v_308 (= ?v_63 e0)) (?v_322 (= ?v_63 e1)) (?v_335 (= ?v_63 e2)) (?v_348 (= ?v_63 e3)) (?v_361 (= ?v_63 e4)) (?v_374 (= ?v_63 e5)) (?v_387 (= ?v_63 e6)) (?v_96 (= ?v_11 e0)) (?v_103 (= ?v_11 e1)) (?v_117 (= ?v_11 e2)) (?v_124 (= ?v_11 e3)) (?v_131 (= ?v_11 e4)) (?v_138 (= ?v_11 e5)) (?v_145 (= ?v_11 e6)) (?v_97 (= ?v_33 e0)) (?v_104 (= ?v_33 e1)) (?v_118 (= ?v_33 e2)) (?v_125 (= ?v_33 e3)) (?v_132 (= ?v_33 e4)) (?v_139 (= ?v_33 e5)) (?v_146 (= ?v_33 e6)) (?v_98 (= ?v_67 e0)) (?v_105 (= ?v_67 e1)) (?v_119 (= ?v_67 e2)) (?v_126 (= ?v_67 e3)) (?v_133 (= ?v_67 e4)) (?v_140 (= ?v_67 e5)) (?v_147 (= ?v_67 e6)) (?v_102 (= ?v_106 e0)) (?v_113 (= ?v_106 e1)) (?v_123 (= ?v_106 e2)) (?v_130 (= ?v_106 e3)) (?v_137 (= ?v_106 e4)) (?v_144 (= ?v_106 e5)) (?v_151 (= ?v_106 e6)) (?v_159 (= ?v_107 e0)) (?v_171 (= ?v_107 e1)) (?v_182 (= ?v_107 e2)) (?v_191 (= ?v_107 e3)) (?v_200 (= ?v_107 e4)) (?v_209 (= ?v_107 e5)) (?v_218 (= ?v_107 e6)) (?v_228 (= ?v_108 e0)) (?v_241 (= ?v_108 e1)) (?v_253 (= ?v_108 e2)) (?v_264 (= ?v_108 e3)) (?v_275 (= ?v_108 e4)) (?v_286 (= ?v_108 e5)) (?v_297 (= ?v_108 e6)) (?v_309 (= ?v_109 e0)) (?v_323 (= ?v_109 e1)) (?v_336 (= ?v_109 e2)) (?v_349 (= ?v_109 e3)) (?v_362 (= ?v_109 e4)) (?v_375 (= ?v_109 e5)) (?v_388 (= ?v_109 e6)) (?v_152 (= ?v_12 e0)) (?v_161 (= ?v_12 e1)) (?v_175 (= ?v_12 e2)) (?v_184 (= ?v_12 e3)) (?v_193 (= ?v_12 e4)) (?v_202 (= ?v_12 e5)) (?v_211 (= ?v_12 e6)) (?v_153 (= ?v_34 e0)) (?v_162 (= ?v_34 e1)) (?v_176 (= ?v_34 e2)) (?v_185 (= ?v_34 e3)) (?v_194 (= ?v_34 e4)) (?v_203 (= ?v_34 e5)) (?v_212 (= ?v_34 e6)) (?v_154 (= ?v_68 e0)) (?v_163 (= ?v_68 e1)) (?v_177 (= ?v_68 e2)) (?v_186 (= ?v_68 e3)) (?v_195 (= ?v_68 e4)) (?v_204 (= ?v_68 e5)) (?v_213 (= ?v_68 e6)) (?v_155 (= ?v_114 e0)) (?v_164 (= ?v_114 e1)) (?v_178 (= ?v_114 e2)) (?v_187 (= ?v_114 e3)) (?v_196 (= ?v_114 e4)) (?v_205 (= ?v_114 e5)) (?v_214 (= ?v_114 e6)) (?v_160 (= ?v_165 e0)) (?v_172 (= ?v_165 e1)) (?v_183 (= ?v_165 e2)) (?v_192 (= ?v_165 e3)) (?v_201 (= ?v_165 e4)) (?v_210 (= ?v_165 e5)) (?v_219 (= ?v_165 e6)) (?v_229 (= ?v_166 e0)) (?v_242 (= ?v_166 e1)) (?v_254 (= ?v_166 e2)) (?v_265 (= ?v_166 e3)) (?v_276 (= ?v_166 e4)) (?v_287 (= ?v_166 e5)) (?v_298 (= ?v_166 e6)) (?v_310 (= ?v_167 e0)) (?v_324 (= ?v_167 e1)) (?v_337 (= ?v_167 e2)) (?v_350 (= ?v_167 e3)) (?v_363 (= ?v_167 e4)) (?v_376 (= ?v_167 e5)) (?v_389 (= ?v_167 e6)) (?v_220 (= ?v_13 e0)) (?v_231 (= ?v_13 e1)) (?v_245 (= ?v_13 e2)) (?v_256 (= ?v_13 e3)) (?v_267 (= ?v_13 e4)) (?v_278 (= ?v_13 e5)) (?v_289 (= ?v_13 e6)) (?v_221 (= ?v_35 e0)) (?v_232 (= ?v_35 e1)) (?v_246 (= ?v_35 e2)) (?v_257 (= ?v_35 e3)) (?v_268 (= ?v_35 e4)) (?v_279 (= ?v_35 e5)) (?v_290 (= ?v_35 e6)) (?v_222 (= ?v_69 e0)) (?v_233 (= ?v_69 e1)) (?v_247 (= ?v_69 e2)) (?v_258 (= ?v_69 e3)) (?v_269 (= ?v_69 e4)) (?v_280 (= ?v_69 e5)) (?v_291 (= ?v_69 e6)) (?v_223 (= ?v_115 e0)) (?v_234 (= ?v_115 e1)) (?v_248 (= ?v_115 e2)) (?v_259 (= ?v_115 e3)) (?v_270 (= ?v_115 e4)) (?v_281 (= ?v_115 e5)) (?v_292 (= ?v_115 e6)) (?v_224 (= ?v_173 e0)) (?v_235 (= ?v_173 e1)) (?v_249 (= ?v_173 e2)) (?v_260 (= ?v_173 e3)) (?v_271 (= ?v_173 e4)) (?v_282 (= ?v_173 e5)) (?v_293 (= ?v_173 e6)) (?v_230 (= ?v_236 e0)) (?v_243 (= ?v_236 e1)) (?v_255 (= ?v_236 e2)) (?v_266 (= ?v_236 e3)) (?v_277 (= ?v_236 e4)) (?v_288 (= ?v_236 e5)) (?v_299 (= ?v_236 e6)) (?v_311 (= ?v_237 e0)) (?v_325 (= ?v_237 e1)) (?v_338 (= ?v_237 e2)) (?v_351 (= ?v_237 e3)) (?v_364 (= ?v_237 e4)) (?v_377 (= ?v_237 e5)) (?v_390 (= ?v_237 e6)) (?v_300 (= ?v_14 e0)) (?v_313 (= ?v_14 e1)) (?v_327 (= ?v_14 e2)) (?v_340 (= ?v_14 e3)) (?v_353 (= ?v_14 e4)) (?v_366 (= ?v_14 e5)) (?v_379 (= ?v_14 e6)) (?v_301 (= ?v_36 e0)) (?v_314 (= ?v_36 e1)) (?v_328 (= ?v_36 e2)) (?v_341 (= ?v_36 e3)) (?v_354 (= ?v_36 e4)) (?v_367 (= ?v_36 e5)) (?v_380 (= ?v_36 e6)) (?v_302 (= ?v_70 e0)) (?v_315 (= ?v_70 e1)) (?v_329 (= ?v_70 e2)) (?v_342 (= ?v_70 e3)) (?v_355 (= ?v_70 e4)) (?v_368 (= ?v_70 e5)) (?v_381 (= ?v_70 e6)) (?v_303 (= ?v_116 e0)) (?v_316 (= ?v_116 e1)) (?v_330 (= ?v_116 e2)) (?v_343 (= ?v_116 e3)) (?v_356 (= ?v_116 e4)) (?v_369 (= ?v_116 e5)) (?v_382 (= ?v_116 e6)) (?v_304 (= ?v_174 e0)) (?v_317 (= ?v_174 e1)) (?v_331 (= ?v_174 e2)) (?v_344 (= ?v_174 e3)) (?v_357 (= ?v_174 e4)) (?v_370 (= ?v_174 e5)) (?v_383 (= ?v_174 e6)) (?v_305 (= ?v_244 e0)) (?v_318 (= ?v_244 e1)) (?v_332 (= ?v_244 e2)) (?v_345 (= ?v_244 e3)) (?v_358 (= ?v_244 e4)) (?v_371 (= ?v_244 e5)) (?v_384 (= ?v_244 e6)) (?v_312 (= ?v_319 e0)) (?v_326 (= ?v_319 e1)) (?v_339 (= ?v_319 e2)) (?v_352 (= ?v_319 e3)) (?v_365 (= ?v_319 e4)) (?v_378 (= ?v_319 e5)) (?v_391 (= ?v_319 e6))) (and (and (and (and (and (and (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_0 ?v_21) ?v_54) ?v_99) ?v_156) ?v_225) ?v_306) (or (or (or (or (or (or ?v_0 ?v_20) ?v_52) ?v_96) ?v_152) ?v_220) ?v_300)) (and (or (or (or (or (or (or ?v_8 ?v_30) ?v_64) ?v_110) ?v_168) ?v_238) ?v_320) (or (or (or (or (or (or ?v_8 ?v_23) ?v_57) ?v_103) ?v_161) ?v_231) ?v_313))) (and (or (or (or (or (or (or ?v_15 ?v_38) ?v_73) ?v_120) ?v_179) ?v_250) ?v_333) (or (or (or (or (or (or ?v_15 ?v_37) ?v_71) ?v_117) ?v_175) ?v_245) ?v_327))) (and (or (or (or (or (or (or ?v_16 ?v_41) ?v_78) ?v_127) ?v_188) ?v_261) ?v_346) (or (or (or (or (or (or ?v_16 ?v_40) ?v_76) ?v_124) ?v_184) ?v_256) ?v_340))) (and (or (or (or (or (or (or ?v_17 ?v_44) ?v_83) ?v_134) ?v_197) ?v_272) ?v_359) (or (or (or (or (or (or ?v_17 ?v_43) ?v_81) ?v_131) ?v_193) ?v_267) ?v_353))) (and (or (or (or (or (or (or ?v_18 ?v_47) ?v_88) ?v_141) ?v_206) ?v_283) ?v_372) (or (or (or (or (or (or ?v_18 ?v_46) ?v_86) ?v_138) ?v_202) ?v_278) ?v_366))) (and (or (or (or (or (or (or ?v_19 ?v_50) ?v_93) ?v_148) ?v_215) ?v_294) ?v_385) (or (or (or (or (or (or ?v_19 ?v_49) ?v_91) ?v_145) ?v_211) ?v_289) ?v_379))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_20 ?v_22) ?v_55) ?v_100) ?v_157) ?v_226) ?v_307) (or (or (or (or (or (or ?v_21 ?v_22) ?v_53) ?v_97) ?v_153) ?v_221) ?v_301)) (and (or (or (or (or (or (or ?v_23 ?v_31) ?v_65) ?v_111) ?v_169) ?v_239) ?v_321) (or (or (or (or (or (or ?v_30 ?v_31) ?v_58) ?v_104) ?v_162) ?v_232) ?v_314))) (and (or (or (or (or (or (or ?v_37 ?v_39) ?v_74) ?v_121) ?v_180) ?v_251) ?v_334) (or (or (or (or (or (or ?v_38 ?v_39) ?v_72) ?v_118) ?v_176) ?v_246) ?v_328))) (and (or (or (or (or (or (or ?v_40 ?v_42) ?v_79) ?v_128) ?v_189) ?v_262) ?v_347) (or (or (or (or (or (or ?v_41 ?v_42) ?v_77) ?v_125) ?v_185) ?v_257) ?v_341))) (and (or (or (or (or (or (or ?v_43 ?v_45) ?v_84) ?v_135) ?v_198) ?v_273) ?v_360) (or (or (or (or (or (or ?v_44 ?v_45) ?v_82) ?v_132) ?v_194) ?v_268) ?v_354))) (and (or (or (or (or (or (or ?v_46 ?v_48) ?v_89) ?v_142) ?v_207) ?v_284) ?v_373) (or (or (or (or (or (or ?v_47 ?v_48) ?v_87) ?v_139) ?v_203) ?v_279) ?v_367))) (and (or (or (or (or (or (or ?v_49 ?v_51) ?v_94) ?v_149) ?v_216) ?v_295) ?v_386) (or (or (or (or (or (or ?v_50 ?v_51) ?v_92) ?v_146) ?v_212) ?v_290) ?v_380)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_52 ?v_53) ?v_56) ?v_101) ?v_158) ?v_227) ?v_308) (or (or (or (or (or (or ?v_54 ?v_55) ?v_56) ?v_98) ?v_154) ?v_222) ?v_302)) (and (or (or (or (or (or (or ?v_57 ?v_58) ?v_66) ?v_112) ?v_170) ?v_240) ?v_322) (or (or (or (or (or (or ?v_64 ?v_65) ?v_66) ?v_105) ?v_163) ?v_233) ?v_315))) (and (or (or (or (or (or (or ?v_71 ?v_72) ?v_75) ?v_122) ?v_181) ?v_252) ?v_335) (or (or (or (or (or (or ?v_73 ?v_74) ?v_75) ?v_119) ?v_177) ?v_247) ?v_329))) (and (or (or (or (or (or (or ?v_76 ?v_77) ?v_80) ?v_129) ?v_190) ?v_263) ?v_348) (or (or (or (or (or (or ?v_78 ?v_79) ?v_80) ?v_126) ?v_186) ?v_258) ?v_342))) (and (or (or (or (or (or (or ?v_81 ?v_82) ?v_85) ?v_136) ?v_199) ?v_274) ?v_361) (or (or (or (or (or (or ?v_83 ?v_84) ?v_85) ?v_133) ?v_195) ?v_269) ?v_355))) (and (or (or (or (or (or (or ?v_86 ?v_87) ?v_90) ?v_143) ?v_208) ?v_285) ?v_374) (or (or (or (or (or (or ?v_88 ?v_89) ?v_90) ?v_140) ?v_204) ?v_280) ?v_368))) (and (or (or (or (or (or (or ?v_91 ?v_92) ?v_95) ?v_150) ?v_217) ?v_296) ?v_387) (or (or (or (or (or (or ?v_93 ?v_94) ?v_95) ?v_147) ?v_213) ?v_291) ?v_381)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_96 ?v_97) ?v_98) ?v_102) ?v_159) ?v_228) ?v_309) (or (or (or (or (or (or ?v_99 ?v_100) ?v_101) ?v_102) ?v_155) ?v_223) ?v_303)) (and (or (or (or (or (or (or ?v_103 ?v_104) ?v_105) ?v_113) ?v_171) ?v_241) ?v_323) (or (or (or (or (or (or ?v_110 ?v_111) ?v_112) ?v_113) ?v_164) ?v_234) ?v_316))) (and (or (or (or (or (or (or ?v_117 ?v_118) ?v_119) ?v_123) ?v_182) ?v_253) ?v_336) (or (or (or (or (or (or ?v_120 ?v_121) ?v_122) ?v_123) ?v_178) ?v_248) ?v_330))) (and (or (or (or (or (or (or ?v_124 ?v_125) ?v_126) ?v_130) ?v_191) ?v_264) ?v_349) (or (or (or (or (or (or ?v_127 ?v_128) ?v_129) ?v_130) ?v_187) ?v_259) ?v_343))) (and (or (or (or (or (or (or ?v_131 ?v_132) ?v_133) ?v_137) ?v_200) ?v_275) ?v_362) (or (or (or (or (or (or ?v_134 ?v_135) ?v_136) ?v_137) ?v_196) ?v_270) ?v_356))) (and (or (or (or (or (or (or ?v_138 ?v_139) ?v_140) ?v_144) ?v_209) ?v_286) ?v_375) (or (or (or (or (or (or ?v_141 ?v_142) ?v_143) ?v_144) ?v_205) ?v_281) ?v_369))) (and (or (or (or (or (or (or ?v_145 ?v_146) ?v_147) ?v_151) ?v_218) ?v_297) ?v_388) (or (or (or (or (or (or ?v_148 ?v_149) ?v_150) ?v_151) ?v_214) ?v_292) ?v_382)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_152 ?v_153) ?v_154) ?v_155) ?v_160) ?v_229) ?v_310) (or (or (or (or (or (or ?v_156 ?v_157) ?v_158) ?v_159) ?v_160) ?v_224) ?v_304)) (and (or (or (or (or (or (or ?v_161 ?v_162) ?v_163) ?v_164) ?v_172) ?v_242) ?v_324) (or (or (or (or (or (or ?v_168 ?v_169) ?v_170) ?v_171) ?v_172) ?v_235) ?v_317))) (and (or (or (or (or (or (or ?v_175 ?v_176) ?v_177) ?v_178) ?v_183) ?v_254) ?v_337) (or (or (or (or (or (or ?v_179 ?v_180) ?v_181) ?v_182) ?v_183) ?v_249) ?v_331))) (and (or (or (or (or (or (or ?v_184 ?v_185) ?v_186) ?v_187) ?v_192) ?v_265) ?v_350) (or (or (or (or (or (or ?v_188 ?v_189) ?v_190) ?v_191) ?v_192) ?v_260) ?v_344))) (and (or (or (or (or (or (or ?v_193 ?v_194) ?v_195) ?v_196) ?v_201) ?v_276) ?v_363) (or (or (or (or (or (or ?v_197 ?v_198) ?v_199) ?v_200) ?v_201) ?v_271) ?v_357))) (and (or (or (or (or (or (or ?v_202 ?v_203) ?v_204) ?v_205) ?v_210) ?v_287) ?v_376) (or (or (or (or (or (or ?v_206 ?v_207) ?v_208) ?v_209) ?v_210) ?v_282) ?v_370))) (and (or (or (or (or (or (or ?v_211 ?v_212) ?v_213) ?v_214) ?v_219) ?v_298) ?v_389) (or (or (or (or (or (or ?v_215 ?v_216) ?v_217) ?v_218) ?v_219) ?v_293) ?v_383)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_220 ?v_221) ?v_222) ?v_223) ?v_224) ?v_230) ?v_311) (or (or (or (or (or (or ?v_225 ?v_226) ?v_227) ?v_228) ?v_229) ?v_230) ?v_305)) (and (or (or (or (or (or (or ?v_231 ?v_232) ?v_233) ?v_234) ?v_235) ?v_243) ?v_325) (or (or (or (or (or (or ?v_238 ?v_239) ?v_240) ?v_241) ?v_242) ?v_243) ?v_318))) (and (or (or (or (or (or (or ?v_245 ?v_246) ?v_247) ?v_248) ?v_249) ?v_255) ?v_338) (or (or (or (or (or (or ?v_250 ?v_251) ?v_252) ?v_253) ?v_254) ?v_255) ?v_332))) (and (or (or (or (or (or (or ?v_256 ?v_257) ?v_258) ?v_259) ?v_260) ?v_266) ?v_351) (or (or (or (or (or (or ?v_261 ?v_262) ?v_263) ?v_264) ?v_265) ?v_266) ?v_345))) (and (or (or (or (or (or (or ?v_267 ?v_268) ?v_269) ?v_270) ?v_271) ?v_277) ?v_364) (or (or (or (or (or (or ?v_272 ?v_273) ?v_274) ?v_275) ?v_276) ?v_277) ?v_358))) (and (or (or (or (or (or (or ?v_278 ?v_279) ?v_280) ?v_281) ?v_282) ?v_288) ?v_377) (or (or (or (or (or (or ?v_283 ?v_284) ?v_285) ?v_286) ?v_287) ?v_288) ?v_371))) (and (or (or (or (or (or (or ?v_289 ?v_290) ?v_291) ?v_292) ?v_293) ?v_299) ?v_390) (or (or (or (or (or (or ?v_294 ?v_295) ?v_296) ?v_297) ?v_298) ?v_299) ?v_384)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_300 ?v_301) ?v_302) ?v_303) ?v_304) ?v_305) ?v_312) (or (or (or (or (or (or ?v_306 ?v_307) ?v_308) ?v_309) ?v_310) ?v_311) ?v_312)) (and (or (or (or (or (or (or ?v_313 ?v_314) ?v_315) ?v_316) ?v_317) ?v_318) ?v_326) (or (or (or (or (or (or ?v_320 ?v_321) ?v_322) ?v_323) ?v_324) ?v_325) ?v_326))) (and (or (or (or (or (or (or ?v_327 ?v_328) ?v_329) ?v_330) ?v_331) ?v_332) ?v_339) (or (or (or (or (or (or ?v_333 ?v_334) ?v_335) ?v_336) ?v_337) ?v_338) ?v_339))) (and (or (or (or (or (or (or ?v_340 ?v_341) ?v_342) ?v_343) ?v_344) ?v_345) ?v_352) (or (or (or (or (or (or ?v_346 ?v_347) ?v_348) ?v_349) ?v_350) ?v_351) ?v_352))) (and (or (or (or (or (or (or ?v_353 ?v_354) ?v_355) ?v_356) ?v_357) ?v_358) ?v_365) (or (or (or (or (or (or ?v_359 ?v_360) ?v_361) ?v_362) ?v_363) ?v_364) ?v_365))) (and (or (or (or (or (or (or ?v_366 ?v_367) ?v_368) ?v_369) ?v_370) ?v_371) ?v_378) (or (or (or (or (or (or ?v_372 ?v_373) ?v_374) ?v_375) ?v_376) ?v_377) ?v_378))) (and (or (or (or (or (or (or ?v_379 ?v_380) ?v_381) ?v_382) ?v_383) ?v_384) ?v_391) (or (or (or (or (or (or ?v_385 ?v_386) ?v_387) ?v_388) ?v_389) ?v_390) ?v_391)))))) :named EBtGYzVTOGramdAeE)) (assert(! (and (and (and (and (and (and (and (and (and (and (and (and (= (op (op (op e0 e0) e0) e0) e0) (= (op (op (op e0 e1) e1) e1) e0)) (= (op (op (op e0 e2) e2) e2) e0)) (= (op (op (op e0 e3) e3) e3) e0)) (= (op (op (op e0 e4) e4) e4) e0)) (= (op (op (op e0 e5) e5) e5) e0)) (= (op (op (op e0 e6) e6) e6) e0)) (and (and (and (and (and (and (= (op (op (op e1 e0) e0) e0) e1) (= (op (op (op e1 e1) e1) e1) e1)) (= (op (op (op e1 e2) e2) e2) e1)) (= (op (op (op e1 e3) e3) e3) e1)) (= (op (op (op e1 e4) e4) e4) e1)) (= (op (op (op e1 e5) e5) e5) e1)) (= (op (op (op e1 e6) e6) e6) e1))) (and (and (and (and (and (and (= (op (op (op e2 e0) e0) e0) e2) (= (op (op (op e2 e1) e1) e1) e2)) (= (op (op (op e2 e2) e2) e2) e2)) (= (op (op (op e2 e3) e3) e3) e2)) (= (op (op (op e2 e4) e4) e4) e2)) (= (op (op (op e2 e5) e5) e5) e2)) (= (op (op (op e2 e6) e6) e6) e2))) (and (and (and (and (and (and (= (op (op (op e3 e0) e0) e0) e3) (= (op (op (op e3 e1) e1) e1) e3)) (= (op (op (op e3 e2) e2) e2) e3)) (= (op (op (op e3 e3) e3) e3) e3)) (= (op (op (op e3 e4) e4) e4) e3)) (= (op (op (op e3 e5) e5) e5) e3)) (= (op (op (op e3 e6) e6) e6) e3))) (and (and (and (and (and (and (= (op (op (op e4 e0) e0) e0) e4) (= (op (op (op e4 e1) e1) e1) e4)) (= (op (op (op e4 e2) e2) e2) e4)) (= (op (op (op e4 e3) e3) e3) e4)) (= (op (op (op e4 e4) e4) e4) e4)) (= (op (op (op e4 e5) e5) e5) e4)) (= (op (op (op e4 e6) e6) e6) e4))) (and (and (and (and (and (and (= (op (op (op e5 e0) e0) e0) e5) (= (op (op (op e5 e1) e1) e1) e5)) (= (op (op (op e5 e2) e2) e2) e5)) (= (op (op (op e5 e3) e3) e3) e5)) (= (op (op (op e5 e4) e4) e4) e5)) (= (op (op (op e5 e5) e5) e5) e5)) (= (op (op (op e5 e6) e6) e6) e5))) (and (and (and (and (and (and (= (op (op (op e6 e0) e0) e0) e6) (= (op (op (op e6 e1) e1) e1) e6)) (= (op (op (op e6 e2) e2) e2) e6)) (= (op (op (op e6 e3) e3) e3) e6)) (= (op (op (op e6 e4) e4) e4) e6)) (= (op (op (op e6 e5) e5) e5) e6)) (= (op (op (op e6 e6) e6) e6) e6))) :named ioixWwpvtaEC)) (assert(! (and (and (and (and (and (and (not (= (op e0 e0) e0)) (not (= (op e1 e1) e1))) (not (= (op e2 e2) e2))) (not (= (op e3 e3) e3))) (not (= (op e4 e4) e4))) (not (= (op e5 e5) e5))) (not (= (op e6 e6) e6))) :named koUeyLLuLGCz)) (assert(! (let ((?v_0 (skc1 e0)) (?v_1 (skc1 e1)) (?v_2 (skc1 e2)) (?v_3 (skc1 e3)) (?v_4 (skc1 e4)) (?v_5 (skc1 e5)) (?v_6 (skc1 e6))) (and (and (and (and (and (and (and (= (op e0 ?v_0) ?v_0) (= (op e1 ?v_1) ?v_1)) (= (op e2 ?v_2) ?v_2)) (= (op e3 ?v_3) ?v_3)) (= (op e4 ?v_4) ?v_4)) (= (op e5 ?v_5) ?v_5)) (= (op e6 ?v_6) ?v_6)) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_0 e0) (= ?v_0 e1)) (= ?v_0 e2)) (= ?v_0 e3)) (= ?v_0 e4)) (= ?v_0 e5)) (= ?v_0 e6)) (or (or (or (or (or (or (= ?v_1 e0) (= ?v_1 e1)) (= ?v_1 e2)) (= ?v_1 e3)) (= ?v_1 e4)) (= ?v_1 e5)) (= ?v_1 e6))) (or (or (or (or (or (or (= ?v_2 e0) (= ?v_2 e1)) (= ?v_2 e2)) (= ?v_2 e3)) (= ?v_2 e4)) (= ?v_2 e5)) (= ?v_2 e6))) (or (or (or (or (or (or (= ?v_3 e0) (= ?v_3 e1)) (= ?v_3 e2)) (= ?v_3 e3)) (= ?v_3 e4)) (= ?v_3 e5)) (= ?v_3 e6))) (or (or (or (or (or (or (= ?v_4 e0) (= ?v_4 e1)) (= ?v_4 e2)) (= ?v_4 e3)) (= ?v_4 e4)) (= ?v_4 e5)) (= ?v_4 e6))) (or (or (or (or (or (or (= ?v_5 e0) (= ?v_5 e1)) (= ?v_5 e2)) (= ?v_5 e3)) (= ?v_5 e4)) (= ?v_5 e5)) (= ?v_5 e6))) (or (or (or (or (or (or (= ?v_6 e0) (= ?v_6 e1)) (= ?v_6 e2)) (= ?v_6 e3)) (= ?v_6 e4)) (= ?v_6 e5)) (= ?v_6 e6))))) :named RQzAFmfjYurAVQO)) (assert(! (and (and (and (= (op skc2 skc3) skc2) (= (op skc3 skc2) skc2)) (or (or (or (or (or (or (= skc2 e0) (= skc2 e1)) (= skc2 e2)) (= skc2 e3)) (= skc2 e4)) (= skc2 e5)) (= skc2 e6))) (or (or (or (or (or (or (= skc3 e0) (= skc3 e1)) (= skc3 e2)) (= skc3 e3)) (= skc3 e4)) (= skc3 e5)) (= skc3 e6))) :named qPwPmsghkmIAoprVYIK)) (assert(! (let ((?v_0 (op e0 e0)) (?v_7 (op e0 e1)) (?v_14 (op e0 e2)) (?v_21 (op e0 e3)) (?v_28 (op e0 e4)) (?v_35 (op e0 e5)) (?v_42 (op e0 e6)) (?v_1 (op e1 e0)) (?v_8 (op e1 e1)) (?v_15 (op e1 e2)) (?v_22 (op e1 e3)) (?v_29 (op e1 e4)) (?v_36 (op e1 e5)) (?v_43 (op e1 e6)) (?v_2 (op e2 e0)) (?v_9 (op e2 e1)) (?v_16 (op e2 e2)) (?v_23 (op e2 e3)) (?v_30 (op e2 e4)) (?v_37 (op e2 e5)) (?v_44 (op e2 e6)) (?v_3 (op e3 e0)) (?v_10 (op e3 e1)) (?v_17 (op e3 e2)) (?v_24 (op e3 e3)) (?v_31 (op e3 e4)) (?v_38 (op e3 e5)) (?v_45 (op e3 e6)) (?v_4 (op e4 e0)) (?v_11 (op e4 e1)) (?v_18 (op e4 e2)) (?v_25 (op e4 e3)) (?v_32 (op e4 e4)) (?v_39 (op e4 e5)) (?v_46 (op e4 e6)) (?v_5 (op e5 e0)) (?v_12 (op e5 e1)) (?v_19 (op e5 e2)) (?v_26 (op e5 e3)) (?v_33 (op e5 e4)) (?v_40 (op e5 e5)) (?v_47 (op e5 e6)) (?v_6 (op e6 e0)) (?v_13 (op e6 e1)) (?v_20 (op e6 e2)) (?v_27 (op e6 e3)) (?v_34 (op e6 e4)) (?v_41 (op e6 e5)) (?v_48 (op e6 e6))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_1)) (not (= ?v_0 ?v_2))) (not (= ?v_0 ?v_3))) (not (= ?v_0 ?v_4))) (not (= ?v_0 ?v_5))) (not (= ?v_0 ?v_6))) (not (= ?v_1 ?v_2))) (not (= ?v_1 ?v_3))) (not (= ?v_1 ?v_4))) (not (= ?v_1 ?v_5))) (not (= ?v_1 ?v_6))) (not (= ?v_2 ?v_3))) (not (= ?v_2 ?v_4))) (not (= ?v_2 ?v_5))) (not (= ?v_2 ?v_6))) (not (= ?v_3 ?v_4))) (not (= ?v_3 ?v_5))) (not (= ?v_3 ?v_6))) (not (= ?v_4 ?v_5))) (not (= ?v_4 ?v_6))) (not (= ?v_5 ?v_6))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_7 ?v_8)) (not (= ?v_7 ?v_9))) (not (= ?v_7 ?v_10))) (not (= ?v_7 ?v_11))) (not (= ?v_7 ?v_12))) (not (= ?v_7 ?v_13))) (not (= ?v_8 ?v_9))) (not (= ?v_8 ?v_10))) (not (= ?v_8 ?v_11))) (not (= ?v_8 ?v_12))) (not (= ?v_8 ?v_13))) (not (= ?v_9 ?v_10))) (not (= ?v_9 ?v_11))) (not (= ?v_9 ?v_12))) (not (= ?v_9 ?v_13))) (not (= ?v_10 ?v_11))) (not (= ?v_10 ?v_12))) (not (= ?v_10 ?v_13))) (not (= ?v_11 ?v_12))) (not (= ?v_11 ?v_13))) (not (= ?v_12 ?v_13)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_14 ?v_15)) (not (= ?v_14 ?v_16))) (not (= ?v_14 ?v_17))) (not (= ?v_14 ?v_18))) (not (= ?v_14 ?v_19))) (not (= ?v_14 ?v_20))) (not (= ?v_15 ?v_16))) (not (= ?v_15 ?v_17))) (not (= ?v_15 ?v_18))) (not (= ?v_15 ?v_19))) (not (= ?v_15 ?v_20))) (not (= ?v_16 ?v_17))) (not (= ?v_16 ?v_18))) (not (= ?v_16 ?v_19))) (not (= ?v_16 ?v_20))) (not (= ?v_17 ?v_18))) (not (= ?v_17 ?v_19))) (not (= ?v_17 ?v_20))) (not (= ?v_18 ?v_19))) (not (= ?v_18 ?v_20))) (not (= ?v_19 ?v_20)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_21 ?v_22)) (not (= ?v_21 ?v_23))) (not (= ?v_21 ?v_24))) (not (= ?v_21 ?v_25))) (not (= ?v_21 ?v_26))) (not (= ?v_21 ?v_27))) (not (= ?v_22 ?v_23))) (not (= ?v_22 ?v_24))) (not (= ?v_22 ?v_25))) (not (= ?v_22 ?v_26))) (not (= ?v_22 ?v_27))) (not (= ?v_23 ?v_24))) (not (= ?v_23 ?v_25))) (not (= ?v_23 ?v_26))) (not (= ?v_23 ?v_27))) (not (= ?v_24 ?v_25))) (not (= ?v_24 ?v_26))) (not (= ?v_24 ?v_27))) (not (= ?v_25 ?v_26))) (not (= ?v_25 ?v_27))) (not (= ?v_26 ?v_27)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_28 ?v_29)) (not (= ?v_28 ?v_30))) (not (= ?v_28 ?v_31))) (not (= ?v_28 ?v_32))) (not (= ?v_28 ?v_33))) (not (= ?v_28 ?v_34))) (not (= ?v_29 ?v_30))) (not (= ?v_29 ?v_31))) (not (= ?v_29 ?v_32))) (not (= ?v_29 ?v_33))) (not (= ?v_29 ?v_34))) (not (= ?v_30 ?v_31))) (not (= ?v_30 ?v_32))) (not (= ?v_30 ?v_33))) (not (= ?v_30 ?v_34))) (not (= ?v_31 ?v_32))) (not (= ?v_31 ?v_33))) (not (= ?v_31 ?v_34))) (not (= ?v_32 ?v_33))) (not (= ?v_32 ?v_34))) (not (= ?v_33 ?v_34)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_35 ?v_36)) (not (= ?v_35 ?v_37))) (not (= ?v_35 ?v_38))) (not (= ?v_35 ?v_39))) (not (= ?v_35 ?v_40))) (not (= ?v_35 ?v_41))) (not (= ?v_36 ?v_37))) (not (= ?v_36 ?v_38))) (not (= ?v_36 ?v_39))) (not (= ?v_36 ?v_40))) (not (= ?v_36 ?v_41))) (not (= ?v_37 ?v_38))) (not (= ?v_37 ?v_39))) (not (= ?v_37 ?v_40))) (not (= ?v_37 ?v_41))) (not (= ?v_38 ?v_39))) (not (= ?v_38 ?v_40))) (not (= ?v_38 ?v_41))) (not (= ?v_39 ?v_40))) (not (= ?v_39 ?v_41))) (not (= ?v_40 ?v_41)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_42 ?v_43)) (not (= ?v_42 ?v_44))) (not (= ?v_42 ?v_45))) (not (= ?v_42 ?v_46))) (not (= ?v_42 ?v_47))) (not (= ?v_42 ?v_48))) (not (= ?v_43 ?v_44))) (not (= ?v_43 ?v_45))) (not (= ?v_43 ?v_46))) (not (= ?v_43 ?v_47))) (not (= ?v_43 ?v_48))) (not (= ?v_44 ?v_45))) (not (= ?v_44 ?v_46))) (not (= ?v_44 ?v_47))) (not (= ?v_44 ?v_48))) (not (= ?v_45 ?v_46))) (not (= ?v_45 ?v_47))) (not (= ?v_45 ?v_48))) (not (= ?v_46 ?v_47))) (not (= ?v_46 ?v_48))) (not (= ?v_47 ?v_48)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_7)) (not (= ?v_0 ?v_14))) (not (= ?v_0 ?v_21))) (not (= ?v_0 ?v_28))) (not (= ?v_0 ?v_35))) (not (= ?v_0 ?v_42))) (not (= ?v_7 ?v_14))) (not (= ?v_7 ?v_21))) (not (= ?v_7 ?v_28))) (not (= ?v_7 ?v_35))) (not (= ?v_7 ?v_42))) (not (= ?v_14 ?v_21))) (not (= ?v_14 ?v_28))) (not (= ?v_14 ?v_35))) (not (= ?v_14 ?v_42))) (not (= ?v_21 ?v_28))) (not (= ?v_21 ?v_35))) (not (= ?v_21 ?v_42))) (not (= ?v_28 ?v_35))) (not (= ?v_28 ?v_42))) (not (= ?v_35 ?v_42))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_1 ?v_8)) (not (= ?v_1 ?v_15))) (not (= ?v_1 ?v_22))) (not (= ?v_1 ?v_29))) (not (= ?v_1 ?v_36))) (not (= ?v_1 ?v_43))) (not (= ?v_8 ?v_15))) (not (= ?v_8 ?v_22))) (not (= ?v_8 ?v_29))) (not (= ?v_8 ?v_36))) (not (= ?v_8 ?v_43))) (not (= ?v_15 ?v_22))) (not (= ?v_15 ?v_29))) (not (= ?v_15 ?v_36))) (not (= ?v_15 ?v_43))) (not (= ?v_22 ?v_29))) (not (= ?v_22 ?v_36))) (not (= ?v_22 ?v_43))) (not (= ?v_29 ?v_36))) (not (= ?v_29 ?v_43))) (not (= ?v_36 ?v_43)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_2 ?v_9)) (not (= ?v_2 ?v_16))) (not (= ?v_2 ?v_23))) (not (= ?v_2 ?v_30))) (not (= ?v_2 ?v_37))) (not (= ?v_2 ?v_44))) (not (= ?v_9 ?v_16))) (not (= ?v_9 ?v_23))) (not (= ?v_9 ?v_30))) (not (= ?v_9 ?v_37))) (not (= ?v_9 ?v_44))) (not (= ?v_16 ?v_23))) (not (= ?v_16 ?v_30))) (not (= ?v_16 ?v_37))) (not (= ?v_16 ?v_44))) (not (= ?v_23 ?v_30))) (not (= ?v_23 ?v_37))) (not (= ?v_23 ?v_44))) (not (= ?v_30 ?v_37))) (not (= ?v_30 ?v_44))) (not (= ?v_37 ?v_44)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_3 ?v_10)) (not (= ?v_3 ?v_17))) (not (= ?v_3 ?v_24))) (not (= ?v_3 ?v_31))) (not (= ?v_3 ?v_38))) (not (= ?v_3 ?v_45))) (not (= ?v_10 ?v_17))) (not (= ?v_10 ?v_24))) (not (= ?v_10 ?v_31))) (not (= ?v_10 ?v_38))) (not (= ?v_10 ?v_45))) (not (= ?v_17 ?v_24))) (not (= ?v_17 ?v_31))) (not (= ?v_17 ?v_38))) (not (= ?v_17 ?v_45))) (not (= ?v_24 ?v_31))) (not (= ?v_24 ?v_38))) (not (= ?v_24 ?v_45))) (not (= ?v_31 ?v_38))) (not (= ?v_31 ?v_45))) (not (= ?v_38 ?v_45)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_4 ?v_11)) (not (= ?v_4 ?v_18))) (not (= ?v_4 ?v_25))) (not (= ?v_4 ?v_32))) (not (= ?v_4 ?v_39))) (not (= ?v_4 ?v_46))) (not (= ?v_11 ?v_18))) (not (= ?v_11 ?v_25))) (not (= ?v_11 ?v_32))) (not (= ?v_11 ?v_39))) (not (= ?v_11 ?v_46))) (not (= ?v_18 ?v_25))) (not (= ?v_18 ?v_32))) (not (= ?v_18 ?v_39))) (not (= ?v_18 ?v_46))) (not (= ?v_25 ?v_32))) (not (= ?v_25 ?v_39))) (not (= ?v_25 ?v_46))) (not (= ?v_32 ?v_39))) (not (= ?v_32 ?v_46))) (not (= ?v_39 ?v_46)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_5 ?v_12)) (not (= ?v_5 ?v_19))) (not (= ?v_5 ?v_26))) (not (= ?v_5 ?v_33))) (not (= ?v_5 ?v_40))) (not (= ?v_5 ?v_47))) (not (= ?v_12 ?v_19))) (not (= ?v_12 ?v_26))) (not (= ?v_12 ?v_33))) (not (= ?v_12 ?v_40))) (not (= ?v_12 ?v_47))) (not (= ?v_19 ?v_26))) (not (= ?v_19 ?v_33))) (not (= ?v_19 ?v_40))) (not (= ?v_19 ?v_47))) (not (= ?v_26 ?v_33))) (not (= ?v_26 ?v_40))) (not (= ?v_26 ?v_47))) (not (= ?v_33 ?v_40))) (not (= ?v_33 ?v_47))) (not (= ?v_40 ?v_47)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_6 ?v_13)) (not (= ?v_6 ?v_20))) (not (= ?v_6 ?v_27))) (not (= ?v_6 ?v_34))) (not (= ?v_6 ?v_41))) (not (= ?v_6 ?v_48))) (not (= ?v_13 ?v_20))) (not (= ?v_13 ?v_27))) (not (= ?v_13 ?v_34))) (not (= ?v_13 ?v_41))) (not (= ?v_13 ?v_48))) (not (= ?v_20 ?v_27))) (not (= ?v_20 ?v_34))) (not (= ?v_20 ?v_41))) (not (= ?v_20 ?v_48))) (not (= ?v_27 ?v_34))) (not (= ?v_27 ?v_41))) (not (= ?v_27 ?v_48))) (not (= ?v_34 ?v_41))) (not (= ?v_34 ?v_48))) (not (= ?v_41 ?v_48)))))) :named jbxovCkiTkdQhRxuO)) (assert(! (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= e0 e1)) (not (= e0 e2))) (not (= e0 e3))) (not (= e0 e4))) (not (= e0 e5))) (not (= e0 e6))) (not (= e1 e2))) (not (= e1 e3))) (not (= e1 e4))) (not (= e1 e5))) (not (= e1 e6))) (not (= e2 e3))) (not (= e2 e4))) (not (= e2 e5))) (not (= e2 e6))) (not (= e3 e4))) (not (= e3 e5))) (not (= e3 e6))) (not (= e4 e5))) (not (= e4 e6))) (not (= e5 e6))) :named LkUluySFGcGIlT)) (assert(! (and (and (and (and (and (= e0 (op e3 e3)) (= e1 (op e0 e6))) (= e2 (op e0 e5))) (= e4 (op e5 e3))) (= e5 (op e1 e3))) (= e6 (op e0 e3))) :named PmWqevubyHT)) (assert(! (not (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= (op e0 e0) e3) (= (op e0 e1) e5)) (= (op e0 e2) e0)) (= (op e0 e3) e6)) (= (op e0 e4) e4)) (= (op e0 e5) e2)) (= (op e0 e6) e1)) (= (op e1 e0) e2)) (= (op e1 e1) e0)) (= (op e1 e2) e3)) (= (op e1 e3) e5)) (= (op e1 e4) e1)) (= (op e1 e5) e4)) (= (op e1 e6) e6)) (= (op e2 e0) e6)) (= (op e2 e1) e4)) (= (op e2 e2) e1)) (= (op e2 e3) e2)) (= (op e2 e4) e0)) (= (op e2 e5) e5)) (= (op e2 e6) e3)) (= (op e3 e0) e4)) (= (op e3 e1) e3)) (= (op e3 e2) e2)) (= (op e3 e3) e0)) (= (op e3 e4) e6)) (= (op e3 e5) e1)) (= (op e3 e6) e5)) (= (op e4 e0) e0)) (= (op e4 e1) e6)) (= (op e4 e2) e5)) (= (op e4 e3) e1)) (= (op e4 e4) e2)) (= (op e4 e5) e3)) (= (op e4 e6) e4)) (= (op e5 e0) e5)) (= (op e5 e1) e1)) (= (op e5 e2) e6)) (= (op e5 e3) e4)) (= (op e5 e4) e3)) (= (op e5 e5) e0)) (= (op e5 e6) e2)) (= (op e6 e0) e1)) (= (op e6 e1) e2)) (= (op e6 e2) e4)) (= (op e6 e3) e3)) (= (op e6 e4) e5)) (= (op e6 e5) e6)) (= (op e6 e6) e0))) :named RqLGTXHgpY)) (check-sat) opensmt-2.5.2/regression/picky/iso_brn_sk004_eufexps.smt2.expected.err000066400000000000000000000000001445011647600260130ustar00rootroot00000000000000opensmt-2.5.2/regression/picky/iso_brn_sk004_eufexps.smt2.expected.out000066400000000000000000000000061445011647600260400ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/picky/iso_brn_sk005_eufexps.smt2000066400000000000000000001217561445011647600234530ustar00rootroot00000000000000(set-option :picky true) (set-option :picky_w 10) (set-logic QF_UF) (set-info :source | http://www.cs.bham.ac.uk/~vxs/quasigroups/benchmark/ |) (set-info :smt-lib-version 2.0) (set-info :category "crafted") (set-info :status unsat) (declare-sort U 0) (declare-sort I 0) (declare-fun op1 (I I) I) (declare-fun op (I I) I) (declare-fun e6 () I) (declare-fun e5 () I) (declare-fun e4 () I) (declare-fun e3 () I) (declare-fun e2 () I) (declare-fun e1 () I) (declare-fun e0 () I) (declare-fun skc1 (I) I) (assert(! (let ((?v_0 (op e0 e0)) (?v_1 (op e0 e1)) (?v_2 (op e0 e2)) (?v_3 (op e0 e3)) (?v_4 (op e0 e4)) (?v_5 (op e0 e5)) (?v_6 (op e0 e6)) (?v_7 (op e1 e0)) (?v_8 (op e1 e1)) (?v_9 (op e1 e2)) (?v_10 (op e1 e3)) (?v_11 (op e1 e4)) (?v_12 (op e1 e5)) (?v_13 (op e1 e6)) (?v_14 (op e2 e0)) (?v_15 (op e2 e1)) (?v_16 (op e2 e2)) (?v_17 (op e2 e3)) (?v_18 (op e2 e4)) (?v_19 (op e2 e5)) (?v_20 (op e2 e6)) (?v_21 (op e3 e0)) (?v_22 (op e3 e1)) (?v_23 (op e3 e2)) (?v_24 (op e3 e3)) (?v_25 (op e3 e4)) (?v_26 (op e3 e5)) (?v_27 (op e3 e6)) (?v_28 (op e4 e0)) (?v_29 (op e4 e1)) (?v_30 (op e4 e2)) (?v_31 (op e4 e3)) (?v_32 (op e4 e4)) (?v_33 (op e4 e5)) (?v_34 (op e4 e6)) (?v_35 (op e5 e0)) (?v_36 (op e5 e1)) (?v_37 (op e5 e2)) (?v_38 (op e5 e3)) (?v_39 (op e5 e4)) (?v_40 (op e5 e5)) (?v_41 (op e5 e6)) (?v_42 (op e6 e0)) (?v_43 (op e6 e1)) (?v_44 (op e6 e2)) (?v_45 (op e6 e3)) (?v_46 (op e6 e4)) (?v_47 (op e6 e5)) (?v_48 (op e6 e6))) (and (and (and (and (and (and (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_0 e0) (= ?v_0 e1)) (= ?v_0 e2)) (= ?v_0 e3)) (= ?v_0 e4)) (= ?v_0 e5)) (= ?v_0 e6)) (or (or (or (or (or (or (= ?v_1 e0) (= ?v_1 e1)) (= ?v_1 e2)) (= ?v_1 e3)) (= ?v_1 e4)) (= ?v_1 e5)) (= ?v_1 e6))) (or (or (or (or (or (or (= ?v_2 e0) (= ?v_2 e1)) (= ?v_2 e2)) (= ?v_2 e3)) (= ?v_2 e4)) (= ?v_2 e5)) (= ?v_2 e6))) (or (or (or (or (or (or (= ?v_3 e0) (= ?v_3 e1)) (= ?v_3 e2)) (= ?v_3 e3)) (= ?v_3 e4)) (= ?v_3 e5)) (= ?v_3 e6))) (or (or (or (or (or (or (= ?v_4 e0) (= ?v_4 e1)) (= ?v_4 e2)) (= ?v_4 e3)) (= ?v_4 e4)) (= ?v_4 e5)) (= ?v_4 e6))) (or (or (or (or (or (or (= ?v_5 e0) (= ?v_5 e1)) (= ?v_5 e2)) (= ?v_5 e3)) (= ?v_5 e4)) (= ?v_5 e5)) (= ?v_5 e6))) (or (or (or (or (or (or (= ?v_6 e0) (= ?v_6 e1)) (= ?v_6 e2)) (= ?v_6 e3)) (= ?v_6 e4)) (= ?v_6 e5)) (= ?v_6 e6))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_7 e0) (= ?v_7 e1)) (= ?v_7 e2)) (= ?v_7 e3)) (= ?v_7 e4)) (= ?v_7 e5)) (= ?v_7 e6)) (or (or (or (or (or (or (= ?v_8 e0) (= ?v_8 e1)) (= ?v_8 e2)) (= ?v_8 e3)) (= ?v_8 e4)) (= ?v_8 e5)) (= ?v_8 e6))) (or (or (or (or (or (or (= ?v_9 e0) (= ?v_9 e1)) (= ?v_9 e2)) (= ?v_9 e3)) (= ?v_9 e4)) (= ?v_9 e5)) (= ?v_9 e6))) (or (or (or (or (or (or (= ?v_10 e0) (= ?v_10 e1)) (= ?v_10 e2)) (= ?v_10 e3)) (= ?v_10 e4)) (= ?v_10 e5)) (= ?v_10 e6))) (or (or (or (or (or (or (= ?v_11 e0) (= ?v_11 e1)) (= ?v_11 e2)) (= ?v_11 e3)) (= ?v_11 e4)) (= ?v_11 e5)) (= ?v_11 e6))) (or (or (or (or (or (or (= ?v_12 e0) (= ?v_12 e1)) (= ?v_12 e2)) (= ?v_12 e3)) (= ?v_12 e4)) (= ?v_12 e5)) (= ?v_12 e6))) (or (or (or (or (or (or (= ?v_13 e0) (= ?v_13 e1)) (= ?v_13 e2)) (= ?v_13 e3)) (= ?v_13 e4)) (= ?v_13 e5)) (= ?v_13 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_14 e0) (= ?v_14 e1)) (= ?v_14 e2)) (= ?v_14 e3)) (= ?v_14 e4)) (= ?v_14 e5)) (= ?v_14 e6)) (or (or (or (or (or (or (= ?v_15 e0) (= ?v_15 e1)) (= ?v_15 e2)) (= ?v_15 e3)) (= ?v_15 e4)) (= ?v_15 e5)) (= ?v_15 e6))) (or (or (or (or (or (or (= ?v_16 e0) (= ?v_16 e1)) (= ?v_16 e2)) (= ?v_16 e3)) (= ?v_16 e4)) (= ?v_16 e5)) (= ?v_16 e6))) (or (or (or (or (or (or (= ?v_17 e0) (= ?v_17 e1)) (= ?v_17 e2)) (= ?v_17 e3)) (= ?v_17 e4)) (= ?v_17 e5)) (= ?v_17 e6))) (or (or (or (or (or (or (= ?v_18 e0) (= ?v_18 e1)) (= ?v_18 e2)) (= ?v_18 e3)) (= ?v_18 e4)) (= ?v_18 e5)) (= ?v_18 e6))) (or (or (or (or (or (or (= ?v_19 e0) (= ?v_19 e1)) (= ?v_19 e2)) (= ?v_19 e3)) (= ?v_19 e4)) (= ?v_19 e5)) (= ?v_19 e6))) (or (or (or (or (or (or (= ?v_20 e0) (= ?v_20 e1)) (= ?v_20 e2)) (= ?v_20 e3)) (= ?v_20 e4)) (= ?v_20 e5)) (= ?v_20 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_21 e0) (= ?v_21 e1)) (= ?v_21 e2)) (= ?v_21 e3)) (= ?v_21 e4)) (= ?v_21 e5)) (= ?v_21 e6)) (or (or (or (or (or (or (= ?v_22 e0) (= ?v_22 e1)) (= ?v_22 e2)) (= ?v_22 e3)) (= ?v_22 e4)) (= ?v_22 e5)) (= ?v_22 e6))) (or (or (or (or (or (or (= ?v_23 e0) (= ?v_23 e1)) (= ?v_23 e2)) (= ?v_23 e3)) (= ?v_23 e4)) (= ?v_23 e5)) (= ?v_23 e6))) (or (or (or (or (or (or (= ?v_24 e0) (= ?v_24 e1)) (= ?v_24 e2)) (= ?v_24 e3)) (= ?v_24 e4)) (= ?v_24 e5)) (= ?v_24 e6))) (or (or (or (or (or (or (= ?v_25 e0) (= ?v_25 e1)) (= ?v_25 e2)) (= ?v_25 e3)) (= ?v_25 e4)) (= ?v_25 e5)) (= ?v_25 e6))) (or (or (or (or (or (or (= ?v_26 e0) (= ?v_26 e1)) (= ?v_26 e2)) (= ?v_26 e3)) (= ?v_26 e4)) (= ?v_26 e5)) (= ?v_26 e6))) (or (or (or (or (or (or (= ?v_27 e0) (= ?v_27 e1)) (= ?v_27 e2)) (= ?v_27 e3)) (= ?v_27 e4)) (= ?v_27 e5)) (= ?v_27 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_28 e0) (= ?v_28 e1)) (= ?v_28 e2)) (= ?v_28 e3)) (= ?v_28 e4)) (= ?v_28 e5)) (= ?v_28 e6)) (or (or (or (or (or (or (= ?v_29 e0) (= ?v_29 e1)) (= ?v_29 e2)) (= ?v_29 e3)) (= ?v_29 e4)) (= ?v_29 e5)) (= ?v_29 e6))) (or (or (or (or (or (or (= ?v_30 e0) (= ?v_30 e1)) (= ?v_30 e2)) (= ?v_30 e3)) (= ?v_30 e4)) (= ?v_30 e5)) (= ?v_30 e6))) (or (or (or (or (or (or (= ?v_31 e0) (= ?v_31 e1)) (= ?v_31 e2)) (= ?v_31 e3)) (= ?v_31 e4)) (= ?v_31 e5)) (= ?v_31 e6))) (or (or (or (or (or (or (= ?v_32 e0) (= ?v_32 e1)) (= ?v_32 e2)) (= ?v_32 e3)) (= ?v_32 e4)) (= ?v_32 e5)) (= ?v_32 e6))) (or (or (or (or (or (or (= ?v_33 e0) (= ?v_33 e1)) (= ?v_33 e2)) (= ?v_33 e3)) (= ?v_33 e4)) (= ?v_33 e5)) (= ?v_33 e6))) (or (or (or (or (or (or (= ?v_34 e0) (= ?v_34 e1)) (= ?v_34 e2)) (= ?v_34 e3)) (= ?v_34 e4)) (= ?v_34 e5)) (= ?v_34 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_35 e0) (= ?v_35 e1)) (= ?v_35 e2)) (= ?v_35 e3)) (= ?v_35 e4)) (= ?v_35 e5)) (= ?v_35 e6)) (or (or (or (or (or (or (= ?v_36 e0) (= ?v_36 e1)) (= ?v_36 e2)) (= ?v_36 e3)) (= ?v_36 e4)) (= ?v_36 e5)) (= ?v_36 e6))) (or (or (or (or (or (or (= ?v_37 e0) (= ?v_37 e1)) (= ?v_37 e2)) (= ?v_37 e3)) (= ?v_37 e4)) (= ?v_37 e5)) (= ?v_37 e6))) (or (or (or (or (or (or (= ?v_38 e0) (= ?v_38 e1)) (= ?v_38 e2)) (= ?v_38 e3)) (= ?v_38 e4)) (= ?v_38 e5)) (= ?v_38 e6))) (or (or (or (or (or (or (= ?v_39 e0) (= ?v_39 e1)) (= ?v_39 e2)) (= ?v_39 e3)) (= ?v_39 e4)) (= ?v_39 e5)) (= ?v_39 e6))) (or (or (or (or (or (or (= ?v_40 e0) (= ?v_40 e1)) (= ?v_40 e2)) (= ?v_40 e3)) (= ?v_40 e4)) (= ?v_40 e5)) (= ?v_40 e6))) (or (or (or (or (or (or (= ?v_41 e0) (= ?v_41 e1)) (= ?v_41 e2)) (= ?v_41 e3)) (= ?v_41 e4)) (= ?v_41 e5)) (= ?v_41 e6)))) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_42 e0) (= ?v_42 e1)) (= ?v_42 e2)) (= ?v_42 e3)) (= ?v_42 e4)) (= ?v_42 e5)) (= ?v_42 e6)) (or (or (or (or (or (or (= ?v_43 e0) (= ?v_43 e1)) (= ?v_43 e2)) (= ?v_43 e3)) (= ?v_43 e4)) (= ?v_43 e5)) (= ?v_43 e6))) (or (or (or (or (or (or (= ?v_44 e0) (= ?v_44 e1)) (= ?v_44 e2)) (= ?v_44 e3)) (= ?v_44 e4)) (= ?v_44 e5)) (= ?v_44 e6))) (or (or (or (or (or (or (= ?v_45 e0) (= ?v_45 e1)) (= ?v_45 e2)) (= ?v_45 e3)) (= ?v_45 e4)) (= ?v_45 e5)) (= ?v_45 e6))) (or (or (or (or (or (or (= ?v_46 e0) (= ?v_46 e1)) (= ?v_46 e2)) (= ?v_46 e3)) (= ?v_46 e4)) (= ?v_46 e5)) (= ?v_46 e6))) (or (or (or (or (or (or (= ?v_47 e0) (= ?v_47 e1)) (= ?v_47 e2)) (= ?v_47 e3)) (= ?v_47 e4)) (= ?v_47 e5)) (= ?v_47 e6))) (or (or (or (or (or (or (= ?v_48 e0) (= ?v_48 e1)) (= ?v_48 e2)) (= ?v_48 e3)) (= ?v_48 e4)) (= ?v_48 e5)) (= ?v_48 e6))))) :named mebtLDBcwEeb)) (assert(! (let ((?v_1 (op e0 e0)) (?v_2 (op e0 e1)) (?v_3 (op e0 e2)) (?v_4 (op e0 e3)) (?v_5 (op e0 e4)) (?v_6 (op e0 e5)) (?v_7 (op e0 e6)) (?v_9 (op e1 e0)) (?v_24 (op e1 e1)) (?v_25 (op e1 e2)) (?v_26 (op e1 e3)) (?v_27 (op e1 e4)) (?v_28 (op e1 e5)) (?v_29 (op e1 e6)) (?v_10 (op e2 e0)) (?v_32 (op e2 e1)) (?v_59 (op e2 e2)) (?v_60 (op e2 e3)) (?v_61 (op e2 e4)) (?v_62 (op e2 e5)) (?v_63 (op e2 e6)) (?v_11 (op e3 e0)) (?v_33 (op e3 e1)) (?v_67 (op e3 e2)) (?v_106 (op e3 e3)) (?v_107 (op e3 e4)) (?v_108 (op e3 e5)) (?v_109 (op e3 e6)) (?v_12 (op e4 e0)) (?v_34 (op e4 e1)) (?v_68 (op e4 e2)) (?v_114 (op e4 e3)) (?v_165 (op e4 e4)) (?v_166 (op e4 e5)) (?v_167 (op e4 e6)) (?v_13 (op e5 e0)) (?v_35 (op e5 e1)) (?v_69 (op e5 e2)) (?v_115 (op e5 e3)) (?v_173 (op e5 e4)) (?v_236 (op e5 e5)) (?v_237 (op e5 e6)) (?v_14 (op e6 e0)) (?v_36 (op e6 e1)) (?v_70 (op e6 e2)) (?v_116 (op e6 e3)) (?v_174 (op e6 e4)) (?v_244 (op e6 e5)) (?v_319 (op e6 e6))) (let ((?v_0 (= ?v_1 e0)) (?v_8 (= ?v_1 e1)) (?v_15 (= ?v_1 e2)) (?v_16 (= ?v_1 e3)) (?v_17 (= ?v_1 e4)) (?v_18 (= ?v_1 e5)) (?v_19 (= ?v_1 e6)) (?v_21 (= ?v_2 e0)) (?v_30 (= ?v_2 e1)) (?v_38 (= ?v_2 e2)) (?v_41 (= ?v_2 e3)) (?v_44 (= ?v_2 e4)) (?v_47 (= ?v_2 e5)) (?v_50 (= ?v_2 e6)) (?v_54 (= ?v_3 e0)) (?v_64 (= ?v_3 e1)) (?v_73 (= ?v_3 e2)) (?v_78 (= ?v_3 e3)) (?v_83 (= ?v_3 e4)) (?v_88 (= ?v_3 e5)) (?v_93 (= ?v_3 e6)) (?v_99 (= ?v_4 e0)) (?v_110 (= ?v_4 e1)) (?v_120 (= ?v_4 e2)) (?v_127 (= ?v_4 e3)) (?v_134 (= ?v_4 e4)) (?v_141 (= ?v_4 e5)) (?v_148 (= ?v_4 e6)) (?v_156 (= ?v_5 e0)) (?v_168 (= ?v_5 e1)) (?v_179 (= ?v_5 e2)) (?v_188 (= ?v_5 e3)) (?v_197 (= ?v_5 e4)) (?v_206 (= ?v_5 e5)) (?v_215 (= ?v_5 e6)) (?v_225 (= ?v_6 e0)) (?v_238 (= ?v_6 e1)) (?v_250 (= ?v_6 e2)) (?v_261 (= ?v_6 e3)) (?v_272 (= ?v_6 e4)) (?v_283 (= ?v_6 e5)) (?v_294 (= ?v_6 e6)) (?v_306 (= ?v_7 e0)) (?v_320 (= ?v_7 e1)) (?v_333 (= ?v_7 e2)) (?v_346 (= ?v_7 e3)) (?v_359 (= ?v_7 e4)) (?v_372 (= ?v_7 e5)) (?v_385 (= ?v_7 e6)) (?v_20 (= ?v_9 e0)) (?v_23 (= ?v_9 e1)) (?v_37 (= ?v_9 e2)) (?v_40 (= ?v_9 e3)) (?v_43 (= ?v_9 e4)) (?v_46 (= ?v_9 e5)) (?v_49 (= ?v_9 e6)) (?v_22 (= ?v_24 e0)) (?v_31 (= ?v_24 e1)) (?v_39 (= ?v_24 e2)) (?v_42 (= ?v_24 e3)) (?v_45 (= ?v_24 e4)) (?v_48 (= ?v_24 e5)) (?v_51 (= ?v_24 e6)) (?v_55 (= ?v_25 e0)) (?v_65 (= ?v_25 e1)) (?v_74 (= ?v_25 e2)) (?v_79 (= ?v_25 e3)) (?v_84 (= ?v_25 e4)) (?v_89 (= ?v_25 e5)) (?v_94 (= ?v_25 e6)) (?v_100 (= ?v_26 e0)) (?v_111 (= ?v_26 e1)) (?v_121 (= ?v_26 e2)) (?v_128 (= ?v_26 e3)) (?v_135 (= ?v_26 e4)) (?v_142 (= ?v_26 e5)) (?v_149 (= ?v_26 e6)) (?v_157 (= ?v_27 e0)) (?v_169 (= ?v_27 e1)) (?v_180 (= ?v_27 e2)) (?v_189 (= ?v_27 e3)) (?v_198 (= ?v_27 e4)) (?v_207 (= ?v_27 e5)) (?v_216 (= ?v_27 e6)) (?v_226 (= ?v_28 e0)) (?v_239 (= ?v_28 e1)) (?v_251 (= ?v_28 e2)) (?v_262 (= ?v_28 e3)) (?v_273 (= ?v_28 e4)) (?v_284 (= ?v_28 e5)) (?v_295 (= ?v_28 e6)) (?v_307 (= ?v_29 e0)) (?v_321 (= ?v_29 e1)) (?v_334 (= ?v_29 e2)) (?v_347 (= ?v_29 e3)) (?v_360 (= ?v_29 e4)) (?v_373 (= ?v_29 e5)) (?v_386 (= ?v_29 e6)) (?v_52 (= ?v_10 e0)) (?v_57 (= ?v_10 e1)) (?v_71 (= ?v_10 e2)) (?v_76 (= ?v_10 e3)) (?v_81 (= ?v_10 e4)) (?v_86 (= ?v_10 e5)) (?v_91 (= ?v_10 e6)) (?v_53 (= ?v_32 e0)) (?v_58 (= ?v_32 e1)) (?v_72 (= ?v_32 e2)) (?v_77 (= ?v_32 e3)) (?v_82 (= ?v_32 e4)) (?v_87 (= ?v_32 e5)) (?v_92 (= ?v_32 e6)) (?v_56 (= ?v_59 e0)) (?v_66 (= ?v_59 e1)) (?v_75 (= ?v_59 e2)) (?v_80 (= ?v_59 e3)) (?v_85 (= ?v_59 e4)) (?v_90 (= ?v_59 e5)) (?v_95 (= ?v_59 e6)) (?v_101 (= ?v_60 e0)) (?v_112 (= ?v_60 e1)) (?v_122 (= ?v_60 e2)) (?v_129 (= ?v_60 e3)) (?v_136 (= ?v_60 e4)) (?v_143 (= ?v_60 e5)) (?v_150 (= ?v_60 e6)) (?v_158 (= ?v_61 e0)) (?v_170 (= ?v_61 e1)) (?v_181 (= ?v_61 e2)) (?v_190 (= ?v_61 e3)) (?v_199 (= ?v_61 e4)) (?v_208 (= ?v_61 e5)) (?v_217 (= ?v_61 e6)) (?v_227 (= ?v_62 e0)) (?v_240 (= ?v_62 e1)) (?v_252 (= ?v_62 e2)) (?v_263 (= ?v_62 e3)) (?v_274 (= ?v_62 e4)) (?v_285 (= ?v_62 e5)) (?v_296 (= ?v_62 e6)) (?v_308 (= ?v_63 e0)) (?v_322 (= ?v_63 e1)) (?v_335 (= ?v_63 e2)) (?v_348 (= ?v_63 e3)) (?v_361 (= ?v_63 e4)) (?v_374 (= ?v_63 e5)) (?v_387 (= ?v_63 e6)) (?v_96 (= ?v_11 e0)) (?v_103 (= ?v_11 e1)) (?v_117 (= ?v_11 e2)) (?v_124 (= ?v_11 e3)) (?v_131 (= ?v_11 e4)) (?v_138 (= ?v_11 e5)) (?v_145 (= ?v_11 e6)) (?v_97 (= ?v_33 e0)) (?v_104 (= ?v_33 e1)) (?v_118 (= ?v_33 e2)) (?v_125 (= ?v_33 e3)) (?v_132 (= ?v_33 e4)) (?v_139 (= ?v_33 e5)) (?v_146 (= ?v_33 e6)) (?v_98 (= ?v_67 e0)) (?v_105 (= ?v_67 e1)) (?v_119 (= ?v_67 e2)) (?v_126 (= ?v_67 e3)) (?v_133 (= ?v_67 e4)) (?v_140 (= ?v_67 e5)) (?v_147 (= ?v_67 e6)) (?v_102 (= ?v_106 e0)) (?v_113 (= ?v_106 e1)) (?v_123 (= ?v_106 e2)) (?v_130 (= ?v_106 e3)) (?v_137 (= ?v_106 e4)) (?v_144 (= ?v_106 e5)) (?v_151 (= ?v_106 e6)) (?v_159 (= ?v_107 e0)) (?v_171 (= ?v_107 e1)) (?v_182 (= ?v_107 e2)) (?v_191 (= ?v_107 e3)) (?v_200 (= ?v_107 e4)) (?v_209 (= ?v_107 e5)) (?v_218 (= ?v_107 e6)) (?v_228 (= ?v_108 e0)) (?v_241 (= ?v_108 e1)) (?v_253 (= ?v_108 e2)) (?v_264 (= ?v_108 e3)) (?v_275 (= ?v_108 e4)) (?v_286 (= ?v_108 e5)) (?v_297 (= ?v_108 e6)) (?v_309 (= ?v_109 e0)) (?v_323 (= ?v_109 e1)) (?v_336 (= ?v_109 e2)) (?v_349 (= ?v_109 e3)) (?v_362 (= ?v_109 e4)) (?v_375 (= ?v_109 e5)) (?v_388 (= ?v_109 e6)) (?v_152 (= ?v_12 e0)) (?v_161 (= ?v_12 e1)) (?v_175 (= ?v_12 e2)) (?v_184 (= ?v_12 e3)) (?v_193 (= ?v_12 e4)) (?v_202 (= ?v_12 e5)) (?v_211 (= ?v_12 e6)) (?v_153 (= ?v_34 e0)) (?v_162 (= ?v_34 e1)) (?v_176 (= ?v_34 e2)) (?v_185 (= ?v_34 e3)) (?v_194 (= ?v_34 e4)) (?v_203 (= ?v_34 e5)) (?v_212 (= ?v_34 e6)) (?v_154 (= ?v_68 e0)) (?v_163 (= ?v_68 e1)) (?v_177 (= ?v_68 e2)) (?v_186 (= ?v_68 e3)) (?v_195 (= ?v_68 e4)) (?v_204 (= ?v_68 e5)) (?v_213 (= ?v_68 e6)) (?v_155 (= ?v_114 e0)) (?v_164 (= ?v_114 e1)) (?v_178 (= ?v_114 e2)) (?v_187 (= ?v_114 e3)) (?v_196 (= ?v_114 e4)) (?v_205 (= ?v_114 e5)) (?v_214 (= ?v_114 e6)) (?v_160 (= ?v_165 e0)) (?v_172 (= ?v_165 e1)) (?v_183 (= ?v_165 e2)) (?v_192 (= ?v_165 e3)) (?v_201 (= ?v_165 e4)) (?v_210 (= ?v_165 e5)) (?v_219 (= ?v_165 e6)) (?v_229 (= ?v_166 e0)) (?v_242 (= ?v_166 e1)) (?v_254 (= ?v_166 e2)) (?v_265 (= ?v_166 e3)) (?v_276 (= ?v_166 e4)) (?v_287 (= ?v_166 e5)) (?v_298 (= ?v_166 e6)) (?v_310 (= ?v_167 e0)) (?v_324 (= ?v_167 e1)) (?v_337 (= ?v_167 e2)) (?v_350 (= ?v_167 e3)) (?v_363 (= ?v_167 e4)) (?v_376 (= ?v_167 e5)) (?v_389 (= ?v_167 e6)) (?v_220 (= ?v_13 e0)) (?v_231 (= ?v_13 e1)) (?v_245 (= ?v_13 e2)) (?v_256 (= ?v_13 e3)) (?v_267 (= ?v_13 e4)) (?v_278 (= ?v_13 e5)) (?v_289 (= ?v_13 e6)) (?v_221 (= ?v_35 e0)) (?v_232 (= ?v_35 e1)) (?v_246 (= ?v_35 e2)) (?v_257 (= ?v_35 e3)) (?v_268 (= ?v_35 e4)) (?v_279 (= ?v_35 e5)) (?v_290 (= ?v_35 e6)) (?v_222 (= ?v_69 e0)) (?v_233 (= ?v_69 e1)) (?v_247 (= ?v_69 e2)) (?v_258 (= ?v_69 e3)) (?v_269 (= ?v_69 e4)) (?v_280 (= ?v_69 e5)) (?v_291 (= ?v_69 e6)) (?v_223 (= ?v_115 e0)) (?v_234 (= ?v_115 e1)) (?v_248 (= ?v_115 e2)) (?v_259 (= ?v_115 e3)) (?v_270 (= ?v_115 e4)) (?v_281 (= ?v_115 e5)) (?v_292 (= ?v_115 e6)) (?v_224 (= ?v_173 e0)) (?v_235 (= ?v_173 e1)) (?v_249 (= ?v_173 e2)) (?v_260 (= ?v_173 e3)) (?v_271 (= ?v_173 e4)) (?v_282 (= ?v_173 e5)) (?v_293 (= ?v_173 e6)) (?v_230 (= ?v_236 e0)) (?v_243 (= ?v_236 e1)) (?v_255 (= ?v_236 e2)) (?v_266 (= ?v_236 e3)) (?v_277 (= ?v_236 e4)) (?v_288 (= ?v_236 e5)) (?v_299 (= ?v_236 e6)) (?v_311 (= ?v_237 e0)) (?v_325 (= ?v_237 e1)) (?v_338 (= ?v_237 e2)) (?v_351 (= ?v_237 e3)) (?v_364 (= ?v_237 e4)) (?v_377 (= ?v_237 e5)) (?v_390 (= ?v_237 e6)) (?v_300 (= ?v_14 e0)) (?v_313 (= ?v_14 e1)) (?v_327 (= ?v_14 e2)) (?v_340 (= ?v_14 e3)) (?v_353 (= ?v_14 e4)) (?v_366 (= ?v_14 e5)) (?v_379 (= ?v_14 e6)) (?v_301 (= ?v_36 e0)) (?v_314 (= ?v_36 e1)) (?v_328 (= ?v_36 e2)) (?v_341 (= ?v_36 e3)) (?v_354 (= ?v_36 e4)) (?v_367 (= ?v_36 e5)) (?v_380 (= ?v_36 e6)) (?v_302 (= ?v_70 e0)) (?v_315 (= ?v_70 e1)) (?v_329 (= ?v_70 e2)) (?v_342 (= ?v_70 e3)) (?v_355 (= ?v_70 e4)) (?v_368 (= ?v_70 e5)) (?v_381 (= ?v_70 e6)) (?v_303 (= ?v_116 e0)) (?v_316 (= ?v_116 e1)) (?v_330 (= ?v_116 e2)) (?v_343 (= ?v_116 e3)) (?v_356 (= ?v_116 e4)) (?v_369 (= ?v_116 e5)) (?v_382 (= ?v_116 e6)) (?v_304 (= ?v_174 e0)) (?v_317 (= ?v_174 e1)) (?v_331 (= ?v_174 e2)) (?v_344 (= ?v_174 e3)) (?v_357 (= ?v_174 e4)) (?v_370 (= ?v_174 e5)) (?v_383 (= ?v_174 e6)) (?v_305 (= ?v_244 e0)) (?v_318 (= ?v_244 e1)) (?v_332 (= ?v_244 e2)) (?v_345 (= ?v_244 e3)) (?v_358 (= ?v_244 e4)) (?v_371 (= ?v_244 e5)) (?v_384 (= ?v_244 e6)) (?v_312 (= ?v_319 e0)) (?v_326 (= ?v_319 e1)) (?v_339 (= ?v_319 e2)) (?v_352 (= ?v_319 e3)) (?v_365 (= ?v_319 e4)) (?v_378 (= ?v_319 e5)) (?v_391 (= ?v_319 e6))) (and (and (and (and (and (and (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_0 ?v_21) ?v_54) ?v_99) ?v_156) ?v_225) ?v_306) (or (or (or (or (or (or ?v_0 ?v_20) ?v_52) ?v_96) ?v_152) ?v_220) ?v_300)) (and (or (or (or (or (or (or ?v_8 ?v_30) ?v_64) ?v_110) ?v_168) ?v_238) ?v_320) (or (or (or (or (or (or ?v_8 ?v_23) ?v_57) ?v_103) ?v_161) ?v_231) ?v_313))) (and (or (or (or (or (or (or ?v_15 ?v_38) ?v_73) ?v_120) ?v_179) ?v_250) ?v_333) (or (or (or (or (or (or ?v_15 ?v_37) ?v_71) ?v_117) ?v_175) ?v_245) ?v_327))) (and (or (or (or (or (or (or ?v_16 ?v_41) ?v_78) ?v_127) ?v_188) ?v_261) ?v_346) (or (or (or (or (or (or ?v_16 ?v_40) ?v_76) ?v_124) ?v_184) ?v_256) ?v_340))) (and (or (or (or (or (or (or ?v_17 ?v_44) ?v_83) ?v_134) ?v_197) ?v_272) ?v_359) (or (or (or (or (or (or ?v_17 ?v_43) ?v_81) ?v_131) ?v_193) ?v_267) ?v_353))) (and (or (or (or (or (or (or ?v_18 ?v_47) ?v_88) ?v_141) ?v_206) ?v_283) ?v_372) (or (or (or (or (or (or ?v_18 ?v_46) ?v_86) ?v_138) ?v_202) ?v_278) ?v_366))) (and (or (or (or (or (or (or ?v_19 ?v_50) ?v_93) ?v_148) ?v_215) ?v_294) ?v_385) (or (or (or (or (or (or ?v_19 ?v_49) ?v_91) ?v_145) ?v_211) ?v_289) ?v_379))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_20 ?v_22) ?v_55) ?v_100) ?v_157) ?v_226) ?v_307) (or (or (or (or (or (or ?v_21 ?v_22) ?v_53) ?v_97) ?v_153) ?v_221) ?v_301)) (and (or (or (or (or (or (or ?v_23 ?v_31) ?v_65) ?v_111) ?v_169) ?v_239) ?v_321) (or (or (or (or (or (or ?v_30 ?v_31) ?v_58) ?v_104) ?v_162) ?v_232) ?v_314))) (and (or (or (or (or (or (or ?v_37 ?v_39) ?v_74) ?v_121) ?v_180) ?v_251) ?v_334) (or (or (or (or (or (or ?v_38 ?v_39) ?v_72) ?v_118) ?v_176) ?v_246) ?v_328))) (and (or (or (or (or (or (or ?v_40 ?v_42) ?v_79) ?v_128) ?v_189) ?v_262) ?v_347) (or (or (or (or (or (or ?v_41 ?v_42) ?v_77) ?v_125) ?v_185) ?v_257) ?v_341))) (and (or (or (or (or (or (or ?v_43 ?v_45) ?v_84) ?v_135) ?v_198) ?v_273) ?v_360) (or (or (or (or (or (or ?v_44 ?v_45) ?v_82) ?v_132) ?v_194) ?v_268) ?v_354))) (and (or (or (or (or (or (or ?v_46 ?v_48) ?v_89) ?v_142) ?v_207) ?v_284) ?v_373) (or (or (or (or (or (or ?v_47 ?v_48) ?v_87) ?v_139) ?v_203) ?v_279) ?v_367))) (and (or (or (or (or (or (or ?v_49 ?v_51) ?v_94) ?v_149) ?v_216) ?v_295) ?v_386) (or (or (or (or (or (or ?v_50 ?v_51) ?v_92) ?v_146) ?v_212) ?v_290) ?v_380)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_52 ?v_53) ?v_56) ?v_101) ?v_158) ?v_227) ?v_308) (or (or (or (or (or (or ?v_54 ?v_55) ?v_56) ?v_98) ?v_154) ?v_222) ?v_302)) (and (or (or (or (or (or (or ?v_57 ?v_58) ?v_66) ?v_112) ?v_170) ?v_240) ?v_322) (or (or (or (or (or (or ?v_64 ?v_65) ?v_66) ?v_105) ?v_163) ?v_233) ?v_315))) (and (or (or (or (or (or (or ?v_71 ?v_72) ?v_75) ?v_122) ?v_181) ?v_252) ?v_335) (or (or (or (or (or (or ?v_73 ?v_74) ?v_75) ?v_119) ?v_177) ?v_247) ?v_329))) (and (or (or (or (or (or (or ?v_76 ?v_77) ?v_80) ?v_129) ?v_190) ?v_263) ?v_348) (or (or (or (or (or (or ?v_78 ?v_79) ?v_80) ?v_126) ?v_186) ?v_258) ?v_342))) (and (or (or (or (or (or (or ?v_81 ?v_82) ?v_85) ?v_136) ?v_199) ?v_274) ?v_361) (or (or (or (or (or (or ?v_83 ?v_84) ?v_85) ?v_133) ?v_195) ?v_269) ?v_355))) (and (or (or (or (or (or (or ?v_86 ?v_87) ?v_90) ?v_143) ?v_208) ?v_285) ?v_374) (or (or (or (or (or (or ?v_88 ?v_89) ?v_90) ?v_140) ?v_204) ?v_280) ?v_368))) (and (or (or (or (or (or (or ?v_91 ?v_92) ?v_95) ?v_150) ?v_217) ?v_296) ?v_387) (or (or (or (or (or (or ?v_93 ?v_94) ?v_95) ?v_147) ?v_213) ?v_291) ?v_381)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_96 ?v_97) ?v_98) ?v_102) ?v_159) ?v_228) ?v_309) (or (or (or (or (or (or ?v_99 ?v_100) ?v_101) ?v_102) ?v_155) ?v_223) ?v_303)) (and (or (or (or (or (or (or ?v_103 ?v_104) ?v_105) ?v_113) ?v_171) ?v_241) ?v_323) (or (or (or (or (or (or ?v_110 ?v_111) ?v_112) ?v_113) ?v_164) ?v_234) ?v_316))) (and (or (or (or (or (or (or ?v_117 ?v_118) ?v_119) ?v_123) ?v_182) ?v_253) ?v_336) (or (or (or (or (or (or ?v_120 ?v_121) ?v_122) ?v_123) ?v_178) ?v_248) ?v_330))) (and (or (or (or (or (or (or ?v_124 ?v_125) ?v_126) ?v_130) ?v_191) ?v_264) ?v_349) (or (or (or (or (or (or ?v_127 ?v_128) ?v_129) ?v_130) ?v_187) ?v_259) ?v_343))) (and (or (or (or (or (or (or ?v_131 ?v_132) ?v_133) ?v_137) ?v_200) ?v_275) ?v_362) (or (or (or (or (or (or ?v_134 ?v_135) ?v_136) ?v_137) ?v_196) ?v_270) ?v_356))) (and (or (or (or (or (or (or ?v_138 ?v_139) ?v_140) ?v_144) ?v_209) ?v_286) ?v_375) (or (or (or (or (or (or ?v_141 ?v_142) ?v_143) ?v_144) ?v_205) ?v_281) ?v_369))) (and (or (or (or (or (or (or ?v_145 ?v_146) ?v_147) ?v_151) ?v_218) ?v_297) ?v_388) (or (or (or (or (or (or ?v_148 ?v_149) ?v_150) ?v_151) ?v_214) ?v_292) ?v_382)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_152 ?v_153) ?v_154) ?v_155) ?v_160) ?v_229) ?v_310) (or (or (or (or (or (or ?v_156 ?v_157) ?v_158) ?v_159) ?v_160) ?v_224) ?v_304)) (and (or (or (or (or (or (or ?v_161 ?v_162) ?v_163) ?v_164) ?v_172) ?v_242) ?v_324) (or (or (or (or (or (or ?v_168 ?v_169) ?v_170) ?v_171) ?v_172) ?v_235) ?v_317))) (and (or (or (or (or (or (or ?v_175 ?v_176) ?v_177) ?v_178) ?v_183) ?v_254) ?v_337) (or (or (or (or (or (or ?v_179 ?v_180) ?v_181) ?v_182) ?v_183) ?v_249) ?v_331))) (and (or (or (or (or (or (or ?v_184 ?v_185) ?v_186) ?v_187) ?v_192) ?v_265) ?v_350) (or (or (or (or (or (or ?v_188 ?v_189) ?v_190) ?v_191) ?v_192) ?v_260) ?v_344))) (and (or (or (or (or (or (or ?v_193 ?v_194) ?v_195) ?v_196) ?v_201) ?v_276) ?v_363) (or (or (or (or (or (or ?v_197 ?v_198) ?v_199) ?v_200) ?v_201) ?v_271) ?v_357))) (and (or (or (or (or (or (or ?v_202 ?v_203) ?v_204) ?v_205) ?v_210) ?v_287) ?v_376) (or (or (or (or (or (or ?v_206 ?v_207) ?v_208) ?v_209) ?v_210) ?v_282) ?v_370))) (and (or (or (or (or (or (or ?v_211 ?v_212) ?v_213) ?v_214) ?v_219) ?v_298) ?v_389) (or (or (or (or (or (or ?v_215 ?v_216) ?v_217) ?v_218) ?v_219) ?v_293) ?v_383)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_220 ?v_221) ?v_222) ?v_223) ?v_224) ?v_230) ?v_311) (or (or (or (or (or (or ?v_225 ?v_226) ?v_227) ?v_228) ?v_229) ?v_230) ?v_305)) (and (or (or (or (or (or (or ?v_231 ?v_232) ?v_233) ?v_234) ?v_235) ?v_243) ?v_325) (or (or (or (or (or (or ?v_238 ?v_239) ?v_240) ?v_241) ?v_242) ?v_243) ?v_318))) (and (or (or (or (or (or (or ?v_245 ?v_246) ?v_247) ?v_248) ?v_249) ?v_255) ?v_338) (or (or (or (or (or (or ?v_250 ?v_251) ?v_252) ?v_253) ?v_254) ?v_255) ?v_332))) (and (or (or (or (or (or (or ?v_256 ?v_257) ?v_258) ?v_259) ?v_260) ?v_266) ?v_351) (or (or (or (or (or (or ?v_261 ?v_262) ?v_263) ?v_264) ?v_265) ?v_266) ?v_345))) (and (or (or (or (or (or (or ?v_267 ?v_268) ?v_269) ?v_270) ?v_271) ?v_277) ?v_364) (or (or (or (or (or (or ?v_272 ?v_273) ?v_274) ?v_275) ?v_276) ?v_277) ?v_358))) (and (or (or (or (or (or (or ?v_278 ?v_279) ?v_280) ?v_281) ?v_282) ?v_288) ?v_377) (or (or (or (or (or (or ?v_283 ?v_284) ?v_285) ?v_286) ?v_287) ?v_288) ?v_371))) (and (or (or (or (or (or (or ?v_289 ?v_290) ?v_291) ?v_292) ?v_293) ?v_299) ?v_390) (or (or (or (or (or (or ?v_294 ?v_295) ?v_296) ?v_297) ?v_298) ?v_299) ?v_384)))) (and (and (and (and (and (and (and (or (or (or (or (or (or ?v_300 ?v_301) ?v_302) ?v_303) ?v_304) ?v_305) ?v_312) (or (or (or (or (or (or ?v_306 ?v_307) ?v_308) ?v_309) ?v_310) ?v_311) ?v_312)) (and (or (or (or (or (or (or ?v_313 ?v_314) ?v_315) ?v_316) ?v_317) ?v_318) ?v_326) (or (or (or (or (or (or ?v_320 ?v_321) ?v_322) ?v_323) ?v_324) ?v_325) ?v_326))) (and (or (or (or (or (or (or ?v_327 ?v_328) ?v_329) ?v_330) ?v_331) ?v_332) ?v_339) (or (or (or (or (or (or ?v_333 ?v_334) ?v_335) ?v_336) ?v_337) ?v_338) ?v_339))) (and (or (or (or (or (or (or ?v_340 ?v_341) ?v_342) ?v_343) ?v_344) ?v_345) ?v_352) (or (or (or (or (or (or ?v_346 ?v_347) ?v_348) ?v_349) ?v_350) ?v_351) ?v_352))) (and (or (or (or (or (or (or ?v_353 ?v_354) ?v_355) ?v_356) ?v_357) ?v_358) ?v_365) (or (or (or (or (or (or ?v_359 ?v_360) ?v_361) ?v_362) ?v_363) ?v_364) ?v_365))) (and (or (or (or (or (or (or ?v_366 ?v_367) ?v_368) ?v_369) ?v_370) ?v_371) ?v_378) (or (or (or (or (or (or ?v_372 ?v_373) ?v_374) ?v_375) ?v_376) ?v_377) ?v_378))) (and (or (or (or (or (or (or ?v_379 ?v_380) ?v_381) ?v_382) ?v_383) ?v_384) ?v_391) (or (or (or (or (or (or ?v_385 ?v_386) ?v_387) ?v_388) ?v_389) ?v_390) ?v_391)))))) :named dEPoQfurjVTsXMrT)) (assert(! (and (and (and (and (and (and (and (and (and (and (and (and (= (op (op (op e0 e0) e0) e0) e0) (= (op (op (op e0 e1) e1) e1) e0)) (= (op (op (op e0 e2) e2) e2) e0)) (= (op (op (op e0 e3) e3) e3) e0)) (= (op (op (op e0 e4) e4) e4) e0)) (= (op (op (op e0 e5) e5) e5) e0)) (= (op (op (op e0 e6) e6) e6) e0)) (and (and (and (and (and (and (= (op (op (op e1 e0) e0) e0) e1) (= (op (op (op e1 e1) e1) e1) e1)) (= (op (op (op e1 e2) e2) e2) e1)) (= (op (op (op e1 e3) e3) e3) e1)) (= (op (op (op e1 e4) e4) e4) e1)) (= (op (op (op e1 e5) e5) e5) e1)) (= (op (op (op e1 e6) e6) e6) e1))) (and (and (and (and (and (and (= (op (op (op e2 e0) e0) e0) e2) (= (op (op (op e2 e1) e1) e1) e2)) (= (op (op (op e2 e2) e2) e2) e2)) (= (op (op (op e2 e3) e3) e3) e2)) (= (op (op (op e2 e4) e4) e4) e2)) (= (op (op (op e2 e5) e5) e5) e2)) (= (op (op (op e2 e6) e6) e6) e2))) (and (and (and (and (and (and (= (op (op (op e3 e0) e0) e0) e3) (= (op (op (op e3 e1) e1) e1) e3)) (= (op (op (op e3 e2) e2) e2) e3)) (= (op (op (op e3 e3) e3) e3) e3)) (= (op (op (op e3 e4) e4) e4) e3)) (= (op (op (op e3 e5) e5) e5) e3)) (= (op (op (op e3 e6) e6) e6) e3))) (and (and (and (and (and (and (= (op (op (op e4 e0) e0) e0) e4) (= (op (op (op e4 e1) e1) e1) e4)) (= (op (op (op e4 e2) e2) e2) e4)) (= (op (op (op e4 e3) e3) e3) e4)) (= (op (op (op e4 e4) e4) e4) e4)) (= (op (op (op e4 e5) e5) e5) e4)) (= (op (op (op e4 e6) e6) e6) e4))) (and (and (and (and (and (and (= (op (op (op e5 e0) e0) e0) e5) (= (op (op (op e5 e1) e1) e1) e5)) (= (op (op (op e5 e2) e2) e2) e5)) (= (op (op (op e5 e3) e3) e3) e5)) (= (op (op (op e5 e4) e4) e4) e5)) (= (op (op (op e5 e5) e5) e5) e5)) (= (op (op (op e5 e6) e6) e6) e5))) (and (and (and (and (and (and (= (op (op (op e6 e0) e0) e0) e6) (= (op (op (op e6 e1) e1) e1) e6)) (= (op (op (op e6 e2) e2) e2) e6)) (= (op (op (op e6 e3) e3) e3) e6)) (= (op (op (op e6 e4) e4) e4) e6)) (= (op (op (op e6 e5) e5) e5) e6)) (= (op (op (op e6 e6) e6) e6) e6))) :named XFXyjtTmNk)) (assert(! (and (and (and (and (and (and (not (= (op e0 e0) e0)) (not (= (op e1 e1) e1))) (not (= (op e2 e2) e2))) (not (= (op e3 e3) e3))) (not (= (op e4 e4) e4))) (not (= (op e5 e5) e5))) (not (= (op e6 e6) e6))) :named ArZkcpQDMGMHRGo)) (assert(! (let ((?v_0 (skc1 e0)) (?v_1 (skc1 e1)) (?v_2 (skc1 e2)) (?v_3 (skc1 e3)) (?v_4 (skc1 e4)) (?v_5 (skc1 e5)) (?v_6 (skc1 e6))) (and (and (and (and (and (and (and (= (op e0 ?v_0) ?v_0) (= (op e1 ?v_1) ?v_1)) (= (op e2 ?v_2) ?v_2)) (= (op e3 ?v_3) ?v_3)) (= (op e4 ?v_4) ?v_4)) (= (op e5 ?v_5) ?v_5)) (= (op e6 ?v_6) ?v_6)) (and (and (and (and (and (and (or (or (or (or (or (or (= ?v_0 e0) (= ?v_0 e1)) (= ?v_0 e2)) (= ?v_0 e3)) (= ?v_0 e4)) (= ?v_0 e5)) (= ?v_0 e6)) (or (or (or (or (or (or (= ?v_1 e0) (= ?v_1 e1)) (= ?v_1 e2)) (= ?v_1 e3)) (= ?v_1 e4)) (= ?v_1 e5)) (= ?v_1 e6))) (or (or (or (or (or (or (= ?v_2 e0) (= ?v_2 e1)) (= ?v_2 e2)) (= ?v_2 e3)) (= ?v_2 e4)) (= ?v_2 e5)) (= ?v_2 e6))) (or (or (or (or (or (or (= ?v_3 e0) (= ?v_3 e1)) (= ?v_3 e2)) (= ?v_3 e3)) (= ?v_3 e4)) (= ?v_3 e5)) (= ?v_3 e6))) (or (or (or (or (or (or (= ?v_4 e0) (= ?v_4 e1)) (= ?v_4 e2)) (= ?v_4 e3)) (= ?v_4 e4)) (= ?v_4 e5)) (= ?v_4 e6))) (or (or (or (or (or (or (= ?v_5 e0) (= ?v_5 e1)) (= ?v_5 e2)) (= ?v_5 e3)) (= ?v_5 e4)) (= ?v_5 e5)) (= ?v_5 e6))) (or (or (or (or (or (or (= ?v_6 e0) (= ?v_6 e1)) (= ?v_6 e2)) (= ?v_6 e3)) (= ?v_6 e4)) (= ?v_6 e5)) (= ?v_6 e6))))) :named GrgZIoxhpyhmgsorI)) (assert(! (let ((?v_2 (op e0 e1)) (?v_5 (op e0 e2)) (?v_10 (op e0 e3)) (?v_17 (op e0 e4)) (?v_26 (op e0 e5)) (?v_37 (op e0 e6)) (?v_1 (op e1 e0)) (?v_7 (op e1 e2)) (?v_12 (op e1 e3)) (?v_19 (op e1 e4)) (?v_28 (op e1 e5)) (?v_39 (op e1 e6)) (?v_4 (op e2 e0)) (?v_6 (op e2 e1)) (?v_14 (op e2 e3)) (?v_21 (op e2 e4)) (?v_30 (op e2 e5)) (?v_41 (op e2 e6)) (?v_9 (op e3 e0)) (?v_11 (op e3 e1)) (?v_13 (op e3 e2)) (?v_23 (op e3 e4)) (?v_32 (op e3 e5)) (?v_43 (op e3 e6)) (?v_16 (op e4 e0)) (?v_18 (op e4 e1)) (?v_20 (op e4 e2)) (?v_22 (op e4 e3)) (?v_34 (op e4 e5)) (?v_45 (op e4 e6)) (?v_25 (op e5 e0)) (?v_27 (op e5 e1)) (?v_29 (op e5 e2)) (?v_31 (op e5 e3)) (?v_33 (op e5 e4)) (?v_47 (op e5 e6)) (?v_36 (op e6 e0)) (?v_38 (op e6 e1)) (?v_40 (op e6 e2)) (?v_42 (op e6 e3)) (?v_44 (op e6 e4)) (?v_46 (op e6 e5)) (?v_0 (not (= (op e0 e0) e0))) (?v_3 (not (= (op e1 e1) e1))) (?v_8 (not (= (op e2 e2) e2))) (?v_15 (not (= (op e3 e3) e3))) (?v_24 (not (= (op e4 e4) e4))) (?v_35 (not (= (op e5 e5) e5))) (?v_48 (not (= (op e6 e6) e6)))) (and (and (and (and (and (and (and (and (and (and (and (and (or ?v_0 ?v_0) (or (not (= ?v_2 e0)) (not (= ?v_1 e0)))) (or (not (= ?v_5 e0)) (not (= ?v_4 e0)))) (or (not (= ?v_10 e0)) (not (= ?v_9 e0)))) (or (not (= ?v_17 e0)) (not (= ?v_16 e0)))) (or (not (= ?v_26 e0)) (not (= ?v_25 e0)))) (or (not (= ?v_37 e0)) (not (= ?v_36 e0)))) (and (and (and (and (and (and (or (not (= ?v_1 e1)) (not (= ?v_2 e1))) (or ?v_3 ?v_3)) (or (not (= ?v_7 e1)) (not (= ?v_6 e1)))) (or (not (= ?v_12 e1)) (not (= ?v_11 e1)))) (or (not (= ?v_19 e1)) (not (= ?v_18 e1)))) (or (not (= ?v_28 e1)) (not (= ?v_27 e1)))) (or (not (= ?v_39 e1)) (not (= ?v_38 e1))))) (and (and (and (and (and (and (or (not (= ?v_4 e2)) (not (= ?v_5 e2))) (or (not (= ?v_6 e2)) (not (= ?v_7 e2)))) (or ?v_8 ?v_8)) (or (not (= ?v_14 e2)) (not (= ?v_13 e2)))) (or (not (= ?v_21 e2)) (not (= ?v_20 e2)))) (or (not (= ?v_30 e2)) (not (= ?v_29 e2)))) (or (not (= ?v_41 e2)) (not (= ?v_40 e2))))) (and (and (and (and (and (and (or (not (= ?v_9 e3)) (not (= ?v_10 e3))) (or (not (= ?v_11 e3)) (not (= ?v_12 e3)))) (or (not (= ?v_13 e3)) (not (= ?v_14 e3)))) (or ?v_15 ?v_15)) (or (not (= ?v_23 e3)) (not (= ?v_22 e3)))) (or (not (= ?v_32 e3)) (not (= ?v_31 e3)))) (or (not (= ?v_43 e3)) (not (= ?v_42 e3))))) (and (and (and (and (and (and (or (not (= ?v_16 e4)) (not (= ?v_17 e4))) (or (not (= ?v_18 e4)) (not (= ?v_19 e4)))) (or (not (= ?v_20 e4)) (not (= ?v_21 e4)))) (or (not (= ?v_22 e4)) (not (= ?v_23 e4)))) (or ?v_24 ?v_24)) (or (not (= ?v_34 e4)) (not (= ?v_33 e4)))) (or (not (= ?v_45 e4)) (not (= ?v_44 e4))))) (and (and (and (and (and (and (or (not (= ?v_25 e5)) (not (= ?v_26 e5))) (or (not (= ?v_27 e5)) (not (= ?v_28 e5)))) (or (not (= ?v_29 e5)) (not (= ?v_30 e5)))) (or (not (= ?v_31 e5)) (not (= ?v_32 e5)))) (or (not (= ?v_33 e5)) (not (= ?v_34 e5)))) (or ?v_35 ?v_35)) (or (not (= ?v_47 e5)) (not (= ?v_46 e5))))) (and (and (and (and (and (and (or (not (= ?v_36 e6)) (not (= ?v_37 e6))) (or (not (= ?v_38 e6)) (not (= ?v_39 e6)))) (or (not (= ?v_40 e6)) (not (= ?v_41 e6)))) (or (not (= ?v_42 e6)) (not (= ?v_43 e6)))) (or (not (= ?v_44 e6)) (not (= ?v_45 e6)))) (or (not (= ?v_46 e6)) (not (= ?v_47 e6)))) (or ?v_48 ?v_48)))) :named tXLRFdgSNIDfMWBiMh)) (assert(! (let ((?v_0 (op e0 e0)) (?v_7 (op e0 e1)) (?v_14 (op e0 e2)) (?v_21 (op e0 e3)) (?v_28 (op e0 e4)) (?v_35 (op e0 e5)) (?v_42 (op e0 e6)) (?v_1 (op e1 e0)) (?v_8 (op e1 e1)) (?v_15 (op e1 e2)) (?v_22 (op e1 e3)) (?v_29 (op e1 e4)) (?v_36 (op e1 e5)) (?v_43 (op e1 e6)) (?v_2 (op e2 e0)) (?v_9 (op e2 e1)) (?v_16 (op e2 e2)) (?v_23 (op e2 e3)) (?v_30 (op e2 e4)) (?v_37 (op e2 e5)) (?v_44 (op e2 e6)) (?v_3 (op e3 e0)) (?v_10 (op e3 e1)) (?v_17 (op e3 e2)) (?v_24 (op e3 e3)) (?v_31 (op e3 e4)) (?v_38 (op e3 e5)) (?v_45 (op e3 e6)) (?v_4 (op e4 e0)) (?v_11 (op e4 e1)) (?v_18 (op e4 e2)) (?v_25 (op e4 e3)) (?v_32 (op e4 e4)) (?v_39 (op e4 e5)) (?v_46 (op e4 e6)) (?v_5 (op e5 e0)) (?v_12 (op e5 e1)) (?v_19 (op e5 e2)) (?v_26 (op e5 e3)) (?v_33 (op e5 e4)) (?v_40 (op e5 e5)) (?v_47 (op e5 e6)) (?v_6 (op e6 e0)) (?v_13 (op e6 e1)) (?v_20 (op e6 e2)) (?v_27 (op e6 e3)) (?v_34 (op e6 e4)) (?v_41 (op e6 e5)) (?v_48 (op e6 e6))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_1)) (not (= ?v_0 ?v_2))) (not (= ?v_0 ?v_3))) (not (= ?v_0 ?v_4))) (not (= ?v_0 ?v_5))) (not (= ?v_0 ?v_6))) (not (= ?v_1 ?v_2))) (not (= ?v_1 ?v_3))) (not (= ?v_1 ?v_4))) (not (= ?v_1 ?v_5))) (not (= ?v_1 ?v_6))) (not (= ?v_2 ?v_3))) (not (= ?v_2 ?v_4))) (not (= ?v_2 ?v_5))) (not (= ?v_2 ?v_6))) (not (= ?v_3 ?v_4))) (not (= ?v_3 ?v_5))) (not (= ?v_3 ?v_6))) (not (= ?v_4 ?v_5))) (not (= ?v_4 ?v_6))) (not (= ?v_5 ?v_6))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_7 ?v_8)) (not (= ?v_7 ?v_9))) (not (= ?v_7 ?v_10))) (not (= ?v_7 ?v_11))) (not (= ?v_7 ?v_12))) (not (= ?v_7 ?v_13))) (not (= ?v_8 ?v_9))) (not (= ?v_8 ?v_10))) (not (= ?v_8 ?v_11))) (not (= ?v_8 ?v_12))) (not (= ?v_8 ?v_13))) (not (= ?v_9 ?v_10))) (not (= ?v_9 ?v_11))) (not (= ?v_9 ?v_12))) (not (= ?v_9 ?v_13))) (not (= ?v_10 ?v_11))) (not (= ?v_10 ?v_12))) (not (= ?v_10 ?v_13))) (not (= ?v_11 ?v_12))) (not (= ?v_11 ?v_13))) (not (= ?v_12 ?v_13)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_14 ?v_15)) (not (= ?v_14 ?v_16))) (not (= ?v_14 ?v_17))) (not (= ?v_14 ?v_18))) (not (= ?v_14 ?v_19))) (not (= ?v_14 ?v_20))) (not (= ?v_15 ?v_16))) (not (= ?v_15 ?v_17))) (not (= ?v_15 ?v_18))) (not (= ?v_15 ?v_19))) (not (= ?v_15 ?v_20))) (not (= ?v_16 ?v_17))) (not (= ?v_16 ?v_18))) (not (= ?v_16 ?v_19))) (not (= ?v_16 ?v_20))) (not (= ?v_17 ?v_18))) (not (= ?v_17 ?v_19))) (not (= ?v_17 ?v_20))) (not (= ?v_18 ?v_19))) (not (= ?v_18 ?v_20))) (not (= ?v_19 ?v_20)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_21 ?v_22)) (not (= ?v_21 ?v_23))) (not (= ?v_21 ?v_24))) (not (= ?v_21 ?v_25))) (not (= ?v_21 ?v_26))) (not (= ?v_21 ?v_27))) (not (= ?v_22 ?v_23))) (not (= ?v_22 ?v_24))) (not (= ?v_22 ?v_25))) (not (= ?v_22 ?v_26))) (not (= ?v_22 ?v_27))) (not (= ?v_23 ?v_24))) (not (= ?v_23 ?v_25))) (not (= ?v_23 ?v_26))) (not (= ?v_23 ?v_27))) (not (= ?v_24 ?v_25))) (not (= ?v_24 ?v_26))) (not (= ?v_24 ?v_27))) (not (= ?v_25 ?v_26))) (not (= ?v_25 ?v_27))) (not (= ?v_26 ?v_27)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_28 ?v_29)) (not (= ?v_28 ?v_30))) (not (= ?v_28 ?v_31))) (not (= ?v_28 ?v_32))) (not (= ?v_28 ?v_33))) (not (= ?v_28 ?v_34))) (not (= ?v_29 ?v_30))) (not (= ?v_29 ?v_31))) (not (= ?v_29 ?v_32))) (not (= ?v_29 ?v_33))) (not (= ?v_29 ?v_34))) (not (= ?v_30 ?v_31))) (not (= ?v_30 ?v_32))) (not (= ?v_30 ?v_33))) (not (= ?v_30 ?v_34))) (not (= ?v_31 ?v_32))) (not (= ?v_31 ?v_33))) (not (= ?v_31 ?v_34))) (not (= ?v_32 ?v_33))) (not (= ?v_32 ?v_34))) (not (= ?v_33 ?v_34)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_35 ?v_36)) (not (= ?v_35 ?v_37))) (not (= ?v_35 ?v_38))) (not (= ?v_35 ?v_39))) (not (= ?v_35 ?v_40))) (not (= ?v_35 ?v_41))) (not (= ?v_36 ?v_37))) (not (= ?v_36 ?v_38))) (not (= ?v_36 ?v_39))) (not (= ?v_36 ?v_40))) (not (= ?v_36 ?v_41))) (not (= ?v_37 ?v_38))) (not (= ?v_37 ?v_39))) (not (= ?v_37 ?v_40))) (not (= ?v_37 ?v_41))) (not (= ?v_38 ?v_39))) (not (= ?v_38 ?v_40))) (not (= ?v_38 ?v_41))) (not (= ?v_39 ?v_40))) (not (= ?v_39 ?v_41))) (not (= ?v_40 ?v_41)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_42 ?v_43)) (not (= ?v_42 ?v_44))) (not (= ?v_42 ?v_45))) (not (= ?v_42 ?v_46))) (not (= ?v_42 ?v_47))) (not (= ?v_42 ?v_48))) (not (= ?v_43 ?v_44))) (not (= ?v_43 ?v_45))) (not (= ?v_43 ?v_46))) (not (= ?v_43 ?v_47))) (not (= ?v_43 ?v_48))) (not (= ?v_44 ?v_45))) (not (= ?v_44 ?v_46))) (not (= ?v_44 ?v_47))) (not (= ?v_44 ?v_48))) (not (= ?v_45 ?v_46))) (not (= ?v_45 ?v_47))) (not (= ?v_45 ?v_48))) (not (= ?v_46 ?v_47))) (not (= ?v_46 ?v_48))) (not (= ?v_47 ?v_48)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_7)) (not (= ?v_0 ?v_14))) (not (= ?v_0 ?v_21))) (not (= ?v_0 ?v_28))) (not (= ?v_0 ?v_35))) (not (= ?v_0 ?v_42))) (not (= ?v_7 ?v_14))) (not (= ?v_7 ?v_21))) (not (= ?v_7 ?v_28))) (not (= ?v_7 ?v_35))) (not (= ?v_7 ?v_42))) (not (= ?v_14 ?v_21))) (not (= ?v_14 ?v_28))) (not (= ?v_14 ?v_35))) (not (= ?v_14 ?v_42))) (not (= ?v_21 ?v_28))) (not (= ?v_21 ?v_35))) (not (= ?v_21 ?v_42))) (not (= ?v_28 ?v_35))) (not (= ?v_28 ?v_42))) (not (= ?v_35 ?v_42))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_1 ?v_8)) (not (= ?v_1 ?v_15))) (not (= ?v_1 ?v_22))) (not (= ?v_1 ?v_29))) (not (= ?v_1 ?v_36))) (not (= ?v_1 ?v_43))) (not (= ?v_8 ?v_15))) (not (= ?v_8 ?v_22))) (not (= ?v_8 ?v_29))) (not (= ?v_8 ?v_36))) (not (= ?v_8 ?v_43))) (not (= ?v_15 ?v_22))) (not (= ?v_15 ?v_29))) (not (= ?v_15 ?v_36))) (not (= ?v_15 ?v_43))) (not (= ?v_22 ?v_29))) (not (= ?v_22 ?v_36))) (not (= ?v_22 ?v_43))) (not (= ?v_29 ?v_36))) (not (= ?v_29 ?v_43))) (not (= ?v_36 ?v_43)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_2 ?v_9)) (not (= ?v_2 ?v_16))) (not (= ?v_2 ?v_23))) (not (= ?v_2 ?v_30))) (not (= ?v_2 ?v_37))) (not (= ?v_2 ?v_44))) (not (= ?v_9 ?v_16))) (not (= ?v_9 ?v_23))) (not (= ?v_9 ?v_30))) (not (= ?v_9 ?v_37))) (not (= ?v_9 ?v_44))) (not (= ?v_16 ?v_23))) (not (= ?v_16 ?v_30))) (not (= ?v_16 ?v_37))) (not (= ?v_16 ?v_44))) (not (= ?v_23 ?v_30))) (not (= ?v_23 ?v_37))) (not (= ?v_23 ?v_44))) (not (= ?v_30 ?v_37))) (not (= ?v_30 ?v_44))) (not (= ?v_37 ?v_44)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_3 ?v_10)) (not (= ?v_3 ?v_17))) (not (= ?v_3 ?v_24))) (not (= ?v_3 ?v_31))) (not (= ?v_3 ?v_38))) (not (= ?v_3 ?v_45))) (not (= ?v_10 ?v_17))) (not (= ?v_10 ?v_24))) (not (= ?v_10 ?v_31))) (not (= ?v_10 ?v_38))) (not (= ?v_10 ?v_45))) (not (= ?v_17 ?v_24))) (not (= ?v_17 ?v_31))) (not (= ?v_17 ?v_38))) (not (= ?v_17 ?v_45))) (not (= ?v_24 ?v_31))) (not (= ?v_24 ?v_38))) (not (= ?v_24 ?v_45))) (not (= ?v_31 ?v_38))) (not (= ?v_31 ?v_45))) (not (= ?v_38 ?v_45)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_4 ?v_11)) (not (= ?v_4 ?v_18))) (not (= ?v_4 ?v_25))) (not (= ?v_4 ?v_32))) (not (= ?v_4 ?v_39))) (not (= ?v_4 ?v_46))) (not (= ?v_11 ?v_18))) (not (= ?v_11 ?v_25))) (not (= ?v_11 ?v_32))) (not (= ?v_11 ?v_39))) (not (= ?v_11 ?v_46))) (not (= ?v_18 ?v_25))) (not (= ?v_18 ?v_32))) (not (= ?v_18 ?v_39))) (not (= ?v_18 ?v_46))) (not (= ?v_25 ?v_32))) (not (= ?v_25 ?v_39))) (not (= ?v_25 ?v_46))) (not (= ?v_32 ?v_39))) (not (= ?v_32 ?v_46))) (not (= ?v_39 ?v_46)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_5 ?v_12)) (not (= ?v_5 ?v_19))) (not (= ?v_5 ?v_26))) (not (= ?v_5 ?v_33))) (not (= ?v_5 ?v_40))) (not (= ?v_5 ?v_47))) (not (= ?v_12 ?v_19))) (not (= ?v_12 ?v_26))) (not (= ?v_12 ?v_33))) (not (= ?v_12 ?v_40))) (not (= ?v_12 ?v_47))) (not (= ?v_19 ?v_26))) (not (= ?v_19 ?v_33))) (not (= ?v_19 ?v_40))) (not (= ?v_19 ?v_47))) (not (= ?v_26 ?v_33))) (not (= ?v_26 ?v_40))) (not (= ?v_26 ?v_47))) (not (= ?v_33 ?v_40))) (not (= ?v_33 ?v_47))) (not (= ?v_40 ?v_47)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_6 ?v_13)) (not (= ?v_6 ?v_20))) (not (= ?v_6 ?v_27))) (not (= ?v_6 ?v_34))) (not (= ?v_6 ?v_41))) (not (= ?v_6 ?v_48))) (not (= ?v_13 ?v_20))) (not (= ?v_13 ?v_27))) (not (= ?v_13 ?v_34))) (not (= ?v_13 ?v_41))) (not (= ?v_13 ?v_48))) (not (= ?v_20 ?v_27))) (not (= ?v_20 ?v_34))) (not (= ?v_20 ?v_41))) (not (= ?v_20 ?v_48))) (not (= ?v_27 ?v_34))) (not (= ?v_27 ?v_41))) (not (= ?v_27 ?v_48))) (not (= ?v_34 ?v_41))) (not (= ?v_34 ?v_48))) (not (= ?v_41 ?v_48)))))) :named jrcYXtZWNHWn)) (assert(! (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= e0 e1)) (not (= e0 e2))) (not (= e0 e3))) (not (= e0 e4))) (not (= e0 e5))) (not (= e0 e6))) (not (= e1 e2))) (not (= e1 e3))) (not (= e1 e4))) (not (= e1 e5))) (not (= e1 e6))) (not (= e2 e3))) (not (= e2 e4))) (not (= e2 e5))) (not (= e2 e6))) (not (= e3 e4))) (not (= e3 e5))) (not (= e3 e6))) (not (= e4 e5))) (not (= e4 e6))) (not (= e5 e6))) :named CXYdZVsdvgDTTwXCVLY)) (assert(! (and (and (and (and (and (= e1 (op e0 e6)) (= e2 (op e0 e0))) (= e3 (op e2 e6))) (= e4 (op e2 e0))) (= e5 (op e0 e1))) (= e6 (op e2 e4))) :named vIKjLfKqbVFbSpdqLQ)) (assert(! (not (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= (op e0 e0) e2) (= (op e0 e1) e5)) (= (op e0 e2) e3)) (= (op e0 e3) e6)) (= (op e0 e4) e4)) (= (op e0 e5) e0)) (= (op e0 e6) e1)) (= (op e1 e0) e5)) (= (op e1 e1) e0)) (= (op e1 e2) e1)) (= (op e1 e3) e4)) (= (op e1 e4) e2)) (= (op e1 e5) e3)) (= (op e1 e6) e6)) (= (op e2 e0) e4)) (= (op e2 e1) e2)) (= (op e2 e2) e0)) (= (op e2 e3) e1)) (= (op e2 e4) e6)) (= (op e2 e5) e5)) (= (op e2 e6) e3)) (= (op e3 e0) e1)) (= (op e3 e1) e6)) (= (op e3 e2) e2)) (= (op e3 e3) e0)) (= (op e3 e4) e3)) (= (op e3 e5) e4)) (= (op e3 e6) e5)) (= (op e4 e0) e0)) (= (op e4 e1) e3)) (= (op e4 e2) e6)) (= (op e4 e3) e2)) (= (op e4 e4) e5)) (= (op e4 e5) e1)) (= (op e4 e6) e4)) (= (op e5 e0) e3)) (= (op e5 e1) e1)) (= (op e5 e2) e4)) (= (op e5 e3) e5)) (= (op e5 e4) e0)) (= (op e5 e5) e6)) (= (op e5 e6) e2)) (= (op e6 e0) e6)) (= (op e6 e1) e4)) (= (op e6 e2) e5)) (= (op e6 e3) e3)) (= (op e6 e4) e1)) (= (op e6 e5) e2)) (= (op e6 e6) e0))) :named uwdonyGDksUV)) (check-sat) opensmt-2.5.2/regression/picky/iso_brn_sk005_eufexps.smt2.expected.err000066400000000000000000000000001445011647600260140ustar00rootroot00000000000000opensmt-2.5.2/regression/picky/iso_brn_sk005_eufexps.smt2.expected.out000066400000000000000000000000061445011647600260410ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/run-test-notiming.sh000077500000000000000000000034421445011647600213420ustar00rootroot00000000000000#!/bin/bash get_abs_filename() { echo "$(cd "$(dirname "$1")" && pwd)/$(basename "$1")" } usage="Usage: $0 [-h] " while [ $# -gt 0 ]; do case $1 in -h|--help) echo "${usage}" exit 1 ;; -*) echo "Error: invalid option '$1'" exit 1 ;; *) break esac shift; shift done opensmt=$1 if [ -z ${opensmt} ]; then echo "Opensmt binary not specified" exit 1 fi echo "This is the script for running regression tests" echo " - date: $(date '+%Y-%m-%d at %H:%M.%S')" echo " - host name $(hostname -f)" echo " - script path: $(get_abs_filename $0)" tmpfolder=log-$(date '+%Y-%m-%d-%H-%M-%S') mkdir ${tmpfolder} export outmod=false export errmod=false export rtmod=false tolerance=1.5 for file in $(find . -name '*.smt2' |sort) generic/foo; do name=$(basename $file) dir=$(dirname $file) sh -c "ulimit -St 60; ${opensmt} $(echo ${options}) $dir/$name > $tmpfolder/$name.out 2>$tmpfolder/$name.err.tmp" 2>/dev/null grep -v '^;' $tmpfolder/$name.err.tmp > $tmpfolder/$name.err diff -q ${tmpfolder}/${name}.out ${dir}/${name}.expected.out if [ $? != 0 ]; then echo "stdout differs for benchmark $file"; outmod=true; diff ${tmpfolder}/${name}.out ${dir}/${name}.expected.out fi diff -q ${tmpfolder}/${name}.err ${dir}/${name}.expected.err if [ $? != 0 ]; then echo "stderr differs for benchmark $file"; errmod=true; diff ${tmpfolder}/${name}.err ${dir}/${name}.expected.err fi done echo "Stdout differs: ${outmod}, stderr differs: ${errmod}" if [[ ${outmod} == true || ${errmod} == true ]]; then echo "There were anomalies: check logs in ${tmpfolder}" exit 1 else rm -rf ${tmpfolder} fi opensmt-2.5.2/regression/run-test.sh000077500000000000000000000076341445011647600175270ustar00rootroot00000000000000#!/bin/bash echo "This is the script for running regression tests" echo " - date: $(date '+%Y-%m-%d at %H:%M.%S')" echo " - host name $(hostname -f)" echo " - script path: $(readlink -f $0)" opensmt=../opensmt tmpfolder=log-$(date '+%Y-%m-%d-%H-%M-%S') mkdir ${tmpfolder} export outmod=false export errmod=false export rtmod=false tolerance=1.5 for file in $(find . -name '*.smt2' |sort) generic/foo state-dump/bar-00.smt2 state-dump/bar-01.smt2; do name=$(basename $file) dir=$(dirname $file) /usr/bin/time -p -o $tmpfolder/$name.time ${opensmt} $dir/$name > $tmpfolder/$name.out 2>$tmpfolder/$name.err.tmp #/usr/bin/time -p -o $tmpfolder/$name.time valgrind --leak-check=full ${opensmt} $dir/$name #continue grep -v '^;' $tmpfolder/$name.err.tmp > $tmpfolder/$name.err diff -q ${tmpfolder}/${name}.out ${dir}/${name}.expected.out if [ $? != 0 ]; then echo "stdout differs for benchmark $file"; outmod=true; fi diff -q ${tmpfolder}/${name}.err ${dir}/${name}.expected.err if [ $? != 0 ]; then echo "stderr differs for benchmark $file"; errmod=true; fi wtime_ref=$(grep "^real" ${dir}/${name}.expected.time |awk '{print $2}') utime_ref=$(grep "^user" ${dir}/${name}.expected.time | awk '{print $2}') stime_ref=$(grep "^sys" ${dir}/${name}.expected.time | awk '{print $2}') wtime=$(grep "^real" ${tmpfolder}/${name}.time |awk '{print $2}') utime=$(grep "^user" ${tmpfolder}/${name}.time | awk '{print $2}') stime=$(grep "^sys" ${tmpfolder}/${name}.time | awk '{print $2}') if [[ $(echo "${wtime_ref} > 1" |bc -l) -eq 1 ]]; then if [[ $(echo "${wtime_ref} * ${tolerance} < ${wtime}" | bc -l) -eq 1 ]]; then rtmod=true; echo "wall time too high for benchmark $file"; fi if [[ $(echo "${wtime} * ${tolerance} < ${wtime_ref}" | bc -l) -eq 1 ]]; then rtmod=true; echo "wall time too low for benchmark $file"; fi fi if [[ $(echo "${utime_ref} > 1" |bc -l) -eq 1 ]]; then if [[ $(echo "${utime_ref} * ${tolerance} < ${utime}" | bc -l) -eq 1 ]]; then rtmod=true; echo "user time too high for benchmark $file"; fi if [[ $(echo "${utime} * ${tolerance} < ${utime_ref}" | bc -l) -eq 1 ]]; then rtmod=true; echo "user time too low for benchmark $file"; fi fi if [[ $(echo "${stime_ref} > 1" |bc -l) -eq 1 ]]; then if [[ $(echo "${stime_ref} * ${tolerance} < ${stime}" | bc -l) -eq 1 ]]; then rtmod=true; echo "sys time too high for benchmark $file"; fi if [[ $(echo "${stime} * ${tolerance} < ${stime_ref}" | bc -l) -eq 1 ]]; then rtmod=true; echo "sys time too low for benchmark $file"; fi fi done echo "Stdout differs: ${outmod}, stderr differs: ${errmod}, run time differs: ${rtmod}" if [[ ${outmod} == true || ${errmod} == true || ${rtmod} == true ]]; then echo "There were anomalies: check logs in ${tmpfolder}" exit 1 else rm -rf ${tmpfolder} fi if [ -z "${OSMT_INSTALLDIR}" ]; then echo "Skipping the check for compilation against the library. " echo "Please set OSMT_INSTALLDIR." else echo "Testing linkage against the libraries" cd linkage; g++ -std=c++11 -o test test.cc -lopensmt2 -lgmp -lgmpxx -lz \ -lreadline -L${OSMT_INSTALLDIR}/lib \ -I${OSMT_INSTALLDIR}/include > /dev/null 2>&1 \ || echo "Failed to link test.cc" LD_LIBRARY_PATH=${OSMT_INSTALLDIR}/lib ./test 2>&1 |grep '^unsat' >/dev/null || echo "Failed to run ./test" gcc -o test_c test_c.c -lopensmt2c -lgmp -lgmpxx -lz -lreadline \ -L${OSMT_INSTALLDIR}/lib \ -I${OSMT_INSTALLDIR}/include > /dev/null 2>&1 \ || echo "Failed to link test_c.c" LD_LIBRARY_PATH=${OSMT_INSTALLDIR}/lib ./test_c 2>&1 |grep '^unsat' >/dev/null || echo "Failed to run ./test" fi opensmt-2.5.2/regression/state-dump/000077500000000000000000000000001445011647600174605ustar00rootroot00000000000000opensmt-2.5.2/regression/state-dump/NEQ004_size4_splitstate_0.smt2.expected.err000066400000000000000000000000001445011647600273240ustar00rootroot00000000000000opensmt-2.5.2/regression/state-dump/NEQ004_size4_splitstate_0.smt2.expected.out000066400000000000000000000000101445011647600273440ustar00rootroot00000000000000unknown opensmt-2.5.2/regression/state-dump/NEQ004_size4_splitstate_0.smt2.expected.time000066400000000000000000000000351445011647600275020ustar00rootroot00000000000000real 1.07 user 1.03 sys 0.03 opensmt-2.5.2/regression/state-dump/NEQ004_size4_splitstate_1.smt2.expected.err000066400000000000000000000000001445011647600273250ustar00rootroot00000000000000opensmt-2.5.2/regression/state-dump/NEQ004_size4_splitstate_1.smt2.expected.out000066400000000000000000000000061445011647600273520ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/state-dump/NEQ004_size4_splitstate_1.smt2.expected.time000066400000000000000000000000351445011647600275030ustar00rootroot00000000000000real 0.70 user 0.69 sys 0.01 opensmt-2.5.2/regression/state-dump/NEQ004_size4_splitstate_2.smt2.expected.err000066400000000000000000000000001445011647600273260ustar00rootroot00000000000000opensmt-2.5.2/regression/state-dump/NEQ004_size4_splitstate_2.smt2.expected.out000066400000000000000000000000061445011647600273530ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/state-dump/NEQ004_size4_splitstate_2.smt2.expected.time000066400000000000000000000000351445011647600275040ustar00rootroot00000000000000real 1.88 user 1.86 sys 0.02 opensmt-2.5.2/regression/state-dump/NEQ004_size4_writestate.osmt2000066400000000000000000000301121445011647600247030ustar00rootroot00000000000000xœíy”Õýö‹ÙDApPƒ®ž­Q@ÅL0 ÑÑ1(ÄQq"q%Á ¨¸**nD@%Š» ŠÄ`D ÊpW‚ ¾ß§ê¹ô—æá¼¾ç=ç×ç<Ó=ÝŸzîR·n}»ëÞ[‡?EM£(êU/Šª÷¢CE_šžïEËM•ö>`ºÙŸ£LCL{âSÓ ¦ÓhÓ_M×™¦›f›š›V™Öš>1}cúÙÔÚ¼Û›ö7lª2alnºÄti–ii©iiòT?ŠÚ˜º˜r¦þ¦jSÍ.Q4Êž/5M4M5ÝfºÇ4״дشÜô¦éÓ§¦oM[MMDÑ.¦RSwS_ÓÓS©ÖTggšlšfºÝt¿éÆfQÔ¯y=m¯W˜†Ùëuö<Þž¿·çYöܬa=gÏì¹Ôôž½îkÏ?Úó{Þ«…¥aÏ•ö<Ξ¯7 ¶×÷Úó…öü¤=_gÏ+ìyž=¯³çoM¯Ú릢è3{î`Ï»´4{>Äžs¦“L›LϵŽ¢Úûï™&µ±}nÏ GÑöº­=w5=n¯³çL+ìu=_dZo¯¯²ç馟ìõ\{^djSEoØóS7{ýƒ=·lE½íu±=gMCìõQö<Ô4Ò^×ÚóXÓD{}½=Ï6Í´× íy™i½~ßž¿Âÿöº¡µ½v¦uöúÖ=¢h¾i©é}Ów¦m£h?SwÓ ÓpÓXÓM¦‡LKL6íÒÎòeª4 0 3]jºÁô i‘iµé SckðMe¦ãL5¦1¦©¦ûLÏšV™6šìeíÚ”1mª6Õ™¦˜î1=ezÝô‰éÓϦ&íÍßt€)c:Ô4ÈtŠi˜i¤i‚éZÓ­¦»MO˜^0½jzË´É´ÙToï(jnêl:ÐTnêelª60]hšdºÁ4ÓtŸéÓRÓJÓ;¦¯L?šuˆ¢]M¿2bÊ™ú˜†šÎ4kú“iŠéfÓ,ÓÓ"Ó2Ó*ÓZÓw¦_L»t´¶bêjÊšz˜ú™N5mºÀt‰é:ÓtÓlÓ<Ó‹¦×Lo›>4m15èdmÌÔÎTbª4õ6g:ÃtŽé"ÓXÓ¦;L˜5ïgÛ[WÒÈþÔkïçìÐHú·}ÙÇ•±ŸëǾn(û»Zöy—‹~ožëû–ï¤ÿkRoç}`öƒÕì G±?œÀ>ñö‹sØ7>Ëþq%ûÈØOnf_ÙŒýeGö™¥ì7û°ï<‰ýçˆúÿïûÏG¤}ç‹ì?W7HûÏ Òþ3j˜öŸE Óþóö¡Ý¦}耆iZÓ0íCë¦}è$ö£3¦ýèü†i?º¤aÚ®n˜ö£Ÿ±/ÝÚ0íKwo”ö¥]¥}iwSSÓ`Ói¦³Mç›Æ˜®4]mšfšiº×4ϴд¨QÚï¾Á¾wC£´ïýýoËÆiÿ[Ì>8Û8íƒb?<´qÚײ/Û8틯g<»qÚ/dŸ¼¬qÚ'¿Ï~ù«Æi¿Ü°IÚ7·k’öÍÝØ?÷h’öÏÙGŸÙ$í£ëØOOj’öÓ3ØWÏk’öÕ‹Ù_¯j’ö׳Ïþ±IÚg·b¿Ý¹iGT˜z2žȘ¢ÆTkª33M6M3ÝnºßôˆéiÓK¦™Ö˜>2}nú¯©¾û[˜ÚšŠMÝLe¦ž¦£M'šNÞ%jM™Æš&™n0Í4ÝgzØô”éEÓk¦·Mš6™6›êÙù½¹iÓ>¦®¦¬©Îû¦A¦SLÃL#McLãMSš¥±Á¦Lšž1-5­4½cZoú´ÅÔÀb–¦v¦Î¦Må¦^ÍÓøbéäæi|1Òtqó4Ƙbº©ygÌ1-hžÆ¯˜^ožÆL_6OãF+´j‘Æû™j‘ƽMǶHãŽjÓðiìq™ib‹4þ˜nº§Eƒ‚±ù8Æç73FŸË8ýEÆêïŠx}7³)âö1"vHÄïÿ1ü"Ž?FÄò—‰xþaÓ¯qý^"¶?^Ä÷Wˆÿ"ÎÿDÄúE¼?HÄüDÜÿ„ˆý7‰ø¿³ø0X|˜$¾ +¼>"·†^eÂk“«û¯ráµ™Ü&zU¯ä¤mßïU ¯fäÀëJxµ©Ÿ¯û¯œðêH® ½º ¯.õóe õu¨ð*%×…^‡ ¯œó eì!¼úËÑ«§ðêïÊòÕKxD®?½^ÕÎ+ä«·ðA®š^G˜~_ÀŒ"ú/p}w©Ûßë+¸‰®Îw¤à¦º2î(ÁÝæòúõ~‚»Çå/pG n®Ë_àŽÜ‚6 îXÁ-vù ç“ã·Üå/pý÷fAûw¼à>(hOàîS—¿p;ApßÏà nkÁ1nàš6Èç/p'šÎ(àvoÏ_h¿\Ç…ýñ[Áuq\¨—Á‚+u\ÈßI‚ëÞ _/!¿\_Ç…ü ÜÇ…ü ÜÇ…ü,¸šùýòwŠàjò÷{ÁÕ9.äïTÁs\Èßi‚›ìÚAÈ_µà¦9.äïtÁÝ3w¿h5¦Ü#íïpÓ™¦ ¸§æÑŽýí‹dÀ"½aQÚV<³B´÷³D¾V‹ö~¶ð['¸áÂo£8.F¿ï÷Gá—|¶?~Î~ÍW+üŠÈ…ã u|®Øæ<± éù*-HÜù"_Ýê÷á×Wp£„ßÇ…ú½Pø ÜháWã¸P¿ ¿ZÁÕ ¿:r>>ÿ“Øãæb±&‘Çý0Fäëú‚ôÀýYäk†ãBý^"üîÜ¥Âo¾ãBý^&üžÜåÂo‰ãBýŽ~+7Nø­&ç¿\!öÃ:ǹRì‡ÏȬã~/òõmAzàþ"òµÕq¡~'?\7.ä& ¿Ýê÷¯Â¯ƒà®~]êw’ð+-àPw“EÝu'‡8ÌÕ‚éCæR2L2ÉLÌ`2SÉ\#˜ÓÈÜFæZÁœMæ2Ss>™¹d®Ì2 É\/˜+É,&sƒ`®&³œÌ4ÁL#ó&™3“Ìdn̽d>%s³`æ‘ù–Ì-‚YHf+™[³ˆLSžïo‹Ò~Ð3ÿ$ãã‹éÂë ràá5#Jû#ϼ'¼f ¯ äÞ£×í"__:¯p.½Cxý@îKzÝ)ò…q…^³„WKràáu—ÈW[çÎ-w ¯brméuÈWWá5[xeÉu¥×½"_‡9¯Ð_Ü'¼Ž"w½îù:Ax= ¼†’;^Š|ÕñqÓáUK®†^ùºHx=$¼Æ’»ˆ^sE¾®r^¡MÌ^ד»Š^óE¾¦ ¯‡…×lrÓéõˆÈ×\çÚÄ£Âk!¹¹ôZ òµHxýCx-#·ˆ^‰|½á¼B›x\x½Oî z-ùÚ ¼ž^_‘Û@¯'E¾~ ããÁ§„ÆSáñ½žùjÙdG¯g„W;ràáõ¬ÈW±ó mâ9áÕ\1½žùÊ ¯E«¹,½‹|å¼B›xAx $w½–ˆ| ^/ ¯3É ¥×K"_µÎ+´‰¥Â«Ž\-½^ù+¼^^“È¥×?E¾®éEù6±LxÍ w=½–‹|Í^¯ ¯yäfÓk…È×BçÚÄkÂk1¹…ôú—È×2áµRx­"·Œ^¯‹|½ï¼B›ø·ðú˜ÜûôzCäë+áµJxýHî+z½)òÕ°iÞ+´‰·„W+ràáµZä«ðz[xu&—ð÷¥×F¶;þÉ„Ø$´Y<Þ‰Òßê=_á.¼¥¿«ûÏ{òsäý½hÇßæâça|g²¢ô7æíŽç³Vø q>YWDéuÞíÎÿäÂmpÿ\-¹0vÜ:ÁÕ‘ cºÁ}(¸q.ÝëÈ}$¸ÉäÂxppë7\+îw»+ÇZrw¿K÷r îra,ú8ò…ÜÓ®^Ú“ûTp/¹rìOî3ÁýË¥{0¹‚[C®šcàÁmÜGä&pl<¸Ï÷9¹93î Áý—Ü(ŽÁ÷¥à0æ8ÖÜW‚kA×qÜׂkKîŽõ÷àŠÉmæXpß ®9\£;‰é~'¸2rÏrN¸ïדÊÐŒ~›w49¤®þ7J¯•xîDrxl‰Òkþó“ù9Òù!ÚñwŒ~Ævn¯ŒDüO<¼~y¾ˆ Æ*ŒbÙ~ÜXrh—’Û*¸Iä°'’ûEp7C½O%‡þ¼›Imò6rõw9\_¿‡\}Á=ìÚî\r ÷”k» É5Ü‹®í.&×Hp¯¹¶»œ\cÁ½Mתß$×Dpº6þ¹¦‚ÛäÚø§ävÜf×Æ¿%×Lp˜€ÚøVrÍל®G‡ßJZnr¸Ö‡ó ¸–‚Û‡®õ %×Jp]ÉáZßåäv\–\w—nkÁõ ‡kxóÈí&¸~äp o9¹Ý7ˆ\+GÁB®Ö¥[$¸aäpm® û°=7’ÜdW/m7†Ü4WŽv‚Oîv¦‹ÇžõÒëZž›ògÚ«ÞŽ1ÏüñXpíEzwC?µ'ýöÜäÐO…بƒà%‡~*ÄF÷ 9ôS!6ê$¸¥äÐO…ØhÁ­$‡~j:¹bÁ½CýTˆ¡: n=9ôS!†ÚWp_C?b¨ý·…ú©Cí/8ÌÓÁýÔ7ä~%¸–äÐO…X«‹àÚ‘C?b­×™ú©kýZp’C?b­®‚+'‡~*ŒÿëV/½Æè¹^äàs`½ÇIöã縶 öp{}P½ÏɃÈášðóö\"òt2xâú2¶Aº‹t‡‘]íÒ=D¤;’Ü:¦[*Ò½˜Ì0¦;’éfDºãÉntéÆ"Ý)ä¾gºY‘îMdÆ3Ý)L·L¤;‹lÔ0Ÿn¹Hw9\‹Fº"Ýdf1Ý9L·R¤ûÙ"—n•H÷•p\0ÝœH÷u2ðÄuëW˜nw‘î{d»»tén ×—é&Òý’Ì{LwÓí!Òý‘ì—nO‘.æÑá1„éöé¶"ó#ÓÅ6H÷p‘î^dk\º½Eºû‘«eºGˆt"O¤»Óí#Ò­$[çÒí+ÒíMîz¦{¤H÷X2ðÄõðÞL÷(‘î`²3\ºýDºÕäîeºG‹t‡“Ìt«™î1"Ý ÉÎwé+Ò½ŒÜ“L÷8‘îD22ݢn‘îud—¸téN'·‚ééÞCæ:¦;éž ÒGvµKw H÷ rß2ÝA"ÝÅdà‰ëìO0ÝEº¯’ÝêÒýH÷-r¸†Žt+Òý€Ì«L÷-¦;X¤ûY\kéž$ÒýŽ\¦û;‘îV2Ÿ1Ýï˜î‘.æ»âÑÅ¥;T¤Û†\)Ó=Y¤Û <‘nØæ”zéxÏÀϯß×Ûñ;ó!üß™Á"_§ÖÛqlEÎqð:­ÞŽã ŽpÌÉäª׿ Mp§‹ø$raN0òv†¨³ÓÉGÕˆ:A¦Û¾3ƒ=S°£Éblè%üþ ö‚Kã‘fñ»$Øa‚ìò€9—’=K°7’Å5Ú5ün ölÁÞIv1þÔO¿§>Ï4 Ù9®l˜O0‘ìÁ>æò€ñïsÉþQ°‹Èâ7ŒýÞJöÁ.wu†¹SÉÖ ö-W6Œu_Hö\Á®syÀ˜ñðýÿ<Ѷ6‘íÉïWh[#EÛÚLcsÁœ/˜drX”~WGÞ.yÛ¥U~߃cVF ¿"²]èw¡ðëØ*¿Á‡1'£…߯ɖÒï"á—i•ß'àØ‘:áwÙîôû“ð;Ò•|t±ðH¶/ëxŒ`†’À4ÿ,Ò¬!ƒö >Œ±¹DøKvý.~udÐöÀ‡12— ¿+ÈÖÐïruü»}>Œ+ün$[K¿qÂïvW^ðaüÒÂï²u¬ã+ó™qLs¼Hó)28ÆÀ‡1A~/‘L¿ Âï5×îÀ‡ñ^…ß²Óè÷Wá÷¡ÛgàÃx­«„ßçdo§ß$á·Ù•|o5Yøa-<îçïzW ¿æd—wç8¢¿ nr8Wõ!7EpûCïOîÁu%‡sÔ`r× .KçŽÓÈM\r˜¯u6¹ë×Îaç“»^pƒÈáü5†Ü ‚;…Êx%¹i‚Fç­«ÉÝ(¸‘ä0÷i¹›7†Îm3ÉÝ,¸ñäp^»—Ü-‚›Bç´yänÜÍäp>[Hî6ÁÍ"W]?]Wèp{=]}ÿ'‡ß ÁÌÌ2øðyÓL‘Þ3dB<…màw»ð{™l ýî~+É„˜ëeúÝ)üÞ%ûWúÍ~ëÉ„¸ì]úÝ%ü¾${ýî~[\yql|I¿{„_CNÒŸÎ:ž-˜–d2Í{EšmÉ„ÛÀï>á×™ì*úÝ/üº‘ qbgú= üÊÉ®¥ßƒÂ¯gëü>ÃñXN¿9ÂﲟÐïïÂïDW^·ÇÐï!áw*ÙoXÇssü¾Š4ç©ãŸLˆ[Ïbšó…ߟɶ§ßÃêø'bÛ?Óïáw Ùýé÷¨:þÝ>C_q ý¿»ÈL¿¨øß•}Ê]ô{Lø=F¿ç³çÇEýÄÐø^‹tŠt_!‡ß>šv`ŸìŽ ëÞ}R°kÖÄû”`?ulX/ìÓ‚ýŽl5ó;Šì3‚ ˃T3¿+É>«ÎÿŽE~?"ûœ:þ‹üâZØçÛ™ìæ÷ú.ìAŽE~7“],ØJÇ"¿¥Ìà ‚=±Èo²K{<Ù9Ìï³ÌË‚âXä·#}_왎E~O"»T°ç9ùAöeuþ'‹v0ܵßWûÇ.uí÷Ÿ‚½Ö±k\û]&ØÛ‹þ;´ßå‚Mve½üš‘`_ì|džu#Á®ìSŽ kK‚}M°/9ù í÷_êüOö#æ7´ß•‚}×±K]û}]°»Æµß ökÇ"¿¡ý¾!ØŸÉ¢LÃ]û]%X¬{Ø¥®ý¾)Ø6Ž]ãÚï[‚íäXä7´ßÕ‚íJõzk¿o ¶Ì±›\û]#Ø^ŽE Úï;‚=Ö±9×~ßì`²›™ßÐ~ßìéŽÝäÚïû‚=DZÈoh¿k[çØœk¿ö ²h_aMV°ÿìßÖe»N°7;6¬Õ öCÁÞåØ°ž+ØûÙ>Ìoh¿ë»Ð±›\ûýÁ¾àXä7´ß ‚]áØœk¿ öm²Èç×~?ìGŽEÌÚ蓼ý±ý]ûýL°?8¶Úµß‚Åz„x ®¸ö»I°­‹ü†öû¹`÷vl×~¿lÇV»öû¥`3dOb~CûýJ°‡9ù í÷kÁösl×~¿쉎­ví÷[ÁžJvDýüšÇ`¿ìpdžuÁ~/Ø ÖB»Y°—;¶šíwœýÿßz;^ÿ™Dã ’ß›Ù"9N½éÝLxá63œwsá]Cóœî¥7æ) ¡w á=’ÛÌwÞ-…÷r˜«ô$½1×h$½[ ï‰Üf‰óÞUxO u×$½®oÌšHïÖÂ{&·Yí¼wÞ÷…ºk’^»ÇõbÌù™IïÝ…÷n³Õy·ÞϒüŸä> Ó5¿лHx/ã6¸þ¼÷Þ«ÈaîNzcîÍ2z·Þë¸MçÝNxo$‡ù7¥ôîÌûHÀ{O±Ínƒßìwçïû{ kúâßÎ;k/¸–äðvr{ ®9ü–\J®ƒà:“õ‚îä: î@rø;/¹N‚+'‡ßÎÛGp½Èá7ì!äŠw 9\£¨!×Yp¿!‡kµäöÜ©äð›}¹ýw6¹ä·srû îr¸62™Ü¯w 9\£˜F®‹à&õ‚ÛÉ ¸kÉá7ûpÝè×¢mßJñÆ£mw~w“Cì€m0‡>Äðî&¼çs›ÕÎû@áý$9ÄØæËFùÞ ï¥Üf£ó.Þ+É!vÀ6˜Ëbx,¼ßç6ˆ‚÷!Âûcrˆ°Íaó1¼K…÷wܦÈyg„÷/ä;`Ì)1¼cá5¹ñè»-9ÄØæªÆùÞeÂ{?n3Ày— ïrˆ°ÍÜÆùÞ»;·©qޕ»/9ÄØæÆùÞUÂ{·©sÞ9á} 9ÄØs¬C ïîÂ{8·™á¼Þ£È!vÀ6˜'bx&¼Çr›ùλ‡ðžD±¶9ªI>†€wOá}·Yâ¼{ ï;É!vÀ6µMò1¼Þq›Õλ·ð~œblƒ9Ç!†€÷Â{ ·Ùê¼ûïä;`›…Mò1¼û ïw¸ â‡à}¤ð^O±¶y¿I>†€÷QÂûknÓÅy÷Þ?‘Cì€m07Äð>Zxc½|<ÐWÐûá݆ø÷ÜwÀ°ʱ»˜Û¬vÞÇ ïnäÀcÝ‘ð0¬gÒ_xWr›ÎûxáÝ›ø®î;`X“d€ðÀmÐï„÷ràOpßú"…÷0nSä¼ ï‘äÀ_來µANÞ—r›îÎû7Â{"9ðÓÝwÀ°¾Ço…÷ ¡¬Î{°ðžIü"÷0¬Ñq’ð~ÛÔ8ïß ïäÀopßÃ:C„÷"nS缇 ïeäÀ·tßÃZ' ïÕÜf†ó>Ex¯ ÇA»t]Šð0¬wñ{áý·™ï¼OÞ[È꾆5+NÞ¹pÿç]-¼[“?Ö} ëNœ.¼;r›ÕÎû á}9ð³ÝwÀ°vDð.ã6[÷™Â»'9ðËÜwÀ°þÄ÷qÜýwð&¼“ÿ•ûÖp8Kx×p›.Îûlá]K|;÷0¬Ã0\xá6è¿{Ò{„ðOýv¸¯¶}‘±ý…÷Ô°/÷9Âû6rè·Ã=¦:ïZá}·Ùè¼ÏÞ“C¿ßðЇßç¼ÏÞφS4Ì{Þ/“C¿î]ö¬ó>_x¯â6EÎûá½–úíp4l‹þ Þ£„÷FnÓÝy_(¼¿'‡~;ÜSm£ó-¼qŸ<8ï‹„wKrè·ÃýÙ°mð®Þí¹Móþ“ðÞŸúíp¯·öÎûbáá6uÎ{Œð>”úípß8l;‰ÞÞGs›Îûá}"9ôÛátG;ïK…w5·™ï¼/Þ#È¡ß÷³«vÞ— ï:n³ÄyÞãÈ¡ß÷Æ«sÞã„÷n³Úy_!¼o&‡~;ÜgÛ~Fï+…÷=Üf«ó/¼ç’C¿îÙwóþ‹ð~ŠÛ ÿÞ„÷‹äÐo‡ûÿ=å¼' ï×¹MçýWáý.9ôÛá^‚¯;ï«„÷'ÜÃza¿3IpßÛ×q“÷3¹~Ž»Zp¸7µä°–ÃßD™v#Wx_)øNQçÿöùò¬fú×î€öùòîZuü·Ï—'pSw¨+Ïj–ç:Qž#ÉÞ ¾× ßA®<™þ ‚;Å•'pÓ7Ì•'p7 n¤+ÏF–ç&Qž1ä ïçß›…ïWžˆíòÁ]ëʸ[w«+OànÜÝ®<àPžé¢<‘+¼|gß'\yŠ˜þLÁ½àʸÛ÷ª+OàîÜ[®Ü%®<=YžÿˆòL WxO[ø®¾×¹ò„5N?ÜtWžÀ}$¸Ù®<[/¸y®<Yžÿåy‚\áýxá»Aø¾èÊÖŒøXp¯¹òîÁ½íʸO÷¡+O²ž¤•ç3QžMä ï% ßÂw‹+OXÛb“àpâPžÀ}.¸–òå Ü‚k×)_ž“Yž/Ey:“+¼2|¿¾%òå ëË}-¸JWžÀ}#¸Þ®<ûVpǹò$kàYy¾åL®ðÎðý^øžáÊÓ‹ë7mÜ9®<û¯à.rå ÜÁuåIÖB³òü Ê3‰\áý§áû£ð½Ñ•'¬‘ò“àîpå ÜÏ‚{À•'p[÷¨+O²v ÆäŠòž…<֠ƺÐXÓ?¯cÍf¬ÇŒµ–±Ž2æÌbd¬Œõ±v1æxbmb¬;Œ5…±^pç`M`¬÷‹µ|±N/ÆÎc^¬±‹õs±6.Æ÷`í[¬k‹5k±-®Ý`X¬óŠ5\±>+Ö^źªX3ë¡b­S¬cŠ5J±þ(Öź¡Xë}b-OŒÄZX‡klbýLŒ«Ãú˜XûëZbÍJŒQÚ”XokIbHŒ÷Â:XÃë3bíE¬«ˆ5±"Ö:Ä:†X£ëbmA¬ˆ5±ÞÖòÃ:}XkÔa½8¬Ý†uÔ°¦ÖÃZ_Xw k`a=*¬ …uš°fÖ/ÂZBXëû`¬“ƒõo°® Ö«Á:4X_ëÆ`=¬ó‚õ[°. Ö[Á:*XÛë‘` ¬ûu8°vÖ»ÀX3ë<`m¬§€5°¾Ö.ÀºXsë `­¬€9þ˜¿¹ù˜w9õ˜/¹ð˜çŽ¹ç˜/Ž9Þ˜—yÒ˜ÛŒùȘCŒ9½˜‡‹¹³˜ïŠ9ª˜Šy¥˜/Šy ÉüÎÝ,/&̳ÄüIÌ‹Ä|GÌcÄüDÌ;Ä|BÌÄü?ÌëÃ|=ÌÃÃü:Ì›Ã|8ÌsÃü5ÌKÃ|3Ì#Ãü0ÌûÂ|.ÌÓÂü+Ì«Â|)̃Âü&Ì[Â|$Ì3Âü!Ì Â|ÌãÁüÌ»Á|Ì“ÁüÌkÁ|ÌCÁüÌÁ|ÌóÀü ÌËÀ| Ì£ÀüÌ{À|ÌSÀ¼ŒÿÇ8}Œ§Ç¸wŒOÇ8rŒ÷ƸlŒŸÆ8gŒGƸaŒïÅ8\Œ—ÅøWŒmŸUŒIÅxSŒ%Å8QŒÅøNŒÝĸLŒ¹ÄxJŒ•Ä8HŒqĸDŒÄ8?ŒÇø9ŒoÃ84Œø.Œ¿Â8)Œg¸#ŒÂ8Œ·Á¸Œ_Á8ŒÁ¸ Œ¯À8ŒWÀ¸\ÿÇuz\OÇuo\ŸÆud\ïÅuY\?ÅuN\ÄuC\ßÃu8\/Ãu-\Âu"\ÏÁu\Áu \oÀïóøM¿ã·SüÞˆßèð»~ Âï'øÍßÓñÝßñ ß;«#¾ELˆ8 ±Î×8Çá¼€¾ëëãëîãôD”Þ_êš÷M'âZHx$sÂëúÉô‡m$Ýïv#¤Þþ1ÈÞk$Þk,ÞkRðÞoí½¦ïn ìíøh,—NMòÐÛ7/xÛ·ˆòù -ÝëVáµyì*ØÖîóÝÄç»»×m[TÈ6Hïq_ø^[áÙÎ}¾§û,|¾Wx]?½ç|ä>ÛÛmÛA¤×Q¤×ɽÞǽ.v¯;óõ~Ümûûõ†ò"_Èü:JcÜ3÷¥Æ½ zGé|ܯ¡”®×Ž5Ù±†\¸_êYQº¾ÛyQºfÖŸÃý0p‹+£ô~x¸7î‡{ÊuÑ°è¬3j/7rtÔ#êÑ3:ã¼?D#GE›þ0âÂÑ#Î;st4bô0ûp»ÏÌ”™âè|ìäß+ü<ü_øüÛ^qÐ5¬«ÛZ°~ÔßÉû…ÇxöáQØ„Gáq…Ç~x4ÛÉûÍwò~‹¼ßj'ï·ÞÉû»ïäý6;y¿h'ïﱓ÷Ûíäý=wò~û¼ßa'ïwÜÉûvòþ>;y÷ÛÁ¾Ä½«Eéý~þ·çÿÛÎÓÇÿïíû û^µcÔuÓhçm ç@ÄN¡M…ç†Q>þ€ÿ.Lûú`rY¾‡s%Α™âÒf%±ýÉšÊLå¦ SÿÄø8®L˜*üÍâã’²Òäo6ù ®\6«Ä«Êä6Ë$6™L²Y&“g¿²ä­òÄ©N¾2ü'Ÿ:›ä€F°½žINžÉÛ8®ãäOÖÞÞÖ5•á´"Ûç™ô,‹·ÑkÄè*,÷™t¯X§T[!c™Éd·õUÉ;p²Ss&Ý9x]Q6i­Uöö¶>©•!—–ïLYè¹rH­ ›ØÙ<“ž™“-!‘;î2eUÛÞGYÐCdìüIORÉûÈâŒz™ô •ö|ÈI9·#0SîºÄÄÉÛñ—©(Í÷…(WEòÇŠËWò²Y„*$¶¬¤§8K6E-‰ôg¹OOr–›ô$g©¥'9+Sz–³¤g9ËCz–³¢¦g9+Lz–³|'½ws~/WTæ÷r~'§)¤;9¿ÓäÒ}œßÅ•nç÷pe&¿‡ó;8Í^ºƒóû·2›ß¿ùÝ›f<ݽù½[é÷n~ç&![عù}›qaßæwme•ßµù=[™ó{6¿c«¶Û±ùýZ•ñû5¿[«âí«:©éªìö5TtUÙöÔsUùöõœTsUÅöÕœÔrUåöµœTrUÕö•œÔqUnû:Nª8Wº}'5œËÔpRÁ¹¸ ‚“úMcW¿IõæÊ «7©Ý\yaí&•›«(¬Ü¤ns•…u›Tm®*_µ%Ûê6—Ë×mI¨Ü¸´4_¹%¡vãÒL¾vKBõÆ¥q¾zKBýÆ¥…ý*8Nb$ßM¡†ãÒò‚^ U—V䫸$Ôq\Zéê¸$Tr\ºC…ZŽÓ˜Ë÷P¨æ8S꫹$ÔsìB²Ð?¡¢ãôÈvÝj:ÎìØ;¡ªc~…Â+¸Zþ’o*±Uzl•Û "ŽÓÈËrcç…ت8N¾˜Äv:ˆ­jcTmrˆ­JcT©uýqz>GUZ[ÆÉ)7¶Ž>¶Š‹QqIï[…Ũ0ëÔã$ŠŠQOÖ¿ÅV9qòõ+¶þ/¶:‰Q'åiÄm4j¢_˜g”ߺçØÊ'}mlml%QÒ¤Ž­+Œ­ã‹­›‹ÓPÏ:±Øº¬Ø:¨8 ì¬û‰­¯‰­c‰“^$¶†[[Œ­/ˆ“ã>¶=¶Ûa'Gml‡il #¶¶'Ç\lí)¶C*¶çÒèÆh;â‚çÄÙuÖšGÖl6ižÙRÄnXSË& +[ŠXÚ"·RÄXæü[à?opensmt-2.5.2/regression/state-dump/NEQ004_size4_writestate.smt2.expected.time000066400000000000000000000000351445011647600272620ustar00rootroot00000000000000real 0.02 user 0.02 sys 0.00 opensmt-2.5.2/regression/state-dump/NEQ_NEQ006_size5-00.osmt2000066400000000000000000003015751445011647600233710ustar00rootroot00000000000000xœÜÝeXUùûïñ…cww6¢"":ˆŠˆˆ…ŠˆˆÝˆˆ¨ˆˆØ…Š]؈ˆˆc‹ˆˆ9vÆyϽÖ5ãœÅƒsœ¯ëuÝ÷ßY³÷f­ÌÿwïÏ=|IVSv“É”7·ÉÐÖÌ4×ÚÌÔ¯™©«™©²ñ÷ê:&ªŽÉÔˆÚ Ð ƒ030K°{p§p/ðIݙɔ…PÕÐ-Ñ]Ð ƒ0 ó±ë° ûqgp·ño7“ÉT P ÑÑ}1£áWÛD<ý%ÜĘg6™  *ÁŽèÁD(Ö` . ÷ð ß‘/ è€büØ7Õyâ1~Ãî烳¸†T<Á[¤#kVnÅQµÑmÐ NèOŒÁTø#+± ¯˜L_«¡Ét—ÿ»ÕæÙøy¨#P—~!u=œéOP¯a:ý;jV.x}%j„Ð÷ zb5ý\êJDÐ¥^À^úÔ_ˆ¢/ca2ÕG<}ê@\¢ŸE E2ý~jÒ?¦~ÅKúbM¦šøLß‘ÚfæœCjrÑï¢Æ¢0ý=ê{”¥ÿ£‰ÉTÕéÛQÑ~5–ô[¨Q°¥¿E}‰ô¹›r£oEíŠú‘T_<¡ß@=€|¼8®«¿Cqúlͨ¨Hß”Ú µé‡R§¢ ý*ên´¡¿H½¯ŽS/²æ&SA8Ñ7 Ú ý êxxÒ/¥nÅú3ÔL¥ÿFÍÓ‚ç}-ª‚éûRGa%ý"j86ÑŸ¤&b7ýªyK“é}j3ÄÑ÷¤záý<êj$Ñ£^Â/úWT3K“©j“©µ!è»QÝ1ž~65 kéRÏb+ýSj:"éKðÆRÑôRû!~5Wè÷PãBÿ€úè YqÿxMߞꂯô¨Èœ“÷j4òÐßVÇ¢(}ÞÖ&Sy…¾5Õ5éGSý`A¿‘zVô7¨i°£ÏÞÆd* GúæT{ô¡Fú5Ô½¢¿L}ˆCô™ÚòœÅ]úFT[˜çâ}†:ué—Q·£ý9j*¬é¿SóYsôu¨màLߟ:nô‹©›àEŠšúOÔíx|ôÕ¨-@ß‹êúùÔµXMœzôo¨™møyè+P-Eßêxú9Ôå¸D˜zÉôϨ?ð¾T{~>¼¤ïLuÃgúÔ”åsg5¶ô«ŽôElyM#Œ¾Õ1ô“¨ p–~‡ú;\£¿C}‹Túü|pUÄú¶T'¼¥KõG:ýfêdÍÃû6õ9òÑç´3™J£8}Kª*Ò§ÎDmúuÔH4¡¿J}„6ôY:ò\C'úÆT;8Ñ¡NF?úÔð¤ÿ‹zcèR tâ5N_j ú•Ø„Ý8‚8$á>žã#~¡`^7ª¢>ZÀ.oŒÇ”µç=‘jI=Fu¥^¦N¤þM £šåã}Z˜zZú–jIÍ×™÷Jjmêpj'ê,ª'u)ÕŸºº‰zœGM¡Þ§¾¦þ¢fÎÏãuà|Q[PkR]¨¨ã©½©¡Ô‘ÔHêlêê2êkêAê9鵧¾CkúlxÁPú:Ô¶XBßCýŽÓ¥NÃSú¹ÔÅø£+ï×ÔÍhI¿‡zƒéOQ/býMêõÏè_P?áozÓ}j/¤DŽ{ô¨³Ôm9ru)ѯ£nC_úýÔã˜K†zûèoSã6ýê7dëÎc*ÈëõèS;¢}_êh̦ŸC]]ô»¨'q“þ/ê drâñQŸ¡ýêOô Ï^ˆ3èKQ«`}=js\§oG팟ô=©P­ï¡ÔqèF?ƒ:Sè—P×`3ýê>\¦?F=oô—©·PÉ™k@}¥îƒþ 5SaÎ%}njl /G­¿èQ[á}j7”ëÉõ¦NBGú…êßÃXúƒÔsXC‡úgè³áù†wô•¨uPÊ…kOm‹öôR{`$}êP¬ K†Sôs©‹ñŠ~u3ŠñË÷êQu[ô§¨1Œþ&õ–Ò¿ ~ õËzQž;xF_ˆZ…\9×ÔhEß’ÚCè»P{a1ý êp£Ÿ@…Çôó©K‘¿7ÏCê64§?N½ŠAô©ß°>/¿ WÀaúÆÔŽx@ß—:¹ûp©sИ~uúÓo¤îÂ<úÃÔ“ØOÿõîÐߣ>Cö¾<©?Ñ€>{qž‡èM_ŠZsèëQ›c};jgÜ¢ïI€,ý8§Ôq¨C?ƒ:=é—P×`ýê>ì ?F=ô—ÕíÁÔŸç!õjСf*Áç&}j L£oEí†-ôƒ©“p•~!u¾Ó¤žC7^?Ô;èBÿ”úNý;ôß©ÙJrÎèóSKà"}%j|¡oJm‹ xR{àOúþÔ¡G?–: ëèçRãý*êf| ßC=Š2yªûAú›ÔMÿ‚ú «èM¥xâ4}!j¼¡¯Fm€üGeKj{´£ïBí…áô^îü®‚Äã!Ìó¹K¸b"Âp×ðù<øLB'x›‡ûø…ÒCø¼ Æ#‘¸‚×ÈãÉgìà?„#wñ%‡ò»œáƒìÅ%¼D./>/a wøb=bŠtÆïpÂc7.à9rxóY ÄL¬E4RðEùr 8b‚°ç‘óü·¬á†éX($ã3 äwytÅ,ÀvœÅdÅï?hƒ~˜Š•8‚$|DÁÑüÎx#[‘€GÈ<†ß»a…>˜Œå8„D¼G±ü®{x!ˆÇC˜ùpýa WLDàÞ"ß8®?:ÁþØ„8܇U®+Ñ…ÉðC–#;q±8DÜEÞãÌËò¸Q•QÍ` {8à ^ðÁt «½ˆB<.!ñŸaVŽç £,ªc÷dž"Áüþw9øÝÍ3Q—àL0ãý-ïƒðžÅë¯<ïoÔµh@¿z-éÿ¦föå5I_„j.ô¨èE?‰ºƒèwPÏc8ýêL Ï?›sYôm©n˜O?–‚¥ô›©ñXG“úÛèsúñ3b?}Kª+ŽÓ§.ÀúuÔ\¥¿J}‹ÛôYæð\ÅcúÆT'¼¡BõÇ7úÔ#È ú‹úyéRKûó™K_ê€ ô¨3Q‹~ 5éOS¡5ýjѹ|ÎÑ× Ú¡;}oêdô¥_H݉!ô'¨w1šþµ@Ÿ‡ô•¨Ö˜C߃êƒEôs©XA”šŒô/¨¹æñyI_†j‰Ãô]¨#p’~u=þ¢ßO½†ô©Yù,¥/Fm‚gô©žø@?…º?éwQ/ {Eþê/üAÿÇ|^û(Eߎ:UèÇQCQ~ 5ÍéoQ¿¢}î¼×¢3}+jô¤I Âú ÔX £¿N}qôÙòšÃ ú¦TgÌ£J ÀúUÔ(¬¡¿H}‰-ô¦ ^KØG߀ÚÇèQ}qš~)õ.ÓŸ¡>Á-úoÔâ‹x­Ð×¢vÂ+ú¾Ô©øB¿ˆº™*q ¨÷‘›þµ`0¯-ú*T”£ïIôó¨[шþ5­è_Qó,æµH_Žj…nôݨ£Ð›~65ƒéR1’þ)Õ<„×.} j3̦ÿ“ê……ôÓ¨«±Œ~õ6Ð? š-áµN_ˆÚéÛSÝq‚~5 çè·QÏâ:ýmj:îÐç å½Oé[Sûáýhj0¾Óo¤Æ![ež£ÔÈOŸ})Ÿ…(Aßœê‚Jôè¨C¿†¦ô—©¯Ñ–>SŸ=ø“¾Õ=èSýП~õ†ÒŸ£¦a,ýwjÉeœú:T{Ì¥ïOŽÅô‹©{±Šþõ!6Ó¢^ι¤¯FµÅQú^Ô‰8E?ŸºéSSq“þ 5ß Î=}j¼ ïNƒOôs¨›`ªÂkžš³•¼žà„éØŠkøª«xžc26á¾¢âj~.ŒÇzœÇG”]ÃûÆ`5ð%×ò¼Å,G^¢è:'¼Š¤¡àzÞ—à`DáòmàyˆX€C¸\á|î ‰T˜oä}®ðÃn$#ó&žWpÆLlG"~¡úf®7¦"WŽÊ¼¿c"ÂqŸQ~ ¯gø`-Îâ=JoåúaV"¯Q|ï×ðFbñ…·óú„'B'(°ƒß=ᎠÁCäÙÉû/܈¸‹»x½¡ü±)Ⱥ›ÏW Äs®ÿG ßÇÏLÍQ•÷.ú‚ÔÒ8N_•Zé[Pm7’s@uAcúToô¥O‰9ôÔPì¢_KÝŠô‘Ôhü¤O ^A•ý<>ê#t¦MýŠqô™«ñsb }Qjyœ¦¯IµÀ+z+ªŠàºQû ½uÓO¦úa!}u9Ò‡Swâý!j,²äùLMDú»Ô4ô OýiôæÕ¹6ØL_’ZéëR›á½5Õeñ\£º¡=½ÕÃé§S°”>„ºÇé#¨{ñ˜>Š¼‡y R“јþ!õ%úÒ¦šÕàüÓç¢Æ.ú²Ôê¸Aßj‰Ÿô¶Ô®¨r„×ÕéGP'b½/uÖЇQ×ã4ývê¼¢¡žE‘£\8b‚°ç‘ó(άá†éX($ã3 ã1¢+F`¶ã,ž k4ï=hƒ~˜Š•8‚$|DÁãÁ^\ÂKä:Íõ‡-Üá‹õˆA*ÒQ<÷8a ‚±ð9Îð~ ÄL¬E4®qíSño‘Ž¬5ùùQQMÐà„~ðÄL…?‚±›°G‡ HÂ}<ÇGüBŽZ\o”FUÔG ØÀ.oŒÇL"k±‘ˆÆçëœïD/šÁ`D ׆_(|ƒëƒ6p†7|±»¼…y a‡~ðA Öã.à!¾"ßM^/h®ðÀT„`+bˆç0Kæýµa Œ€Vb/Š÷Èq‹ç/,Ð nÇ\Â#¤£@ ç–p„'¦#Û‹$¼DæÛ\wÔ… \1 þXHœÅ]|D®T^h{ ÄDa¢pOðïð|†œà…™ÃNÄ!¯‘õ.¯Ô‡-ú` °Àµ¿‚<Âk|EæÚ<PåQ°‚Ñ…ÉðC–#;q±8DÜEÞãÌëp~Q•QÍ` {8à ^ðÁt «½Xñˆß…± ‡qÉxˆ—ø ³Çüw* £5œá/ø`:–b¶a?Ž#w‘†÷øBOø|C54@K8¢<0 “±«°{pW‚Gx¯Èÿ”ßÙQ uÐpÁ@xc<b6`â’pÏñ¹ÓølB9Ô@#t‚úÁc0K°[°gq ©x‚·ÈþŒÿ~E)TA=Ø¢+\᎘ƒEXØ…x\B2â%²<çsÅPµ` {8à ^˜…ùXŠu؆XœG"î"í¹ ÔäD!”A5XÁŽèLÃ\,Æ*lF4p)x„ïÈö’남„°\0“0 ± pq¸€$ÜÇdzÅuA”C´A'8¡Æaæa Öàbp׊ø‰ì¯¹.(…†°„-ºÂ£1s°+°QˆÇ%$ã ¾!Ë® Š¡.šÁöpÆpLÀ,ÌÇRìÄ!Äâ<ñŸ`zËuA!Ô„¬`G ÅXLÃ\,ÆVD" ¸‚§x‡ïÈöŽë‚ª¨°c$&a6bvãâpã¾ Ó{® *¢6š  :a†af`Öc; gqÏð?‘ýŸ5¨Ž†°„-úbFc æ`5"°QˆÇm<Æ|C–¼W¢2ê¢¬Ñ ƒ00 ËŽ8„XÜļÀ§2|VåQ°BôÇPŒÅ4„b-¶"ѸŽ;xŠwøŽ‚Ÿù¬GUÔG tCo ÆHLB0Vbvã.ãþÆ+|A¾/|¦¢"j£ :£'`Æa°Ûqáîá> ×W~wAYTGCtDwôÅŒFB°Ø‹3¸ŠÛxŒ70ÿÆgJ¢2ê¢=º a8ü„åÇNœÂEÜļ@æt>{QåQmñ'z ?†b&ŠµØŠ8‡ë¸ƒ§ø…ß¹.(ªh…è†ÞŒ©ðG0VbŽá4.ãþF:²þຠ8*¢9Ú¡3zb& †õ8Œ“ø 7pŸaö“ë‚Â(‹ÆhŽèŽ¾ðÁt «±ÇqWqïñ濸.(‰h‰öè‚^…ÉðC–cŽâ.â&^ã+2›ÌLyPuÐmñ'zÀã1ÅÄ œÃu<ÇGüB33SAÔ@#´Btƒ'Æ`*üŒ-؇c8Ëx‚·HGÖLf¦|¨‚zhŽvè wŒÀDøb6bã$þÂC¼Äg˜e63åBÔBc´FG¸Á >˜Ž¬Ã6ìÇqœÁ]¤á=~À<‹™© ª¡Z¢=úÀ£0~X…Í؃£8…<Âk|Eæ¬f¦¨„:hŠ¶pÁ@xc® J >ZÀpÁHLÂl,Ä2ìÆÄá’ð _)?×EPMÐà„a‡˜‡%ØŽˆÁY\Ã3|ÀOd/ÀuAu4„%lÑC0S0‹½ˆB<.á1Þà²üÁuAeÔE3XÃ00 óŽ8„XœÇ¼À'ð†mʉò¨ XÁ“ó~įUI%ø½Ä?ßÈo’ywõ¿1óŸ×¿}_ Û¾30á?ßX“Áwnjÿ{õÿËwÔÌý„ÿ‡ï|Óþ·ñÿ›ïLÑþ·ôEX†u؆HDgú?¿kððÃà{µÑVßA ˜ið}„½8Š8ƒï&¼×¾Ÿ-‹|G¡¸ö=…ZÚw¬´ï+tƒ+Áã0sŒÇŽ,ÿ¾Ç°‡‹óHÌ*ßgHÃ{üÈ*ßi(€’¨œM¾×Ð Ö°Ï&ßmpƒ|²É÷Ô÷Ô÷Ô÷Ô÷Ô÷Ô÷Ô÷Ô÷Ô÷Ô÷Ô÷Ô÷Ô÷Ô÷ Ô÷ Ô÷ Ô÷ Ô÷ Ô÷Ô÷ºÂîæò‚‰ðÅsùÁzlÇsù.ÁY\Cª¹|Ÿà-Ò‘5»|§@}—@}‡@}w@}g@}W@}G@}7@}'@}@}@Íþ«™5ë¯füÕl¿šéW³üj†_Íî«™ýûxŽÙen?G^â(Cf÷ë£lrÈü¾ Â;‡ÌðÏD BsÈ¿šßWsûj^_Íé«ù|5—¯æñÕ¾š¿Ws÷jÞ^ÍÙ«ùz5W¯æéÕ½šŸWsój^^ÍÉÂdøå”YùåÇÎœ2/‹óHÌ)3óix9en¾J¢r.™W3ójV^ÍÈ«Ùx5¯fáÕ ¼š}W3ïjÖ]͸«Ùv5Ó®fÙÕ »š]W3ëjV]ͨ«Ùt³Ü\Î-óéÕÑ–¹eF½+\áž[æÔ' rˬúzlÇÜ2¯®æÔÕ|ºšKWóèj]ÍŸ«¹s5o®æÌÕ|¹š+WóäjŽ\Í«¹q5/®æÄÕ|¸š WóàÁÌ„_È`.\Í͆Ûd0®f‡µ9ñ5yeN|_^™?WæÄoå•9ñWø’WfÅså“Yñ²ùdV¼a>™·Í'³â®pÏ'óâòɼøü|2/¾.ŸÌ‹ïÏ'óâgp5ŸÌŒ?Ê'3ã_óÉÌxžü23^>¿ÌŒ[À*¿ÌwË/sãƒóËÜø¤ü27¾0¿ÌoÀŽü2;~B›¿ž_æÇŸj3äßóË y~mŽ¼R™#oªÍ’ÿY@fÉûkóäú,¹>G®Ïëóãúì¸>7®ÏŒëóâú¬¸>'®Ïˆëóáúl¸>®Ï„ëóàú,¸>®Ï€ëóßY Êüw1m¼VA™o­Íw/(sàC´Yð)e|‘6¾± ÌƒÖfÂõyp}\Ÿ×gÀõùo}ö[ŸûÖg¾õyo}Ö[ŸóÖg¼õùn}¶[ŸëÖgºõyn}–[ŸãÖg¸{–î‘Ú÷ìÂ2ǽL›åÞQXf¹OhóÜ× Ë<÷Sm¦û{a™éίÍuë3Ýú<·>Ë­Ïqë3Üúü¶>»­Ïmë3Ûú¼¶>«­Ïië3Úú|¶>›­Ïeë3Ùú<¶>‹­Ïaï/*sØg´YìÛEeû6¥˜ÌcÓf²k“™ìÖÚ\v÷b2—=D›ÍÖç²õ™l}[ŸÅÖç°õl}þZŸ½Öç®õ™k}ÞZŸµÖç¬õk}¾ZŸ­Öçªõ™j}žZŸ¥Î]Bf©ËióÔJÈO­ÏRësÔú µ>?­ÏNësÓúÌ´>/­ÏJësÒúŒ´>­ÏFësÑúL´>=އ阋`¬@8vàŽ#—‘ŒxŽøl¥ù¼A1”G 4DKØÀ.oŒÇL"k±‘ˆF® ð_‘¹ ïÑ(Šò¨ ‹2ÿsfoÂ¶è €Æb*æ Ë°Û‰cˆÇE$áÒðéÈRžs§foQ¶¼Ìêª]5›«frÕ,®šÁU³·jæVÍÚª[5[«fjÕ,­š¡U³³jfVÍʪY5«fbÕ,¬šU³¯jæUͺªW5ÛªfZÕ,«šaU³«jfUͪªU5›ªfRÕ,ªšAU³§jæTÍšªS5[ªfJÕ,©š!U³£jfTÍŠªQ5ªfBÕ,¨šU³ŸjæSÍzªO5Û©f:Õ,§šáT³›jfSÍjªM5›©f2Õ,¦šÁT³—jæRÍZªK5[©f*Õ,¥š¡T³“jfRÍJªI5©f"Õ,¤šT³jæQÍ:ªG5Û¨fÕ,£šaT³‹jfQÍ*ªE5›¨fÕ,¢šAT³‡jæPͪC5[¨f Õ,¡š!T³ƒjfPÍ ªA5¨fÕ, šT³jæOÍú©?5Û§fúÔ,_ND)TF4AkØ¡\1އ阋`¬@8vàŽ#—‘ŒUþ™ÓçÅôY1}NLŸÓçÃôÙ0}.LŸ ÓçÁôY0}LŸÓç¿ôÙ/}îKŸùÒç½ôY/}ÎKŸñÒç»ôÙ.}®KŸéÒç¹ôY.}ŽKŸáÒç·ôÙ-}nKŸÙÒçµôY-}NKŸÑÒç³ôÙ,}.KŸÉÒç±ôY,}KŸÁÒç¯ôÙ+}îJŸ¹Òç­þ§ÌÝüO™¿Pgp·ð¯ð™êò³ Ê£,Ð ¶èW ÆL‚/" °ûƒ3¸†Ûx‚7HG–z\CyÔ‚ZÃÝÑC0 SêIÞÅB,Õr/¶á Nâ"ná1Þá'rÖçç@ÔAs´G7ôÅŒÆÌÁ"¬ÀFìÂaœÄ_¸{x†ø‰ì xÿG)TA=4G;tFO À0ŒÃ ÌìÁìÃ1œÆeÜÂß þɽÈÔP²/ £LCÉ¿h¤e`Ø¢KCÉÁ¬eaLĬ†’‡±LËÄØŽý %㜖‘ŠÇ %ã»–‘‘ÅINF-+£ :6’¼ŒþZfÆLi$¹‹µìŒMØÕHò3N5’ $Ük$9ŸI–F Ι…äiTÓ25Z …äjôÒ²5¼1ÎBò5ækk±ÅBr6Ž[HÖÆܲ¼7’¹‘¹1Ÿ™%w£‚–½aV%£{cÉàðÀÈÆ’Ã1§±dq,džƒÇq¸±drœÇõÆ’Ëñ¬±dsü@¶&’ÏQJË訋¦M$§£³–ÕᆡM$¯c†–Ù‚UM$·cŸ–Ý‹M$¿ãï&’áñ¦¦’ãQDËò¨ŽM%Ï£ƒ–éáŠAM%×c’–í±K›J¾Ç-ã#gšJÎÇ-ëã-¾5•¼üzæj5“ܶZö‡ú6“ü±Zˆ?5“ÍZÈœl&y 7µLçøÐLrArjÙ ¥Q¥¹äƒ´Ô2Bг¹ä„ ײBfb^sÉ Y§e†DâXsÉ ¹ªe‡<«æ’’¥…dˆE¹’#ÒX˱C·’'2DË™ŒÙ-$Wd…–-²[H¾È_-$cä.ž¶œ‘Ÿ-$k¤J´”¼‘zZæˆ5þl)¹#´ìLk)ù#K´ ’ìi)9$§µ,’d Å+É?Ù¯e $ಕä <Ö²P¾"SkÉC)¦e¢ÔD£Ö’‹ÒQËFéƒÁ­%eJkÉH ²֒“²«µd¥Äâ\kÉK¹×Z2SÞã{kÉMùCËN©Œ:m$?¥–¡âŒþm$Geœ–¥€Åm$Oe‹–©…Sm$Wå––­òŸÚH¾Jn-c¥,ªµ•œ•Vm%k¥+zµ•¼•‘m%sÅóÛJîʆ¶’½rÇÛJþÊõ¶’ÁòoÚJK6kÉb)Ž Ö’ÇÒTËdé„îÖ’Ë2ÔZ²Y¦bŽµä³¬²–Œ–Ý8l-9-­%«å>žYK^‹©d¶D©v’ÛÒ@Ën±Açv’ß2¨d¸ŒÇŒv’ã²´d¹lžv’çr¦dº¤àïv’ëò­d»äAÉw©e#/Vè`#9/}m$ëe&ÙHÞË"É| ÇÉ}9i#Ù/‰¸c#ù/l$Ƽ=ï™í%¦J{É‚i†¶í%¦g{É„ñÂØö’ 3¯½dìÆæö’s¬½dÄ\ÂÍö’óª½dŘÙòži+y1ål%3¦!ZÚJnL7[ÉŽqÇp[É™m+2aXg+92m%Kæ,®ÚJžÌS[É”IG–’+S¢ƒdËÔFã’/ógɘé‡!$gfZÉš ÆŠ’7³§ƒdÎÄᯒ;ó ƒdÏ|ÄÏ’?SÈN2hª¢žäд·“, °“<š v’Iˆ%v’K³ÍN²i¢qÚNòinÛIFÍk|±“œš¼%«¦Âô'¯BiTC}´„ :Ãàq˜‰yÅlÅ>Dá4.áâ>#“=Ÿ3(b/ù9ÕÑÀ^2tlÑÅ^rtÜ1Ü^²t|1ß^òtÖc›½dêÄàŒ½äê¤â±½dë¤#KgÉ×)Ž %c§ Zw–œ'ôí,Y;c0¥³äícEgÉÜÙÃ%wçnt–ìçøÐYòwr8ðÞì ðí&ù>K±;»IÆÏ œER7Éùy†÷0s”¬ŸB(šŽ’÷Ó ¶pr”ÌŸ!…鎒û³+±ÕQ²Ž!×%ÿç1^㇣dåGqTí.9@Ía®Ý% h¼1¹»ä-D6u—L ÃˆÅ¥î’ ôÏñµ»dåFaTt’| Æ°‚½“dõ‡'Æ;INÐ<„`½“díG4Î;I^Ð<ÁG'É ÊÞƒ÷”í!¹A Ðv=$;¨7Ü1¦‡äÍAV÷ ¡=8‚„’#t ñ¶‡d eq湊’Î’'TM`ã,™B=á†Î’+4 Xî,ÙB;pqÎ’/twñÒY2†L=y®¢hOɪ†hÓS²†º£¼zJÞÐ4ø#´§dmÁ^Äô”Ü¡«HAZOÉúŽ¬.üîà"ùCUP–.’AÔ.ðp‘¢IðE°‹dmÄND¹HÑE$á‘‹d}Y/Þ›zI.QÔD³^’Mô'œ0°—äÃt,è%Eë°‡zINÑ9\Ãý^’Uô?ËUòŠÊ *,\%³¨º¢Ÿ«äÆd¸JvÑ*lB¤«äÆ%¤ºJ†Ñ|…yoÉ1*Š¨ß[²ŒÚÁ®½%Ïh8Æï·d-Ãzìî-¹F'qɽ%Ûè>"sÉ7*‚²¨ÝG2ŽZÃÎ}$çh(Æ`fÉ:Z‚ÕØÞGòŽŽ#‰}$óè)ÞâWÉ=ú%Q½¯dµ„ ûJþÑ`ŒÀÔ¾’´ËÑWrŽ"WúJÒßx‰ô¾’‡”EQ¹Ÿd"5E8ô“\¤ðÂÄ~’4¡ï'ùHƒ ý$#éÒð¦þ¼ç¡ Ê÷—¬¤F°D§þ’—Ôðé/™IsŒµý%7i¢p¶¿d'ÝÆ#¼ï/ùIÙÜx®¢´›d(ÕC3غIŽR/ Ä(7ÉRšXé&yJ»pñn’©t÷ñÚMr•2 ๊â$[©,`=@ò•z ¼HÆÒ  l€ä,mC$bHÖÒu¤âùÉ[ú 󼧔̥j¨«’»Ô ®ð(ÙKSà‡’¿´»=P2˜.#OJÓ7dÄ{ê Ébª„Úh1Hò˜:Ãîƒ$“if"+° {…Ó¸‚Ûx‚wøìî\c”Au4‚: ýÝ%ëÉÓÜ%ó)«Ü%ûi/ŽºKÔ%Üt—,¨—øä.™P¹Ph°dCUGƒÁ’e‹.ƒ%+ÊÃKf”/æ–ì¨õØ6X2¤bpf°dI¥âñ`É”JGÉ–*Ž ’1Õ­=$kÊ }=$sj ¦xHöT0VxHÕnö,ª ¸á!™TÏñÁC²©r áu=D2ªª¢Þɪ²Aç!’Y5ÆHvÕLÌ"Vk±eˆdYEãôÉ´JÁßC$Ûê+2yJÆUQ”ó”¬+ ´ò”Ì+Gôö”ì«Q˜ä)XAXæ)YX;qÐS2±Î㺧dc¥á§dd™å}v¨deUF¡’™e?‡Jv–†• ­é˜;T²´VcóPÉԊ©¡’­•ŒC%cë3L^’µUe¼$s«!ZzIöVWôò’ ®˜à%Y\ °ÔK2¹¶c¿—dsÅU/Éèz‚7^’Õ•uï‡Ã$³«"j “ì®6è8L2¼úaÈ0ÉòšŠ9Ã$Ók%6“l¯#89L2¾’po˜d}}ÄÏa’ùU¥¼%û«>š{K˜zzK˜7ÆyK&X –xK6ØVì󖌰\ö–¬°Gxå-™a™‡óù4\²ÃÊ£ÆpɳB‡á’%Öƒ‡K¦ØdÌ.Ùb˱a¸dŒ‰á’5–ˆ;Ã%sì=¾—ì±(¡eÕES-‹Ì=´L2/Œ!ÙdXR2Ï®áöHÉ>{‹o#%-ŠiYhµÑXËDë„îZ6š'FkiþX¤e¥m®Q’™‡¿FIvÚ}<%j¿}´d©•F-S­ÚiÙj.0Z2ÖÆcÆhÉZ Śђ¹‰c£%{í n– ¶×ø2Z²Øò ˆ–ÉVÆH6›º‘Œ6Œ#Ym~X8F2Û±cŒd·ÅâÜÉp»‹§c$Ëí²•L·’¨4V²Ýš¡íXÉxsFÿ±’õæƒic%ó-«ÆJöÛ^+p—ps¬dÁ½Ä§±’ — …|$®:øHFœ-ºøHVœ;†ûHfœ/æûHvÜzló‘ ¹œñ‘,¹T<ö‘L¹td'ÙrÅQaœdÌ5Aëq’5焾ã$sn ¦Œ“ì¹`¬'t»qxœdÑ]Àq’I÷ð ¹ÆóºDEÔE ØÂýà…ñðEV"‘ˆÁy$á!^#æxN¡,j¢ ¬áWx` ¦#aÇnD!×pÏñ™'r>PUÑVèg ÄL†?B°Ûqq¸„<Á{üB®Iüü¨ˆºh[8¢¼0¾ÂJD 18$<Äk¤Ã|2??Ê¢&šÀp…Æ`:†ðÉ’±w±“%k/w&Kæ޻ɒ»—u Ÿ (ŽŠ¨ƒfhô‚;Fb2æ «}ˆÆ\äá~!çTÞÛP5Ñmð'œ1ÞYX€eÇ.Á)\Â-<¤#Û4^Ÿ(…ªhKt€#úÂc1óŠuØŽƒˆÅyÜÀ}¼ÀgdšÎ{ Š¡"ê ÚÁ½àŽ‘˜Œ9Æ*D`¢q×piø€_È9ƒó‚²¨ ´F'ô€†aÅ[_É{4Ÿ-y%Pq¶ä>6›-¹Âi¶ä?zÍ–üÇiðŸ-9«gKä™-y—fKä<Ÿ-¹f~’ Y¥ý$²¡ŸäC¶‡ƒŸäDºûINäÌô“¼È0?ɋ܆H?É<ë'¹‘·ñÈOò#Óý$?2/ŠÎ‘ÉÚs$G²5ìæHžd¿9’'9“çH®dðɕ܈s$_2nŽäKÞÀÝ9’3ùqŽäLf÷ç9æ/y“Uý%o²9¬ý%wÒÅ_r'‡ÁÇ_ò'ý%r "ü%‡2Ú_r(/#Ù_ò(_ûKe¦¹¼ŸÎ•\Êòs%—²,çJ>¥ã\ɧŒs%§Òo®äT.Ãú¹’Wyh®äUžÃµ¹’[™6Wr+¿#k€äW– üÊ:h 9–ö’cÙž’g9=@ò,ce€äZî \ËS¸ ù–$ßò~HÎeáy’sY õçIÞ¥í<É»ì…ó$÷râ<ɽœÐy’¹}žä_GÂ<ÉÁL'9˜oðužäaæ ”<Ì ¨(¹˜m%³;úJ>æ˜@ÉÇœƒ @ÉÉÜ(9™‡(y™I’—ù ï%73Ç|ÉÍ,…Êó%?³Å|ÉÏì çù’£é=_r4g `¾äi®/yšû5_r5¯Ì—\Í¿ñr¾äkf^ ùšEPvälZ,œÍèº@ò6=HÞæ$ø.ÜÍå $ws,üÍó $óž,Î $‡3?Š/”<κ %³-:-”\N·…’Ë9SJ>gÈBÉçÜŒÝ %§3~¡ätÞÄý…’×ù*¯3' Ingõ Éíl › Éït ’üÎá$9ž ‚$Çs¶IžgLäy^EJäz¾ ’\Ï,‹xÏ\$ùžI¾gcX-’œO§E’ó9£IÞ§ÿ"Éû\ðE’ûyd‘ä~þ…ÄE’ÿù|‘äþ„y°ä€––Ðzh,y Á’:^Á’ :3XrA—`u°äƒFK>èi\ –œÐGÁ’úf‹%/´èbÉ ­†‹%7Ôn±ä†ö†ûbɼXòC"l±äˆî\,9¢'pv±ä‰Þ],y¢ï¾XrE „H®h%Ô‘|QëÉí~!’3ê"9£s"y£!’7zq!’;š"¹£/ð1DòGs-‘üÑ2¨ºDrH-—Hi¸,‘<ÒK$t—H.éú%’KºÑK$ŸôÚÉ'}Œ×K$§4k¨ä”CùPÉ+m*y¥á*¹¥ž¡’[:~¡’_º2TòKwáP¨ä˜^•Ó{H •<Ó_¡’gúJ.•\ÓúK%×´ì—J¾éÀ¥’o:Ó—JÎièRÉ9Ý‚½K%ï4a©äÞÂÃ¥’{úu©äžæFá0É?­&ù§­`&9¨}Â$u$&†IjP˜ä¡nÀö0ÉE “\ÔëH “|Ô÷a’šmï™Ë$'µò2ÉImŠ6Ë$/Õy™ä¥Ře’›°LrSWaÓ2ÉOZ&ù©‘´LrT_.“UÓrÞ3—KžjÙå’§Ú-–K®j×å’«:ÞË%_Õw¹ä«.ÅÚå’³z`¹ä¬žÁ•å’·úd¹ä­~Cæ’»Z|…ä®Ö‚Å É_í´BòWûÂc…ä°N]!9¬‹°|…ä±î^!y¬'q~…ä²ÞÇ3¼_!­¹P¥WJ^«ZÁv¥d·öÃŒZ)9®XŒ•+%Ó5Ç¿Rò]Sñ¯WJÖ«ù*Þ“Q|•ä¾ÖGsX¯’ XW ‚÷*ɃõÃB„­’lØÝ8ŒØU’›Œx¾J2c3¯æ¹…«%?¶6ÃjµdÉ:£?˜ÿu’»[°wäèžÅU¤¬“LÝ÷øŽ¬ë%_·4ª îzÉÚµE¸¬—ÜÝQ˜ßõ’Á»±s½äñÆã"’ÖK6ïk|ÙÉé-Ž ¨¹A2{­ñ'œ6H~¯7ÆaúÉò Ã:lÝ ¹¾±8‡k$ã÷9>àÇÉû-Œ2¨.Ù¿V耮á’ì‰Ñ˜.™À!X…Má’Ó¸.YÁOð_Ã%7¸J âFÉnv°ß(yÂîŽñ%[8Ë°~£ä ÁIœß(™Ãñ7JþpAÙM’EÜ­a·Ir‰Ý0c6IFq –`õ&É+>€ãHØ$ÙÅwño7IŽqŽÍ|^ äfÉ4nˆ–°Ù,ùÆ}0#6KÖ±?aùfÉ=Þ‹£ˆÛ,È)ø/7KrÖ>÷P4B²‘ë¢)ÚDHN² À+B2“}1¡’Ÿ¼!YÊI¸‡´ÉU6ÛÂïo(¸E2–k¢,·HÞ²úÂc‹d/OÇ\o‘æ­Ø‡¨-’É| ·ñh‹ä3ÿ@¶­^(Œ²¨Ž†°„-ºÂîû$Ÿ|fbÁ>É(_‡­8°OrÊÏà R÷IVù|EÖHÉ+/†ò¨)™å­a§HÉ-‚Q˜)Ùå‹°›"%¿ü0bq!R2Ìï! #%Ç<û~ÎJï—,ózh›ý’gÞnðÞ/™æ3€Ðý’k¾{½_²Í/#öK¾ù˜àÚŒór¨‹’sÞ]Ñç€dÄDø¼óeX$óüÎ"ñ€äž?Å[ü8 ÙçùQ•JþyS´ýAÉ@ïOø”ô¹Æꃒ…¾GPòÐoâ>^”LtÓ!^(|HrÑ«¡>,I6z¸Àýä£OÀL,8$éë°INú\Aê!ÉJƒ¯ÈzXòÒ‹¡="¹ê[°ÑG$[ý2’ñèˆä«ÙQ®ÿQÉX/‡êG%kÝ ŽJæz >*Ùë“1û¨d°/dž£’Å~'ŽJ&{"î•lö÷ø~T2Ú  D”dµ×EÓ(Él·G(Én÷ÂØ(ÉpÀâ(ÉrÀž(ÉtÇÅ(ÉvˆQ’ñnvŒÏõc’õ^ÕŽIæ»%Ú“ìwW :&ð1ë˜dÁ‡aÝ1É„?€ãÇ$þn“Œø·øvL²âó¡X´dÆ×FãhÉŽï„îÑ’!ï‰ÑÑ’%ïEÑ’)¿ »¢%[>EKÆü}<‹–¬ù_È~\2çK£ÊqÉžovÇ%ƒÞŽKýxÌ8.™ô¡Xs\²é#qì¸dÔ_Á­ã’Uÿ_ŽKf}‰‘ìúšh#övè#Yö#™ö~X#ÙöáØ#÷±8#Y÷wñ4F2ï Û É¾/‰J'$¿Úž,|gô?!™ø>˜vB²ñC°ê„däïÅÑ’• 7OHfþK|:!Ùù¹P(V2ô«£A¬déÛ¢K¬dê»cx¬dëûb~¬dì¯Ç¶XÉÚÁ™XÉÜOÅãXÉÞOG–“’Á_NJ´>)™üNè{R²ùÇ`ÊIÉèÆŠ“’Õ¿‡OJfÿÜ8)ÙýÏñá¤døçˆã÷ì8Éò¯Šzq’éoƒÎq’í?Ãâ$ã&æÅIÖÿZl‰“ÌÿhœŽ“ìÿü';¾"Ó)ÙPåNÉN ´:%»Ñû”ì…I§dW@–’;qð”ì8ë§d‡@Þ’]æñ¼ÿÇËNʨ/»¬ñg¼ìpÃÐxÙ50sãeçÀjlŽ—ÝQ8/;’ñ ^v|†é´ì$(Œ2§e7AC´<-; º¢×iÙU0NË΂XzZvlÇþÓ²Ãà,®ž–]Oðæ´ì4ÈšÀû‚ì6¨ˆZ ²ã  :&È®ƒ~’ ;¦bN‚ì>X‰ ²áN&È.„$ÜKñ3Av#D©3²#¡>šŸ‘] èyFv&xcÜÙˆ%gd‡ÂVì;#»p)x„×øŠÌg¹þ(Šò¨ XÁŽèŒÂdø!ËŽ8„XœG"î" ïñæçxý£$*£.šÁöp†¼àƒé@V#{…x\B2â%>Ãì<×…QÕÑ–°EW¸Â#0¾X€0¬Çv@ ÎâRño‘Ž,qÎP•P-ÐöpÅ xc2°+±û…³¸Š¤á3²^ๅ¢¨Œ:h8 #03„ÕØŽ#HÀe$ã Þà+Ì/òúCqTE=4ƒ-œÐðÁ4ø#kˆÃÜÂC¼Å7d¾ÄµEYÔF ´ƒ=\á‰ñðCVa"q ñ¸†Ûx„÷øŽ¬—yþ£ðE0Öb ö"‚´ë²ëÄ,QöM”'µeï‰u¢ì>qI”ý'#eŠ_¢ìAY™(»Pö&Ê>”„DÙ‰’š({QÞ'Ên”7d?JÙ²#Åâ†ìIétCv¥¸Ý})ãoÈΔ7doJø Ùrä†ìO¹tCv¨<º!{TÒoÈ.•I²O¥j’ìT±L’½*ŽI²[Å3Iö«LO’+¡I²ge{’ìZ‰M’}+II²såe’ì]É|Sv¯¿)ûWêÞ”,67e‹ëMÙÅ2ê¦ìcñ¿);YVß”½,‘7e7ËÙ›²ŸåîMÙÑòñ¦ìiÉ•,»ZÊ'˾–&ɲ³Å>Yö¶ L–Ý-“eKP²ìpÙ”,{\¢’e—Ë•dÙçò$YvºüH–½.oÉn—ê·d¿‹Õ-ÙñâtKö¼xÝ’]/3oɾ—°[²óeç-ÙûwKv¿$ß’ý/¯oɘ¬)²¦dŠì‚©Ÿ"û`lSd'LŸÙ 3&EväÈ~˜µ)²#æ@Šì‰9Ÿ"»bî§È¾˜Ï)²3&ÏmÙSñ¶ìŽiv[öÇ8Ü–2î·eÌäÛ²K&ø¶ì“‰¸-;e¢oË^™k·e·LÚmÙ/óë¶ì˜)œ*{fj¦Ê®™6©²oÆ9UvÎx§ÊÞßTÙ=³ïYÊûÑx×’ýGã}Kó?ï\:ÿÑxïRÎOÆ»—ì>ï_šûÉxSÂ'ã=LÙ>ïb²ùl¼iögãLqŸ÷2eúb¼›©ÍãýL3¾ïhŠùb¼§éçã]M–_÷5Mùj¼³)ê«ñÞ¦o_w75ûf¼¿iÂ7ãN‡¾ïqúôÍx—“Eºñ>§±éÆ;"Ó÷:½K7ÞíTÿ»ñ~§‘ßw<íþn¼çéÕwã]Oµï{öÃxçÓöÆ{Ÿžý0ÞýTý§ñþ§!?w@Eü4Þõø§ñ.¨Ê¿Œ÷A úe¼*ü—ñ^¨¿ŒwC•Ï`?Tÿ vD­Í`OÔ vE•Î`_Tï vF­Ì`oÔ­ vGÏ`TÏ vH…e°GêF»¤ g°Oª{;¥B2Ø+u5ƒÝR2Ø/Õ%ƒSA왺˜Á®©<ì›ú3ƒSì:—Áî©ÙŒ÷OuÈ`•{¨Ng°‹*«¹ñ>ªvì¤òÍ`/ÕÉ vS™e7ÞOÕ:ƒUÓ3ØSu<ƒ]U?2ØWÕ2ƒU“3Ø[u4ƒÝU_3Ø_Õ4ƒVã3Øcu0ƒ]V3ØgÕ(ƒVc2Økµ/ƒÝVo3ØoU/ƒW#2Øsµ+ƒ]W/3ØwU+ƒW^ì½Ú–Áî«´ ö_UË`–G{°6g° ëQû°*e°k`{±6d°ë~û±Êe°#«_{²Öd°++5ƒ}Y¥2Ø™åšÁÞ¬ìÎJÎ`V± vh9g°Gki»´3اU(ƒZŽè%yÞ ‹©€é¿~ýú5=“VÕÿXVþž[ÿßû¸þýϳÿ럫¿[öŸžŸº°¬ìàRÿn«ÿüóbÔ÷¥e§—¢ŽËëÿW:¡ì?Ç©?Y±ò?ÇÕ¢ÎÕî/›Áý52É^uµ´û3Gÿ×J»—Ýàqu î+óÏqêO“ìû÷qݨ‹´Ç•Óàqõ¢†å’Ûé¦Ý_.ƒÇ5è_K?.·ÁãNÝTúŸãÔŸƒÇ5ï_K?.¿ÁãZB½VøŸãÔõ ÜøŸãÔùó××k3µ“v¾Öh÷WÐàqíù×ãÒ+d𸎚dÇÄ¿+lp¿§¨‰åZëÏ×"·w‘Z·ÄïÇ5¸½›&Ùc¡ŽÓŸgÅ nïµ]Ùß+np{/¨ÇóË1úó£„Áyù¤—WÒà~ÿ÷¼‚¿WÊà~Õ®¼\Åä8ýú—6¸_µOO¿_ý¸2÷«vîåÿã÷ãÊܯÚË— ý¼úu+gp¿ þu¿úqå îWí÷kYâ÷ã*ܯÚ¸¾ œýúV4¸=µ'ð~©ß«dp{j—àª2rœ~}+ÜžÚ7سìïÇU1¸=µ“ðli9N¿nU nOí-ì\ö÷ãªÜžÚm˜VTŽÑ¯Guƒó<_;Ïÿ>®†Áýª‰}Kÿ~\MƒûU{ëå–ãôëQËà~·ýë~õãjܯÚÇø¹ÌïÇÕ1¸_µ³Ñ»ˆ<6ýºÕ5¸=µ×±ÚŽ«gp{j÷ãú2rœ~ÝêÜžÚéXö÷ãÜžÚ!Y'«§_·†·§öL>+ùûq nOí¢|^ZŽÓ¯‡…Áí©}•£Êþ~\cƒÛS;-wi·§Ÿç&×Mí½4™~?®©ÁýªÝ˜kJþ~\3ƒûUû3?—côëÑÜàöÔŽÍ×~?®…Áí©=œ£ËÈqúõhip{jW§]Ùß³4¸½îÚÏ»æ_×£•Áí©ŸÛ ü~œ•Áí©½ S Éqúõhmp{jwè÷"¿×ÆàöÔ~QµGiÍ¿Îs[ƒÛS;HÕ(ý8“vL‡ÿ§ö”.Ô~?lçÿüsµÃtdi¹ígýíõO3¢ô?ûNÕÏÖÞ$;^{ýkçU¿–¶·ù¯côãÕãíûŸãÔÕÚïvç(^ûwõ«ê1uD§ÿ§ö°žÉóÏcRÿÜí?ÇÜ4¸­?1ø?Ç©]®jïc~íúÚ›ä÷Ûó\»­Úít68OjìÚ"ÿÙz9e·¬þØ»œµs¶ˆÙ?÷ÙÍà<¨´«‹ü~[ŽçAí­½™YnKÓÝà<¨½¶ê:VãdpÔÞÛk9ÿymõ08j/îUíu¼:ÎÙà<¨Ý¹çrÊ]ý±÷48j¿®Ú)©ß§‹ÁyPûw¯üç¶zœµ£÷X&¹-uŒ«Áy¡‡ÁÚyèmpÔŽß}ùÿyOècpÔà½Ú1´óÐ×à<¨=Á{òËÎ`ý±÷38¡ÚãÒﳿÁyP»†=Í¿-7ƒó öÌ-·¥Ž`pöj÷·E; ΃ÚgܳÔ?ïyƒ ΃Úwì¬sT;îçAíDv)%û‘õÇ>Øà<¨½Éê³I¿OƒópO{ìÿ¾­!çAí^¾n&·¥Žñ48ïµÛz¦=ö¡šó];FT·åep[j¿³úó]»­a·¥ö?OÉ÷Ïûˆº-oƒÛ*®Ý–:^ÝÖpƒÛª £¿Õm0¸­ZÚq´Ûip[Ú1úóYÝÖ(ƒÛ²ÒŽ³Ðnk´ÁmuÐŽÑŸê¶ÆÜV7í8u¼:f¬Á1®Ú1­´kècpÌ í˜AÚ1ã ŽñÖŽ™§3Þà˜qÚ1{´c&3];æ“vÌDƒcæjǨÿ®SÇL28&X;¦vÌdƒcVhÇÌ׎™bpL¸vÌ6혩ÇìÐŽ)¦}nM3ÉóäßǨ}âOKýþÿsú_l˜×…wqw‡]‚;ÁÝÝÝ-xð‚CpnÁ=H XîÜ‚îžàï}êMÍpÞ÷í—äõ_§Î™Ûµ;ÒÓwádÏñXaýßH8Ù—¼Bÿ÷dNö.Öÿ=’Á„“ýÍepû^ÄÂÉè£ú¿Ç0”p²Oú“dþïüH8ÙK½o2ÿ×úÃ'û­ç ëÿÚ|8ádOöCñý_K œìÛ.{bÛ×È# '{»¿ŽâÿÚwádÿ÷íÉü_ÓŽ&œì_$¬ÿkÐ1„“}ä3DðÍ8–p²×|¸xþ¯ÇNö£oÎÿ5ÞO„“=ë»%ôí6žp²¯½ìÁj_“M \WÇíOèÿj"áú…÷ö)·¯&n¸ãî†óÍ3™p7$¡ÿk™)„ûÙqÂù¿F™J¸ÅŽ›ðÚcZ÷;Õr«ÃûÞsôåßóßÝñ,ɽ× 7#Èû}i¹]îØÇPÿß3ƒ¼ßQ–;"\À{Ùòþô î¬ãª'÷çf}ù·ÿïð^6áÏÂßlâïž;–>¹ÿï©9Äß ÇýâÏÍ%þ>8®N€Þ<â/bŸ¿ð7Ÿø‹ÁçO×ñ—4‚ïñSn!ñ—ÆqEô_R#Übâ/¿;61Ôÿ÷ò⯤ñ§ÜRâ¯rßã§Ü2⯮ñWþ~!þš¹cBýÿ,'þÚ;î}À{Ø+ˆ¿îŽ«ÜŸ[Iü 0þºÃß*Â÷Áœ§¿n’áô|YM¸ÙŽ«ê1ºnk·Ôèéã÷á~3zšc-á¶@OzjŽu„Ûg8ͱžpÇ §96î/ÃiŽ„ûÇpšãwÂ=rLJõ´4Ç&Âý뎊êqšãÂGôúV696Nž³dˆéqšc áâ Çc4ÇVÂ%Gßî&Ç6Âe0œæØN¸œ†Ó;WØqqáMsì$\YÇŒãqšcWЗó[Ýq/> Úôåü6Œèí o¹=A_Îo«ˆÞgœ–ÛKü}‡¼ÂËpûˆ¿ÞîØÓ$þÏ÷CŒ?åc·'€;HüM3þÆÂß!âo¾ñ§¿ï+w(€;BümpÜîî(ñ·Ãq«“xþ6ÀߟÄß!w¬RbÿçÃLj¿ÓæñSî8ñwÅq³¸Äßóø]¿“Äß3wìUÀgZ§ˆ¿wŽ àNá#EOîÏ!þb:.VrÏŸÔw–p‰#y9ÆšóôáRNÏ—ó„Ëb8]· „Ëk8}üþ"\qÃiŽ‹„«nƒÉq‰pµ §9.îÃiŽ+„kk8Íq•p]—>‰ÇiŽ¿ ×Ï«-ÍqpÃÑ÷ŠÉqpw9ŒÇiŽ„ûÙèiŽ·Øpšã&áVGò~ß £9nîè §9nnr§9îîO£§9îî¼á4ǽ /ç÷º;Ö?ÿëãûA_ÎïÇ JîÏÉ×]ç÷•ãb$õçŸàOøWð÷ˆø‹9(¨Obÿ×剿¸‘}þ”{Bü…8naÀgáO‰¿t‘}þ¤F¸gÄ_vw¬gbÿ÷ž#{ŸUYîñW:²ïñSî%ñW5²÷:Gü•†¿WÄ_}wlv,ÿ÷!^-7'ÔŸû—øëè¸uÜÄ_Oóøu„¿7Äß óøéïû·ÄßhÇÍ ølýñ7ÅøSî=ñ7×<~Sàïá~A9ô<ýH¸u†Óóåá¶N×M®ƒ äN¿`Â4œæC¸KàJ›a wËpš#ážNs„'ÜÃiŽ„ ÅÇiŽˆ„‹î¸[Q<-͉p ¡×ÑäˆL¸Žû;šÇiŽ(„Ëdô4GTÂåv\öˆ£9¢®¨ãŠÄ÷ÍpåÑwŠÉƒp5žæˆI¸ÆFOsÄ"Ü·È1Åäˆüåü~︪¡þïKÊ¥¢óûƒãV„øsqƒ¿œßw7©?øû 9„—áâ3ܱ©!þï‡& þÊ%$þV9®A—ˆøûÝø[‰‰¿]îXþ€kh’G·<ÄŸKJüu\ã.ñ÷·ñwþBˆ¿{îØô€kwB‰¿ŽËÔŸKNü}p\ý¯ˆ¿ˆQ}þ>À_ â/vTßù÷ÿkꈿ¤Q}ë«\*â/ã^\ ”šøûÚø“áÒ.?¸Uæ•5OÖ¬ôjbÍ&žÀØßñIÏ^Ž+ËŸ›Dô=]‹ÉDoŒãjÅñ禽©FO×b*Ñ›ç¸êqü¹iDo¹ÑÓµ˜NôÖ;®[|nÑÛnôtÍf½ƒŽëßÇÉšýLÖìô¦`Íf‘ž—ÀØ¿g³IÏ[ŽKð>í¢÷ÄèéZÌ%zo×4™?7è…åÓÓµ˜Oô¢;îRÀû¥ ˆ^B£§k±è¥p\HÀû‘‹ˆ^&£§k¶˜èåv\¨yŸQÖl Y³¢Ð;5[Jz–cÿv/#=k¸ƒ|ßð¢×ÈèéZ,'z­W0™?·‚èu6zº+‰^ŸX¾ï¶(·Šè 5zº¿½qŽ«ðÜb5Ñ›nôtÍÖ½ŽËÌŸû-Ø»>Ýr+×,àyÃÚà/¿¿¸}…—áÖ{׉[n§;–.àšÞõä9Òaè ¿zˆ¿3îØÈ€ç!‰¿«ÆßèýNüÝ5þToñ÷ÜCÄõôt=®½–ÆŸ®ÇU¢×ÉøÓõø›èõ2zº׈Þ`£§ëqè‰ã͇hézÜ zSž®Ç?Do¸Jf=n½åàššõ¸EôÖ=]ÛDo»ÑÓõ¸Cô=]»Dï”ã’%õôt=î½ËFO×ã>Ñ»-×Ï'ðôt=½§FO×ã!Ñ{kòêz<"ß¹sô\À{ Ißq==áåG¸'äï["w¬OÀµìO‰¿”Ð>ôž™Ý±'‰ýß3xNüå‰ëGâ-3ô^Åâz÷Dzz/‰¿ Ž»–ØóV z¯ˆ¿ZîرÄþïA¼&þš8îkúHüý×»?‰ø[½OÄß&sþ©žÜÈ.Ðßî¸Þ{¾âoô‚Ã|Ù÷(—Ìæ¼CôÎ+fÎç°DïšÑÓó4Ñ»oôôü Oô^==¯"½8_Š™ó%"Ñ‹ÏÍkbOOσHD/N<Ÿ?]ßÈD/Y<Ÿ?]·(D/­ÑÓõˆJô²«eÖ#Ñ+à¸ÌQ½¬ºщ^)ÇŠèéézÄ zUзY˜D¯žñ§ë‹è57zº±‰^£§ë‡èõ0zºq‰Þ@£§ëè2zºñ‰ÞäxÞû(}Íz$ zs 7Þ¬GB¢· \_³‰ˆÞZ£§ë‘˜èmu\Ï°žž®G¢·ßèéz$%z'Œ?]dDï¢ÑÓõ!z7Íã§ëJô=]äDï?p‹Ìz|EôÂÄ÷¸Mf=R½hŽ‹ÕÓÓõHIôÄ÷þ^n2ë‘Šè}å¸ìÐÓõHMô2ºiˆ^®ø¾¼ºi‰ž\§+6™õHGôÊÅ÷Þ'[dÖ#=Ñ«aüézdóåß·FŽ[‘ØÿýøŒ¤okÇÕ‰$¼ü—)Ì—ß:»cg>ëÍLüõ?á;C/ ñ7Ô Nêÿþ~VâoœãZDò¼ …Þ×ÄßtwìD€^6âoãŽ'õ¼M‡^vâo¥yüôùPâo#òŠ¿•ÐËIüítÇvÇô×ËEü6ßNèå&þθca’úþ‡ø»j¿3ÐËKüÝuÇ6|×#ñ÷ÜqgñøÝ…^~âï½yüôùPâ/Bßù÷z‰¿X |çŸê"þ’8î<üIp…IßÔ ¼Çy¨9¬à¦›ó¹(ÑËgôô<-FôJ==ÿŠ½JŽ[ÆÓÒóªÑ«ã¸ÃQ=-=_J½¦ÆŸž¥ˆ^»Þ|L7ë[šèu3zºneˆ^£§ëQ–è€ÞJ³åˆÞDÇ5ŽèeÕõ(Oôf9îvXOO×£Ñ[‚¾;ÍzT$zkŒ?]JDo³ÑÓõ¨Lôö=]*Dï˜ÑÓõ¨Jô.=]jDï†ÑÓõ¨Nô‚;cÖ£Ñ{ î®YšDOnZ6©§§ëQ‹èEqÜÔDžž®Gm¢Ïq[czzºuˆ^hBŸ?]ºD/}B_^]zD/‡ô õôt=ê½BŽÛÑÓÒõh@ôʘ¼º ‰^µ„ÞïÉ÷f=½ŽK×ÓÒõhLôZ"ï{³Mˆ^'p¢§ëñ Ñëeôt=š½ÁFO×£Ñcôt=š½©FOףћgôt=Z½å ½¿¢§ëÑŠü}[ï¸%Ÿ·&}·;.¯û=$¼ü÷-ùûvÐ;p Zâïrzm‰¿Ëîز€ï.µ#þn;®MÏÛeèµ'þžª×ø{ë¸*q=oO¡×‘ø —Èçïÿ×úr½¶¼-þ¤F¸ïˆ¿DîØÀk:)ù¿DÐûžøËìŽ- ¸V  ñ—zâ/3ôºÅܱg¡×úw"ÔóW z݉¿ZæñÓçC=ˆ¿&Ž–ÔóW z=‰¿6ÆŸêõ"þº˜Ç¯ ôz“¾}Á]6ç}¢7 ÜSs>ÿ@ôÆ==Oû½™FOÏ¿~Do‘ÑÓóª?ÑûÕ{œÔÓÒóeÑÛäŽ- ñôô<Hôvc}ŸšõDôŽ=]·ÁDï\"ïþ¼OÍz !z×W²êz %z÷ÁIV]‰ÞËDÞï ÑÓõFô>=]áD/’{­;¼§§ë1‚èÅIì­‡èézŒ$zÉûòêzŒ"ziûüézŒ&zÙŒž®Ç¢WÀèézŒ%z¥Àe6ë1ŽèUW̬ÇOD¯žÑÓõOôš=] D¯ƒã:„õôt=&½FO×cÑhüézL&z£Œž®Ç¢7Ùqâ{ZºS‰Þ£§ë1è-Kìý®eÖc:Ñ[ ½6f=f½­‰½{íÖ2ë1“èíw\®hžž®ÇÏDïDbïºÆZf=f½‹ÆŸ®Çl¢w\-³sˆÞc£§ë1—èý—Øû;SˬÇ<¢&‰OO×c>ùû-‰wo {ÛÒ7ô„—á’¿o_¹cÕCýõ¡'üWÐ[LüårÇÞ\C¿„ø+’Ä»ºx˽¥Ä_9w,a\½eÄ_ ã¯ô~!þ¹c©“û_‡·œøkm¿FÐ[AüuvÇ2|`%ñ×Çøë ½UÄßPw,Uò€ëÿˆ¿qÆßPè­&þ¦»c5BýõÖ Œ¿éÐûø[iüéó¡µÄßFão%ôÖ;ݱŠaýõÖ‡¿ÐÛ@úžqÇ^…z甞÷‰ÞUw,]Xï\Ñóùw¢w}s™ótÑ{®œ9ÿþ zïžžW›‰^÷;#AxOKÏ—-D/VRŸžž[‰^’¤Þç åÌún#z©ž®Ûv¢—5©/¯®Ç¢—ÏqC½¬º;‰^ èu6뱋èU×ȬÇn¢WÇèézì!zMž®Ç^¢×Îqyãzzºûˆ^7£§ë±Ÿèõw\šPOK×ãÑaôt=½‰&¯®Ç!¢7 ÜP³‡‰ÞÇÕ õ¼éz!zkŒž®ÇQ¢·Üt³½½FO×ãÑ;†õ˜nÖã8Ñ»`ôt=N½Ž»…µÐõ8Iô=]SDïµÉ«ëqšèÉf_òûj¥Y3D/J2Oo§Y³D/^2ïïêJ³çˆ^¨ÑÓõ8OôÒƒ[iÖãÑËá¸Ja==]¿ˆ^!£§ëq‘è•1þt=.½jFO×ã2Ñk`ô䧘û÷+aÈýÿÁÉ÷脹J˜Ž`–ù›0=Àls0Àœs0#ÀÜsƒ0ÀÈ÷È„ù‡03ÁÄs“0 Áds‹0+Ás›0ÀTs‡0ÛÁts—0À s0'ÀLsŸ0Yæan€Ùæ!a€¹æa^‚yæ1a>€‘ïûó„0B<&!˜§„‰ &˜g„I¦˜ç„I¦˜„ɦ3˜—„É f(˜W„)f:®å|Æ»ç¾eä»Øõbù'ä_ÂUu\ì˜þßÍøpõ7*`ïÏ7„ká¸äÑý¿«ð–p×?šÿwÞ®§ã¦Eö¿öò=á9nLRÿk ?n´äHê-âGÂMqÜìèþ×~"œìÇ92iÀµya¿ä~qÜúÿk‚ ·Î1k¾Ï†pÛS9²ÿgþa wÀq ¾ÏŽp²¿ç‡hþŸ‡'Ü%Ç%‹àÿYBÂÝrܤ(þïéG$ÜÇØ?"ád¿·õ‘üßãŽL¸°îyÀ¨€ý#¢.z¨·÷§}Í•p §9¢.…ãþ ñ p™ §9b.·ãÄóM3ì—{ úü?û¬X„+o8½<6ájN¯íŽC¸Æ†Ók¶ãî[pö»2ñ÷½á´o|Âý`8훀p?‚³ßáHH¸Ÿ §z‰7œýÎ@bÂ-g¯ÙNB¸U†ÓkÆ’îwÃýÿÚ<Âí2œ^ãB¸#àìµµ¡„;k8훜pNû~E¸{àì5Ÿ)÷Âpª—’pÀÙk S."öu´×x¥&\lÃégÌi—ÔpúÙqZÂ¥1œ~&œŽp_ƒ³×â¤'\~Ãiß „+i8훑p•ÁÙkD2®®áT/3áš³×$d!\{pö3ᬄën8}Oúk 0œ¾×œp# §ï!g'Ü$pö³»„›m8훓pK §}sî7pö3¥Ü„Ûb8ÕËC¸}àìgy wœ}9áþ2œ¾†ÍO¸ §¯M î‘áô5gAÂý ξ×WˆpÁ_ù8í[˜pQ §}‹.>8ûTQÂ%7œê#\pö=âa¿|o8çWÞw‡í~O%Wø+ï;¼vÏÙ’a¿|­P}åþV”"L50?ƒ)M˜ú`ö€)C˜æ`ƒ)K˜ö`^)G˜n`Vƒ)O˜~`Òá5} ót*æ'0õ¡S‰0ÓÁü Ê„™æ˜*„Y&;zU%Ì:0-ÀT#ÌV0çÑ«:aö‰ „9¦ ˜š„9¦#˜Z„¹æ:üÔ&Ì=0q¡S‡0ÏÁ”S—0ïÀôS0áRxÌø©O˜è`B Ó€0 ÀTÓ0ÉÁÈý§ºÊ޸#{´íÂL7&\Çýâ1÷À5!\!£{ú|C¸2Ž»ÌãòƒkJ¸jF¯¸f„k \rÏ›æhN¸–лgr´ \'ÃiŽ–„ëe8ÍÑŠpƒ §9Zn 8é©9¾%ÜTÃiŽ6„›g8ÍÑ–pËW*Äc4G;­wܸ‰„+å¸B•—ÁäØO¸J†ÓWÇpšã ášNs"\;ÇŒèqšã0áº9.a"¯§æ8B¸þè[Ýä8J¸†ÓnbïõKu“ãáf9neÓÇ ·}{›'·Æpšã$á6;î—D§9Nn¯ÑÓ§ wÌpšã á.8.f"Ñg wzóMŽs„{h8Íqžp¯ §9..(­{ž“Ðã䧘ûÿÿ ûå{uQÒzzò²F˜‹„‰ ¦˜K„I¦˜Ë„If2˜+„É f3˜«„É æ˜¿ S Ì 0×SŒì)ÌuÂÔ æa‚)æ´S ÌMÂtÓÌ-ÂôÓ Ìm 3ÌÂŒ³Ì]ÂLsÌ=ÂÌsÌ}Â,ó̬#÷Èæ!a6è¹ æa¶ƒÉæ1a€©æ aN€iæ)aþÓÌ3ÂÜ#ßÕèþù<ì—Ÿƒ=s6|Pм‡÷‚p¯ÀqÌ p/ ÷Éè¥Á{s¯9O/)¸×„‹›Î§WÜ¿„ 1z%ÁýG¸tF¯;¸7„ËnôÚƒ{K¸‚à>˜¼ïWÜ “÷=áª=ÍûpõžæýH¸FOó~"\G£§yƒÂ}Éõ'YÕ_0ᓬê/ áF=õ–pSŒžú G¸¹à*½ð„û\I£pëÀµ2û•G$Ü6p 3\$Â0zºxdÂ4z+ÀE!Ü%£§û†G%Ü-£w\4Â=1zº¿xt½1zï ƒpaÓ{ÜX“7&ᢃbòÆ"\B£§yc.…ÑÓ¼q—ÉèiÞ¸„Ëmô4o<·Áø‹O¸òàV WÓè©¿„„klôÔ_"Â} îŠÑKL¸ïÁ6zI÷8»ŸzRÂýNö› .á~2zºßqáf½‚àB ·Ðèé¾ÈÉ ·Êèµ÷á~7zºr Âí2z£Á¥$ÜpvßðT„; N;Í›šp=Í›†p÷ŒžæMK¸FOó¦#Ü£§yÓ.b³û†g \lp¿Œ„KjôÔ_&Â¥1zê/3á¾g÷ùÎB¸üàZ½¬„+ Îîý5á*ƒ“ý´êþµ„«kôt?×ì„kfôŽèþµ„koôþ¿-ẽàrn€ÑÓýasn¤ÑK .á&³û"ç%Ülp MÞ|„[jô4o~Âýfô4oÂm1zš· áö=Í[ˆpÇÁÙ}‘ î/pGŒ¿"„ûÇè©¿¢„{dôÔ_1Âý Îîc\œpÁ=î…Ñ+A¸¨àì~¸% œìœ\)Â%7zÿß¿–pŒ^Cpe—Óèé¾–e WØè WŽpežîYžpÕÞ pלÝ÷µ"áZËiòV"ÜwFOóV&\o£§y«nˆÑÓ¼U 7ÖèiÞj„›ÎîûZpóÁ54þjn…ÑS5 ·Áè©¿Z„ÛÎîÓZ›p‡À 1zuwœÝƒ§.á®N÷ ¨G¸;†Ó=êî™áôÞþ ÷œÝS¥!áÂgòqÚ·ábNû6&\bpv¯&„Ke8Õû†pYÀÙ½%š./8{Ïþf„+n8½·psÂU4œÞ3¸ájNïÜ’p߀³÷`oE¸¶†Ó¾­ ×ÕpÚ÷[Âõgï Þ†pà §zm 7œ½u;Âý ÎÞã·=áNïEØp« §÷ìH¸? §÷ìD¸=àì=[¿#ÜŸ†Ó¾ wÞpÚ÷{Â]gï%Ú…p §z] ÷JçÒpÝ÷ œ½'`wÂEÎìãôÞE=×pzO¢ž„ 1œÞk¨áÒ³÷xëM¸ì†Ó¾}WÐpÚ÷•gï=Ö—pU §zýWœ½×Uµgï!4€p §÷:H¸ž†Ó{ "Ü Ãé½"n48{O˜!„›b8í;”ps §}$Ü/àì½J†náTo8ᶳ÷ÆA¸àäûàò]oáFî¤áêƒE¸K†kn4án®#¸1„{®ªé;–po §}Ç.l§}"\tpõÞxÂ%4œêM \ p- 7‘p™ÀÉ÷Ú›D¸Ü† n2áŠn ¸)„+o¸¹à¦®&¸A¦ï4Â56œöN¸o §}gî{p£ÞLÂý`8Õû™p?‚›b¸Y„û œ|?¸Ù„›a¸màæn¡á€›K¸U†; ná~·ÎôO¸]†Ó¾ wÄpÚw!á΂ÛfôîoéÞbÂÝwÀpK÷œÜgล„û`¸'à–.bV÷Ü/„‹m8ù„pË —Ü-ÓwáÒNû®$Ü׆Ӿ«—Ü£÷+áJNõV®2¸7†[C¸ºàä~ ÁýF¸f†Kn-áÚ.¸u„ën¸ÜàÖn¸„¦ïÂ4œöÝH¸I†Ó¾¿n6¸Foá–Nõþ Üoà2+´Ùq9¸-àô~-z_Ý#zK¸/?—?ˆšD`¶æ$˜\îg§ûÙæ˜ÄÌE0 ò]#³èÝÛz;ˆÞc=÷Ý?[ù®§ÙIôÞ€½]D/Ì×#ì¨ ßµ7»‰^t°K ·‡è%#ìš ßu:{‰^ °{¡·èe#¬<~Ç ·Ÿèå{ÌÂó=’žeÁûZþ×¥"z5ÀF öô½†`„ì»VèÑk 6=ôŽ½ïÀ›#Øw]ÑŸD¯Ø2Ð;Fô†€VÎ)½é8ѶôN½i`ÆáñÓë•N½`;9E˜`£çiÒs=aÇû®m:Côv€½³Dï aeŸv½êÑ; v;ôνË`„•9Ók¦.½;`OAï/¢÷ÌœSz}ÕE¢÷ìmè]"zá²yÌ;<~z-Öe¢ì[0W“Œì¡'=¯’ž)À+{»éu[½Ì`3CïÑË­L6ïw^ãuè[ z7ˆ^ye²ys¦×ƒýCôj­½›D¯±2Ù¼sJ¯»EôÚ€m½ÛDï{eðøéufwˆ^_°}ÁÜuLÅæÇlÞ=æäþò¿{Ž©ÀŒËæí›:Ðý÷ýpÞßR{|ªôIâi+܃pÞïnËÍsÇÂ:Nx¹/µüŽ}H2.‡o¹ç©ÜgSîùü#Âo/÷Í’{5É}„äž*Â?&ünðr¿ù.¿|ý;ðO ¼|·N¾Ï%ß5ú üSö÷¼\;-×ëÊu¦/À?#ümð’U®u’¬ïÁ?'üsð’U®‘¬ríŽð/ÿ¼d•ÏÖ%kJð/ %»ÇKVùLR²æÿŠýý/Yå³ÉZük§Ìî[_ÉyܬￄϚݷ¾’3¶Yßÿ_ »o}%gM³¾o_&»o}%ç³¾o _#»o}%çy¬¯œ÷ïß¼|þ"Ï…{O¸6àäóƒà>® 8yÿ{ ¸„ë NÞ¿]îá†{Á…ÿ’NÞ§|.˜p3ÁÉûlòI¸0„[NÞ'J.,á~5Kpá·Éøk.<ávƒ“÷Mƒ‹@¸£àäuÿ‰ 7 \ÞðÞ9(\ÂMW<¼w.—”psÀU ï[d„[®¶y\B·Ü7Æ_(ᶂëÞ;…KN¸ýàú…÷_î¸áf=Rî¢Î‘y\Rî&¸Ÿ?Y›/¾ÿë¸Ìîù×ïá½ûè —:ü—ϯþƒžÞ?§˜û÷4á¿|^&§Ç /ZiIϨ`ä:û#ÐJG´âƒûÌ»ßUéIÎP0ÒWþÎKÍßø®B’#cN_Ž{è‘ôÎNxÑÊDrvǺÄò}?B´2­²Ð*ŒYHŽj`r!‡ÔDÄ5êYIŽF&‡Ü_EzMz·×9²‘ß™õH ­ìD«7¸ï#É1Lk䚯‘#'É1ÎäÈÞ¹HïéàÆ!Gn’c¾ÉQZyˆÖ pó‘#/ɱÌt䚺ȑäØir4Cïü¤÷ap;‘£Éq:§·§”~E´ ­+Ð:…HŽÛ`#‡Ô @ŽÂ$Çsðz)é]„ô~î9r%9Âçò˜f΋­˜à>óÁÞïüÀ‰À¼G©‰%HŽÔ¹|9tÎK’ÞYÁ /Z¥HŽ¼&‡Îyi¢U\^ä(CrT#}%‡ÔLBŽ²$G“Cç¼éÝ\ä(Or´59tÎ+­®àÚ"GE’£/˜¦È!5³‘£É1ÂäÐ9¯LzO79ª?›:çU‰Öbp?#G5öüÌD䚥ÈQäØlrèœ× ½÷‚ÛŒ5IŽ?MóZDë<¸?‘£6{þf/rHÍoÈQ‡äx^ï¿&½ë’Þ¯Á=DŽz$Ç'0rNéœ×'Z‘s{Ü'ähÀžÿƒyR³9’¡îøê¾ûÃIïF¤wzè /ZIŽì¹}9tΛ­‚à>óÁÞsÅ/žÿƒ‘¾’Cjö!GS’£Znßzèœ7#½€«†ÍIŽ&‡Îy ¢Õ\ ähÉžÿƒi€Rs9Z‘ƒMóÖ¤÷pƒ‘ã[’cŠÉ¡sÞ†hÍ79Ú²çÿ`Æ ‡Ôü…íHŽõ&‡Îy{Ò{;¸õÈÑä8`rèœw$Z'Á@ŽNìù?˜íÈ!5ÿ Çw$ÇmðùÍœw&½Ÿ‚»ß“oÀ”4sÞ…h…Íãqo£+É ÌSäšGÈÑäH”Ç—Cç¼;éœð¢ÕƒäȔǗCç¼'ÑÊ î3ïrô"9Š€‘¾’CjþEŽÞ$G“Cç¼é] \äøähìŽ}ŒãåÐ9ïK´¾…VcäèGrtS 9¤&XïÿGrôuÇ+ÇôÝRz ½‡A·/r $9~2ë¡s>ˆhÍ÷r &9€†RUïÿGrüjÖCç|(é½ Ü¯Èñ#ɱËäÐ9F´Ž€Û…ÃIŽ3`6!‡ÔÄ×ûÿ‘×À73s>’ô¾îrŒ"9^€ioæ|4ÑúîrŒ!9"äõ˜ûÈ!5Éõþ$Gœ¼¾:çãHïdà„­ŸHŽ4îØ/½:çã‰Ö×Ð^rL 9ò‘¾’Cj2 ÇD’£”É¡s>‰ô®®rL&9êºcÃCç| Ñj­ºÈ1•äh¦ rHMNä˜Frô09tΧ“ÞÁõ@Ž$Çȼ¾óJç|&Ñšn$rüLrÌ39¤¦0rÌ"9–¹ã5býÿþ±Ò{6齺ËcɱÅäÐ9ŸK´öÛ‚óHŽc`Ö"‡Ô”EŽù$ÇEðz[é½€ô¾ î"r,$9‘ïó7„Ö"¢õ/¸Gȱ˜äÊç1ÒW>?“šïc É-Ÿ/Goô^Jz''¼h-#9’»c²Ï²Þ‡A´~!Z %¼äXNrä#}%‡ÔLCŽ$Gw|]|ßý¥÷JÒ»t‹ Ç*’£z>ßz¬€Ö¯D«¡>vȱšäh ¦rHÍäXCrt6ëq½#½û€ëŒkIŽ!&Çih­#ZcÁ AŽõ$ÇT0}Cjî Ç’cÉñ ½7’Þ+Á-@ŽßIŽ &Ç;hm"Z;Àm@Ž?HŽƒ`V"‡ÔÄĽ6“gÀ÷6s¾…ô¾ î rl%9îèãlæ|Ñzîrl'9Þ‚¹ŠR“9vòûrèœï$½c^´v‘‰óûrèœï&Z©À}æ]Ž=$Gf0ÒWrHM*äØKrä39tÎ÷‘Þ%ÀåCŽý$GE“CçüѪ ®"r$9š€)R“9‘íLóäw7píãÉÑ/¿÷{wˆ™ó£Dk8´ú!ÇŸ$Çx0ÝCjò"Ç1’c–É¡s~œô^nrœ 9Vç÷îí5ÄÌùI¢õ´V#Ç)’c7˜%È!5Å‘ã4Éq ü|3çgHï àŽ!ÇY’ã:˜fÎÏ­à®#Çy’ã%˜ È!5‘ãÉTÀ=ߌê»»ôþ‹ôŽRÀÓ^´.’q ørèœ_"Z!à>órÍ"É‘Œô•RS9®9 øÖCçü*é]\äø›ä(-ÇÂx9tί­ªÐ*×IŽz` !‡Ô|ƒ7HŽ–îø„¨¾ûßKïHïNÐm‰7IŽž¼k¹V˜9¿E´A«'rÜ&9Fé„RÓ9îSÍzèœß%½ç›Š÷HŽ_Ìy¥s~Ÿh­÷ r< 9¶‚™‡RÓ9’Ýñ1|ûHïG¤÷)èDŽÇ$Ç%0§Íœ?!Z·À]BŽ§$Çc0§Cjú!Ç3’ã-øCfΟ“Þá zÜ[äxArD/èË¡sþ’h%÷™—ëIŽ¯ÀH_É!5Ñã5É‘¹ /‡Îù¿¤wp‹Ö$GQ“Cçü Ñ*®(r¼%9j€ÉƒR39Þ‘MLó÷¤wpMãÉñ}Aïïùi3ç‰ÖÐú9>‘CÁ´A©ù9D00Çxw|[ßþÒ;8¹ÿ'tÇ#G˜_æXhÖCç<,ÑZn!r„‹@®ÿ39¤f1r„'9v»ã¯“øö×ÞHï£ÐÝIŽ³`Þ™9D´þw9"“wÁE©YQHŽ—àŸ™9Jz÷9¢‘ ùrèœG'Z±Á}æ]Ž$G0‘Cjþ@Ž˜$GÚB¾:ç±Hïlà„­Ø$G~“Cç<Ñ* .?rÄ%9*‘¾’Cjö G<’£žÉ¡sŸôn®r$ 9Ú›:ç ‰Vwpí‘#ÉÑLsäš?õƒ$Ç(“Cç< é=Ü(äHJrÌ.äÝ'õ™ódDk)´f#GɱÌdäšóÈJrl¯ûÏHïä¤÷~p[‘ã+’ã8¹oàh¥ Z;Ž)IŽ`¤¯\—.5Ÿ#ÉñØäý?¤wjÒû?p‘# É\8(hhrßýE+-ÑŠZØÓ^r¤#9âù9¤&Þcäøª°/GvôÎ@zg'¼he$9rö­GAhe"Z…ÁåDŽÌ$G0ÒWrHMU½Ç ÉQÃä¨ÞYIïFàj Ç×$G+“£´²­ïÀµBŽì$G/0Cjz"G’c¨É1½s’ÞãÀ EŽ\$Ç4“c4´r­ùà¦!G’c9˜qÈ!5s‘#/ɱ¼îÏ$½ó‘Þ;ÁmDŽü$Ç!02:çˆÖip‡£ ÉqÌNäš_£Éq×äÐ9/Lz?w9ŠïLó¢D+|{‡ÅHŽ`ž#‡Ô¬CŽâ$G’"¾:ç%HïÔà„­’$G–"¾:祈V^pŸy—£4ÉQ Œô•R³ 9Ê•Ló²¤wp•£ÉñÉ¡s^žhµ÷ rT 9º€©ƒRs9*’ýMóJ¤÷pý‘£2É1ÁäÐ9¯B´~79ª’‹ÀŒ@©9‰ÕHŽ5à³›9¯Nzo·9j{À4s^“hý nrÔ"9ÎÙŒRs 9j“7Ló:¤÷Cp7£.ÉñÊäÐ9¯G´>{…õIŽHE=æ!rHÍ-äh@rÄ+êË¡sÞô'¼h5"9ÒõåÐ9oL´²ƒûÌ»MHŽ`¤¯äš'Èñ ÉQÆäÐ9oJzWW9š‘õMóæD«¸úÈÑ‚äè¦rHÍähIrô29tÎ[‘ÞƒÁõBŽÖ$Çh“Cçü[¢5ÜhähCrÌ39¤&,îÛ–äX®™óv¤÷zpË‘£=ɱ L 3çˆÖpÛ£#ÉqÌzäšèÈщä¸lrèœGzßw9:“Oܱ²q½:çß­7Ðz‚]HŽ0Å<æ6rHMBäèJrÄ(æË¡sÞôNNxÑêNr¤(æË¡sÞƒhe‚–ð’£'É‘ Œô•R“9z‘ÅLóÞ¤wpÅ£ÉQ³˜ï¼Ò9ÿh5W9ú’­ÁT@©É„ýHŽ.&‡ÎyÒ»/¸.È1€äøÑäÐ9H´~÷#r "9¦ƒé‹R“9“‹À2s>„ôþÜ"äJrüf´™ó‰Ö.p¿#Ç0’ã0˜_‘CjŠ"Çp’ãœÉ¡s>‚ô¾îrŒ$9î¹c=B½:ç£ˆÖ hÝCŽÑ$Ç{0×CjÊ#Ç’#Rq_ó±¤wp‹Ö8’#iqßzèœÿD´Ò€ûÌ»ãIŽ¬`¤¯äššÈ1ä(`rèœO$½K+€“HŽÊ&‡Îùd¢U\eä˜Br4S 9¤¦1rL%9:˜:çÓHïà: Çt’c€É¡s>ƒh79f’Áô@©ù9~&9æ€×ýa¥÷,Ò{¸9È1›äø ŒìOð´æ­-à~CŽ¹$Ç^0ÒWî÷ 5?!Ç<’ã„É1½ç“ÞÁ@Ž$Ç?îX‡¸¾}%Dk!Ñz­cÉñÌEäšß‘c1ɦ„/Ç.ô^BzG'¼h-%9â—ð­Çh-#ZÉÁ}æ]Ž_HŽô`¤¯äš¿uÿ_’#—Éq½WÞEÀåBŽ•$GY“ã´V­êàÊ"ǯ$G0ECj"b¯…Õ$Gk“Cö_•ÞkHïÎàZ#Ço$Go“#)´Ö­!àz#Ç:’c ˜ÎÈ!5_#Çz’c:øfÎ7Þ ÀMGŽ$Ç 0 ÍœÿN´6€[›HŽí` ‡ÔäGŽ?HŽÃ&‡ÎùfÒû ¸Ãȱ…ä¸R»¿÷B3ç[‰Öh]AŽm$ÇS0gCjJ"Çv’ã½É¡s¾ƒôŽPÒãÞ#ÇN’#fIßzèœï"Z‰Á}æ]ŽÝ$GJ0ÒWrHMeäØCrd-éË¡s¾—ôÎNxÑÚGr79tÎ÷­ŠàŠ#Ç’£˜|È!5u‘ã ÉÑÔäÐ9?Dz·×9“]Mó#D«¸®Èq”ä¦rHM3äø“ä˜~—™óc¤÷,p‘ã8ɱÌ3ç'ˆÖjp‹‘ã$ɱ Ì,äšöÈqŠäØkr蜟&½Û‹gHŽó%½9?bæü,Ѻ­óÈqŽä¸ærHMwä8Or¼69tÎ/ÞA¥<î5rüErD.å[ó‹D+.¸Ï¼Ëq‰äHFúJ©€—IŽô¥|9tίÞ9À /ZWIŽ‚îX“¨¾}˜Dëo¢UZ‘ãÉQLäš‘Èqäh`rèœß ½[‚k€ÿÍzèœß$Z=ÁuDŽ[$Ç@0-‘Cj&!Çm’c ø{fÎïÞSÁAŽ»$Ç\w¬TTo-tÎï­_ 59î“kÁLE©™HŽí&‡ÎùCÒû ¸íÈñˆä8 æ…™óÇD븓Èñ„ä¸ æ rHÍRäxJr<59tΟ‘ÞoÁ=EŽç$GØÒ¾õÐ9A´¢—ö´„ÿ|¿@’#˜·È!5¿!Ç+’#ei_óפwfp‹ֿ$GîÒÞœ¿0sþÑ* ­ÜÈñ†ä(FúJ©Ù‚oIŽZ¥½{Ñß3sþŽônÝZÈñžäø¶´ï¼Ò9ÿ@´¾÷-r|$9ú€i‚R³9>‘ÃÀKó ˆ_önrÈwsÌ#tÎí…àf G؈_æX fúؘ9ÏAz×9r’cÁä4sž‹hM79r“óÀ E©9„yHŽ•&‡Îy^Ò{#¸•È‘äØarèœç'Z‡Àí@Ž$Ç)0‘CjN#GA’ãªÉ¡s^ˆô¾ î*r&9ž™:çEˆÖ;pÏ£(É®œÇÜE©¹‚ÅHŽXå|9t΋“ÞIÀ /Z%HŽTå|9tÎK­,à>ó.G)’#é+9¤æŽî1Lr”09tÎËÞ•À•@Ž²$GírÞßœfÎË­o U9Ê“mÀTB©y¦{ “ÝÀW7s^‘ôî®rT"9†ƒihæ¼2Ñšn8rT!9f‚éRóN÷&9–˜:çÕHï5à– Gu’ã“Cç¼ÑÚîä¨Ir³9¤&|t¯w-’ã‚É¡s^›ô¾îrÔ!9˜:çu‰Ö+p£ÉñÌ äš˜ÈQŸäˆRÞ—Cç¼éœð¢Õä)ïË¡sÞˆh¥÷™w9“ÙÀH_É!5‰‘£ ÉQÈäÐ9ÿ†ô.®r4%9ªºcï‚}ûL‹V3¢UZU‘£9ÉÑLäšTÈÑ‚äè¾·™ó–¤w/p£É1Ì3ç­‰Öhpƒã[’c2˜^È!5Y£ É1ÏäÐ9oKz/79Ú‘ëܱ‰½:çí‰Ö6h­CŽ$Ç~0Ë‘Cjò"GG’ã”É¡sÞ‰ô¾ îr|GrÜ29tÎ;­'к…ß“ÿ¹ŒRS9ºá*ørèœw%½c€^´º‘ +øÎ+óîD+¸Ï¼ËуäÈFúJ©©ˆ=IŽ<&‡Îy/Ò»¸<ÈÑ›ä(orèœ÷!Z5Á•GŽHŽF`Š!‡ÔÔFŽ¾$GðóÍœ÷#½»€kƒýIŽÀ¬0s>€hýîäHrŒÓ9¤æäDrÌ49tΓދÀÍDŽ!$Ç*“Cç|(ÑúÜ*äø‘äØ frHM[äFr59t·“ÞçÀEŽ$Çß&‡ÎùH¢uÜßÈ1ŠäxærHMWäMr|49tÎÇÞ‘*zÜGäKrÄ®èË¡s>Žh%÷™w9~"9Rƒ‘¾’Cjú!Çx’#[E_ó ¤wp‹ÖD’£¤É¡s>‰hUW9&“uÀ@©ÝÓœB4›ƒ—ý7…™J˜ö`dO”AÞý;xÿÌÏ®—ðòx‰Þt¢7ì!èÍ z#À,vz·„ÞL¢7 ìièýLôfYíô„½YDo)Ø+ЛMôÖ€ùÃé ¿zsˆÞ°w 7—èí³Çém1ß<¢wì3¬Ù|Â\ó=ž×Áœw=…ž ‰ÞC°²OŒè-"z¯À\wzÂ˾€¢·˜èUòؘÐ[Bô"ƒyàô„Ͻ¥ìù?ØÄÐ[FôBÀ¼rzÂë9õ ÑK6ô–½ì`>9=áõñ[Aô •½<„YI˜Ò`ò¢ç*Ò³ ˜¸1‚‚„ƒÇäWöülqè­fÏÿÁ„8=á—Co Ñë¶"ô~#z=À¤szÂ뜭%zƒÀÖ†Þ:¢7 Lv§'¼žSë‰Þ°ß@oÑ›¦ Ó›b¿Dï°m±f¿f-˜®è¹‰ôܦªë)¼ì•(z½ý`ûAo3Ñ;¦¾Ó^÷l!zÁ‡ÞV¢÷˜N³mDï1Ø ÐÛNôþÓÑé=6çÔ¢¦²Çþ ½D/*˜žNOx}üv½`垣Ý?w“¿ÝÉÁ̉áía$Z{ˆVp‹·½Ä[0£Öd÷#5Òwé[ØëâÎÓw?é[š…Ñ÷é[Íô]æ~Ê¢ïAÒ·aeï»êûMßC¤o+h6Dßäo'Ów«ûi…¾GHßÞ`/š¾GIß!àz£ïŸ¤ïÓ÷„û‚¾ÇHßiîØ÷;ù±é{œôÍiè{‚ô]núÞt?óÑ÷$é»ÁkϽƉéë{ŠôÝÍ è{šô=æ?×3Øéí@ß3¤ïiwl±Hnúž%}¯@ó4úž#}o›¾ñÞô=Oú>sÇN$p¯…Lß ¤ï;h>Cß¿HßpU|}38½wè{‘ôéØdIÜ9oú^"}CSxé{™ôMiúvzR#}¯¾Yªxyš¾WIß¼ÐÌ‚¾“¾ÅLßêN//ú^#}+ºcgÓËô½NúÖ†fEô½Aú6ÓÊiur?µÑ÷Ò·­;6ÒùcúÞ$}»B³-úÞ"}ûš¾ƒÝOWô½Múwdžº¾óLß;¤ïhGß»¤ïLÓwªû™€¾÷HßÅ`×›¾÷IßÕà£ïÒw“é»Üý¬F߇¤ïž*Þ5GMßG¤ïŸÐ܃¾Ißs¦ïv÷ó'ú>!}¯ƒ½eú>%}€»Ž¾ÏHß—`NÅôöp~€¾ÏIßOîØØAAoLߤo䪞æ'ô}IúÆ©êëûÄýHô}Eú†¸c›]ßè±|}_“¾é )¼ôý—ôÍfú†uzéÐ÷?Ò· ئïöü\Aô}Ëžÿ›¾ ^iô}GúÖwÇòÆ Êmú¾'}[@³>ú~ };˜¾™œ^ ôýHúö[ÃôýÄžÿƒë‰¾A‘Èó0EV9÷3}ƒ#}Ùw ØÖ¦o˜H_ö n ú†%}—™¾ÜÏ\ô Gú®«ê]‹ÜÇô Oúnƒæ:ô@úî7};‹úF$}O‚gúF"}/;‰¾‘Iß›¦ïP÷s }£¾OªzßY`úF%}ß@ó úF#}ÃTóõî~¤Fô¢½è`ÇÂu~Žù.€IFîw|¯Ûb­¯À ?н>‰E¼e#û,Èsû®¯xZùoÑŽM´ó¢î9|Æ!>‹Ÿà3.Ѫ®|Æ#>kø¼êúŠ©]Ÿñ‰v3Ô%‰íùL@|¶3>ån¢•hu×>Ÿý|Fp}ŃÔn…ÏÄD{4êJÀgâs²ñY>“­9à&Ãg2âsi€Ï¬®¯xÚðB´7ècŸ¡Äçvã³;|&'ZÁm‡Ï¯ˆÏ“>븾âAjoÂg ¢ý7êúÃgJâó.˜fŽR­çàîÂgjâóñ)çc7×W<<7s”†hG®îÕM„Ï´ÄgÇ<áùÔ9JG´’AKxñ™žøLSÝßç×Wg¹¾âAjuŽ²íÆ¨Û ŸY‰ÏÖƧÎÑ×D«3¸Öð™øìàsë+¤Vç(;ÑŽºcð™ƒøo|êå$Z3Á‡Ï\ÄçŸ{]_ñ µ:G¹‰öo¨»ŸyˆÏÍ`dÍuŽò­½º6ð™øüÓø”u¾àúŠ©Õ9ÊÏþþ£î5| >oŸ:G‰Öcp7á³ñùo€Ï‡®¯xxlæ¨0Ñ_ë‹ÇóY„øŒQÃçSç¨(ÑJNxñYŒøLQÃßgë+¤Vç¨8Ñþu¡ðY‚øÌg|ê•$Z%ÀåƒÏRÄgÅŸñ\_ñ µ:G¥‰v}Ôå€Ï2ÄgsãSç¨,Ñê®9|–#>»øLïúŠ©Õ9*O´‡ ® |V >Ç€©læ¨"Ñš n |V">çŸòør}ŃÔêU&Ú«P×>«ŸO£ªDk'¸ðYø<೚ë+¤Vç¨:Ñ>ºNðYƒø¼f|êÕ$Z÷Á]ƒÏZÄç‹Ÿ-]_ñpßÌQm¢\Ó« ŸuˆÏ(5}>uŽê­xà„ŸõˆÏšþ>{¹¾âAjuŽêíL¨› Ÿ ˆÏ\ƧÎQC¢U\.ølD|– ð9ÆõR«sÔ˜h×FÝrølB|6ÓÝÌÑ7D« ¸&ðÙ”øüÞø_ó\_ñ µ:G͈öÔm‡ÏæÄçÇüÌó©sÔ‚hM„ÖølI|þàs½ë+¤Vç¨Ñþu§à³5ñ¹Ö<ž:Gß­­àÖÂgâs_€Ïƒ®¯xZ£¶Dû4ênÃg;âórMï{{Ý͵'Z·¡u>;ŸO|^v}ÅÃm3G‰öÔ½…ÏNÄg„Z¾ÇSçè;¢ œðâ³3ñ™¸–¿Ï§®¯xZ£ï‰v:Ô¥Œ‹ë‰Ïl`äºVù­®D«¸lðÙø, Fî#/ŸõÄp}ŃÔÊ‹vw¢]uà³ñÙÀø Ÿ=‰VKp à³ñÙ1Àg×WwøæúŠ©- ŸƒˆöqÔí†ÏÁÄçãSÞ‹­!Dë¸ ð9”ø|àóW×Wã×öù”óñ¨ë+¤Vçh$ÑN…ºûð9ŠøÌl|ê&ZyÀe†Ï1ÄgÑŸ×\_ñ µ:Gc‰veÔ}„ÏqÄgãSçè'¢Õ\øO|¶ ðùÒõR«s4h÷D]œx¸æ‘øh|êM"Z£À „ÏÉÄ礟‘\_ñ µ:GSˆö|Ô¥…Ï©ÄçrãSçhÑZn9|N'>·øLæúŠ©Õ9šA´ ®|Î$>Ï€Ù`æèg¢uÜøœE|Þ1>e³¹¾â᪙£ÙDûêªÀçâó£ñ©s4—hEªãqásñ»Ž¿ÏR®¯xZ£ùD;9êšÃçâ3}ŸO£…D+8áÅç"â³`€Ïz®¯xZ£ÅD»<êzÀçⳆñ©s´”h5W>—Ÿ­|vp}ŃÔêýB´»¢n|.'>ûŸ:G+ˆÖ0p}ás%ñùS€Ï®¯xZ£UD{6êæÀç¯Äç0WÌ­&ZkÀ-Ï5ÄçƧ<~“]_ñ µ:G¿í¨[ Ÿk‰ÏƧÎÑ:¢uÜ ø\O|þàs™ë+.š9Ú@´Ÿ¡n?|n$>ߟ:G¿­pu=î-|n">£×õ÷¹ÕõR«sôÑNŠº‹ð¹™øL]×çSçh ÑÊ Nxñ¹•øÌàó„ë+¤VçhÑ.ºÇð¹ø¬b|êí ZõÀUÏÄg³Ÿ7]_ñ µ:G»ˆöw¨ ×XŸ½ÀˆG£=Dk0¸^ð¹—øm|Š¯ÿœOñ µ:Gûˆö Ô%€ÏýÄçãSçèÑZ n|$>7øŒæúŠ©Õ9:D´÷ .#|&>Ÿ:GGˆÖ9pGáó(ñùw€Ï¯\_ñpÎÌÑŸDûêŠÀç1âóµñ©stœhÕó¸×ðy‚øŒ\Ïßg.×÷³‡z¾9:I´¢®|ž">¿ªçó©stšhe'¼ø/ŸÃ|Žs}ŃÔ†Ï+D{ êÃçUâsŽñY>ÿ&ZËÀÍÏkÄço>7º¾âAj§Âçu¢½uÏáóñyÐøìŸÿ­SàÂçMâóR€Ï«®¯xÚåðy‹hßC]’¸V“ø|n|NÏ;Dë½f†Ï»Ägøúþ>#¸¾âAj·Ãç=¢uYáó>ñ™ Œœ›:GˆVZp‹χÄç×Ƨœ©]_ñ µ:GˆvaÔ•€ÏÇÄgãSçè Ѫ® |>%>ëøÌçúŠ©Õ9zF´¿E]ø|N|v„žG£D«´:ÃçKâsH€ÏJ®¯xZ£WD{êÚÁçkâs¦y›º¾âAjuŽÞí-¨ëŸo‰Ï½ŽYŸ:GïˆÖ1hí…Ï÷ÄçùŸÝ\_ñ µ:Gˆö-ÔM„ÏÄçc0¥Í}"Zÿ{ ŸA‘¿ôÜÀçSÖy„ë+þ3sùK혨[Ÿa"é3QŸO£°D+%8áÅg8â3S€ÏY®¯xZ£ðD;?ê6ÃgⳄñ©s‘hUW>#Ÿµ|®q}ŃÔêE&Ú-Pw >£ŸŒO£¨D«¸ðøàs¯ë+¤Vç(:Ñ‹ºðƒøœj|êÅ$ZóÀM…ÏXÄç/>/¸¾âAjuŽbíßQ÷>ãŸ;Át4s—h·>㟧Oyüº¾âAjuŽâí먋’Ðó™€ø¼o|ê%$Z/Á݇ÏDÄ營A®¯xxiæ(1ÑŽÚЫ …Ï$Äg¼†>Ÿ:GI‰V(8á?_ÿI|¦kèï3žë+¤Vç(„hçF]ø %>‹Ÿ:GɉV9pEàó+â³z€Ïô®¯xZ£DûÔ•Ï”ÄgãSç(Ñê® |¦&>ðYÈõR«s”†hD]øLK|N3ÅÌQ:¢5 ÜDøLO|.6>ÅW5×W[º¾âAjuŽ²í+¨ ŸY‰ÏÛƧÎÑ×Dë)¸Ûð™ø|à³—ë+žš9ÊN´#6òê¦Âgâ3V#ŸO£œD+ 8á?_ÿI|¦jäïsŒë+¤Vç(7ÑÎŽºåð™‡ø,`|êå%Z¥À€Ï|ÄgåŸó\_ñ µ:Gù‰vCÔ‚ÏÄgK0?Fñ~D« Ñê®%|">{‚ù|yçk»ë+¤ö|&Ú?¢î-|!>ÇŸ«à³(Ñšn|#>çø¼íúŠ©}ŸÅ‰öjÔ¥Läù,A|n2>ÏÂgI¢µÜ&ø,E| ðÃõR+ß=íÒDû/ÔU€Ï2Äç ãó|–%ZÁÝ€ÏrÄç«Ÿy\_ñ µ á³<ÑÛث럈Ïh}>Óà^Õ‰Vp¾þ“øLÞØßg×Wó€Yeæ¨*Ñ*.|V#>ËŸr>öu}ŃÔêU'ÚuQ7>kŸMO£šD«¸¦ðY‹øìàs¼ë+¤Vç¨6Ñ„º_á³ñ9ÊøÔ9ªK´&ƒŸõˆÏÙ>¹¾âAjuŽêí¨Û Ÿ ˆÏõƧÎQC¢µÜzølD|ð¹ÉõR«sÔ˜hŸEÝ9ølB|^5>uŽ¾!ZwÁ]…ϦÄ糟G]_ñp×ÌQ3¢ý u÷á³9ñ©‰Çœ5sÔ‚hÅ'üçë?‰Ï¤M|>e¯¹¾âAjuŽZí ¨ûŸ­‰ÏƧÎÑ·D«¸ðÙ†ø,àó¥ë+¤Vç¨-Ñ®‰º8‰=ŸíˆÏFƧÎQ{¢Õ\#øì@|~à3’ăÔêu$ÚýP—>;ŸÃŒO£ïˆÖxpÃà³3ñ9#Àg2ˆ©Õ9úžh/E]øìB|®1>uŽº­ÍàÖÀg7âsO€ÏlR«sÔhŸD]øìA|^óÁÌQO¢uÜEøìE|>2>åñ+åñpÓÌQo¢ýuÍá³ñîŸO£ˆV p¾þ“øLø¿ÏzR«sÔh§A]øìO|f5>uŽ­|à²Âç@â³x€ÏR«s4ˆhWEÝ(øL|Ö3>uŽ†­æàêÁçPâ³}€ÏR«sô#Ñîº9ð9Œøl|ê 'ZcÀ †ÏÄ生“ ¤Vçh$Ñ^ˆºµð9Šø\ F<ê&ZÁ­„Ï1ÄçãS|-s€xZ£±DûOÔí‡ÏqÄç9ãSçè'¢u Ü9øO|Þ ð¹Õâáš™£ Dû_Ô]„ωÄgPSŸO£ID+ 8á?_ÿI|Æmêïó„ăÔêM!Ú)P÷>§ŸO£iD+¸Œð9ø,àó¦ăÔêÍ ÚQ&‰çs&ñYËøÔ9ú™h5W >gŸßøüÏâAjuŽfíîúÀçâ³?˜øѼÑšK´F€ëŸóˆÏ `ä>§ro®¯xÚrð9ŸhÏE] ø\@|.sÌË(žÇÂð¹h­…Ö2ø\D|n ðYÄõRÛ>íC¨ëŸKˆÏSæñlŸK‰Öep§àsñy+Àgk×WÇÂç ¢¡™Ç½‡Ï•ÄgÌfþ>ǹ¾âAj‡Âç*¢‚ºÃðù+ñ™¶™Ïçø\M´²þóõŸÄgþŸ]_ñ µÓáó7¢]uWás-ñY La3GëˆVpÕàs=ñÙÂø”óñŒÜ[ÍýR«s´hºçð¹‘øìc|êýN´†‚럛ˆÏ±>ﺾâAjuŽþ Ú?£.BRÏçfâs‘ñ©s´…hý n|n%>ðùÞùR«s´hïC]øÜN|sÌ“(žO£Dë´ŽÁçNâóz€ÏX®¯x¸`æhÑ~‚º¬ð¹›øüÏ<ž:G{ˆV˜æ÷|î%>£6÷÷™ÚõR«s´h'F] øÜO|¦ÓÊÌÑ¢•œðŸ¯ÿ$>sŸ²Îù\_ñ µ:G‡ˆvIÔÕÏÃÄg%ãSçèѪ®|%>¿ ðYÉõR«sô'ÑvðyŒøìa|ê'ZÁõ€ÏÄçÈŸM]_ñ µ:G'‰ö4Ôõ‡ÏSÄç<ãSçè4ÑZn|ž!>×øìæúŠ©Õ9:K´w¡n"|ž#>Ÿ:Gç‰Öp‡áóñy%Àç×W<œ1sôÑ~€º%ðy‘ø| f¬™£KDë#¸—ðy™øŒØÂçS¿Y®¯xøhæè ÑŽºÍðy•ø má=¯kæèo¢•Z¾þ“øÌàsë+¤Vçè:Ñ.Šºcðyƒø,×Â÷xêýC´j€+Ÿ7‰Ï†>÷º¾âAjuŽní¶¨»Ÿ·‰Ï.ƧÎÑ¢Õ\ø¼K|þàó‚ë+¤VçèÑž„º×ðyŸøœe|ê= ZKÀ͂χÄçêŸ]_ñ µ:Gˆö6ÔEIæù|L|î³ÁÌÑ¢uÜ~ø|J|þe|Š¯ ×W5>uŽ^­·àžÂçKâ3lKŸñ\_ñðÖÌÑ+¢u9àó5ñ™¤¥Ï§ÎÑ¿D+58á?_ÿI|f ð™ÞõR«sô†hD]ø|K|–2>uŽÞ­*àJÁç{â³n€ÏB®¯xZ£D»êÀçGⳓñ©sô‰hõ× >ƒ¢|ésP€Ïj®¯xZùïîX0©û ur_ÊrAÞž#†!ìL°òNAÞ~"†%ìb°²gÁä o¯aÃv Ø5îgs·ˆ°á »Åø=äíñ!lÂî+{I{{s‘°'ÁÊž¡ÁÞ¾ÂF"ìe¹f#ØÛSCØÈ„½c³jÁÞ~ÂF!ìsã·¥c?JØ`eÏ…©ÁÞÂF#l¤V+{¬öö§6:aã¶ò­ÛÁ`oï ac6´•ï1»ìí+!lLÂfhåóû4ØÛ3BØX„ÍVö&HÆÛëAØØ„-ÚÊwîä ãíã lÂVhå[· a¼=„KØÚæ1kÆÛAØx„mjüv ãí­0Ðýwü(_îOÔ¬Ý/!Aòþ8á¥oBÒ·?aåžú-ñ»&é;Ò1 ’ùï—˜ô͑蛄ôfúvDߤ¤ïRÇdNî¿_B2Ò÷7h.EßÒw3˜ßзú†’¾û32Ä¿„ä¤ïqhîC߯Hß `Ž£ïôMAúþã˜öÉü÷KHIú>‚æ?蛊ô} æúŽ@ßÔ¤opkµû%¤!}£‚^ú¦%}ã©VkïžúÐ7é›Ü1«’øï—žôÍÍäè›ôÍ&úÎDߌ¤oaÇÌLè¿_B&Ò·,4 £ofÒ·˜²è»}³¾ S)¾ÿ~ YIßVÐlˆ¾_“¾À´Bß•è›ôí혉ý÷KÈNúfoôÍAúŽ3}7 oNÒwšcÂEóß/!é;šÓÐ77黌°Ÿï©¾yHß ŽÉË¿„¼¤ïhn@ß|¤ïA0;Ð÷úæ'}O;¦X,ÿý ¾W y} ’¾·Á\Aßè[ˆô}昫1ý÷K(Lú¾ƒæ3ô-Bú†ûÖcÞ¡ï_è[”ô Öî—PŒôM Nxé[œôM FXé{}K¾YÀÚýJ’¾yÁeAßR¤o10ÂÊ=õ oiÒ·¢cZFõß/¡ é[šÑ·,éÛLmô}‰¾åH߶Ž)ÿ„ò¤oWh¶Eß ¤o_0]Ñ÷úV$}‡;&qˆÿ~ •Hß ÐŽ¾•Ùó0Ð7B®Ý$};fYRÿýª’¾«¡ù?¶ÎÜƲmÃJRɔ̱I*I’„$$! I’Ì É<“L™“9SB’dÊ”9™’©2%Ó'!I’üïí=ŸcÝ?×ûø?ÖùÜçu­÷y^˶[kު»f.Þ´x« ïjXÿy /ïf¸Õx« ï.cí=õ³à}QxÁúÏK¨!¼'áá}Ixÿ„9‰77ÞšÂ{Ö^ÂËÂ{kÓ˜»‚·–ðÞc¬yÀûŠð战×ÒüÿÏK¨-¼÷1Óxó¾*¼Ã܇·0Þ:Â[Ö^B]á-Wo=á}¦Þ'ðÖÞZÍ™·ð6‚«…·¡ð¾ c¬}þ‚½§¢y o§ˆ¹#m쬂÷5áíÅÌNx ï{0ÆþἯ ïH×·Þ&Â; n$Þ¦Âû Œ±öùÁÛLxçGÌžÛbo#¼oï2fÎÇÛ\ýýÆاœ÷MáÝîú¶ÀÛBx‚ÛŽ·¥ðþ cìÎÛJxOGLÛãköUká½ÈÌÓxÛïÍbÆØ··­ð¦nï«*n_µÞÌÌ4Þ¼í…7Œ±ï;oáÍ1ƒRÅΰ¯: ofæÇÛIxŸ„1vºóvÞŠ°Uܾê"¼Õá*âí*¼¯Â»Äy» oç ûê-ám×owáí cìç}[xûÀÖrûª‡ð…냷§ðŽ1öçí%¼S7ì«w„w6ÜT¼½…÷+cÿrÞw…w•ó†}ÕGx7Á­ÂÛWx€1ÖÞ??xû ïfñó_Ëí«þÂ{‚™ðÞ?`ŒÍé¼ï ïe×7ì«Â›ò˜»Œwð¦ƒ1öç,¼Ùa¹}5DxóÂoÞ¡ÂûŒ±Ï8ï0á-î¼a_ Þ²pÅñ¾/¼ÏÁûŠóŽÞšÎöÕÂÛ®&Þ‘ÂûŒ±-w”ðvpÞ°¯F o¸xÇocßqÞ±Â;Âyþ'¼àFà/¼ÓaŒå¼ ï<Øn_MÞ¥póðNÞ50Æ~꼓„w«ó†}5Yx÷ÂmÅ;Ex1v¹ó~$¼§œ7ì«©Â{îÞ…7Yó˜1ö{ç&¼©šÇÿFÞÂí«é›‘™Æ›w†ðæ„1ö¨ó~"¼ùšÇ?ÛÂí«™Â[˜™ùð~*¼OÀûóÎÞò°rÄ_æýLx«Á•Ç;[x_1ÖÞÏÜޣ̼s„·qóø¿±7g/¼s…·3ãý\x;Ãû¬óÎÞÞ®ï@¼_ï`¸Þxç ï(cÛ:ï—Â;ÅyGâ] ¼³à¦àýJx¿„1vœó.ÞÍãŸ57ï$¼‹„w#3Wà],¼ßÃûó.Þ}°½Ü¾Z*¼ÇàöáýZxÏÀ»Ëy— 賂9xGì ûj¹ð¦x3žy ï áMcìÿœw¥ðf}3Ñ7ì«U›Îxó~#¼ÂûŸó®Þ¢ÎöÕá-WïZá}ÆX{?íà]'¼5œ7ì«õÂ[®Þ ÂÛÆØ{w£ð¶ƒèöÕ·ÂÛ®ÞMÂÛÆØÇ÷;á1³ÇÞ°¯6 ïxfÇ»Ex?†1öyçÝ*¼s]ß°¯¶ ïb¸¹x· ï70Æ6tÞï…w³ó†}µCxwÃmÆûƒð„1¶£óîÞ“îyûj—ðžgæI¼»…÷?cßsÞ=Â{k‹øýAFº}µWx3´ˆgoÞ…÷.c':ïOÂ{_‹ø}-Fº}õ³ðbæ}x÷ ïã0Æ~á¼û…·ìH·¯o¸rx ïË0Æ®sÞCÂÛÈyþúEx[À5Â{Xx;Âû£óþ*¼½ZÄŽtûêˆðdf/¼G…÷cwÞcÂ; v’ÛWÇ…wfàðžÞ/`Œµ÷CÞÿ ï²ñŸƒ“ܾ:)¼ë™¹ ïo» ÆØLÎ{Jxr}þú]xÀý„÷´ðþcìÎ{Fx/F̤Ա7쫳›¼e<ó"Þ?„÷vcŸtÞs›¹e¢oØW on8ãÍ{^x€1öçýKx‹ÀÎÌ™÷‚ð–‚+‚÷oá­c¬½?p+¼…·zÄü{{ìœ÷á­ÃÌêx/ ïë0Æ~ä¼ÿ o×wÞËÂÛ ® Þÿ„÷]c¿uÞ+Â;´eüskæ]7Yªë½c™9ï ©®÷~cìÎ{cªë½³[Æ?iÞíx“ ïBfÎÆ{“ð®„1ÖÞ_7xS練ñuïöÕÍ»“™›ð¦Þý0Æ>ä¼·ï Øùn_Ý*¼çàNà½Mxÿ…1ö)çM%¼)[%¼a_Ý.¼éáŒ7ojáÍcìKΛFxó¶Jt û*­ðdf^¼é„·Œ±o8ozá-Û*>¿óݾºCx+3³,Þ ÂûŒ±o;ïÂÛv™ÛW…·9\¼™„·=Œ±ï;ofáíá¼a_eÞp=ðfÞ÷aŒî¼Ù„w‚ó†}•]xgÀMÀ{—ð~cìçÍ!¼K7쫜»n)Þ$áÝcìçÍ%¼{7ì«ÜÂ{n/Þ»…÷7cqÞ<Â{¡UüýÃõn_Ý#¼7´Žg^À›Wxoƒ1ö/ç½Wx3FÌ„;boØW÷ o37ïýÂ{?Œ±öþ¨Á›Ox îwûêá- Wo~á}ÆØœÎû ðV‹˜W“boØW„·63«á}Hx_ƒ1öç-(¼­ZÇïc³Þí«‡…· 3[á-$¼ïÀûŒó>"¼ƒa·»}UXxGà Æû¨ðN†1öç-"¼³œ7ì«Ç„wÜ,¼E…w9Œ±-·˜ðntÞ°¯Š ï¸xÞŸaŒ}ÇyKï1ç ûê á= w oIáýÆØQÎû¤ð¦hÿ9¸Ýí«R›¶M<Óxó–Þ,0Æ~ê¼e„7ìO9â/ó>%¼àòà-+¼Ákï·9ïÓÂ[Æyà-'¼•àÊà}Fx_„1öç-/¼õ"&Çͱ÷4Þ ÂÛŒ™õðVÞ¶0ÆÚûaï³ÂÛ=bÎÜ{/â­$¼ý˜ÙïsÂ; ÆØg·²ðŽwÏsòœ±÷yá7oácl[ç­*¼‹a¸}UMxWÃ-Æû‚ð~cl_ç­.¼»7ì«…÷Ün¼5„÷0ÆŽsÞ—„÷|›øó¸}USx¯0ó<Þ—…÷–¶1cìç­%¼Ú&ú†}õŠðæ€3Þ¼µ…÷^c¿qÞW…·ó†}UGxKÀÂ[WxŸ†1v—óÖÞ*°§Ý¾ª/¼µàªàm ¼ aŒýŸó6Þmãÿ¦ê´ÛW„·3[à}Mx{ÂûŸó6ÞSãæØöÕëÂ;’™ñ6Þ‰0ÆÚû%oSáéžç°¯š ï|¸™xßÞ¯aŒ½×y› ïú¶ñ{PŸvûêMáÝÎÌõx[ï0Æ>î¼-…÷ìE·¯Z ïé°ïñ¶Þ¿Ãs×6~Âàm#¼ÉÛ%¼a_µÞÔpÆ›·ðf‚1¶¡ó¶ÞÜÎöUáÍ—oGá}ÆØŽÎÛIxK9oØW…·"\)¼]„÷cßsÞ®Â[Çyþê&¼Màêà}Kx[Ã;Ñy» o·pÝr&öÕÛÂÛ®ÞÂ;ÆØ/œ·§ðŽmÿ,•yþê%¼S™9ï;ÂûŒ±ëœ··ð.tÞ°¯ÞÞUÌ\ˆ·ð~ cìÎÛWxwºç9ì«~Â{n'ÞþÂ{ÆØßw€ðžsÞ°¯ÞÞËpçðÞ›ÛÇŒ±ö~wÁ;HxÓæΙw°ðf‡3Þ¼C„÷cíýëÎá*¼#&ÞÌx‡ oqfÄ;\xŸ‚1öç}_x+»¾¹ñŽÞšp•ñ~ ¼õaŒíê¼#…·¹óæÇ;Jx;À5Ç;Zx߆1ö#ç#¼œ·Þ±Â;nÞqÂû!Œ±ß:ïxá›Ùí«…wÜ ¼„w Œ±ûw¢ð®uÞ°¯& ïV¸µx' ïcÿpÞ)Â{ØyþúHxOÁÆ;Uxÿ‚1ÖÞo-x?Þ:$¼a_MÞTpÆ›wºðÞ cl6ç!¼IÎöÕ'›. ïLá}Æ؇œ÷Sá- ›Ûí«YÂ[®$ÞÏ„·*Œ±O9ïlá­í¼a_ÍÞÆpµñÎÞ–0ƾ伟 oç ûjžðö†ë‚÷ ácìÎ;_xGGÌ¡±3ì«/…w 3Gã] ¼ŸÂû¶ó~%¼ "fq†ØöÕBá]ÁÌx ïcßwÞÅ»6¿ÛWK„wܼK…÷(Œ±Ó÷ká=ë¼a_-ÞKpgñ.Þ›:ÆŒ±Kœw…ð¦Ø9boØW+…7+37ï*á½ÆØ-Îûðè˜èöÕjá- Wïá- cì/λVx+ELû ±3ì«uÂ[ƒ™•ð®Þº0Æþ弄·l·¯6 o;¸fx¿Þ·`Œµ÷¿ ÞMÂÛÏyþúNx‡ÃõûYxÇÁ›Óy·ï4ç ûj«ðÎ…›†w›ð.‚1öçÝ.¼«7ì«ï…w3Üj¼;„wŒ±Ï8ïÂ{ÈyþÚ)¼'ááÝ%¼Âû Þ«ï_$Ø+°¥rÆïÃb? oïcüÁ§êósÆïŸâù½‚Ï _=gü¾'žÿQðyàëäŒß¯Äó? ¾`§Dþ×à[Àÿ,øðM\þÀï|yø6.à÷ ¾:|7—?ð_Ï=Ÿ!Gøƒ‚oîò·¸†?$øNð}\þÀÿ"øÞðC]þÀüPw}Cþð¿ ~¼{>[\Ãü —¿ã5üQÁχëòþ˜àW¸ýò÷‡?.øMîú¶¸†?!øÝîùìx ÿ?Ávù{\ßüiø©9ã÷»±Ÿ‰ÿ›à/ÁÏοOçO >eç˜_˜3~Ïÿ.ø ð«rÆï ãùÓ‚OêœÈ?~üÁç‡ßäòþ¬à‹Âïtùÿ‡àËÂpùNðU:'žÏ*üŸ‚¯íò»†?/ø&ð'\þÀÿ%øvðç\þÀ_|w}CþÏàÿü@÷|Ž»†¿(øÑ.ÿÔkø?þ²ËøK‚Ÿëö[È¿þ_Á/u×wÜ5üeÁ¯wÏçÔkøÿ¿ÃåÿìþŠàÀ§LŠßWèêçIÂ'»ýzþ$|ú¤øý€<ƒà/ÀgOŠßÇÇó7 >y—˜Ï›¿ÿŽç“ >m—Dþåðëáo|vø‚.àSþ>øâ.ào|aø².àS ¾T—Äóòoƒ¿Eð•\þõ×ð· ¾&|e—?ð· ¾|M—?ð©ߪKâú†ü{áo|7÷|®¿†O-ø~.ÿ¶kø4‚ßÀå|ZÁOrû-äÿ>àg¹ë»þ>½àºçsÛ5ü‚_íòï½†Ï ø­ðÍ“â÷o²ï‘Ÿ„¿Sð?ÁwHŠßwÉó ¾GÄÛû%y>“àÏÁHŠßçÈó™Åå?Iž?á³>Uטáò>«à3ÃOpùŸMðyàg¸üÏ.ø‚]ÏgÈþ.Á—pùÿ¼†Ï!øòðó\þÀç|uø¥.à“_¯kâú†üæ1>—à›»çóÏkøÜ‚ïäò_¾†¿[ð½á׺üÏ#ø¡]û-äO àÇ»ëûç5|^ÁÏpÏçåkø{?ßå×+ð÷ ~üÖ¤ø}²ìïÊYàïü&ø½Iñû[y>ŸàwÃNŠß—Êóþ0ü©¤øý¤<Ÿ_ð§]þ,ð¹áü%ø .à >e·˜¿!W"à|øT¹ù_PðIÝÏgÈÿüÂÏß-‘?÷5|!Á…ÏèòþÁ—…Orù_XðUº%®oÈ_þQÁ×vÏgîkø"‚oâò?p ÿ˜àÛÁçsù_Tð=º%ö[Èÿ|1Át×7÷5|qÁvÏç×ð ~ªË_Øñ=£ß+q{ü¾ÝÿïõÄ·Ÿ|cü~nöODÜÈk¸Å×3g<ÇÞ#¿ï5¯Š.º¿ ‹~ã*ýþ“·‹ÿþ'z¬BÄ_8?{»øï豉Y¥…sôØ ¤Ø9äa~&6⺆;ά’‘ÏÖ˜ó)áüî8β"ÿ¥è±Iqö’äZÌJñV<Ëø•Ñÿ/'®Uëjn[cÞg›vxêdÉÊçŠg–Wþ;®jÄÕ‚­ ؇Û0âšÃVlqǶ¸î°Ï öiÇö¸¡°•Ôù‡O¯ª°Ï öÇ7¶²`;ÖºM}^°­kÝ>…­¢^ÿ;ֺ͇­*ؾ°ÓèÖ¶š`‡;Öº} û‚`?t¬Í\ []ýùïXë¶öEÁ~áX붶†`—ÁÎ¥[{Ø—»Á±Öí lMÁîp¬u;û²`÷;ÖüÀÖì ÇZ·K°¯öOØÅtë [[½þw¬u»)w̾*ØÛº'Xë–¶Ž`3:Öºe‚­+Ø\Žµ¬I°õÔŸÿ°ö¹ vo÷’ú‚}̱vÖ½¤`Ë8Öön¸—4ìsŽµ½î%ÔßÿkÏm¸—¼&؆°›éf×£g²ø³R®e[86ÜG^W¯ÿg½¦À6ì;Žµ^á>ÒT°ƒk½Â}¤™`ÇÀî¦W¸¼¡þüw¬õ ÷‘æ‚ãXãÂ}äMÁ.v¬u ÷‘‚]ãXëî#-ÕßÿaÑ-ÜGZ öGÇZ·pi-Ø#Žµná>ÒF°gk3Ã}¤­zýïXëî#í{óÛ1{’ná>Ò^°ékÝÂ}¤ƒ`ïr¬u ÷‘ŽêûŽµná>ÒI°8Öüá>ÒY°%aíóT쬇ûHÁVpì”\‰ûHWõ÷ÇÚ~ ÷‘n‚­ëX»¾á>ò–`›96µ»tl{Ø+t ¯IÞV¯ÿkݽ¤‡`ßs¬u›ÛS°#kݽ¤—`';6µ»—¼£¾ÿ{kš¸[¸—ôìWŽµ¬¶×zF¿~W°«î#}Ôßÿg½Â}¤¯`w96µ»ôì!Ø ô ÷‘þ‚ýͱÖ+ÜGö‚c­W¸¼'Ø{$XãÂ}d `S;6µ» lØt ÷‘Áêõ¿c­[¸ Q¯ÿkÝÂ}d¨zýïXëî#ÃÔëǦv÷‘áêõ?¬}Αßpy_½þw¬‡p¡^ÿ;ÖöX¸| ^ÿ;Ö®Y¸ŒT¯ÿ›ÉÝGF©×ÿ°…èî#£ÕëÇZ·p£^ÿ;ÖºM«^ÿ;Öº…ûÈ8õúß±™Ü}d¼zý[‚ná>ò¡zýïXó‡×$ÔëÇZ·p/™¨^ÿ;Öº…{É$õúß±™Ü½d²zý[Žná^2E½þw¬u ÷’Ôëÿž Ö²Ú9²ßšª^ÿ;6ÜG>Vßÿs\&w™&Ø`«Ð+ÜG¦ ¶ˆc­W¸ÌliÇZ¯pùD°•k½Â}d¦`_rl&wùT° `íóÇìL†ûÈ,Á¾éXÛãá>ò™zýïXÛ3á>2[½þw¬]‡p™£^ÿ;6ÉÝGæª×ÿ°èî#Ÿ«×ÿŽµná>2O½þw¬u›û…zýïXëî#óÕëÇ&¹ûÈ—êõ?l º…ûÈõúß±63ÜG¾R¯ÿkÝÂ}d¡zýïXëî#‹ÔëÇ&¹ûÈbõú¿WÌv¢[¸,Q¯ÿkÝÂ}d©zýïXó‡×$_«×ÿŽµná^²L½þwl’»—,W¯ÿa{Ñ-ÜKV¨×ÿŽµná^²R½þw¬u ÷’Uêõ¿c-«Ý#ìò|£^ÿ;6 nµàÚÁÝ,¾‡·FpÝáì3;kÁ­\?8{˨æpëÔŸÿpöYÝáÖ n<œ}NçP¸ ‚›·%Yâû 7î—dñ½Â¸oÕù‡³w˜·Ip«áì3#z‰{}Õ÷Yá.ÅܪôøCô¨àz4gÖ91ë¸ ôøSô¨ízXFó¿@ó¢GøËîœÿ%Ümà^¡ÇÑ£+Ì9wÎÿ³Þ…ëJ‹êõ¿ëaÍÿ.=þ=ƺáœ_î©p¯Ñã_Ñã3×#œóËbÖWpŸÑã?Ñc…ëaÍÿ=®ˆ›\pΓ¥ÿþ×’7¤¾¾Ç~×#œóŬãpûé‘<õõ=κ–ÑüÇéqSêë{\Ž+ž3îÎy áNùn<·3=n=Ò½›èÎyJ1+ÜU>êq‹è‘çÝDËh~[gî[E‚ï&z„s~›pgî;ôH%z<õnüçÇ9wÎo³žcÖSôH-zÔp=®fŒ¾ž£GÑ£¼í©pÎÓ ws¸AôH'z´‡±=Îyz1ëm¸öô¸CôèçzXFó¿M ¢Ç×#œó;…{Ü(zd=¦»áœg³>‡›NÌ¢Çb×Ã2šÿszd=Öºáœgî­p“é‘MôØãz„sž]Ìún=î=Nº–Ñü¿Ð#‡èq!zlÏMq‡pÎs ÷ }⹟Ò#Iô¸­O¢G8ç¹Ä¬;á®òQÜ¢GŽ>‰–Ñü¶ÎÜw‹ùú$®G8çy„»0Ü—ô¸GôxÂõç<¯˜õ Üô¸Wô¨âzXFó?CûDÚð•Ý9¿_¸Ã-§G>Ñ£%LYwγ:õ¤G~Ñ£—ëaÍß™Šƒ]pÎ ÷h¸ ôxHô˜ìz„s^PÌún2==æ»–ÑüŸÒ£è±¢OüßSWvçüáÞÈÜïéQXôøÞõçüQ1ëç0‹ED#®‡e4ÿÏôxLô8ë®G8çE…ûÜÏô(&zÜÔ7Ñ#œóâbV¸«|ÔãqÑ#sßDËh~[gî¢Gž¾ñ«QÙó'„»sÒ£¤èñXßøÏó²îœ?)f•fÖcô(%zTt=,£ùKÓ£´èQ#z,mʸC8çe„»sÏÐã)Ñ£)LswÎËŠYmášÒãiÑ£›ëaÍß–åD~ÑcíÓÆ=Â9F¸‡3÷z”=ƹáœW³>†GŠ¢Çl×Ã2šÿcz<+z,îŸóîœWîÕaOßÏzNôøÎõç¼²˜µ î;z¸,ôxIôx¸_¢G8ç5ŬÇá®òQ—E²®‡e4ÿãô¨%zT‰“-úó2eüeîW„»sï¦GmÑ£!Lí”ñ—ÍzUÌz®!=êˆ`ì¿?µŒæ“uE^ðÖa0îzÂ=îAzÔ=>ˆ˜»²Åz3«˜5‘YУ¡è1Ãõ°ŒæŸHF¢Ç|c¸ p¿&ܢû=‹ëúÅï‹f=f1ëu1k³ÖÑ£‰è±×õ°ŒæßF¦¢Ç‘è±2ì©}¸› ÷i斦ǢÇßn_í`Vs1ëÆþ1÷7=Þ=RõOô°Œæ·uæn!zdŽ{™ë‘â–ØÝR¸s3÷Yz´=èŸèq‰­Å¬Gá®òQ6¢GI×Ã2šÿQz´=*Âvç¼pW‡{‘íEWaz»sÞAÌzîUzt=Z¹–Ñü¯Ó£“èÑÍõç¼³p÷«K.¢Ç×#œó®bÖ¸!ôè&zLq=,£ùÇÐã-ÑcvôØšlq‡pλ ÷Bæ6¥ÇÛ¢ÇʈÙ-îÎy1ë[f­¤GOÑc‡ëaÍÿ-=z‰Üõçüá>×–½E?Üõçü]1ë_¸?èÑGôH1 ÑÃ2šÿ_zô=ÒG|«¬qpÎû wvæ¾Eþ¢Ç=â??z»s>@ÌzˆYÆ[÷D¢®‡e4¿­3÷@Ñ£ì€øÏîœîÊÌíKÁ¢ÇK0³Ü9"fÕ‡{‰CEf®‡e4}z =:À/pç|¸p÷€F÷Eþ®G8ç#Ĭ÷áúÓãÑc¼ëaÍÿ>=FŠ3\pÎG ÷<¸qô-z,q=Â9#f­[B±¢Çf×Ã2š =Ɖ{ÄïíºÀóñÂ}˜¹ÓãCÑã7×#œó bÖ_p¿Ñc¢èqÅõ°Œæÿ‹“DTïÅž/pç|²pg|/ž;‡SDœïÅç|–;ç‰Y÷3Ëxë1Uô(ô^¢‡e4¿­3÷Ç¢GIø}îœOîòp‹è1]ô¨ ³ÃóbÖ+pUéñ‰èÑÈõ°Œæ…3EVö¦ˆ{„sþ©pwaî7ô˜%z¼ãz„sþ™˜5îzÌ=Fº–Ñüƒè1Gô˜=V,cÜ#œó¹Â=‹¹ßÑãsÑãK×#œóybÖr¸/éñ…è±Þõ°Œæ_Nù¢Ç·¯Â9ÿR¸÷Áí¢ÇÑã¨ëÎùWbÖ¸£ôX(z\t=,£ùÏÐc‘è‘b`tÍwç|±p§Ï=H%¢G–‰áœ/³î†»ÊÛÏA‰ù&zXFóÛ:s/=ŠÂ[‡pΗ w¸ÿÑc…èñ,Ì%wÎWŠY/Â=KU¢G×Ã2šÿEz|#z4‹”5îÎùjánÇÜ?é±FôxËõç|­˜Õî-z¬=†º–Ñü}é±^ô=v)SÜ#œó Â=¹ÿÑc£è1Çõçü[1kÜzl=V¹–Ñü‹èñè±Ùí«pÎ7 ÷n¸[òð³¢ÇA×#œó­bÖÿÂY£Ç6ÑãœëaÍÿ?zl=®¸áœ/Ü·Š¹;è±Cô¸cP¢G8ç?ˆYw…Yƒâ;E¼ƒ=,£ùm¹w‰…àÏß™{·p—€»‹{D§aNÞÙ¬½bÖópOÓãGÑ£&Œ½”e4ÿóôøIôhäzä¸5vÿ,Ü-àî¥Ç>Ñ£cÄœËwÈÀ¬ýbVOfu¤ÇÑc€ëaÍß“E‘®G9܇„{ÜÃôøEôøÄ]Ì:,f}÷ =~=–º–Ñü_Ðãˆè±Þõhû¨po‡{œÇD]FÌ:.fý ÷#=Nˆ§\Ëhþ_éñ?Ñã¢ë1÷IáN>8枦Ço¢Çíƒ=2딘• î*õø]ôHœèaÍoëÌ}ZôÈog#œó3Â]îyzœ=ž„±³ÎùbV¸'éqNô¨æzXFóW ÇŸ¢G×#œóóÂÝîezü%z´v=Â9¿ fu…kM¿EÞ®‡e4Wz\=†FuÎwçüáË܆ô¸$z|1÷§ˆ;„sþ¯˜õ³>¢ÇeÑcëaÍÿ=þ=V¹ëÎùáÞ÷&=’¥¹¾Çîz„s~Cšëgí‡û7¦¹¾Ç1×Ã2š?=’§¹¾Ç9×#œó›„û2\Gz¤=n’èÎùÍbV:¸«|Ô#¥è‘uH¢‡e4¿­3÷-¢GÞè±-iã=Îù­Â]¹=éq›èQ ¦„;ç©Ä¬§àŠÑãvÑ£’ëaÍÿ=R‹5á˹sžF¸À½G´¢Ç®G8çéĬöpoÐ#½èÑÝõ°ŒæoO;DÑcûo‹{„sžA¸G0÷zÜ)z|èz„sžQÌš÷!=2‰s]ËhþéôÈ,z,œ&îÎyá^Ë܉ôÈ*zlq=Â9Ï&fíÛBì¢Ç!×Ã2š=î=NŸ*îÎyá¾ÀÜOè‘SôH64Ñ#œó$1ë6¸«|Ô#—è‘ah¢‡e4¿­3wnÑ#)zìRÆøZ„s~·pçcîôÈ#z<1Í3Å×"œó{Ĭ'˜õ=òŠå\Ëhþ'èq¯èQ ¾…;ç÷ wm¸¯éq¿èñšëÎy>1«%³^£Ç¢G'×Ã2š¿%=ò‹½ÝõçüAáÌÜuô( zŒŠ˜)âáœ?$fMfÖ(z=fº–Ñü“éñ°è± zìlŠ¸G8ç…„{s·ÑãÑcL#wÎ ‹YßÃm Ç£¢ÇO®‡e4ÿ÷ô("zsû*œóÇ„û,Üô(*züãz„s^L̺iXÌýCâ¢Gêa‰–Ñü¶ÎÜ‹YáGºs^B¸óÀýJ'Daºs^RÌz î*õxRô(åzXFó?FR¢G%×#œóÒÂ]îwz”=ê‹¿§:Ðó§Ä¬¦ÌªK²¢G×Ã2š¿)=ž=º»᜗î~pÓãÑc˜»᜗³ÆÁ £GÑcªëaÍ?ŽE¹ÑcórÆ=Â9V¸3÷Æ{âY•Do"frθG8çωYß1ëzT=vº–ÑüßÑãyÑã»áœWî“p·Ó£ªèñ§»áœW³þƒû“/ˆ)‡'zXFóÿGê¢Gø>·Å_æ~Q¸sÀe¢G Ñã^˜n·Å_6ë%1ëa¸«|Ô£¦èQÆÞÚ2šßÖ™ûeÑ£\ôX¾ôq‡Ù¸k wææ¢Ç+¢ÇËS8{Üa*³j‹Y ™õ2=^=š»–Ñü éQGôè=v"{Üc'îºÂÝ‹¹Уžèñ^ÄM÷ØĬúbÖÌz D ®‡e4ÿôh(zÌŒËÆõ¸Œ»‘pÏgî£ôxMôøÚ]sÌj,f­cÖ×ôx]ôØêzXFó¯£GÑã§è±WoŠ{äM»› ÷æ>If¢Çïî|dgÖbÖßp¿Ó£¹èqÃû‰–ÑüÓãMÑ#uÄÍŸpÎ[wfæV GKÑ#ÌTwÎ[‰YÀ]壭E®‡e4¿­3wÑ£ülwÎÛ wE¸èÑNôxÁõç¼½˜õj˜E¢Gc×Ã2šÿUzt=Ú¸áœwînp¯Ò£³èñnÄ|–#îÎy1k³Þ¥GWÑc´ëaÍ?„ÝD©ÑcïŠ{„sþ–pÏfîëôè.z|õ~|Χºsþ¶˜µ’Y_Ñ£‡è±Ñõ°Œæ_Iž¢ÇÎè±²Ùãáœ÷îÌmMwDãn_…sÞ[Ìúî8=Þ=.¹–ÑüУè‘rDôw¶ôñž 缯p§ÏíJ~¢G6˜Mîœ÷³î»ÊG=ˆF$zXFóÛ:s¿'z{5GÜ#œóÂ]–¹ïÒcèñ܈x_mrç|°˜õ³ž£ÇÑ£žëaÍÿ=†ŠÍáwºs>L¸;À ¡ÇpÑãmw=Â9_Ìê÷6=FˆÃ]Ëhþþôø@ô˜àz„s>R¸gÀ¡Ç(Ñãs×#œóÑbÖ¸Ïé1FôXízXFó/¡ÇXÑc«;áœî½ÌýˆãE_\pÎ?³~ƒû…Dó®‡e4ÿoô˜(zÜðAÌ_vç|’p§‚ûŒ“E;aιs>EÌÊ w•z|$zÜ÷A¢‡e4¿­3÷TÑ£ðñ9¿ìÎùÇÂ]’¹_ÑcšèñŒëÎùt1«*Ü3ô˜!zÔr=,£ù«ÒãÑ£qôXC®G8ç3…»sWÒãSÑ£sÄÔJ÷ç|–˜õ³:Óã3Ñc ëaÍÿ=f‹£Ý¾ ç|ŽpOû–sEOÝõçüs1ëK¸Oé1OôXæzXFóI/D®G8çó…{ÜôøRôøÙõç|˜uîgz|%zœv=,£ùÒc¡èq)z¬[ö¸C8ç‹„;ÅÈxî~z,=ÒÀdO•8çKĬ,pWù¨ÇRÑ#÷ÈDËh~[gî¯EðÖ#œóeÂ]î8=–‹¥GÆŸed=Â9_!f=ˬÒôX)zTw=,£ùŸ¥Ç*Ñ£ÞÈøœ[pοîfÌýƒ«E¶#ã×íÖ#œó5bÖ[ÌjKµ¢G×Ã2šÿ-z¬=†»ëÎùzá÷/=6ˆ»}ÎùF1kÜÇôøVôXèzXFóÏ¡Ç&ÑcµëÎùw½îæ¼ñ¬Í¢Ç.×#œó-bÖA¸]ôØ*zœp=,£ùÒc›èqÞ>Sо̽]¸¯À¥£Ç÷¢Ç-£bÆ>2³vˆYwÀ]å£?ˆÙaìs,£ùm¹wŠ÷Jô(‰{—p‚ËFÝ¢Çã®Gafí³ž†{œ{EÊ®‡e4ÿÓôøQô¨åz4Æý“p7‚»‡?‹oºµ™µOÌê÷&=ö‹=\ËhþŽô8 z t=ã>(Ü#á¢Ç!Ñc¢ëÑ›Y¿ˆYŸÀM¤ÇaÑcžëaÍÿ =~=–¹ pîõpÅèqTôØæzÌbÖ11ëG¸mô8.zv=,£ù¤Ç Ñã4|IwÎÿ'ÜអÇIÑãÆÑ1SØóßĬÛá®òQS¢GÆщ–Ñü¶ÎÜ¿‹¹G'z„s~Z¸óÃ=G3¢Ç£®G8çgŬ'á¥Ç¢Gy×Ã2šÿIzœ=ª»áœÿ)Üuà^¢ÇyÑãu×#œó¿Ä¬Öp¯Óã‚èÑÅõ°ŒæoM¿E>®G8ç…{(\}zü#zŒq=Â9¿$f}7†ÿŠ³\ËhþèqYôXèz„sþŸp¯‚{ƒWDoGÇïW[Øódi¯Ÿõ³¾¥Ç i¯ï±Ïõ°Œæÿ7¦½¾Ç øÆîœ'îspíéqSÚë{ü SÛóbÖÍcbî_zÜ,z¤“èaÍoëÌRôÈ>&Ñ#œó[„;/ÜÛô¸UôxhL¢G8ç·‰YÅà®òQT¢G×Ã2š¿=n=*»ᜧîšpýé‘Fô¨ïz„sžVÌz®>=Ò‰í\Ëhþ7è‘^ôèáz„s~‡p€{ŸD÷]pÎï³> ³è‘Qô˜æzXFóHL¢Ç<×#œó̽îCzd=ÖŒ‰ÏymwγŠY[˜µ†ÙDÝ®‡e4ÿzd=Ãvçü.á>79D¿`z»sžSÌJ66æþ¢G’èqëØDËxÕ?6vç=2ŽMôç<·p'Á}N»EûÇ&z„sžGÌzî*õ¸Gô(ázXFó?B¼¢Gy×#œó{…»ÜzÜ'z¼âz„s~¿˜õÜ+ôÈ'z´p=,£ù_£Ç¢G×#œóüÂÝn ==¹áœ³FÁ ¢ÇC¢Ç$×Ã2š= Š³¢Ç&¦Œ;„sþ°p/`îz=–»áœ?"fm€[N¢Çv×Ã2š==öÁ/p缈pƒÛCÇD30³Ü9/*fýw†ÅDäã=,£ùÿ¡GqÑ#í¸DpÎî¬p¿Ð£„èq÷¸DpΟ³„»ÊG=JŠE\Ëh~[gî'E2®G8祄»Üoô(-z¼èz„s^F̪ ÷"=ž=š¸–ÑüuéQVôhçz„sþ´pw‡û‹åD¾®G8çψYÃàúÒ£¼è1Öõ°ŒæF ¢Ç4×#œóŠÂ=.Ù½ñ¬gEE®G8ç•Ä¬oàÑã9Ñc“ëaÍÿ =*G|«køÝð+ÓÅ_æ~^¸ÁoLÁüæ@ŠÈå«*òƒ±sµ™ö>v¶Î~ýUº8g5‘ó†ññºã.ç "C*8ã©.˜;aÜç|QäÌ1>‘ÓfZN[gÿÖ>=?(r昒ÑsŸ.}"çK"Cæç'gMÁ< ³”œ/‹œå]Î"ä´uöo{ÈYKä¬Áºb.ç+"C=¸ä¬-˜¦0§ÈùªÈÙÆå¬GN[gß~â~>PäìÁºú.g]õú®9ë æ}˜¤”qÎú"çx—s9m}n29ˆœ3#æô]qÆãäl(2ÌgþLr6Ì×0)y>_9×ÂØ~œON[g¹÷sŽ‹œ;Ü9 9_öÁí gÁ…AΦ"çi—s9rŽú³?›‰œ—Ygç(ä|CdHùaÌ]&gsÁ¤ƒYKÎ7Eά&rÚLËiëìýFÎ"ç}Óà¦ø…œ-E†BÌ7Þ˜V‚yæ9[‹œe]ÎBä´uvŽª²?ÛˆœÕÈYßål+2Ôf~5r¶S¯ÿaòqŽÚ«×ÿ.gmrÚ:;G_’³ƒÈÙuvŽìÚ[†Ž"C¸näì$˜!0y>;‹œ£aì:÷!§­³st3×½‹È9-b–¤ŠŸË³«úóŸùÓÈÙM0‹`&ó-‘s•Ë9—œ¶ÎžßÉÙ]äÜÊ:Ër¾-2ì…ÛJ΂ù%0äì)ržt9÷’óÎQ2®{/‘óbÄ$¿3>G!ç;"Cò ñü‹äì-˜Ûan`¾+rfœÈi3-§­³sô9ûˆœy"¦,ç(äì+2`¾ñÆôÌc0…ÉÙ_ä,år §­³s´œDÎʳ8y|ŽŠ‘ó=‘¡&ó+“s `êÃÔäº9›ÁØóW“œ¶ÎÎÑCìÏÁ"g'Öw9‡ˆ ½à:‘s¨`Þƒ™AÎa"ç—³9m£ÏÉ9\äœÂ:»æ!çû"Ã,¸)ä!˜/aö’ó‘s™Ë9‹œ¶ÎöÁ\÷‘"ç&Ös9G‰ ;á6‘s´`öäbŽ9¹œ;ɹŸsÔ™œcEÎó¬«ïrŽ®À'çxÁÜ21fJ’óC‘3ýÄDÎ+ä´uvŽ~&ç‘3)bÖdŽÏQ}rNò1ßxc& æ˜\÷É"g Ëe3-§­³sôûsŠÈYqbüúó¸Ëù‘ÈPùÉ9U0¯ÂÌ#çÇ"gc—³:9m£5äœ&r¶c£sºúû?\;rÎL_˜ÃäüDäêrv'§­³st?×}¦È9ë^ÌåüTd˜Áü äœ%˜Ïa2²??9»œ3Èiël¿"çl‘s=ë껜sD†ípëÉ9W0?”'çç"ça—s;9ä!ç<‘ó,ë²dˆ¿,Ã"Ã%¸³äœ/˜›&ÅL+r~)r¦†±Û´™ö>]¶Î~&CœsÈ™u¥]ίD†¼pƳP0Ád½%ιHä,êrÚLËiëìßœ¾#çb‘³뚺œKD†*påȹT0/ÃT"ç×"g—³ 9m}ïÿá;ãœËDÎVÓ.s9—‹ ]Â5%ç Á¼Óœ+EÎ.grÚ:ûìä\%rŽeÝ"—ó‘a*ÜXr®Ìg0sɹFä\àrN%§­³ï}ýMε"çjÖ]ÍHÎu"Ãf¸Õä\/˜]0£9GDÎ0¶7“sçè1öçF‘ó”;G!ç·"øSäÜ$˜d“c&Ïçw"ç­“9/ÓÖÙ¯’s³È™™uM]Î-"Cn8ãÙ*˜`js›ÈYØå´™–ÓÖÙ9zšë¾]ä,úa.ç÷"C%¸2äÜ!˜aú‘󑳎ËY‰œ¶ÎÎÑ'äÜ)r6˜_nŠÏQȹKdèÀüæäÜ-˜·a“sÈÙÏåì@N[gçèöŒqν"çHÖÙ9jJÎE†Ip#Éù“`>YÁ9úYäœc×y9m£ºìÏ}"ç Ö•v9÷‹ CrÌ÷0x>Šœ?¹œÉiëìùý“œ‡Dάkêrþ"2œƒ;AÎÂù¦99SLIäG!çÿD†òÌ/IΓ‚© ³šœ¿‰œµ\Îòä´uvŽrqŽN‰œMXgçh9ÚÀ5!çiÁt…9Æ9:#rö}£ÇÚÓÖÙ9êËþ<+rg]i—ó‘a|¸¦ä<'˜aŠò|þ)rÎv9Ç“ÓÖÙ9º…ë~^ä\ʺ¦.ç_"ÃZ¸¥ä¼ ˜-0ÍÈù·È¹Ûå\KN[gûàMr^9¸srþ#2œ†;BÎK‚ùf<9ÿ9oø(‘ó49ÿæm#çe‘3-빜ÿ‰ YáŒ7æŠ`î†ÙLÎdé®Ï™ßå´™–ÓÖÙ9z”stCºës˜wÅçh9oLw}†²Ì/NÎä‚y.t!çM"g ËU–œ¶ÎÎÑÎQ ‘³ëJ»œ7‹ -à‘3¥`:”!ç-"g—³9m£»¸î·ŠœƒY×Ôå¼Md 7˜œ©3¦9o9gºœ£Éiëìõ$gj‘s!놹œiD†Up É™V0ßÂL#g:‘s‡Ë¹Šœ¶Îöë¯äL/rrç(ä¼Cd8 wˆœó'ÌnrÞ)r^v9O’óOÎQÎQF‘3ÕÔx]ëŒñ—eÈ$2d„3Þ˜Ì‚É s…œYDÎû`ìßül¦½‘­³_¿Nά"gÖq9³‰ ¥àŠ3»`*À̼5Îy—ÈYÍå,EN[gÿÆrO&~FSä¬Çº•.gN‘¡\=r& ¦-ÌOäÌ%rvs9›‘ÓÖÙ÷°û“3·È9 b^ˆ^7w9ïF09óæC˜Ô·Å9ï9§¹œ#Èiëì{„¿‘3¯È9Ÿœé2%rÞ+2,cþ|rÞ'˜u0¥Èy¿È¹Õå\FN[g߃©š9ΙOäÜ75þ¾…eCÎD†cÌßGÎü‚9s×ýA‘ó"ŒíÇcä<Ã9Â9* r¦ü8^7Æå|HdHg¼1“ f>99ó|œÈi3-§­³_ãº9 ±n¥ËùˆÈP®9 æi˜#ä|Tä¬ìr– §­³sô!9‹ˆœµ?Ž¯ûq—ó1‘¡1ók“³¨`ZÂdf9;¹œÉiëì%c9û°ÎÎQÈù¸È0®9Kf LEr>!rNq9‡’ÓÖÙ9zœ%E鬳s´’œOŠ ‹áæ’³”`¾©Âu/-rn‚±ë¼˜œ¶ÎÎÑWœ£2"ç^wŽBΧD†Ãp{ÉYV0¿Á,#çÓ"çy—ó09ã=Çþ,'r&Ÿ¯[ér>#2¤†3Þ˜ò‚ÉsšœDΤi‰œ6ÓrÚ:ûõçä¬(r˜–8G!ç³"CQæ g%Á”†ÉÍþ|Nä¬èr%§­³st'û³²ÈY“uvŽBÎçE†p5ÉYE0oÀT'gU‘³ËÙ€œ¶ÎÎQgrV9{±ÎÎÑqr¾ 2 „ëEÎê‚ù¦×ýE‘sŒ=ÉiëìíçÕ9g±nŒËù’È°n9k f9Ìzr¾,r®w9ÓÖÙ9ªÏþ¬%rc7Å×<ä|Ed8Àüä¬-˜ã0ÉùªÈyÖå<@Î㜣5ä¬#r^aÝq—³®Èpëô˜»BÎz‚¹&?û³¾È™}z"§Í´œ¶Î~}?û³È™uvŽBΆ"Ca8ãi$˜'`êó5‘³œËY˜œ¶ÎÎÑ r69«³ÎΑeµ ¯‹ uઓ³‰`^‡™Äuo*r¶‚±\uÈië®þŒ$×½™ÈÙuc\Î7D†~pÝÉÙ\0Ã`¶“óM‘s¬ËÙœ¶ÎÎQ{r¶9g°n¥ËÙRd˜7ƒœ­³&9×½µÈ¹ÚåœGN[gçh9ÛˆœÛYwÜål+2üž+r¶̯0EÈÙ^ä<årþDÎ_9GO°?;ˆœ—Ü9 9;Š )fÄÜ%rvL˜&äì,rfž‘Èi3-§­³_O&g‘3/ë6dŽ¿,CW‘¡ œñÆtL1˜¡ä|Kä,cÿþd3í}Vlýz99»‹œUXwÆå|[d¨W…œ=Ó¦xª8gO‘³¹ËY‹œ¶Î¾ßÿV–8g/‘³ ë²dIä|Gdè ×…œ½3¦99ß9Gºœ½Éiëìû©ÉÙGäœÊºÒ.g_‘a6ÜTröÌW0ÈÙ_ä\árÎ&§­³ïW=5Î9@äÜ̺¦.ç{"Ãn¸Íä(˜ƒ0[É9Hä<árî&§­³ï|BÎÁ"çwŽÎsˆÈpÃ'1wœCsÌBÎÑ0‘3ŒíG›i9må>Ê9.ræfÝ—ó}‘!?œñƌ̣0ey>?9KºœùÉiëì×ÃØŸ#EÎJ¬³srŽjÀU"çhÁÔ…é@Î1"g—³9m£?É9VäìÀºÒ.ç8‘¡GÈ@Îñ‚é3ƒœŠœÃ]Îä´uvŽ^fN9'±®©Ë9Qd˜ 7‰œ“óÌ^rN9—ºœ3Éiëì}MÎ)"çFÖÙ9²ko>vÀm$çTÁü s€sô±ÈyÆ®órþÌ9JÃuŸ&ržsç(äœ.2\†;G΂¹yfÌTæùüDäL;3‘ó29m=¿“s¦È™ƒu–1äüTd¸Îxcf æa˜äüLä,îrÚLËiëì×·pÝg‹œåYWÚåœ#2Tƒ+Oι‚yf9?9¹œÕÈiëì½IÎy"gÖ5u9¿ºÁµ!ç|Á¼ s˜œ_Šœƒ]Înä´uvŽ¶‘sÈ9žuWÿÌ$çW"Ã4¸ñä\(˜90)ɹHä\cÏß4rÚ:;G±?‹œkYwÆå\"2l…[KÎ¥‚ÙS“œ_‹œ‡\έäÜÃ9ZDÎe"çiwŽBÎå"ÃE¸Óä\!˜?™ä\)r¦ú4‘ó"9m탻¸î«Dά¬+ír~#2ä3Þ˜Õ‚yf)9׈œE\N›i9mýº'9׊œeY×Ôå\'2T†+KÎõ‚y æ97ˆœõ\ÎÊä´uvŽ~%çF‘³EĬÏŸ£¦äüVdèÄüäÜ$˜ž0ÉùÈ9Æru"§­³sT—ý¹YäMÎ3.ç‘a óG“s«`>…i@Îm"ç|—s 9m£ïȹ]ä\Å:;G!ç÷"Ã&¸UäÜ!˜`Fó‘sŸË¹‰œ?pŽæºï9OºsrîÎÃ$çnÁü³–œ{DΔ³9Ï“ó?ÎÑäÜ+rfd]S—óG‘! Îxc~Ìý0Èù³ÈYÈå´™–ÓÖÙ¯ÿ&ç>‘³ëre‹¿,Ã~‘¡"\)rÌ 0I·Ç9ŠœµaìßBl¦½„­³_gÊç<$r6 ë\Î_D†vpÍÈyX0oÁl$ç¯"g—³9m}ïùr9G°®µËyTd˜7‚œÇ3æ9‹œs]Î ä´uö½½bÙãœ'DÎe¬ãrþOdX·Œœ'³ ¦@ê8ço"ç^—s=9m}ïäCrž9±n¥Ëù»Èpî9O æ˜zä<#r&ÿ,‘ó,9mýÝ4Ù]qγ"gzÖYÆ äüCdÈg¼1çsLy®ûŸ"gÛ6ÓrÚ:Ëý$ûó¼ÈY"ôs9ÿÊÁ• çÁ<³ƒœ‹œ5]Îrä´uöëãä¼(r6f]k—ó‘¡\cr^Lg˜\÷EÎ^.g+rÚ:;Gϱ?/‹œCY7ÆåüOd 7”œWóLQr&K}ÎY.çXrÚ:;GŸ“ó†ô×ç\̺•.çé¯Ï°n19“ æ;˜fä¼IäÜér®&§­³st'ç(…ÈyØ£Öä¼Yd8w˜œ)óL+öç-"ç•°Ï¢\§Èùçèuöç­"gêÙñº .çm"Cf8ãI%˜\0ûÈy»È™ov"§Í´œ¶ÎžßÉ™Zä,Ö¹œiD†2pEÉ™V0Ϥ座9«»œeÈiëì×õÙŸéEάãrÞ!24‡k@Î ‚iS†œwŠœÝ]Îæä´uvŽÖ3£È9u+]ÎL"ÃH¸äÌ,˜‰0íÈ™EäœárŽ$§­³st?ç(«È¹€uvŽÆ3›È°n9³ fÌhöç]"çv{þVÓÖÙ9ÂþÌ!rpç(äÌ)2œ€;@Î$ÁüsŒœ¹DÎK.ç rþÁ9JÇuÏ-rÞ:‡ëàrÞ-2d€3Þ˜<‚¹ &+×ý‘3ïœDN›i9míƒöäÌ+rfÝ—ó^‘¡$\arÞ'˜g`*‘ó~‘³ŠËY’œ¶Î~½‡œùDÎ:¬[ér> 24«CÎü‚i ÓœŠœ]\Î&ä´uvŽžà9û±ÎÎÑJr>$2 ‡ëG΂‚³‚ýù°È95\¿(×prÚ:;G_qŽ ‰œóXWÁå|DdX 7œ…³æ,997»œKÉiëìÝÃu/"rþäÎQÈù˜Èpî'rÌï0y¸îÅDÎ .çrþÎ9êOÎâ"gŠ¹¬s9ÒÂoL Ád©AÎ'DÎÜs9m¦å´u¶_#gI‘³ ëVºœOŠ Åá ’³”`ž‚éGÎÒ"g%—³89mýº*ç¨L´î…kÖÕŠ˜9“%ýÆân1÷TÄ5¸†kqÝ"Îø…)b®¬ÈÑ‚UsEl®˜{ZpàFLs¸r‚ë×>bºÃ=#¸p}#f(\yÁ„³lUá*nÜ×3®¢àfÂŒ˜OážÜ|¸›r'K6®’à–ÁÙsÒî9Á­‡³l_ÃUVþȘ-pÏ î'¸ÔQ¾ÝpUwήE{¸ª‚; gÏÉA¸j‚»gÙNÀ½ ¸äŸÇ\¦(ß%¸ê‚K g{ /Ü‹‚Ë g×®‰q5Ôù‡³ç$5ÜK‚ËgÙ,c²èœÖ\8{ÿ”=Ñ×Í7%K¶õƘYðeàí¿ƒÊ}eøôÉc¾–à+ÃÛÏ3½jÿ¶ñÕá_|-xû¾äÄè«TÄ„¯-øÆðv9hß#ŒøÝÉãçåUÁ·Ï}ÝvoÌÕ\7¸G£¯ pu×î•èë.¸z‚ gç…«/¸±pöãgÁ5Pþ퉾ŠÂ5Ül¸=ÑWi¸F‚[÷[ôUî5Á­‚»-º/À5Ü&¸ûíºÁ½®þþ÷Œý|)\ÁÏsĵ€k*¸p-#®#\3Áƒ{'âzÀ½!¸Ëp“íç¢àš .弘[qÃáÞ\z¸ï#n\ Áe‡;qSáZª×ÿpÿØ¿çõ\A¸4Ño,€k-¸âpF¿±®àÊ•Ž~c=\[uþá^Œ~c\;ÁÕ„kýÆ^¸ö‚k÷Vô¿Àu\s8;ãÃSÇ\GÁu€³3¾®“àzÀÙ?×YpàìŒß—&æºnœñZp]7ÎÎøx¼ÝÔßÿÃõˆ¸Ípo nœñ+pÝ·ÎÎx!ò½-¸µpvÆÁõÜV8;ãÓðöÜ^8;ã»áz î0œñ[ñ¾#¸SpvÆKÀõV¯ÿá쌷€{Wp7|svÆç’¯àRÁÙ?×WpáìŒgÀÛOpIpvÆËÁõ\>8;ãà®0œñÅä{Op%á쌟„(¸òpvÆsà$¸jpvÆ«À \m8;ãöyð¥£ÿ=Dü]¤1ÜyîC#æ¡k˜–0«¢¿'œHÏ&fu†»ÊÛ}\½þ‡9ùÌm¯›lÍ|_Ì ë}q¾"ß(—/ýÍñ¬ĬÉp£È7R½þ‡¹åL¾Éä%f.€ÏA¾Ñ"ßr—¯8ùƈYž"ßXõú&Cä[@¾ ä'fîƒ/D¾ñ"ßQ—¯ù>³ÎÀ%ßõúæ¾È·|gÈ7QÌL1?æË‘o’È—æ„»¾“Õßÿá®òQ¾)êõ?L‰ÈgnËgëlæGbføZä›*ò=æò…ëû±˜Uî1òMù*ÂT‰|ÈWš|ÓÅÌð-È7Cä«ëò…ëû‰˜Õ®.ùfª×ÿ0"_ ò5%ߧbfwø^ä›%òõ…±kž¿ÏĬap}É7[½þ‡éùº“où戙ÓàG’o®È7Çå ÏßçbÖ"¸9䛧^ÿà Œ|ÓÈ·ˆ|_ˆ™›ág’o¾È· ¦¸Ë÷¥˜unù¨×ÿ0“"ßfò$ßWbæyøeä[(òýS-eôZ.eò™Ûò=L¾åbf9ø#ä[!ò=ïòm$ßJ1ëe¸çÉ·J½þ‡ù)ò•#ßËäûFÌl‘|«E¾Ž.ßYò­³zÂu$ßZõúætäkA¾žä['fŽ„O}œo½È7¦‹»¾ĬOà&’o£zý“<ò$ß'äûVÌ\Ÿ›|›D¾u._¸¾ß‰YÛàÖ‘o³zý“9ò-#ß6òm3À!ßV‘ïw—/\ßmbÖßp¿“o»zý¿ fòG¾#äû›|ß‹™©á+’o‡È— fŠ{þ~³rÁ]å£|;Õë˜R‘ÏÜ–ÏÖÙÌ]bfø:äÛ-ò=éò…ço˜UîIòíU¯ÿaªG¾"ä«@¾ÅÌ:ðmÈ÷“È÷:ÌF—ïg1«5ÜëäÛ'òuiùê¯5ùö‹™}àûï€È7æÐ-Ñßng³ÆÀ !ß!‘o L·Ègî«ïÿA¾_ÄÌÙðcÉwXäûÊå+D¾_Ŭ•p_‘ïˆÈ·fhä›M¾•ä;*fî„ŸM¾c"ß~—¯ùŽ‹YÇáö“ï„ÈwfjäÛI¾ãäûŸ˜y~ùNŠ|7•È׋|¿‰Yéà®òQ¾S"_V˜…‘ï2ùlÍü]ÌÌ ¿“|§E¾‡`lï…ë{FÌ*÷ùΊ|e`6E>s[¾bäûC̬ ‚|çD¾—\¾p}ÿ³êýD¾ó"_3˜‘¯2ùê“ï/1³üeò]ùÞvùÂõý[Ìê÷6ù.Š|ÃaÎE¾äëO¾ÄÌ ðéóÅù.‰|Óa ¹çï_1ës¸éä»,ò-†Iù&ïsòý'f®…ÏK¾+"ß—/<ö<×ÎÚ·…|7Üq}¾C0Ù#ßZòí!ßbæ)øâäK~Çõùþ‚©åòÝ$f%[s‘/…Èw+LÁÈwŠ|¶ÎfÞ,ff„¯L¾”"_N˜6·E÷ñÛâY·ˆY÷Ã]å£|·Š|…`ÊF>s_ýùòÝ&f–„o@¾T"ß3.ß*òÝ.fU…{†|©E¾Z05#_IòU%_1³1|ò¥ùZº|'È—NÌê ×’|éE¾^0Í#_còu&ßbæ`øäË òrùÒ§ŠgÝ)fM†E¾Œ"ßL˜‘o0ù&“/“˜¹~ù2‹|Ëaƺë›EÌÚ·œ|YE¾í0#"ßòm _61sü<òeùŽº|áúÞ%f;J¾"ßE˜‘oùÎ/§˜™bQ̯%_’È—fQ"_¸¾¹Ä¬,pWù(_n‘/7ÌÒÈgnËgëlæÝbfø½äË#ò=³Ê=÷ˆY¥á#_^‘¯"ÌÖÈW€|¥Éw¯˜Yþùîùêº|áù»_Ìj W—|ùD¾60‡#_ ò5%ßbfwøˆóåùúÂœpù³†Áõ%_‘o,Ì…(_wò #ßCbæ4øŒä+(òÍ nž“ðYàbÖ"¸9ä+$ò­‚IùÌm?w±ˆ|ˆ™›á󑯰ȷËå«F¾GŬƒp»ÈWDä;“ù6“ï ù3Ï×$_Q‘ï?—¯ ùŠ‰Y·,Ž¹ÿÈW\äKS8ò'Ÿ­³™‹™9à«‘¯„ÈwïâD¾)áóÀŬ‡á®òQ¾’"_q˜ò‘ÏÜ–ïaò=)f–ƒoL¾R"ßó0ùÜõ--f½ ÷<ùʈ| `jG¾rä{™|O‰™-໯¬È×Ñå ×÷i1«'\Gò•ùÀ´Š|-Èד|ψ™#ᓯ¼È7Ñå ×·‚˜õ ÜDòUùæÁôŽ|#É÷ ùž3—ÁO!_%‘o]Ø£îù{NÌÚ·Ž|•E¾½0£#ß2òm#ßóbæøä«"òýîò…篪˜õ7Üïä«&òÝ°$ffE¾#äû›|/ˆ™©á7’¯ºÈ— ¦‹Ë÷¢˜• î*å«!òåƒYùÌ}õ¿ÿYÂÏ ÞqýÏÑŸ˜&þ2wMá.güÊèÿ¿,Ü`ìß\Œ¿ŸŸO¬%¼Õ£Ç‡äˆ_à}Exë0³:ÞÚÂûºóÿÞW…·Í’øç†Í»oáíÆÌ6xë ï»Îküxë ïÐèñbI±÷G¼õ…w,3‡âm ¼9¯ñÏàm(¼³£Ç_§ïïx ïBfÎÆûšð®t^ã«âm,¼›¢Ç[䈯mØW¯ ïNfnÂÛDx÷;¯ñ¯àm*¼'`¿pûª™ðžƒ;÷ áý×y osáM¹4ºäŒa_½)¼é—Æ37o áͶ4á5¾%ޖ›7züѤØöU+á-È̼x[ o1ç5¾3Þ6Â[6zü ¼a_µÞÊÌ,‹·ð¾ä¼Æ¿ƒ·½ð6€]çöUám×oGámï¼ÆÂÛIx{8oØW…w\¼]„÷}ç5~Þ®Â;Áyþê&¼3à&à}Kx?w^ã'ãí.¼K£ÇLŠa_½-¼k™¹oáÝâ¼ÆŠ·§ðîu}þê%¼‡áöâ}Gxs^ã¿ÄÛ[x/D?™w ûê]á½áëxæ¼}„÷¶¯^ã—ãí+¼atûªŸð&ÁoÞþÂ{¿ó¿ïá-ì¼a_½§¾ÿWï@á}Æyÿï á­æ¼a_ ÞÚpÕðÞל×øŸñÞVÎöÕ0áí× ïpá}Çy?Š÷}á=þOöØöÕáÍÌÁx?ÞÉÎkü¼#…wìïn_Rßÿƒ›…w´ð.w^ãÿÁ;Fx7:oØWc…wÜF¼ã„÷gç5þ¦»ù@á=æžç°¯>Þ³Ì<†w‚ðþã¼Æ§Á;QxS,Kô ûj’ð¦…3Þ¼“…7˲„×ø,x§ožèñ^Ñ€Tiã/ó~¤¾ÿÇ̸$¼· ï#Îk|G¼· oÉèqû|ÇÉn_¥ÞòÌ,‰÷vá­ê¼Æ÷Ä›ZxkG×L{þJ#¼™YoZámé¼Æ¿‡7ðvìöUzáí ×ïÂ;Èyÿoáí¼a_Ý)¼SàFãÍ(¼Ÿ:¯ññfÞÎöUfá]·oáÝà¼Æ‚7«ðîˆ?MÜ5ì«l»™;ðfÞ£ÎküxïÞ³«âƒÿÒí«Â{‰™gñæÞ›¾Ixÿo’ð¦ý&á û*—ðfe¦ñæÍ-¼w;¯ñëðÞ-¼`¿tû*ð…+€÷á-í¼ÆoÛWx+9oØW÷ o ¸JxïÞºÎküxïÞf°ܾÊ'¼íàšá}@xßr^ãÅ›_xû9oØW ïp¸~x ï8ç5þw¼ ï4ç ûª ðÎ…›†÷aá]ä¼Æÿ·ð®Žï˜1ö†}õˆðnfæj¼……w—óã=±÷Qá=äú†}UDxOÂÂû˜ðþé¼Æߎ·¨ð^=’6þ2o1á½uuÌ]Á[\xŸí4>ÞÇ…7Çê„÷"ÞÂ{œñæ}Bxv^ãsá-)¼%¢Ç›g½©ÓñóÂ[Ž™%ð–Þç×øð–ÞZ®on¼e„·\-¼O ï›Îkü£xË o'ç-‚÷iáí× o9á}Ïyï3Â;2z¼k¦øÚ†}U^x'1s$Þ Âû‰ó_oEá{Ñí«g…wÜ|¼•„wóÿÞç„w»ó†}UYx‚ÛŽ÷yáýÕyoá==^3{ì ûªªð^dæi¼Õ„÷Æ5 ¯ñ¯ã}AxS¯Iô ûªºðf†3Þ¼/ o.ç5¾5Þ›?ÌK—ØW/ o¸üxk ï“Îk|W¼/ oÅèñŸ³ÇÞ°¯j oufVÄûŠð¾ê¼Æ¿‹·¶ð6‰4Kì ûêUámÃÌ&xëoWç5~ÞºÂÛÇ=Ïa_ÕÞ¡p}ðÖÞ1Îkü¼ „wêšøçqÌöUCáÍÌ©x ïWÎküGx_ÞUÑãYsÄ]þj,¼›˜¹ ïëÂûƒóÿÞ&Â{`Müý¹Ün_5ÞÌ<€·™ðþá¼Æ…÷ á½ ›Ûí«æ›rmÌ]Æû¦ð¦[›ð¿o á;6á ûª¥ðæ…3Þ¼­„÷!ç5þ[¼­…·¸ó†}ÕFxËÂÇÛVxŸs^ãÀÛNxk®~¿ˆÛWí…·3kâí ¼o8¯ñûñvÞÑãõa_uÞÌ쀷³ðöw^ããí"¼#`‹¸}ÕUx'ÀÀÛMx§;¯ñà}KxçE'刽a_uÞ¥a&Þ·…wóÿ/Þ»Õõ ûª§ðî…ÛŠ·—ðþâ¼Æßœ7ö¾#¼§ÖÆï òBºø˼½…÷3Oá}Wx“­‹û™zãÓáí#¼©`Íù:޾›ÎxóöÞœÎk|6¼ý…7ŸóvÅ;@x ÃåÃûžð>á¼Æ߃w ð–wÞ!x o5¸òx ï+ÎküCx‡ocçýïPám×ï0áíì¼ÆÃ;\x{GŸI_Û°¯ÞÞÁÌìw„ðŽr^ãŸÂûðN}Ýí«‘Â; n ÞQÂû¥óÿÞÑ»Âyþ#¼áVà+¼ß;¯ñ/á'¼ûœ7ì«ñÂ{ nÞ…÷Œó_ïá½ä¼a_MÞëcîÞI›f}Âküx' oVØ®n_MÞ?e£àN“[—8ú“M‚»BnkâèóD6 .Ѻ8·7qô¹[—šÜÑÄÑçÏl\frgÁ$·MpyÈ]K}ÎÊvÁ$—$Iôy'¿ ®4¹´I¢ÏÙ!¸Jä²&‰>çÁU'—7Iô95;W‡\ap«Éí\#re“DŸÇ²[p-É=–$ú\”=‚kO®F’èó{ö ®¹zI¢ÏÑùSp}É5I}žÍ>Á "× Ü9r n¹ŽIâŸÛbÜ~ÁM"×#IôùB7›\¿$ÑçüÜrC’DŸ·sHp+ÉI}îÍaÁ­'7\.zÜvrpžüQÁí#w?ž;þ%wLpÇɵ°ŸõHËŸÿÜyrÓÀm!÷·ànû\¥tqî„à’ýçì}èíßï÷àÒ“³÷ƒÜIÁe'—Óq§—\qÇ\QrUwFpåÉ5pÜYÁU!×ÆqçW“\/Ç\}rÃwApMÉMwÜEÁµ&gïë|ë=xñëK‚ëLn³ã. ®'¹ÃŽûWpýÉ]qÜÁ %gïû¸«‚G.ã® n*¹ÒŽ».¸¹äª;î†à“kä¸ÿ·š\{ÇÝÜFrö>©mÉÅîþ_n'¹QŽK ¸ƒäf;.¡àN’[é¸D‚»Ln»ã .Áú8wÜqI—ŠÜ Ç%\&röþŽK&¸\äò9.¹à +︂+IÎÞwp.¹”‚«H®©ãR ®¹ÎŽ»KpµÉõw\jÁ5$7ÎqiלÜ\Ç¥\[r«—Np]Éít\zÁõ&wÒq7œ½Xà2 n9{¯óäîÜDr—Ip3ÉUtÜ=‚›O®¶ã2 n9¹æŽË"¸uäº:.«à¶’è¸l‚ÛKn¢ã² î(¹ùŽË!¸³äÖ‘«Œ_ç¼[üü9ûœcîLâ_ãÌV{oŸx#ÖKMÆúŒ¿õÞ8÷ÆbÃðfÿ½pnÑÇÝäúys?™½\ÿ>±~a2Öw?ׯÎõ—pý¼¢»³Ïi1æ~Á Ýœ»X ëûŒë·äúaß ‹îé<®×/"˜oÉ$)_¿¨X1ëû–ë·çúaߊ‰îu<®×/.˜-dÒrýbýÝd¬o ×ïÆõþ•Ç¿Ãã} ÷íÖç«ßÿïp/qߧ¥…K’ ñãºÐ·Œ`ÒÉJß²býÌd¬Ïx[¿/×÷w9ÑÇ àúåS„L^®ÿ°X¿,ë+ÂõqýpWÇUåq·or÷÷#â¸:ôãkïo;®¢8®éî§MîûâQq´åqx?UÌ;d ó~ª,ÖïEÆúÞáú£¸~¸ŸÇ âq·?r÷Óãâ¸qô÷Á!w?UQ¿ÿßa?ñ~²ãžÇ-ºƒß!÷8¬*î»5Ƙ:‚iL¦ ç®+ÖoÜðµ1ç^ÏõþÕÝy\f®ÿ‚`Þ#ÓŠë×ë÷#c}ïqýí\?ìÛ‹¢{8+Èõf<™Ž\ÿ%±þT2Ö7žëïãúaߪ×ÿ¿éÇ{î›÷²8nÕîïîû´‘pÙÌã*Ñ·±`v‘éAß&êÏÿd¬o×?ÎõÃýýŠè>Ëãêpý¦‚¹J¦×U¬Ÿhcœ±¾«\ÿ<×÷w3q\zwû÷wEw¿¦þü¿Q?¾*òþ¶ãš«×ÿõýTÑ}_´P¯ÿy\KÞO-Õë2Cx?½®^ÿ“±>ãoýi®î§VêÏÿ<îöç¡Úî~zC×j£þ>¨íî§Öâ¸.wØÏÚ¼Ÿì¸7Åq}ïàWÛ=Ûˆûn(ëÆû÷-ÁŒ%3†÷o[±þ2Ög¼óI– }Xû®ßNtÏãqƒ¸~{Á,!3…ëwë¯&c}K¸~z®ÿ9×ï(º·ò¸I\¿“`ö™Ãõ;‹õ“±¾=\?;ןÁõßÝçyÜ®ßE0×É,âúïˆõ“lŠ3ÖwëçãúËø¸é*ŽË¸Iï›íÙ[œû]1S·žswÌCdVqîîêüë3ÞÖ/ÊõþõÝñ¸}\ÿ=Áǘó™ýôí'ÖŸCÆú¾âú5¹~¸¿?ÝKy\v®ß_0?“9Áõ?ëo$c}?sýú\?ÜßÔù?wû÷÷ w"Ž;q‡Ç× ÞßvÜ@õúÿ÷Ó ÷}ñ©zý¿9~\QÞOƒÔë2y? V¯ÿÉXŸñ¶~S®î§!â¸ü<îöç¡eî~úLWz³þ>Xæâ¸*›õ~.ãýdÇ ÇÕ¾ƒß2÷8.î»&<® ïßÏó:™›¼GˆõÛ“±>ãíœ|k¬¿kŸæú#EwOWŸëÌGdRŠ¯?Z¬?„Œõ}Äõ;sýDáç[E÷ךëÌ42¹þ8±þ\2Ö7ë÷äú™ÃϹŠîåan®?A0kÉääú_ˆõ7“±¾µ\¿?×/˜.~ÜDqܾ;ì›íÙnîÛ—b¦“ãíïL7bý§°öË\…è®Áãrqý•‚©K¦ ×ÿQ¬ßˆŒõÕåú;¹~;®¿Jt·æq%¹þO‚éD¦ ×_-ÖïAÆú:qýƒ\¿×ÿYtàqÕ¸þÁ #Ó‹ë¯ë#c}øþI®?’›u⸙wØ7Û³§8÷/b¦E<®!ç^/˜ÃLœûW±þz2Ö÷#׿ÌõþmÝ;y\[®ÿ›`Îõ7ª×ÿd¬ï×O;¾~Ø·M¢û ëÍõ7 &á¶83ëoë§"c}ÆÛú©¸~Ø·­êõÿ6ýxoÇ}³ã¶©×ÿÛôýÝÎ}Ÿn.¥yÜúþ.˜GÉL§ï±~52Ö÷(}3厯îï?Dw=7“ëïLc2ó¸þ.±~K2ÖטëçâúáþÞ-ŽëÌãnÿþîãîï=â¸ÞÛôã«ïo;n¯zý‡û©û¾øS½þçqËy?íS¯ÿÉ,åýô—zý»ø:ëàúá~Ú/Ž[Îãnéî§⸠wø>éâ¸ÝwØÏ‘¼Ÿì¸Câ¸ãwðÉÇáû¸íðÝâó?À6‡Ï¬tñØçkQ¿ÿo÷¿–#þ÷¶ö÷£v¬õ½©Éos½ÇDof×;½v¬õ½yqÛŸøõu×û·è-ìz—°7/{OˆÞòäïOõþ£þüïz7±·<{OŠÞZÛã÷ï3®÷”èmàz±·{O‹Þæä­s{ψ޶äÚ¸}kÎÞ³¢·›Û·Ð{Nôöu½aߺ±÷¼èBþºë½ ^ÿ»Þ°oCØ{QôNuûz/©ï×öm*{/‹Þ¥¸­Cšø¾…ÞEï×öm){¯ˆÞ­¸í©ñ}»ÎÞ«¢w/{ßvû¶•½×Dïq·o¡÷ºzýïzþgï Ñ{Óí[èýOô¦ø=ê ûv“½7Eo¦ß£} ½±LâÏÿ®7ì›k½ 2‰÷ÿ!ÿŒëM(zK»Þ°oÙ›Hô>†ÛÆ$Žï›Íl½‰Eo öötûö{“ˆÞú¸mxŽø¾…Þ¤¢·©ë ûVŸ½ÉDoÜ–0gü>½ÉEo×ö­ {SˆÞÞnßBoJÑ;Ðõ†}ëÍÞT¢w”Û·Ð{—èäzþbojÑ;‡¼íÛ3ìM#z‘ûÈíÛö¦½«qÛù4ñ} ½éDïF×öm5{Ó‹Þݸí3î[èÍ z»Þ°o»Ù›QôžÅmrÅïÛÐ{·è½æzþeo&Ñ›lG´o¡÷Ñ›~GÔöÍŽµÞÌ¢7'y{/b‹õf½ùÉ Éÿûñ[ŸÂÞ¬¢·$ùB®7›è­èz3±·${³‹ÞêäëºÞ¢·Žë-ÀÞêìÍ)z›ïîzï½­\oEö6ao.ÑÛ™üd×›[ôöt½µÙÛ™½yDï·o…Ø{ŸèNn´Û·ìÍ+z'º} ½÷‹Þ™®7ìÛDöæ½ ܾ…ÞDïJ×öm{ó‹Þ nßBw‡ë û¶½DïA·o¡÷!Ñ{Òõ†};ÈÞ‚¢÷ nk%¾ouÙ[Hô&ú#Þ;ÉíÛö½iÿˆÿüW!×[Dôfu½aßìXë-*zóýí[è-&z‹ºÞ°oùØ[\ôVø#Ú·Ð[BôVu½aß*°·¤è­ýGüþìzK‰Þ†®7ì[mö–½-ÉÛ¾ugoÑÛžÜ,·o-Ù[Vôö _Èõ–½ý\oØ·ì-/z‡º} ½‹Þq®7ìÛPöV½Óݾ…ÞGDï<×öm:{+ŠÞåä'»ÞGEï:×öm9{+‰Þí¸mç½ñ}›ÌÞÊ¢w{ç»}ÛÎÞÇDï Ü67k|ßBïã¢÷¢ë ûv‚½UDo‚x^Êß·Ðû„èMµ3ê ûfÇZoUÑ›·íË¿oCï“¢7ë û–™½ÕDoáѾ…Þ§DoY×ö­0{«‹Þ*ä_Îõ>-zk’[–#þs·~¾€½5Doò}\ï3¢·™ëý€½ Ø[Sô¶%?Ëõ>+z»ºÞÏÙÛ–½µDo_Üv×os½Ï‰ÞA®w{û²·¶èCþºë}^ôNq½ËØ;†½uDï\Ü6+k¼³{ëŠÞÅì]ãöm.{ë‰Þ5nßBï ¢w³ë û¶†½õEï^Ü–3u|ßBï‹¢÷¨ë û¶—½ Dïyܶ m|ßBïK¢÷†ë ûvž½ EoŠ]Ѿ…Þ—EoÆ]QoØ7;Öz‰Þ\ä­k{‹Þä6¹}ËÅÞ&¢·4nÛÁYCï+¢·’ë ûVš½MEo ò³\ï«¢·žë ûVƒ½ÍDoSÜ–4}|ßBïk¢·µë ûÖ”½ÍEo·o¡·…èíåzþuaoKÑ;ÐíÛ6ö¾.zGÛéöm {[‰ÞIäû¸Þ7Dïl×öm{[‹ÞEnßBw•ë û¶ˆ½mDïFòÛ\ï[¢w§ë û¶‘½mEïaÜö`êø¾…Þv¢÷´ë ûv˜½íEï5·o×ÙÛAô&Ùç¸}»ÆÞŽ¢7ýîèû-ôv½Ù]oØ7;Öz;‹Þü¸íä]ñ} ½o‹Þâ®7ì[~öv½wG¿¿…ÞwDo5×ö­"{»ŠÞ:䯻ÞwEo#×ö­{»‰ÞVä¿Ëõv½ÉÈÿyû¹ŠVìí!z{’ßãzß½ý]ïiöödoOÑ;œ|â,Qïû¢w‚뵟±Þáìí%zg’/äz?½ó]oföÎdooÑ»’|]×ÛGô®w½Ù»’½}Eï·o{Øû¡èÝOî‚Û·ìí'zOº} ½‰ÞË®7ìÛIöö½‰öDûz?½©÷D½aßìXë z³î‰ö-ô~"zóºÞ°oYÙ;PôÝí[èýTô–w½aߊ²wè­ŠÛžËß7»/¬w°è­ÅÞnߪ²wˆèm¸'Ú·Ðû™èmîzþ5dïPÑÛÞí[è&z»¹Þ°oíÙ;\ôösûz?½C\oØ·~ì!zÇñþ­ëzGŠÞ©®7ìÛ8öŽ½óÈÛ¾bïhÑ»”\ҜѾÍcïÑ»nOüÏk{\ïXÑ»Õõ†}[ÇÞq¢wŸÛ·Ð;^ôw½aßö±w‚è½èö-ô~!zoºÞ°oÙ;Qô¦Úí[èýRôfÚõ†}³c­w’è̓ۖ¥ï[]öN½Ù›Öí[öN½eqÛþìñ} ½_‰ÞÇ\oØ·²ì*zkò~°} ½ÓDo}×ö­&{§‹Þf{ãçQ ¹Þ¢·ë ûÖŒ½3EoWòu]ï,ÑÛÛõ†}ëÊÞÙ¢wù»²Åc½_‹ÞQä²äŒÿ\ýüÊ öνSÈ—r½ßˆÞ9®÷eöNaï\Ñ»·¥µŸ×s½ßŠÞÕ®·{³wžèÝL¾ëýNôîv½}Ø»™½óEïQÜv7.Ìr½ß‹Þ³®w${²wè½áö­{ŠÞdƹòe×»Kôöp½aß:²w·èí¿/þ~}\ïÑ;Ôõ†}ëÏÞ½¢w‚Û·Ðû§èîzþٱ•qÝ>ð-nãç㶶wáÏl ãkÿ%:—±sM¡è=W÷ n-¹ÍŽ; ¸-äv;î àö;ì¸C‚;Bî´ã î ¹+Ž;"¸«äŽ¸£‚KüWœKí¸c‚KC.³ãŽ . ¹<Žû[p÷‘+X8zÏÕ‚+D®´ãþ\r•wRp•ÉUwÜ)Á=M®ŽãN ®.¹FŽ;#¸ÆäZ:î¬à^'×Þqç×\7Ç\wr}wAp’T8zÏÕ‹‚Ln”ã. n4¹IŽ»,¸Éäf;î_Á}Mnã®n!¹•Ž»*¸É­wÜ5ÁýJn»ã® îwrûwCp‘;î¸ÿ÷7¹ó…£÷\½)¸ än8.vÏÿrÿ‘KV$â.ùþ8—Þq —\vÇ%\rù—Xp+ê¸$‚+F®¼ã’ îarU—LpO«é¸ä‚{–\ý"Ñ{³¦Ü‹äš:.¥à^%×Úq©÷&¹ÎŽ»Kpo“ëé¸Ô‚{Ÿ\Ç¥ÜÇä†:.­à†‘ç¸t‚OnªãÒ n¹¹E¢÷¶ÍpxÿOröûù |Í(º“¹õóöáÏþûã}w‹¾ŸÉnf_&Ñ·ÑõÙûÕþ̾{Dß.²»Ù—Yôt}öþ³»Ø—Eô"{˜}YEße×gï'{Š}ÙD_Âqö4û²‹¾T¢>{ŸW;Æúrˆ¾{È^a_NÑ—ËõÙû¶Þþ{EßCdíõ‹õå}%]Ÿ½ëCìË-ú%›š}yD_5×gïsú(ûî}Ï“Í̾¼¢¯¡ë³÷-}ž}÷‹¾dó°/Ÿèkëúìý=[°ïÑ÷.Ù‚ìË/úz“±×ö~–ï²ïAÑ÷)ÙÒì+ úF¸>{ÊOÙ÷èû’l%ö}3]Ÿ½ßä—ì+$ú¾'[}…Eßr×gïù=ûŠˆ¾_ÈÖa_QÑ·ÕõÙû:þ¾b¢ïO²ØW\ôu}ö>²¯„è;G¶%ûJŠ¾k®ÏÞwñûJ‰¾¤ãl{ö•}iF}ö¾†vŒõ•}ÙÈvc_YÑ—×õÙûfc_9ÑW„l_ö•}e]Ÿ½Ÿ_ö=,ú';ˆ}D_ 2·~ }³ïÑ÷ÙQì«(úš¸>{?ºØ÷¨è{ƒì$öU}]Ÿ½¿Üì«,úÞ#;›}‰¾~®ÏÞ/î=ö=.ú>#»€}UDß×gïãöûž}_‘]ɾª¢oŽë³÷eûŠ}OŠ¾È®g_5Ñ·ÊõÙû¬ýÀ¾§Dßod·³¯ºèÛáúì}Ì~cßÓ¢ïÙ}ì«!úN¸>{_²ì{Fô]"{œ}5EßM×gïßu‰}ÏŠ¾”‡âìyöÕ}ÉØëf{¿*;Æúž}÷’½Á¾Ú¢/¿ë³÷Ÿº—}Ï‹¾díÏ3ÖWGôUp}ö~R%ØWWô=I6=ûꉾZ®ÏÞêIö½ ú^"›}õE_3×gïÛôû^}o‘ÍǾ¢¯‹ë³÷az‹}/‰¾Èe_CÑ7ÀõÙû*}À¾—Eßçd˳¯‘è›àúì}‹>g_cÑ7ƒlö5}ó\Ÿ½Ñ ö½"ú–‘­É¾¦¢oë³÷ëYƾWEß²õÙ×LôíßC‰âïO³…}¯‰¾#d›²¯¹è;íúìýfŽ°¯…è»J¶5ûZŠ¾D‡£>{ÿ˜«ì{]ô¥!Û™}­D_f×gïcÇXߢï>²=Ù×Zôt}ö>-÷±ïMÑW†löµ}•\Ÿ½ïJö½%úž&;”}mE_×gï£ò4ûÚ‰¾ÆdDZ¯½èkéúì}J³¯ƒèë@v*û:Š¾n®ÏÞw¤û:‰¾ÉÎe_gÑ7ÈõÙûsØ1ïãòÛ`‹ÜÆŽ&kÿl{|þl¦à&“+ä¸w÷5¹ç×Up ɽã¸w÷#¹ñä*'ÀkUáü+9ó±Ym[ãGºwÝ;û·œ¡‡à:÷À½'¸“Î=p=wÙ¹î}Á%8¹K÷^êÏÿäÌÇfµ9l ;Þº?ÝYŽDî?s†Þ‚»ïHä¸>‚+t$r\_Á•9¹îCÁUvî?Ó½Ÿpšœùج6‡­Q™î‰îúÎ}gè/¸¦Î=p ®µsÜÁuvîûDp=û.ºîýÉ™ÍjsØ=éþ©èþܹŸâ ƒ÷…sÜ`ÁÍpî"¸ïœ{à>Ü2ç~ŠîC…ûZræc³Ú¶Æ2ºÝÛ{ª´üùJÁísîû\pÇ{àFî¼sÜHÁÝpîÆ™û(ážìhœ3›Õæ°5nÐ}´è¾ûhäž‹3ŒܽG#÷À܃G#÷À\‰£‘{àÆ î‘£‘{.ºOîO’3›Õæ°5ìxëþBt×qî%9ÃDÁ5rîûRp-{à& ®½sÜdÁusî%é>E¸÷%g>6«Íakt£ûW¢û3ç^3LÜXç¸i‚ûʹnºà¾qî›!¸œ{5ºÏî?‘3›Õæ°5~ û,ѽٹ7ä ³·Û¹îkÁvî›#¸ÓÎ=pßîŠsoH÷¹êõÿ±8g>6«Íak\¡û·¢;ݱÈýÎ0OpÙŽEîûNp÷‹Ü7_pEŽEîû^påŽEîïÐ}p6«Íakt¡û2Ñý©sÿ‚3,ÜH縂ûÒ¹n¥àf9÷Àý(¸ïût_%ÜW3›Õæ°5¾§ûO¢{ƒsÿŽ3¬Ü縟·ß¹nàN8÷À­ÜEçþÝשóäÌÇfµ9l‹tÿEtßu6«Íak|M÷ ¢{µsoÁ. n£sÜ%uþϹî²:ÿçÜ÷¯:ÿçÜ[ÐýŠp¿LÎ|lV›ÃÖ8I÷«¢;ñ‰Èý]ÎpMpiNDî»®ÎÿˆÜwCÿ;¹î?uþïDäþ.Ýo ÷2äÌÇfµ9l ;Þºc™ÿ·»Šsÿ”3$\M縄‚«ïÜ—HpM{à ®µsÿ”îI2ÿ¯{græc³Ú¶Fkº'Ý8÷/9C2Á}âÜ—\pŸ;÷À¥ÜÎ=p)7ùI÷TÂý;ræc³Ú¶Æ ºß%ºW:÷•Iâ\jÁ­wîK#¸íÎ=pi·Ï¹.àŽ;wãÌ=½p?OÎ|lV›ÃÖ8N÷ ¢;öOä~œ3d\Ê"÷ÀÝ-¸»ÿ‰Ü—Ip÷þ¹îÁ=øOä~œî™…{ ræc³Ú¶†oÝYDw%çž>iœË*¸êÎ=pÙWǹ.»à9÷Àå\Kçnœ¹çîíÉ™ÍjsØ-é~¯è~Ϲ—ç ¹÷‘s\nÁ}æÜ—Gpc{àîÜWν<Ýó ÷oÈ™ÍjsØ_Ñý~ѽԹ7å ù·Æ¹îÁmvîË/¸ÝÎ=p î°soJ÷Âý49ó±Ym[ã0ÝÝ×{ídq® à’žŒÜWHpéNFî+,¸l'#÷ÀÜý'#wã̽¨p/BÎ|lV›ÃÖ°ã­»˜è®p2rïÊŠ ®ªs\ ÁÕrî+)¸Î=p¥×̹w¥{iáÞ†œùج6‡­ÑŒîeD÷»Î}"g(+¸>Î=på÷©s\yÁtî{Xp_:÷‰t¯ Üg‘3›Õæ°5¾¤û#¢{‘s_Ç* n•sÜ£‚ÛàÜWIp;œ{à* n¿s_G÷Ç„û ræc³Ú¶Æ~º?.ºÿuîg9CÁ%<¹î ÁÝu*r\UÁÝs*rÜ“‚Ë}*r?K÷jÂý!ræc³Ú¶†oÝO‰î²§"÷ýÉã\uÁ=æÜ÷´àj8÷ÀÕ\=ç¸g×Ĺgî5…{+ræc³Ú¶Fº?+ºßvî)RĹZ‚{ß¹î9Á}ìÜW[pÃœ{àžÜxçnœ¹×îÓÈ™ÍjsØãé^WtÏwîÅ9C=Á-wî{Apëœ{àê n«sÜ‹‚ÛëÜ‹Ó½p?JÎ|lV›ÃÖØK÷—D÷çÞ€34ÜÎ=p/ .ùéÈ=p—átä¸Æ‚Ëq:ro@÷&Âýræc³Ú¶†oݯˆî’§#÷^œ¡©à*žŽÜ÷ªàª9÷À5\mç¸××й÷¢{sáÞœœùج6‡­Ñî-DwçÞ>eœk)¸îÎ=p¯ îCç¸V‚ìÜ÷†àF;wã̽µpŸLÎ|lV›ÃÖM÷7E÷\ç>Š3´Üb縷·Ú¹®­à6:÷ÀµÜNç>Šîí…ûAræc³Ú¶ÆNºwÝgœûJÎÐQpW{à: .ñ™È=p—æL丷—åLä¾’î]„û}äÌÇfµ9l ;ÞºßÝEÏDîÇ9CWÁ•?¹î]uþϹ®›:ÿçÜ×]ÿsîÇéÞC¸7%g>6«ÍakÔ§û{¢û-çž>Uœë)¸wœ{àÞWçÿœ{àz©óÎ=p¨óÎÝ8sï-Ü¿ g>6«Íak|N÷>¢{¶sOpWœë+¸Î=pªóÎ=pýÔù?ç¸Ôù?çnœ¹÷îûÈ™ÍjsØÛéþ±èþǹà wɹîuþïlä¸êüßÙÈ=pŸªóg#÷t$Üï%g>·fÅe[ÃŽ·îÁ¢»àÙȽ6g"¸Òg#÷À}¦Îÿ9÷À Uçÿœ{à†©óν6݇ ÷FäÌÇfµ9l:tÿ\t¿áÜ»r†‚ëäÜ7Rÿsî¥Îÿ9÷ÀVçÿœ{WºîcÉ™ÍjsØŸÑ}¬èžîÜ'r†q‚›çÜ7^ÿsî› Îÿ9÷À}¡Îÿ9÷‰tŸ(Üw“3›Õæ°56ÓýKÑ}̹¯çyòI‚;çÜ7YÿsÎÿ‹Ü÷•:ÿw.r_ÏóóS…{6ræc³Ú¶†oÝÓDwþs‘ûyÎ0]pÅÏEÎÿ‹Ü7SÿsÎÿ9÷ótŸ-Ü3›Õæ°5jÑýkÑݹgç¹â9‚kçÜ÷:ÿçÜ7WÿsîûVÿsîÙyŽzžpIÎ|lV›ÃÖø”î߉î)ν g˜/¸9Î=pß«óÎ=p Ôù?縅êüŸs¯B÷EÂ}9ó±Ym[cÝ݇œ{kΰXp§œ{à–¨óÎ=pKÕù¿ó‘{à–©óç#÷Öt_.Üï!g>6«ÍakØñÖ½Btç=¹7ä9Õ‚+|>rÜêüßùÈ=p«Ôù?縟Ôù?çÞç*W ÷zäÌÇfµ9ltÿYt¿êÜ{s†5‚{Ó¹n­:ÿçÜ·NÿsîûEÿsî½é¾^¸#g>6«Íak|L÷_E÷Dç>“3lÜLç¸ßÔù?ç¸êüŸsÜ&uþϹϤûfᾕœùج6‡­±Žî[D÷_Î}+gØ*¸¿{ඩóÎ=pÛÕù?ç¸ßÕù¿ ‘ûVºïîÈ™ÍjsØv¼uÿ!ºs]ˆÜ¯q†‚+p!rÜ.uþïBä¸Ýêüß…È=p{Ôù?ç~î{…{mræc³Ú¶F5ºÿ)º;÷ü;‚}‚{ݹî/uþϹn¿:ÿçÜw@ÿsî'øw…û`ræc³Ú¶Æ‡t?$ºÇ9÷Œ<_zXpS{àŽ¨óÎ=pGÕù?ç¸cêüŸsÏÈó´Ç…ûFræc³Ú¶Æjºÿ-º÷8÷ œá„àŽ8÷Àý£Îÿ9÷ÀTçÿœ{àN©ó#÷ t?-ÜÓ3›Õæ°5ìxë>#º³_ŒÜ›q†³‚Ëw1rÜ9uþïbä¸óêüßÅÈ=pÔù?çÞŒî…{Mræc³Ú¶Fº_Ý/9÷œá²à^sîûWÿsÎÿ9÷À]Uçÿœûº_îŸ3›Õæ°5> ûuÑ=ʹwãùÒ‚›äÜ÷Ÿ:ÿçÜwSÿsî‹eçÿœ{7ž§MåÝד3›Õæ°5VÒ=¡èþùOâ ‰wÀ¹.±àþqîK"¸KÎ=pI»¹O¢{2áž’œùج6Ç­5.Å»“‹îÌ—"÷õœ!…àò\ŠÜ—Rp/EîK%¸Ò—"÷ÀÝ%¸JÎ}=ÝS ÷êäÌÇfµ9lJtO#º_pîç9CZÁ½âÜ—Npo8÷À¥\'ç¸ ‚{ϹŸ§{Fáþ9ó±Ym[ã=ºß-º‡;÷ìü;‚L‚›àÜwà¦;÷ÀeÜ<ç¸,‚[êܳóï&² ÷5äÌÇfµ9l¥tÏ&º·9÷Tá^•œùج6‡­aÇ[÷¢ûyçÞ3äÜËÎ=p ®…s\Áµsî{Hpï:÷†t/(Üû„uñÕfµ9lwé^Htqî½9CaÁqî+"¸)Î=pE7ǹ®˜à9÷Þt/.ÜW‘3›Õæ°5ѽ„èÞäÜgr†’‚ÛåÜWJp‡œ{àJ î”s\ÁýëÜgÒ½¬pOøoœ3›Õæ°5þ¥{9ÑößÈ};Ï“—\Ö#÷À=,¸¼ÿFî« ¸ÂÿFî{DpeÿÜ·óü|Eáþ9ó±Ym[ÃŽ·îGE÷³Îýg¨$¸{à* îUç¸Ç÷¦sÜã‚{۹ߠ{áþ>9ó±Ym[ãmº?!º:÷|6«ÍaķûÓ¢ûWç^“3ÔÜïÎ=pÏî/縚‚ûÛ¹îYÁ]pî5é^K¸ÿGÎ|lV›ÃÖ¸@÷çDwª+‘{gÎP[p™®Dî{^p¹®Dî«#¸W"÷ÀÕ\É+‘{gº×îÉ™ÍjsØv¼u¿ ºŸvîÍyΰ¾àê:÷À½(¸ÆÎ=p ÷ºsÜK‚ëàÜ›ó\eCáÞœùج6‡­Ñî/‹îþÎ} gh$¸¡Î=p7鮉à¦:÷À½"¸¹Î} Ý› ÷ÅäÌÇfµ9l¹tUt¯uîó9C3Ámqî{Mp{œ{àš îˆs\ ÁqîóéÞR¸_%g>6«Íakœ¡ûë¢;ÙÕÈ}/gh%¸ôW#÷À½!¸ìW#÷Àµ\¾«‘{àÞ\Ñ«‘û^º·îåÉ™ÍjsØv¼u¿%ºŸtîIxž¼­àžsîk'¸—œ{àÚ î5縂{˹'áùùŽÂýræc³Ú¶Æ[tï$ºû:÷‹œ¡³à9÷À½-¸QÎ=p]7ɹîÁÍvîéÞU¸/ g>6«Íak̦û»¢û'çž“çK» î7ç¸î‚ûù®‡à8÷À½'¸œ{Nž§í)Ü/‘3›Õæ°5þ¡ûû¢;ѵȽ*gè%¸Ô×"÷À} ¸Ì×"÷Àõ\žk‘{àú®àµÈ½*Ýû ÷ÒäÌÇfµ9l ;Þº?Ý;÷6œ¡ŸàžqîûHp/8÷ÀõÜ+Î=p î çÞ†î„{'ræc³Ú¶ÆtÿDt÷rîÃ9Ã@Á pîûTpÃ{à n‚sÜ`ÁMwîÃé>D¸Ï#g>6«ÍakL§ûg¢{…sïËó¥C÷‹sÜ0Ámsî.¸?{à>Ü1çÞ—çiG÷säÌÇfµ9lct)ºo:÷Ùœa”àR\Ü7Zp¯Gî#¸œ×#÷À\þë‘ûlºîÅÉ™ÍjsØv¼uÝ^Ü·s† ‚{ʹî Á=ïÜ7Qp/;÷À})¸Î};Ý' ÷väÌÇfµ9ltŸ,º{8÷œaŠàú9÷À}%¸!Î=pS7ƹnšà¦8÷tŸ.Üç3›Õæ°5¦Ð}†è^âÜóñïf îgç¸Y‚ÛäÜ7[p»œ{à¾Ü!çž71G¸Ÿ"g>6«Íak¢û7¢ûšsÏÄs†s—äFä¸o—öFä¸y‚Ëz#rÜw‚Ë{#rÏÄs•ó…{aræc³Ú¶†oÝß‹î‡oDî9ÃÁ=áÜ·PpÏ:÷À-Ü‹Î=p?îUç^‘î‹…û›äÌÇfµ9lWé¾DtwuîÍ9ÃRÁõvî[&¸Î=pË7¹n…à&:÷æt_)Üg’3›Õæ°5&ÒýGѽйä «÷£sÜO‚ûÕ¹nµà~wîûYp9÷t_#Üÿ&g>6«ÍaküE÷µ¢û²sŸÏÖ .Á‘{à~\ªÿ"÷À­\¦ÿ"÷Àý*¸\ÿEîóé¾A¸ g>6«ÍakØñÖý›è.ó_ä>‹ï+µQp•{à6 îiç¸Í‚«ëÜ·Epû,¾ŸÕVáþ:9ó±Ym[£1Ý·‰îÎÎ}gØ.¸žÎ=p¿ ®¿sÜÁ uîûCpãœû6ºïîSÉ™ÍjsØãè¾Ktçܯs†Ý‚[æÜ·Gpk{àö n‹sÜŸ‚ÛãܯÓ}Ÿp?BÎ|lV›ÃÖØC÷¿D÷yç~ú8·_p7œ{à.ÙÍÈ=p—þfä¸C‚Ë~3r7ÎÜ ÷|äÌÇfµ9l ;Þºˆî7#÷g8ÃQÁ=r3rÜ1Á=éÜw\pÏ9÷Àý-¸—œû3t?!Ü_#g>6«Íak¼D÷Dw{çž8cœ;)¸nÎ=p§××¹î´à9÷ÀÜ(çnœ¹Ÿî“È™ÍjsØ£è~NtãÜ q†ó‚ûÁ¹î‚à~rî»(¸ßœ{à. îç^ˆî—…ûræc³Ú¶ÆtÿWtŸvîu9ÃÁ]qî»*¸D±ÿÇ=p×—šÜ;Ž».¸ÌäÆ“3÷Â=9ó±Ym[ÃŽ·îÿDwcîÝ9ÃMÁ•#WÈq6ÀÿœÿsîK ¸gœ{à îçÞþ¯û+äÌÇfµ9lèžXt·qî“9CÁuqîK*¸^Î=pÉ7À¹.¹à†;÷ÉtO!Ü'3›Õæ°5†Ó=¥èžåÜ_Ο!•à¾wî»Kp+œ{àR îç¸4‚ÛæÜ3÷´ÂýOræc³Ú¶Æ6º§Ý'œ{Î^p{à2î¦s\FÁ¥H¹înÁeL¹÷¡{&áž“œùج6‡­aÇ[÷=¢û¡‘û,ÎYp¥DîË"¸GDîË*¸§œ{ಠîyç>‹îÙ…ûËäÌÇfµ9lçéžCt·rîÛ8CNÁutî»Wp=œ{àr ®Ÿs\nÁ qîÛèžG¸!g>6«Íak ¡û}¢{šs¿Îò î[ç¸û·Ä¹.Ÿà~vî{@p›œûuºçî»È™ÍjsØ›èþ è>êÜíßIW@pg{àÜ5縂‚K’0r\!Á¥M¹gî……{Vræc³Ú¶†oÝED÷ #÷=œ¡¨àŠ%ŒÜWLp'ŒÜW\pO8÷À•ܳÎ}ÝK ÷É™ÍjsØÏÒ½”ènîÜí߀WZpm{àÊ®«s\YÁõvî+'¸ÎÝ8s//ÜG3›Õæ°5ÒýaÑ=Ù¹â ÷µsÜ#‚[èÜWQp?:÷À=*¸_{!ºWî¿“3›Õæ°5~¥{eÑ}й×å î¤sÜã‚»ìÜWEp ¹×óäž\ªDîõ<Ý« ÷LäÌÇfµ9l ;ÞºŸÝ÷%ŠÜïÊŸ¡šà %ŠÜ÷”àÊ$ŠÜW]p•{àžÜÓÎÝ8s¯!Üë’3›Õæ°5ž¦û3¢»©s/Åj ®µsܳ‚ëìÜWKp={àž\ç^Šîµ…ûPræc³Ú¶Fº?/º¿pî/s†:‚›áÜWWpß9÷ÀÕÜ2縷ֹ¿L÷úÂ} 9ó±Ym[c-Ý_Ýûœ{ÎÐ@pÇ{à^Üy縆‚»áÜ÷²à’%v¯çéÞH¸§'g>6«ÍakØñÖÝXtߛؽžç M÷`b÷zžÜ+‚+‘ؽž'×Tp$v¯çɽ*¸'û,º7îÏ‘3›Õæ°5ž¤ûk¢»‘s_ÁsÅÍ×Ò¹®…àÚ;÷Àµ\7ç¸×××¹¯à9êVÂ}9ó±Ym[£/ÝßÝcû1ÎÐZp_9÷À½)¸oœ{àÚî縷÷“s?F÷¶Âý7ræc³Ú¶ÆOto'ºw;÷t6«ÍakØñÖý¶èΖ$r/Ǻîþ$‘{àÞ\‘$‘{ຠ®\’È=pï îqç^ŽîÝ„û3äÌÇfµ9lÇéÞ]t7pî¯p†‚kæÜ÷žàÚ8÷Àõ\ç¸÷×˹¿B÷^Â}9ó±Ym[£Ý?Ý#{ž3ì-¸/{àún–s\_Á}ïÜ÷¡àV8÷,6«Íak,¡û¢{«soÇs†·×¹îKÁuî›$¸³Î=p“w͹·ã¹Ê)Â=I²8g>6«Íak\£ûW¢;C²È}$g˜*¸É"÷ÀMÜÉ"÷ÀM\±d‘{àfîád‘ûHºÏîO3›Õæ°5ìxëž%ºk;÷œa¶à:÷À}-¸æÎ=ps×Ö¹îÁuuî+è>W¸÷&g>6«Íakt¥û·¢{°s?Ææ n´sÜw‚›ìÜ7_p_;÷À}/¸…ÎýÝ÷É™ÍjsØ é¾Ptotîéî‰Ï°Hp;{à~ÜAç¸Å‚;éÜ·Dp—»qæ¾T¸'HçÌÇfµ9lËt_&ºÓ$Ü×ò<ùrÁeI¹n…àîK¹n¥à %Ü÷£àÊ$Ü×òüü*á^™œùج6‡­aÇ[÷O¢»¦s?ÃV ®¾sÜÏ‚kêÜ·Fp­{àÖ ®³s?C÷u½'9ó±Ym[£3ÝÝŸ8÷,ÁµtîûKpí{nž«Ü/Ü»‘3›Õæ°5ÚÓý€èþȹ?Å î3ç¸C‚ëÜwXp_9÷ÀÜ7Îý)ºî?3›Õæ°5¾¡û1ѽƹ·ã Ç·Ù¹îoÁívî;!¸ÃÎ=pÿî´soG÷“Âý 9ó±Ym[ã4ÝO‰î¤)ÝëyÎpZpéRº×óäÎ.[J÷zžÜYÁÝŸÒ½ž'wNpERº×ót?/ÜË‘3›Õæ°5ìxë¾ º«:÷œá¢àj9÷À]\ç¸Ë‚kæÜ÷¯àÚ8÷t¿"Ü»3›Õæ°5ÚÐýªèîãÜ«æŒÏpMpŸ:÷À]ÜH縂ûÒ¹î?ÁÍrîÆ™ûMáþ=9ó±Ym[cÝcÙþ·{•s¯Ånƒs\BÁípîK$¸ýÎ=p‰w¹ע{’lÿë~‘œùج6‡­q‚îIEwÂT‘{ÎLpw¥ŠÜ—\p÷¤ŠÜ—Bp¹SEîK)¸‡REî èžJ¸—"g>6«ÍakØñÖ}—è~̹7ã ©Wù.àê9÷À¥\ç¸t‚kåÜ›Ñ=½pïHÎ|lV›ÃÖhE÷ ¢û}çÞ†3dÜÇÎ=pw n˜s\&Áwî»GpÓœ{ºgîß’3›Õæ°5¦Ñ=‹è^îÜ»p†¬‚[çÜ—Mp[{ಠn¯s\Áuî]èžS¸Ÿ%g>6«Íak¥û½¢û?çÞ‹3ä\ò»"÷Àå\†»"÷Àå\Ž»"÷ÀÝ'¸îŠÜ{Ñ=¯p/FÎ|lV›ÃÖ°ã­û~Ñ]ñ®È}gÈ'¸jÎ=p®¶s\~Á5tî{PpÍûºîmÉ™ÍjsØÍéþèîî܇s†‚‚ûй®à;÷ÀÜhç¸"‚›ì܇ӽ¨pÿšœùج6‡­1™îÅD÷bç>3Üj縂ÛèÜWRp;{àJ î sŸ@÷ÒÂý$9ó±Ym[ã Ýˈî«Î}:g(+¸Ä©#÷À•\šÔ‘{àÊ .KêÈ=p î¾Ô‘ûtºWî…È™ÍjsØv¼u?"ºË§ŽÜçq†Š‚«âÜ÷¨àj:÷ÀU\}ç¸Ê‚kêÜçÑý1áÞšœùج6‡­Ñ”î‹îwœûRÎPEp8÷À=!¸Oœ{ઠîsç¸'÷…s_J÷jÂ}FèÃW›Õæ°5¾ ûS¢{s_ê n¥sÜÓ‚[ïÜWCpÛ{àžÜ>羆î5…ûqræc³Ú¶Æ>º?+º/9÷Íœ¡–àbi"÷À='¸”i"÷ÀÕÜÝi"÷À=/¸{ÓDî›é^G¸?Hî–~msØv¼u×Ý¥ÓDî»9C=ÁUrî{ApÕ{àê ®ŽsÜ‹‚käÜwÓ½poIÎ|lV›ÃÖhD÷—Dw'ç~˜34Ü{Î=p/ î#ç¸F‚û̹®±àÆ:÷Ãto"Ü¿"g>6«ÍakŒ¥û+¢{žs?Íš n©sÜ«‚[ãÜ×Lp›{à^Ünç~šîÍ…ûaræc³Ú¶Ænº·ÝçœûÎÐRp×{à^\Ò´‘{àZ .]ÚÈ=po.[ÚÈý Ý[ ÷ûÉ™ÍjsØv¼u¿)º‹§ÜÝŸ¡à*¤Ü÷–àª:÷Àµ\-ç¸v‚kàÜ3÷ö½9ó±Ym[£Ý;ˆîvÎ=5gè(¸w{à: ®s\gÁ}êÜ÷¶àF:÷Ôtï"Ü¿$g>6«ÍakŒ¤û;¢{ŽsÏ̺ n‘sÜ»êüŸs\7uþϹ®»:ÿçÜ3Ó½‡pßOÎ|lV›ÃÖØA÷÷D÷)瞇3ôÜ¿Î=pï«óé"÷ÀõRçÿÒEîû@ÿK¹ç¡{oáž›œùج6‡­aÇ[wÑ]8]ä^3ô\Ùt‘{à>Tçÿœ{àú©óÎ=p©óν Ýû ÷&äÌÇfµ9lztÿXt¿éÜKs†‚{Û¹îuþϹn :ÿçÜ÷©:ÿçÜKÓ}pOÎ|lV›ÃÖF÷Á¢{¦sŸ‘0>ÃÁÍwîûLÿsîªÎÿ9÷À Sçÿœ»qæ>\¸ï%g>6«Íakl¥ûç¢ûoç~3ŒÜ縑êüŸsÜ(uþ/}ä¸Ñêü_úÈýÝÇ÷äÌÇfµ9l ;޺NJîé#÷2‰â3Œ\Éô‘{àÆ«óé#÷ÀMPçÿœ{à¾Pçÿœ»qæ>Q¸7$g>6«ÍakÔ¦û—¢ûuçþg˜$¸Î=p“Õù?ç¸)êüŸsÜWêüŸs‡îS…ûhræc³Ú¶Æ`ºOÝSûœaºàæ:÷ÀÍPçÿœ{àfªóÎ=p³Ôù?çþÝg ÷äÌÇfµ9ltÿZtqîƒù}7Gpgœ{à¾Qçÿœ{àæªó"÷À}«ÎÿeˆÜóû}žpÏBÎ|lV›ÃÖ°ã­û;Ñ/Cäþi±ø óW4Cä¸ïÕù¿ ‘{à¨óÎ=p Õù?çnœ¹/îõÉ™ÍjsØ5éþƒè~͹äý¿Xpo9÷À-Qçÿœ{à–ªóÎ=pËÔù?ç>’û¾\¸NÎ|lV›ÃÖø„î+D÷$ç¾”3¬Ülç¸Õù?ç¸UêüŸsÜOêüŸs_J÷ÕÂ};9ó±Ym[c=ÝÝœû~®ÓÁýãÜ·Vÿsî[§ÎÿeŒÜ÷‹:ÿ—1rŸÃÏ“Z/Üï&g>6ë­9poÝ¿Šî<#÷EÝâ3l\ÁŒ‘{à~Sçÿ2FîÛ¨Îÿ9÷ÀmRçÿœ»qæ¾Y¸×!g>6«ÍakÜ:>MÂØs÷mǼÂccÑ]È)$aÑXìä!¤Òi‹ôFF ß!k‘=È$1žƒò ¥‘êH#¤=Òù™|üˆü†ìBŽ çÿ”űrRyyy¾ø­Ë5Æ×בHwäCä\?_G#“‘¯‘…È[Ðù_E~GþBþF®âú øú’¼D,–ÉtÇ1?q,ö~] yyy9‹ë_Ä×W‘7‘·‘÷‘Âxü}Œ¯ÃñÈ4ä[¤®_‚¯?#›]È!d ®?…¯÷–ŒÅžC>@¾CŽ YJÅbO#Ý‘¯‘¿ ¥1ò62 Ù…ÜU&{i‡|‰lC’–ÅÊ!o c‘ßX¹X¬òò9²¹Š*ûŒüˆ\@x~ÈÇÈä’»îw¤ò=r ÉöH,ö òò r¹»"öy™ìAÒ<ŠÇ&Ò™ŒüŽ$¯„ûylBVŽÅJ!-‘È/Èu¤Èc±Ø+ÈgÈOÈ%äÁÇc±—OeÈä¾*±X]äCd!ò7’ã ìò>ò-r¹§j,öò.2 ùI÷d,ö8Ò ù ùIY-{y ùÙ‚$~ ¯¥‘בÑȯÈH±êx< ß‘‘‡žŽÅ^F>EV çûkÄb/ ±È7ÈOÈ~ä"’â™X,'Ryyyù,F6"‘ËHªšØ[ä9ä-äd²9‚$~÷ RiŒtGF# ‘ß‘ H†Zp@žEÞD>F¦!?#‡„ÏáÏH¤2ÙŒ\CòÕŽÅj!]‘IÈä2’Ot5ÎÈdrÉYÏH{d ²9d­‹UAÚ #•È $S½X¬Ò Š,EŽ"é_ˆÅ* Í‘AÈ"ä ’º~,ViŠ @æ#û/Æb%‘FH?d.²IÒ +Š4@z#³‘H‚—b±‚H=¤'2ÙŠÜ@ò7ŒÅj#Ý)ÈFä ’÷åX¬&Ò™ˆ¬G."¹á9鈌CÖ g‘ìc±ªH[d² 9‰dn‹=†´F†#Ë‘ãHÆWb±ŠHKd²9Œ¤m‹•Gš!‘È~$Õ«xþEš ý‘yÈ^$Y3<¾†H_d²IôžÇúH/d2™‚|ƒ,F~F6#{£È9ä’¼9æCîE ¥JÈÓH=ää=d,òòr ¹»¿ÈsÈ[È'È d-rIÜ_¤2Ò鎌F"¿# ¯ãñ‹<‹¼‰|ŒLC~F! [á9 yyy‰|lCÎ!éÞÀs ò òòòòr‰µ†òòòò9ò²9ƒ¤yÏ©ÈÓÈëȇÈdäGä/ä?$G<÷!/"o#Ão‘MÈ)ä®·ðÜ<…´@ú _"+?‘ëH¶¶xJG^@:!Ÿ!ß ¿!ÿ )Ûá9yy ùùY†ìA®"YÚã¹ ©‹t@#_#¿"#É;à÷ä äUä}d<²Ù…ü‹ÜÓûŒ<´C>Ef!¿ Ǥðœ‡<Ž¼‚¼‡ŒE~@þ@.!wwÆþ#Ï!o!Ÿ 3µÈ$ñÛؤ2Ò鎌F"¿#›Hª.ø¾Aò"E‘ H5¤ÒitAz#ƒ1ÈTd²Yì@"§‘kH2¼ˈäB "e‘*H-¤!ÒéˆôD #IÈd1²ÙŠìCN —‘D]ñýŠdGò#%‘JH ¤>Ò i‹tCú!C‘ ÈLd² ÙˆìFŽ"ç‘›HªwáäEŠ"jH¤ Òé‚ôF!c©Èä8r¹$›‹Ç’ɇEÊ#UšH}¤)ÒéŒôDú#C‘qÈTd.²YlDv"‘“Èe$Á·Ø#$’ )€”D*"ÕÚHC¤2ÙŒ\áå<óð˜BÚÏ‹ßf—G!+çŹê¼||^ü˜ö¼Í.§ÿ.HS¤ÿwñËs‘H‚ùñÛìrüºöü8·“—»Î“€·Ùå‰È:ä,’õûøåÇðµ2äûømvy²ÿû8׊—S,ˆ3„·ÙåâH¤2—7#W< ã·Ùåêøuû…qî /Z?&o³Ë+‘ãHúEp[¿Ü_û#sÅo³Ë;‘?Ĺþ¼\à‡ø1sy›]~ iôA¾DV "בl‹ñºyé„|†|ƒü†üƒ¤\‚×õÈ“ÈkÈÈÈ2drɲ¯‡ºHd0ò5ò+ò7’|^×#O ¯"ï#ã‘%È.ä_äžåx]<´C>Ef!¿ Ǥ+ðºyyy‹ü€ü\Bî^‰×ÈsÈ[È'È d-rIü#^×#•‘ÆHwd4²ù¹€dX…?×!Ï"o"#ÓŸ‘CHŸðyyy‰|lCÎ!éVãuò òòòòr‰ýŒ?×! /!ï Ÿ#ß![3Hš5øsò4ò:ò!2ùù ùɱ®C^DÞF†!ß"›ÝÈaä4rI´ÏCHf$R)TBª#uFHK¤=Ò é‹ BF!“ÙÈd%²ÙŽìCŽ#ç‘H²_ðxD²#ù~‰_.Š”Gªð6»\©O®~L*Þf—K"‘jHm^nˆ4GÚò6»ÜéM®9/ä1my›]LDf"óyy9²ÙÊÛìò^ä(¹u¼|–Çlåmv9õ¯ø=©‰´Aº!cÅÈnä8rɼ¯CªH¤)Ò „ŒCf"‹È$ëoØ7¤Òé‡LEæ#«ƒH¢Øo$R©‰4DZ!]¾Èd5rI² ¯’H¤#Ò „ÌA6"{‘È$ëf¼¶AJ#UÚH{d2ÙŒìCn"¹¶à±ŽÔD"Ý1Ètd²9ŒœGlÅk$'Ri„ô@Æ!3‘õÈ $Õ6Ì€äGª!-‘ÎHod2YŽl@v#Ç‘Ûq_#…‘*H¤-ÒƒÌEÖ {‘óHŠß1;R©4Eº ‘IÈ"d#r¹†¤ßyŠH¤ÒŽÌDV";“H¢?0?R©Š4DÚ#ýqȤR©ÌËO#u‘ƼÍ.¿Žt W——»ó˜Æ¼Í.ˆ FF#“yùkd!ò#o³Ë¿"¿“[ÈËñ˜y›]þ¹€ü‡$ß¿œ_s ìßf—‹!ïs9xù‰ýñcàmvùYäEäUäM^~yù˜·ÙåaÈxrïóò4ó1o³Ë‹‘ÈAä2/§:€ï5¤äømv¹Òð@œËÅËmÄ)ÉÛìrod2YÎË[‘£È5Þf—ÓÄãö`œ;ÊËeÆ1.//×@š ‘~¼<™ƒ¬âmvyr‚Ü^¾ÉcVñ6»œñž H­CñËÍ.ÈÞf—' óÈuáå5;¿\_+!uÇo³Ë-‘n‡ã\%^Äcêð6»ü+’ê³Hd-’ì(^w"}‘ŸDÇðúé…¬@n"Ç÷²¹†<ü7ž“…Èe¤Ì |ï"ß!ç‘ÿà9ù99‰çdryèž3‘iÈQäÓxnA&#‘ûÎà9ùÙ‡Ü{ÏUÈXd7’ížÓ‘‘ÈäžóxîC†![‘ ð F6"i.â¹ùY¤¼„çä#d ’ô2ž›‘>È*$á¿xCÞG–#ÿ!¯à{YŒ\EÊ_ÅkJdr )} ¯íû\xû|tûœpû¼lûÜhûüdûaû<]û\Yû|UûœQû¼MûÜIûüEûBû<>û\:û|6ûœ2û¼.ûÜ*ûü&û#û<û\û|ûœû¼ûÜ ûüûû<{_|{x{Ÿt{¿p{ßl{ÿh{e{?a{_]{Y{ŸU{¿Q{ßM{ÿI{F{?B{_>{:{Ÿ6{¿2{ß.{ÿ*{'{?#{_{{Ÿ{¿{ß{ÿ {{?{_û÷ñöïÄíßKÛ¿¶?kÿŽÔþ=¥ý»Bû÷uöïÌìß[Ù¿;²cÿÅþ=†ý»ûù|û9uûymû¹eûù]û9VûyNû¹Fûù>û97ûy/û¹'ûùû9ûyû¹ûºÄÈ¿Çf"S‘çbéoýüCåøAüŸ_‡‹•bbÏ'²Ï‡ûÿ÷x¢x·ÿ¯6®K"®K*®KvÛuuq]òÛ®«ŒRÄþ÷¿çÀ¦ä¯3v|ªÛ®³ãïŠEs†ëM&µ¸.Íí×áI~0þ³21w[zwlw\¸=£;öîÛnË䎽çöuÁgök%ŠÿLÈíófófs·g¿}&\—C\—S\w¯¸.—¸.·ðÎã~}Ÿûu^÷ëûݯó¹_?À_?H7{ÜÙãÇöÛöÂîGó¶ùò’³Ÿ*»õc ±G‘*ÈSH ¤V,þ3Iõ‘—ÆHS¤bíÙé„tAº#½‘È`d82‹ÿ,ÒDd2Ý©Cçæ±MßìØ<öVÛN±Š±ŠÆš¾õZ¬m‡Ø;Èk­:vjõV³N±VšãÆÿ×ÅvÅcíJÄš/‹_Ù×r±¥ñ¥|¬Eñ2øZ:Ö®n±”Œµ+kV¢X¬…ÝX<Ö¢L¬è⸢,®/kÖ¤b_QÔl“R±²¥wð¾+ÈûÈîïð}ÿxÛ¶oÚ×zî×êºz"·óêøÿ¯™…LsóÝé¿„w¸þöç¦ðßíÏEá¿ÛŸ{·?ÿ„ÿRÞáúTw¸þ®;\Ÿúק¹Ãõiïpýw¸>Ó®Ï|‡ë³Üáú¬w¸>Û®Ï~‡ësÜáúœw¸þÞ;\Ÿë×ç¾Ãõyîpý}w¸>ï®ÇK­[-üQ/†—»1¼T‹ýßï·ÿûýþû¿ßoñÿþÿú~³Ç=æÔ÷“í}òØËöÚÁ^׆Çrøš8½6´þ\Ã{EÈ•äuöýl¯-Šç.–²p ü¯$Rº”ý¯4þWή/g×—³ÊÙ ånÝPÿ+o7”/‡ÿ/f·/^ìÖÿ‹ßúI»µx™RFÆÅðµ,¿–ã×òñ¯¥Šñkq~-Á¯%ùµ¿Úò%Š•¿USúÖuåËÞbË–»UQ®4Iûü¨ñ²rÅo­YâÖ…’ñ«ÊÇáø%JÄï«…SùxEî2¹íŠò¹ —Í}K¶DîÂ0k–ƯKæ.~K¿,~gKÃ/Ëå¾U[¢dîÂè½µj‰2øu©Ü·(\¢lîårÇG*Ÿ»d±8^¸dñÜ%KæŽW²Tî’ÿO[×–d»ª#ÿ{ka%ïùO¬I¥ö>÷£*Œ X`õH±ÚOS·'nÏ™†µ'mÏ—w¹‡ö·çÌëï¹ùÛó¥ACœýÕù«KmÆ.ÿšÏUïEý¶9Ÿ¿¶ÇÐÈFǯ?¿n¿¿î/ _ß3Ñ~Ý™öëó××ox?£ýFýòó71vWÝûi|K»Ÿ1nWcþno»Èy5vÕ9ûzoÑÕ~Ã>€ù ±ù™ä¤þ¬è¾õxƒçíú[ÜÓ¬¹ÛbD¬xõEÓ¸ç6…Er¹[—¬SS‚B÷Eñ¨3škwÜΡGÎïß\ÑxiÆ’ªÍÌ*ñDÉàîv¿+‡$)ß¼¬´ç9aÑÞž”h{JðcOËyzº¯Ð‘óá½ÌS/Ößâ]™/mbíu^7'šÅ ˜¤-ÑðIJٗ%Új Ù~”¡'M“¼¥Ý°’¦þö‹àN!ZQûìêЊƱ_·Œ¨§ùÙK€ÛEÐbžw3îÞ6öŒÊqÔGÕs+ÛTuhz‹Ö¸°›M/½q·4=w¯k9Ž¦þ(Þ¶%ÝëuÍ_ç8zŒ£k[ò­ç8´–l¯!9Ž®qì`#߇–‚ ŽcÄ8†ž;ü~ŒC í Ûf¾©÷±wm›ù>¦æeN_’6kDËÔçB"k‹ãX$¶Üöžõ(’WŽ[<ñp.$±ØÉx¸%§Ø)ERrº7t^梁×w<Æ¥¬ö»`ç[NAÙ„©-e[>A¹Œ¶[ ÷?4ò°h—F ažglQÜô½ch§ÀGP.uSãØbˆ2’&^¶¢>I›ùõQy +´™¨H~¶\"ö•-Ž¨+ëj?¢8¢©Ch“Aã¤E=É)š/ïGÓs{ò±_:ºÆÁrgÝ-£èÚxzOÚæ¥ë¹}%Û'å#›nqÜÿ,> û²ñßfjh±Ãï‹ýN†ä`ZжŒbj³&móìj‹ X‚² É$iK,¾í§XÉÌTĺÅ.—N×ûXGyØvÍä¹PFË–Çòäç­P,ËÇýÏû+[÷¿ÄÇ™í\F7Mûdá¾Y¬M{¬E3ÊfÑ'ªP+([F 4É ÷ÎÂ/öÉââé7ú¦e½B‘,Ü?‹Ëi)1¥§PJ¶¥êŠ÷ÍáuØ‹ÆÁ}Ói[X‹Ô#ÉËÌR5Ž-†¼Q¸UÉi¡8ªòK‹/)Ûmù,Ü+GкÚR6K‹oûiúæ—îûKÙ¢¨"ûœ–-Š¢ñ¥HNý‘>¶-“Eû¤ÓôoCûd5øÛ[F»õØvËhóШo”-£Eû¤häcËh™÷¹[Ëdûyûã¾Y¶´í“e!ž»¥µø×½,²Ïm³¬;/+ßÇÖ¢}²>zõ¡:§o<«Tî›uËhÕ>YŸõ&éþ>ªÅû¨[Fkè½Ç=ôJÙ¬’ÓÊ=Óiƒ4c)–•rZ¥€:m7¯Ó*m™K¼RñáVY%§^o±Èþ´wVÊ¢WÞÒZK¶­ÅIì´ÔÓ÷κe´jŸd=Še-ì´†fãà^Y%§µÆ8(›UrZ¹o’FÙ¬užgl‘¬”Í*9õ*Å´¶3”ÈJ9­íðB±¬ÜCk?m)–•rZ{(ÙCÏå7½†nÌ:ÃÛí÷1N[ŠeåÞYG94>R ²m¥HVî¡u¬ÓßÇJ¹¬’Ó:›žË}²ºœVŠçþ“¹þÆÅÓ:WX[TëzÂ,ØrZ÷Ÿ·ØòZ·K¶°ÖUd`ümñ­+Œ–JYÞB=ýz?{‹°7©Üx× ;dK8߸”ÕÊ=˜ÚªsиScUçÔXÛö˵ֶïÉ"¡î@íÕT¢²Å_J,5X׿ݦáÖMMV _Û÷Št³¶×G£~‘ÅmôpÏâVÞ¹Z²¸×yYl¾³®Í ]óm¾{QÚ?h§ñn˻݋ìŠûJi\9^”Ò»/×NÓDx‘Lùri¾«{eïÊ•H §íµÒ¸h|Ol\C~×—Kã RÑ»¢¬¢wåû;äk¦ù2bÑUâFíCEïŠ IEyZ]víÇ0 5ýnIþµ= -TcÒõ.¤#·½ŒZ¨È|)j']¹íµÕz¿íü-u y$­µ¶yjÿ¦ÌO®ÃŠu›UÌHWh{¶9þ›ô—¶¼?|Ÿ&âr½¿Ý†²Ûò¾æ¥oFZèÞ{Uµµ^·øšÝBìü¤ô§|ç±KÇé{åô'U4-ý‘Îá×ö|ž×e9ö½ˆº…ÍÒÙPæxßÏíaGúTø³¤ÿt›ŸwÖµ¸|>ú^Jïé'ÿZV}/«ŽòÏØ´ ô½ªzØ™÷y©Ç?zŽ/µbáÙØ—d×õv)ô=ÖÜ^\½H¯ÖJ/Ã+æJwSdí:Ôo¹æd³_sNÒàz¾ö€ª>;¿aô‡e»½äzñ¼Ϭâ±Y”›Œ‡Þžî“äÓ¿c=´ÿ]qo>Â}/Êîóqû >:?|Ý¿o¯{{n¸)©íúmúŒJrérËÇ^ŽÎ‡ÔÝ;#æc¸þß½‚븧Ÿ%F†Â{3áb4:‹ž¸§îgÍûû…ÏrÛåûc·Ï~øXOVÔYwßöâžc.ѾÊyg«Ç„Ü÷:mr¬å\ ~áú^Œ}¯Õ¼×ò~ãѼ왓ñ¨ÂàWnH¯üŒAvÄp½ï ן‘!ýñ‘ágd„5²É®v¶ü°K?süÀ yÍžû¬=>ÿâ ½—áïpÓÝ”Ö37QzºxH›eÈ^Xúž% Î럺á*b‰¾¸½¿"ˆßô°aF©yOó±×®äØýÛ¥9Ù ðó<Úà#ìºçâÞp}ÒuF ¿’Öƒ2–ºãój“óÑì|È7Ù§®žú¿z¾ê®j~‡#¥K¨îæ­Í×óÜjaËî$ÚîŸ8SÁϤ·w»¨…bôFð(À/GðÏo¥Ï£ÛG|,ï´ç‡ÛK£Ýv1À‘2ö—œ7ÌA†ÍÄåVd—ŒIÞÃnš=hÍﻊ2dÓ®¹MS¶+-ÿ®° /îµBõÔûÖ7pp¹UÙ†cÕ¼'ùØËm,ñqŸ'ûj†}5¹6ç¿éôôBzszsÏï|Äþ&S±æbô{á§q¦Ý5¹ k;}šæcîئ4îiêtò[å2ëiN¼Úú1Lñ7¹ ë±Iç^{~QÔP~¤ ÍŤokr1Öíή6Jöcö6¹óß½ö&}“ òŒmsp{Îf¯çmRtJo6ÍIªºm“ùøæ}®7½ó ä‹pv|îí)jNfŸ=û›]¦¨kÆ“kböùi·g‚ìLÚƒsØûÞ^zâ5õï9zTð†ãèå^\ÎÈä·rÎçuoîÕ(>¸ç,Ÿv\ƒ•Èÿìo>ø‰ô±Mïs}ÚqýñyüVΕöü¤ûm.¯P½Â^ü46{Í×â\Ç_\{ëagšµK>W%Û­ÇÿÕëiy6§ë§ù¬Å•©{»ò²çX*|æ^ƒ‹zêrýT& c05Ú˜WzÏÇ¢*Öœ<ùï3 æ7uÕu}#‹ëo1„ÃõyÇ–ÏãÊôçqÓ^ÒOמ÷•»¯™v|FÓ†7\ÞÚµà7«iÀã¹ö;Ê5ß÷“?Ö{„i¼gÈ‘¶{†Ãt÷/. ÷ 9Òl…É^ÿ1Ø3äHsýr¤^ÒTÏãŸ[ËÃ?2¾ý –—1.3}ÓTŸjÍ*iïKjþö*Óº›Ý-½Ï˜qZHaµç}jbKÞ¦åѤ°Ûe…oÙ /¬›ïì/¼øn’Sº4•½¿vËÞIWÿä/¬wŽ'Œö}# y˲¬·ÓÙ_„kÓx_áÍrÃóáÇ4ßW+ç>—ÉRL\e¿ßn™üÉ‚_i½Ë ¶ZØšš1¯&××â~Ù3^¼‹4˜Ÿ[ ÛV¾®•6¾Ü\«‡‰8¢ò–¢‰Û–±èv‹Á•bª+ÂgMÔÕƒ+•u¹bhù¹\Ñ, SØ‹4hû-n…?ü^¤z¹Ú¬w»\yL{Þâ6æ`·¸ÕÔSÜ;5MÕSÜ\•ËÕ ¯œØК,ö[Üœ•¨¼¹ª'¨¥»›3IÜša–H VZ=ÍnåÍ™Äaím„Æbtµ"ö×å–_+¸z=h±¨7¸Âv–$¯•6nåÍ•¼++¥1ïÝ=_órEs)Â’Ï“vYš×¤"ðÄý`L*á.—(÷W}Ún+îoõ93¶Ë=l­ 9‘FkÆýЩå1Ýåeò—=šÁ…ž­p¸_9FÂè÷y»¯áªXZB¤½øÙŸ¤QÞeÚCóUÞºn@e þ|õðwøáõÖ—}qk%hÁh§ÈRyóÖV”݉úáyÝãp;äÔ{¡¿øÛŸ™1‚¿0ŠÆˆ÷[·}ÚY¾~ ÂnÐ&ÆhòC[jöWyó8׫¼ßñ«¼y\ÁoÚ&+ÞoÄÃæü•åà/tÙùŒÛÕÚ|ߡÿø£nH”§†M¨¢'•\$®µoúkø°QZÌ_KÅ9æŸWn3´AÚæ¯×[Þ{ÈÔû2uÖàÏí[ê·±{‰rÕß<ÞðÇ.SQÅ«Üs¶WyÏßœ¯òž¿õâooSõrõÕeô`—–bãUïcë)¯rù­§Ÿúѯñºâ˜ü¹V¹i!#˘¿1C)Ìç¹ö¸é딿yø+Ο¶K*Mû:03ékv¿j8d÷Ýòª(’ðб%QîoÇ%>äô­¢Ïñ":„è|üôà[sÝ>×ó~cêNÍ|ºëF¶Ü!îËf_—Ô劔6'ÖÐزÛ§æ«OrÃ(Uz/q¨Ÿ/qfó}½ÞÒÓÍ ±ˆhŸšgϦ¢h tíq„¶È²ÙHe bà(Ûæ>žv¿lnæ‹ìø|÷aöŒž>ÿWó¨îPÍ'xêÿ>h¿aó×*¥¤Å&iæ‘o=fþ"]iŽ=Ö‰5´Ö±E9Mþì³ÁLÛçëACý|‰S]<ÿ÷n¹nÍCôh‚×4ów–þhî@*š+į¹êü%†îü%V)Ð_b“ý¤Ω󘄚ã‘--€o¯šó4W%;5×›hæã»&+¹@ÅN-äœyèÕü½yP˜Vä_•vD3òÏ9_Ϻï‹T_?Úª¯õõ͉¾þ›D™v¦×9õýYÉ~ßûî·\Ý|}×WY_çxœüüUA[>ï†é)ó•Ðð̲ý¢SœúοÊÁ=÷WŸözÞpâí¿ß²ÅøW}ÕŸ·\’ÿšõ=h®ùË¡1DÙÝ¿ÇÔUIïGå¡wvÊó¾/ç¨Q¾•õ¼!öOÿ3Þ·êG¹ÞúóÊ£9Êî£9Jsð¯íËÿÑÉèQÛm!ŒqkûH§ÏüXwªQwL°aF'3G9½ïùz—“ïrú»œ¯NGº¼ï£ ¯”9>Øl‰ 6B„Y¼Ž [ñ«¡<òñÁ,ÖWíîÿýf$&„wÈ.l%œÄ‹L%ÚŠŒ/+Ö’ìIá2 LØÊñ,•ð$PØ:lÅæxa#X8j‡_¦„ƈf1GiŽ6Ç [É$‹„¡Âøá x{O¹Èô‹’£,>Jÿ$˜£ˆ­Ôô•ZÎ#«Ï@à†£ŠÚ3³#R1!Ž›{Xiêûø©Rl 6GûšsÙî(#7ħJ¾ +=ße÷w)…•€¼›ãŒ­„'ªôew.ÃaA\±ÛŽ4¶bOhqÁ‘îs¤±ÏÍØØhlDËaSæuVglŽ:¶ /6BŽIð®æu mlŽ=¶²ìEÞbïd+«¾ÈÎòQ®Ë §mTÉþJ7š9 Ùƒlõ¹Þ­ê L`9Ȩ̀á‡Àj|?VW´,-ÇVC!¹8ùŒÒAÉæd«vGIT²ÌK½K%{8ƒ‘Uäd‘›“#Á+É>ÖòœGú: 8™ÿË%ûøÜxª®™#”­&~Þj&UÖÏ·.ÙjÍQ* éÚ™æXe#0Ùj½n®ê=AËVjÕõ‡-[mõU›¯¡érÜÚ>>þÚŸCvýÇAÌVc·wø²ÕZ[=;s³9ŠÙj¿œ¸þS5ÊÐ}Ǭ›Îàh·¶¿Kþ:æ%;k¾¾lŽeö›Óœ—“é<ºð‡.²³æb¦¡æ„1O7Ê,,´ {{jAu½fpQbÝû:ª¹‚Î'˜f†Å Õÿ·KîNþÿºÝ f[8Ђ¼w3¥–•y¬Ë+Í7zwGµpz¨:"`zh¦Ø­ÿÂ\- ÈL}ûöÔÂãE]ÙQ¡o@¨µXO ‚Y¶l§exÆ¡¼&€3¿8VKâHp-•ÿ–Ž@#þY,i1y¦i 7ýÉJ‘7þ µ€LÓÃs°Ã> î5o®x”T/‰ª~?“`’UÎÍâ7™æל6Þ¬‰m¥ßBcí(§Bèå¿`e ¼öÔ.ž7ŽØ™Š÷ýÌyn2Ë6ˆçLfÊaÆq¹þÍo Ü ã¢÷ Ärú„­Õxgvnþ¥…̚Ѱï3]‡i‘e9ûkvÔ·f†Ç"ÍÖ½´Ðs^Óº¬­°°Ö"ñÏ~[¹ÛÕ¥ž Û“‘gt§uAejé©tF ;Aœß¤¥ôÁøZs¤­ž¹§©­œ˜wù¢›’ qn¨mïéi&õeœ.kbSchTí»…«É±£tu½ŠHúâØ“!­EˆÖŸé~h9#atᎲ·é Öë”ufšcSù¦ŸD¨ZŽœjQAiƒ|Û/>Ðb†ÿ<3ྀZŠÓªÄÝÆô²8_ÓÀAÄš ÿ~Si¤¾¦<3ÓÎóƒgŠ2¬¿»5& 5G+‹ó%ý¢~­é{GÃ)k múÒÿh:}p¸¦Dƒ¤ýѲÈÕwù‘HÜ?™#ã¢V­ z:44ç¢MO0”35üÑÕ²}žùÿš`ÀDD›]ÚbM¬hµ†CcÝåoÊoð›i®̪ š‘Ô?þ<ךBSB 'Ü8ºÝ:êן;Û¹©=}l·˜:"7Úò†v H %TÖ·g½¿›Üø8|5»üÎŒß(qæÍþ™€©G´<À\½…â`àìVIþ¦$D»ÿÃL<ϵåpœw(ÓX˜jÞÌ–zU+ß®y¶…ìÖÍÌ”mcëÀÓ(ôgvµ® „>íI&)@àbë3äÑàL,ŠÎõùÓ¿ûi<»‘ {€òHrïç…P áà±'j±’Ÿ½¡ã!ò<ž-ÉqOÉóxzœÇ³_¼ÀM<À㤫$ý•ø­çñÔ¥óx<ŒÀ‚8§ÿ2lÙijr‘ý5?ɵÇÀíD[µ°ü¼E4ßœGÔ»<?.J_óá%(óD»Ÿˆ+$«çö÷2Êñb…vÏ žÆ´;ëáÕ µ ¿ Oòé·š1)Ò#ô`Y»á«v :Æ|9á¶éŸá°¡²Û7ÌHŸü“9pA8Žk)£‘g#T8÷ ~/ÀsÛlÔçEh$w¦gµY¤³Ùhá—kqN‡†ÓÄ?sÊV3ÏRSÏý¸N=?Í”›„ê„ëÁbšôYg6Ü”2Ï9 j{ÕàœZnÌðÇüe6þÏ\y´1_O¡W| ¹eãåd–˜8ïj¯¥Cp=mcÍKp™Zë8Ÿó`Éq6O, ‚ûZçsWÕG8ŸÓkœõâ‘e›O{5aô÷¬(Èé/c¸óyõšwíO?nöð¡¹^üNÔXrº^|Ðmig>HÐM‹Àîóâ”.ÍŒ ‹À¸½8Ut÷Å)½ü~–Ó!0g/Noä7×¾‡|y'a`dólÓ#ÂÅ^r¾¢ìÃõÙÁ‚Í=¼ëÚÀóÙŒàñ‰áÎòœ>Ü4 ˜®1{î„p³†¯¨YÒe—ÑÉ@Ò2¹Î¶‡ÓBNû—Sßwìk³$§ãò1ÄXÌEËì©áœ`œ6™a~9õ5㨻é¡ìùšSî.xíÉŸp«'Æêû‡,|ÏÝëG×°é¿'š´'C§7@HÄâ´%›íDQ„ŒçY8[MBÌ)¿„¯–l¶Œõ…ƒ{žb¾}~+KlÌ"œhgpÚs+#ï9‚ª±.ëáË*•¨†{ÀfE}ý÷t˜’Óöâto£Šv¾gL¡MÍ©›³ÿ3§ÜqËë)®v'ÚšI‡AŽ9½Ñ̘ÓQ’sJtKó Äç‰tæir£'Á¡9¥Ô^çÒÍhn²|=<™5–= 3j¬CÈ°fÄ"ç –zü‘„¶sódÞ£šŒ¸p‹slÎŒZ=MÜ =çx5a`.À&LŒÈa¼ýõ$¡!£œ7›Ö¦G¢n ­Ñªòxâ%ÔŸåaG"Ó\•+9­7`E¤º/œ¶çE`HëbR`v^;mëE §/9í7çß)¥`FÏœnë'ˆ/<“2=ö—MÜB\vļÈåÖ œ*a3Ë †OH½Õ“vê=R_£åwªÞ$S#öÞB%W¸ÎO/|ÅØ–‡Þžñ"ð@ǡb7뜆å:†â8DdÄÐkÌñ1íæ±^l*ùö» Ó„“–_E«ÎÿLè¾:0NTj_}VÖ.lÒþA@¸œöƒµ 9ô“@_hC*T¸¬F^i{ašš_l1οøL=è­×£3õf÷òÚçLYëý¹—å^ö{yô­>p/¯M2ò›dy$ˆ_Ö{9Îåzîe¹—ý^¦b7?Ìò(¿ÌÖ†ÙkÓ5å‚Å¥*àùT@¹—ý^®sy7¦D/åì¸ÒÔ_—Jö­ãS¡]½¼‰ßÖ¿²cô«åw=­+ ŵr‹ËP¼ë½ÔØâTÞ¤Þ5œ9Y~yÖ˸+6“°h½ž¬• û ‚žÐ^3T­åf¯dH5C”iÙz&Ëm±î¹N™Ñâ7:^7J&³DW¡Ÿ{B‹¸ò–?ÀÉ•ií¬çuֈ̔ýs“8Ù €Ý³a«ŒSzzLyÅE»>„LrÉfŠP…©ìr†¨"a&Ož¹¹.aPÇìò£ô¬ÛYF43†Ö#qÓ³_W+»ñlÂ.}n|Ì«ét7'¹UíÝX„òn@F90nf+ªŸ‡Ô¤Aýœd·´ÏÑ6ÊhÉØIŠñ8G˜à'®c:´&²c>7€ß+9&ƒ/ʉašcþn†Lp J”‘¡~bUÁH©/ví²h­{¶LžEâÏðà›ß>á·ÜãFz¸sHeÛSh†ý2}EFÿRâÌL\W?-{Ï¢ÑÃó„’?Ùù™Móm1•M“]e½8ŒäÏûò„šW3H?glxN{YÃðº‘Nj¹ŽÛ}‘÷R¿-Z8àå"øäØdWÇSn:¦ý^É6Ÿ\›èJ1Ãô;»çà•t“7<ç&Z¬ôÿæáʽI—‚çÕ­qA,—VÏvqiEqi÷³G‰v¶Æþ\ÚúöGZž\—ý9Í>ýèü’fk~yŽÍ.êµW½7æ™æ´3D›oÚm½h:Áb½³³?åþµOÊlŸþÜþÚ‚vñCÿI*d¦ù Çq6äµÖ»˜vž;W»õð¸. Ï:O<Ç?§Â‘ŒÇ·*<îÌÉzïþVöwÐ/*rκUæ¡Ef!{.-p ,âÑù§?‡Ú¿RáÄòžÕ«YOüÝ}ùs,X`D’?;™’¯þÖ¥eWÝ ZlÈÜËñè¹±âñ¼:¼ƒñxÄTîÙï¶yú<ó<{Vx¿Ϛÿ;:ebž¶Ê´d‡¶‚ÅiÉße¼œS³¢m÷§*Þqùö7“v@ñ”õÎR+ËåŒ×ÿò§lËö™S‚Q“VNÛ–Jj†šÁTóø<½hÿ~NàYçÊûÌïWøKôÇ5ÐâÈ«Kc7xΩБêuÛ¡µC; l&r‚éçÙߥÍóUc‡ÞŸ~À‹Æq†æã'÷K0=û;]Õ¬w¢ÖQ·û㋉åVÒN–ª²cyÈûÓ×{¼Þ89ª'ŸL5ÿ'ÏÈS–ð$1?rßzý§dЬÏ>8³¿®ø"ÒÍo™ðÆVâ#÷¦Û§?×áÛ;Œ ©ïÁŸg.½ÎÊþ‚„çsú”g±"ôñw¢,·¤_ÍÖïïÕŸÓü;Òʇ?ÿŽÄ$þiíÓŸG‚V’Ö’†çø¾ñœ(ìøÿaÇó;>Ø9]v|ã°ãá‡óf`×WÎÝ2~”C—ªp Á©ç7?Ñ¡Ë¢ºõ[·ÝË~/Ó@…t¿¸ÔÓŽ ûœPîe¹—õ^¶{ÙÕÃÈ(évζ€Ÿì€òaç° Øñ¡Á<Vê½l÷²ßK±^Ò®õW¿ â—õ¹—v/q/˽¬÷òvv ûÐïˆØÂñR,”{Yïe»—ý^Ž{9ïåñ~¬s:­sr­­òñÙ¯òº¬ªÐ¾ú½¿e~+¬sYŸ{)­ê|hlH/:îÊÖùšØªý[!¨óKÕ(Úsšï·­øt„—"O°òËz/Û½ì÷rÜËy/÷cÝæ:‡–Ø:P[½ÜËz/Û½ì÷rÜËy/÷csElù€À¼V0«Œ3‚Ù¯°ªE׸f%Š›£ŒP¾+˜Ø ¦±‚¡F0¼%·Â|1ûrëlÐýQ|ß2_ †7`'ú†a.½ƒ­;Z5“­ëò:˜¬ s#ÌKóQÁ#˜ ›Zä‹u§×eÓÅN–ZñÌ9¦‚)©`hæL0€ÿ¡柂AF(å '‚ ¦`Ì@…ÒNÁÌR0˜ÿ]¦—B©§ðß~a.)ü§aO´+ÆOÀ°.utS+þSFÁ4Qè‡a gV#P…I£`,Ê"…ÿŒÿò Š`Æ( Çû…ùŸ€Ÿ”WØÞ—>³?Á$Q0¼è—ÌDsAÁØ!üG` O)S:Á,P0Ž&~’ FÁÈ!üÇ]˜ï ¥z‚Iž`:'9£‰€dƒÉ›`2'=„ÿ¶ ºÆÅßjaþ&ü—\R„~ÏÌÓ#ˆ`:'ü\ô.`–&:³6á?ä¢_mƒ…`v&˜³ ¡4MÀÏ&¤DøO¶0`ý† ˜š‰â¿@Ù`E³.ÁÐ!˜z ¦eBC0\†Á$L0åJÄó,Á4K0½ÌÄb‡`:%)c‡`Ž%JœŸH±`¼Œ‚–(Â11­Ì–DñŸ¢l(§ÅˆQüç‚( E²Á¨ ˜; æL‚QC(‰ÌŽÃ…`Î$˜ %R‚ñB0B&E‚é‘(Ú7S Á€!˜- ¥H‚)‘`¾#˜ ¦BB?µF Áø ˜ø¦CBÉ`Ê#˜à Áà ” ÆÁôF0õLwDѾÁ€ ˜Ûf;‚AC(µ ‚IŒ`R#˜ßˆ"Ù`LL^Á¬E”©qQ"˜¯f1‚aC”­øûH” &.‚ÉŠPò"˜¬f"‚ñA0Uúu0>æ!‚)‰`Î"“Á` ˜FQM­(Ì3£‚`""jü®Å‚‘@0ÕÌ:D Œ%‚é…`Ì<„ÁìB0­L*ÂPò!ªÿf”ÿ6¥„BèçOÀP ˜0ÆÁ¼B(­Õ-Š²Áh ˜3å‚Ñ@0C ‚ƒP!˜,†þÀTA0*ý¼ ˜ f ‚É€`– 3Á ˜f¢ú·Ìùã€`ìÌ „RÁ\?0ùLò3Q§ÆÅã`æDjE±`€ Œ¡ÁO¬JŒ…Á6õMƒ"e`Ð €¡¹€póP” Œz.4ÿõ~]þÓ÷ÀÜ<й†!—èEs÷ÀàÜC$ï˜bwù¸ÿ…){P²šÿ¸#ü§ºØŠ²!˜´ZìpO³à û³Äà>f›Á-uY¼`*Ü„vû˜éZP’˜w·úܼdRd¯¢ùÉ«Íë²=$̳¦c] È‚3…Àœ0©Ì ‚òÀd07̹SxÐ\%Ó]ÀL0L~¤LY“ZÀ40÷ÊTÓ@ÀD0ÏÌD’JÀt0LÏsD ,0Ì°“3Àt (mLu³$ÀÜ0‡Ê‹@wÙXÞt·bºô ¦€pÞ¦ @I 2߃ ~ånjEÙ Ľƒ€{BÏAÔ:ˆmaêè’ ÂÇA˜8ˆ2qè8Dzƒøl·ѵo â¬A5Æ€Ú Ð„BƒÀeÚ A¦Áhˆ=‘ÉàN@¿HiAü(y÷ÐN€A50ìÆlAL)tT('÷` Ý=N²ÁH.ºÿtÅ‚(RèP0€HÁÀ.Ò…âe` „‚Ñ]0`ýFca`´Œó¢ë›Âè.Cb –:6Œt¨Q0î ÀЧfƒÂÀ¸/íá¤Ðá¡`ÜŒlÁ` — í iQ+0" H¡_lQ¢`DD‘‚!,èôP0‚"GÁ¸0'†bU`$ „Œ‚Á*0` ýüãÄ ‚ŒHAd ÇKS"1#ÈÐ)€&. ¡À02„"á¡`D‚a'èüP0Š F”À°2x‚~Œae0°‚F!)3ãË > 8C¿yFÀX3eCDfŒ5ƒèP0 Š ô(þ#Ï @„B'ˆ‚‘ ÿAAÿAJ‰ð¢ T ÷€q,  F¥A (ˆ #ÓP˜Œî€ñi02 †r ¢`„„‚ Q(f B;A8'ˆúÄp‘l¥ "3Aì&ˆèÄ”lž .A%ˆÅÄ”;‡ K% b'AD%ô» î„G‚€G ý\1¦ÿN0eƒÀFöˆ µ¢DÂA#Gñ‚ ¾D‚ÀBèQ bA ˆÄ”lÄ‚A òÔl¹‚ó@PˆÝÔlƒ¢ê@ð¸ÃÔ7…8=bê@¤tn(l!o DÃAX9¢ÂÚ@aƒÖ‘g È ¥Ø5èì|%†é¿/I!Š s¨•ÿÂäô—d{J‰ŽÅô#±¸e÷B» ƒîAˆÀÂôƒÓ):DD]8*]b® £îA؈†aU h ::DA˜&ä‚£ üˆc‘I € Ä+A8',ÿábŠH Z :;t)Î$Ðû:›°$ôayŽ7ú– ƒçAgèýE —ò%^ ÐñzŠ@Oä$}: ËôÈúy@èÐ<³ôØ€¾Уúr  èŠ0 ×ô×@žÐ:Z@ è“\0 Ï<Çt®€ÎÈùFKÁ,sªXÚ7x<7CŸ`¼k¨eƒNð”m0̉%;…qJ,ÿ…Q C™Xú¦0 ÆÁ %–ÿö¨Û)åñŸu±àaúŒ+BÁÆÂ`_a°ðÐêÂXaQÜ°0nWø+ŒôFõÊó¨Õ–°\áÑ…Á¼ò˜žÅŸ eè­0ÖVxÌsy|ß(Œ“Ú Ci…1¶ò Z±›ç4†ÂÊãߔƒ• ÃZ…±¬ÂÈWyŠZU6àoó„äÂxUyŠžUY­²Aå+ÛW«ò Í›²AcS×E £=…áÂXPá9ÅåijÕù˜ÎºM›7Õ³:9ìlÐÙ¾³U‡Ã°îðö|´£\ £*…a”€Ha¥ø½ÿh*ýÀopensmt-2.5.2/regression/state-dump/QG-classification-foobar.osmt2000066400000000000000000010450211445011647600252170ustar00rootroot00000000000000ñI¡õ¸õ ö}öŒö™¼‹‰€.ƒgîˆÑˆä…(j@fuj­$à‚ jô‚Í‚°‚ò~T-ß~öiâi…ko…a‚~{k@ˆ-:‚i~-uR…5…ÎiL~N‚'‚ ‚íÄi}~°iqk&~ ~ÆoÔ‡E2žœio’iÀ„ŠÃ}Tow~iG}Ao°}“}tiY}gkjip„ø€}C‡&‡]kÑ€ViôtS„Biª€Sk倾€½-8iÐ|.iIkä|½| |±‰±†Þƒid|i‹†Êƒ+€?kát·ƒ5k€òh?€èhûÞ |+k>|]4 |ð{Á\ì]abäÚXÕ>Õ$Õ ÕØÚÓoÓNÓ-Ó™¸¸…¸žS¸I¸?¸© ¸¸ù·OÇ·½·³·õœ·w·m·c·)ººíŸºã¹Ù¹“ŸÏ¹¹“¹9Ÿ‰¹W¹M¹C¹9¹¹ý¸ó¸ž¹»×¡¯»¥»s»}¡i»_»-»#»»»ÝºÓºÓ Éº—ººy ƒºÁ£I½?½5½½ù¼ï¼å¼³¼£©¼Ÿ¼m¼½¢c¼Y¼'¼c¢¼¼ËÚìÓßÓÒÓÓùÒm²Y²E²1²Rxå²Ñ²½²(y©²]³I³5³!³Õ³·zÁ³­³™³{M´9´%´´¾Ú ÔÔÔùÓßÒ{`zÄy y6{}záyoxS{šzEyŒxp{þyby©xÔzzyÆx±ÚTÔGÔ:Ô-ÔÅÒ•Úñ¹±¯±¥±i±_±U±K±±±û°ñ°µ°«°¡°—°3°°Ï¯¯“¯‰¯¯u¯Å¯»¯±¯§¯÷¯í¯ã¯Ù¯)°°° °ˆÚˆÔ{ÔnÔaÔŠÒB­/­­ ­7¦¶­£­­ §}­*®®®ñ­ž®œ¨‹®x®e®r©¯ÿ®ì®Ù®{Ú¼Ô¯Ô¢Ô•ÔpÒ6ªªü©ß©û–Òªµª˜ªÑ—{ªn«Q«4«« ¬ì˜í«Ð«³«Â™¦¬‰¬l¬O¬nÚðÔãÔÖÔÉÔVÒ«¦Ž¦q¦T¦d§G§*§ð¦¨ã§Æ§©§¹¨¨b¨E¨U©8©©þ¨aÚ@ڹјÑwÑVÑ+ž!žž žÑǽ³wmcY ÿœÃœ¹œ¯œ¥œ   ÷ŸãŸ±Ÿ§ŸŸ‰ŸWŸMŸCŸ/Ÿýžóžéžßž­ž£ž™ž…žë¡á¡Í¡Ã¡‘¡‡¡s¡i¡7¡-¡#¡¡ç Ý É ¿  ƒ o e Ë£·£­£££q£g£]£S£!£ ££ù¢Ç¢³¢©¢Ÿ¢m¢Y¢O¢E¢«¥¡¥—¥¥[¥Q¥G¥=¥3¥¥÷¤ã¤Ù¤§¤¤“¤‰¤¤M¤C¤9¤/¤%¤Kœ7œ#œœÓ›¿›«›—›[›G›3››ãšÏš»š§škšWšCš/š3Ú"ÑÑîÐÔкÐo—R—5——(˜ ˜î—´— ™Ï˜²˜•˜¥™ˆ™k™N™&ÚÒÒûÑ<Ñ ÐÚùÙDÐ#ÐÐáÏá×Íù‡}si_-#ӌɌ¿ŒµŒ«ŒyŒoŒeŒ[ŒQŒËÁ·­£qg]SI ùŽïŽ½Ž³Ž©ŽŸŽ•ŽcŽYŽOŽEŽ;Ž«‘¡‘—‘‘ƒ‘Q‘G‘=‘3‘)‘÷íÊJãÙ§“‰MC9/%•“‹““w“m“;“1“'“““á’×’Í’Ã’¹’‡’}’s’i’_’-’#’’’’•u•k•a•W•%••••ý”Ë”Á”­”£”q”g”]”S”I”” ””ù“ï“ØÙÏ‹²‹Ÿ‹•‹‚‹G‹4‹!‹‹ûŠÀŠ¶Š™Š†ŠKŠ8Š%ŠŠÿ‰Ä‰§‰”‰‰n‰’Ï ‰äˆÇˆ´ˆ¡ˆfˆSˆ6ˆ,ˆˆÞ‡Ê‡·‡¤‡‘‡V‡9‡‡ ‡ö†»†ž††n†[†¸Ùø…î…Ñ…Ç…´…y…e…H…+……Ê„„T¶„¬„z„f„I„6„#„èƒÔƒ­ƒšƒ‡ƒPÏ$ƒƒê‚¦‚k‚D‚‚‚㨔mZ=Û€´€ €€R€5€€ñÔ/ÏqJ#ü~Õ~š~s~V~9~~×}Í}¦}‰}l}'} }÷|Ú|³|n|Q|4|*||«Ù<Ò/Ò"Ò†Ð"Ï©w–wƒwpw]wJw7w$wwþv‘v~vkvXvEv2vv vùuæuyuSu@uuuÎtatNt;t(tttïsÜsÉs¶sIs6s#ssýrêr×rÄr±ržr röqãqÐq½qªq—q„qqq^qñpÞpËp¸p¥p’pplpYpFpÙo³o ozogo.oÁn®n›nˆnunbnOnHR\fpz„Ž˜¢¬¶ÀÊÔÞèòü$.8BLV`jt~ˆ’œ¦°ºÄÎØâìö (2<FPZdnx‚Œ– ª´¾ÈÒÜæðú",6@JT^hr|†š¤®¸ÂÌÖàêôþ&0:DNXblv€Š”ž¨²¼ÆÐÚäîø  * 4 > H R \ f p z „ Ž ˜ ¢ ¬ ¶ À Ê Ô Þ è ò ü    $ . 8 B L V ` j t ~ ˆ ’ œ ¦ ° º Ä Î Ø â ì ö   ( 2 < F P Z d n x ‚ Œ –   ª ´ ¾ È Ò Ü æ ð ú    " , 6 @ J T ^ h r | † š ¤ ® ¸ Â Ì Ö à ê ô þ    & 0 : D N X b l v € Š ” ž ¨ ² ¼ Æ Ð Ú ä î ø   *4>HR\fpz„Ž˜¢¬¶ÀÊÔÞèòü$.8BLV`jt~ˆ’œ¦°ºÄÎØâìö (2<FPZdnx‚Œ– ª´¾ÈÒÜæðú",6@JT^hr|†š¤®¸ÂÌÖàêôþ&0:DNXblv€Š”ž¨²¼ÆÐÚäîø  *4>HR\fpz„Ž˜¢¬¶ÀÊÔÞèòü$.8BLV`jt~ˆ’œ¦¯¸ÂËÕÞèñû  *3=FPZclv‰’œ¥¯¹ÂËÕÞèñû!*4=GPZcmw€‰’›¤­¶¿ÈÑÚãìõþ"+4=FOXajs|…Ž— ©²»ÄÍÖßèñú '09BKT]foxŠ“œ¥®·ÀÉÒÛäíöÿ#,5>GPYbkt}†˜¡ª³¼ÅÎ×àéòû#-7AKU_is}‡‘›¥¯¹ÃÍ×áëõÿ '1;EOYcmw‹•Ÿ©³½ÇÑÛåïù !+5?IS]gq{…™£­·ÁËÕßéóý%/9CMWaku‰“§±»ÅÏÙãí÷ )3=GQ[eoyƒ—¡«µ¿ÉÓÝçñû#-7AKU_is}‡‘›¥¯¹ÃÍ×áëõÿ   ' 1 ; E O Y c m w ‹ • Ÿ © ³ ½ Ç Ñ Û å ï ù ! !!!!+!5!?!I!S!]!g!q!{!…!!™!£!­!·!Á!Ë!Õ!ß!é!ó!ý!"""%"/"9"C"M"W"a"k"u""‰"“""§"±"»"Å"Ï"Ù"ã"í"÷"# ###'#1#;#D#N#X#b#k#u##‰#’#œ#¦#°#¹#Ã#Í#Ö#à#ê#ô#ý#$$$$$.$8$B$K$U$_$i$s$|$†$$™$£$­$·$À$Ê$Ô$Þ$ç$ñ$û$%%%"%,%6%?%I%S%\%f%p%z%ƒ%%—%¡%ª%´%¾%È%Ñ%Û%å%ï%ù%& &&&)&3&=&F&P&Z&d&m&w&&‹&”&ž&¨&²&¼&Å&Ï&Ù&ã&ì&ö&' '''''1':'D'N'X'a'k'u''ˆ'’'œ'¦'¯'¹'Ã'Í'Ö'à'ê'ô'þ'((($(.(8(B(L(U(_(i(s(|(†((š(¤(­(·(Á(Ê(Ô(Þ(è(ñ(û()))"),)6)@)J)S)])g)p)z)„)Ž)—)¡)«)µ)¾)È)Ò)Ü)æ)ð)ú)***"*,*6*@*J*T*^*h*r*|*†**š*¤*®*¸*Â*Ì*Ö*à*ê*ô*þ*+++&+0+:+D+N+X+b+l+v+€+Š+”+ž+¨+²+¼+Æ+Ð+Ú+ä+î+ø+, ,, ,*,4,>,H,R,\,f,p,z,„,Ž,˜,¢,¬,¶,À,Ê,Ó,Ý,ç,ð,ú,---!-+-5->-H-R-\-e-o-y-ƒ-Œ-–- -©-³-½-Ç-Ð-Ú-ä-î-÷-. ...(.2.<.F.O.Y.c.l.v.€.Š.“..§.±.º.Ä.Î.Ø.á.ë.õ.ÿ. ///&///9/C/M/V/`/j/t/}/‡/‘/›/¤/®/¸/Â/Ì/Õ/ß/é/ò/ü/000#0-070@0J0T0^0g0q0{0…00˜0¢0¬0µ0¿0É0Ó0Ü0æ0ð0ú01 11!1*141>1H1Q1[1e1n1x1‚1Œ1•1Ÿ1©1³1¼1Æ1Ð1Ú1ã1í1÷12 222(212;2E2O2X2b2l2v22‰2“22¦2°2º2Ä2Î2×2á2ë2ô2þ2333%3/393B3L3V3`3i3s3}3‡3‘3š3¤3®3·3Á3Ë3Õ3Þ3è3ò3ü3444#4,464@4J4S4]4g4p4z4„44—4¡4ª4´4¾4Ç4Ñ4Û4ä4î4ø45 555(525<5E5O5X5b5l5v55‰5“5œ5¦5°5º5Ã5Í5Ö5à5ê5ó5ý5666$6.686A6K6T6^6h6q6{6…6Ž6˜6¢6¬6¶6À6Ê6Ô6Þ6è6ò6ü6777$7.787B7L7V7`7j7t7~7ˆ7’7œ7¦7°7º7Ä7Î7Ø7â7ì7ö78 888(828<8F8P8Z8d8n8x8‚8Œ8–8 8ª8´8¾8È8Ò8Ü8æ8ð8ú8999"9,969@9J9T9^9h9r9|9†99š9¤9®9¸9Â9Ì9Ö9à9ê9ô9þ9:::&:0:::D:N:X:b:l:v:€:Š:”:ž:¨:²:¼:Æ:Ð:Ú:ä:î:ø:; ;; ;*;4;>;H;R;\;f;p;z;„;Ž;˜;¢;¬;¶;À;Ê;Ô;Þ;è;ò;ü;<<<$<.<8<B<L<V<`<j<t<~<ˆ<’<œ<¦<°<º<Ä<Î<Ø<â<ì<ö<= ===(=2=<=F=P=Z=d=n=x=‚=Œ=–= =ª=´=¾=È=Ò=Ü=æ=ð=ú=>>>">,>6>@>J>T>^>h>r>|>†>>š>¤>®>¸>Â>Ì>Ö>à>ê>ô>þ>???&?0?:?D?N?X?b?l?v?€?Š?”?ž?¨?²?¼?Æ?Ð?Ú?ä?î?ø?@ @@ @*@4@>@H@R@\@f@p@z@„@Ž@˜@¢@¬@¶@À@Ê@Ô@Þ@è@ò@ü@AAA$A.A8ABALAVA`AjAtA~AˆA’AœA¦A°AºAÄAÎAØAâAìAöAB BBB'B0B:BDBNBWBaBkBuB~BˆB’BœB¥B¯B¹BÃBÌBÖBàBêBóBýBCCC$C.C8CBCKCUC_ChCrC|C†CC™C£C­C·CÀCÊCÔCÞCèCñCûCDDD"D,D5D?DIDSD]DfDpDzD„DŽD—D¡D«D´D¾DÈDÒDÛDåDïDùDE EE E*E4E>EHERE\EfEpEzE„EŽE˜E¢E¬E¶EÀEÊEÔEÞEèEòEüEFFF$F.F8FBFLFVF`FjFtF~FˆF’FœF¦F°FºFÄFÎFØFâFìFöFG GGG(G2GJHJRJ\JfJpJzJ„JŽJ˜J¢J¬J¶JÀJÊJÔJÞJèJòJüJKKK$K.K8KBKLKVK`KjKtK~KˆK’KœK¦K°KºKÄKÎKØKâKìKöKL LLL(L2LOHORO\OfOpOzO„OŽO˜O¢O¬O¶OÀOÊOÔOÞOèOòOüOPPP$P.P8PBPLPVP`PjPtP~PˆP’PœP¦P°PºPÄPÎPØPâPìPöPQ QQQ(Q2QTHTRT\TfTpTzT„TŽT˜T¢T¬T¶TÀTÊTÔTÞTèTòTüTUUU$U.U8UBULUVU`UjUtU~UˆU’UœU¦U°UºUÄUÎUØUâUìUöUV VVV(V2VYHYRY\YfYpYzY„YŽY˜Y¢Y¬Y¶YÀYÊYÔYÞYèYòYüYZZZ$Z.Z8ZBZLZVZ`ZjZtZ~Z‡Z‘ZšZ¤Z®Z·ZÁZËZÔZÞZèZñZûZ[[["[+[5[?[H[R[\[e[o[y[‚[Œ[–[Ÿ[©[²[¼[Æ[Ï[Ù[ã[ì[ö[\ \\\&\0\:\C\M\W\`\j\t\}\‡\‘\š\¤\®\¸\Á\Ë\Ô\Þ\è\ñ\û\]]]"]+]5]?]H]R]\]e]o]y]‚]Œ]–]Ÿ]©]³]¼]Æ]Ð]Ú]ã]í]ö]^ ^^^'^0^:^D^M^W^a^j^t^~^‡^‘^›^¤^®^¸^Á^Ë^Õ^Þ^è^ò^ü^___"_,_5_?_I_R_\_f_o_y_ƒ_Œ_–_ _©_³_½_Æ_Ð_Ú_ã_í_÷_` ```'`1`:`D`N`W`a`k`t`~`ˆ`‘`›`¥`®`¸`Â`Ë`Õ`ß`è`ò`ü`aaa"a,a6a?aIaRa\afaoayaƒaŒa–a a©a³a½aÆaÐaÚaãaía÷ab bbb'b1b:bDbNbXbabkbtb~bˆb‘b›b¥b®b¸bÂbËbÕbßbèbòbübccc"c,c6c?cIcSc\cfcpczcƒcc–c cªc³c½cÇcÐcÚcäcíc÷cd ddd'd1d;dDdNdXdadkdud~dˆd’dœd¥d¯d¸dÂdÌdÕdßdédòdüdeee#e,e6e@eIeSe]efepezeƒee—e eªe´e¾eÈeÑeÛeäeîeøef fff(f2f;fEfOfXfbflfuff‰f’fœf¦f¯f¹fÃfÌfÖfàfêfôfþfggg&g0g:gDgNgXgbglgvg€gŠg”gžg¨g²g¼gÆgÐgÚgägíg÷gh hhh)h3h=hGhQh[hehohyhƒhh—h¡h«hµh¾hÞhèhòhühiii$i.i8iBiLiVi`ijiti~iˆi’iœi¦i°iºiÄiÎiØiâiìiöij jjj(j2jxHxRx\xexoxyx‚xŒx–xŸx©x³x¼xÆxÐxÙxãxíx÷xy yyy(y2y;yEyOyXybylyuyy‰y’yœy¦y°yºyÄyÎy×yáyëyôyþyzzz%z.z8zBzLzVz`zjzsz}z‡zzšz¤z­z·zÁzÊzÔzÞzçzñzûz{{{#{,{6{@{I{S{]{f{p{z{ƒ{{—{ {ª{´{¾{È{Ò{Ü{æ{ð{ú{| || |*|4|>|H|Q|[|d|n|x|‚|Œ|–| |ª|³|½|Ç|Ð|Ú|ä|î|÷|} }}}'}1};}E}O}Y}c}l}v}}‰}“}}¦}°}º}Ã}Í}×}á}ë}õ}ÿ} ~~~&~0~9~C~L~V~`~i~s~}~‡~~š~¤~®~¸~Â~Ì~Õ~ß~é~ò~ü~#-7@JT^gq{…™£­·ÁËÔÞèñû€€€"€+€5€?€I€R€\€f€p€z€„€€—€ €ª€´€¾€È€Ñ€Û€å€ï€ø€  *4=GQZdmwŠ”ž¨²¼ÆÐÚãí÷‚ ‚‚‚'‚1‚:‚D‚N‚X‚a‚k‚u‚‚‰‚“‚‚¦‚°‚º‚Âׂ͂à‚ê‚ô‚þ‚ƒƒƒ$ƒ.ƒ8ƒBƒLƒVƒ`ƒjƒtƒ~ƒ‡ƒ‘ƒšƒ¤ƒ­ƒ·ƒÁƒÊƒÔƒÞƒèƒòƒüƒ„„„#„-„6„@„I„S„]„f„p„z„„„Ž„˜„¢„¬„¶„À„Ê„Ô„Ý„ç„ñ„û„………"…+…5…?…H…R…\…e…o…y…ƒ……—…¡…«…´…¾…Ç…Ñ…Û…ä…î…ø…† †† †*†4†>†H†R†[†e†n†x††‹†•†ž†¨†±†»†Å†Ï†Ù†ã†í†ö†‡ ‡‡‡&‡0‡9‡C‡M‡V‡`‡j‡t‡~‡ˆ‡‘‡›‡¤‡®‡·‡Á‡Ê‡Ô‡Þ‡è‡ò‡ü‡ˆˆˆ#ˆ,ˆ6ˆ@ˆJˆSˆ]ˆfˆpˆzˆ„ˆŽˆ˜ˆ¡ˆ«ˆ´ˆ¾ˆÇˆÑˆÛˆäˆîˆøˆ‰ ‰‰‰)‰3‰=‰G‰Q‰[‰e‰n‰x‰‰‹‰”‰ž‰§‰±‰»‰Ä‰Î‰Ø‰â‰ì‰ö‰ÿ‰ ŠŠŠ%Š/Š8ŠBŠKŠUŠ_ŠiŠsŠ}Š†ŠŠ™Š£Š­Š¶ŠÀŠÊŠÔŠÞŠèŠòŠûŠ‹‹‹!‹+‹4‹>‹G‹Q‹[‹e‹o‹y‹‚‹Œ‹•‹Ÿ‹©‹²‹¼‹Æ‹Ï‹Ù‹ã‹í‹÷‹Œ ŒŒŒ)Œ3Œ=ŒGŒQŒ[ŒeŒoŒyŒƒŒŒ—Œ¡Œ«ŒµŒ¿ŒÉŒÓŒÝŒçŒñŒûŒ#-7AKU_is}‡‘›¥¯¹ÃÍ×áëõÿ ŽŽŽ'Ž1Ž;ŽEŽOŽYŽcŽmŽwŽŽ‹Ž•ŽŸŽ©Ž³Ž½ŽÇŽÑŽÛŽåŽïŽùŽ !+5?IS]gq{…™£­·ÁËÕßéóý%/9CMWaku‰“§±»ÅÏÙãí÷‘ ‘‘‘)‘3‘=‘G‘Q‘[‘e‘o‘y‘ƒ‘‘—‘¡‘«‘µ‘¿‘É‘Ó‘Ý‘ç‘ñ‘û‘’’’#’-’7’A’K’U’_’i’s’}’‡’‘’›’¥’¯’¹’Ã’Í’×’á’ë’õ’ÿ’ “““'“1“;“E“O“Y“c“m“w““‹“•“Ÿ“©“³“½“Ç“Ñ“Û“å“ï“ù“” ””!”+”5”?”I”S”]”g”q”{”…””™”£”­”·”Á”˔Քߔé”ó”ý”•••%•/•9•C•M•W•a•k•u••‰•“••§•±•»•Å•Ï•Ù•ã•í•÷•– –––)–3–=–G–Q–[–e–o–y–ƒ––—–¡–«–µ–¿–É–Ó–Ý–ç–ñ–û–———"—+—5—?—H—R—\—e—o—y—‚—Œ—–— —ª—´—¾—Ç—Ñ—Û—ä—î—ø—˜ ˜˜˜(˜2˜;˜E˜O˜Y˜c˜m˜w˜˜‹˜•˜Ÿ˜¨˜²˜¼˜Å˜Ï˜Ù˜â˜ì˜ö˜ÿ˜ ™™™&™0™:™D™N™X™a™k™u™~™ˆ™’™›™¥™¯™¸™Â™Ì™Õ™ß™é™ó™ý™ššš%š/š9šCšMšWšaškšušš‰š“šš§š±š»šÅšÏšÙšãšíš÷š› ›››)›3›=›G›Q›[›e›o›y›ƒ››—›¡›«›µ›¿›É›Ó›Ý›ç›ñ›û›œœœ#œ-œ7œAœKœUœ_œiœsœ}œ‡œ‘œ›œ¥œ¯œ¹œÃœÍœ×œáœëœõœÿœ '1;EOYcmw‹•Ÿ©³½ÇÑÛåïùž žž!ž+ž5ž?žIžSž]žgžqž{ž…žž™ž£ž­ž·žÁžËžÕžßžéžóžýžŸŸŸ%Ÿ/Ÿ9ŸCŸMŸWŸaŸkŸuŸŸ‰Ÿ“ŸŸ§Ÿ±Ÿ»ŸÅŸÏŸÙŸãŸíŸ÷Ÿ     ) 3 = G Q [ e o y ƒ  — ¡ « µ ¿ É Ó Ý ç ñ û ¡¡¡#¡-¡7¡A¡K¡U¡_¡i¡s¡}¡‡¡‘¡›¡¥¡¯¡¹¡Ã¡Í¡×¡á¡ë¡õ¡ÿ¡ ¢¢¢'¢1¢;¢E¢O¢Y¢c¢m¢w¢¢‹¢•¢Ÿ¢©¢³¢½¢Ç¢Ñ¢Û¢å¢ï¢ù¢£ ££!£+£5£?£I£S£]£g£q£{£…££™£££­£·£Á£Ë£Õ£ß£é£ó£ý£¤¤¤%¤/¤9¤C¤M¤W¤a¤k¤u¤¤‰¤“¤¤§¤±¤»¤Å¤Ï¤Ù¤ã¤í¤÷¤¥ ¥¥¥)¥3¥=¥G¥Q¥[¥e¥o¥y¥ƒ¥¥—¥¡¥«¥µ¥¿¥É¥Ó¥Ý¥ç¥ñ¥û¥¦¦¦#¦-¦7¦A¦J¦T¦^¦g¦q¦{¦„¦Ž¦˜¦¡¦«¦µ¦¾¦È¦Ò¦Ü¦æ¦ð¦ú¦§ §§ §*§4§=§G§Q§Z§d§n§w§§‹§•§Ÿ§©§³§¼§Æ§Ð§Ù§ã§í§ö§¨ ¨¨¨'¨1¨;¨E¨O¨X¨b¨l¨u¨¨‰¨’¨œ¨¦¨¯¨¹¨Ã¨Ì¨Ö¨à¨ê¨ô¨þ¨©©©%©.©8©B©K©U©_©h©r©|©…©©™©£©­©·©Á©Ë©Õ©ß©é©ò©ü©ªªª#ª,ª6ª@ªIªSª]ªgªqª{ª…ªŽª˜ª¢ª«ªµª¿ªÈªÒªÜªåªïªùª« ««!«*«4«>«G«Q«[«d«n«x««‹«•«Ÿ«©«³«½«Æ«Ð«Ú«ã«í«÷«¬ ¬¬¬'¬1¬;¬E¬O¬Y¬b¬l¬v¬¬‰¬“¬œ¬¦¬°¬¹¬Ã¬Í¬×¬á¬ë¬õ¬ÿ¬ ­­­&­/­9­B­L­U­_­i­s­}­‡­­š­£­­­¶­À­É­Ó­Ý­ç­ñ­û­®®®!®*®4®=®G®Q®[®e®o®x®‚®‹®•®ž®¨®±®»®Å®Ï®Ù®ã®ì®ö®ÿ® ¯¯¯%¯/¯9¯C¯M¯W¯a¯k¯u¯¯‰¯“¯¯§¯±¯»¯Å¯Ï¯Ù¯ã¯í¯÷¯° °°°)°3°=°G°Q°[°e°o°y°ƒ°°—°¡°«°µ°¿°É°Ó°Ý°ç°ñ°û°±±±#±-±7±A±K±U±_±i±s±}±‡±‘±›±¥±¯±¹±Ã±Í±×±á±ë±õ±ÿ± ²²²'²1²;²E²O²Y²c²m²w²²‹²•²Ÿ²©²³²½²Ç²Ñ²Û²å²ï²ù²³ ³³!³+³5³?³I³S³]³g³q³{³…³³™³£³­³·³Á³Ë³Õ³ß³é³ó³ý³´´´%´/´9´C´M´W´a´k´u´´‰´“´´§´±´»´Å´Ï´Ù´ã´í´÷´µ µµµ)µ3µ=µGµQµ[µeµoµyµƒµµ—µ µ©µ²µ»µÅµÏµÙµãµìµõµþµ¶¶¶%¶/¶8¶A¶J¶S¶]¶g¶q¶{¶„¶¶–¶Ÿ¶©¶³¶½¶Ç¶Ð¶Ù¶â¶ë¶õ¶ÿ¶ ···'·1·;·E·O·Y·c·m·w··‹·•·Ÿ·©·³·½·Ç·Ñ·Û·å·ï·ù·¸ ¸¸!¸+¸5¸?¸I¸S¸]¸g¸q¸{¸…¸¸™¸£¸­¸·¸Á¸Ë¸Õ¸ß¸é¸ó¸ý¸¹¹¹%¹/¹9¹C¹M¹W¹a¹k¹u¹¹‰¹“¹¹§¹±¹»¹Å¹Ï¹Ù¹ã¹í¹÷¹º ººº)º3º=ºGºQº[ºeºoºyºƒºº—º¡º«ºµº¿ºÉºÓºÝºçºñºûº»»»#»-»7»A»K»U»_»i»s»}»‡»‘»›»¥»¯»¹»Ã»Í»×»á»ë»õ»ÿ» ¼¼¼'¼1¼;¼E¼O¼Y¼c¼m¼w¼¼‹¼•¼Ÿ¼©¼³¼½¼Ç¼Ñ¼Û¼å¼ï¼ù¼½ ½½!½+½5½?½I½S½]½g½q½{½…½½™½£½­½·½Á½Ë½Õ½ß½é½ó½ý½¾¾¾%¾/¾9¾C¾M¾W¾a¾k¾u¾¾‰¾“¾¾§¾±¾»¾Å¾Ï¾Ù¾ã¾í¾÷¾¿ ¿¿¿)¿3¿=¿G¿Q¿[¿e¿o¿y¿ƒ¿¿—¿¡¿«¿µ¿¿¿É¿Ó¿Ý¿ç¿ñ¿û¿ÀÀÀ#À-À7ÀAÀKÀUÀ_ÀiÀsÀ}À‡À‘À›À¥À¯À¹ÀÃÀÍÀ×ÀáÀëÀõÀÿÀ ÁÁÁ'Á1Á;ÁEÁOÁYÁcÁmÁwÁÁ‹Á•ÁŸÁ©Á³Á½ÁÇÁÑÁÛÁåÁïÁùÁ ÂÂ!Â+Â5Â?ÂIÂSÂ]ÂgÂqÂ{…™£­·ÂÁÂËÂÕÂßÂéÂóÂýÂÃÃÃ%Ã/Ã9ÃCÃMÃWÃaÃkÃuÃÉÓÃçñûÃÅÃÏÃÙÃãÃíÃ÷ÃÄ ÄÄÄ)Ä3Ä=ÄGÄQÄ[ÄeÄoÄyăÄėġīĵĿÄÉÄÓÄÝÄçÄñÄûÄÅÅÅ#Å-Å7ÅAÅKÅUÅ_ÅiÅsÅ}ŇőśťůŹÅÃÅÍÅ×ÅáÅëÅõÅÿÅ ÆÆÆ'Æ1Æ;ÆEÆOÆYÆcÆmÆwÆƋƕƟƩƳƽÆÇÆÑÆÛÆåÆïÆùÆÇ ÇÇ!Ç+Ç5Ç?ÇIÇSÇ]ÇgÇqÇ{Ç…ÇǙǣǭǷÇÁÇËÇÕÇßÇéÇóÇýÇÈÈÈ%È/È9ÈCÈMÈWÈaÈkÈuÈȉȓÈȧȱȻÈÅÈÏÈÙÈãÈíÈ÷ÈÉ ÉÉÉ)É3É=ÉGÉQÉ[ÉeÉoÉyɃÉɗɡɫɵɿÉÉÉÓÉÝÉçÉñÉûÉÊÊÊ#Ê-Ê7ÊAÊKÊUÊ_ÊiÊsÊ}ʇʑʛʥʯʹÊÃÊÍÊ×ÊáÊëÊõÊÿÊ ËËË'Ë1Ë;ËEËOËYËcËmËwËˋ˕˟˩˳˽ËÇËÑËÛËåËïËùËÌ ÌÌ!Ì+Ì5Ì?ÌIÌSÌ]ÌgÌqÌ{Ì…Ì̷̙̣̭ÌÁÌËÌÕÌßÌéÌóÌýÌÍÍÍ%Í/Í9ÍCÍMÍWÍaÍkÍuÍ͉͓ÍͧͱͻÍÅÍÏÍÙÍãÍíÍ÷ÍÎ ÎÎ5ÎÏ"Ï/ÏPÏqϒϳÏÔÏáÏÐ#ÐDÐeІГРЭкÐÇÐÔÐáÐîÐûÐÑÑ"Ñ/Ñ<ÑIÑVÑwјѹÑÚÑûÑÒÒ"Ò/Ò<ÒIÒVÒcÒpÒ}ÒŠÒ—Ò¸ÒÅÒÒÒßÒìÒùÒÓÓ Ó-ÓNÓoÓÓ±ÓÒÓßÓìÓùÓÔÔ Ô-Ô:ÔGÔTÔaÔnÔ{ÔˆÔ•Ô¢Ô¯Ô¼ÔÉÔÖÔãÔðÔýÔ ÕÕ$Õ1Õ>ÕKÕXÕeÕrÕՌՙզճÕÀÕÍÕÚÕçÕôÕÖÖÖ(Ö5ÖBÖOÖ\ÖiÖvÖƒÖÖÖªÖ·ÖÄÖÑÖÞÖëÖøÖ×××,×9×F×S×`×m×zׇהס׮׻×È×Õ×â×ï×ü× ØØ#Ø0Ø=ØJØWØdØqØ~؋ؘإزؿØÌØÙØæØóØÙ ÙÙ7ÙTÙaÙ}ن٢٫ٸÙØÙùÙÚ&Ú3Ú@ÚaÚnÚ{ÚˆÚ•Ú±Ú¾ÚËÚØÚäÚðÚÐÛÌÛPZÿÿÿÿÿÿÿÿÿÿÿÿdÿÿÿÿÿÿ€Sÿÿÿÿÿÿaÿÿÿÿÿÿ"€Sÿÿÿÿÿÿ*"^ÿÿÿÿÿÿ4€Sÿÿÿÿÿÿ<4[ÿÿÿÿÿÿF€ SÿÿÿÿÿÿNF XÿÿÿÿÿÿX€ Sÿÿÿÿÿÿ`X€ Sÿÿÿÿÿÿj"€ Sÿÿÿÿÿÿt""€Sÿÿÿÿÿÿ~"4€Sÿÿÿÿÿÿˆ"F€Sÿÿÿÿÿÿ’"X€Sÿÿÿÿÿÿœ4€Sÿÿÿÿÿÿ¦4"€Sÿÿÿÿÿÿ°44€Sÿÿÿÿÿÿº4F€SÿÿÿÿÿÿÄ4X€SÿÿÿÿÿÿÎF€SÿÿÿÿÿÿØF"€SÿÿÿÿÿÿâF4€SÿÿÿÿÿÿìFF€SÿÿÿÿÿÿöFX€SÿÿÿÿÿÿX€Sÿÿÿÿÿÿ X"€SÿÿÿÿÿÿX4€SÿÿÿÿÿÿXF€Sÿÿÿÿÿÿ(XX€ >ÿÿÿÿÿÿ2€!>ÿÿÿÿÿÿ<"€"ÿÿÿÿÿÿF2<€#>ÿÿÿÿÿÿP4€$ÿÿÿÿÿÿZFP€%>ÿÿÿÿÿÿdF€&ÿÿÿÿÿÿnZd€'>ÿÿÿÿÿÿxX€(ÿÿÿÿÿÿ‚nx€)>ÿÿÿÿÿÿŒ*€*>ÿÿÿÿÿÿ–"*€+ÿÿÿÿÿÿ Œ–€,>ÿÿÿÿÿÿª*4€-ÿÿÿÿÿÿ´ ª€.>ÿÿÿÿÿÿ¾*F€/ÿÿÿÿÿÿÈ´¾€0>ÿÿÿÿÿÿÒ*X€1ÿÿÿÿÿÿÜÈÒ€2ÿÿÿÿÿÿæ‚Ü€3>ÿÿÿÿÿÿð<€4>ÿÿÿÿÿÿú"<€5ÿÿÿÿÿÿðú€6>ÿÿÿÿÿÿ4<€7ÿÿÿÿÿÿ€8>ÿÿÿÿÿÿ"<F€9ÿÿÿÿÿÿ,"€:>ÿÿÿÿÿÿ6<X€;ÿÿÿÿÿÿ@,6€<ÿÿÿÿÿÿJæ@€=>ÿÿÿÿÿÿTN€>>ÿÿÿÿÿÿ^"N€?ÿÿÿÿÿÿhT^€@>ÿÿÿÿÿÿr4N€Aÿÿÿÿÿÿ|hr€B>ÿÿÿÿÿÿ†FN€Cÿÿÿÿÿÿ|†€D>ÿÿÿÿÿÿšNX€Eÿÿÿÿÿÿ¤š€Fÿÿÿÿÿÿ®J¤€G>ÿÿÿÿÿÿ¸`€H>ÿÿÿÿÿÿÂ"`€Iÿÿÿÿÿÿ̸€J>ÿÿÿÿÿÿÖ4`€KÿÿÿÿÿÿàÌÖ€L>ÿÿÿÿÿÿêF`€Mÿÿÿÿÿÿôàê€N>ÿÿÿÿÿÿþX`€Oÿÿÿÿÿÿôþ€Pÿÿÿÿÿÿ®€Q>ÿÿÿÿÿÿj€R>ÿÿÿÿÿÿ&"j€Sÿÿÿÿÿÿ0&€T>ÿÿÿÿÿÿ:4j€UÿÿÿÿÿÿD0:€V>ÿÿÿÿÿÿNFj€WÿÿÿÿÿÿXDN€X>ÿÿÿÿÿÿbXj€YÿÿÿÿÿÿlXb€Z>ÿÿÿÿÿÿvt€[>ÿÿÿÿÿÿ€"t€\ÿÿÿÿÿÿŠv€€]>ÿÿÿÿÿÿ”4t€^ÿÿÿÿÿÿžŠ”€_>ÿÿÿÿÿÿ¨Ft€`ÿÿÿÿÿÿ²ž¨€a>ÿÿÿÿÿÿ¼Xt€bÿÿÿÿÿÿƲ¼€cÿÿÿÿÿÿÐlÆ€d>ÿÿÿÿÿÿÚ~€e>ÿÿÿÿÿÿä"~€fÿÿÿÿÿÿîÚä€g>ÿÿÿÿÿÿø4~€hÿÿÿÿÿÿîø€i>ÿÿÿÿÿÿ F~€jÿÿÿÿÿÿ €k>ÿÿÿÿÿÿ X~€lÿÿÿÿÿÿ* €mÿÿÿÿÿÿ4Ð*€n>ÿÿÿÿÿÿ>ˆ€o>ÿÿÿÿÿÿH"ˆ€pÿÿÿÿÿÿR>H€q>ÿÿÿÿÿÿ\4ˆ€rÿÿÿÿÿÿfR\€s>ÿÿÿÿÿÿpFˆ€tÿÿÿÿÿÿzfp€u>ÿÿÿÿÿÿ„Xˆ€vÿÿÿÿÿÿŽz„€wÿÿÿÿÿÿ˜4Ž€x>ÿÿÿÿÿÿ¢’€y>ÿÿÿÿÿÿ¬"’€zÿÿÿÿÿÿ¶¢¬€{>ÿÿÿÿÿÿÀ4’€|ÿÿÿÿÿÿʶÀ€}>ÿÿÿÿÿÿÔF’€~ÿÿÿÿÿÿÞÊÔ€>ÿÿÿÿÿÿèX’€€ÿÿÿÿÿÿòÞè€ÿÿÿÿÿÿü˜ò€‚ÿÿÿÿÿÿü€ƒ>ÿÿÿÿÿÿœ€„>ÿÿÿÿÿÿ"œ€…ÿÿÿÿÿÿ$€†>ÿÿÿÿÿÿ.4œ€‡ÿÿÿÿÿÿ8$.€ˆ>ÿÿÿÿÿÿBFœ€‰ÿÿÿÿÿÿL8B€Š>ÿÿÿÿÿÿVXœ€‹ÿÿÿÿÿÿ`LV€Œ>ÿÿÿÿÿÿj¦€>ÿÿÿÿÿÿt"¦€Žÿÿÿÿÿÿ~jt€>ÿÿÿÿÿÿˆ4¦€ÿÿÿÿÿÿ’~ˆ€‘>ÿÿÿÿÿÿœF¦€’ÿÿÿÿÿÿ¦’œ€“>ÿÿÿÿÿÿ°X¦€”ÿÿÿÿÿÿº¦°€•ÿÿÿÿÿÿÄ`º€–>ÿÿÿÿÿÿΰ€—>ÿÿÿÿÿÿØ"°€˜ÿÿÿÿÿÿâÎØ€™>ÿÿÿÿÿÿì4°€šÿÿÿÿÿÿöâ쀛>ÿÿÿÿÿÿF°€œÿÿÿÿÿÿ ö€>ÿÿÿÿÿÿX°€žÿÿÿÿÿÿ €Ÿÿÿÿÿÿÿ(Ä€ >ÿÿÿÿÿÿ2º€¡>ÿÿÿÿÿÿ<"º€¢ÿÿÿÿÿÿF2<€£>ÿÿÿÿÿÿP4º€¤ÿÿÿÿÿÿZFP€¥>ÿÿÿÿÿÿdFº€¦ÿÿÿÿÿÿnZd€§>ÿÿÿÿÿÿxXº€¨ÿÿÿÿÿÿ‚nx€©ÿÿÿÿÿÿŒ(‚€ª>ÿÿÿÿÿÿ–Ä€«>ÿÿÿÿÿÿ "Ä€¬ÿÿÿÿÿÿª– €­>ÿÿÿÿÿÿ´4Ä€®ÿÿÿÿÿÿ¾ª´€¯>ÿÿÿÿÿÿÈFÄ€°ÿÿÿÿÿÿҾȀ±>ÿÿÿÿÿÿÜXÄ€²ÿÿÿÿÿÿæÒÜ€³ÿÿÿÿÿÿðŒæ€´ÿÿÿÿÿÿúð€µ>ÿÿÿÿÿÿ΀¶>ÿÿÿÿÿÿ"΀·ÿÿÿÿÿÿ€¸>ÿÿÿÿÿÿ"4΀¹ÿÿÿÿÿÿ,"€º>ÿÿÿÿÿÿ6F΀»ÿÿÿÿÿÿ@,6€¼>ÿÿÿÿÿÿJX΀½ÿÿÿÿÿÿT@J€¾>ÿÿÿÿÿÿ^Ø€¿>ÿÿÿÿÿÿh"Ø€Àÿÿÿÿÿÿr^h€Á>ÿÿÿÿÿÿ|4Ø€Âÿÿÿÿÿÿ†r|€Ã>ÿÿÿÿÿÿFØ€Äÿÿÿÿÿÿš†€Å>ÿÿÿÿÿÿ¤XØ€Æÿÿÿÿÿÿ®š¤€Çÿÿÿÿÿÿ¸T®€È>ÿÿÿÿÿÿÂâ€É>ÿÿÿÿÿÿÌ"â€ÊÿÿÿÿÿÿÖÂÌ€Ë>ÿÿÿÿÿÿà4â€ÌÿÿÿÿÿÿêÖà€Í>ÿÿÿÿÿÿôFâ€Îÿÿÿÿÿÿþêô€Ï>ÿÿÿÿÿÿXâ€Ðÿÿÿÿÿÿþ€Ñÿÿÿÿÿÿ¸€Ò>ÿÿÿÿÿÿ&ì€Ó>ÿÿÿÿÿÿ0"ì€Ôÿÿÿÿÿÿ:&0€Õ>ÿÿÿÿÿÿD4ì€ÖÿÿÿÿÿÿN:D€×>ÿÿÿÿÿÿXFì€ØÿÿÿÿÿÿbNX€Ù>ÿÿÿÿÿÿlXì€Úÿÿÿÿÿÿvbl€Ûÿÿÿÿÿÿ€v€Ü>ÿÿÿÿÿÿŠö€Ý>ÿÿÿÿÿÿ”"ö€ÞÿÿÿÿÿÿžŠ”€ß>ÿÿÿÿÿÿ¨4ö€àÿÿÿÿÿÿ²ž¨€á>ÿÿÿÿÿÿ¼Fö€âÿÿÿÿÿÿƲ¼€ã>ÿÿÿÿÿÿÐXö€äÿÿÿÿÿÿÚÆЀåÿÿÿÿÿÿä€Ú€æÿÿÿÿÿÿîúä€ç>ÿÿÿÿÿÿø€è>ÿÿÿÿÿÿ "€éÿÿÿÿÿÿ ø €ê>ÿÿÿÿÿÿ 4€ëÿÿÿÿÿÿ  €ì>ÿÿÿÿÿÿ* F€íÿÿÿÿÿÿ4 * €î>ÿÿÿÿÿÿ> X€ïÿÿÿÿÿÿH 4 > €ð>ÿÿÿÿÿÿR  €ñ>ÿÿÿÿÿÿ\ " €òÿÿÿÿÿÿf R \ €ó>ÿÿÿÿÿÿp 4 €ôÿÿÿÿÿÿz f p €õ>ÿÿÿÿÿÿ„ F €öÿÿÿÿÿÿŽ z „ €÷>ÿÿÿÿÿÿ˜ X €øÿÿÿÿÿÿ¢ Ž ˜ €ùÿÿÿÿÿÿ¬ H ¢ €ú>ÿÿÿÿÿÿ¶ €û>ÿÿÿÿÿÿÀ "€üÿÿÿÿÿÿÊ ¶ À €ý>ÿÿÿÿÿÿÔ 4€þÿÿÿÿÿÿÞ Ê Ô €ÿ>ÿÿÿÿÿÿè F€ÿÿÿÿÿÿò Þ è €>ÿÿÿÿÿÿü X€ÿÿÿÿÿÿ ò ü €ÿÿÿÿÿÿ ¬  €>ÿÿÿÿÿÿ €>ÿÿÿÿÿÿ$ "€ÿÿÿÿÿÿ.  $ €>ÿÿÿÿÿÿ8 4€ÿÿÿÿÿÿB . 8 € >ÿÿÿÿÿÿL F€ ÿÿÿÿÿÿV B L € >ÿÿÿÿÿÿ` X€ ÿÿÿÿÿÿj V ` € ÿÿÿÿÿÿt  j €>ÿÿÿÿÿÿ~ (€>ÿÿÿÿÿÿˆ "(€ÿÿÿÿÿÿ’ ~ ˆ €>ÿÿÿÿÿÿœ 4(€ÿÿÿÿÿÿ¦ ’ œ €>ÿÿÿÿÿÿ° F(€ÿÿÿÿÿÿº ¦ ° €>ÿÿÿÿÿÿÄ X(€ÿÿÿÿÿÿÎ º Ä €ÿÿÿÿÿÿØ t Î €ÿÿÿÿÿÿâ îØ €ÿÿÿÿÿÿì 2Œ€ÿÿÿÿÿÿö ì ð€ÿÿÿÿÿÿ ö T€ÿÿÿÿÿÿ ¸€ÿÿÿÿÿÿ 2€ÿÿÿÿÿÿ  €ÿÿÿÿÿÿ(  € ÿÿÿÿÿÿ2 ( ø€!ÿÿÿÿÿÿ< 2 €"ÿÿÿÿÿÿF <–€#ÿÿÿÿÿÿP F ú€$ÿÿÿÿÿÿZ P ^€%ÿÿÿÿÿÿd Z €&ÿÿÿÿÿÿn <&€'ÿÿÿÿÿÿx n €(ÿÿÿÿÿÿ‚ x €)ÿÿÿÿÿÿŒ ‚  €*ÿÿÿÿÿÿ– d Œ €+ÿÿÿÿÿÿ  < – €,ÿÿÿÿÿÿª Pª€-ÿÿÿÿÿÿ´ ª €.ÿÿÿÿÿÿ¾ ´ r€/ÿÿÿÿÿÿÈ ¾ Ö€0ÿÿÿÿÿÿÒ P:€1ÿÿÿÿÿÿÜ Ò .€2ÿÿÿÿÿÿæ Ü "€3ÿÿÿÿÿÿð æ  €4ÿÿÿÿÿÿú È ð €5ÿÿÿÿÿÿ   ú €6ÿÿÿÿÿÿ d¾€7ÿÿÿÿÿÿ  "€8ÿÿÿÿÿÿ"  †€9ÿÿÿÿÿÿ, " ê€:ÿÿÿÿÿÿ6 dN€;ÿÿÿÿÿÿ@ 6 B€<ÿÿÿÿÿÿJ @ 6€=ÿÿÿÿÿÿT J * €>ÿÿÿÿÿÿ^ , T €?ÿÿÿÿÿÿh  ^ €@ÿÿÿÿÿÿr xÒ€Aÿÿÿÿÿÿ| r 6€Bÿÿÿÿÿÿ† | š€Cÿÿÿÿÿÿ † þ€Dÿÿÿÿÿÿš xb€Eÿÿÿÿÿÿ¤ š V€Fÿÿÿÿÿÿ® ¤ J€Gÿÿÿÿÿÿ¸ ® > €Hÿÿÿÿÿÿ ¸ €IÿÿÿÿÿÿÌ h  €JÿÿÿÿÿÿÖ v€Kÿÿÿÿÿÿà Ö Ú€Lÿÿÿÿÿÿê à >€Mÿÿÿÿÿÿô ê ¢€Nÿÿÿÿÿÿþ Œv€Oÿÿÿÿÿÿ þ j€Pÿÿÿÿÿÿ  ^€Qÿÿÿÿÿÿ  R €Rÿÿÿÿÿÿ& ô  €Sÿÿÿÿÿÿ0 &€€Tÿÿÿÿÿÿ: 0 ä€UÿÿÿÿÿÿD : H€VÿÿÿÿÿÿN D ¬€WÿÿÿÿÿÿX –€€Xÿÿÿÿÿÿb X t€Yÿÿÿÿÿÿl b h€Zÿÿÿÿÿÿv l \ €[ÿÿÿÿÿÿ€ N v €\ÿÿÿÿÿÿŠ & € €]ÿÿÿÿÿÿ” :”€^ÿÿÿÿÿÿž ” ø€_ÿÿÿÿÿÿ¨ ž \€`ÿÿÿÿÿÿ² ¨ À€aÿÿÿÿÿÿ¼ ª”€bÿÿÿÿÿÿÆ ¼ ˆ€cÿÿÿÿÿÿÐ Æ |€dÿÿÿÿÿÿÚ Ð p €eÿÿÿÿÿÿä ² Ú €fÿÿÿÿÿÿî Š ä €gÿÿÿÿÿÿø N¨€hÿÿÿÿÿÿø €iÿÿÿÿÿÿ p€jÿÿÿÿÿÿ Ô€kÿÿÿÿÿÿ ¾¨€lÿÿÿÿÿÿ* œ€mÿÿÿÿÿÿ4*€nÿÿÿÿÿÿ>4„ €oÿÿÿÿÿÿH>€pÿÿÿÿÿÿRî H€qÿÿÿÿÿÿ\b¼€rÿÿÿÿÿÿf\ €sÿÿÿÿÿÿpf„€tÿÿÿÿÿÿzpè€uÿÿÿÿÿÿ„Ò¼€vÿÿÿÿÿÿŽ„°€wÿÿÿÿÿÿ˜Ž¤€xÿÿÿÿÿÿ¢˜˜ €yÿÿÿÿÿÿ¬z¢€zÿÿÿÿÿÿ¶R¬€{ÿÿÿÿÿÿÀÌ ¶€|ÿÿÿÿÿÿÊj€}ÿÿÿÿÿÿÔÊ΀~ÿÿÿÿÿÿÞÔ2€ÿÿÿÿÿÿèÞ–€€ÿÿÿÿÿÿòðÚ€ÿÿÿÿÿÿüò΀‚ÿÿÿÿÿÿü€ƒÿÿÿÿÿÿ¶ €„ÿÿÿÿÿÿ者ÿÿÿÿÿÿ$t€†ÿÿÿÿÿÿ.$Ø€‡ÿÿÿÿÿÿ8.<€ˆÿÿÿÿÿÿB8 €‰ÿÿÿÿÿÿLú䀊ÿÿÿÿÿÿVLØ€‹ÿÿÿÿÿÿ`VÌ€Œÿÿÿÿÿÿj`À €ÿÿÿÿÿÿtBj€Žÿÿÿÿÿÿ~t€ÿÿÿÿÿÿˆ.ˆ€ÿÿÿÿÿÿ’ˆì€‘ÿÿÿÿÿÿœ’P€’ÿÿÿÿÿÿ¦œ´€“ÿÿÿÿÿÿ°ø€”ÿÿÿÿÿÿº°ì€•ÿÿÿÿÿÿÄºà€–ÿÿÿÿÿÿÎÄÔ €—ÿÿÿÿÿÿئ΀˜ÿÿÿÿÿÿâ~Ø€™ÿÿÿÿÿÿìBœ€šÿÿÿÿÿÿö쀛ÿÿÿÿÿÿöd€œÿÿÿÿÿÿ È€ÿÿÿÿÿÿ" €žÿÿÿÿÿÿ€Ÿÿÿÿÿÿÿ(ô€ ÿÿÿÿÿÿ2(è €¡ÿÿÿÿÿÿ< 2€¢ÿÿÿÿÿÿFâ<€£ÿÿÿÿÿÿPV°€¤ÿÿÿÿÿÿZP€¥ÿÿÿÿÿÿdZx€¦ÿÿÿÿÿÿndÜ€§ÿÿÿÿÿÿx6 €¨ÿÿÿÿÿÿ‚x€©ÿÿÿÿÿÿŒ‚€ªÿÿÿÿÿÿ–Œü €«ÿÿÿÿÿÿ n–€¬ÿÿÿÿÿÿªF €­ÿÿÿÿÿÿ´Àª€®ÿÿÿÿÿÿ¾^€¯ÿÿÿÿÿÿȾ€°ÿÿÿÿÿÿÒÈ&€±ÿÿÿÿÿÿÜÒŠ€²ÿÿÿÿÿÿæT>€³ÿÿÿÿÿÿðæ2€´ÿÿÿÿÿÿúð&€µÿÿÿÿÿÿú €¶ÿÿÿÿÿÿÜ€·ÿÿÿÿÿÿh€¸ÿÿÿÿÿÿ"Ì€¹ÿÿÿÿÿÿ,"0€ºÿÿÿÿÿÿ6,”€»ÿÿÿÿÿÿ@^H€¼ÿÿÿÿÿÿJ@<€½ÿÿÿÿÿÿTJ0€¾ÿÿÿÿÿÿ^T$ €¿ÿÿÿÿÿÿh6^€Àÿÿÿÿÿÿrh€Áÿÿÿÿÿÿ|"|€Âÿÿÿÿÿÿ†|à€Ãÿÿÿÿÿÿ†D€Äÿÿÿÿÿÿš¨€Åÿÿÿÿÿÿ¤r\€Æÿÿÿÿÿÿ®¤P€Çÿÿÿÿÿÿ¸®D€Èÿÿÿÿÿÿ¸8 €Éÿÿÿÿÿÿ̚€ÊÿÿÿÿÿÿÖrÌ€Ëÿÿÿÿÿÿà6€Ìÿÿÿÿÿÿêàô€ÍÿÿÿÿÿÿôêX€Îÿÿÿÿÿÿþô¼€Ïÿÿÿÿÿÿ†p€Ðÿÿÿÿÿÿd€ÑÿÿÿÿÿÿX€Òÿÿÿÿÿÿ&L €Óÿÿÿÿÿÿ0þ&€Ôÿÿÿÿÿÿ:Ö0€ÕÿÿÿÿÿÿDJ¤€ÖÿÿÿÿÿÿND€×ÿÿÿÿÿÿXNl€ØÿÿÿÿÿÿbXЀÙÿÿÿÿÿÿlš„€Úÿÿÿÿÿÿvlx€Ûÿÿÿÿÿÿ€vl€ÜÿÿÿÿÿÿŠ€` €Ýÿÿÿÿÿÿ”bŠ€Þÿÿÿÿÿÿž:”€ßÿÿÿÿÿÿ¨´ž€àÿÿÿÿÿÿ²øR €áÿÿÿÿÿÿ¼²¶ €âÿÿÿÿÿÿƼ €ãÿÿÿÿÿÿÐÆ~ €äÿÿÿÿÿÿÚ¸¢€åÿÿÿÿÿÿäÚ–€æÿÿÿÿÿÿî䊀çÿÿÿÿÿÿøî~ €èÿÿÿÿÿÿÐø€éÿÿÿÿÿÿ  \ €êÿÿÿÿÿÿ À €ëÿÿÿÿÿÿ $ €ìÿÿÿÿÿÿ* ˆ €íÿÿÿÿÿÿ4¬€îÿÿÿÿÿÿ>4 €ïÿÿÿÿÿÿH>”€ðÿÿÿÿÿÿRHˆ €ñÿÿÿÿÿÿ\*R€òÿÿÿÿÿÿf\€óÿÿÿÿÿÿp p €ôÿÿÿÿÿÿzpÔ €õÿÿÿÿÿÿ„z8 €öÿÿÿÿÿÿŽ„œ €÷ÿÿÿÿÿÿ˜ÖÀ€øÿÿÿÿÿÿ¢˜´€ùÿÿÿÿÿÿ¬¢¨€úÿÿÿÿÿÿ¶¬œ €ûÿÿÿÿÿÿÀŽ¶€üÿÿÿÿÿÿÊfÀ€ýÿÿÿÿÿÿÔ* „ €þÿÿÿÿÿÿÞÔè €ÿÿÿÿÿÿÿèÞL €ÿÿÿÿÿÿòè° €ÿÿÿÿÿÿüêÔ€ÿÿÿÿÿÿüÈ€ÿÿÿÿÿÿ¼€ÿÿÿÿÿÿ° €ÿÿÿÿÿÿ$ò€ÿÿÿÿÿÿ.Ê$€ÿÿÿÿÿÿ8> ˜ €ÿÿÿÿÿÿB8ü € ÿÿÿÿÿÿLB` € ÿÿÿÿÿÿVLÄ € ÿÿÿÿÿÿ`þè€ ÿÿÿÿÿÿj`Ü€ ÿÿÿÿÿÿtjЀÿÿÿÿÿÿ~tÄ €ÿÿÿÿÿÿˆV~€ÿÿÿÿÿÿ’.ˆ€ÿÿÿÿÿÿœ¨’@ÿÿÿÿÿÿ¦2@ÿÿÿÿÿÿ¯v€ÿÿÿÿÿÿ¸¦¯@ÿÿÿÿÿÿÂ΀ÿÿÿÿÿÿ˸Â@ÿÿÿÿÿÿÕ&€ÿÿÿÿÿÿÞËÕ@ÿÿÿÿÿÿè~ €ÿÿÿÿÿÿñÞè@ÿÿÿÿÿÿû<@ÿÿÿÿÿÿ€€ÿÿÿÿÿÿ û@ÿÿÿÿÿÿØ€ÿÿÿÿÿÿ  @ ÿÿÿÿÿÿ*0€!ÿÿÿÿÿÿ3 *@"ÿÿÿÿÿÿ=ˆ €#ÿÿÿÿÿÿF3=€$ÿÿÿÿÿÿPñF@%ÿÿÿÿÿÿZP@&ÿÿÿÿÿÿc”€'ÿÿÿÿÿÿlZc@(ÿÿÿÿÿÿvì€)ÿÿÿÿÿÿlv@*ÿÿÿÿÿÿ‰D€+ÿÿÿÿÿÿ’‰@,ÿÿÿÿÿÿœœ €-ÿÿÿÿÿÿ¥’œ€.ÿÿÿÿÿÿ¯P¥@/ÿÿÿÿÿÿ¹d@0ÿÿÿÿÿÿ¨€1ÿÿÿÿÿÿ˹Â@2ÿÿÿÿÿÿÕ€3ÿÿÿÿÿÿÞËÕ@4ÿÿÿÿÿÿèX€5ÿÿÿÿÿÿñÞè@6ÿÿÿÿÿÿû° €7ÿÿÿÿÿÿñû€8ÿÿÿÿÿÿ¯@9ÿÿÿÿÿÿx@:ÿÿÿÿÿÿ!¼€;ÿÿÿÿÿÿ*!@<ÿÿÿÿÿÿ4€=ÿÿÿÿÿÿ=*4@>ÿÿÿÿÿÿGl€?ÿÿÿÿÿÿP=G@@ÿÿÿÿÿÿZÄ €AÿÿÿÿÿÿcPZ€Bÿÿÿÿÿÿmc@CÿÿÿÿÿÿwŒ@Dÿÿÿÿÿÿ€@Eÿÿÿÿÿÿ‰ð@Fÿÿÿÿÿÿ’@Gÿÿÿÿÿÿ›T@Hÿÿÿÿÿÿ¤@Iÿÿÿÿÿÿ­¸@Jÿÿÿÿÿÿ¶ø@Kÿÿÿÿÿÿ¿Ú@LÿÿÿÿÿÿÈj@MÿÿÿÿÿÿÑ>@NÿÿÿÿÿÿÚ^@Oÿÿÿÿÿÿã¢@PÿÿÿÿÿÿìR @Qÿÿÿÿÿÿõ2@RÿÿÿÿÿÿþÂ@Sÿÿÿÿÿÿ–@Tÿÿÿÿÿÿ¶ @UÿÿÿÿÿÿŠ@Vÿÿÿÿÿÿ" @Wÿÿÿÿÿÿ+–@Xÿÿÿÿÿÿ4&@Yÿÿÿÿÿÿ=ú@ZÿÿÿÿÿÿF@[ÿÿÿÿÿÿO^@\ÿÿÿÿÿÿX@]ÿÿÿÿÿÿaÂ@^ÿÿÿÿÿÿj @_ÿÿÿÿÿÿsä@`ÿÿÿÿÿÿ|t@aÿÿÿÿÿÿ…H@bÿÿÿÿÿÿŽh@cÿÿÿÿÿÿ—¬@dÿÿÿÿÿÿ \ @eÿÿÿÿÿÿ©<@fÿÿÿÿÿÿ²Ì@gÿÿÿÿÿÿ» @hÿÿÿÿÿÿÄÀ @iÿÿÿÿÿÿÍ”@jÿÿÿÿÿÿÖ$ @kÿÿÿÿÿÿߪ@lÿÿÿÿÿÿè:@mÿÿÿÿÿÿñ@nÿÿÿÿÿÿú.@oÿÿÿÿÿÿr@pÿÿÿÿÿÿ "@qÿÿÿÿÿÿÖ@rÿÿÿÿÿÿ @sÿÿÿÿÿÿ'ø@tÿÿÿÿÿÿ0ˆ@uÿÿÿÿÿÿ9\@vÿÿÿÿÿÿB|@wÿÿÿÿÿÿKÀ@xÿÿÿÿÿÿTp @yÿÿÿÿÿÿ]P@zÿÿÿÿÿÿfà@{ÿÿÿÿÿÿo´@|ÿÿÿÿÿÿxÔ @}ÿÿÿÿÿÿ¨@~ÿÿÿÿÿÿŠ8 @ÿÿÿÿÿÿ“¾@€ÿÿÿÿÿÿœN@ÿÿÿÿÿÿ¥"@‚ÿÿÿÿÿÿ®B@ƒÿÿÿÿÿÿ·†@„ÿÿÿÿÿÿÀ6@…ÿÿÿÿÿÿÉê@†ÿÿÿÿÿÿÒ* @‡ÿÿÿÿÿÿÛ @ˆÿÿÿÿÿÿäœ@‰ÿÿÿÿÿÿíp@Šÿÿÿÿÿÿö@‹ÿÿÿÿÿÿÿÔ@Œÿÿÿÿÿÿ„ @ÿÿÿÿÿÿd@Žÿÿÿÿÿÿô@ÿÿÿÿÿÿ#È@ÿÿÿÿÿÿ,è @‘ÿÿÿÿÿÿ5¼@’ÿÿÿÿÿÿ>L @“ÿÿÿÿÿÿGÒ@”ÿÿÿÿÿÿPb@•ÿÿÿÿÿÿY6@–ÿÿÿÿÿÿbV@—ÿÿÿÿÿÿkš@˜ÿÿÿÿÿÿtJ@™ÿÿÿÿÿÿ}þ@šÿÿÿÿÿÿ†> @›ÿÿÿÿÿÿ @œÿÿÿÿÿÿ˜°@ÿÿÿÿÿÿ¡„@žÿÿÿÿÿÿª¤@Ÿÿÿÿÿÿÿ³è@ ÿÿÿÿÿÿ¼˜ @¡ÿÿÿÿÿÿÅx@¢ÿÿÿÿÿÿÎ@£ÿÿÿÿÿÿ×Ü@¤ÿÿÿÿÿÿàü @¥ÿÿÿÿÿÿéÐ@¦ÿÿÿÿÿÿò` €§ÿÿÿÿÿÿûw€€¨ÿÿÿÿÿÿ¦û€©ÿÿÿÿÿÿ‰’€ªÿÿÿÿÿÿ€«ÿÿÿÿÿÿ#›¤€¬ÿÿÿÿÿÿ-#€­ÿÿÿÿÿÿ7­¶€®ÿÿÿÿÿÿA-7€¯ÿÿÿÿÿÿK€w€°ÿÿÿÿÿÿUK¯€±ÿÿÿÿÿÿ_¿È€²ÿÿÿÿÿÿiU_€³ÿÿÿÿÿÿsÑÚ€´ÿÿÿÿÿÿ}is€µÿÿÿÿÿÿ‡ã쀶ÿÿÿÿÿÿ‘}‡€·ÿÿÿÿÿÿ›A‘€¸ÿÿÿÿÿÿ¥’‰€¹ÿÿÿÿÿÿ¯È¿€ºÿÿÿÿÿÿ¹¥¯€»ÿÿÿÿÿÿù€¼ÿÿÿÿÿÿÍõþ€½ÿÿÿÿÿÿ×ÃÍ€¾ÿÿÿÿÿÿဿÿÿÿÿÿÿë×á€Àÿÿÿÿÿÿõ›ë€Áÿÿÿÿÿÿÿ¤›€Âÿÿÿÿÿÿ ÚÑ€Ãÿÿÿÿÿÿÿ €Äÿÿÿÿÿÿþõ€Åÿÿÿÿÿÿ'€Æÿÿÿÿÿÿ1'Õ€Çÿÿÿÿÿÿ;"€ÈÿÿÿÿÿÿE1;€ÉÿÿÿÿÿÿOõE€ÊÿÿÿÿÿÿY¶­€Ëÿÿÿÿÿÿcìã€ÌÿÿÿÿÿÿmYc€Íÿÿÿÿÿÿw€Îÿÿÿÿÿÿmw€Ïÿÿÿÿÿÿ‹"€Ðÿÿÿÿÿÿ•‹€ÑÿÿÿÿÿÿŸ•è€Òÿÿÿÿÿÿ©OŸ€Óÿÿÿÿÿÿ³+4€Ôÿÿÿÿÿÿ½û³€ÕÿÿÿÿÿÿÇ=F€Öÿÿÿÿÿÿѽǀ×ÿÿÿÿÿÿÛOX€ØÿÿÿÿÿÿåÑÛ€Ùÿÿÿÿÿÿïaj€Úÿÿÿÿÿÿùåï€Ûÿÿÿÿÿÿ4+€Üÿÿÿÿÿÿ €Ýÿÿÿÿÿÿs|€Þÿÿÿÿÿÿ! €ßÿÿÿÿÿÿ+…Ž€àÿÿÿÿÿÿ5!+€áÿÿÿÿÿÿ?— €âÿÿÿÿÿÿI5?€ãÿÿÿÿÿÿSùI€äÿÿÿÿÿÿ]F=€åÿÿÿÿÿÿg|s€æÿÿÿÿÿÿq]g€çÿÿÿÿÿÿ{q€èÿÿÿÿÿÿ…©²€éÿÿÿÿÿÿ{…€êÿÿÿÿÿÿ™»Ä€ëÿÿÿÿÿÿ£™€ìÿÿÿÿÿÿ­S£€íÿÿÿÿÿÿ·XO€îÿÿÿÿÿÿÁŽ…€ïÿÿÿÿÿÿË·Á€ðÿÿÿÿÿÿÕ²©€ñÿÿÿÿÿÿßËÕ€òÿÿÿÿÿÿéß*€óÿÿÿÿÿÿóÍÖ€ôÿÿÿÿÿÿýéó€õÿÿÿÿÿÿ­ý€öÿÿÿÿÿÿja€÷ÿÿÿÿÿÿ —€øÿÿÿÿÿÿ%€ùÿÿÿÿÿÿ/Ä»€úÿÿÿÿÿÿ9%/€ûÿÿÿÿÿÿCÖÍ€üÿÿÿÿÿÿM9C€ýÿÿÿÿÿÿWM=€þÿÿÿÿÿÿaW€ÿÿÿÿÿÿÿk©a€ÿÿÿÿÿÿußè€ÿÿÿÿÿÿZu€ÿÿÿÿÿÿ‰ñú€ÿÿÿÿÿÿ“‰€ÿÿÿÿÿÿ €ÿÿÿÿÿÿ§“€ÿÿÿÿÿÿ±€ÿÿÿÿÿÿ»§±€ÿÿÿÿÿÿÅè߀ ÿÿÿÿÿÿÏÅc€ ÿÿÿÿÿÿÙ'0€ ÿÿÿÿÿÿãÏÙ€ ÿÿÿÿÿÿí9B€ ÿÿÿÿÿÿ÷ãí€ÿÿÿÿÿÿKT€ÿÿÿÿÿÿ ÷€ÿÿÿÿÿÿ» €ÿÿÿÿÿÿúñ€ÿÿÿÿÿÿ)0'€ÿÿÿÿÿÿ3)€ÿÿÿÿÿÿ=3v€ÿÿÿÿÿÿG]f€ÿÿÿÿÿÿQ=G€ÿÿÿÿÿÿ[ox€ÿÿÿÿÿÿeQ[€ÿÿÿÿÿÿoe€ÿÿÿÿÿÿy €ÿÿÿÿÿÿƒB9€ÿÿÿÿÿÿyƒ€ÿÿÿÿÿÿ—f]€ÿÿÿÿÿÿ¡—€ÿÿÿÿÿÿ«¡‰€ ÿÿÿÿÿÿµŠ€!ÿÿÿÿÿÿ¿«µ€"ÿÿÿÿÿÿÉo¿€#ÿÿÿÿÿÿÓ€$ÿÿÿÿÿÿÝTK€%ÿÿÿÿÿÿçÓÝ€&ÿÿÿÿÿÿñxo€'ÿÿÿÿÿÿûçñ€(ÿÿÿÿÿÿŠ€)ÿÿÿÿÿÿû€*ÿÿÿÿÿÿœ€+ÿÿÿÿÿÿ#É€,ÿÿÿÿÿÿ-k#€-ÿÿÿÿÿÿ7“œ€.ÿÿÿÿÿÿA¹7€/ÿÿÿÿÿÿK¥®€0ÿÿÿÿÿÿUAK€1ÿÿÿÿÿÿ_·À€2ÿÿÿÿÿÿiU_€3ÿÿÿÿÿÿsÉÒ€4ÿÿÿÿÿÿ}is€5ÿÿÿÿÿÿ‡œ“€6ÿÿÿÿÿÿ‘‡Â€7ÿÿÿÿÿÿ›Ûä€8ÿÿÿÿÿÿ¥‘›€9ÿÿÿÿÿÿ¯íö€:ÿÿÿÿÿÿ¹¥¯€;ÿÿÿÿÿÿÃÿ€<ÿÿÿÿÿÿ͹À=ÿÿÿÿÿÿ×}Í€>ÿÿÿÿÿÿᮥ€?ÿÿÿÿÿÿëäÛ€@ÿÿÿÿÿÿõáë€AÿÿÿÿÿÿÿõÕ€Bÿÿÿÿÿÿ €Cÿÿÿÿÿÿ ÿ €Dÿÿÿÿÿÿ #,€Eÿÿÿÿÿÿ'   €Fÿÿÿÿÿÿ1 ×' €Gÿÿÿÿÿÿ; À·€HÿÿÿÿÿÿE öí€IÿÿÿÿÿÿO ; E €JÿÿÿÿÿÿY €Kÿÿÿÿÿÿc O Y €Lÿÿÿÿÿÿm c è€Mÿÿÿÿÿÿw 5>€Nÿÿÿÿÿÿ m w €Oÿÿÿÿÿÿ‹ 1 €Pÿÿÿÿÿÿ• ÒÉ€QÿÿÿÿÿÿŸ ÿ€Rÿÿÿÿÿÿ© • Ÿ €Sÿÿÿÿÿÿ³ ,#€Tÿÿÿÿÿÿ½ © ³ €UÿÿÿÿÿÿÇ >5€VÿÿÿÿÿÿÑ ½ Ç €WÿÿÿÿÿÿÛ Ñ û€Xÿÿÿÿÿÿå ‹ Û €Yÿÿÿÿÿÿï -å €Zÿÿÿÿÿÿù GP€[ÿÿÿÿÿÿ!ù €\ÿÿÿÿÿÿ !Yb€]ÿÿÿÿÿÿ!! !€^ÿÿÿÿÿÿ!!kt€_ÿÿÿÿÿÿ+!!!!€`ÿÿÿÿÿÿ5!}†€aÿÿÿÿÿÿ?!+!5!€bÿÿÿÿÿÿI!PG€cÿÿÿÿÿÿS!I!!€dÿÿÿÿÿÿ]!˜€eÿÿÿÿÿÿg!S!]!€fÿÿÿÿÿÿq!¡ª€gÿÿÿÿÿÿ{!g!q!€hÿÿÿÿÿÿ…!³¼€iÿÿÿÿÿÿ!{!…!€jÿÿÿÿÿÿ™!?!!€kÿÿÿÿÿÿ£!bY€lÿÿÿÿÿÿ­!˜€mÿÿÿÿÿÿ·!£!­!€nÿÿÿÿÿÿÁ!·!4€oÿÿÿÿÿÿË!Å΀pÿÿÿÿÿÿÕ!Á!Ë!€qÿÿÿÿÿÿß!×à€rÿÿÿÿÿÿé!Õ!ß!€sÿÿÿÿÿÿó!™!é!€tÿÿÿÿÿÿý!tk€uÿÿÿÿÿÿ"ª¡€vÿÿÿÿÿÿ"ý!"€wÿÿÿÿÿÿ"ÎÅ€xÿÿÿÿÿÿ%"""€yÿÿÿÿÿÿ/"%"G€zÿÿÿÿÿÿ9"éò€{ÿÿÿÿÿÿC"/"9"€|ÿÿÿÿÿÿM"ó!C"€}ÿÿÿÿÿÿW"†}€~ÿÿÿÿÿÿa"¼³€ÿÿÿÿÿÿk"W"a"€€ÿÿÿÿÿÿu"à×€ÿÿÿÿÿÿ"k"u"€‚ÿÿÿÿÿÿ‰"ò逃ÿÿÿÿÿÿ“""‰"€„ÿÿÿÿÿÿ"“"Z€…ÿÿÿÿÿÿ§"M""€†ÿÿÿÿÿÿ±"ï §"€‡ÿÿÿÿÿÿ»"2€€ˆÿÿÿÿÿÿÅ"»"쀉ÿÿÿÿÿÿÏ"Å"X€ŠÿÿÿÿÿÿÙ"Ï"Ä €‹Sÿÿÿÿÿÿã"€Œ>ÿÿÿÿÿÿí"ã"@ÿÿÿÿÿÿ÷"í"€ŽSÿÿÿÿÿÿ#j€>ÿÿÿÿÿÿ #"#@ÿÿÿÿÿÿ# #€‘ÿÿÿÿÿÿ#÷"#€’Sÿÿÿÿÿÿ'#œ€“>ÿÿÿÿÿÿ1#4'#@”ÿÿÿÿÿÿ;#1#€•ÿÿÿÿÿÿD##;#€–SÿÿÿÿÿÿN#΀—>ÿÿÿÿÿÿX#FN#@˜ÿÿÿÿÿÿb#X#€™ÿÿÿÿÿÿk#D#b#€šSÿÿÿÿÿÿu#€›>ÿÿÿÿÿÿ#Xu#@œÿÿÿÿÿÿ‰##€ÿÿÿÿÿÿ’#k#‰#€žSÿÿÿÿÿÿœ#*"€Ÿ>ÿÿÿÿÿÿ¦#œ#@ ÿÿÿÿÿÿ°#¦#€¡Sÿÿÿÿÿÿ¹#t"€¢>ÿÿÿÿÿÿÃ#"¹#@£ÿÿÿÿÿÿÍ#Ã#€¤ÿÿÿÿÿÿÖ#°#Í#€¥Sÿÿÿÿÿÿà#¦"€¦>ÿÿÿÿÿÿê#4à#@§ÿÿÿÿÿÿô#ê#€¨ÿÿÿÿÿÿý#Ö#ô#€©Sÿÿÿÿÿÿ$Ø"€ª>ÿÿÿÿÿÿ$F$@«ÿÿÿÿÿÿ$$€¬ÿÿÿÿÿÿ$$ý#$€­Sÿÿÿÿÿÿ.$ "€®>ÿÿÿÿÿÿ8$X.$@¯ÿÿÿÿÿÿB$8$€°ÿÿÿÿÿÿK$$$B$€±ÿÿÿÿÿÿU$’#K$€²Sÿÿÿÿÿÿ_$<4€³>ÿÿÿÿÿÿi$_$@´ÿÿÿÿÿÿs$i$€µSÿÿÿÿÿÿ|$~4€¶>ÿÿÿÿÿÿ†$"|$@·ÿÿÿÿÿÿ$†$€¸ÿÿÿÿÿÿ™$s$$€¹Sÿÿÿÿÿÿ£$°4€º>ÿÿÿÿÿÿ­$4£$@»ÿÿÿÿÿÿ·$­$€¼ÿÿÿÿÿÿÀ$™$·$€½SÿÿÿÿÿÿÊ$â4€¾>ÿÿÿÿÿÿÔ$FÊ$@¿ÿÿÿÿÿÿÞ$Ô$€Àÿÿÿÿÿÿç$À$Þ$€ÁSÿÿÿÿÿÿñ$4€Â>ÿÿÿÿÿÿû$Xñ$@Ãÿÿÿÿÿÿ%û$€Äÿÿÿÿÿÿ%ç$%€Åÿÿÿÿÿÿ%U$%€ÆSÿÿÿÿÿÿ"%NF€Ç>ÿÿÿÿÿÿ,%"%@Èÿÿÿÿÿÿ6%,%€ÉSÿÿÿÿÿÿ?%ˆF€Ê>ÿÿÿÿÿÿI%"?%@ËÿÿÿÿÿÿS%I%€Ìÿÿÿÿÿÿ\%6%S%€ÍSÿÿÿÿÿÿf%ºF€Î>ÿÿÿÿÿÿp%4f%@Ïÿÿÿÿÿÿz%p%€Ðÿÿÿÿÿÿƒ%\%z%€ÑSÿÿÿÿÿÿ%ìF€Ò>ÿÿÿÿÿÿ—%F%@Óÿÿÿÿÿÿ¡%—%€Ôÿÿÿÿÿÿª%ƒ%¡%€ÕSÿÿÿÿÿÿ´%F€Ö>ÿÿÿÿÿÿ¾%X´%@×ÿÿÿÿÿÿÈ%¾%€ØÿÿÿÿÿÿÑ%ª%È%€ÙÿÿÿÿÿÿÛ%%Ñ%€ÚSÿÿÿÿÿÿå%`X€Û>ÿÿÿÿÿÿï%å%@Üÿÿÿÿÿÿù%ï%€ÝSÿÿÿÿÿÿ&’X€Þ>ÿÿÿÿÿÿ &"&@ßÿÿÿÿÿÿ& &€àÿÿÿÿÿÿ&ù%&€áSÿÿÿÿÿÿ)&ÄX€â>ÿÿÿÿÿÿ3&4)&@ãÿÿÿÿÿÿ=&3&€äÿÿÿÿÿÿF&&=&€åSÿÿÿÿÿÿP&öX€æ>ÿÿÿÿÿÿZ&FP&@çÿÿÿÿÿÿd&Z&€èÿÿÿÿÿÿm&F&d&€éSÿÿÿÿÿÿw&(X€ê>ÿÿÿÿÿÿ&Xw&@ëÿÿÿÿÿÿ‹&&€ìÿÿÿÿÿÿ”&m&‹&€íÿÿÿÿÿÿž&Û%”&€îSÿÿÿÿÿÿ¨&*€ï>ÿÿÿÿÿÿ²&"¨&@ðÿÿÿÿÿÿ¼&²&€ñÿÿÿÿÿÿÅ&÷"¼&€òSÿÿÿÿÿÿÏ&<€ó>ÿÿÿÿÿÿÙ&4Ï&@ôÿÿÿÿÿÿã&Ù&€õÿÿÿÿÿÿì&Å&ã&€öSÿÿÿÿÿÿö&N€÷>ÿÿÿÿÿÿ'Fö&@øÿÿÿÿÿÿ ''€ùÿÿÿÿÿÿ'ì& '€úSÿÿÿÿÿÿ'`€û>ÿÿÿÿÿÿ''X'@üÿÿÿÿÿÿ1'''€ýÿÿÿÿÿÿ:''1'€þSÿÿÿÿÿÿD'j"€ÿ>ÿÿÿÿÿÿN'D'@ÿÿÿÿÿÿX'N'€ÿÿÿÿÿÿa'X'Í#€Sÿÿÿÿÿÿk'~"€>ÿÿÿÿÿÿu'4k'@ÿÿÿÿÿÿ'u'€ÿÿÿÿÿÿˆ'a''€Sÿÿÿÿÿÿ’'ˆ"€>ÿÿÿÿÿÿœ'F’'@ÿÿÿÿÿÿ¦'œ'€ ÿÿÿÿÿÿ¯'ˆ'¦'€ Sÿÿÿÿÿÿ¹'’"€ >ÿÿÿÿÿÿÃ'X¹'@ ÿÿÿÿÿÿÍ'Ã'€ ÿÿÿÿÿÿÖ'¯'Í'€ÿÿÿÿÿÿà':'Ö'€Sÿÿÿÿÿÿê'œ4€>ÿÿÿÿÿÿô'ê'@ÿÿÿÿÿÿþ'ô'€Sÿÿÿÿÿÿ(¦4€>ÿÿÿÿÿÿ("(@ÿÿÿÿÿÿ((€ÿÿÿÿÿÿ$(þ'(€ÿÿÿÿÿÿ.($(·$€Sÿÿÿÿÿÿ8(º4€>ÿÿÿÿÿÿB(F8(@ÿÿÿÿÿÿL(B(€ÿÿÿÿÿÿU(.(L(€Sÿÿÿÿÿÿ_(Ä4€>ÿÿÿÿÿÿi(X_(@ÿÿÿÿÿÿs(i(€ÿÿÿÿÿÿ|(U(s(€ÿÿÿÿÿÿ†(à'|(€ Sÿÿÿÿÿÿ(ÎF€!>ÿÿÿÿÿÿš((@"ÿÿÿÿÿÿ¤(š(€#Sÿÿÿÿÿÿ­(ØF€$>ÿÿÿÿÿÿ·("­(@%ÿÿÿÿÿÿÁ(·(€&ÿÿÿÿÿÿÊ(¤(Á(€'SÿÿÿÿÿÿÔ(âF€(>ÿÿÿÿÿÿÞ(4Ô(@)ÿÿÿÿÿÿè(Þ(€*ÿÿÿÿÿÿñ(Ê(è(€+ÿÿÿÿÿÿû(ñ(¡%€,Sÿÿÿÿÿÿ)öF€->ÿÿÿÿÿÿ)X)@.ÿÿÿÿÿÿ))€/ÿÿÿÿÿÿ")û()€0ÿÿÿÿÿÿ,)†(")€1Sÿÿÿÿÿÿ6)X€2>ÿÿÿÿÿÿ@)6)@3ÿÿÿÿÿÿJ)@)€4SÿÿÿÿÿÿS) X€5>ÿÿÿÿÿÿ])"S)@6ÿÿÿÿÿÿg)])€7ÿÿÿÿÿÿp)J)g)€8Sÿÿÿÿÿÿz)X€9>ÿÿÿÿÿÿ„)4z)@:ÿÿÿÿÿÿŽ)„)€;ÿÿÿÿÿÿ—)p)Ž)€<Sÿÿÿÿÿÿ¡)X€=>ÿÿÿÿÿÿ«)F¡)@>ÿÿÿÿÿÿµ)«)€?ÿÿÿÿÿÿ¾)—)µ)€@ÿÿÿÿÿÿÈ)¾)‹&€AÿÿÿÿÿÿÒ),)È)€BÿÿÿÿÿÿÜ)í" #€Cÿÿÿÿÿÿæ)Ü)1#€Dÿÿÿÿÿÿð)æ)X#€Eÿÿÿÿÿÿú)ð)#€Fÿÿÿÿÿÿ*¦#Ã#€Gÿÿÿÿÿÿ**ê#€Hÿÿÿÿÿÿ**$€Iÿÿÿÿÿÿ"**8$€Jÿÿÿÿÿÿ,*ú)"*€Kÿÿÿÿÿÿ6*i$†$€Lÿÿÿÿÿÿ@*6*­$€MÿÿÿÿÿÿJ*@*Ô$€NÿÿÿÿÿÿT*J*û$€Oÿÿÿÿÿÿ^*,*T*€Pÿÿÿÿÿÿh*,%I%€Qÿÿÿÿÿÿr*h*p%€Rÿÿÿÿÿÿ|*r*—%€Sÿÿÿÿÿÿ†*|*¾%€Tÿÿÿÿÿÿ*^*†*€Uÿÿÿÿÿÿš*ï% &€Vÿÿÿÿÿÿ¤*š*3&€Wÿÿÿÿÿÿ®*¤*Z&€Xÿÿÿÿÿÿ¸*®*&€YÿÿÿÿÿÿÂ**¸*€ZÿÿÿÿÿÿÌ*2ñ€[ÿÿÿÿÿÿÖ*ŒF€\ÿÿÿÿÿÿà*Ì*Ö*€]ÿÿÿÿÿÿê*ð¥€^ÿÿÿÿÿÿô*à*ê*€_ÿÿÿÿÿÿþ*T€`ÿÿÿÿÿÿ+ô*þ*€aÿÿÿÿÿÿ+¸c€bÿÿÿÿÿÿ+++€cÿÿÿÿÿÿ&+&ñ€dÿÿÿÿÿÿ0+€F€eÿÿÿÿÿÿ:+&+0+€fÿÿÿÿÿÿD+䥀gÿÿÿÿÿÿN+:+D+€hÿÿÿÿÿÿX+H€iÿÿÿÿÿÿb+N+X+€jÿÿÿÿÿÿl+¬c€kÿÿÿÿÿÿv+b+l+€lÿÿÿÿÿÿ€++v+€mÿÿÿÿÿÿŠ+.ñ€nÿÿÿÿÿÿ”+ˆF€oÿÿÿÿÿÿž+Š+”+€pÿÿÿÿÿÿ¨+쥀qÿÿÿÿÿÿ²+ž+¨+€rÿÿÿÿÿÿ¼+P€sÿÿÿÿÿÿÆ+²+¼+€tÿÿÿÿÿÿÐ+´c€uÿÿÿÿÿÿÚ+Æ+Ð+€vÿÿÿÿÿÿä+€+Ú+€wÿÿÿÿÿÿî+6ñ€xÿÿÿÿÿÿø+F€yÿÿÿÿÿÿ,î+ø+€zÿÿÿÿÿÿ ,ô¥€{ÿÿÿÿÿÿ,, ,€|ÿÿÿÿÿÿ ,X€}ÿÿÿÿÿÿ*,, ,€~ÿÿÿÿÿÿ4,¼c€ÿÿÿÿÿÿ>,*,4,€€ÿÿÿÿÿÿH,ä+>,€ÿÿÿÿÿÿR,> ñ€‚ÿÿÿÿÿÿ\,˜ F€ƒÿÿÿÿÿÿf,R,\,€„ÿÿÿÿÿÿp,ü ¥€…ÿÿÿÿÿÿz,f,p,€†ÿÿÿÿÿÿ„,` €‡ÿÿÿÿÿÿŽ,z,„,€ˆÿÿÿÿÿÿ˜,Ä c€‰ÿÿÿÿÿÿ¢,Ž,˜,€Šÿÿÿÿÿÿ¬,H,¢,€‹Sÿÿÿÿÿÿ¶,€Œ>ÿÿÿÿÿÿÀ,¶,@ÿÿÿÿÿÿÊ,À,€ŽSÿÿÿÿÿÿÓ,**€>ÿÿÿÿÿÿÝ,"Ó,@ÿÿÿÿÿÿç,Ý,€‘ÿÿÿÿÿÿð,Ê,ç,€’Sÿÿÿÿÿÿú,<<€“>ÿÿÿÿÿÿ-4ú,@”ÿÿÿÿÿÿ--€•ÿÿÿÿÿÿ-ð,-€–Sÿÿÿÿÿÿ!-NN€—>ÿÿÿÿÿÿ+-F!-@˜ÿÿÿÿÿÿ5-+-€™ÿÿÿÿÿÿ>--5-€šSÿÿÿÿÿÿH-``€›>ÿÿÿÿÿÿR-XH-@œÿÿÿÿÿÿ\-R-€ÿÿÿÿÿÿe->-\-€žSÿÿÿÿÿÿo-jj€Ÿ>ÿÿÿÿÿÿy-o-@ ÿÿÿÿÿÿƒ-y-€¡SÿÿÿÿÿÿŒ-tt€¢>ÿÿÿÿÿÿ–-"Œ-@£ÿÿÿÿÿÿ -–-€¤ÿÿÿÿÿÿ©-ƒ- -€¥Sÿÿÿÿÿÿ³-~~€¦>ÿÿÿÿÿÿ½-4³-@§ÿÿÿÿÿÿÇ-½-€¨ÿÿÿÿÿÿÐ-©-Ç-€©SÿÿÿÿÿÿÚ-ˆˆ€ª>ÿÿÿÿÿÿä-FÚ-@«ÿÿÿÿÿÿî-ä-€¬ÿÿÿÿÿÿ÷-Ð-î-€­Sÿÿÿÿÿÿ.’’€®>ÿÿÿÿÿÿ .X.@¯ÿÿÿÿÿÿ. .€°ÿÿÿÿÿÿ.÷-.€±ÿÿÿÿÿÿ(.e-.€²Sÿÿÿÿÿÿ2.œœ€³>ÿÿÿÿÿÿ<.2.@´ÿÿÿÿÿÿF.<.€µSÿÿÿÿÿÿO.¦¦€¶>ÿÿÿÿÿÿY."O.@·ÿÿÿÿÿÿc.Y.€¸ÿÿÿÿÿÿl.F.c.€¹Sÿÿÿÿÿÿv.°°€º>ÿÿÿÿÿÿ€.4v.@»ÿÿÿÿÿÿŠ.€.€¼ÿÿÿÿÿÿ“.l.Š.€½Sÿÿÿÿÿÿ.ºº€¾>ÿÿÿÿÿÿ§.F.@¿ÿÿÿÿÿÿ±.§.€Àÿÿÿÿÿÿº.“.±.€ÁSÿÿÿÿÿÿÄ.ÄÄ€Â>ÿÿÿÿÿÿÎ.XÄ.@ÃÿÿÿÿÿÿØ.Î.€Äÿÿÿÿÿÿá.º.Ø.€Åÿÿÿÿÿÿë.(.á.€ÆSÿÿÿÿÿÿõ.Î΀Ç>ÿÿÿÿÿÿÿ.õ.@Èÿÿÿÿÿÿ /ÿ.€ÉSÿÿÿÿÿÿ/ØØ€Ê>ÿÿÿÿÿÿ/"/@Ëÿÿÿÿÿÿ&//€Ìÿÿÿÿÿÿ// /&/€ÍSÿÿÿÿÿÿ9/ââ€Î>ÿÿÿÿÿÿC/49/@ÏÿÿÿÿÿÿM/C/€ÐÿÿÿÿÿÿV///M/€ÑSÿÿÿÿÿÿ`/ìì€Ò>ÿÿÿÿÿÿj/F`/@Óÿÿÿÿÿÿt/j/€Ôÿÿÿÿÿÿ}/V/t/€ÕSÿÿÿÿÿÿ‡/öö€Ö>ÿÿÿÿÿÿ‘/X‡/@×ÿÿÿÿÿÿ›/‘/€Øÿÿÿÿÿÿ¤/}/›/€Ùÿÿÿÿÿÿ®/ë.¤/€ÚSÿÿÿÿÿÿ¸/€Û>ÿÿÿÿÿÿÂ/¸/@ÜÿÿÿÿÿÿÌ/Â/€ÝSÿÿÿÿÿÿÕ/  €Þ>ÿÿÿÿÿÿß/"Õ/@ßÿÿÿÿÿÿé/ß/€àÿÿÿÿÿÿò/Ì/é/€áSÿÿÿÿÿÿü/€â>ÿÿÿÿÿÿ04ü/@ãÿÿÿÿÿÿ00€äÿÿÿÿÿÿ0ò/0€åSÿÿÿÿÿÿ#0€æ>ÿÿÿÿÿÿ-0F#0@çÿÿÿÿÿÿ70-0€èÿÿÿÿÿÿ@0070€éSÿÿÿÿÿÿJ0((€ê>ÿÿÿÿÿÿT0XJ0@ëÿÿÿÿÿÿ^0T0€ìÿÿÿÿÿÿg0@0^0€íÿÿÿÿÿÿq0®/g0€îSÿÿÿÿÿÿ{0€ï>ÿÿÿÿÿÿ…0{0@ðÿÿÿÿÿÿ0…0€ñSÿÿÿÿÿÿ˜0"*€ò>ÿÿÿÿÿÿ¢0˜0@óÿÿÿÿÿÿ¬0¢0€ôÿÿÿÿÿÿµ00¬0€õSÿÿÿÿÿÿ¿04<€ö>ÿÿÿÿÿÿÉ0¿0@÷ÿÿÿÿÿÿÓ0É0€øÿÿÿÿÿÿÜ0µ0Ó0€ùSÿÿÿÿÿÿæ0FN€ú>ÿÿÿÿÿÿð0æ0@ûÿÿÿÿÿÿú0ð0€üÿÿÿÿÿÿ1Ü0ú0€ýSÿÿÿÿÿÿ 1X`€þ>ÿÿÿÿÿÿ1 1@ÿÿÿÿÿÿÿ!11€ÿÿÿÿÿÿ*11!1€Sÿÿÿÿÿÿ41j€>ÿÿÿÿÿÿ>1"41@ÿÿÿÿÿÿH1>1€SÿÿÿÿÿÿQ1"t€>ÿÿÿÿÿÿ[1"Q1@ÿÿÿÿÿÿe1[1€ÿÿÿÿÿÿn1H1e1€Sÿÿÿÿÿÿx14~€ >ÿÿÿÿÿÿ‚1"x1@ ÿÿÿÿÿÿŒ1‚1€ ÿÿÿÿÿÿ•1n1Œ1€ SÿÿÿÿÿÿŸ1Fˆ€ >ÿÿÿÿÿÿ©1"Ÿ1@ÿÿÿÿÿÿ³1©1€ÿÿÿÿÿÿ¼1•1³1€SÿÿÿÿÿÿÆ1X’€>ÿÿÿÿÿÿÐ1"Æ1@ÿÿÿÿÿÿÚ1Ð1€ÿÿÿÿÿÿã1¼1Ú1€ÿÿÿÿÿÿí1*1ã1€Sÿÿÿÿÿÿ÷1œ€>ÿÿÿÿÿÿ24÷1@ÿÿÿÿÿÿ 22€Sÿÿÿÿÿÿ2"¦€>ÿÿÿÿÿÿ242@ÿÿÿÿÿÿ(22€ÿÿÿÿÿÿ12 2(2€Sÿÿÿÿÿÿ;24°€>ÿÿÿÿÿÿE24;2@ÿÿÿÿÿÿO2E2€ÿÿÿÿÿÿX212O2€ Sÿÿÿÿÿÿb2Fº€!>ÿÿÿÿÿÿl24b2@"ÿÿÿÿÿÿv2l2€#ÿÿÿÿÿÿ2X2v2€$Sÿÿÿÿÿÿ‰2XÄ€%>ÿÿÿÿÿÿ“24‰2@&ÿÿÿÿÿÿ2“2€'ÿÿÿÿÿÿ¦222€(ÿÿÿÿÿÿ°2í1¦2€)Sÿÿÿÿÿÿº2΀*>ÿÿÿÿÿÿÄ2Fº2@+ÿÿÿÿÿÿÎ2Ä2€,Sÿÿÿÿÿÿ×2"Ø€->ÿÿÿÿÿÿá2F×2@.ÿÿÿÿÿÿë2á2€/ÿÿÿÿÿÿô2Î2ë2€0Sÿÿÿÿÿÿþ24â€1>ÿÿÿÿÿÿ3Fþ2@2ÿÿÿÿÿÿ33€3ÿÿÿÿÿÿ3ô23€4Sÿÿÿÿÿÿ%3Fì€5>ÿÿÿÿÿÿ/3F%3@6ÿÿÿÿÿÿ93/3€7ÿÿÿÿÿÿB3393€8SÿÿÿÿÿÿL3Xö€9>ÿÿÿÿÿÿV3FL3@:ÿÿÿÿÿÿ`3V3€;ÿÿÿÿÿÿi3B3`3€<ÿÿÿÿÿÿs3°2i3€=Sÿÿÿÿÿÿ}3€>>ÿÿÿÿÿÿ‡3X}3@?ÿÿÿÿÿÿ‘3‡3€@Sÿÿÿÿÿÿš3" €A>ÿÿÿÿÿÿ¤3Xš3@Bÿÿÿÿÿÿ®3¤3€Cÿÿÿÿÿÿ·3‘3®3€DSÿÿÿÿÿÿÁ34€E>ÿÿÿÿÿÿË3XÁ3@FÿÿÿÿÿÿÕ3Ë3€GÿÿÿÿÿÿÞ3·3Õ3€HSÿÿÿÿÿÿè3F€I>ÿÿÿÿÿÿò3Xè3@Jÿÿÿÿÿÿü3ò3€Kÿÿÿÿÿÿ4Þ3ü3€LSÿÿÿÿÿÿ4X(€M>ÿÿÿÿÿÿ4X4@Nÿÿÿÿÿÿ#44€Oÿÿÿÿÿÿ,44#4€Pÿÿÿÿÿÿ64s3,4€Q>ÿÿÿÿÿÿ@4"o-@RÿÿÿÿÿÿJ4@4€SÿÿÿÿÿÿS4Ê,J4€T>ÿÿÿÿÿÿ]442.@Uÿÿÿÿÿÿg4]4€Vÿÿÿÿÿÿp4S4g4€W>ÿÿÿÿÿÿz4Fõ.@Xÿÿÿÿÿÿ„4z4€Yÿÿÿÿÿÿ4p4„4€Z>ÿÿÿÿÿÿ—4X¸/@[ÿÿÿÿÿÿ¡4—4€\ÿÿÿÿÿÿª44¡4€]>ÿÿÿÿÿÿ´4Ó,@^ÿÿÿÿÿÿ¾4´4€_ÿÿÿÿÿÿÇ4¾4 -€`>ÿÿÿÿÿÿÑ44O.@aÿÿÿÿÿÿÛ4Ñ4€bÿÿÿÿÿÿä4Ç4Û4€c>ÿÿÿÿÿÿî4F/@dÿÿÿÿÿÿø4î4€eÿÿÿÿÿÿ5ä4ø4€f>ÿÿÿÿÿÿ 5XÕ/@gÿÿÿÿÿÿ5 5€hÿÿÿÿÿÿ555€iÿÿÿÿÿÿ(5ª45€j>ÿÿÿÿÿÿ25ú,@kÿÿÿÿÿÿ<525€l>ÿÿÿÿÿÿE5"³-@mÿÿÿÿÿÿO5E5€nÿÿÿÿÿÿX5<5O5€oÿÿÿÿÿÿb5X5Š.€p>ÿÿÿÿÿÿl5F9/@qÿÿÿÿÿÿv5l5€rÿÿÿÿÿÿ5b5v5€s>ÿÿÿÿÿÿ‰5Xü/@tÿÿÿÿÿÿ“5‰5€uÿÿÿÿÿÿœ55“5€vÿÿÿÿÿÿ¦5(5œ5€w>ÿÿÿÿÿÿ°5!-@xÿÿÿÿÿÿº5°5€y>ÿÿÿÿÿÿÃ5"Ú-@zÿÿÿÿÿÿÍ5Ã5€{ÿÿÿÿÿÿÖ5º5Í5€|>ÿÿÿÿÿÿà54.@}ÿÿÿÿÿÿê5à5€~ÿÿÿÿÿÿó5Ö5ê5€ÿÿÿÿÿÿý5ó5t/€€>ÿÿÿÿÿÿ6X#0@ÿÿÿÿÿÿ66€‚ÿÿÿÿÿÿ6ý56€ƒÿÿÿÿÿÿ$6¦56€„>ÿÿÿÿÿÿ.6H-@…ÿÿÿÿÿÿ86.6€†>ÿÿÿÿÿÿA6".@‡ÿÿÿÿÿÿK6A6€ˆÿÿÿÿÿÿT686K6€‰>ÿÿÿÿÿÿ^64Ä.@Šÿÿÿÿÿÿh6^6€‹ÿÿÿÿÿÿq6T6h6€Œ>ÿÿÿÿÿÿ{6F‡/@ÿÿÿÿÿÿ…6{6€ŽÿÿÿÿÿÿŽ6q6…6€ÿÿÿÿÿÿ˜6Ž6^0€ÿÿÿÿÿÿ¢6$6˜6€‘ÿÿÿÿÿÿ¬6w4€’ÿÿÿÿÿÿ¶6¦¬6€“ÿÿÿÿÿÿÀ6‰ú€”ÿÿÿÿÿÿÊ6¶6À6€•ÿÿÿÿÿÿÔ6›À€–ÿÿÿÿÿÿÞ6Ê6Ô6€—ÿÿÿÿÿÿè6­†€˜ÿÿÿÿÿÿò6Þ6è6€™ÿÿÿÿÿÿü6¯€šÿÿÿÿÿÿ7Kü6€›ÿÿÿÿÿÿ7¿0€œÿÿÿÿÿÿ777€ÿÿÿÿÿÿ$7Ñö€žÿÿÿÿÿÿ.77$7€Ÿÿÿÿÿÿÿ87ã¼€ ÿÿÿÿÿÿB7.787€¡ÿÿÿÿÿÿL7ò6B7€¢ÿÿÿÿÿÿV7Ès€£ÿÿÿÿÿÿ`7¥V7€¤ÿÿÿÿÿÿj7Âv€¥ÿÿÿÿÿÿt7`7j7€¦ÿÿÿÿÿÿ~7õ€§ÿÿÿÿÿÿˆ7t7~7€¨ÿÿÿÿÿÿ’7à€©ÿÿÿÿÿÿœ7ˆ7’7€ªÿÿÿÿÿÿ¦7L7œ7€«ÿÿÿÿÿÿ°7Ú…€¬ÿÿÿÿÿÿº7ÿ°7€­ÿÿÿÿÿÿÄ7þ]€®ÿÿÿÿÿÿÎ7º7Ä7€¯ÿÿÿÿÿÿØ7Õ耰ÿÿÿÿÿÿâ7Î7Ø7€±ÿÿÿÿÿÿì7ò€²ÿÿÿÿÿÿö7â7ì7€³ÿÿÿÿÿÿ8¦7ö7€´ÿÿÿÿÿÿ 8ì—€µÿÿÿÿÿÿ8Y 8€¶ÿÿÿÿÿÿ8o€·ÿÿÿÿÿÿ(888€¸ÿÿÿÿÿÿ28"5€¹ÿÿÿÿÿÿ<8(828€ºÿÿÿÿÿÿF8èZ€»ÿÿÿÿÿÿP8<8F8€¼ÿÿÿÿÿÿZ88P8€½ÿÿÿÿÿÿd8û¦€¾ÿÿÿÿÿÿn8d8³€¿ÿÿÿÿÿÿx8=ú€Àÿÿÿÿÿÿ‚8n8x8€ÁÿÿÿÿÿÿŒ8OÀ€Âÿÿÿÿÿÿ–8‚8Œ8€Ãÿÿÿÿÿÿ 8a†€Äÿÿÿÿÿÿª8–8 8€Åÿÿÿÿÿÿ´84w€Æÿÿÿÿÿÿ¾8´8€ÇÿÿÿÿÿÿÈ8s0€ÈÿÿÿÿÿÿÒ8¾8È8€ÉÿÿÿÿÿÿÜ8…ö€Êÿÿÿÿÿÿæ8Ò8Ü8€Ëÿÿÿÿÿÿð8—¼€Ìÿÿÿÿÿÿú8æ8ð8€Íÿÿÿÿÿÿ9ª8ú8€Îÿÿÿÿÿÿ9F‰€Ïÿÿÿÿÿÿ99g€Ðÿÿÿÿÿÿ"9v€Ñÿÿÿÿÿÿ,99"9€Òÿÿÿÿÿÿ69©€Óÿÿÿÿÿÿ@9,969€ÔÿÿÿÿÿÿJ9»à€ÕÿÿÿÿÿÿT9@9J9€Öÿÿÿÿÿÿ^99T9€×ÿÿÿÿÿÿh9X›€Øÿÿÿÿÿÿr9h9Á€Ùÿÿÿÿÿÿ|9²]€Úÿÿÿÿÿÿ†9r9|9€Ûÿÿÿÿÿÿ9*è€Üÿÿÿÿÿÿš9†99€Ýÿÿÿÿÿÿ¤9Íò€Þÿÿÿÿÿÿ®9š9¤9€ßÿÿÿÿÿÿ¸9^9®9€àÿÿÿÿÿÿÂ9j­€áÿÿÿÿÿÿÌ9Â9€âÿÿÿÿÿÿÖ9Äo€ãÿÿÿÿÿÿà9Ì9Ö9€äÿÿÿÿÿÿê9Ö5€åÿÿÿÿÿÿô9à9ê9€æÿÿÿÿÿÿþ9=Z€çÿÿÿÿÿÿ:ô9þ9€èÿÿÿÿÿÿ:¸9:€éÿÿÿÿÿÿ:Z8:€êÿÿÿÿÿÿ&:Z¦€ëÿÿÿÿÿÿ0:ß4€ìÿÿÿÿÿÿ::&:0:€íÿÿÿÿÿÿD:::‰€îÿÿÿÿÿÿN:À€ïÿÿÿÿÿÿX:D:N:€ðÿÿÿÿÿÿb:†€ñÿÿÿÿÿÿl:X:b:€òÿÿÿÿÿÿv:èw€óÿÿÿÿÿÿ€:c€ôÿÿÿÿÿÿŠ:v:€:€õÿÿÿÿÿÿ”:Š:Ù€öÿÿÿÿÿÿž:9ö€÷ÿÿÿÿÿÿ¨:”:ž:€øÿÿÿÿÿÿ²:K¼€ùÿÿÿÿÿÿ¼:¨:²:€úÿÿÿÿÿÿÆ:l:¼:€ûÿÿÿÿÿÿÐ:ú‰€üÿÿÿÿÿÿÚ:0s€ýÿÿÿÿÿÿä:Ð:Ú:€þÿÿÿÿÿÿî:ä:v€ÿÿÿÿÿÿÿø:]€ÿÿÿÿÿÿ;î:ø:€ÿÿÿÿÿÿ ;oà€ÿÿÿÿÿÿ;; ;€ÿÿÿÿÿÿ ;Æ:;€ÿÿÿÿÿÿ*; ›€ÿÿÿÿÿÿ4;B…€ÿÿÿÿÿÿ>;*;4;€ÿÿÿÿÿÿH;>;—€ÿÿÿÿÿÿR;‰è€ ÿÿÿÿÿÿ\;H;R;€ ÿÿÿÿÿÿf;ò€ ÿÿÿÿÿÿp;\;f;€ ÿÿÿÿÿÿz; ;p;€ ÿÿÿÿÿÿ„;­€ÿÿÿÿÿÿŽ;T—€ÿÿÿÿÿÿ˜;„;Ž;€ÿÿÿÿÿÿ¢;˜;ñ€ÿÿÿÿÿÿ¬;Š5€ÿÿÿÿÿÿ¶;¢;¬;€ÿÿÿÿÿÿÀ;œZ€ÿÿÿÿÿÿÊ;¶;À;€ÿÿÿÿÿÿÔ;z;Ê;€ÿÿÿÿÿÿÞ;:Ô;€ÿÿÿÿÿÿè;¹¦€ÿÿÿÿÿÿò;“4€ÿÿÿÿÿÿü;è;ò;€ÿÿÿÿÿÿ<¥ú€ÿÿÿÿÿÿ<ü;<€ÿÿÿÿÿÿ<<_€ÿÿÿÿÿÿ$<Ɇ€ÿÿÿÿÿÿ.<<$<€ÿÿÿÿÿÿ8<œw€ ÿÿÿÿÿÿB<€!ÿÿÿÿÿÿL<8<B<€"ÿÿÿÿÿÿV<Û0€#ÿÿÿÿÿÿ`<L<V<€$ÿÿÿÿÿÿj<`<¯€%ÿÿÿÿÿÿt<ÿ¼€&ÿÿÿÿÿÿ~<j<t<€'ÿÿÿÿÿÿˆ<.<~<€(ÿÿÿÿÿÿ’<®‰€)ÿÿÿÿÿÿœ<äs€*ÿÿÿÿÿÿ¦<’<œ<€+ÿÿÿÿÿÿ°<Õv€,ÿÿÿÿÿÿº<¦<°<€-ÿÿÿÿÿÿÄ<º< €.ÿÿÿÿÿÿÎ<#à€/ÿÿÿÿÿÿØ<Ä<Î<€0ÿÿÿÿÿÿâ<ˆ<Ø<€1ÿÿÿÿÿÿì<À›€2ÿÿÿÿÿÿö<ö…€3ÿÿÿÿÿÿ=ì<ö<€4ÿÿÿÿÿÿ =]€5ÿÿÿÿÿÿ== =€6ÿÿÿÿÿÿ==è€7ÿÿÿÿÿÿ(=5ò€8ÿÿÿÿÿÿ2==(=€9ÿÿÿÿÿÿ<=â<2=€:ÿÿÿÿÿÿF=Ò­€;ÿÿÿÿÿÿP=—€<ÿÿÿÿÿÿZ=F=P=€=ÿÿÿÿÿÿd=,o€>ÿÿÿÿÿÿn=Z=d=€?ÿÿÿÿÿÿx=n=Ç €@ÿÿÿÿÿÿ‚=ûZ€AÿÿÿÿÿÿŒ=x=‚=€Bÿÿÿÿÿÿ–=<=Œ=€Cÿÿÿÿÿÿ =Þ;–=€Dÿÿÿÿÿÿª=¦€Eÿÿÿÿÿÿ´=G4€Fÿÿÿÿÿÿ¾=ª=´=€GÿÿÿÿÿÿÈ=Yú€HÿÿÿÿÿÿÒ=¾=È=€IÿÿÿÿÿÿÜ=kÀ€Jÿÿÿÿÿÿæ=Ò=Ü=€Kÿÿÿÿÿÿð=æ=5!€Lÿÿÿÿÿÿú=Pw€Mÿÿÿÿÿÿ>!€Nÿÿÿÿÿÿ>ú=>€Oÿÿÿÿÿÿ>0€Pÿÿÿÿÿÿ">>>€Qÿÿÿÿÿÿ,>¡ö€Rÿÿÿÿÿÿ6>">,>€Sÿÿÿÿÿÿ@>6>…!€TÿÿÿÿÿÿJ>ð=@>€UÿÿÿÿÿÿT>b‰€Vÿÿÿÿÿÿ^>˜s€Wÿÿÿÿÿÿh>T>^>€Xÿÿÿÿÿÿr>4v€Yÿÿÿÿÿÿ|>h>r>€Zÿÿÿÿÿÿ†>Å€[ÿÿÿÿÿÿ>|>†>€\ÿÿÿÿÿÿš>>ß!€]ÿÿÿÿÿÿ¤>J>š>€^ÿÿÿÿÿÿ®>t›€_ÿÿÿÿÿÿ¸>ª…€`ÿÿÿÿÿÿÂ>®>¸>€aÿÿÿÿÿÿÌ>Î]€bÿÿÿÿÿÿÖ>Â>Ì>€cÿÿÿÿÿÿà>Gè€dÿÿÿÿÿÿê>Ö>à>€eÿÿÿÿÿÿô>ê>9"€fÿÿÿÿÿÿþ>¤>ô>€gÿÿÿÿÿÿ?†­€hÿÿÿÿÿÿ?¼—€iÿÿÿÿÿÿ???€jÿÿÿÿÿÿ&?ào€kÿÿÿÿÿÿ0??&?€lÿÿÿÿÿÿ:?ò5€mÿÿÿÿÿÿD?0?:?€nÿÿÿÿÿÿN?D?Z€oÿÿÿÿÿÿX?þ>N?€pÿÿÿÿÿÿb? =X?€qSÿÿÿÿÿÿl?*€r>ÿÿÿÿÿÿv?"l?€sÿÿÿÿÿÿ€?…0v?€tSÿÿÿÿÿÿŠ?<€u>ÿÿÿÿÿÿ”?4Š?€vÿÿÿÿÿÿž?€?”?€wSÿÿÿÿÿÿ¨?N€x>ÿÿÿÿÿÿ²?F¨?€yÿÿÿÿÿÿ¼?ž?²?€zSÿÿÿÿÿÿÆ?`€{>ÿÿÿÿÿÿÐ?XÆ?€|ÿÿÿÿÿÿÚ?¼?Ð?€}Sÿÿÿÿÿÿä?"j€~>ÿÿÿÿÿÿî?ä?€ÿÿÿÿÿÿø?î?[1€€Sÿÿÿÿÿÿ@"~€>ÿÿÿÿÿÿ @4@€‚ÿÿÿÿÿÿ@ø? @€ƒSÿÿÿÿÿÿ @"ˆ€„>ÿÿÿÿÿÿ*@F @€…ÿÿÿÿÿÿ4@@*@€†Sÿÿÿÿÿÿ>@"’€‡>ÿÿÿÿÿÿH@X>@€ˆÿÿÿÿÿÿR@4@H@€‰ÿÿÿÿÿÿ\@Ú?R@€ŠSÿÿÿÿÿÿf@4œ€‹>ÿÿÿÿÿÿp@f@€ŒSÿÿÿÿÿÿz@4¦€>ÿÿÿÿÿÿ„@"z@€ŽÿÿÿÿÿÿŽ@p@„@€ÿÿÿÿÿÿ˜@Ž@E2€Sÿÿÿÿÿÿ¢@4º€‘>ÿÿÿÿÿÿ¬@F¢@€’ÿÿÿÿÿÿ¶@˜@¬@€“SÿÿÿÿÿÿÀ@4Ä€”>ÿÿÿÿÿÿÊ@XÀ@€•ÿÿÿÿÿÿÔ@¶@Ê@€–ÿÿÿÿÿÿÞ@\@Ô@€—Sÿÿÿÿÿÿè@F΀˜>ÿÿÿÿÿÿò@è@€™Sÿÿÿÿÿÿü@FØ€š>ÿÿÿÿÿÿA"ü@€›ÿÿÿÿÿÿAò@A€œSÿÿÿÿÿÿAFâ€>ÿÿÿÿÿÿ$A4A€žÿÿÿÿÿÿ.AA$A€Ÿÿÿÿÿÿÿ8A.A/3€ SÿÿÿÿÿÿBAFö€¡>ÿÿÿÿÿÿLAXBA€¢ÿÿÿÿÿÿVA8ALA€£ÿÿÿÿÿÿ`AÞ@VA€¤SÿÿÿÿÿÿjAX€¥>ÿÿÿÿÿÿtAjA€¦Sÿÿÿÿÿÿ~AX €§>ÿÿÿÿÿÿˆA"~A€¨ÿÿÿÿÿÿ’AtAˆA€©SÿÿÿÿÿÿœAX€ª>ÿÿÿÿÿÿ¦A4œA€«ÿÿÿÿÿÿ°A’A¦A€¬SÿÿÿÿÿÿºAX€­>ÿÿÿÿÿÿÄAFºA€®ÿÿÿÿÿÿÎA°AÄA€¯ÿÿÿÿÿÿØAÎA4€°ÿÿÿÿÿÿâA`AØA€±SÿÿÿÿÿÿìA"€²>ÿÿÿÿÿÿöA"ìA@³ÿÿÿÿÿÿBöA€´ÿÿÿÿÿÿ B0B€µSÿÿÿÿÿÿB4€¶>ÿÿÿÿÿÿB4B@·ÿÿÿÿÿÿ'BB€¸ÿÿÿÿÿÿ0B B'B€¹Sÿÿÿÿÿÿ:BF€º>ÿÿÿÿÿÿDBF:B@»ÿÿÿÿÿÿNBDB€¼ÿÿÿÿÿÿWB0BNB€½SÿÿÿÿÿÿaBX€¾>ÿÿÿÿÿÿkBXaB@¿ÿÿÿÿÿÿuBkB€Àÿÿÿÿÿÿ~BWBuB€ÁSÿÿÿÿÿÿˆBt€Â>ÿÿÿÿÿÿ’BˆB@ÃÿÿÿÿÿÿœB’B€Äÿÿÿÿÿÿ¥BœBe1€ÅSÿÿÿÿÿÿ¯B4t€Æ>ÿÿÿÿÿÿ¹B4¯B@ÇÿÿÿÿÿÿÃB¹B€ÈÿÿÿÿÿÿÌB¥BÃB€ÉSÿÿÿÿÿÿÖBFt€Ê>ÿÿÿÿÿÿàBFÖB@ËÿÿÿÿÿÿêBàB€ÌÿÿÿÿÿÿóBÌBêB€ÍSÿÿÿÿÿÿýBXt€Î>ÿÿÿÿÿÿCXýB@ÏÿÿÿÿÿÿCC€ÐÿÿÿÿÿÿCóBC€Ñÿÿÿÿÿÿ$C~BC€ÒSÿÿÿÿÿÿ.C°€Ó>ÿÿÿÿÿÿ8C.C@ÔÿÿÿÿÿÿBC8C€ÕSÿÿÿÿÿÿKC"°€Ö>ÿÿÿÿÿÿUC"KC@×ÿÿÿÿÿÿ_CUC€ØÿÿÿÿÿÿhCBC_C€ÙÿÿÿÿÿÿrChCO2€ÚSÿÿÿÿÿÿ|CF°€Û>ÿÿÿÿÿÿ†CF|C@ÜÿÿÿÿÿÿC†C€Ýÿÿÿÿÿÿ™CrCC€ÞSÿÿÿÿÿÿ£CX°€ß>ÿÿÿÿÿÿ­CX£C@àÿÿÿÿÿÿ·C­C€áÿÿÿÿÿÿÀC™C·C€âÿÿÿÿÿÿÊC$CÀC€ãSÿÿÿÿÿÿÔCì€ä>ÿÿÿÿÿÿÞCÔC@åÿÿÿÿÿÿèCÞC€æSÿÿÿÿÿÿñC"ì€ç>ÿÿÿÿÿÿûC"ñC@èÿÿÿÿÿÿDûC€éÿÿÿÿÿÿDèCD€êSÿÿÿÿÿÿD4ì€ë>ÿÿÿÿÿÿ"D4D@ìÿÿÿÿÿÿ,D"D€íÿÿÿÿÿÿ5DD,D€îÿÿÿÿÿÿ?D5D93€ïSÿÿÿÿÿÿIDXì€ð>ÿÿÿÿÿÿSDXID@ñÿÿÿÿÿÿ]DSD€òÿÿÿÿÿÿfD?D]D€óÿÿÿÿÿÿpDÊCfD€ôSÿÿÿÿÿÿzD(€õ>ÿÿÿÿÿÿ„DzD@öÿÿÿÿÿÿŽD„D€÷Sÿÿÿÿÿÿ—D"(€ø>ÿÿÿÿÿÿ¡D"—D@ùÿÿÿÿÿÿ«D¡D€úÿÿÿÿÿÿ´DŽD«D€ûSÿÿÿÿÿÿ¾D4(€ü>ÿÿÿÿÿÿÈD4¾D@ýÿÿÿÿÿÿÒDÈD€þÿÿÿÿÿÿÛD´DÒD€ÿSÿÿÿÿÿÿåDF(€>ÿÿÿÿÿÿïDFåD@ÿÿÿÿÿÿùDïD€ÿÿÿÿÿÿEÛDùD€ÿÿÿÿÿÿ EE#4€ÿÿÿÿÿÿEpD E€ÿÿÿÿÿÿ E¦+€ÿÿÿÿÿÿ*E Eñ€ÿÿÿÿÿÿ4E*E·€ÿÿÿÿÿÿ>E4E}€ ÿÿÿÿÿÿHE€€ ÿÿÿÿÿÿREHE'€ ÿÿÿÿÿÿ\EREí€ ÿÿÿÿÿÿfE\E³€ ÿÿÿÿÿÿpE>EfE€ÿÿÿÿÿÿzE’|€ÿÿÿÿÿÿ„EzEv€ÿÿÿÿÿÿŽE„E€ÿÿÿÿÿÿ˜EŽE×€ÿÿÿÿÿÿ¢EpE˜E€ÿÿÿÿÿÿ¬E¤Ž€ÿÿÿÿÿÿ¶E¬Ef€ÿÿÿÿÿÿÀE¶Eè€ÿÿÿÿÿÿÊEÀEé€ÿÿÿÿÿÿÔE¢EÊE€ÿÿÿÿÿÿÞE¶ €ÿÿÿÿÿÿèEÞEx€ÿÿÿÿÿÿòEèE>€ÿÿÿÿÿÿüEòEZ€ÿÿÿÿÿÿFÔEüE€ÿÿÿÿÿÿF¦2€ÿÿÿÿÿÿFw€ÿÿÿÿÿÿ$FFF€ ÿÿÿÿÿÿ.F‰€!ÿÿÿÿÿÿ8F$F.F€"ÿÿÿÿÿÿBF›€#ÿÿÿÿÿÿLF8FBF€$ÿÿÿÿÿÿVF­ø€%ÿÿÿÿÿÿ`FLFVF€&ÿÿÿÿÿÿjF€Œ€'ÿÿÿÿÿÿtF¯v€(ÿÿÿÿÿÿ~FjFtF€)ÿÿÿÿÿÿˆF¿j€*ÿÿÿÿÿÿ’F~FˆF€+ÿÿÿÿÿÿœFÑ^€,ÿÿÿÿÿÿ¦F’FœF€-ÿÿÿÿÿÿ°FãR €.ÿÿÿÿÿÿºF¦F°F€/ÿÿÿÿÿÿÄF`FºF€0ÿÿÿÿÿÿÎF’ð€1ÿÿÿÿÿÿØFÈÚ€2ÿÿÿÿÿÿâFÎFØF€3ÿÿÿÿÿÿìFÂ΀4ÿÿÿÿÿÿöFâFìF€5ÿÿÿÿÿÿGõ€6ÿÿÿÿÿÿ GöFG€7ÿÿÿÿÿÿG¶ €8ÿÿÿÿÿÿG GG€9ÿÿÿÿÿÿ(GÄFG€:ÿÿÿÿÿÿ2G¤T€;ÿÿÿÿÿÿ€<ÿÿÿÿÿÿFG2GÿÿÿÿÿÿZGFGPG€?ÿÿÿÿÿÿdGÕ&€@ÿÿÿÿÿÿnGZGdG€AÿÿÿÿÿÿxG €Bÿÿÿÿÿÿ‚GnGxG€CÿÿÿÿÿÿŒG(G‚G€Dÿÿÿÿÿÿ–G¶¸€Eÿÿÿÿÿÿ G좀FÿÿÿÿÿÿªG–G G€Gÿÿÿÿÿÿ´G–€Hÿÿÿÿÿÿ¾GªG´G€IÿÿÿÿÿÿÈG"Š€JÿÿÿÿÿÿÒG¾GÈG€KÿÿÿÿÿÿÜGè~ €LÿÿÿÿÿÿæGÒGÜG€MÿÿÿÿÿÿðGŒGæG€NÿÿÿÿÿÿúGû<€OÿÿÿÿÿÿH+&€PÿÿÿÿÿÿHúGH€QÿÿÿÿÿÿH=€Rÿÿÿÿÿÿ"HHH€Sÿÿÿÿÿÿ,HO€Tÿÿÿÿÿÿ6H"H,H€Uÿÿÿÿÿÿ@Ha €VÿÿÿÿÿÿJH6H@H€WÿÿÿÿÿÿTH4–€Xÿÿÿÿÿÿ^H€€YÿÿÿÿÿÿhHTH^H€ZÿÿÿÿÿÿrHst€[ÿÿÿÿÿÿ|HhHrH€\ÿÿÿÿÿÿ†H…h€]ÿÿÿÿÿÿH|H†H€^ÿÿÿÿÿÿšH—\ €_ÿÿÿÿÿÿ¤HHšH€`ÿÿÿÿÿÿ®HJH¤H€aÿÿÿÿÿÿ¸HFú€bÿÿÿÿÿÿÂH|ä€cÿÿÿÿÿÿÌH¸HÂH€dÿÿÿÿÿÿÖHØ€eÿÿÿÿÿÿàHÌHÖH€fÿÿÿÿÿÿêH©Ì€gÿÿÿÿÿÿôHàHêH€hÿÿÿÿÿÿþH»À €iÿÿÿÿÿÿIôHþH€jÿÿÿÿÿÿI®HI€kÿÿÿÿÿÿIX^€lÿÿÿÿÿÿ&IŽH€mÿÿÿÿÿÿ0II&I€nÿÿÿÿÿÿ:I²<€oÿÿÿÿÿÿDI0I:I€pÿÿÿÿÿÿNI*0€qÿÿÿÿÿÿXIDINI€rÿÿÿÿÿÿbIÍ$ €sÿÿÿÿÿÿlIXIbI€tÿÿÿÿÿÿvIIlI€uÿÿÿÿÿÿ€Ij€vÿÿÿÿÿÿŠI ¬€wÿÿÿÿÿÿ”I€IŠI€xÿÿÿÿÿÿžIÄ €yÿÿÿÿÿÿ¨I”IžI€zÿÿÿÿÿÿ²IÖ”€{ÿÿÿÿÿÿ¼I¨I²I€|ÿÿÿÿÿÿÆI=ˆ €}ÿÿÿÿÿÿÐI¼IÆI€~ÿÿÿÿÿÿÚIvIÐI€ÿÿÿÿÿÿäIðGÚI€€ÿÿÿÿÿÿîIZP€ÿÿÿÿÿÿøIß:€‚ÿÿÿÿÿÿJîIøI€ƒÿÿÿÿÿÿ Jñ.€„ÿÿÿÿÿÿJJ J€…ÿÿÿÿÿÿ J"€†ÿÿÿÿÿÿ*JJ J€‡ÿÿÿÿÿÿ4J €ˆÿÿÿÿÿÿ>J*J4J€‰ÿÿÿÿÿÿHJ誀ŠÿÿÿÿÿÿRJc”€‹ÿÿÿÿÿÿ\JHJRJ€ŒÿÿÿÿÿÿfJ'ˆ€ÿÿÿÿÿÿpJ\JfJ€ŽÿÿÿÿÿÿzJ9|€ÿÿÿÿÿÿ„JpJzJ€ÿÿÿÿÿÿŽJKp €‘ÿÿÿÿÿÿ˜J„JŽJ€’ÿÿÿÿÿÿ¢J>J˜J€“ÿÿÿÿÿÿ¬Jú€”ÿÿÿÿÿÿ¶J0ø€•ÿÿÿÿÿÿÀJ¬J¶J€–ÿÿÿÿÿÿÊJv쀗ÿÿÿÿÿÿÔJÀJÊJ€˜ÿÿÿÿÿÿÞJ]à€™ÿÿÿÿÿÿèJÔJÞJ€šÿÿÿÿÿÿòJoÔ €›ÿÿÿÿÿÿüJèJòJ€œÿÿÿÿÿÿK¢JüJ€ÿÿÿÿÿÿK r€žÿÿÿÿÿÿKB\€Ÿÿÿÿÿÿÿ$KKK€ ÿÿÿÿÿÿ.KfP€¡ÿÿÿÿÿÿ8K$K.K€¢ÿÿÿÿÿÿBK‰D€£ÿÿÿÿÿÿLK8KBK€¤ÿÿÿÿÿÿVK8 €¥ÿÿÿÿÿÿ`KLKVK€¦ÿÿÿÿÿÿjKK`K€§ÿÿÿÿÿÿtKÖ€¨ÿÿÿÿÿÿ~KTÀ€©ÿÿÿÿÿÿˆKtK~K€ªÿÿÿÿÿÿ’Kx´€«ÿÿÿÿÿÿœKˆK’K€¬ÿÿÿÿÿÿ¦KŠ¨€­ÿÿÿÿÿÿ°KœK¦K€®ÿÿÿÿÿÿºKœœ €¯ÿÿÿÿÿÿÄK°KºK€°ÿÿÿÿÿÿÎKjKÄK€±ÿÿÿÿÿÿØKäIÎK€²ÿÿÿÿÿÿâK¹d€³ÿÿÿÿÿÿìK“N€´ÿÿÿÿÿÿöKâKìK€µÿÿÿÿÿÿL¥B€¶ÿÿÿÿÿÿ LöKL€·ÿÿÿÿÿÿL·6€¸ÿÿÿÿÿÿL LL€¹ÿÿÿÿÿÿ(LÉ* €ºÿÿÿÿÿÿ2LL(L€»ÿÿÿÿÿÿ¼€ßÿÿÿÿÿÿ¤MMšM€àÿÿÿÿÿÿ®Mû° €áÿÿÿÿÿÿ¸M¤M®M€âÿÿÿÿÿÿÂM^M¸M€ãÿÿÿÿÿÿÌMØKÂM€äÿÿÿÿÿÿÖMx€åÿÿÿÿÿÿàMGb€æÿÿÿÿÿÿêMÖMàM€çÿÿÿÿÿÿôMYV€èÿÿÿÿÿÿþMêMôM€éÿÿÿÿÿÿNkJ€êÿÿÿÿÿÿNþMN€ëÿÿÿÿÿÿN}> €ìÿÿÿÿÿÿ&NNN€íÿÿÿÿÿÿ0NPÒ€îÿÿÿÿÿÿ:N!¼€ïÿÿÿÿÿÿDN0N:N€ðÿÿÿÿÿÿNN°€ñÿÿÿÿÿÿXNDNNN€òÿÿÿÿÿÿbN¡¤€óÿÿÿÿÿÿlNXNbN€ôÿÿÿÿÿÿvN³˜ €õÿÿÿÿÿÿ€NlNvN€öÿÿÿÿÿÿŠN&N€N€÷ÿÿÿÿÿÿ”Nb6€øÿÿÿÿÿÿžN˜ €ùÿÿÿÿÿÿ¨N”NžN€úÿÿÿÿÿÿ²N4€ûÿÿÿÿÿÿ¼N¨N²N€üÿÿÿÿÿÿÆNÅ€ýÿÿÿÿÿÿÐN¼NÆN€þÿÿÿÿÿÿÚN×ü €ÿÿÿÿÿÿÿäNÐNÚN€ÿÿÿÿÿÿîNŠNäN€ÿÿÿÿÿÿøNtš€ÿÿÿÿÿÿOª„€ÿÿÿÿÿÿ OøNO€ÿÿÿÿÿÿOÎx€ÿÿÿÿÿÿ O OO€ÿÿÿÿÿÿ*OGl€ÿÿÿÿÿÿ4O O*O€ÿÿÿÿÿÿ>Oé` € ÿÿÿÿÿÿHO4O>O€ ÿÿÿÿÿÿROîNHO€ ÿÿÿÿÿÿ\O†þ€ ÿÿÿÿÿÿfO¼è€ ÿÿÿÿÿÿpO\OfO€ÿÿÿÿÿÿzOàÜ€ÿÿÿÿÿÿ„OpOzO€ÿÿÿÿÿÿŽOòЀÿÿÿÿÿÿ˜O„OŽO€ÿÿÿÿÿÿ¢OZÄ €ÿÿÿÿÿÿ¬O˜O¢O€ÿÿÿÿÿÿ¶ORO¬O€ÿÿÿÿÿÿÀOÌM¶O€ÿÿÿÿÿÿÊO2¦€ÿÿÿÿÿÿÔOŒû€ÿÿÿÿÿÿÞOÊOÔO€ÿÿÿÿÿÿèOðZ€ÿÿÿÿÿÿòOÞOèO€ÿÿÿÿÿÿüOT¹€ÿÿÿÿÿÿPòOüO€ÿÿÿÿÿÿP¸€ÿÿÿÿÿÿPPP€ÿÿÿÿÿÿ$P€€ ÿÿÿÿÿÿ.Pv4€!ÿÿÿÿÿÿ8P$P.P€"ÿÿÿÿÿÿBPÚè€#ÿÿÿÿÿÿLP8PBP€$ÿÿÿÿÿÿVP>œ€%ÿÿÿÿÿÿ`PLPVP€&ÿÿÿÿÿÿjP¢P€'ÿÿÿÿÿÿtP`PjP€(ÿÿÿÿÿÿ~PPtP€)ÿÿÿÿÿÿˆP’€*ÿÿÿÿÿÿ’PjF€+ÿÿÿÿÿÿœPˆP’P€,ÿÿÿÿÿÿ¦PÎú€-ÿÿÿÿÿÿ°PœP¦P€.ÿÿÿÿÿÿºP2®€/ÿÿÿÿÿÿÄP°PºP€0ÿÿÿÿÿÿÎP–b€1ÿÿÿÿÿÿØPÄPÎP€2ÿÿÿÿÿÿâP~PØP€3ÿÿÿÿÿÿìP¤€4ÿÿÿÿÿÿöP^X€5ÿÿÿÿÿÿQìPöP€6ÿÿÿÿÿÿ Q €7ÿÿÿÿÿÿQQ Q€8ÿÿÿÿÿÿQ&À€9ÿÿÿÿÿÿ(QQQ€:ÿÿÿÿÿÿ2QŠt€;ÿÿÿÿÿÿÿÿÿÿÿÿZQR j€?ÿÿÿÿÿÿdQPQZQ€@ÿÿÿÿÿÿnQ¶ €AÿÿÿÿÿÿxQdQnQ€Bÿÿÿÿÿÿ‚Q Ò€CÿÿÿÿÿÿŒQxQ‚Q€Dÿÿÿÿÿÿ–Q~ †€Eÿÿÿÿÿÿ QŒQ–Q€FÿÿÿÿÿÿªQFQ Q€Gÿÿÿÿÿÿ´Q<w€Hÿÿÿÿÿÿ¾Q–+€IÿÿÿÿÿÿÈQ´Q¾Q€JÿÿÿÿÿÿÒQú߀KÿÿÿÿÿÿÜQÈQÒQ€LÿÿÿÿÿÿæQ^“€MÿÿÿÿÿÿðQÜQæQ€NÿÿÿÿÿÿúQÂG€OÿÿÿÿÿÿRðQúQ€PÿÿÿÿÿÿR&¯€QÿÿÿÿÿÿR€€Rÿÿÿÿÿÿ"RRR€Sÿÿÿÿÿÿ,Räc€Tÿÿÿÿÿÿ6R"R,R€Uÿÿÿÿÿÿ@RH€VÿÿÿÿÿÿJR6R@R€WÿÿÿÿÿÿTR¬!€Xÿÿÿÿÿÿ^RJRTR€YÿÿÿÿÿÿhRR^R€ZÿÿÿÿÿÿrRÈ€[ÿÿÿÿÿÿ|Rt|€\ÿÿÿÿÿÿ†RrR|R€]ÿÿÿÿÿÿRØ0€^ÿÿÿÿÿÿšR†RR€_ÿÿÿÿÿÿ¤R<ä€`ÿÿÿÿÿÿ®RšR¤R€aÿÿÿÿÿÿ¸R ˜€bÿÿÿÿÿÿÂR®R¸R€cÿÿÿÿÿÿÌRhRÂR€dÿÿÿÿÿÿÖRÚ€eÿÿÿÿÿÿàRhŽ€fÿÿÿÿÿÿêRÖRàR€gÿÿÿÿÿÿôRÌB€hÿÿÿÿÿÿþRêRôR€iÿÿÿÿÿÿS0ö€jÿÿÿÿÿÿSþRS€kÿÿÿÿÿÿS”ª€lÿÿÿÿÿÿ&SSS€mÿÿÿÿÿÿ0SÌR&S€nÿÿÿÿÿÿ:S ì€oÿÿÿÿÿÿDS\  €pÿÿÿÿÿÿNS:SDS€qÿÿÿÿÿÿXSÀ T€rÿÿÿÿÿÿbSNSXS€sÿÿÿÿÿÿlS$ €tÿÿÿÿÿÿvSbSlS€uÿÿÿÿÿÿ€Sˆ ¼€vÿÿÿÿÿÿŠSvS€S€wÿÿÿÿÿÿ”S0SŠS€xÿÿÿÿÿÿžSªQ”S€yÿÿÿÿÿÿ¨SP‰€zÿÿÿÿÿÿ²Sª=€{ÿÿÿÿÿÿ¼S¨S²S€|ÿÿÿÿÿÿÆSñ€}ÿÿÿÿÿÿÐS¼SÆS€~ÿÿÿÿÿÿÚSr¥€ÿÿÿÿÿÿäSÐSÚS€€ÿÿÿÿÿÿîSÖY€ÿÿÿÿÿÿøSäSîS€‚ÿÿÿÿÿÿT:¿€ƒÿÿÿÿÿÿ T”s€„ÿÿÿÿÿÿTT T€…ÿÿÿÿÿÿ Tø'€†ÿÿÿÿÿÿ*TT T€‡ÿÿÿÿÿÿ4T\Û€ˆÿÿÿÿÿÿ>T*T4T€‰ÿÿÿÿÿÿHTÀ€ŠÿÿÿÿÿÿRT>THT€‹ÿÿÿÿÿÿ\TøSRT€ŒÿÿÿÿÿÿfT.€ÿÿÿÿÿÿpTˆ€ŽÿÿÿÿÿÿzTfTpT€ÿÿÿÿÿÿ„Tìv€ÿÿÿÿÿÿŽTzT„T€‘ÿÿÿÿÿÿ˜TPÕ€’ÿÿÿÿÿÿ¢TŽT˜T€“ÿÿÿÿÿÿ¬T´4€”ÿÿÿÿÿÿ¶T¢T¬T€•ÿÿÿÿÿÿÀT\T¶T€–ÿÿÿÿÿÿÊT"þ€—ÿÿÿÿÿÿÔT|²€˜ÿÿÿÿÿÿÞTÊTÔT€™ÿÿÿÿÿÿèTàf€šÿÿÿÿÿÿòTÞTèT€›ÿÿÿÿÿÿüTD€œÿÿÿÿÿÿUòTüT€ÿÿÿÿÿÿU¨Î€žÿÿÿÿÿÿUUU€Ÿÿÿÿÿÿÿ$UÀTU€ ÿÿÿÿÿÿ.U €¡ÿÿÿÿÿÿ8Up Ä€¢ÿÿÿÿÿÿBU.U8U€£ÿÿÿÿÿÿLUÔ x€¤ÿÿÿÿÿÿVUBULU€¥ÿÿÿÿÿÿ`U8 ,€¦ÿÿÿÿÿÿjUVU`U€§ÿÿÿÿÿÿtUœ à€¨ÿÿÿÿÿÿ~UjUtU€©ÿÿÿÿÿÿˆU$U~U€ªÿÿÿÿÿÿ’UžSˆU€«ÿÿÿÿÿÿœUd›€¬ÿÿÿÿÿÿ¦U¾O€­ÿÿÿÿÿÿ°UœU¦U€®ÿÿÿÿÿÿºU"€¯ÿÿÿÿÿÿÄU°UºU€°ÿÿÿÿÿÿÎU†·€±ÿÿÿÿÿÿØUÄUÎU€²ÿÿÿÿÿÿâUêk€³ÿÿÿÿÿÿìUØUâU€´ÿÿÿÿÿÿöUNÑ€µÿÿÿÿÿÿV¨…€¶ÿÿÿÿÿÿ VöUV€·ÿÿÿÿÿÿV 9€¸ÿÿÿÿÿÿV VV€¹ÿÿÿÿÿÿ(Vp퀺ÿÿÿÿÿÿ2VV(V€»ÿÿÿÿÿÿ€Øÿÿÿÿÿÿ^WJWTW€ÙÿÿÿÿÿÿhW° ò€ÚÿÿÿÿÿÿrW^WhW€Ûÿÿÿÿÿÿ|WWrW€Üÿÿÿÿÿÿ†W’U|W€ÝÿÿÿÿÿÿWx­€ÞÿÿÿÿÿÿšWÒa€ßÿÿÿÿÿÿ¤WWšW€àÿÿÿÿÿÿ®W6€áÿÿÿÿÿÿ¸W¤W®W€âÿÿÿÿÿÿÂWšÉ€ãÿÿÿÿÿÿÌW¸WÂW€äÿÿÿÿÿÿÖWþ}€åÿÿÿÿÿÿàWÌWÖW€æÿÿÿÿÿÿêWbã€çÿÿÿÿÿÿôW¼—€èÿÿÿÿÿÿþWêWôW€éÿÿÿÿÿÿX K€êÿÿÿÿÿÿXþWX€ëÿÿÿÿÿÿX„ÿ€ìÿÿÿÿÿÿ&XXX€íÿÿÿÿÿÿ0Xè³€îÿÿÿÿÿÿ:X&X0X€ïÿÿÿÿÿÿDXàW:X€ðÿÿÿÿÿÿNXV€ñÿÿÿÿÿÿXX°»€òÿÿÿÿÿÿbXNXXX€óÿÿÿÿÿÿlXo€ôÿÿÿÿÿÿvXbXlX€õÿÿÿÿÿÿ€Xx#€öÿÿÿÿÿÿŠXvX€X€÷ÿÿÿÿÿÿ”XÜ×€øÿÿÿÿÿÿžXŠX”X€ùÿÿÿÿÿÿ¨XDXžX€úÿÿÿÿÿÿ²XJ€ûÿÿÿÿÿÿ¼X¤Í€üÿÿÿÿÿÿÆX²X¼X€ýÿÿÿÿÿÿÐX€þÿÿÿÿÿÿÚXÆXÐX€ÿÿÿÿÿÿÿäXl5€ ÿÿÿÿÿÿîXÚXäX€ ÿÿÿÿÿÿøXÐé€ ÿÿÿÿÿÿYîXøX€ ÿÿÿÿÿÿ Y¨XY€ ÿÿÿÿÿÿY> è€ ÿÿÿÿÿÿ Y˜ =€ ÿÿÿÿÿÿ*YY Y€ ÿÿÿÿÿÿ4Yü œ€ ÿÿÿÿÿÿ>Y*Y4Y€ ÿÿÿÿÿÿHY` û€ ÿÿÿÿÿÿRY>YHY€ ÿÿÿÿÿÿ\YÄ Z€ ÿÿÿÿÿÿfYRY\Y€ ÿÿÿÿÿÿpY YfY€ ÿÿÿÿÿÿzY†WpY€ ÿÿÿÿÿÿ„Y÷"X'€ ÿÿÿÿÿÿŽY„Yþ'€ ÿÿÿÿÿÿ˜YŽY¤(€ ÿÿÿÿÿÿ¢Y˜YJ)€ ÿÿÿÿÿÿ¬Y¼&Í#€ ÿÿÿÿÿÿ¶Y¬Y(€ ÿÿÿÿÿÿÀY¶YÁ(€ ÿÿÿÿÿÿÊYÀYg)€ ÿÿÿÿÿÿÔY¢YÊY€ ÿÿÿÿÿÿÞYã&'€ ÿÿÿÿÿÿèYÞY·$€ ÿÿÿÿÿÿòYèYè(€ ÿÿÿÿÿÿüYòYŽ)€ ÿÿÿÿÿÿZÔYüY€ ÿÿÿÿÿÿZ '¦'€ ÿÿÿÿÿÿZZL(€ ÿÿÿÿÿÿ$ZZ¡%€ ÿÿÿÿÿÿ.Z$Zµ)€! ÿÿÿÿÿÿ8ZZ.Z€" ÿÿÿÿÿÿBZ1'Í'€# ÿÿÿÿÿÿLZBZs(€$ ÿÿÿÿÿÿVZLZ)€% ÿÿÿÿÿÿ`ZVZ‹&€& ÿÿÿÿÿÿjZ8Z`Z€' >ÿÿÿÿÿÿtZj@( ÿÿÿÿÿÿ~ZtZ€) >ÿÿÿÿÿÿ‡Zœ@* ÿÿÿÿÿÿ‘Z‡Z€+ ÿÿÿÿÿÿšZ~Z‘Z€, >ÿÿÿÿÿÿ¤ZÎ@- ÿÿÿÿÿÿ®Z¤Z€. ÿÿÿÿÿÿ·ZšZ®Z€/ >ÿÿÿÿÿÿÁZ@0 ÿÿÿÿÿÿËZÁZ€1 ÿÿÿÿÿÿÔZ·ZËZ€2 >ÿÿÿÿÿÿÞZjœ@3 ÿÿÿÿÿÿèZÞZ€4 ÿÿÿÿÿÿñZÔZèZ€5 >ÿÿÿÿÿÿûZjÎ@6 ÿÿÿÿÿÿ[ûZ€7 ÿÿÿÿÿÿ[ñZ[€8 >ÿÿÿÿÿÿ[j@9 ÿÿÿÿÿÿ"[[€: ÿÿÿÿÿÿ+[["[€; >ÿÿÿÿÿÿ5[œÎ@< ÿÿÿÿÿÿ?[5[€= ÿÿÿÿÿÿH[+[?[€> >ÿÿÿÿÿÿR[œ@? ÿÿÿÿÿÿ\[R[€@ ÿÿÿÿÿÿe[H[\[€A >ÿÿÿÿÿÿo[Î@B ÿÿÿÿÿÿy[o[€C ÿÿÿÿÿÿ‚[e[y[€D >ÿÿÿÿÿÿŒ[*t@E ÿÿÿÿÿÿ–[Œ[€F >ÿÿÿÿÿÿŸ[*¦@G ÿÿÿÿÿÿ©[Ÿ[€H ÿÿÿÿÿÿ²[–[©[€I >ÿÿÿÿÿÿ¼[*Ø@J ÿÿÿÿÿÿÆ[¼[€K ÿÿÿÿÿÿÏ[²[Æ[€L >ÿÿÿÿÿÿÙ[* @M ÿÿÿÿÿÿã[Ù[€N ÿÿÿÿÿÿì[Ï[ã[€O >ÿÿÿÿÿÿö[t¦@P ÿÿÿÿÿÿ\ö[€Q ÿÿÿÿÿÿ \ì[\€R >ÿÿÿÿÿÿ\tØ@S ÿÿÿÿÿÿ\\€T ÿÿÿÿÿÿ&\ \\€U >ÿÿÿÿÿÿ0\t @V ÿÿÿÿÿÿ:\0\€W ÿÿÿÿÿÿC\&\:\€X >ÿÿÿÿÿÿM\¦Ø@Y ÿÿÿÿÿÿW\M\€Z ÿÿÿÿÿÿ`\C\W\€[ >ÿÿÿÿÿÿj\¦ @\ ÿÿÿÿÿÿt\j\€] ÿÿÿÿÿÿ}\`\t\€^ >ÿÿÿÿÿÿ‡\Ø @_ ÿÿÿÿÿÿ‘\‡\€` ÿÿÿÿÿÿš\}\‘\€a ÿÿÿÿÿÿ¤\‚[š\€b >ÿÿÿÿÿÿ®\<~@c ÿÿÿÿÿÿ¸\®\€d >ÿÿÿÿÿÿÁ\<°@e ÿÿÿÿÿÿË\Á\€f ÿÿÿÿÿÿÔ\¸\Ë\€g >ÿÿÿÿÿÿÞ\<â@h ÿÿÿÿÿÿè\Þ\€i ÿÿÿÿÿÿñ\Ô\è\€j >ÿÿÿÿÿÿû\<@k ÿÿÿÿÿÿ]û\€l ÿÿÿÿÿÿ]ñ\]€m >ÿÿÿÿÿÿ]~°@n ÿÿÿÿÿÿ"]]€o ÿÿÿÿÿÿ+]]"]€p >ÿÿÿÿÿÿ5]~â@q ÿÿÿÿÿÿ?]5]€r ÿÿÿÿÿÿH]+]?]€s >ÿÿÿÿÿÿR]~@t ÿÿÿÿÿÿ\]R]€u ÿÿÿÿÿÿe]H]\]€v >ÿÿÿÿÿÿo]°â@w ÿÿÿÿÿÿy]o]€x ÿÿÿÿÿÿ‚]e]y]€y >ÿÿÿÿÿÿŒ]°@z ÿÿÿÿÿÿ–]Œ]€{ ÿÿÿÿÿÿŸ]‚]–]€| >ÿÿÿÿÿÿ©]â@} ÿÿÿÿÿÿ³]©]€~ ÿÿÿÿÿÿ¼]Ÿ]³]€ ÿÿÿÿÿÿÆ]¤\¼]€€ >ÿÿÿÿÿÿÐ]Nˆ@ ÿÿÿÿÿÿÚ]Ð]€‚ >ÿÿÿÿÿÿã]Nº@ƒ ÿÿÿÿÿÿí]ã]€„ ÿÿÿÿÿÿö]Ú]í]€… >ÿÿÿÿÿÿ^Nì@† ÿÿÿÿÿÿ ^^€‡ ÿÿÿÿÿÿ^ö] ^€ˆ >ÿÿÿÿÿÿ^N@‰ ÿÿÿÿÿÿ'^^€Š ÿÿÿÿÿÿ0^^'^€‹ >ÿÿÿÿÿÿ:^ˆº@Œ ÿÿÿÿÿÿD^:^€ ÿÿÿÿÿÿM^0^D^€Ž >ÿÿÿÿÿÿW^ˆì@ ÿÿÿÿÿÿa^W^€ ÿÿÿÿÿÿj^M^a^€‘ >ÿÿÿÿÿÿt^ˆ@’ ÿÿÿÿÿÿ~^t^€“ ÿÿÿÿÿÿ‡^j^~^€” >ÿÿÿÿÿÿ‘^ºì@• ÿÿÿÿÿÿ›^‘^€– ÿÿÿÿÿÿ¤^‡^›^€— >ÿÿÿÿÿÿ®^º@˜ ÿÿÿÿÿÿ¸^®^€™ ÿÿÿÿÿÿÁ^¤^¸^€š >ÿÿÿÿÿÿË^ì@› ÿÿÿÿÿÿÕ^Ë^€œ ÿÿÿÿÿÿÞ^Á^Õ^€ ÿÿÿÿÿÿè^Æ]Þ^€ž >ÿÿÿÿÿÿò^`’@Ÿ ÿÿÿÿÿÿü^ò^€  >ÿÿÿÿÿÿ_`Ä@¡ ÿÿÿÿÿÿ__€¢ ÿÿÿÿÿÿ_ü^_€£ >ÿÿÿÿÿÿ"_`ö@¤ ÿÿÿÿÿÿ,_"_€¥ ÿÿÿÿÿÿ5__,_€¦ >ÿÿÿÿÿÿ?_`(@§ ÿÿÿÿÿÿI_?_€¨ ÿÿÿÿÿÿR_5_I_€© >ÿÿÿÿÿÿ\_’Ä@ª ÿÿÿÿÿÿf_\_€« ÿÿÿÿÿÿo_R_f_€¬ >ÿÿÿÿÿÿy_’ö@­ ÿÿÿÿÿÿƒ_y_€® ÿÿÿÿÿÿŒ_o_ƒ_€¯ >ÿÿÿÿÿÿ–_’(@° ÿÿÿÿÿÿ _–_€± ÿÿÿÿÿÿ©_Œ_ _€² >ÿÿÿÿÿÿ³_Äö@³ ÿÿÿÿÿÿ½_³_€´ ÿÿÿÿÿÿÆ_©_½_€µ >ÿÿÿÿÿÿÐ_Ä(@¶ ÿÿÿÿÿÿÚ_Ð_€· ÿÿÿÿÿÿã_Æ_Ú_€¸ >ÿÿÿÿÿÿí_ö(@¹ ÿÿÿÿÿÿ÷_í_€º ÿÿÿÿÿÿ`ã_÷_€» ÿÿÿÿÿÿ `è^`€¼ >ÿÿÿÿÿÿ`*@½ ÿÿÿÿÿÿ``€¾ >ÿÿÿÿÿÿ'`<@¿ ÿÿÿÿÿÿ1`'`€À ÿÿÿÿÿÿ:``1`€Á >ÿÿÿÿÿÿD`N@ ÿÿÿÿÿÿN`D`€Ã ÿÿÿÿÿÿW`:`N`€Ä >ÿÿÿÿÿÿa``@Å ÿÿÿÿÿÿk`a`€Æ ÿÿÿÿÿÿt`W`k`€Ç >ÿÿÿÿÿÿ~`*<@È ÿÿÿÿÿÿˆ`~`€É ÿÿÿÿÿÿ‘`t`ˆ`€Ê >ÿÿÿÿÿÿ›`*N@Ë ÿÿÿÿÿÿ¥`›`€Ì ÿÿÿÿÿÿ®`‘`¥`€Í >ÿÿÿÿÿÿ¸`*`@Î ÿÿÿÿÿÿÂ`¸`€Ï ÿÿÿÿÿÿË`®`Â`€Ð >ÿÿÿÿÿÿÕ`<N@Ñ ÿÿÿÿÿÿß`Õ`€Ò ÿÿÿÿÿÿè`Ë`ß`€Ó >ÿÿÿÿÿÿò`<`@Ô ÿÿÿÿÿÿü`ò`€Õ ÿÿÿÿÿÿaè`ü`€Ö >ÿÿÿÿÿÿaN`@× ÿÿÿÿÿÿaa€Ø ÿÿÿÿÿÿ"aaa€Ù >ÿÿÿÿÿÿ,ajt@Ú ÿÿÿÿÿÿ6a,a€Û >ÿÿÿÿÿÿ?aj~@Ü ÿÿÿÿÿÿIa?a€Ý ÿÿÿÿÿÿRa6aIa€Þ >ÿÿÿÿÿÿ\ajˆ@ß ÿÿÿÿÿÿfa\a€à ÿÿÿÿÿÿoaRafa€á >ÿÿÿÿÿÿyaj’@â ÿÿÿÿÿÿƒaya€ã ÿÿÿÿÿÿŒaoaƒa€ä >ÿÿÿÿÿÿ–at~@å ÿÿÿÿÿÿ a–a€æ ÿÿÿÿÿÿ©aŒa a€ç >ÿÿÿÿÿÿ³atˆ@è ÿÿÿÿÿÿ½a³a€é ÿÿÿÿÿÿÆa©a½a€ê >ÿÿÿÿÿÿÐat’@ë ÿÿÿÿÿÿÚaÐa€ì ÿÿÿÿÿÿãaÆaÚa€í >ÿÿÿÿÿÿía~ˆ@î ÿÿÿÿÿÿ÷aía€ï ÿÿÿÿÿÿbãa÷a€ð >ÿÿÿÿÿÿ b~’@ñ ÿÿÿÿÿÿb b€ò ÿÿÿÿÿÿbbb€ó >ÿÿÿÿÿÿ'bˆ’@ô ÿÿÿÿÿÿ1b'b€õ ÿÿÿÿÿÿ:bb1b€ö ÿÿÿÿÿÿDb"a:b€÷ >ÿÿÿÿÿÿNbœ¦@ø ÿÿÿÿÿÿXbNb€ù >ÿÿÿÿÿÿabœ°@ú ÿÿÿÿÿÿkbab€û ÿÿÿÿÿÿtbXbkb€ü >ÿÿÿÿÿÿ~bœº@ý ÿÿÿÿÿÿˆb~b€þ ÿÿÿÿÿÿ‘btbˆb€ÿ >ÿÿÿÿÿÿ›bœÄ@ ÿÿÿÿÿÿ¥b›b€ ÿÿÿÿÿÿ®b‘b¥b€ >ÿÿÿÿÿÿ¸b¦°@ ÿÿÿÿÿÿÂb¸b€ ÿÿÿÿÿÿËb®bÂb€ >ÿÿÿÿÿÿÕb¦º@ ÿÿÿÿÿÿßbÕb€ ÿÿÿÿÿÿèbËbßb€ >ÿÿÿÿÿÿòb¦Ä@ ÿÿÿÿÿÿübòb€ ÿÿÿÿÿÿcèbüb€ >ÿÿÿÿÿÿc°º@ ÿÿÿÿÿÿcc€ ÿÿÿÿÿÿ"ccc€ >ÿÿÿÿÿÿ,c°Ä@ ÿÿÿÿÿÿ6c,c€ ÿÿÿÿÿÿ?c"c6c€ >ÿÿÿÿÿÿIcºÄ@ ÿÿÿÿÿÿScIc€ ÿÿÿÿÿÿ\c?cSc€ ÿÿÿÿÿÿfcDb\c€ >ÿÿÿÿÿÿpcÎØ@ ÿÿÿÿÿÿzcpc€ >ÿÿÿÿÿÿƒcÎâ@ ÿÿÿÿÿÿcƒc€ ÿÿÿÿÿÿ–czcc€ >ÿÿÿÿÿÿ cÎì@ ÿÿÿÿÿÿªc c€ ÿÿÿÿÿÿ³c–cªc€ >ÿÿÿÿÿÿ½cÎö@ ÿÿÿÿÿÿÇc½c€ ÿÿÿÿÿÿÐc³cÇc€ >ÿÿÿÿÿÿÚcØâ@! ÿÿÿÿÿÿäcÚc€" ÿÿÿÿÿÿícÐcäc€# >ÿÿÿÿÿÿ÷cØì@$ ÿÿÿÿÿÿd÷c€% ÿÿÿÿÿÿ dícd€& >ÿÿÿÿÿÿdØö@' ÿÿÿÿÿÿdd€( ÿÿÿÿÿÿ'd dd€) >ÿÿÿÿÿÿ1dâì@* ÿÿÿÿÿÿ;d1d€+ ÿÿÿÿÿÿDd'd;d€, >ÿÿÿÿÿÿNdâö@- ÿÿÿÿÿÿXdNd€. ÿÿÿÿÿÿadDdXd€/ >ÿÿÿÿÿÿkdìö@0 ÿÿÿÿÿÿudkd€1 ÿÿÿÿÿÿ~dadud€2 ÿÿÿÿÿÿˆdfc~d€3 >ÿÿÿÿÿÿ’d @4 ÿÿÿÿÿÿœd’d€5 >ÿÿÿÿÿÿ¥d@6 ÿÿÿÿÿÿ¯d¥d€7 ÿÿÿÿÿÿ¸dœd¯d€8 >ÿÿÿÿÿÿÂd@9 ÿÿÿÿÿÿÌdÂd€: ÿÿÿÿÿÿÕd¸dÌd€; >ÿÿÿÿÿÿßd(@< ÿÿÿÿÿÿédßd€= ÿÿÿÿÿÿòdÕdéd€> >ÿÿÿÿÿÿüd @? ÿÿÿÿÿÿeüd€@ ÿÿÿÿÿÿeòde€A >ÿÿÿÿÿÿe @B ÿÿÿÿÿÿ#ee€C ÿÿÿÿÿÿ,ee#e€D >ÿÿÿÿÿÿ6e (@E ÿÿÿÿÿÿ@e6e€F ÿÿÿÿÿÿIe,e@e€G >ÿÿÿÿÿÿSe@H ÿÿÿÿÿÿ]eSe€I ÿÿÿÿÿÿfeIe]e€J >ÿÿÿÿÿÿpe(@K ÿÿÿÿÿÿzepe€L ÿÿÿÿÿÿƒefeze€M >ÿÿÿÿÿÿe(@N ÿÿÿÿÿÿ—ee€O ÿÿÿÿÿÿ eƒe—e€P ÿÿÿÿÿÿªeˆd e€Q ÿÿÿÿÿÿ´e `ªe€R >ÿÿÿÿÿÿ¾e"@S ÿÿÿÿÿÿÈe¾e€T >ÿÿÿÿÿÿÑe4@U ÿÿÿÿÿÿÛeÑe€V ÿÿÿÿÿÿäeÈeÛe€W >ÿÿÿÿÿÿîeF@X ÿÿÿÿÿÿøeîe€Y ÿÿÿÿÿÿfäeøe€Z >ÿÿÿÿÿÿ fX@[ ÿÿÿÿÿÿf f€\ ÿÿÿÿÿÿfff€] >ÿÿÿÿÿÿ(f"4@^ ÿÿÿÿÿÿ2f(f€_ ÿÿÿÿÿÿ;ff2f€` >ÿÿÿÿÿÿEf"F@a ÿÿÿÿÿÿOfEf€b ÿÿÿÿÿÿXf;fOf€c >ÿÿÿÿÿÿbf"X@d ÿÿÿÿÿÿlfbf€e ÿÿÿÿÿÿufXflf€f >ÿÿÿÿÿÿf4F@g ÿÿÿÿÿÿ‰ff€h ÿÿÿÿÿÿ’fuf‰f€i >ÿÿÿÿÿÿœf4X@j ÿÿÿÿÿÿ¦fœf€k ÿÿÿÿÿÿ¯f’f¦f€l >ÿÿÿÿÿÿ¹fFX@m ÿÿÿÿÿÿÃf¹f€n ÿÿÿÿÿÿÌf¯fÃf€o ÿÿÿÿÿÿÖfÎú€p ÿÿÿÿÿÿàfÖf €q ÿÿÿÿÿÿêfàfV€r ÿÿÿÿÿÿôfP¾€s ÿÿÿÿÿÿþfôfú€t ÿÿÿÿÿÿgþfT€u ÿÿÿÿÿÿggþ€v ÿÿÿÿÿÿgg&€w ÿÿÿÿÿÿ&ggv€x ÿÿÿÿÿÿ0g&g €y ÿÿÿÿÿÿ:g0g„€z ÿÿÿÿÿÿDg:gÀ€{ ÿÿÿÿÿÿNgDgV€| ÿÿÿÿÿÿXgNgt€} ÿÿÿÿÿÿbgXg΀~ ÿÿÿÿÿÿlgbgP€ ÿÿÿÿÿÿvglgÈ€€ ÿÿÿÿÿÿ€gvg€ ÿÿÿÿÿÿŠg€g|€‚ ÿÿÿÿÿÿ”gŠg€ƒ ÿÿÿÿÿÿžg”gX€„ ÿÿÿÿÿÿ¨gžg”€… ÿÿÿÿÿÿ²g¨g* €† ÿÿÿÿÿÿ¼g²g˜ €‡ ÿÿÿÿÿÿÆg¼gÔ €ˆ ÿÿÿÿÿÿÐgÆg$ €‰ ÿÿÿÿÿÿÚgÐg~ @Š ÿÿÿÿÿÿägÚg€‹ ÿÿÿÿÿÿígg€Œ ÿÿÿÿÿÿ÷gíg”€ ÿÿÿÿÿÿh÷g €Ž ÿÿÿÿÿÿ hh„€ ÿÿÿÿÿÿh h¬€ ÿÿÿÿÿÿhhV€‘ ÿÿÿÿÿÿ)hht€’ ÿÿÿÿÿÿ3h)h΀“ ÿÿÿÿÿÿ=h3hP€” ÿÿÿÿÿÿGh=hÈ€• ÿÿÿÿÿÿQhGh€– ÿÿÿÿÿÿ[hQh¤€— ÿÿÿÿÿÿeh[hà€˜ ÿÿÿÿÿÿohehX€™ ÿÿÿÿÿÿyhohŠ€š ÿÿÿÿÿÿƒhyh* €› ÿÿÿÿÿÿhƒhR €œ ÿÿÿÿÿÿ—hhü € ÿÿÿÿÿÿ¡h—h$ €ž ÿÿÿÿÿÿ«h¡hœ @Ÿ ÿÿÿÿÿÿµh«h  ÿÿÿÿÿÿ¾hâ œm±"Ù"ž&Ò)Â*¬,q064¢6b?âAEFÀOzYjZ´eÌfêfägµh€¡ SÿÿÿÿÿÿÞhœ~€¢ >ÿÿÿÿÿÿèh<Þh€£ >ÿÿÿÿÿÿòhœê'€¤ Sÿÿÿÿÿÿühœ<€¥ >ÿÿÿÿÿÿi°üh€¦ Sÿÿÿÿÿÿiœ°€§ >ÿÿÿÿÿÿi~i€¨ Sÿÿÿÿÿÿ$i~œ€© >ÿÿÿÿÿÿ.i°$i€ª >ÿÿÿÿÿÿ8i~³-€« >ÿÿÿÿÿÿBi4|$€¬ SÿÿÿÿÿÿLi~<€­ >ÿÿÿÿÿÿViœLi€® Sÿÿÿÿÿÿ`i~°€¯ >ÿÿÿÿÿÿji<`i€° >ÿÿÿÿÿÿti~f@€± >ÿÿÿÿÿÿ~i4x1€² >ÿÿÿÿÿÿˆi°°€³ >ÿÿÿÿÿÿ’i<¿0€´ >ÿÿÿÿÿÿœiœ;2€µ Sÿÿÿÿÿÿ¦i<œ€¶ >ÿÿÿÿÿÿ°i<¦i€· Sÿÿÿÿÿÿºi<~€¸ >ÿÿÿÿÿÿÄiœºi€¹ >ÿÿÿÿÿÿÎi~_$€º SÿÿÿÿÿÿØi<°€» >ÿÿÿÿÿÿâi°Øi€¼ Sÿÿÿÿÿÿìi°œ€½ >ÿÿÿÿÿÿöiœìi€¾ Sÿÿÿÿÿÿj°~€¿ >ÿÿÿÿÿÿ j°j€À >ÿÿÿÿÿÿj<£$€Á Sÿÿÿÿÿÿj°<€Â >ÿÿÿÿÿÿ(j~j€Ã ÿÿÿÿÿÿ2j€.(j€Ä ÿÿÿÿÿÿÿÿÿÿÿÿ+k°2.€Ý >ÿÿÿÿÿÿ5k4ê'€Þ >ÿÿÿÿÿÿ?kœüh€ß >ÿÿÿÿÿÿIk<$i€à >ÿÿÿÿÿÿSkœ|$€á >ÿÿÿÿÿÿ]k4Li€â >ÿÿÿÿÿÿgk°`i€ã >ÿÿÿÿÿÿqk4¦i€ä >ÿÿÿÿÿÿ{k°ú,€å >ÿÿÿÿÿÿ…k<Øi€æ ÿÿÿÿÿÿkPj…k€ç ÿÿÿÿÿÿ™kk{k€è ÿÿÿÿÿÿ£k™kÎi€é ÿÿÿÿÿÿ­k£kÄi€ê ÿÿÿÿÿÿ·k­kqk€ë ÿÿÿÿÿÿÁk·kœi€ì ÿÿÿÿÿÿËkÁk’i€í ÿÿÿÿÿÿÕkËkˆi€î ÿÿÿÿÿÿßkÕk~i€ï ÿÿÿÿÿÿékßkti€ð ÿÿÿÿÿÿókékgk€ñ ÿÿÿÿÿÿýkók]k€ò ÿÿÿÿÿÿlýkSk€ó ÿÿÿÿÿÿll8i€ô ÿÿÿÿÿÿllIk€õ ÿÿÿÿÿÿ%lli€ö ÿÿÿÿÿÿ/l%l?k€÷ ÿÿÿÿÿÿ9l/l5k€ø ÿÿÿÿÿÿCl9lèh€ù ÿÿÿÿÿÿMlCl+k@ú ÿÿÿÿÿÿWl†Ù€û ÿÿÿÿÿÿ`lˆij€ü ÿÿÿÿÿÿjl`lÎi€ý ÿÿÿÿÿÿtljlœi€þ >ÿÿÿÿÿÿ~l~œ@ÿ ÿÿÿÿÿÿˆl~l€ >ÿÿÿÿÿÿ‘l<œ@ ÿÿÿÿÿÿ›l‘l€ ÿÿÿÿÿÿ¤lË\v€ ÿÿÿÿÿÿ®l¤l"]€ ÿÿÿÿÿÿ¸l®lkb€ ÿÿÿÿÿÿÂl¸lñ€ ÿÿÿÿÿÿÌlÂl¸\€ ÿÿÿÿÿÿÖlÌl›l€ ÿÿÿÿÿÿàlÖl'€ ÿÿÿÿÿÿêlàlú€ ÿÿÿÿÿÿôlêlˆl€ >ÿÿÿÿÿÿþl2.Þh@ ÿÿÿÿÿÿmþl€ >ÿÿÿÿÿÿmê'2.@ ÿÿÿÿÿÿmm€ >ÿÿÿÿÿÿ$mê'Þh@ ÿÿÿÿÿÿ.m$m€ >ÿÿÿÿÿÿ7m2.üh@ ÿÿÿÿÿÿAm7m€ >ÿÿÿÿÿÿJmÞhüh@ ÿÿÿÿÿÿTmJm€ >ÿÿÿÿÿÿ]mê'üh@ ÿÿÿÿÿÿgm]m€ >ÿÿÿÿÿÿpm2.i@ ÿÿÿÿÿÿzmpm€ >ÿÿÿÿÿÿƒmÞhi@ ÿÿÿÿÿÿmƒm€ >ÿÿÿÿÿÿ–mê'i@ ÿÿÿÿÿÿ m–m€ >ÿÿÿÿÿÿ©mühi@ ÿÿÿÿÿÿ³m©m€ ÿÿÿÿÿÿ¼m³m m€ ÿÿÿÿÿÿÆm¼mm€! ÿÿÿÿÿÿÐmÆmzm€" ÿÿÿÿÿÿÚmÐmgm€# ÿÿÿÿÿÿämÚmTm€$ ÿÿÿÿÿÿîmämAm€% ÿÿÿÿÿÿømîm.m€& ÿÿÿÿÿÿnømm€' ÿÿÿÿÿÿ nnm€( >ÿÿÿÿÿÿn³-$i@) ÿÿÿÿÿÿ nn€* >ÿÿÿÿÿÿ)n|$$i@+ ÿÿÿÿÿÿ3n)n€, >ÿÿÿÿÿÿÿÿÿÿÿÿOn$iLi@/ ÿÿÿÿÿÿYnOn€0 >ÿÿÿÿÿÿbn³-Li@1 ÿÿÿÿÿÿlnbn€2 >ÿÿÿÿÿÿun|$Li@3 ÿÿÿÿÿÿnun€4 >ÿÿÿÿÿÿˆn$i`i@5 ÿÿÿÿÿÿ’nˆn€6 >ÿÿÿÿÿÿ›n³-`i@7 ÿÿÿÿÿÿ¥n›n€8 >ÿÿÿÿÿÿ®n|$`i@9 ÿÿÿÿÿÿ¸n®n€: >ÿÿÿÿÿÿÁnLi`i@; ÿÿÿÿÿÿËnÁn€< ÿÿÿÿÿÿÔnËn¸n€= ÿÿÿÿÿÿÞnÔn¥n€> ÿÿÿÿÿÿènÞn’n€? ÿÿÿÿÿÿònènn€@ ÿÿÿÿÿÿünònln€A ÿÿÿÿÿÿoünYn€B ÿÿÿÿÿÿooFn€C ÿÿÿÿÿÿoo3n€D ÿÿÿÿÿÿ$oo n€E >ÿÿÿÿÿÿ.ox1f@@F ÿÿÿÿÿÿ8o.o€G >ÿÿÿÿÿÿAo°f@@H ÿÿÿÿÿÿKoAo€I >ÿÿÿÿÿÿTo°x1@J ÿÿÿÿÿÿ^oTo€K >ÿÿÿÿÿÿgo¿0f@@L ÿÿÿÿÿÿqogo€M >ÿÿÿÿÿÿzo¿0x1@N ÿÿÿÿÿÿ„ozo€O >ÿÿÿÿÿÿo°¿0@P ÿÿÿÿÿÿ—oo€Q >ÿÿÿÿÿÿ o;2f@@R ÿÿÿÿÿÿªo o€S >ÿÿÿÿÿÿ³ox1;2@T ÿÿÿÿÿÿ½o³o€U >ÿÿÿÿÿÿÆo°;2@V ÿÿÿÿÿÿÐoÆo€W >ÿÿÿÿÿÿÙo¿0;2@X ÿÿÿÿÿÿãoÙo€Y ÿÿÿÿÿÿìoãoÐo€Z ÿÿÿÿÿÿöoìo½o€[ ÿÿÿÿÿÿpöoªo€\ ÿÿÿÿÿÿ pp—o€] ÿÿÿÿÿÿp p„o€^ ÿÿÿÿÿÿppqo€_ ÿÿÿÿÿÿ(pp^o€` ÿÿÿÿÿÿ2p(pKo€a ÿÿÿÿÿÿÿÿÿÿÿÿFp¦iºi@c ÿÿÿÿÿÿPpFp€d >ÿÿÿÿÿÿYp_$¦i@e ÿÿÿÿÿÿcpYp€f >ÿÿÿÿÿÿlp_$ºi@g ÿÿÿÿÿÿvplp€h >ÿÿÿÿÿÿpú,¦i@i ÿÿÿÿÿÿ‰pp€j >ÿÿÿÿÿÿ’pú,ºi@k ÿÿÿÿÿÿœp’p€l >ÿÿÿÿÿÿ¥p_$ú,@m ÿÿÿÿÿÿ¯p¥p€n >ÿÿÿÿÿÿ¸p¦iØi@o ÿÿÿÿÿÿÂp¸p€p >ÿÿÿÿÿÿËpºiØi@q ÿÿÿÿÿÿÕpËp€r >ÿÿÿÿÿÿÞp_$Øi@s ÿÿÿÿÿÿèpÞp€t >ÿÿÿÿÿÿñpú,Øi@u ÿÿÿÿÿÿûpñp€v ÿÿÿÿÿÿqûpèp€w ÿÿÿÿÿÿqqÕp€x ÿÿÿÿÿÿqqÂp€y ÿÿÿÿÿÿ"qq¯p€z ÿÿÿÿÿÿ,q"qœp€{ ÿÿÿÿÿÿ6q,q‰p€| ÿÿÿÿÿÿ@q6qvp€} ÿÿÿÿÿÿJq@qcp€~ ÿÿÿÿÿÿTqJqPp€ >ÿÿÿÿÿÿ^qìij@€ ÿÿÿÿÿÿhq^q€ >ÿÿÿÿÿÿqq£$ìi@‚ ÿÿÿÿÿÿ{qqq€ƒ >ÿÿÿÿÿÿ„q£$j@„ ÿÿÿÿÿÿŽq„q€… >ÿÿÿÿÿÿ—qìij@† ÿÿÿÿÿÿ¡q—q€‡ >ÿÿÿÿÿÿªqjj@ˆ ÿÿÿÿÿÿ´qªq€‰ >ÿÿÿÿÿÿ½q£$j@Š ÿÿÿÿÿÿÇq½q€‹ >ÿÿÿÿÿÿÐqv.ìi@Œ ÿÿÿÿÿÿÚqÐq€ >ÿÿÿÿÿÿãqv.j@Ž ÿÿÿÿÿÿíqãq€ >ÿÿÿÿÿÿöq£$v.@ ÿÿÿÿÿÿröq€‘ >ÿÿÿÿÿÿ rv.j@’ ÿÿÿÿÿÿr r€“ ÿÿÿÿÿÿrrr€” ÿÿÿÿÿÿ&rríq€• ÿÿÿÿÿÿ0r&rÚq€– ÿÿÿÿÿÿ:r0rÇq€— ÿÿÿÿÿÿDr:r´q€˜ ÿÿÿÿÿÿNrDr¡q€™ ÿÿÿÿÿÿXrNrŽq€š ÿÿÿÿÿÿbrXr{q€› ÿÿÿÿÿÿlrbrhq€œ ÿÿÿÿÿÿvrlrTq€ ÿÿÿÿÿÿ€rvrÿÿÿÿÿÿžr2.$i@¡ ÿÿÿÿÿÿ¨ržr€¢ >ÿÿÿÿÿÿ±r2.f@@£ ÿÿÿÿÿÿ»r±r€¤ >ÿÿÿÿÿÿÄrf@$i@¥ ÿÿÿÿÿÿÎrÄr€¦ >ÿÿÿÿÿÿ×r2.¦i@§ ÿÿÿÿÿÿár×r€¨ >ÿÿÿÿÿÿêr$i¦i@© ÿÿÿÿÿÿôrêr€ª >ÿÿÿÿÿÿýrf@¦i@« ÿÿÿÿÿÿsýr€¬ >ÿÿÿÿÿÿs2.ìi@­ ÿÿÿÿÿÿss€® >ÿÿÿÿÿÿ#s$iìi@¯ ÿÿÿÿÿÿ-s#s€° >ÿÿÿÿÿÿ6sf@ìi@± ÿÿÿÿÿÿ@s6s€² >ÿÿÿÿÿÿIs¦iìi@³ ÿÿÿÿÿÿSsIs€´ ÿÿÿÿÿÿ\sSs@s€µ ÿÿÿÿÿÿfs\s-s€¶ ÿÿÿÿÿÿpsfss€· ÿÿÿÿÿÿzspss€¸ ÿÿÿÿÿÿ„szsôr€¹ ÿÿÿÿÿÿŽs„sár€º ÿÿÿÿÿÿ˜sŽsÎr€» ÿÿÿÿÿÿ¢s˜s»r€¼ ÿÿÿÿÿÿ¬s¢s¨r€½ >ÿÿÿÿÿÿ¶s³-Þh@¾ ÿÿÿÿÿÿÀs¶s€¿ >ÿÿÿÿÿÿÉsx1Þh@À ÿÿÿÿÿÿÓsÉs€Á >ÿÿÿÿÿÿÜs³-x1@ ÿÿÿÿÿÿæsÜs€Ã >ÿÿÿÿÿÿïsÞhºi@Ä ÿÿÿÿÿÿùsïs€Å >ÿÿÿÿÿÿt³-ºi@Æ ÿÿÿÿÿÿ tt€Ç >ÿÿÿÿÿÿtx1ºi@È ÿÿÿÿÿÿtt€É >ÿÿÿÿÿÿ(tÞhj@Ê ÿÿÿÿÿÿ2t(t€Ë >ÿÿÿÿÿÿ;t³-j@Ì ÿÿÿÿÿÿEt;t€Í >ÿÿÿÿÿÿNtx1j@Î ÿÿÿÿÿÿXtNt€Ï >ÿÿÿÿÿÿatºij@Ð ÿÿÿÿÿÿktat€Ñ ÿÿÿÿÿÿttktXt€Ò ÿÿÿÿÿÿ~tttEt€Ó ÿÿÿÿÿÿˆt~t2t€Ô ÿÿÿÿÿÿ’tˆtt€Õ ÿÿÿÿÿÿœt’t t€Ö ÿÿÿÿÿÿ¦tœtùs€× ÿÿÿÿÿÿ°t¦tæs€Ø ÿÿÿÿÿÿºt°tÓs€Ù ÿÿÿÿÿÿÄtºtÀs€Ú >ÿÿÿÿÿÿÎt|$ê'@Û ÿÿÿÿÿÿØtÎt€Ü >ÿÿÿÿÿÿát°ê'@Ý ÿÿÿÿÿÿëtát€Þ >ÿÿÿÿÿÿôt°|$@ß ÿÿÿÿÿÿþtôt€à >ÿÿÿÿÿÿu_$ê'@á ÿÿÿÿÿÿuu€â >ÿÿÿÿÿÿu_$|$@ã ÿÿÿÿÿÿ$uu€ä >ÿÿÿÿÿÿ-u°_$@å ÿÿÿÿÿÿ7u-u€æ >ÿÿÿÿÿÿ@u£$ê'@ç ÿÿÿÿÿÿJu@u€è >ÿÿÿÿÿÿSu|$£$@é ÿÿÿÿÿÿ]uSu€ê >ÿÿÿÿÿÿfu°£$@ë ÿÿÿÿÿÿpufu€ì >ÿÿÿÿÿÿyu_$£$@í ÿÿÿÿÿÿƒuyu€î ÿÿÿÿÿÿŒuƒupu€ï ÿÿÿÿÿÿ–uŒu]u€ð ÿÿÿÿÿÿ u–uJu€ñ ÿÿÿÿÿÿªu u7u€ò ÿÿÿÿÿÿ´uªu$u€ó ÿÿÿÿÿÿ¾u´uu€ô ÿÿÿÿÿÿÈu¾uþt€õ ÿÿÿÿÿÿÒuÈuët€ö ÿÿÿÿÿÿÜuÒuØt€÷ >ÿÿÿÿÿÿæuühLi@ø ÿÿÿÿÿÿðuæu€ù >ÿÿÿÿÿÿùu¿0üh@ú ÿÿÿÿÿÿvùu€û >ÿÿÿÿÿÿ v¿0Li@ü ÿÿÿÿÿÿv v€ý >ÿÿÿÿÿÿvú,üh@þ ÿÿÿÿÿÿ)vv€ÿ >ÿÿÿÿÿÿ2vú,Li@ ÿÿÿÿÿÿÿÿÿÿÿÿEvú,¿0@ ÿÿÿÿÿÿOvEv€ >ÿÿÿÿÿÿXvühj@ ÿÿÿÿÿÿbvXv€ >ÿÿÿÿÿÿkvLij@ ÿÿÿÿÿÿuvkv€ >ÿÿÿÿÿÿ~v¿0j@ ÿÿÿÿÿÿˆv~v€ >ÿÿÿÿÿÿ‘vú,j@ ÿÿÿÿÿÿ›v‘v€ ÿÿÿÿÿÿ¤v›vˆv€ ÿÿÿÿÿÿ®v¤vuv€ ÿÿÿÿÿÿ¸v®vbv€ ÿÿÿÿÿÿÂv¸vOv€ ÿÿÿÿÿÿÌvÂvÿÿÿÿÿÿþvi`i@ ÿÿÿÿÿÿwþv€ >ÿÿÿÿÿÿw;2i@ ÿÿÿÿÿÿww€ >ÿÿÿÿÿÿ$w;2`i@ ÿÿÿÿÿÿ.w$w€ >ÿÿÿÿÿÿ7wiØi@ ÿÿÿÿÿÿAw7w€ >ÿÿÿÿÿÿJw`iØi@ ÿÿÿÿÿÿTwJw€ >ÿÿÿÿÿÿ]w;2Øi@ ÿÿÿÿÿÿgw]w€ >ÿÿÿÿÿÿpwv.i@! ÿÿÿÿÿÿzwpw€" >ÿÿÿÿÿÿƒwv.`i@# ÿÿÿÿÿÿwƒw€$ >ÿÿÿÿÿÿ–wv.;2@% ÿÿÿÿÿÿ w–w€& >ÿÿÿÿÿÿ©wv.Øi@' ÿÿÿÿÿÿ³w©w€( ÿÿÿÿÿÿ¼w³w w€) ÿÿÿÿÿÿÆw¼ww€* ÿÿÿÿÿÿÐwÆwzw€+ ÿÿÿÿÿÿÚwÐwgw€, ÿÿÿÿÿÿäwÚwTw€- ÿÿÿÿÿÿîwäwAw€. ÿÿÿÿÿÿøwîw.w€/ ÿÿÿÿÿÿxøww€0 ÿÿÿÿÿÿ xxw€1 ÿÿÿÿÿÿx xôv€2 ÿÿÿÿÿÿ xxÜu€3 ÿÿÿÿÿÿ*x xÄt€4 ÿÿÿÿÿÿ4x*x¬s€5 ÿÿÿÿÿÿ>x4x”r€6 SÿÿÿÿÿÿHx2.œ€7 >ÿÿÿÿÿÿRxœHx@8 ÿÿÿÿÿÿ\xRx€9 Sÿÿÿÿÿÿex$i~€: >ÿÿÿÿÿÿoxœex@; ÿÿÿÿÿÿyxox€< Sÿÿÿÿÿÿ‚xf@4€= >ÿÿÿÿÿÿŒxœ‚x@> ÿÿÿÿÿÿ–xŒx€? SÿÿÿÿÿÿŸx¦i<€@ >ÿÿÿÿÿÿ©xœŸx@A ÿÿÿÿÿÿ³x©x€B Sÿÿÿÿÿÿ¼xìi°€C >ÿÿÿÿÿÿÆxœ¼x@D ÿÿÿÿÿÿÐxÆx€E ÿÿÿÿÿÿÙxÐx³x€F ÿÿÿÿÿÿãxÙx–x€G ÿÿÿÿÿÿíxãxyx€H ÿÿÿÿÿÿ÷xíx\x€I SÿÿÿÿÿÿyÞhœ€J >ÿÿÿÿÿÿ y~y@K ÿÿÿÿÿÿy y€L Sÿÿÿÿÿÿy³-~€M >ÿÿÿÿÿÿ(y~y@N ÿÿÿÿÿÿ2y(y€O Sÿÿÿÿÿÿ;yx14€P >ÿÿÿÿÿÿEy~;y@Q ÿÿÿÿÿÿOyEy€R SÿÿÿÿÿÿXyºi<€S >ÿÿÿÿÿÿby~Xy@T ÿÿÿÿÿÿlyby€U Sÿÿÿÿÿÿuyj°€V >ÿÿÿÿÿÿy~uy@W ÿÿÿÿÿÿ‰yy€X ÿÿÿÿÿÿ’y‰yly€Y ÿÿÿÿÿÿœy’yOy€Z ÿÿÿÿÿÿ¦yœy2y€[ ÿÿÿÿÿÿ°y¦yy€\ Sÿÿÿÿÿÿºyê'œ€] >ÿÿÿÿÿÿÄy4ºy@^ ÿÿÿÿÿÿÎyÄy€_ Sÿÿÿÿÿÿ×y|$~€` >ÿÿÿÿÿÿáy4×y@a ÿÿÿÿÿÿëyáy€b Sÿÿÿÿÿÿôy_$<€c >ÿÿÿÿÿÿþy4ôy@d ÿÿÿÿÿÿzþy€e Sÿÿÿÿÿÿz£$°€f >ÿÿÿÿÿÿz4z@g ÿÿÿÿÿÿ%zz€h ÿÿÿÿÿÿ.z%zz€i ÿÿÿÿÿÿ8z.z·$€j ÿÿÿÿÿÿBz8zëy€k ÿÿÿÿÿÿLzBzÎy€l SÿÿÿÿÿÿVzühœ€m >ÿÿÿÿÿÿ`z<Vz@n ÿÿÿÿÿÿjz`z€o SÿÿÿÿÿÿszLi~€p >ÿÿÿÿÿÿ}z<sz@q ÿÿÿÿÿÿ‡z}z€r Sÿÿÿÿÿÿz¿04€s >ÿÿÿÿÿÿšz<z@t ÿÿÿÿÿÿ¤zšz€u Sÿÿÿÿÿÿ­zú,<€v >ÿÿÿÿÿÿ·z<­z@w ÿÿÿÿÿÿÁz·z€x SÿÿÿÿÿÿÊzj°€y >ÿÿÿÿÿÿÔz<Êz@z ÿÿÿÿÿÿÞzÔz€{ ÿÿÿÿÿÿçzÞzÁz€| ÿÿÿÿÿÿñzçz¤z€} ÿÿÿÿÿÿûzñz‡z€~ ÿÿÿÿÿÿ{ûzjz€ Sÿÿÿÿÿÿ{iœ€€ >ÿÿÿÿÿÿ{°{@ ÿÿÿÿÿÿ#{{€‚ Sÿÿÿÿÿÿ,{`i~€ƒ >ÿÿÿÿÿÿ6{°,{@„ ÿÿÿÿÿÿ@{6{€… SÿÿÿÿÿÿI{;24€† >ÿÿÿÿÿÿS{°I{@‡ ÿÿÿÿÿÿ]{S{€ˆ Sÿÿÿÿÿÿf{Øi<€‰ >ÿÿÿÿÿÿp{°f{@Š ÿÿÿÿÿÿz{p{€‹ Sÿÿÿÿÿÿƒ{v.°€Œ >ÿÿÿÿÿÿ{°ƒ{@ ÿÿÿÿÿÿ—{{€Ž ÿÿÿÿÿÿ {—{z{€ ÿÿÿÿÿÿª{ {]{€ ÿÿÿÿÿÿ´{ª{@{€‘ ÿÿÿÿÿÿ¾{´{#{€’ ÿÿÿÿÿÿÈ{¾{{€“ ÿÿÿÿÿÿÒ{È{Lz€” ÿÿÿÿÿÿÜ{Ò{°y€• ÿÿÿÿÿÿæ{Ü{÷x€– >ÿÿÿÿÿÿð{œ2.@— ÿÿÿÿÿÿú{ð{€˜ ÿÿÿÿÿÿ|ð{ú{€™ >ÿÿÿÿÿÿ |~2.@š ÿÿÿÿÿÿ| |€› >ÿÿÿÿÿÿ |œÞh€œ ÿÿÿÿÿÿ*| ||€ ÿÿÿÿÿÿ4|òhg4€ž >ÿÿÿÿÿÿ>|<2.@Ÿ ÿÿÿÿÿÿH|>|€  ÿÿÿÿÿÿQ|?kH|@¡ ÿÿÿÿÿÿ[|+k€¢ >ÿÿÿÿÿÿd|œi€£ ÿÿÿÿÿÿn|d|[|€¤ ÿÿÿÿÿÿx|n|Q|€¥ ÿÿÿÿÿÿ‚|x|4|€¦ ÿÿÿÿÿÿŒ|‚|*|€§ ÿÿÿÿÿÿ–|Œ||€¨ >ÿÿÿÿÿÿ |œ$i@© ÿÿÿÿÿÿª| |€ª ÿÿÿÿÿÿ³| |ª|€« >ÿÿÿÿÿÿ½|~$i@¬ ÿÿÿÿÿÿÇ|½|€­ >ÿÿÿÿÿÿÐ|œ³-€® ÿÿÿÿÿÿÚ|Ð|Ç|€¯ >ÿÿÿÿÿÿä|4$i@° ÿÿÿÿÿÿî|ä|€± ÿÿÿÿÿÿ÷|Skî|@² ÿÿÿÿÿÿ}Ik€³ ÿÿÿÿÿÿ }Vi}@´ ÿÿÿÿÿÿ}.i€µ >ÿÿÿÿÿÿ}œ`i€¶ ÿÿÿÿÿÿ'}}}€· ÿÿÿÿÿÿ1}'} }€¸ ÿÿÿÿÿÿ;}1}÷|€¹ ÿÿÿÿÿÿE};}Ú|€º ÿÿÿÿÿÿO}E}³|€» >ÿÿÿÿÿÿY}œf@@¼ ÿÿÿÿÿÿc}Y}€½ ÿÿÿÿÿÿl}Y}c}@¾ ÿÿÿÿÿÿv}ti€¿ >ÿÿÿÿÿÿ}œx1€À ÿÿÿÿÿÿ‰}}v}€Á >ÿÿÿÿÿÿ“}4f@@ ÿÿÿÿÿÿ}“}€Ã ÿÿÿÿÿÿ¦}ab}€Ä >ÿÿÿÿÿÿ°}<f@@Å ÿÿÿÿÿÿº}°}€Æ >ÿÿÿÿÿÿÃ}œ¿0€Ç ÿÿÿÿÿÿÍ}Ã}º}€È ÿÿÿÿÿÿ×}œiKo€É ÿÿÿÿÿÿá}×}Í}€Ê ÿÿÿÿÿÿë}á}¦}€Ë ÿÿÿÿÿÿõ}ë}‰}€Ì ÿÿÿÿÿÿÿ}õ}l}€Í >ÿÿÿÿÿÿ ~œ¦i@Î ÿÿÿÿÿÿ~ ~€Ï ÿÿÿÿÿÿ~ ~~€Ð >ÿÿÿÿÿÿ&~~¦i@Ñ ÿÿÿÿÿÿ0~&~€Ò ÿÿÿÿÿÿ9~Äi0~@Ó ÿÿÿÿÿÿC~qk€Ô >ÿÿÿÿÿÿL~œ_$€Õ ÿÿÿÿÿÿV~L~C~@Ö ÿÿÿÿÿÿ`~°i€× >ÿÿÿÿÿÿi~œú,€Ø ÿÿÿÿÿÿs~i~`~€Ù >ÿÿÿÿÿÿ}~°¦i@Ú ÿÿÿÿÿÿ‡~}~€Û >ÿÿÿÿÿÿ~œØi€Ü ÿÿÿÿÿÿš~~‡~€Ý ÿÿÿÿÿÿ¤~š~s~€Þ ÿÿÿÿÿÿ®~¤~V~€ß ÿÿÿÿÿÿ¸~®~9~€à ÿÿÿÿÿÿÂ~¸~~@á ÿÿÿÿÿÿÌ~öi€â ÿÿÿÿÿÿÕ~öiÌ~€ã >ÿÿÿÿÿÿß~~ìi@ä ÿÿÿÿÿÿé~ß~€å >ÿÿÿÿÿÿò~œj€æ ÿÿÿÿÿÿü~ò~é~€ç >ÿÿÿÿÿÿ4ìi@è ÿÿÿÿÿÿ€é >ÿÿÿÿÿÿœ£$€ê ÿÿÿÿÿÿ#€ë >ÿÿÿÿÿÿ-<ìi@ì ÿÿÿÿÿÿ7-€í >ÿÿÿÿÿÿ@œj€î ÿÿÿÿÿÿJ@7€ï >ÿÿÿÿÿÿT°ìi@ð ÿÿÿÿÿÿ^T€ñ >ÿÿÿÿÿÿgœv.€ò ÿÿÿÿÿÿqg^€ó ÿÿÿÿÿÿ{qJ€ô ÿÿÿÿÿÿ…{#€õ ÿÿÿÿÿÿ…ü~€ö ÿÿÿÿÿÿ™Õ~€÷ ÿÿÿÿÿÿ£™Â~€ø ÿÿÿÿÿÿ­£ÿ}€ù ÿÿÿÿÿÿ·­O}€ú ÿÿÿÿÿÿÁ·–|@û ÿÿÿÿÿÿË |€ü ÿÿÿÿÿÿÔ |Ë€ý >ÿÿÿÿÿÿÞ~Þh@þ ÿÿÿÿÿÿèÞ€ÿ ÿÿÿÿÿÿñÞè€ >ÿÿÿÿÿÿû4Þh@ ÿÿÿÿÿÿ€û€ >ÿÿÿÿÿÿ€~ê'€ ÿÿÿÿÿÿ€€€@ ÿÿÿÿÿÿ"€èh€ >ÿÿÿÿÿÿ+€~üh€ ÿÿÿÿÿÿ5€+€"€€ >ÿÿÿÿÿÿ?€°Þh@ ÿÿÿÿÿÿI€?€€ ÿÿÿÿÿÿR€iI€€ ÿÿÿÿÿÿ\€R€5€€ ÿÿÿÿÿÿf€\€€€ ÿÿÿÿÿÿp€f€ñ€ ÿÿÿÿÿÿz€p€Ô@ ÿÿÿÿÿÿ„€Ð|€ ÿÿÿÿÿÿ€½|„€@ ÿÿÿÿÿÿ—€8i€ ÿÿÿÿÿÿ €8i—€€ >ÿÿÿÿÿÿª€~|$€ ÿÿÿÿÿÿ´€ª€Ç-€ >ÿÿÿÿÿÿ¾€<³-@ ÿÿÿÿÿÿÈ€¾€€ >ÿÿÿÿÿÿÑ€~Li€ ÿÿÿÿÿÿۀрȀ€ >ÿÿÿÿÿÿ倰³-@ ÿÿÿÿÿÿï€å€€ >ÿÿÿÿÿÿø€~`i€ ÿÿÿÿÿÿø€ï€€ ÿÿÿÿÿÿ Û€€ ÿÿÿÿÿÿ ´€€ ÿÿÿÿÿÿ  €€ ÿÿÿÿÿÿ* €@ ÿÿÿÿÿÿ4}€! ÿÿÿÿÿÿ=ti4€" >ÿÿÿÿÿÿG~x1@# ÿÿÿÿÿÿQG€$ ÿÿÿÿÿÿZGQ@% ÿÿÿÿÿÿd~i€& ÿÿÿÿÿÿm]d€' >ÿÿÿÿÿÿw<x1@( ÿÿÿÿÿÿw€) >ÿÿÿÿÿÿŠ~¿0€* ÿÿÿÿÿÿ”Š€+ >ÿÿÿÿÿÿž~;2€, ÿÿÿÿÿÿ¨ž^o€- ÿÿÿÿÿÿ²¨”€. ÿÿÿÿÿÿ¼²m€/ ÿÿÿÿÿÿƼZ€0 ÿÿÿÿÿÿÐÆ=@1 ÿÿÿÿÿÿÚÄi€2 ÿÿÿÿÿÿã&~Ú€3 >ÿÿÿÿÿÿí~ºi@4 ÿÿÿÿÿÿ÷í€5 ÿÿÿÿÿÿ‚í÷€6 >ÿÿÿÿÿÿ ‚4ºi@7 ÿÿÿÿÿÿ‚ ‚€8 ÿÿÿÿÿÿ‚Îi‚€9 >ÿÿÿÿÿÿ'‚<ºi@: ÿÿÿÿÿÿ1‚'‚€; >ÿÿÿÿÿÿ:‚~ú,€< ÿÿÿÿÿÿD‚:‚1‚€= >ÿÿÿÿÿÿN‚°ºi@> ÿÿÿÿÿÿX‚N‚€? >ÿÿÿÿÿÿa‚~Øi€@ ÿÿÿÿÿÿk‚a‚X‚€A ÿÿÿÿÿÿu‚k‚D‚€B ÿÿÿÿÿÿ‚u‚‚€C ÿÿÿÿÿÿ‰‚‚‚€D ÿÿÿÿÿÿ“‚‰‚ã@E ÿÿÿÿÿÿ‚ò~€F ÿÿÿÿÿÿ¦‚ß~‚€G >ÿÿÿÿÿÿ°‚~j@H ÿÿÿÿÿÿº‚°‚€I ÿÿÿÿÿÿ°‚º‚€J >ÿÿÿÿÿÿÍ‚4j@K ÿÿÿÿÿÿׂ͂€L >ÿÿÿÿÿÿà‚~£$€M ÿÿÿÿÿÿê‚à‚ׂ€N >ÿÿÿÿÿÿô‚<j@O ÿÿÿÿÿÿþ‚ô‚€P ÿÿÿÿÿÿƒ(jþ‚@Q ÿÿÿÿÿÿƒ j€R >ÿÿÿÿÿÿƒ~v.€S ÿÿÿÿÿÿ$ƒƒƒ€T ÿÿÿÿÿÿ.ƒ$ƒƒ€U ÿÿÿÿÿÿ8ƒ.ƒê‚€V ÿÿÿÿÿÿBƒ8ƒÃ‚€W ÿÿÿÿÿÿLƒBƒ¦‚€X ÿÿÿÿÿÿVƒLƒ“‚€Y ÿÿÿÿÿÿ`ƒVƒÐ€Z ÿÿÿÿÿÿjƒ`ƒ*€[ ÿÿÿÿÿÿtƒjƒz€@\ ÿÿÿÿÿÿ~ƒòh€] ÿÿÿÿÿÿ‡ƒ]4~ƒ@^ ÿÿÿÿÿÿ‘ƒ€€_ ÿÿÿÿÿÿšƒû‘ƒ@` ÿÿÿÿÿÿ¤ƒ5k€a ÿÿÿÿÿÿ­ƒ5k¤ƒ€b >ÿÿÿÿÿÿ·ƒ<ê'@c ÿÿÿÿÿÿÁƒ·ƒ€d >ÿÿÿÿÿÿʃ4üh€e ÿÿÿÿÿÿԃʃÁƒ€f >ÿÿÿÿÿÿÞƒ4i€g ÿÿÿÿÿÿèƒÞƒët€h ÿÿÿÿÿÿòƒèƒÔƒ€i ÿÿÿÿÿÿüƒòƒ­ƒ€j ÿÿÿÿÿÿ„üƒšƒ€k ÿÿÿÿÿÿ„„‡ƒ@l ÿÿÿÿÿÿ„Sk€m ÿÿÿÿÿÿ#„ä|„@n ÿÿÿÿÿÿ-„ª€€o ÿÿÿÿÿÿ6„½--„@p ÿÿÿÿÿÿ@„Bi€q ÿÿÿÿÿÿI„Bi@„€r >ÿÿÿÿÿÿS„<|$@s ÿÿÿÿÿÿ]„S„€t ÿÿÿÿÿÿf„]k]„€u >ÿÿÿÿÿÿp„4`i€v ÿÿÿÿÿÿz„p„þt€w ÿÿÿÿÿÿ„„z„f„€x ÿÿÿÿÿÿŽ„„„I„€y ÿÿÿÿÿÿ˜„Ž„6„€z ÿÿÿÿÿÿ¢„˜„#„€{ ÿÿÿÿÿÿ¬„“}kb€| ÿÿÿÿÿÿ¶„~i"]€} >ÿÿÿÿÿÿÀ„4¿0€~ ÿÿÿÿÿÿÊ„À„Ë\@ ÿÿÿÿÿÿÔ„€€ ÿÿÿÿÿÿÝ„E2€ ÿÿÿÿÿÿç„Ý„Ê„€‚ ÿÿÿÿÿÿñ„ç„„T€ƒ ÿÿÿÿÿÿû„ñ„¶„€„ ÿÿÿÿÿÿ…û„¬„@… ÿÿÿÿÿÿ…L~€† ÿÿÿÿÿÿ…qk…@‡ ÿÿÿÿÿÿ"…Îi€ˆ ÿÿÿÿÿÿ+… ‚"…€‰ >ÿÿÿÿÿÿ5…4_$@Š ÿÿÿÿÿÿ?…5…€‹ ÿÿÿÿÿÿH…5…?…€Œ >ÿÿÿÿÿÿR…<_$@ ÿÿÿÿÿÿ\…R…€Ž ÿÿÿÿÿÿe…-\…€ >ÿÿÿÿÿÿo…4Øi€ ÿÿÿÿÿÿy…o…7u€‘ ÿÿÿÿÿÿƒ…y…e…€’ ÿÿÿÿÿÿ…ƒ…H…€“ ÿÿÿÿÿÿ—……+…€” ÿÿÿÿÿÿ¡…—……@• ÿÿÿÿÿÿ«…€– ÿÿÿÿÿÿ´…«…@— ÿÿÿÿÿÿ¾…à‚€˜ ÿÿÿÿÿÿÇ…Í‚¾…€™ ÿÿÿÿÿÿÑ…­$·$@š ÿÿÿÿÿÿÛ…j€› >ÿÿÿÿÿÿä…4j€œ ÿÿÿÿÿÿî…ä…Û…€ ÿÿÿÿÿÿø…€.pu€ž ÿÿÿÿÿÿ†ø…î…€Ÿ ÿÿÿÿÿÿ ††Ñ…€  ÿÿÿÿÿÿ† †Ç…€¡ ÿÿÿÿÿÿ ††´…€¢ ÿÿÿÿÿÿ*† †¡…€£ ÿÿÿÿÿÿ4†*†…€¤ ÿÿÿÿÿÿ>†4†¢„€¥ ÿÿÿÿÿÿH†>†„@¦ ÿÿÿÿÿÿR†?k€§ ÿÿÿÿÿÿ[†>|R†@¨ ÿÿÿÿÿÿe†+€€© ÿÿÿÿÿÿn†èhe†@ª ÿÿÿÿÿÿx†Êƒ€« ÿÿÿÿÿÿ†·ƒx†€¬ >ÿÿÿÿÿÿ‹†<üh@­ ÿÿÿÿÿÿ•†‹†€® ÿÿÿÿÿÿž†‹†•†@¯ ÿÿÿÿÿÿ¨†i€° >ÿÿÿÿÿÿ±†<i€± ÿÿÿÿÿÿ»†±†¨†€² ÿÿÿÿÿÿņ»†ž†€³ ÿÿÿÿÿÿφņ†€´ ÿÿÿÿÿÿنφn†€µ ÿÿÿÿÿÿã†Ù†[†@¶ ÿÿÿÿÿÿí†Vi€· ÿÿÿÿÿÿö†Ikí†@¸ ÿÿÿÿÿÿ‡Ñ€€¹ ÿÿÿÿÿÿ ‡¾€‡@º ÿÿÿÿÿÿ‡]k€» ÿÿÿÿÿÿ‡S„‡€¼ >ÿÿÿÿÿÿ&‡<Li@½ ÿÿÿÿÿÿ0‡&‡€¾ ÿÿÿÿÿÿ9‡&‡0‡€¿ >ÿÿÿÿÿÿC‡°Li@À ÿÿÿÿÿÿM‡C‡€Á ÿÿÿÿÿÿV‡jiM‡€Â ÿÿÿÿÿÿ`‡V‡9‡€Ã ÿÿÿÿÿÿj‡`‡‡€Ä ÿÿÿÿÿÿt‡j‡ ‡€Å ÿÿÿÿÿÿ~‡t‡ö†@Æ ÿÿÿÿÿÿˆ‡Ã}€Ç ÿÿÿÿÿÿ‘‡°}ˆ‡@È ÿÿÿÿÿÿ›‡Š€É ÿÿÿÿÿÿ¤‡w›‡@Ê ÿÿÿÿÿÿ®‡À„€Ë ÿÿÿÿÿÿ·‡Á\®‡@Ì ÿÿÿÿÿÿÁ‡’i€Í ÿÿÿÿÿÿʇ’iÁ‡€Î >ÿÿÿÿÿÿÔ‡<;2€Ï ÿÿÿÿÿÿÞ‡Ô‡—o€Ð ÿÿÿÿÿÿè‡Þ‡Ê‡€Ñ ÿÿÿÿÿÿò‡è‡·‡€Ò ÿÿÿÿÿÿü‡ò‡¤‡€Ó ÿÿÿÿÿÿˆü‡‘‡@Ô ÿÿÿÿÿÿˆi~€Õ ÿÿÿÿÿÿˆ°iˆ@Ö ÿÿÿÿÿÿ#ˆ:‚€× ÿÿÿÿÿÿ,ˆ'‚#ˆ€Ø ÿÿÿÿÿÿ6ˆR…-€Ù >ÿÿÿÿÿÿ@ˆ<ú,@Ú ÿÿÿÿÿÿJˆ@ˆ€Û ÿÿÿÿÿÿSˆ@ˆJˆ@Ü ÿÿÿÿÿÿ]ˆ{k€Ý ÿÿÿÿÿÿfˆ…k]ˆ€Þ ÿÿÿÿÿÿpˆfˆSˆ€ß ÿÿÿÿÿÿzˆpˆ6ˆ€à ÿÿÿÿÿÿ„ˆzˆ,ˆ€á ÿÿÿÿÿÿŽˆ„ˆˆ@â ÿÿÿÿÿÿ˜ˆ@€ã ÿÿÿÿÿÿ¡ˆ-˜ˆ@ä ÿÿÿÿÿÿ«ˆ(j€å ÿÿÿÿÿÿ´ˆô‚«ˆ@æ ÿÿÿÿÿÿ¾ˆä…€ç ÿÿÿÿÿÿLjj¾ˆ€è >ÿÿÿÿÿÿш<j@é ÿÿÿÿÿÿۈш€ê ÿÿÿÿÿÿäˆÑˆÛˆ€ë >ÿÿÿÿÿÿj@ì ÿÿÿÿÿÿøˆîˆ€í >ÿÿÿÿÿÿ‰<v.€î ÿÿÿÿÿÿ ‰‰øˆ€ï ÿÿÿÿÿÿ‰ ‰äˆ€ð ÿÿÿÿÿÿ‰‰Çˆ€ñ ÿÿÿÿÿÿ)‰‰´ˆ€ò ÿÿÿÿÿÿ3‰)‰¡ˆ€ó ÿÿÿÿÿÿ=‰3‰Žˆ€ô ÿÿÿÿÿÿG‰=‰ˆ€õ ÿÿÿÿÿÿQ‰G‰~‡€ö ÿÿÿÿÿÿ[‰Q‰ã†@÷ ÿÿÿÿÿÿe‰d|€ø ÿÿÿÿÿÿn‰+ke‰@ù ÿÿÿÿÿÿx‰i€ú ÿÿÿÿÿÿ‰?€x‰@û ÿÿÿÿÿÿ‹‰Þƒ€ü ÿÿÿÿÿÿ”‰át‹‰@ý ÿÿÿÿÿÿž‰±†€þ ÿÿÿÿÿÿ§‰iž‰€ÿ >ÿÿÿÿÿÿ±‰°i@ÿÿÿÿÿÿ»‰±‰€ÿÿÿÿÿÿĉ±‰»‰€ÿÿÿÿÿÿΉĉ§‰€ÿÿÿÿÿÿ؉Ή”‰€ÿÿÿÿÿÿâ‰Ø‰‰€ÿÿÿÿÿÿì‰â‰n‰@ÿÿÿÿÿÿö‰}€ÿÿÿÿÿÿÿ‰.iö‰@ÿÿÿÿÿÿ Šø€€ ÿÿÿÿÿÿŠå€ Š@ ÿÿÿÿÿÿŠp„€ ÿÿÿÿÿÿ%ŠôtŠ@ ÿÿÿÿÿÿ/Šji€ ÿÿÿÿÿÿ8ŠC‡/Š@ÿÿÿÿÿÿBŠgk€ÿÿÿÿÿÿKŠgkBŠ€ÿÿÿÿÿÿUŠKŠ8Š€ÿÿÿÿÿÿ_ŠUŠ%Š€ÿÿÿÿÿÿiŠ_ŠŠ€ÿÿÿÿÿÿsŠiŠÿ‰@ÿÿÿÿÿÿ}Šœi€ÿÿÿÿÿÿ†ŠAo}Š@ÿÿÿÿÿÿŠž€ÿÿÿÿÿÿ™ŠToŠ€ÿÿÿÿÿÿ£ŠO2@ÿÿÿÿÿÿ­ŠÔ‡€ÿÿÿÿÿÿ¶Šo­Š€ÿÿÿÿÿÿÀŠÆoÐo€ÿÿÿÿÿÿÊŠÀŠ¶Š€ÿÿÿÿÿÿÔŠÊŠ£Š€ÿÿÿÿÿÿÞŠÔŠ™Š€ÿÿÿÿÿÿèŠÞŠ†Š@ ÿÿÿÿÿÿòŠ~€!ÿÿÿÿÿÿûŠ}~òŠ@"ÿÿÿÿÿÿ‹a‚€#ÿÿÿÿÿÿ‹N‚‹@$ÿÿÿÿÿÿ‹o…€%ÿÿÿÿÿÿ!‹-u‹@&ÿÿÿÿÿÿ+‹…k€'ÿÿÿÿÿÿ4‹{k+‹@(ÿÿÿÿÿÿ>‹âi€)ÿÿÿÿÿÿG‹âi>‹€*ÿÿÿÿÿÿQ‹G‹4‹€+ÿÿÿÿÿÿ[‹Q‹!‹€,ÿÿÿÿÿÿe‹[‹‹€-ÿÿÿÿÿÿo‹e‹ûŠ@.ÿÿÿÿÿÿy‹g€/ÿÿÿÿÿÿ‚‹Ty‹@0ÿÿÿÿÿÿŒ‹ƒ€1ÿÿÿÿÿÿ•‹ jŒ‹€2ÿÿÿÿÿÿŸ‹fuŠ.@3ÿÿÿÿÿÿ©‹‰€4ÿÿÿÿÿÿ²‹îˆ©‹€5>ÿÿÿÿÿÿ¼‹°v.@6ÿÿÿÿÿÿÆ‹¼‹€7ÿÿÿÿÿÿÏ‹¼‹Æ‹€8ÿÿÿÿÿÿÙ‹Ï‹²‹€9ÿÿÿÿÿÿã‹Ù‹Ÿ‹€:ÿÿÿÿÿÿí‹ã‹•‹€;ÿÿÿÿÿÿ÷‹í‹‚‹€<ÿÿÿÿÿÿŒ÷‹o‹€=ÿÿÿÿÿÿ ŒŒèŠ€>ÿÿÿÿÿÿŒ ŒsŠ€?ÿÿÿÿÿÿŒŒì‰€@ÿÿÿÿÿÿ)ŒŒ[‰€Aÿÿÿÿÿÿ3Œ)ŒH†€Bÿÿÿÿÿÿ=Œ3Œtƒ€CÿÿÿÿÿÿGŒ=ŒÁ€DÿÿÿÿÿÿQŒú{ð{€Eÿÿÿÿÿÿ[ŒË |€FÿÿÿÿÿÿeŒ~ƒY}€GÿÿÿÿÿÿoŒR† ~€HÿÿÿÿÿÿyŒe‰öi€IÿÿÿÿÿÿƒŒyŒoŒ€JÿÿÿÿÿÿŒƒŒeŒ€Kÿÿÿÿÿÿ—ŒŒ[Œ€Lÿÿÿÿÿÿ¡Œ—ŒQŒ€Mÿÿÿÿÿÿ«Œª| |€NÿÿÿÿÿÿµŒ„€Ð|€Oÿÿÿÿÿÿ¿Œ„}€PÿÿÿÿÿÿÉŒí†Äi€QÿÿÿÿÿÿÓŒö‰ò~€Rÿÿÿÿÿÿ݌ӌɌ€SÿÿÿÿÿÿçŒÝŒ¿Œ€TÿÿÿÿÿÿñŒçŒµŒ€UÿÿÿÿÿÿûŒñŒ«Œ€Vÿÿÿÿÿÿc}òh€Wÿÿÿÿÿÿ4Sk€Xÿÿÿÿÿÿkbab€Yÿÿÿÿÿÿ#ˆ‡L~€Zÿÿÿÿÿÿ-}Š€[ÿÿÿÿÿÿ7-#€\ÿÿÿÿÿÿA7€]ÿÿÿÿÿÿKA€^ÿÿÿÿÿÿUK€_ÿÿÿÿÿÿ_~?k€`ÿÿÿÿÿÿiÚVi€aÿÿÿÿÿÿs…Ã}€bÿÿÿÿÿÿ}ˆi~€cÿÿÿÿÿÿ‡òŠ@€dÿÿÿÿÿÿ‘‡}€eÿÿÿÿÿÿ›‘s€fÿÿÿÿÿÿ¥›i€gÿÿÿÿÿÿ¯¥_€hÿÿÿÿÿÿ¹Ì~d|€iÿÿÿÿÿÿÂ}€jÿÿÿÿÿÿÍ«…œi€kÿÿÿÿÿÿטˆ~€lÿÿÿÿÿÿáy‹g€mÿÿÿÿÿÿëá×€nÿÿÿÿÿÿõëÍ€oÿÿÿÿÿÿÿõÀpÿÿÿÿÿÿ Žÿ¹€qÿÿÿÿÿÿŽ Ž¯€rÿÿÿÿÿÿŽŽU€sÿÿÿÿÿÿ'ŽŽûŒ€tÿÿÿÿÿÿ1Ž'Ž¡Œ€uÿÿÿÿÿÿ;Ž| |€vÿÿÿÿÿÿEŽè½|€wÿÿÿÿÿÿOŽ‘ƒti€xÿÿÿÿÿÿYŽe†&~€yÿÿÿÿÿÿcŽx‰ß~€zÿÿÿÿÿÿmŽcŽYŽ€{ÿÿÿÿÿÿwŽmŽOŽ€|ÿÿÿÿÿÿŽwŽEŽ€}ÿÿÿÿÿÿ‹ŽŽ;Ž€~ÿÿÿÿÿÿ•ŽÇ|Þ€ÿÿÿÿÿÿŸŽ—€8i€€ÿÿÿÿÿÿ©Ž-„G€ÿÿÿÿÿÿ³Ž‡í€‚ÿÿÿÿÿÿ½Ž Š°‚€ƒÿÿÿÿÿÿÇŽ½Ž³Ž€„ÿÿÿÿÿÿÑŽÇŽ©Ž€…ÿÿÿÿÿÿÛŽÑŽŸŽ€†ÿÿÿÿÿÿåŽÛŽ•Ž€‡ÿÿÿÿÿÿïŽv}€€ˆÿÿÿÿÿÿùŽQª€€‰ÿÿÿÿÿÿ"]]€Šÿÿÿÿÿÿ ›‡Îi€‹ÿÿÿÿÿÿŠà‚€Œÿÿÿÿÿÿ! €ÿÿÿÿÿÿ+!€Žÿÿÿÿÿÿ5+ùŽ€ÿÿÿÿÿÿ?5ÿÿÿÿÿÿI0~+€€‘ÿÿÿÿÿÿS÷Ñ€€’ÿÿÿÿÿÿ]"…Š€“ÿÿÿÿÿÿg#ˆ:‚€”ÿÿÿÿÿÿq‹(j€•ÿÿÿÿÿÿ{qg€–ÿÿÿÿÿÿ…{]€—ÿÿÿÿÿÿ…S€˜ÿÿÿÿÿÿ™I€™ÿÿÿÿÿÿ£é~i€šÿÿÿÿÿÿ­º‚ø€€›ÿÿÿÿÿÿ·¾…ž€œÿÿÿÿÿÿÁ«ˆa‚€ÿÿÿÿÿÿËŒ‹ƒ€žÿÿÿÿÿÿÕËÁ€ŸÿÿÿÿÿÿßÕ·€ ÿÿÿÿÿÿéß­€¡ÿÿÿÿÿÿó飀¢ÿÿÿÿÿÿý󙀣ÿÿÿÿÿÿý?€¤ÿÿÿÿÿÿ厀¥ÿÿÿÿÿÿ‹Ž€¦ÿÿÿÿÿÿ%g4]4€§ÿÿÿÿÿÿ/€ä|€¨ÿÿÿÿÿÿ9¤ƒ“}€©ÿÿÿÿÿÿCx†qk€ªÿÿÿÿÿÿM‹‰€«ÿÿÿÿÿÿWMC€¬ÿÿÿÿÿÿaW9€­ÿÿÿÿÿÿka/€®ÿÿÿÿÿÿuk%€¯ÿÿÿÿÿÿî|û€°ÿÿÿÿÿÿ‰Ç-½-€±ÿÿÿÿÿÿ“@„~i€²ÿÿÿÿÿÿ‡ ‚€³ÿÿÿÿÿÿ§ŠÍ‚€´ÿÿÿÿÿÿ±§€µÿÿÿÿÿÿ»±“€¶ÿÿÿÿÿÿÅ»‰€·ÿÿÿÿÿÿÏÅ€¸ÿÿÿÿÿÿÙ}5k€¹ÿÿÿÿÿÿãdBi€ºÿÿÿÿÿÿí®‡5…€»ÿÿÿÿÿÿ÷O2­$€¼ÿÿÿÿÿÿ‘÷퀽ÿÿÿÿÿÿ ‘‘ÊJ€¾ÿÿÿÿÿÿ‘ ‘〿ÿÿÿÿÿÿ‘‘Ù€Àÿÿÿÿÿÿ)‘C~ʃ€Áÿÿÿÿÿÿ3‘‚]k€Âÿÿÿÿÿÿ=‘?…À„€ÃÿÿÿÿÿÿG‘--€ÄÿÿÿÿÿÿQ‘‹ä…€Åÿÿÿÿÿÿ[‘Q‘G‘€Æÿÿÿÿÿÿe‘[‘=‘€Çÿÿÿÿÿÿo‘e‘3‘€Èÿÿÿÿÿÿy‘o‘)‘€Éÿÿÿÿÿÿƒ‘Þƒ€Êÿÿÿÿÿÿ‘ׂp„€Ëÿÿÿÿÿÿ—‘·$E2€Ìÿÿÿÿÿÿ¡‘¾ˆo…€Íÿÿÿÿÿÿ«‘Š.€.€Îÿÿÿÿÿÿµ‘«‘¡‘€Ïÿÿÿÿÿÿ¿‘µ‘—‘€ÐÿÿÿÿÿÿÉ‘¿‘‘€ÑÿÿÿÿÿÿÓ‘É‘ƒ‘€ÒÿÿÿÿÿÿÝ‘Ó‘y‘€Óÿÿÿÿÿÿç‘Ý‘‘€Ôÿÿÿÿÿÿñ‘ç‘Ï€Õÿÿÿÿÿÿû‘ñ‘u€Öÿÿÿÿÿÿ’H|>|€×ÿÿÿÿÿÿ’"€Ik€Øÿÿÿÿÿÿ’Áƒ°}€Ùÿÿÿÿÿÿ#’•†°i€Úÿÿÿÿÿÿ-’ž‰-€Ûÿÿÿÿÿÿ7’-’#’€ÜÿÿÿÿÿÿA’7’’€ÝÿÿÿÿÿÿK’A’’€ÞÿÿÿÿÿÿU’K’’€ßÿÿÿÿÿÿ_’}èh€àÿÿÿÿÿÿi’È€¾€€áÿÿÿÿÿÿs’]„w€âÿÿÿÿÿÿ}’0‡'‚€ãÿÿÿÿÿÿ‡’/Šô‚€äÿÿÿÿÿÿ‘’‡’}’€åÿÿÿÿÿÿ›’‘’s’€æÿÿÿÿÿÿ¥’›’i’€çÿÿÿÿÿÿ¯’¥’_’€èÿÿÿÿÿÿ¹’º}·ƒ€éÿÿÿÿÿÿÃ’S„€êÿÿÿÿÿÿÍ’Ë\Á\€ëÿÿÿÿÿÿ×’Á‡R…€ìÿÿÿÿÿÿá’­Šj€íÿÿÿÿÿÿë’á’×’€îÿÿÿÿÿÿõ’ë’Í’€ïÿÿÿÿÿÿÿ’õ’Ã’€ðÿÿÿÿÿÿ “ÿ’¹’€ñÿÿÿÿÿÿ“`~‹†€òÿÿÿÿÿÿ“1‚&‡€óÿÿÿÿÿÿ'“\…’i€ôÿÿÿÿÿÿ1“Jˆ@ˆ€õÿÿÿÿÿÿ;“+‹Ñˆ€öÿÿÿÿÿÿE“;“1“€÷ÿÿÿÿÿÿO“E“'“€øÿÿÿÿÿÿY“O““€ùÿÿÿÿÿÿc“Y““€úÿÿÿÿÿÿm“7±†€ûÿÿÿÿÿÿw“þ‚ji€üÿÿÿÿÿÿ“Û…Ô‡€ýÿÿÿÿÿÿ‹“Ûˆ…k€þÿÿÿÿÿÿ•“©‹‰€ÿÿÿÿÿÿÿŸ“•“‹“€ÿÿÿÿÿÿ©“Ÿ““€ÿÿÿÿÿÿ³“©“w“€ÿÿÿÿÿÿ½“³“m“€ÿÿÿÿÿÿÇ“½“c“€ÿÿÿÿÿÿÑ“Ç“ “€ÿÿÿÿÿÿÛ“Ñ“¯’€ÿÿÿÿÿÿå“Û“U’€ÿÿÿÿÿÿï“[|+k€ÿÿÿÿÿÿù“I€.i€ ÿÿÿÿÿÿ”ëtAo€ ÿÿÿÿÿÿ ”¨†}~€ ÿÿÿÿÿÿ”»‰T€ ÿÿÿÿÿÿ!”” ”€ ÿÿÿÿÿÿ+”!””€ÿÿÿÿÿÿ5”+”ù“€ÿÿÿÿÿÿ?”5”ï“€ÿÿÿÿÿÿI”}?€€ÿÿÿÿÿÿS”ï€å€€ÿÿÿÿÿÿ]”þtTo€ÿÿÿÿÿÿg”M‡N‚€ÿÿÿÿÿÿq”BŠ j€ÿÿÿÿÿÿ{”q”g”€ÿÿÿÿÿÿ…”{”]”€ÿÿÿÿÿÿ”…”S”€ÿÿÿÿÿÿ™””I”€ÿÿÿÿÿÿ£”Koát€ÿÿÿÿÿÿ­”^oôt€ÿÿÿÿÿÿ·”€ÿÿÿÿÿÿÁ”—o-u€ÿÿÿÿÿÿË”Ðofu€ÿÿÿÿÿÿՔ˔Á”€ÿÿÿÿÿÿߔՔ·”€ ÿÿÿÿÿÿé”ß”­”€!ÿÿÿÿÿÿó”锣”€"ÿÿÿÿÿÿý”‡~i€#ÿÿÿÿÿÿ•X‚C‡€$ÿÿÿÿÿÿ•7uo€%ÿÿÿÿÿÿ•]ˆ{k€&ÿÿÿÿÿÿ%•>‹îˆ€'ÿÿÿÿÿÿ/•%••€(ÿÿÿÿÿÿ9•/••€)ÿÿÿÿÿÿC•9••€*ÿÿÿÿÿÿM•C•ý”€+ÿÿÿÿÿÿW•^±‰€,ÿÿÿÿÿÿa•ƒgk€-ÿÿÿÿÿÿk•puÆo€.ÿÿÿÿÿÿu•øˆâi€/ÿÿÿÿÿÿ•Æ‹¼‹€0ÿÿÿÿÿÿ‰••u•€1ÿÿÿÿÿÿ“•‰•k•€2ÿÿÿÿÿÿ•“•a•€3ÿÿÿÿÿÿ§••W•€4ÿÿÿÿÿÿ±•§•M•€5ÿÿÿÿÿÿ»•±•ó”€6ÿÿÿÿÿÿÅ•»•™”€7ÿÿÿÿÿÿÏ•Å•?”€8ÿÿÿÿÿÿÙ•Ï•å“€9ÿÿÿÿÿÿã•Ù•û‘€:ÿÿÿÿÿÿí•ã•€;ÿÿÿÿÿÿ÷•í•1Ž€<ÿÿÿÿÿÿ–»‰•†€=ÿÿÿÿÿÿ ––¤ƒ€>ÿÿÿÿÿÿ– –è€?ÿÿÿÿÿÿ––ú{€@ÿÿÿÿÿÿ)–BŠ0‡€Aÿÿÿÿÿÿ3–)–@„€Bÿÿÿÿÿÿ=–3–—€€CÿÿÿÿÿÿG–=–ª|€DÿÿÿÿÿÿQ–ÐoÁ‡€Eÿÿÿÿÿÿ[–Q–v€Fÿÿÿÿÿÿe–[–Q€Gÿÿÿÿÿÿo–e–c}€Hÿÿÿÿÿÿy–>‹Jˆ€Iÿÿÿÿÿÿƒ–y–?…€Jÿÿÿÿÿÿ–ƒ–÷€Kÿÿÿÿÿÿ—––~€Lÿÿÿÿÿÿ¡–Æ‹Ûˆ€Mÿÿÿÿÿÿ«–¡–·$€Nÿÿÿÿÿÿµ–«–º‚€Oÿÿÿÿÿÿ¿–µ–Ì~€PÿÿÿÿÿÿÉ–¿–—–€QÿÿÿÿÿÿÓ–É–o–€RÿÿÿÿÿÿÝ–Ó–G–€Sÿÿÿÿÿÿç–Ý––€TSÿÿÿÿÿÿñ–œ2.€U>ÿÿÿÿÿÿû–œñ–@Vÿÿÿÿÿÿ—û–€WSÿÿÿÿÿÿ—~2.€X>ÿÿÿÿÿÿ—~—@Yÿÿÿÿÿÿ"——€ZSÿÿÿÿÿÿ+—42.€[>ÿÿÿÿÿÿ5—4+—@\ÿÿÿÿÿÿ?—5—€]SÿÿÿÿÿÿH—<2.€^>ÿÿÿÿÿÿR—<H—@_ÿÿÿÿÿÿ\—R—€`Sÿÿÿÿÿÿe—°2.€a>ÿÿÿÿÿÿo—°e—@bÿÿÿÿÿÿy—o—€cÿÿÿÿÿÿ‚—y—\—€dÿÿÿÿÿÿŒ—‚—?—€eÿÿÿÿÿÿ–—Œ—"—€fÿÿÿÿÿÿ —–——€gSÿÿÿÿÿÿª—œ³-€h>ÿÿÿÿÿÿ´—œª—@iÿÿÿÿÿÿ¾—´—€jSÿÿÿÿÿÿÇ—~³-€k>ÿÿÿÿÿÿÑ—~Ç—@lÿÿÿÿÿÿÛ—Ñ—€mSÿÿÿÿÿÿä—4³-€n>ÿÿÿÿÿÿî—4ä—@oÿÿÿÿÿÿø—î—€pSÿÿÿÿÿÿ˜<³-€q>ÿÿÿÿÿÿ ˜<˜@rÿÿÿÿÿÿ˜ ˜€sSÿÿÿÿÿÿ˜°³-€t>ÿÿÿÿÿÿ(˜°˜@uÿÿÿÿÿÿ2˜(˜€vÿÿÿÿÿÿ;˜2˜˜€wÿÿÿÿÿÿE˜;˜ø—€xÿÿÿÿÿÿO˜E˜Û—€yÿÿÿÿÿÿY˜O˜¾—€zÿÿÿÿÿÿc˜Æ‹+‹€{ÿÿÿÿÿÿm˜c˜O2€|ÿÿÿÿÿÿw˜m˜ Š€}ÿÿÿÿÿÿ˜w˜e‰€~Sÿÿÿÿÿÿ‹˜œú,€>ÿÿÿÿÿÿ•˜œ‹˜@€ÿÿÿÿÿÿŸ˜•˜€Sÿÿÿÿÿÿ¨˜~ú,€‚>ÿÿÿÿÿÿ²˜~¨˜@ƒÿÿÿÿÿÿ¼˜²˜€„SÿÿÿÿÿÿŘ4ú,€…>ÿÿÿÿÿÿϘ4Ř@†ÿÿÿÿÿÿ٘Ϙ€‡Sÿÿÿÿÿÿâ˜<ú,€ˆ>ÿÿÿÿÿÿì˜<â˜@‰ÿÿÿÿÿÿö˜ì˜€ŠSÿÿÿÿÿÿÿ˜°ú,€‹>ÿÿÿÿÿÿ ™°ÿ˜@Œÿÿÿÿÿÿ™ ™€ÿÿÿÿÿÿ™™ö˜€Žÿÿÿÿÿÿ&™™Ù˜€ÿÿÿÿÿÿ0™&™¼˜€ÿÿÿÿÿÿ:™0™Ÿ˜€‘SÿÿÿÿÿÿD™œv.€’>ÿÿÿÿÿÿN™œD™@“ÿÿÿÿÿÿX™N™€”Sÿÿÿÿÿÿa™~v.€•>ÿÿÿÿÿÿk™~a™@–ÿÿÿÿÿÿu™k™€—Sÿÿÿÿÿÿ~™4v.€˜>ÿÿÿÿÿÿˆ™4~™@™ÿÿÿÿÿÿ’™ˆ™€šSÿÿÿÿÿÿ›™<v.€›>ÿÿÿÿÿÿ¥™<›™@œÿÿÿÿÿÿ¯™¥™€Sÿÿÿÿÿÿ¸™°v.€ž>ÿÿÿÿÿÿ™°¸™@Ÿÿÿÿÿÿÿ̙™€ ÿÿÿÿÿÿՙ̙¯™€¡ÿÿÿÿÿÿߙՙ’™€¢ÿÿÿÿÿÿé™ß™u™€£ÿÿÿÿÿÿó™é™X™€¤ÿÿÿÿÿÿý™ó™:™€¥ÿÿÿÿÿÿšý™˜€¦ÿÿÿÿÿÿššY˜€§ÿÿÿÿÿÿšš —€¨Sÿÿÿÿÿÿ%šœÞh€©>ÿÿÿÿÿÿ/š~%š€ªSÿÿÿÿÿÿ9šœê'€«>ÿÿÿÿÿÿCš49š€¬SÿÿÿÿÿÿMšœüh€­>ÿÿÿÿÿÿWš<Mš€®Sÿÿÿÿÿÿašœi€¯>ÿÿÿÿÿÿkš°aš€°ÿÿÿÿÿÿuškšWš€±ÿÿÿÿÿÿšušCš€²ÿÿÿÿÿÿ‰šš/š€³ÿÿÿÿÿÿ“š‰šû–€´Sÿÿÿÿÿÿš~$i€µ>ÿÿÿÿÿÿ§šœš€¶Sÿÿÿÿÿÿ±š~|$€·>ÿÿÿÿÿÿ»š4±š€¸SÿÿÿÿÿÿÅš~Li€¹>ÿÿÿÿÿÿÏš<Åš€ºSÿÿÿÿÿÿÙš~`i€»>ÿÿÿÿÿÿãš°Ùš€¼ÿÿÿÿÿÿíšãšÏš€½ÿÿÿÿÿÿ÷šíš»š€¾ÿÿÿÿÿÿ›÷šÑ—€¿ÿÿÿÿÿÿ ››§š€ÀSÿÿÿÿÿÿ›4f@€Á>ÿÿÿÿÿÿ›œ›€ÂSÿÿÿÿÿÿ)›4x1€Ã>ÿÿÿÿÿÿ3›~)›€ÄSÿÿÿÿÿÿ=›4¿0€Å>ÿÿÿÿÿÿG›<=›€ÆSÿÿÿÿÿÿQ›4;2€Ç>ÿÿÿÿÿÿ[›°Q›€Èÿÿÿÿÿÿe›[›G›€Éÿÿÿÿÿÿo›e›E2€Êÿÿÿÿÿÿy›o›3›€Ëÿÿÿÿÿÿƒ›y››€ÌSÿÿÿÿÿÿ›<¦i€Í>ÿÿÿÿÿÿ—›œ›€ÎSÿÿÿÿÿÿ¡›<ºi€Ï>ÿÿÿÿÿÿ«›~¡›€ÐSÿÿÿÿÿÿµ›<_$€Ñ>ÿÿÿÿÿÿ¿›4µ›€ÒSÿÿÿÿÿÿÉ›<Øi€Ó>ÿÿÿÿÿÿÓ›°É›€Ôÿÿÿÿÿÿݛӛ였Õÿÿÿÿÿÿç›Ý›¿›€Öÿÿÿÿÿÿñ›ç›«›€×ÿÿÿÿÿÿû›ñ›—›€ØSÿÿÿÿÿÿœ°ìi€Ù>ÿÿÿÿÿÿœœœ€ÚSÿÿÿÿÿÿœ°j€Û>ÿÿÿÿÿÿ#œ~œ€ÜSÿÿÿÿÿÿ-œ°£$€Ý>ÿÿÿÿÿÿ7œ4-œ€ÞSÿÿÿÿÿÿAœ°j€ß>ÿÿÿÿÿÿKœ<Aœ€àÿÿÿÿÿÿUœÂ™Kœ€áÿÿÿÿÿÿ_œUœ7œ€âÿÿÿÿÿÿiœ_œ#œ€ãÿÿÿÿÿÿsœiœœ€äÿÿÿÿÿÿ}œsœû›€åÿÿÿÿÿÿ‡œ}œƒ›€æÿÿÿÿÿÿ‘œ‡œ ›€çÿÿÿÿÿÿ›œ‘œ“š€èÿÿÿÿÿÿ¥œËÇ|€éÿÿÿÿÿÿ¯œ~ƒ}€êÿÿÿÿÿÿ¹œR†`~€ëÿÿÿÿÿÿÃœe‰^€ìÿÿÿÿÿÿܹ͜œ€íÿÿÿÿÿÿל͜¯œ€îÿÿÿÿÿÿáœ×œ¥œ€ïÿÿÿÿÿÿëœáœú{€ðÿÿÿÿÿÿõœª|Ë€ñÿÿÿÿÿÿÿœ„€—€€òÿÿÿÿÿÿ „d€óÿÿÿÿÿÿí†1‚€ôÿÿÿÿÿÿö‰ƒ€õÿÿÿÿÿÿ'€öÿÿÿÿÿÿ1' €÷ÿÿÿÿÿÿ;1ÿœ€øÿÿÿÿÿÿE;õœ€ùÿÿÿÿÿÿOc}~ƒ€úÿÿÿÿÿÿY4-„€ûÿÿÿÿÿÿckbv€üÿÿÿÿÿÿmˆ‡\…€ýÿÿÿÿÿÿw}Špu€þÿÿÿÿÿÿwm€ÿÿÿÿÿÿÿ‹c€ÿÿÿÿÿÿ•‹Y€ÿÿÿÿÿÿŸ•O€ÿÿÿÿÿÿ©~R†€ÿÿÿÿÿÿ³Ú‡€ÿÿÿÿÿÿ½…®‡€ÿÿÿÿÿÿLjJˆ€ÿÿÿÿÿÿÑòŠøˆ€ÿÿÿÿÿÿÛÑÇ€ÿÿÿÿÿÿåÛ½€ ÿÿÿÿÿÿïå³€ ÿÿÿÿÿÿùï©€ ÿÿÿÿÿÿžÌ~e‰€ ÿÿÿÿÿÿ ž‚ Š€ ÿÿÿÿÿÿž«…O2€ÿÿÿÿÿÿ!ž˜ˆ+‹€ÿÿÿÿÿÿ+žy‹Æ‹€ÿÿÿÿÿÿ5ž+ž!ž€ÿÿÿÿÿÿ?ž5žž€ÿÿÿÿÿÿIž?ž ž€ÿÿÿÿÿÿSžIžž€ÿÿÿÿÿÿ]žSžù€ÿÿÿÿÿÿgž]žŸ€ÿÿÿÿÿÿqžgžE€ÿÿÿÿÿÿ{žqžëœ€ÿÿÿÿÿÿ…ž|ú{€ÿÿÿÿÿÿžèÇ|€ÿÿÿÿÿÿ™ž‘ƒ}€ÿÿÿÿÿÿ£že†`~€ÿÿÿÿÿÿ­žx‰^€ÿÿÿÿÿÿ·ž­ž£ž€ÿÿÿÿÿÿÁž·ž™ž€ÿÿÿÿÿÿËžÁžž€ ÿÿÿÿÿÿ՞˞…ž€!ÿÿÿÿÿÿßžÇ|Ë€"ÿÿÿÿÿÿéž-„d€#ÿÿÿÿÿÿóž‡1‚€$ÿÿÿÿÿÿýž Šƒ€%ÿÿÿÿÿÿŸýžóž€&ÿÿÿÿÿÿŸŸéž€'ÿÿÿÿÿÿŸŸ—€€(ÿÿÿÿÿÿ%ŸŸßž€)ÿÿÿÿÿÿ/Ÿv}~ƒ€*ÿÿÿÿÿÿ9ŸQ-„€+ÿÿÿÿÿÿCŸ"]v€,ÿÿÿÿÿÿMŸ›‡\…€-ÿÿÿÿÿÿWŸŠpu€.ÿÿÿÿÿÿaŸWŸMŸ€/ÿÿÿÿÿÿkŸaŸCŸ€0ÿÿÿÿÿÿuŸkŸ9Ÿ€1ÿÿÿÿÿÿŸuŸ/Ÿ€2ÿÿÿÿÿÿ‰Ÿ0~R†€3ÿÿÿÿÿÿ“Ÿ÷‡€4ÿÿÿÿÿÿŸ"…®‡€5ÿÿÿÿÿÿ§Ÿ#ˆJˆ€6ÿÿÿÿÿÿ±Ÿ‹øˆ€7ÿÿÿÿÿÿ»Ÿ±Ÿ§Ÿ€8ÿÿÿÿÿÿÅŸ»ŸŸ€9ÿÿÿÿÿÿÏŸÅŸ“Ÿ€:ÿÿÿÿÿÿÙŸÏŸ‰Ÿ€;ÿÿÿÿÿÿãŸé~e‰€<ÿÿÿÿÿÿퟺ‚ Š€=ÿÿÿÿÿÿ÷Ÿ¾…O2€>ÿÿÿÿÿÿ «ˆ+‹€?ÿÿÿÿÿÿ  Œ‹Æ‹€@ÿÿÿÿÿÿ    €Aÿÿÿÿÿÿ  ÷Ÿ€Bÿÿÿÿÿÿ)  íŸ€Cÿÿÿÿÿÿ3 ) ãŸ€Dÿÿÿÿÿÿ= 3 ÙŸ€EÿÿÿÿÿÿG = Ÿ€FÿÿÿÿÿÿQ G %Ÿ€Gÿÿÿÿÿÿ[ Q Õž€Hÿÿÿÿÿÿe g4ú{€Iÿÿÿÿÿÿo €Ç|€Jÿÿÿÿÿÿy ¤ƒ}€Kÿÿÿÿÿÿƒ x†`~€Lÿÿÿÿÿÿ ‹‰^€Mÿÿÿÿÿÿ—  ƒ €Nÿÿÿÿÿÿ¡ — y €Oÿÿÿÿÿÿ« ¡ o €Pÿÿÿÿÿÿµ « e €Qÿÿÿÿÿÿ¿ î|Ë€RÿÿÿÿÿÿÉ Ç-—€€SÿÿÿÿÿÿÓ @„d€TÿÿÿÿÿÿÝ ‡1‚€Uÿÿÿÿÿÿç Šƒ€Vÿÿÿÿÿÿñ ç Ý €Wÿÿÿÿÿÿû ñ Ó €Xÿÿÿÿÿÿ¡û É €Yÿÿÿÿÿÿ¡¡¿ €Zÿÿÿÿÿÿ¡}~ƒ€[ÿÿÿÿÿÿ#¡d-„€\ÿÿÿÿÿÿ-¡®‡\…€]ÿÿÿÿÿÿ7¡O2pu€^ÿÿÿÿÿÿA¡7¡-¡€_ÿÿÿÿÿÿK¡A¡v€`ÿÿÿÿÿÿU¡K¡#¡€aÿÿÿÿÿÿ_¡U¡¡€bÿÿÿÿÿÿi¡C~R†€cÿÿÿÿÿÿs¡‚‡€dÿÿÿÿÿÿ}¡?…®‡€eÿÿÿÿÿÿ‡¡-Jˆ€fÿÿÿÿÿÿ‘¡‹øˆ€gÿÿÿÿÿÿ›¡‘¡‡¡€hÿÿÿÿÿÿ¥¡›¡}¡€iÿÿÿÿÿÿ¯¡¥¡s¡€jÿÿÿÿÿÿ¹¡¯¡i¡€kÿÿÿÿÿÿáe‰€lÿÿÿÿÿÿׂ͡ Š€mÿÿÿÿÿÿס·$O2€nÿÿÿÿÿÿ᡾ˆ+‹€oÿÿÿÿÿÿë¡Š.Æ‹€pÿÿÿÿÿÿõ¡ë¡á¡€qÿÿÿÿÿÿÿ¡õ¡×¡€rÿÿÿÿÿÿ ¢ÿ¡Í¡€sÿÿÿÿÿÿ¢ ¢Ã¡€tÿÿÿÿÿÿ¢¢¹¡€uÿÿÿÿÿÿ'¢¢_¡€vÿÿÿÿÿÿ1¢'¢¡€wÿÿÿÿÿÿ;¢1¢µ €xÿÿÿÿÿÿE¢H|ú{€yÿÿÿÿÿÿO¢"€Ç|€zÿÿÿÿÿÿY¢Áƒ}€{ÿÿÿÿÿÿc¢•†`~€|ÿÿÿÿÿÿm¢ž‰^€}ÿÿÿÿÿÿw¢m¢c¢€~ÿÿÿÿÿÿ¢w¢Y¢€ÿÿÿÿÿÿ‹¢¢O¢€€ÿÿÿÿÿÿ•¢‹¢E¢€ÿÿÿÿÿÿŸ¢}Ë€‚ÿÿÿÿÿÿ©¢È€—€€ƒÿÿÿÿÿÿ³¢]„d€„ÿÿÿÿÿÿ½¢0‡1‚€…ÿÿÿÿÿÿÇ¢/Šƒ€†ÿÿÿÿÿÿѢǢ½¢€‡ÿÿÿÿÿÿۢѢ³¢€ˆÿÿÿÿÿÿå¢Û¢©¢€‰ÿÿÿÿÿÿï¢å¢Ÿ¢€Šÿÿÿÿÿÿù¢º}~ƒ€‹ÿÿÿÿÿÿ£-„€Œÿÿÿÿÿÿ £Ë\v€ÿÿÿÿÿÿ£Á‡\…€Žÿÿÿÿÿÿ!£­Špu€ÿÿÿÿÿÿ+£!££€ÿÿÿÿÿÿ5£+£ £€‘ÿÿÿÿÿÿ?£5££€’ÿÿÿÿÿÿI£?£ù¢€“ÿÿÿÿÿÿS£`~R†€”ÿÿÿÿÿÿ]£1‚‡€•ÿÿÿÿÿÿg£\…®‡€–ÿÿÿÿÿÿq£+‹øˆ€—ÿÿÿÿÿÿ{£q£Jˆ€˜ÿÿÿÿÿÿ…£{£g£€™ÿÿÿÿÿÿ£…£]£€šÿÿÿÿÿÿ™££S£€›ÿÿÿÿÿÿ££7e‰€œÿÿÿÿÿÿ­£þ‚ Š€ÿÿÿÿÿÿ·£Û…O2€žÿÿÿÿÿÿÁ£Ûˆ+‹€ŸÿÿÿÿÿÿË£©‹Æ‹€ ÿÿÿÿÿÿգˣÁ£€¡ÿÿÿÿÿÿߣգ·£€¢ÿÿÿÿÿÿé£ß£­£€£ÿÿÿÿÿÿó£é£££€¤ÿÿÿÿÿÿý£ó£™£€¥ÿÿÿÿÿÿ¤ý£I£€¦ÿÿÿÿÿÿ¤¤ï¢€§ÿÿÿÿÿÿ¤¤•¢€¨ÿÿÿÿÿÿ%¤[|ú{€©ÿÿÿÿÿÿ/¤I€Ç|€ªÿÿÿÿÿÿ9¤ët}€«ÿÿÿÿÿÿC¤¨†`~€¬ÿÿÿÿÿÿM¤»‰^€­ÿÿÿÿÿÿW¤M¤C¤€®ÿÿÿÿÿÿa¤W¤9¤€¯ÿÿÿÿÿÿk¤a¤/¤€°ÿÿÿÿÿÿu¤k¤%¤€±ÿÿÿÿÿÿ¤}Ë€²ÿÿÿÿÿÿ‰¤ï€—€€³ÿÿÿÿÿÿ“¤þtd€´ÿÿÿÿÿÿ¤M‡1‚€µÿÿÿÿÿÿ§¤BŠƒ€¶ÿÿÿÿÿÿ±¤§¤¤€·ÿÿÿÿÿÿ»¤±¤“¤€¸ÿÿÿÿÿÿŤ»¤‰¤€¹ÿÿÿÿÿÿϤŤ¤€ºÿÿÿÿÿÿÙ¤Ko~ƒ€»ÿÿÿÿÿÿã¤^o-„€¼ÿÿÿÿÿÿí¤v€½ÿÿÿÿÿÿ÷¤—o\…€¾ÿÿÿÿÿÿ¥Ðopu€¿ÿÿÿÿÿÿ ¥¥÷¤€Àÿÿÿÿÿÿ¥ ¥í¤€Áÿÿÿÿÿÿ¥¥ã¤€Âÿÿÿÿÿÿ)¥¥Ù¤€Ãÿÿÿÿÿÿ3¥‡~R†€Äÿÿÿÿÿÿ=¥X‚‡€ÅÿÿÿÿÿÿG¥7u®‡€ÆÿÿÿÿÿÿQ¥]ˆJˆ€Çÿÿÿÿÿÿ[¥>‹øˆ€Èÿÿÿÿÿÿe¥[¥Q¥€Éÿÿÿÿÿÿo¥e¥G¥€Êÿÿÿÿÿÿy¥o¥=¥€Ëÿÿÿÿÿÿƒ¥y¥3¥€Ìÿÿÿÿÿÿ¥^e‰€Íÿÿÿÿÿÿ—¥ƒ Š€Îÿÿÿÿÿÿ¡¥puO2€Ïÿÿÿÿÿÿ«¥øˆ+‹€Ðÿÿÿÿÿÿµ¥Æ‹«¥€Ñÿÿÿÿÿÿ¿¥µ¥¡¥€ÒÿÿÿÿÿÿÉ¥¿¥—¥€Óÿÿÿÿÿÿӥɥ¥€ÔÿÿÿÿÿÿÝ¥Ó¥ƒ¥€Õÿÿÿÿÿÿç¥Ý¥)¥€Öÿÿÿÿÿÿñ¥ç¥Ï¤€×ÿÿÿÿÿÿû¥ñ¥u¤€Øÿÿÿÿÿÿ¦û¥¤€Ùÿÿÿÿÿÿ¦¦;¢€Úÿÿÿÿÿÿ¦¦[ €Ûÿÿÿÿÿÿ#¦¦{ž€ÜSÿÿÿÿÿÿ-¦2.2.€Ý>ÿÿÿÿÿÿ7¦œ-¦@ÞÿÿÿÿÿÿA¦7¦€ßSÿÿÿÿÿÿJ¦$i$i€à>ÿÿÿÿÿÿT¦~J¦@áÿÿÿÿÿÿ^¦T¦€âSÿÿÿÿÿÿg¦f@f@€ã>ÿÿÿÿÿÿq¦4g¦@äÿÿÿÿÿÿ{¦q¦€åSÿÿÿÿÿÿ„¦¦i¦i€æ>ÿÿÿÿÿÿŽ¦<„¦@çÿÿÿÿÿÿ˜¦Ž¦€èSÿÿÿÿÿÿ¡¦ìiìi€é>ÿÿÿÿÿÿ«¦°¡¦@êÿÿÿÿÿÿµ¦«¦€ëÿÿÿÿÿÿ¾¦µ¦˜¦€ìÿÿÿÿÿÿȦ¾¦{¦€íÿÿÿÿÿÿҦȦ^¦€îÿÿÿÿÿÿܦҦA¦€ïSÿÿÿÿÿÿæ¦ÞhÞh€ð>ÿÿÿÿÿÿð¦œæ¦@ñÿÿÿÿÿÿú¦ð¦€òSÿÿÿÿÿÿ§³-³-€ó>ÿÿÿÿÿÿ §~§@ôÿÿÿÿÿÿ§ §€õSÿÿÿÿÿÿ §x1x1€ö>ÿÿÿÿÿÿ*§4 §@÷ÿÿÿÿÿÿ4§*§€øSÿÿÿÿÿÿ=§ºiºi€ù>ÿÿÿÿÿÿG§<=§@úÿÿÿÿÿÿQ§G§€ûSÿÿÿÿÿÿZ§jj€ü>ÿÿÿÿÿÿd§°Z§@ýÿÿÿÿÿÿn§d§€þÿÿÿÿÿÿw§n§Q§€ÿÿÿÿÿÿÿ§w§4§€ÿÿÿÿÿÿ‹§§§€ÿÿÿÿÿÿ•§‹§ú¦€SÿÿÿÿÿÿŸ§ê'ê'€>ÿÿÿÿÿÿ©§œŸ§@ÿÿÿÿÿÿ³§©§€Sÿÿÿÿÿÿ¼§|$|$€>ÿÿÿÿÿÿƧ~¼§@ÿÿÿÿÿÿЧƧ€SÿÿÿÿÿÿÙ§_$_$€ >ÿÿÿÿÿÿã§<Ù§@ ÿÿÿÿÿÿí§ã§€ Sÿÿÿÿÿÿö§£$£$€ >ÿÿÿÿÿÿ¨°ö§@ ÿÿÿÿÿÿ ¨¨€ÿÿÿÿÿÿ¨ ¨í§€ÿÿÿÿÿÿ¨¨Š.€ÿÿÿÿÿÿ'¨¨Ð§€ÿÿÿÿÿÿ1¨'¨³§€Sÿÿÿÿÿÿ;¨ühüh€>ÿÿÿÿÿÿE¨œ;¨@ÿÿÿÿÿÿO¨E¨€SÿÿÿÿÿÿX¨LiLi€>ÿÿÿÿÿÿb¨~X¨@ÿÿÿÿÿÿl¨b¨€Sÿÿÿÿÿÿu¨¿0¿0€>ÿÿÿÿÿÿ¨4u¨@ÿÿÿÿÿÿ‰¨¨€Sÿÿÿÿÿÿ’¨ú,ú,€>ÿÿÿÿÿÿœ¨<’¨@ÿÿÿÿÿÿ¦¨œ¨€Sÿÿÿÿÿÿ¯¨jj€>ÿÿÿÿÿÿ¹¨°¯¨@ ÿÿÿÿÿÿ蹨€!ÿÿÿÿÿÿ̨覨€"ÿÿÿÿÿÿ̨֨‰¨€#ÿÿÿÿÿÿà¨Ö¨l¨€$ÿÿÿÿÿÿê¨à¨O¨€%Sÿÿÿÿÿÿô¨ii€&>ÿÿÿÿÿÿþ¨œô¨@'ÿÿÿÿÿÿ©þ¨€(Sÿÿÿÿÿÿ©`i`i€)>ÿÿÿÿÿÿ©~©@*ÿÿÿÿÿÿ%©©€+Sÿÿÿÿÿÿ.©;2;2€,>ÿÿÿÿÿÿ8©4.©@-ÿÿÿÿÿÿB©8©€.SÿÿÿÿÿÿK©ØiØi€/>ÿÿÿÿÿÿU©<K©@0ÿÿÿÿÿÿ_©U©€1Sÿÿÿÿÿÿh©v.v.€2>ÿÿÿÿÿÿr©°h©@3ÿÿÿÿÿÿ|©r©€4ÿÿÿÿÿÿ…©|©_©€5ÿÿÿÿÿÿ©…©B©€6ÿÿÿÿÿÿ™©©%©€7ÿÿÿÿÿÿ£©™©©€8ÿÿÿÿÿÿ­©£©ê¨€9ÿÿÿÿÿÿ·©­©1¨€:ÿÿÿÿÿÿÁ©·©•§€;ÿÿÿÿÿÿË©Á©Ü¦€<SÿÿÿÿÿÿÕ©~Þh€=>ÿÿÿÿÿÿß©œÕ©@>ÿÿÿÿÿÿé©ß©€?Sÿÿÿÿÿÿò©4ê'€@>ÿÿÿÿÿÿü©œò©@Aÿÿÿÿÿÿªü©€BSÿÿÿÿÿÿª<üh€C>ÿÿÿÿÿÿªœª@Dÿÿÿÿÿÿ#ªª€ESÿÿÿÿÿÿ,ª°i€F>ÿÿÿÿÿÿ6ªœ,ª@Gÿÿÿÿÿÿ@ª6ª€HÿÿÿÿÿÿIª@ª#ª€IÿÿÿÿÿÿSªIªª€Jÿÿÿÿÿÿ]ªSªé©€Kÿÿÿÿÿÿgª]ª—€LSÿÿÿÿÿÿqªœ$i€M>ÿÿÿÿÿÿ{ª~qª@Nÿÿÿÿÿÿ…ª{ª€OSÿÿÿÿÿÿŽª4|$€P>ÿÿÿÿÿÿ˜ª~Žª@Qÿÿÿÿÿÿ¢ª˜ª€RSÿÿÿÿÿÿ«ª<Li€S>ÿÿÿÿÿÿµª~«ª@Tÿÿÿÿÿÿ¿ªµª€USÿÿÿÿÿÿȪ°`i€V>ÿÿÿÿÿÿÒª~Ȫ@WÿÿÿÿÿÿܪҪ€XÿÿÿÿÿÿåªÜª¿ª€Yÿÿÿÿÿÿïªåª¢ª€ZÿÿÿÿÿÿùªïªÛ—€[ÿÿÿÿÿÿ«ùª…ª€\Sÿÿÿÿÿÿ «œf@€]>ÿÿÿÿÿÿ«4 «@^ÿÿÿÿÿÿ!««€_Sÿÿÿÿÿÿ*«~x1€`>ÿÿÿÿÿÿ4«4*«@aÿÿÿÿÿÿ>«4«€bSÿÿÿÿÿÿG«<¿0€c>ÿÿÿÿÿÿQ«4G«@dÿÿÿÿÿÿ[«Q«€eSÿÿÿÿÿÿd«°;2€f>ÿÿÿÿÿÿn«4d«@gÿÿÿÿÿÿx«n«€hÿÿÿÿÿÿ«x«[«€iÿÿÿÿÿÿ‹««O2€jÿÿÿÿÿÿ•«‹«>«€kÿÿÿÿÿÿŸ«•«!«€lSÿÿÿÿÿÿ©«œ¦i€m>ÿÿÿÿÿÿ³«<©«@nÿÿÿÿÿÿ½«³«€oSÿÿÿÿÿÿÆ«~ºi€p>ÿÿÿÿÿÿЫ<Æ«@qÿÿÿÿÿÿګЫ€rSÿÿÿÿÿÿã«4_$€s>ÿÿÿÿÿÿí«<ã«@tÿÿÿÿÿÿ÷«í«€uSÿÿÿÿÿÿ¬°Øi€v>ÿÿÿÿÿÿ ¬<¬@wÿÿÿÿÿÿ¬ ¬€xÿÿÿÿÿÿ¬¬ö˜€yÿÿÿÿÿÿ'¬¬÷«€zÿÿÿÿÿÿ1¬'¬Ú«€{ÿÿÿÿÿÿ;¬1¬½«€|SÿÿÿÿÿÿE¬œìi€}>ÿÿÿÿÿÿO¬°E¬@~ÿÿÿÿÿÿY¬O¬€Sÿÿÿÿÿÿb¬~j€€>ÿÿÿÿÿÿl¬°b¬@ÿÿÿÿÿÿv¬l¬€‚Sÿÿÿÿÿÿ¬4£$€ƒ>ÿÿÿÿÿÿ‰¬°¬@„ÿÿÿÿÿÿ“¬‰¬€…Sÿÿÿÿÿÿœ¬<j€†>ÿÿÿÿÿÿ¦¬°œ¬@‡ÿÿÿÿÿÿ°¬¦¬€ˆÿÿÿÿÿÿ¹¬Ì™°¬€‰ÿÿÿÿÿÿ칬“¬€Šÿÿÿÿÿÿͬìv¬€‹ÿÿÿÿÿÿ׬ͬY¬€Œÿÿÿÿÿÿá¬×¬;¬€ÿÿÿÿÿÿë¬á¬Ÿ«€Žÿÿÿÿÿÿõ¬ë¬«€ÿÿÿÿÿÿÿ¬õ¬gª€>ÿÿÿÿÿÿ ­~æ¦@‘ÿÿÿÿÿÿ­ ­€’>ÿÿÿÿÿÿ­4Ÿ§@“ÿÿÿÿÿÿ&­­€”>ÿÿÿÿÿÿ/­<;¨@•ÿÿÿÿÿÿ9­/­€–>ÿÿÿÿÿÿB­°ô¨@—ÿÿÿÿÿÿL­B­€˜ÿÿÿÿÿÿU­L­9­€™ÿÿÿÿÿÿ_­U­&­€šÿÿÿÿÿÿi­_­­€›ÿÿÿÿÿÿs­i­A¦€œ>ÿÿÿÿÿÿ}­œJ¦@ÿÿÿÿÿÿ‡­}­€ž>ÿÿÿÿÿÿ­4¼§@Ÿÿÿÿÿÿÿš­­€ >ÿÿÿÿÿÿ£­<X¨@¡ÿÿÿÿÿÿ­­£­€¢>ÿÿÿÿÿÿ¶­°©@£ÿÿÿÿÿÿÀ­¶­€¤ÿÿÿÿÿÿÉ­À­­­€¥ÿÿÿÿÿÿÓ­É­š­€¦ÿÿÿÿÿÿÝ­Ó­§€§ÿÿÿÿÿÿç­Ý­‡­€¨>ÿÿÿÿÿÿñ­œg¦@©ÿÿÿÿÿÿû­ñ­€ª>ÿÿÿÿÿÿ®~ §@«ÿÿÿÿÿÿ®®€¬>ÿÿÿÿÿÿ®<u¨@­ÿÿÿÿÿÿ!®®€®>ÿÿÿÿÿÿ*®°.©@¯ÿÿÿÿÿÿ4®*®€°ÿÿÿÿÿÿ=®4®!®€±ÿÿÿÿÿÿG®=®Š.€²ÿÿÿÿÿÿQ®G®®€³ÿÿÿÿÿÿ[®Q®û­€´>ÿÿÿÿÿÿe®œ„¦@µÿÿÿÿÿÿo®e®€¶>ÿÿÿÿÿÿx®~=§@·ÿÿÿÿÿÿ‚®x®€¸>ÿÿÿÿÿÿ‹®4Ù§@¹ÿÿÿÿÿÿ•®‹®€º>ÿÿÿÿÿÿž®°K©@»ÿÿÿÿÿÿ¨®ž®€¼ÿÿÿÿÿÿ±®¨®¦¨€½ÿÿÿÿÿÿ»®±®•®€¾ÿÿÿÿÿÿÅ®»®‚®€¿ÿÿÿÿÿÿϮŮo®€À>ÿÿÿÿÿÿÙ®œ¡¦@Áÿÿÿÿÿÿã®Ù®€Â>ÿÿÿÿÿÿì®~Z§@Ãÿÿÿÿÿÿö®ì®€Ä>ÿÿÿÿÿÿÿ®4ö§@Åÿÿÿÿÿÿ ¯ÿ®€Æ>ÿÿÿÿÿÿ¯<¯¨@Çÿÿÿÿÿÿ¯¯€Èÿÿÿÿÿÿ%¯|©¯€Éÿÿÿÿÿÿ/¯%¯ ¯€Êÿÿÿÿÿÿ9¯/¯ö®€ËÿÿÿÿÿÿC¯9¯ã®€ÌÿÿÿÿÿÿM¯C¯Ï®€ÍÿÿÿÿÿÿW¯M¯[®€Îÿÿÿÿÿÿa¯W¯ç­€Ïÿÿÿÿÿÿk¯a¯s­€Ðÿÿÿÿÿÿu¯y‹ˆ€Ñÿÿÿÿÿÿ¯u¯kb€Òÿÿÿÿÿÿ‰¯¯„€€Óÿÿÿÿÿÿ“¯‰¯ú{€Ôÿÿÿÿÿÿ¯ð{“¯€Õÿÿÿÿÿÿ§¯Œ‹#ˆ€Öÿÿÿÿÿÿ±¯§¯"]€×ÿÿÿÿÿÿ»¯±¯—€€Øÿÿÿÿÿÿů»¯|€Ùÿÿÿÿÿÿϯ |ů€ÚÿÿÿÿÿÿÙ¯Š.-€Ûÿÿÿÿÿÿã¯Ù¯v€Üÿÿÿÿÿÿí¯ã¯Ç-€Ýÿÿÿÿÿÿ÷¯í¯g4€Þÿÿÿÿÿÿ°òh÷¯€ßÿÿÿÿÿÿ °©‹Jˆ€àÿÿÿÿÿÿ° °Ë\€áÿÿÿÿÿÿ°°È€€âÿÿÿÿÿÿ)°°H|€ãÿÿÿÿÿÿ3°?k)°€äÿÿÿÿÿÿ=°Æ‹]ˆ€åÿÿÿÿÿÿG°=°€æÿÿÿÿÿÿQ°çÿÿÿÿÿÿ[°[|€èÿÿÿÿÿÿe°d|€éÿÿÿÿÿÿo°e°3°€êÿÿÿÿÿÿy°o°°€ëÿÿÿÿÿÿƒ°y°Ï¯€ìÿÿÿÿÿÿ°ƒ°¯€íÿÿÿÿÿÿ—°½|“¯€îÿÿÿÿÿÿ¡°8iů€ïÿÿÿÿÿÿ«°ª€÷¯€ðÿÿÿÿÿÿµ°Ñ€)°€ñÿÿÿÿÿÿ¿°ø€€òÿÿÿÿÿÿÉ°¿°µ°€óÿÿÿÿÿÿÓ°É°«°€ôÿÿÿÿÿÿÝ°Ó°¡°€õÿÿÿÿÿÿç°Ý°—°€öÿÿÿÿÿÿñ°“}“¯€÷ÿÿÿÿÿÿû°~iů€øÿÿÿÿÿÿ±ì÷¯€ùÿÿÿÿÿÿ±À„)°€úÿÿÿÿÿÿ±E2€ûÿÿÿÿÿÿ#±±±€üÿÿÿÿÿÿ-±#±±€ýÿÿÿÿÿÿ7±-±û°€þÿÿÿÿÿÿA±7±ñ°€ÿÿÿÿÿÿÿK±°i“¯€ÿÿÿÿÿÿU±'‚ů€ÿÿÿÿÿÿ_±R…÷¯€ÿÿÿÿÿÿi±@ˆ)°€ÿÿÿÿÿÿs±…k€ÿÿÿÿÿÿ}±s±i±€ÿÿÿÿÿÿ‡±}±_±€ÿÿÿÿÿÿ‘±‡±U±€ÿÿÿÿÿÿ›±‘±K±€ÿÿÿÿÿÿ¥±T“¯€ ÿÿÿÿÿÿ¯± jů€ ÿÿÿÿÿÿ¹±fu÷¯€ ÿÿÿÿÿÿñîˆ)°€ ÿÿÿÿÿÿͱ¼‹€ ÿÿÿÿÿÿױͱñ€ÿÿÿÿÿÿá±×±¹±€ÿÿÿÿÿÿë±á±¯±€ÿÿÿÿÿÿõ±ë±¥±€ÿÿÿÿÿÿÿ±õ±›±€ÿÿÿÿÿÿ ²ÿ±A±€ÿÿÿÿÿÿ² ²ç°€ÿÿÿÿÿÿ²²°€Sÿÿÿÿÿÿ'²$iœ€>ÿÿÿÿÿÿ1²~'²€Sÿÿÿÿÿÿ;²f@œ€>ÿÿÿÿÿÿE²4;²€SÿÿÿÿÿÿO²¦iœ€>ÿÿÿÿÿÿY²<O²€Sÿÿÿÿÿÿc²ìiœ€>ÿÿÿÿÿÿm²°c²€ÿÿÿÿÿÿw²m²Y²€ÿÿÿÿÿÿ²w²E²€ÿÿÿÿÿÿ‹²²1²€ ÿÿÿÿÿÿ•²‹²Rx€!SÿÿÿÿÿÿŸ²Þh~€">ÿÿÿÿÿÿ©²œŸ²€#Sÿÿÿÿÿÿ³²x1~€$>ÿÿÿÿÿÿ½²4³²€%SÿÿÿÿÿÿDzºi~€&>ÿÿÿÿÿÿѲ<Dz€'SÿÿÿÿÿÿÛ²j~€(>ÿÿÿÿÿÿå²°Û²€)ÿÿÿÿÿÿï²å²Ñ²€*ÿÿÿÿÿÿù²ï²½²€+ÿÿÿÿÿÿ³ù²(y€,ÿÿÿÿÿÿ ³³©²€-Sÿÿÿÿÿÿ³ê'4€.>ÿÿÿÿÿÿ!³œ³€/Sÿÿÿÿÿÿ+³|$4€0>ÿÿÿÿÿÿ5³~+³€1Sÿÿÿÿÿÿ?³_$4€2>ÿÿÿÿÿÿI³<?³€3SÿÿÿÿÿÿS³£$4€4>ÿÿÿÿÿÿ]³°S³€5ÿÿÿÿÿÿg³]³I³€6ÿÿÿÿÿÿq³g³­$€7ÿÿÿÿÿÿ{³q³5³€8ÿÿÿÿÿÿ…³{³!³€9Sÿÿÿÿÿÿ³üh<€:>ÿÿÿÿÿÿ™³œ³€;Sÿÿÿÿÿÿ£³Li<€<>ÿÿÿÿÿÿ­³~£³€=Sÿÿÿÿÿÿ·³¿0<€>>ÿÿÿÿÿÿÁ³4·³€?Sÿÿÿÿÿÿ˳j<€@>ÿÿÿÿÿÿÕ³°Ë³€Aÿÿÿÿÿÿß³Õ³·z€Bÿÿÿÿÿÿé³ß³Á³€Cÿÿÿÿÿÿó³é³­³€Dÿÿÿÿÿÿý³ó³™³€ESÿÿÿÿÿÿ´i°€F>ÿÿÿÿÿÿ´œ´€GSÿÿÿÿÿÿ´`i°€H>ÿÿÿÿÿÿ%´~´€ISÿÿÿÿÿÿ/´;2°€J>ÿÿÿÿÿÿ9´4/´€KSÿÿÿÿÿÿC´Øi°€L>ÿÿÿÿÿÿM´<C´€MÿÿÿÿÿÿW´{M´€Nÿÿÿÿÿÿa´W´9´€Oÿÿÿÿÿÿk´a´%´€Pÿÿÿÿÿÿu´k´´€Qÿÿÿÿÿÿ´u´ý³€Rÿÿÿÿÿÿ‰´´…³€Sÿÿÿÿÿÿ“´‰´ ³€Tÿÿÿÿÿÿ´“´•²€Uÿÿÿÿÿÿ§´#{jz€Vÿÿÿÿÿÿ±´§´Îy€Wÿÿÿÿÿÿ»´±´y€XÿÿÿÿÿÿÅ´»´\x€YÿÿÿÿÿÿÏ´@{‡z€ZÿÿÿÿÿÿÙ´Ï´ëy€[ÿÿÿÿÿÿã´Ù´2y€\ÿÿÿÿÿÿí´ã´yx€]ÿÿÿÿÿÿ÷´]{¤z€^ÿÿÿÿÿÿµ÷´·$€_ÿÿÿÿÿÿ µµOy€`ÿÿÿÿÿÿµ µ–x€aÿÿÿÿÿÿµz{Áz€bÿÿÿÿÿÿ)µµz€cÿÿÿÿÿÿ3µ)µly€dÿÿÿÿÿÿ=µ3µ³x€eÿÿÿÿÿÿGµ—{Þz€fÿÿÿÿÿÿQµGµ%z€gÿÿÿÿÿÿ[µQµ‰y€hÿÿÿÿÿÿeµ[µÐx€iÿÿÿÿÿÿoµeµ=µ€jÿÿÿÿÿÿyµoµµ€kÿÿÿÿÿÿƒµyµí´€lÿÿÿÿÿÿµƒµÅ´@mÿÿÿÿÿÿ—µ1²@nÿÿÿÿÿÿ µE²@oÿÿÿÿÿÿ©µY²@pÿÿÿÿÿÿ²µm²€qÿÿÿÿÿÿ»µ²µ©µ€rÿÿÿÿÿÿŵ»µ µ€sÿÿÿÿÿÿϵŵ—µ€tÿÿÿÿÿÿٵϵ\x@uÿÿÿÿÿÿ㵩²@vÿÿÿÿÿÿìµ½²@wÿÿÿÿÿÿõµÑ²@xÿÿÿÿÿÿþµå²€yÿÿÿÿÿÿ¶þµõµ€zÿÿÿÿÿÿ¶¶ìµ€{ÿÿÿÿÿÿ¶¶2y€|ÿÿÿÿÿÿ%¶¶ãµ@}ÿÿÿÿÿÿ/¶!³@~ÿÿÿÿÿÿ8¶5³@ÿÿÿÿÿÿA¶I³@€ÿÿÿÿÿÿJ¶]³€ÿÿÿÿÿÿS¶J¶A¶€‚ÿÿÿÿÿÿ]¶S¶·$€ƒÿÿÿÿÿÿg¶]¶8¶€„ÿÿÿÿÿÿq¶g¶/¶@…ÿÿÿÿÿÿ{¶™³@†ÿÿÿÿÿÿ„¶­³@‡ÿÿÿÿÿÿ¶Á³@ˆÿÿÿÿÿÿ–¶Õ³€‰ÿÿÿÿÿÿŸ¶–¶Áz€Šÿÿÿÿÿÿ©¶Ÿ¶¶€‹ÿÿÿÿÿÿ³¶©¶„¶€Œÿÿÿÿÿÿ½¶³¶{¶@ÿÿÿÿÿÿǶ´@Žÿÿÿÿÿÿж%´@ÿÿÿÿÿÿÙ¶9´@ÿÿÿÿÿÿâ¶M´€‘ÿÿÿÿÿÿ붗{ⶀ’ÿÿÿÿÿÿõ¶ë¶Ù¶€“ÿÿÿÿÿÿÿ¶õ¶Ð¶€”ÿÿÿÿÿÿ ·ÿ¶Ç¶€•ÿÿÿÿÿÿ· ·½¶€–ÿÿÿÿÿÿ··q¶€—ÿÿÿÿÿÿ'··%¶€˜ÿÿÿÿÿÿ1·'·Ùµ€™ÿÿÿÿÿÿ;·¼‹@ˆ€šÿÿÿÿÿÿE·;·ì€›ÿÿÿÿÿÿO·E·8i€œÿÿÿÿÿÿY·O·ð{€ÿÿÿÿÿÿc·Ëª|€žÿÿÿÿÿÿm·~ƒc}€Ÿÿÿÿÿÿÿw·R†~€ ÿÿÿÿÿÿ·e‰Ì~€¡ÿÿÿÿÿÿ‹··w·€¢ÿÿÿÿÿÿ•·‹·m·€£ÿÿÿÿÿÿŸ·•·c·€¤ÿÿÿÿÿÿ©·Ÿ·ú{€¥ÿÿÿÿÿÿ³·„4€¦ÿÿÿÿÿÿ½·í†Ú€§ÿÿÿÿÿÿÇ·ö‰‚€¨ÿÿÿÿÿÿÑ·Ç·½·€©ÿÿÿÿÿÿÛ·Ñ·³·€ªÿÿÿÿÿÿå·Û·„€€«ÿÿÿÿÿÿï·å·õœ€¬ÿÿÿÿÿÿù·4„€­ÿÿÿÿÿÿ¸ˆ‡…€®ÿÿÿÿÿÿ ¸}Š«…€¯ÿÿÿÿÿÿ¸ ¸¸€°ÿÿÿÿÿÿ!¸¸kb€±ÿÿÿÿÿÿ+¸!¸ù·€²ÿÿÿÿÿÿ5¸+¸O€³ÿÿÿÿÿÿ?¸Ú톀´ÿÿÿÿÿÿI¸…ˆ‡€µÿÿÿÿÿÿS¸òŠ˜ˆ€¶ÿÿÿÿÿÿ]¸S¸ˆ€·ÿÿÿÿÿÿg¸]¸I¸€¸ÿÿÿÿÿÿq¸g¸?¸€¹ÿÿÿÿÿÿ{¸q¸©€ºÿÿÿÿÿÿ…¸‚ö‰€»ÿÿÿÿÿÿ¸«…}Š€¼ÿÿÿÿÿÿ™¸˜ˆòŠ€½ÿÿÿÿÿÿ£¸y‹™¸€¾ÿÿÿÿÿÿ­¸£¸¸€¿ÿÿÿÿÿÿ·¸­¸…¸€ÀÿÿÿÿÿÿÁ¸·¸ž€Áÿÿÿÿÿÿ˸Á¸{¸€Âÿÿÿÿÿÿո˸5¸€Ãÿÿÿÿÿÿ߸ոﷀÄÿÿÿÿÿÿé¸ß¸©·€Åÿÿÿÿÿÿ󸑃v}€Æÿÿÿÿÿÿý¸e†0~€Çÿÿÿÿÿÿ¹x‰é~€Èÿÿÿÿÿÿ¹¹ý¸€Éÿÿÿÿÿÿ¹¹ó¸€Êÿÿÿÿÿÿ%¹¹ž€Ëÿÿÿÿÿÿ/¹%¹|€Ìÿÿÿÿÿÿ9¹Ç|è€ÍÿÿÿÿÿÿC¹-„Q€ÎÿÿÿÿÿÿM¹‡÷€ÏÿÿÿÿÿÿW¹ Šº‚€Ðÿÿÿÿÿÿa¹W¹M¹€Ñÿÿÿÿÿÿk¹a¹C¹€Òÿÿÿÿÿÿu¹k¹—€€Óÿÿÿÿÿÿ¹u¹9¹€Ôÿÿÿÿÿÿ‰¹v}‘ƒ€Õÿÿÿÿÿÿ“¹›‡"…€Öÿÿÿÿÿÿ¹Š¾…€×ÿÿÿÿÿÿ§¹¹“¹€Øÿÿÿÿÿÿ±¹§¹"]€Ùÿÿÿÿÿÿ»¹±¹9Ÿ€ÚÿÿÿÿÿÿŹ»¹‰¹€ÛÿÿÿÿÿÿϹ0~e†€ÜÿÿÿÿÿÿÙ¹"…›‡€Ýÿÿÿÿÿÿ㹋«ˆ€Þÿÿÿÿÿÿí¹ã¹#ˆ€ßÿÿÿÿÿÿ÷¹í¹Ù¹€àÿÿÿÿÿÿº÷¹“Ÿ€áÿÿÿÿÿÿ ººÏ¹€âÿÿÿÿÿÿºé~x‰€ãÿÿÿÿÿÿº¾…Š€äÿÿÿÿÿÿ)º«ˆ‹€åÿÿÿÿÿÿ3ºŒ‹)º€æÿÿÿÿÿÿ=º3ºº€çÿÿÿÿÿÿGº=ºíŸ€èÿÿÿÿÿÿQºGºº€éÿÿÿÿÿÿ[ºQº º€êÿÿÿÿÿÿeº[ºÅ¹€ëÿÿÿÿÿÿoºeº¹€ìÿÿÿÿÿÿyºoº/¹€íÿÿÿÿÿÿƒº€î|€îÿÿÿÿÿÿºx†C~€ïÿÿÿÿÿÿ—º‹‰€ðÿÿÿÿÿÿ¡º—ºº€ñÿÿÿÿÿÿ«º¡ºy €òÿÿÿÿÿÿµº«ºƒº€óÿÿÿÿÿÿ¿ºµºg4€ôÿÿÿÿÿÿɺî|€€õÿÿÿÿÿÿÓº‡‚€öÿÿÿÿÿÿݺŠ×‚€÷ÿÿÿÿÿÿçºÝºÓº€øÿÿÿÿÿÿñºçºÓ €ùÿÿÿÿÿÿûºñºÇ-€úÿÿÿÿÿÿ»ûºÉº€ûÿÿÿÿÿÿ»}¤ƒ€üÿÿÿÿÿÿ»d@„€ýÿÿÿÿÿÿ#»®‡?…€þÿÿÿÿÿÿ-»O2·$€ÿÿÿÿÿÿÿ7»-»#»€ÿÿÿÿÿÿA»7»v€ÿÿÿÿÿÿK»A»»€ÿÿÿÿÿÿU»K»»€ÿÿÿÿÿÿ_»C~x†€ÿÿÿÿÿÿi»‚‡€ÿÿÿÿÿÿs»‹¾ˆ€ÿÿÿÿÿÿ}»s»-€ÿÿÿÿÿÿ‡»}»}¡€ÿÿÿÿÿÿ‘»‡»i»€ ÿÿÿÿÿÿ›»‘»_»€ ÿÿÿÿÿÿ¥»‹‰€ ÿÿÿÿÿÿ¯»×‚Š€ ÿÿÿÿÿÿ¹»¾ˆ‹€ ÿÿÿÿÿÿûŠ.¹»€ÿÿÿÿÿÿͻûס€ÿÿÿÿÿÿ׻ͻ¯»€ÿÿÿÿÿÿá»×»¥»€ÿÿÿÿÿÿë»á»›»€ÿÿÿÿÿÿõ»ë»U»€ÿÿÿÿÿÿÿ»õ»»€ÿÿÿÿÿÿ ¼ÿ»¿º€ÿÿÿÿÿÿ¼"€}€ÿÿÿÿÿÿ¼Áƒº}€ÿÿÿÿÿÿ'¼ž‰7€ÿÿÿÿÿÿ1¼'¼c¢€ÿÿÿÿÿÿ;¼1¼¼€ÿÿÿÿÿÿE¼;¼¼€ÿÿÿÿÿÿO¼E¼H|€ÿÿÿÿÿÿY¼}"€€ÿÿÿÿÿÿc¼]„€ÿÿÿÿÿÿm¼/Šþ‚€ÿÿÿÿÿÿw¼m¼½¢€ ÿÿÿÿÿÿ¼w¼c¼€!ÿÿÿÿÿÿ‹¼¼È€€"ÿÿÿÿÿÿ•¼‹¼Y¼€#ÿÿÿÿÿÿŸ¼º}Áƒ€$ÿÿÿÿÿÿ©¼]„€%ÿÿÿÿÿÿ³¼­ŠÛ…€&ÿÿÿÿÿÿ½¼³¼£€'ÿÿÿÿÿÿǼ½¼Ë\€(ÿÿÿÿÿÿѼǼ©¼€)ÿÿÿÿÿÿۼѼŸ¼€*ÿÿÿÿÿÿå¼`~•†€+ÿÿÿÿÿÿï¼1‚0‡€,ÿÿÿÿÿÿù¼\…Á‡€-ÿÿÿÿÿÿ½+‹Ûˆ€.ÿÿÿÿÿÿ ½½Jˆ€/ÿÿÿÿÿÿ½ ½ù¼€0ÿÿÿÿÿÿ!½½ï¼€1ÿÿÿÿÿÿ+½!½å¼€2ÿÿÿÿÿÿ5½7ž‰€3ÿÿÿÿÿÿ?½þ‚/Š€4ÿÿÿÿÿÿI½Û…­Š€5ÿÿÿÿÿÿS½©‹Á£€6ÿÿÿÿÿÿ]½S½I½€7ÿÿÿÿÿÿg½]½?½€8ÿÿÿÿÿÿq½g½5½€9ÿÿÿÿÿÿ{½q½+½€:ÿÿÿÿÿÿ…½{½Û¼€;ÿÿÿÿÿÿ½…½•¼€<ÿÿÿÿÿÿ™½½O¼€=ÿÿÿÿÿÿ£½I€}€>ÿÿÿÿÿÿ­½ëtKo€?ÿÿÿÿÿÿ·½¨†‡~€@ÿÿÿÿÿÿÁ½M¤·½€Aÿÿÿÿÿÿ˽Á½­½€Bÿÿÿÿÿÿս˽£½€Cÿÿÿÿÿÿß½Õ½[|€Dÿÿÿÿÿÿé½}I€€Eÿÿÿÿÿÿó½þt^o€Fÿÿÿÿÿÿý½M‡X‚€Gÿÿÿÿÿÿ¾§¤ý½€Hÿÿÿÿÿÿ¾¾ó½€Iÿÿÿÿÿÿ¾¾ï€€Jÿÿÿÿÿÿ%¾¾é½€Kÿÿÿÿÿÿ/¾Koët€Lÿÿÿÿÿÿ9¾^oþt€MÿÿÿÿÿÿC¾—o7u€NÿÿÿÿÿÿM¾¥C¾€OÿÿÿÿÿÿW¾M¾Ô„€Pÿÿÿÿÿÿa¾W¾9¾€Qÿÿÿÿÿÿk¾a¾/¾€Rÿÿÿÿÿÿu¾‡~¨†€Sÿÿÿÿÿÿ¾X‚M‡€Tÿÿÿÿÿÿ‰¾7u—o€Uÿÿÿÿÿÿ“¾[¥]ˆ€Vÿÿÿÿÿÿ¾“¾‰¾€Wÿÿÿÿÿÿ§¾¾¾€Xÿÿÿÿÿÿ±¾§¾u¾€Yÿÿÿÿÿÿ»¾^»‰€ZÿÿÿÿÿÿžƒBŠ€[ÿÿÿÿÿÿϾpuÐo€\ÿÿÿÿÿÿÙ¾øˆ>‹€]ÿÿÿÿÿÿã¾Æ‹Ù¾€^ÿÿÿÿÿÿí¾ã¾Ï¾€_ÿÿÿÿÿÿ÷¾í¾Å¾€`ÿÿÿÿÿÿ¿÷¾»¾€aÿÿÿÿÿÿ ¿¿±¾€bÿÿÿÿÿÿ¿ ¿k¾€cÿÿÿÿÿÿ¿¿%¾€dÿÿÿÿÿÿ)¿¿ß½€eÿÿÿÿÿÿ3¿)¿™½€fÿÿÿÿÿÿ=¿3¿ ¼€gÿÿÿÿÿÿG¿=¿yº€hÿÿÿÿÿÿQ¿G¿é¸€iÿÿÿÿÿÿ[¿[°)°€jÿÿÿÿÿÿe¿[¿÷¯€kÿÿÿÿÿÿo¿e¿Å¯€lÿÿÿÿÿÿy¿o¿“¯€mÿÿÿÿÿÿƒ¿öi ~€nÿÿÿÿÿÿ¿ƒ¿Y}€oÿÿÿÿÿÿ—¿¿ |€pÿÿÿÿÿÿ¡¿—¿ð{€qÿÿÿÿÿÿ«¿d|?k€rÿÿÿÿÿÿµ¿«¿òh€sÿÿÿÿÿÿ¿¿µ¿ |€tÿÿÿÿÿÿÉ¿¿¿ð{€uÿÿÿÿÿÿÓ¿É¿¡¿€vÿÿÿÿÿÿÝ¿ß~&~€wÿÿÿÿÿÿç¿Ý¿ti€xÿÿÿÿÿÿñ¿ç¿½|€yÿÿÿÿÿÿû¿ñ¿ |€zÿÿÿÿÿÿÀi+€€{ÿÿÿÿÿÿÀÀ€€|ÿÿÿÿÿÿÀÀÞ€}ÿÿÿÿÿÿ#ÀÀ |€~ÿÿÿÿÿÿ-À#Àû¿€ÿÿÿÿÿÿ7Àqk€€ÿÿÿÿÿÿAÀ7À“}€ÿÿÿÿÿÿKÀAÀä|€‚ÿÿÿÿÿÿUÀKÀ]4€ƒÿÿÿÿÿÿ_Àރʃ€„ÿÿÿÿÿÿiÀ_À5k€…ÿÿÿÿÿÿsÀiÀû€†ÿÿÿÿÿÿ}ÀsÀ]4€‡ÿÿÿÿÿÿ‡À}ÀUÀ€ˆÿÿÿÿÿÿ‘À-°i€‰ÿÿÿÿÿÿ›À‘À°}€Šÿÿÿÿÿÿ¥À›ÀIk€‹ÿÿÿÿÿÿ¯À¥À>|€Œÿÿÿÿÿÿ¹À±†‹†€ÿÿÿÿÿÿÃÀ¹À·ƒ€ŽÿÿÿÿÿÿÍÀÃÀèh€ÿÿÿÿÿÿ×ÀÍÀ>|€ÿÿÿÿÿÿáÀ×À¯À€‘ÿÿÿÿÿÿëÀT}~€’ÿÿÿÿÿÿõÀëÀAo€“ÿÿÿÿÿÿÿÀõÀ.i€”ÿÿÿÿÿÿ ÁÿÀ+k€•ÿÿÿÿÿÿÁ±‰i€–ÿÿÿÿÿÿÁÁát€—ÿÿÿÿÿÿ'ÁÁ?€€˜ÿÿÿÿÿÿ1Á'Á+k€™ÿÿÿÿÿÿ;Á1Á Á€šÿÿÿÿÿÿEÁ;ÁáÀ€›ÿÿÿÿÿÿOÁEÁ‡À€œÿÿÿÿÿÿYÁOÁ-À€ÿÿÿÿÿÿcÁYÁÓ¿€žÿÿÿÿÿÿmÁò~Äi€ŸÿÿÿÿÿÿwÁmÁ}€ ÿÿÿÿÿÿÁwÁÐ|€¡ÿÿÿÿÿÿ‹ÁÁ |€¢ÿÿÿÿÿÿ•Á}Vi€£ÿÿÿÿÿÿŸÁ•ÁSk€¤ÿÿÿÿÿÿ©ÁŸÁÐ|€¥ÿÿÿÿÿÿ³Á©Á |€¦ÿÿÿÿÿÿ½Á³Á‹Á€§ÿÿÿÿÿÿÇÁ°‚퀨ÿÿÿÿÿÿÑÁÇÁG€©ÿÿÿÿÿÿÛÁÑÁ8i€ªÿÿÿÿÿÿåÁÛÁÞ€«ÿÿÿÿÿÿïÁø€Ñ€€¬ÿÿÿÿÿÿùÁïÁª€€­ÿÿÿÿÿÿÂùÁ8i€®ÿÿÿÿÿÿ ½|€¯ÿÿÿÿÿÿ ÂåÁ€°ÿÿÿÿÿÿ!ÂÍ‚ ‚€±ÿÿÿÿÿÿ+Â!Â~i€²ÿÿÿÿÿÿ5Â+½-€³ÿÿÿÿÿÿ?Â5Âû€´ÿÿÿÿÿÿIÂp„]k€µÿÿÿÿÿÿSÂIÂBi€¶ÿÿÿÿÿÿ]ÂS½-€·ÿÿÿÿÿÿgÂ]Âä|€¸ÿÿÿÿÿÿqÂgÂ?€¹ÿÿÿÿÿÿ{Âô‚'‚€ºÿÿÿÿÿÿ…Â{Âw€»ÿÿÿÿÿÿ…¾€€¼ÿÿÿÿÿÿ™ÂÂèh€½ÿÿÿÿÿÿ£Âji&‡€¾ÿÿÿÿÿÿ­Â£ÂS„€¿ÿÿÿÿÿÿ·Â­Â¾€€ÀÿÿÿÿÿÿÁ·ÂIk€ÁÿÿÿÿÿÿËÂÁ™€ÂÿÿÿÿÿÿÕ jN‚€ÃÿÿÿÿÿÿßÂÕÂTo€ÄÿÿÿÿÿÿéÂßÂ倀ÅÿÿÿÿÿÿóÂéÂ?€€ÆÿÿÿÿÿÿýÂgkC‡€ÇÿÿÿÿÿÿÃýÂôt€ÈÿÿÿÿÿÿÃÃ倀ÉÿÿÿÿÿÿÃÃ.i€Êÿÿÿÿÿÿ%ÃÃó€Ëÿÿÿÿÿÿ/Ã%ÃË€Ìÿÿÿÿÿÿ9Ã/Ãq€ÍÿÿÿÿÿÿCÃ9ÀÎÿÿÿÿÿÿMÃCýÁ€ÏÿÿÿÿÿÿWÃL~€ÐÿÿÿÿÿÿaÃWÃab€ÑÿÿÿÿÿÿkÃaÃSk€ÒÿÿÿÿÿÿuÃkÃòh€ÓÿÿÿÿÿÿÃœiÃ}€Ôÿÿÿÿÿÿ‰ÃÃab€Õÿÿÿÿÿÿ“ÉÃ}€ÖÿÿÿÿÿÿÓÃY}€×ÿÿÿÿÿÿ§ÃÃuÀØÿÿÿÿÿÿ±Ãà‚Îi€Ùÿÿÿÿÿÿ»Ã±Ã]€ÚÿÿÿÿÿÿÅûꀀÛÿÿÿÿÿÿÏÃÅÀ€ÜÿÿÿÿÿÿÙÞŠ€ÝÿÿÿÿÿÿãÃÙÃ]€ÞÿÿÿÿÿÿíÃãÃG€ßÿÿÿÿÿÿ÷ÃíÃti€àÿÿÿÿÿÿÄ÷ÃÏÀáÿÿÿÿÿÿ Ä­$5…€âÿÿÿÿÿÿÄ Äì€ãÿÿÿÿÿÿÄÄBi€äÿÿÿÿÿÿ)ÄÄ5k€åÿÿÿÿÿÿ3ÄE2À„€æÿÿÿÿÿÿ=Ä3Äì€çÿÿÿÿÿÿGÄ=Ä~i€èÿÿÿÿÿÿQÄGÄ“}€éÿÿÿÿÿÿ[ÄQÄ)Ä€êÿÿÿÿÿÿeÄjR…€ëÿÿÿÿÿÿoÄeÄÁ\€ìÿÿÿÿÿÿyÄoÄS„€íÿÿÿÿÿÿƒÄyÄ·ƒ€îÿÿÿÿÿÿÄÔ‡’i€ïÿÿÿÿÿÿ—ÄÄÁ\€ðÿÿÿÿÿÿ¡Ä—Äw€ñÿÿÿÿÿÿ«Ä¡Ä°}€òÿÿÿÿÿÿµÄ«ÄƒÄ€óÿÿÿÿÿÿ¿Äfu-u€ôÿÿÿÿÿÿÉĿĈi€õÿÿÿÿÿÿÓÄÉÄôt€öÿÿÿÿÿÿÝÄÓÄát€÷ÿÿÿÿÿÿçÄÆoo€øÿÿÿÿÿÿñÄçĈi€ùÿÿÿÿÿÿûÄñÄTo€úÿÿÿÿÿÿÅûÄAo€ûÿÿÿÿÿÿÅÅÝÄ€üÿÿÿÿÿÿÅŵĀýÿÿÿÿÿÿ#ÅÅ[Ä€þÿÿÿÿÿÿ-Å#ÅÄ€ÿÿÿÿÿÿÿ7Å-ŧÀÿÿÿÿÿÿAÅ@i~€ÿÿÿÿÿÿKÅAÅÃ}€ÿÿÿÿÿÿUÅKÅVi€ÿÿÿÿÿÿ_ÅUÅ?k€ÿÿÿÿÿÿiÅ~i~€ÿÿÿÿÿÿsÅiÅL~€ÿÿÿÿÿÿ}ÅsÅÄi€ÿÿÿÿÿÿ‡Å}Å ~€ÿÿÿÿÿÿ‘ŇÅ_Å€ ÿÿÿÿÿÿ›Å(j:‚€ ÿÿÿÿÿÿ¥Å›ÅŠ€ ÿÿÿÿÿÿ¯Å¥ÅÑ€€ ÿÿÿÿÿÿ¹Å¯Å+€€ ÿÿÿÿÿÿÃÅa‚:‚€ÿÿÿÿÿÿÍÅÃÅÎi€ÿÿÿÿÿÿ×ÅÍÅí€ÿÿÿÿÿÿáÅ×Å&~€ÿÿÿÿÿÿëÅáŹŀÿÿÿÿÿÿõÅä…-€ÿÿÿÿÿÿÿÅõÅÀ„€ÿÿÿÿÿÿ ÆÿÅ]k€ÿÿÿÿÿÿÆ Æʃ€ÿÿÿÿÿÿÆo…-€ÿÿÿÿÿÿ'ÆÆ5…€ÿÿÿÿÿÿ1Æ'Æ ‚€ÿÿÿÿÿÿ;Æ1Æqk€ÿÿÿÿÿÿEÆ;ÆÆ€ÿÿÿÿÿÿOÆш@ˆ€ÿÿÿÿÿÿYÆOÆ’i€ÿÿÿÿÿÿcÆYÆ&‡€ÿÿÿÿÿÿmÆcÆ‹†€ÿÿÿÿÿÿwÆ…k@ˆ€ ÿÿÿÿÿÿÆwÆR…€!ÿÿÿÿÿÿ‹ÆÆ'‚€"ÿÿÿÿÿÿ•Æ‹Æ°i€#ÿÿÿÿÿÿŸÆ•ÆmÆ€$ÿÿÿÿÿÿ©Æîˆ{k€%ÿÿÿÿÿÿ³Æ©Æo€&ÿÿÿÿÿÿ½Æ³ÆC‡€'ÿÿÿÿÿÿÇƽÆi€(ÿÿÿÿÿÿÑÆâi{k€)ÿÿÿÿÿÿÛÆÑÆ-u€*ÿÿÿÿÿÿåÆÛÆN‚€+ÿÿÿÿÿÿïÆåÆ}~€,ÿÿÿÿÿÿùÆïÆÇÆ€-ÿÿÿÿÿÿÇùÆŸÆ€.ÿÿÿÿÿÿ ÇÇEÆ€/ÿÿÿÿÿÿÇ ÇëÅ€0ÿÿÿÿÿÿ!ÇÇ‘Å€1ÿÿÿÿÿÿ+Çg~€2ÿÿÿÿÿÿ5Ç+Çœi€3ÿÿÿÿÿÿ?Ç5Ç}€4ÿÿÿÿÿÿIÇ?Çd|€5ÿÿÿÿÿÿSÇg@€6ÿÿÿÿÿÿ]ÇSÇ€7ÿÿÿÿÿÿgÇ]Çò~€8ÿÿÿÿÿÿqÇgÇöi€9ÿÿÿÿÿÿ{ÇqÇIÇ€:ÿÿÿÿÿÿ…ǃa‚€;ÿÿÿÿÿÿÇ…Çž€<ÿÿÿÿÿÿ™ÇÇø€€=ÿÿÿÿÿÿ£Ç™Çi€>ÿÿÿÿÿÿ­Çƒ(j€?ÿÿÿÿÿÿ·Ç­Çà‚€@ÿÿÿÿÿÿÁÇ·Ç°‚€AÿÿÿÿÿÿËÇÁÇß~€BÿÿÿÿÿÿÕÇËǣǀCÿÿÿÿÿÿßÇ€.o…€DÿÿÿÿÿÿéÇßÇE2€EÿÿÿÿÿÿóÇéÇp„€FÿÿÿÿÿÿýÇóÇÞƒ€GÿÿÿÿÿÿÈ€.ä…€HÿÿÿÿÿÿÈÈ­$€IÿÿÿÿÿÿÈÈÍ‚€Jÿÿÿÿÿÿ%ÈÈ€Kÿÿÿÿÿÿ/È%ÈýÇ€Lÿÿÿÿÿÿ9ȉ…k€MÿÿÿÿÿÿCÈ9ÈÔ‡€NÿÿÿÿÿÿMÈCÈji€OÿÿÿÿÿÿWÈMȱ†€Pÿÿÿÿÿÿaȉш€QÿÿÿÿÿÿkÈaÈj€RÿÿÿÿÿÿuÈkÈô‚€SÿÿÿÿÿÿÈuÈ-€Tÿÿÿÿÿÿ‰ÈÈWÈ€Uÿÿÿÿÿÿ“ȼ‹âi€VÿÿÿÿÿÿÈ“ÈÆo€Wÿÿÿÿÿÿ§ÈÈgk€Xÿÿÿÿÿÿ±È§È±‰€Yÿÿÿÿÿÿ»È¼‹îˆ€ZÿÿÿÿÿÿÅÈ»Èfu€[ÿÿÿÿÿÿÏÈÅÈ j€\ÿÿÿÿÿÿÙÈÏÈT€]ÿÿÿÿÿÿãÈÙȱȀ^ÿÿÿÿÿÿíÈãȉȀ_ÿÿÿÿÿÿ÷ÈíÈ/È€`ÿÿÿÿÿÿÉ÷ÈÕÇ€aÿÿÿÿÿÿ ÉÉ{Ç€bÿÿÿÿÿÿÉ É!Ç€cÿÿÿÿÿÿÉÉ7Å€dÿÿÿÿÿÿ)ÉÉMÀeÿÿÿÿÿÿ3É)ÉcÁ€fÿÿÿÿÿÿ=É+k>|€gÿÿÿÿÿÿGÉ=É]4€hÿÿÿÿÿÿQÉGÉ |€iÿÿÿÿÿÿ[ÉQÉð{€jÿÿÿÿÿÿeÉ?€èh€kÿÿÿÿÿÿoÉeÉû€lÿÿÿÿÿÿyÉoÉÞ€mÿÿÿÿÿÿƒÉyÉ |€nÿÿÿÿÿÿÉát·ƒ€oÿÿÿÿÿÿ—ÉÉ5k€pÿÿÿÿÿÿ¡É—É€€qÿÿÿÿÿÿ«É¡Éòh€rÿÿÿÿÿÿµÉi‹†€sÿÿÿÿÿÿ¿ÉµÉʃ€tÿÿÿÿÿÿÉÉ¿É+€€uÿÿÿÿÿÿÓÉÉÉ?k€vÿÿÿÿÿÿÝɱ‰±†€wÿÿÿÿÿÿçÉÝÉÞƒ€xÿÿÿÿÿÿñÉçÉi€yÿÿÿÿÿÿûÉñÉd|€zÿÿÿÿÿÿÊûÉÓÉ€{ÿÿÿÿÿÿÊÊ«É€|ÿÿÿÿÿÿÊʃɀ}ÿÿÿÿÿÿ#ÊÊ[É€~ÿÿÿÿÿÿ-Ê.iIk€ÿÿÿÿÿÿ7Ê-Êä|€€ÿÿÿÿÿÿAÊ7ʽ|€ÿÿÿÿÿÿKÊAÊ |€‚ÿÿÿÿÿÿUÊ倾€€ƒÿÿÿÿÿÿ_ÊUʽ-€„ÿÿÿÿÿÿiÊ_Ê8i€…ÿÿÿÿÿÿsÊiÊÐ|€†ÿÿÿÿÿÿ}ÊôtS„€‡ÿÿÿÿÿÿ‡Ê}ÊBi€ˆÿÿÿÿÿÿ‘ʇʪ€€‰ÿÿÿÿÿÿ›Ê‘ÊSk€Šÿÿÿÿÿÿ¥ÊC‡&‡€‹ÿÿÿÿÿÿ¯Ê¥Ê]k€Œÿÿÿÿÿÿ¹Ê¯ÊÑ€€ÿÿÿÿÿÿÃʹÊVi€ŽÿÿÿÿÿÿÍÊgkji€ÿÿÿÿÿÿ×ÊÍÊp„€ÿÿÿÿÿÿáÊ×Êø€€‘ÿÿÿÿÿÿëÊáÊ}€’ÿÿÿÿÿÿõÊëÊÃÊ€“ÿÿÿÿÿÿÿÊõʛʀ”ÿÿÿÿÿÿ ËÿÊsÊ€•ÿÿÿÿÿÿË ËKÊ€–ÿÿÿÿÿÿËAo°}€—ÿÿÿÿÿÿ'ËË“}€˜ÿÿÿÿÿÿ1Ë'Ëti€™ÿÿÿÿÿÿ;Ë1ËY}€šÿÿÿÿÿÿEËTow€›ÿÿÿÿÿÿOËEË~i€œÿÿÿÿÿÿYËOËG€ÿÿÿÿÿÿcËYË}€žÿÿÿÿÿÿmˈiÁ\€ŸÿÿÿÿÿÿwËmË쀠ÿÿÿÿÿÿËwË]€¡ÿÿÿÿÿÿ‹ËËab€¢ÿÿÿÿÿÿ•Ëo’i€£ÿÿÿÿÿÿŸË•ËÀ„€¤ÿÿÿÿÿÿ©ËŸËŠ€¥ÿÿÿÿÿÿ³Ë©ËÃ}€¦ÿÿÿÿÿÿ½ËÆoÔ‡€§ÿÿÿÿÿÿÇ˽ËE2€¨ÿÿÿÿÿÿÑËÇËž€©ÿÿÿÿÿÿÛËÑËœi€ªÿÿÿÿÿÿåËÛ˳ˀ«ÿÿÿÿÿÿïËåË‹Ë€¬ÿÿÿÿÿÿùËïËcË€­ÿÿÿÿÿÿÌùË;Ë€®ÿÿÿÿÿÿ Ì}~°i€¯ÿÿÿÿÿÿÌ Ìqk€°ÿÿÿÿÿÿ!ÌÌ&~€±ÿÿÿÿÿÿ+Ì!Ì ~€²ÿÿÿÿÿÿ5ÌN‚'‚€³ÿÿÿÿÿÿ?Ì5Ì ‚€´ÿÿÿÿÿÿIÌ?Ì퀵ÿÿÿÿÿÿSÌIÌÄi€¶ÿÿÿÿÿÿ]Ì-uR…€·ÿÿÿÿÿÿgÌ]Ì5…€¸ÿÿÿÿÿÿqÌgÌÎi€¹ÿÿÿÿÿÿ{ÌqÌL~€ºÿÿÿÿÿÿ…Ì{k@ˆ€»ÿÿÿÿÿÿÌ…Ì-€¼ÿÿÿÿÿÿ™ÌÌ:‚€½ÿÿÿÿÿÿ£Ì™Ìi~€¾ÿÿÿÿÿÿ­Ìâi…k€¿ÿÿÿÿÿÿ·Ì­Ìo…€ÀÿÿÿÿÿÿÁÌ·Ìa‚€ÁÿÿÿÿÿÿËÌÁÌ~€ÂÿÿÿÿÿÿÕÌẸ̈̀ÃÿÿÿÿÿÿßÌÕÌ{Ì€ÄÿÿÿÿÿÿéÌßÌSÌ€ÅÿÿÿÿÿÿóÌéÌ+Ì€ÆÿÿÿÿÿÿýÌT-€ÇÿÿÿÿÿÿÍýÌ€ÈÿÿÿÿÿÿÍÍß~€ÉÿÿÿÿÿÿÍÍöi€Êÿÿÿÿÿÿ%Í jô‚€Ëÿÿÿÿÿÿ/Í%ÍÍ‚€Ìÿÿÿÿÿÿ9Í/Í°‚€ÍÿÿÿÿÿÿCÍ9Íò~€ÎÿÿÿÿÿÿMÍfuj€ÏÿÿÿÿÿÿWÍMÍ­$€ÐÿÿÿÿÿÿaÍWÍà‚€ÑÿÿÿÿÿÿkÍaÍ€ÒÿÿÿÿÿÿuÍîˆÑˆ€ÓÿÿÿÿÿÿÍuÍä…€Ôÿÿÿÿÿÿ‰ÍÍ(j€Õÿÿÿÿÿÿ“͉Í@€Öÿÿÿÿÿÿͼ‹‰€×ÿÿÿÿÿÿ§ÍÍ€.€Øÿÿÿÿÿÿ±Í§Íƒ€Ùÿÿÿÿÿÿ»Í±Íg€ÚÿÿÿÿÿÿÅͻ͓̀ÛÿÿÿÿÿÿÏÍÅÍkÍ€ÜÿÿÿÿÿÿÙÍÏÍCÍ€ÝÿÿÿÿÿÿãÍÙÍÍ€ÞÿÿÿÿÿÿíÍãÍóÌ€ßÿÿÿÿÿÿ÷ÍíÍÌ€àÿÿÿÿÿÿÎ÷ÍË€áÿÿÿÿÿÿ ÎÎ#ÊâÿÿÿÿÿÿÎ Î3Éy¿Q¿Y·1·µ´²k¯ÿ¬Ë©#¦›œšç–÷•GŒæ{>xôltlWl"k6ãÿÿÿÿÿÿ5Î ÙÙóØæØÙØÌؿزإؘ؋Ø~ØdØWØJØ=Ø0Ø#ØØ Øü×ï×â×Õ×È׻׮סהׇ×z×m×`×S×F×9×,××××øÖëÖÞÖÑÖªÖÖÖƒÖvÖiÖ\ÖOÖBÖ5Ö(ÖÖÖÖôÕçÕÚÕÍÕÀÕ³Õ¦Õ™ÕŒÕÕeÕKÕ1ÕÕäÚØÚÓËÚ¾Ú±Ú•ÚˆÚ{ÚnÚaÚ/ÑÑûÐáÐÇÐ3Ú&ÚÚØْϸÙPÏ/Ï«Ù³w wwzwgwTwAw.www›vˆvuvbvOv‹Jˆ?…÷~@ÿÿÿÿÿÿÒÆ‹Ûˆ·$º‚Ì~@ ÿÿÿÿÿÿ"Ò%zz·$ëyÎy@ ÿÿÿÿÿÿ/ÒÞzÁz¤z‡zjz@ ÿÿÿÿÿÿ<Ò—{z{]{@{#{@ ÿÿÿÿÿÿIÒðÔãÔÖÔÉÔVÒ@ ÿÿÿÿÿÿVÒµ¦˜¦{¦^¦A¦@ÿÿÿÿÿÿcÒ¼Ô¯Ô¢Ô•ÔpÒ@ÿÿÿÿÿÿpÒ@ª#ªªé©—@ÿÿÿÿÿÿ}ÒˆÔ{ÔnÔaÔŠÒ@ÿÿÿÿÿÿŠÒL­9­&­­A¦@ÿÿÿÿÿÿ—Òñ¹±¯±¥±i±_±U±K±±±û°ñ°µ°«°¡°—°3°°Ï¯¯@ÿÿÿÿÿÿ¸ÒTÔGÔ:Ô-ÔÅÒ@ÿÿÿÿÿÿÅÒm²Y²E²1²Rx@ÿÿÿÿÿÿÒÒ ÔÔÔùÓßÒ@ÿÿÿÿÿÿßÒ#{jzÎyy\x@ÿÿÿÿÿÿìÒìÓßÓÒÓÓùÒ@ÿÿÿÿÿÿùÒ²µ©µ µ—µ\x@ÿÿÿÿÿÿÓ¼‹@ˆì8ið{@ÿÿÿÿÿÿÓþµõµìµ2yãµ@ÿÿÿÿÿÿ ÓÓoÓNÓ-Ó@ÿÿÿÿÿÿ-Óy‹™¸¸…¸žS¸ˆI¸?¸© ¸¸kbù·OÇ·½·³·„€õœ·w·m·c·ú{@ÿÿÿÿÿÿNÓŒ‹)ººíŸºã¹#ˆÙ¹“ŸÏ¹¹“¹"]9Ÿ‰¹W¹M¹C¹—€9¹¹ý¸ó¸ž|@ÿÿÿÿÿÿoÓŠ.¹»×¡¯»¥»s»-}¡i»_»-»#»v»»ÝºÓºÓ Ç-ɺ—ººy ƒºg4@ÿÿÿÿÿÿÓ©‹Á£I½?½5½½Jˆù¼ï¼å¼³¼£Ë\©¼Ÿ¼m¼½¢c¼È€Y¼'¼c¢¼¼H|@ ÿÿÿÿÿÿ±ÓƋپϾž»¾[¥]ˆ‰¾¾u¾¥C¾9¾/¾§¤ý½ó½ï€é½M¤·½­½£½[|@!ÿÿÿÿÿÿÒÓJ¶A¶·$8¶/¶@"ÿÿÿÿÿÿßÓ–¶Áz¶„¶{¶@#ÿÿÿÿÿÿìÓ—{â¶Ù¶Ð¶Ç¶@$ÿÿÿÿÿÿùÓ@{‡zëy2yyx@%ÿÿÿÿÿÿÔ]{¤z·$Oy–x@&ÿÿÿÿÿÿÔz{Ázzly³x@'ÿÿÿÿÿÿ Ô—{Þz%z‰yÐx@(ÿÿÿÿÿÿ-Ôå²Ñ²½²(y©²@)ÿÿÿÿÿÿ:Ô]³I³­$5³!³@*ÿÿÿÿÿÿGÔÕ³·zÁ³­³™³@+ÿÿÿÿÿÿTÔ{M´9´%´´@,ÿÿÿÿÿÿaÔÀ­­­š­§‡­@-ÿÿÿÿÿÿnÔ4®!®Š.®û­@.ÿÿÿÿÿÿ{Ô¨®¦¨•®‚®o®@/ÿÿÿÿÿÿˆÔ|©¯ ¯ö®ã®@0ÿÿÿÿÿÿ•Ôܪ¿ª¢ªÛ—…ª@1ÿÿÿÿÿÿ¢Ôx«[«O2>«!«@2ÿÿÿÿÿÿ¯Ô¬ö˜÷«Ú«½«@3ÿÿÿÿÿÿ¼ÔÌ™°¬“¬v¬Y¬@4ÿÿÿÿÿÿÉÔn§Q§4§§ú¦@5ÿÿÿÿÿÿÖÔ ¨í§Š.Ч³§@6ÿÿÿÿÿÿãÔ覨‰¨l¨O¨@7ÿÿÿÿÿÿðÔ|©_©B©%©©@8ÿÿÿÿÿÿýÔXÕ>Õ$Õ Õ@9ÿÿÿÿÿÿ Õy‹ˆkb„€ú{@:ÿÿÿÿÿÿÕöi ~Y} |ð{@;ÿÿÿÿÿÿ$ÕŒ‹#ˆ"]—€|@<ÿÿÿÿÿÿ1Õd|?kòh |ð{@=ÿÿÿÿÿÿ>ÕŠ.-vÇ-g4@>ÿÿÿÿÿÿKÕß~&~ti½| |@?ÿÿÿÿÿÿXÕ©‹JˆË\È€H|@@ÿÿÿÿÿÿeÕi+€€Þ |@AÿÿÿÿÿÿrÕÆ‹]ˆï€[|@BÿÿÿÿÿÿÕqk“}ä|]4@CÿÿÿÿÿÿŒÕރʃ5kû]4@Dÿÿÿÿÿÿ™Õ-°i°}Ik>|@Eÿÿÿÿÿÿ¦Õ±†‹†·ƒèh>|@Fÿÿÿÿÿÿ³ÕT}~Ao.i+k@GÿÿÿÿÿÿÀÕ±‰iát?€+k@HÿÿÿÿÿÿÍÕò~Äi}Ð| |@IÿÿÿÿÿÿÚÕ}ViSkÐ| |@JÿÿÿÿÿÿçÕ°‚íG8iÞ@KÿÿÿÿÿÿôÕø€Ñ€ª€8i½|@LÿÿÿÿÿÿÖÍ‚ ‚~i½-û@MÿÿÿÿÿÿÖp„]kBi½-ä|@NÿÿÿÿÿÿÖô‚'‚w¾€èh@Oÿÿÿÿÿÿ(Öji&‡S„¾€Ik@Pÿÿÿÿÿÿ5Ö jN‚Toå€?€@QÿÿÿÿÿÿBÖgkC‡ôtå€.i@RÿÿÿÿÿÿOÖL~abSkòh@Sÿÿÿÿÿÿ\ÖœiÃ}ab}Y}@TÿÿÿÿÿÿiÖà‚Îi]ª€€@UÿÿÿÿÿÿvÖžŠ]Gti@VÿÿÿÿÿÿƒÖ­$5…ìBi5k@WÿÿÿÿÿÿÖE2À„ì~i“}@XÿÿÿÿÿÿÖjR…Á\S„·ƒ@YÿÿÿÿÿÿªÖÔ‡’iÁ\w°}@Zÿÿÿÿÿÿ·Öfu-uôtát@[ÿÿÿÿÿÿÄÖÆooToAo@\ÿÿÿÿÿÿÑÖ@i~Ã}Vi?k@]ÿÿÿÿÿÿÞÖ~i~L~Äi ~@^ÿÿÿÿÿÿëÖ(j:‚ŠÑ€+€@_ÿÿÿÿÿÿøÖa‚:‚Îií&~@`ÿÿÿÿÿÿ×ä…-À„]kʃ@aÿÿÿÿÿÿ×o…-5… ‚qk@bÿÿÿÿÿÿ×ш@ˆ’i&‡‹†@cÿÿÿÿÿÿ,×…k@ˆR…'‚°i@dÿÿÿÿÿÿ9×îˆ{koC‡i@eÿÿÿÿÿÿF×âi{k-uN‚}~@fÿÿÿÿÿÿS×g~œi}d|@gÿÿÿÿÿÿ`×g@ò~öi@hÿÿÿÿÿÿm׃a‚žø€i@iÿÿÿÿÿÿz׃(jà‚°‚ß~@jÿÿÿÿÿÿ‡×€.o…E2p„Þƒ@kÿÿÿÿÿÿ”×€.ä…­$Í‚@lÿÿÿÿÿÿ¡×‰…kÔ‡ji±†@mÿÿÿÿÿÿ®×‰Ñˆjô‚-@nÿÿÿÿÿÿ»×¼‹âiÆogk±‰@oÿÿÿÿÿÿÈ×¼‹îˆfu jT@pÿÿÿÿÿÿÕ×+k>|]4 |ð{@qÿÿÿÿÿÿâ×?€èhûÞ |@rÿÿÿÿÿÿï×át·ƒ5k€òh@sÿÿÿÿÿÿü×i‹†Êƒ+€?k@tÿÿÿÿÿÿ ر‰±†Þƒid|@uÿÿÿÿÿÿØ.iIkä|½| |@vÿÿÿÿÿÿ#Ø倾€½-8iÐ|@wÿÿÿÿÿÿ0ØôtS„Biª€Sk@xÿÿÿÿÿÿ=ØC‡&‡]kÑ€Vi@yÿÿÿÿÿÿJØgkjip„ø€}@zÿÿÿÿÿÿWØAo°}“}tiY}@{ÿÿÿÿÿÿdØTow~iG}@|ÿÿÿÿÿÿqØÁ\ì]ab@}ÿÿÿÿÿÿ~Øo’iÀ„ŠÃ}@~ÿÿÿÿÿÿ‹ØÆoÔ‡E2žœi@ÿÿÿÿÿÿ˜Ø}~°iqk&~ ~@€ÿÿÿÿÿÿ¥ØN‚'‚ ‚íÄi@ÿÿÿÿÿÿ²Ø-uR…5…ÎiL~@‚ÿÿÿÿÿÿ¿Ø{k@ˆ-:‚i~@ƒÿÿÿÿÿÿÌØâi…ko…a‚~@„ÿÿÿÿÿÿÙØT-ß~öi@…ÿÿÿÿÿÿæØ jô‚Í‚°‚ò~@†ÿÿÿÿÿÿóØfuj­$à‚@‡ÿÿÿÿÿÿÙîˆÑˆä…(j@@ˆÿÿÿÿÿÿ Ù¼‹‰€.ƒg@‰ÿÿÿÿÿÿÙTÙ…k{kÎiÄiqkœi’i~itigk]kSk8iIki?k5kèh+k@Šÿÿÿÿÿÿ7ÙTÙâi-ÎiÄi°iœi’i~itijiViBi8i.iiiòhèh]4@‹ÿÿÿÿÿÿTÙ€.(jj jöiŒÿÿÿÿÿÿaÙTÙâi-ÎiÄi°iœi’i~itijiViBi8i.iiiòhèh]4@ÿÿÿÿÿÿ}ÙaÙŽÿÿÿÿÿÿ†ÙTÙ…k{kÎiÄiqkœi’i~itigk]kSk8iIki?k5kèh+k@ÿÿÿÿÿÿ¢Ù†Ù@ÿÿÿÿÿÿ«Ù<Ò/Ò"Ò†Ð"Ï‘ÿÿÿÿÿÿ¸Ùø…î…Ñ…Ç…´…y…e…H…+……Ê„„T¶„¬„z„f„I„6„#„èƒÔƒ­ƒšƒ‡ƒ@’ÿÿÿÿÿÿØÙÏ‹²‹Ÿ‹•‹‚‹G‹4‹!‹‹ûŠÀŠ¶ŠO2™Š†ŠKŠ8Š%ŠŠÿ‰Ä‰§‰”‰‰n‰“ÿÿÿÿÿÿùÙ•u•k•a•W•%••••ý”Ë”Á”­”£”q”g”]”S”I”” ””ù“ï“@”ÿÿÿÿÿÿÚùÙDÐ#ÐÐáÏ@•ÿÿÿÿÿÿ&ÚÒÒûÑ<Ñ Ð@–ÿÿÿÿÿÿ3Ú"ÑÑîÐÔкÐ@—ÿÿÿÿÿÿ@ÚÆ‹«¥¡¥—¥¥[¥Q¥G¥=¥3¥¥÷¤vã¤Ù¤§¤¤“¤‰¤¤M¤C¤9¤/¤%¤@˜ÿÿÿÿÿÿaÚ@ڹјÑwÑVÑ@™ÿÿÿÿÿÿnÚðÔãÔÖÔÉÔVÒ@šÿÿÿÿÿÿ{Ú¼Ô¯Ô¢Ô•ÔpÒ@›ÿÿÿÿÿÿˆÚˆÔ{ÔnÔaÔŠÒœÿÿÿÿÿÿ•Úñ¹±¯±¥±i±_±U±K±±±û°ñ°µ°«°¡°—°3°°Ï¯¯@ÿÿÿÿÿÿ±ÚTÔGÔ:Ô-ÔÅÒ@žÿÿÿÿÿÿ¾Ú ÔÔÔùÓßÒ@ŸÿÿÿÿÿÿËÚìÓßÓÒÓÓùÒ ÿÿÿÿÿÿØÚÓoÓNÓ-Ó¡ÿÿÿÿÿÿäÚXÕ>Õ$Õ Õ5¢ÿÿÿÿÿÿðÚ ÙÙóØæØÙØÌؿزإؘ؋Ø~ØdØWØJØ=Ø0Ø#ØØ Øü×ï×â×Õ×È׻׮סהׇ×z×m×`×S×F×9×,××××øÖëÖÞÖÑÖªÖÖÖƒÖvÖiÖ\ÖOÖBÖ5Ö(ÖÖÖÖôÕçÕÚÕÍÕÀÕ³Õ¦Õ™ÕŒÕÕeÕKÕ1ÕÕäÚØÚÓËÚ¾Ú±Ú•ÚˆÚ{ÚnÚaÚ/ÑÑûÐáÐÇÐ3Ú&ÚÚØْϸÙPÏ/Ï«Ù³w wwzwgwTwAw.www›vˆvuvbvOvCHNSX[^addtruefalsenot==>andorxordistinctite=distinctite=distinctiteop1ope4e3e2e1e0R PBoolUIIIIIIII@<P sW_oR PBoolUIIIIIIII@<P PBoolUI P   .>3C(8H1 0 -2 0 127 0 132 0 217 0 247 0 273 0 279 0 316 0 346 0 376 0 402 0 531 0 553 0 559 0 689 0 714 0 740 0 765 0 791 0 817 0 -823 0 -824 0 -825 0 -826 0 -827 0 -828 0 -829 0 -830 0 -831 0 -832 0 -833 0 -834 0 -835 0 -836 0 -837 0 -838 0 -839 0 -840 0 -841 0 -842 0 -843 0 -13 0 -281 0 416 0 436 0 456 0 476 0 497 0 489 0 667 0 -692 0 -844 0 -845 0 -38 0 494 0 672 0 -697 0 -846 0 -847 0 -83 0 503 0 681 0 -706 0 -108 0 508 0 686 0 -711 0 -848 0 -849 0 -850 0 -851 0 -852 0 -853 0 -854 0 -855 0 -856 0 -857 0 -858 0 -859 0 -860 0 -861 0 -862 0 -863 0 -864 0 -865 0 -866 0 -867 0 -868 0 -869 0 -870 0 -871 0 -872 0 -873 0 -874 0 -875 0 -876 0 -877 0 -878 0 -879 0 -880 0 -881 0 -882 0 -883 0 -884 0 -885 0 -886 0 -887 0 -888 0 -889 0 -53 0 675 0 -700 0 -890 0 -891 0 -58 0 498 0 676 0 -701 0 -892 0 -893 0 -63 0 499 0 677 0 -702 0 -68 0 500 0 678 0 -703 0 -894 0 -895 0 -896 0 -897 0 -898 0 -899 0 -900 0 -901 0 -902 0 -903 0 -904 0 -905 0 -906 0 -907 0 -908 0 -909 0 -910 0 -911 0 -912 0 -913 0 -914 0 -123 0 477 0 652 0 -727 0 -124 0 -289 0 418 0 438 0 627 0 -752 0 -125 0 602 0 -778 0 -126 0 577 0 -804 0 -915 0 -916 0 -917 0 -918 0 -919 0 -920 0 14 0 650 0 -742 0 41 0 601 0 -749 0 57 0 567 0 802 0 3 4 5 6 7 0 8 9 10 11 12 0 14 15 13 16 17 0 18 19 20 21 22 0 23 24 25 26 27 0 28 29 30 31 32 0 33 34 35 36 37 0 39 40 38 41 42 0 43 44 45 46 47 0 48 49 50 51 52 0 54 55 53 56 57 0 59 60 58 61 62 0 64 65 63 66 67 0 69 70 68 71 72 0 73 74 75 76 77 0 78 79 80 81 82 0 84 85 83 86 87 0 88 89 90 91 92 0 93 94 95 96 97 0 98 99 100 101 102 0 103 104 105 106 107 0 109 110 108 111 112 0 113 114 115 116 117 0 118 119 120 121 122 0 3 8 13 18 23 0 3 28 53 73 98 0 4 9 14 19 24 0 4 29 54 74 99 0 5 10 15 20 25 0 5 30 55 75 100 0 6 11 16 21 26 0 6 31 56 76 101 0 7 12 17 22 27 0 7 32 57 77 102 0 28 33 38 43 48 0 8 33 58 78 103 0 29 34 39 44 49 0 9 34 59 79 104 0 30 35 40 45 50 0 10 35 60 80 105 0 31 36 41 46 51 0 11 36 61 81 106 0 32 37 42 47 52 0 12 37 62 82 107 0 54 59 64 69 123 0 14 39 84 109 123 0 55 60 65 70 124 0 15 40 85 110 124 0 56 61 66 71 125 0 16 41 86 111 125 0 57 62 67 72 126 0 17 42 87 112 126 0 73 78 83 88 93 0 18 43 63 88 113 0 74 79 84 89 94 0 19 44 64 89 114 0 75 80 85 90 95 0 20 45 65 90 115 0 76 81 86 91 96 0 21 46 66 91 116 0 77 82 87 92 97 0 22 47 67 92 117 0 98 103 108 113 118 0 23 48 68 93 118 0 99 104 109 114 119 0 24 49 69 94 119 0 100 105 110 115 120 0 25 50 70 95 120 0 101 106 111 116 121 0 26 51 71 96 121 0 102 107 112 117 122 0 27 52 72 97 122 0 128 129 130 131 0 -7 -131 0 -37 -131 0 -126 -131 0 -92 -131 0 -122 -131 0 7 37 92 122 126 131 0 -6 -130 0 -36 -130 0 -125 -130 0 -91 -130 0 -121 -130 0 6 36 91 121 125 130 0 -5 -129 0 -35 -129 0 -124 -129 0 -90 -129 0 -120 -129 0 5 35 90 120 124 129 0 -4 -128 0 -34 -128 0 -123 -128 0 -89 -128 0 -119 -128 0 4 34 89 119 123 128 0 133 134 135 136 0 -7 -136 0 -136 137 0 -136 138 0 -136 139 0 -136 140 0 -136 141 0 -37 -136 0 -136 142 0 -136 143 0 -136 144 0 -136 145 0 -136 146 0 -126 -136 0 -136 147 0 -136 148 0 -136 149 0 -136 150 0 -136 151 0 -92 -136 0 -136 152 0 -136 153 0 -136 154 0 -136 155 0 -136 156 0 -122 -136 0 7 37 92 122 126 136 -137 -138 -139 -140 -141 -142 -143 -144 -145 -146 -147 -148 -149 -150 -151 -152 -153 -154 -155 -156 0 117 156 0 97 156 0 -97 -117 -156 0 112 155 0 72 155 0 -72 -112 -155 0 107 154 0 52 154 0 -52 -107 -154 0 102 153 0 27 153 0 -27 -102 -153 0 97 152 0 117 152 0 -97 -117 -152 0 87 151 0 67 151 0 -67 -87 -151 0 82 150 0 47 150 0 -47 -82 -150 0 77 149 0 22 149 0 -22 -77 -149 0 72 148 0 112 148 0 -72 -112 -148 0 67 147 0 87 147 0 -67 -87 -147 0 62 146 0 42 146 0 -42 -62 -146 0 57 145 0 17 145 0 -17 -145 -57 0 52 144 0 107 144 0 -52 -107 -144 0 47 143 0 82 143 0 -47 -82 -143 0 42 142 0 62 142 0 -42 -62 -142 0 32 141 0 12 141 0 -12 -32 -141 0 27 140 0 102 140 0 -27 -102 -140 0 22 139 0 77 139 0 -22 -77 -139 0 17 138 0 57 138 0 -17 -138 -57 0 12 137 0 32 137 0 -12 -32 -137 0 -6 -135 0 -135 157 0 -135 158 0 -135 159 0 -135 160 0 -135 161 0 -36 -135 0 -135 162 0 -135 163 0 -135 164 0 -135 165 0 -135 166 0 -125 -135 0 -135 167 0 -135 168 0 -135 169 0 -135 170 0 -135 171 0 -91 -135 0 -135 172 0 -135 173 0 -135 174 0 -135 175 0 -135 176 0 -121 -135 0 6 36 91 121 125 135 -157 -158 -159 -160 -161 -162 -163 -164 -165 -166 -167 -168 -169 -170 -171 -172 -173 -174 -175 -176 0 116 176 0 96 176 0 -96 -116 -176 0 111 175 0 71 175 0 -71 -111 -175 0 106 174 0 51 174 0 -51 -106 -174 0 101 173 0 26 173 0 -26 -101 -173 0 96 172 0 116 172 0 -96 -116 -172 0 86 171 0 66 171 0 -66 -86 -171 0 81 170 0 46 170 0 -46 -81 -170 0 76 169 0 21 169 0 -21 -76 -169 0 71 168 0 111 168 0 -71 -111 -168 0 66 167 0 86 167 0 -66 -86 -167 0 61 166 0 41 166 0 -61 -166 -41 0 56 165 0 16 165 0 -16 -56 -165 0 51 164 0 106 164 0 -51 -106 -164 0 46 163 0 81 163 0 -46 -81 -163 0 41 162 0 61 162 0 -61 -162 -41 0 31 161 0 11 161 0 -11 -31 -161 0 26 160 0 101 160 0 -26 -101 -160 0 21 159 0 76 159 0 -21 -76 -159 0 16 158 0 56 158 0 -16 -56 -158 0 11 157 0 31 157 0 -11 -31 -157 0 -5 -134 0 -134 177 0 -134 178 0 -134 179 0 -134 180 0 -134 181 0 -35 -134 0 -134 182 0 -134 183 0 -134 184 0 -134 185 0 -134 186 0 -124 -134 0 -134 187 0 -134 188 0 -134 189 0 -134 190 0 -134 191 0 -90 -134 0 -134 192 0 -134 193 0 -134 194 0 -134 195 0 -134 196 0 -120 -134 0 5 35 90 120 124 134 -177 -178 -179 -180 -181 -182 -183 -184 -185 -186 -187 -188 -189 -190 -191 -192 -193 -194 -195 -196 0 115 196 0 95 196 0 -95 -115 -196 0 110 195 0 70 195 0 -70 -110 -195 0 105 194 0 50 194 0 -50 -105 -194 0 100 193 0 25 193 0 -25 -100 -193 0 95 192 0 115 192 0 -95 -115 -192 0 85 191 0 65 191 0 -65 -85 -191 0 80 190 0 45 190 0 -45 -80 -190 0 75 189 0 20 189 0 -20 -75 -189 0 70 188 0 110 188 0 -70 -110 -188 0 65 187 0 85 187 0 -65 -85 -187 0 60 186 0 40 186 0 -40 -60 -186 0 55 185 0 15 185 0 -15 -55 -185 0 50 184 0 105 184 0 -50 -105 -184 0 45 183 0 80 183 0 -45 -80 -183 0 40 182 0 60 182 0 -40 -60 -182 0 30 181 0 10 181 0 -10 -30 -181 0 25 180 0 100 180 0 -25 -100 -180 0 20 179 0 75 179 0 -20 -75 -179 0 15 178 0 55 178 0 -15 -55 -178 0 10 177 0 30 177 0 -10 -30 -177 0 -4 -133 0 -133 197 0 -133 198 0 -133 199 0 -133 200 0 -133 201 0 -34 -133 0 -133 202 0 -133 203 0 -133 204 0 -133 205 0 -133 206 0 -123 -133 0 -133 207 0 -133 208 0 -133 209 0 -133 210 0 -133 211 0 -89 -133 0 -133 212 0 -133 213 0 -133 214 0 -133 215 0 -133 216 0 -119 -133 0 4 34 89 119 123 133 -197 -198 -199 -200 -201 -202 -203 -204 -205 -206 -207 -208 -209 -210 -211 -212 -213 -214 -215 -216 0 114 216 0 94 216 0 -94 -114 -216 0 109 215 0 69 215 0 -69 -109 -215 0 104 214 0 49 214 0 -49 -104 -214 0 99 213 0 24 213 0 -24 -99 -213 0 94 212 0 114 212 0 -94 -114 -212 0 84 211 0 64 211 0 -64 -84 -211 0 79 210 0 44 210 0 -44 -79 -210 0 74 209 0 19 209 0 -19 -74 -209 0 69 208 0 109 208 0 -69 -109 -208 0 64 207 0 84 207 0 -64 -84 -207 0 59 206 0 39 206 0 -39 -59 -206 0 54 205 0 14 205 0 -54 -205 -14 0 49 204 0 104 204 0 -49 -104 -204 0 44 203 0 79 203 0 -44 -79 -203 0 39 202 0 59 202 0 -39 -59 -202 0 29 201 0 9 201 0 -9 -29 -201 0 24 200 0 99 200 0 -24 -99 -200 0 19 199 0 74 199 0 -19 -74 -199 0 14 198 0 54 198 0 -54 -198 -14 0 9 197 0 29 197 0 -9 -29 -197 0 3 34 91 122 124 0 218 219 220 221 222 0 -222 -223 0 -222 -224 0 -222 -225 0 -222 -226 0 -222 -227 0 222 223 224 225 226 227 0 -221 -228 0 -221 -229 0 -221 -230 0 -221 -231 0 -221 -232 0 221 228 229 230 231 232 0 -220 -233 0 -220 -234 0 -15 -220 0 -220 -235 0 -220 -236 0 15 220 233 234 235 236 0 -219 -237 0 -219 -238 0 -219 -239 0 -219 -240 0 -219 -241 0 219 237 238 239 240 241 0 -218 -242 0 -218 -243 0 -218 -244 0 -218 -245 0 -218 -246 0 218 242 243 244 245 246 0 248 249 250 251 252 0 -252 -253 0 -252 -254 0 -252 -255 0 -252 -256 0 -227 -252 0 227 252 253 254 255 256 0 -251 -257 0 -251 -258 0 -251 -259 0 -231 -251 0 -251 -260 0 231 251 257 258 259 260 0 -250 -261 0 -250 -262 0 -15 -250 0 -250 -263 0 -250 -264 0 15 250 261 262 263 264 0 -249 -265 0 -238 -249 0 -249 -266 0 -249 -267 0 -249 -268 0 238 249 265 266 267 268 0 -242 -248 0 -248 -269 0 -248 -270 0 -248 -271 0 -248 -272 0 242 248 269 270 271 272 0 274 275 276 277 278 0 223 -278 0 224 -278 0 225 -278 0 226 -278 0 227 -278 0 -223 -224 -225 -226 -227 278 0 228 -277 0 229 -277 0 230 -277 0 231 -277 0 232 -277 0 -228 -229 -230 -231 -232 277 0 233 -276 0 234 -276 0 15 -276 0 235 -276 0 236 -276 0 -15 -233 -234 -235 -236 276 0 237 -275 0 238 -275 0 239 -275 0 240 -275 0 241 -275 0 -237 -238 -239 -240 -241 275 0 242 -274 0 243 -274 0 244 -274 0 245 -274 0 246 -274 0 -242 -243 -244 -245 -246 274 0 280 282 281 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 0 122 -299 0 -299 300 0 -122 299 -300 0 -300 301 0 -122 -300 0 122 300 -301 0 -301 302 0 -92 -301 0 92 301 -302 0 -302 303 0 -126 -302 0 302 -303 126 0 -7 -303 0 -37 -303 0 7 37 303 0 117 -298 0 -298 304 0 -117 298 -304 0 -304 305 0 -121 -304 0 121 304 -305 0 -305 306 0 -91 -305 0 91 305 -306 0 -306 307 0 -125 -306 0 306 -307 125 0 -6 -307 0 -36 -307 0 6 36 307 0 112 -297 0 -297 308 0 -112 297 -308 0 -308 309 0 -120 -308 0 120 308 -309 0 -309 310 0 -90 -309 0 90 309 -310 0 -310 311 0 -124 -310 0 310 -311 124 0 -5 -311 0 -35 -311 0 5 35 311 0 107 -296 0 -296 312 0 -107 296 -312 0 -312 313 0 -119 -312 0 119 312 -313 0 -313 314 0 -89 -313 0 89 313 -314 0 -314 315 0 -123 -314 0 314 -315 123 0 -4 -315 0 -34 -315 0 4 34 315 0 96 -295 0 -295 300 0 -96 295 -300 0 91 -294 0 -294 304 0 -91 294 -304 0 86 -293 0 -293 308 0 -86 293 -308 0 81 -292 0 -292 312 0 -81 292 -312 0 70 -291 0 -291 300 0 -70 291 -300 0 65 -290 0 -290 304 0 -65 290 -304 0 -289 124 0 -289 308 0 -124 289 -308 0 60 -288 0 -288 312 0 -60 288 -312 0 49 -287 0 -287 300 0 -49 287 -300 0 44 -286 0 -286 304 0 -44 286 -304 0 39 -285 0 -285 308 0 -39 285 -308 0 34 -284 0 -284 312 0 -34 284 -312 0 23 -283 0 -283 300 0 -23 283 -300 0 18 -282 0 -282 304 0 -18 282 -304 0 -281 13 0 -281 308 0 -13 281 -308 0 8 -280 0 -280 312 0 -8 280 -312 0 317 318 319 320 321 0 -321 -322 0 -321 -323 0 -321 -324 0 -321 -325 0 -321 -326 0 321 322 323 324 325 326 0 -320 -327 0 -320 -328 0 -320 -329 0 -320 -330 0 -320 -331 0 320 327 328 329 330 331 0 -319 -332 0 -319 -333 0 -5 -319 0 -319 -334 0 -319 -335 0 5 319 332 333 334 335 0 -318 -336 0 -318 -337 0 -318 -338 0 -318 -339 0 -318 -340 0 318 336 337 338 339 340 0 -317 -341 0 -317 -342 0 -317 -343 0 -317 -344 0 -317 -345 0 317 341 342 343 344 345 0 347 348 349 350 351 0 -351 -352 0 -351 -353 0 -351 -354 0 -351 -355 0 -351 -356 0 351 352 353 354 355 356 0 -350 -357 0 -350 -358 0 -350 -359 0 -350 -360 0 -350 -361 0 350 357 358 359 360 361 0 -349 -362 0 -349 -363 0 -55 -349 0 -349 -364 0 -349 -365 0 55 349 362 363 364 365 0 -348 -366 0 -348 -367 0 -348 -368 0 -348 -369 0 -348 -370 0 348 366 367 368 369 370 0 -347 -371 0 -347 -372 0 -347 -373 0 -347 -374 0 -347 -375 0 347 371 372 373 374 375 0 377 378 379 380 381 0 -381 -382 0 -381 -383 0 -381 -384 0 -381 -385 0 -326 -381 0 326 381 382 383 384 385 0 -380 -386 0 -380 -387 0 -380 -388 0 -330 -380 0 -380 -389 0 330 380 386 387 388 389 0 -379 -390 0 -379 -391 0 -5 -379 0 -379 -392 0 -379 -393 0 5 379 390 391 392 393 0 -378 -394 0 -337 -378 0 -378 -395 0 -378 -396 0 -378 -397 0 337 378 394 395 396 397 0 -341 -377 0 -377 -398 0 -377 -399 0 -377 -400 0 -377 -401 0 341 377 398 399 400 401 0 403 404 405 406 407 0 -407 408 0 -407 409 0 -407 410 0 -407 411 0 140 -407 0 -407 412 0 -407 413 0 -407 414 0 -407 415 0 144 -407 0 -407 416 0 -407 417 0 -407 418 0 -407 419 0 148 -407 0 -407 420 0 -407 421 0 -407 422 0 -407 423 0 152 -407 0 -407 424 0 -407 425 0 -407 426 0 -407 427 0 -122 -407 0 122 -140 -144 -148 -152 407 -408 -409 -410 -411 -412 -413 -414 -415 -416 -417 -418 -419 -420 -421 -422 -423 -424 -425 -426 -427 0 117 427 0 96 427 0 -96 -117 -427 0 112 426 0 70 426 0 -70 -112 -426 0 107 425 0 49 425 0 -49 -107 -425 0 102 424 0 23 424 0 -23 -102 -424 0 92 423 0 91 423 0 -91 -92 -423 0 87 422 0 65 422 0 -65 -87 -422 0 82 421 0 44 421 0 -44 -82 -421 0 77 420 0 18 420 0 -18 -77 -420 0 67 419 0 86 419 0 -67 -86 -419 0 418 126 0 418 124 0 -124 -126 -418 0 62 417 0 39 417 0 -39 -62 -417 0 57 416 0 416 13 0 -13 -57 -416 0 47 415 0 81 415 0 -47 -81 -415 0 42 414 0 60 414 0 -42 -60 -414 0 37 413 0 34 413 0 -34 -37 -413 0 32 412 0 8 412 0 -8 -32 -412 0 22 411 0 76 411 0 -22 -76 -411 0 17 410 0 55 410 0 -17 -55 -410 0 12 409 0 29 409 0 -12 -29 -409 0 7 408 0 3 408 0 -3 -7 -408 0 -406 428 0 -406 429 0 -406 430 0 159 -406 0 -406 431 0 -406 432 0 -406 433 0 -406 434 0 163 -406 0 -406 435 0 -406 436 0 -406 437 0 -406 438 0 167 -406 0 -406 439 0 -406 440 0 -406 441 0 -406 442 0 -91 -406 0 -406 443 0 -406 444 0 -406 445 0 -406 446 0 176 -406 0 -406 447 0 91 -159 -163 -167 -176 406 -428 -429 -430 -431 -432 -433 -434 -435 -436 -437 -438 -439 -440 -441 -442 -443 -444 -445 -446 -447 0 121 447 0 122 447 0 -121 -122 -447 0 111 446 0 70 446 0 -70 -111 -446 0 106 445 0 49 445 0 -49 -106 -445 0 101 444 0 23 444 0 -23 -101 -444 0 96 443 0 117 443 0 -96 -117 -443 0 86 442 0 65 442 0 -65 -86 -442 0 81 441 0 44 441 0 -44 -81 -441 0 76 440 0 18 440 0 -18 -76 -440 0 71 439 0 112 439 0 -71 -112 -439 0 438 125 0 438 124 0 -124 -125 -438 0 61 437 0 39 437 0 -39 -61 -437 0 56 436 0 436 13 0 -13 -56 -436 0 51 435 0 107 435 0 -51 -107 -435 0 41 434 0 60 434 0 -60 -434 -41 0 36 433 0 34 433 0 -34 -36 -433 0 31 432 0 8 432 0 -8 -31 -432 0 26 431 0 102 431 0 -26 -102 -431 0 16 430 0 55 430 0 -16 -55 -430 0 11 429 0 29 429 0 -11 -29 -429 0 6 428 0 3 428 0 -3 -6 -428 0 -405 448 0 -405 449 0 178 -405 0 -405 450 0 -405 451 0 -405 452 0 -405 453 0 182 -405 0 -405 454 0 -405 455 0 -405 456 0 -405 457 0 -124 -405 0 -405 458 0 -405 459 0 -405 460 0 -405 461 0 191 -405 0 -405 462 0 -405 463 0 -405 464 0 -405 465 0 195 -405 0 -405 466 0 -405 467 0 -178 -182 124 -191 -195 405 -448 -449 -450 -451 -452 -453 -454 -455 -456 -457 -458 -459 -460 -461 -462 -463 -464 -465 -466 -467 0 120 467 0 122 467 0 -120 -122 -467 0 115 466 0 96 466 0 -96 -115 -466 0 105 465 0 49 465 0 -49 -105 -465 0 100 464 0 23 464 0 -23 -100 -464 0 95 463 0 117 463 0 -95 -117 -463 0 90 462 0 91 462 0 -90 -91 -462 0 80 461 0 44 461 0 -44 -80 -461 0 75 460 0 18 460 0 -18 -75 -460 0 70 459 0 112 459 0 -70 -112 -459 0 65 458 0 86 458 0 -65 -86 -458 0 60 457 0 39 457 0 -39 -60 -457 0 55 456 0 456 13 0 -13 -55 -456 0 50 455 0 107 455 0 -50 -107 -455 0 45 454 0 81 454 0 -45 -81 -454 0 35 453 0 34 453 0 -34 -35 -453 0 30 452 0 8 452 0 -8 -30 -452 0 25 451 0 102 451 0 -25 -102 -451 0 20 450 0 76 450 0 -20 -76 -450 0 10 449 0 29 449 0 -10 -29 -449 0 5 448 0 3 448 0 -3 -5 -448 0 -404 468 0 197 -404 0 -404 469 0 -404 470 0 -404 471 0 -404 472 0 -34 -404 0 -404 473 0 -404 474 0 -404 475 0 -404 476 0 206 -404 0 -404 477 0 -404 478 0 -404 479 0 -404 480 0 210 -404 0 -404 481 0 -404 482 0 -404 483 0 -404 484 0 214 -404 0 -404 485 0 -404 486 0 -404 487 0 34 -197 -206 -210 -214 404 -468 -469 -470 -471 -472 -473 -474 -475 -476 -477 -478 -479 -480 -481 -482 -483 -484 -485 -486 -487 0 119 487 0 122 487 0 -119 -122 -487 0 114 486 0 96 486 0 -96 -114 -486 0 109 485 0 70 485 0 -70 -109 -485 0 99 484 0 23 484 0 -23 -99 -484 0 94 483 0 117 483 0 -94 -117 -483 0 89 482 0 91 482 0 -89 -91 -482 0 84 481 0 65 481 0 -65 -84 -481 0 74 480 0 18 480 0 -18 -74 -480 0 69 479 0 112 479 0 -69 -112 -479 0 64 478 0 86 478 0 -64 -86 -478 0 477 123 0 477 124 0 -123 -124 -477 0 54 476 0 476 13 0 -13 -54 -476 0 49 475 0 107 475 0 -49 -107 -475 0 44 474 0 81 474 0 -44 -81 -474 0 39 473 0 60 473 0 -39 -60 -473 0 29 472 0 8 472 0 -8 -29 -472 0 24 471 0 102 471 0 -24 -102 -471 0 19 470 0 76 470 0 -19 -76 -470 0 14 469 0 55 469 0 -55 -469 -14 0 4 468 0 3 468 0 -3 -4 -468 0 -3 -403 0 -403 488 0 -403 489 0 -403 490 0 -403 491 0 -403 492 0 -403 493 0 -403 494 0 -403 495 0 -403 496 0 -403 497 0 -403 498 0 -124 -403 0 -403 499 0 -403 500 0 -403 501 0 -403 502 0 -403 503 0 -403 504 0 -403 505 0 -403 506 0 -403 507 0 -403 508 0 -403 509 0 -403 510 0 3 403 124 -488 -489 -490 -491 -492 -493 -494 -495 -496 -497 -498 -499 -500 -501 -502 -503 -504 -505 -506 -507 -508 -509 -510 0 118 510 0 122 510 0 -118 -122 -510 0 113 509 0 96 509 0 -96 -113 -509 0 508 108 0 70 508 0 -70 -108 -508 0 103 507 0 49 507 0 -49 -103 -507 0 98 506 0 23 506 0 -23 -98 -506 0 93 505 0 117 505 0 -93 -117 -505 0 88 504 0 91 504 0 -88 -91 -504 0 503 83 0 65 503 0 -65 -83 -503 0 78 502 0 44 502 0 -44 -78 -502 0 73 501 0 18 501 0 -18 -73 -501 0 500 68 0 112 500 0 -68 -112 -500 0 499 63 0 86 499 0 -63 -86 -499 0 498 58 0 39 498 0 -39 -58 -498 0 497 53 0 497 13 0 -13 -53 -497 0 48 496 0 107 496 0 -48 -107 -496 0 43 495 0 81 495 0 -43 -81 -495 0 494 38 0 60 494 0 -38 -60 -494 0 33 493 0 34 493 0 -33 -34 -493 0 28 492 0 8 492 0 -8 -28 -492 0 23 491 0 102 491 0 -23 -102 -491 0 18 490 0 76 490 0 -18 -76 -490 0 489 13 0 55 489 0 -13 -55 -489 0 8 488 0 29 488 0 -8 -29 -488 0 371 511 512 513 514 0 367 515 516 517 518 0 55 519 520 521 522 0 360 523 524 525 526 0 356 527 528 529 530 0 532 533 534 535 536 0 -536 -537 0 -536 -538 0 -536 -539 0 -536 -540 0 -356 -536 0 356 536 537 538 539 540 0 -535 -541 0 -535 -542 0 -535 -543 0 -360 -535 0 -535 -544 0 360 535 541 542 543 544 0 -3 -534 0 -29 -534 0 -55 -534 0 -76 -534 0 -102 -534 0 3 29 55 76 102 534 0 -533 -545 0 -367 -533 0 -533 -546 0 -533 -547 0 -533 -548 0 367 533 545 546 547 548 0 -371 -532 0 -532 -549 0 -532 -550 0 -532 -551 0 -532 -552 0 371 532 549 550 551 552 0 554 555 556 557 558 0 -98 -558 0 -104 -558 0 -110 -558 0 -116 -558 0 -122 -558 0 98 104 110 116 122 558 0 -73 -557 0 -79 -557 0 -85 -557 0 -91 -557 0 -97 -557 0 73 79 85 91 97 557 0 -53 -556 0 -59 -556 0 -124 -556 0 -66 -556 0 -72 -556 0 59 66 53 72 124 556 0 -28 -555 0 -34 -555 0 -40 -555 0 -46 -555 0 -52 -555 0 28 34 40 46 52 555 0 -3 -554 0 -9 -554 0 -15 -554 0 -21 -554 0 -27 -554 0 3 9 15 21 27 554 0 560 561 562 563 564 0 -564 565 0 -564 566 0 -564 567 0 -564 568 0 -564 569 0 -564 570 0 -564 571 0 -564 572 0 -564 573 0 -564 574 0 -564 575 0 -564 576 0 -564 577 0 -564 578 0 -564 579 0 -564 580 0 -564 581 0 -564 582 0 -564 583 0 -564 584 0 -564 585 0 -564 586 0 -564 587 0 -564 588 0 -564 589 0 564 -565 -566 -567 -568 -569 -570 -571 -572 -573 -574 -575 -576 -577 -578 -579 -580 -581 -582 -583 -584 -585 -586 -587 -588 -589 0 122 589 0 -122 589 0 117 588 0 -97 588 0 97 -117 -588 0 112 587 0 -72 587 0 72 -112 -587 0 107 586 0 -52 586 0 52 -107 -586 0 102 585 0 -27 585 0 27 -102 -585 0 97 584 0 -117 584 0 -97 117 -584 0 92 583 0 -92 583 0 87 582 0 -67 582 0 67 -87 -582 0 82 581 0 -47 581 0 47 -82 -581 0 77 580 0 -22 580 0 22 -77 -580 0 72 579 0 -112 579 0 -72 112 -579 0 67 578 0 -87 578 0 -67 87 -578 0 577 126 0 -126 577 0 62 576 0 -42 576 0 42 -62 -576 0 57 575 0 -17 575 0 17 -575 -57 0 52 574 0 -107 574 0 -52 107 -574 0 47 573 0 -82 573 0 -47 82 -573 0 42 572 0 -62 572 0 -42 62 -572 0 37 571 0 -37 571 0 32 570 0 -12 570 0 12 -32 -570 0 27 569 0 -102 569 0 -27 102 -569 0 22 568 0 -77 568 0 -22 77 -568 0 17 567 0 567 -57 0 -17 57 -567 0 12 566 0 -32 566 0 -12 32 -566 0 7 565 0 -7 565 0 -563 590 0 -563 591 0 -563 592 0 -563 593 0 -563 594 0 -563 595 0 -563 596 0 -563 597 0 -563 598 0 -563 599 0 -563 600 0 -563 601 0 -563 602 0 -563 603 0 -563 604 0 -563 605 0 -563 606 0 -563 607 0 -563 608 0 -563 609 0 -563 610 0 -563 611 0 -563 612 0 -563 613 0 -563 614 0 563 -590 -591 -592 -593 -594 -595 -596 -597 -598 -599 -600 -601 -602 -603 -604 -605 -606 -607 -608 -609 -610 -611 -612 -613 -614 0 121 614 0 -121 614 0 116 613 0 -96 613 0 96 -116 -613 0 111 612 0 -71 612 0 71 -111 -612 0 106 611 0 -51 611 0 51 -106 -611 0 101 610 0 -26 610 0 26 -101 -610 0 96 609 0 -116 609 0 -96 116 -609 0 91 608 0 -91 608 0 86 607 0 -66 607 0 66 -86 -607 0 81 606 0 -46 606 0 46 -81 -606 0 76 605 0 -21 605 0 21 -76 -605 0 71 604 0 -111 604 0 -71 111 -604 0 66 603 0 -86 603 0 -66 86 -603 0 602 125 0 -125 602 0 61 601 0 601 -41 0 41 -61 -601 0 56 600 0 -16 600 0 16 -56 -600 0 51 599 0 -106 599 0 -51 106 -599 0 46 598 0 -81 598 0 -46 81 -598 0 41 597 0 -61 597 0 61 -597 -41 0 36 596 0 -36 596 0 31 595 0 -11 595 0 11 -31 -595 0 26 594 0 -101 594 0 -26 101 -594 0 21 593 0 -76 593 0 -21 76 -593 0 16 592 0 -56 592 0 -16 56 -592 0 11 591 0 -31 591 0 -11 31 -591 0 6 590 0 -6 590 0 -562 615 0 -562 616 0 -562 617 0 -562 618 0 -562 619 0 -562 620 0 -562 621 0 -562 622 0 -562 623 0 -562 624 0 -562 625 0 -562 626 0 -562 627 0 -562 628 0 -562 629 0 -562 630 0 -562 631 0 -562 632 0 -562 633 0 -562 634 0 -562 635 0 -562 636 0 -562 637 0 -562 638 0 -562 639 0 562 -615 -616 -617 -618 -619 -620 -621 -622 -623 -624 -625 -626 -627 -628 -629 -630 -631 -632 -633 -634 -635 -636 -637 -638 -639 0 120 639 0 -120 639 0 115 638 0 -95 638 0 95 -115 -638 0 110 637 0 -70 637 0 70 -110 -637 0 105 636 0 -50 636 0 50 -105 -636 0 100 635 0 -25 635 0 25 -100 -635 0 95 634 0 -115 634 0 -95 115 -634 0 90 633 0 -90 633 0 85 632 0 -65 632 0 65 -85 -632 0 80 631 0 -45 631 0 45 -80 -631 0 75 630 0 -20 630 0 20 -75 -630 0 70 629 0 -110 629 0 -70 110 -629 0 65 628 0 -85 628 0 -65 85 -628 0 627 124 0 -124 627 0 60 626 0 -40 626 0 40 -60 -626 0 55 625 0 -15 625 0 15 -55 -625 0 50 624 0 -105 624 0 -50 105 -624 0 45 623 0 -80 623 0 -45 80 -623 0 40 622 0 -60 622 0 -40 60 -622 0 35 621 0 -35 621 0 30 620 0 -10 620 0 10 -30 -620 0 25 619 0 -100 619 0 -25 100 -619 0 20 618 0 -75 618 0 -20 75 -618 0 15 617 0 -55 617 0 -15 55 -617 0 10 616 0 -30 616 0 -10 30 -616 0 5 615 0 -5 615 0 -561 640 0 -561 641 0 -561 642 0 -561 643 0 -561 644 0 -561 645 0 -561 646 0 -561 647 0 -561 648 0 -561 649 0 -561 650 0 -561 651 0 -561 652 0 -561 653 0 -561 654 0 -561 655 0 -561 656 0 -561 657 0 -561 658 0 -561 659 0 -561 660 0 -561 661 0 -561 662 0 -561 663 0 -561 664 0 561 -640 -641 -642 -643 -644 -645 -646 -647 -648 -649 -650 -651 -652 -653 -654 -655 -656 -657 -658 -659 -660 -661 -662 -663 -664 0 119 664 0 -119 664 0 114 663 0 -94 663 0 94 -114 -663 0 109 662 0 -69 662 0 69 -109 -662 0 104 661 0 -49 661 0 49 -104 -661 0 99 660 0 -24 660 0 24 -99 -660 0 94 659 0 -114 659 0 -94 114 -659 0 89 658 0 -89 658 0 84 657 0 -64 657 0 64 -84 -657 0 79 656 0 -44 656 0 44 -79 -656 0 74 655 0 -19 655 0 19 -74 -655 0 69 654 0 -109 654 0 -69 109 -654 0 64 653 0 -84 653 0 -64 84 -653 0 652 123 0 -123 652 0 59 651 0 -39 651 0 39 -59 -651 0 54 650 0 650 -14 0 14 -54 -650 0 49 649 0 -104 649 0 -49 104 -649 0 44 648 0 -79 648 0 -44 79 -648 0 39 647 0 -59 647 0 -39 59 -647 0 34 646 0 -34 646 0 29 645 0 -9 645 0 9 -29 -645 0 24 644 0 -99 644 0 -24 99 -644 0 19 643 0 -74 643 0 -19 74 -643 0 14 642 0 -54 642 0 54 -642 -14 0 9 641 0 -29 641 0 -9 29 -641 0 4 640 0 -4 640 0 -560 665 0 -560 666 0 -560 667 0 -560 668 0 -560 669 0 -560 670 0 -560 671 0 -560 672 0 -560 673 0 -560 674 0 -560 675 0 -560 676 0 -560 677 0 -560 678 0 -560 679 0 -560 680 0 -560 681 0 -560 682 0 -560 683 0 -560 684 0 -560 685 0 -560 686 0 -560 687 0 -560 688 0 560 -665 -666 -667 -668 -669 -670 -671 -672 -673 -674 -675 -676 -677 -678 -679 -680 -681 -682 -683 -684 -685 -686 -687 -688 0 118 688 0 -118 688 0 113 687 0 -93 687 0 93 -113 -687 0 686 108 0 -68 686 0 -108 68 -686 0 103 685 0 -48 685 0 48 -103 -685 0 98 684 0 -23 684 0 23 -98 -684 0 93 683 0 -113 683 0 -93 113 -683 0 88 682 0 -88 682 0 681 83 0 -63 681 0 -83 63 -681 0 78 680 0 -43 680 0 43 -78 -680 0 73 679 0 -18 679 0 18 -73 -679 0 678 68 0 -108 678 0 -68 -678 108 0 677 63 0 -83 677 0 -63 -677 83 0 676 58 0 -38 676 0 -58 -676 38 0 675 53 0 -13 675 0 -53 -675 13 0 48 674 0 -103 674 0 -48 103 -674 0 43 673 0 -78 673 0 -43 78 -673 0 672 38 0 -58 672 0 -38 58 -672 0 33 671 0 -33 671 0 28 670 0 -8 670 0 8 -28 -670 0 23 669 0 -98 669 0 -23 98 -669 0 18 668 0 -73 668 0 -18 73 -668 0 667 13 0 -53 667 0 -13 53 -667 0 8 666 0 -28 666 0 -8 28 -666 0 3 665 0 -3 665 0 -55 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 0 118 -713 0 -102 -713 0 102 -118 713 0 113 -712 0 -101 -712 0 101 -113 712 0 -711 108 0 -100 -711 0 100 -108 711 0 103 -710 0 -99 -710 0 99 -103 710 0 98 -709 0 -98 -709 0 93 -708 0 -77 -708 0 77 -93 708 0 88 -707 0 -76 -707 0 76 -88 707 0 -706 83 0 -75 -706 0 75 -83 706 0 78 -705 0 -74 -705 0 74 -78 705 0 73 -704 0 -73 -704 0 -703 68 0 -703 -57 0 57 -68 703 0 -702 63 0 -56 -702 0 56 -63 702 0 -701 58 0 -54 -701 0 54 -58 701 0 -700 53 0 -53 -700 0 48 -699 0 -32 -699 0 32 -48 699 0 43 -698 0 -31 -698 0 31 -43 698 0 -697 38 0 -30 -697 0 30 -38 697 0 33 -696 0 -29 -696 0 29 -33 696 0 28 -695 0 -28 -695 0 23 -694 0 -7 -694 0 7 -23 694 0 18 -693 0 -6 -693 0 6 -18 693 0 -692 13 0 -5 -692 0 5 -13 692 0 8 -691 0 -4 -691 0 4 -8 691 0 3 -690 0 -3 -690 0 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 0 119 -739 0 -107 -739 0 107 -119 739 0 114 -738 0 -106 -738 0 106 -114 738 0 109 -737 0 -105 -737 0 105 -109 737 0 104 -736 0 -104 -736 0 99 -735 0 -103 -735 0 -99 103 735 0 94 -734 0 -82 -734 0 82 -94 734 0 89 -733 0 -81 -733 0 81 -89 733 0 84 -732 0 -80 -732 0 80 -84 732 0 79 -731 0 -79 -731 0 74 -730 0 -78 -730 0 -74 78 730 0 69 -729 0 -62 -729 0 62 -69 729 0 64 -728 0 -61 -728 0 61 -64 728 0 -727 123 0 -60 -727 0 60 -123 727 0 59 -726 0 -59 -726 0 54 -725 0 -58 -725 0 -54 725 58 0 49 -724 0 -37 -724 0 37 -49 724 0 44 -723 0 -36 -723 0 36 -44 723 0 39 -722 0 -35 -722 0 35 -39 722 0 34 -721 0 -34 -721 0 29 -720 0 -33 -720 0 -29 33 720 0 24 -719 0 -12 -719 0 12 -24 719 0 19 -718 0 -11 -718 0 11 -19 718 0 14 -717 0 -10 -717 0 10 717 -14 0 9 -716 0 -9 -716 0 4 -715 0 -8 -715 0 -4 8 715 0 741 743 742 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 0 120 -764 0 -112 -764 0 112 -120 764 0 115 -763 0 -111 -763 0 111 -115 763 0 110 -762 0 -110 -762 0 105 -761 0 -109 -761 0 -105 109 761 0 100 -760 0 -108 -760 0 -100 760 108 0 95 -759 0 -87 -759 0 87 -95 759 0 90 -758 0 -86 -758 0 86 -90 758 0 85 -757 0 -85 -757 0 80 -756 0 -84 -756 0 -80 84 756 0 75 -755 0 -83 -755 0 -75 755 83 0 70 -754 0 -126 -754 0 -70 754 126 0 65 -753 0 -125 -753 0 -65 753 125 0 -752 124 0 -124 -752 0 60 -751 0 -123 -751 0 -60 751 123 0 50 -750 0 -42 -750 0 42 -50 750 0 45 -749 0 -749 -41 0 41 -45 749 0 40 -748 0 -40 -748 0 35 -747 0 -39 -747 0 -35 39 747 0 30 -746 0 -38 -746 0 -30 746 38 0 25 -745 0 -17 -745 0 17 -25 745 0 20 -744 0 -16 -744 0 16 -20 744 0 15 -743 0 -15 -743 0 10 -742 0 -742 -14 0 -10 14 742 0 5 -741 0 -13 -741 0 -5 741 13 0 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 0 121 -790 0 -117 -790 0 117 -121 790 0 116 -789 0 -116 -789 0 111 -788 0 -115 -788 0 -111 115 788 0 106 -787 0 -114 -787 0 -106 114 787 0 101 -786 0 -113 -786 0 -101 113 786 0 96 -785 0 -92 -785 0 92 -96 785 0 91 -784 0 -91 -784 0 86 -783 0 -90 -783 0 -86 90 783 0 81 -782 0 -89 -782 0 -81 89 782 0 76 -781 0 -88 -781 0 -76 88 781 0 71 -780 0 -67 -780 0 67 -71 780 0 66 -779 0 -66 -779 0 -778 125 0 -65 -778 0 65 -125 778 0 61 -777 0 -64 -777 0 -61 64 777 0 56 -776 0 -63 -776 0 -56 776 63 0 51 -775 0 -47 -775 0 47 -51 775 0 46 -774 0 -46 -774 0 41 -773 0 -45 -773 0 45 773 -41 0 36 -772 0 -44 -772 0 -36 44 772 0 31 -771 0 -43 -771 0 -31 43 771 0 26 -770 0 -22 -770 0 22 -26 770 0 21 -769 0 -21 -769 0 16 -768 0 -20 -768 0 -16 20 768 0 11 -767 0 -19 -767 0 -11 19 767 0 6 -766 0 -18 -766 0 -6 18 766 0 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 0 122 -816 0 -122 -816 0 117 -815 0 -121 -815 0 -117 121 815 0 112 -814 0 -120 -814 0 -112 120 814 0 107 -813 0 -119 -813 0 -107 119 813 0 102 -812 0 -118 -812 0 -102 118 812 0 97 -811 0 -97 -811 0 92 -810 0 -96 -810 0 -92 96 810 0 87 -809 0 -95 -809 0 -87 95 809 0 82 -808 0 -94 -808 0 -82 94 808 0 77 -807 0 -93 -807 0 -77 93 807 0 72 -806 0 -72 -806 0 67 -805 0 -71 -805 0 -67 71 805 0 -804 126 0 -70 -804 0 70 -126 804 0 62 -803 0 -69 -803 0 -62 69 803 0 57 -802 0 -68 -802 0 802 -57 68 0 52 -801 0 -52 -801 0 47 -800 0 -51 -800 0 -47 51 800 0 42 -799 0 -50 -799 0 -42 50 799 0 37 -798 0 -49 -798 0 -37 49 798 0 32 -797 0 -48 -797 0 -32 48 797 0 27 -796 0 -27 -796 0 22 -795 0 -26 -795 0 -22 26 795 0 17 -794 0 -25 -794 0 -17 25 794 0 12 -793 0 -24 -793 0 -12 24 793 0 7 -792 0 -23 -792 0 -7 23 792 0 818 819 820 821 822 0 -272 -822 0 -268 -822 0 -264 -822 0 -260 -822 0 -227 -822 0 227 260 264 268 272 822 0 -271 -821 0 -267 -821 0 -263 -821 0 -231 -821 0 -256 -821 0 231 256 263 267 271 821 0 -270 -820 0 -266 -820 0 -15 -820 0 -259 -820 0 -255 -820 0 15 255 259 266 270 820 0 -269 -819 0 -238 -819 0 -262 -819 0 -258 -819 0 -254 -819 0 238 254 258 262 269 819 0 -242 -818 0 -265 -818 0 -261 -818 0 -257 -818 0 -253 -818 0 242 253 257 261 265 818 0 -5 -11 -18 -27 -29 -33 -47 -50 -59 -65 -71 -73 -80 -87 -91 -94 -101 -107 -110 -114 -118 0 -5 -11 -18 -27 -28 -35 -47 -49 -59 -65 -71 -74 -82 -85 -91 -93 -101 -103 -112 -114 -120 0 -300 -312 -304 299 -740 -134 0 opensmt-2.5.2/regression/state-dump/QG-classification_qg5_iso_brn644-split1.osmt2000066400000000000000000010450271445011647600277160ustar00rootroot00000000000000ñI¡õ¸õ ö}öŒö™¼‹‰€.ƒgîˆÑˆä…(j@fuj­$à‚ jô‚Í‚°‚ò~T-ß~öiâi…ko…a‚~{k@ˆ-:‚i~-uR…5…ÎiL~N‚'‚ ‚íÄi}~°iqk&~ ~ÆoÔ‡E2žœio’iÀ„ŠÃ}Tow~iG}Ao°}“}tiY}gkjip„ø€}C‡&‡]kÑ€ViôtS„Biª€Sk倾€½-8iÐ|.iIkä|½| |±‰±†Þƒid|i‹†Êƒ+€?kát·ƒ5k€òh?€èhûÞ |+k>|]4 |ð{Á\ì]abäÚXÕ>Õ$Õ ÕØÚÓoÓNÓ-Ó™¸¸…¸žS¸I¸?¸© ¸¸ù·OÇ·½·³·õœ·w·m·c·)ººíŸºã¹Ù¹“ŸÏ¹¹“¹9Ÿ‰¹W¹M¹C¹9¹¹ý¸ó¸ž¹»×¡¯»¥»s»}¡i»_»-»#»»»ÝºÓºÓ Éº—ººy ƒºÁ£I½?½5½½ù¼ï¼å¼³¼£©¼Ÿ¼m¼½¢c¼Y¼'¼c¢¼¼ËÚìÓßÓÒÓÓùÒm²Y²E²1²Rxå²Ñ²½²(y©²]³I³5³!³Õ³·zÁ³­³™³{M´9´%´´¾Ú ÔÔÔùÓßÒ{`zÄy y6{}záyoxS{šzEyŒxp{þyby©xÔzzyÆx±ÚTÔGÔ:Ô-ÔÅÒ•Úñ¹±¯±¥±i±_±U±K±±±û°ñ°µ°«°¡°—°3°°Ï¯¯“¯‰¯¯u¯Å¯»¯±¯§¯÷¯í¯ã¯Ù¯)°°° °ˆÚˆÔ{ÔnÔaÔŠÒB­/­­ ­7¦¶­£­­ §}­*®®®ñ­ž®œ¨‹®x®e®r©¯ÿ®ì®Ù®{Ú¼Ô¯Ô¢Ô•ÔpÒ6ªªü©ß©û–Òªµª˜ªÑ—{ªn«Q«4«« ¬ì˜í«Ð«³«Â™¦¬‰¬l¬O¬nÚðÔãÔÖÔÉÔVÒ«¦Ž¦q¦T¦d§G§*§ð¦¨ã§Æ§©§¹¨¨b¨E¨U©8©©þ¨aÚ@ڹјÑwÑVÑ+ž!žž žÑǽ³wmcY ÿœÃœ¹œ¯œ¥œ   ÷ŸãŸ±Ÿ§ŸŸ‰ŸWŸMŸCŸ/Ÿýžóžéžßž­ž£ž™ž…žë¡á¡Í¡Ã¡‘¡‡¡s¡i¡7¡-¡#¡¡ç Ý É ¿  ƒ o e Ë£·£­£££q£g£]£S£!£ ££ù¢Ç¢³¢©¢Ÿ¢m¢Y¢O¢E¢«¥¡¥—¥¥[¥Q¥G¥=¥3¥¥÷¤ã¤Ù¤§¤¤“¤‰¤¤M¤C¤9¤/¤%¤Kœ7œ#œœÓ›¿›«›—›[›G›3››ãšÏš»š§škšWšCš/š3Ú"ÑÑîÐÔкÐo—R—5——(˜ ˜î—´— ™Ï˜²˜•˜¥™ˆ™k™N™&ÚÒÒûÑ<Ñ ÐÚùÙDÐ#ÐÐáÏá×Íù‡}si_-#ӌɌ¿ŒµŒ«ŒyŒoŒeŒ[ŒQŒËÁ·­£qg]SI ùŽïŽ½Ž³Ž©ŽŸŽ•ŽcŽYŽOŽEŽ;Ž«‘¡‘—‘‘ƒ‘Q‘G‘=‘3‘)‘÷íÊJãÙ§“‰MC9/%•“‹““w“m“;“1“'“““á’×’Í’Ã’¹’‡’}’s’i’_’-’#’’’’•u•k•a•W•%••••ý”Ë”Á”­”£”q”g”]”S”I”” ””ù“ï“ØÙÏ‹²‹Ÿ‹•‹‚‹G‹4‹!‹‹ûŠÀŠ¶Š™Š†ŠKŠ8Š%ŠŠÿ‰Ä‰§‰”‰‰n‰’Ï ‰äˆÇˆ´ˆ¡ˆfˆSˆ6ˆ,ˆˆÞ‡Ê‡·‡¤‡‘‡V‡9‡‡ ‡ö†»†ž††n†[†¸Ùø…î…Ñ…Ç…´…y…e…H…+……Ê„„T¶„¬„z„f„I„6„#„èƒÔƒ­ƒšƒ‡ƒPÏ$ƒƒê‚¦‚k‚D‚‚‚㨔mZ=Û€´€ €€R€5€€ñÔ/ÏqJ#ü~Õ~š~s~V~9~~×}Í}¦}‰}l}'} }÷|Ú|³|n|Q|4|*||«Ù<Ò/Ò"Ò†Ð"Ï©w–wƒwpw]wJw7w$wwþv‘v~vkvXvEv2vv vùuæuyuSu@uuuÎtatNt;t(tttïsÜsÉs¶sIs6s#ssýrêr×rÄr±ržr röqãqÐq½qªq—q„qqq^qñpÞpËp¸p¥p’pplpYpFpÙo³o ozogo.oÁn®n›nˆnunbnOnHR\fpz„Ž˜¢¬¶ÀÊÔÞèòü$.8BLV`jt~ˆ’œ¦°ºÄÎØâìö (2<FPZdnx‚Œ– ª´¾ÈÒÜæðú",6@JT^hr|†š¤®¸ÂÌÖàêôþ&0:DNXblv€Š”ž¨²¼ÆÐÚäîø  * 4 > H R \ f p z „ Ž ˜ ¢ ¬ ¶ À Ê Ô Þ è ò ü    $ . 8 B L V ` j t ~ ˆ ’ œ ¦ ° º Ä Î Ø â ì ö   ( 2 < F P Z d n x ‚ Œ –   ª ´ ¾ È Ò Ü æ ð ú    " , 6 @ J T ^ h r | † š ¤ ® ¸ Â Ì Ö à ê ô þ    & 0 : D N X b l v € Š ” ž ¨ ² ¼ Æ Ð Ú ä î ø   *4>HR\fpz„Ž˜¢¬¶ÀÊÔÞèòü$.8BLV`jt~ˆ’œ¦°ºÄÎØâìö (2<FPZdnx‚Œ– ª´¾ÈÒÜæðú",6@JT^hr|†š¤®¸ÂÌÖàêôþ&0:DNXblv€Š”ž¨²¼ÆÐÚäîø  *4>HR\fpz„Ž˜¢¬¶ÀÊÔÞèòü$.8BLV`jt~ˆ’œ¦¯¸ÂËÕÞèñû  *3=FPZclv‰’œ¥¯¹ÂËÕÞèñû!*4=GPZcmw€‰’›¤­¶¿ÈÑÚãìõþ"+4=FOXajs|…Ž— ©²»ÄÍÖßèñú '09BKT]foxŠ“œ¥®·ÀÉÒÛäíöÿ#,5>GPYbkt}†˜¡ª³¼ÅÎ×àéòû#-7AKU_is}‡‘›¥¯¹ÃÍ×áëõÿ '1;EOYcmw‹•Ÿ©³½ÇÑÛåïù !+5?IS]gq{…™£­·ÁËÕßéóý%/9CMWaku‰“§±»ÅÏÙãí÷ )3=GQ[eoyƒ—¡«µ¿ÉÓÝçñû#-7AKU_is}‡‘›¥¯¹ÃÍ×áëõÿ   ' 1 ; E O Y c m w ‹ • Ÿ © ³ ½ Ç Ñ Û å ï ù ! !!!!+!5!?!I!S!]!g!q!{!…!!™!£!­!·!Á!Ë!Õ!ß!é!ó!ý!"""%"/"9"C"M"W"a"k"u""‰"“""§"±"»"Å"Ï"Ù"ã"í"÷"# ###'#1#;#D#N#X#b#k#u##‰#’#œ#¦#°#¹#Ã#Í#Ö#à#ê#ô#ý#$$$$$.$8$B$K$U$_$i$s$|$†$$™$£$­$·$À$Ê$Ô$Þ$ç$ñ$û$%%%"%,%6%?%I%S%\%f%p%z%ƒ%%—%¡%ª%´%¾%È%Ñ%Û%å%ï%ù%& &&&)&3&=&F&P&Z&d&m&w&&‹&”&ž&¨&²&¼&Å&Ï&Ù&ã&ì&ö&' '''''1':'D'N'X'a'k'u''ˆ'’'œ'¦'¯'¹'Ã'Í'Ö'à'ê'ô'þ'((($(.(8(B(L(U(_(i(s(|(†((š(¤(­(·(Á(Ê(Ô(Þ(è(ñ(û()))"),)6)@)J)S)])g)p)z)„)Ž)—)¡)«)µ)¾)È)Ò)Ü)æ)ð)ú)***"*,*6*@*J*T*^*h*r*|*†**š*¤*®*¸*Â*Ì*Ö*à*ê*ô*þ*+++&+0+:+D+N+X+b+l+v+€+Š+”+ž+¨+²+¼+Æ+Ð+Ú+ä+î+ø+, ,, ,*,4,>,H,R,\,f,p,z,„,Ž,˜,¢,¬,¶,À,Ê,Ó,Ý,ç,ð,ú,---!-+-5->-H-R-\-e-o-y-ƒ-Œ-–- -©-³-½-Ç-Ð-Ú-ä-î-÷-. ...(.2.<.F.O.Y.c.l.v.€.Š.“..§.±.º.Ä.Î.Ø.á.ë.õ.ÿ. ///&///9/C/M/V/`/j/t/}/‡/‘/›/¤/®/¸/Â/Ì/Õ/ß/é/ò/ü/000#0-070@0J0T0^0g0q0{0…00˜0¢0¬0µ0¿0É0Ó0Ü0æ0ð0ú01 11!1*141>1H1Q1[1e1n1x1‚1Œ1•1Ÿ1©1³1¼1Æ1Ð1Ú1ã1í1÷12 222(212;2E2O2X2b2l2v22‰2“22¦2°2º2Ä2Î2×2á2ë2ô2þ2333%3/393B3L3V3`3i3s3}3‡3‘3š3¤3®3·3Á3Ë3Õ3Þ3è3ò3ü3444#4,464@4J4S4]4g4p4z4„44—4¡4ª4´4¾4Ç4Ñ4Û4ä4î4ø45 555(525<5E5O5X5b5l5v55‰5“5œ5¦5°5º5Ã5Í5Ö5à5ê5ó5ý5666$6.686A6K6T6^6h6q6{6…6Ž6˜6¢6¬6¶6À6Ê6Ô6Þ6è6ò6ü6777$7.787B7L7V7`7j7t7~7ˆ7’7œ7¦7°7º7Ä7Î7Ø7â7ì7ö78 888(828<8F8P8Z8d8n8x8‚8Œ8–8 8ª8´8¾8È8Ò8Ü8æ8ð8ú8999"9,969@9J9T9^9h9r9|9†99š9¤9®9¸9Â9Ì9Ö9à9ê9ô9þ9:::&:0:::D:N:X:b:l:v:€:Š:”:ž:¨:²:¼:Æ:Ð:Ú:ä:î:ø:; ;; ;*;4;>;H;R;\;f;p;z;„;Ž;˜;¢;¬;¶;À;Ê;Ô;Þ;è;ò;ü;<<<$<.<8<B<L<V<`<j<t<~<ˆ<’<œ<¦<°<º<Ä<Î<Ø<â<ì<ö<= ===(=2=<=F=P=Z=d=n=x=‚=Œ=–= =ª=´=¾=È=Ò=Ü=æ=ð=ú=>>>">,>6>@>J>T>^>h>r>|>†>>š>¤>®>¸>Â>Ì>Ö>à>ê>ô>þ>???&?0?:?D?N?X?b?l?v?€?Š?”?ž?¨?²?¼?Æ?Ð?Ú?ä?î?ø?@ @@ @*@4@>@H@R@\@f@p@z@„@Ž@˜@¢@¬@¶@À@Ê@Ô@Þ@è@ò@ü@AAA$A.A8ABALAVA`AjAtA~AˆA’AœA¦A°AºAÄAÎAØAâAìAöAB BBB'B0B:BDBNBWBaBkBuB~BˆB’BœB¥B¯B¹BÃBÌBÖBàBêBóBýBCCC$C.C8CBCKCUC_ChCrC|C†CC™C£C­C·CÀCÊCÔCÞCèCñCûCDDD"D,D5D?DIDSD]DfDpDzD„DŽD—D¡D«D´D¾DÈDÒDÛDåDïDùDE EE E*E4E>EHERE\EfEpEzE„EŽE˜E¢E¬E¶EÀEÊEÔEÞEèEòEüEFFF$F.F8FBFLFVF`FjFtF~FˆF’FœF¦F°FºFÄFÎFØFâFìFöFG GGG(G2GJHJRJ\JfJpJzJ„JŽJ˜J¢J¬J¶JÀJÊJÔJÞJèJòJüJKKK$K.K8KBKLKVK`KjKtK~KˆK’KœK¦K°KºKÄKÎKØKâKìKöKL LLL(L2LOHORO\OfOpOzO„OŽO˜O¢O¬O¶OÀOÊOÔOÞOèOòOüOPPP$P.P8PBPLPVP`PjPtP~PˆP’PœP¦P°PºPÄPÎPØPâPìPöPQ QQQ(Q2QTHTRT\TfTpTzT„TŽT˜T¢T¬T¶TÀTÊTÔTÞTèTòTüTUUU$U.U8UBULUVU`UjUtU~UˆU’UœU¦U°UºUÄUÎUØUâUìUöUV VVV(V2VYHYRY\YfYpYzY„YŽY˜Y¢Y¬Y¶YÀYÊYÔYÞYèYòYüYZZZ$Z.Z8ZBZLZVZ`ZjZtZ~Z‡Z‘ZšZ¤Z®Z·ZÁZËZÔZÞZèZñZûZ[[["[+[5[?[H[R[\[e[o[y[‚[Œ[–[Ÿ[©[²[¼[Æ[Ï[Ù[ã[ì[ö[\ \\\&\0\:\C\M\W\`\j\t\}\‡\‘\š\¤\®\¸\Á\Ë\Ô\Þ\è\ñ\û\]]]"]+]5]?]H]R]\]e]o]y]‚]Œ]–]Ÿ]©]³]¼]Æ]Ð]Ú]ã]í]ö]^ ^^^'^0^:^D^M^W^a^j^t^~^‡^‘^›^¤^®^¸^Á^Ë^Õ^Þ^è^ò^ü^___"_,_5_?_I_R_\_f_o_y_ƒ_Œ_–_ _©_³_½_Æ_Ð_Ú_ã_í_÷_` ```'`1`:`D`N`W`a`k`t`~`ˆ`‘`›`¥`®`¸`Â`Ë`Õ`ß`è`ò`ü`aaa"a,a6a?aIaRa\afaoayaƒaŒa–a a©a³a½aÆaÐaÚaãaía÷ab bbb'b1b:bDbNbXbabkbtb~bˆb‘b›b¥b®b¸bÂbËbÕbßbèbòbübccc"c,c6c?cIcSc\cfcpczcƒcc–c cªc³c½cÇcÐcÚcäcíc÷cd ddd'd1d;dDdNdXdadkdud~dˆd’dœd¥d¯d¸dÂdÌdÕdßdédòdüdeee#e,e6e@eIeSe]efepezeƒee—e eªe´e¾eÈeÑeÛeäeîeøef fff(f2f;fEfOfXfbflfuff‰f’fœf¦f¯f¹fÃfÌfÖfàfêfôfþfggg&g0g:gDgNgXgbglgvg€gŠg”gžg¨g²g¼gÆgÐgÚgägíg÷gh hhh)h3h=hGhQh[hehohyhƒhh—h¡h«hµh¾hÞhèhòhühiii$i.i8iBiLiVi`ijiti~iˆi’iœi¦i°iºiÄiÎiØiâiìiöij jjj(j2jxHxRx\xexoxyx‚xŒx–xŸx©x³x¼xÆxÐxÙxãxíx÷xy yyy(y2y;yEyOyXybylyuyy‰y’yœy¦y°yºyÄyÎy×yáyëyôyþyzzz%z.z8zBzLzVz`zjzsz}z‡zzšz¤z­z·zÁzÊzÔzÞzçzñzûz{{{#{,{6{@{I{S{]{f{p{z{ƒ{{—{ {ª{´{¾{È{Ò{Ü{æ{ð{ú{| || |*|4|>|H|Q|[|d|n|x|‚|Œ|–| |ª|³|½|Ç|Ð|Ú|ä|î|÷|} }}}'}1};}E}O}Y}c}l}v}}‰}“}}¦}°}º}Ã}Í}×}á}ë}õ}ÿ} ~~~&~0~9~C~L~V~`~i~s~}~‡~~š~¤~®~¸~Â~Ì~Õ~ß~é~ò~ü~#-7@JT^gq{…™£­·ÁËÔÞèñû€€€"€+€5€?€I€R€\€f€p€z€„€€—€ €ª€´€¾€È€Ñ€Û€å€ï€ø€  *4=GQZdmwŠ”ž¨²¼ÆÐÚãí÷‚ ‚‚‚'‚1‚:‚D‚N‚X‚a‚k‚u‚‚‰‚“‚‚¦‚°‚º‚Âׂ͂à‚ê‚ô‚þ‚ƒƒƒ$ƒ.ƒ8ƒBƒLƒVƒ`ƒjƒtƒ~ƒ‡ƒ‘ƒšƒ¤ƒ­ƒ·ƒÁƒÊƒÔƒÞƒèƒòƒüƒ„„„#„-„6„@„I„S„]„f„p„z„„„Ž„˜„¢„¬„¶„À„Ê„Ô„Ý„ç„ñ„û„………"…+…5…?…H…R…\…e…o…y…ƒ……—…¡…«…´…¾…Ç…Ñ…Û…ä…î…ø…† †† †*†4†>†H†R†[†e†n†x††‹†•†ž†¨†±†»†Å†Ï†Ù†ã†í†ö†‡ ‡‡‡&‡0‡9‡C‡M‡V‡`‡j‡t‡~‡ˆ‡‘‡›‡¤‡®‡·‡Á‡Ê‡Ô‡Þ‡è‡ò‡ü‡ˆˆˆ#ˆ,ˆ6ˆ@ˆJˆSˆ]ˆfˆpˆzˆ„ˆŽˆ˜ˆ¡ˆ«ˆ´ˆ¾ˆÇˆÑˆÛˆäˆîˆøˆ‰ ‰‰‰)‰3‰=‰G‰Q‰[‰e‰n‰x‰‰‹‰”‰ž‰§‰±‰»‰Ä‰Î‰Ø‰â‰ì‰ö‰ÿ‰ ŠŠŠ%Š/Š8ŠBŠKŠUŠ_ŠiŠsŠ}Š†ŠŠ™Š£Š­Š¶ŠÀŠÊŠÔŠÞŠèŠòŠûŠ‹‹‹!‹+‹4‹>‹G‹Q‹[‹e‹o‹y‹‚‹Œ‹•‹Ÿ‹©‹²‹¼‹Æ‹Ï‹Ù‹ã‹í‹÷‹Œ ŒŒŒ)Œ3Œ=ŒGŒQŒ[ŒeŒoŒyŒƒŒŒ—Œ¡Œ«ŒµŒ¿ŒÉŒÓŒÝŒçŒñŒûŒ#-7AKU_is}‡‘›¥¯¹ÃÍ×áëõÿ ŽŽŽ'Ž1Ž;ŽEŽOŽYŽcŽmŽwŽŽ‹Ž•ŽŸŽ©Ž³Ž½ŽÇŽÑŽÛŽåŽïŽùŽ !+5?IS]gq{…™£­·ÁËÕßéóý%/9CMWaku‰“§±»ÅÏÙãí÷‘ ‘‘‘)‘3‘=‘G‘Q‘[‘e‘o‘y‘ƒ‘‘—‘¡‘«‘µ‘¿‘É‘Ó‘Ý‘ç‘ñ‘û‘’’’#’-’7’A’K’U’_’i’s’}’‡’‘’›’¥’¯’¹’Ã’Í’×’á’ë’õ’ÿ’ “““'“1“;“E“O“Y“c“m“w““‹“•“Ÿ“©“³“½“Ç“Ñ“Û“å“ï“ù“” ””!”+”5”?”I”S”]”g”q”{”…””™”£”­”·”Á”˔Քߔé”ó”ý”•••%•/•9•C•M•W•a•k•u••‰•“••§•±•»•Å•Ï•Ù•ã•í•÷•– –––)–3–=–G–Q–[–e–o–y–ƒ––—–¡–«–µ–¿–É–Ó–Ý–ç–ñ–û–———"—+—5—?—H—R—\—e—o—y—‚—Œ—–— —ª—´—¾—Ç—Ñ—Û—ä—î—ø—˜ ˜˜˜(˜2˜;˜E˜O˜Y˜c˜m˜w˜˜‹˜•˜Ÿ˜¨˜²˜¼˜Å˜Ï˜Ù˜â˜ì˜ö˜ÿ˜ ™™™&™0™:™D™N™X™a™k™u™~™ˆ™’™›™¥™¯™¸™Â™Ì™Õ™ß™é™ó™ý™ššš%š/š9šCšMšWšaškšušš‰š“šš§š±š»šÅšÏšÙšãšíš÷š› ›››)›3›=›G›Q›[›e›o›y›ƒ››—›¡›«›µ›¿›É›Ó›Ý›ç›ñ›û›œœœ#œ-œ7œAœKœUœ_œiœsœ}œ‡œ‘œ›œ¥œ¯œ¹œÃœÍœ×œáœëœõœÿœ '1;EOYcmw‹•Ÿ©³½ÇÑÛåïùž žž!ž+ž5ž?žIžSž]žgžqž{ž…žž™ž£ž­ž·žÁžËžÕžßžéžóžýžŸŸŸ%Ÿ/Ÿ9ŸCŸMŸWŸaŸkŸuŸŸ‰Ÿ“ŸŸ§Ÿ±Ÿ»ŸÅŸÏŸÙŸãŸíŸ÷Ÿ     ) 3 = G Q [ e o y ƒ  — ¡ « µ ¿ É Ó Ý ç ñ û ¡¡¡#¡-¡7¡A¡K¡U¡_¡i¡s¡}¡‡¡‘¡›¡¥¡¯¡¹¡Ã¡Í¡×¡á¡ë¡õ¡ÿ¡ ¢¢¢'¢1¢;¢E¢O¢Y¢c¢m¢w¢¢‹¢•¢Ÿ¢©¢³¢½¢Ç¢Ñ¢Û¢å¢ï¢ù¢£ ££!£+£5£?£I£S£]£g£q£{£…££™£££­£·£Á£Ë£Õ£ß£é£ó£ý£¤¤¤%¤/¤9¤C¤M¤W¤a¤k¤u¤¤‰¤“¤¤§¤±¤»¤Å¤Ï¤Ù¤ã¤í¤÷¤¥ ¥¥¥)¥3¥=¥G¥Q¥[¥e¥o¥y¥ƒ¥¥—¥¡¥«¥µ¥¿¥É¥Ó¥Ý¥ç¥ñ¥û¥¦¦¦#¦-¦7¦A¦J¦T¦^¦g¦q¦{¦„¦Ž¦˜¦¡¦«¦µ¦¾¦È¦Ò¦Ü¦æ¦ð¦ú¦§ §§ §*§4§=§G§Q§Z§d§n§w§§‹§•§Ÿ§©§³§¼§Æ§Ð§Ù§ã§í§ö§¨ ¨¨¨'¨1¨;¨E¨O¨X¨b¨l¨u¨¨‰¨’¨œ¨¦¨¯¨¹¨Ã¨Ì¨Ö¨à¨ê¨ô¨þ¨©©©%©.©8©B©K©U©_©h©r©|©…©©™©£©­©·©Á©Ë©Õ©ß©é©ò©ü©ªªª#ª,ª6ª@ªIªSª]ªgªqª{ª…ªŽª˜ª¢ª«ªµª¿ªÈªÒªÜªåªïªùª« ««!«*«4«>«G«Q«[«d«n«x««‹«•«Ÿ«©«³«½«Æ«Ð«Ú«ã«í«÷«¬ ¬¬¬'¬1¬;¬E¬O¬Y¬b¬l¬v¬¬‰¬“¬œ¬¦¬°¬¹¬Ã¬Í¬×¬á¬ë¬õ¬ÿ¬ ­­­&­/­9­B­L­U­_­i­s­}­‡­­š­£­­­¶­À­É­Ó­Ý­ç­ñ­û­®®®!®*®4®=®G®Q®[®e®o®x®‚®‹®•®ž®¨®±®»®Å®Ï®Ù®ã®ì®ö®ÿ® ¯¯¯%¯/¯9¯C¯M¯W¯a¯k¯u¯¯‰¯“¯¯§¯±¯»¯Å¯Ï¯Ù¯ã¯í¯÷¯° °°°)°3°=°G°Q°[°e°o°y°ƒ°°—°¡°«°µ°¿°É°Ó°Ý°ç°ñ°û°±±±#±-±7±A±K±U±_±i±s±}±‡±‘±›±¥±¯±¹±Ã±Í±×±á±ë±õ±ÿ± ²²²'²1²;²E²O²Y²c²m²w²²‹²•²Ÿ²©²³²½²Ç²Ñ²Û²å²ï²ù²³ ³³!³+³5³?³I³S³]³g³q³{³…³³™³£³­³·³Á³Ë³Õ³ß³é³ó³ý³´´´%´/´9´C´M´W´a´k´u´´‰´“´´§´±´»´Å´Ï´Ù´ã´í´÷´µ µµµ)µ3µ=µGµQµ[µeµoµyµƒµµ—µ µ©µ²µ»µÅµÏµÙµãµìµõµþµ¶¶¶%¶/¶8¶A¶J¶S¶]¶g¶q¶{¶„¶¶–¶Ÿ¶©¶³¶½¶Ç¶Ð¶Ù¶â¶ë¶õ¶ÿ¶ ···'·1·;·E·O·Y·c·m·w··‹·•·Ÿ·©·³·½·Ç·Ñ·Û·å·ï·ù·¸ ¸¸!¸+¸5¸?¸I¸S¸]¸g¸q¸{¸…¸¸™¸£¸­¸·¸Á¸Ë¸Õ¸ß¸é¸ó¸ý¸¹¹¹%¹/¹9¹C¹M¹W¹a¹k¹u¹¹‰¹“¹¹§¹±¹»¹Å¹Ï¹Ù¹ã¹í¹÷¹º ººº)º3º=ºGºQº[ºeºoºyºƒºº—º¡º«ºµº¿ºÉºÓºÝºçºñºûº»»»#»-»7»A»K»U»_»i»s»}»‡»‘»›»¥»¯»¹»Ã»Í»×»á»ë»õ»ÿ» ¼¼¼'¼1¼;¼E¼O¼Y¼c¼m¼w¼¼‹¼•¼Ÿ¼©¼³¼½¼Ç¼Ñ¼Û¼å¼ï¼ù¼½ ½½!½+½5½?½I½S½]½g½q½{½…½½™½£½­½·½Á½Ë½Õ½ß½é½ó½ý½¾¾¾%¾/¾9¾C¾M¾W¾a¾k¾u¾¾‰¾“¾¾§¾±¾»¾Å¾Ï¾Ù¾ã¾í¾÷¾¿ ¿¿¿)¿3¿=¿G¿Q¿[¿e¿o¿y¿ƒ¿¿—¿¡¿«¿µ¿¿¿É¿Ó¿Ý¿ç¿ñ¿û¿ÀÀÀ#À-À7ÀAÀKÀUÀ_ÀiÀsÀ}À‡À‘À›À¥À¯À¹ÀÃÀÍÀ×ÀáÀëÀõÀÿÀ ÁÁÁ'Á1Á;ÁEÁOÁYÁcÁmÁwÁÁ‹Á•ÁŸÁ©Á³Á½ÁÇÁÑÁÛÁåÁïÁùÁ ÂÂ!Â+Â5Â?ÂIÂSÂ]ÂgÂqÂ{…™£­·ÂÁÂËÂÕÂßÂéÂóÂýÂÃÃÃ%Ã/Ã9ÃCÃMÃWÃaÃkÃuÃÉÓÃçñûÃÅÃÏÃÙÃãÃíÃ÷ÃÄ ÄÄÄ)Ä3Ä=ÄGÄQÄ[ÄeÄoÄyăÄėġīĵĿÄÉÄÓÄÝÄçÄñÄûÄÅÅÅ#Å-Å7ÅAÅKÅUÅ_ÅiÅsÅ}ŇőśťůŹÅÃÅÍÅ×ÅáÅëÅõÅÿÅ ÆÆÆ'Æ1Æ;ÆEÆOÆYÆcÆmÆwÆƋƕƟƩƳƽÆÇÆÑÆÛÆåÆïÆùÆÇ ÇÇ!Ç+Ç5Ç?ÇIÇSÇ]ÇgÇqÇ{Ç…ÇǙǣǭǷÇÁÇËÇÕÇßÇéÇóÇýÇÈÈÈ%È/È9ÈCÈMÈWÈaÈkÈuÈȉȓÈȧȱȻÈÅÈÏÈÙÈãÈíÈ÷ÈÉ ÉÉÉ)É3É=ÉGÉQÉ[ÉeÉoÉyɃÉɗɡɫɵɿÉÉÉÓÉÝÉçÉñÉûÉÊÊÊ#Ê-Ê7ÊAÊKÊUÊ_ÊiÊsÊ}ʇʑʛʥʯʹÊÃÊÍÊ×ÊáÊëÊõÊÿÊ ËËË'Ë1Ë;ËEËOËYËcËmËwËˋ˕˟˩˳˽ËÇËÑËÛËåËïËùËÌ ÌÌ!Ì+Ì5Ì?ÌIÌSÌ]ÌgÌqÌ{Ì…Ì̷̙̣̭ÌÁÌËÌÕÌßÌéÌóÌýÌÍÍÍ%Í/Í9ÍCÍMÍWÍaÍkÍuÍ͉͓ÍͧͱͻÍÅÍÏÍÙÍãÍíÍ÷ÍÎ ÎÎ5ÎÏ"Ï/ÏPÏqϒϳÏÔÏáÏÐ#ÐDÐeІГРЭкÐÇÐÔÐáÐîÐûÐÑÑ"Ñ/Ñ<ÑIÑVÑwјѹÑÚÑûÑÒÒ"Ò/Ò<ÒIÒVÒcÒpÒ}ÒŠÒ—Ò¸ÒÅÒÒÒßÒìÒùÒÓÓ Ó-ÓNÓoÓÓ±ÓÒÓßÓìÓùÓÔÔ Ô-Ô:ÔGÔTÔaÔnÔ{ÔˆÔ•Ô¢Ô¯Ô¼ÔÉÔÖÔãÔðÔýÔ ÕÕ$Õ1Õ>ÕKÕXÕeÕrÕՌՙզճÕÀÕÍÕÚÕçÕôÕÖÖÖ(Ö5ÖBÖOÖ\ÖiÖvÖƒÖÖÖªÖ·ÖÄÖÑÖÞÖëÖøÖ×××,×9×F×S×`×m×zׇהס׮׻×È×Õ×â×ï×ü× ØØ#Ø0Ø=ØJØWØdØqØ~؋ؘإزؿØÌØÙØæØóØÙ ÙÙ7ÙTÙaÙ}ن٢٫ٸÙØÙùÙÚ&Ú3Ú@ÚaÚnÚ{ÚˆÚ•Ú±Ú¾ÚËÚØÚäÚðÚÐÛÌÛPZÿÿÿÿÿÿÿÿÿÿÿÿdÿÿÿÿÿÿ€Sÿÿÿÿÿÿaÿÿÿÿÿÿ"€Sÿÿÿÿÿÿ*"^ÿÿÿÿÿÿ4€Sÿÿÿÿÿÿ<4[ÿÿÿÿÿÿF€ SÿÿÿÿÿÿNF XÿÿÿÿÿÿX€ Sÿÿÿÿÿÿ`X€ Sÿÿÿÿÿÿj"€ Sÿÿÿÿÿÿt""€Sÿÿÿÿÿÿ~"4€Sÿÿÿÿÿÿˆ"F€Sÿÿÿÿÿÿ’"X€Sÿÿÿÿÿÿœ4€Sÿÿÿÿÿÿ¦4"€Sÿÿÿÿÿÿ°44€Sÿÿÿÿÿÿº4F€SÿÿÿÿÿÿÄ4X€SÿÿÿÿÿÿÎF€SÿÿÿÿÿÿØF"€SÿÿÿÿÿÿâF4€SÿÿÿÿÿÿìFF€SÿÿÿÿÿÿöFX€SÿÿÿÿÿÿX€Sÿÿÿÿÿÿ X"€SÿÿÿÿÿÿX4€SÿÿÿÿÿÿXF€Sÿÿÿÿÿÿ(XX€ >ÿÿÿÿÿÿ2€!>ÿÿÿÿÿÿ<"€"ÿÿÿÿÿÿF2<€#>ÿÿÿÿÿÿP4€$ÿÿÿÿÿÿZFP€%>ÿÿÿÿÿÿdF€&ÿÿÿÿÿÿnZd€'>ÿÿÿÿÿÿxX€(ÿÿÿÿÿÿ‚nx€)>ÿÿÿÿÿÿŒ*€*>ÿÿÿÿÿÿ–"*€+ÿÿÿÿÿÿ Œ–€,>ÿÿÿÿÿÿª*4€-ÿÿÿÿÿÿ´ ª€.>ÿÿÿÿÿÿ¾*F€/ÿÿÿÿÿÿÈ´¾€0>ÿÿÿÿÿÿÒ*X€1ÿÿÿÿÿÿÜÈÒ€2ÿÿÿÿÿÿæ‚Ü€3>ÿÿÿÿÿÿð<€4>ÿÿÿÿÿÿú"<€5ÿÿÿÿÿÿðú€6>ÿÿÿÿÿÿ4<€7ÿÿÿÿÿÿ€8>ÿÿÿÿÿÿ"<F€9ÿÿÿÿÿÿ,"€:>ÿÿÿÿÿÿ6<X€;ÿÿÿÿÿÿ@,6€<ÿÿÿÿÿÿJæ@€=>ÿÿÿÿÿÿTN€>>ÿÿÿÿÿÿ^"N€?ÿÿÿÿÿÿhT^€@>ÿÿÿÿÿÿr4N€Aÿÿÿÿÿÿ|hr€B>ÿÿÿÿÿÿ†FN€Cÿÿÿÿÿÿ|†€D>ÿÿÿÿÿÿšNX€Eÿÿÿÿÿÿ¤š€Fÿÿÿÿÿÿ®J¤€G>ÿÿÿÿÿÿ¸`€H>ÿÿÿÿÿÿÂ"`€Iÿÿÿÿÿÿ̸€J>ÿÿÿÿÿÿÖ4`€KÿÿÿÿÿÿàÌÖ€L>ÿÿÿÿÿÿêF`€Mÿÿÿÿÿÿôàê€N>ÿÿÿÿÿÿþX`€Oÿÿÿÿÿÿôþ€Pÿÿÿÿÿÿ®€Q>ÿÿÿÿÿÿj€R>ÿÿÿÿÿÿ&"j€Sÿÿÿÿÿÿ0&€T>ÿÿÿÿÿÿ:4j€UÿÿÿÿÿÿD0:€V>ÿÿÿÿÿÿNFj€WÿÿÿÿÿÿXDN€X>ÿÿÿÿÿÿbXj€YÿÿÿÿÿÿlXb€Z>ÿÿÿÿÿÿvt€[>ÿÿÿÿÿÿ€"t€\ÿÿÿÿÿÿŠv€€]>ÿÿÿÿÿÿ”4t€^ÿÿÿÿÿÿžŠ”€_>ÿÿÿÿÿÿ¨Ft€`ÿÿÿÿÿÿ²ž¨€a>ÿÿÿÿÿÿ¼Xt€bÿÿÿÿÿÿƲ¼€cÿÿÿÿÿÿÐlÆ€d>ÿÿÿÿÿÿÚ~€e>ÿÿÿÿÿÿä"~€fÿÿÿÿÿÿîÚä€g>ÿÿÿÿÿÿø4~€hÿÿÿÿÿÿîø€i>ÿÿÿÿÿÿ F~€jÿÿÿÿÿÿ €k>ÿÿÿÿÿÿ X~€lÿÿÿÿÿÿ* €mÿÿÿÿÿÿ4Ð*€n>ÿÿÿÿÿÿ>ˆ€o>ÿÿÿÿÿÿH"ˆ€pÿÿÿÿÿÿR>H€q>ÿÿÿÿÿÿ\4ˆ€rÿÿÿÿÿÿfR\€s>ÿÿÿÿÿÿpFˆ€tÿÿÿÿÿÿzfp€u>ÿÿÿÿÿÿ„Xˆ€vÿÿÿÿÿÿŽz„€wÿÿÿÿÿÿ˜4Ž€x>ÿÿÿÿÿÿ¢’€y>ÿÿÿÿÿÿ¬"’€zÿÿÿÿÿÿ¶¢¬€{>ÿÿÿÿÿÿÀ4’€|ÿÿÿÿÿÿʶÀ€}>ÿÿÿÿÿÿÔF’€~ÿÿÿÿÿÿÞÊÔ€>ÿÿÿÿÿÿèX’€€ÿÿÿÿÿÿòÞè€ÿÿÿÿÿÿü˜ò€‚ÿÿÿÿÿÿü€ƒ>ÿÿÿÿÿÿœ€„>ÿÿÿÿÿÿ"œ€…ÿÿÿÿÿÿ$€†>ÿÿÿÿÿÿ.4œ€‡ÿÿÿÿÿÿ8$.€ˆ>ÿÿÿÿÿÿBFœ€‰ÿÿÿÿÿÿL8B€Š>ÿÿÿÿÿÿVXœ€‹ÿÿÿÿÿÿ`LV€Œ>ÿÿÿÿÿÿj¦€>ÿÿÿÿÿÿt"¦€Žÿÿÿÿÿÿ~jt€>ÿÿÿÿÿÿˆ4¦€ÿÿÿÿÿÿ’~ˆ€‘>ÿÿÿÿÿÿœF¦€’ÿÿÿÿÿÿ¦’œ€“>ÿÿÿÿÿÿ°X¦€”ÿÿÿÿÿÿº¦°€•ÿÿÿÿÿÿÄ`º€–>ÿÿÿÿÿÿΰ€—>ÿÿÿÿÿÿØ"°€˜ÿÿÿÿÿÿâÎØ€™>ÿÿÿÿÿÿì4°€šÿÿÿÿÿÿöâ쀛>ÿÿÿÿÿÿF°€œÿÿÿÿÿÿ ö€>ÿÿÿÿÿÿX°€žÿÿÿÿÿÿ €Ÿÿÿÿÿÿÿ(Ä€ >ÿÿÿÿÿÿ2º€¡>ÿÿÿÿÿÿ<"º€¢ÿÿÿÿÿÿF2<€£>ÿÿÿÿÿÿP4º€¤ÿÿÿÿÿÿZFP€¥>ÿÿÿÿÿÿdFº€¦ÿÿÿÿÿÿnZd€§>ÿÿÿÿÿÿxXº€¨ÿÿÿÿÿÿ‚nx€©ÿÿÿÿÿÿŒ(‚€ª>ÿÿÿÿÿÿ–Ä€«>ÿÿÿÿÿÿ "Ä€¬ÿÿÿÿÿÿª– €­>ÿÿÿÿÿÿ´4Ä€®ÿÿÿÿÿÿ¾ª´€¯>ÿÿÿÿÿÿÈFÄ€°ÿÿÿÿÿÿҾȀ±>ÿÿÿÿÿÿÜXÄ€²ÿÿÿÿÿÿæÒÜ€³ÿÿÿÿÿÿðŒæ€´ÿÿÿÿÿÿúð€µ>ÿÿÿÿÿÿ΀¶>ÿÿÿÿÿÿ"΀·ÿÿÿÿÿÿ€¸>ÿÿÿÿÿÿ"4΀¹ÿÿÿÿÿÿ,"€º>ÿÿÿÿÿÿ6F΀»ÿÿÿÿÿÿ@,6€¼>ÿÿÿÿÿÿJX΀½ÿÿÿÿÿÿT@J€¾>ÿÿÿÿÿÿ^Ø€¿>ÿÿÿÿÿÿh"Ø€Àÿÿÿÿÿÿr^h€Á>ÿÿÿÿÿÿ|4Ø€Âÿÿÿÿÿÿ†r|€Ã>ÿÿÿÿÿÿFØ€Äÿÿÿÿÿÿš†€Å>ÿÿÿÿÿÿ¤XØ€Æÿÿÿÿÿÿ®š¤€Çÿÿÿÿÿÿ¸T®€È>ÿÿÿÿÿÿÂâ€É>ÿÿÿÿÿÿÌ"â€ÊÿÿÿÿÿÿÖÂÌ€Ë>ÿÿÿÿÿÿà4â€ÌÿÿÿÿÿÿêÖà€Í>ÿÿÿÿÿÿôFâ€Îÿÿÿÿÿÿþêô€Ï>ÿÿÿÿÿÿXâ€Ðÿÿÿÿÿÿþ€Ñÿÿÿÿÿÿ¸€Ò>ÿÿÿÿÿÿ&ì€Ó>ÿÿÿÿÿÿ0"ì€Ôÿÿÿÿÿÿ:&0€Õ>ÿÿÿÿÿÿD4ì€ÖÿÿÿÿÿÿN:D€×>ÿÿÿÿÿÿXFì€ØÿÿÿÿÿÿbNX€Ù>ÿÿÿÿÿÿlXì€Úÿÿÿÿÿÿvbl€Ûÿÿÿÿÿÿ€v€Ü>ÿÿÿÿÿÿŠö€Ý>ÿÿÿÿÿÿ”"ö€ÞÿÿÿÿÿÿžŠ”€ß>ÿÿÿÿÿÿ¨4ö€àÿÿÿÿÿÿ²ž¨€á>ÿÿÿÿÿÿ¼Fö€âÿÿÿÿÿÿƲ¼€ã>ÿÿÿÿÿÿÐXö€äÿÿÿÿÿÿÚÆЀåÿÿÿÿÿÿä€Ú€æÿÿÿÿÿÿîúä€ç>ÿÿÿÿÿÿø€è>ÿÿÿÿÿÿ "€éÿÿÿÿÿÿ ø €ê>ÿÿÿÿÿÿ 4€ëÿÿÿÿÿÿ  €ì>ÿÿÿÿÿÿ* F€íÿÿÿÿÿÿ4 * €î>ÿÿÿÿÿÿ> X€ïÿÿÿÿÿÿH 4 > €ð>ÿÿÿÿÿÿR  €ñ>ÿÿÿÿÿÿ\ " €òÿÿÿÿÿÿf R \ €ó>ÿÿÿÿÿÿp 4 €ôÿÿÿÿÿÿz f p €õ>ÿÿÿÿÿÿ„ F €öÿÿÿÿÿÿŽ z „ €÷>ÿÿÿÿÿÿ˜ X €øÿÿÿÿÿÿ¢ Ž ˜ €ùÿÿÿÿÿÿ¬ H ¢ €ú>ÿÿÿÿÿÿ¶ €û>ÿÿÿÿÿÿÀ "€üÿÿÿÿÿÿÊ ¶ À €ý>ÿÿÿÿÿÿÔ 4€þÿÿÿÿÿÿÞ Ê Ô €ÿ>ÿÿÿÿÿÿè F€ÿÿÿÿÿÿò Þ è €>ÿÿÿÿÿÿü X€ÿÿÿÿÿÿ ò ü €ÿÿÿÿÿÿ ¬  €>ÿÿÿÿÿÿ €>ÿÿÿÿÿÿ$ "€ÿÿÿÿÿÿ.  $ €>ÿÿÿÿÿÿ8 4€ÿÿÿÿÿÿB . 8 € >ÿÿÿÿÿÿL F€ ÿÿÿÿÿÿV B L € >ÿÿÿÿÿÿ` X€ ÿÿÿÿÿÿj V ` € ÿÿÿÿÿÿt  j €>ÿÿÿÿÿÿ~ (€>ÿÿÿÿÿÿˆ "(€ÿÿÿÿÿÿ’ ~ ˆ €>ÿÿÿÿÿÿœ 4(€ÿÿÿÿÿÿ¦ ’ œ €>ÿÿÿÿÿÿ° F(€ÿÿÿÿÿÿº ¦ ° €>ÿÿÿÿÿÿÄ X(€ÿÿÿÿÿÿÎ º Ä €ÿÿÿÿÿÿØ t Î €ÿÿÿÿÿÿâ îØ €ÿÿÿÿÿÿì 2Œ€ÿÿÿÿÿÿö ì ð€ÿÿÿÿÿÿ ö T€ÿÿÿÿÿÿ ¸€ÿÿÿÿÿÿ 2€ÿÿÿÿÿÿ  €ÿÿÿÿÿÿ(  € ÿÿÿÿÿÿ2 ( ø€!ÿÿÿÿÿÿ< 2 €"ÿÿÿÿÿÿF <–€#ÿÿÿÿÿÿP F ú€$ÿÿÿÿÿÿZ P ^€%ÿÿÿÿÿÿd Z €&ÿÿÿÿÿÿn <&€'ÿÿÿÿÿÿx n €(ÿÿÿÿÿÿ‚ x €)ÿÿÿÿÿÿŒ ‚  €*ÿÿÿÿÿÿ– d Œ €+ÿÿÿÿÿÿ  < – €,ÿÿÿÿÿÿª Pª€-ÿÿÿÿÿÿ´ ª €.ÿÿÿÿÿÿ¾ ´ r€/ÿÿÿÿÿÿÈ ¾ Ö€0ÿÿÿÿÿÿÒ P:€1ÿÿÿÿÿÿÜ Ò .€2ÿÿÿÿÿÿæ Ü "€3ÿÿÿÿÿÿð æ  €4ÿÿÿÿÿÿú È ð €5ÿÿÿÿÿÿ   ú €6ÿÿÿÿÿÿ d¾€7ÿÿÿÿÿÿ  "€8ÿÿÿÿÿÿ"  †€9ÿÿÿÿÿÿ, " ê€:ÿÿÿÿÿÿ6 dN€;ÿÿÿÿÿÿ@ 6 B€<ÿÿÿÿÿÿJ @ 6€=ÿÿÿÿÿÿT J * €>ÿÿÿÿÿÿ^ , T €?ÿÿÿÿÿÿh  ^ €@ÿÿÿÿÿÿr xÒ€Aÿÿÿÿÿÿ| r 6€Bÿÿÿÿÿÿ† | š€Cÿÿÿÿÿÿ † þ€Dÿÿÿÿÿÿš xb€Eÿÿÿÿÿÿ¤ š V€Fÿÿÿÿÿÿ® ¤ J€Gÿÿÿÿÿÿ¸ ® > €Hÿÿÿÿÿÿ ¸ €IÿÿÿÿÿÿÌ h  €JÿÿÿÿÿÿÖ v€Kÿÿÿÿÿÿà Ö Ú€Lÿÿÿÿÿÿê à >€Mÿÿÿÿÿÿô ê ¢€Nÿÿÿÿÿÿþ Œv€Oÿÿÿÿÿÿ þ j€Pÿÿÿÿÿÿ  ^€Qÿÿÿÿÿÿ  R €Rÿÿÿÿÿÿ& ô  €Sÿÿÿÿÿÿ0 &€€Tÿÿÿÿÿÿ: 0 ä€UÿÿÿÿÿÿD : H€VÿÿÿÿÿÿN D ¬€WÿÿÿÿÿÿX –€€Xÿÿÿÿÿÿb X t€Yÿÿÿÿÿÿl b h€Zÿÿÿÿÿÿv l \ €[ÿÿÿÿÿÿ€ N v €\ÿÿÿÿÿÿŠ & € €]ÿÿÿÿÿÿ” :”€^ÿÿÿÿÿÿž ” ø€_ÿÿÿÿÿÿ¨ ž \€`ÿÿÿÿÿÿ² ¨ À€aÿÿÿÿÿÿ¼ ª”€bÿÿÿÿÿÿÆ ¼ ˆ€cÿÿÿÿÿÿÐ Æ |€dÿÿÿÿÿÿÚ Ð p €eÿÿÿÿÿÿä ² Ú €fÿÿÿÿÿÿî Š ä €gÿÿÿÿÿÿø N¨€hÿÿÿÿÿÿø €iÿÿÿÿÿÿ p€jÿÿÿÿÿÿ Ô€kÿÿÿÿÿÿ ¾¨€lÿÿÿÿÿÿ* œ€mÿÿÿÿÿÿ4*€nÿÿÿÿÿÿ>4„ €oÿÿÿÿÿÿH>€pÿÿÿÿÿÿRî H€qÿÿÿÿÿÿ\b¼€rÿÿÿÿÿÿf\ €sÿÿÿÿÿÿpf„€tÿÿÿÿÿÿzpè€uÿÿÿÿÿÿ„Ò¼€vÿÿÿÿÿÿŽ„°€wÿÿÿÿÿÿ˜Ž¤€xÿÿÿÿÿÿ¢˜˜ €yÿÿÿÿÿÿ¬z¢€zÿÿÿÿÿÿ¶R¬€{ÿÿÿÿÿÿÀÌ ¶€|ÿÿÿÿÿÿÊj€}ÿÿÿÿÿÿÔÊ΀~ÿÿÿÿÿÿÞÔ2€ÿÿÿÿÿÿèÞ–€€ÿÿÿÿÿÿòðÚ€ÿÿÿÿÿÿüò΀‚ÿÿÿÿÿÿü€ƒÿÿÿÿÿÿ¶ €„ÿÿÿÿÿÿ者ÿÿÿÿÿÿ$t€†ÿÿÿÿÿÿ.$Ø€‡ÿÿÿÿÿÿ8.<€ˆÿÿÿÿÿÿB8 €‰ÿÿÿÿÿÿLú䀊ÿÿÿÿÿÿVLØ€‹ÿÿÿÿÿÿ`VÌ€Œÿÿÿÿÿÿj`À €ÿÿÿÿÿÿtBj€Žÿÿÿÿÿÿ~t€ÿÿÿÿÿÿˆ.ˆ€ÿÿÿÿÿÿ’ˆì€‘ÿÿÿÿÿÿœ’P€’ÿÿÿÿÿÿ¦œ´€“ÿÿÿÿÿÿ°ø€”ÿÿÿÿÿÿº°ì€•ÿÿÿÿÿÿÄºà€–ÿÿÿÿÿÿÎÄÔ €—ÿÿÿÿÿÿئ΀˜ÿÿÿÿÿÿâ~Ø€™ÿÿÿÿÿÿìBœ€šÿÿÿÿÿÿö쀛ÿÿÿÿÿÿöd€œÿÿÿÿÿÿ È€ÿÿÿÿÿÿ" €žÿÿÿÿÿÿ€Ÿÿÿÿÿÿÿ(ô€ ÿÿÿÿÿÿ2(è €¡ÿÿÿÿÿÿ< 2€¢ÿÿÿÿÿÿFâ<€£ÿÿÿÿÿÿPV°€¤ÿÿÿÿÿÿZP€¥ÿÿÿÿÿÿdZx€¦ÿÿÿÿÿÿndÜ€§ÿÿÿÿÿÿx6 €¨ÿÿÿÿÿÿ‚x€©ÿÿÿÿÿÿŒ‚€ªÿÿÿÿÿÿ–Œü €«ÿÿÿÿÿÿ n–€¬ÿÿÿÿÿÿªF €­ÿÿÿÿÿÿ´Àª€®ÿÿÿÿÿÿ¾^€¯ÿÿÿÿÿÿȾ€°ÿÿÿÿÿÿÒÈ&€±ÿÿÿÿÿÿÜÒŠ€²ÿÿÿÿÿÿæT>€³ÿÿÿÿÿÿðæ2€´ÿÿÿÿÿÿúð&€µÿÿÿÿÿÿú €¶ÿÿÿÿÿÿÜ€·ÿÿÿÿÿÿh€¸ÿÿÿÿÿÿ"Ì€¹ÿÿÿÿÿÿ,"0€ºÿÿÿÿÿÿ6,”€»ÿÿÿÿÿÿ@^H€¼ÿÿÿÿÿÿJ@<€½ÿÿÿÿÿÿTJ0€¾ÿÿÿÿÿÿ^T$ €¿ÿÿÿÿÿÿh6^€Àÿÿÿÿÿÿrh€Áÿÿÿÿÿÿ|"|€Âÿÿÿÿÿÿ†|à€Ãÿÿÿÿÿÿ†D€Äÿÿÿÿÿÿš¨€Åÿÿÿÿÿÿ¤r\€Æÿÿÿÿÿÿ®¤P€Çÿÿÿÿÿÿ¸®D€Èÿÿÿÿÿÿ¸8 €Éÿÿÿÿÿÿ̚€ÊÿÿÿÿÿÿÖrÌ€Ëÿÿÿÿÿÿà6€Ìÿÿÿÿÿÿêàô€ÍÿÿÿÿÿÿôêX€Îÿÿÿÿÿÿþô¼€Ïÿÿÿÿÿÿ†p€Ðÿÿÿÿÿÿd€ÑÿÿÿÿÿÿX€Òÿÿÿÿÿÿ&L €Óÿÿÿÿÿÿ0þ&€Ôÿÿÿÿÿÿ:Ö0€ÕÿÿÿÿÿÿDJ¤€ÖÿÿÿÿÿÿND€×ÿÿÿÿÿÿXNl€ØÿÿÿÿÿÿbXЀÙÿÿÿÿÿÿlš„€Úÿÿÿÿÿÿvlx€Ûÿÿÿÿÿÿ€vl€ÜÿÿÿÿÿÿŠ€` €Ýÿÿÿÿÿÿ”bŠ€Þÿÿÿÿÿÿž:”€ßÿÿÿÿÿÿ¨´ž€àÿÿÿÿÿÿ²øR €áÿÿÿÿÿÿ¼²¶ €âÿÿÿÿÿÿƼ €ãÿÿÿÿÿÿÐÆ~ €äÿÿÿÿÿÿÚ¸¢€åÿÿÿÿÿÿäÚ–€æÿÿÿÿÿÿî䊀çÿÿÿÿÿÿøî~ €èÿÿÿÿÿÿÐø€éÿÿÿÿÿÿ  \ €êÿÿÿÿÿÿ À €ëÿÿÿÿÿÿ $ €ìÿÿÿÿÿÿ* ˆ €íÿÿÿÿÿÿ4¬€îÿÿÿÿÿÿ>4 €ïÿÿÿÿÿÿH>”€ðÿÿÿÿÿÿRHˆ €ñÿÿÿÿÿÿ\*R€òÿÿÿÿÿÿf\€óÿÿÿÿÿÿp p €ôÿÿÿÿÿÿzpÔ €õÿÿÿÿÿÿ„z8 €öÿÿÿÿÿÿŽ„œ €÷ÿÿÿÿÿÿ˜ÖÀ€øÿÿÿÿÿÿ¢˜´€ùÿÿÿÿÿÿ¬¢¨€úÿÿÿÿÿÿ¶¬œ €ûÿÿÿÿÿÿÀŽ¶€üÿÿÿÿÿÿÊfÀ€ýÿÿÿÿÿÿÔ* „ €þÿÿÿÿÿÿÞÔè €ÿÿÿÿÿÿÿèÞL €ÿÿÿÿÿÿòè° €ÿÿÿÿÿÿüêÔ€ÿÿÿÿÿÿüÈ€ÿÿÿÿÿÿ¼€ÿÿÿÿÿÿ° €ÿÿÿÿÿÿ$ò€ÿÿÿÿÿÿ.Ê$€ÿÿÿÿÿÿ8> ˜ €ÿÿÿÿÿÿB8ü € ÿÿÿÿÿÿLB` € ÿÿÿÿÿÿVLÄ € ÿÿÿÿÿÿ`þè€ ÿÿÿÿÿÿj`Ü€ ÿÿÿÿÿÿtjЀÿÿÿÿÿÿ~tÄ €ÿÿÿÿÿÿˆV~€ÿÿÿÿÿÿ’.ˆ€ÿÿÿÿÿÿœ¨’@ÿÿÿÿÿÿ¦2@ÿÿÿÿÿÿ¯v€ÿÿÿÿÿÿ¸¦¯@ÿÿÿÿÿÿÂ΀ÿÿÿÿÿÿ˸Â@ÿÿÿÿÿÿÕ&€ÿÿÿÿÿÿÞËÕ@ÿÿÿÿÿÿè~ €ÿÿÿÿÿÿñÞè@ÿÿÿÿÿÿû<@ÿÿÿÿÿÿ€€ÿÿÿÿÿÿ û@ÿÿÿÿÿÿØ€ÿÿÿÿÿÿ  @ ÿÿÿÿÿÿ*0€!ÿÿÿÿÿÿ3 *@"ÿÿÿÿÿÿ=ˆ €#ÿÿÿÿÿÿF3=€$ÿÿÿÿÿÿPñF@%ÿÿÿÿÿÿZP@&ÿÿÿÿÿÿc”€'ÿÿÿÿÿÿlZc@(ÿÿÿÿÿÿvì€)ÿÿÿÿÿÿlv@*ÿÿÿÿÿÿ‰D€+ÿÿÿÿÿÿ’‰@,ÿÿÿÿÿÿœœ €-ÿÿÿÿÿÿ¥’œ€.ÿÿÿÿÿÿ¯P¥@/ÿÿÿÿÿÿ¹d@0ÿÿÿÿÿÿ¨€1ÿÿÿÿÿÿ˹Â@2ÿÿÿÿÿÿÕ€3ÿÿÿÿÿÿÞËÕ@4ÿÿÿÿÿÿèX€5ÿÿÿÿÿÿñÞè@6ÿÿÿÿÿÿû° €7ÿÿÿÿÿÿñû€8ÿÿÿÿÿÿ¯@9ÿÿÿÿÿÿx@:ÿÿÿÿÿÿ!¼€;ÿÿÿÿÿÿ*!@<ÿÿÿÿÿÿ4€=ÿÿÿÿÿÿ=*4@>ÿÿÿÿÿÿGl€?ÿÿÿÿÿÿP=G@@ÿÿÿÿÿÿZÄ €AÿÿÿÿÿÿcPZ€Bÿÿÿÿÿÿmc@CÿÿÿÿÿÿwŒ@Dÿÿÿÿÿÿ€@Eÿÿÿÿÿÿ‰ð@Fÿÿÿÿÿÿ’@Gÿÿÿÿÿÿ›T@Hÿÿÿÿÿÿ¤@Iÿÿÿÿÿÿ­¸@Jÿÿÿÿÿÿ¶ø@Kÿÿÿÿÿÿ¿Ú@LÿÿÿÿÿÿÈj@MÿÿÿÿÿÿÑ>@NÿÿÿÿÿÿÚ^@Oÿÿÿÿÿÿã¢@PÿÿÿÿÿÿìR @Qÿÿÿÿÿÿõ2@RÿÿÿÿÿÿþÂ@Sÿÿÿÿÿÿ–@Tÿÿÿÿÿÿ¶ @UÿÿÿÿÿÿŠ@Vÿÿÿÿÿÿ" @Wÿÿÿÿÿÿ+–@Xÿÿÿÿÿÿ4&@Yÿÿÿÿÿÿ=ú@ZÿÿÿÿÿÿF@[ÿÿÿÿÿÿO^@\ÿÿÿÿÿÿX@]ÿÿÿÿÿÿaÂ@^ÿÿÿÿÿÿj @_ÿÿÿÿÿÿsä@`ÿÿÿÿÿÿ|t@aÿÿÿÿÿÿ…H@bÿÿÿÿÿÿŽh@cÿÿÿÿÿÿ—¬@dÿÿÿÿÿÿ \ @eÿÿÿÿÿÿ©<@fÿÿÿÿÿÿ²Ì@gÿÿÿÿÿÿ» @hÿÿÿÿÿÿÄÀ @iÿÿÿÿÿÿÍ”@jÿÿÿÿÿÿÖ$ @kÿÿÿÿÿÿߪ@lÿÿÿÿÿÿè:@mÿÿÿÿÿÿñ@nÿÿÿÿÿÿú.@oÿÿÿÿÿÿr@pÿÿÿÿÿÿ "@qÿÿÿÿÿÿÖ@rÿÿÿÿÿÿ @sÿÿÿÿÿÿ'ø@tÿÿÿÿÿÿ0ˆ@uÿÿÿÿÿÿ9\@vÿÿÿÿÿÿB|@wÿÿÿÿÿÿKÀ@xÿÿÿÿÿÿTp @yÿÿÿÿÿÿ]P@zÿÿÿÿÿÿfà@{ÿÿÿÿÿÿo´@|ÿÿÿÿÿÿxÔ @}ÿÿÿÿÿÿ¨@~ÿÿÿÿÿÿŠ8 @ÿÿÿÿÿÿ“¾@€ÿÿÿÿÿÿœN@ÿÿÿÿÿÿ¥"@‚ÿÿÿÿÿÿ®B@ƒÿÿÿÿÿÿ·†@„ÿÿÿÿÿÿÀ6@…ÿÿÿÿÿÿÉê@†ÿÿÿÿÿÿÒ* @‡ÿÿÿÿÿÿÛ @ˆÿÿÿÿÿÿäœ@‰ÿÿÿÿÿÿíp@Šÿÿÿÿÿÿö@‹ÿÿÿÿÿÿÿÔ@Œÿÿÿÿÿÿ„ @ÿÿÿÿÿÿd@Žÿÿÿÿÿÿô@ÿÿÿÿÿÿ#È@ÿÿÿÿÿÿ,è @‘ÿÿÿÿÿÿ5¼@’ÿÿÿÿÿÿ>L @“ÿÿÿÿÿÿGÒ@”ÿÿÿÿÿÿPb@•ÿÿÿÿÿÿY6@–ÿÿÿÿÿÿbV@—ÿÿÿÿÿÿkš@˜ÿÿÿÿÿÿtJ@™ÿÿÿÿÿÿ}þ@šÿÿÿÿÿÿ†> @›ÿÿÿÿÿÿ @œÿÿÿÿÿÿ˜°@ÿÿÿÿÿÿ¡„@žÿÿÿÿÿÿª¤@Ÿÿÿÿÿÿÿ³è@ ÿÿÿÿÿÿ¼˜ @¡ÿÿÿÿÿÿÅx@¢ÿÿÿÿÿÿÎ@£ÿÿÿÿÿÿ×Ü@¤ÿÿÿÿÿÿàü @¥ÿÿÿÿÿÿéÐ@¦ÿÿÿÿÿÿò` €§ÿÿÿÿÿÿûw€€¨ÿÿÿÿÿÿ¦û€©ÿÿÿÿÿÿ‰’€ªÿÿÿÿÿÿ€«ÿÿÿÿÿÿ#›¤€¬ÿÿÿÿÿÿ-#€­ÿÿÿÿÿÿ7­¶€®ÿÿÿÿÿÿA-7€¯ÿÿÿÿÿÿK€w€°ÿÿÿÿÿÿUK¯€±ÿÿÿÿÿÿ_¿È€²ÿÿÿÿÿÿiU_€³ÿÿÿÿÿÿsÑÚ€´ÿÿÿÿÿÿ}is€µÿÿÿÿÿÿ‡ã쀶ÿÿÿÿÿÿ‘}‡€·ÿÿÿÿÿÿ›A‘€¸ÿÿÿÿÿÿ¥’‰€¹ÿÿÿÿÿÿ¯È¿€ºÿÿÿÿÿÿ¹¥¯€»ÿÿÿÿÿÿù€¼ÿÿÿÿÿÿÍõþ€½ÿÿÿÿÿÿ×ÃÍ€¾ÿÿÿÿÿÿဿÿÿÿÿÿÿë×á€Àÿÿÿÿÿÿõ›ë€Áÿÿÿÿÿÿÿ¤›€Âÿÿÿÿÿÿ ÚÑ€Ãÿÿÿÿÿÿÿ €Äÿÿÿÿÿÿþõ€Åÿÿÿÿÿÿ'€Æÿÿÿÿÿÿ1'Õ€Çÿÿÿÿÿÿ;"€ÈÿÿÿÿÿÿE1;€ÉÿÿÿÿÿÿOõE€ÊÿÿÿÿÿÿY¶­€Ëÿÿÿÿÿÿcìã€ÌÿÿÿÿÿÿmYc€Íÿÿÿÿÿÿw€Îÿÿÿÿÿÿmw€Ïÿÿÿÿÿÿ‹"€Ðÿÿÿÿÿÿ•‹€ÑÿÿÿÿÿÿŸ•è€Òÿÿÿÿÿÿ©OŸ€Óÿÿÿÿÿÿ³+4€Ôÿÿÿÿÿÿ½û³€ÕÿÿÿÿÿÿÇ=F€Öÿÿÿÿÿÿѽǀ×ÿÿÿÿÿÿÛOX€ØÿÿÿÿÿÿåÑÛ€Ùÿÿÿÿÿÿïaj€Úÿÿÿÿÿÿùåï€Ûÿÿÿÿÿÿ4+€Üÿÿÿÿÿÿ €Ýÿÿÿÿÿÿs|€Þÿÿÿÿÿÿ! €ßÿÿÿÿÿÿ+…Ž€àÿÿÿÿÿÿ5!+€áÿÿÿÿÿÿ?— €âÿÿÿÿÿÿI5?€ãÿÿÿÿÿÿSùI€äÿÿÿÿÿÿ]F=€åÿÿÿÿÿÿg|s€æÿÿÿÿÿÿq]g€çÿÿÿÿÿÿ{q€èÿÿÿÿÿÿ…©²€éÿÿÿÿÿÿ{…€êÿÿÿÿÿÿ™»Ä€ëÿÿÿÿÿÿ£™€ìÿÿÿÿÿÿ­S£€íÿÿÿÿÿÿ·XO€îÿÿÿÿÿÿÁŽ…€ïÿÿÿÿÿÿË·Á€ðÿÿÿÿÿÿÕ²©€ñÿÿÿÿÿÿßËÕ€òÿÿÿÿÿÿéß*€óÿÿÿÿÿÿóÍÖ€ôÿÿÿÿÿÿýéó€õÿÿÿÿÿÿ­ý€öÿÿÿÿÿÿja€÷ÿÿÿÿÿÿ —€øÿÿÿÿÿÿ%€ùÿÿÿÿÿÿ/Ä»€úÿÿÿÿÿÿ9%/€ûÿÿÿÿÿÿCÖÍ€üÿÿÿÿÿÿM9C€ýÿÿÿÿÿÿWM=€þÿÿÿÿÿÿaW€ÿÿÿÿÿÿÿk©a€ÿÿÿÿÿÿußè€ÿÿÿÿÿÿZu€ÿÿÿÿÿÿ‰ñú€ÿÿÿÿÿÿ“‰€ÿÿÿÿÿÿ €ÿÿÿÿÿÿ§“€ÿÿÿÿÿÿ±€ÿÿÿÿÿÿ»§±€ÿÿÿÿÿÿÅè߀ ÿÿÿÿÿÿÏÅc€ ÿÿÿÿÿÿÙ'0€ ÿÿÿÿÿÿãÏÙ€ ÿÿÿÿÿÿí9B€ ÿÿÿÿÿÿ÷ãí€ÿÿÿÿÿÿKT€ÿÿÿÿÿÿ ÷€ÿÿÿÿÿÿ» €ÿÿÿÿÿÿúñ€ÿÿÿÿÿÿ)0'€ÿÿÿÿÿÿ3)€ÿÿÿÿÿÿ=3v€ÿÿÿÿÿÿG]f€ÿÿÿÿÿÿQ=G€ÿÿÿÿÿÿ[ox€ÿÿÿÿÿÿeQ[€ÿÿÿÿÿÿoe€ÿÿÿÿÿÿy €ÿÿÿÿÿÿƒB9€ÿÿÿÿÿÿyƒ€ÿÿÿÿÿÿ—f]€ÿÿÿÿÿÿ¡—€ÿÿÿÿÿÿ«¡‰€ ÿÿÿÿÿÿµŠ€!ÿÿÿÿÿÿ¿«µ€"ÿÿÿÿÿÿÉo¿€#ÿÿÿÿÿÿÓ€$ÿÿÿÿÿÿÝTK€%ÿÿÿÿÿÿçÓÝ€&ÿÿÿÿÿÿñxo€'ÿÿÿÿÿÿûçñ€(ÿÿÿÿÿÿŠ€)ÿÿÿÿÿÿû€*ÿÿÿÿÿÿœ€+ÿÿÿÿÿÿ#É€,ÿÿÿÿÿÿ-k#€-ÿÿÿÿÿÿ7“œ€.ÿÿÿÿÿÿA¹7€/ÿÿÿÿÿÿK¥®€0ÿÿÿÿÿÿUAK€1ÿÿÿÿÿÿ_·À€2ÿÿÿÿÿÿiU_€3ÿÿÿÿÿÿsÉÒ€4ÿÿÿÿÿÿ}is€5ÿÿÿÿÿÿ‡œ“€6ÿÿÿÿÿÿ‘‡Â€7ÿÿÿÿÿÿ›Ûä€8ÿÿÿÿÿÿ¥‘›€9ÿÿÿÿÿÿ¯íö€:ÿÿÿÿÿÿ¹¥¯€;ÿÿÿÿÿÿÃÿ€<ÿÿÿÿÿÿ͹À=ÿÿÿÿÿÿ×}Í€>ÿÿÿÿÿÿᮥ€?ÿÿÿÿÿÿëäÛ€@ÿÿÿÿÿÿõáë€AÿÿÿÿÿÿÿõÕ€Bÿÿÿÿÿÿ €Cÿÿÿÿÿÿ ÿ €Dÿÿÿÿÿÿ #,€Eÿÿÿÿÿÿ'   €Fÿÿÿÿÿÿ1 ×' €Gÿÿÿÿÿÿ; À·€HÿÿÿÿÿÿE öí€IÿÿÿÿÿÿO ; E €JÿÿÿÿÿÿY €Kÿÿÿÿÿÿc O Y €Lÿÿÿÿÿÿm c è€Mÿÿÿÿÿÿw 5>€Nÿÿÿÿÿÿ m w €Oÿÿÿÿÿÿ‹ 1 €Pÿÿÿÿÿÿ• ÒÉ€QÿÿÿÿÿÿŸ ÿ€Rÿÿÿÿÿÿ© • Ÿ €Sÿÿÿÿÿÿ³ ,#€Tÿÿÿÿÿÿ½ © ³ €UÿÿÿÿÿÿÇ >5€VÿÿÿÿÿÿÑ ½ Ç €WÿÿÿÿÿÿÛ Ñ û€Xÿÿÿÿÿÿå ‹ Û €Yÿÿÿÿÿÿï -å €Zÿÿÿÿÿÿù GP€[ÿÿÿÿÿÿ!ù €\ÿÿÿÿÿÿ !Yb€]ÿÿÿÿÿÿ!! !€^ÿÿÿÿÿÿ!!kt€_ÿÿÿÿÿÿ+!!!!€`ÿÿÿÿÿÿ5!}†€aÿÿÿÿÿÿ?!+!5!€bÿÿÿÿÿÿI!PG€cÿÿÿÿÿÿS!I!!€dÿÿÿÿÿÿ]!˜€eÿÿÿÿÿÿg!S!]!€fÿÿÿÿÿÿq!¡ª€gÿÿÿÿÿÿ{!g!q!€hÿÿÿÿÿÿ…!³¼€iÿÿÿÿÿÿ!{!…!€jÿÿÿÿÿÿ™!?!!€kÿÿÿÿÿÿ£!bY€lÿÿÿÿÿÿ­!˜€mÿÿÿÿÿÿ·!£!­!€nÿÿÿÿÿÿÁ!·!4€oÿÿÿÿÿÿË!Å΀pÿÿÿÿÿÿÕ!Á!Ë!€qÿÿÿÿÿÿß!×à€rÿÿÿÿÿÿé!Õ!ß!€sÿÿÿÿÿÿó!™!é!€tÿÿÿÿÿÿý!tk€uÿÿÿÿÿÿ"ª¡€vÿÿÿÿÿÿ"ý!"€wÿÿÿÿÿÿ"ÎÅ€xÿÿÿÿÿÿ%"""€yÿÿÿÿÿÿ/"%"G€zÿÿÿÿÿÿ9"éò€{ÿÿÿÿÿÿC"/"9"€|ÿÿÿÿÿÿM"ó!C"€}ÿÿÿÿÿÿW"†}€~ÿÿÿÿÿÿa"¼³€ÿÿÿÿÿÿk"W"a"€€ÿÿÿÿÿÿu"à×€ÿÿÿÿÿÿ"k"u"€‚ÿÿÿÿÿÿ‰"ò逃ÿÿÿÿÿÿ“""‰"€„ÿÿÿÿÿÿ"“"Z€…ÿÿÿÿÿÿ§"M""€†ÿÿÿÿÿÿ±"ï §"€‡ÿÿÿÿÿÿ»"2€€ˆÿÿÿÿÿÿÅ"»"쀉ÿÿÿÿÿÿÏ"Å"X€ŠÿÿÿÿÿÿÙ"Ï"Ä €‹Sÿÿÿÿÿÿã"€Œ>ÿÿÿÿÿÿí"ã"@ÿÿÿÿÿÿ÷"í"€ŽSÿÿÿÿÿÿ#j€>ÿÿÿÿÿÿ #"#@ÿÿÿÿÿÿ# #€‘ÿÿÿÿÿÿ#÷"#€’Sÿÿÿÿÿÿ'#œ€“>ÿÿÿÿÿÿ1#4'#@”ÿÿÿÿÿÿ;#1#€•ÿÿÿÿÿÿD##;#€–SÿÿÿÿÿÿN#΀—>ÿÿÿÿÿÿX#FN#@˜ÿÿÿÿÿÿb#X#€™ÿÿÿÿÿÿk#D#b#€šSÿÿÿÿÿÿu#€›>ÿÿÿÿÿÿ#Xu#@œÿÿÿÿÿÿ‰##€ÿÿÿÿÿÿ’#k#‰#€žSÿÿÿÿÿÿœ#*"€Ÿ>ÿÿÿÿÿÿ¦#œ#@ ÿÿÿÿÿÿ°#¦#€¡Sÿÿÿÿÿÿ¹#t"€¢>ÿÿÿÿÿÿÃ#"¹#@£ÿÿÿÿÿÿÍ#Ã#€¤ÿÿÿÿÿÿÖ#°#Í#€¥Sÿÿÿÿÿÿà#¦"€¦>ÿÿÿÿÿÿê#4à#@§ÿÿÿÿÿÿô#ê#€¨ÿÿÿÿÿÿý#Ö#ô#€©Sÿÿÿÿÿÿ$Ø"€ª>ÿÿÿÿÿÿ$F$@«ÿÿÿÿÿÿ$$€¬ÿÿÿÿÿÿ$$ý#$€­Sÿÿÿÿÿÿ.$ "€®>ÿÿÿÿÿÿ8$X.$@¯ÿÿÿÿÿÿB$8$€°ÿÿÿÿÿÿK$$$B$€±ÿÿÿÿÿÿU$’#K$€²Sÿÿÿÿÿÿ_$<4€³>ÿÿÿÿÿÿi$_$@´ÿÿÿÿÿÿs$i$€µSÿÿÿÿÿÿ|$~4€¶>ÿÿÿÿÿÿ†$"|$@·ÿÿÿÿÿÿ$†$€¸ÿÿÿÿÿÿ™$s$$€¹Sÿÿÿÿÿÿ£$°4€º>ÿÿÿÿÿÿ­$4£$@»ÿÿÿÿÿÿ·$­$€¼ÿÿÿÿÿÿÀ$™$·$€½SÿÿÿÿÿÿÊ$â4€¾>ÿÿÿÿÿÿÔ$FÊ$@¿ÿÿÿÿÿÿÞ$Ô$€Àÿÿÿÿÿÿç$À$Þ$€ÁSÿÿÿÿÿÿñ$4€Â>ÿÿÿÿÿÿû$Xñ$@Ãÿÿÿÿÿÿ%û$€Äÿÿÿÿÿÿ%ç$%€Åÿÿÿÿÿÿ%U$%€ÆSÿÿÿÿÿÿ"%NF€Ç>ÿÿÿÿÿÿ,%"%@Èÿÿÿÿÿÿ6%,%€ÉSÿÿÿÿÿÿ?%ˆF€Ê>ÿÿÿÿÿÿI%"?%@ËÿÿÿÿÿÿS%I%€Ìÿÿÿÿÿÿ\%6%S%€ÍSÿÿÿÿÿÿf%ºF€Î>ÿÿÿÿÿÿp%4f%@Ïÿÿÿÿÿÿz%p%€Ðÿÿÿÿÿÿƒ%\%z%€ÑSÿÿÿÿÿÿ%ìF€Ò>ÿÿÿÿÿÿ—%F%@Óÿÿÿÿÿÿ¡%—%€Ôÿÿÿÿÿÿª%ƒ%¡%€ÕSÿÿÿÿÿÿ´%F€Ö>ÿÿÿÿÿÿ¾%X´%@×ÿÿÿÿÿÿÈ%¾%€ØÿÿÿÿÿÿÑ%ª%È%€ÙÿÿÿÿÿÿÛ%%Ñ%€ÚSÿÿÿÿÿÿå%`X€Û>ÿÿÿÿÿÿï%å%@Üÿÿÿÿÿÿù%ï%€ÝSÿÿÿÿÿÿ&’X€Þ>ÿÿÿÿÿÿ &"&@ßÿÿÿÿÿÿ& &€àÿÿÿÿÿÿ&ù%&€áSÿÿÿÿÿÿ)&ÄX€â>ÿÿÿÿÿÿ3&4)&@ãÿÿÿÿÿÿ=&3&€äÿÿÿÿÿÿF&&=&€åSÿÿÿÿÿÿP&öX€æ>ÿÿÿÿÿÿZ&FP&@çÿÿÿÿÿÿd&Z&€èÿÿÿÿÿÿm&F&d&€éSÿÿÿÿÿÿw&(X€ê>ÿÿÿÿÿÿ&Xw&@ëÿÿÿÿÿÿ‹&&€ìÿÿÿÿÿÿ”&m&‹&€íÿÿÿÿÿÿž&Û%”&€îSÿÿÿÿÿÿ¨&*€ï>ÿÿÿÿÿÿ²&"¨&@ðÿÿÿÿÿÿ¼&²&€ñÿÿÿÿÿÿÅ&÷"¼&€òSÿÿÿÿÿÿÏ&<€ó>ÿÿÿÿÿÿÙ&4Ï&@ôÿÿÿÿÿÿã&Ù&€õÿÿÿÿÿÿì&Å&ã&€öSÿÿÿÿÿÿö&N€÷>ÿÿÿÿÿÿ'Fö&@øÿÿÿÿÿÿ ''€ùÿÿÿÿÿÿ'ì& '€úSÿÿÿÿÿÿ'`€û>ÿÿÿÿÿÿ''X'@üÿÿÿÿÿÿ1'''€ýÿÿÿÿÿÿ:''1'€þSÿÿÿÿÿÿD'j"€ÿ>ÿÿÿÿÿÿN'D'@ÿÿÿÿÿÿX'N'€ÿÿÿÿÿÿa'X'Í#€Sÿÿÿÿÿÿk'~"€>ÿÿÿÿÿÿu'4k'@ÿÿÿÿÿÿ'u'€ÿÿÿÿÿÿˆ'a''€Sÿÿÿÿÿÿ’'ˆ"€>ÿÿÿÿÿÿœ'F’'@ÿÿÿÿÿÿ¦'œ'€ ÿÿÿÿÿÿ¯'ˆ'¦'€ Sÿÿÿÿÿÿ¹'’"€ >ÿÿÿÿÿÿÃ'X¹'@ ÿÿÿÿÿÿÍ'Ã'€ ÿÿÿÿÿÿÖ'¯'Í'€ÿÿÿÿÿÿà':'Ö'€Sÿÿÿÿÿÿê'œ4€>ÿÿÿÿÿÿô'ê'@ÿÿÿÿÿÿþ'ô'€Sÿÿÿÿÿÿ(¦4€>ÿÿÿÿÿÿ("(@ÿÿÿÿÿÿ((€ÿÿÿÿÿÿ$(þ'(€ÿÿÿÿÿÿ.($(·$€Sÿÿÿÿÿÿ8(º4€>ÿÿÿÿÿÿB(F8(@ÿÿÿÿÿÿL(B(€ÿÿÿÿÿÿU(.(L(€Sÿÿÿÿÿÿ_(Ä4€>ÿÿÿÿÿÿi(X_(@ÿÿÿÿÿÿs(i(€ÿÿÿÿÿÿ|(U(s(€ÿÿÿÿÿÿ†(à'|(€ Sÿÿÿÿÿÿ(ÎF€!>ÿÿÿÿÿÿš((@"ÿÿÿÿÿÿ¤(š(€#Sÿÿÿÿÿÿ­(ØF€$>ÿÿÿÿÿÿ·("­(@%ÿÿÿÿÿÿÁ(·(€&ÿÿÿÿÿÿÊ(¤(Á(€'SÿÿÿÿÿÿÔ(âF€(>ÿÿÿÿÿÿÞ(4Ô(@)ÿÿÿÿÿÿè(Þ(€*ÿÿÿÿÿÿñ(Ê(è(€+ÿÿÿÿÿÿû(ñ(¡%€,Sÿÿÿÿÿÿ)öF€->ÿÿÿÿÿÿ)X)@.ÿÿÿÿÿÿ))€/ÿÿÿÿÿÿ")û()€0ÿÿÿÿÿÿ,)†(")€1Sÿÿÿÿÿÿ6)X€2>ÿÿÿÿÿÿ@)6)@3ÿÿÿÿÿÿJ)@)€4SÿÿÿÿÿÿS) X€5>ÿÿÿÿÿÿ])"S)@6ÿÿÿÿÿÿg)])€7ÿÿÿÿÿÿp)J)g)€8Sÿÿÿÿÿÿz)X€9>ÿÿÿÿÿÿ„)4z)@:ÿÿÿÿÿÿŽ)„)€;ÿÿÿÿÿÿ—)p)Ž)€<Sÿÿÿÿÿÿ¡)X€=>ÿÿÿÿÿÿ«)F¡)@>ÿÿÿÿÿÿµ)«)€?ÿÿÿÿÿÿ¾)—)µ)€@ÿÿÿÿÿÿÈ)¾)‹&€AÿÿÿÿÿÿÒ),)È)€BÿÿÿÿÿÿÜ)í" #€Cÿÿÿÿÿÿæ)Ü)1#€Dÿÿÿÿÿÿð)æ)X#€Eÿÿÿÿÿÿú)ð)#€Fÿÿÿÿÿÿ*¦#Ã#€Gÿÿÿÿÿÿ**ê#€Hÿÿÿÿÿÿ**$€Iÿÿÿÿÿÿ"**8$€Jÿÿÿÿÿÿ,*ú)"*€Kÿÿÿÿÿÿ6*i$†$€Lÿÿÿÿÿÿ@*6*­$€MÿÿÿÿÿÿJ*@*Ô$€NÿÿÿÿÿÿT*J*û$€Oÿÿÿÿÿÿ^*,*T*€Pÿÿÿÿÿÿh*,%I%€Qÿÿÿÿÿÿr*h*p%€Rÿÿÿÿÿÿ|*r*—%€Sÿÿÿÿÿÿ†*|*¾%€Tÿÿÿÿÿÿ*^*†*€Uÿÿÿÿÿÿš*ï% &€Vÿÿÿÿÿÿ¤*š*3&€Wÿÿÿÿÿÿ®*¤*Z&€Xÿÿÿÿÿÿ¸*®*&€YÿÿÿÿÿÿÂ**¸*€ZÿÿÿÿÿÿÌ*2ñ€[ÿÿÿÿÿÿÖ*ŒF€\ÿÿÿÿÿÿà*Ì*Ö*€]ÿÿÿÿÿÿê*ð¥€^ÿÿÿÿÿÿô*à*ê*€_ÿÿÿÿÿÿþ*T€`ÿÿÿÿÿÿ+ô*þ*€aÿÿÿÿÿÿ+¸c€bÿÿÿÿÿÿ+++€cÿÿÿÿÿÿ&+&ñ€dÿÿÿÿÿÿ0+€F€eÿÿÿÿÿÿ:+&+0+€fÿÿÿÿÿÿD+䥀gÿÿÿÿÿÿN+:+D+€hÿÿÿÿÿÿX+H€iÿÿÿÿÿÿb+N+X+€jÿÿÿÿÿÿl+¬c€kÿÿÿÿÿÿv+b+l+€lÿÿÿÿÿÿ€++v+€mÿÿÿÿÿÿŠ+.ñ€nÿÿÿÿÿÿ”+ˆF€oÿÿÿÿÿÿž+Š+”+€pÿÿÿÿÿÿ¨+쥀qÿÿÿÿÿÿ²+ž+¨+€rÿÿÿÿÿÿ¼+P€sÿÿÿÿÿÿÆ+²+¼+€tÿÿÿÿÿÿÐ+´c€uÿÿÿÿÿÿÚ+Æ+Ð+€vÿÿÿÿÿÿä+€+Ú+€wÿÿÿÿÿÿî+6ñ€xÿÿÿÿÿÿø+F€yÿÿÿÿÿÿ,î+ø+€zÿÿÿÿÿÿ ,ô¥€{ÿÿÿÿÿÿ,, ,€|ÿÿÿÿÿÿ ,X€}ÿÿÿÿÿÿ*,, ,€~ÿÿÿÿÿÿ4,¼c€ÿÿÿÿÿÿ>,*,4,€€ÿÿÿÿÿÿH,ä+>,€ÿÿÿÿÿÿR,> ñ€‚ÿÿÿÿÿÿ\,˜ F€ƒÿÿÿÿÿÿf,R,\,€„ÿÿÿÿÿÿp,ü ¥€…ÿÿÿÿÿÿz,f,p,€†ÿÿÿÿÿÿ„,` €‡ÿÿÿÿÿÿŽ,z,„,€ˆÿÿÿÿÿÿ˜,Ä c€‰ÿÿÿÿÿÿ¢,Ž,˜,€Šÿÿÿÿÿÿ¬,H,¢,€‹Sÿÿÿÿÿÿ¶,€Œ>ÿÿÿÿÿÿÀ,¶,@ÿÿÿÿÿÿÊ,À,€ŽSÿÿÿÿÿÿÓ,**€>ÿÿÿÿÿÿÝ,"Ó,@ÿÿÿÿÿÿç,Ý,€‘ÿÿÿÿÿÿð,Ê,ç,€’Sÿÿÿÿÿÿú,<<€“>ÿÿÿÿÿÿ-4ú,@”ÿÿÿÿÿÿ--€•ÿÿÿÿÿÿ-ð,-€–Sÿÿÿÿÿÿ!-NN€—>ÿÿÿÿÿÿ+-F!-@˜ÿÿÿÿÿÿ5-+-€™ÿÿÿÿÿÿ>--5-€šSÿÿÿÿÿÿH-``€›>ÿÿÿÿÿÿR-XH-@œÿÿÿÿÿÿ\-R-€ÿÿÿÿÿÿe->-\-€žSÿÿÿÿÿÿo-jj€Ÿ>ÿÿÿÿÿÿy-o-@ ÿÿÿÿÿÿƒ-y-€¡SÿÿÿÿÿÿŒ-tt€¢>ÿÿÿÿÿÿ–-"Œ-@£ÿÿÿÿÿÿ -–-€¤ÿÿÿÿÿÿ©-ƒ- -€¥Sÿÿÿÿÿÿ³-~~€¦>ÿÿÿÿÿÿ½-4³-@§ÿÿÿÿÿÿÇ-½-€¨ÿÿÿÿÿÿÐ-©-Ç-€©SÿÿÿÿÿÿÚ-ˆˆ€ª>ÿÿÿÿÿÿä-FÚ-@«ÿÿÿÿÿÿî-ä-€¬ÿÿÿÿÿÿ÷-Ð-î-€­Sÿÿÿÿÿÿ.’’€®>ÿÿÿÿÿÿ .X.@¯ÿÿÿÿÿÿ. .€°ÿÿÿÿÿÿ.÷-.€±ÿÿÿÿÿÿ(.e-.€²Sÿÿÿÿÿÿ2.œœ€³>ÿÿÿÿÿÿ<.2.@´ÿÿÿÿÿÿF.<.€µSÿÿÿÿÿÿO.¦¦€¶>ÿÿÿÿÿÿY."O.@·ÿÿÿÿÿÿc.Y.€¸ÿÿÿÿÿÿl.F.c.€¹Sÿÿÿÿÿÿv.°°€º>ÿÿÿÿÿÿ€.4v.@»ÿÿÿÿÿÿŠ.€.€¼ÿÿÿÿÿÿ“.l.Š.€½Sÿÿÿÿÿÿ.ºº€¾>ÿÿÿÿÿÿ§.F.@¿ÿÿÿÿÿÿ±.§.€Àÿÿÿÿÿÿº.“.±.€ÁSÿÿÿÿÿÿÄ.ÄÄ€Â>ÿÿÿÿÿÿÎ.XÄ.@ÃÿÿÿÿÿÿØ.Î.€Äÿÿÿÿÿÿá.º.Ø.€Åÿÿÿÿÿÿë.(.á.€ÆSÿÿÿÿÿÿõ.Î΀Ç>ÿÿÿÿÿÿÿ.õ.@Èÿÿÿÿÿÿ /ÿ.€ÉSÿÿÿÿÿÿ/ØØ€Ê>ÿÿÿÿÿÿ/"/@Ëÿÿÿÿÿÿ&//€Ìÿÿÿÿÿÿ// /&/€ÍSÿÿÿÿÿÿ9/ââ€Î>ÿÿÿÿÿÿC/49/@ÏÿÿÿÿÿÿM/C/€ÐÿÿÿÿÿÿV///M/€ÑSÿÿÿÿÿÿ`/ìì€Ò>ÿÿÿÿÿÿj/F`/@Óÿÿÿÿÿÿt/j/€Ôÿÿÿÿÿÿ}/V/t/€ÕSÿÿÿÿÿÿ‡/öö€Ö>ÿÿÿÿÿÿ‘/X‡/@×ÿÿÿÿÿÿ›/‘/€Øÿÿÿÿÿÿ¤/}/›/€Ùÿÿÿÿÿÿ®/ë.¤/€ÚSÿÿÿÿÿÿ¸/€Û>ÿÿÿÿÿÿÂ/¸/@ÜÿÿÿÿÿÿÌ/Â/€ÝSÿÿÿÿÿÿÕ/  €Þ>ÿÿÿÿÿÿß/"Õ/@ßÿÿÿÿÿÿé/ß/€àÿÿÿÿÿÿò/Ì/é/€áSÿÿÿÿÿÿü/€â>ÿÿÿÿÿÿ04ü/@ãÿÿÿÿÿÿ00€äÿÿÿÿÿÿ0ò/0€åSÿÿÿÿÿÿ#0€æ>ÿÿÿÿÿÿ-0F#0@çÿÿÿÿÿÿ70-0€èÿÿÿÿÿÿ@0070€éSÿÿÿÿÿÿJ0((€ê>ÿÿÿÿÿÿT0XJ0@ëÿÿÿÿÿÿ^0T0€ìÿÿÿÿÿÿg0@0^0€íÿÿÿÿÿÿq0®/g0€îSÿÿÿÿÿÿ{0€ï>ÿÿÿÿÿÿ…0{0@ðÿÿÿÿÿÿ0…0€ñSÿÿÿÿÿÿ˜0"*€ò>ÿÿÿÿÿÿ¢0˜0@óÿÿÿÿÿÿ¬0¢0€ôÿÿÿÿÿÿµ00¬0€õSÿÿÿÿÿÿ¿04<€ö>ÿÿÿÿÿÿÉ0¿0@÷ÿÿÿÿÿÿÓ0É0€øÿÿÿÿÿÿÜ0µ0Ó0€ùSÿÿÿÿÿÿæ0FN€ú>ÿÿÿÿÿÿð0æ0@ûÿÿÿÿÿÿú0ð0€üÿÿÿÿÿÿ1Ü0ú0€ýSÿÿÿÿÿÿ 1X`€þ>ÿÿÿÿÿÿ1 1@ÿÿÿÿÿÿÿ!11€ÿÿÿÿÿÿ*11!1€Sÿÿÿÿÿÿ41j€>ÿÿÿÿÿÿ>1"41@ÿÿÿÿÿÿH1>1€SÿÿÿÿÿÿQ1"t€>ÿÿÿÿÿÿ[1"Q1@ÿÿÿÿÿÿe1[1€ÿÿÿÿÿÿn1H1e1€Sÿÿÿÿÿÿx14~€ >ÿÿÿÿÿÿ‚1"x1@ ÿÿÿÿÿÿŒ1‚1€ ÿÿÿÿÿÿ•1n1Œ1€ SÿÿÿÿÿÿŸ1Fˆ€ >ÿÿÿÿÿÿ©1"Ÿ1@ÿÿÿÿÿÿ³1©1€ÿÿÿÿÿÿ¼1•1³1€SÿÿÿÿÿÿÆ1X’€>ÿÿÿÿÿÿÐ1"Æ1@ÿÿÿÿÿÿÚ1Ð1€ÿÿÿÿÿÿã1¼1Ú1€ÿÿÿÿÿÿí1*1ã1€Sÿÿÿÿÿÿ÷1œ€>ÿÿÿÿÿÿ24÷1@ÿÿÿÿÿÿ 22€Sÿÿÿÿÿÿ2"¦€>ÿÿÿÿÿÿ242@ÿÿÿÿÿÿ(22€ÿÿÿÿÿÿ12 2(2€Sÿÿÿÿÿÿ;24°€>ÿÿÿÿÿÿE24;2@ÿÿÿÿÿÿO2E2€ÿÿÿÿÿÿX212O2€ Sÿÿÿÿÿÿb2Fº€!>ÿÿÿÿÿÿl24b2@"ÿÿÿÿÿÿv2l2€#ÿÿÿÿÿÿ2X2v2€$Sÿÿÿÿÿÿ‰2XÄ€%>ÿÿÿÿÿÿ“24‰2@&ÿÿÿÿÿÿ2“2€'ÿÿÿÿÿÿ¦222€(ÿÿÿÿÿÿ°2í1¦2€)Sÿÿÿÿÿÿº2΀*>ÿÿÿÿÿÿÄ2Fº2@+ÿÿÿÿÿÿÎ2Ä2€,Sÿÿÿÿÿÿ×2"Ø€->ÿÿÿÿÿÿá2F×2@.ÿÿÿÿÿÿë2á2€/ÿÿÿÿÿÿô2Î2ë2€0Sÿÿÿÿÿÿþ24â€1>ÿÿÿÿÿÿ3Fþ2@2ÿÿÿÿÿÿ33€3ÿÿÿÿÿÿ3ô23€4Sÿÿÿÿÿÿ%3Fì€5>ÿÿÿÿÿÿ/3F%3@6ÿÿÿÿÿÿ93/3€7ÿÿÿÿÿÿB3393€8SÿÿÿÿÿÿL3Xö€9>ÿÿÿÿÿÿV3FL3@:ÿÿÿÿÿÿ`3V3€;ÿÿÿÿÿÿi3B3`3€<ÿÿÿÿÿÿs3°2i3€=Sÿÿÿÿÿÿ}3€>>ÿÿÿÿÿÿ‡3X}3@?ÿÿÿÿÿÿ‘3‡3€@Sÿÿÿÿÿÿš3" €A>ÿÿÿÿÿÿ¤3Xš3@Bÿÿÿÿÿÿ®3¤3€Cÿÿÿÿÿÿ·3‘3®3€DSÿÿÿÿÿÿÁ34€E>ÿÿÿÿÿÿË3XÁ3@FÿÿÿÿÿÿÕ3Ë3€GÿÿÿÿÿÿÞ3·3Õ3€HSÿÿÿÿÿÿè3F€I>ÿÿÿÿÿÿò3Xè3@Jÿÿÿÿÿÿü3ò3€Kÿÿÿÿÿÿ4Þ3ü3€LSÿÿÿÿÿÿ4X(€M>ÿÿÿÿÿÿ4X4@Nÿÿÿÿÿÿ#44€Oÿÿÿÿÿÿ,44#4€Pÿÿÿÿÿÿ64s3,4€Q>ÿÿÿÿÿÿ@4"o-@RÿÿÿÿÿÿJ4@4€SÿÿÿÿÿÿS4Ê,J4€T>ÿÿÿÿÿÿ]442.@Uÿÿÿÿÿÿg4]4€Vÿÿÿÿÿÿp4S4g4€W>ÿÿÿÿÿÿz4Fõ.@Xÿÿÿÿÿÿ„4z4€Yÿÿÿÿÿÿ4p4„4€Z>ÿÿÿÿÿÿ—4X¸/@[ÿÿÿÿÿÿ¡4—4€\ÿÿÿÿÿÿª44¡4€]>ÿÿÿÿÿÿ´4Ó,@^ÿÿÿÿÿÿ¾4´4€_ÿÿÿÿÿÿÇ4¾4 -€`>ÿÿÿÿÿÿÑ44O.@aÿÿÿÿÿÿÛ4Ñ4€bÿÿÿÿÿÿä4Ç4Û4€c>ÿÿÿÿÿÿî4F/@dÿÿÿÿÿÿø4î4€eÿÿÿÿÿÿ5ä4ø4€f>ÿÿÿÿÿÿ 5XÕ/@gÿÿÿÿÿÿ5 5€hÿÿÿÿÿÿ555€iÿÿÿÿÿÿ(5ª45€j>ÿÿÿÿÿÿ25ú,@kÿÿÿÿÿÿ<525€l>ÿÿÿÿÿÿE5"³-@mÿÿÿÿÿÿO5E5€nÿÿÿÿÿÿX5<5O5€oÿÿÿÿÿÿb5X5Š.€p>ÿÿÿÿÿÿl5F9/@qÿÿÿÿÿÿv5l5€rÿÿÿÿÿÿ5b5v5€s>ÿÿÿÿÿÿ‰5Xü/@tÿÿÿÿÿÿ“5‰5€uÿÿÿÿÿÿœ55“5€vÿÿÿÿÿÿ¦5(5œ5€w>ÿÿÿÿÿÿ°5!-@xÿÿÿÿÿÿº5°5€y>ÿÿÿÿÿÿÃ5"Ú-@zÿÿÿÿÿÿÍ5Ã5€{ÿÿÿÿÿÿÖ5º5Í5€|>ÿÿÿÿÿÿà54.@}ÿÿÿÿÿÿê5à5€~ÿÿÿÿÿÿó5Ö5ê5€ÿÿÿÿÿÿý5ó5t/€€>ÿÿÿÿÿÿ6X#0@ÿÿÿÿÿÿ66€‚ÿÿÿÿÿÿ6ý56€ƒÿÿÿÿÿÿ$6¦56€„>ÿÿÿÿÿÿ.6H-@…ÿÿÿÿÿÿ86.6€†>ÿÿÿÿÿÿA6".@‡ÿÿÿÿÿÿK6A6€ˆÿÿÿÿÿÿT686K6€‰>ÿÿÿÿÿÿ^64Ä.@Šÿÿÿÿÿÿh6^6€‹ÿÿÿÿÿÿq6T6h6€Œ>ÿÿÿÿÿÿ{6F‡/@ÿÿÿÿÿÿ…6{6€ŽÿÿÿÿÿÿŽ6q6…6€ÿÿÿÿÿÿ˜6Ž6^0€ÿÿÿÿÿÿ¢6$6˜6€‘ÿÿÿÿÿÿ¬6w4€’ÿÿÿÿÿÿ¶6¦¬6€“ÿÿÿÿÿÿÀ6‰ú€”ÿÿÿÿÿÿÊ6¶6À6€•ÿÿÿÿÿÿÔ6›À€–ÿÿÿÿÿÿÞ6Ê6Ô6€—ÿÿÿÿÿÿè6­†€˜ÿÿÿÿÿÿò6Þ6è6€™ÿÿÿÿÿÿü6¯€šÿÿÿÿÿÿ7Kü6€›ÿÿÿÿÿÿ7¿0€œÿÿÿÿÿÿ777€ÿÿÿÿÿÿ$7Ñö€žÿÿÿÿÿÿ.77$7€Ÿÿÿÿÿÿÿ87ã¼€ ÿÿÿÿÿÿB7.787€¡ÿÿÿÿÿÿL7ò6B7€¢ÿÿÿÿÿÿV7Ès€£ÿÿÿÿÿÿ`7¥V7€¤ÿÿÿÿÿÿj7Âv€¥ÿÿÿÿÿÿt7`7j7€¦ÿÿÿÿÿÿ~7õ€§ÿÿÿÿÿÿˆ7t7~7€¨ÿÿÿÿÿÿ’7à€©ÿÿÿÿÿÿœ7ˆ7’7€ªÿÿÿÿÿÿ¦7L7œ7€«ÿÿÿÿÿÿ°7Ú…€¬ÿÿÿÿÿÿº7ÿ°7€­ÿÿÿÿÿÿÄ7þ]€®ÿÿÿÿÿÿÎ7º7Ä7€¯ÿÿÿÿÿÿØ7Õ耰ÿÿÿÿÿÿâ7Î7Ø7€±ÿÿÿÿÿÿì7ò€²ÿÿÿÿÿÿö7â7ì7€³ÿÿÿÿÿÿ8¦7ö7€´ÿÿÿÿÿÿ 8ì—€µÿÿÿÿÿÿ8Y 8€¶ÿÿÿÿÿÿ8o€·ÿÿÿÿÿÿ(888€¸ÿÿÿÿÿÿ28"5€¹ÿÿÿÿÿÿ<8(828€ºÿÿÿÿÿÿF8èZ€»ÿÿÿÿÿÿP8<8F8€¼ÿÿÿÿÿÿZ88P8€½ÿÿÿÿÿÿd8û¦€¾ÿÿÿÿÿÿn8d8³€¿ÿÿÿÿÿÿx8=ú€Àÿÿÿÿÿÿ‚8n8x8€ÁÿÿÿÿÿÿŒ8OÀ€Âÿÿÿÿÿÿ–8‚8Œ8€Ãÿÿÿÿÿÿ 8a†€Äÿÿÿÿÿÿª8–8 8€Åÿÿÿÿÿÿ´84w€Æÿÿÿÿÿÿ¾8´8€ÇÿÿÿÿÿÿÈ8s0€ÈÿÿÿÿÿÿÒ8¾8È8€ÉÿÿÿÿÿÿÜ8…ö€Êÿÿÿÿÿÿæ8Ò8Ü8€Ëÿÿÿÿÿÿð8—¼€Ìÿÿÿÿÿÿú8æ8ð8€Íÿÿÿÿÿÿ9ª8ú8€Îÿÿÿÿÿÿ9F‰€Ïÿÿÿÿÿÿ99g€Ðÿÿÿÿÿÿ"9v€Ñÿÿÿÿÿÿ,99"9€Òÿÿÿÿÿÿ69©€Óÿÿÿÿÿÿ@9,969€ÔÿÿÿÿÿÿJ9»à€ÕÿÿÿÿÿÿT9@9J9€Öÿÿÿÿÿÿ^99T9€×ÿÿÿÿÿÿh9X›€Øÿÿÿÿÿÿr9h9Á€Ùÿÿÿÿÿÿ|9²]€Úÿÿÿÿÿÿ†9r9|9€Ûÿÿÿÿÿÿ9*è€Üÿÿÿÿÿÿš9†99€Ýÿÿÿÿÿÿ¤9Íò€Þÿÿÿÿÿÿ®9š9¤9€ßÿÿÿÿÿÿ¸9^9®9€àÿÿÿÿÿÿÂ9j­€áÿÿÿÿÿÿÌ9Â9€âÿÿÿÿÿÿÖ9Äo€ãÿÿÿÿÿÿà9Ì9Ö9€äÿÿÿÿÿÿê9Ö5€åÿÿÿÿÿÿô9à9ê9€æÿÿÿÿÿÿþ9=Z€çÿÿÿÿÿÿ:ô9þ9€èÿÿÿÿÿÿ:¸9:€éÿÿÿÿÿÿ:Z8:€êÿÿÿÿÿÿ&:Z¦€ëÿÿÿÿÿÿ0:ß4€ìÿÿÿÿÿÿ::&:0:€íÿÿÿÿÿÿD:::‰€îÿÿÿÿÿÿN:À€ïÿÿÿÿÿÿX:D:N:€ðÿÿÿÿÿÿb:†€ñÿÿÿÿÿÿl:X:b:€òÿÿÿÿÿÿv:èw€óÿÿÿÿÿÿ€:c€ôÿÿÿÿÿÿŠ:v:€:€õÿÿÿÿÿÿ”:Š:Ù€öÿÿÿÿÿÿž:9ö€÷ÿÿÿÿÿÿ¨:”:ž:€øÿÿÿÿÿÿ²:K¼€ùÿÿÿÿÿÿ¼:¨:²:€úÿÿÿÿÿÿÆ:l:¼:€ûÿÿÿÿÿÿÐ:ú‰€üÿÿÿÿÿÿÚ:0s€ýÿÿÿÿÿÿä:Ð:Ú:€þÿÿÿÿÿÿî:ä:v€ÿÿÿÿÿÿÿø:]€ÿÿÿÿÿÿ;î:ø:€ÿÿÿÿÿÿ ;oà€ÿÿÿÿÿÿ;; ;€ÿÿÿÿÿÿ ;Æ:;€ÿÿÿÿÿÿ*; ›€ÿÿÿÿÿÿ4;B…€ÿÿÿÿÿÿ>;*;4;€ÿÿÿÿÿÿH;>;—€ÿÿÿÿÿÿR;‰è€ ÿÿÿÿÿÿ\;H;R;€ ÿÿÿÿÿÿf;ò€ ÿÿÿÿÿÿp;\;f;€ ÿÿÿÿÿÿz; ;p;€ ÿÿÿÿÿÿ„;­€ÿÿÿÿÿÿŽ;T—€ÿÿÿÿÿÿ˜;„;Ž;€ÿÿÿÿÿÿ¢;˜;ñ€ÿÿÿÿÿÿ¬;Š5€ÿÿÿÿÿÿ¶;¢;¬;€ÿÿÿÿÿÿÀ;œZ€ÿÿÿÿÿÿÊ;¶;À;€ÿÿÿÿÿÿÔ;z;Ê;€ÿÿÿÿÿÿÞ;:Ô;€ÿÿÿÿÿÿè;¹¦€ÿÿÿÿÿÿò;“4€ÿÿÿÿÿÿü;è;ò;€ÿÿÿÿÿÿ<¥ú€ÿÿÿÿÿÿ<ü;<€ÿÿÿÿÿÿ<<_€ÿÿÿÿÿÿ$<Ɇ€ÿÿÿÿÿÿ.<<$<€ÿÿÿÿÿÿ8<œw€ ÿÿÿÿÿÿB<€!ÿÿÿÿÿÿL<8<B<€"ÿÿÿÿÿÿV<Û0€#ÿÿÿÿÿÿ`<L<V<€$ÿÿÿÿÿÿj<`<¯€%ÿÿÿÿÿÿt<ÿ¼€&ÿÿÿÿÿÿ~<j<t<€'ÿÿÿÿÿÿˆ<.<~<€(ÿÿÿÿÿÿ’<®‰€)ÿÿÿÿÿÿœ<äs€*ÿÿÿÿÿÿ¦<’<œ<€+ÿÿÿÿÿÿ°<Õv€,ÿÿÿÿÿÿº<¦<°<€-ÿÿÿÿÿÿÄ<º< €.ÿÿÿÿÿÿÎ<#à€/ÿÿÿÿÿÿØ<Ä<Î<€0ÿÿÿÿÿÿâ<ˆ<Ø<€1ÿÿÿÿÿÿì<À›€2ÿÿÿÿÿÿö<ö…€3ÿÿÿÿÿÿ=ì<ö<€4ÿÿÿÿÿÿ =]€5ÿÿÿÿÿÿ== =€6ÿÿÿÿÿÿ==è€7ÿÿÿÿÿÿ(=5ò€8ÿÿÿÿÿÿ2==(=€9ÿÿÿÿÿÿ<=â<2=€:ÿÿÿÿÿÿF=Ò­€;ÿÿÿÿÿÿP=—€<ÿÿÿÿÿÿZ=F=P=€=ÿÿÿÿÿÿd=,o€>ÿÿÿÿÿÿn=Z=d=€?ÿÿÿÿÿÿx=n=Ç €@ÿÿÿÿÿÿ‚=ûZ€AÿÿÿÿÿÿŒ=x=‚=€Bÿÿÿÿÿÿ–=<=Œ=€Cÿÿÿÿÿÿ =Þ;–=€Dÿÿÿÿÿÿª=¦€Eÿÿÿÿÿÿ´=G4€Fÿÿÿÿÿÿ¾=ª=´=€GÿÿÿÿÿÿÈ=Yú€HÿÿÿÿÿÿÒ=¾=È=€IÿÿÿÿÿÿÜ=kÀ€Jÿÿÿÿÿÿæ=Ò=Ü=€Kÿÿÿÿÿÿð=æ=5!€Lÿÿÿÿÿÿú=Pw€Mÿÿÿÿÿÿ>!€Nÿÿÿÿÿÿ>ú=>€Oÿÿÿÿÿÿ>0€Pÿÿÿÿÿÿ">>>€Qÿÿÿÿÿÿ,>¡ö€Rÿÿÿÿÿÿ6>">,>€Sÿÿÿÿÿÿ@>6>…!€TÿÿÿÿÿÿJ>ð=@>€UÿÿÿÿÿÿT>b‰€Vÿÿÿÿÿÿ^>˜s€Wÿÿÿÿÿÿh>T>^>€Xÿÿÿÿÿÿr>4v€Yÿÿÿÿÿÿ|>h>r>€Zÿÿÿÿÿÿ†>Å€[ÿÿÿÿÿÿ>|>†>€\ÿÿÿÿÿÿš>>ß!€]ÿÿÿÿÿÿ¤>J>š>€^ÿÿÿÿÿÿ®>t›€_ÿÿÿÿÿÿ¸>ª…€`ÿÿÿÿÿÿÂ>®>¸>€aÿÿÿÿÿÿÌ>Î]€bÿÿÿÿÿÿÖ>Â>Ì>€cÿÿÿÿÿÿà>Gè€dÿÿÿÿÿÿê>Ö>à>€eÿÿÿÿÿÿô>ê>9"€fÿÿÿÿÿÿþ>¤>ô>€gÿÿÿÿÿÿ?†­€hÿÿÿÿÿÿ?¼—€iÿÿÿÿÿÿ???€jÿÿÿÿÿÿ&?ào€kÿÿÿÿÿÿ0??&?€lÿÿÿÿÿÿ:?ò5€mÿÿÿÿÿÿD?0?:?€nÿÿÿÿÿÿN?D?Z€oÿÿÿÿÿÿX?þ>N?€pÿÿÿÿÿÿb? =X?€qSÿÿÿÿÿÿl?*€r>ÿÿÿÿÿÿv?"l?€sÿÿÿÿÿÿ€?…0v?€tSÿÿÿÿÿÿŠ?<€u>ÿÿÿÿÿÿ”?4Š?€vÿÿÿÿÿÿž?€?”?€wSÿÿÿÿÿÿ¨?N€x>ÿÿÿÿÿÿ²?F¨?€yÿÿÿÿÿÿ¼?ž?²?€zSÿÿÿÿÿÿÆ?`€{>ÿÿÿÿÿÿÐ?XÆ?€|ÿÿÿÿÿÿÚ?¼?Ð?€}Sÿÿÿÿÿÿä?"j€~>ÿÿÿÿÿÿî?ä?€ÿÿÿÿÿÿø?î?[1€€Sÿÿÿÿÿÿ@"~€>ÿÿÿÿÿÿ @4@€‚ÿÿÿÿÿÿ@ø? @€ƒSÿÿÿÿÿÿ @"ˆ€„>ÿÿÿÿÿÿ*@F @€…ÿÿÿÿÿÿ4@@*@€†Sÿÿÿÿÿÿ>@"’€‡>ÿÿÿÿÿÿH@X>@€ˆÿÿÿÿÿÿR@4@H@€‰ÿÿÿÿÿÿ\@Ú?R@€ŠSÿÿÿÿÿÿf@4œ€‹>ÿÿÿÿÿÿp@f@€ŒSÿÿÿÿÿÿz@4¦€>ÿÿÿÿÿÿ„@"z@€ŽÿÿÿÿÿÿŽ@p@„@€ÿÿÿÿÿÿ˜@Ž@E2€Sÿÿÿÿÿÿ¢@4º€‘>ÿÿÿÿÿÿ¬@F¢@€’ÿÿÿÿÿÿ¶@˜@¬@€“SÿÿÿÿÿÿÀ@4Ä€”>ÿÿÿÿÿÿÊ@XÀ@€•ÿÿÿÿÿÿÔ@¶@Ê@€–ÿÿÿÿÿÿÞ@\@Ô@€—Sÿÿÿÿÿÿè@F΀˜>ÿÿÿÿÿÿò@è@€™Sÿÿÿÿÿÿü@FØ€š>ÿÿÿÿÿÿA"ü@€›ÿÿÿÿÿÿAò@A€œSÿÿÿÿÿÿAFâ€>ÿÿÿÿÿÿ$A4A€žÿÿÿÿÿÿ.AA$A€Ÿÿÿÿÿÿÿ8A.A/3€ SÿÿÿÿÿÿBAFö€¡>ÿÿÿÿÿÿLAXBA€¢ÿÿÿÿÿÿVA8ALA€£ÿÿÿÿÿÿ`AÞ@VA€¤SÿÿÿÿÿÿjAX€¥>ÿÿÿÿÿÿtAjA€¦Sÿÿÿÿÿÿ~AX €§>ÿÿÿÿÿÿˆA"~A€¨ÿÿÿÿÿÿ’AtAˆA€©SÿÿÿÿÿÿœAX€ª>ÿÿÿÿÿÿ¦A4œA€«ÿÿÿÿÿÿ°A’A¦A€¬SÿÿÿÿÿÿºAX€­>ÿÿÿÿÿÿÄAFºA€®ÿÿÿÿÿÿÎA°AÄA€¯ÿÿÿÿÿÿØAÎA4€°ÿÿÿÿÿÿâA`AØA€±SÿÿÿÿÿÿìA"€²>ÿÿÿÿÿÿöA"ìA@³ÿÿÿÿÿÿBöA€´ÿÿÿÿÿÿ B0B€µSÿÿÿÿÿÿB4€¶>ÿÿÿÿÿÿB4B@·ÿÿÿÿÿÿ'BB€¸ÿÿÿÿÿÿ0B B'B€¹Sÿÿÿÿÿÿ:BF€º>ÿÿÿÿÿÿDBF:B@»ÿÿÿÿÿÿNBDB€¼ÿÿÿÿÿÿWB0BNB€½SÿÿÿÿÿÿaBX€¾>ÿÿÿÿÿÿkBXaB@¿ÿÿÿÿÿÿuBkB€Àÿÿÿÿÿÿ~BWBuB€ÁSÿÿÿÿÿÿˆBt€Â>ÿÿÿÿÿÿ’BˆB@ÃÿÿÿÿÿÿœB’B€Äÿÿÿÿÿÿ¥BœBe1€ÅSÿÿÿÿÿÿ¯B4t€Æ>ÿÿÿÿÿÿ¹B4¯B@ÇÿÿÿÿÿÿÃB¹B€ÈÿÿÿÿÿÿÌB¥BÃB€ÉSÿÿÿÿÿÿÖBFt€Ê>ÿÿÿÿÿÿàBFÖB@ËÿÿÿÿÿÿêBàB€ÌÿÿÿÿÿÿóBÌBêB€ÍSÿÿÿÿÿÿýBXt€Î>ÿÿÿÿÿÿCXýB@ÏÿÿÿÿÿÿCC€ÐÿÿÿÿÿÿCóBC€Ñÿÿÿÿÿÿ$C~BC€ÒSÿÿÿÿÿÿ.C°€Ó>ÿÿÿÿÿÿ8C.C@ÔÿÿÿÿÿÿBC8C€ÕSÿÿÿÿÿÿKC"°€Ö>ÿÿÿÿÿÿUC"KC@×ÿÿÿÿÿÿ_CUC€ØÿÿÿÿÿÿhCBC_C€ÙÿÿÿÿÿÿrChCO2€ÚSÿÿÿÿÿÿ|CF°€Û>ÿÿÿÿÿÿ†CF|C@ÜÿÿÿÿÿÿC†C€Ýÿÿÿÿÿÿ™CrCC€ÞSÿÿÿÿÿÿ£CX°€ß>ÿÿÿÿÿÿ­CX£C@àÿÿÿÿÿÿ·C­C€áÿÿÿÿÿÿÀC™C·C€âÿÿÿÿÿÿÊC$CÀC€ãSÿÿÿÿÿÿÔCì€ä>ÿÿÿÿÿÿÞCÔC@åÿÿÿÿÿÿèCÞC€æSÿÿÿÿÿÿñC"ì€ç>ÿÿÿÿÿÿûC"ñC@èÿÿÿÿÿÿDûC€éÿÿÿÿÿÿDèCD€êSÿÿÿÿÿÿD4ì€ë>ÿÿÿÿÿÿ"D4D@ìÿÿÿÿÿÿ,D"D€íÿÿÿÿÿÿ5DD,D€îÿÿÿÿÿÿ?D5D93€ïSÿÿÿÿÿÿIDXì€ð>ÿÿÿÿÿÿSDXID@ñÿÿÿÿÿÿ]DSD€òÿÿÿÿÿÿfD?D]D€óÿÿÿÿÿÿpDÊCfD€ôSÿÿÿÿÿÿzD(€õ>ÿÿÿÿÿÿ„DzD@öÿÿÿÿÿÿŽD„D€÷Sÿÿÿÿÿÿ—D"(€ø>ÿÿÿÿÿÿ¡D"—D@ùÿÿÿÿÿÿ«D¡D€úÿÿÿÿÿÿ´DŽD«D€ûSÿÿÿÿÿÿ¾D4(€ü>ÿÿÿÿÿÿÈD4¾D@ýÿÿÿÿÿÿÒDÈD€þÿÿÿÿÿÿÛD´DÒD€ÿSÿÿÿÿÿÿåDF(€>ÿÿÿÿÿÿïDFåD@ÿÿÿÿÿÿùDïD€ÿÿÿÿÿÿEÛDùD€ÿÿÿÿÿÿ EE#4€ÿÿÿÿÿÿEpD E€ÿÿÿÿÿÿ E¦+€ÿÿÿÿÿÿ*E Eñ€ÿÿÿÿÿÿ4E*E·€ÿÿÿÿÿÿ>E4E}€ ÿÿÿÿÿÿHE€€ ÿÿÿÿÿÿREHE'€ ÿÿÿÿÿÿ\EREí€ ÿÿÿÿÿÿfE\E³€ ÿÿÿÿÿÿpE>EfE€ÿÿÿÿÿÿzE’|€ÿÿÿÿÿÿ„EzEv€ÿÿÿÿÿÿŽE„E€ÿÿÿÿÿÿ˜EŽE×€ÿÿÿÿÿÿ¢EpE˜E€ÿÿÿÿÿÿ¬E¤Ž€ÿÿÿÿÿÿ¶E¬Ef€ÿÿÿÿÿÿÀE¶Eè€ÿÿÿÿÿÿÊEÀEé€ÿÿÿÿÿÿÔE¢EÊE€ÿÿÿÿÿÿÞE¶ €ÿÿÿÿÿÿèEÞEx€ÿÿÿÿÿÿòEèE>€ÿÿÿÿÿÿüEòEZ€ÿÿÿÿÿÿFÔEüE€ÿÿÿÿÿÿF¦2€ÿÿÿÿÿÿFw€ÿÿÿÿÿÿ$FFF€ ÿÿÿÿÿÿ.F‰€!ÿÿÿÿÿÿ8F$F.F€"ÿÿÿÿÿÿBF›€#ÿÿÿÿÿÿLF8FBF€$ÿÿÿÿÿÿVF­ø€%ÿÿÿÿÿÿ`FLFVF€&ÿÿÿÿÿÿjF€Œ€'ÿÿÿÿÿÿtF¯v€(ÿÿÿÿÿÿ~FjFtF€)ÿÿÿÿÿÿˆF¿j€*ÿÿÿÿÿÿ’F~FˆF€+ÿÿÿÿÿÿœFÑ^€,ÿÿÿÿÿÿ¦F’FœF€-ÿÿÿÿÿÿ°FãR €.ÿÿÿÿÿÿºF¦F°F€/ÿÿÿÿÿÿÄF`FºF€0ÿÿÿÿÿÿÎF’ð€1ÿÿÿÿÿÿØFÈÚ€2ÿÿÿÿÿÿâFÎFØF€3ÿÿÿÿÿÿìFÂ΀4ÿÿÿÿÿÿöFâFìF€5ÿÿÿÿÿÿGõ€6ÿÿÿÿÿÿ GöFG€7ÿÿÿÿÿÿG¶ €8ÿÿÿÿÿÿG GG€9ÿÿÿÿÿÿ(GÄFG€:ÿÿÿÿÿÿ2G¤T€;ÿÿÿÿÿÿ€<ÿÿÿÿÿÿFG2GÿÿÿÿÿÿZGFGPG€?ÿÿÿÿÿÿdGÕ&€@ÿÿÿÿÿÿnGZGdG€AÿÿÿÿÿÿxG €Bÿÿÿÿÿÿ‚GnGxG€CÿÿÿÿÿÿŒG(G‚G€Dÿÿÿÿÿÿ–G¶¸€Eÿÿÿÿÿÿ G좀FÿÿÿÿÿÿªG–G G€Gÿÿÿÿÿÿ´G–€Hÿÿÿÿÿÿ¾GªG´G€IÿÿÿÿÿÿÈG"Š€JÿÿÿÿÿÿÒG¾GÈG€KÿÿÿÿÿÿÜGè~ €LÿÿÿÿÿÿæGÒGÜG€MÿÿÿÿÿÿðGŒGæG€NÿÿÿÿÿÿúGû<€OÿÿÿÿÿÿH+&€PÿÿÿÿÿÿHúGH€QÿÿÿÿÿÿH=€Rÿÿÿÿÿÿ"HHH€Sÿÿÿÿÿÿ,HO€Tÿÿÿÿÿÿ6H"H,H€Uÿÿÿÿÿÿ@Ha €VÿÿÿÿÿÿJH6H@H€WÿÿÿÿÿÿTH4–€Xÿÿÿÿÿÿ^H€€YÿÿÿÿÿÿhHTH^H€ZÿÿÿÿÿÿrHst€[ÿÿÿÿÿÿ|HhHrH€\ÿÿÿÿÿÿ†H…h€]ÿÿÿÿÿÿH|H†H€^ÿÿÿÿÿÿšH—\ €_ÿÿÿÿÿÿ¤HHšH€`ÿÿÿÿÿÿ®HJH¤H€aÿÿÿÿÿÿ¸HFú€bÿÿÿÿÿÿÂH|ä€cÿÿÿÿÿÿÌH¸HÂH€dÿÿÿÿÿÿÖHØ€eÿÿÿÿÿÿàHÌHÖH€fÿÿÿÿÿÿêH©Ì€gÿÿÿÿÿÿôHàHêH€hÿÿÿÿÿÿþH»À €iÿÿÿÿÿÿIôHþH€jÿÿÿÿÿÿI®HI€kÿÿÿÿÿÿIX^€lÿÿÿÿÿÿ&IŽH€mÿÿÿÿÿÿ0II&I€nÿÿÿÿÿÿ:I²<€oÿÿÿÿÿÿDI0I:I€pÿÿÿÿÿÿNI*0€qÿÿÿÿÿÿXIDINI€rÿÿÿÿÿÿbIÍ$ €sÿÿÿÿÿÿlIXIbI€tÿÿÿÿÿÿvIIlI€uÿÿÿÿÿÿ€Ij€vÿÿÿÿÿÿŠI ¬€wÿÿÿÿÿÿ”I€IŠI€xÿÿÿÿÿÿžIÄ €yÿÿÿÿÿÿ¨I”IžI€zÿÿÿÿÿÿ²IÖ”€{ÿÿÿÿÿÿ¼I¨I²I€|ÿÿÿÿÿÿÆI=ˆ €}ÿÿÿÿÿÿÐI¼IÆI€~ÿÿÿÿÿÿÚIvIÐI€ÿÿÿÿÿÿäIðGÚI€€ÿÿÿÿÿÿîIZP€ÿÿÿÿÿÿøIß:€‚ÿÿÿÿÿÿJîIøI€ƒÿÿÿÿÿÿ Jñ.€„ÿÿÿÿÿÿJJ J€…ÿÿÿÿÿÿ J"€†ÿÿÿÿÿÿ*JJ J€‡ÿÿÿÿÿÿ4J €ˆÿÿÿÿÿÿ>J*J4J€‰ÿÿÿÿÿÿHJ誀ŠÿÿÿÿÿÿRJc”€‹ÿÿÿÿÿÿ\JHJRJ€ŒÿÿÿÿÿÿfJ'ˆ€ÿÿÿÿÿÿpJ\JfJ€ŽÿÿÿÿÿÿzJ9|€ÿÿÿÿÿÿ„JpJzJ€ÿÿÿÿÿÿŽJKp €‘ÿÿÿÿÿÿ˜J„JŽJ€’ÿÿÿÿÿÿ¢J>J˜J€“ÿÿÿÿÿÿ¬Jú€”ÿÿÿÿÿÿ¶J0ø€•ÿÿÿÿÿÿÀJ¬J¶J€–ÿÿÿÿÿÿÊJv쀗ÿÿÿÿÿÿÔJÀJÊJ€˜ÿÿÿÿÿÿÞJ]à€™ÿÿÿÿÿÿèJÔJÞJ€šÿÿÿÿÿÿòJoÔ €›ÿÿÿÿÿÿüJèJòJ€œÿÿÿÿÿÿK¢JüJ€ÿÿÿÿÿÿK r€žÿÿÿÿÿÿKB\€Ÿÿÿÿÿÿÿ$KKK€ ÿÿÿÿÿÿ.KfP€¡ÿÿÿÿÿÿ8K$K.K€¢ÿÿÿÿÿÿBK‰D€£ÿÿÿÿÿÿLK8KBK€¤ÿÿÿÿÿÿVK8 €¥ÿÿÿÿÿÿ`KLKVK€¦ÿÿÿÿÿÿjKK`K€§ÿÿÿÿÿÿtKÖ€¨ÿÿÿÿÿÿ~KTÀ€©ÿÿÿÿÿÿˆKtK~K€ªÿÿÿÿÿÿ’Kx´€«ÿÿÿÿÿÿœKˆK’K€¬ÿÿÿÿÿÿ¦KŠ¨€­ÿÿÿÿÿÿ°KœK¦K€®ÿÿÿÿÿÿºKœœ €¯ÿÿÿÿÿÿÄK°KºK€°ÿÿÿÿÿÿÎKjKÄK€±ÿÿÿÿÿÿØKäIÎK€²ÿÿÿÿÿÿâK¹d€³ÿÿÿÿÿÿìK“N€´ÿÿÿÿÿÿöKâKìK€µÿÿÿÿÿÿL¥B€¶ÿÿÿÿÿÿ LöKL€·ÿÿÿÿÿÿL·6€¸ÿÿÿÿÿÿL LL€¹ÿÿÿÿÿÿ(LÉ* €ºÿÿÿÿÿÿ2LL(L€»ÿÿÿÿÿÿ¼€ßÿÿÿÿÿÿ¤MMšM€àÿÿÿÿÿÿ®Mû° €áÿÿÿÿÿÿ¸M¤M®M€âÿÿÿÿÿÿÂM^M¸M€ãÿÿÿÿÿÿÌMØKÂM€äÿÿÿÿÿÿÖMx€åÿÿÿÿÿÿàMGb€æÿÿÿÿÿÿêMÖMàM€çÿÿÿÿÿÿôMYV€èÿÿÿÿÿÿþMêMôM€éÿÿÿÿÿÿNkJ€êÿÿÿÿÿÿNþMN€ëÿÿÿÿÿÿN}> €ìÿÿÿÿÿÿ&NNN€íÿÿÿÿÿÿ0NPÒ€îÿÿÿÿÿÿ:N!¼€ïÿÿÿÿÿÿDN0N:N€ðÿÿÿÿÿÿNN°€ñÿÿÿÿÿÿXNDNNN€òÿÿÿÿÿÿbN¡¤€óÿÿÿÿÿÿlNXNbN€ôÿÿÿÿÿÿvN³˜ €õÿÿÿÿÿÿ€NlNvN€öÿÿÿÿÿÿŠN&N€N€÷ÿÿÿÿÿÿ”Nb6€øÿÿÿÿÿÿžN˜ €ùÿÿÿÿÿÿ¨N”NžN€úÿÿÿÿÿÿ²N4€ûÿÿÿÿÿÿ¼N¨N²N€üÿÿÿÿÿÿÆNÅ€ýÿÿÿÿÿÿÐN¼NÆN€þÿÿÿÿÿÿÚN×ü €ÿÿÿÿÿÿÿäNÐNÚN€ÿÿÿÿÿÿîNŠNäN€ÿÿÿÿÿÿøNtš€ÿÿÿÿÿÿOª„€ÿÿÿÿÿÿ OøNO€ÿÿÿÿÿÿOÎx€ÿÿÿÿÿÿ O OO€ÿÿÿÿÿÿ*OGl€ÿÿÿÿÿÿ4O O*O€ÿÿÿÿÿÿ>Oé` € ÿÿÿÿÿÿHO4O>O€ ÿÿÿÿÿÿROîNHO€ ÿÿÿÿÿÿ\O†þ€ ÿÿÿÿÿÿfO¼è€ ÿÿÿÿÿÿpO\OfO€ÿÿÿÿÿÿzOàÜ€ÿÿÿÿÿÿ„OpOzO€ÿÿÿÿÿÿŽOòЀÿÿÿÿÿÿ˜O„OŽO€ÿÿÿÿÿÿ¢OZÄ €ÿÿÿÿÿÿ¬O˜O¢O€ÿÿÿÿÿÿ¶ORO¬O€ÿÿÿÿÿÿÀOÌM¶O€ÿÿÿÿÿÿÊO2¦€ÿÿÿÿÿÿÔOŒû€ÿÿÿÿÿÿÞOÊOÔO€ÿÿÿÿÿÿèOðZ€ÿÿÿÿÿÿòOÞOèO€ÿÿÿÿÿÿüOT¹€ÿÿÿÿÿÿPòOüO€ÿÿÿÿÿÿP¸€ÿÿÿÿÿÿPPP€ÿÿÿÿÿÿ$P€€ ÿÿÿÿÿÿ.Pv4€!ÿÿÿÿÿÿ8P$P.P€"ÿÿÿÿÿÿBPÚè€#ÿÿÿÿÿÿLP8PBP€$ÿÿÿÿÿÿVP>œ€%ÿÿÿÿÿÿ`PLPVP€&ÿÿÿÿÿÿjP¢P€'ÿÿÿÿÿÿtP`PjP€(ÿÿÿÿÿÿ~PPtP€)ÿÿÿÿÿÿˆP’€*ÿÿÿÿÿÿ’PjF€+ÿÿÿÿÿÿœPˆP’P€,ÿÿÿÿÿÿ¦PÎú€-ÿÿÿÿÿÿ°PœP¦P€.ÿÿÿÿÿÿºP2®€/ÿÿÿÿÿÿÄP°PºP€0ÿÿÿÿÿÿÎP–b€1ÿÿÿÿÿÿØPÄPÎP€2ÿÿÿÿÿÿâP~PØP€3ÿÿÿÿÿÿìP¤€4ÿÿÿÿÿÿöP^X€5ÿÿÿÿÿÿQìPöP€6ÿÿÿÿÿÿ Q €7ÿÿÿÿÿÿQQ Q€8ÿÿÿÿÿÿQ&À€9ÿÿÿÿÿÿ(QQQ€:ÿÿÿÿÿÿ2QŠt€;ÿÿÿÿÿÿÿÿÿÿÿÿZQR j€?ÿÿÿÿÿÿdQPQZQ€@ÿÿÿÿÿÿnQ¶ €AÿÿÿÿÿÿxQdQnQ€Bÿÿÿÿÿÿ‚Q Ò€CÿÿÿÿÿÿŒQxQ‚Q€Dÿÿÿÿÿÿ–Q~ †€Eÿÿÿÿÿÿ QŒQ–Q€FÿÿÿÿÿÿªQFQ Q€Gÿÿÿÿÿÿ´Q<w€Hÿÿÿÿÿÿ¾Q–+€IÿÿÿÿÿÿÈQ´Q¾Q€JÿÿÿÿÿÿÒQú߀KÿÿÿÿÿÿÜQÈQÒQ€LÿÿÿÿÿÿæQ^“€MÿÿÿÿÿÿðQÜQæQ€NÿÿÿÿÿÿúQÂG€OÿÿÿÿÿÿRðQúQ€PÿÿÿÿÿÿR&¯€QÿÿÿÿÿÿR€€Rÿÿÿÿÿÿ"RRR€Sÿÿÿÿÿÿ,Räc€Tÿÿÿÿÿÿ6R"R,R€Uÿÿÿÿÿÿ@RH€VÿÿÿÿÿÿJR6R@R€WÿÿÿÿÿÿTR¬!€Xÿÿÿÿÿÿ^RJRTR€YÿÿÿÿÿÿhRR^R€ZÿÿÿÿÿÿrRÈ€[ÿÿÿÿÿÿ|Rt|€\ÿÿÿÿÿÿ†RrR|R€]ÿÿÿÿÿÿRØ0€^ÿÿÿÿÿÿšR†RR€_ÿÿÿÿÿÿ¤R<ä€`ÿÿÿÿÿÿ®RšR¤R€aÿÿÿÿÿÿ¸R ˜€bÿÿÿÿÿÿÂR®R¸R€cÿÿÿÿÿÿÌRhRÂR€dÿÿÿÿÿÿÖRÚ€eÿÿÿÿÿÿàRhŽ€fÿÿÿÿÿÿêRÖRàR€gÿÿÿÿÿÿôRÌB€hÿÿÿÿÿÿþRêRôR€iÿÿÿÿÿÿS0ö€jÿÿÿÿÿÿSþRS€kÿÿÿÿÿÿS”ª€lÿÿÿÿÿÿ&SSS€mÿÿÿÿÿÿ0SÌR&S€nÿÿÿÿÿÿ:S ì€oÿÿÿÿÿÿDS\  €pÿÿÿÿÿÿNS:SDS€qÿÿÿÿÿÿXSÀ T€rÿÿÿÿÿÿbSNSXS€sÿÿÿÿÿÿlS$ €tÿÿÿÿÿÿvSbSlS€uÿÿÿÿÿÿ€Sˆ ¼€vÿÿÿÿÿÿŠSvS€S€wÿÿÿÿÿÿ”S0SŠS€xÿÿÿÿÿÿžSªQ”S€yÿÿÿÿÿÿ¨SP‰€zÿÿÿÿÿÿ²Sª=€{ÿÿÿÿÿÿ¼S¨S²S€|ÿÿÿÿÿÿÆSñ€}ÿÿÿÿÿÿÐS¼SÆS€~ÿÿÿÿÿÿÚSr¥€ÿÿÿÿÿÿäSÐSÚS€€ÿÿÿÿÿÿîSÖY€ÿÿÿÿÿÿøSäSîS€‚ÿÿÿÿÿÿT:¿€ƒÿÿÿÿÿÿ T”s€„ÿÿÿÿÿÿTT T€…ÿÿÿÿÿÿ Tø'€†ÿÿÿÿÿÿ*TT T€‡ÿÿÿÿÿÿ4T\Û€ˆÿÿÿÿÿÿ>T*T4T€‰ÿÿÿÿÿÿHTÀ€ŠÿÿÿÿÿÿRT>THT€‹ÿÿÿÿÿÿ\TøSRT€ŒÿÿÿÿÿÿfT.€ÿÿÿÿÿÿpTˆ€ŽÿÿÿÿÿÿzTfTpT€ÿÿÿÿÿÿ„Tìv€ÿÿÿÿÿÿŽTzT„T€‘ÿÿÿÿÿÿ˜TPÕ€’ÿÿÿÿÿÿ¢TŽT˜T€“ÿÿÿÿÿÿ¬T´4€”ÿÿÿÿÿÿ¶T¢T¬T€•ÿÿÿÿÿÿÀT\T¶T€–ÿÿÿÿÿÿÊT"þ€—ÿÿÿÿÿÿÔT|²€˜ÿÿÿÿÿÿÞTÊTÔT€™ÿÿÿÿÿÿèTàf€šÿÿÿÿÿÿòTÞTèT€›ÿÿÿÿÿÿüTD€œÿÿÿÿÿÿUòTüT€ÿÿÿÿÿÿU¨Î€žÿÿÿÿÿÿUUU€Ÿÿÿÿÿÿÿ$UÀTU€ ÿÿÿÿÿÿ.U €¡ÿÿÿÿÿÿ8Up Ä€¢ÿÿÿÿÿÿBU.U8U€£ÿÿÿÿÿÿLUÔ x€¤ÿÿÿÿÿÿVUBULU€¥ÿÿÿÿÿÿ`U8 ,€¦ÿÿÿÿÿÿjUVU`U€§ÿÿÿÿÿÿtUœ à€¨ÿÿÿÿÿÿ~UjUtU€©ÿÿÿÿÿÿˆU$U~U€ªÿÿÿÿÿÿ’UžSˆU€«ÿÿÿÿÿÿœUd›€¬ÿÿÿÿÿÿ¦U¾O€­ÿÿÿÿÿÿ°UœU¦U€®ÿÿÿÿÿÿºU"€¯ÿÿÿÿÿÿÄU°UºU€°ÿÿÿÿÿÿÎU†·€±ÿÿÿÿÿÿØUÄUÎU€²ÿÿÿÿÿÿâUêk€³ÿÿÿÿÿÿìUØUâU€´ÿÿÿÿÿÿöUNÑ€µÿÿÿÿÿÿV¨…€¶ÿÿÿÿÿÿ VöUV€·ÿÿÿÿÿÿV 9€¸ÿÿÿÿÿÿV VV€¹ÿÿÿÿÿÿ(Vp퀺ÿÿÿÿÿÿ2VV(V€»ÿÿÿÿÿÿ€Øÿÿÿÿÿÿ^WJWTW€ÙÿÿÿÿÿÿhW° ò€ÚÿÿÿÿÿÿrW^WhW€Ûÿÿÿÿÿÿ|WWrW€Üÿÿÿÿÿÿ†W’U|W€ÝÿÿÿÿÿÿWx­€ÞÿÿÿÿÿÿšWÒa€ßÿÿÿÿÿÿ¤WWšW€àÿÿÿÿÿÿ®W6€áÿÿÿÿÿÿ¸W¤W®W€âÿÿÿÿÿÿÂWšÉ€ãÿÿÿÿÿÿÌW¸WÂW€äÿÿÿÿÿÿÖWþ}€åÿÿÿÿÿÿàWÌWÖW€æÿÿÿÿÿÿêWbã€çÿÿÿÿÿÿôW¼—€èÿÿÿÿÿÿþWêWôW€éÿÿÿÿÿÿX K€êÿÿÿÿÿÿXþWX€ëÿÿÿÿÿÿX„ÿ€ìÿÿÿÿÿÿ&XXX€íÿÿÿÿÿÿ0Xè³€îÿÿÿÿÿÿ:X&X0X€ïÿÿÿÿÿÿDXàW:X€ðÿÿÿÿÿÿNXV€ñÿÿÿÿÿÿXX°»€òÿÿÿÿÿÿbXNXXX€óÿÿÿÿÿÿlXo€ôÿÿÿÿÿÿvXbXlX€õÿÿÿÿÿÿ€Xx#€öÿÿÿÿÿÿŠXvX€X€÷ÿÿÿÿÿÿ”XÜ×€øÿÿÿÿÿÿžXŠX”X€ùÿÿÿÿÿÿ¨XDXžX€úÿÿÿÿÿÿ²XJ€ûÿÿÿÿÿÿ¼X¤Í€üÿÿÿÿÿÿÆX²X¼X€ýÿÿÿÿÿÿÐX€þÿÿÿÿÿÿÚXÆXÐX€ÿÿÿÿÿÿÿäXl5€ ÿÿÿÿÿÿîXÚXäX€ ÿÿÿÿÿÿøXÐé€ ÿÿÿÿÿÿYîXøX€ ÿÿÿÿÿÿ Y¨XY€ ÿÿÿÿÿÿY> è€ ÿÿÿÿÿÿ Y˜ =€ ÿÿÿÿÿÿ*YY Y€ ÿÿÿÿÿÿ4Yü œ€ ÿÿÿÿÿÿ>Y*Y4Y€ ÿÿÿÿÿÿHY` û€ ÿÿÿÿÿÿRY>YHY€ ÿÿÿÿÿÿ\YÄ Z€ ÿÿÿÿÿÿfYRY\Y€ ÿÿÿÿÿÿpY YfY€ ÿÿÿÿÿÿzY†WpY€ ÿÿÿÿÿÿ„Y÷"X'€ ÿÿÿÿÿÿŽY„Yþ'€ ÿÿÿÿÿÿ˜YŽY¤(€ ÿÿÿÿÿÿ¢Y˜YJ)€ ÿÿÿÿÿÿ¬Y¼&Í#€ ÿÿÿÿÿÿ¶Y¬Y(€ ÿÿÿÿÿÿÀY¶YÁ(€ ÿÿÿÿÿÿÊYÀYg)€ ÿÿÿÿÿÿÔY¢YÊY€ ÿÿÿÿÿÿÞYã&'€ ÿÿÿÿÿÿèYÞY·$€ ÿÿÿÿÿÿòYèYè(€ ÿÿÿÿÿÿüYòYŽ)€ ÿÿÿÿÿÿZÔYüY€ ÿÿÿÿÿÿZ '¦'€ ÿÿÿÿÿÿZZL(€ ÿÿÿÿÿÿ$ZZ¡%€ ÿÿÿÿÿÿ.Z$Zµ)€! ÿÿÿÿÿÿ8ZZ.Z€" ÿÿÿÿÿÿBZ1'Í'€# ÿÿÿÿÿÿLZBZs(€$ ÿÿÿÿÿÿVZLZ)€% ÿÿÿÿÿÿ`ZVZ‹&€& ÿÿÿÿÿÿjZ8Z`Z€' >ÿÿÿÿÿÿtZj@( ÿÿÿÿÿÿ~ZtZ€) >ÿÿÿÿÿÿ‡Zœ@* ÿÿÿÿÿÿ‘Z‡Z€+ ÿÿÿÿÿÿšZ~Z‘Z€, >ÿÿÿÿÿÿ¤ZÎ@- ÿÿÿÿÿÿ®Z¤Z€. ÿÿÿÿÿÿ·ZšZ®Z€/ >ÿÿÿÿÿÿÁZ@0 ÿÿÿÿÿÿËZÁZ€1 ÿÿÿÿÿÿÔZ·ZËZ€2 >ÿÿÿÿÿÿÞZjœ@3 ÿÿÿÿÿÿèZÞZ€4 ÿÿÿÿÿÿñZÔZèZ€5 >ÿÿÿÿÿÿûZjÎ@6 ÿÿÿÿÿÿ[ûZ€7 ÿÿÿÿÿÿ[ñZ[€8 >ÿÿÿÿÿÿ[j@9 ÿÿÿÿÿÿ"[[€: ÿÿÿÿÿÿ+[["[€; >ÿÿÿÿÿÿ5[œÎ@< ÿÿÿÿÿÿ?[5[€= ÿÿÿÿÿÿH[+[?[€> >ÿÿÿÿÿÿR[œ@? ÿÿÿÿÿÿ\[R[€@ ÿÿÿÿÿÿe[H[\[€A >ÿÿÿÿÿÿo[Î@B ÿÿÿÿÿÿy[o[€C ÿÿÿÿÿÿ‚[e[y[€D >ÿÿÿÿÿÿŒ[*t@E ÿÿÿÿÿÿ–[Œ[€F >ÿÿÿÿÿÿŸ[*¦@G ÿÿÿÿÿÿ©[Ÿ[€H ÿÿÿÿÿÿ²[–[©[€I >ÿÿÿÿÿÿ¼[*Ø@J ÿÿÿÿÿÿÆ[¼[€K ÿÿÿÿÿÿÏ[²[Æ[€L >ÿÿÿÿÿÿÙ[* @M ÿÿÿÿÿÿã[Ù[€N ÿÿÿÿÿÿì[Ï[ã[€O >ÿÿÿÿÿÿö[t¦@P ÿÿÿÿÿÿ\ö[€Q ÿÿÿÿÿÿ \ì[\€R >ÿÿÿÿÿÿ\tØ@S ÿÿÿÿÿÿ\\€T ÿÿÿÿÿÿ&\ \\€U >ÿÿÿÿÿÿ0\t @V ÿÿÿÿÿÿ:\0\€W ÿÿÿÿÿÿC\&\:\€X >ÿÿÿÿÿÿM\¦Ø@Y ÿÿÿÿÿÿW\M\€Z ÿÿÿÿÿÿ`\C\W\€[ >ÿÿÿÿÿÿj\¦ @\ ÿÿÿÿÿÿt\j\€] ÿÿÿÿÿÿ}\`\t\€^ >ÿÿÿÿÿÿ‡\Ø @_ ÿÿÿÿÿÿ‘\‡\€` ÿÿÿÿÿÿš\}\‘\€a ÿÿÿÿÿÿ¤\‚[š\€b >ÿÿÿÿÿÿ®\<~@c ÿÿÿÿÿÿ¸\®\€d >ÿÿÿÿÿÿÁ\<°@e ÿÿÿÿÿÿË\Á\€f ÿÿÿÿÿÿÔ\¸\Ë\€g >ÿÿÿÿÿÿÞ\<â@h ÿÿÿÿÿÿè\Þ\€i ÿÿÿÿÿÿñ\Ô\è\€j >ÿÿÿÿÿÿû\<@k ÿÿÿÿÿÿ]û\€l ÿÿÿÿÿÿ]ñ\]€m >ÿÿÿÿÿÿ]~°@n ÿÿÿÿÿÿ"]]€o ÿÿÿÿÿÿ+]]"]€p >ÿÿÿÿÿÿ5]~â@q ÿÿÿÿÿÿ?]5]€r ÿÿÿÿÿÿH]+]?]€s >ÿÿÿÿÿÿR]~@t ÿÿÿÿÿÿ\]R]€u ÿÿÿÿÿÿe]H]\]€v >ÿÿÿÿÿÿo]°â@w ÿÿÿÿÿÿy]o]€x ÿÿÿÿÿÿ‚]e]y]€y >ÿÿÿÿÿÿŒ]°@z ÿÿÿÿÿÿ–]Œ]€{ ÿÿÿÿÿÿŸ]‚]–]€| >ÿÿÿÿÿÿ©]â@} ÿÿÿÿÿÿ³]©]€~ ÿÿÿÿÿÿ¼]Ÿ]³]€ ÿÿÿÿÿÿÆ]¤\¼]€€ >ÿÿÿÿÿÿÐ]Nˆ@ ÿÿÿÿÿÿÚ]Ð]€‚ >ÿÿÿÿÿÿã]Nº@ƒ ÿÿÿÿÿÿí]ã]€„ ÿÿÿÿÿÿö]Ú]í]€… >ÿÿÿÿÿÿ^Nì@† ÿÿÿÿÿÿ ^^€‡ ÿÿÿÿÿÿ^ö] ^€ˆ >ÿÿÿÿÿÿ^N@‰ ÿÿÿÿÿÿ'^^€Š ÿÿÿÿÿÿ0^^'^€‹ >ÿÿÿÿÿÿ:^ˆº@Œ ÿÿÿÿÿÿD^:^€ ÿÿÿÿÿÿM^0^D^€Ž >ÿÿÿÿÿÿW^ˆì@ ÿÿÿÿÿÿa^W^€ ÿÿÿÿÿÿj^M^a^€‘ >ÿÿÿÿÿÿt^ˆ@’ ÿÿÿÿÿÿ~^t^€“ ÿÿÿÿÿÿ‡^j^~^€” >ÿÿÿÿÿÿ‘^ºì@• ÿÿÿÿÿÿ›^‘^€– ÿÿÿÿÿÿ¤^‡^›^€— >ÿÿÿÿÿÿ®^º@˜ ÿÿÿÿÿÿ¸^®^€™ ÿÿÿÿÿÿÁ^¤^¸^€š >ÿÿÿÿÿÿË^ì@› ÿÿÿÿÿÿÕ^Ë^€œ ÿÿÿÿÿÿÞ^Á^Õ^€ ÿÿÿÿÿÿè^Æ]Þ^€ž >ÿÿÿÿÿÿò^`’@Ÿ ÿÿÿÿÿÿü^ò^€  >ÿÿÿÿÿÿ_`Ä@¡ ÿÿÿÿÿÿ__€¢ ÿÿÿÿÿÿ_ü^_€£ >ÿÿÿÿÿÿ"_`ö@¤ ÿÿÿÿÿÿ,_"_€¥ ÿÿÿÿÿÿ5__,_€¦ >ÿÿÿÿÿÿ?_`(@§ ÿÿÿÿÿÿI_?_€¨ ÿÿÿÿÿÿR_5_I_€© >ÿÿÿÿÿÿ\_’Ä@ª ÿÿÿÿÿÿf_\_€« ÿÿÿÿÿÿo_R_f_€¬ >ÿÿÿÿÿÿy_’ö@­ ÿÿÿÿÿÿƒ_y_€® ÿÿÿÿÿÿŒ_o_ƒ_€¯ >ÿÿÿÿÿÿ–_’(@° ÿÿÿÿÿÿ _–_€± ÿÿÿÿÿÿ©_Œ_ _€² >ÿÿÿÿÿÿ³_Äö@³ ÿÿÿÿÿÿ½_³_€´ ÿÿÿÿÿÿÆ_©_½_€µ >ÿÿÿÿÿÿÐ_Ä(@¶ ÿÿÿÿÿÿÚ_Ð_€· ÿÿÿÿÿÿã_Æ_Ú_€¸ >ÿÿÿÿÿÿí_ö(@¹ ÿÿÿÿÿÿ÷_í_€º ÿÿÿÿÿÿ`ã_÷_€» ÿÿÿÿÿÿ `è^`€¼ >ÿÿÿÿÿÿ`*@½ ÿÿÿÿÿÿ``€¾ >ÿÿÿÿÿÿ'`<@¿ ÿÿÿÿÿÿ1`'`€À ÿÿÿÿÿÿ:``1`€Á >ÿÿÿÿÿÿD`N@ ÿÿÿÿÿÿN`D`€Ã ÿÿÿÿÿÿW`:`N`€Ä >ÿÿÿÿÿÿa``@Å ÿÿÿÿÿÿk`a`€Æ ÿÿÿÿÿÿt`W`k`€Ç >ÿÿÿÿÿÿ~`*<@È ÿÿÿÿÿÿˆ`~`€É ÿÿÿÿÿÿ‘`t`ˆ`€Ê >ÿÿÿÿÿÿ›`*N@Ë ÿÿÿÿÿÿ¥`›`€Ì ÿÿÿÿÿÿ®`‘`¥`€Í >ÿÿÿÿÿÿ¸`*`@Î ÿÿÿÿÿÿÂ`¸`€Ï ÿÿÿÿÿÿË`®`Â`€Ð >ÿÿÿÿÿÿÕ`<N@Ñ ÿÿÿÿÿÿß`Õ`€Ò ÿÿÿÿÿÿè`Ë`ß`€Ó >ÿÿÿÿÿÿò`<`@Ô ÿÿÿÿÿÿü`ò`€Õ ÿÿÿÿÿÿaè`ü`€Ö >ÿÿÿÿÿÿaN`@× ÿÿÿÿÿÿaa€Ø ÿÿÿÿÿÿ"aaa€Ù >ÿÿÿÿÿÿ,ajt@Ú ÿÿÿÿÿÿ6a,a€Û >ÿÿÿÿÿÿ?aj~@Ü ÿÿÿÿÿÿIa?a€Ý ÿÿÿÿÿÿRa6aIa€Þ >ÿÿÿÿÿÿ\ajˆ@ß ÿÿÿÿÿÿfa\a€à ÿÿÿÿÿÿoaRafa€á >ÿÿÿÿÿÿyaj’@â ÿÿÿÿÿÿƒaya€ã ÿÿÿÿÿÿŒaoaƒa€ä >ÿÿÿÿÿÿ–at~@å ÿÿÿÿÿÿ a–a€æ ÿÿÿÿÿÿ©aŒa a€ç >ÿÿÿÿÿÿ³atˆ@è ÿÿÿÿÿÿ½a³a€é ÿÿÿÿÿÿÆa©a½a€ê >ÿÿÿÿÿÿÐat’@ë ÿÿÿÿÿÿÚaÐa€ì ÿÿÿÿÿÿãaÆaÚa€í >ÿÿÿÿÿÿía~ˆ@î ÿÿÿÿÿÿ÷aía€ï ÿÿÿÿÿÿbãa÷a€ð >ÿÿÿÿÿÿ b~’@ñ ÿÿÿÿÿÿb b€ò ÿÿÿÿÿÿbbb€ó >ÿÿÿÿÿÿ'bˆ’@ô ÿÿÿÿÿÿ1b'b€õ ÿÿÿÿÿÿ:bb1b€ö ÿÿÿÿÿÿDb"a:b€÷ >ÿÿÿÿÿÿNbœ¦@ø ÿÿÿÿÿÿXbNb€ù >ÿÿÿÿÿÿabœ°@ú ÿÿÿÿÿÿkbab€û ÿÿÿÿÿÿtbXbkb€ü >ÿÿÿÿÿÿ~bœº@ý ÿÿÿÿÿÿˆb~b€þ ÿÿÿÿÿÿ‘btbˆb€ÿ >ÿÿÿÿÿÿ›bœÄ@ ÿÿÿÿÿÿ¥b›b€ ÿÿÿÿÿÿ®b‘b¥b€ >ÿÿÿÿÿÿ¸b¦°@ ÿÿÿÿÿÿÂb¸b€ ÿÿÿÿÿÿËb®bÂb€ >ÿÿÿÿÿÿÕb¦º@ ÿÿÿÿÿÿßbÕb€ ÿÿÿÿÿÿèbËbßb€ >ÿÿÿÿÿÿòb¦Ä@ ÿÿÿÿÿÿübòb€ ÿÿÿÿÿÿcèbüb€ >ÿÿÿÿÿÿc°º@ ÿÿÿÿÿÿcc€ ÿÿÿÿÿÿ"ccc€ >ÿÿÿÿÿÿ,c°Ä@ ÿÿÿÿÿÿ6c,c€ ÿÿÿÿÿÿ?c"c6c€ >ÿÿÿÿÿÿIcºÄ@ ÿÿÿÿÿÿScIc€ ÿÿÿÿÿÿ\c?cSc€ ÿÿÿÿÿÿfcDb\c€ >ÿÿÿÿÿÿpcÎØ@ ÿÿÿÿÿÿzcpc€ >ÿÿÿÿÿÿƒcÎâ@ ÿÿÿÿÿÿcƒc€ ÿÿÿÿÿÿ–czcc€ >ÿÿÿÿÿÿ cÎì@ ÿÿÿÿÿÿªc c€ ÿÿÿÿÿÿ³c–cªc€ >ÿÿÿÿÿÿ½cÎö@ ÿÿÿÿÿÿÇc½c€ ÿÿÿÿÿÿÐc³cÇc€ >ÿÿÿÿÿÿÚcØâ@! ÿÿÿÿÿÿäcÚc€" ÿÿÿÿÿÿícÐcäc€# >ÿÿÿÿÿÿ÷cØì@$ ÿÿÿÿÿÿd÷c€% ÿÿÿÿÿÿ dícd€& >ÿÿÿÿÿÿdØö@' ÿÿÿÿÿÿdd€( ÿÿÿÿÿÿ'd dd€) >ÿÿÿÿÿÿ1dâì@* ÿÿÿÿÿÿ;d1d€+ ÿÿÿÿÿÿDd'd;d€, >ÿÿÿÿÿÿNdâö@- ÿÿÿÿÿÿXdNd€. ÿÿÿÿÿÿadDdXd€/ >ÿÿÿÿÿÿkdìö@0 ÿÿÿÿÿÿudkd€1 ÿÿÿÿÿÿ~dadud€2 ÿÿÿÿÿÿˆdfc~d€3 >ÿÿÿÿÿÿ’d @4 ÿÿÿÿÿÿœd’d€5 >ÿÿÿÿÿÿ¥d@6 ÿÿÿÿÿÿ¯d¥d€7 ÿÿÿÿÿÿ¸dœd¯d€8 >ÿÿÿÿÿÿÂd@9 ÿÿÿÿÿÿÌdÂd€: ÿÿÿÿÿÿÕd¸dÌd€; >ÿÿÿÿÿÿßd(@< ÿÿÿÿÿÿédßd€= ÿÿÿÿÿÿòdÕdéd€> >ÿÿÿÿÿÿüd @? ÿÿÿÿÿÿeüd€@ ÿÿÿÿÿÿeòde€A >ÿÿÿÿÿÿe @B ÿÿÿÿÿÿ#ee€C ÿÿÿÿÿÿ,ee#e€D >ÿÿÿÿÿÿ6e (@E ÿÿÿÿÿÿ@e6e€F ÿÿÿÿÿÿIe,e@e€G >ÿÿÿÿÿÿSe@H ÿÿÿÿÿÿ]eSe€I ÿÿÿÿÿÿfeIe]e€J >ÿÿÿÿÿÿpe(@K ÿÿÿÿÿÿzepe€L ÿÿÿÿÿÿƒefeze€M >ÿÿÿÿÿÿe(@N ÿÿÿÿÿÿ—ee€O ÿÿÿÿÿÿ eƒe—e€P ÿÿÿÿÿÿªeˆd e€Q ÿÿÿÿÿÿ´e `ªe€R >ÿÿÿÿÿÿ¾e"@S ÿÿÿÿÿÿÈe¾e€T >ÿÿÿÿÿÿÑe4@U ÿÿÿÿÿÿÛeÑe€V ÿÿÿÿÿÿäeÈeÛe€W >ÿÿÿÿÿÿîeF@X ÿÿÿÿÿÿøeîe€Y ÿÿÿÿÿÿfäeøe€Z >ÿÿÿÿÿÿ fX@[ ÿÿÿÿÿÿf f€\ ÿÿÿÿÿÿfff€] >ÿÿÿÿÿÿ(f"4@^ ÿÿÿÿÿÿ2f(f€_ ÿÿÿÿÿÿ;ff2f€` >ÿÿÿÿÿÿEf"F@a ÿÿÿÿÿÿOfEf€b ÿÿÿÿÿÿXf;fOf€c >ÿÿÿÿÿÿbf"X@d ÿÿÿÿÿÿlfbf€e ÿÿÿÿÿÿufXflf€f >ÿÿÿÿÿÿf4F@g ÿÿÿÿÿÿ‰ff€h ÿÿÿÿÿÿ’fuf‰f€i >ÿÿÿÿÿÿœf4X@j ÿÿÿÿÿÿ¦fœf€k ÿÿÿÿÿÿ¯f’f¦f€l >ÿÿÿÿÿÿ¹fFX@m ÿÿÿÿÿÿÃf¹f€n ÿÿÿÿÿÿÌf¯fÃf€o ÿÿÿÿÿÿÖfÎú€p ÿÿÿÿÿÿàfÖf €q ÿÿÿÿÿÿêfàfV€r ÿÿÿÿÿÿôfP¾€s ÿÿÿÿÿÿþfôfú€t ÿÿÿÿÿÿgþfT€u ÿÿÿÿÿÿggþ€v ÿÿÿÿÿÿgg&€w ÿÿÿÿÿÿ&ggv€x ÿÿÿÿÿÿ0g&g €y ÿÿÿÿÿÿ:g0g„€z ÿÿÿÿÿÿDg:gÀ€{ ÿÿÿÿÿÿNgDgV€| ÿÿÿÿÿÿXgNgt€} ÿÿÿÿÿÿbgXg΀~ ÿÿÿÿÿÿlgbgP€ ÿÿÿÿÿÿvglgÈ€€ ÿÿÿÿÿÿ€gvg€ ÿÿÿÿÿÿŠg€g|€‚ ÿÿÿÿÿÿ”gŠg€ƒ ÿÿÿÿÿÿžg”gX€„ ÿÿÿÿÿÿ¨gžg”€… ÿÿÿÿÿÿ²g¨g* €† ÿÿÿÿÿÿ¼g²g˜ €‡ ÿÿÿÿÿÿÆg¼gÔ €ˆ ÿÿÿÿÿÿÐgÆg$ €‰ ÿÿÿÿÿÿÚgÐg~ @Š ÿÿÿÿÿÿägÚg€‹ ÿÿÿÿÿÿígg€Œ ÿÿÿÿÿÿ÷gíg”€ ÿÿÿÿÿÿh÷g €Ž ÿÿÿÿÿÿ hh„€ ÿÿÿÿÿÿh h¬€ ÿÿÿÿÿÿhhV€‘ ÿÿÿÿÿÿ)hht€’ ÿÿÿÿÿÿ3h)h΀“ ÿÿÿÿÿÿ=h3hP€” ÿÿÿÿÿÿGh=hÈ€• ÿÿÿÿÿÿQhGh€– ÿÿÿÿÿÿ[hQh¤€— ÿÿÿÿÿÿeh[hà€˜ ÿÿÿÿÿÿohehX€™ ÿÿÿÿÿÿyhohŠ€š ÿÿÿÿÿÿƒhyh* €› ÿÿÿÿÿÿhƒhR €œ ÿÿÿÿÿÿ—hhü € ÿÿÿÿÿÿ¡h—h$ €ž ÿÿÿÿÿÿ«h¡hœ @Ÿ ÿÿÿÿÿÿµh«h  ÿÿÿÿÿÿ¾hâ œm±"Ù"ž&Ò)Â*¬,q064¢6b?âAEFÀOzYjZ´eÌfêfägµh€¡ SÿÿÿÿÿÿÞhœ~€¢ >ÿÿÿÿÿÿèh<Þh€£ >ÿÿÿÿÿÿòhœê'€¤ Sÿÿÿÿÿÿühœ<€¥ >ÿÿÿÿÿÿi°üh€¦ Sÿÿÿÿÿÿiœ°€§ >ÿÿÿÿÿÿi~i€¨ Sÿÿÿÿÿÿ$i~œ€© >ÿÿÿÿÿÿ.i°$i€ª >ÿÿÿÿÿÿ8i~³-€« >ÿÿÿÿÿÿBi4|$€¬ SÿÿÿÿÿÿLi~<€­ >ÿÿÿÿÿÿViœLi€® Sÿÿÿÿÿÿ`i~°€¯ >ÿÿÿÿÿÿji<`i€° >ÿÿÿÿÿÿti~f@€± >ÿÿÿÿÿÿ~i4x1€² >ÿÿÿÿÿÿˆi°°€³ >ÿÿÿÿÿÿ’i<¿0€´ >ÿÿÿÿÿÿœiœ;2€µ Sÿÿÿÿÿÿ¦i<œ€¶ >ÿÿÿÿÿÿ°i<¦i€· Sÿÿÿÿÿÿºi<~€¸ >ÿÿÿÿÿÿÄiœºi€¹ >ÿÿÿÿÿÿÎi~_$€º SÿÿÿÿÿÿØi<°€» >ÿÿÿÿÿÿâi°Øi€¼ Sÿÿÿÿÿÿìi°œ€½ >ÿÿÿÿÿÿöiœìi€¾ Sÿÿÿÿÿÿj°~€¿ >ÿÿÿÿÿÿ j°j€À >ÿÿÿÿÿÿj<£$€Á Sÿÿÿÿÿÿj°<€Â >ÿÿÿÿÿÿ(j~j€Ã ÿÿÿÿÿÿ2j€.(j€Ä ÿÿÿÿÿÿÿÿÿÿÿÿ+k°2.€Ý >ÿÿÿÿÿÿ5k4ê'€Þ >ÿÿÿÿÿÿ?kœüh€ß >ÿÿÿÿÿÿIk<$i€à >ÿÿÿÿÿÿSkœ|$€á >ÿÿÿÿÿÿ]k4Li€â >ÿÿÿÿÿÿgk°`i€ã >ÿÿÿÿÿÿqk4¦i€ä >ÿÿÿÿÿÿ{k°ú,€å >ÿÿÿÿÿÿ…k<Øi€æ ÿÿÿÿÿÿkPj…k€ç ÿÿÿÿÿÿ™kk{k€è ÿÿÿÿÿÿ£k™kÎi€é ÿÿÿÿÿÿ­k£kÄi€ê ÿÿÿÿÿÿ·k­kqk€ë ÿÿÿÿÿÿÁk·kœi€ì ÿÿÿÿÿÿËkÁk’i€í ÿÿÿÿÿÿÕkËkˆi€î ÿÿÿÿÿÿßkÕk~i€ï ÿÿÿÿÿÿékßkti€ð ÿÿÿÿÿÿókékgk€ñ ÿÿÿÿÿÿýkók]k€ò ÿÿÿÿÿÿlýkSk€ó ÿÿÿÿÿÿll8i€ô ÿÿÿÿÿÿllIk€õ ÿÿÿÿÿÿ%lli€ö ÿÿÿÿÿÿ/l%l?k€÷ ÿÿÿÿÿÿ9l/l5k€ø ÿÿÿÿÿÿCl9lèh€ù ÿÿÿÿÿÿMlCl+k@ú ÿÿÿÿÿÿWl†Ù€û ÿÿÿÿÿÿ`lˆij€ü ÿÿÿÿÿÿjl`lÎi€ý ÿÿÿÿÿÿtljlœi€þ >ÿÿÿÿÿÿ~l~œ@ÿ ÿÿÿÿÿÿˆl~l€ >ÿÿÿÿÿÿ‘l<œ@ ÿÿÿÿÿÿ›l‘l€ ÿÿÿÿÿÿ¤lË\v€ ÿÿÿÿÿÿ®l¤l"]€ ÿÿÿÿÿÿ¸l®lkb€ ÿÿÿÿÿÿÂl¸lñ€ ÿÿÿÿÿÿÌlÂl¸\€ ÿÿÿÿÿÿÖlÌl›l€ ÿÿÿÿÿÿàlÖl'€ ÿÿÿÿÿÿêlàlú€ ÿÿÿÿÿÿôlêlˆl€ >ÿÿÿÿÿÿþl2.Þh@ ÿÿÿÿÿÿmþl€ >ÿÿÿÿÿÿmê'2.@ ÿÿÿÿÿÿmm€ >ÿÿÿÿÿÿ$mê'Þh@ ÿÿÿÿÿÿ.m$m€ >ÿÿÿÿÿÿ7m2.üh@ ÿÿÿÿÿÿAm7m€ >ÿÿÿÿÿÿJmÞhüh@ ÿÿÿÿÿÿTmJm€ >ÿÿÿÿÿÿ]mê'üh@ ÿÿÿÿÿÿgm]m€ >ÿÿÿÿÿÿpm2.i@ ÿÿÿÿÿÿzmpm€ >ÿÿÿÿÿÿƒmÞhi@ ÿÿÿÿÿÿmƒm€ >ÿÿÿÿÿÿ–mê'i@ ÿÿÿÿÿÿ m–m€ >ÿÿÿÿÿÿ©mühi@ ÿÿÿÿÿÿ³m©m€ ÿÿÿÿÿÿ¼m³m m€ ÿÿÿÿÿÿÆm¼mm€! ÿÿÿÿÿÿÐmÆmzm€" ÿÿÿÿÿÿÚmÐmgm€# ÿÿÿÿÿÿämÚmTm€$ ÿÿÿÿÿÿîmämAm€% ÿÿÿÿÿÿømîm.m€& ÿÿÿÿÿÿnømm€' ÿÿÿÿÿÿ nnm€( >ÿÿÿÿÿÿn³-$i@) ÿÿÿÿÿÿ nn€* >ÿÿÿÿÿÿ)n|$$i@+ ÿÿÿÿÿÿ3n)n€, >ÿÿÿÿÿÿÿÿÿÿÿÿOn$iLi@/ ÿÿÿÿÿÿYnOn€0 >ÿÿÿÿÿÿbn³-Li@1 ÿÿÿÿÿÿlnbn€2 >ÿÿÿÿÿÿun|$Li@3 ÿÿÿÿÿÿnun€4 >ÿÿÿÿÿÿˆn$i`i@5 ÿÿÿÿÿÿ’nˆn€6 >ÿÿÿÿÿÿ›n³-`i@7 ÿÿÿÿÿÿ¥n›n€8 >ÿÿÿÿÿÿ®n|$`i@9 ÿÿÿÿÿÿ¸n®n€: >ÿÿÿÿÿÿÁnLi`i@; ÿÿÿÿÿÿËnÁn€< ÿÿÿÿÿÿÔnËn¸n€= ÿÿÿÿÿÿÞnÔn¥n€> ÿÿÿÿÿÿènÞn’n€? ÿÿÿÿÿÿònènn€@ ÿÿÿÿÿÿünònln€A ÿÿÿÿÿÿoünYn€B ÿÿÿÿÿÿooFn€C ÿÿÿÿÿÿoo3n€D ÿÿÿÿÿÿ$oo n€E >ÿÿÿÿÿÿ.ox1f@@F ÿÿÿÿÿÿ8o.o€G >ÿÿÿÿÿÿAo°f@@H ÿÿÿÿÿÿKoAo€I >ÿÿÿÿÿÿTo°x1@J ÿÿÿÿÿÿ^oTo€K >ÿÿÿÿÿÿgo¿0f@@L ÿÿÿÿÿÿqogo€M >ÿÿÿÿÿÿzo¿0x1@N ÿÿÿÿÿÿ„ozo€O >ÿÿÿÿÿÿo°¿0@P ÿÿÿÿÿÿ—oo€Q >ÿÿÿÿÿÿ o;2f@@R ÿÿÿÿÿÿªo o€S >ÿÿÿÿÿÿ³ox1;2@T ÿÿÿÿÿÿ½o³o€U >ÿÿÿÿÿÿÆo°;2@V ÿÿÿÿÿÿÐoÆo€W >ÿÿÿÿÿÿÙo¿0;2@X ÿÿÿÿÿÿãoÙo€Y ÿÿÿÿÿÿìoãoÐo€Z ÿÿÿÿÿÿöoìo½o€[ ÿÿÿÿÿÿpöoªo€\ ÿÿÿÿÿÿ pp—o€] ÿÿÿÿÿÿp p„o€^ ÿÿÿÿÿÿppqo€_ ÿÿÿÿÿÿ(pp^o€` ÿÿÿÿÿÿ2p(pKo€a ÿÿÿÿÿÿÿÿÿÿÿÿFp¦iºi@c ÿÿÿÿÿÿPpFp€d >ÿÿÿÿÿÿYp_$¦i@e ÿÿÿÿÿÿcpYp€f >ÿÿÿÿÿÿlp_$ºi@g ÿÿÿÿÿÿvplp€h >ÿÿÿÿÿÿpú,¦i@i ÿÿÿÿÿÿ‰pp€j >ÿÿÿÿÿÿ’pú,ºi@k ÿÿÿÿÿÿœp’p€l >ÿÿÿÿÿÿ¥p_$ú,@m ÿÿÿÿÿÿ¯p¥p€n >ÿÿÿÿÿÿ¸p¦iØi@o ÿÿÿÿÿÿÂp¸p€p >ÿÿÿÿÿÿËpºiØi@q ÿÿÿÿÿÿÕpËp€r >ÿÿÿÿÿÿÞp_$Øi@s ÿÿÿÿÿÿèpÞp€t >ÿÿÿÿÿÿñpú,Øi@u ÿÿÿÿÿÿûpñp€v ÿÿÿÿÿÿqûpèp€w ÿÿÿÿÿÿqqÕp€x ÿÿÿÿÿÿqqÂp€y ÿÿÿÿÿÿ"qq¯p€z ÿÿÿÿÿÿ,q"qœp€{ ÿÿÿÿÿÿ6q,q‰p€| ÿÿÿÿÿÿ@q6qvp€} ÿÿÿÿÿÿJq@qcp€~ ÿÿÿÿÿÿTqJqPp€ >ÿÿÿÿÿÿ^qìij@€ ÿÿÿÿÿÿhq^q€ >ÿÿÿÿÿÿqq£$ìi@‚ ÿÿÿÿÿÿ{qqq€ƒ >ÿÿÿÿÿÿ„q£$j@„ ÿÿÿÿÿÿŽq„q€… >ÿÿÿÿÿÿ—qìij@† ÿÿÿÿÿÿ¡q—q€‡ >ÿÿÿÿÿÿªqjj@ˆ ÿÿÿÿÿÿ´qªq€‰ >ÿÿÿÿÿÿ½q£$j@Š ÿÿÿÿÿÿÇq½q€‹ >ÿÿÿÿÿÿÐqv.ìi@Œ ÿÿÿÿÿÿÚqÐq€ >ÿÿÿÿÿÿãqv.j@Ž ÿÿÿÿÿÿíqãq€ >ÿÿÿÿÿÿöq£$v.@ ÿÿÿÿÿÿröq€‘ >ÿÿÿÿÿÿ rv.j@’ ÿÿÿÿÿÿr r€“ ÿÿÿÿÿÿrrr€” ÿÿÿÿÿÿ&rríq€• ÿÿÿÿÿÿ0r&rÚq€– ÿÿÿÿÿÿ:r0rÇq€— ÿÿÿÿÿÿDr:r´q€˜ ÿÿÿÿÿÿNrDr¡q€™ ÿÿÿÿÿÿXrNrŽq€š ÿÿÿÿÿÿbrXr{q€› ÿÿÿÿÿÿlrbrhq€œ ÿÿÿÿÿÿvrlrTq€ ÿÿÿÿÿÿ€rvrÿÿÿÿÿÿžr2.$i@¡ ÿÿÿÿÿÿ¨ržr€¢ >ÿÿÿÿÿÿ±r2.f@@£ ÿÿÿÿÿÿ»r±r€¤ >ÿÿÿÿÿÿÄrf@$i@¥ ÿÿÿÿÿÿÎrÄr€¦ >ÿÿÿÿÿÿ×r2.¦i@§ ÿÿÿÿÿÿár×r€¨ >ÿÿÿÿÿÿêr$i¦i@© ÿÿÿÿÿÿôrêr€ª >ÿÿÿÿÿÿýrf@¦i@« ÿÿÿÿÿÿsýr€¬ >ÿÿÿÿÿÿs2.ìi@­ ÿÿÿÿÿÿss€® >ÿÿÿÿÿÿ#s$iìi@¯ ÿÿÿÿÿÿ-s#s€° >ÿÿÿÿÿÿ6sf@ìi@± ÿÿÿÿÿÿ@s6s€² >ÿÿÿÿÿÿIs¦iìi@³ ÿÿÿÿÿÿSsIs€´ ÿÿÿÿÿÿ\sSs@s€µ ÿÿÿÿÿÿfs\s-s€¶ ÿÿÿÿÿÿpsfss€· ÿÿÿÿÿÿzspss€¸ ÿÿÿÿÿÿ„szsôr€¹ ÿÿÿÿÿÿŽs„sár€º ÿÿÿÿÿÿ˜sŽsÎr€» ÿÿÿÿÿÿ¢s˜s»r€¼ ÿÿÿÿÿÿ¬s¢s¨r€½ >ÿÿÿÿÿÿ¶s³-Þh@¾ ÿÿÿÿÿÿÀs¶s€¿ >ÿÿÿÿÿÿÉsx1Þh@À ÿÿÿÿÿÿÓsÉs€Á >ÿÿÿÿÿÿÜs³-x1@ ÿÿÿÿÿÿæsÜs€Ã >ÿÿÿÿÿÿïsÞhºi@Ä ÿÿÿÿÿÿùsïs€Å >ÿÿÿÿÿÿt³-ºi@Æ ÿÿÿÿÿÿ tt€Ç >ÿÿÿÿÿÿtx1ºi@È ÿÿÿÿÿÿtt€É >ÿÿÿÿÿÿ(tÞhj@Ê ÿÿÿÿÿÿ2t(t€Ë >ÿÿÿÿÿÿ;t³-j@Ì ÿÿÿÿÿÿEt;t€Í >ÿÿÿÿÿÿNtx1j@Î ÿÿÿÿÿÿXtNt€Ï >ÿÿÿÿÿÿatºij@Ð ÿÿÿÿÿÿktat€Ñ ÿÿÿÿÿÿttktXt€Ò ÿÿÿÿÿÿ~tttEt€Ó ÿÿÿÿÿÿˆt~t2t€Ô ÿÿÿÿÿÿ’tˆtt€Õ ÿÿÿÿÿÿœt’t t€Ö ÿÿÿÿÿÿ¦tœtùs€× ÿÿÿÿÿÿ°t¦tæs€Ø ÿÿÿÿÿÿºt°tÓs€Ù ÿÿÿÿÿÿÄtºtÀs€Ú >ÿÿÿÿÿÿÎt|$ê'@Û ÿÿÿÿÿÿØtÎt€Ü >ÿÿÿÿÿÿát°ê'@Ý ÿÿÿÿÿÿëtát€Þ >ÿÿÿÿÿÿôt°|$@ß ÿÿÿÿÿÿþtôt€à >ÿÿÿÿÿÿu_$ê'@á ÿÿÿÿÿÿuu€â >ÿÿÿÿÿÿu_$|$@ã ÿÿÿÿÿÿ$uu€ä >ÿÿÿÿÿÿ-u°_$@å ÿÿÿÿÿÿ7u-u€æ >ÿÿÿÿÿÿ@u£$ê'@ç ÿÿÿÿÿÿJu@u€è >ÿÿÿÿÿÿSu|$£$@é ÿÿÿÿÿÿ]uSu€ê >ÿÿÿÿÿÿfu°£$@ë ÿÿÿÿÿÿpufu€ì >ÿÿÿÿÿÿyu_$£$@í ÿÿÿÿÿÿƒuyu€î ÿÿÿÿÿÿŒuƒupu€ï ÿÿÿÿÿÿ–uŒu]u€ð ÿÿÿÿÿÿ u–uJu€ñ ÿÿÿÿÿÿªu u7u€ò ÿÿÿÿÿÿ´uªu$u€ó ÿÿÿÿÿÿ¾u´uu€ô ÿÿÿÿÿÿÈu¾uþt€õ ÿÿÿÿÿÿÒuÈuët€ö ÿÿÿÿÿÿÜuÒuØt€÷ >ÿÿÿÿÿÿæuühLi@ø ÿÿÿÿÿÿðuæu€ù >ÿÿÿÿÿÿùu¿0üh@ú ÿÿÿÿÿÿvùu€û >ÿÿÿÿÿÿ v¿0Li@ü ÿÿÿÿÿÿv v€ý >ÿÿÿÿÿÿvú,üh@þ ÿÿÿÿÿÿ)vv€ÿ >ÿÿÿÿÿÿ2vú,Li@ ÿÿÿÿÿÿÿÿÿÿÿÿEvú,¿0@ ÿÿÿÿÿÿOvEv€ >ÿÿÿÿÿÿXvühj@ ÿÿÿÿÿÿbvXv€ >ÿÿÿÿÿÿkvLij@ ÿÿÿÿÿÿuvkv€ >ÿÿÿÿÿÿ~v¿0j@ ÿÿÿÿÿÿˆv~v€ >ÿÿÿÿÿÿ‘vú,j@ ÿÿÿÿÿÿ›v‘v€ ÿÿÿÿÿÿ¤v›vˆv€ ÿÿÿÿÿÿ®v¤vuv€ ÿÿÿÿÿÿ¸v®vbv€ ÿÿÿÿÿÿÂv¸vOv€ ÿÿÿÿÿÿÌvÂvÿÿÿÿÿÿþvi`i@ ÿÿÿÿÿÿwþv€ >ÿÿÿÿÿÿw;2i@ ÿÿÿÿÿÿww€ >ÿÿÿÿÿÿ$w;2`i@ ÿÿÿÿÿÿ.w$w€ >ÿÿÿÿÿÿ7wiØi@ ÿÿÿÿÿÿAw7w€ >ÿÿÿÿÿÿJw`iØi@ ÿÿÿÿÿÿTwJw€ >ÿÿÿÿÿÿ]w;2Øi@ ÿÿÿÿÿÿgw]w€ >ÿÿÿÿÿÿpwv.i@! ÿÿÿÿÿÿzwpw€" >ÿÿÿÿÿÿƒwv.`i@# ÿÿÿÿÿÿwƒw€$ >ÿÿÿÿÿÿ–wv.;2@% ÿÿÿÿÿÿ w–w€& >ÿÿÿÿÿÿ©wv.Øi@' ÿÿÿÿÿÿ³w©w€( ÿÿÿÿÿÿ¼w³w w€) ÿÿÿÿÿÿÆw¼ww€* ÿÿÿÿÿÿÐwÆwzw€+ ÿÿÿÿÿÿÚwÐwgw€, ÿÿÿÿÿÿäwÚwTw€- ÿÿÿÿÿÿîwäwAw€. ÿÿÿÿÿÿøwîw.w€/ ÿÿÿÿÿÿxøww€0 ÿÿÿÿÿÿ xxw€1 ÿÿÿÿÿÿx xôv€2 ÿÿÿÿÿÿ xxÜu€3 ÿÿÿÿÿÿ*x xÄt€4 ÿÿÿÿÿÿ4x*x¬s€5 ÿÿÿÿÿÿ>x4x”r€6 SÿÿÿÿÿÿHx2.œ€7 >ÿÿÿÿÿÿRxœHx@8 ÿÿÿÿÿÿ\xRx€9 Sÿÿÿÿÿÿex$i~€: >ÿÿÿÿÿÿoxœex@; ÿÿÿÿÿÿyxox€< Sÿÿÿÿÿÿ‚xf@4€= >ÿÿÿÿÿÿŒxœ‚x@> ÿÿÿÿÿÿ–xŒx€? SÿÿÿÿÿÿŸx¦i<€@ >ÿÿÿÿÿÿ©xœŸx@A ÿÿÿÿÿÿ³x©x€B Sÿÿÿÿÿÿ¼xìi°€C >ÿÿÿÿÿÿÆxœ¼x@D ÿÿÿÿÿÿÐxÆx€E ÿÿÿÿÿÿÙxÐx³x€F ÿÿÿÿÿÿãxÙx–x€G ÿÿÿÿÿÿíxãxyx€H ÿÿÿÿÿÿ÷xíx\x€I SÿÿÿÿÿÿyÞhœ€J >ÿÿÿÿÿÿ y~y@K ÿÿÿÿÿÿy y€L Sÿÿÿÿÿÿy³-~€M >ÿÿÿÿÿÿ(y~y@N ÿÿÿÿÿÿ2y(y€O Sÿÿÿÿÿÿ;yx14€P >ÿÿÿÿÿÿEy~;y@Q ÿÿÿÿÿÿOyEy€R SÿÿÿÿÿÿXyºi<€S >ÿÿÿÿÿÿby~Xy@T ÿÿÿÿÿÿlyby€U Sÿÿÿÿÿÿuyj°€V >ÿÿÿÿÿÿy~uy@W ÿÿÿÿÿÿ‰yy€X ÿÿÿÿÿÿ’y‰yly€Y ÿÿÿÿÿÿœy’yOy€Z ÿÿÿÿÿÿ¦yœy2y€[ ÿÿÿÿÿÿ°y¦yy€\ Sÿÿÿÿÿÿºyê'œ€] >ÿÿÿÿÿÿÄy4ºy@^ ÿÿÿÿÿÿÎyÄy€_ Sÿÿÿÿÿÿ×y|$~€` >ÿÿÿÿÿÿáy4×y@a ÿÿÿÿÿÿëyáy€b Sÿÿÿÿÿÿôy_$<€c >ÿÿÿÿÿÿþy4ôy@d ÿÿÿÿÿÿzþy€e Sÿÿÿÿÿÿz£$°€f >ÿÿÿÿÿÿz4z@g ÿÿÿÿÿÿ%zz€h ÿÿÿÿÿÿ.z%zz€i ÿÿÿÿÿÿ8z.z·$€j ÿÿÿÿÿÿBz8zëy€k ÿÿÿÿÿÿLzBzÎy€l SÿÿÿÿÿÿVzühœ€m >ÿÿÿÿÿÿ`z<Vz@n ÿÿÿÿÿÿjz`z€o SÿÿÿÿÿÿszLi~€p >ÿÿÿÿÿÿ}z<sz@q ÿÿÿÿÿÿ‡z}z€r Sÿÿÿÿÿÿz¿04€s >ÿÿÿÿÿÿšz<z@t ÿÿÿÿÿÿ¤zšz€u Sÿÿÿÿÿÿ­zú,<€v >ÿÿÿÿÿÿ·z<­z@w ÿÿÿÿÿÿÁz·z€x SÿÿÿÿÿÿÊzj°€y >ÿÿÿÿÿÿÔz<Êz@z ÿÿÿÿÿÿÞzÔz€{ ÿÿÿÿÿÿçzÞzÁz€| ÿÿÿÿÿÿñzçz¤z€} ÿÿÿÿÿÿûzñz‡z€~ ÿÿÿÿÿÿ{ûzjz€ Sÿÿÿÿÿÿ{iœ€€ >ÿÿÿÿÿÿ{°{@ ÿÿÿÿÿÿ#{{€‚ Sÿÿÿÿÿÿ,{`i~€ƒ >ÿÿÿÿÿÿ6{°,{@„ ÿÿÿÿÿÿ@{6{€… SÿÿÿÿÿÿI{;24€† >ÿÿÿÿÿÿS{°I{@‡ ÿÿÿÿÿÿ]{S{€ˆ Sÿÿÿÿÿÿf{Øi<€‰ >ÿÿÿÿÿÿp{°f{@Š ÿÿÿÿÿÿz{p{€‹ Sÿÿÿÿÿÿƒ{v.°€Œ >ÿÿÿÿÿÿ{°ƒ{@ ÿÿÿÿÿÿ—{{€Ž ÿÿÿÿÿÿ {—{z{€ ÿÿÿÿÿÿª{ {]{€ ÿÿÿÿÿÿ´{ª{@{€‘ ÿÿÿÿÿÿ¾{´{#{€’ ÿÿÿÿÿÿÈ{¾{{€“ ÿÿÿÿÿÿÒ{È{Lz€” ÿÿÿÿÿÿÜ{Ò{°y€• ÿÿÿÿÿÿæ{Ü{÷x€– >ÿÿÿÿÿÿð{œ2.@— ÿÿÿÿÿÿú{ð{€˜ ÿÿÿÿÿÿ|ð{ú{€™ >ÿÿÿÿÿÿ |~2.@š ÿÿÿÿÿÿ| |€› >ÿÿÿÿÿÿ |œÞh€œ ÿÿÿÿÿÿ*| ||€ ÿÿÿÿÿÿ4|òhg4€ž >ÿÿÿÿÿÿ>|<2.@Ÿ ÿÿÿÿÿÿH|>|€  ÿÿÿÿÿÿQ|?kH|@¡ ÿÿÿÿÿÿ[|+k€¢ >ÿÿÿÿÿÿd|œi€£ ÿÿÿÿÿÿn|d|[|€¤ ÿÿÿÿÿÿx|n|Q|€¥ ÿÿÿÿÿÿ‚|x|4|€¦ ÿÿÿÿÿÿŒ|‚|*|€§ ÿÿÿÿÿÿ–|Œ||€¨ >ÿÿÿÿÿÿ |œ$i@© ÿÿÿÿÿÿª| |€ª ÿÿÿÿÿÿ³| |ª|€« >ÿÿÿÿÿÿ½|~$i@¬ ÿÿÿÿÿÿÇ|½|€­ >ÿÿÿÿÿÿÐ|œ³-€® ÿÿÿÿÿÿÚ|Ð|Ç|€¯ >ÿÿÿÿÿÿä|4$i@° ÿÿÿÿÿÿî|ä|€± ÿÿÿÿÿÿ÷|Skî|@² ÿÿÿÿÿÿ}Ik€³ ÿÿÿÿÿÿ }Vi}@´ ÿÿÿÿÿÿ}.i€µ >ÿÿÿÿÿÿ}œ`i€¶ ÿÿÿÿÿÿ'}}}€· ÿÿÿÿÿÿ1}'} }€¸ ÿÿÿÿÿÿ;}1}÷|€¹ ÿÿÿÿÿÿE};}Ú|€º ÿÿÿÿÿÿO}E}³|€» >ÿÿÿÿÿÿY}œf@@¼ ÿÿÿÿÿÿc}Y}€½ ÿÿÿÿÿÿl}Y}c}@¾ ÿÿÿÿÿÿv}ti€¿ >ÿÿÿÿÿÿ}œx1€À ÿÿÿÿÿÿ‰}}v}€Á >ÿÿÿÿÿÿ“}4f@@ ÿÿÿÿÿÿ}“}€Ã ÿÿÿÿÿÿ¦}ab}€Ä >ÿÿÿÿÿÿ°}<f@@Å ÿÿÿÿÿÿº}°}€Æ >ÿÿÿÿÿÿÃ}œ¿0€Ç ÿÿÿÿÿÿÍ}Ã}º}€È ÿÿÿÿÿÿ×}œiKo€É ÿÿÿÿÿÿá}×}Í}€Ê ÿÿÿÿÿÿë}á}¦}€Ë ÿÿÿÿÿÿõ}ë}‰}€Ì ÿÿÿÿÿÿÿ}õ}l}€Í >ÿÿÿÿÿÿ ~œ¦i@Î ÿÿÿÿÿÿ~ ~€Ï ÿÿÿÿÿÿ~ ~~€Ð >ÿÿÿÿÿÿ&~~¦i@Ñ ÿÿÿÿÿÿ0~&~€Ò ÿÿÿÿÿÿ9~Äi0~@Ó ÿÿÿÿÿÿC~qk€Ô >ÿÿÿÿÿÿL~œ_$€Õ ÿÿÿÿÿÿV~L~C~@Ö ÿÿÿÿÿÿ`~°i€× >ÿÿÿÿÿÿi~œú,€Ø ÿÿÿÿÿÿs~i~`~€Ù >ÿÿÿÿÿÿ}~°¦i@Ú ÿÿÿÿÿÿ‡~}~€Û >ÿÿÿÿÿÿ~œØi€Ü ÿÿÿÿÿÿš~~‡~€Ý ÿÿÿÿÿÿ¤~š~s~€Þ ÿÿÿÿÿÿ®~¤~V~€ß ÿÿÿÿÿÿ¸~®~9~€à ÿÿÿÿÿÿÂ~¸~~@á ÿÿÿÿÿÿÌ~öi€â ÿÿÿÿÿÿÕ~öiÌ~€ã >ÿÿÿÿÿÿß~~ìi@ä ÿÿÿÿÿÿé~ß~€å >ÿÿÿÿÿÿò~œj€æ ÿÿÿÿÿÿü~ò~é~€ç >ÿÿÿÿÿÿ4ìi@è ÿÿÿÿÿÿ€é >ÿÿÿÿÿÿœ£$€ê ÿÿÿÿÿÿ#€ë >ÿÿÿÿÿÿ-<ìi@ì ÿÿÿÿÿÿ7-€í >ÿÿÿÿÿÿ@œj€î ÿÿÿÿÿÿJ@7€ï >ÿÿÿÿÿÿT°ìi@ð ÿÿÿÿÿÿ^T€ñ >ÿÿÿÿÿÿgœv.€ò ÿÿÿÿÿÿqg^€ó ÿÿÿÿÿÿ{qJ€ô ÿÿÿÿÿÿ…{#€õ ÿÿÿÿÿÿ…ü~€ö ÿÿÿÿÿÿ™Õ~€÷ ÿÿÿÿÿÿ£™Â~€ø ÿÿÿÿÿÿ­£ÿ}€ù ÿÿÿÿÿÿ·­O}€ú ÿÿÿÿÿÿÁ·–|@û ÿÿÿÿÿÿË |€ü ÿÿÿÿÿÿÔ |Ë€ý >ÿÿÿÿÿÿÞ~Þh@þ ÿÿÿÿÿÿèÞ€ÿ ÿÿÿÿÿÿñÞè€ >ÿÿÿÿÿÿû4Þh@ ÿÿÿÿÿÿ€û€ >ÿÿÿÿÿÿ€~ê'€ ÿÿÿÿÿÿ€€€@ ÿÿÿÿÿÿ"€èh€ >ÿÿÿÿÿÿ+€~üh€ ÿÿÿÿÿÿ5€+€"€€ >ÿÿÿÿÿÿ?€°Þh@ ÿÿÿÿÿÿI€?€€ ÿÿÿÿÿÿR€iI€€ ÿÿÿÿÿÿ\€R€5€€ ÿÿÿÿÿÿf€\€€€ ÿÿÿÿÿÿp€f€ñ€ ÿÿÿÿÿÿz€p€Ô@ ÿÿÿÿÿÿ„€Ð|€ ÿÿÿÿÿÿ€½|„€@ ÿÿÿÿÿÿ—€8i€ ÿÿÿÿÿÿ €8i—€€ >ÿÿÿÿÿÿª€~|$€ ÿÿÿÿÿÿ´€ª€Ç-€ >ÿÿÿÿÿÿ¾€<³-@ ÿÿÿÿÿÿÈ€¾€€ >ÿÿÿÿÿÿÑ€~Li€ ÿÿÿÿÿÿۀрȀ€ >ÿÿÿÿÿÿ倰³-@ ÿÿÿÿÿÿï€å€€ >ÿÿÿÿÿÿø€~`i€ ÿÿÿÿÿÿø€ï€€ ÿÿÿÿÿÿ Û€€ ÿÿÿÿÿÿ ´€€ ÿÿÿÿÿÿ  €€ ÿÿÿÿÿÿ* €@ ÿÿÿÿÿÿ4}€! ÿÿÿÿÿÿ=ti4€" >ÿÿÿÿÿÿG~x1@# ÿÿÿÿÿÿQG€$ ÿÿÿÿÿÿZGQ@% ÿÿÿÿÿÿd~i€& ÿÿÿÿÿÿm]d€' >ÿÿÿÿÿÿw<x1@( ÿÿÿÿÿÿw€) >ÿÿÿÿÿÿŠ~¿0€* ÿÿÿÿÿÿ”Š€+ >ÿÿÿÿÿÿž~;2€, ÿÿÿÿÿÿ¨ž^o€- ÿÿÿÿÿÿ²¨”€. ÿÿÿÿÿÿ¼²m€/ ÿÿÿÿÿÿƼZ€0 ÿÿÿÿÿÿÐÆ=@1 ÿÿÿÿÿÿÚÄi€2 ÿÿÿÿÿÿã&~Ú€3 >ÿÿÿÿÿÿí~ºi@4 ÿÿÿÿÿÿ÷í€5 ÿÿÿÿÿÿ‚í÷€6 >ÿÿÿÿÿÿ ‚4ºi@7 ÿÿÿÿÿÿ‚ ‚€8 ÿÿÿÿÿÿ‚Îi‚€9 >ÿÿÿÿÿÿ'‚<ºi@: ÿÿÿÿÿÿ1‚'‚€; >ÿÿÿÿÿÿ:‚~ú,€< ÿÿÿÿÿÿD‚:‚1‚€= >ÿÿÿÿÿÿN‚°ºi@> ÿÿÿÿÿÿX‚N‚€? >ÿÿÿÿÿÿa‚~Øi€@ ÿÿÿÿÿÿk‚a‚X‚€A ÿÿÿÿÿÿu‚k‚D‚€B ÿÿÿÿÿÿ‚u‚‚€C ÿÿÿÿÿÿ‰‚‚‚€D ÿÿÿÿÿÿ“‚‰‚ã@E ÿÿÿÿÿÿ‚ò~€F ÿÿÿÿÿÿ¦‚ß~‚€G >ÿÿÿÿÿÿ°‚~j@H ÿÿÿÿÿÿº‚°‚€I ÿÿÿÿÿÿ°‚º‚€J >ÿÿÿÿÿÿÍ‚4j@K ÿÿÿÿÿÿׂ͂€L >ÿÿÿÿÿÿà‚~£$€M ÿÿÿÿÿÿê‚à‚ׂ€N >ÿÿÿÿÿÿô‚<j@O ÿÿÿÿÿÿþ‚ô‚€P ÿÿÿÿÿÿƒ(jþ‚@Q ÿÿÿÿÿÿƒ j€R >ÿÿÿÿÿÿƒ~v.€S ÿÿÿÿÿÿ$ƒƒƒ€T ÿÿÿÿÿÿ.ƒ$ƒƒ€U ÿÿÿÿÿÿ8ƒ.ƒê‚€V ÿÿÿÿÿÿBƒ8ƒÃ‚€W ÿÿÿÿÿÿLƒBƒ¦‚€X ÿÿÿÿÿÿVƒLƒ“‚€Y ÿÿÿÿÿÿ`ƒVƒÐ€Z ÿÿÿÿÿÿjƒ`ƒ*€[ ÿÿÿÿÿÿtƒjƒz€@\ ÿÿÿÿÿÿ~ƒòh€] ÿÿÿÿÿÿ‡ƒ]4~ƒ@^ ÿÿÿÿÿÿ‘ƒ€€_ ÿÿÿÿÿÿšƒû‘ƒ@` ÿÿÿÿÿÿ¤ƒ5k€a ÿÿÿÿÿÿ­ƒ5k¤ƒ€b >ÿÿÿÿÿÿ·ƒ<ê'@c ÿÿÿÿÿÿÁƒ·ƒ€d >ÿÿÿÿÿÿʃ4üh€e ÿÿÿÿÿÿԃʃÁƒ€f >ÿÿÿÿÿÿÞƒ4i€g ÿÿÿÿÿÿèƒÞƒët€h ÿÿÿÿÿÿòƒèƒÔƒ€i ÿÿÿÿÿÿüƒòƒ­ƒ€j ÿÿÿÿÿÿ„üƒšƒ€k ÿÿÿÿÿÿ„„‡ƒ@l ÿÿÿÿÿÿ„Sk€m ÿÿÿÿÿÿ#„ä|„@n ÿÿÿÿÿÿ-„ª€€o ÿÿÿÿÿÿ6„½--„@p ÿÿÿÿÿÿ@„Bi€q ÿÿÿÿÿÿI„Bi@„€r >ÿÿÿÿÿÿS„<|$@s ÿÿÿÿÿÿ]„S„€t ÿÿÿÿÿÿf„]k]„€u >ÿÿÿÿÿÿp„4`i€v ÿÿÿÿÿÿz„p„þt€w ÿÿÿÿÿÿ„„z„f„€x ÿÿÿÿÿÿŽ„„„I„€y ÿÿÿÿÿÿ˜„Ž„6„€z ÿÿÿÿÿÿ¢„˜„#„€{ ÿÿÿÿÿÿ¬„“}kb€| ÿÿÿÿÿÿ¶„~i"]€} >ÿÿÿÿÿÿÀ„4¿0€~ ÿÿÿÿÿÿÊ„À„Ë\@ ÿÿÿÿÿÿÔ„€€ ÿÿÿÿÿÿÝ„E2€ ÿÿÿÿÿÿç„Ý„Ê„€‚ ÿÿÿÿÿÿñ„ç„„T€ƒ ÿÿÿÿÿÿû„ñ„¶„€„ ÿÿÿÿÿÿ…û„¬„@… ÿÿÿÿÿÿ…L~€† ÿÿÿÿÿÿ…qk…@‡ ÿÿÿÿÿÿ"…Îi€ˆ ÿÿÿÿÿÿ+… ‚"…€‰ >ÿÿÿÿÿÿ5…4_$@Š ÿÿÿÿÿÿ?…5…€‹ ÿÿÿÿÿÿH…5…?…€Œ >ÿÿÿÿÿÿR…<_$@ ÿÿÿÿÿÿ\…R…€Ž ÿÿÿÿÿÿe…-\…€ >ÿÿÿÿÿÿo…4Øi€ ÿÿÿÿÿÿy…o…7u€‘ ÿÿÿÿÿÿƒ…y…e…€’ ÿÿÿÿÿÿ…ƒ…H…€“ ÿÿÿÿÿÿ—……+…€” ÿÿÿÿÿÿ¡…—……@• ÿÿÿÿÿÿ«…€– ÿÿÿÿÿÿ´…«…@— ÿÿÿÿÿÿ¾…à‚€˜ ÿÿÿÿÿÿÇ…Í‚¾…€™ ÿÿÿÿÿÿÑ…­$·$@š ÿÿÿÿÿÿÛ…j€› >ÿÿÿÿÿÿä…4j€œ ÿÿÿÿÿÿî…ä…Û…€ ÿÿÿÿÿÿø…€.pu€ž ÿÿÿÿÿÿ†ø…î…€Ÿ ÿÿÿÿÿÿ ††Ñ…€  ÿÿÿÿÿÿ† †Ç…€¡ ÿÿÿÿÿÿ ††´…€¢ ÿÿÿÿÿÿ*† †¡…€£ ÿÿÿÿÿÿ4†*†…€¤ ÿÿÿÿÿÿ>†4†¢„€¥ ÿÿÿÿÿÿH†>†„@¦ ÿÿÿÿÿÿR†?k€§ ÿÿÿÿÿÿ[†>|R†@¨ ÿÿÿÿÿÿe†+€€© ÿÿÿÿÿÿn†èhe†@ª ÿÿÿÿÿÿx†Êƒ€« ÿÿÿÿÿÿ†·ƒx†€¬ >ÿÿÿÿÿÿ‹†<üh@­ ÿÿÿÿÿÿ•†‹†€® ÿÿÿÿÿÿž†‹†•†@¯ ÿÿÿÿÿÿ¨†i€° >ÿÿÿÿÿÿ±†<i€± ÿÿÿÿÿÿ»†±†¨†€² ÿÿÿÿÿÿņ»†ž†€³ ÿÿÿÿÿÿφņ†€´ ÿÿÿÿÿÿنφn†€µ ÿÿÿÿÿÿã†Ù†[†@¶ ÿÿÿÿÿÿí†Vi€· ÿÿÿÿÿÿö†Ikí†@¸ ÿÿÿÿÿÿ‡Ñ€€¹ ÿÿÿÿÿÿ ‡¾€‡@º ÿÿÿÿÿÿ‡]k€» ÿÿÿÿÿÿ‡S„‡€¼ >ÿÿÿÿÿÿ&‡<Li@½ ÿÿÿÿÿÿ0‡&‡€¾ ÿÿÿÿÿÿ9‡&‡0‡€¿ >ÿÿÿÿÿÿC‡°Li@À ÿÿÿÿÿÿM‡C‡€Á ÿÿÿÿÿÿV‡jiM‡€Â ÿÿÿÿÿÿ`‡V‡9‡€Ã ÿÿÿÿÿÿj‡`‡‡€Ä ÿÿÿÿÿÿt‡j‡ ‡€Å ÿÿÿÿÿÿ~‡t‡ö†@Æ ÿÿÿÿÿÿˆ‡Ã}€Ç ÿÿÿÿÿÿ‘‡°}ˆ‡@È ÿÿÿÿÿÿ›‡Š€É ÿÿÿÿÿÿ¤‡w›‡@Ê ÿÿÿÿÿÿ®‡À„€Ë ÿÿÿÿÿÿ·‡Á\®‡@Ì ÿÿÿÿÿÿÁ‡’i€Í ÿÿÿÿÿÿʇ’iÁ‡€Î >ÿÿÿÿÿÿÔ‡<;2€Ï ÿÿÿÿÿÿÞ‡Ô‡—o€Ð ÿÿÿÿÿÿè‡Þ‡Ê‡€Ñ ÿÿÿÿÿÿò‡è‡·‡€Ò ÿÿÿÿÿÿü‡ò‡¤‡€Ó ÿÿÿÿÿÿˆü‡‘‡@Ô ÿÿÿÿÿÿˆi~€Õ ÿÿÿÿÿÿˆ°iˆ@Ö ÿÿÿÿÿÿ#ˆ:‚€× ÿÿÿÿÿÿ,ˆ'‚#ˆ€Ø ÿÿÿÿÿÿ6ˆR…-€Ù >ÿÿÿÿÿÿ@ˆ<ú,@Ú ÿÿÿÿÿÿJˆ@ˆ€Û ÿÿÿÿÿÿSˆ@ˆJˆ@Ü ÿÿÿÿÿÿ]ˆ{k€Ý ÿÿÿÿÿÿfˆ…k]ˆ€Þ ÿÿÿÿÿÿpˆfˆSˆ€ß ÿÿÿÿÿÿzˆpˆ6ˆ€à ÿÿÿÿÿÿ„ˆzˆ,ˆ€á ÿÿÿÿÿÿŽˆ„ˆˆ@â ÿÿÿÿÿÿ˜ˆ@€ã ÿÿÿÿÿÿ¡ˆ-˜ˆ@ä ÿÿÿÿÿÿ«ˆ(j€å ÿÿÿÿÿÿ´ˆô‚«ˆ@æ ÿÿÿÿÿÿ¾ˆä…€ç ÿÿÿÿÿÿLjj¾ˆ€è >ÿÿÿÿÿÿш<j@é ÿÿÿÿÿÿۈш€ê ÿÿÿÿÿÿäˆÑˆÛˆ€ë >ÿÿÿÿÿÿj@ì ÿÿÿÿÿÿøˆîˆ€í >ÿÿÿÿÿÿ‰<v.€î ÿÿÿÿÿÿ ‰‰øˆ€ï ÿÿÿÿÿÿ‰ ‰äˆ€ð ÿÿÿÿÿÿ‰‰Çˆ€ñ ÿÿÿÿÿÿ)‰‰´ˆ€ò ÿÿÿÿÿÿ3‰)‰¡ˆ€ó ÿÿÿÿÿÿ=‰3‰Žˆ€ô ÿÿÿÿÿÿG‰=‰ˆ€õ ÿÿÿÿÿÿQ‰G‰~‡€ö ÿÿÿÿÿÿ[‰Q‰ã†@÷ ÿÿÿÿÿÿe‰d|€ø ÿÿÿÿÿÿn‰+ke‰@ù ÿÿÿÿÿÿx‰i€ú ÿÿÿÿÿÿ‰?€x‰@û ÿÿÿÿÿÿ‹‰Þƒ€ü ÿÿÿÿÿÿ”‰át‹‰@ý ÿÿÿÿÿÿž‰±†€þ ÿÿÿÿÿÿ§‰iž‰€ÿ >ÿÿÿÿÿÿ±‰°i@ÿÿÿÿÿÿ»‰±‰€ÿÿÿÿÿÿĉ±‰»‰€ÿÿÿÿÿÿΉĉ§‰€ÿÿÿÿÿÿ؉Ή”‰€ÿÿÿÿÿÿâ‰Ø‰‰€ÿÿÿÿÿÿì‰â‰n‰@ÿÿÿÿÿÿö‰}€ÿÿÿÿÿÿÿ‰.iö‰@ÿÿÿÿÿÿ Šø€€ ÿÿÿÿÿÿŠå€ Š@ ÿÿÿÿÿÿŠp„€ ÿÿÿÿÿÿ%ŠôtŠ@ ÿÿÿÿÿÿ/Šji€ ÿÿÿÿÿÿ8ŠC‡/Š@ÿÿÿÿÿÿBŠgk€ÿÿÿÿÿÿKŠgkBŠ€ÿÿÿÿÿÿUŠKŠ8Š€ÿÿÿÿÿÿ_ŠUŠ%Š€ÿÿÿÿÿÿiŠ_ŠŠ€ÿÿÿÿÿÿsŠiŠÿ‰@ÿÿÿÿÿÿ}Šœi€ÿÿÿÿÿÿ†ŠAo}Š@ÿÿÿÿÿÿŠž€ÿÿÿÿÿÿ™ŠToŠ€ÿÿÿÿÿÿ£ŠO2@ÿÿÿÿÿÿ­ŠÔ‡€ÿÿÿÿÿÿ¶Šo­Š€ÿÿÿÿÿÿÀŠÆoÐo€ÿÿÿÿÿÿÊŠÀŠ¶Š€ÿÿÿÿÿÿÔŠÊŠ£Š€ÿÿÿÿÿÿÞŠÔŠ™Š€ÿÿÿÿÿÿèŠÞŠ†Š@ ÿÿÿÿÿÿòŠ~€!ÿÿÿÿÿÿûŠ}~òŠ@"ÿÿÿÿÿÿ‹a‚€#ÿÿÿÿÿÿ‹N‚‹@$ÿÿÿÿÿÿ‹o…€%ÿÿÿÿÿÿ!‹-u‹@&ÿÿÿÿÿÿ+‹…k€'ÿÿÿÿÿÿ4‹{k+‹@(ÿÿÿÿÿÿ>‹âi€)ÿÿÿÿÿÿG‹âi>‹€*ÿÿÿÿÿÿQ‹G‹4‹€+ÿÿÿÿÿÿ[‹Q‹!‹€,ÿÿÿÿÿÿe‹[‹‹€-ÿÿÿÿÿÿo‹e‹ûŠ@.ÿÿÿÿÿÿy‹g€/ÿÿÿÿÿÿ‚‹Ty‹@0ÿÿÿÿÿÿŒ‹ƒ€1ÿÿÿÿÿÿ•‹ jŒ‹€2ÿÿÿÿÿÿŸ‹fuŠ.@3ÿÿÿÿÿÿ©‹‰€4ÿÿÿÿÿÿ²‹îˆ©‹€5>ÿÿÿÿÿÿ¼‹°v.@6ÿÿÿÿÿÿÆ‹¼‹€7ÿÿÿÿÿÿÏ‹¼‹Æ‹€8ÿÿÿÿÿÿÙ‹Ï‹²‹€9ÿÿÿÿÿÿã‹Ù‹Ÿ‹€:ÿÿÿÿÿÿí‹ã‹•‹€;ÿÿÿÿÿÿ÷‹í‹‚‹€<ÿÿÿÿÿÿŒ÷‹o‹€=ÿÿÿÿÿÿ ŒŒèŠ€>ÿÿÿÿÿÿŒ ŒsŠ€?ÿÿÿÿÿÿŒŒì‰€@ÿÿÿÿÿÿ)ŒŒ[‰€Aÿÿÿÿÿÿ3Œ)ŒH†€Bÿÿÿÿÿÿ=Œ3Œtƒ€CÿÿÿÿÿÿGŒ=ŒÁ€DÿÿÿÿÿÿQŒú{ð{€Eÿÿÿÿÿÿ[ŒË |€FÿÿÿÿÿÿeŒ~ƒY}€GÿÿÿÿÿÿoŒR† ~€HÿÿÿÿÿÿyŒe‰öi€IÿÿÿÿÿÿƒŒyŒoŒ€JÿÿÿÿÿÿŒƒŒeŒ€Kÿÿÿÿÿÿ—ŒŒ[Œ€Lÿÿÿÿÿÿ¡Œ—ŒQŒ€Mÿÿÿÿÿÿ«Œª| |€NÿÿÿÿÿÿµŒ„€Ð|€Oÿÿÿÿÿÿ¿Œ„}€PÿÿÿÿÿÿÉŒí†Äi€QÿÿÿÿÿÿÓŒö‰ò~€Rÿÿÿÿÿÿ݌ӌɌ€SÿÿÿÿÿÿçŒÝŒ¿Œ€TÿÿÿÿÿÿñŒçŒµŒ€UÿÿÿÿÿÿûŒñŒ«Œ€Vÿÿÿÿÿÿc}òh€Wÿÿÿÿÿÿ4Sk€Xÿÿÿÿÿÿkbab€Yÿÿÿÿÿÿ#ˆ‡L~€Zÿÿÿÿÿÿ-}Š€[ÿÿÿÿÿÿ7-#€\ÿÿÿÿÿÿA7€]ÿÿÿÿÿÿKA€^ÿÿÿÿÿÿUK€_ÿÿÿÿÿÿ_~?k€`ÿÿÿÿÿÿiÚVi€aÿÿÿÿÿÿs…Ã}€bÿÿÿÿÿÿ}ˆi~€cÿÿÿÿÿÿ‡òŠ@€dÿÿÿÿÿÿ‘‡}€eÿÿÿÿÿÿ›‘s€fÿÿÿÿÿÿ¥›i€gÿÿÿÿÿÿ¯¥_€hÿÿÿÿÿÿ¹Ì~d|€iÿÿÿÿÿÿÂ}€jÿÿÿÿÿÿÍ«…œi€kÿÿÿÿÿÿטˆ~€lÿÿÿÿÿÿáy‹g€mÿÿÿÿÿÿëá×€nÿÿÿÿÿÿõëÍ€oÿÿÿÿÿÿÿõÀpÿÿÿÿÿÿ Žÿ¹€qÿÿÿÿÿÿŽ Ž¯€rÿÿÿÿÿÿŽŽU€sÿÿÿÿÿÿ'ŽŽûŒ€tÿÿÿÿÿÿ1Ž'Ž¡Œ€uÿÿÿÿÿÿ;Ž| |€vÿÿÿÿÿÿEŽè½|€wÿÿÿÿÿÿOŽ‘ƒti€xÿÿÿÿÿÿYŽe†&~€yÿÿÿÿÿÿcŽx‰ß~€zÿÿÿÿÿÿmŽcŽYŽ€{ÿÿÿÿÿÿwŽmŽOŽ€|ÿÿÿÿÿÿŽwŽEŽ€}ÿÿÿÿÿÿ‹ŽŽ;Ž€~ÿÿÿÿÿÿ•ŽÇ|Þ€ÿÿÿÿÿÿŸŽ—€8i€€ÿÿÿÿÿÿ©Ž-„G€ÿÿÿÿÿÿ³Ž‡í€‚ÿÿÿÿÿÿ½Ž Š°‚€ƒÿÿÿÿÿÿÇŽ½Ž³Ž€„ÿÿÿÿÿÿÑŽÇŽ©Ž€…ÿÿÿÿÿÿÛŽÑŽŸŽ€†ÿÿÿÿÿÿåŽÛŽ•Ž€‡ÿÿÿÿÿÿïŽv}€€ˆÿÿÿÿÿÿùŽQª€€‰ÿÿÿÿÿÿ"]]€Šÿÿÿÿÿÿ ›‡Îi€‹ÿÿÿÿÿÿŠà‚€Œÿÿÿÿÿÿ! €ÿÿÿÿÿÿ+!€Žÿÿÿÿÿÿ5+ùŽ€ÿÿÿÿÿÿ?5ÿÿÿÿÿÿI0~+€€‘ÿÿÿÿÿÿS÷Ñ€€’ÿÿÿÿÿÿ]"…Š€“ÿÿÿÿÿÿg#ˆ:‚€”ÿÿÿÿÿÿq‹(j€•ÿÿÿÿÿÿ{qg€–ÿÿÿÿÿÿ…{]€—ÿÿÿÿÿÿ…S€˜ÿÿÿÿÿÿ™I€™ÿÿÿÿÿÿ£é~i€šÿÿÿÿÿÿ­º‚ø€€›ÿÿÿÿÿÿ·¾…ž€œÿÿÿÿÿÿÁ«ˆa‚€ÿÿÿÿÿÿËŒ‹ƒ€žÿÿÿÿÿÿÕËÁ€ŸÿÿÿÿÿÿßÕ·€ ÿÿÿÿÿÿéß­€¡ÿÿÿÿÿÿó飀¢ÿÿÿÿÿÿý󙀣ÿÿÿÿÿÿý?€¤ÿÿÿÿÿÿ厀¥ÿÿÿÿÿÿ‹Ž€¦ÿÿÿÿÿÿ%g4]4€§ÿÿÿÿÿÿ/€ä|€¨ÿÿÿÿÿÿ9¤ƒ“}€©ÿÿÿÿÿÿCx†qk€ªÿÿÿÿÿÿM‹‰€«ÿÿÿÿÿÿWMC€¬ÿÿÿÿÿÿaW9€­ÿÿÿÿÿÿka/€®ÿÿÿÿÿÿuk%€¯ÿÿÿÿÿÿî|û€°ÿÿÿÿÿÿ‰Ç-½-€±ÿÿÿÿÿÿ“@„~i€²ÿÿÿÿÿÿ‡ ‚€³ÿÿÿÿÿÿ§ŠÍ‚€´ÿÿÿÿÿÿ±§€µÿÿÿÿÿÿ»±“€¶ÿÿÿÿÿÿÅ»‰€·ÿÿÿÿÿÿÏÅ€¸ÿÿÿÿÿÿÙ}5k€¹ÿÿÿÿÿÿãdBi€ºÿÿÿÿÿÿí®‡5…€»ÿÿÿÿÿÿ÷O2­$€¼ÿÿÿÿÿÿ‘÷퀽ÿÿÿÿÿÿ ‘‘ÊJ€¾ÿÿÿÿÿÿ‘ ‘〿ÿÿÿÿÿÿ‘‘Ù€Àÿÿÿÿÿÿ)‘C~ʃ€Áÿÿÿÿÿÿ3‘‚]k€Âÿÿÿÿÿÿ=‘?…À„€ÃÿÿÿÿÿÿG‘--€ÄÿÿÿÿÿÿQ‘‹ä…€Åÿÿÿÿÿÿ[‘Q‘G‘€Æÿÿÿÿÿÿe‘[‘=‘€Çÿÿÿÿÿÿo‘e‘3‘€Èÿÿÿÿÿÿy‘o‘)‘€Éÿÿÿÿÿÿƒ‘Þƒ€Êÿÿÿÿÿÿ‘ׂp„€Ëÿÿÿÿÿÿ—‘·$E2€Ìÿÿÿÿÿÿ¡‘¾ˆo…€Íÿÿÿÿÿÿ«‘Š.€.€Îÿÿÿÿÿÿµ‘«‘¡‘€Ïÿÿÿÿÿÿ¿‘µ‘—‘€ÐÿÿÿÿÿÿÉ‘¿‘‘€ÑÿÿÿÿÿÿÓ‘É‘ƒ‘€ÒÿÿÿÿÿÿÝ‘Ó‘y‘€Óÿÿÿÿÿÿç‘Ý‘‘€Ôÿÿÿÿÿÿñ‘ç‘Ï€Õÿÿÿÿÿÿû‘ñ‘u€Öÿÿÿÿÿÿ’H|>|€×ÿÿÿÿÿÿ’"€Ik€Øÿÿÿÿÿÿ’Áƒ°}€Ùÿÿÿÿÿÿ#’•†°i€Úÿÿÿÿÿÿ-’ž‰-€Ûÿÿÿÿÿÿ7’-’#’€ÜÿÿÿÿÿÿA’7’’€ÝÿÿÿÿÿÿK’A’’€ÞÿÿÿÿÿÿU’K’’€ßÿÿÿÿÿÿ_’}èh€àÿÿÿÿÿÿi’È€¾€€áÿÿÿÿÿÿs’]„w€âÿÿÿÿÿÿ}’0‡'‚€ãÿÿÿÿÿÿ‡’/Šô‚€äÿÿÿÿÿÿ‘’‡’}’€åÿÿÿÿÿÿ›’‘’s’€æÿÿÿÿÿÿ¥’›’i’€çÿÿÿÿÿÿ¯’¥’_’€èÿÿÿÿÿÿ¹’º}·ƒ€éÿÿÿÿÿÿÃ’S„€êÿÿÿÿÿÿÍ’Ë\Á\€ëÿÿÿÿÿÿ×’Á‡R…€ìÿÿÿÿÿÿá’­Šj€íÿÿÿÿÿÿë’á’×’€îÿÿÿÿÿÿõ’ë’Í’€ïÿÿÿÿÿÿÿ’õ’Ã’€ðÿÿÿÿÿÿ “ÿ’¹’€ñÿÿÿÿÿÿ“`~‹†€òÿÿÿÿÿÿ“1‚&‡€óÿÿÿÿÿÿ'“\…’i€ôÿÿÿÿÿÿ1“Jˆ@ˆ€õÿÿÿÿÿÿ;“+‹Ñˆ€öÿÿÿÿÿÿE“;“1“€÷ÿÿÿÿÿÿO“E“'“€øÿÿÿÿÿÿY“O““€ùÿÿÿÿÿÿc“Y““€úÿÿÿÿÿÿm“7±†€ûÿÿÿÿÿÿw“þ‚ji€üÿÿÿÿÿÿ“Û…Ô‡€ýÿÿÿÿÿÿ‹“Ûˆ…k€þÿÿÿÿÿÿ•“©‹‰€ÿÿÿÿÿÿÿŸ“•“‹“€ÿÿÿÿÿÿ©“Ÿ““€ÿÿÿÿÿÿ³“©“w“€ÿÿÿÿÿÿ½“³“m“€ÿÿÿÿÿÿÇ“½“c“€ÿÿÿÿÿÿÑ“Ç“ “€ÿÿÿÿÿÿÛ“Ñ“¯’€ÿÿÿÿÿÿå“Û“U’€ÿÿÿÿÿÿï“[|+k€ÿÿÿÿÿÿù“I€.i€ ÿÿÿÿÿÿ”ëtAo€ ÿÿÿÿÿÿ ”¨†}~€ ÿÿÿÿÿÿ”»‰T€ ÿÿÿÿÿÿ!”” ”€ ÿÿÿÿÿÿ+”!””€ÿÿÿÿÿÿ5”+”ù“€ÿÿÿÿÿÿ?”5”ï“€ÿÿÿÿÿÿI”}?€€ÿÿÿÿÿÿS”ï€å€€ÿÿÿÿÿÿ]”þtTo€ÿÿÿÿÿÿg”M‡N‚€ÿÿÿÿÿÿq”BŠ j€ÿÿÿÿÿÿ{”q”g”€ÿÿÿÿÿÿ…”{”]”€ÿÿÿÿÿÿ”…”S”€ÿÿÿÿÿÿ™””I”€ÿÿÿÿÿÿ£”Koát€ÿÿÿÿÿÿ­”^oôt€ÿÿÿÿÿÿ·”€ÿÿÿÿÿÿÁ”—o-u€ÿÿÿÿÿÿË”Ðofu€ÿÿÿÿÿÿՔ˔Á”€ÿÿÿÿÿÿߔՔ·”€ ÿÿÿÿÿÿé”ß”­”€!ÿÿÿÿÿÿó”锣”€"ÿÿÿÿÿÿý”‡~i€#ÿÿÿÿÿÿ•X‚C‡€$ÿÿÿÿÿÿ•7uo€%ÿÿÿÿÿÿ•]ˆ{k€&ÿÿÿÿÿÿ%•>‹îˆ€'ÿÿÿÿÿÿ/•%••€(ÿÿÿÿÿÿ9•/••€)ÿÿÿÿÿÿC•9••€*ÿÿÿÿÿÿM•C•ý”€+ÿÿÿÿÿÿW•^±‰€,ÿÿÿÿÿÿa•ƒgk€-ÿÿÿÿÿÿk•puÆo€.ÿÿÿÿÿÿu•øˆâi€/ÿÿÿÿÿÿ•Æ‹¼‹€0ÿÿÿÿÿÿ‰••u•€1ÿÿÿÿÿÿ“•‰•k•€2ÿÿÿÿÿÿ•“•a•€3ÿÿÿÿÿÿ§••W•€4ÿÿÿÿÿÿ±•§•M•€5ÿÿÿÿÿÿ»•±•ó”€6ÿÿÿÿÿÿÅ•»•™”€7ÿÿÿÿÿÿÏ•Å•?”€8ÿÿÿÿÿÿÙ•Ï•å“€9ÿÿÿÿÿÿã•Ù•û‘€:ÿÿÿÿÿÿí•ã•€;ÿÿÿÿÿÿ÷•í•1Ž€<ÿÿÿÿÿÿ–»‰•†€=ÿÿÿÿÿÿ ––¤ƒ€>ÿÿÿÿÿÿ– –è€?ÿÿÿÿÿÿ––ú{€@ÿÿÿÿÿÿ)–BŠ0‡€Aÿÿÿÿÿÿ3–)–@„€Bÿÿÿÿÿÿ=–3–—€€CÿÿÿÿÿÿG–=–ª|€DÿÿÿÿÿÿQ–ÐoÁ‡€Eÿÿÿÿÿÿ[–Q–v€Fÿÿÿÿÿÿe–[–Q€Gÿÿÿÿÿÿo–e–c}€Hÿÿÿÿÿÿy–>‹Jˆ€Iÿÿÿÿÿÿƒ–y–?…€Jÿÿÿÿÿÿ–ƒ–÷€Kÿÿÿÿÿÿ—––~€Lÿÿÿÿÿÿ¡–Æ‹Ûˆ€Mÿÿÿÿÿÿ«–¡–·$€Nÿÿÿÿÿÿµ–«–º‚€Oÿÿÿÿÿÿ¿–µ–Ì~€PÿÿÿÿÿÿÉ–¿–—–€QÿÿÿÿÿÿÓ–É–o–€RÿÿÿÿÿÿÝ–Ó–G–€Sÿÿÿÿÿÿç–Ý––€TSÿÿÿÿÿÿñ–œ2.€U>ÿÿÿÿÿÿû–œñ–@Vÿÿÿÿÿÿ—û–€WSÿÿÿÿÿÿ—~2.€X>ÿÿÿÿÿÿ—~—@Yÿÿÿÿÿÿ"——€ZSÿÿÿÿÿÿ+—42.€[>ÿÿÿÿÿÿ5—4+—@\ÿÿÿÿÿÿ?—5—€]SÿÿÿÿÿÿH—<2.€^>ÿÿÿÿÿÿR—<H—@_ÿÿÿÿÿÿ\—R—€`Sÿÿÿÿÿÿe—°2.€a>ÿÿÿÿÿÿo—°e—@bÿÿÿÿÿÿy—o—€cÿÿÿÿÿÿ‚—y—\—€dÿÿÿÿÿÿŒ—‚—?—€eÿÿÿÿÿÿ–—Œ—"—€fÿÿÿÿÿÿ —–——€gSÿÿÿÿÿÿª—œ³-€h>ÿÿÿÿÿÿ´—œª—@iÿÿÿÿÿÿ¾—´—€jSÿÿÿÿÿÿÇ—~³-€k>ÿÿÿÿÿÿÑ—~Ç—@lÿÿÿÿÿÿÛ—Ñ—€mSÿÿÿÿÿÿä—4³-€n>ÿÿÿÿÿÿî—4ä—@oÿÿÿÿÿÿø—î—€pSÿÿÿÿÿÿ˜<³-€q>ÿÿÿÿÿÿ ˜<˜@rÿÿÿÿÿÿ˜ ˜€sSÿÿÿÿÿÿ˜°³-€t>ÿÿÿÿÿÿ(˜°˜@uÿÿÿÿÿÿ2˜(˜€vÿÿÿÿÿÿ;˜2˜˜€wÿÿÿÿÿÿE˜;˜ø—€xÿÿÿÿÿÿO˜E˜Û—€yÿÿÿÿÿÿY˜O˜¾—€zÿÿÿÿÿÿc˜Æ‹+‹€{ÿÿÿÿÿÿm˜c˜O2€|ÿÿÿÿÿÿw˜m˜ Š€}ÿÿÿÿÿÿ˜w˜e‰€~Sÿÿÿÿÿÿ‹˜œú,€>ÿÿÿÿÿÿ•˜œ‹˜@€ÿÿÿÿÿÿŸ˜•˜€Sÿÿÿÿÿÿ¨˜~ú,€‚>ÿÿÿÿÿÿ²˜~¨˜@ƒÿÿÿÿÿÿ¼˜²˜€„SÿÿÿÿÿÿŘ4ú,€…>ÿÿÿÿÿÿϘ4Ř@†ÿÿÿÿÿÿ٘Ϙ€‡Sÿÿÿÿÿÿâ˜<ú,€ˆ>ÿÿÿÿÿÿì˜<â˜@‰ÿÿÿÿÿÿö˜ì˜€ŠSÿÿÿÿÿÿÿ˜°ú,€‹>ÿÿÿÿÿÿ ™°ÿ˜@Œÿÿÿÿÿÿ™ ™€ÿÿÿÿÿÿ™™ö˜€Žÿÿÿÿÿÿ&™™Ù˜€ÿÿÿÿÿÿ0™&™¼˜€ÿÿÿÿÿÿ:™0™Ÿ˜€‘SÿÿÿÿÿÿD™œv.€’>ÿÿÿÿÿÿN™œD™@“ÿÿÿÿÿÿX™N™€”Sÿÿÿÿÿÿa™~v.€•>ÿÿÿÿÿÿk™~a™@–ÿÿÿÿÿÿu™k™€—Sÿÿÿÿÿÿ~™4v.€˜>ÿÿÿÿÿÿˆ™4~™@™ÿÿÿÿÿÿ’™ˆ™€šSÿÿÿÿÿÿ›™<v.€›>ÿÿÿÿÿÿ¥™<›™@œÿÿÿÿÿÿ¯™¥™€Sÿÿÿÿÿÿ¸™°v.€ž>ÿÿÿÿÿÿ™°¸™@Ÿÿÿÿÿÿÿ̙™€ ÿÿÿÿÿÿՙ̙¯™€¡ÿÿÿÿÿÿߙՙ’™€¢ÿÿÿÿÿÿé™ß™u™€£ÿÿÿÿÿÿó™é™X™€¤ÿÿÿÿÿÿý™ó™:™€¥ÿÿÿÿÿÿšý™˜€¦ÿÿÿÿÿÿššY˜€§ÿÿÿÿÿÿšš —€¨Sÿÿÿÿÿÿ%šœÞh€©>ÿÿÿÿÿÿ/š~%š€ªSÿÿÿÿÿÿ9šœê'€«>ÿÿÿÿÿÿCš49š€¬SÿÿÿÿÿÿMšœüh€­>ÿÿÿÿÿÿWš<Mš€®Sÿÿÿÿÿÿašœi€¯>ÿÿÿÿÿÿkš°aš€°ÿÿÿÿÿÿuškšWš€±ÿÿÿÿÿÿšušCš€²ÿÿÿÿÿÿ‰šš/š€³ÿÿÿÿÿÿ“š‰šû–€´Sÿÿÿÿÿÿš~$i€µ>ÿÿÿÿÿÿ§šœš€¶Sÿÿÿÿÿÿ±š~|$€·>ÿÿÿÿÿÿ»š4±š€¸SÿÿÿÿÿÿÅš~Li€¹>ÿÿÿÿÿÿÏš<Åš€ºSÿÿÿÿÿÿÙš~`i€»>ÿÿÿÿÿÿãš°Ùš€¼ÿÿÿÿÿÿíšãšÏš€½ÿÿÿÿÿÿ÷šíš»š€¾ÿÿÿÿÿÿ›÷šÑ—€¿ÿÿÿÿÿÿ ››§š€ÀSÿÿÿÿÿÿ›4f@€Á>ÿÿÿÿÿÿ›œ›€ÂSÿÿÿÿÿÿ)›4x1€Ã>ÿÿÿÿÿÿ3›~)›€ÄSÿÿÿÿÿÿ=›4¿0€Å>ÿÿÿÿÿÿG›<=›€ÆSÿÿÿÿÿÿQ›4;2€Ç>ÿÿÿÿÿÿ[›°Q›€Èÿÿÿÿÿÿe›[›G›€Éÿÿÿÿÿÿo›e›E2€Êÿÿÿÿÿÿy›o›3›€Ëÿÿÿÿÿÿƒ›y››€ÌSÿÿÿÿÿÿ›<¦i€Í>ÿÿÿÿÿÿ—›œ›€ÎSÿÿÿÿÿÿ¡›<ºi€Ï>ÿÿÿÿÿÿ«›~¡›€ÐSÿÿÿÿÿÿµ›<_$€Ñ>ÿÿÿÿÿÿ¿›4µ›€ÒSÿÿÿÿÿÿÉ›<Øi€Ó>ÿÿÿÿÿÿÓ›°É›€Ôÿÿÿÿÿÿݛӛ였Õÿÿÿÿÿÿç›Ý›¿›€Öÿÿÿÿÿÿñ›ç›«›€×ÿÿÿÿÿÿû›ñ›—›€ØSÿÿÿÿÿÿœ°ìi€Ù>ÿÿÿÿÿÿœœœ€ÚSÿÿÿÿÿÿœ°j€Û>ÿÿÿÿÿÿ#œ~œ€ÜSÿÿÿÿÿÿ-œ°£$€Ý>ÿÿÿÿÿÿ7œ4-œ€ÞSÿÿÿÿÿÿAœ°j€ß>ÿÿÿÿÿÿKœ<Aœ€àÿÿÿÿÿÿUœÂ™Kœ€áÿÿÿÿÿÿ_œUœ7œ€âÿÿÿÿÿÿiœ_œ#œ€ãÿÿÿÿÿÿsœiœœ€äÿÿÿÿÿÿ}œsœû›€åÿÿÿÿÿÿ‡œ}œƒ›€æÿÿÿÿÿÿ‘œ‡œ ›€çÿÿÿÿÿÿ›œ‘œ“š€èÿÿÿÿÿÿ¥œËÇ|€éÿÿÿÿÿÿ¯œ~ƒ}€êÿÿÿÿÿÿ¹œR†`~€ëÿÿÿÿÿÿÃœe‰^€ìÿÿÿÿÿÿܹ͜œ€íÿÿÿÿÿÿל͜¯œ€îÿÿÿÿÿÿáœ×œ¥œ€ïÿÿÿÿÿÿëœáœú{€ðÿÿÿÿÿÿõœª|Ë€ñÿÿÿÿÿÿÿœ„€—€€òÿÿÿÿÿÿ „d€óÿÿÿÿÿÿí†1‚€ôÿÿÿÿÿÿö‰ƒ€õÿÿÿÿÿÿ'€öÿÿÿÿÿÿ1' €÷ÿÿÿÿÿÿ;1ÿœ€øÿÿÿÿÿÿE;õœ€ùÿÿÿÿÿÿOc}~ƒ€úÿÿÿÿÿÿY4-„€ûÿÿÿÿÿÿckbv€üÿÿÿÿÿÿmˆ‡\…€ýÿÿÿÿÿÿw}Špu€þÿÿÿÿÿÿwm€ÿÿÿÿÿÿÿ‹c€ÿÿÿÿÿÿ•‹Y€ÿÿÿÿÿÿŸ•O€ÿÿÿÿÿÿ©~R†€ÿÿÿÿÿÿ³Ú‡€ÿÿÿÿÿÿ½…®‡€ÿÿÿÿÿÿLjJˆ€ÿÿÿÿÿÿÑòŠøˆ€ÿÿÿÿÿÿÛÑÇ€ÿÿÿÿÿÿåÛ½€ ÿÿÿÿÿÿïå³€ ÿÿÿÿÿÿùï©€ ÿÿÿÿÿÿžÌ~e‰€ ÿÿÿÿÿÿ ž‚ Š€ ÿÿÿÿÿÿž«…O2€ÿÿÿÿÿÿ!ž˜ˆ+‹€ÿÿÿÿÿÿ+žy‹Æ‹€ÿÿÿÿÿÿ5ž+ž!ž€ÿÿÿÿÿÿ?ž5žž€ÿÿÿÿÿÿIž?ž ž€ÿÿÿÿÿÿSžIžž€ÿÿÿÿÿÿ]žSžù€ÿÿÿÿÿÿgž]žŸ€ÿÿÿÿÿÿqžgžE€ÿÿÿÿÿÿ{žqžëœ€ÿÿÿÿÿÿ…ž|ú{€ÿÿÿÿÿÿžèÇ|€ÿÿÿÿÿÿ™ž‘ƒ}€ÿÿÿÿÿÿ£že†`~€ÿÿÿÿÿÿ­žx‰^€ÿÿÿÿÿÿ·ž­ž£ž€ÿÿÿÿÿÿÁž·ž™ž€ÿÿÿÿÿÿËžÁžž€ ÿÿÿÿÿÿ՞˞…ž€!ÿÿÿÿÿÿßžÇ|Ë€"ÿÿÿÿÿÿéž-„d€#ÿÿÿÿÿÿóž‡1‚€$ÿÿÿÿÿÿýž Šƒ€%ÿÿÿÿÿÿŸýžóž€&ÿÿÿÿÿÿŸŸéž€'ÿÿÿÿÿÿŸŸ—€€(ÿÿÿÿÿÿ%ŸŸßž€)ÿÿÿÿÿÿ/Ÿv}~ƒ€*ÿÿÿÿÿÿ9ŸQ-„€+ÿÿÿÿÿÿCŸ"]v€,ÿÿÿÿÿÿMŸ›‡\…€-ÿÿÿÿÿÿWŸŠpu€.ÿÿÿÿÿÿaŸWŸMŸ€/ÿÿÿÿÿÿkŸaŸCŸ€0ÿÿÿÿÿÿuŸkŸ9Ÿ€1ÿÿÿÿÿÿŸuŸ/Ÿ€2ÿÿÿÿÿÿ‰Ÿ0~R†€3ÿÿÿÿÿÿ“Ÿ÷‡€4ÿÿÿÿÿÿŸ"…®‡€5ÿÿÿÿÿÿ§Ÿ#ˆJˆ€6ÿÿÿÿÿÿ±Ÿ‹øˆ€7ÿÿÿÿÿÿ»Ÿ±Ÿ§Ÿ€8ÿÿÿÿÿÿÅŸ»ŸŸ€9ÿÿÿÿÿÿÏŸÅŸ“Ÿ€:ÿÿÿÿÿÿÙŸÏŸ‰Ÿ€;ÿÿÿÿÿÿãŸé~e‰€<ÿÿÿÿÿÿퟺ‚ Š€=ÿÿÿÿÿÿ÷Ÿ¾…O2€>ÿÿÿÿÿÿ «ˆ+‹€?ÿÿÿÿÿÿ  Œ‹Æ‹€@ÿÿÿÿÿÿ    €Aÿÿÿÿÿÿ  ÷Ÿ€Bÿÿÿÿÿÿ)  íŸ€Cÿÿÿÿÿÿ3 ) ãŸ€Dÿÿÿÿÿÿ= 3 ÙŸ€EÿÿÿÿÿÿG = Ÿ€FÿÿÿÿÿÿQ G %Ÿ€Gÿÿÿÿÿÿ[ Q Õž€Hÿÿÿÿÿÿe g4ú{€Iÿÿÿÿÿÿo €Ç|€Jÿÿÿÿÿÿy ¤ƒ}€Kÿÿÿÿÿÿƒ x†`~€Lÿÿÿÿÿÿ ‹‰^€Mÿÿÿÿÿÿ—  ƒ €Nÿÿÿÿÿÿ¡ — y €Oÿÿÿÿÿÿ« ¡ o €Pÿÿÿÿÿÿµ « e €Qÿÿÿÿÿÿ¿ î|Ë€RÿÿÿÿÿÿÉ Ç-—€€SÿÿÿÿÿÿÓ @„d€TÿÿÿÿÿÿÝ ‡1‚€Uÿÿÿÿÿÿç Šƒ€Vÿÿÿÿÿÿñ ç Ý €Wÿÿÿÿÿÿû ñ Ó €Xÿÿÿÿÿÿ¡û É €Yÿÿÿÿÿÿ¡¡¿ €Zÿÿÿÿÿÿ¡}~ƒ€[ÿÿÿÿÿÿ#¡d-„€\ÿÿÿÿÿÿ-¡®‡\…€]ÿÿÿÿÿÿ7¡O2pu€^ÿÿÿÿÿÿA¡7¡-¡€_ÿÿÿÿÿÿK¡A¡v€`ÿÿÿÿÿÿU¡K¡#¡€aÿÿÿÿÿÿ_¡U¡¡€bÿÿÿÿÿÿi¡C~R†€cÿÿÿÿÿÿs¡‚‡€dÿÿÿÿÿÿ}¡?…®‡€eÿÿÿÿÿÿ‡¡-Jˆ€fÿÿÿÿÿÿ‘¡‹øˆ€gÿÿÿÿÿÿ›¡‘¡‡¡€hÿÿÿÿÿÿ¥¡›¡}¡€iÿÿÿÿÿÿ¯¡¥¡s¡€jÿÿÿÿÿÿ¹¡¯¡i¡€kÿÿÿÿÿÿáe‰€lÿÿÿÿÿÿׂ͡ Š€mÿÿÿÿÿÿס·$O2€nÿÿÿÿÿÿ᡾ˆ+‹€oÿÿÿÿÿÿë¡Š.Æ‹€pÿÿÿÿÿÿõ¡ë¡á¡€qÿÿÿÿÿÿÿ¡õ¡×¡€rÿÿÿÿÿÿ ¢ÿ¡Í¡€sÿÿÿÿÿÿ¢ ¢Ã¡€tÿÿÿÿÿÿ¢¢¹¡€uÿÿÿÿÿÿ'¢¢_¡€vÿÿÿÿÿÿ1¢'¢¡€wÿÿÿÿÿÿ;¢1¢µ €xÿÿÿÿÿÿE¢H|ú{€yÿÿÿÿÿÿO¢"€Ç|€zÿÿÿÿÿÿY¢Áƒ}€{ÿÿÿÿÿÿc¢•†`~€|ÿÿÿÿÿÿm¢ž‰^€}ÿÿÿÿÿÿw¢m¢c¢€~ÿÿÿÿÿÿ¢w¢Y¢€ÿÿÿÿÿÿ‹¢¢O¢€€ÿÿÿÿÿÿ•¢‹¢E¢€ÿÿÿÿÿÿŸ¢}Ë€‚ÿÿÿÿÿÿ©¢È€—€€ƒÿÿÿÿÿÿ³¢]„d€„ÿÿÿÿÿÿ½¢0‡1‚€…ÿÿÿÿÿÿÇ¢/Šƒ€†ÿÿÿÿÿÿѢǢ½¢€‡ÿÿÿÿÿÿۢѢ³¢€ˆÿÿÿÿÿÿå¢Û¢©¢€‰ÿÿÿÿÿÿï¢å¢Ÿ¢€Šÿÿÿÿÿÿù¢º}~ƒ€‹ÿÿÿÿÿÿ£-„€Œÿÿÿÿÿÿ £Ë\v€ÿÿÿÿÿÿ£Á‡\…€Žÿÿÿÿÿÿ!£­Špu€ÿÿÿÿÿÿ+£!££€ÿÿÿÿÿÿ5£+£ £€‘ÿÿÿÿÿÿ?£5££€’ÿÿÿÿÿÿI£?£ù¢€“ÿÿÿÿÿÿS£`~R†€”ÿÿÿÿÿÿ]£1‚‡€•ÿÿÿÿÿÿg£\…®‡€–ÿÿÿÿÿÿq£+‹øˆ€—ÿÿÿÿÿÿ{£q£Jˆ€˜ÿÿÿÿÿÿ…£{£g£€™ÿÿÿÿÿÿ£…£]£€šÿÿÿÿÿÿ™££S£€›ÿÿÿÿÿÿ££7e‰€œÿÿÿÿÿÿ­£þ‚ Š€ÿÿÿÿÿÿ·£Û…O2€žÿÿÿÿÿÿÁ£Ûˆ+‹€ŸÿÿÿÿÿÿË£©‹Æ‹€ ÿÿÿÿÿÿգˣÁ£€¡ÿÿÿÿÿÿߣգ·£€¢ÿÿÿÿÿÿé£ß£­£€£ÿÿÿÿÿÿó£é£££€¤ÿÿÿÿÿÿý£ó£™£€¥ÿÿÿÿÿÿ¤ý£I£€¦ÿÿÿÿÿÿ¤¤ï¢€§ÿÿÿÿÿÿ¤¤•¢€¨ÿÿÿÿÿÿ%¤[|ú{€©ÿÿÿÿÿÿ/¤I€Ç|€ªÿÿÿÿÿÿ9¤ët}€«ÿÿÿÿÿÿC¤¨†`~€¬ÿÿÿÿÿÿM¤»‰^€­ÿÿÿÿÿÿW¤M¤C¤€®ÿÿÿÿÿÿa¤W¤9¤€¯ÿÿÿÿÿÿk¤a¤/¤€°ÿÿÿÿÿÿu¤k¤%¤€±ÿÿÿÿÿÿ¤}Ë€²ÿÿÿÿÿÿ‰¤ï€—€€³ÿÿÿÿÿÿ“¤þtd€´ÿÿÿÿÿÿ¤M‡1‚€µÿÿÿÿÿÿ§¤BŠƒ€¶ÿÿÿÿÿÿ±¤§¤¤€·ÿÿÿÿÿÿ»¤±¤“¤€¸ÿÿÿÿÿÿŤ»¤‰¤€¹ÿÿÿÿÿÿϤŤ¤€ºÿÿÿÿÿÿÙ¤Ko~ƒ€»ÿÿÿÿÿÿã¤^o-„€¼ÿÿÿÿÿÿí¤v€½ÿÿÿÿÿÿ÷¤—o\…€¾ÿÿÿÿÿÿ¥Ðopu€¿ÿÿÿÿÿÿ ¥¥÷¤€Àÿÿÿÿÿÿ¥ ¥í¤€Áÿÿÿÿÿÿ¥¥ã¤€Âÿÿÿÿÿÿ)¥¥Ù¤€Ãÿÿÿÿÿÿ3¥‡~R†€Äÿÿÿÿÿÿ=¥X‚‡€ÅÿÿÿÿÿÿG¥7u®‡€ÆÿÿÿÿÿÿQ¥]ˆJˆ€Çÿÿÿÿÿÿ[¥>‹øˆ€Èÿÿÿÿÿÿe¥[¥Q¥€Éÿÿÿÿÿÿo¥e¥G¥€Êÿÿÿÿÿÿy¥o¥=¥€Ëÿÿÿÿÿÿƒ¥y¥3¥€Ìÿÿÿÿÿÿ¥^e‰€Íÿÿÿÿÿÿ—¥ƒ Š€Îÿÿÿÿÿÿ¡¥puO2€Ïÿÿÿÿÿÿ«¥øˆ+‹€Ðÿÿÿÿÿÿµ¥Æ‹«¥€Ñÿÿÿÿÿÿ¿¥µ¥¡¥€ÒÿÿÿÿÿÿÉ¥¿¥—¥€Óÿÿÿÿÿÿӥɥ¥€ÔÿÿÿÿÿÿÝ¥Ó¥ƒ¥€Õÿÿÿÿÿÿç¥Ý¥)¥€Öÿÿÿÿÿÿñ¥ç¥Ï¤€×ÿÿÿÿÿÿû¥ñ¥u¤€Øÿÿÿÿÿÿ¦û¥¤€Ùÿÿÿÿÿÿ¦¦;¢€Úÿÿÿÿÿÿ¦¦[ €Ûÿÿÿÿÿÿ#¦¦{ž€ÜSÿÿÿÿÿÿ-¦2.2.€Ý>ÿÿÿÿÿÿ7¦œ-¦@ÞÿÿÿÿÿÿA¦7¦€ßSÿÿÿÿÿÿJ¦$i$i€à>ÿÿÿÿÿÿT¦~J¦@áÿÿÿÿÿÿ^¦T¦€âSÿÿÿÿÿÿg¦f@f@€ã>ÿÿÿÿÿÿq¦4g¦@äÿÿÿÿÿÿ{¦q¦€åSÿÿÿÿÿÿ„¦¦i¦i€æ>ÿÿÿÿÿÿŽ¦<„¦@çÿÿÿÿÿÿ˜¦Ž¦€èSÿÿÿÿÿÿ¡¦ìiìi€é>ÿÿÿÿÿÿ«¦°¡¦@êÿÿÿÿÿÿµ¦«¦€ëÿÿÿÿÿÿ¾¦µ¦˜¦€ìÿÿÿÿÿÿȦ¾¦{¦€íÿÿÿÿÿÿҦȦ^¦€îÿÿÿÿÿÿܦҦA¦€ïSÿÿÿÿÿÿæ¦ÞhÞh€ð>ÿÿÿÿÿÿð¦œæ¦@ñÿÿÿÿÿÿú¦ð¦€òSÿÿÿÿÿÿ§³-³-€ó>ÿÿÿÿÿÿ §~§@ôÿÿÿÿÿÿ§ §€õSÿÿÿÿÿÿ §x1x1€ö>ÿÿÿÿÿÿ*§4 §@÷ÿÿÿÿÿÿ4§*§€øSÿÿÿÿÿÿ=§ºiºi€ù>ÿÿÿÿÿÿG§<=§@úÿÿÿÿÿÿQ§G§€ûSÿÿÿÿÿÿZ§jj€ü>ÿÿÿÿÿÿd§°Z§@ýÿÿÿÿÿÿn§d§€þÿÿÿÿÿÿw§n§Q§€ÿÿÿÿÿÿÿ§w§4§€ÿÿÿÿÿÿ‹§§§€ÿÿÿÿÿÿ•§‹§ú¦€SÿÿÿÿÿÿŸ§ê'ê'€>ÿÿÿÿÿÿ©§œŸ§@ÿÿÿÿÿÿ³§©§€Sÿÿÿÿÿÿ¼§|$|$€>ÿÿÿÿÿÿƧ~¼§@ÿÿÿÿÿÿЧƧ€SÿÿÿÿÿÿÙ§_$_$€ >ÿÿÿÿÿÿã§<Ù§@ ÿÿÿÿÿÿí§ã§€ Sÿÿÿÿÿÿö§£$£$€ >ÿÿÿÿÿÿ¨°ö§@ ÿÿÿÿÿÿ ¨¨€ÿÿÿÿÿÿ¨ ¨í§€ÿÿÿÿÿÿ¨¨Š.€ÿÿÿÿÿÿ'¨¨Ð§€ÿÿÿÿÿÿ1¨'¨³§€Sÿÿÿÿÿÿ;¨ühüh€>ÿÿÿÿÿÿE¨œ;¨@ÿÿÿÿÿÿO¨E¨€SÿÿÿÿÿÿX¨LiLi€>ÿÿÿÿÿÿb¨~X¨@ÿÿÿÿÿÿl¨b¨€Sÿÿÿÿÿÿu¨¿0¿0€>ÿÿÿÿÿÿ¨4u¨@ÿÿÿÿÿÿ‰¨¨€Sÿÿÿÿÿÿ’¨ú,ú,€>ÿÿÿÿÿÿœ¨<’¨@ÿÿÿÿÿÿ¦¨œ¨€Sÿÿÿÿÿÿ¯¨jj€>ÿÿÿÿÿÿ¹¨°¯¨@ ÿÿÿÿÿÿ蹨€!ÿÿÿÿÿÿ̨覨€"ÿÿÿÿÿÿ̨֨‰¨€#ÿÿÿÿÿÿà¨Ö¨l¨€$ÿÿÿÿÿÿê¨à¨O¨€%Sÿÿÿÿÿÿô¨ii€&>ÿÿÿÿÿÿþ¨œô¨@'ÿÿÿÿÿÿ©þ¨€(Sÿÿÿÿÿÿ©`i`i€)>ÿÿÿÿÿÿ©~©@*ÿÿÿÿÿÿ%©©€+Sÿÿÿÿÿÿ.©;2;2€,>ÿÿÿÿÿÿ8©4.©@-ÿÿÿÿÿÿB©8©€.SÿÿÿÿÿÿK©ØiØi€/>ÿÿÿÿÿÿU©<K©@0ÿÿÿÿÿÿ_©U©€1Sÿÿÿÿÿÿh©v.v.€2>ÿÿÿÿÿÿr©°h©@3ÿÿÿÿÿÿ|©r©€4ÿÿÿÿÿÿ…©|©_©€5ÿÿÿÿÿÿ©…©B©€6ÿÿÿÿÿÿ™©©%©€7ÿÿÿÿÿÿ£©™©©€8ÿÿÿÿÿÿ­©£©ê¨€9ÿÿÿÿÿÿ·©­©1¨€:ÿÿÿÿÿÿÁ©·©•§€;ÿÿÿÿÿÿË©Á©Ü¦€<SÿÿÿÿÿÿÕ©~Þh€=>ÿÿÿÿÿÿß©œÕ©@>ÿÿÿÿÿÿé©ß©€?Sÿÿÿÿÿÿò©4ê'€@>ÿÿÿÿÿÿü©œò©@Aÿÿÿÿÿÿªü©€BSÿÿÿÿÿÿª<üh€C>ÿÿÿÿÿÿªœª@Dÿÿÿÿÿÿ#ªª€ESÿÿÿÿÿÿ,ª°i€F>ÿÿÿÿÿÿ6ªœ,ª@Gÿÿÿÿÿÿ@ª6ª€HÿÿÿÿÿÿIª@ª#ª€IÿÿÿÿÿÿSªIªª€Jÿÿÿÿÿÿ]ªSªé©€Kÿÿÿÿÿÿgª]ª—€LSÿÿÿÿÿÿqªœ$i€M>ÿÿÿÿÿÿ{ª~qª@Nÿÿÿÿÿÿ…ª{ª€OSÿÿÿÿÿÿŽª4|$€P>ÿÿÿÿÿÿ˜ª~Žª@Qÿÿÿÿÿÿ¢ª˜ª€RSÿÿÿÿÿÿ«ª<Li€S>ÿÿÿÿÿÿµª~«ª@Tÿÿÿÿÿÿ¿ªµª€USÿÿÿÿÿÿȪ°`i€V>ÿÿÿÿÿÿÒª~Ȫ@WÿÿÿÿÿÿܪҪ€XÿÿÿÿÿÿåªÜª¿ª€Yÿÿÿÿÿÿïªåª¢ª€ZÿÿÿÿÿÿùªïªÛ—€[ÿÿÿÿÿÿ«ùª…ª€\Sÿÿÿÿÿÿ «œf@€]>ÿÿÿÿÿÿ«4 «@^ÿÿÿÿÿÿ!««€_Sÿÿÿÿÿÿ*«~x1€`>ÿÿÿÿÿÿ4«4*«@aÿÿÿÿÿÿ>«4«€bSÿÿÿÿÿÿG«<¿0€c>ÿÿÿÿÿÿQ«4G«@dÿÿÿÿÿÿ[«Q«€eSÿÿÿÿÿÿd«°;2€f>ÿÿÿÿÿÿn«4d«@gÿÿÿÿÿÿx«n«€hÿÿÿÿÿÿ«x«[«€iÿÿÿÿÿÿ‹««O2€jÿÿÿÿÿÿ•«‹«>«€kÿÿÿÿÿÿŸ«•«!«€lSÿÿÿÿÿÿ©«œ¦i€m>ÿÿÿÿÿÿ³«<©«@nÿÿÿÿÿÿ½«³«€oSÿÿÿÿÿÿÆ«~ºi€p>ÿÿÿÿÿÿЫ<Æ«@qÿÿÿÿÿÿګЫ€rSÿÿÿÿÿÿã«4_$€s>ÿÿÿÿÿÿí«<ã«@tÿÿÿÿÿÿ÷«í«€uSÿÿÿÿÿÿ¬°Øi€v>ÿÿÿÿÿÿ ¬<¬@wÿÿÿÿÿÿ¬ ¬€xÿÿÿÿÿÿ¬¬ö˜€yÿÿÿÿÿÿ'¬¬÷«€zÿÿÿÿÿÿ1¬'¬Ú«€{ÿÿÿÿÿÿ;¬1¬½«€|SÿÿÿÿÿÿE¬œìi€}>ÿÿÿÿÿÿO¬°E¬@~ÿÿÿÿÿÿY¬O¬€Sÿÿÿÿÿÿb¬~j€€>ÿÿÿÿÿÿl¬°b¬@ÿÿÿÿÿÿv¬l¬€‚Sÿÿÿÿÿÿ¬4£$€ƒ>ÿÿÿÿÿÿ‰¬°¬@„ÿÿÿÿÿÿ“¬‰¬€…Sÿÿÿÿÿÿœ¬<j€†>ÿÿÿÿÿÿ¦¬°œ¬@‡ÿÿÿÿÿÿ°¬¦¬€ˆÿÿÿÿÿÿ¹¬Ì™°¬€‰ÿÿÿÿÿÿ칬“¬€Šÿÿÿÿÿÿͬìv¬€‹ÿÿÿÿÿÿ׬ͬY¬€Œÿÿÿÿÿÿá¬×¬;¬€ÿÿÿÿÿÿë¬á¬Ÿ«€Žÿÿÿÿÿÿõ¬ë¬«€ÿÿÿÿÿÿÿ¬õ¬gª€>ÿÿÿÿÿÿ ­~æ¦@‘ÿÿÿÿÿÿ­ ­€’>ÿÿÿÿÿÿ­4Ÿ§@“ÿÿÿÿÿÿ&­­€”>ÿÿÿÿÿÿ/­<;¨@•ÿÿÿÿÿÿ9­/­€–>ÿÿÿÿÿÿB­°ô¨@—ÿÿÿÿÿÿL­B­€˜ÿÿÿÿÿÿU­L­9­€™ÿÿÿÿÿÿ_­U­&­€šÿÿÿÿÿÿi­_­­€›ÿÿÿÿÿÿs­i­A¦€œ>ÿÿÿÿÿÿ}­œJ¦@ÿÿÿÿÿÿ‡­}­€ž>ÿÿÿÿÿÿ­4¼§@Ÿÿÿÿÿÿÿš­­€ >ÿÿÿÿÿÿ£­<X¨@¡ÿÿÿÿÿÿ­­£­€¢>ÿÿÿÿÿÿ¶­°©@£ÿÿÿÿÿÿÀ­¶­€¤ÿÿÿÿÿÿÉ­À­­­€¥ÿÿÿÿÿÿÓ­É­š­€¦ÿÿÿÿÿÿÝ­Ó­§€§ÿÿÿÿÿÿç­Ý­‡­€¨>ÿÿÿÿÿÿñ­œg¦@©ÿÿÿÿÿÿû­ñ­€ª>ÿÿÿÿÿÿ®~ §@«ÿÿÿÿÿÿ®®€¬>ÿÿÿÿÿÿ®<u¨@­ÿÿÿÿÿÿ!®®€®>ÿÿÿÿÿÿ*®°.©@¯ÿÿÿÿÿÿ4®*®€°ÿÿÿÿÿÿ=®4®!®€±ÿÿÿÿÿÿG®=®Š.€²ÿÿÿÿÿÿQ®G®®€³ÿÿÿÿÿÿ[®Q®û­€´>ÿÿÿÿÿÿe®œ„¦@µÿÿÿÿÿÿo®e®€¶>ÿÿÿÿÿÿx®~=§@·ÿÿÿÿÿÿ‚®x®€¸>ÿÿÿÿÿÿ‹®4Ù§@¹ÿÿÿÿÿÿ•®‹®€º>ÿÿÿÿÿÿž®°K©@»ÿÿÿÿÿÿ¨®ž®€¼ÿÿÿÿÿÿ±®¨®¦¨€½ÿÿÿÿÿÿ»®±®•®€¾ÿÿÿÿÿÿÅ®»®‚®€¿ÿÿÿÿÿÿϮŮo®€À>ÿÿÿÿÿÿÙ®œ¡¦@Áÿÿÿÿÿÿã®Ù®€Â>ÿÿÿÿÿÿì®~Z§@Ãÿÿÿÿÿÿö®ì®€Ä>ÿÿÿÿÿÿÿ®4ö§@Åÿÿÿÿÿÿ ¯ÿ®€Æ>ÿÿÿÿÿÿ¯<¯¨@Çÿÿÿÿÿÿ¯¯€Èÿÿÿÿÿÿ%¯|©¯€Éÿÿÿÿÿÿ/¯%¯ ¯€Êÿÿÿÿÿÿ9¯/¯ö®€ËÿÿÿÿÿÿC¯9¯ã®€ÌÿÿÿÿÿÿM¯C¯Ï®€ÍÿÿÿÿÿÿW¯M¯[®€Îÿÿÿÿÿÿa¯W¯ç­€Ïÿÿÿÿÿÿk¯a¯s­€Ðÿÿÿÿÿÿu¯y‹ˆ€Ñÿÿÿÿÿÿ¯u¯kb€Òÿÿÿÿÿÿ‰¯¯„€€Óÿÿÿÿÿÿ“¯‰¯ú{€Ôÿÿÿÿÿÿ¯ð{“¯€Õÿÿÿÿÿÿ§¯Œ‹#ˆ€Öÿÿÿÿÿÿ±¯§¯"]€×ÿÿÿÿÿÿ»¯±¯—€€Øÿÿÿÿÿÿů»¯|€Ùÿÿÿÿÿÿϯ |ů€ÚÿÿÿÿÿÿÙ¯Š.-€Ûÿÿÿÿÿÿã¯Ù¯v€Üÿÿÿÿÿÿí¯ã¯Ç-€Ýÿÿÿÿÿÿ÷¯í¯g4€Þÿÿÿÿÿÿ°òh÷¯€ßÿÿÿÿÿÿ °©‹Jˆ€àÿÿÿÿÿÿ° °Ë\€áÿÿÿÿÿÿ°°È€€âÿÿÿÿÿÿ)°°H|€ãÿÿÿÿÿÿ3°?k)°€äÿÿÿÿÿÿ=°Æ‹]ˆ€åÿÿÿÿÿÿG°=°€æÿÿÿÿÿÿQ°çÿÿÿÿÿÿ[°[|€èÿÿÿÿÿÿe°d|€éÿÿÿÿÿÿo°e°3°€êÿÿÿÿÿÿy°o°°€ëÿÿÿÿÿÿƒ°y°Ï¯€ìÿÿÿÿÿÿ°ƒ°¯€íÿÿÿÿÿÿ—°½|“¯€îÿÿÿÿÿÿ¡°8iů€ïÿÿÿÿÿÿ«°ª€÷¯€ðÿÿÿÿÿÿµ°Ñ€)°€ñÿÿÿÿÿÿ¿°ø€€òÿÿÿÿÿÿÉ°¿°µ°€óÿÿÿÿÿÿÓ°É°«°€ôÿÿÿÿÿÿÝ°Ó°¡°€õÿÿÿÿÿÿç°Ý°—°€öÿÿÿÿÿÿñ°“}“¯€÷ÿÿÿÿÿÿû°~iů€øÿÿÿÿÿÿ±ì÷¯€ùÿÿÿÿÿÿ±À„)°€úÿÿÿÿÿÿ±E2€ûÿÿÿÿÿÿ#±±±€üÿÿÿÿÿÿ-±#±±€ýÿÿÿÿÿÿ7±-±û°€þÿÿÿÿÿÿA±7±ñ°€ÿÿÿÿÿÿÿK±°i“¯€ÿÿÿÿÿÿU±'‚ů€ÿÿÿÿÿÿ_±R…÷¯€ÿÿÿÿÿÿi±@ˆ)°€ÿÿÿÿÿÿs±…k€ÿÿÿÿÿÿ}±s±i±€ÿÿÿÿÿÿ‡±}±_±€ÿÿÿÿÿÿ‘±‡±U±€ÿÿÿÿÿÿ›±‘±K±€ÿÿÿÿÿÿ¥±T“¯€ ÿÿÿÿÿÿ¯± jů€ ÿÿÿÿÿÿ¹±fu÷¯€ ÿÿÿÿÿÿñîˆ)°€ ÿÿÿÿÿÿͱ¼‹€ ÿÿÿÿÿÿױͱñ€ÿÿÿÿÿÿá±×±¹±€ÿÿÿÿÿÿë±á±¯±€ÿÿÿÿÿÿõ±ë±¥±€ÿÿÿÿÿÿÿ±õ±›±€ÿÿÿÿÿÿ ²ÿ±A±€ÿÿÿÿÿÿ² ²ç°€ÿÿÿÿÿÿ²²°€Sÿÿÿÿÿÿ'²$iœ€>ÿÿÿÿÿÿ1²~'²€Sÿÿÿÿÿÿ;²f@œ€>ÿÿÿÿÿÿE²4;²€SÿÿÿÿÿÿO²¦iœ€>ÿÿÿÿÿÿY²<O²€Sÿÿÿÿÿÿc²ìiœ€>ÿÿÿÿÿÿm²°c²€ÿÿÿÿÿÿw²m²Y²€ÿÿÿÿÿÿ²w²E²€ÿÿÿÿÿÿ‹²²1²€ ÿÿÿÿÿÿ•²‹²Rx€!SÿÿÿÿÿÿŸ²Þh~€">ÿÿÿÿÿÿ©²œŸ²€#Sÿÿÿÿÿÿ³²x1~€$>ÿÿÿÿÿÿ½²4³²€%SÿÿÿÿÿÿDzºi~€&>ÿÿÿÿÿÿѲ<Dz€'SÿÿÿÿÿÿÛ²j~€(>ÿÿÿÿÿÿå²°Û²€)ÿÿÿÿÿÿï²å²Ñ²€*ÿÿÿÿÿÿù²ï²½²€+ÿÿÿÿÿÿ³ù²(y€,ÿÿÿÿÿÿ ³³©²€-Sÿÿÿÿÿÿ³ê'4€.>ÿÿÿÿÿÿ!³œ³€/Sÿÿÿÿÿÿ+³|$4€0>ÿÿÿÿÿÿ5³~+³€1Sÿÿÿÿÿÿ?³_$4€2>ÿÿÿÿÿÿI³<?³€3SÿÿÿÿÿÿS³£$4€4>ÿÿÿÿÿÿ]³°S³€5ÿÿÿÿÿÿg³]³I³€6ÿÿÿÿÿÿq³g³­$€7ÿÿÿÿÿÿ{³q³5³€8ÿÿÿÿÿÿ…³{³!³€9Sÿÿÿÿÿÿ³üh<€:>ÿÿÿÿÿÿ™³œ³€;Sÿÿÿÿÿÿ£³Li<€<>ÿÿÿÿÿÿ­³~£³€=Sÿÿÿÿÿÿ·³¿0<€>>ÿÿÿÿÿÿÁ³4·³€?Sÿÿÿÿÿÿ˳j<€@>ÿÿÿÿÿÿÕ³°Ë³€Aÿÿÿÿÿÿß³Õ³·z€Bÿÿÿÿÿÿé³ß³Á³€Cÿÿÿÿÿÿó³é³­³€Dÿÿÿÿÿÿý³ó³™³€ESÿÿÿÿÿÿ´i°€F>ÿÿÿÿÿÿ´œ´€GSÿÿÿÿÿÿ´`i°€H>ÿÿÿÿÿÿ%´~´€ISÿÿÿÿÿÿ/´;2°€J>ÿÿÿÿÿÿ9´4/´€KSÿÿÿÿÿÿC´Øi°€L>ÿÿÿÿÿÿM´<C´€MÿÿÿÿÿÿW´{M´€Nÿÿÿÿÿÿa´W´9´€Oÿÿÿÿÿÿk´a´%´€Pÿÿÿÿÿÿu´k´´€Qÿÿÿÿÿÿ´u´ý³€Rÿÿÿÿÿÿ‰´´…³€Sÿÿÿÿÿÿ“´‰´ ³€Tÿÿÿÿÿÿ´“´•²€Uÿÿÿÿÿÿ§´#{jz€Vÿÿÿÿÿÿ±´§´Îy€Wÿÿÿÿÿÿ»´±´y€XÿÿÿÿÿÿÅ´»´\x€YÿÿÿÿÿÿÏ´@{‡z€ZÿÿÿÿÿÿÙ´Ï´ëy€[ÿÿÿÿÿÿã´Ù´2y€\ÿÿÿÿÿÿí´ã´yx€]ÿÿÿÿÿÿ÷´]{¤z€^ÿÿÿÿÿÿµ÷´·$€_ÿÿÿÿÿÿ µµOy€`ÿÿÿÿÿÿµ µ–x€aÿÿÿÿÿÿµz{Áz€bÿÿÿÿÿÿ)µµz€cÿÿÿÿÿÿ3µ)µly€dÿÿÿÿÿÿ=µ3µ³x€eÿÿÿÿÿÿGµ—{Þz€fÿÿÿÿÿÿQµGµ%z€gÿÿÿÿÿÿ[µQµ‰y€hÿÿÿÿÿÿeµ[µÐx€iÿÿÿÿÿÿoµeµ=µ€jÿÿÿÿÿÿyµoµµ€kÿÿÿÿÿÿƒµyµí´€lÿÿÿÿÿÿµƒµÅ´@mÿÿÿÿÿÿ—µ1²@nÿÿÿÿÿÿ µE²@oÿÿÿÿÿÿ©µY²@pÿÿÿÿÿÿ²µm²€qÿÿÿÿÿÿ»µ²µ©µ€rÿÿÿÿÿÿŵ»µ µ€sÿÿÿÿÿÿϵŵ—µ€tÿÿÿÿÿÿٵϵ\x@uÿÿÿÿÿÿ㵩²@vÿÿÿÿÿÿìµ½²@wÿÿÿÿÿÿõµÑ²@xÿÿÿÿÿÿþµå²€yÿÿÿÿÿÿ¶þµõµ€zÿÿÿÿÿÿ¶¶ìµ€{ÿÿÿÿÿÿ¶¶2y€|ÿÿÿÿÿÿ%¶¶ãµ@}ÿÿÿÿÿÿ/¶!³@~ÿÿÿÿÿÿ8¶5³@ÿÿÿÿÿÿA¶I³@€ÿÿÿÿÿÿJ¶]³€ÿÿÿÿÿÿS¶J¶A¶€‚ÿÿÿÿÿÿ]¶S¶·$€ƒÿÿÿÿÿÿg¶]¶8¶€„ÿÿÿÿÿÿq¶g¶/¶@…ÿÿÿÿÿÿ{¶™³@†ÿÿÿÿÿÿ„¶­³@‡ÿÿÿÿÿÿ¶Á³@ˆÿÿÿÿÿÿ–¶Õ³€‰ÿÿÿÿÿÿŸ¶–¶Áz€Šÿÿÿÿÿÿ©¶Ÿ¶¶€‹ÿÿÿÿÿÿ³¶©¶„¶€Œÿÿÿÿÿÿ½¶³¶{¶@ÿÿÿÿÿÿǶ´@Žÿÿÿÿÿÿж%´@ÿÿÿÿÿÿÙ¶9´@ÿÿÿÿÿÿâ¶M´€‘ÿÿÿÿÿÿ붗{ⶀ’ÿÿÿÿÿÿõ¶ë¶Ù¶€“ÿÿÿÿÿÿÿ¶õ¶Ð¶€”ÿÿÿÿÿÿ ·ÿ¶Ç¶€•ÿÿÿÿÿÿ· ·½¶€–ÿÿÿÿÿÿ··q¶€—ÿÿÿÿÿÿ'··%¶€˜ÿÿÿÿÿÿ1·'·Ùµ€™ÿÿÿÿÿÿ;·¼‹@ˆ€šÿÿÿÿÿÿE·;·ì€›ÿÿÿÿÿÿO·E·8i€œÿÿÿÿÿÿY·O·ð{€ÿÿÿÿÿÿc·Ëª|€žÿÿÿÿÿÿm·~ƒc}€Ÿÿÿÿÿÿÿw·R†~€ ÿÿÿÿÿÿ·e‰Ì~€¡ÿÿÿÿÿÿ‹··w·€¢ÿÿÿÿÿÿ•·‹·m·€£ÿÿÿÿÿÿŸ·•·c·€¤ÿÿÿÿÿÿ©·Ÿ·ú{€¥ÿÿÿÿÿÿ³·„4€¦ÿÿÿÿÿÿ½·í†Ú€§ÿÿÿÿÿÿÇ·ö‰‚€¨ÿÿÿÿÿÿÑ·Ç·½·€©ÿÿÿÿÿÿÛ·Ñ·³·€ªÿÿÿÿÿÿå·Û·„€€«ÿÿÿÿÿÿï·å·õœ€¬ÿÿÿÿÿÿù·4„€­ÿÿÿÿÿÿ¸ˆ‡…€®ÿÿÿÿÿÿ ¸}Š«…€¯ÿÿÿÿÿÿ¸ ¸¸€°ÿÿÿÿÿÿ!¸¸kb€±ÿÿÿÿÿÿ+¸!¸ù·€²ÿÿÿÿÿÿ5¸+¸O€³ÿÿÿÿÿÿ?¸Ú톀´ÿÿÿÿÿÿI¸…ˆ‡€µÿÿÿÿÿÿS¸òŠ˜ˆ€¶ÿÿÿÿÿÿ]¸S¸ˆ€·ÿÿÿÿÿÿg¸]¸I¸€¸ÿÿÿÿÿÿq¸g¸?¸€¹ÿÿÿÿÿÿ{¸q¸©€ºÿÿÿÿÿÿ…¸‚ö‰€»ÿÿÿÿÿÿ¸«…}Š€¼ÿÿÿÿÿÿ™¸˜ˆòŠ€½ÿÿÿÿÿÿ£¸y‹™¸€¾ÿÿÿÿÿÿ­¸£¸¸€¿ÿÿÿÿÿÿ·¸­¸…¸€ÀÿÿÿÿÿÿÁ¸·¸ž€Áÿÿÿÿÿÿ˸Á¸{¸€Âÿÿÿÿÿÿո˸5¸€Ãÿÿÿÿÿÿ߸ոﷀÄÿÿÿÿÿÿé¸ß¸©·€Åÿÿÿÿÿÿ󸑃v}€Æÿÿÿÿÿÿý¸e†0~€Çÿÿÿÿÿÿ¹x‰é~€Èÿÿÿÿÿÿ¹¹ý¸€Éÿÿÿÿÿÿ¹¹ó¸€Êÿÿÿÿÿÿ%¹¹ž€Ëÿÿÿÿÿÿ/¹%¹|€Ìÿÿÿÿÿÿ9¹Ç|è€ÍÿÿÿÿÿÿC¹-„Q€ÎÿÿÿÿÿÿM¹‡÷€ÏÿÿÿÿÿÿW¹ Šº‚€Ðÿÿÿÿÿÿa¹W¹M¹€Ñÿÿÿÿÿÿk¹a¹C¹€Òÿÿÿÿÿÿu¹k¹—€€Óÿÿÿÿÿÿ¹u¹9¹€Ôÿÿÿÿÿÿ‰¹v}‘ƒ€Õÿÿÿÿÿÿ“¹›‡"…€Öÿÿÿÿÿÿ¹Š¾…€×ÿÿÿÿÿÿ§¹¹“¹€Øÿÿÿÿÿÿ±¹§¹"]€Ùÿÿÿÿÿÿ»¹±¹9Ÿ€ÚÿÿÿÿÿÿŹ»¹‰¹€ÛÿÿÿÿÿÿϹ0~e†€ÜÿÿÿÿÿÿÙ¹"…›‡€Ýÿÿÿÿÿÿ㹋«ˆ€Þÿÿÿÿÿÿí¹ã¹#ˆ€ßÿÿÿÿÿÿ÷¹í¹Ù¹€àÿÿÿÿÿÿº÷¹“Ÿ€áÿÿÿÿÿÿ ººÏ¹€âÿÿÿÿÿÿºé~x‰€ãÿÿÿÿÿÿº¾…Š€äÿÿÿÿÿÿ)º«ˆ‹€åÿÿÿÿÿÿ3ºŒ‹)º€æÿÿÿÿÿÿ=º3ºº€çÿÿÿÿÿÿGº=ºíŸ€èÿÿÿÿÿÿQºGºº€éÿÿÿÿÿÿ[ºQº º€êÿÿÿÿÿÿeº[ºÅ¹€ëÿÿÿÿÿÿoºeº¹€ìÿÿÿÿÿÿyºoº/¹€íÿÿÿÿÿÿƒº€î|€îÿÿÿÿÿÿºx†C~€ïÿÿÿÿÿÿ—º‹‰€ðÿÿÿÿÿÿ¡º—ºº€ñÿÿÿÿÿÿ«º¡ºy €òÿÿÿÿÿÿµº«ºƒº€óÿÿÿÿÿÿ¿ºµºg4€ôÿÿÿÿÿÿɺî|€€õÿÿÿÿÿÿÓº‡‚€öÿÿÿÿÿÿݺŠ×‚€÷ÿÿÿÿÿÿçºÝºÓº€øÿÿÿÿÿÿñºçºÓ €ùÿÿÿÿÿÿûºñºÇ-€úÿÿÿÿÿÿ»ûºÉº€ûÿÿÿÿÿÿ»}¤ƒ€üÿÿÿÿÿÿ»d@„€ýÿÿÿÿÿÿ#»®‡?…€þÿÿÿÿÿÿ-»O2·$€ÿÿÿÿÿÿÿ7»-»#»€ÿÿÿÿÿÿA»7»v€ÿÿÿÿÿÿK»A»»€ÿÿÿÿÿÿU»K»»€ÿÿÿÿÿÿ_»C~x†€ÿÿÿÿÿÿi»‚‡€ÿÿÿÿÿÿs»‹¾ˆ€ÿÿÿÿÿÿ}»s»-€ÿÿÿÿÿÿ‡»}»}¡€ÿÿÿÿÿÿ‘»‡»i»€ ÿÿÿÿÿÿ›»‘»_»€ ÿÿÿÿÿÿ¥»‹‰€ ÿÿÿÿÿÿ¯»×‚Š€ ÿÿÿÿÿÿ¹»¾ˆ‹€ ÿÿÿÿÿÿûŠ.¹»€ÿÿÿÿÿÿͻûס€ÿÿÿÿÿÿ׻ͻ¯»€ÿÿÿÿÿÿá»×»¥»€ÿÿÿÿÿÿë»á»›»€ÿÿÿÿÿÿõ»ë»U»€ÿÿÿÿÿÿÿ»õ»»€ÿÿÿÿÿÿ ¼ÿ»¿º€ÿÿÿÿÿÿ¼"€}€ÿÿÿÿÿÿ¼Áƒº}€ÿÿÿÿÿÿ'¼ž‰7€ÿÿÿÿÿÿ1¼'¼c¢€ÿÿÿÿÿÿ;¼1¼¼€ÿÿÿÿÿÿE¼;¼¼€ÿÿÿÿÿÿO¼E¼H|€ÿÿÿÿÿÿY¼}"€€ÿÿÿÿÿÿc¼]„€ÿÿÿÿÿÿm¼/Šþ‚€ÿÿÿÿÿÿw¼m¼½¢€ ÿÿÿÿÿÿ¼w¼c¼€!ÿÿÿÿÿÿ‹¼¼È€€"ÿÿÿÿÿÿ•¼‹¼Y¼€#ÿÿÿÿÿÿŸ¼º}Áƒ€$ÿÿÿÿÿÿ©¼]„€%ÿÿÿÿÿÿ³¼­ŠÛ…€&ÿÿÿÿÿÿ½¼³¼£€'ÿÿÿÿÿÿǼ½¼Ë\€(ÿÿÿÿÿÿѼǼ©¼€)ÿÿÿÿÿÿۼѼŸ¼€*ÿÿÿÿÿÿå¼`~•†€+ÿÿÿÿÿÿï¼1‚0‡€,ÿÿÿÿÿÿù¼\…Á‡€-ÿÿÿÿÿÿ½+‹Ûˆ€.ÿÿÿÿÿÿ ½½Jˆ€/ÿÿÿÿÿÿ½ ½ù¼€0ÿÿÿÿÿÿ!½½ï¼€1ÿÿÿÿÿÿ+½!½å¼€2ÿÿÿÿÿÿ5½7ž‰€3ÿÿÿÿÿÿ?½þ‚/Š€4ÿÿÿÿÿÿI½Û…­Š€5ÿÿÿÿÿÿS½©‹Á£€6ÿÿÿÿÿÿ]½S½I½€7ÿÿÿÿÿÿg½]½?½€8ÿÿÿÿÿÿq½g½5½€9ÿÿÿÿÿÿ{½q½+½€:ÿÿÿÿÿÿ…½{½Û¼€;ÿÿÿÿÿÿ½…½•¼€<ÿÿÿÿÿÿ™½½O¼€=ÿÿÿÿÿÿ£½I€}€>ÿÿÿÿÿÿ­½ëtKo€?ÿÿÿÿÿÿ·½¨†‡~€@ÿÿÿÿÿÿÁ½M¤·½€Aÿÿÿÿÿÿ˽Á½­½€Bÿÿÿÿÿÿս˽£½€Cÿÿÿÿÿÿß½Õ½[|€Dÿÿÿÿÿÿé½}I€€Eÿÿÿÿÿÿó½þt^o€Fÿÿÿÿÿÿý½M‡X‚€Gÿÿÿÿÿÿ¾§¤ý½€Hÿÿÿÿÿÿ¾¾ó½€Iÿÿÿÿÿÿ¾¾ï€€Jÿÿÿÿÿÿ%¾¾é½€Kÿÿÿÿÿÿ/¾Koët€Lÿÿÿÿÿÿ9¾^oþt€MÿÿÿÿÿÿC¾—o7u€NÿÿÿÿÿÿM¾¥C¾€OÿÿÿÿÿÿW¾M¾Ô„€Pÿÿÿÿÿÿa¾W¾9¾€Qÿÿÿÿÿÿk¾a¾/¾€Rÿÿÿÿÿÿu¾‡~¨†€Sÿÿÿÿÿÿ¾X‚M‡€Tÿÿÿÿÿÿ‰¾7u—o€Uÿÿÿÿÿÿ“¾[¥]ˆ€Vÿÿÿÿÿÿ¾“¾‰¾€Wÿÿÿÿÿÿ§¾¾¾€Xÿÿÿÿÿÿ±¾§¾u¾€Yÿÿÿÿÿÿ»¾^»‰€ZÿÿÿÿÿÿžƒBŠ€[ÿÿÿÿÿÿϾpuÐo€\ÿÿÿÿÿÿÙ¾øˆ>‹€]ÿÿÿÿÿÿã¾Æ‹Ù¾€^ÿÿÿÿÿÿí¾ã¾Ï¾€_ÿÿÿÿÿÿ÷¾í¾Å¾€`ÿÿÿÿÿÿ¿÷¾»¾€aÿÿÿÿÿÿ ¿¿±¾€bÿÿÿÿÿÿ¿ ¿k¾€cÿÿÿÿÿÿ¿¿%¾€dÿÿÿÿÿÿ)¿¿ß½€eÿÿÿÿÿÿ3¿)¿™½€fÿÿÿÿÿÿ=¿3¿ ¼€gÿÿÿÿÿÿG¿=¿yº€hÿÿÿÿÿÿQ¿G¿é¸€iÿÿÿÿÿÿ[¿[°)°€jÿÿÿÿÿÿe¿[¿÷¯€kÿÿÿÿÿÿo¿e¿Å¯€lÿÿÿÿÿÿy¿o¿“¯€mÿÿÿÿÿÿƒ¿öi ~€nÿÿÿÿÿÿ¿ƒ¿Y}€oÿÿÿÿÿÿ—¿¿ |€pÿÿÿÿÿÿ¡¿—¿ð{€qÿÿÿÿÿÿ«¿d|?k€rÿÿÿÿÿÿµ¿«¿òh€sÿÿÿÿÿÿ¿¿µ¿ |€tÿÿÿÿÿÿÉ¿¿¿ð{€uÿÿÿÿÿÿÓ¿É¿¡¿€vÿÿÿÿÿÿÝ¿ß~&~€wÿÿÿÿÿÿç¿Ý¿ti€xÿÿÿÿÿÿñ¿ç¿½|€yÿÿÿÿÿÿû¿ñ¿ |€zÿÿÿÿÿÿÀi+€€{ÿÿÿÿÿÿÀÀ€€|ÿÿÿÿÿÿÀÀÞ€}ÿÿÿÿÿÿ#ÀÀ |€~ÿÿÿÿÿÿ-À#Àû¿€ÿÿÿÿÿÿ7Àqk€€ÿÿÿÿÿÿAÀ7À“}€ÿÿÿÿÿÿKÀAÀä|€‚ÿÿÿÿÿÿUÀKÀ]4€ƒÿÿÿÿÿÿ_Àރʃ€„ÿÿÿÿÿÿiÀ_À5k€…ÿÿÿÿÿÿsÀiÀû€†ÿÿÿÿÿÿ}ÀsÀ]4€‡ÿÿÿÿÿÿ‡À}ÀUÀ€ˆÿÿÿÿÿÿ‘À-°i€‰ÿÿÿÿÿÿ›À‘À°}€Šÿÿÿÿÿÿ¥À›ÀIk€‹ÿÿÿÿÿÿ¯À¥À>|€Œÿÿÿÿÿÿ¹À±†‹†€ÿÿÿÿÿÿÃÀ¹À·ƒ€ŽÿÿÿÿÿÿÍÀÃÀèh€ÿÿÿÿÿÿ×ÀÍÀ>|€ÿÿÿÿÿÿáÀ×À¯À€‘ÿÿÿÿÿÿëÀT}~€’ÿÿÿÿÿÿõÀëÀAo€“ÿÿÿÿÿÿÿÀõÀ.i€”ÿÿÿÿÿÿ ÁÿÀ+k€•ÿÿÿÿÿÿÁ±‰i€–ÿÿÿÿÿÿÁÁát€—ÿÿÿÿÿÿ'ÁÁ?€€˜ÿÿÿÿÿÿ1Á'Á+k€™ÿÿÿÿÿÿ;Á1Á Á€šÿÿÿÿÿÿEÁ;ÁáÀ€›ÿÿÿÿÿÿOÁEÁ‡À€œÿÿÿÿÿÿYÁOÁ-À€ÿÿÿÿÿÿcÁYÁÓ¿€žÿÿÿÿÿÿmÁò~Äi€ŸÿÿÿÿÿÿwÁmÁ}€ ÿÿÿÿÿÿÁwÁÐ|€¡ÿÿÿÿÿÿ‹ÁÁ |€¢ÿÿÿÿÿÿ•Á}Vi€£ÿÿÿÿÿÿŸÁ•ÁSk€¤ÿÿÿÿÿÿ©ÁŸÁÐ|€¥ÿÿÿÿÿÿ³Á©Á |€¦ÿÿÿÿÿÿ½Á³Á‹Á€§ÿÿÿÿÿÿÇÁ°‚퀨ÿÿÿÿÿÿÑÁÇÁG€©ÿÿÿÿÿÿÛÁÑÁ8i€ªÿÿÿÿÿÿåÁÛÁÞ€«ÿÿÿÿÿÿïÁø€Ñ€€¬ÿÿÿÿÿÿùÁïÁª€€­ÿÿÿÿÿÿÂùÁ8i€®ÿÿÿÿÿÿ ½|€¯ÿÿÿÿÿÿ ÂåÁ€°ÿÿÿÿÿÿ!ÂÍ‚ ‚€±ÿÿÿÿÿÿ+Â!Â~i€²ÿÿÿÿÿÿ5Â+½-€³ÿÿÿÿÿÿ?Â5Âû€´ÿÿÿÿÿÿIÂp„]k€µÿÿÿÿÿÿSÂIÂBi€¶ÿÿÿÿÿÿ]ÂS½-€·ÿÿÿÿÿÿgÂ]Âä|€¸ÿÿÿÿÿÿqÂgÂ?€¹ÿÿÿÿÿÿ{Âô‚'‚€ºÿÿÿÿÿÿ…Â{Âw€»ÿÿÿÿÿÿ…¾€€¼ÿÿÿÿÿÿ™ÂÂèh€½ÿÿÿÿÿÿ£Âji&‡€¾ÿÿÿÿÿÿ­Â£ÂS„€¿ÿÿÿÿÿÿ·Â­Â¾€€ÀÿÿÿÿÿÿÁ·ÂIk€ÁÿÿÿÿÿÿËÂÁ™€ÂÿÿÿÿÿÿÕ jN‚€ÃÿÿÿÿÿÿßÂÕÂTo€ÄÿÿÿÿÿÿéÂßÂ倀ÅÿÿÿÿÿÿóÂéÂ?€€ÆÿÿÿÿÿÿýÂgkC‡€ÇÿÿÿÿÿÿÃýÂôt€ÈÿÿÿÿÿÿÃÃ倀ÉÿÿÿÿÿÿÃÃ.i€Êÿÿÿÿÿÿ%ÃÃó€Ëÿÿÿÿÿÿ/Ã%ÃË€Ìÿÿÿÿÿÿ9Ã/Ãq€ÍÿÿÿÿÿÿCÃ9ÀÎÿÿÿÿÿÿMÃCýÁ€ÏÿÿÿÿÿÿWÃL~€ÐÿÿÿÿÿÿaÃWÃab€ÑÿÿÿÿÿÿkÃaÃSk€ÒÿÿÿÿÿÿuÃkÃòh€ÓÿÿÿÿÿÿÃœiÃ}€Ôÿÿÿÿÿÿ‰ÃÃab€Õÿÿÿÿÿÿ“ÉÃ}€ÖÿÿÿÿÿÿÓÃY}€×ÿÿÿÿÿÿ§ÃÃuÀØÿÿÿÿÿÿ±Ãà‚Îi€Ùÿÿÿÿÿÿ»Ã±Ã]€ÚÿÿÿÿÿÿÅûꀀÛÿÿÿÿÿÿÏÃÅÀ€ÜÿÿÿÿÿÿÙÞŠ€ÝÿÿÿÿÿÿãÃÙÃ]€ÞÿÿÿÿÿÿíÃãÃG€ßÿÿÿÿÿÿ÷ÃíÃti€àÿÿÿÿÿÿÄ÷ÃÏÀáÿÿÿÿÿÿ Ä­$5…€âÿÿÿÿÿÿÄ Äì€ãÿÿÿÿÿÿÄÄBi€äÿÿÿÿÿÿ)ÄÄ5k€åÿÿÿÿÿÿ3ÄE2À„€æÿÿÿÿÿÿ=Ä3Äì€çÿÿÿÿÿÿGÄ=Ä~i€èÿÿÿÿÿÿQÄGÄ“}€éÿÿÿÿÿÿ[ÄQÄ)Ä€êÿÿÿÿÿÿeÄjR…€ëÿÿÿÿÿÿoÄeÄÁ\€ìÿÿÿÿÿÿyÄoÄS„€íÿÿÿÿÿÿƒÄyÄ·ƒ€îÿÿÿÿÿÿÄÔ‡’i€ïÿÿÿÿÿÿ—ÄÄÁ\€ðÿÿÿÿÿÿ¡Ä—Äw€ñÿÿÿÿÿÿ«Ä¡Ä°}€òÿÿÿÿÿÿµÄ«ÄƒÄ€óÿÿÿÿÿÿ¿Äfu-u€ôÿÿÿÿÿÿÉĿĈi€õÿÿÿÿÿÿÓÄÉÄôt€öÿÿÿÿÿÿÝÄÓÄát€÷ÿÿÿÿÿÿçÄÆoo€øÿÿÿÿÿÿñÄçĈi€ùÿÿÿÿÿÿûÄñÄTo€úÿÿÿÿÿÿÅûÄAo€ûÿÿÿÿÿÿÅÅÝÄ€üÿÿÿÿÿÿÅŵĀýÿÿÿÿÿÿ#ÅÅ[Ä€þÿÿÿÿÿÿ-Å#ÅÄ€ÿÿÿÿÿÿÿ7Å-ŧÀÿÿÿÿÿÿAÅ@i~€ÿÿÿÿÿÿKÅAÅÃ}€ÿÿÿÿÿÿUÅKÅVi€ÿÿÿÿÿÿ_ÅUÅ?k€ÿÿÿÿÿÿiÅ~i~€ÿÿÿÿÿÿsÅiÅL~€ÿÿÿÿÿÿ}ÅsÅÄi€ÿÿÿÿÿÿ‡Å}Å ~€ÿÿÿÿÿÿ‘ŇÅ_Å€ ÿÿÿÿÿÿ›Å(j:‚€ ÿÿÿÿÿÿ¥Å›ÅŠ€ ÿÿÿÿÿÿ¯Å¥ÅÑ€€ ÿÿÿÿÿÿ¹Å¯Å+€€ ÿÿÿÿÿÿÃÅa‚:‚€ÿÿÿÿÿÿÍÅÃÅÎi€ÿÿÿÿÿÿ×ÅÍÅí€ÿÿÿÿÿÿáÅ×Å&~€ÿÿÿÿÿÿëÅáŹŀÿÿÿÿÿÿõÅä…-€ÿÿÿÿÿÿÿÅõÅÀ„€ÿÿÿÿÿÿ ÆÿÅ]k€ÿÿÿÿÿÿÆ Æʃ€ÿÿÿÿÿÿÆo…-€ÿÿÿÿÿÿ'ÆÆ5…€ÿÿÿÿÿÿ1Æ'Æ ‚€ÿÿÿÿÿÿ;Æ1Æqk€ÿÿÿÿÿÿEÆ;ÆÆ€ÿÿÿÿÿÿOÆш@ˆ€ÿÿÿÿÿÿYÆOÆ’i€ÿÿÿÿÿÿcÆYÆ&‡€ÿÿÿÿÿÿmÆcÆ‹†€ÿÿÿÿÿÿwÆ…k@ˆ€ ÿÿÿÿÿÿÆwÆR…€!ÿÿÿÿÿÿ‹ÆÆ'‚€"ÿÿÿÿÿÿ•Æ‹Æ°i€#ÿÿÿÿÿÿŸÆ•ÆmÆ€$ÿÿÿÿÿÿ©Æîˆ{k€%ÿÿÿÿÿÿ³Æ©Æo€&ÿÿÿÿÿÿ½Æ³ÆC‡€'ÿÿÿÿÿÿÇƽÆi€(ÿÿÿÿÿÿÑÆâi{k€)ÿÿÿÿÿÿÛÆÑÆ-u€*ÿÿÿÿÿÿåÆÛÆN‚€+ÿÿÿÿÿÿïÆåÆ}~€,ÿÿÿÿÿÿùÆïÆÇÆ€-ÿÿÿÿÿÿÇùÆŸÆ€.ÿÿÿÿÿÿ ÇÇEÆ€/ÿÿÿÿÿÿÇ ÇëÅ€0ÿÿÿÿÿÿ!ÇÇ‘Å€1ÿÿÿÿÿÿ+Çg~€2ÿÿÿÿÿÿ5Ç+Çœi€3ÿÿÿÿÿÿ?Ç5Ç}€4ÿÿÿÿÿÿIÇ?Çd|€5ÿÿÿÿÿÿSÇg@€6ÿÿÿÿÿÿ]ÇSÇ€7ÿÿÿÿÿÿgÇ]Çò~€8ÿÿÿÿÿÿqÇgÇöi€9ÿÿÿÿÿÿ{ÇqÇIÇ€:ÿÿÿÿÿÿ…ǃa‚€;ÿÿÿÿÿÿÇ…Çž€<ÿÿÿÿÿÿ™ÇÇø€€=ÿÿÿÿÿÿ£Ç™Çi€>ÿÿÿÿÿÿ­Çƒ(j€?ÿÿÿÿÿÿ·Ç­Çà‚€@ÿÿÿÿÿÿÁÇ·Ç°‚€AÿÿÿÿÿÿËÇÁÇß~€BÿÿÿÿÿÿÕÇËǣǀCÿÿÿÿÿÿßÇ€.o…€DÿÿÿÿÿÿéÇßÇE2€EÿÿÿÿÿÿóÇéÇp„€FÿÿÿÿÿÿýÇóÇÞƒ€GÿÿÿÿÿÿÈ€.ä…€HÿÿÿÿÿÿÈÈ­$€IÿÿÿÿÿÿÈÈÍ‚€Jÿÿÿÿÿÿ%ÈÈ€Kÿÿÿÿÿÿ/È%ÈýÇ€Lÿÿÿÿÿÿ9ȉ…k€MÿÿÿÿÿÿCÈ9ÈÔ‡€NÿÿÿÿÿÿMÈCÈji€OÿÿÿÿÿÿWÈMȱ†€Pÿÿÿÿÿÿaȉш€QÿÿÿÿÿÿkÈaÈj€RÿÿÿÿÿÿuÈkÈô‚€SÿÿÿÿÿÿÈuÈ-€Tÿÿÿÿÿÿ‰ÈÈWÈ€Uÿÿÿÿÿÿ“ȼ‹âi€VÿÿÿÿÿÿÈ“ÈÆo€Wÿÿÿÿÿÿ§ÈÈgk€Xÿÿÿÿÿÿ±È§È±‰€Yÿÿÿÿÿÿ»È¼‹îˆ€ZÿÿÿÿÿÿÅÈ»Èfu€[ÿÿÿÿÿÿÏÈÅÈ j€\ÿÿÿÿÿÿÙÈÏÈT€]ÿÿÿÿÿÿãÈÙȱȀ^ÿÿÿÿÿÿíÈãȉȀ_ÿÿÿÿÿÿ÷ÈíÈ/È€`ÿÿÿÿÿÿÉ÷ÈÕÇ€aÿÿÿÿÿÿ ÉÉ{Ç€bÿÿÿÿÿÿÉ É!Ç€cÿÿÿÿÿÿÉÉ7Å€dÿÿÿÿÿÿ)ÉÉMÀeÿÿÿÿÿÿ3É)ÉcÁ€fÿÿÿÿÿÿ=É+k>|€gÿÿÿÿÿÿGÉ=É]4€hÿÿÿÿÿÿQÉGÉ |€iÿÿÿÿÿÿ[ÉQÉð{€jÿÿÿÿÿÿeÉ?€èh€kÿÿÿÿÿÿoÉeÉû€lÿÿÿÿÿÿyÉoÉÞ€mÿÿÿÿÿÿƒÉyÉ |€nÿÿÿÿÿÿÉát·ƒ€oÿÿÿÿÿÿ—ÉÉ5k€pÿÿÿÿÿÿ¡É—É€€qÿÿÿÿÿÿ«É¡Éòh€rÿÿÿÿÿÿµÉi‹†€sÿÿÿÿÿÿ¿ÉµÉʃ€tÿÿÿÿÿÿÉÉ¿É+€€uÿÿÿÿÿÿÓÉÉÉ?k€vÿÿÿÿÿÿÝɱ‰±†€wÿÿÿÿÿÿçÉÝÉÞƒ€xÿÿÿÿÿÿñÉçÉi€yÿÿÿÿÿÿûÉñÉd|€zÿÿÿÿÿÿÊûÉÓÉ€{ÿÿÿÿÿÿÊÊ«É€|ÿÿÿÿÿÿÊʃɀ}ÿÿÿÿÿÿ#ÊÊ[É€~ÿÿÿÿÿÿ-Ê.iIk€ÿÿÿÿÿÿ7Ê-Êä|€€ÿÿÿÿÿÿAÊ7ʽ|€ÿÿÿÿÿÿKÊAÊ |€‚ÿÿÿÿÿÿUÊ倾€€ƒÿÿÿÿÿÿ_ÊUʽ-€„ÿÿÿÿÿÿiÊ_Ê8i€…ÿÿÿÿÿÿsÊiÊÐ|€†ÿÿÿÿÿÿ}ÊôtS„€‡ÿÿÿÿÿÿ‡Ê}ÊBi€ˆÿÿÿÿÿÿ‘ʇʪ€€‰ÿÿÿÿÿÿ›Ê‘ÊSk€Šÿÿÿÿÿÿ¥ÊC‡&‡€‹ÿÿÿÿÿÿ¯Ê¥Ê]k€Œÿÿÿÿÿÿ¹Ê¯ÊÑ€€ÿÿÿÿÿÿÃʹÊVi€ŽÿÿÿÿÿÿÍÊgkji€ÿÿÿÿÿÿ×ÊÍÊp„€ÿÿÿÿÿÿáÊ×Êø€€‘ÿÿÿÿÿÿëÊáÊ}€’ÿÿÿÿÿÿõÊëÊÃÊ€“ÿÿÿÿÿÿÿÊõʛʀ”ÿÿÿÿÿÿ ËÿÊsÊ€•ÿÿÿÿÿÿË ËKÊ€–ÿÿÿÿÿÿËAo°}€—ÿÿÿÿÿÿ'ËË“}€˜ÿÿÿÿÿÿ1Ë'Ëti€™ÿÿÿÿÿÿ;Ë1ËY}€šÿÿÿÿÿÿEËTow€›ÿÿÿÿÿÿOËEË~i€œÿÿÿÿÿÿYËOËG€ÿÿÿÿÿÿcËYË}€žÿÿÿÿÿÿmˈiÁ\€ŸÿÿÿÿÿÿwËmË쀠ÿÿÿÿÿÿËwË]€¡ÿÿÿÿÿÿ‹ËËab€¢ÿÿÿÿÿÿ•Ëo’i€£ÿÿÿÿÿÿŸË•ËÀ„€¤ÿÿÿÿÿÿ©ËŸËŠ€¥ÿÿÿÿÿÿ³Ë©ËÃ}€¦ÿÿÿÿÿÿ½ËÆoÔ‡€§ÿÿÿÿÿÿÇ˽ËE2€¨ÿÿÿÿÿÿÑËÇËž€©ÿÿÿÿÿÿÛËÑËœi€ªÿÿÿÿÿÿåËÛ˳ˀ«ÿÿÿÿÿÿïËåË‹Ë€¬ÿÿÿÿÿÿùËïËcË€­ÿÿÿÿÿÿÌùË;Ë€®ÿÿÿÿÿÿ Ì}~°i€¯ÿÿÿÿÿÿÌ Ìqk€°ÿÿÿÿÿÿ!ÌÌ&~€±ÿÿÿÿÿÿ+Ì!Ì ~€²ÿÿÿÿÿÿ5ÌN‚'‚€³ÿÿÿÿÿÿ?Ì5Ì ‚€´ÿÿÿÿÿÿIÌ?Ì퀵ÿÿÿÿÿÿSÌIÌÄi€¶ÿÿÿÿÿÿ]Ì-uR…€·ÿÿÿÿÿÿgÌ]Ì5…€¸ÿÿÿÿÿÿqÌgÌÎi€¹ÿÿÿÿÿÿ{ÌqÌL~€ºÿÿÿÿÿÿ…Ì{k@ˆ€»ÿÿÿÿÿÿÌ…Ì-€¼ÿÿÿÿÿÿ™ÌÌ:‚€½ÿÿÿÿÿÿ£Ì™Ìi~€¾ÿÿÿÿÿÿ­Ìâi…k€¿ÿÿÿÿÿÿ·Ì­Ìo…€ÀÿÿÿÿÿÿÁÌ·Ìa‚€ÁÿÿÿÿÿÿËÌÁÌ~€ÂÿÿÿÿÿÿÕÌẸ̈̀ÃÿÿÿÿÿÿßÌÕÌ{Ì€ÄÿÿÿÿÿÿéÌßÌSÌ€ÅÿÿÿÿÿÿóÌéÌ+Ì€ÆÿÿÿÿÿÿýÌT-€ÇÿÿÿÿÿÿÍýÌ€ÈÿÿÿÿÿÿÍÍß~€ÉÿÿÿÿÿÿÍÍöi€Êÿÿÿÿÿÿ%Í jô‚€Ëÿÿÿÿÿÿ/Í%ÍÍ‚€Ìÿÿÿÿÿÿ9Í/Í°‚€ÍÿÿÿÿÿÿCÍ9Íò~€ÎÿÿÿÿÿÿMÍfuj€ÏÿÿÿÿÿÿWÍMÍ­$€ÐÿÿÿÿÿÿaÍWÍà‚€ÑÿÿÿÿÿÿkÍaÍ€ÒÿÿÿÿÿÿuÍîˆÑˆ€ÓÿÿÿÿÿÿÍuÍä…€Ôÿÿÿÿÿÿ‰ÍÍ(j€Õÿÿÿÿÿÿ“͉Í@€Öÿÿÿÿÿÿͼ‹‰€×ÿÿÿÿÿÿ§ÍÍ€.€Øÿÿÿÿÿÿ±Í§Íƒ€Ùÿÿÿÿÿÿ»Í±Íg€ÚÿÿÿÿÿÿÅͻ͓̀ÛÿÿÿÿÿÿÏÍÅÍkÍ€ÜÿÿÿÿÿÿÙÍÏÍCÍ€ÝÿÿÿÿÿÿãÍÙÍÍ€ÞÿÿÿÿÿÿíÍãÍóÌ€ßÿÿÿÿÿÿ÷ÍíÍÌ€àÿÿÿÿÿÿÎ÷ÍË€áÿÿÿÿÿÿ ÎÎ#ÊâÿÿÿÿÿÿÎ Î3Éy¿Q¿Y·1·µ´²k¯ÿ¬Ë©#¦›œšç–÷•GŒæ{>xôltlWl"k6ãÿÿÿÿÿÿ5Î ÙÙóØæØÙØÌؿزإؘ؋Ø~ØdØWØJØ=Ø0Ø#ØØ Øü×ï×â×Õ×È׻׮סהׇ×z×m×`×S×F×9×,××××øÖëÖÞÖÑÖªÖÖÖƒÖvÖiÖ\ÖOÖBÖ5Ö(ÖÖÖÖôÕçÕÚÕÍÕÀÕ³Õ¦Õ™ÕŒÕÕeÕKÕ1ÕÕäÚØÚÓËÚ¾Ú±Ú•ÚˆÚ{ÚnÚaÚ/ÑÑûÐáÐÇÐ3Ú&ÚÚØْϸÙPÏ/Ï«Ù³w wwzwgwTwAw.www›vˆvuvbvOv‹Jˆ?…÷~@ÿÿÿÿÿÿÒÆ‹Ûˆ·$º‚Ì~@ ÿÿÿÿÿÿ"Ò%zz·$ëyÎy@ ÿÿÿÿÿÿ/ÒÞzÁz¤z‡zjz@ ÿÿÿÿÿÿ<Ò—{z{]{@{#{@ ÿÿÿÿÿÿIÒðÔãÔÖÔÉÔVÒ@ ÿÿÿÿÿÿVÒµ¦˜¦{¦^¦A¦@ÿÿÿÿÿÿcÒ¼Ô¯Ô¢Ô•ÔpÒ@ÿÿÿÿÿÿpÒ@ª#ªªé©—@ÿÿÿÿÿÿ}ÒˆÔ{ÔnÔaÔŠÒ@ÿÿÿÿÿÿŠÒL­9­&­­A¦@ÿÿÿÿÿÿ—Òñ¹±¯±¥±i±_±U±K±±±û°ñ°µ°«°¡°—°3°°Ï¯¯@ÿÿÿÿÿÿ¸ÒTÔGÔ:Ô-ÔÅÒ@ÿÿÿÿÿÿÅÒm²Y²E²1²Rx@ÿÿÿÿÿÿÒÒ ÔÔÔùÓßÒ@ÿÿÿÿÿÿßÒ#{jzÎyy\x@ÿÿÿÿÿÿìÒìÓßÓÒÓÓùÒ@ÿÿÿÿÿÿùÒ²µ©µ µ—µ\x@ÿÿÿÿÿÿÓ¼‹@ˆì8ið{@ÿÿÿÿÿÿÓþµõµìµ2yãµ@ÿÿÿÿÿÿ ÓÓoÓNÓ-Ó@ÿÿÿÿÿÿ-Óy‹™¸¸…¸žS¸ˆI¸?¸© ¸¸kbù·OÇ·½·³·„€õœ·w·m·c·ú{@ÿÿÿÿÿÿNÓŒ‹)ººíŸºã¹#ˆÙ¹“ŸÏ¹¹“¹"]9Ÿ‰¹W¹M¹C¹—€9¹¹ý¸ó¸ž|@ÿÿÿÿÿÿoÓŠ.¹»×¡¯»¥»s»-}¡i»_»-»#»v»»ÝºÓºÓ Ç-ɺ—ººy ƒºg4@ÿÿÿÿÿÿÓ©‹Á£I½?½5½½Jˆù¼ï¼å¼³¼£Ë\©¼Ÿ¼m¼½¢c¼È€Y¼'¼c¢¼¼H|@ ÿÿÿÿÿÿ±ÓƋپϾž»¾[¥]ˆ‰¾¾u¾¥C¾9¾/¾§¤ý½ó½ï€é½M¤·½­½£½[|@!ÿÿÿÿÿÿÒÓJ¶A¶·$8¶/¶@"ÿÿÿÿÿÿßÓ–¶Áz¶„¶{¶@#ÿÿÿÿÿÿìÓ—{â¶Ù¶Ð¶Ç¶@$ÿÿÿÿÿÿùÓ@{‡zëy2yyx@%ÿÿÿÿÿÿÔ]{¤z·$Oy–x@&ÿÿÿÿÿÿÔz{Ázzly³x@'ÿÿÿÿÿÿ Ô—{Þz%z‰yÐx@(ÿÿÿÿÿÿ-Ôå²Ñ²½²(y©²@)ÿÿÿÿÿÿ:Ô]³I³­$5³!³@*ÿÿÿÿÿÿGÔÕ³·zÁ³­³™³@+ÿÿÿÿÿÿTÔ{M´9´%´´@,ÿÿÿÿÿÿaÔÀ­­­š­§‡­@-ÿÿÿÿÿÿnÔ4®!®Š.®û­@.ÿÿÿÿÿÿ{Ô¨®¦¨•®‚®o®@/ÿÿÿÿÿÿˆÔ|©¯ ¯ö®ã®@0ÿÿÿÿÿÿ•Ôܪ¿ª¢ªÛ—…ª@1ÿÿÿÿÿÿ¢Ôx«[«O2>«!«@2ÿÿÿÿÿÿ¯Ô¬ö˜÷«Ú«½«@3ÿÿÿÿÿÿ¼ÔÌ™°¬“¬v¬Y¬@4ÿÿÿÿÿÿÉÔn§Q§4§§ú¦@5ÿÿÿÿÿÿÖÔ ¨í§Š.Ч³§@6ÿÿÿÿÿÿãÔ覨‰¨l¨O¨@7ÿÿÿÿÿÿðÔ|©_©B©%©©@8ÿÿÿÿÿÿýÔXÕ>Õ$Õ Õ@9ÿÿÿÿÿÿ Õy‹ˆkb„€ú{@:ÿÿÿÿÿÿÕöi ~Y} |ð{@;ÿÿÿÿÿÿ$ÕŒ‹#ˆ"]—€|@<ÿÿÿÿÿÿ1Õd|?kòh |ð{@=ÿÿÿÿÿÿ>ÕŠ.-vÇ-g4@>ÿÿÿÿÿÿKÕß~&~ti½| |@?ÿÿÿÿÿÿXÕ©‹JˆË\È€H|@@ÿÿÿÿÿÿeÕi+€€Þ |@AÿÿÿÿÿÿrÕÆ‹]ˆï€[|@BÿÿÿÿÿÿÕqk“}ä|]4@CÿÿÿÿÿÿŒÕރʃ5kû]4@Dÿÿÿÿÿÿ™Õ-°i°}Ik>|@Eÿÿÿÿÿÿ¦Õ±†‹†·ƒèh>|@Fÿÿÿÿÿÿ³ÕT}~Ao.i+k@GÿÿÿÿÿÿÀÕ±‰iát?€+k@HÿÿÿÿÿÿÍÕò~Äi}Ð| |@IÿÿÿÿÿÿÚÕ}ViSkÐ| |@JÿÿÿÿÿÿçÕ°‚íG8iÞ@KÿÿÿÿÿÿôÕø€Ñ€ª€8i½|@LÿÿÿÿÿÿÖÍ‚ ‚~i½-û@MÿÿÿÿÿÿÖp„]kBi½-ä|@NÿÿÿÿÿÿÖô‚'‚w¾€èh@Oÿÿÿÿÿÿ(Öji&‡S„¾€Ik@Pÿÿÿÿÿÿ5Ö jN‚Toå€?€@QÿÿÿÿÿÿBÖgkC‡ôtå€.i@RÿÿÿÿÿÿOÖL~abSkòh@Sÿÿÿÿÿÿ\ÖœiÃ}ab}Y}@TÿÿÿÿÿÿiÖà‚Îi]ª€€@UÿÿÿÿÿÿvÖžŠ]Gti@VÿÿÿÿÿÿƒÖ­$5…ìBi5k@WÿÿÿÿÿÿÖE2À„ì~i“}@XÿÿÿÿÿÿÖjR…Á\S„·ƒ@YÿÿÿÿÿÿªÖÔ‡’iÁ\w°}@Zÿÿÿÿÿÿ·Öfu-uôtát@[ÿÿÿÿÿÿÄÖÆooToAo@\ÿÿÿÿÿÿÑÖ@i~Ã}Vi?k@]ÿÿÿÿÿÿÞÖ~i~L~Äi ~@^ÿÿÿÿÿÿëÖ(j:‚ŠÑ€+€@_ÿÿÿÿÿÿøÖa‚:‚Îií&~@`ÿÿÿÿÿÿ×ä…-À„]kʃ@aÿÿÿÿÿÿ×o…-5… ‚qk@bÿÿÿÿÿÿ×ш@ˆ’i&‡‹†@cÿÿÿÿÿÿ,×…k@ˆR…'‚°i@dÿÿÿÿÿÿ9×îˆ{koC‡i@eÿÿÿÿÿÿF×âi{k-uN‚}~@fÿÿÿÿÿÿS×g~œi}d|@gÿÿÿÿÿÿ`×g@ò~öi@hÿÿÿÿÿÿm׃a‚žø€i@iÿÿÿÿÿÿz׃(jà‚°‚ß~@jÿÿÿÿÿÿ‡×€.o…E2p„Þƒ@kÿÿÿÿÿÿ”×€.ä…­$Í‚@lÿÿÿÿÿÿ¡×‰…kÔ‡ji±†@mÿÿÿÿÿÿ®×‰Ñˆjô‚-@nÿÿÿÿÿÿ»×¼‹âiÆogk±‰@oÿÿÿÿÿÿÈ×¼‹îˆfu jT@pÿÿÿÿÿÿÕ×+k>|]4 |ð{@qÿÿÿÿÿÿâ×?€èhûÞ |@rÿÿÿÿÿÿï×át·ƒ5k€òh@sÿÿÿÿÿÿü×i‹†Êƒ+€?k@tÿÿÿÿÿÿ ر‰±†Þƒid|@uÿÿÿÿÿÿØ.iIkä|½| |@vÿÿÿÿÿÿ#Ø倾€½-8iÐ|@wÿÿÿÿÿÿ0ØôtS„Biª€Sk@xÿÿÿÿÿÿ=ØC‡&‡]kÑ€Vi@yÿÿÿÿÿÿJØgkjip„ø€}@zÿÿÿÿÿÿWØAo°}“}tiY}@{ÿÿÿÿÿÿdØTow~iG}@|ÿÿÿÿÿÿqØÁ\ì]ab@}ÿÿÿÿÿÿ~Øo’iÀ„ŠÃ}@~ÿÿÿÿÿÿ‹ØÆoÔ‡E2žœi@ÿÿÿÿÿÿ˜Ø}~°iqk&~ ~@€ÿÿÿÿÿÿ¥ØN‚'‚ ‚íÄi@ÿÿÿÿÿÿ²Ø-uR…5…ÎiL~@‚ÿÿÿÿÿÿ¿Ø{k@ˆ-:‚i~@ƒÿÿÿÿÿÿÌØâi…ko…a‚~@„ÿÿÿÿÿÿÙØT-ß~öi@…ÿÿÿÿÿÿæØ jô‚Í‚°‚ò~@†ÿÿÿÿÿÿóØfuj­$à‚@‡ÿÿÿÿÿÿÙîˆÑˆä…(j@@ˆÿÿÿÿÿÿ Ù¼‹‰€.ƒg@‰ÿÿÿÿÿÿÙTÙ…k{kÎiÄiqkœi’i~itigk]kSk8iIki?k5kèh+k@Šÿÿÿÿÿÿ7ÙTÙâi-ÎiÄi°iœi’i~itijiViBi8i.iiiòhèh]4@‹ÿÿÿÿÿÿTÙ€.(jj jöiŒÿÿÿÿÿÿaÙTÙâi-ÎiÄi°iœi’i~itijiViBi8i.iiiòhèh]4@ÿÿÿÿÿÿ}ÙaÙŽÿÿÿÿÿÿ†ÙTÙ…k{kÎiÄiqkœi’i~itigk]kSk8iIki?k5kèh+k@ÿÿÿÿÿÿ¢Ù†Ù@ÿÿÿÿÿÿ«Ù<Ò/Ò"Ò†Ð"Ï‘ÿÿÿÿÿÿ¸Ùø…î…Ñ…Ç…´…y…e…H…+……Ê„„T¶„¬„z„f„I„6„#„èƒÔƒ­ƒšƒ‡ƒ@’ÿÿÿÿÿÿØÙÏ‹²‹Ÿ‹•‹‚‹G‹4‹!‹‹ûŠÀŠ¶ŠO2™Š†ŠKŠ8Š%ŠŠÿ‰Ä‰§‰”‰‰n‰“ÿÿÿÿÿÿùÙ•u•k•a•W•%••••ý”Ë”Á”­”£”q”g”]”S”I”” ””ù“ï“@”ÿÿÿÿÿÿÚùÙDÐ#ÐÐáÏ@•ÿÿÿÿÿÿ&ÚÒÒûÑ<Ñ Ð@–ÿÿÿÿÿÿ3Ú"ÑÑîÐÔкÐ@—ÿÿÿÿÿÿ@ÚÆ‹«¥¡¥—¥¥[¥Q¥G¥=¥3¥¥÷¤vã¤Ù¤§¤¤“¤‰¤¤M¤C¤9¤/¤%¤@˜ÿÿÿÿÿÿaÚ@ڹјÑwÑVÑ@™ÿÿÿÿÿÿnÚðÔãÔÖÔÉÔVÒ@šÿÿÿÿÿÿ{Ú¼Ô¯Ô¢Ô•ÔpÒ@›ÿÿÿÿÿÿˆÚˆÔ{ÔnÔaÔŠÒœÿÿÿÿÿÿ•Úñ¹±¯±¥±i±_±U±K±±±û°ñ°µ°«°¡°—°3°°Ï¯¯@ÿÿÿÿÿÿ±ÚTÔGÔ:Ô-ÔÅÒ@žÿÿÿÿÿÿ¾Ú ÔÔÔùÓßÒ@ŸÿÿÿÿÿÿËÚìÓßÓÒÓÓùÒ ÿÿÿÿÿÿØÚÓoÓNÓ-Ó¡ÿÿÿÿÿÿäÚXÕ>Õ$Õ Õ5¢ÿÿÿÿÿÿðÚ ÙÙóØæØÙØÌؿزإؘ؋Ø~ØdØWØJØ=Ø0Ø#ØØ Øü×ï×â×Õ×È׻׮סהׇ×z×m×`×S×F×9×,××××øÖëÖÞÖÑÖªÖÖÖƒÖvÖiÖ\ÖOÖBÖ5Ö(ÖÖÖÖôÕçÕÚÕÍÕÀÕ³Õ¦Õ™ÕŒÕÕeÕKÕ1ÕÕäÚØÚÓËÚ¾Ú±Ú•ÚˆÚ{ÚnÚaÚ/ÑÑûÐáÐÇÐ3Ú&ÚÚØْϸÙPÏ/Ï«Ù³w wwzwgwTwAw.www›vˆvuvbvOvCHNSX[^addtruefalsenot==>andorxordistinctite=distinctite=distinctiteop1ope4e3e2e1e0R PBoolUIIIIIIII@<P sW_oR PBoolUIIIIIIII@<P PBoolUI P   .>3C(8H1 0 -2 0 127 0 132 0 217 0 247 0 273 0 279 0 316 0 346 0 376 0 402 0 531 0 553 0 559 0 689 0 714 0 740 0 765 0 791 0 817 0 -823 0 -824 0 -825 0 -826 0 -827 0 -828 0 -829 0 -830 0 -831 0 -832 0 -833 0 -834 0 -835 0 -836 0 -837 0 -838 0 -839 0 -840 0 -841 0 -842 0 -843 0 -13 0 -281 0 416 0 436 0 456 0 476 0 497 0 489 0 667 0 -692 0 -844 0 -845 0 -38 0 494 0 672 0 -697 0 -846 0 -847 0 -83 0 503 0 681 0 -706 0 -108 0 508 0 686 0 -711 0 -848 0 -849 0 -850 0 -851 0 -852 0 -853 0 -854 0 -855 0 -856 0 -857 0 -858 0 -859 0 -860 0 -861 0 -862 0 -863 0 -864 0 -865 0 -866 0 -867 0 -868 0 -869 0 -870 0 -871 0 -872 0 -873 0 -874 0 -875 0 -876 0 -877 0 -878 0 -879 0 -880 0 -881 0 -882 0 -883 0 -884 0 -885 0 -886 0 -887 0 -888 0 -889 0 -53 0 675 0 -700 0 -890 0 -891 0 -58 0 498 0 676 0 -701 0 -892 0 -893 0 -63 0 499 0 677 0 -702 0 -68 0 500 0 678 0 -703 0 -894 0 -895 0 -896 0 -897 0 -898 0 -899 0 -900 0 -901 0 -902 0 -903 0 -904 0 -905 0 -906 0 -907 0 -908 0 -909 0 -910 0 -911 0 -912 0 -913 0 -914 0 -123 0 477 0 652 0 -727 0 -124 0 -289 0 418 0 438 0 627 0 -752 0 -125 0 602 0 -778 0 -126 0 577 0 -804 0 -915 0 -916 0 -917 0 -918 0 -919 0 -920 0 14 0 650 0 -742 0 41 0 601 0 -749 0 57 0 567 0 802 0 3 4 5 6 7 0 8 9 10 11 12 0 14 15 13 16 17 0 18 19 20 21 22 0 23 24 25 26 27 0 28 29 30 31 32 0 33 34 35 36 37 0 39 40 38 41 42 0 43 44 45 46 47 0 48 49 50 51 52 0 54 55 53 56 57 0 59 60 58 61 62 0 64 65 63 66 67 0 69 70 68 71 72 0 73 74 75 76 77 0 78 79 80 81 82 0 84 85 83 86 87 0 88 89 90 91 92 0 93 94 95 96 97 0 98 99 100 101 102 0 103 104 105 106 107 0 109 110 108 111 112 0 113 114 115 116 117 0 118 119 120 121 122 0 3 8 13 18 23 0 3 28 53 73 98 0 4 9 14 19 24 0 4 29 54 74 99 0 5 10 15 20 25 0 5 30 55 75 100 0 6 11 16 21 26 0 6 31 56 76 101 0 7 12 17 22 27 0 7 32 57 77 102 0 28 33 38 43 48 0 8 33 58 78 103 0 29 34 39 44 49 0 9 34 59 79 104 0 30 35 40 45 50 0 10 35 60 80 105 0 31 36 41 46 51 0 11 36 61 81 106 0 32 37 42 47 52 0 12 37 62 82 107 0 54 59 64 69 123 0 14 39 84 109 123 0 55 60 65 70 124 0 15 40 85 110 124 0 56 61 66 71 125 0 16 41 86 111 125 0 57 62 67 72 126 0 17 42 87 112 126 0 73 78 83 88 93 0 18 43 63 88 113 0 74 79 84 89 94 0 19 44 64 89 114 0 75 80 85 90 95 0 20 45 65 90 115 0 76 81 86 91 96 0 21 46 66 91 116 0 77 82 87 92 97 0 22 47 67 92 117 0 98 103 108 113 118 0 23 48 68 93 118 0 99 104 109 114 119 0 24 49 69 94 119 0 100 105 110 115 120 0 25 50 70 95 120 0 101 106 111 116 121 0 26 51 71 96 121 0 102 107 112 117 122 0 27 52 72 97 122 0 128 129 130 131 0 -7 -131 0 -37 -131 0 -126 -131 0 -92 -131 0 -122 -131 0 7 37 92 122 126 131 0 -6 -130 0 -36 -130 0 -125 -130 0 -91 -130 0 -121 -130 0 6 36 91 121 125 130 0 -5 -129 0 -35 -129 0 -124 -129 0 -90 -129 0 -120 -129 0 5 35 90 120 124 129 0 -4 -128 0 -34 -128 0 -123 -128 0 -89 -128 0 -119 -128 0 4 34 89 119 123 128 0 133 134 135 136 0 -7 -136 0 -136 137 0 -136 138 0 -136 139 0 -136 140 0 -136 141 0 -37 -136 0 -136 142 0 -136 143 0 -136 144 0 -136 145 0 -136 146 0 -126 -136 0 -136 147 0 -136 148 0 -136 149 0 -136 150 0 -136 151 0 -92 -136 0 -136 152 0 -136 153 0 -136 154 0 -136 155 0 -136 156 0 -122 -136 0 7 37 92 122 126 136 -137 -138 -139 -140 -141 -142 -143 -144 -145 -146 -147 -148 -149 -150 -151 -152 -153 -154 -155 -156 0 117 156 0 97 156 0 -97 -117 -156 0 112 155 0 72 155 0 -72 -112 -155 0 107 154 0 52 154 0 -52 -107 -154 0 102 153 0 27 153 0 -27 -102 -153 0 97 152 0 117 152 0 -97 -117 -152 0 87 151 0 67 151 0 -67 -87 -151 0 82 150 0 47 150 0 -47 -82 -150 0 77 149 0 22 149 0 -22 -77 -149 0 72 148 0 112 148 0 -72 -112 -148 0 67 147 0 87 147 0 -67 -87 -147 0 62 146 0 42 146 0 -42 -62 -146 0 57 145 0 17 145 0 -17 -145 -57 0 52 144 0 107 144 0 -52 -107 -144 0 47 143 0 82 143 0 -47 -82 -143 0 42 142 0 62 142 0 -42 -62 -142 0 32 141 0 12 141 0 -12 -32 -141 0 27 140 0 102 140 0 -27 -102 -140 0 22 139 0 77 139 0 -22 -77 -139 0 17 138 0 57 138 0 -17 -138 -57 0 12 137 0 32 137 0 -12 -32 -137 0 -6 -135 0 -135 157 0 -135 158 0 -135 159 0 -135 160 0 -135 161 0 -36 -135 0 -135 162 0 -135 163 0 -135 164 0 -135 165 0 -135 166 0 -125 -135 0 -135 167 0 -135 168 0 -135 169 0 -135 170 0 -135 171 0 -91 -135 0 -135 172 0 -135 173 0 -135 174 0 -135 175 0 -135 176 0 -121 -135 0 6 36 91 121 125 135 -157 -158 -159 -160 -161 -162 -163 -164 -165 -166 -167 -168 -169 -170 -171 -172 -173 -174 -175 -176 0 116 176 0 96 176 0 -96 -116 -176 0 111 175 0 71 175 0 -71 -111 -175 0 106 174 0 51 174 0 -51 -106 -174 0 101 173 0 26 173 0 -26 -101 -173 0 96 172 0 116 172 0 -96 -116 -172 0 86 171 0 66 171 0 -66 -86 -171 0 81 170 0 46 170 0 -46 -81 -170 0 76 169 0 21 169 0 -21 -76 -169 0 71 168 0 111 168 0 -71 -111 -168 0 66 167 0 86 167 0 -66 -86 -167 0 61 166 0 41 166 0 -61 -166 -41 0 56 165 0 16 165 0 -16 -56 -165 0 51 164 0 106 164 0 -51 -106 -164 0 46 163 0 81 163 0 -46 -81 -163 0 41 162 0 61 162 0 -61 -162 -41 0 31 161 0 11 161 0 -11 -31 -161 0 26 160 0 101 160 0 -26 -101 -160 0 21 159 0 76 159 0 -21 -76 -159 0 16 158 0 56 158 0 -16 -56 -158 0 11 157 0 31 157 0 -11 -31 -157 0 -5 -134 0 -134 177 0 -134 178 0 -134 179 0 -134 180 0 -134 181 0 -35 -134 0 -134 182 0 -134 183 0 -134 184 0 -134 185 0 -134 186 0 -124 -134 0 -134 187 0 -134 188 0 -134 189 0 -134 190 0 -134 191 0 -90 -134 0 -134 192 0 -134 193 0 -134 194 0 -134 195 0 -134 196 0 -120 -134 0 5 35 90 120 124 134 -177 -178 -179 -180 -181 -182 -183 -184 -185 -186 -187 -188 -189 -190 -191 -192 -193 -194 -195 -196 0 115 196 0 95 196 0 -95 -115 -196 0 110 195 0 70 195 0 -70 -110 -195 0 105 194 0 50 194 0 -50 -105 -194 0 100 193 0 25 193 0 -25 -100 -193 0 95 192 0 115 192 0 -95 -115 -192 0 85 191 0 65 191 0 -65 -85 -191 0 80 190 0 45 190 0 -45 -80 -190 0 75 189 0 20 189 0 -20 -75 -189 0 70 188 0 110 188 0 -70 -110 -188 0 65 187 0 85 187 0 -65 -85 -187 0 60 186 0 40 186 0 -40 -60 -186 0 55 185 0 15 185 0 -15 -55 -185 0 50 184 0 105 184 0 -50 -105 -184 0 45 183 0 80 183 0 -45 -80 -183 0 40 182 0 60 182 0 -40 -60 -182 0 30 181 0 10 181 0 -10 -30 -181 0 25 180 0 100 180 0 -25 -100 -180 0 20 179 0 75 179 0 -20 -75 -179 0 15 178 0 55 178 0 -15 -55 -178 0 10 177 0 30 177 0 -10 -30 -177 0 -4 -133 0 -133 197 0 -133 198 0 -133 199 0 -133 200 0 -133 201 0 -34 -133 0 -133 202 0 -133 203 0 -133 204 0 -133 205 0 -133 206 0 -123 -133 0 -133 207 0 -133 208 0 -133 209 0 -133 210 0 -133 211 0 -89 -133 0 -133 212 0 -133 213 0 -133 214 0 -133 215 0 -133 216 0 -119 -133 0 4 34 89 119 123 133 -197 -198 -199 -200 -201 -202 -203 -204 -205 -206 -207 -208 -209 -210 -211 -212 -213 -214 -215 -216 0 114 216 0 94 216 0 -94 -114 -216 0 109 215 0 69 215 0 -69 -109 -215 0 104 214 0 49 214 0 -49 -104 -214 0 99 213 0 24 213 0 -24 -99 -213 0 94 212 0 114 212 0 -94 -114 -212 0 84 211 0 64 211 0 -64 -84 -211 0 79 210 0 44 210 0 -44 -79 -210 0 74 209 0 19 209 0 -19 -74 -209 0 69 208 0 109 208 0 -69 -109 -208 0 64 207 0 84 207 0 -64 -84 -207 0 59 206 0 39 206 0 -39 -59 -206 0 54 205 0 14 205 0 -54 -205 -14 0 49 204 0 104 204 0 -49 -104 -204 0 44 203 0 79 203 0 -44 -79 -203 0 39 202 0 59 202 0 -39 -59 -202 0 29 201 0 9 201 0 -9 -29 -201 0 24 200 0 99 200 0 -24 -99 -200 0 19 199 0 74 199 0 -19 -74 -199 0 14 198 0 54 198 0 -54 -198 -14 0 9 197 0 29 197 0 -9 -29 -197 0 3 34 91 122 124 0 218 219 220 221 222 0 -222 -223 0 -222 -224 0 -222 -225 0 -222 -226 0 -222 -227 0 222 223 224 225 226 227 0 -221 -228 0 -221 -229 0 -221 -230 0 -221 -231 0 -221 -232 0 221 228 229 230 231 232 0 -220 -233 0 -220 -234 0 -15 -220 0 -220 -235 0 -220 -236 0 15 220 233 234 235 236 0 -219 -237 0 -219 -238 0 -219 -239 0 -219 -240 0 -219 -241 0 219 237 238 239 240 241 0 -218 -242 0 -218 -243 0 -218 -244 0 -218 -245 0 -218 -246 0 218 242 243 244 245 246 0 248 249 250 251 252 0 -252 -253 0 -252 -254 0 -252 -255 0 -252 -256 0 -227 -252 0 227 252 253 254 255 256 0 -251 -257 0 -251 -258 0 -251 -259 0 -231 -251 0 -251 -260 0 231 251 257 258 259 260 0 -250 -261 0 -250 -262 0 -15 -250 0 -250 -263 0 -250 -264 0 15 250 261 262 263 264 0 -249 -265 0 -238 -249 0 -249 -266 0 -249 -267 0 -249 -268 0 238 249 265 266 267 268 0 -242 -248 0 -248 -269 0 -248 -270 0 -248 -271 0 -248 -272 0 242 248 269 270 271 272 0 274 275 276 277 278 0 223 -278 0 224 -278 0 225 -278 0 226 -278 0 227 -278 0 -223 -224 -225 -226 -227 278 0 228 -277 0 229 -277 0 230 -277 0 231 -277 0 232 -277 0 -228 -229 -230 -231 -232 277 0 233 -276 0 234 -276 0 15 -276 0 235 -276 0 236 -276 0 -15 -233 -234 -235 -236 276 0 237 -275 0 238 -275 0 239 -275 0 240 -275 0 241 -275 0 -237 -238 -239 -240 -241 275 0 242 -274 0 243 -274 0 244 -274 0 245 -274 0 246 -274 0 -242 -243 -244 -245 -246 274 0 280 282 281 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 0 122 -299 0 -299 300 0 -122 299 -300 0 -300 301 0 -122 -300 0 122 300 -301 0 -301 302 0 -92 -301 0 92 301 -302 0 -302 303 0 -126 -302 0 302 -303 126 0 -7 -303 0 -37 -303 0 7 37 303 0 117 -298 0 -298 304 0 -117 298 -304 0 -304 305 0 -121 -304 0 121 304 -305 0 -305 306 0 -91 -305 0 91 305 -306 0 -306 307 0 -125 -306 0 306 -307 125 0 -6 -307 0 -36 -307 0 6 36 307 0 112 -297 0 -297 308 0 -112 297 -308 0 -308 309 0 -120 -308 0 120 308 -309 0 -309 310 0 -90 -309 0 90 309 -310 0 -310 311 0 -124 -310 0 310 -311 124 0 -5 -311 0 -35 -311 0 5 35 311 0 107 -296 0 -296 312 0 -107 296 -312 0 -312 313 0 -119 -312 0 119 312 -313 0 -313 314 0 -89 -313 0 89 313 -314 0 -314 315 0 -123 -314 0 314 -315 123 0 -4 -315 0 -34 -315 0 4 34 315 0 96 -295 0 -295 300 0 -96 295 -300 0 91 -294 0 -294 304 0 -91 294 -304 0 86 -293 0 -293 308 0 -86 293 -308 0 81 -292 0 -292 312 0 -81 292 -312 0 70 -291 0 -291 300 0 -70 291 -300 0 65 -290 0 -290 304 0 -65 290 -304 0 -289 124 0 -289 308 0 -124 289 -308 0 60 -288 0 -288 312 0 -60 288 -312 0 49 -287 0 -287 300 0 -49 287 -300 0 44 -286 0 -286 304 0 -44 286 -304 0 39 -285 0 -285 308 0 -39 285 -308 0 34 -284 0 -284 312 0 -34 284 -312 0 23 -283 0 -283 300 0 -23 283 -300 0 18 -282 0 -282 304 0 -18 282 -304 0 -281 13 0 -281 308 0 -13 281 -308 0 8 -280 0 -280 312 0 -8 280 -312 0 317 318 319 320 321 0 -321 -322 0 -321 -323 0 -321 -324 0 -321 -325 0 -321 -326 0 321 322 323 324 325 326 0 -320 -327 0 -320 -328 0 -320 -329 0 -320 -330 0 -320 -331 0 320 327 328 329 330 331 0 -319 -332 0 -319 -333 0 -5 -319 0 -319 -334 0 -319 -335 0 5 319 332 333 334 335 0 -318 -336 0 -318 -337 0 -318 -338 0 -318 -339 0 -318 -340 0 318 336 337 338 339 340 0 -317 -341 0 -317 -342 0 -317 -343 0 -317 -344 0 -317 -345 0 317 341 342 343 344 345 0 347 348 349 350 351 0 -351 -352 0 -351 -353 0 -351 -354 0 -351 -355 0 -351 -356 0 351 352 353 354 355 356 0 -350 -357 0 -350 -358 0 -350 -359 0 -350 -360 0 -350 -361 0 350 357 358 359 360 361 0 -349 -362 0 -349 -363 0 -55 -349 0 -349 -364 0 -349 -365 0 55 349 362 363 364 365 0 -348 -366 0 -348 -367 0 -348 -368 0 -348 -369 0 -348 -370 0 348 366 367 368 369 370 0 -347 -371 0 -347 -372 0 -347 -373 0 -347 -374 0 -347 -375 0 347 371 372 373 374 375 0 377 378 379 380 381 0 -381 -382 0 -381 -383 0 -381 -384 0 -381 -385 0 -326 -381 0 326 381 382 383 384 385 0 -380 -386 0 -380 -387 0 -380 -388 0 -330 -380 0 -380 -389 0 330 380 386 387 388 389 0 -379 -390 0 -379 -391 0 -5 -379 0 -379 -392 0 -379 -393 0 5 379 390 391 392 393 0 -378 -394 0 -337 -378 0 -378 -395 0 -378 -396 0 -378 -397 0 337 378 394 395 396 397 0 -341 -377 0 -377 -398 0 -377 -399 0 -377 -400 0 -377 -401 0 341 377 398 399 400 401 0 403 404 405 406 407 0 -407 408 0 -407 409 0 -407 410 0 -407 411 0 140 -407 0 -407 412 0 -407 413 0 -407 414 0 -407 415 0 144 -407 0 -407 416 0 -407 417 0 -407 418 0 -407 419 0 148 -407 0 -407 420 0 -407 421 0 -407 422 0 -407 423 0 152 -407 0 -407 424 0 -407 425 0 -407 426 0 -407 427 0 -122 -407 0 122 -140 -144 -148 -152 407 -408 -409 -410 -411 -412 -413 -414 -415 -416 -417 -418 -419 -420 -421 -422 -423 -424 -425 -426 -427 0 117 427 0 96 427 0 -96 -117 -427 0 112 426 0 70 426 0 -70 -112 -426 0 107 425 0 49 425 0 -49 -107 -425 0 102 424 0 23 424 0 -23 -102 -424 0 92 423 0 91 423 0 -91 -92 -423 0 87 422 0 65 422 0 -65 -87 -422 0 82 421 0 44 421 0 -44 -82 -421 0 77 420 0 18 420 0 -18 -77 -420 0 67 419 0 86 419 0 -67 -86 -419 0 418 126 0 418 124 0 -124 -126 -418 0 62 417 0 39 417 0 -39 -62 -417 0 57 416 0 416 13 0 -13 -57 -416 0 47 415 0 81 415 0 -47 -81 -415 0 42 414 0 60 414 0 -42 -60 -414 0 37 413 0 34 413 0 -34 -37 -413 0 32 412 0 8 412 0 -8 -32 -412 0 22 411 0 76 411 0 -22 -76 -411 0 17 410 0 55 410 0 -17 -55 -410 0 12 409 0 29 409 0 -12 -29 -409 0 7 408 0 3 408 0 -3 -7 -408 0 -406 428 0 -406 429 0 -406 430 0 159 -406 0 -406 431 0 -406 432 0 -406 433 0 -406 434 0 163 -406 0 -406 435 0 -406 436 0 -406 437 0 -406 438 0 167 -406 0 -406 439 0 -406 440 0 -406 441 0 -406 442 0 -91 -406 0 -406 443 0 -406 444 0 -406 445 0 -406 446 0 176 -406 0 -406 447 0 91 -159 -163 -167 -176 406 -428 -429 -430 -431 -432 -433 -434 -435 -436 -437 -438 -439 -440 -441 -442 -443 -444 -445 -446 -447 0 121 447 0 122 447 0 -121 -122 -447 0 111 446 0 70 446 0 -70 -111 -446 0 106 445 0 49 445 0 -49 -106 -445 0 101 444 0 23 444 0 -23 -101 -444 0 96 443 0 117 443 0 -96 -117 -443 0 86 442 0 65 442 0 -65 -86 -442 0 81 441 0 44 441 0 -44 -81 -441 0 76 440 0 18 440 0 -18 -76 -440 0 71 439 0 112 439 0 -71 -112 -439 0 438 125 0 438 124 0 -124 -125 -438 0 61 437 0 39 437 0 -39 -61 -437 0 56 436 0 436 13 0 -13 -56 -436 0 51 435 0 107 435 0 -51 -107 -435 0 41 434 0 60 434 0 -60 -434 -41 0 36 433 0 34 433 0 -34 -36 -433 0 31 432 0 8 432 0 -8 -31 -432 0 26 431 0 102 431 0 -26 -102 -431 0 16 430 0 55 430 0 -16 -55 -430 0 11 429 0 29 429 0 -11 -29 -429 0 6 428 0 3 428 0 -3 -6 -428 0 -405 448 0 -405 449 0 178 -405 0 -405 450 0 -405 451 0 -405 452 0 -405 453 0 182 -405 0 -405 454 0 -405 455 0 -405 456 0 -405 457 0 -124 -405 0 -405 458 0 -405 459 0 -405 460 0 -405 461 0 191 -405 0 -405 462 0 -405 463 0 -405 464 0 -405 465 0 195 -405 0 -405 466 0 -405 467 0 -178 -182 124 -191 -195 405 -448 -449 -450 -451 -452 -453 -454 -455 -456 -457 -458 -459 -460 -461 -462 -463 -464 -465 -466 -467 0 120 467 0 122 467 0 -120 -122 -467 0 115 466 0 96 466 0 -96 -115 -466 0 105 465 0 49 465 0 -49 -105 -465 0 100 464 0 23 464 0 -23 -100 -464 0 95 463 0 117 463 0 -95 -117 -463 0 90 462 0 91 462 0 -90 -91 -462 0 80 461 0 44 461 0 -44 -80 -461 0 75 460 0 18 460 0 -18 -75 -460 0 70 459 0 112 459 0 -70 -112 -459 0 65 458 0 86 458 0 -65 -86 -458 0 60 457 0 39 457 0 -39 -60 -457 0 55 456 0 456 13 0 -13 -55 -456 0 50 455 0 107 455 0 -50 -107 -455 0 45 454 0 81 454 0 -45 -81 -454 0 35 453 0 34 453 0 -34 -35 -453 0 30 452 0 8 452 0 -8 -30 -452 0 25 451 0 102 451 0 -25 -102 -451 0 20 450 0 76 450 0 -20 -76 -450 0 10 449 0 29 449 0 -10 -29 -449 0 5 448 0 3 448 0 -3 -5 -448 0 -404 468 0 197 -404 0 -404 469 0 -404 470 0 -404 471 0 -404 472 0 -34 -404 0 -404 473 0 -404 474 0 -404 475 0 -404 476 0 206 -404 0 -404 477 0 -404 478 0 -404 479 0 -404 480 0 210 -404 0 -404 481 0 -404 482 0 -404 483 0 -404 484 0 214 -404 0 -404 485 0 -404 486 0 -404 487 0 34 -197 -206 -210 -214 404 -468 -469 -470 -471 -472 -473 -474 -475 -476 -477 -478 -479 -480 -481 -482 -483 -484 -485 -486 -487 0 119 487 0 122 487 0 -119 -122 -487 0 114 486 0 96 486 0 -96 -114 -486 0 109 485 0 70 485 0 -70 -109 -485 0 99 484 0 23 484 0 -23 -99 -484 0 94 483 0 117 483 0 -94 -117 -483 0 89 482 0 91 482 0 -89 -91 -482 0 84 481 0 65 481 0 -65 -84 -481 0 74 480 0 18 480 0 -18 -74 -480 0 69 479 0 112 479 0 -69 -112 -479 0 64 478 0 86 478 0 -64 -86 -478 0 477 123 0 477 124 0 -123 -124 -477 0 54 476 0 476 13 0 -13 -54 -476 0 49 475 0 107 475 0 -49 -107 -475 0 44 474 0 81 474 0 -44 -81 -474 0 39 473 0 60 473 0 -39 -60 -473 0 29 472 0 8 472 0 -8 -29 -472 0 24 471 0 102 471 0 -24 -102 -471 0 19 470 0 76 470 0 -19 -76 -470 0 14 469 0 55 469 0 -55 -469 -14 0 4 468 0 3 468 0 -3 -4 -468 0 -3 -403 0 -403 488 0 -403 489 0 -403 490 0 -403 491 0 -403 492 0 -403 493 0 -403 494 0 -403 495 0 -403 496 0 -403 497 0 -403 498 0 -124 -403 0 -403 499 0 -403 500 0 -403 501 0 -403 502 0 -403 503 0 -403 504 0 -403 505 0 -403 506 0 -403 507 0 -403 508 0 -403 509 0 -403 510 0 3 403 124 -488 -489 -490 -491 -492 -493 -494 -495 -496 -497 -498 -499 -500 -501 -502 -503 -504 -505 -506 -507 -508 -509 -510 0 118 510 0 122 510 0 -118 -122 -510 0 113 509 0 96 509 0 -96 -113 -509 0 508 108 0 70 508 0 -70 -108 -508 0 103 507 0 49 507 0 -49 -103 -507 0 98 506 0 23 506 0 -23 -98 -506 0 93 505 0 117 505 0 -93 -117 -505 0 88 504 0 91 504 0 -88 -91 -504 0 503 83 0 65 503 0 -65 -83 -503 0 78 502 0 44 502 0 -44 -78 -502 0 73 501 0 18 501 0 -18 -73 -501 0 500 68 0 112 500 0 -68 -112 -500 0 499 63 0 86 499 0 -63 -86 -499 0 498 58 0 39 498 0 -39 -58 -498 0 497 53 0 497 13 0 -13 -53 -497 0 48 496 0 107 496 0 -48 -107 -496 0 43 495 0 81 495 0 -43 -81 -495 0 494 38 0 60 494 0 -38 -60 -494 0 33 493 0 34 493 0 -33 -34 -493 0 28 492 0 8 492 0 -8 -28 -492 0 23 491 0 102 491 0 -23 -102 -491 0 18 490 0 76 490 0 -18 -76 -490 0 489 13 0 55 489 0 -13 -55 -489 0 8 488 0 29 488 0 -8 -29 -488 0 371 511 512 513 514 0 367 515 516 517 518 0 55 519 520 521 522 0 360 523 524 525 526 0 356 527 528 529 530 0 532 533 534 535 536 0 -536 -537 0 -536 -538 0 -536 -539 0 -536 -540 0 -356 -536 0 356 536 537 538 539 540 0 -535 -541 0 -535 -542 0 -535 -543 0 -360 -535 0 -535 -544 0 360 535 541 542 543 544 0 -3 -534 0 -29 -534 0 -55 -534 0 -76 -534 0 -102 -534 0 3 29 55 76 102 534 0 -533 -545 0 -367 -533 0 -533 -546 0 -533 -547 0 -533 -548 0 367 533 545 546 547 548 0 -371 -532 0 -532 -549 0 -532 -550 0 -532 -551 0 -532 -552 0 371 532 549 550 551 552 0 554 555 556 557 558 0 -98 -558 0 -104 -558 0 -110 -558 0 -116 -558 0 -122 -558 0 98 104 110 116 122 558 0 -73 -557 0 -79 -557 0 -85 -557 0 -91 -557 0 -97 -557 0 73 79 85 91 97 557 0 -53 -556 0 -59 -556 0 -124 -556 0 -66 -556 0 -72 -556 0 59 66 53 72 124 556 0 -28 -555 0 -34 -555 0 -40 -555 0 -46 -555 0 -52 -555 0 28 34 40 46 52 555 0 -3 -554 0 -9 -554 0 -15 -554 0 -21 -554 0 -27 -554 0 3 9 15 21 27 554 0 560 561 562 563 564 0 -564 565 0 -564 566 0 -564 567 0 -564 568 0 -564 569 0 -564 570 0 -564 571 0 -564 572 0 -564 573 0 -564 574 0 -564 575 0 -564 576 0 -564 577 0 -564 578 0 -564 579 0 -564 580 0 -564 581 0 -564 582 0 -564 583 0 -564 584 0 -564 585 0 -564 586 0 -564 587 0 -564 588 0 -564 589 0 564 -565 -566 -567 -568 -569 -570 -571 -572 -573 -574 -575 -576 -577 -578 -579 -580 -581 -582 -583 -584 -585 -586 -587 -588 -589 0 122 589 0 -122 589 0 117 588 0 -97 588 0 97 -117 -588 0 112 587 0 -72 587 0 72 -112 -587 0 107 586 0 -52 586 0 52 -107 -586 0 102 585 0 -27 585 0 27 -102 -585 0 97 584 0 -117 584 0 -97 117 -584 0 92 583 0 -92 583 0 87 582 0 -67 582 0 67 -87 -582 0 82 581 0 -47 581 0 47 -82 -581 0 77 580 0 -22 580 0 22 -77 -580 0 72 579 0 -112 579 0 -72 112 -579 0 67 578 0 -87 578 0 -67 87 -578 0 577 126 0 -126 577 0 62 576 0 -42 576 0 42 -62 -576 0 57 575 0 -17 575 0 17 -575 -57 0 52 574 0 -107 574 0 -52 107 -574 0 47 573 0 -82 573 0 -47 82 -573 0 42 572 0 -62 572 0 -42 62 -572 0 37 571 0 -37 571 0 32 570 0 -12 570 0 12 -32 -570 0 27 569 0 -102 569 0 -27 102 -569 0 22 568 0 -77 568 0 -22 77 -568 0 17 567 0 567 -57 0 -17 57 -567 0 12 566 0 -32 566 0 -12 32 -566 0 7 565 0 -7 565 0 -563 590 0 -563 591 0 -563 592 0 -563 593 0 -563 594 0 -563 595 0 -563 596 0 -563 597 0 -563 598 0 -563 599 0 -563 600 0 -563 601 0 -563 602 0 -563 603 0 -563 604 0 -563 605 0 -563 606 0 -563 607 0 -563 608 0 -563 609 0 -563 610 0 -563 611 0 -563 612 0 -563 613 0 -563 614 0 563 -590 -591 -592 -593 -594 -595 -596 -597 -598 -599 -600 -601 -602 -603 -604 -605 -606 -607 -608 -609 -610 -611 -612 -613 -614 0 121 614 0 -121 614 0 116 613 0 -96 613 0 96 -116 -613 0 111 612 0 -71 612 0 71 -111 -612 0 106 611 0 -51 611 0 51 -106 -611 0 101 610 0 -26 610 0 26 -101 -610 0 96 609 0 -116 609 0 -96 116 -609 0 91 608 0 -91 608 0 86 607 0 -66 607 0 66 -86 -607 0 81 606 0 -46 606 0 46 -81 -606 0 76 605 0 -21 605 0 21 -76 -605 0 71 604 0 -111 604 0 -71 111 -604 0 66 603 0 -86 603 0 -66 86 -603 0 602 125 0 -125 602 0 61 601 0 601 -41 0 41 -61 -601 0 56 600 0 -16 600 0 16 -56 -600 0 51 599 0 -106 599 0 -51 106 -599 0 46 598 0 -81 598 0 -46 81 -598 0 41 597 0 -61 597 0 61 -597 -41 0 36 596 0 -36 596 0 31 595 0 -11 595 0 11 -31 -595 0 26 594 0 -101 594 0 -26 101 -594 0 21 593 0 -76 593 0 -21 76 -593 0 16 592 0 -56 592 0 -16 56 -592 0 11 591 0 -31 591 0 -11 31 -591 0 6 590 0 -6 590 0 -562 615 0 -562 616 0 -562 617 0 -562 618 0 -562 619 0 -562 620 0 -562 621 0 -562 622 0 -562 623 0 -562 624 0 -562 625 0 -562 626 0 -562 627 0 -562 628 0 -562 629 0 -562 630 0 -562 631 0 -562 632 0 -562 633 0 -562 634 0 -562 635 0 -562 636 0 -562 637 0 -562 638 0 -562 639 0 562 -615 -616 -617 -618 -619 -620 -621 -622 -623 -624 -625 -626 -627 -628 -629 -630 -631 -632 -633 -634 -635 -636 -637 -638 -639 0 120 639 0 -120 639 0 115 638 0 -95 638 0 95 -115 -638 0 110 637 0 -70 637 0 70 -110 -637 0 105 636 0 -50 636 0 50 -105 -636 0 100 635 0 -25 635 0 25 -100 -635 0 95 634 0 -115 634 0 -95 115 -634 0 90 633 0 -90 633 0 85 632 0 -65 632 0 65 -85 -632 0 80 631 0 -45 631 0 45 -80 -631 0 75 630 0 -20 630 0 20 -75 -630 0 70 629 0 -110 629 0 -70 110 -629 0 65 628 0 -85 628 0 -65 85 -628 0 627 124 0 -124 627 0 60 626 0 -40 626 0 40 -60 -626 0 55 625 0 -15 625 0 15 -55 -625 0 50 624 0 -105 624 0 -50 105 -624 0 45 623 0 -80 623 0 -45 80 -623 0 40 622 0 -60 622 0 -40 60 -622 0 35 621 0 -35 621 0 30 620 0 -10 620 0 10 -30 -620 0 25 619 0 -100 619 0 -25 100 -619 0 20 618 0 -75 618 0 -20 75 -618 0 15 617 0 -55 617 0 -15 55 -617 0 10 616 0 -30 616 0 -10 30 -616 0 5 615 0 -5 615 0 -561 640 0 -561 641 0 -561 642 0 -561 643 0 -561 644 0 -561 645 0 -561 646 0 -561 647 0 -561 648 0 -561 649 0 -561 650 0 -561 651 0 -561 652 0 -561 653 0 -561 654 0 -561 655 0 -561 656 0 -561 657 0 -561 658 0 -561 659 0 -561 660 0 -561 661 0 -561 662 0 -561 663 0 -561 664 0 561 -640 -641 -642 -643 -644 -645 -646 -647 -648 -649 -650 -651 -652 -653 -654 -655 -656 -657 -658 -659 -660 -661 -662 -663 -664 0 119 664 0 -119 664 0 114 663 0 -94 663 0 94 -114 -663 0 109 662 0 -69 662 0 69 -109 -662 0 104 661 0 -49 661 0 49 -104 -661 0 99 660 0 -24 660 0 24 -99 -660 0 94 659 0 -114 659 0 -94 114 -659 0 89 658 0 -89 658 0 84 657 0 -64 657 0 64 -84 -657 0 79 656 0 -44 656 0 44 -79 -656 0 74 655 0 -19 655 0 19 -74 -655 0 69 654 0 -109 654 0 -69 109 -654 0 64 653 0 -84 653 0 -64 84 -653 0 652 123 0 -123 652 0 59 651 0 -39 651 0 39 -59 -651 0 54 650 0 650 -14 0 14 -54 -650 0 49 649 0 -104 649 0 -49 104 -649 0 44 648 0 -79 648 0 -44 79 -648 0 39 647 0 -59 647 0 -39 59 -647 0 34 646 0 -34 646 0 29 645 0 -9 645 0 9 -29 -645 0 24 644 0 -99 644 0 -24 99 -644 0 19 643 0 -74 643 0 -19 74 -643 0 14 642 0 -54 642 0 54 -642 -14 0 9 641 0 -29 641 0 -9 29 -641 0 4 640 0 -4 640 0 -560 665 0 -560 666 0 -560 667 0 -560 668 0 -560 669 0 -560 670 0 -560 671 0 -560 672 0 -560 673 0 -560 674 0 -560 675 0 -560 676 0 -560 677 0 -560 678 0 -560 679 0 -560 680 0 -560 681 0 -560 682 0 -560 683 0 -560 684 0 -560 685 0 -560 686 0 -560 687 0 -560 688 0 560 -665 -666 -667 -668 -669 -670 -671 -672 -673 -674 -675 -676 -677 -678 -679 -680 -681 -682 -683 -684 -685 -686 -687 -688 0 118 688 0 -118 688 0 113 687 0 -93 687 0 93 -113 -687 0 686 108 0 -68 686 0 -108 68 -686 0 103 685 0 -48 685 0 48 -103 -685 0 98 684 0 -23 684 0 23 -98 -684 0 93 683 0 -113 683 0 -93 113 -683 0 88 682 0 -88 682 0 681 83 0 -63 681 0 -83 63 -681 0 78 680 0 -43 680 0 43 -78 -680 0 73 679 0 -18 679 0 18 -73 -679 0 678 68 0 -108 678 0 -68 -678 108 0 677 63 0 -83 677 0 -63 -677 83 0 676 58 0 -38 676 0 -58 -676 38 0 675 53 0 -13 675 0 -53 -675 13 0 48 674 0 -103 674 0 -48 103 -674 0 43 673 0 -78 673 0 -43 78 -673 0 672 38 0 -58 672 0 -38 58 -672 0 33 671 0 -33 671 0 28 670 0 -8 670 0 8 -28 -670 0 23 669 0 -98 669 0 -23 98 -669 0 18 668 0 -73 668 0 -18 73 -668 0 667 13 0 -53 667 0 -13 53 -667 0 8 666 0 -28 666 0 -8 28 -666 0 3 665 0 -3 665 0 -55 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 0 118 -713 0 -102 -713 0 102 -118 713 0 113 -712 0 -101 -712 0 101 -113 712 0 -711 108 0 -100 -711 0 100 -108 711 0 103 -710 0 -99 -710 0 99 -103 710 0 98 -709 0 -98 -709 0 93 -708 0 -77 -708 0 77 -93 708 0 88 -707 0 -76 -707 0 76 -88 707 0 -706 83 0 -75 -706 0 75 -83 706 0 78 -705 0 -74 -705 0 74 -78 705 0 73 -704 0 -73 -704 0 -703 68 0 -703 -57 0 57 -68 703 0 -702 63 0 -56 -702 0 56 -63 702 0 -701 58 0 -54 -701 0 54 -58 701 0 -700 53 0 -53 -700 0 48 -699 0 -32 -699 0 32 -48 699 0 43 -698 0 -31 -698 0 31 -43 698 0 -697 38 0 -30 -697 0 30 -38 697 0 33 -696 0 -29 -696 0 29 -33 696 0 28 -695 0 -28 -695 0 23 -694 0 -7 -694 0 7 -23 694 0 18 -693 0 -6 -693 0 6 -18 693 0 -692 13 0 -5 -692 0 5 -13 692 0 8 -691 0 -4 -691 0 4 -8 691 0 3 -690 0 -3 -690 0 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 0 119 -739 0 -107 -739 0 107 -119 739 0 114 -738 0 -106 -738 0 106 -114 738 0 109 -737 0 -105 -737 0 105 -109 737 0 104 -736 0 -104 -736 0 99 -735 0 -103 -735 0 -99 103 735 0 94 -734 0 -82 -734 0 82 -94 734 0 89 -733 0 -81 -733 0 81 -89 733 0 84 -732 0 -80 -732 0 80 -84 732 0 79 -731 0 -79 -731 0 74 -730 0 -78 -730 0 -74 78 730 0 69 -729 0 -62 -729 0 62 -69 729 0 64 -728 0 -61 -728 0 61 -64 728 0 -727 123 0 -60 -727 0 60 -123 727 0 59 -726 0 -59 -726 0 54 -725 0 -58 -725 0 -54 725 58 0 49 -724 0 -37 -724 0 37 -49 724 0 44 -723 0 -36 -723 0 36 -44 723 0 39 -722 0 -35 -722 0 35 -39 722 0 34 -721 0 -34 -721 0 29 -720 0 -33 -720 0 -29 33 720 0 24 -719 0 -12 -719 0 12 -24 719 0 19 -718 0 -11 -718 0 11 -19 718 0 14 -717 0 -10 -717 0 10 717 -14 0 9 -716 0 -9 -716 0 4 -715 0 -8 -715 0 -4 8 715 0 741 743 742 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 0 120 -764 0 -112 -764 0 112 -120 764 0 115 -763 0 -111 -763 0 111 -115 763 0 110 -762 0 -110 -762 0 105 -761 0 -109 -761 0 -105 109 761 0 100 -760 0 -108 -760 0 -100 760 108 0 95 -759 0 -87 -759 0 87 -95 759 0 90 -758 0 -86 -758 0 86 -90 758 0 85 -757 0 -85 -757 0 80 -756 0 -84 -756 0 -80 84 756 0 75 -755 0 -83 -755 0 -75 755 83 0 70 -754 0 -126 -754 0 -70 754 126 0 65 -753 0 -125 -753 0 -65 753 125 0 -752 124 0 -124 -752 0 60 -751 0 -123 -751 0 -60 751 123 0 50 -750 0 -42 -750 0 42 -50 750 0 45 -749 0 -749 -41 0 41 -45 749 0 40 -748 0 -40 -748 0 35 -747 0 -39 -747 0 -35 39 747 0 30 -746 0 -38 -746 0 -30 746 38 0 25 -745 0 -17 -745 0 17 -25 745 0 20 -744 0 -16 -744 0 16 -20 744 0 15 -743 0 -15 -743 0 10 -742 0 -742 -14 0 -10 14 742 0 5 -741 0 -13 -741 0 -5 741 13 0 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 0 121 -790 0 -117 -790 0 117 -121 790 0 116 -789 0 -116 -789 0 111 -788 0 -115 -788 0 -111 115 788 0 106 -787 0 -114 -787 0 -106 114 787 0 101 -786 0 -113 -786 0 -101 113 786 0 96 -785 0 -92 -785 0 92 -96 785 0 91 -784 0 -91 -784 0 86 -783 0 -90 -783 0 -86 90 783 0 81 -782 0 -89 -782 0 -81 89 782 0 76 -781 0 -88 -781 0 -76 88 781 0 71 -780 0 -67 -780 0 67 -71 780 0 66 -779 0 -66 -779 0 -778 125 0 -65 -778 0 65 -125 778 0 61 -777 0 -64 -777 0 -61 64 777 0 56 -776 0 -63 -776 0 -56 776 63 0 51 -775 0 -47 -775 0 47 -51 775 0 46 -774 0 -46 -774 0 41 -773 0 -45 -773 0 45 773 -41 0 36 -772 0 -44 -772 0 -36 44 772 0 31 -771 0 -43 -771 0 -31 43 771 0 26 -770 0 -22 -770 0 22 -26 770 0 21 -769 0 -21 -769 0 16 -768 0 -20 -768 0 -16 20 768 0 11 -767 0 -19 -767 0 -11 19 767 0 6 -766 0 -18 -766 0 -6 18 766 0 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 0 122 -816 0 -122 -816 0 117 -815 0 -121 -815 0 -117 121 815 0 112 -814 0 -120 -814 0 -112 120 814 0 107 -813 0 -119 -813 0 -107 119 813 0 102 -812 0 -118 -812 0 -102 118 812 0 97 -811 0 -97 -811 0 92 -810 0 -96 -810 0 -92 96 810 0 87 -809 0 -95 -809 0 -87 95 809 0 82 -808 0 -94 -808 0 -82 94 808 0 77 -807 0 -93 -807 0 -77 93 807 0 72 -806 0 -72 -806 0 67 -805 0 -71 -805 0 -67 71 805 0 -804 126 0 -70 -804 0 70 -126 804 0 62 -803 0 -69 -803 0 -62 69 803 0 57 -802 0 -68 -802 0 802 -57 68 0 52 -801 0 -52 -801 0 47 -800 0 -51 -800 0 -47 51 800 0 42 -799 0 -50 -799 0 -42 50 799 0 37 -798 0 -49 -798 0 -37 49 798 0 32 -797 0 -48 -797 0 -32 48 797 0 27 -796 0 -27 -796 0 22 -795 0 -26 -795 0 -22 26 795 0 17 -794 0 -25 -794 0 -17 25 794 0 12 -793 0 -24 -793 0 -12 24 793 0 7 -792 0 -23 -792 0 -7 23 792 0 818 819 820 821 822 0 -272 -822 0 -268 -822 0 -264 -822 0 -260 -822 0 -227 -822 0 227 260 264 268 272 822 0 -271 -821 0 -267 -821 0 -263 -821 0 -231 -821 0 -256 -821 0 231 256 263 267 271 821 0 -270 -820 0 -266 -820 0 -15 -820 0 -259 -820 0 -255 -820 0 15 255 259 266 270 820 0 -269 -819 0 -238 -819 0 -262 -819 0 -258 -819 0 -254 -819 0 238 254 258 262 269 819 0 -242 -818 0 -265 -818 0 -261 -818 0 -257 -818 0 -253 -818 0 242 253 257 261 265 818 0 -5 -11 -18 -27 -29 -33 -47 -50 -59 -65 -71 -73 -80 -87 -91 -94 -101 -107 -110 -114 -118 0 -5 -11 -18 -27 -28 -35 -47 -49 -59 -65 -71 -74 -82 -85 -91 -93 -101 -103 -112 -114 -120 0 301 0 313 0 305 0 -300 0 741 0 135 0 opensmt-2.5.2/regression/state-dump/QG-classification_qg5_iso_brn644-split2.osmt2000066400000000000000000010450311445011647600277120ustar00rootroot00000000000000ñI¡õ¸õ ö}öŒö™¼‹‰€.ƒgîˆÑˆä…(j@fuj­$à‚ jô‚Í‚°‚ò~T-ß~öiâi…ko…a‚~{k@ˆ-:‚i~-uR…5…ÎiL~N‚'‚ ‚íÄi}~°iqk&~ ~ÆoÔ‡E2žœio’iÀ„ŠÃ}Tow~iG}Ao°}“}tiY}gkjip„ø€}C‡&‡]kÑ€ViôtS„Biª€Sk倾€½-8iÐ|.iIkä|½| |±‰±†Þƒid|i‹†Êƒ+€?kát·ƒ5k€òh?€èhûÞ |+k>|]4 |ð{Á\ì]abäÚXÕ>Õ$Õ ÕØÚÓoÓNÓ-Ó™¸¸…¸žS¸I¸?¸© ¸¸ù·OÇ·½·³·õœ·w·m·c·)ººíŸºã¹Ù¹“ŸÏ¹¹“¹9Ÿ‰¹W¹M¹C¹9¹¹ý¸ó¸ž¹»×¡¯»¥»s»}¡i»_»-»#»»»ÝºÓºÓ Éº—ººy ƒºÁ£I½?½5½½ù¼ï¼å¼³¼£©¼Ÿ¼m¼½¢c¼Y¼'¼c¢¼¼ËÚìÓßÓÒÓÓùÒm²Y²E²1²Rxå²Ñ²½²(y©²]³I³5³!³Õ³·zÁ³­³™³{M´9´%´´¾Ú ÔÔÔùÓßÒ{`zÄy y6{}záyoxS{šzEyŒxp{þyby©xÔzzyÆx±ÚTÔGÔ:Ô-ÔÅÒ•Úñ¹±¯±¥±i±_±U±K±±±û°ñ°µ°«°¡°—°3°°Ï¯¯“¯‰¯¯u¯Å¯»¯±¯§¯÷¯í¯ã¯Ù¯)°°° °ˆÚˆÔ{ÔnÔaÔŠÒB­/­­ ­7¦¶­£­­ §}­*®®®ñ­ž®œ¨‹®x®e®r©¯ÿ®ì®Ù®{Ú¼Ô¯Ô¢Ô•ÔpÒ6ªªü©ß©û–Òªµª˜ªÑ—{ªn«Q«4«« ¬ì˜í«Ð«³«Â™¦¬‰¬l¬O¬nÚðÔãÔÖÔÉÔVÒ«¦Ž¦q¦T¦d§G§*§ð¦¨ã§Æ§©§¹¨¨b¨E¨U©8©©þ¨aÚ@ڹјÑwÑVÑ+ž!žž žÑǽ³wmcY ÿœÃœ¹œ¯œ¥œ   ÷ŸãŸ±Ÿ§ŸŸ‰ŸWŸMŸCŸ/Ÿýžóžéžßž­ž£ž™ž…žë¡á¡Í¡Ã¡‘¡‡¡s¡i¡7¡-¡#¡¡ç Ý É ¿  ƒ o e Ë£·£­£££q£g£]£S£!£ ££ù¢Ç¢³¢©¢Ÿ¢m¢Y¢O¢E¢«¥¡¥—¥¥[¥Q¥G¥=¥3¥¥÷¤ã¤Ù¤§¤¤“¤‰¤¤M¤C¤9¤/¤%¤Kœ7œ#œœÓ›¿›«›—›[›G›3››ãšÏš»š§škšWšCš/š3Ú"ÑÑîÐÔкÐo—R—5——(˜ ˜î—´— ™Ï˜²˜•˜¥™ˆ™k™N™&ÚÒÒûÑ<Ñ ÐÚùÙDÐ#ÐÐáÏá×Íù‡}si_-#ӌɌ¿ŒµŒ«ŒyŒoŒeŒ[ŒQŒËÁ·­£qg]SI ùŽïŽ½Ž³Ž©ŽŸŽ•ŽcŽYŽOŽEŽ;Ž«‘¡‘—‘‘ƒ‘Q‘G‘=‘3‘)‘÷íÊJãÙ§“‰MC9/%•“‹““w“m“;“1“'“““á’×’Í’Ã’¹’‡’}’s’i’_’-’#’’’’•u•k•a•W•%••••ý”Ë”Á”­”£”q”g”]”S”I”” ””ù“ï“ØÙÏ‹²‹Ÿ‹•‹‚‹G‹4‹!‹‹ûŠÀŠ¶Š™Š†ŠKŠ8Š%ŠŠÿ‰Ä‰§‰”‰‰n‰’Ï ‰äˆÇˆ´ˆ¡ˆfˆSˆ6ˆ,ˆˆÞ‡Ê‡·‡¤‡‘‡V‡9‡‡ ‡ö†»†ž††n†[†¸Ùø…î…Ñ…Ç…´…y…e…H…+……Ê„„T¶„¬„z„f„I„6„#„èƒÔƒ­ƒšƒ‡ƒPÏ$ƒƒê‚¦‚k‚D‚‚‚㨔mZ=Û€´€ €€R€5€€ñÔ/ÏqJ#ü~Õ~š~s~V~9~~×}Í}¦}‰}l}'} }÷|Ú|³|n|Q|4|*||«Ù<Ò/Ò"Ò†Ð"Ï©w–wƒwpw]wJw7w$wwþv‘v~vkvXvEv2vv vùuæuyuSu@uuuÎtatNt;t(tttïsÜsÉs¶sIs6s#ssýrêr×rÄr±ržr röqãqÐq½qªq—q„qqq^qñpÞpËp¸p¥p’pplpYpFpÙo³o ozogo.oÁn®n›nˆnunbnOnHR\fpz„Ž˜¢¬¶ÀÊÔÞèòü$.8BLV`jt~ˆ’œ¦°ºÄÎØâìö (2<FPZdnx‚Œ– ª´¾ÈÒÜæðú",6@JT^hr|†š¤®¸ÂÌÖàêôþ&0:DNXblv€Š”ž¨²¼ÆÐÚäîø  * 4 > H R \ f p z „ Ž ˜ ¢ ¬ ¶ À Ê Ô Þ è ò ü    $ . 8 B L V ` j t ~ ˆ ’ œ ¦ ° º Ä Î Ø â ì ö   ( 2 < F P Z d n x ‚ Œ –   ª ´ ¾ È Ò Ü æ ð ú    " , 6 @ J T ^ h r | † š ¤ ® ¸ Â Ì Ö à ê ô þ    & 0 : D N X b l v € Š ” ž ¨ ² ¼ Æ Ð Ú ä î ø   *4>HR\fpz„Ž˜¢¬¶ÀÊÔÞèòü$.8BLV`jt~ˆ’œ¦°ºÄÎØâìö (2<FPZdnx‚Œ– ª´¾ÈÒÜæðú",6@JT^hr|†š¤®¸ÂÌÖàêôþ&0:DNXblv€Š”ž¨²¼ÆÐÚäîø  *4>HR\fpz„Ž˜¢¬¶ÀÊÔÞèòü$.8BLV`jt~ˆ’œ¦¯¸ÂËÕÞèñû  *3=FPZclv‰’œ¥¯¹ÂËÕÞèñû!*4=GPZcmw€‰’›¤­¶¿ÈÑÚãìõþ"+4=FOXajs|…Ž— ©²»ÄÍÖßèñú '09BKT]foxŠ“œ¥®·ÀÉÒÛäíöÿ#,5>GPYbkt}†˜¡ª³¼ÅÎ×àéòû#-7AKU_is}‡‘›¥¯¹ÃÍ×áëõÿ '1;EOYcmw‹•Ÿ©³½ÇÑÛåïù !+5?IS]gq{…™£­·ÁËÕßéóý%/9CMWaku‰“§±»ÅÏÙãí÷ )3=GQ[eoyƒ—¡«µ¿ÉÓÝçñû#-7AKU_is}‡‘›¥¯¹ÃÍ×áëõÿ   ' 1 ; E O Y c m w ‹ • Ÿ © ³ ½ Ç Ñ Û å ï ù ! !!!!+!5!?!I!S!]!g!q!{!…!!™!£!­!·!Á!Ë!Õ!ß!é!ó!ý!"""%"/"9"C"M"W"a"k"u""‰"“""§"±"»"Å"Ï"Ù"ã"í"÷"# ###'#1#;#D#N#X#b#k#u##‰#’#œ#¦#°#¹#Ã#Í#Ö#à#ê#ô#ý#$$$$$.$8$B$K$U$_$i$s$|$†$$™$£$­$·$À$Ê$Ô$Þ$ç$ñ$û$%%%"%,%6%?%I%S%\%f%p%z%ƒ%%—%¡%ª%´%¾%È%Ñ%Û%å%ï%ù%& &&&)&3&=&F&P&Z&d&m&w&&‹&”&ž&¨&²&¼&Å&Ï&Ù&ã&ì&ö&' '''''1':'D'N'X'a'k'u''ˆ'’'œ'¦'¯'¹'Ã'Í'Ö'à'ê'ô'þ'((($(.(8(B(L(U(_(i(s(|(†((š(¤(­(·(Á(Ê(Ô(Þ(è(ñ(û()))"),)6)@)J)S)])g)p)z)„)Ž)—)¡)«)µ)¾)È)Ò)Ü)æ)ð)ú)***"*,*6*@*J*T*^*h*r*|*†**š*¤*®*¸*Â*Ì*Ö*à*ê*ô*þ*+++&+0+:+D+N+X+b+l+v+€+Š+”+ž+¨+²+¼+Æ+Ð+Ú+ä+î+ø+, ,, ,*,4,>,H,R,\,f,p,z,„,Ž,˜,¢,¬,¶,À,Ê,Ó,Ý,ç,ð,ú,---!-+-5->-H-R-\-e-o-y-ƒ-Œ-–- -©-³-½-Ç-Ð-Ú-ä-î-÷-. ...(.2.<.F.O.Y.c.l.v.€.Š.“..§.±.º.Ä.Î.Ø.á.ë.õ.ÿ. ///&///9/C/M/V/`/j/t/}/‡/‘/›/¤/®/¸/Â/Ì/Õ/ß/é/ò/ü/000#0-070@0J0T0^0g0q0{0…00˜0¢0¬0µ0¿0É0Ó0Ü0æ0ð0ú01 11!1*141>1H1Q1[1e1n1x1‚1Œ1•1Ÿ1©1³1¼1Æ1Ð1Ú1ã1í1÷12 222(212;2E2O2X2b2l2v22‰2“22¦2°2º2Ä2Î2×2á2ë2ô2þ2333%3/393B3L3V3`3i3s3}3‡3‘3š3¤3®3·3Á3Ë3Õ3Þ3è3ò3ü3444#4,464@4J4S4]4g4p4z4„44—4¡4ª4´4¾4Ç4Ñ4Û4ä4î4ø45 555(525<5E5O5X5b5l5v55‰5“5œ5¦5°5º5Ã5Í5Ö5à5ê5ó5ý5666$6.686A6K6T6^6h6q6{6…6Ž6˜6¢6¬6¶6À6Ê6Ô6Þ6è6ò6ü6777$7.787B7L7V7`7j7t7~7ˆ7’7œ7¦7°7º7Ä7Î7Ø7â7ì7ö78 888(828<8F8P8Z8d8n8x8‚8Œ8–8 8ª8´8¾8È8Ò8Ü8æ8ð8ú8999"9,969@9J9T9^9h9r9|9†99š9¤9®9¸9Â9Ì9Ö9à9ê9ô9þ9:::&:0:::D:N:X:b:l:v:€:Š:”:ž:¨:²:¼:Æ:Ð:Ú:ä:î:ø:; ;; ;*;4;>;H;R;\;f;p;z;„;Ž;˜;¢;¬;¶;À;Ê;Ô;Þ;è;ò;ü;<<<$<.<8<B<L<V<`<j<t<~<ˆ<’<œ<¦<°<º<Ä<Î<Ø<â<ì<ö<= ===(=2=<=F=P=Z=d=n=x=‚=Œ=–= =ª=´=¾=È=Ò=Ü=æ=ð=ú=>>>">,>6>@>J>T>^>h>r>|>†>>š>¤>®>¸>Â>Ì>Ö>à>ê>ô>þ>???&?0?:?D?N?X?b?l?v?€?Š?”?ž?¨?²?¼?Æ?Ð?Ú?ä?î?ø?@ @@ @*@4@>@H@R@\@f@p@z@„@Ž@˜@¢@¬@¶@À@Ê@Ô@Þ@è@ò@ü@AAA$A.A8ABALAVA`AjAtA~AˆA’AœA¦A°AºAÄAÎAØAâAìAöAB BBB'B0B:BDBNBWBaBkBuB~BˆB’BœB¥B¯B¹BÃBÌBÖBàBêBóBýBCCC$C.C8CBCKCUC_ChCrC|C†CC™C£C­C·CÀCÊCÔCÞCèCñCûCDDD"D,D5D?DIDSD]DfDpDzD„DŽD—D¡D«D´D¾DÈDÒDÛDåDïDùDE EE E*E4E>EHERE\EfEpEzE„EŽE˜E¢E¬E¶EÀEÊEÔEÞEèEòEüEFFF$F.F8FBFLFVF`FjFtF~FˆF’FœF¦F°FºFÄFÎFØFâFìFöFG GGG(G2GJHJRJ\JfJpJzJ„JŽJ˜J¢J¬J¶JÀJÊJÔJÞJèJòJüJKKK$K.K8KBKLKVK`KjKtK~KˆK’KœK¦K°KºKÄKÎKØKâKìKöKL LLL(L2LOHORO\OfOpOzO„OŽO˜O¢O¬O¶OÀOÊOÔOÞOèOòOüOPPP$P.P8PBPLPVP`PjPtP~PˆP’PœP¦P°PºPÄPÎPØPâPìPöPQ QQQ(Q2QTHTRT\TfTpTzT„TŽT˜T¢T¬T¶TÀTÊTÔTÞTèTòTüTUUU$U.U8UBULUVU`UjUtU~UˆU’UœU¦U°UºUÄUÎUØUâUìUöUV VVV(V2VYHYRY\YfYpYzY„YŽY˜Y¢Y¬Y¶YÀYÊYÔYÞYèYòYüYZZZ$Z.Z8ZBZLZVZ`ZjZtZ~Z‡Z‘ZšZ¤Z®Z·ZÁZËZÔZÞZèZñZûZ[[["[+[5[?[H[R[\[e[o[y[‚[Œ[–[Ÿ[©[²[¼[Æ[Ï[Ù[ã[ì[ö[\ \\\&\0\:\C\M\W\`\j\t\}\‡\‘\š\¤\®\¸\Á\Ë\Ô\Þ\è\ñ\û\]]]"]+]5]?]H]R]\]e]o]y]‚]Œ]–]Ÿ]©]³]¼]Æ]Ð]Ú]ã]í]ö]^ ^^^'^0^:^D^M^W^a^j^t^~^‡^‘^›^¤^®^¸^Á^Ë^Õ^Þ^è^ò^ü^___"_,_5_?_I_R_\_f_o_y_ƒ_Œ_–_ _©_³_½_Æ_Ð_Ú_ã_í_÷_` ```'`1`:`D`N`W`a`k`t`~`ˆ`‘`›`¥`®`¸`Â`Ë`Õ`ß`è`ò`ü`aaa"a,a6a?aIaRa\afaoayaƒaŒa–a a©a³a½aÆaÐaÚaãaía÷ab bbb'b1b:bDbNbXbabkbtb~bˆb‘b›b¥b®b¸bÂbËbÕbßbèbòbübccc"c,c6c?cIcSc\cfcpczcƒcc–c cªc³c½cÇcÐcÚcäcíc÷cd ddd'd1d;dDdNdXdadkdud~dˆd’dœd¥d¯d¸dÂdÌdÕdßdédòdüdeee#e,e6e@eIeSe]efepezeƒee—e eªe´e¾eÈeÑeÛeäeîeøef fff(f2f;fEfOfXfbflfuff‰f’fœf¦f¯f¹fÃfÌfÖfàfêfôfþfggg&g0g:gDgNgXgbglgvg€gŠg”gžg¨g²g¼gÆgÐgÚgägíg÷gh hhh)h3h=hGhQh[hehohyhƒhh—h¡h«hµh¾hÞhèhòhühiii$i.i8iBiLiVi`ijiti~iˆi’iœi¦i°iºiÄiÎiØiâiìiöij jjj(j2jxHxRx\xexoxyx‚xŒx–xŸx©x³x¼xÆxÐxÙxãxíx÷xy yyy(y2y;yEyOyXybylyuyy‰y’yœy¦y°yºyÄyÎy×yáyëyôyþyzzz%z.z8zBzLzVz`zjzsz}z‡zzšz¤z­z·zÁzÊzÔzÞzçzñzûz{{{#{,{6{@{I{S{]{f{p{z{ƒ{{—{ {ª{´{¾{È{Ò{Ü{æ{ð{ú{| || |*|4|>|H|Q|[|d|n|x|‚|Œ|–| |ª|³|½|Ç|Ð|Ú|ä|î|÷|} }}}'}1};}E}O}Y}c}l}v}}‰}“}}¦}°}º}Ã}Í}×}á}ë}õ}ÿ} ~~~&~0~9~C~L~V~`~i~s~}~‡~~š~¤~®~¸~Â~Ì~Õ~ß~é~ò~ü~#-7@JT^gq{…™£­·ÁËÔÞèñû€€€"€+€5€?€I€R€\€f€p€z€„€€—€ €ª€´€¾€È€Ñ€Û€å€ï€ø€  *4=GQZdmwŠ”ž¨²¼ÆÐÚãí÷‚ ‚‚‚'‚1‚:‚D‚N‚X‚a‚k‚u‚‚‰‚“‚‚¦‚°‚º‚Âׂ͂à‚ê‚ô‚þ‚ƒƒƒ$ƒ.ƒ8ƒBƒLƒVƒ`ƒjƒtƒ~ƒ‡ƒ‘ƒšƒ¤ƒ­ƒ·ƒÁƒÊƒÔƒÞƒèƒòƒüƒ„„„#„-„6„@„I„S„]„f„p„z„„„Ž„˜„¢„¬„¶„À„Ê„Ô„Ý„ç„ñ„û„………"…+…5…?…H…R…\…e…o…y…ƒ……—…¡…«…´…¾…Ç…Ñ…Û…ä…î…ø…† †† †*†4†>†H†R†[†e†n†x††‹†•†ž†¨†±†»†Å†Ï†Ù†ã†í†ö†‡ ‡‡‡&‡0‡9‡C‡M‡V‡`‡j‡t‡~‡ˆ‡‘‡›‡¤‡®‡·‡Á‡Ê‡Ô‡Þ‡è‡ò‡ü‡ˆˆˆ#ˆ,ˆ6ˆ@ˆJˆSˆ]ˆfˆpˆzˆ„ˆŽˆ˜ˆ¡ˆ«ˆ´ˆ¾ˆÇˆÑˆÛˆäˆîˆøˆ‰ ‰‰‰)‰3‰=‰G‰Q‰[‰e‰n‰x‰‰‹‰”‰ž‰§‰±‰»‰Ä‰Î‰Ø‰â‰ì‰ö‰ÿ‰ ŠŠŠ%Š/Š8ŠBŠKŠUŠ_ŠiŠsŠ}Š†ŠŠ™Š£Š­Š¶ŠÀŠÊŠÔŠÞŠèŠòŠûŠ‹‹‹!‹+‹4‹>‹G‹Q‹[‹e‹o‹y‹‚‹Œ‹•‹Ÿ‹©‹²‹¼‹Æ‹Ï‹Ù‹ã‹í‹÷‹Œ ŒŒŒ)Œ3Œ=ŒGŒQŒ[ŒeŒoŒyŒƒŒŒ—Œ¡Œ«ŒµŒ¿ŒÉŒÓŒÝŒçŒñŒûŒ#-7AKU_is}‡‘›¥¯¹ÃÍ×áëõÿ ŽŽŽ'Ž1Ž;ŽEŽOŽYŽcŽmŽwŽŽ‹Ž•ŽŸŽ©Ž³Ž½ŽÇŽÑŽÛŽåŽïŽùŽ !+5?IS]gq{…™£­·ÁËÕßéóý%/9CMWaku‰“§±»ÅÏÙãí÷‘ ‘‘‘)‘3‘=‘G‘Q‘[‘e‘o‘y‘ƒ‘‘—‘¡‘«‘µ‘¿‘É‘Ó‘Ý‘ç‘ñ‘û‘’’’#’-’7’A’K’U’_’i’s’}’‡’‘’›’¥’¯’¹’Ã’Í’×’á’ë’õ’ÿ’ “““'“1“;“E“O“Y“c“m“w““‹“•“Ÿ“©“³“½“Ç“Ñ“Û“å“ï“ù“” ””!”+”5”?”I”S”]”g”q”{”…””™”£”­”·”Á”˔Քߔé”ó”ý”•••%•/•9•C•M•W•a•k•u••‰•“••§•±•»•Å•Ï•Ù•ã•í•÷•– –––)–3–=–G–Q–[–e–o–y–ƒ––—–¡–«–µ–¿–É–Ó–Ý–ç–ñ–û–———"—+—5—?—H—R—\—e—o—y—‚—Œ—–— —ª—´—¾—Ç—Ñ—Û—ä—î—ø—˜ ˜˜˜(˜2˜;˜E˜O˜Y˜c˜m˜w˜˜‹˜•˜Ÿ˜¨˜²˜¼˜Å˜Ï˜Ù˜â˜ì˜ö˜ÿ˜ ™™™&™0™:™D™N™X™a™k™u™~™ˆ™’™›™¥™¯™¸™Â™Ì™Õ™ß™é™ó™ý™ššš%š/š9šCšMšWšaškšušš‰š“šš§š±š»šÅšÏšÙšãšíš÷š› ›››)›3›=›G›Q›[›e›o›y›ƒ››—›¡›«›µ›¿›É›Ó›Ý›ç›ñ›û›œœœ#œ-œ7œAœKœUœ_œiœsœ}œ‡œ‘œ›œ¥œ¯œ¹œÃœÍœ×œáœëœõœÿœ '1;EOYcmw‹•Ÿ©³½ÇÑÛåïùž žž!ž+ž5ž?žIžSž]žgžqž{ž…žž™ž£ž­ž·žÁžËžÕžßžéžóžýžŸŸŸ%Ÿ/Ÿ9ŸCŸMŸWŸaŸkŸuŸŸ‰Ÿ“ŸŸ§Ÿ±Ÿ»ŸÅŸÏŸÙŸãŸíŸ÷Ÿ     ) 3 = G Q [ e o y ƒ  — ¡ « µ ¿ É Ó Ý ç ñ û ¡¡¡#¡-¡7¡A¡K¡U¡_¡i¡s¡}¡‡¡‘¡›¡¥¡¯¡¹¡Ã¡Í¡×¡á¡ë¡õ¡ÿ¡ ¢¢¢'¢1¢;¢E¢O¢Y¢c¢m¢w¢¢‹¢•¢Ÿ¢©¢³¢½¢Ç¢Ñ¢Û¢å¢ï¢ù¢£ ££!£+£5£?£I£S£]£g£q£{£…££™£££­£·£Á£Ë£Õ£ß£é£ó£ý£¤¤¤%¤/¤9¤C¤M¤W¤a¤k¤u¤¤‰¤“¤¤§¤±¤»¤Å¤Ï¤Ù¤ã¤í¤÷¤¥ ¥¥¥)¥3¥=¥G¥Q¥[¥e¥o¥y¥ƒ¥¥—¥¡¥«¥µ¥¿¥É¥Ó¥Ý¥ç¥ñ¥û¥¦¦¦#¦-¦7¦A¦J¦T¦^¦g¦q¦{¦„¦Ž¦˜¦¡¦«¦µ¦¾¦È¦Ò¦Ü¦æ¦ð¦ú¦§ §§ §*§4§=§G§Q§Z§d§n§w§§‹§•§Ÿ§©§³§¼§Æ§Ð§Ù§ã§í§ö§¨ ¨¨¨'¨1¨;¨E¨O¨X¨b¨l¨u¨¨‰¨’¨œ¨¦¨¯¨¹¨Ã¨Ì¨Ö¨à¨ê¨ô¨þ¨©©©%©.©8©B©K©U©_©h©r©|©…©©™©£©­©·©Á©Ë©Õ©ß©é©ò©ü©ªªª#ª,ª6ª@ªIªSª]ªgªqª{ª…ªŽª˜ª¢ª«ªµª¿ªÈªÒªÜªåªïªùª« ««!«*«4«>«G«Q«[«d«n«x««‹«•«Ÿ«©«³«½«Æ«Ð«Ú«ã«í«÷«¬ ¬¬¬'¬1¬;¬E¬O¬Y¬b¬l¬v¬¬‰¬“¬œ¬¦¬°¬¹¬Ã¬Í¬×¬á¬ë¬õ¬ÿ¬ ­­­&­/­9­B­L­U­_­i­s­}­‡­­š­£­­­¶­À­É­Ó­Ý­ç­ñ­û­®®®!®*®4®=®G®Q®[®e®o®x®‚®‹®•®ž®¨®±®»®Å®Ï®Ù®ã®ì®ö®ÿ® ¯¯¯%¯/¯9¯C¯M¯W¯a¯k¯u¯¯‰¯“¯¯§¯±¯»¯Å¯Ï¯Ù¯ã¯í¯÷¯° °°°)°3°=°G°Q°[°e°o°y°ƒ°°—°¡°«°µ°¿°É°Ó°Ý°ç°ñ°û°±±±#±-±7±A±K±U±_±i±s±}±‡±‘±›±¥±¯±¹±Ã±Í±×±á±ë±õ±ÿ± ²²²'²1²;²E²O²Y²c²m²w²²‹²•²Ÿ²©²³²½²Ç²Ñ²Û²å²ï²ù²³ ³³!³+³5³?³I³S³]³g³q³{³…³³™³£³­³·³Á³Ë³Õ³ß³é³ó³ý³´´´%´/´9´C´M´W´a´k´u´´‰´“´´§´±´»´Å´Ï´Ù´ã´í´÷´µ µµµ)µ3µ=µGµQµ[µeµoµyµƒµµ—µ µ©µ²µ»µÅµÏµÙµãµìµõµþµ¶¶¶%¶/¶8¶A¶J¶S¶]¶g¶q¶{¶„¶¶–¶Ÿ¶©¶³¶½¶Ç¶Ð¶Ù¶â¶ë¶õ¶ÿ¶ ···'·1·;·E·O·Y·c·m·w··‹·•·Ÿ·©·³·½·Ç·Ñ·Û·å·ï·ù·¸ ¸¸!¸+¸5¸?¸I¸S¸]¸g¸q¸{¸…¸¸™¸£¸­¸·¸Á¸Ë¸Õ¸ß¸é¸ó¸ý¸¹¹¹%¹/¹9¹C¹M¹W¹a¹k¹u¹¹‰¹“¹¹§¹±¹»¹Å¹Ï¹Ù¹ã¹í¹÷¹º ººº)º3º=ºGºQº[ºeºoºyºƒºº—º¡º«ºµº¿ºÉºÓºÝºçºñºûº»»»#»-»7»A»K»U»_»i»s»}»‡»‘»›»¥»¯»¹»Ã»Í»×»á»ë»õ»ÿ» ¼¼¼'¼1¼;¼E¼O¼Y¼c¼m¼w¼¼‹¼•¼Ÿ¼©¼³¼½¼Ç¼Ñ¼Û¼å¼ï¼ù¼½ ½½!½+½5½?½I½S½]½g½q½{½…½½™½£½­½·½Á½Ë½Õ½ß½é½ó½ý½¾¾¾%¾/¾9¾C¾M¾W¾a¾k¾u¾¾‰¾“¾¾§¾±¾»¾Å¾Ï¾Ù¾ã¾í¾÷¾¿ ¿¿¿)¿3¿=¿G¿Q¿[¿e¿o¿y¿ƒ¿¿—¿¡¿«¿µ¿¿¿É¿Ó¿Ý¿ç¿ñ¿û¿ÀÀÀ#À-À7ÀAÀKÀUÀ_ÀiÀsÀ}À‡À‘À›À¥À¯À¹ÀÃÀÍÀ×ÀáÀëÀõÀÿÀ ÁÁÁ'Á1Á;ÁEÁOÁYÁcÁmÁwÁÁ‹Á•ÁŸÁ©Á³Á½ÁÇÁÑÁÛÁåÁïÁùÁ ÂÂ!Â+Â5Â?ÂIÂSÂ]ÂgÂqÂ{…™£­·ÂÁÂËÂÕÂßÂéÂóÂýÂÃÃÃ%Ã/Ã9ÃCÃMÃWÃaÃkÃuÃÉÓÃçñûÃÅÃÏÃÙÃãÃíÃ÷ÃÄ ÄÄÄ)Ä3Ä=ÄGÄQÄ[ÄeÄoÄyăÄėġīĵĿÄÉÄÓÄÝÄçÄñÄûÄÅÅÅ#Å-Å7ÅAÅKÅUÅ_ÅiÅsÅ}ŇőśťůŹÅÃÅÍÅ×ÅáÅëÅõÅÿÅ ÆÆÆ'Æ1Æ;ÆEÆOÆYÆcÆmÆwÆƋƕƟƩƳƽÆÇÆÑÆÛÆåÆïÆùÆÇ ÇÇ!Ç+Ç5Ç?ÇIÇSÇ]ÇgÇqÇ{Ç…ÇǙǣǭǷÇÁÇËÇÕÇßÇéÇóÇýÇÈÈÈ%È/È9ÈCÈMÈWÈaÈkÈuÈȉȓÈȧȱȻÈÅÈÏÈÙÈãÈíÈ÷ÈÉ ÉÉÉ)É3É=ÉGÉQÉ[ÉeÉoÉyɃÉɗɡɫɵɿÉÉÉÓÉÝÉçÉñÉûÉÊÊÊ#Ê-Ê7ÊAÊKÊUÊ_ÊiÊsÊ}ʇʑʛʥʯʹÊÃÊÍÊ×ÊáÊëÊõÊÿÊ ËËË'Ë1Ë;ËEËOËYËcËmËwËˋ˕˟˩˳˽ËÇËÑËÛËåËïËùËÌ ÌÌ!Ì+Ì5Ì?ÌIÌSÌ]ÌgÌqÌ{Ì…Ì̷̙̣̭ÌÁÌËÌÕÌßÌéÌóÌýÌÍÍÍ%Í/Í9ÍCÍMÍWÍaÍkÍuÍ͉͓ÍͧͱͻÍÅÍÏÍÙÍãÍíÍ÷ÍÎ ÎÎ5ÎÏ"Ï/ÏPÏqϒϳÏÔÏáÏÐ#ÐDÐeІГРЭкÐÇÐÔÐáÐîÐûÐÑÑ"Ñ/Ñ<ÑIÑVÑwјѹÑÚÑûÑÒÒ"Ò/Ò<ÒIÒVÒcÒpÒ}ÒŠÒ—Ò¸ÒÅÒÒÒßÒìÒùÒÓÓ Ó-ÓNÓoÓÓ±ÓÒÓßÓìÓùÓÔÔ Ô-Ô:ÔGÔTÔaÔnÔ{ÔˆÔ•Ô¢Ô¯Ô¼ÔÉÔÖÔãÔðÔýÔ ÕÕ$Õ1Õ>ÕKÕXÕeÕrÕՌՙզճÕÀÕÍÕÚÕçÕôÕÖÖÖ(Ö5ÖBÖOÖ\ÖiÖvÖƒÖÖÖªÖ·ÖÄÖÑÖÞÖëÖøÖ×××,×9×F×S×`×m×zׇהס׮׻×È×Õ×â×ï×ü× ØØ#Ø0Ø=ØJØWØdØqØ~؋ؘإزؿØÌØÙØæØóØÙ ÙÙ7ÙTÙaÙ}ن٢٫ٸÙØÙùÙÚ&Ú3Ú@ÚaÚnÚ{ÚˆÚ•Ú±Ú¾ÚËÚØÚäÚðÚÐÛÌÛPZÿÿÿÿÿÿÿÿÿÿÿÿdÿÿÿÿÿÿ€Sÿÿÿÿÿÿaÿÿÿÿÿÿ"€Sÿÿÿÿÿÿ*"^ÿÿÿÿÿÿ4€Sÿÿÿÿÿÿ<4[ÿÿÿÿÿÿF€ SÿÿÿÿÿÿNF XÿÿÿÿÿÿX€ Sÿÿÿÿÿÿ`X€ Sÿÿÿÿÿÿj"€ Sÿÿÿÿÿÿt""€Sÿÿÿÿÿÿ~"4€Sÿÿÿÿÿÿˆ"F€Sÿÿÿÿÿÿ’"X€Sÿÿÿÿÿÿœ4€Sÿÿÿÿÿÿ¦4"€Sÿÿÿÿÿÿ°44€Sÿÿÿÿÿÿº4F€SÿÿÿÿÿÿÄ4X€SÿÿÿÿÿÿÎF€SÿÿÿÿÿÿØF"€SÿÿÿÿÿÿâF4€SÿÿÿÿÿÿìFF€SÿÿÿÿÿÿöFX€SÿÿÿÿÿÿX€Sÿÿÿÿÿÿ X"€SÿÿÿÿÿÿX4€SÿÿÿÿÿÿXF€Sÿÿÿÿÿÿ(XX€ >ÿÿÿÿÿÿ2€!>ÿÿÿÿÿÿ<"€"ÿÿÿÿÿÿF2<€#>ÿÿÿÿÿÿP4€$ÿÿÿÿÿÿZFP€%>ÿÿÿÿÿÿdF€&ÿÿÿÿÿÿnZd€'>ÿÿÿÿÿÿxX€(ÿÿÿÿÿÿ‚nx€)>ÿÿÿÿÿÿŒ*€*>ÿÿÿÿÿÿ–"*€+ÿÿÿÿÿÿ Œ–€,>ÿÿÿÿÿÿª*4€-ÿÿÿÿÿÿ´ ª€.>ÿÿÿÿÿÿ¾*F€/ÿÿÿÿÿÿÈ´¾€0>ÿÿÿÿÿÿÒ*X€1ÿÿÿÿÿÿÜÈÒ€2ÿÿÿÿÿÿæ‚Ü€3>ÿÿÿÿÿÿð<€4>ÿÿÿÿÿÿú"<€5ÿÿÿÿÿÿðú€6>ÿÿÿÿÿÿ4<€7ÿÿÿÿÿÿ€8>ÿÿÿÿÿÿ"<F€9ÿÿÿÿÿÿ,"€:>ÿÿÿÿÿÿ6<X€;ÿÿÿÿÿÿ@,6€<ÿÿÿÿÿÿJæ@€=>ÿÿÿÿÿÿTN€>>ÿÿÿÿÿÿ^"N€?ÿÿÿÿÿÿhT^€@>ÿÿÿÿÿÿr4N€Aÿÿÿÿÿÿ|hr€B>ÿÿÿÿÿÿ†FN€Cÿÿÿÿÿÿ|†€D>ÿÿÿÿÿÿšNX€Eÿÿÿÿÿÿ¤š€Fÿÿÿÿÿÿ®J¤€G>ÿÿÿÿÿÿ¸`€H>ÿÿÿÿÿÿÂ"`€Iÿÿÿÿÿÿ̸€J>ÿÿÿÿÿÿÖ4`€KÿÿÿÿÿÿàÌÖ€L>ÿÿÿÿÿÿêF`€Mÿÿÿÿÿÿôàê€N>ÿÿÿÿÿÿþX`€Oÿÿÿÿÿÿôþ€Pÿÿÿÿÿÿ®€Q>ÿÿÿÿÿÿj€R>ÿÿÿÿÿÿ&"j€Sÿÿÿÿÿÿ0&€T>ÿÿÿÿÿÿ:4j€UÿÿÿÿÿÿD0:€V>ÿÿÿÿÿÿNFj€WÿÿÿÿÿÿXDN€X>ÿÿÿÿÿÿbXj€YÿÿÿÿÿÿlXb€Z>ÿÿÿÿÿÿvt€[>ÿÿÿÿÿÿ€"t€\ÿÿÿÿÿÿŠv€€]>ÿÿÿÿÿÿ”4t€^ÿÿÿÿÿÿžŠ”€_>ÿÿÿÿÿÿ¨Ft€`ÿÿÿÿÿÿ²ž¨€a>ÿÿÿÿÿÿ¼Xt€bÿÿÿÿÿÿƲ¼€cÿÿÿÿÿÿÐlÆ€d>ÿÿÿÿÿÿÚ~€e>ÿÿÿÿÿÿä"~€fÿÿÿÿÿÿîÚä€g>ÿÿÿÿÿÿø4~€hÿÿÿÿÿÿîø€i>ÿÿÿÿÿÿ F~€jÿÿÿÿÿÿ €k>ÿÿÿÿÿÿ X~€lÿÿÿÿÿÿ* €mÿÿÿÿÿÿ4Ð*€n>ÿÿÿÿÿÿ>ˆ€o>ÿÿÿÿÿÿH"ˆ€pÿÿÿÿÿÿR>H€q>ÿÿÿÿÿÿ\4ˆ€rÿÿÿÿÿÿfR\€s>ÿÿÿÿÿÿpFˆ€tÿÿÿÿÿÿzfp€u>ÿÿÿÿÿÿ„Xˆ€vÿÿÿÿÿÿŽz„€wÿÿÿÿÿÿ˜4Ž€x>ÿÿÿÿÿÿ¢’€y>ÿÿÿÿÿÿ¬"’€zÿÿÿÿÿÿ¶¢¬€{>ÿÿÿÿÿÿÀ4’€|ÿÿÿÿÿÿʶÀ€}>ÿÿÿÿÿÿÔF’€~ÿÿÿÿÿÿÞÊÔ€>ÿÿÿÿÿÿèX’€€ÿÿÿÿÿÿòÞè€ÿÿÿÿÿÿü˜ò€‚ÿÿÿÿÿÿü€ƒ>ÿÿÿÿÿÿœ€„>ÿÿÿÿÿÿ"œ€…ÿÿÿÿÿÿ$€†>ÿÿÿÿÿÿ.4œ€‡ÿÿÿÿÿÿ8$.€ˆ>ÿÿÿÿÿÿBFœ€‰ÿÿÿÿÿÿL8B€Š>ÿÿÿÿÿÿVXœ€‹ÿÿÿÿÿÿ`LV€Œ>ÿÿÿÿÿÿj¦€>ÿÿÿÿÿÿt"¦€Žÿÿÿÿÿÿ~jt€>ÿÿÿÿÿÿˆ4¦€ÿÿÿÿÿÿ’~ˆ€‘>ÿÿÿÿÿÿœF¦€’ÿÿÿÿÿÿ¦’œ€“>ÿÿÿÿÿÿ°X¦€”ÿÿÿÿÿÿº¦°€•ÿÿÿÿÿÿÄ`º€–>ÿÿÿÿÿÿΰ€—>ÿÿÿÿÿÿØ"°€˜ÿÿÿÿÿÿâÎØ€™>ÿÿÿÿÿÿì4°€šÿÿÿÿÿÿöâ쀛>ÿÿÿÿÿÿF°€œÿÿÿÿÿÿ ö€>ÿÿÿÿÿÿX°€žÿÿÿÿÿÿ €Ÿÿÿÿÿÿÿ(Ä€ >ÿÿÿÿÿÿ2º€¡>ÿÿÿÿÿÿ<"º€¢ÿÿÿÿÿÿF2<€£>ÿÿÿÿÿÿP4º€¤ÿÿÿÿÿÿZFP€¥>ÿÿÿÿÿÿdFº€¦ÿÿÿÿÿÿnZd€§>ÿÿÿÿÿÿxXº€¨ÿÿÿÿÿÿ‚nx€©ÿÿÿÿÿÿŒ(‚€ª>ÿÿÿÿÿÿ–Ä€«>ÿÿÿÿÿÿ "Ä€¬ÿÿÿÿÿÿª– €­>ÿÿÿÿÿÿ´4Ä€®ÿÿÿÿÿÿ¾ª´€¯>ÿÿÿÿÿÿÈFÄ€°ÿÿÿÿÿÿҾȀ±>ÿÿÿÿÿÿÜXÄ€²ÿÿÿÿÿÿæÒÜ€³ÿÿÿÿÿÿðŒæ€´ÿÿÿÿÿÿúð€µ>ÿÿÿÿÿÿ΀¶>ÿÿÿÿÿÿ"΀·ÿÿÿÿÿÿ€¸>ÿÿÿÿÿÿ"4΀¹ÿÿÿÿÿÿ,"€º>ÿÿÿÿÿÿ6F΀»ÿÿÿÿÿÿ@,6€¼>ÿÿÿÿÿÿJX΀½ÿÿÿÿÿÿT@J€¾>ÿÿÿÿÿÿ^Ø€¿>ÿÿÿÿÿÿh"Ø€Àÿÿÿÿÿÿr^h€Á>ÿÿÿÿÿÿ|4Ø€Âÿÿÿÿÿÿ†r|€Ã>ÿÿÿÿÿÿFØ€Äÿÿÿÿÿÿš†€Å>ÿÿÿÿÿÿ¤XØ€Æÿÿÿÿÿÿ®š¤€Çÿÿÿÿÿÿ¸T®€È>ÿÿÿÿÿÿÂâ€É>ÿÿÿÿÿÿÌ"â€ÊÿÿÿÿÿÿÖÂÌ€Ë>ÿÿÿÿÿÿà4â€ÌÿÿÿÿÿÿêÖà€Í>ÿÿÿÿÿÿôFâ€Îÿÿÿÿÿÿþêô€Ï>ÿÿÿÿÿÿXâ€Ðÿÿÿÿÿÿþ€Ñÿÿÿÿÿÿ¸€Ò>ÿÿÿÿÿÿ&ì€Ó>ÿÿÿÿÿÿ0"ì€Ôÿÿÿÿÿÿ:&0€Õ>ÿÿÿÿÿÿD4ì€ÖÿÿÿÿÿÿN:D€×>ÿÿÿÿÿÿXFì€ØÿÿÿÿÿÿbNX€Ù>ÿÿÿÿÿÿlXì€Úÿÿÿÿÿÿvbl€Ûÿÿÿÿÿÿ€v€Ü>ÿÿÿÿÿÿŠö€Ý>ÿÿÿÿÿÿ”"ö€ÞÿÿÿÿÿÿžŠ”€ß>ÿÿÿÿÿÿ¨4ö€àÿÿÿÿÿÿ²ž¨€á>ÿÿÿÿÿÿ¼Fö€âÿÿÿÿÿÿƲ¼€ã>ÿÿÿÿÿÿÐXö€äÿÿÿÿÿÿÚÆЀåÿÿÿÿÿÿä€Ú€æÿÿÿÿÿÿîúä€ç>ÿÿÿÿÿÿø€è>ÿÿÿÿÿÿ "€éÿÿÿÿÿÿ ø €ê>ÿÿÿÿÿÿ 4€ëÿÿÿÿÿÿ  €ì>ÿÿÿÿÿÿ* F€íÿÿÿÿÿÿ4 * €î>ÿÿÿÿÿÿ> X€ïÿÿÿÿÿÿH 4 > €ð>ÿÿÿÿÿÿR  €ñ>ÿÿÿÿÿÿ\ " €òÿÿÿÿÿÿf R \ €ó>ÿÿÿÿÿÿp 4 €ôÿÿÿÿÿÿz f p €õ>ÿÿÿÿÿÿ„ F €öÿÿÿÿÿÿŽ z „ €÷>ÿÿÿÿÿÿ˜ X €øÿÿÿÿÿÿ¢ Ž ˜ €ùÿÿÿÿÿÿ¬ H ¢ €ú>ÿÿÿÿÿÿ¶ €û>ÿÿÿÿÿÿÀ "€üÿÿÿÿÿÿÊ ¶ À €ý>ÿÿÿÿÿÿÔ 4€þÿÿÿÿÿÿÞ Ê Ô €ÿ>ÿÿÿÿÿÿè F€ÿÿÿÿÿÿò Þ è €>ÿÿÿÿÿÿü X€ÿÿÿÿÿÿ ò ü €ÿÿÿÿÿÿ ¬  €>ÿÿÿÿÿÿ €>ÿÿÿÿÿÿ$ "€ÿÿÿÿÿÿ.  $ €>ÿÿÿÿÿÿ8 4€ÿÿÿÿÿÿB . 8 € >ÿÿÿÿÿÿL F€ ÿÿÿÿÿÿV B L € >ÿÿÿÿÿÿ` X€ ÿÿÿÿÿÿj V ` € ÿÿÿÿÿÿt  j €>ÿÿÿÿÿÿ~ (€>ÿÿÿÿÿÿˆ "(€ÿÿÿÿÿÿ’ ~ ˆ €>ÿÿÿÿÿÿœ 4(€ÿÿÿÿÿÿ¦ ’ œ €>ÿÿÿÿÿÿ° F(€ÿÿÿÿÿÿº ¦ ° €>ÿÿÿÿÿÿÄ X(€ÿÿÿÿÿÿÎ º Ä €ÿÿÿÿÿÿØ t Î €ÿÿÿÿÿÿâ îØ €ÿÿÿÿÿÿì 2Œ€ÿÿÿÿÿÿö ì ð€ÿÿÿÿÿÿ ö T€ÿÿÿÿÿÿ ¸€ÿÿÿÿÿÿ 2€ÿÿÿÿÿÿ  €ÿÿÿÿÿÿ(  € ÿÿÿÿÿÿ2 ( ø€!ÿÿÿÿÿÿ< 2 €"ÿÿÿÿÿÿF <–€#ÿÿÿÿÿÿP F ú€$ÿÿÿÿÿÿZ P ^€%ÿÿÿÿÿÿd Z €&ÿÿÿÿÿÿn <&€'ÿÿÿÿÿÿx n €(ÿÿÿÿÿÿ‚ x €)ÿÿÿÿÿÿŒ ‚  €*ÿÿÿÿÿÿ– d Œ €+ÿÿÿÿÿÿ  < – €,ÿÿÿÿÿÿª Pª€-ÿÿÿÿÿÿ´ ª €.ÿÿÿÿÿÿ¾ ´ r€/ÿÿÿÿÿÿÈ ¾ Ö€0ÿÿÿÿÿÿÒ P:€1ÿÿÿÿÿÿÜ Ò .€2ÿÿÿÿÿÿæ Ü "€3ÿÿÿÿÿÿð æ  €4ÿÿÿÿÿÿú È ð €5ÿÿÿÿÿÿ   ú €6ÿÿÿÿÿÿ d¾€7ÿÿÿÿÿÿ  "€8ÿÿÿÿÿÿ"  †€9ÿÿÿÿÿÿ, " ê€:ÿÿÿÿÿÿ6 dN€;ÿÿÿÿÿÿ@ 6 B€<ÿÿÿÿÿÿJ @ 6€=ÿÿÿÿÿÿT J * €>ÿÿÿÿÿÿ^ , T €?ÿÿÿÿÿÿh  ^ €@ÿÿÿÿÿÿr xÒ€Aÿÿÿÿÿÿ| r 6€Bÿÿÿÿÿÿ† | š€Cÿÿÿÿÿÿ † þ€Dÿÿÿÿÿÿš xb€Eÿÿÿÿÿÿ¤ š V€Fÿÿÿÿÿÿ® ¤ J€Gÿÿÿÿÿÿ¸ ® > €Hÿÿÿÿÿÿ ¸ €IÿÿÿÿÿÿÌ h  €JÿÿÿÿÿÿÖ v€Kÿÿÿÿÿÿà Ö Ú€Lÿÿÿÿÿÿê à >€Mÿÿÿÿÿÿô ê ¢€Nÿÿÿÿÿÿþ Œv€Oÿÿÿÿÿÿ þ j€Pÿÿÿÿÿÿ  ^€Qÿÿÿÿÿÿ  R €Rÿÿÿÿÿÿ& ô  €Sÿÿÿÿÿÿ0 &€€Tÿÿÿÿÿÿ: 0 ä€UÿÿÿÿÿÿD : H€VÿÿÿÿÿÿN D ¬€WÿÿÿÿÿÿX –€€Xÿÿÿÿÿÿb X t€Yÿÿÿÿÿÿl b h€Zÿÿÿÿÿÿv l \ €[ÿÿÿÿÿÿ€ N v €\ÿÿÿÿÿÿŠ & € €]ÿÿÿÿÿÿ” :”€^ÿÿÿÿÿÿž ” ø€_ÿÿÿÿÿÿ¨ ž \€`ÿÿÿÿÿÿ² ¨ À€aÿÿÿÿÿÿ¼ ª”€bÿÿÿÿÿÿÆ ¼ ˆ€cÿÿÿÿÿÿÐ Æ |€dÿÿÿÿÿÿÚ Ð p €eÿÿÿÿÿÿä ² Ú €fÿÿÿÿÿÿî Š ä €gÿÿÿÿÿÿø N¨€hÿÿÿÿÿÿø €iÿÿÿÿÿÿ p€jÿÿÿÿÿÿ Ô€kÿÿÿÿÿÿ ¾¨€lÿÿÿÿÿÿ* œ€mÿÿÿÿÿÿ4*€nÿÿÿÿÿÿ>4„ €oÿÿÿÿÿÿH>€pÿÿÿÿÿÿRî H€qÿÿÿÿÿÿ\b¼€rÿÿÿÿÿÿf\ €sÿÿÿÿÿÿpf„€tÿÿÿÿÿÿzpè€uÿÿÿÿÿÿ„Ò¼€vÿÿÿÿÿÿŽ„°€wÿÿÿÿÿÿ˜Ž¤€xÿÿÿÿÿÿ¢˜˜ €yÿÿÿÿÿÿ¬z¢€zÿÿÿÿÿÿ¶R¬€{ÿÿÿÿÿÿÀÌ ¶€|ÿÿÿÿÿÿÊj€}ÿÿÿÿÿÿÔÊ΀~ÿÿÿÿÿÿÞÔ2€ÿÿÿÿÿÿèÞ–€€ÿÿÿÿÿÿòðÚ€ÿÿÿÿÿÿüò΀‚ÿÿÿÿÿÿü€ƒÿÿÿÿÿÿ¶ €„ÿÿÿÿÿÿ者ÿÿÿÿÿÿ$t€†ÿÿÿÿÿÿ.$Ø€‡ÿÿÿÿÿÿ8.<€ˆÿÿÿÿÿÿB8 €‰ÿÿÿÿÿÿLú䀊ÿÿÿÿÿÿVLØ€‹ÿÿÿÿÿÿ`VÌ€Œÿÿÿÿÿÿj`À €ÿÿÿÿÿÿtBj€Žÿÿÿÿÿÿ~t€ÿÿÿÿÿÿˆ.ˆ€ÿÿÿÿÿÿ’ˆì€‘ÿÿÿÿÿÿœ’P€’ÿÿÿÿÿÿ¦œ´€“ÿÿÿÿÿÿ°ø€”ÿÿÿÿÿÿº°ì€•ÿÿÿÿÿÿÄºà€–ÿÿÿÿÿÿÎÄÔ €—ÿÿÿÿÿÿئ΀˜ÿÿÿÿÿÿâ~Ø€™ÿÿÿÿÿÿìBœ€šÿÿÿÿÿÿö쀛ÿÿÿÿÿÿöd€œÿÿÿÿÿÿ È€ÿÿÿÿÿÿ" €žÿÿÿÿÿÿ€Ÿÿÿÿÿÿÿ(ô€ ÿÿÿÿÿÿ2(è €¡ÿÿÿÿÿÿ< 2€¢ÿÿÿÿÿÿFâ<€£ÿÿÿÿÿÿPV°€¤ÿÿÿÿÿÿZP€¥ÿÿÿÿÿÿdZx€¦ÿÿÿÿÿÿndÜ€§ÿÿÿÿÿÿx6 €¨ÿÿÿÿÿÿ‚x€©ÿÿÿÿÿÿŒ‚€ªÿÿÿÿÿÿ–Œü €«ÿÿÿÿÿÿ n–€¬ÿÿÿÿÿÿªF €­ÿÿÿÿÿÿ´Àª€®ÿÿÿÿÿÿ¾^€¯ÿÿÿÿÿÿȾ€°ÿÿÿÿÿÿÒÈ&€±ÿÿÿÿÿÿÜÒŠ€²ÿÿÿÿÿÿæT>€³ÿÿÿÿÿÿðæ2€´ÿÿÿÿÿÿúð&€µÿÿÿÿÿÿú €¶ÿÿÿÿÿÿÜ€·ÿÿÿÿÿÿh€¸ÿÿÿÿÿÿ"Ì€¹ÿÿÿÿÿÿ,"0€ºÿÿÿÿÿÿ6,”€»ÿÿÿÿÿÿ@^H€¼ÿÿÿÿÿÿJ@<€½ÿÿÿÿÿÿTJ0€¾ÿÿÿÿÿÿ^T$ €¿ÿÿÿÿÿÿh6^€Àÿÿÿÿÿÿrh€Áÿÿÿÿÿÿ|"|€Âÿÿÿÿÿÿ†|à€Ãÿÿÿÿÿÿ†D€Äÿÿÿÿÿÿš¨€Åÿÿÿÿÿÿ¤r\€Æÿÿÿÿÿÿ®¤P€Çÿÿÿÿÿÿ¸®D€Èÿÿÿÿÿÿ¸8 €Éÿÿÿÿÿÿ̚€ÊÿÿÿÿÿÿÖrÌ€Ëÿÿÿÿÿÿà6€Ìÿÿÿÿÿÿêàô€ÍÿÿÿÿÿÿôêX€Îÿÿÿÿÿÿþô¼€Ïÿÿÿÿÿÿ†p€Ðÿÿÿÿÿÿd€ÑÿÿÿÿÿÿX€Òÿÿÿÿÿÿ&L €Óÿÿÿÿÿÿ0þ&€Ôÿÿÿÿÿÿ:Ö0€ÕÿÿÿÿÿÿDJ¤€ÖÿÿÿÿÿÿND€×ÿÿÿÿÿÿXNl€ØÿÿÿÿÿÿbXЀÙÿÿÿÿÿÿlš„€Úÿÿÿÿÿÿvlx€Ûÿÿÿÿÿÿ€vl€ÜÿÿÿÿÿÿŠ€` €Ýÿÿÿÿÿÿ”bŠ€Þÿÿÿÿÿÿž:”€ßÿÿÿÿÿÿ¨´ž€àÿÿÿÿÿÿ²øR €áÿÿÿÿÿÿ¼²¶ €âÿÿÿÿÿÿƼ €ãÿÿÿÿÿÿÐÆ~ €äÿÿÿÿÿÿÚ¸¢€åÿÿÿÿÿÿäÚ–€æÿÿÿÿÿÿî䊀çÿÿÿÿÿÿøî~ €èÿÿÿÿÿÿÐø€éÿÿÿÿÿÿ  \ €êÿÿÿÿÿÿ À €ëÿÿÿÿÿÿ $ €ìÿÿÿÿÿÿ* ˆ €íÿÿÿÿÿÿ4¬€îÿÿÿÿÿÿ>4 €ïÿÿÿÿÿÿH>”€ðÿÿÿÿÿÿRHˆ €ñÿÿÿÿÿÿ\*R€òÿÿÿÿÿÿf\€óÿÿÿÿÿÿp p €ôÿÿÿÿÿÿzpÔ €õÿÿÿÿÿÿ„z8 €öÿÿÿÿÿÿŽ„œ €÷ÿÿÿÿÿÿ˜ÖÀ€øÿÿÿÿÿÿ¢˜´€ùÿÿÿÿÿÿ¬¢¨€úÿÿÿÿÿÿ¶¬œ €ûÿÿÿÿÿÿÀŽ¶€üÿÿÿÿÿÿÊfÀ€ýÿÿÿÿÿÿÔ* „ €þÿÿÿÿÿÿÞÔè €ÿÿÿÿÿÿÿèÞL €ÿÿÿÿÿÿòè° €ÿÿÿÿÿÿüêÔ€ÿÿÿÿÿÿüÈ€ÿÿÿÿÿÿ¼€ÿÿÿÿÿÿ° €ÿÿÿÿÿÿ$ò€ÿÿÿÿÿÿ.Ê$€ÿÿÿÿÿÿ8> ˜ €ÿÿÿÿÿÿB8ü € ÿÿÿÿÿÿLB` € ÿÿÿÿÿÿVLÄ € ÿÿÿÿÿÿ`þè€ ÿÿÿÿÿÿj`Ü€ ÿÿÿÿÿÿtjЀÿÿÿÿÿÿ~tÄ €ÿÿÿÿÿÿˆV~€ÿÿÿÿÿÿ’.ˆ€ÿÿÿÿÿÿœ¨’@ÿÿÿÿÿÿ¦2@ÿÿÿÿÿÿ¯v€ÿÿÿÿÿÿ¸¦¯@ÿÿÿÿÿÿÂ΀ÿÿÿÿÿÿ˸Â@ÿÿÿÿÿÿÕ&€ÿÿÿÿÿÿÞËÕ@ÿÿÿÿÿÿè~ €ÿÿÿÿÿÿñÞè@ÿÿÿÿÿÿû<@ÿÿÿÿÿÿ€€ÿÿÿÿÿÿ û@ÿÿÿÿÿÿØ€ÿÿÿÿÿÿ  @ ÿÿÿÿÿÿ*0€!ÿÿÿÿÿÿ3 *@"ÿÿÿÿÿÿ=ˆ €#ÿÿÿÿÿÿF3=€$ÿÿÿÿÿÿPñF@%ÿÿÿÿÿÿZP@&ÿÿÿÿÿÿc”€'ÿÿÿÿÿÿlZc@(ÿÿÿÿÿÿvì€)ÿÿÿÿÿÿlv@*ÿÿÿÿÿÿ‰D€+ÿÿÿÿÿÿ’‰@,ÿÿÿÿÿÿœœ €-ÿÿÿÿÿÿ¥’œ€.ÿÿÿÿÿÿ¯P¥@/ÿÿÿÿÿÿ¹d@0ÿÿÿÿÿÿ¨€1ÿÿÿÿÿÿ˹Â@2ÿÿÿÿÿÿÕ€3ÿÿÿÿÿÿÞËÕ@4ÿÿÿÿÿÿèX€5ÿÿÿÿÿÿñÞè@6ÿÿÿÿÿÿû° €7ÿÿÿÿÿÿñû€8ÿÿÿÿÿÿ¯@9ÿÿÿÿÿÿx@:ÿÿÿÿÿÿ!¼€;ÿÿÿÿÿÿ*!@<ÿÿÿÿÿÿ4€=ÿÿÿÿÿÿ=*4@>ÿÿÿÿÿÿGl€?ÿÿÿÿÿÿP=G@@ÿÿÿÿÿÿZÄ €AÿÿÿÿÿÿcPZ€Bÿÿÿÿÿÿmc@CÿÿÿÿÿÿwŒ@Dÿÿÿÿÿÿ€@Eÿÿÿÿÿÿ‰ð@Fÿÿÿÿÿÿ’@Gÿÿÿÿÿÿ›T@Hÿÿÿÿÿÿ¤@Iÿÿÿÿÿÿ­¸@Jÿÿÿÿÿÿ¶ø@Kÿÿÿÿÿÿ¿Ú@LÿÿÿÿÿÿÈj@MÿÿÿÿÿÿÑ>@NÿÿÿÿÿÿÚ^@Oÿÿÿÿÿÿã¢@PÿÿÿÿÿÿìR @Qÿÿÿÿÿÿõ2@RÿÿÿÿÿÿþÂ@Sÿÿÿÿÿÿ–@Tÿÿÿÿÿÿ¶ @UÿÿÿÿÿÿŠ@Vÿÿÿÿÿÿ" @Wÿÿÿÿÿÿ+–@Xÿÿÿÿÿÿ4&@Yÿÿÿÿÿÿ=ú@ZÿÿÿÿÿÿF@[ÿÿÿÿÿÿO^@\ÿÿÿÿÿÿX@]ÿÿÿÿÿÿaÂ@^ÿÿÿÿÿÿj @_ÿÿÿÿÿÿsä@`ÿÿÿÿÿÿ|t@aÿÿÿÿÿÿ…H@bÿÿÿÿÿÿŽh@cÿÿÿÿÿÿ—¬@dÿÿÿÿÿÿ \ @eÿÿÿÿÿÿ©<@fÿÿÿÿÿÿ²Ì@gÿÿÿÿÿÿ» @hÿÿÿÿÿÿÄÀ @iÿÿÿÿÿÿÍ”@jÿÿÿÿÿÿÖ$ @kÿÿÿÿÿÿߪ@lÿÿÿÿÿÿè:@mÿÿÿÿÿÿñ@nÿÿÿÿÿÿú.@oÿÿÿÿÿÿr@pÿÿÿÿÿÿ "@qÿÿÿÿÿÿÖ@rÿÿÿÿÿÿ @sÿÿÿÿÿÿ'ø@tÿÿÿÿÿÿ0ˆ@uÿÿÿÿÿÿ9\@vÿÿÿÿÿÿB|@wÿÿÿÿÿÿKÀ@xÿÿÿÿÿÿTp @yÿÿÿÿÿÿ]P@zÿÿÿÿÿÿfà@{ÿÿÿÿÿÿo´@|ÿÿÿÿÿÿxÔ @}ÿÿÿÿÿÿ¨@~ÿÿÿÿÿÿŠ8 @ÿÿÿÿÿÿ“¾@€ÿÿÿÿÿÿœN@ÿÿÿÿÿÿ¥"@‚ÿÿÿÿÿÿ®B@ƒÿÿÿÿÿÿ·†@„ÿÿÿÿÿÿÀ6@…ÿÿÿÿÿÿÉê@†ÿÿÿÿÿÿÒ* @‡ÿÿÿÿÿÿÛ @ˆÿÿÿÿÿÿäœ@‰ÿÿÿÿÿÿíp@Šÿÿÿÿÿÿö@‹ÿÿÿÿÿÿÿÔ@Œÿÿÿÿÿÿ„ @ÿÿÿÿÿÿd@Žÿÿÿÿÿÿô@ÿÿÿÿÿÿ#È@ÿÿÿÿÿÿ,è @‘ÿÿÿÿÿÿ5¼@’ÿÿÿÿÿÿ>L @“ÿÿÿÿÿÿGÒ@”ÿÿÿÿÿÿPb@•ÿÿÿÿÿÿY6@–ÿÿÿÿÿÿbV@—ÿÿÿÿÿÿkš@˜ÿÿÿÿÿÿtJ@™ÿÿÿÿÿÿ}þ@šÿÿÿÿÿÿ†> @›ÿÿÿÿÿÿ @œÿÿÿÿÿÿ˜°@ÿÿÿÿÿÿ¡„@žÿÿÿÿÿÿª¤@Ÿÿÿÿÿÿÿ³è@ ÿÿÿÿÿÿ¼˜ @¡ÿÿÿÿÿÿÅx@¢ÿÿÿÿÿÿÎ@£ÿÿÿÿÿÿ×Ü@¤ÿÿÿÿÿÿàü @¥ÿÿÿÿÿÿéÐ@¦ÿÿÿÿÿÿò` €§ÿÿÿÿÿÿûw€€¨ÿÿÿÿÿÿ¦û€©ÿÿÿÿÿÿ‰’€ªÿÿÿÿÿÿ€«ÿÿÿÿÿÿ#›¤€¬ÿÿÿÿÿÿ-#€­ÿÿÿÿÿÿ7­¶€®ÿÿÿÿÿÿA-7€¯ÿÿÿÿÿÿK€w€°ÿÿÿÿÿÿUK¯€±ÿÿÿÿÿÿ_¿È€²ÿÿÿÿÿÿiU_€³ÿÿÿÿÿÿsÑÚ€´ÿÿÿÿÿÿ}is€µÿÿÿÿÿÿ‡ã쀶ÿÿÿÿÿÿ‘}‡€·ÿÿÿÿÿÿ›A‘€¸ÿÿÿÿÿÿ¥’‰€¹ÿÿÿÿÿÿ¯È¿€ºÿÿÿÿÿÿ¹¥¯€»ÿÿÿÿÿÿù€¼ÿÿÿÿÿÿÍõþ€½ÿÿÿÿÿÿ×ÃÍ€¾ÿÿÿÿÿÿဿÿÿÿÿÿÿë×á€Àÿÿÿÿÿÿõ›ë€Áÿÿÿÿÿÿÿ¤›€Âÿÿÿÿÿÿ ÚÑ€Ãÿÿÿÿÿÿÿ €Äÿÿÿÿÿÿþõ€Åÿÿÿÿÿÿ'€Æÿÿÿÿÿÿ1'Õ€Çÿÿÿÿÿÿ;"€ÈÿÿÿÿÿÿE1;€ÉÿÿÿÿÿÿOõE€ÊÿÿÿÿÿÿY¶­€Ëÿÿÿÿÿÿcìã€ÌÿÿÿÿÿÿmYc€Íÿÿÿÿÿÿw€Îÿÿÿÿÿÿmw€Ïÿÿÿÿÿÿ‹"€Ðÿÿÿÿÿÿ•‹€ÑÿÿÿÿÿÿŸ•è€Òÿÿÿÿÿÿ©OŸ€Óÿÿÿÿÿÿ³+4€Ôÿÿÿÿÿÿ½û³€ÕÿÿÿÿÿÿÇ=F€Öÿÿÿÿÿÿѽǀ×ÿÿÿÿÿÿÛOX€ØÿÿÿÿÿÿåÑÛ€Ùÿÿÿÿÿÿïaj€Úÿÿÿÿÿÿùåï€Ûÿÿÿÿÿÿ4+€Üÿÿÿÿÿÿ €Ýÿÿÿÿÿÿs|€Þÿÿÿÿÿÿ! €ßÿÿÿÿÿÿ+…Ž€àÿÿÿÿÿÿ5!+€áÿÿÿÿÿÿ?— €âÿÿÿÿÿÿI5?€ãÿÿÿÿÿÿSùI€äÿÿÿÿÿÿ]F=€åÿÿÿÿÿÿg|s€æÿÿÿÿÿÿq]g€çÿÿÿÿÿÿ{q€èÿÿÿÿÿÿ…©²€éÿÿÿÿÿÿ{…€êÿÿÿÿÿÿ™»Ä€ëÿÿÿÿÿÿ£™€ìÿÿÿÿÿÿ­S£€íÿÿÿÿÿÿ·XO€îÿÿÿÿÿÿÁŽ…€ïÿÿÿÿÿÿË·Á€ðÿÿÿÿÿÿÕ²©€ñÿÿÿÿÿÿßËÕ€òÿÿÿÿÿÿéß*€óÿÿÿÿÿÿóÍÖ€ôÿÿÿÿÿÿýéó€õÿÿÿÿÿÿ­ý€öÿÿÿÿÿÿja€÷ÿÿÿÿÿÿ —€øÿÿÿÿÿÿ%€ùÿÿÿÿÿÿ/Ä»€úÿÿÿÿÿÿ9%/€ûÿÿÿÿÿÿCÖÍ€üÿÿÿÿÿÿM9C€ýÿÿÿÿÿÿWM=€þÿÿÿÿÿÿaW€ÿÿÿÿÿÿÿk©a€ÿÿÿÿÿÿußè€ÿÿÿÿÿÿZu€ÿÿÿÿÿÿ‰ñú€ÿÿÿÿÿÿ“‰€ÿÿÿÿÿÿ €ÿÿÿÿÿÿ§“€ÿÿÿÿÿÿ±€ÿÿÿÿÿÿ»§±€ÿÿÿÿÿÿÅè߀ ÿÿÿÿÿÿÏÅc€ ÿÿÿÿÿÿÙ'0€ ÿÿÿÿÿÿãÏÙ€ ÿÿÿÿÿÿí9B€ ÿÿÿÿÿÿ÷ãí€ÿÿÿÿÿÿKT€ÿÿÿÿÿÿ ÷€ÿÿÿÿÿÿ» €ÿÿÿÿÿÿúñ€ÿÿÿÿÿÿ)0'€ÿÿÿÿÿÿ3)€ÿÿÿÿÿÿ=3v€ÿÿÿÿÿÿG]f€ÿÿÿÿÿÿQ=G€ÿÿÿÿÿÿ[ox€ÿÿÿÿÿÿeQ[€ÿÿÿÿÿÿoe€ÿÿÿÿÿÿy €ÿÿÿÿÿÿƒB9€ÿÿÿÿÿÿyƒ€ÿÿÿÿÿÿ—f]€ÿÿÿÿÿÿ¡—€ÿÿÿÿÿÿ«¡‰€ ÿÿÿÿÿÿµŠ€!ÿÿÿÿÿÿ¿«µ€"ÿÿÿÿÿÿÉo¿€#ÿÿÿÿÿÿÓ€$ÿÿÿÿÿÿÝTK€%ÿÿÿÿÿÿçÓÝ€&ÿÿÿÿÿÿñxo€'ÿÿÿÿÿÿûçñ€(ÿÿÿÿÿÿŠ€)ÿÿÿÿÿÿû€*ÿÿÿÿÿÿœ€+ÿÿÿÿÿÿ#É€,ÿÿÿÿÿÿ-k#€-ÿÿÿÿÿÿ7“œ€.ÿÿÿÿÿÿA¹7€/ÿÿÿÿÿÿK¥®€0ÿÿÿÿÿÿUAK€1ÿÿÿÿÿÿ_·À€2ÿÿÿÿÿÿiU_€3ÿÿÿÿÿÿsÉÒ€4ÿÿÿÿÿÿ}is€5ÿÿÿÿÿÿ‡œ“€6ÿÿÿÿÿÿ‘‡Â€7ÿÿÿÿÿÿ›Ûä€8ÿÿÿÿÿÿ¥‘›€9ÿÿÿÿÿÿ¯íö€:ÿÿÿÿÿÿ¹¥¯€;ÿÿÿÿÿÿÃÿ€<ÿÿÿÿÿÿ͹À=ÿÿÿÿÿÿ×}Í€>ÿÿÿÿÿÿᮥ€?ÿÿÿÿÿÿëäÛ€@ÿÿÿÿÿÿõáë€AÿÿÿÿÿÿÿõÕ€Bÿÿÿÿÿÿ €Cÿÿÿÿÿÿ ÿ €Dÿÿÿÿÿÿ #,€Eÿÿÿÿÿÿ'   €Fÿÿÿÿÿÿ1 ×' €Gÿÿÿÿÿÿ; À·€HÿÿÿÿÿÿE öí€IÿÿÿÿÿÿO ; E €JÿÿÿÿÿÿY €Kÿÿÿÿÿÿc O Y €Lÿÿÿÿÿÿm c è€Mÿÿÿÿÿÿw 5>€Nÿÿÿÿÿÿ m w €Oÿÿÿÿÿÿ‹ 1 €Pÿÿÿÿÿÿ• ÒÉ€QÿÿÿÿÿÿŸ ÿ€Rÿÿÿÿÿÿ© • Ÿ €Sÿÿÿÿÿÿ³ ,#€Tÿÿÿÿÿÿ½ © ³ €UÿÿÿÿÿÿÇ >5€VÿÿÿÿÿÿÑ ½ Ç €WÿÿÿÿÿÿÛ Ñ û€Xÿÿÿÿÿÿå ‹ Û €Yÿÿÿÿÿÿï -å €Zÿÿÿÿÿÿù GP€[ÿÿÿÿÿÿ!ù €\ÿÿÿÿÿÿ !Yb€]ÿÿÿÿÿÿ!! !€^ÿÿÿÿÿÿ!!kt€_ÿÿÿÿÿÿ+!!!!€`ÿÿÿÿÿÿ5!}†€aÿÿÿÿÿÿ?!+!5!€bÿÿÿÿÿÿI!PG€cÿÿÿÿÿÿS!I!!€dÿÿÿÿÿÿ]!˜€eÿÿÿÿÿÿg!S!]!€fÿÿÿÿÿÿq!¡ª€gÿÿÿÿÿÿ{!g!q!€hÿÿÿÿÿÿ…!³¼€iÿÿÿÿÿÿ!{!…!€jÿÿÿÿÿÿ™!?!!€kÿÿÿÿÿÿ£!bY€lÿÿÿÿÿÿ­!˜€mÿÿÿÿÿÿ·!£!­!€nÿÿÿÿÿÿÁ!·!4€oÿÿÿÿÿÿË!Å΀pÿÿÿÿÿÿÕ!Á!Ë!€qÿÿÿÿÿÿß!×à€rÿÿÿÿÿÿé!Õ!ß!€sÿÿÿÿÿÿó!™!é!€tÿÿÿÿÿÿý!tk€uÿÿÿÿÿÿ"ª¡€vÿÿÿÿÿÿ"ý!"€wÿÿÿÿÿÿ"ÎÅ€xÿÿÿÿÿÿ%"""€yÿÿÿÿÿÿ/"%"G€zÿÿÿÿÿÿ9"éò€{ÿÿÿÿÿÿC"/"9"€|ÿÿÿÿÿÿM"ó!C"€}ÿÿÿÿÿÿW"†}€~ÿÿÿÿÿÿa"¼³€ÿÿÿÿÿÿk"W"a"€€ÿÿÿÿÿÿu"à×€ÿÿÿÿÿÿ"k"u"€‚ÿÿÿÿÿÿ‰"ò逃ÿÿÿÿÿÿ“""‰"€„ÿÿÿÿÿÿ"“"Z€…ÿÿÿÿÿÿ§"M""€†ÿÿÿÿÿÿ±"ï §"€‡ÿÿÿÿÿÿ»"2€€ˆÿÿÿÿÿÿÅ"»"쀉ÿÿÿÿÿÿÏ"Å"X€ŠÿÿÿÿÿÿÙ"Ï"Ä €‹Sÿÿÿÿÿÿã"€Œ>ÿÿÿÿÿÿí"ã"@ÿÿÿÿÿÿ÷"í"€ŽSÿÿÿÿÿÿ#j€>ÿÿÿÿÿÿ #"#@ÿÿÿÿÿÿ# #€‘ÿÿÿÿÿÿ#÷"#€’Sÿÿÿÿÿÿ'#œ€“>ÿÿÿÿÿÿ1#4'#@”ÿÿÿÿÿÿ;#1#€•ÿÿÿÿÿÿD##;#€–SÿÿÿÿÿÿN#΀—>ÿÿÿÿÿÿX#FN#@˜ÿÿÿÿÿÿb#X#€™ÿÿÿÿÿÿk#D#b#€šSÿÿÿÿÿÿu#€›>ÿÿÿÿÿÿ#Xu#@œÿÿÿÿÿÿ‰##€ÿÿÿÿÿÿ’#k#‰#€žSÿÿÿÿÿÿœ#*"€Ÿ>ÿÿÿÿÿÿ¦#œ#@ ÿÿÿÿÿÿ°#¦#€¡Sÿÿÿÿÿÿ¹#t"€¢>ÿÿÿÿÿÿÃ#"¹#@£ÿÿÿÿÿÿÍ#Ã#€¤ÿÿÿÿÿÿÖ#°#Í#€¥Sÿÿÿÿÿÿà#¦"€¦>ÿÿÿÿÿÿê#4à#@§ÿÿÿÿÿÿô#ê#€¨ÿÿÿÿÿÿý#Ö#ô#€©Sÿÿÿÿÿÿ$Ø"€ª>ÿÿÿÿÿÿ$F$@«ÿÿÿÿÿÿ$$€¬ÿÿÿÿÿÿ$$ý#$€­Sÿÿÿÿÿÿ.$ "€®>ÿÿÿÿÿÿ8$X.$@¯ÿÿÿÿÿÿB$8$€°ÿÿÿÿÿÿK$$$B$€±ÿÿÿÿÿÿU$’#K$€²Sÿÿÿÿÿÿ_$<4€³>ÿÿÿÿÿÿi$_$@´ÿÿÿÿÿÿs$i$€µSÿÿÿÿÿÿ|$~4€¶>ÿÿÿÿÿÿ†$"|$@·ÿÿÿÿÿÿ$†$€¸ÿÿÿÿÿÿ™$s$$€¹Sÿÿÿÿÿÿ£$°4€º>ÿÿÿÿÿÿ­$4£$@»ÿÿÿÿÿÿ·$­$€¼ÿÿÿÿÿÿÀ$™$·$€½SÿÿÿÿÿÿÊ$â4€¾>ÿÿÿÿÿÿÔ$FÊ$@¿ÿÿÿÿÿÿÞ$Ô$€Àÿÿÿÿÿÿç$À$Þ$€ÁSÿÿÿÿÿÿñ$4€Â>ÿÿÿÿÿÿû$Xñ$@Ãÿÿÿÿÿÿ%û$€Äÿÿÿÿÿÿ%ç$%€Åÿÿÿÿÿÿ%U$%€ÆSÿÿÿÿÿÿ"%NF€Ç>ÿÿÿÿÿÿ,%"%@Èÿÿÿÿÿÿ6%,%€ÉSÿÿÿÿÿÿ?%ˆF€Ê>ÿÿÿÿÿÿI%"?%@ËÿÿÿÿÿÿS%I%€Ìÿÿÿÿÿÿ\%6%S%€ÍSÿÿÿÿÿÿf%ºF€Î>ÿÿÿÿÿÿp%4f%@Ïÿÿÿÿÿÿz%p%€Ðÿÿÿÿÿÿƒ%\%z%€ÑSÿÿÿÿÿÿ%ìF€Ò>ÿÿÿÿÿÿ—%F%@Óÿÿÿÿÿÿ¡%—%€Ôÿÿÿÿÿÿª%ƒ%¡%€ÕSÿÿÿÿÿÿ´%F€Ö>ÿÿÿÿÿÿ¾%X´%@×ÿÿÿÿÿÿÈ%¾%€ØÿÿÿÿÿÿÑ%ª%È%€ÙÿÿÿÿÿÿÛ%%Ñ%€ÚSÿÿÿÿÿÿå%`X€Û>ÿÿÿÿÿÿï%å%@Üÿÿÿÿÿÿù%ï%€ÝSÿÿÿÿÿÿ&’X€Þ>ÿÿÿÿÿÿ &"&@ßÿÿÿÿÿÿ& &€àÿÿÿÿÿÿ&ù%&€áSÿÿÿÿÿÿ)&ÄX€â>ÿÿÿÿÿÿ3&4)&@ãÿÿÿÿÿÿ=&3&€äÿÿÿÿÿÿF&&=&€åSÿÿÿÿÿÿP&öX€æ>ÿÿÿÿÿÿZ&FP&@çÿÿÿÿÿÿd&Z&€èÿÿÿÿÿÿm&F&d&€éSÿÿÿÿÿÿw&(X€ê>ÿÿÿÿÿÿ&Xw&@ëÿÿÿÿÿÿ‹&&€ìÿÿÿÿÿÿ”&m&‹&€íÿÿÿÿÿÿž&Û%”&€îSÿÿÿÿÿÿ¨&*€ï>ÿÿÿÿÿÿ²&"¨&@ðÿÿÿÿÿÿ¼&²&€ñÿÿÿÿÿÿÅ&÷"¼&€òSÿÿÿÿÿÿÏ&<€ó>ÿÿÿÿÿÿÙ&4Ï&@ôÿÿÿÿÿÿã&Ù&€õÿÿÿÿÿÿì&Å&ã&€öSÿÿÿÿÿÿö&N€÷>ÿÿÿÿÿÿ'Fö&@øÿÿÿÿÿÿ ''€ùÿÿÿÿÿÿ'ì& '€úSÿÿÿÿÿÿ'`€û>ÿÿÿÿÿÿ''X'@üÿÿÿÿÿÿ1'''€ýÿÿÿÿÿÿ:''1'€þSÿÿÿÿÿÿD'j"€ÿ>ÿÿÿÿÿÿN'D'@ÿÿÿÿÿÿX'N'€ÿÿÿÿÿÿa'X'Í#€Sÿÿÿÿÿÿk'~"€>ÿÿÿÿÿÿu'4k'@ÿÿÿÿÿÿ'u'€ÿÿÿÿÿÿˆ'a''€Sÿÿÿÿÿÿ’'ˆ"€>ÿÿÿÿÿÿœ'F’'@ÿÿÿÿÿÿ¦'œ'€ ÿÿÿÿÿÿ¯'ˆ'¦'€ Sÿÿÿÿÿÿ¹'’"€ >ÿÿÿÿÿÿÃ'X¹'@ ÿÿÿÿÿÿÍ'Ã'€ ÿÿÿÿÿÿÖ'¯'Í'€ÿÿÿÿÿÿà':'Ö'€Sÿÿÿÿÿÿê'œ4€>ÿÿÿÿÿÿô'ê'@ÿÿÿÿÿÿþ'ô'€Sÿÿÿÿÿÿ(¦4€>ÿÿÿÿÿÿ("(@ÿÿÿÿÿÿ((€ÿÿÿÿÿÿ$(þ'(€ÿÿÿÿÿÿ.($(·$€Sÿÿÿÿÿÿ8(º4€>ÿÿÿÿÿÿB(F8(@ÿÿÿÿÿÿL(B(€ÿÿÿÿÿÿU(.(L(€Sÿÿÿÿÿÿ_(Ä4€>ÿÿÿÿÿÿi(X_(@ÿÿÿÿÿÿs(i(€ÿÿÿÿÿÿ|(U(s(€ÿÿÿÿÿÿ†(à'|(€ Sÿÿÿÿÿÿ(ÎF€!>ÿÿÿÿÿÿš((@"ÿÿÿÿÿÿ¤(š(€#Sÿÿÿÿÿÿ­(ØF€$>ÿÿÿÿÿÿ·("­(@%ÿÿÿÿÿÿÁ(·(€&ÿÿÿÿÿÿÊ(¤(Á(€'SÿÿÿÿÿÿÔ(âF€(>ÿÿÿÿÿÿÞ(4Ô(@)ÿÿÿÿÿÿè(Þ(€*ÿÿÿÿÿÿñ(Ê(è(€+ÿÿÿÿÿÿû(ñ(¡%€,Sÿÿÿÿÿÿ)öF€->ÿÿÿÿÿÿ)X)@.ÿÿÿÿÿÿ))€/ÿÿÿÿÿÿ")û()€0ÿÿÿÿÿÿ,)†(")€1Sÿÿÿÿÿÿ6)X€2>ÿÿÿÿÿÿ@)6)@3ÿÿÿÿÿÿJ)@)€4SÿÿÿÿÿÿS) X€5>ÿÿÿÿÿÿ])"S)@6ÿÿÿÿÿÿg)])€7ÿÿÿÿÿÿp)J)g)€8Sÿÿÿÿÿÿz)X€9>ÿÿÿÿÿÿ„)4z)@:ÿÿÿÿÿÿŽ)„)€;ÿÿÿÿÿÿ—)p)Ž)€<Sÿÿÿÿÿÿ¡)X€=>ÿÿÿÿÿÿ«)F¡)@>ÿÿÿÿÿÿµ)«)€?ÿÿÿÿÿÿ¾)—)µ)€@ÿÿÿÿÿÿÈ)¾)‹&€AÿÿÿÿÿÿÒ),)È)€BÿÿÿÿÿÿÜ)í" #€Cÿÿÿÿÿÿæ)Ü)1#€Dÿÿÿÿÿÿð)æ)X#€Eÿÿÿÿÿÿú)ð)#€Fÿÿÿÿÿÿ*¦#Ã#€Gÿÿÿÿÿÿ**ê#€Hÿÿÿÿÿÿ**$€Iÿÿÿÿÿÿ"**8$€Jÿÿÿÿÿÿ,*ú)"*€Kÿÿÿÿÿÿ6*i$†$€Lÿÿÿÿÿÿ@*6*­$€MÿÿÿÿÿÿJ*@*Ô$€NÿÿÿÿÿÿT*J*û$€Oÿÿÿÿÿÿ^*,*T*€Pÿÿÿÿÿÿh*,%I%€Qÿÿÿÿÿÿr*h*p%€Rÿÿÿÿÿÿ|*r*—%€Sÿÿÿÿÿÿ†*|*¾%€Tÿÿÿÿÿÿ*^*†*€Uÿÿÿÿÿÿš*ï% &€Vÿÿÿÿÿÿ¤*š*3&€Wÿÿÿÿÿÿ®*¤*Z&€Xÿÿÿÿÿÿ¸*®*&€YÿÿÿÿÿÿÂ**¸*€ZÿÿÿÿÿÿÌ*2ñ€[ÿÿÿÿÿÿÖ*ŒF€\ÿÿÿÿÿÿà*Ì*Ö*€]ÿÿÿÿÿÿê*ð¥€^ÿÿÿÿÿÿô*à*ê*€_ÿÿÿÿÿÿþ*T€`ÿÿÿÿÿÿ+ô*þ*€aÿÿÿÿÿÿ+¸c€bÿÿÿÿÿÿ+++€cÿÿÿÿÿÿ&+&ñ€dÿÿÿÿÿÿ0+€F€eÿÿÿÿÿÿ:+&+0+€fÿÿÿÿÿÿD+䥀gÿÿÿÿÿÿN+:+D+€hÿÿÿÿÿÿX+H€iÿÿÿÿÿÿb+N+X+€jÿÿÿÿÿÿl+¬c€kÿÿÿÿÿÿv+b+l+€lÿÿÿÿÿÿ€++v+€mÿÿÿÿÿÿŠ+.ñ€nÿÿÿÿÿÿ”+ˆF€oÿÿÿÿÿÿž+Š+”+€pÿÿÿÿÿÿ¨+쥀qÿÿÿÿÿÿ²+ž+¨+€rÿÿÿÿÿÿ¼+P€sÿÿÿÿÿÿÆ+²+¼+€tÿÿÿÿÿÿÐ+´c€uÿÿÿÿÿÿÚ+Æ+Ð+€vÿÿÿÿÿÿä+€+Ú+€wÿÿÿÿÿÿî+6ñ€xÿÿÿÿÿÿø+F€yÿÿÿÿÿÿ,î+ø+€zÿÿÿÿÿÿ ,ô¥€{ÿÿÿÿÿÿ,, ,€|ÿÿÿÿÿÿ ,X€}ÿÿÿÿÿÿ*,, ,€~ÿÿÿÿÿÿ4,¼c€ÿÿÿÿÿÿ>,*,4,€€ÿÿÿÿÿÿH,ä+>,€ÿÿÿÿÿÿR,> ñ€‚ÿÿÿÿÿÿ\,˜ F€ƒÿÿÿÿÿÿf,R,\,€„ÿÿÿÿÿÿp,ü ¥€…ÿÿÿÿÿÿz,f,p,€†ÿÿÿÿÿÿ„,` €‡ÿÿÿÿÿÿŽ,z,„,€ˆÿÿÿÿÿÿ˜,Ä c€‰ÿÿÿÿÿÿ¢,Ž,˜,€Šÿÿÿÿÿÿ¬,H,¢,€‹Sÿÿÿÿÿÿ¶,€Œ>ÿÿÿÿÿÿÀ,¶,@ÿÿÿÿÿÿÊ,À,€ŽSÿÿÿÿÿÿÓ,**€>ÿÿÿÿÿÿÝ,"Ó,@ÿÿÿÿÿÿç,Ý,€‘ÿÿÿÿÿÿð,Ê,ç,€’Sÿÿÿÿÿÿú,<<€“>ÿÿÿÿÿÿ-4ú,@”ÿÿÿÿÿÿ--€•ÿÿÿÿÿÿ-ð,-€–Sÿÿÿÿÿÿ!-NN€—>ÿÿÿÿÿÿ+-F!-@˜ÿÿÿÿÿÿ5-+-€™ÿÿÿÿÿÿ>--5-€šSÿÿÿÿÿÿH-``€›>ÿÿÿÿÿÿR-XH-@œÿÿÿÿÿÿ\-R-€ÿÿÿÿÿÿe->-\-€žSÿÿÿÿÿÿo-jj€Ÿ>ÿÿÿÿÿÿy-o-@ ÿÿÿÿÿÿƒ-y-€¡SÿÿÿÿÿÿŒ-tt€¢>ÿÿÿÿÿÿ–-"Œ-@£ÿÿÿÿÿÿ -–-€¤ÿÿÿÿÿÿ©-ƒ- -€¥Sÿÿÿÿÿÿ³-~~€¦>ÿÿÿÿÿÿ½-4³-@§ÿÿÿÿÿÿÇ-½-€¨ÿÿÿÿÿÿÐ-©-Ç-€©SÿÿÿÿÿÿÚ-ˆˆ€ª>ÿÿÿÿÿÿä-FÚ-@«ÿÿÿÿÿÿî-ä-€¬ÿÿÿÿÿÿ÷-Ð-î-€­Sÿÿÿÿÿÿ.’’€®>ÿÿÿÿÿÿ .X.@¯ÿÿÿÿÿÿ. .€°ÿÿÿÿÿÿ.÷-.€±ÿÿÿÿÿÿ(.e-.€²Sÿÿÿÿÿÿ2.œœ€³>ÿÿÿÿÿÿ<.2.@´ÿÿÿÿÿÿF.<.€µSÿÿÿÿÿÿO.¦¦€¶>ÿÿÿÿÿÿY."O.@·ÿÿÿÿÿÿc.Y.€¸ÿÿÿÿÿÿl.F.c.€¹Sÿÿÿÿÿÿv.°°€º>ÿÿÿÿÿÿ€.4v.@»ÿÿÿÿÿÿŠ.€.€¼ÿÿÿÿÿÿ“.l.Š.€½Sÿÿÿÿÿÿ.ºº€¾>ÿÿÿÿÿÿ§.F.@¿ÿÿÿÿÿÿ±.§.€Àÿÿÿÿÿÿº.“.±.€ÁSÿÿÿÿÿÿÄ.ÄÄ€Â>ÿÿÿÿÿÿÎ.XÄ.@ÃÿÿÿÿÿÿØ.Î.€Äÿÿÿÿÿÿá.º.Ø.€Åÿÿÿÿÿÿë.(.á.€ÆSÿÿÿÿÿÿõ.Î΀Ç>ÿÿÿÿÿÿÿ.õ.@Èÿÿÿÿÿÿ /ÿ.€ÉSÿÿÿÿÿÿ/ØØ€Ê>ÿÿÿÿÿÿ/"/@Ëÿÿÿÿÿÿ&//€Ìÿÿÿÿÿÿ// /&/€ÍSÿÿÿÿÿÿ9/ââ€Î>ÿÿÿÿÿÿC/49/@ÏÿÿÿÿÿÿM/C/€ÐÿÿÿÿÿÿV///M/€ÑSÿÿÿÿÿÿ`/ìì€Ò>ÿÿÿÿÿÿj/F`/@Óÿÿÿÿÿÿt/j/€Ôÿÿÿÿÿÿ}/V/t/€ÕSÿÿÿÿÿÿ‡/öö€Ö>ÿÿÿÿÿÿ‘/X‡/@×ÿÿÿÿÿÿ›/‘/€Øÿÿÿÿÿÿ¤/}/›/€Ùÿÿÿÿÿÿ®/ë.¤/€ÚSÿÿÿÿÿÿ¸/€Û>ÿÿÿÿÿÿÂ/¸/@ÜÿÿÿÿÿÿÌ/Â/€ÝSÿÿÿÿÿÿÕ/  €Þ>ÿÿÿÿÿÿß/"Õ/@ßÿÿÿÿÿÿé/ß/€àÿÿÿÿÿÿò/Ì/é/€áSÿÿÿÿÿÿü/€â>ÿÿÿÿÿÿ04ü/@ãÿÿÿÿÿÿ00€äÿÿÿÿÿÿ0ò/0€åSÿÿÿÿÿÿ#0€æ>ÿÿÿÿÿÿ-0F#0@çÿÿÿÿÿÿ70-0€èÿÿÿÿÿÿ@0070€éSÿÿÿÿÿÿJ0((€ê>ÿÿÿÿÿÿT0XJ0@ëÿÿÿÿÿÿ^0T0€ìÿÿÿÿÿÿg0@0^0€íÿÿÿÿÿÿq0®/g0€îSÿÿÿÿÿÿ{0€ï>ÿÿÿÿÿÿ…0{0@ðÿÿÿÿÿÿ0…0€ñSÿÿÿÿÿÿ˜0"*€ò>ÿÿÿÿÿÿ¢0˜0@óÿÿÿÿÿÿ¬0¢0€ôÿÿÿÿÿÿµ00¬0€õSÿÿÿÿÿÿ¿04<€ö>ÿÿÿÿÿÿÉ0¿0@÷ÿÿÿÿÿÿÓ0É0€øÿÿÿÿÿÿÜ0µ0Ó0€ùSÿÿÿÿÿÿæ0FN€ú>ÿÿÿÿÿÿð0æ0@ûÿÿÿÿÿÿú0ð0€üÿÿÿÿÿÿ1Ü0ú0€ýSÿÿÿÿÿÿ 1X`€þ>ÿÿÿÿÿÿ1 1@ÿÿÿÿÿÿÿ!11€ÿÿÿÿÿÿ*11!1€Sÿÿÿÿÿÿ41j€>ÿÿÿÿÿÿ>1"41@ÿÿÿÿÿÿH1>1€SÿÿÿÿÿÿQ1"t€>ÿÿÿÿÿÿ[1"Q1@ÿÿÿÿÿÿe1[1€ÿÿÿÿÿÿn1H1e1€Sÿÿÿÿÿÿx14~€ >ÿÿÿÿÿÿ‚1"x1@ ÿÿÿÿÿÿŒ1‚1€ ÿÿÿÿÿÿ•1n1Œ1€ SÿÿÿÿÿÿŸ1Fˆ€ >ÿÿÿÿÿÿ©1"Ÿ1@ÿÿÿÿÿÿ³1©1€ÿÿÿÿÿÿ¼1•1³1€SÿÿÿÿÿÿÆ1X’€>ÿÿÿÿÿÿÐ1"Æ1@ÿÿÿÿÿÿÚ1Ð1€ÿÿÿÿÿÿã1¼1Ú1€ÿÿÿÿÿÿí1*1ã1€Sÿÿÿÿÿÿ÷1œ€>ÿÿÿÿÿÿ24÷1@ÿÿÿÿÿÿ 22€Sÿÿÿÿÿÿ2"¦€>ÿÿÿÿÿÿ242@ÿÿÿÿÿÿ(22€ÿÿÿÿÿÿ12 2(2€Sÿÿÿÿÿÿ;24°€>ÿÿÿÿÿÿE24;2@ÿÿÿÿÿÿO2E2€ÿÿÿÿÿÿX212O2€ Sÿÿÿÿÿÿb2Fº€!>ÿÿÿÿÿÿl24b2@"ÿÿÿÿÿÿv2l2€#ÿÿÿÿÿÿ2X2v2€$Sÿÿÿÿÿÿ‰2XÄ€%>ÿÿÿÿÿÿ“24‰2@&ÿÿÿÿÿÿ2“2€'ÿÿÿÿÿÿ¦222€(ÿÿÿÿÿÿ°2í1¦2€)Sÿÿÿÿÿÿº2΀*>ÿÿÿÿÿÿÄ2Fº2@+ÿÿÿÿÿÿÎ2Ä2€,Sÿÿÿÿÿÿ×2"Ø€->ÿÿÿÿÿÿá2F×2@.ÿÿÿÿÿÿë2á2€/ÿÿÿÿÿÿô2Î2ë2€0Sÿÿÿÿÿÿþ24â€1>ÿÿÿÿÿÿ3Fþ2@2ÿÿÿÿÿÿ33€3ÿÿÿÿÿÿ3ô23€4Sÿÿÿÿÿÿ%3Fì€5>ÿÿÿÿÿÿ/3F%3@6ÿÿÿÿÿÿ93/3€7ÿÿÿÿÿÿB3393€8SÿÿÿÿÿÿL3Xö€9>ÿÿÿÿÿÿV3FL3@:ÿÿÿÿÿÿ`3V3€;ÿÿÿÿÿÿi3B3`3€<ÿÿÿÿÿÿs3°2i3€=Sÿÿÿÿÿÿ}3€>>ÿÿÿÿÿÿ‡3X}3@?ÿÿÿÿÿÿ‘3‡3€@Sÿÿÿÿÿÿš3" €A>ÿÿÿÿÿÿ¤3Xš3@Bÿÿÿÿÿÿ®3¤3€Cÿÿÿÿÿÿ·3‘3®3€DSÿÿÿÿÿÿÁ34€E>ÿÿÿÿÿÿË3XÁ3@FÿÿÿÿÿÿÕ3Ë3€GÿÿÿÿÿÿÞ3·3Õ3€HSÿÿÿÿÿÿè3F€I>ÿÿÿÿÿÿò3Xè3@Jÿÿÿÿÿÿü3ò3€Kÿÿÿÿÿÿ4Þ3ü3€LSÿÿÿÿÿÿ4X(€M>ÿÿÿÿÿÿ4X4@Nÿÿÿÿÿÿ#44€Oÿÿÿÿÿÿ,44#4€Pÿÿÿÿÿÿ64s3,4€Q>ÿÿÿÿÿÿ@4"o-@RÿÿÿÿÿÿJ4@4€SÿÿÿÿÿÿS4Ê,J4€T>ÿÿÿÿÿÿ]442.@Uÿÿÿÿÿÿg4]4€Vÿÿÿÿÿÿp4S4g4€W>ÿÿÿÿÿÿz4Fõ.@Xÿÿÿÿÿÿ„4z4€Yÿÿÿÿÿÿ4p4„4€Z>ÿÿÿÿÿÿ—4X¸/@[ÿÿÿÿÿÿ¡4—4€\ÿÿÿÿÿÿª44¡4€]>ÿÿÿÿÿÿ´4Ó,@^ÿÿÿÿÿÿ¾4´4€_ÿÿÿÿÿÿÇ4¾4 -€`>ÿÿÿÿÿÿÑ44O.@aÿÿÿÿÿÿÛ4Ñ4€bÿÿÿÿÿÿä4Ç4Û4€c>ÿÿÿÿÿÿî4F/@dÿÿÿÿÿÿø4î4€eÿÿÿÿÿÿ5ä4ø4€f>ÿÿÿÿÿÿ 5XÕ/@gÿÿÿÿÿÿ5 5€hÿÿÿÿÿÿ555€iÿÿÿÿÿÿ(5ª45€j>ÿÿÿÿÿÿ25ú,@kÿÿÿÿÿÿ<525€l>ÿÿÿÿÿÿE5"³-@mÿÿÿÿÿÿO5E5€nÿÿÿÿÿÿX5<5O5€oÿÿÿÿÿÿb5X5Š.€p>ÿÿÿÿÿÿl5F9/@qÿÿÿÿÿÿv5l5€rÿÿÿÿÿÿ5b5v5€s>ÿÿÿÿÿÿ‰5Xü/@tÿÿÿÿÿÿ“5‰5€uÿÿÿÿÿÿœ55“5€vÿÿÿÿÿÿ¦5(5œ5€w>ÿÿÿÿÿÿ°5!-@xÿÿÿÿÿÿº5°5€y>ÿÿÿÿÿÿÃ5"Ú-@zÿÿÿÿÿÿÍ5Ã5€{ÿÿÿÿÿÿÖ5º5Í5€|>ÿÿÿÿÿÿà54.@}ÿÿÿÿÿÿê5à5€~ÿÿÿÿÿÿó5Ö5ê5€ÿÿÿÿÿÿý5ó5t/€€>ÿÿÿÿÿÿ6X#0@ÿÿÿÿÿÿ66€‚ÿÿÿÿÿÿ6ý56€ƒÿÿÿÿÿÿ$6¦56€„>ÿÿÿÿÿÿ.6H-@…ÿÿÿÿÿÿ86.6€†>ÿÿÿÿÿÿA6".@‡ÿÿÿÿÿÿK6A6€ˆÿÿÿÿÿÿT686K6€‰>ÿÿÿÿÿÿ^64Ä.@Šÿÿÿÿÿÿh6^6€‹ÿÿÿÿÿÿq6T6h6€Œ>ÿÿÿÿÿÿ{6F‡/@ÿÿÿÿÿÿ…6{6€ŽÿÿÿÿÿÿŽ6q6…6€ÿÿÿÿÿÿ˜6Ž6^0€ÿÿÿÿÿÿ¢6$6˜6€‘ÿÿÿÿÿÿ¬6w4€’ÿÿÿÿÿÿ¶6¦¬6€“ÿÿÿÿÿÿÀ6‰ú€”ÿÿÿÿÿÿÊ6¶6À6€•ÿÿÿÿÿÿÔ6›À€–ÿÿÿÿÿÿÞ6Ê6Ô6€—ÿÿÿÿÿÿè6­†€˜ÿÿÿÿÿÿò6Þ6è6€™ÿÿÿÿÿÿü6¯€šÿÿÿÿÿÿ7Kü6€›ÿÿÿÿÿÿ7¿0€œÿÿÿÿÿÿ777€ÿÿÿÿÿÿ$7Ñö€žÿÿÿÿÿÿ.77$7€Ÿÿÿÿÿÿÿ87ã¼€ ÿÿÿÿÿÿB7.787€¡ÿÿÿÿÿÿL7ò6B7€¢ÿÿÿÿÿÿV7Ès€£ÿÿÿÿÿÿ`7¥V7€¤ÿÿÿÿÿÿj7Âv€¥ÿÿÿÿÿÿt7`7j7€¦ÿÿÿÿÿÿ~7õ€§ÿÿÿÿÿÿˆ7t7~7€¨ÿÿÿÿÿÿ’7à€©ÿÿÿÿÿÿœ7ˆ7’7€ªÿÿÿÿÿÿ¦7L7œ7€«ÿÿÿÿÿÿ°7Ú…€¬ÿÿÿÿÿÿº7ÿ°7€­ÿÿÿÿÿÿÄ7þ]€®ÿÿÿÿÿÿÎ7º7Ä7€¯ÿÿÿÿÿÿØ7Õ耰ÿÿÿÿÿÿâ7Î7Ø7€±ÿÿÿÿÿÿì7ò€²ÿÿÿÿÿÿö7â7ì7€³ÿÿÿÿÿÿ8¦7ö7€´ÿÿÿÿÿÿ 8ì—€µÿÿÿÿÿÿ8Y 8€¶ÿÿÿÿÿÿ8o€·ÿÿÿÿÿÿ(888€¸ÿÿÿÿÿÿ28"5€¹ÿÿÿÿÿÿ<8(828€ºÿÿÿÿÿÿF8èZ€»ÿÿÿÿÿÿP8<8F8€¼ÿÿÿÿÿÿZ88P8€½ÿÿÿÿÿÿd8û¦€¾ÿÿÿÿÿÿn8d8³€¿ÿÿÿÿÿÿx8=ú€Àÿÿÿÿÿÿ‚8n8x8€ÁÿÿÿÿÿÿŒ8OÀ€Âÿÿÿÿÿÿ–8‚8Œ8€Ãÿÿÿÿÿÿ 8a†€Äÿÿÿÿÿÿª8–8 8€Åÿÿÿÿÿÿ´84w€Æÿÿÿÿÿÿ¾8´8€ÇÿÿÿÿÿÿÈ8s0€ÈÿÿÿÿÿÿÒ8¾8È8€ÉÿÿÿÿÿÿÜ8…ö€Êÿÿÿÿÿÿæ8Ò8Ü8€Ëÿÿÿÿÿÿð8—¼€Ìÿÿÿÿÿÿú8æ8ð8€Íÿÿÿÿÿÿ9ª8ú8€Îÿÿÿÿÿÿ9F‰€Ïÿÿÿÿÿÿ99g€Ðÿÿÿÿÿÿ"9v€Ñÿÿÿÿÿÿ,99"9€Òÿÿÿÿÿÿ69©€Óÿÿÿÿÿÿ@9,969€ÔÿÿÿÿÿÿJ9»à€ÕÿÿÿÿÿÿT9@9J9€Öÿÿÿÿÿÿ^99T9€×ÿÿÿÿÿÿh9X›€Øÿÿÿÿÿÿr9h9Á€Ùÿÿÿÿÿÿ|9²]€Úÿÿÿÿÿÿ†9r9|9€Ûÿÿÿÿÿÿ9*è€Üÿÿÿÿÿÿš9†99€Ýÿÿÿÿÿÿ¤9Íò€Þÿÿÿÿÿÿ®9š9¤9€ßÿÿÿÿÿÿ¸9^9®9€àÿÿÿÿÿÿÂ9j­€áÿÿÿÿÿÿÌ9Â9€âÿÿÿÿÿÿÖ9Äo€ãÿÿÿÿÿÿà9Ì9Ö9€äÿÿÿÿÿÿê9Ö5€åÿÿÿÿÿÿô9à9ê9€æÿÿÿÿÿÿþ9=Z€çÿÿÿÿÿÿ:ô9þ9€èÿÿÿÿÿÿ:¸9:€éÿÿÿÿÿÿ:Z8:€êÿÿÿÿÿÿ&:Z¦€ëÿÿÿÿÿÿ0:ß4€ìÿÿÿÿÿÿ::&:0:€íÿÿÿÿÿÿD:::‰€îÿÿÿÿÿÿN:À€ïÿÿÿÿÿÿX:D:N:€ðÿÿÿÿÿÿb:†€ñÿÿÿÿÿÿl:X:b:€òÿÿÿÿÿÿv:èw€óÿÿÿÿÿÿ€:c€ôÿÿÿÿÿÿŠ:v:€:€õÿÿÿÿÿÿ”:Š:Ù€öÿÿÿÿÿÿž:9ö€÷ÿÿÿÿÿÿ¨:”:ž:€øÿÿÿÿÿÿ²:K¼€ùÿÿÿÿÿÿ¼:¨:²:€úÿÿÿÿÿÿÆ:l:¼:€ûÿÿÿÿÿÿÐ:ú‰€üÿÿÿÿÿÿÚ:0s€ýÿÿÿÿÿÿä:Ð:Ú:€þÿÿÿÿÿÿî:ä:v€ÿÿÿÿÿÿÿø:]€ÿÿÿÿÿÿ;î:ø:€ÿÿÿÿÿÿ ;oà€ÿÿÿÿÿÿ;; ;€ÿÿÿÿÿÿ ;Æ:;€ÿÿÿÿÿÿ*; ›€ÿÿÿÿÿÿ4;B…€ÿÿÿÿÿÿ>;*;4;€ÿÿÿÿÿÿH;>;—€ÿÿÿÿÿÿR;‰è€ ÿÿÿÿÿÿ\;H;R;€ ÿÿÿÿÿÿf;ò€ ÿÿÿÿÿÿp;\;f;€ ÿÿÿÿÿÿz; ;p;€ ÿÿÿÿÿÿ„;­€ÿÿÿÿÿÿŽ;T—€ÿÿÿÿÿÿ˜;„;Ž;€ÿÿÿÿÿÿ¢;˜;ñ€ÿÿÿÿÿÿ¬;Š5€ÿÿÿÿÿÿ¶;¢;¬;€ÿÿÿÿÿÿÀ;œZ€ÿÿÿÿÿÿÊ;¶;À;€ÿÿÿÿÿÿÔ;z;Ê;€ÿÿÿÿÿÿÞ;:Ô;€ÿÿÿÿÿÿè;¹¦€ÿÿÿÿÿÿò;“4€ÿÿÿÿÿÿü;è;ò;€ÿÿÿÿÿÿ<¥ú€ÿÿÿÿÿÿ<ü;<€ÿÿÿÿÿÿ<<_€ÿÿÿÿÿÿ$<Ɇ€ÿÿÿÿÿÿ.<<$<€ÿÿÿÿÿÿ8<œw€ ÿÿÿÿÿÿB<€!ÿÿÿÿÿÿL<8<B<€"ÿÿÿÿÿÿV<Û0€#ÿÿÿÿÿÿ`<L<V<€$ÿÿÿÿÿÿj<`<¯€%ÿÿÿÿÿÿt<ÿ¼€&ÿÿÿÿÿÿ~<j<t<€'ÿÿÿÿÿÿˆ<.<~<€(ÿÿÿÿÿÿ’<®‰€)ÿÿÿÿÿÿœ<äs€*ÿÿÿÿÿÿ¦<’<œ<€+ÿÿÿÿÿÿ°<Õv€,ÿÿÿÿÿÿº<¦<°<€-ÿÿÿÿÿÿÄ<º< €.ÿÿÿÿÿÿÎ<#à€/ÿÿÿÿÿÿØ<Ä<Î<€0ÿÿÿÿÿÿâ<ˆ<Ø<€1ÿÿÿÿÿÿì<À›€2ÿÿÿÿÿÿö<ö…€3ÿÿÿÿÿÿ=ì<ö<€4ÿÿÿÿÿÿ =]€5ÿÿÿÿÿÿ== =€6ÿÿÿÿÿÿ==è€7ÿÿÿÿÿÿ(=5ò€8ÿÿÿÿÿÿ2==(=€9ÿÿÿÿÿÿ<=â<2=€:ÿÿÿÿÿÿF=Ò­€;ÿÿÿÿÿÿP=—€<ÿÿÿÿÿÿZ=F=P=€=ÿÿÿÿÿÿd=,o€>ÿÿÿÿÿÿn=Z=d=€?ÿÿÿÿÿÿx=n=Ç €@ÿÿÿÿÿÿ‚=ûZ€AÿÿÿÿÿÿŒ=x=‚=€Bÿÿÿÿÿÿ–=<=Œ=€Cÿÿÿÿÿÿ =Þ;–=€Dÿÿÿÿÿÿª=¦€Eÿÿÿÿÿÿ´=G4€Fÿÿÿÿÿÿ¾=ª=´=€GÿÿÿÿÿÿÈ=Yú€HÿÿÿÿÿÿÒ=¾=È=€IÿÿÿÿÿÿÜ=kÀ€Jÿÿÿÿÿÿæ=Ò=Ü=€Kÿÿÿÿÿÿð=æ=5!€Lÿÿÿÿÿÿú=Pw€Mÿÿÿÿÿÿ>!€Nÿÿÿÿÿÿ>ú=>€Oÿÿÿÿÿÿ>0€Pÿÿÿÿÿÿ">>>€Qÿÿÿÿÿÿ,>¡ö€Rÿÿÿÿÿÿ6>">,>€Sÿÿÿÿÿÿ@>6>…!€TÿÿÿÿÿÿJ>ð=@>€UÿÿÿÿÿÿT>b‰€Vÿÿÿÿÿÿ^>˜s€Wÿÿÿÿÿÿh>T>^>€Xÿÿÿÿÿÿr>4v€Yÿÿÿÿÿÿ|>h>r>€Zÿÿÿÿÿÿ†>Å€[ÿÿÿÿÿÿ>|>†>€\ÿÿÿÿÿÿš>>ß!€]ÿÿÿÿÿÿ¤>J>š>€^ÿÿÿÿÿÿ®>t›€_ÿÿÿÿÿÿ¸>ª…€`ÿÿÿÿÿÿÂ>®>¸>€aÿÿÿÿÿÿÌ>Î]€bÿÿÿÿÿÿÖ>Â>Ì>€cÿÿÿÿÿÿà>Gè€dÿÿÿÿÿÿê>Ö>à>€eÿÿÿÿÿÿô>ê>9"€fÿÿÿÿÿÿþ>¤>ô>€gÿÿÿÿÿÿ?†­€hÿÿÿÿÿÿ?¼—€iÿÿÿÿÿÿ???€jÿÿÿÿÿÿ&?ào€kÿÿÿÿÿÿ0??&?€lÿÿÿÿÿÿ:?ò5€mÿÿÿÿÿÿD?0?:?€nÿÿÿÿÿÿN?D?Z€oÿÿÿÿÿÿX?þ>N?€pÿÿÿÿÿÿb? =X?€qSÿÿÿÿÿÿl?*€r>ÿÿÿÿÿÿv?"l?€sÿÿÿÿÿÿ€?…0v?€tSÿÿÿÿÿÿŠ?<€u>ÿÿÿÿÿÿ”?4Š?€vÿÿÿÿÿÿž?€?”?€wSÿÿÿÿÿÿ¨?N€x>ÿÿÿÿÿÿ²?F¨?€yÿÿÿÿÿÿ¼?ž?²?€zSÿÿÿÿÿÿÆ?`€{>ÿÿÿÿÿÿÐ?XÆ?€|ÿÿÿÿÿÿÚ?¼?Ð?€}Sÿÿÿÿÿÿä?"j€~>ÿÿÿÿÿÿî?ä?€ÿÿÿÿÿÿø?î?[1€€Sÿÿÿÿÿÿ@"~€>ÿÿÿÿÿÿ @4@€‚ÿÿÿÿÿÿ@ø? @€ƒSÿÿÿÿÿÿ @"ˆ€„>ÿÿÿÿÿÿ*@F @€…ÿÿÿÿÿÿ4@@*@€†Sÿÿÿÿÿÿ>@"’€‡>ÿÿÿÿÿÿH@X>@€ˆÿÿÿÿÿÿR@4@H@€‰ÿÿÿÿÿÿ\@Ú?R@€ŠSÿÿÿÿÿÿf@4œ€‹>ÿÿÿÿÿÿp@f@€ŒSÿÿÿÿÿÿz@4¦€>ÿÿÿÿÿÿ„@"z@€ŽÿÿÿÿÿÿŽ@p@„@€ÿÿÿÿÿÿ˜@Ž@E2€Sÿÿÿÿÿÿ¢@4º€‘>ÿÿÿÿÿÿ¬@F¢@€’ÿÿÿÿÿÿ¶@˜@¬@€“SÿÿÿÿÿÿÀ@4Ä€”>ÿÿÿÿÿÿÊ@XÀ@€•ÿÿÿÿÿÿÔ@¶@Ê@€–ÿÿÿÿÿÿÞ@\@Ô@€—Sÿÿÿÿÿÿè@F΀˜>ÿÿÿÿÿÿò@è@€™Sÿÿÿÿÿÿü@FØ€š>ÿÿÿÿÿÿA"ü@€›ÿÿÿÿÿÿAò@A€œSÿÿÿÿÿÿAFâ€>ÿÿÿÿÿÿ$A4A€žÿÿÿÿÿÿ.AA$A€Ÿÿÿÿÿÿÿ8A.A/3€ SÿÿÿÿÿÿBAFö€¡>ÿÿÿÿÿÿLAXBA€¢ÿÿÿÿÿÿVA8ALA€£ÿÿÿÿÿÿ`AÞ@VA€¤SÿÿÿÿÿÿjAX€¥>ÿÿÿÿÿÿtAjA€¦Sÿÿÿÿÿÿ~AX €§>ÿÿÿÿÿÿˆA"~A€¨ÿÿÿÿÿÿ’AtAˆA€©SÿÿÿÿÿÿœAX€ª>ÿÿÿÿÿÿ¦A4œA€«ÿÿÿÿÿÿ°A’A¦A€¬SÿÿÿÿÿÿºAX€­>ÿÿÿÿÿÿÄAFºA€®ÿÿÿÿÿÿÎA°AÄA€¯ÿÿÿÿÿÿØAÎA4€°ÿÿÿÿÿÿâA`AØA€±SÿÿÿÿÿÿìA"€²>ÿÿÿÿÿÿöA"ìA@³ÿÿÿÿÿÿBöA€´ÿÿÿÿÿÿ B0B€µSÿÿÿÿÿÿB4€¶>ÿÿÿÿÿÿB4B@·ÿÿÿÿÿÿ'BB€¸ÿÿÿÿÿÿ0B B'B€¹Sÿÿÿÿÿÿ:BF€º>ÿÿÿÿÿÿDBF:B@»ÿÿÿÿÿÿNBDB€¼ÿÿÿÿÿÿWB0BNB€½SÿÿÿÿÿÿaBX€¾>ÿÿÿÿÿÿkBXaB@¿ÿÿÿÿÿÿuBkB€Àÿÿÿÿÿÿ~BWBuB€ÁSÿÿÿÿÿÿˆBt€Â>ÿÿÿÿÿÿ’BˆB@ÃÿÿÿÿÿÿœB’B€Äÿÿÿÿÿÿ¥BœBe1€ÅSÿÿÿÿÿÿ¯B4t€Æ>ÿÿÿÿÿÿ¹B4¯B@ÇÿÿÿÿÿÿÃB¹B€ÈÿÿÿÿÿÿÌB¥BÃB€ÉSÿÿÿÿÿÿÖBFt€Ê>ÿÿÿÿÿÿàBFÖB@ËÿÿÿÿÿÿêBàB€ÌÿÿÿÿÿÿóBÌBêB€ÍSÿÿÿÿÿÿýBXt€Î>ÿÿÿÿÿÿCXýB@ÏÿÿÿÿÿÿCC€ÐÿÿÿÿÿÿCóBC€Ñÿÿÿÿÿÿ$C~BC€ÒSÿÿÿÿÿÿ.C°€Ó>ÿÿÿÿÿÿ8C.C@ÔÿÿÿÿÿÿBC8C€ÕSÿÿÿÿÿÿKC"°€Ö>ÿÿÿÿÿÿUC"KC@×ÿÿÿÿÿÿ_CUC€ØÿÿÿÿÿÿhCBC_C€ÙÿÿÿÿÿÿrChCO2€ÚSÿÿÿÿÿÿ|CF°€Û>ÿÿÿÿÿÿ†CF|C@ÜÿÿÿÿÿÿC†C€Ýÿÿÿÿÿÿ™CrCC€ÞSÿÿÿÿÿÿ£CX°€ß>ÿÿÿÿÿÿ­CX£C@àÿÿÿÿÿÿ·C­C€áÿÿÿÿÿÿÀC™C·C€âÿÿÿÿÿÿÊC$CÀC€ãSÿÿÿÿÿÿÔCì€ä>ÿÿÿÿÿÿÞCÔC@åÿÿÿÿÿÿèCÞC€æSÿÿÿÿÿÿñC"ì€ç>ÿÿÿÿÿÿûC"ñC@èÿÿÿÿÿÿDûC€éÿÿÿÿÿÿDèCD€êSÿÿÿÿÿÿD4ì€ë>ÿÿÿÿÿÿ"D4D@ìÿÿÿÿÿÿ,D"D€íÿÿÿÿÿÿ5DD,D€îÿÿÿÿÿÿ?D5D93€ïSÿÿÿÿÿÿIDXì€ð>ÿÿÿÿÿÿSDXID@ñÿÿÿÿÿÿ]DSD€òÿÿÿÿÿÿfD?D]D€óÿÿÿÿÿÿpDÊCfD€ôSÿÿÿÿÿÿzD(€õ>ÿÿÿÿÿÿ„DzD@öÿÿÿÿÿÿŽD„D€÷Sÿÿÿÿÿÿ—D"(€ø>ÿÿÿÿÿÿ¡D"—D@ùÿÿÿÿÿÿ«D¡D€úÿÿÿÿÿÿ´DŽD«D€ûSÿÿÿÿÿÿ¾D4(€ü>ÿÿÿÿÿÿÈD4¾D@ýÿÿÿÿÿÿÒDÈD€þÿÿÿÿÿÿÛD´DÒD€ÿSÿÿÿÿÿÿåDF(€>ÿÿÿÿÿÿïDFåD@ÿÿÿÿÿÿùDïD€ÿÿÿÿÿÿEÛDùD€ÿÿÿÿÿÿ EE#4€ÿÿÿÿÿÿEpD E€ÿÿÿÿÿÿ E¦+€ÿÿÿÿÿÿ*E Eñ€ÿÿÿÿÿÿ4E*E·€ÿÿÿÿÿÿ>E4E}€ ÿÿÿÿÿÿHE€€ ÿÿÿÿÿÿREHE'€ ÿÿÿÿÿÿ\EREí€ ÿÿÿÿÿÿfE\E³€ ÿÿÿÿÿÿpE>EfE€ÿÿÿÿÿÿzE’|€ÿÿÿÿÿÿ„EzEv€ÿÿÿÿÿÿŽE„E€ÿÿÿÿÿÿ˜EŽE×€ÿÿÿÿÿÿ¢EpE˜E€ÿÿÿÿÿÿ¬E¤Ž€ÿÿÿÿÿÿ¶E¬Ef€ÿÿÿÿÿÿÀE¶Eè€ÿÿÿÿÿÿÊEÀEé€ÿÿÿÿÿÿÔE¢EÊE€ÿÿÿÿÿÿÞE¶ €ÿÿÿÿÿÿèEÞEx€ÿÿÿÿÿÿòEèE>€ÿÿÿÿÿÿüEòEZ€ÿÿÿÿÿÿFÔEüE€ÿÿÿÿÿÿF¦2€ÿÿÿÿÿÿFw€ÿÿÿÿÿÿ$FFF€ ÿÿÿÿÿÿ.F‰€!ÿÿÿÿÿÿ8F$F.F€"ÿÿÿÿÿÿBF›€#ÿÿÿÿÿÿLF8FBF€$ÿÿÿÿÿÿVF­ø€%ÿÿÿÿÿÿ`FLFVF€&ÿÿÿÿÿÿjF€Œ€'ÿÿÿÿÿÿtF¯v€(ÿÿÿÿÿÿ~FjFtF€)ÿÿÿÿÿÿˆF¿j€*ÿÿÿÿÿÿ’F~FˆF€+ÿÿÿÿÿÿœFÑ^€,ÿÿÿÿÿÿ¦F’FœF€-ÿÿÿÿÿÿ°FãR €.ÿÿÿÿÿÿºF¦F°F€/ÿÿÿÿÿÿÄF`FºF€0ÿÿÿÿÿÿÎF’ð€1ÿÿÿÿÿÿØFÈÚ€2ÿÿÿÿÿÿâFÎFØF€3ÿÿÿÿÿÿìFÂ΀4ÿÿÿÿÿÿöFâFìF€5ÿÿÿÿÿÿGõ€6ÿÿÿÿÿÿ GöFG€7ÿÿÿÿÿÿG¶ €8ÿÿÿÿÿÿG GG€9ÿÿÿÿÿÿ(GÄFG€:ÿÿÿÿÿÿ2G¤T€;ÿÿÿÿÿÿ€<ÿÿÿÿÿÿFG2GÿÿÿÿÿÿZGFGPG€?ÿÿÿÿÿÿdGÕ&€@ÿÿÿÿÿÿnGZGdG€AÿÿÿÿÿÿxG €Bÿÿÿÿÿÿ‚GnGxG€CÿÿÿÿÿÿŒG(G‚G€Dÿÿÿÿÿÿ–G¶¸€Eÿÿÿÿÿÿ G좀FÿÿÿÿÿÿªG–G G€Gÿÿÿÿÿÿ´G–€Hÿÿÿÿÿÿ¾GªG´G€IÿÿÿÿÿÿÈG"Š€JÿÿÿÿÿÿÒG¾GÈG€KÿÿÿÿÿÿÜGè~ €LÿÿÿÿÿÿæGÒGÜG€MÿÿÿÿÿÿðGŒGæG€NÿÿÿÿÿÿúGû<€OÿÿÿÿÿÿH+&€PÿÿÿÿÿÿHúGH€QÿÿÿÿÿÿH=€Rÿÿÿÿÿÿ"HHH€Sÿÿÿÿÿÿ,HO€Tÿÿÿÿÿÿ6H"H,H€Uÿÿÿÿÿÿ@Ha €VÿÿÿÿÿÿJH6H@H€WÿÿÿÿÿÿTH4–€Xÿÿÿÿÿÿ^H€€YÿÿÿÿÿÿhHTH^H€ZÿÿÿÿÿÿrHst€[ÿÿÿÿÿÿ|HhHrH€\ÿÿÿÿÿÿ†H…h€]ÿÿÿÿÿÿH|H†H€^ÿÿÿÿÿÿšH—\ €_ÿÿÿÿÿÿ¤HHšH€`ÿÿÿÿÿÿ®HJH¤H€aÿÿÿÿÿÿ¸HFú€bÿÿÿÿÿÿÂH|ä€cÿÿÿÿÿÿÌH¸HÂH€dÿÿÿÿÿÿÖHØ€eÿÿÿÿÿÿàHÌHÖH€fÿÿÿÿÿÿêH©Ì€gÿÿÿÿÿÿôHàHêH€hÿÿÿÿÿÿþH»À €iÿÿÿÿÿÿIôHþH€jÿÿÿÿÿÿI®HI€kÿÿÿÿÿÿIX^€lÿÿÿÿÿÿ&IŽH€mÿÿÿÿÿÿ0II&I€nÿÿÿÿÿÿ:I²<€oÿÿÿÿÿÿDI0I:I€pÿÿÿÿÿÿNI*0€qÿÿÿÿÿÿXIDINI€rÿÿÿÿÿÿbIÍ$ €sÿÿÿÿÿÿlIXIbI€tÿÿÿÿÿÿvIIlI€uÿÿÿÿÿÿ€Ij€vÿÿÿÿÿÿŠI ¬€wÿÿÿÿÿÿ”I€IŠI€xÿÿÿÿÿÿžIÄ €yÿÿÿÿÿÿ¨I”IžI€zÿÿÿÿÿÿ²IÖ”€{ÿÿÿÿÿÿ¼I¨I²I€|ÿÿÿÿÿÿÆI=ˆ €}ÿÿÿÿÿÿÐI¼IÆI€~ÿÿÿÿÿÿÚIvIÐI€ÿÿÿÿÿÿäIðGÚI€€ÿÿÿÿÿÿîIZP€ÿÿÿÿÿÿøIß:€‚ÿÿÿÿÿÿJîIøI€ƒÿÿÿÿÿÿ Jñ.€„ÿÿÿÿÿÿJJ J€…ÿÿÿÿÿÿ J"€†ÿÿÿÿÿÿ*JJ J€‡ÿÿÿÿÿÿ4J €ˆÿÿÿÿÿÿ>J*J4J€‰ÿÿÿÿÿÿHJ誀ŠÿÿÿÿÿÿRJc”€‹ÿÿÿÿÿÿ\JHJRJ€ŒÿÿÿÿÿÿfJ'ˆ€ÿÿÿÿÿÿpJ\JfJ€ŽÿÿÿÿÿÿzJ9|€ÿÿÿÿÿÿ„JpJzJ€ÿÿÿÿÿÿŽJKp €‘ÿÿÿÿÿÿ˜J„JŽJ€’ÿÿÿÿÿÿ¢J>J˜J€“ÿÿÿÿÿÿ¬Jú€”ÿÿÿÿÿÿ¶J0ø€•ÿÿÿÿÿÿÀJ¬J¶J€–ÿÿÿÿÿÿÊJv쀗ÿÿÿÿÿÿÔJÀJÊJ€˜ÿÿÿÿÿÿÞJ]à€™ÿÿÿÿÿÿèJÔJÞJ€šÿÿÿÿÿÿòJoÔ €›ÿÿÿÿÿÿüJèJòJ€œÿÿÿÿÿÿK¢JüJ€ÿÿÿÿÿÿK r€žÿÿÿÿÿÿKB\€Ÿÿÿÿÿÿÿ$KKK€ ÿÿÿÿÿÿ.KfP€¡ÿÿÿÿÿÿ8K$K.K€¢ÿÿÿÿÿÿBK‰D€£ÿÿÿÿÿÿLK8KBK€¤ÿÿÿÿÿÿVK8 €¥ÿÿÿÿÿÿ`KLKVK€¦ÿÿÿÿÿÿjKK`K€§ÿÿÿÿÿÿtKÖ€¨ÿÿÿÿÿÿ~KTÀ€©ÿÿÿÿÿÿˆKtK~K€ªÿÿÿÿÿÿ’Kx´€«ÿÿÿÿÿÿœKˆK’K€¬ÿÿÿÿÿÿ¦KŠ¨€­ÿÿÿÿÿÿ°KœK¦K€®ÿÿÿÿÿÿºKœœ €¯ÿÿÿÿÿÿÄK°KºK€°ÿÿÿÿÿÿÎKjKÄK€±ÿÿÿÿÿÿØKäIÎK€²ÿÿÿÿÿÿâK¹d€³ÿÿÿÿÿÿìK“N€´ÿÿÿÿÿÿöKâKìK€µÿÿÿÿÿÿL¥B€¶ÿÿÿÿÿÿ LöKL€·ÿÿÿÿÿÿL·6€¸ÿÿÿÿÿÿL LL€¹ÿÿÿÿÿÿ(LÉ* €ºÿÿÿÿÿÿ2LL(L€»ÿÿÿÿÿÿ¼€ßÿÿÿÿÿÿ¤MMšM€àÿÿÿÿÿÿ®Mû° €áÿÿÿÿÿÿ¸M¤M®M€âÿÿÿÿÿÿÂM^M¸M€ãÿÿÿÿÿÿÌMØKÂM€äÿÿÿÿÿÿÖMx€åÿÿÿÿÿÿàMGb€æÿÿÿÿÿÿêMÖMàM€çÿÿÿÿÿÿôMYV€èÿÿÿÿÿÿþMêMôM€éÿÿÿÿÿÿNkJ€êÿÿÿÿÿÿNþMN€ëÿÿÿÿÿÿN}> €ìÿÿÿÿÿÿ&NNN€íÿÿÿÿÿÿ0NPÒ€îÿÿÿÿÿÿ:N!¼€ïÿÿÿÿÿÿDN0N:N€ðÿÿÿÿÿÿNN°€ñÿÿÿÿÿÿXNDNNN€òÿÿÿÿÿÿbN¡¤€óÿÿÿÿÿÿlNXNbN€ôÿÿÿÿÿÿvN³˜ €õÿÿÿÿÿÿ€NlNvN€öÿÿÿÿÿÿŠN&N€N€÷ÿÿÿÿÿÿ”Nb6€øÿÿÿÿÿÿžN˜ €ùÿÿÿÿÿÿ¨N”NžN€úÿÿÿÿÿÿ²N4€ûÿÿÿÿÿÿ¼N¨N²N€üÿÿÿÿÿÿÆNÅ€ýÿÿÿÿÿÿÐN¼NÆN€þÿÿÿÿÿÿÚN×ü €ÿÿÿÿÿÿÿäNÐNÚN€ÿÿÿÿÿÿîNŠNäN€ÿÿÿÿÿÿøNtš€ÿÿÿÿÿÿOª„€ÿÿÿÿÿÿ OøNO€ÿÿÿÿÿÿOÎx€ÿÿÿÿÿÿ O OO€ÿÿÿÿÿÿ*OGl€ÿÿÿÿÿÿ4O O*O€ÿÿÿÿÿÿ>Oé` € ÿÿÿÿÿÿHO4O>O€ ÿÿÿÿÿÿROîNHO€ ÿÿÿÿÿÿ\O†þ€ ÿÿÿÿÿÿfO¼è€ ÿÿÿÿÿÿpO\OfO€ÿÿÿÿÿÿzOàÜ€ÿÿÿÿÿÿ„OpOzO€ÿÿÿÿÿÿŽOòЀÿÿÿÿÿÿ˜O„OŽO€ÿÿÿÿÿÿ¢OZÄ €ÿÿÿÿÿÿ¬O˜O¢O€ÿÿÿÿÿÿ¶ORO¬O€ÿÿÿÿÿÿÀOÌM¶O€ÿÿÿÿÿÿÊO2¦€ÿÿÿÿÿÿÔOŒû€ÿÿÿÿÿÿÞOÊOÔO€ÿÿÿÿÿÿèOðZ€ÿÿÿÿÿÿòOÞOèO€ÿÿÿÿÿÿüOT¹€ÿÿÿÿÿÿPòOüO€ÿÿÿÿÿÿP¸€ÿÿÿÿÿÿPPP€ÿÿÿÿÿÿ$P€€ ÿÿÿÿÿÿ.Pv4€!ÿÿÿÿÿÿ8P$P.P€"ÿÿÿÿÿÿBPÚè€#ÿÿÿÿÿÿLP8PBP€$ÿÿÿÿÿÿVP>œ€%ÿÿÿÿÿÿ`PLPVP€&ÿÿÿÿÿÿjP¢P€'ÿÿÿÿÿÿtP`PjP€(ÿÿÿÿÿÿ~PPtP€)ÿÿÿÿÿÿˆP’€*ÿÿÿÿÿÿ’PjF€+ÿÿÿÿÿÿœPˆP’P€,ÿÿÿÿÿÿ¦PÎú€-ÿÿÿÿÿÿ°PœP¦P€.ÿÿÿÿÿÿºP2®€/ÿÿÿÿÿÿÄP°PºP€0ÿÿÿÿÿÿÎP–b€1ÿÿÿÿÿÿØPÄPÎP€2ÿÿÿÿÿÿâP~PØP€3ÿÿÿÿÿÿìP¤€4ÿÿÿÿÿÿöP^X€5ÿÿÿÿÿÿQìPöP€6ÿÿÿÿÿÿ Q €7ÿÿÿÿÿÿQQ Q€8ÿÿÿÿÿÿQ&À€9ÿÿÿÿÿÿ(QQQ€:ÿÿÿÿÿÿ2QŠt€;ÿÿÿÿÿÿÿÿÿÿÿÿZQR j€?ÿÿÿÿÿÿdQPQZQ€@ÿÿÿÿÿÿnQ¶ €AÿÿÿÿÿÿxQdQnQ€Bÿÿÿÿÿÿ‚Q Ò€CÿÿÿÿÿÿŒQxQ‚Q€Dÿÿÿÿÿÿ–Q~ †€Eÿÿÿÿÿÿ QŒQ–Q€FÿÿÿÿÿÿªQFQ Q€Gÿÿÿÿÿÿ´Q<w€Hÿÿÿÿÿÿ¾Q–+€IÿÿÿÿÿÿÈQ´Q¾Q€JÿÿÿÿÿÿÒQú߀KÿÿÿÿÿÿÜQÈQÒQ€LÿÿÿÿÿÿæQ^“€MÿÿÿÿÿÿðQÜQæQ€NÿÿÿÿÿÿúQÂG€OÿÿÿÿÿÿRðQúQ€PÿÿÿÿÿÿR&¯€QÿÿÿÿÿÿR€€Rÿÿÿÿÿÿ"RRR€Sÿÿÿÿÿÿ,Räc€Tÿÿÿÿÿÿ6R"R,R€Uÿÿÿÿÿÿ@RH€VÿÿÿÿÿÿJR6R@R€WÿÿÿÿÿÿTR¬!€Xÿÿÿÿÿÿ^RJRTR€YÿÿÿÿÿÿhRR^R€ZÿÿÿÿÿÿrRÈ€[ÿÿÿÿÿÿ|Rt|€\ÿÿÿÿÿÿ†RrR|R€]ÿÿÿÿÿÿRØ0€^ÿÿÿÿÿÿšR†RR€_ÿÿÿÿÿÿ¤R<ä€`ÿÿÿÿÿÿ®RšR¤R€aÿÿÿÿÿÿ¸R ˜€bÿÿÿÿÿÿÂR®R¸R€cÿÿÿÿÿÿÌRhRÂR€dÿÿÿÿÿÿÖRÚ€eÿÿÿÿÿÿàRhŽ€fÿÿÿÿÿÿêRÖRàR€gÿÿÿÿÿÿôRÌB€hÿÿÿÿÿÿþRêRôR€iÿÿÿÿÿÿS0ö€jÿÿÿÿÿÿSþRS€kÿÿÿÿÿÿS”ª€lÿÿÿÿÿÿ&SSS€mÿÿÿÿÿÿ0SÌR&S€nÿÿÿÿÿÿ:S ì€oÿÿÿÿÿÿDS\  €pÿÿÿÿÿÿNS:SDS€qÿÿÿÿÿÿXSÀ T€rÿÿÿÿÿÿbSNSXS€sÿÿÿÿÿÿlS$ €tÿÿÿÿÿÿvSbSlS€uÿÿÿÿÿÿ€Sˆ ¼€vÿÿÿÿÿÿŠSvS€S€wÿÿÿÿÿÿ”S0SŠS€xÿÿÿÿÿÿžSªQ”S€yÿÿÿÿÿÿ¨SP‰€zÿÿÿÿÿÿ²Sª=€{ÿÿÿÿÿÿ¼S¨S²S€|ÿÿÿÿÿÿÆSñ€}ÿÿÿÿÿÿÐS¼SÆS€~ÿÿÿÿÿÿÚSr¥€ÿÿÿÿÿÿäSÐSÚS€€ÿÿÿÿÿÿîSÖY€ÿÿÿÿÿÿøSäSîS€‚ÿÿÿÿÿÿT:¿€ƒÿÿÿÿÿÿ T”s€„ÿÿÿÿÿÿTT T€…ÿÿÿÿÿÿ Tø'€†ÿÿÿÿÿÿ*TT T€‡ÿÿÿÿÿÿ4T\Û€ˆÿÿÿÿÿÿ>T*T4T€‰ÿÿÿÿÿÿHTÀ€ŠÿÿÿÿÿÿRT>THT€‹ÿÿÿÿÿÿ\TøSRT€ŒÿÿÿÿÿÿfT.€ÿÿÿÿÿÿpTˆ€ŽÿÿÿÿÿÿzTfTpT€ÿÿÿÿÿÿ„Tìv€ÿÿÿÿÿÿŽTzT„T€‘ÿÿÿÿÿÿ˜TPÕ€’ÿÿÿÿÿÿ¢TŽT˜T€“ÿÿÿÿÿÿ¬T´4€”ÿÿÿÿÿÿ¶T¢T¬T€•ÿÿÿÿÿÿÀT\T¶T€–ÿÿÿÿÿÿÊT"þ€—ÿÿÿÿÿÿÔT|²€˜ÿÿÿÿÿÿÞTÊTÔT€™ÿÿÿÿÿÿèTàf€šÿÿÿÿÿÿòTÞTèT€›ÿÿÿÿÿÿüTD€œÿÿÿÿÿÿUòTüT€ÿÿÿÿÿÿU¨Î€žÿÿÿÿÿÿUUU€Ÿÿÿÿÿÿÿ$UÀTU€ ÿÿÿÿÿÿ.U €¡ÿÿÿÿÿÿ8Up Ä€¢ÿÿÿÿÿÿBU.U8U€£ÿÿÿÿÿÿLUÔ x€¤ÿÿÿÿÿÿVUBULU€¥ÿÿÿÿÿÿ`U8 ,€¦ÿÿÿÿÿÿjUVU`U€§ÿÿÿÿÿÿtUœ à€¨ÿÿÿÿÿÿ~UjUtU€©ÿÿÿÿÿÿˆU$U~U€ªÿÿÿÿÿÿ’UžSˆU€«ÿÿÿÿÿÿœUd›€¬ÿÿÿÿÿÿ¦U¾O€­ÿÿÿÿÿÿ°UœU¦U€®ÿÿÿÿÿÿºU"€¯ÿÿÿÿÿÿÄU°UºU€°ÿÿÿÿÿÿÎU†·€±ÿÿÿÿÿÿØUÄUÎU€²ÿÿÿÿÿÿâUêk€³ÿÿÿÿÿÿìUØUâU€´ÿÿÿÿÿÿöUNÑ€µÿÿÿÿÿÿV¨…€¶ÿÿÿÿÿÿ VöUV€·ÿÿÿÿÿÿV 9€¸ÿÿÿÿÿÿV VV€¹ÿÿÿÿÿÿ(Vp퀺ÿÿÿÿÿÿ2VV(V€»ÿÿÿÿÿÿ€Øÿÿÿÿÿÿ^WJWTW€ÙÿÿÿÿÿÿhW° ò€ÚÿÿÿÿÿÿrW^WhW€Ûÿÿÿÿÿÿ|WWrW€Üÿÿÿÿÿÿ†W’U|W€ÝÿÿÿÿÿÿWx­€ÞÿÿÿÿÿÿšWÒa€ßÿÿÿÿÿÿ¤WWšW€àÿÿÿÿÿÿ®W6€áÿÿÿÿÿÿ¸W¤W®W€âÿÿÿÿÿÿÂWšÉ€ãÿÿÿÿÿÿÌW¸WÂW€äÿÿÿÿÿÿÖWþ}€åÿÿÿÿÿÿàWÌWÖW€æÿÿÿÿÿÿêWbã€çÿÿÿÿÿÿôW¼—€èÿÿÿÿÿÿþWêWôW€éÿÿÿÿÿÿX K€êÿÿÿÿÿÿXþWX€ëÿÿÿÿÿÿX„ÿ€ìÿÿÿÿÿÿ&XXX€íÿÿÿÿÿÿ0Xè³€îÿÿÿÿÿÿ:X&X0X€ïÿÿÿÿÿÿDXàW:X€ðÿÿÿÿÿÿNXV€ñÿÿÿÿÿÿXX°»€òÿÿÿÿÿÿbXNXXX€óÿÿÿÿÿÿlXo€ôÿÿÿÿÿÿvXbXlX€õÿÿÿÿÿÿ€Xx#€öÿÿÿÿÿÿŠXvX€X€÷ÿÿÿÿÿÿ”XÜ×€øÿÿÿÿÿÿžXŠX”X€ùÿÿÿÿÿÿ¨XDXžX€úÿÿÿÿÿÿ²XJ€ûÿÿÿÿÿÿ¼X¤Í€üÿÿÿÿÿÿÆX²X¼X€ýÿÿÿÿÿÿÐX€þÿÿÿÿÿÿÚXÆXÐX€ÿÿÿÿÿÿÿäXl5€ ÿÿÿÿÿÿîXÚXäX€ ÿÿÿÿÿÿøXÐé€ ÿÿÿÿÿÿYîXøX€ ÿÿÿÿÿÿ Y¨XY€ ÿÿÿÿÿÿY> è€ ÿÿÿÿÿÿ Y˜ =€ ÿÿÿÿÿÿ*YY Y€ ÿÿÿÿÿÿ4Yü œ€ ÿÿÿÿÿÿ>Y*Y4Y€ ÿÿÿÿÿÿHY` û€ ÿÿÿÿÿÿRY>YHY€ ÿÿÿÿÿÿ\YÄ Z€ ÿÿÿÿÿÿfYRY\Y€ ÿÿÿÿÿÿpY YfY€ ÿÿÿÿÿÿzY†WpY€ ÿÿÿÿÿÿ„Y÷"X'€ ÿÿÿÿÿÿŽY„Yþ'€ ÿÿÿÿÿÿ˜YŽY¤(€ ÿÿÿÿÿÿ¢Y˜YJ)€ ÿÿÿÿÿÿ¬Y¼&Í#€ ÿÿÿÿÿÿ¶Y¬Y(€ ÿÿÿÿÿÿÀY¶YÁ(€ ÿÿÿÿÿÿÊYÀYg)€ ÿÿÿÿÿÿÔY¢YÊY€ ÿÿÿÿÿÿÞYã&'€ ÿÿÿÿÿÿèYÞY·$€ ÿÿÿÿÿÿòYèYè(€ ÿÿÿÿÿÿüYòYŽ)€ ÿÿÿÿÿÿZÔYüY€ ÿÿÿÿÿÿZ '¦'€ ÿÿÿÿÿÿZZL(€ ÿÿÿÿÿÿ$ZZ¡%€ ÿÿÿÿÿÿ.Z$Zµ)€! ÿÿÿÿÿÿ8ZZ.Z€" ÿÿÿÿÿÿBZ1'Í'€# ÿÿÿÿÿÿLZBZs(€$ ÿÿÿÿÿÿVZLZ)€% ÿÿÿÿÿÿ`ZVZ‹&€& ÿÿÿÿÿÿjZ8Z`Z€' >ÿÿÿÿÿÿtZj@( ÿÿÿÿÿÿ~ZtZ€) >ÿÿÿÿÿÿ‡Zœ@* ÿÿÿÿÿÿ‘Z‡Z€+ ÿÿÿÿÿÿšZ~Z‘Z€, >ÿÿÿÿÿÿ¤ZÎ@- ÿÿÿÿÿÿ®Z¤Z€. ÿÿÿÿÿÿ·ZšZ®Z€/ >ÿÿÿÿÿÿÁZ@0 ÿÿÿÿÿÿËZÁZ€1 ÿÿÿÿÿÿÔZ·ZËZ€2 >ÿÿÿÿÿÿÞZjœ@3 ÿÿÿÿÿÿèZÞZ€4 ÿÿÿÿÿÿñZÔZèZ€5 >ÿÿÿÿÿÿûZjÎ@6 ÿÿÿÿÿÿ[ûZ€7 ÿÿÿÿÿÿ[ñZ[€8 >ÿÿÿÿÿÿ[j@9 ÿÿÿÿÿÿ"[[€: ÿÿÿÿÿÿ+[["[€; >ÿÿÿÿÿÿ5[œÎ@< ÿÿÿÿÿÿ?[5[€= ÿÿÿÿÿÿH[+[?[€> >ÿÿÿÿÿÿR[œ@? ÿÿÿÿÿÿ\[R[€@ ÿÿÿÿÿÿe[H[\[€A >ÿÿÿÿÿÿo[Î@B ÿÿÿÿÿÿy[o[€C ÿÿÿÿÿÿ‚[e[y[€D >ÿÿÿÿÿÿŒ[*t@E ÿÿÿÿÿÿ–[Œ[€F >ÿÿÿÿÿÿŸ[*¦@G ÿÿÿÿÿÿ©[Ÿ[€H ÿÿÿÿÿÿ²[–[©[€I >ÿÿÿÿÿÿ¼[*Ø@J ÿÿÿÿÿÿÆ[¼[€K ÿÿÿÿÿÿÏ[²[Æ[€L >ÿÿÿÿÿÿÙ[* @M ÿÿÿÿÿÿã[Ù[€N ÿÿÿÿÿÿì[Ï[ã[€O >ÿÿÿÿÿÿö[t¦@P ÿÿÿÿÿÿ\ö[€Q ÿÿÿÿÿÿ \ì[\€R >ÿÿÿÿÿÿ\tØ@S ÿÿÿÿÿÿ\\€T ÿÿÿÿÿÿ&\ \\€U >ÿÿÿÿÿÿ0\t @V ÿÿÿÿÿÿ:\0\€W ÿÿÿÿÿÿC\&\:\€X >ÿÿÿÿÿÿM\¦Ø@Y ÿÿÿÿÿÿW\M\€Z ÿÿÿÿÿÿ`\C\W\€[ >ÿÿÿÿÿÿj\¦ @\ ÿÿÿÿÿÿt\j\€] ÿÿÿÿÿÿ}\`\t\€^ >ÿÿÿÿÿÿ‡\Ø @_ ÿÿÿÿÿÿ‘\‡\€` ÿÿÿÿÿÿš\}\‘\€a ÿÿÿÿÿÿ¤\‚[š\€b >ÿÿÿÿÿÿ®\<~@c ÿÿÿÿÿÿ¸\®\€d >ÿÿÿÿÿÿÁ\<°@e ÿÿÿÿÿÿË\Á\€f ÿÿÿÿÿÿÔ\¸\Ë\€g >ÿÿÿÿÿÿÞ\<â@h ÿÿÿÿÿÿè\Þ\€i ÿÿÿÿÿÿñ\Ô\è\€j >ÿÿÿÿÿÿû\<@k ÿÿÿÿÿÿ]û\€l ÿÿÿÿÿÿ]ñ\]€m >ÿÿÿÿÿÿ]~°@n ÿÿÿÿÿÿ"]]€o ÿÿÿÿÿÿ+]]"]€p >ÿÿÿÿÿÿ5]~â@q ÿÿÿÿÿÿ?]5]€r ÿÿÿÿÿÿH]+]?]€s >ÿÿÿÿÿÿR]~@t ÿÿÿÿÿÿ\]R]€u ÿÿÿÿÿÿe]H]\]€v >ÿÿÿÿÿÿo]°â@w ÿÿÿÿÿÿy]o]€x ÿÿÿÿÿÿ‚]e]y]€y >ÿÿÿÿÿÿŒ]°@z ÿÿÿÿÿÿ–]Œ]€{ ÿÿÿÿÿÿŸ]‚]–]€| >ÿÿÿÿÿÿ©]â@} ÿÿÿÿÿÿ³]©]€~ ÿÿÿÿÿÿ¼]Ÿ]³]€ ÿÿÿÿÿÿÆ]¤\¼]€€ >ÿÿÿÿÿÿÐ]Nˆ@ ÿÿÿÿÿÿÚ]Ð]€‚ >ÿÿÿÿÿÿã]Nº@ƒ ÿÿÿÿÿÿí]ã]€„ ÿÿÿÿÿÿö]Ú]í]€… >ÿÿÿÿÿÿ^Nì@† ÿÿÿÿÿÿ ^^€‡ ÿÿÿÿÿÿ^ö] ^€ˆ >ÿÿÿÿÿÿ^N@‰ ÿÿÿÿÿÿ'^^€Š ÿÿÿÿÿÿ0^^'^€‹ >ÿÿÿÿÿÿ:^ˆº@Œ ÿÿÿÿÿÿD^:^€ ÿÿÿÿÿÿM^0^D^€Ž >ÿÿÿÿÿÿW^ˆì@ ÿÿÿÿÿÿa^W^€ ÿÿÿÿÿÿj^M^a^€‘ >ÿÿÿÿÿÿt^ˆ@’ ÿÿÿÿÿÿ~^t^€“ ÿÿÿÿÿÿ‡^j^~^€” >ÿÿÿÿÿÿ‘^ºì@• ÿÿÿÿÿÿ›^‘^€– ÿÿÿÿÿÿ¤^‡^›^€— >ÿÿÿÿÿÿ®^º@˜ ÿÿÿÿÿÿ¸^®^€™ ÿÿÿÿÿÿÁ^¤^¸^€š >ÿÿÿÿÿÿË^ì@› ÿÿÿÿÿÿÕ^Ë^€œ ÿÿÿÿÿÿÞ^Á^Õ^€ ÿÿÿÿÿÿè^Æ]Þ^€ž >ÿÿÿÿÿÿò^`’@Ÿ ÿÿÿÿÿÿü^ò^€  >ÿÿÿÿÿÿ_`Ä@¡ ÿÿÿÿÿÿ__€¢ ÿÿÿÿÿÿ_ü^_€£ >ÿÿÿÿÿÿ"_`ö@¤ ÿÿÿÿÿÿ,_"_€¥ ÿÿÿÿÿÿ5__,_€¦ >ÿÿÿÿÿÿ?_`(@§ ÿÿÿÿÿÿI_?_€¨ ÿÿÿÿÿÿR_5_I_€© >ÿÿÿÿÿÿ\_’Ä@ª ÿÿÿÿÿÿf_\_€« ÿÿÿÿÿÿo_R_f_€¬ >ÿÿÿÿÿÿy_’ö@­ ÿÿÿÿÿÿƒ_y_€® ÿÿÿÿÿÿŒ_o_ƒ_€¯ >ÿÿÿÿÿÿ–_’(@° ÿÿÿÿÿÿ _–_€± ÿÿÿÿÿÿ©_Œ_ _€² >ÿÿÿÿÿÿ³_Äö@³ ÿÿÿÿÿÿ½_³_€´ ÿÿÿÿÿÿÆ_©_½_€µ >ÿÿÿÿÿÿÐ_Ä(@¶ ÿÿÿÿÿÿÚ_Ð_€· ÿÿÿÿÿÿã_Æ_Ú_€¸ >ÿÿÿÿÿÿí_ö(@¹ ÿÿÿÿÿÿ÷_í_€º ÿÿÿÿÿÿ`ã_÷_€» ÿÿÿÿÿÿ `è^`€¼ >ÿÿÿÿÿÿ`*@½ ÿÿÿÿÿÿ``€¾ >ÿÿÿÿÿÿ'`<@¿ ÿÿÿÿÿÿ1`'`€À ÿÿÿÿÿÿ:``1`€Á >ÿÿÿÿÿÿD`N@ ÿÿÿÿÿÿN`D`€Ã ÿÿÿÿÿÿW`:`N`€Ä >ÿÿÿÿÿÿa``@Å ÿÿÿÿÿÿk`a`€Æ ÿÿÿÿÿÿt`W`k`€Ç >ÿÿÿÿÿÿ~`*<@È ÿÿÿÿÿÿˆ`~`€É ÿÿÿÿÿÿ‘`t`ˆ`€Ê >ÿÿÿÿÿÿ›`*N@Ë ÿÿÿÿÿÿ¥`›`€Ì ÿÿÿÿÿÿ®`‘`¥`€Í >ÿÿÿÿÿÿ¸`*`@Î ÿÿÿÿÿÿÂ`¸`€Ï ÿÿÿÿÿÿË`®`Â`€Ð >ÿÿÿÿÿÿÕ`<N@Ñ ÿÿÿÿÿÿß`Õ`€Ò ÿÿÿÿÿÿè`Ë`ß`€Ó >ÿÿÿÿÿÿò`<`@Ô ÿÿÿÿÿÿü`ò`€Õ ÿÿÿÿÿÿaè`ü`€Ö >ÿÿÿÿÿÿaN`@× ÿÿÿÿÿÿaa€Ø ÿÿÿÿÿÿ"aaa€Ù >ÿÿÿÿÿÿ,ajt@Ú ÿÿÿÿÿÿ6a,a€Û >ÿÿÿÿÿÿ?aj~@Ü ÿÿÿÿÿÿIa?a€Ý ÿÿÿÿÿÿRa6aIa€Þ >ÿÿÿÿÿÿ\ajˆ@ß ÿÿÿÿÿÿfa\a€à ÿÿÿÿÿÿoaRafa€á >ÿÿÿÿÿÿyaj’@â ÿÿÿÿÿÿƒaya€ã ÿÿÿÿÿÿŒaoaƒa€ä >ÿÿÿÿÿÿ–at~@å ÿÿÿÿÿÿ a–a€æ ÿÿÿÿÿÿ©aŒa a€ç >ÿÿÿÿÿÿ³atˆ@è ÿÿÿÿÿÿ½a³a€é ÿÿÿÿÿÿÆa©a½a€ê >ÿÿÿÿÿÿÐat’@ë ÿÿÿÿÿÿÚaÐa€ì ÿÿÿÿÿÿãaÆaÚa€í >ÿÿÿÿÿÿía~ˆ@î ÿÿÿÿÿÿ÷aía€ï ÿÿÿÿÿÿbãa÷a€ð >ÿÿÿÿÿÿ b~’@ñ ÿÿÿÿÿÿb b€ò ÿÿÿÿÿÿbbb€ó >ÿÿÿÿÿÿ'bˆ’@ô ÿÿÿÿÿÿ1b'b€õ ÿÿÿÿÿÿ:bb1b€ö ÿÿÿÿÿÿDb"a:b€÷ >ÿÿÿÿÿÿNbœ¦@ø ÿÿÿÿÿÿXbNb€ù >ÿÿÿÿÿÿabœ°@ú ÿÿÿÿÿÿkbab€û ÿÿÿÿÿÿtbXbkb€ü >ÿÿÿÿÿÿ~bœº@ý ÿÿÿÿÿÿˆb~b€þ ÿÿÿÿÿÿ‘btbˆb€ÿ >ÿÿÿÿÿÿ›bœÄ@ ÿÿÿÿÿÿ¥b›b€ ÿÿÿÿÿÿ®b‘b¥b€ >ÿÿÿÿÿÿ¸b¦°@ ÿÿÿÿÿÿÂb¸b€ ÿÿÿÿÿÿËb®bÂb€ >ÿÿÿÿÿÿÕb¦º@ ÿÿÿÿÿÿßbÕb€ ÿÿÿÿÿÿèbËbßb€ >ÿÿÿÿÿÿòb¦Ä@ ÿÿÿÿÿÿübòb€ ÿÿÿÿÿÿcèbüb€ >ÿÿÿÿÿÿc°º@ ÿÿÿÿÿÿcc€ ÿÿÿÿÿÿ"ccc€ >ÿÿÿÿÿÿ,c°Ä@ ÿÿÿÿÿÿ6c,c€ ÿÿÿÿÿÿ?c"c6c€ >ÿÿÿÿÿÿIcºÄ@ ÿÿÿÿÿÿScIc€ ÿÿÿÿÿÿ\c?cSc€ ÿÿÿÿÿÿfcDb\c€ >ÿÿÿÿÿÿpcÎØ@ ÿÿÿÿÿÿzcpc€ >ÿÿÿÿÿÿƒcÎâ@ ÿÿÿÿÿÿcƒc€ ÿÿÿÿÿÿ–czcc€ >ÿÿÿÿÿÿ cÎì@ ÿÿÿÿÿÿªc c€ ÿÿÿÿÿÿ³c–cªc€ >ÿÿÿÿÿÿ½cÎö@ ÿÿÿÿÿÿÇc½c€ ÿÿÿÿÿÿÐc³cÇc€ >ÿÿÿÿÿÿÚcØâ@! ÿÿÿÿÿÿäcÚc€" ÿÿÿÿÿÿícÐcäc€# >ÿÿÿÿÿÿ÷cØì@$ ÿÿÿÿÿÿd÷c€% ÿÿÿÿÿÿ dícd€& >ÿÿÿÿÿÿdØö@' ÿÿÿÿÿÿdd€( ÿÿÿÿÿÿ'd dd€) >ÿÿÿÿÿÿ1dâì@* ÿÿÿÿÿÿ;d1d€+ ÿÿÿÿÿÿDd'd;d€, >ÿÿÿÿÿÿNdâö@- ÿÿÿÿÿÿXdNd€. ÿÿÿÿÿÿadDdXd€/ >ÿÿÿÿÿÿkdìö@0 ÿÿÿÿÿÿudkd€1 ÿÿÿÿÿÿ~dadud€2 ÿÿÿÿÿÿˆdfc~d€3 >ÿÿÿÿÿÿ’d @4 ÿÿÿÿÿÿœd’d€5 >ÿÿÿÿÿÿ¥d@6 ÿÿÿÿÿÿ¯d¥d€7 ÿÿÿÿÿÿ¸dœd¯d€8 >ÿÿÿÿÿÿÂd@9 ÿÿÿÿÿÿÌdÂd€: ÿÿÿÿÿÿÕd¸dÌd€; >ÿÿÿÿÿÿßd(@< ÿÿÿÿÿÿédßd€= ÿÿÿÿÿÿòdÕdéd€> >ÿÿÿÿÿÿüd @? ÿÿÿÿÿÿeüd€@ ÿÿÿÿÿÿeòde€A >ÿÿÿÿÿÿe @B ÿÿÿÿÿÿ#ee€C ÿÿÿÿÿÿ,ee#e€D >ÿÿÿÿÿÿ6e (@E ÿÿÿÿÿÿ@e6e€F ÿÿÿÿÿÿIe,e@e€G >ÿÿÿÿÿÿSe@H ÿÿÿÿÿÿ]eSe€I ÿÿÿÿÿÿfeIe]e€J >ÿÿÿÿÿÿpe(@K ÿÿÿÿÿÿzepe€L ÿÿÿÿÿÿƒefeze€M >ÿÿÿÿÿÿe(@N ÿÿÿÿÿÿ—ee€O ÿÿÿÿÿÿ eƒe—e€P ÿÿÿÿÿÿªeˆd e€Q ÿÿÿÿÿÿ´e `ªe€R >ÿÿÿÿÿÿ¾e"@S ÿÿÿÿÿÿÈe¾e€T >ÿÿÿÿÿÿÑe4@U ÿÿÿÿÿÿÛeÑe€V ÿÿÿÿÿÿäeÈeÛe€W >ÿÿÿÿÿÿîeF@X ÿÿÿÿÿÿøeîe€Y ÿÿÿÿÿÿfäeøe€Z >ÿÿÿÿÿÿ fX@[ ÿÿÿÿÿÿf f€\ ÿÿÿÿÿÿfff€] >ÿÿÿÿÿÿ(f"4@^ ÿÿÿÿÿÿ2f(f€_ ÿÿÿÿÿÿ;ff2f€` >ÿÿÿÿÿÿEf"F@a ÿÿÿÿÿÿOfEf€b ÿÿÿÿÿÿXf;fOf€c >ÿÿÿÿÿÿbf"X@d ÿÿÿÿÿÿlfbf€e ÿÿÿÿÿÿufXflf€f >ÿÿÿÿÿÿf4F@g ÿÿÿÿÿÿ‰ff€h ÿÿÿÿÿÿ’fuf‰f€i >ÿÿÿÿÿÿœf4X@j ÿÿÿÿÿÿ¦fœf€k ÿÿÿÿÿÿ¯f’f¦f€l >ÿÿÿÿÿÿ¹fFX@m ÿÿÿÿÿÿÃf¹f€n ÿÿÿÿÿÿÌf¯fÃf€o ÿÿÿÿÿÿÖfÎú€p ÿÿÿÿÿÿàfÖf €q ÿÿÿÿÿÿêfàfV€r ÿÿÿÿÿÿôfP¾€s ÿÿÿÿÿÿþfôfú€t ÿÿÿÿÿÿgþfT€u ÿÿÿÿÿÿggþ€v ÿÿÿÿÿÿgg&€w ÿÿÿÿÿÿ&ggv€x ÿÿÿÿÿÿ0g&g €y ÿÿÿÿÿÿ:g0g„€z ÿÿÿÿÿÿDg:gÀ€{ ÿÿÿÿÿÿNgDgV€| ÿÿÿÿÿÿXgNgt€} ÿÿÿÿÿÿbgXg΀~ ÿÿÿÿÿÿlgbgP€ ÿÿÿÿÿÿvglgÈ€€ ÿÿÿÿÿÿ€gvg€ ÿÿÿÿÿÿŠg€g|€‚ ÿÿÿÿÿÿ”gŠg€ƒ ÿÿÿÿÿÿžg”gX€„ ÿÿÿÿÿÿ¨gžg”€… ÿÿÿÿÿÿ²g¨g* €† ÿÿÿÿÿÿ¼g²g˜ €‡ ÿÿÿÿÿÿÆg¼gÔ €ˆ ÿÿÿÿÿÿÐgÆg$ €‰ ÿÿÿÿÿÿÚgÐg~ @Š ÿÿÿÿÿÿägÚg€‹ ÿÿÿÿÿÿígg€Œ ÿÿÿÿÿÿ÷gíg”€ ÿÿÿÿÿÿh÷g €Ž ÿÿÿÿÿÿ hh„€ ÿÿÿÿÿÿh h¬€ ÿÿÿÿÿÿhhV€‘ ÿÿÿÿÿÿ)hht€’ ÿÿÿÿÿÿ3h)h΀“ ÿÿÿÿÿÿ=h3hP€” ÿÿÿÿÿÿGh=hÈ€• ÿÿÿÿÿÿQhGh€– ÿÿÿÿÿÿ[hQh¤€— ÿÿÿÿÿÿeh[hà€˜ ÿÿÿÿÿÿohehX€™ ÿÿÿÿÿÿyhohŠ€š ÿÿÿÿÿÿƒhyh* €› ÿÿÿÿÿÿhƒhR €œ ÿÿÿÿÿÿ—hhü € ÿÿÿÿÿÿ¡h—h$ €ž ÿÿÿÿÿÿ«h¡hœ @Ÿ ÿÿÿÿÿÿµh«h  ÿÿÿÿÿÿ¾hâ œm±"Ù"ž&Ò)Â*¬,q064¢6b?âAEFÀOzYjZ´eÌfêfägµh€¡ SÿÿÿÿÿÿÞhœ~€¢ >ÿÿÿÿÿÿèh<Þh€£ >ÿÿÿÿÿÿòhœê'€¤ Sÿÿÿÿÿÿühœ<€¥ >ÿÿÿÿÿÿi°üh€¦ Sÿÿÿÿÿÿiœ°€§ >ÿÿÿÿÿÿi~i€¨ Sÿÿÿÿÿÿ$i~œ€© >ÿÿÿÿÿÿ.i°$i€ª >ÿÿÿÿÿÿ8i~³-€« >ÿÿÿÿÿÿBi4|$€¬ SÿÿÿÿÿÿLi~<€­ >ÿÿÿÿÿÿViœLi€® Sÿÿÿÿÿÿ`i~°€¯ >ÿÿÿÿÿÿji<`i€° >ÿÿÿÿÿÿti~f@€± >ÿÿÿÿÿÿ~i4x1€² >ÿÿÿÿÿÿˆi°°€³ >ÿÿÿÿÿÿ’i<¿0€´ >ÿÿÿÿÿÿœiœ;2€µ Sÿÿÿÿÿÿ¦i<œ€¶ >ÿÿÿÿÿÿ°i<¦i€· Sÿÿÿÿÿÿºi<~€¸ >ÿÿÿÿÿÿÄiœºi€¹ >ÿÿÿÿÿÿÎi~_$€º SÿÿÿÿÿÿØi<°€» >ÿÿÿÿÿÿâi°Øi€¼ Sÿÿÿÿÿÿìi°œ€½ >ÿÿÿÿÿÿöiœìi€¾ Sÿÿÿÿÿÿj°~€¿ >ÿÿÿÿÿÿ j°j€À >ÿÿÿÿÿÿj<£$€Á Sÿÿÿÿÿÿj°<€Â >ÿÿÿÿÿÿ(j~j€Ã ÿÿÿÿÿÿ2j€.(j€Ä ÿÿÿÿÿÿÿÿÿÿÿÿ+k°2.€Ý >ÿÿÿÿÿÿ5k4ê'€Þ >ÿÿÿÿÿÿ?kœüh€ß >ÿÿÿÿÿÿIk<$i€à >ÿÿÿÿÿÿSkœ|$€á >ÿÿÿÿÿÿ]k4Li€â >ÿÿÿÿÿÿgk°`i€ã >ÿÿÿÿÿÿqk4¦i€ä >ÿÿÿÿÿÿ{k°ú,€å >ÿÿÿÿÿÿ…k<Øi€æ ÿÿÿÿÿÿkPj…k€ç ÿÿÿÿÿÿ™kk{k€è ÿÿÿÿÿÿ£k™kÎi€é ÿÿÿÿÿÿ­k£kÄi€ê ÿÿÿÿÿÿ·k­kqk€ë ÿÿÿÿÿÿÁk·kœi€ì ÿÿÿÿÿÿËkÁk’i€í ÿÿÿÿÿÿÕkËkˆi€î ÿÿÿÿÿÿßkÕk~i€ï ÿÿÿÿÿÿékßkti€ð ÿÿÿÿÿÿókékgk€ñ ÿÿÿÿÿÿýkók]k€ò ÿÿÿÿÿÿlýkSk€ó ÿÿÿÿÿÿll8i€ô ÿÿÿÿÿÿllIk€õ ÿÿÿÿÿÿ%lli€ö ÿÿÿÿÿÿ/l%l?k€÷ ÿÿÿÿÿÿ9l/l5k€ø ÿÿÿÿÿÿCl9lèh€ù ÿÿÿÿÿÿMlCl+k@ú ÿÿÿÿÿÿWl†Ù€û ÿÿÿÿÿÿ`lˆij€ü ÿÿÿÿÿÿjl`lÎi€ý ÿÿÿÿÿÿtljlœi€þ >ÿÿÿÿÿÿ~l~œ@ÿ ÿÿÿÿÿÿˆl~l€ >ÿÿÿÿÿÿ‘l<œ@ ÿÿÿÿÿÿ›l‘l€ ÿÿÿÿÿÿ¤lË\v€ ÿÿÿÿÿÿ®l¤l"]€ ÿÿÿÿÿÿ¸l®lkb€ ÿÿÿÿÿÿÂl¸lñ€ ÿÿÿÿÿÿÌlÂl¸\€ ÿÿÿÿÿÿÖlÌl›l€ ÿÿÿÿÿÿàlÖl'€ ÿÿÿÿÿÿêlàlú€ ÿÿÿÿÿÿôlêlˆl€ >ÿÿÿÿÿÿþl2.Þh@ ÿÿÿÿÿÿmþl€ >ÿÿÿÿÿÿmê'2.@ ÿÿÿÿÿÿmm€ >ÿÿÿÿÿÿ$mê'Þh@ ÿÿÿÿÿÿ.m$m€ >ÿÿÿÿÿÿ7m2.üh@ ÿÿÿÿÿÿAm7m€ >ÿÿÿÿÿÿJmÞhüh@ ÿÿÿÿÿÿTmJm€ >ÿÿÿÿÿÿ]mê'üh@ ÿÿÿÿÿÿgm]m€ >ÿÿÿÿÿÿpm2.i@ ÿÿÿÿÿÿzmpm€ >ÿÿÿÿÿÿƒmÞhi@ ÿÿÿÿÿÿmƒm€ >ÿÿÿÿÿÿ–mê'i@ ÿÿÿÿÿÿ m–m€ >ÿÿÿÿÿÿ©mühi@ ÿÿÿÿÿÿ³m©m€ ÿÿÿÿÿÿ¼m³m m€ ÿÿÿÿÿÿÆm¼mm€! ÿÿÿÿÿÿÐmÆmzm€" ÿÿÿÿÿÿÚmÐmgm€# ÿÿÿÿÿÿämÚmTm€$ ÿÿÿÿÿÿîmämAm€% ÿÿÿÿÿÿømîm.m€& ÿÿÿÿÿÿnømm€' ÿÿÿÿÿÿ nnm€( >ÿÿÿÿÿÿn³-$i@) ÿÿÿÿÿÿ nn€* >ÿÿÿÿÿÿ)n|$$i@+ ÿÿÿÿÿÿ3n)n€, >ÿÿÿÿÿÿÿÿÿÿÿÿOn$iLi@/ ÿÿÿÿÿÿYnOn€0 >ÿÿÿÿÿÿbn³-Li@1 ÿÿÿÿÿÿlnbn€2 >ÿÿÿÿÿÿun|$Li@3 ÿÿÿÿÿÿnun€4 >ÿÿÿÿÿÿˆn$i`i@5 ÿÿÿÿÿÿ’nˆn€6 >ÿÿÿÿÿÿ›n³-`i@7 ÿÿÿÿÿÿ¥n›n€8 >ÿÿÿÿÿÿ®n|$`i@9 ÿÿÿÿÿÿ¸n®n€: >ÿÿÿÿÿÿÁnLi`i@; ÿÿÿÿÿÿËnÁn€< ÿÿÿÿÿÿÔnËn¸n€= ÿÿÿÿÿÿÞnÔn¥n€> ÿÿÿÿÿÿènÞn’n€? ÿÿÿÿÿÿònènn€@ ÿÿÿÿÿÿünònln€A ÿÿÿÿÿÿoünYn€B ÿÿÿÿÿÿooFn€C ÿÿÿÿÿÿoo3n€D ÿÿÿÿÿÿ$oo n€E >ÿÿÿÿÿÿ.ox1f@@F ÿÿÿÿÿÿ8o.o€G >ÿÿÿÿÿÿAo°f@@H ÿÿÿÿÿÿKoAo€I >ÿÿÿÿÿÿTo°x1@J ÿÿÿÿÿÿ^oTo€K >ÿÿÿÿÿÿgo¿0f@@L ÿÿÿÿÿÿqogo€M >ÿÿÿÿÿÿzo¿0x1@N ÿÿÿÿÿÿ„ozo€O >ÿÿÿÿÿÿo°¿0@P ÿÿÿÿÿÿ—oo€Q >ÿÿÿÿÿÿ o;2f@@R ÿÿÿÿÿÿªo o€S >ÿÿÿÿÿÿ³ox1;2@T ÿÿÿÿÿÿ½o³o€U >ÿÿÿÿÿÿÆo°;2@V ÿÿÿÿÿÿÐoÆo€W >ÿÿÿÿÿÿÙo¿0;2@X ÿÿÿÿÿÿãoÙo€Y ÿÿÿÿÿÿìoãoÐo€Z ÿÿÿÿÿÿöoìo½o€[ ÿÿÿÿÿÿpöoªo€\ ÿÿÿÿÿÿ pp—o€] ÿÿÿÿÿÿp p„o€^ ÿÿÿÿÿÿppqo€_ ÿÿÿÿÿÿ(pp^o€` ÿÿÿÿÿÿ2p(pKo€a ÿÿÿÿÿÿÿÿÿÿÿÿFp¦iºi@c ÿÿÿÿÿÿPpFp€d >ÿÿÿÿÿÿYp_$¦i@e ÿÿÿÿÿÿcpYp€f >ÿÿÿÿÿÿlp_$ºi@g ÿÿÿÿÿÿvplp€h >ÿÿÿÿÿÿpú,¦i@i ÿÿÿÿÿÿ‰pp€j >ÿÿÿÿÿÿ’pú,ºi@k ÿÿÿÿÿÿœp’p€l >ÿÿÿÿÿÿ¥p_$ú,@m ÿÿÿÿÿÿ¯p¥p€n >ÿÿÿÿÿÿ¸p¦iØi@o ÿÿÿÿÿÿÂp¸p€p >ÿÿÿÿÿÿËpºiØi@q ÿÿÿÿÿÿÕpËp€r >ÿÿÿÿÿÿÞp_$Øi@s ÿÿÿÿÿÿèpÞp€t >ÿÿÿÿÿÿñpú,Øi@u ÿÿÿÿÿÿûpñp€v ÿÿÿÿÿÿqûpèp€w ÿÿÿÿÿÿqqÕp€x ÿÿÿÿÿÿqqÂp€y ÿÿÿÿÿÿ"qq¯p€z ÿÿÿÿÿÿ,q"qœp€{ ÿÿÿÿÿÿ6q,q‰p€| ÿÿÿÿÿÿ@q6qvp€} ÿÿÿÿÿÿJq@qcp€~ ÿÿÿÿÿÿTqJqPp€ >ÿÿÿÿÿÿ^qìij@€ ÿÿÿÿÿÿhq^q€ >ÿÿÿÿÿÿqq£$ìi@‚ ÿÿÿÿÿÿ{qqq€ƒ >ÿÿÿÿÿÿ„q£$j@„ ÿÿÿÿÿÿŽq„q€… >ÿÿÿÿÿÿ—qìij@† ÿÿÿÿÿÿ¡q—q€‡ >ÿÿÿÿÿÿªqjj@ˆ ÿÿÿÿÿÿ´qªq€‰ >ÿÿÿÿÿÿ½q£$j@Š ÿÿÿÿÿÿÇq½q€‹ >ÿÿÿÿÿÿÐqv.ìi@Œ ÿÿÿÿÿÿÚqÐq€ >ÿÿÿÿÿÿãqv.j@Ž ÿÿÿÿÿÿíqãq€ >ÿÿÿÿÿÿöq£$v.@ ÿÿÿÿÿÿröq€‘ >ÿÿÿÿÿÿ rv.j@’ ÿÿÿÿÿÿr r€“ ÿÿÿÿÿÿrrr€” ÿÿÿÿÿÿ&rríq€• ÿÿÿÿÿÿ0r&rÚq€– ÿÿÿÿÿÿ:r0rÇq€— ÿÿÿÿÿÿDr:r´q€˜ ÿÿÿÿÿÿNrDr¡q€™ ÿÿÿÿÿÿXrNrŽq€š ÿÿÿÿÿÿbrXr{q€› ÿÿÿÿÿÿlrbrhq€œ ÿÿÿÿÿÿvrlrTq€ ÿÿÿÿÿÿ€rvrÿÿÿÿÿÿžr2.$i@¡ ÿÿÿÿÿÿ¨ržr€¢ >ÿÿÿÿÿÿ±r2.f@@£ ÿÿÿÿÿÿ»r±r€¤ >ÿÿÿÿÿÿÄrf@$i@¥ ÿÿÿÿÿÿÎrÄr€¦ >ÿÿÿÿÿÿ×r2.¦i@§ ÿÿÿÿÿÿár×r€¨ >ÿÿÿÿÿÿêr$i¦i@© ÿÿÿÿÿÿôrêr€ª >ÿÿÿÿÿÿýrf@¦i@« ÿÿÿÿÿÿsýr€¬ >ÿÿÿÿÿÿs2.ìi@­ ÿÿÿÿÿÿss€® >ÿÿÿÿÿÿ#s$iìi@¯ ÿÿÿÿÿÿ-s#s€° >ÿÿÿÿÿÿ6sf@ìi@± ÿÿÿÿÿÿ@s6s€² >ÿÿÿÿÿÿIs¦iìi@³ ÿÿÿÿÿÿSsIs€´ ÿÿÿÿÿÿ\sSs@s€µ ÿÿÿÿÿÿfs\s-s€¶ ÿÿÿÿÿÿpsfss€· ÿÿÿÿÿÿzspss€¸ ÿÿÿÿÿÿ„szsôr€¹ ÿÿÿÿÿÿŽs„sár€º ÿÿÿÿÿÿ˜sŽsÎr€» ÿÿÿÿÿÿ¢s˜s»r€¼ ÿÿÿÿÿÿ¬s¢s¨r€½ >ÿÿÿÿÿÿ¶s³-Þh@¾ ÿÿÿÿÿÿÀs¶s€¿ >ÿÿÿÿÿÿÉsx1Þh@À ÿÿÿÿÿÿÓsÉs€Á >ÿÿÿÿÿÿÜs³-x1@ ÿÿÿÿÿÿæsÜs€Ã >ÿÿÿÿÿÿïsÞhºi@Ä ÿÿÿÿÿÿùsïs€Å >ÿÿÿÿÿÿt³-ºi@Æ ÿÿÿÿÿÿ tt€Ç >ÿÿÿÿÿÿtx1ºi@È ÿÿÿÿÿÿtt€É >ÿÿÿÿÿÿ(tÞhj@Ê ÿÿÿÿÿÿ2t(t€Ë >ÿÿÿÿÿÿ;t³-j@Ì ÿÿÿÿÿÿEt;t€Í >ÿÿÿÿÿÿNtx1j@Î ÿÿÿÿÿÿXtNt€Ï >ÿÿÿÿÿÿatºij@Ð ÿÿÿÿÿÿktat€Ñ ÿÿÿÿÿÿttktXt€Ò ÿÿÿÿÿÿ~tttEt€Ó ÿÿÿÿÿÿˆt~t2t€Ô ÿÿÿÿÿÿ’tˆtt€Õ ÿÿÿÿÿÿœt’t t€Ö ÿÿÿÿÿÿ¦tœtùs€× ÿÿÿÿÿÿ°t¦tæs€Ø ÿÿÿÿÿÿºt°tÓs€Ù ÿÿÿÿÿÿÄtºtÀs€Ú >ÿÿÿÿÿÿÎt|$ê'@Û ÿÿÿÿÿÿØtÎt€Ü >ÿÿÿÿÿÿát°ê'@Ý ÿÿÿÿÿÿëtát€Þ >ÿÿÿÿÿÿôt°|$@ß ÿÿÿÿÿÿþtôt€à >ÿÿÿÿÿÿu_$ê'@á ÿÿÿÿÿÿuu€â >ÿÿÿÿÿÿu_$|$@ã ÿÿÿÿÿÿ$uu€ä >ÿÿÿÿÿÿ-u°_$@å ÿÿÿÿÿÿ7u-u€æ >ÿÿÿÿÿÿ@u£$ê'@ç ÿÿÿÿÿÿJu@u€è >ÿÿÿÿÿÿSu|$£$@é ÿÿÿÿÿÿ]uSu€ê >ÿÿÿÿÿÿfu°£$@ë ÿÿÿÿÿÿpufu€ì >ÿÿÿÿÿÿyu_$£$@í ÿÿÿÿÿÿƒuyu€î ÿÿÿÿÿÿŒuƒupu€ï ÿÿÿÿÿÿ–uŒu]u€ð ÿÿÿÿÿÿ u–uJu€ñ ÿÿÿÿÿÿªu u7u€ò ÿÿÿÿÿÿ´uªu$u€ó ÿÿÿÿÿÿ¾u´uu€ô ÿÿÿÿÿÿÈu¾uþt€õ ÿÿÿÿÿÿÒuÈuët€ö ÿÿÿÿÿÿÜuÒuØt€÷ >ÿÿÿÿÿÿæuühLi@ø ÿÿÿÿÿÿðuæu€ù >ÿÿÿÿÿÿùu¿0üh@ú ÿÿÿÿÿÿvùu€û >ÿÿÿÿÿÿ v¿0Li@ü ÿÿÿÿÿÿv v€ý >ÿÿÿÿÿÿvú,üh@þ ÿÿÿÿÿÿ)vv€ÿ >ÿÿÿÿÿÿ2vú,Li@ ÿÿÿÿÿÿÿÿÿÿÿÿEvú,¿0@ ÿÿÿÿÿÿOvEv€ >ÿÿÿÿÿÿXvühj@ ÿÿÿÿÿÿbvXv€ >ÿÿÿÿÿÿkvLij@ ÿÿÿÿÿÿuvkv€ >ÿÿÿÿÿÿ~v¿0j@ ÿÿÿÿÿÿˆv~v€ >ÿÿÿÿÿÿ‘vú,j@ ÿÿÿÿÿÿ›v‘v€ ÿÿÿÿÿÿ¤v›vˆv€ ÿÿÿÿÿÿ®v¤vuv€ ÿÿÿÿÿÿ¸v®vbv€ ÿÿÿÿÿÿÂv¸vOv€ ÿÿÿÿÿÿÌvÂvÿÿÿÿÿÿþvi`i@ ÿÿÿÿÿÿwþv€ >ÿÿÿÿÿÿw;2i@ ÿÿÿÿÿÿww€ >ÿÿÿÿÿÿ$w;2`i@ ÿÿÿÿÿÿ.w$w€ >ÿÿÿÿÿÿ7wiØi@ ÿÿÿÿÿÿAw7w€ >ÿÿÿÿÿÿJw`iØi@ ÿÿÿÿÿÿTwJw€ >ÿÿÿÿÿÿ]w;2Øi@ ÿÿÿÿÿÿgw]w€ >ÿÿÿÿÿÿpwv.i@! ÿÿÿÿÿÿzwpw€" >ÿÿÿÿÿÿƒwv.`i@# ÿÿÿÿÿÿwƒw€$ >ÿÿÿÿÿÿ–wv.;2@% ÿÿÿÿÿÿ w–w€& >ÿÿÿÿÿÿ©wv.Øi@' ÿÿÿÿÿÿ³w©w€( ÿÿÿÿÿÿ¼w³w w€) ÿÿÿÿÿÿÆw¼ww€* ÿÿÿÿÿÿÐwÆwzw€+ ÿÿÿÿÿÿÚwÐwgw€, ÿÿÿÿÿÿäwÚwTw€- ÿÿÿÿÿÿîwäwAw€. ÿÿÿÿÿÿøwîw.w€/ ÿÿÿÿÿÿxøww€0 ÿÿÿÿÿÿ xxw€1 ÿÿÿÿÿÿx xôv€2 ÿÿÿÿÿÿ xxÜu€3 ÿÿÿÿÿÿ*x xÄt€4 ÿÿÿÿÿÿ4x*x¬s€5 ÿÿÿÿÿÿ>x4x”r€6 SÿÿÿÿÿÿHx2.œ€7 >ÿÿÿÿÿÿRxœHx@8 ÿÿÿÿÿÿ\xRx€9 Sÿÿÿÿÿÿex$i~€: >ÿÿÿÿÿÿoxœex@; ÿÿÿÿÿÿyxox€< Sÿÿÿÿÿÿ‚xf@4€= >ÿÿÿÿÿÿŒxœ‚x@> ÿÿÿÿÿÿ–xŒx€? SÿÿÿÿÿÿŸx¦i<€@ >ÿÿÿÿÿÿ©xœŸx@A ÿÿÿÿÿÿ³x©x€B Sÿÿÿÿÿÿ¼xìi°€C >ÿÿÿÿÿÿÆxœ¼x@D ÿÿÿÿÿÿÐxÆx€E ÿÿÿÿÿÿÙxÐx³x€F ÿÿÿÿÿÿãxÙx–x€G ÿÿÿÿÿÿíxãxyx€H ÿÿÿÿÿÿ÷xíx\x€I SÿÿÿÿÿÿyÞhœ€J >ÿÿÿÿÿÿ y~y@K ÿÿÿÿÿÿy y€L Sÿÿÿÿÿÿy³-~€M >ÿÿÿÿÿÿ(y~y@N ÿÿÿÿÿÿ2y(y€O Sÿÿÿÿÿÿ;yx14€P >ÿÿÿÿÿÿEy~;y@Q ÿÿÿÿÿÿOyEy€R SÿÿÿÿÿÿXyºi<€S >ÿÿÿÿÿÿby~Xy@T ÿÿÿÿÿÿlyby€U Sÿÿÿÿÿÿuyj°€V >ÿÿÿÿÿÿy~uy@W ÿÿÿÿÿÿ‰yy€X ÿÿÿÿÿÿ’y‰yly€Y ÿÿÿÿÿÿœy’yOy€Z ÿÿÿÿÿÿ¦yœy2y€[ ÿÿÿÿÿÿ°y¦yy€\ Sÿÿÿÿÿÿºyê'œ€] >ÿÿÿÿÿÿÄy4ºy@^ ÿÿÿÿÿÿÎyÄy€_ Sÿÿÿÿÿÿ×y|$~€` >ÿÿÿÿÿÿáy4×y@a ÿÿÿÿÿÿëyáy€b Sÿÿÿÿÿÿôy_$<€c >ÿÿÿÿÿÿþy4ôy@d ÿÿÿÿÿÿzþy€e Sÿÿÿÿÿÿz£$°€f >ÿÿÿÿÿÿz4z@g ÿÿÿÿÿÿ%zz€h ÿÿÿÿÿÿ.z%zz€i ÿÿÿÿÿÿ8z.z·$€j ÿÿÿÿÿÿBz8zëy€k ÿÿÿÿÿÿLzBzÎy€l SÿÿÿÿÿÿVzühœ€m >ÿÿÿÿÿÿ`z<Vz@n ÿÿÿÿÿÿjz`z€o SÿÿÿÿÿÿszLi~€p >ÿÿÿÿÿÿ}z<sz@q ÿÿÿÿÿÿ‡z}z€r Sÿÿÿÿÿÿz¿04€s >ÿÿÿÿÿÿšz<z@t ÿÿÿÿÿÿ¤zšz€u Sÿÿÿÿÿÿ­zú,<€v >ÿÿÿÿÿÿ·z<­z@w ÿÿÿÿÿÿÁz·z€x SÿÿÿÿÿÿÊzj°€y >ÿÿÿÿÿÿÔz<Êz@z ÿÿÿÿÿÿÞzÔz€{ ÿÿÿÿÿÿçzÞzÁz€| ÿÿÿÿÿÿñzçz¤z€} ÿÿÿÿÿÿûzñz‡z€~ ÿÿÿÿÿÿ{ûzjz€ Sÿÿÿÿÿÿ{iœ€€ >ÿÿÿÿÿÿ{°{@ ÿÿÿÿÿÿ#{{€‚ Sÿÿÿÿÿÿ,{`i~€ƒ >ÿÿÿÿÿÿ6{°,{@„ ÿÿÿÿÿÿ@{6{€… SÿÿÿÿÿÿI{;24€† >ÿÿÿÿÿÿS{°I{@‡ ÿÿÿÿÿÿ]{S{€ˆ Sÿÿÿÿÿÿf{Øi<€‰ >ÿÿÿÿÿÿp{°f{@Š ÿÿÿÿÿÿz{p{€‹ Sÿÿÿÿÿÿƒ{v.°€Œ >ÿÿÿÿÿÿ{°ƒ{@ ÿÿÿÿÿÿ—{{€Ž ÿÿÿÿÿÿ {—{z{€ ÿÿÿÿÿÿª{ {]{€ ÿÿÿÿÿÿ´{ª{@{€‘ ÿÿÿÿÿÿ¾{´{#{€’ ÿÿÿÿÿÿÈ{¾{{€“ ÿÿÿÿÿÿÒ{È{Lz€” ÿÿÿÿÿÿÜ{Ò{°y€• ÿÿÿÿÿÿæ{Ü{÷x€– >ÿÿÿÿÿÿð{œ2.@— ÿÿÿÿÿÿú{ð{€˜ ÿÿÿÿÿÿ|ð{ú{€™ >ÿÿÿÿÿÿ |~2.@š ÿÿÿÿÿÿ| |€› >ÿÿÿÿÿÿ |œÞh€œ ÿÿÿÿÿÿ*| ||€ ÿÿÿÿÿÿ4|òhg4€ž >ÿÿÿÿÿÿ>|<2.@Ÿ ÿÿÿÿÿÿH|>|€  ÿÿÿÿÿÿQ|?kH|@¡ ÿÿÿÿÿÿ[|+k€¢ >ÿÿÿÿÿÿd|œi€£ ÿÿÿÿÿÿn|d|[|€¤ ÿÿÿÿÿÿx|n|Q|€¥ ÿÿÿÿÿÿ‚|x|4|€¦ ÿÿÿÿÿÿŒ|‚|*|€§ ÿÿÿÿÿÿ–|Œ||€¨ >ÿÿÿÿÿÿ |œ$i@© ÿÿÿÿÿÿª| |€ª ÿÿÿÿÿÿ³| |ª|€« >ÿÿÿÿÿÿ½|~$i@¬ ÿÿÿÿÿÿÇ|½|€­ >ÿÿÿÿÿÿÐ|œ³-€® ÿÿÿÿÿÿÚ|Ð|Ç|€¯ >ÿÿÿÿÿÿä|4$i@° ÿÿÿÿÿÿî|ä|€± ÿÿÿÿÿÿ÷|Skî|@² ÿÿÿÿÿÿ}Ik€³ ÿÿÿÿÿÿ }Vi}@´ ÿÿÿÿÿÿ}.i€µ >ÿÿÿÿÿÿ}œ`i€¶ ÿÿÿÿÿÿ'}}}€· ÿÿÿÿÿÿ1}'} }€¸ ÿÿÿÿÿÿ;}1}÷|€¹ ÿÿÿÿÿÿE};}Ú|€º ÿÿÿÿÿÿO}E}³|€» >ÿÿÿÿÿÿY}œf@@¼ ÿÿÿÿÿÿc}Y}€½ ÿÿÿÿÿÿl}Y}c}@¾ ÿÿÿÿÿÿv}ti€¿ >ÿÿÿÿÿÿ}œx1€À ÿÿÿÿÿÿ‰}}v}€Á >ÿÿÿÿÿÿ“}4f@@ ÿÿÿÿÿÿ}“}€Ã ÿÿÿÿÿÿ¦}ab}€Ä >ÿÿÿÿÿÿ°}<f@@Å ÿÿÿÿÿÿº}°}€Æ >ÿÿÿÿÿÿÃ}œ¿0€Ç ÿÿÿÿÿÿÍ}Ã}º}€È ÿÿÿÿÿÿ×}œiKo€É ÿÿÿÿÿÿá}×}Í}€Ê ÿÿÿÿÿÿë}á}¦}€Ë ÿÿÿÿÿÿõ}ë}‰}€Ì ÿÿÿÿÿÿÿ}õ}l}€Í >ÿÿÿÿÿÿ ~œ¦i@Î ÿÿÿÿÿÿ~ ~€Ï ÿÿÿÿÿÿ~ ~~€Ð >ÿÿÿÿÿÿ&~~¦i@Ñ ÿÿÿÿÿÿ0~&~€Ò ÿÿÿÿÿÿ9~Äi0~@Ó ÿÿÿÿÿÿC~qk€Ô >ÿÿÿÿÿÿL~œ_$€Õ ÿÿÿÿÿÿV~L~C~@Ö ÿÿÿÿÿÿ`~°i€× >ÿÿÿÿÿÿi~œú,€Ø ÿÿÿÿÿÿs~i~`~€Ù >ÿÿÿÿÿÿ}~°¦i@Ú ÿÿÿÿÿÿ‡~}~€Û >ÿÿÿÿÿÿ~œØi€Ü ÿÿÿÿÿÿš~~‡~€Ý ÿÿÿÿÿÿ¤~š~s~€Þ ÿÿÿÿÿÿ®~¤~V~€ß ÿÿÿÿÿÿ¸~®~9~€à ÿÿÿÿÿÿÂ~¸~~@á ÿÿÿÿÿÿÌ~öi€â ÿÿÿÿÿÿÕ~öiÌ~€ã >ÿÿÿÿÿÿß~~ìi@ä ÿÿÿÿÿÿé~ß~€å >ÿÿÿÿÿÿò~œj€æ ÿÿÿÿÿÿü~ò~é~€ç >ÿÿÿÿÿÿ4ìi@è ÿÿÿÿÿÿ€é >ÿÿÿÿÿÿœ£$€ê ÿÿÿÿÿÿ#€ë >ÿÿÿÿÿÿ-<ìi@ì ÿÿÿÿÿÿ7-€í >ÿÿÿÿÿÿ@œj€î ÿÿÿÿÿÿJ@7€ï >ÿÿÿÿÿÿT°ìi@ð ÿÿÿÿÿÿ^T€ñ >ÿÿÿÿÿÿgœv.€ò ÿÿÿÿÿÿqg^€ó ÿÿÿÿÿÿ{qJ€ô ÿÿÿÿÿÿ…{#€õ ÿÿÿÿÿÿ…ü~€ö ÿÿÿÿÿÿ™Õ~€÷ ÿÿÿÿÿÿ£™Â~€ø ÿÿÿÿÿÿ­£ÿ}€ù ÿÿÿÿÿÿ·­O}€ú ÿÿÿÿÿÿÁ·–|@û ÿÿÿÿÿÿË |€ü ÿÿÿÿÿÿÔ |Ë€ý >ÿÿÿÿÿÿÞ~Þh@þ ÿÿÿÿÿÿèÞ€ÿ ÿÿÿÿÿÿñÞè€ >ÿÿÿÿÿÿû4Þh@ ÿÿÿÿÿÿ€û€ >ÿÿÿÿÿÿ€~ê'€ ÿÿÿÿÿÿ€€€@ ÿÿÿÿÿÿ"€èh€ >ÿÿÿÿÿÿ+€~üh€ ÿÿÿÿÿÿ5€+€"€€ >ÿÿÿÿÿÿ?€°Þh@ ÿÿÿÿÿÿI€?€€ ÿÿÿÿÿÿR€iI€€ ÿÿÿÿÿÿ\€R€5€€ ÿÿÿÿÿÿf€\€€€ ÿÿÿÿÿÿp€f€ñ€ ÿÿÿÿÿÿz€p€Ô@ ÿÿÿÿÿÿ„€Ð|€ ÿÿÿÿÿÿ€½|„€@ ÿÿÿÿÿÿ—€8i€ ÿÿÿÿÿÿ €8i—€€ >ÿÿÿÿÿÿª€~|$€ ÿÿÿÿÿÿ´€ª€Ç-€ >ÿÿÿÿÿÿ¾€<³-@ ÿÿÿÿÿÿÈ€¾€€ >ÿÿÿÿÿÿÑ€~Li€ ÿÿÿÿÿÿۀрȀ€ >ÿÿÿÿÿÿ倰³-@ ÿÿÿÿÿÿï€å€€ >ÿÿÿÿÿÿø€~`i€ ÿÿÿÿÿÿø€ï€€ ÿÿÿÿÿÿ Û€€ ÿÿÿÿÿÿ ´€€ ÿÿÿÿÿÿ  €€ ÿÿÿÿÿÿ* €@ ÿÿÿÿÿÿ4}€! ÿÿÿÿÿÿ=ti4€" >ÿÿÿÿÿÿG~x1@# ÿÿÿÿÿÿQG€$ ÿÿÿÿÿÿZGQ@% ÿÿÿÿÿÿd~i€& ÿÿÿÿÿÿm]d€' >ÿÿÿÿÿÿw<x1@( ÿÿÿÿÿÿw€) >ÿÿÿÿÿÿŠ~¿0€* ÿÿÿÿÿÿ”Š€+ >ÿÿÿÿÿÿž~;2€, ÿÿÿÿÿÿ¨ž^o€- ÿÿÿÿÿÿ²¨”€. ÿÿÿÿÿÿ¼²m€/ ÿÿÿÿÿÿƼZ€0 ÿÿÿÿÿÿÐÆ=@1 ÿÿÿÿÿÿÚÄi€2 ÿÿÿÿÿÿã&~Ú€3 >ÿÿÿÿÿÿí~ºi@4 ÿÿÿÿÿÿ÷í€5 ÿÿÿÿÿÿ‚í÷€6 >ÿÿÿÿÿÿ ‚4ºi@7 ÿÿÿÿÿÿ‚ ‚€8 ÿÿÿÿÿÿ‚Îi‚€9 >ÿÿÿÿÿÿ'‚<ºi@: ÿÿÿÿÿÿ1‚'‚€; >ÿÿÿÿÿÿ:‚~ú,€< ÿÿÿÿÿÿD‚:‚1‚€= >ÿÿÿÿÿÿN‚°ºi@> ÿÿÿÿÿÿX‚N‚€? >ÿÿÿÿÿÿa‚~Øi€@ ÿÿÿÿÿÿk‚a‚X‚€A ÿÿÿÿÿÿu‚k‚D‚€B ÿÿÿÿÿÿ‚u‚‚€C ÿÿÿÿÿÿ‰‚‚‚€D ÿÿÿÿÿÿ“‚‰‚ã@E ÿÿÿÿÿÿ‚ò~€F ÿÿÿÿÿÿ¦‚ß~‚€G >ÿÿÿÿÿÿ°‚~j@H ÿÿÿÿÿÿº‚°‚€I ÿÿÿÿÿÿ°‚º‚€J >ÿÿÿÿÿÿÍ‚4j@K ÿÿÿÿÿÿׂ͂€L >ÿÿÿÿÿÿà‚~£$€M ÿÿÿÿÿÿê‚à‚ׂ€N >ÿÿÿÿÿÿô‚<j@O ÿÿÿÿÿÿþ‚ô‚€P ÿÿÿÿÿÿƒ(jþ‚@Q ÿÿÿÿÿÿƒ j€R >ÿÿÿÿÿÿƒ~v.€S ÿÿÿÿÿÿ$ƒƒƒ€T ÿÿÿÿÿÿ.ƒ$ƒƒ€U ÿÿÿÿÿÿ8ƒ.ƒê‚€V ÿÿÿÿÿÿBƒ8ƒÃ‚€W ÿÿÿÿÿÿLƒBƒ¦‚€X ÿÿÿÿÿÿVƒLƒ“‚€Y ÿÿÿÿÿÿ`ƒVƒÐ€Z ÿÿÿÿÿÿjƒ`ƒ*€[ ÿÿÿÿÿÿtƒjƒz€@\ ÿÿÿÿÿÿ~ƒòh€] ÿÿÿÿÿÿ‡ƒ]4~ƒ@^ ÿÿÿÿÿÿ‘ƒ€€_ ÿÿÿÿÿÿšƒû‘ƒ@` ÿÿÿÿÿÿ¤ƒ5k€a ÿÿÿÿÿÿ­ƒ5k¤ƒ€b >ÿÿÿÿÿÿ·ƒ<ê'@c ÿÿÿÿÿÿÁƒ·ƒ€d >ÿÿÿÿÿÿʃ4üh€e ÿÿÿÿÿÿԃʃÁƒ€f >ÿÿÿÿÿÿÞƒ4i€g ÿÿÿÿÿÿèƒÞƒët€h ÿÿÿÿÿÿòƒèƒÔƒ€i ÿÿÿÿÿÿüƒòƒ­ƒ€j ÿÿÿÿÿÿ„üƒšƒ€k ÿÿÿÿÿÿ„„‡ƒ@l ÿÿÿÿÿÿ„Sk€m ÿÿÿÿÿÿ#„ä|„@n ÿÿÿÿÿÿ-„ª€€o ÿÿÿÿÿÿ6„½--„@p ÿÿÿÿÿÿ@„Bi€q ÿÿÿÿÿÿI„Bi@„€r >ÿÿÿÿÿÿS„<|$@s ÿÿÿÿÿÿ]„S„€t ÿÿÿÿÿÿf„]k]„€u >ÿÿÿÿÿÿp„4`i€v ÿÿÿÿÿÿz„p„þt€w ÿÿÿÿÿÿ„„z„f„€x ÿÿÿÿÿÿŽ„„„I„€y ÿÿÿÿÿÿ˜„Ž„6„€z ÿÿÿÿÿÿ¢„˜„#„€{ ÿÿÿÿÿÿ¬„“}kb€| ÿÿÿÿÿÿ¶„~i"]€} >ÿÿÿÿÿÿÀ„4¿0€~ ÿÿÿÿÿÿÊ„À„Ë\@ ÿÿÿÿÿÿÔ„€€ ÿÿÿÿÿÿÝ„E2€ ÿÿÿÿÿÿç„Ý„Ê„€‚ ÿÿÿÿÿÿñ„ç„„T€ƒ ÿÿÿÿÿÿû„ñ„¶„€„ ÿÿÿÿÿÿ…û„¬„@… ÿÿÿÿÿÿ…L~€† ÿÿÿÿÿÿ…qk…@‡ ÿÿÿÿÿÿ"…Îi€ˆ ÿÿÿÿÿÿ+… ‚"…€‰ >ÿÿÿÿÿÿ5…4_$@Š ÿÿÿÿÿÿ?…5…€‹ ÿÿÿÿÿÿH…5…?…€Œ >ÿÿÿÿÿÿR…<_$@ ÿÿÿÿÿÿ\…R…€Ž ÿÿÿÿÿÿe…-\…€ >ÿÿÿÿÿÿo…4Øi€ ÿÿÿÿÿÿy…o…7u€‘ ÿÿÿÿÿÿƒ…y…e…€’ ÿÿÿÿÿÿ…ƒ…H…€“ ÿÿÿÿÿÿ—……+…€” ÿÿÿÿÿÿ¡…—……@• ÿÿÿÿÿÿ«…€– ÿÿÿÿÿÿ´…«…@— ÿÿÿÿÿÿ¾…à‚€˜ ÿÿÿÿÿÿÇ…Í‚¾…€™ ÿÿÿÿÿÿÑ…­$·$@š ÿÿÿÿÿÿÛ…j€› >ÿÿÿÿÿÿä…4j€œ ÿÿÿÿÿÿî…ä…Û…€ ÿÿÿÿÿÿø…€.pu€ž ÿÿÿÿÿÿ†ø…î…€Ÿ ÿÿÿÿÿÿ ††Ñ…€  ÿÿÿÿÿÿ† †Ç…€¡ ÿÿÿÿÿÿ ††´…€¢ ÿÿÿÿÿÿ*† †¡…€£ ÿÿÿÿÿÿ4†*†…€¤ ÿÿÿÿÿÿ>†4†¢„€¥ ÿÿÿÿÿÿH†>†„@¦ ÿÿÿÿÿÿR†?k€§ ÿÿÿÿÿÿ[†>|R†@¨ ÿÿÿÿÿÿe†+€€© ÿÿÿÿÿÿn†èhe†@ª ÿÿÿÿÿÿx†Êƒ€« ÿÿÿÿÿÿ†·ƒx†€¬ >ÿÿÿÿÿÿ‹†<üh@­ ÿÿÿÿÿÿ•†‹†€® ÿÿÿÿÿÿž†‹†•†@¯ ÿÿÿÿÿÿ¨†i€° >ÿÿÿÿÿÿ±†<i€± ÿÿÿÿÿÿ»†±†¨†€² ÿÿÿÿÿÿņ»†ž†€³ ÿÿÿÿÿÿφņ†€´ ÿÿÿÿÿÿنφn†€µ ÿÿÿÿÿÿã†Ù†[†@¶ ÿÿÿÿÿÿí†Vi€· ÿÿÿÿÿÿö†Ikí†@¸ ÿÿÿÿÿÿ‡Ñ€€¹ ÿÿÿÿÿÿ ‡¾€‡@º ÿÿÿÿÿÿ‡]k€» ÿÿÿÿÿÿ‡S„‡€¼ >ÿÿÿÿÿÿ&‡<Li@½ ÿÿÿÿÿÿ0‡&‡€¾ ÿÿÿÿÿÿ9‡&‡0‡€¿ >ÿÿÿÿÿÿC‡°Li@À ÿÿÿÿÿÿM‡C‡€Á ÿÿÿÿÿÿV‡jiM‡€Â ÿÿÿÿÿÿ`‡V‡9‡€Ã ÿÿÿÿÿÿj‡`‡‡€Ä ÿÿÿÿÿÿt‡j‡ ‡€Å ÿÿÿÿÿÿ~‡t‡ö†@Æ ÿÿÿÿÿÿˆ‡Ã}€Ç ÿÿÿÿÿÿ‘‡°}ˆ‡@È ÿÿÿÿÿÿ›‡Š€É ÿÿÿÿÿÿ¤‡w›‡@Ê ÿÿÿÿÿÿ®‡À„€Ë ÿÿÿÿÿÿ·‡Á\®‡@Ì ÿÿÿÿÿÿÁ‡’i€Í ÿÿÿÿÿÿʇ’iÁ‡€Î >ÿÿÿÿÿÿÔ‡<;2€Ï ÿÿÿÿÿÿÞ‡Ô‡—o€Ð ÿÿÿÿÿÿè‡Þ‡Ê‡€Ñ ÿÿÿÿÿÿò‡è‡·‡€Ò ÿÿÿÿÿÿü‡ò‡¤‡€Ó ÿÿÿÿÿÿˆü‡‘‡@Ô ÿÿÿÿÿÿˆi~€Õ ÿÿÿÿÿÿˆ°iˆ@Ö ÿÿÿÿÿÿ#ˆ:‚€× ÿÿÿÿÿÿ,ˆ'‚#ˆ€Ø ÿÿÿÿÿÿ6ˆR…-€Ù >ÿÿÿÿÿÿ@ˆ<ú,@Ú ÿÿÿÿÿÿJˆ@ˆ€Û ÿÿÿÿÿÿSˆ@ˆJˆ@Ü ÿÿÿÿÿÿ]ˆ{k€Ý ÿÿÿÿÿÿfˆ…k]ˆ€Þ ÿÿÿÿÿÿpˆfˆSˆ€ß ÿÿÿÿÿÿzˆpˆ6ˆ€à ÿÿÿÿÿÿ„ˆzˆ,ˆ€á ÿÿÿÿÿÿŽˆ„ˆˆ@â ÿÿÿÿÿÿ˜ˆ@€ã ÿÿÿÿÿÿ¡ˆ-˜ˆ@ä ÿÿÿÿÿÿ«ˆ(j€å ÿÿÿÿÿÿ´ˆô‚«ˆ@æ ÿÿÿÿÿÿ¾ˆä…€ç ÿÿÿÿÿÿLjj¾ˆ€è >ÿÿÿÿÿÿш<j@é ÿÿÿÿÿÿۈш€ê ÿÿÿÿÿÿäˆÑˆÛˆ€ë >ÿÿÿÿÿÿj@ì ÿÿÿÿÿÿøˆîˆ€í >ÿÿÿÿÿÿ‰<v.€î ÿÿÿÿÿÿ ‰‰øˆ€ï ÿÿÿÿÿÿ‰ ‰äˆ€ð ÿÿÿÿÿÿ‰‰Çˆ€ñ ÿÿÿÿÿÿ)‰‰´ˆ€ò ÿÿÿÿÿÿ3‰)‰¡ˆ€ó ÿÿÿÿÿÿ=‰3‰Žˆ€ô ÿÿÿÿÿÿG‰=‰ˆ€õ ÿÿÿÿÿÿQ‰G‰~‡€ö ÿÿÿÿÿÿ[‰Q‰ã†@÷ ÿÿÿÿÿÿe‰d|€ø ÿÿÿÿÿÿn‰+ke‰@ù ÿÿÿÿÿÿx‰i€ú ÿÿÿÿÿÿ‰?€x‰@û ÿÿÿÿÿÿ‹‰Þƒ€ü ÿÿÿÿÿÿ”‰át‹‰@ý ÿÿÿÿÿÿž‰±†€þ ÿÿÿÿÿÿ§‰iž‰€ÿ >ÿÿÿÿÿÿ±‰°i@ÿÿÿÿÿÿ»‰±‰€ÿÿÿÿÿÿĉ±‰»‰€ÿÿÿÿÿÿΉĉ§‰€ÿÿÿÿÿÿ؉Ή”‰€ÿÿÿÿÿÿâ‰Ø‰‰€ÿÿÿÿÿÿì‰â‰n‰@ÿÿÿÿÿÿö‰}€ÿÿÿÿÿÿÿ‰.iö‰@ÿÿÿÿÿÿ Šø€€ ÿÿÿÿÿÿŠå€ Š@ ÿÿÿÿÿÿŠp„€ ÿÿÿÿÿÿ%ŠôtŠ@ ÿÿÿÿÿÿ/Šji€ ÿÿÿÿÿÿ8ŠC‡/Š@ÿÿÿÿÿÿBŠgk€ÿÿÿÿÿÿKŠgkBŠ€ÿÿÿÿÿÿUŠKŠ8Š€ÿÿÿÿÿÿ_ŠUŠ%Š€ÿÿÿÿÿÿiŠ_ŠŠ€ÿÿÿÿÿÿsŠiŠÿ‰@ÿÿÿÿÿÿ}Šœi€ÿÿÿÿÿÿ†ŠAo}Š@ÿÿÿÿÿÿŠž€ÿÿÿÿÿÿ™ŠToŠ€ÿÿÿÿÿÿ£ŠO2@ÿÿÿÿÿÿ­ŠÔ‡€ÿÿÿÿÿÿ¶Šo­Š€ÿÿÿÿÿÿÀŠÆoÐo€ÿÿÿÿÿÿÊŠÀŠ¶Š€ÿÿÿÿÿÿÔŠÊŠ£Š€ÿÿÿÿÿÿÞŠÔŠ™Š€ÿÿÿÿÿÿèŠÞŠ†Š@ ÿÿÿÿÿÿòŠ~€!ÿÿÿÿÿÿûŠ}~òŠ@"ÿÿÿÿÿÿ‹a‚€#ÿÿÿÿÿÿ‹N‚‹@$ÿÿÿÿÿÿ‹o…€%ÿÿÿÿÿÿ!‹-u‹@&ÿÿÿÿÿÿ+‹…k€'ÿÿÿÿÿÿ4‹{k+‹@(ÿÿÿÿÿÿ>‹âi€)ÿÿÿÿÿÿG‹âi>‹€*ÿÿÿÿÿÿQ‹G‹4‹€+ÿÿÿÿÿÿ[‹Q‹!‹€,ÿÿÿÿÿÿe‹[‹‹€-ÿÿÿÿÿÿo‹e‹ûŠ@.ÿÿÿÿÿÿy‹g€/ÿÿÿÿÿÿ‚‹Ty‹@0ÿÿÿÿÿÿŒ‹ƒ€1ÿÿÿÿÿÿ•‹ jŒ‹€2ÿÿÿÿÿÿŸ‹fuŠ.@3ÿÿÿÿÿÿ©‹‰€4ÿÿÿÿÿÿ²‹îˆ©‹€5>ÿÿÿÿÿÿ¼‹°v.@6ÿÿÿÿÿÿÆ‹¼‹€7ÿÿÿÿÿÿÏ‹¼‹Æ‹€8ÿÿÿÿÿÿÙ‹Ï‹²‹€9ÿÿÿÿÿÿã‹Ù‹Ÿ‹€:ÿÿÿÿÿÿí‹ã‹•‹€;ÿÿÿÿÿÿ÷‹í‹‚‹€<ÿÿÿÿÿÿŒ÷‹o‹€=ÿÿÿÿÿÿ ŒŒèŠ€>ÿÿÿÿÿÿŒ ŒsŠ€?ÿÿÿÿÿÿŒŒì‰€@ÿÿÿÿÿÿ)ŒŒ[‰€Aÿÿÿÿÿÿ3Œ)ŒH†€Bÿÿÿÿÿÿ=Œ3Œtƒ€CÿÿÿÿÿÿGŒ=ŒÁ€DÿÿÿÿÿÿQŒú{ð{€Eÿÿÿÿÿÿ[ŒË |€FÿÿÿÿÿÿeŒ~ƒY}€GÿÿÿÿÿÿoŒR† ~€HÿÿÿÿÿÿyŒe‰öi€IÿÿÿÿÿÿƒŒyŒoŒ€JÿÿÿÿÿÿŒƒŒeŒ€Kÿÿÿÿÿÿ—ŒŒ[Œ€Lÿÿÿÿÿÿ¡Œ—ŒQŒ€Mÿÿÿÿÿÿ«Œª| |€NÿÿÿÿÿÿµŒ„€Ð|€Oÿÿÿÿÿÿ¿Œ„}€PÿÿÿÿÿÿÉŒí†Äi€QÿÿÿÿÿÿÓŒö‰ò~€Rÿÿÿÿÿÿ݌ӌɌ€SÿÿÿÿÿÿçŒÝŒ¿Œ€TÿÿÿÿÿÿñŒçŒµŒ€UÿÿÿÿÿÿûŒñŒ«Œ€Vÿÿÿÿÿÿc}òh€Wÿÿÿÿÿÿ4Sk€Xÿÿÿÿÿÿkbab€Yÿÿÿÿÿÿ#ˆ‡L~€Zÿÿÿÿÿÿ-}Š€[ÿÿÿÿÿÿ7-#€\ÿÿÿÿÿÿA7€]ÿÿÿÿÿÿKA€^ÿÿÿÿÿÿUK€_ÿÿÿÿÿÿ_~?k€`ÿÿÿÿÿÿiÚVi€aÿÿÿÿÿÿs…Ã}€bÿÿÿÿÿÿ}ˆi~€cÿÿÿÿÿÿ‡òŠ@€dÿÿÿÿÿÿ‘‡}€eÿÿÿÿÿÿ›‘s€fÿÿÿÿÿÿ¥›i€gÿÿÿÿÿÿ¯¥_€hÿÿÿÿÿÿ¹Ì~d|€iÿÿÿÿÿÿÂ}€jÿÿÿÿÿÿÍ«…œi€kÿÿÿÿÿÿטˆ~€lÿÿÿÿÿÿáy‹g€mÿÿÿÿÿÿëá×€nÿÿÿÿÿÿõëÍ€oÿÿÿÿÿÿÿõÀpÿÿÿÿÿÿ Žÿ¹€qÿÿÿÿÿÿŽ Ž¯€rÿÿÿÿÿÿŽŽU€sÿÿÿÿÿÿ'ŽŽûŒ€tÿÿÿÿÿÿ1Ž'Ž¡Œ€uÿÿÿÿÿÿ;Ž| |€vÿÿÿÿÿÿEŽè½|€wÿÿÿÿÿÿOŽ‘ƒti€xÿÿÿÿÿÿYŽe†&~€yÿÿÿÿÿÿcŽx‰ß~€zÿÿÿÿÿÿmŽcŽYŽ€{ÿÿÿÿÿÿwŽmŽOŽ€|ÿÿÿÿÿÿŽwŽEŽ€}ÿÿÿÿÿÿ‹ŽŽ;Ž€~ÿÿÿÿÿÿ•ŽÇ|Þ€ÿÿÿÿÿÿŸŽ—€8i€€ÿÿÿÿÿÿ©Ž-„G€ÿÿÿÿÿÿ³Ž‡í€‚ÿÿÿÿÿÿ½Ž Š°‚€ƒÿÿÿÿÿÿÇŽ½Ž³Ž€„ÿÿÿÿÿÿÑŽÇŽ©Ž€…ÿÿÿÿÿÿÛŽÑŽŸŽ€†ÿÿÿÿÿÿåŽÛŽ•Ž€‡ÿÿÿÿÿÿïŽv}€€ˆÿÿÿÿÿÿùŽQª€€‰ÿÿÿÿÿÿ"]]€Šÿÿÿÿÿÿ ›‡Îi€‹ÿÿÿÿÿÿŠà‚€Œÿÿÿÿÿÿ! €ÿÿÿÿÿÿ+!€Žÿÿÿÿÿÿ5+ùŽ€ÿÿÿÿÿÿ?5ÿÿÿÿÿÿI0~+€€‘ÿÿÿÿÿÿS÷Ñ€€’ÿÿÿÿÿÿ]"…Š€“ÿÿÿÿÿÿg#ˆ:‚€”ÿÿÿÿÿÿq‹(j€•ÿÿÿÿÿÿ{qg€–ÿÿÿÿÿÿ…{]€—ÿÿÿÿÿÿ…S€˜ÿÿÿÿÿÿ™I€™ÿÿÿÿÿÿ£é~i€šÿÿÿÿÿÿ­º‚ø€€›ÿÿÿÿÿÿ·¾…ž€œÿÿÿÿÿÿÁ«ˆa‚€ÿÿÿÿÿÿËŒ‹ƒ€žÿÿÿÿÿÿÕËÁ€ŸÿÿÿÿÿÿßÕ·€ ÿÿÿÿÿÿéß­€¡ÿÿÿÿÿÿó飀¢ÿÿÿÿÿÿý󙀣ÿÿÿÿÿÿý?€¤ÿÿÿÿÿÿ厀¥ÿÿÿÿÿÿ‹Ž€¦ÿÿÿÿÿÿ%g4]4€§ÿÿÿÿÿÿ/€ä|€¨ÿÿÿÿÿÿ9¤ƒ“}€©ÿÿÿÿÿÿCx†qk€ªÿÿÿÿÿÿM‹‰€«ÿÿÿÿÿÿWMC€¬ÿÿÿÿÿÿaW9€­ÿÿÿÿÿÿka/€®ÿÿÿÿÿÿuk%€¯ÿÿÿÿÿÿî|û€°ÿÿÿÿÿÿ‰Ç-½-€±ÿÿÿÿÿÿ“@„~i€²ÿÿÿÿÿÿ‡ ‚€³ÿÿÿÿÿÿ§ŠÍ‚€´ÿÿÿÿÿÿ±§€µÿÿÿÿÿÿ»±“€¶ÿÿÿÿÿÿÅ»‰€·ÿÿÿÿÿÿÏÅ€¸ÿÿÿÿÿÿÙ}5k€¹ÿÿÿÿÿÿãdBi€ºÿÿÿÿÿÿí®‡5…€»ÿÿÿÿÿÿ÷O2­$€¼ÿÿÿÿÿÿ‘÷퀽ÿÿÿÿÿÿ ‘‘ÊJ€¾ÿÿÿÿÿÿ‘ ‘〿ÿÿÿÿÿÿ‘‘Ù€Àÿÿÿÿÿÿ)‘C~ʃ€Áÿÿÿÿÿÿ3‘‚]k€Âÿÿÿÿÿÿ=‘?…À„€ÃÿÿÿÿÿÿG‘--€ÄÿÿÿÿÿÿQ‘‹ä…€Åÿÿÿÿÿÿ[‘Q‘G‘€Æÿÿÿÿÿÿe‘[‘=‘€Çÿÿÿÿÿÿo‘e‘3‘€Èÿÿÿÿÿÿy‘o‘)‘€Éÿÿÿÿÿÿƒ‘Þƒ€Êÿÿÿÿÿÿ‘ׂp„€Ëÿÿÿÿÿÿ—‘·$E2€Ìÿÿÿÿÿÿ¡‘¾ˆo…€Íÿÿÿÿÿÿ«‘Š.€.€Îÿÿÿÿÿÿµ‘«‘¡‘€Ïÿÿÿÿÿÿ¿‘µ‘—‘€ÐÿÿÿÿÿÿÉ‘¿‘‘€ÑÿÿÿÿÿÿÓ‘É‘ƒ‘€ÒÿÿÿÿÿÿÝ‘Ó‘y‘€Óÿÿÿÿÿÿç‘Ý‘‘€Ôÿÿÿÿÿÿñ‘ç‘Ï€Õÿÿÿÿÿÿû‘ñ‘u€Öÿÿÿÿÿÿ’H|>|€×ÿÿÿÿÿÿ’"€Ik€Øÿÿÿÿÿÿ’Áƒ°}€Ùÿÿÿÿÿÿ#’•†°i€Úÿÿÿÿÿÿ-’ž‰-€Ûÿÿÿÿÿÿ7’-’#’€ÜÿÿÿÿÿÿA’7’’€ÝÿÿÿÿÿÿK’A’’€ÞÿÿÿÿÿÿU’K’’€ßÿÿÿÿÿÿ_’}èh€àÿÿÿÿÿÿi’È€¾€€áÿÿÿÿÿÿs’]„w€âÿÿÿÿÿÿ}’0‡'‚€ãÿÿÿÿÿÿ‡’/Šô‚€äÿÿÿÿÿÿ‘’‡’}’€åÿÿÿÿÿÿ›’‘’s’€æÿÿÿÿÿÿ¥’›’i’€çÿÿÿÿÿÿ¯’¥’_’€èÿÿÿÿÿÿ¹’º}·ƒ€éÿÿÿÿÿÿÃ’S„€êÿÿÿÿÿÿÍ’Ë\Á\€ëÿÿÿÿÿÿ×’Á‡R…€ìÿÿÿÿÿÿá’­Šj€íÿÿÿÿÿÿë’á’×’€îÿÿÿÿÿÿõ’ë’Í’€ïÿÿÿÿÿÿÿ’õ’Ã’€ðÿÿÿÿÿÿ “ÿ’¹’€ñÿÿÿÿÿÿ“`~‹†€òÿÿÿÿÿÿ“1‚&‡€óÿÿÿÿÿÿ'“\…’i€ôÿÿÿÿÿÿ1“Jˆ@ˆ€õÿÿÿÿÿÿ;“+‹Ñˆ€öÿÿÿÿÿÿE“;“1“€÷ÿÿÿÿÿÿO“E“'“€øÿÿÿÿÿÿY“O““€ùÿÿÿÿÿÿc“Y““€úÿÿÿÿÿÿm“7±†€ûÿÿÿÿÿÿw“þ‚ji€üÿÿÿÿÿÿ“Û…Ô‡€ýÿÿÿÿÿÿ‹“Ûˆ…k€þÿÿÿÿÿÿ•“©‹‰€ÿÿÿÿÿÿÿŸ“•“‹“€ÿÿÿÿÿÿ©“Ÿ““€ÿÿÿÿÿÿ³“©“w“€ÿÿÿÿÿÿ½“³“m“€ÿÿÿÿÿÿÇ“½“c“€ÿÿÿÿÿÿÑ“Ç“ “€ÿÿÿÿÿÿÛ“Ñ“¯’€ÿÿÿÿÿÿå“Û“U’€ÿÿÿÿÿÿï“[|+k€ÿÿÿÿÿÿù“I€.i€ ÿÿÿÿÿÿ”ëtAo€ ÿÿÿÿÿÿ ”¨†}~€ ÿÿÿÿÿÿ”»‰T€ ÿÿÿÿÿÿ!”” ”€ ÿÿÿÿÿÿ+”!””€ÿÿÿÿÿÿ5”+”ù“€ÿÿÿÿÿÿ?”5”ï“€ÿÿÿÿÿÿI”}?€€ÿÿÿÿÿÿS”ï€å€€ÿÿÿÿÿÿ]”þtTo€ÿÿÿÿÿÿg”M‡N‚€ÿÿÿÿÿÿq”BŠ j€ÿÿÿÿÿÿ{”q”g”€ÿÿÿÿÿÿ…”{”]”€ÿÿÿÿÿÿ”…”S”€ÿÿÿÿÿÿ™””I”€ÿÿÿÿÿÿ£”Koát€ÿÿÿÿÿÿ­”^oôt€ÿÿÿÿÿÿ·”€ÿÿÿÿÿÿÁ”—o-u€ÿÿÿÿÿÿË”Ðofu€ÿÿÿÿÿÿՔ˔Á”€ÿÿÿÿÿÿߔՔ·”€ ÿÿÿÿÿÿé”ß”­”€!ÿÿÿÿÿÿó”锣”€"ÿÿÿÿÿÿý”‡~i€#ÿÿÿÿÿÿ•X‚C‡€$ÿÿÿÿÿÿ•7uo€%ÿÿÿÿÿÿ•]ˆ{k€&ÿÿÿÿÿÿ%•>‹îˆ€'ÿÿÿÿÿÿ/•%••€(ÿÿÿÿÿÿ9•/••€)ÿÿÿÿÿÿC•9••€*ÿÿÿÿÿÿM•C•ý”€+ÿÿÿÿÿÿW•^±‰€,ÿÿÿÿÿÿa•ƒgk€-ÿÿÿÿÿÿk•puÆo€.ÿÿÿÿÿÿu•øˆâi€/ÿÿÿÿÿÿ•Æ‹¼‹€0ÿÿÿÿÿÿ‰••u•€1ÿÿÿÿÿÿ“•‰•k•€2ÿÿÿÿÿÿ•“•a•€3ÿÿÿÿÿÿ§••W•€4ÿÿÿÿÿÿ±•§•M•€5ÿÿÿÿÿÿ»•±•ó”€6ÿÿÿÿÿÿÅ•»•™”€7ÿÿÿÿÿÿÏ•Å•?”€8ÿÿÿÿÿÿÙ•Ï•å“€9ÿÿÿÿÿÿã•Ù•û‘€:ÿÿÿÿÿÿí•ã•€;ÿÿÿÿÿÿ÷•í•1Ž€<ÿÿÿÿÿÿ–»‰•†€=ÿÿÿÿÿÿ ––¤ƒ€>ÿÿÿÿÿÿ– –è€?ÿÿÿÿÿÿ––ú{€@ÿÿÿÿÿÿ)–BŠ0‡€Aÿÿÿÿÿÿ3–)–@„€Bÿÿÿÿÿÿ=–3–—€€CÿÿÿÿÿÿG–=–ª|€DÿÿÿÿÿÿQ–ÐoÁ‡€Eÿÿÿÿÿÿ[–Q–v€Fÿÿÿÿÿÿe–[–Q€Gÿÿÿÿÿÿo–e–c}€Hÿÿÿÿÿÿy–>‹Jˆ€Iÿÿÿÿÿÿƒ–y–?…€Jÿÿÿÿÿÿ–ƒ–÷€Kÿÿÿÿÿÿ—––~€Lÿÿÿÿÿÿ¡–Æ‹Ûˆ€Mÿÿÿÿÿÿ«–¡–·$€Nÿÿÿÿÿÿµ–«–º‚€Oÿÿÿÿÿÿ¿–µ–Ì~€PÿÿÿÿÿÿÉ–¿–—–€QÿÿÿÿÿÿÓ–É–o–€RÿÿÿÿÿÿÝ–Ó–G–€Sÿÿÿÿÿÿç–Ý––€TSÿÿÿÿÿÿñ–œ2.€U>ÿÿÿÿÿÿû–œñ–@Vÿÿÿÿÿÿ—û–€WSÿÿÿÿÿÿ—~2.€X>ÿÿÿÿÿÿ—~—@Yÿÿÿÿÿÿ"——€ZSÿÿÿÿÿÿ+—42.€[>ÿÿÿÿÿÿ5—4+—@\ÿÿÿÿÿÿ?—5—€]SÿÿÿÿÿÿH—<2.€^>ÿÿÿÿÿÿR—<H—@_ÿÿÿÿÿÿ\—R—€`Sÿÿÿÿÿÿe—°2.€a>ÿÿÿÿÿÿo—°e—@bÿÿÿÿÿÿy—o—€cÿÿÿÿÿÿ‚—y—\—€dÿÿÿÿÿÿŒ—‚—?—€eÿÿÿÿÿÿ–—Œ—"—€fÿÿÿÿÿÿ —–——€gSÿÿÿÿÿÿª—œ³-€h>ÿÿÿÿÿÿ´—œª—@iÿÿÿÿÿÿ¾—´—€jSÿÿÿÿÿÿÇ—~³-€k>ÿÿÿÿÿÿÑ—~Ç—@lÿÿÿÿÿÿÛ—Ñ—€mSÿÿÿÿÿÿä—4³-€n>ÿÿÿÿÿÿî—4ä—@oÿÿÿÿÿÿø—î—€pSÿÿÿÿÿÿ˜<³-€q>ÿÿÿÿÿÿ ˜<˜@rÿÿÿÿÿÿ˜ ˜€sSÿÿÿÿÿÿ˜°³-€t>ÿÿÿÿÿÿ(˜°˜@uÿÿÿÿÿÿ2˜(˜€vÿÿÿÿÿÿ;˜2˜˜€wÿÿÿÿÿÿE˜;˜ø—€xÿÿÿÿÿÿO˜E˜Û—€yÿÿÿÿÿÿY˜O˜¾—€zÿÿÿÿÿÿc˜Æ‹+‹€{ÿÿÿÿÿÿm˜c˜O2€|ÿÿÿÿÿÿw˜m˜ Š€}ÿÿÿÿÿÿ˜w˜e‰€~Sÿÿÿÿÿÿ‹˜œú,€>ÿÿÿÿÿÿ•˜œ‹˜@€ÿÿÿÿÿÿŸ˜•˜€Sÿÿÿÿÿÿ¨˜~ú,€‚>ÿÿÿÿÿÿ²˜~¨˜@ƒÿÿÿÿÿÿ¼˜²˜€„SÿÿÿÿÿÿŘ4ú,€…>ÿÿÿÿÿÿϘ4Ř@†ÿÿÿÿÿÿ٘Ϙ€‡Sÿÿÿÿÿÿâ˜<ú,€ˆ>ÿÿÿÿÿÿì˜<â˜@‰ÿÿÿÿÿÿö˜ì˜€ŠSÿÿÿÿÿÿÿ˜°ú,€‹>ÿÿÿÿÿÿ ™°ÿ˜@Œÿÿÿÿÿÿ™ ™€ÿÿÿÿÿÿ™™ö˜€Žÿÿÿÿÿÿ&™™Ù˜€ÿÿÿÿÿÿ0™&™¼˜€ÿÿÿÿÿÿ:™0™Ÿ˜€‘SÿÿÿÿÿÿD™œv.€’>ÿÿÿÿÿÿN™œD™@“ÿÿÿÿÿÿX™N™€”Sÿÿÿÿÿÿa™~v.€•>ÿÿÿÿÿÿk™~a™@–ÿÿÿÿÿÿu™k™€—Sÿÿÿÿÿÿ~™4v.€˜>ÿÿÿÿÿÿˆ™4~™@™ÿÿÿÿÿÿ’™ˆ™€šSÿÿÿÿÿÿ›™<v.€›>ÿÿÿÿÿÿ¥™<›™@œÿÿÿÿÿÿ¯™¥™€Sÿÿÿÿÿÿ¸™°v.€ž>ÿÿÿÿÿÿ™°¸™@Ÿÿÿÿÿÿÿ̙™€ ÿÿÿÿÿÿՙ̙¯™€¡ÿÿÿÿÿÿߙՙ’™€¢ÿÿÿÿÿÿé™ß™u™€£ÿÿÿÿÿÿó™é™X™€¤ÿÿÿÿÿÿý™ó™:™€¥ÿÿÿÿÿÿšý™˜€¦ÿÿÿÿÿÿššY˜€§ÿÿÿÿÿÿšš —€¨Sÿÿÿÿÿÿ%šœÞh€©>ÿÿÿÿÿÿ/š~%š€ªSÿÿÿÿÿÿ9šœê'€«>ÿÿÿÿÿÿCš49š€¬SÿÿÿÿÿÿMšœüh€­>ÿÿÿÿÿÿWš<Mš€®Sÿÿÿÿÿÿašœi€¯>ÿÿÿÿÿÿkš°aš€°ÿÿÿÿÿÿuškšWš€±ÿÿÿÿÿÿšušCš€²ÿÿÿÿÿÿ‰šš/š€³ÿÿÿÿÿÿ“š‰šû–€´Sÿÿÿÿÿÿš~$i€µ>ÿÿÿÿÿÿ§šœš€¶Sÿÿÿÿÿÿ±š~|$€·>ÿÿÿÿÿÿ»š4±š€¸SÿÿÿÿÿÿÅš~Li€¹>ÿÿÿÿÿÿÏš<Åš€ºSÿÿÿÿÿÿÙš~`i€»>ÿÿÿÿÿÿãš°Ùš€¼ÿÿÿÿÿÿíšãšÏš€½ÿÿÿÿÿÿ÷šíš»š€¾ÿÿÿÿÿÿ›÷šÑ—€¿ÿÿÿÿÿÿ ››§š€ÀSÿÿÿÿÿÿ›4f@€Á>ÿÿÿÿÿÿ›œ›€ÂSÿÿÿÿÿÿ)›4x1€Ã>ÿÿÿÿÿÿ3›~)›€ÄSÿÿÿÿÿÿ=›4¿0€Å>ÿÿÿÿÿÿG›<=›€ÆSÿÿÿÿÿÿQ›4;2€Ç>ÿÿÿÿÿÿ[›°Q›€Èÿÿÿÿÿÿe›[›G›€Éÿÿÿÿÿÿo›e›E2€Êÿÿÿÿÿÿy›o›3›€Ëÿÿÿÿÿÿƒ›y››€ÌSÿÿÿÿÿÿ›<¦i€Í>ÿÿÿÿÿÿ—›œ›€ÎSÿÿÿÿÿÿ¡›<ºi€Ï>ÿÿÿÿÿÿ«›~¡›€ÐSÿÿÿÿÿÿµ›<_$€Ñ>ÿÿÿÿÿÿ¿›4µ›€ÒSÿÿÿÿÿÿÉ›<Øi€Ó>ÿÿÿÿÿÿÓ›°É›€Ôÿÿÿÿÿÿݛӛ였Õÿÿÿÿÿÿç›Ý›¿›€Öÿÿÿÿÿÿñ›ç›«›€×ÿÿÿÿÿÿû›ñ›—›€ØSÿÿÿÿÿÿœ°ìi€Ù>ÿÿÿÿÿÿœœœ€ÚSÿÿÿÿÿÿœ°j€Û>ÿÿÿÿÿÿ#œ~œ€ÜSÿÿÿÿÿÿ-œ°£$€Ý>ÿÿÿÿÿÿ7œ4-œ€ÞSÿÿÿÿÿÿAœ°j€ß>ÿÿÿÿÿÿKœ<Aœ€àÿÿÿÿÿÿUœÂ™Kœ€áÿÿÿÿÿÿ_œUœ7œ€âÿÿÿÿÿÿiœ_œ#œ€ãÿÿÿÿÿÿsœiœœ€äÿÿÿÿÿÿ}œsœû›€åÿÿÿÿÿÿ‡œ}œƒ›€æÿÿÿÿÿÿ‘œ‡œ ›€çÿÿÿÿÿÿ›œ‘œ“š€èÿÿÿÿÿÿ¥œËÇ|€éÿÿÿÿÿÿ¯œ~ƒ}€êÿÿÿÿÿÿ¹œR†`~€ëÿÿÿÿÿÿÃœe‰^€ìÿÿÿÿÿÿܹ͜œ€íÿÿÿÿÿÿל͜¯œ€îÿÿÿÿÿÿáœ×œ¥œ€ïÿÿÿÿÿÿëœáœú{€ðÿÿÿÿÿÿõœª|Ë€ñÿÿÿÿÿÿÿœ„€—€€òÿÿÿÿÿÿ „d€óÿÿÿÿÿÿí†1‚€ôÿÿÿÿÿÿö‰ƒ€õÿÿÿÿÿÿ'€öÿÿÿÿÿÿ1' €÷ÿÿÿÿÿÿ;1ÿœ€øÿÿÿÿÿÿE;õœ€ùÿÿÿÿÿÿOc}~ƒ€úÿÿÿÿÿÿY4-„€ûÿÿÿÿÿÿckbv€üÿÿÿÿÿÿmˆ‡\…€ýÿÿÿÿÿÿw}Špu€þÿÿÿÿÿÿwm€ÿÿÿÿÿÿÿ‹c€ÿÿÿÿÿÿ•‹Y€ÿÿÿÿÿÿŸ•O€ÿÿÿÿÿÿ©~R†€ÿÿÿÿÿÿ³Ú‡€ÿÿÿÿÿÿ½…®‡€ÿÿÿÿÿÿLjJˆ€ÿÿÿÿÿÿÑòŠøˆ€ÿÿÿÿÿÿÛÑÇ€ÿÿÿÿÿÿåÛ½€ ÿÿÿÿÿÿïå³€ ÿÿÿÿÿÿùï©€ ÿÿÿÿÿÿžÌ~e‰€ ÿÿÿÿÿÿ ž‚ Š€ ÿÿÿÿÿÿž«…O2€ÿÿÿÿÿÿ!ž˜ˆ+‹€ÿÿÿÿÿÿ+žy‹Æ‹€ÿÿÿÿÿÿ5ž+ž!ž€ÿÿÿÿÿÿ?ž5žž€ÿÿÿÿÿÿIž?ž ž€ÿÿÿÿÿÿSžIžž€ÿÿÿÿÿÿ]žSžù€ÿÿÿÿÿÿgž]žŸ€ÿÿÿÿÿÿqžgžE€ÿÿÿÿÿÿ{žqžëœ€ÿÿÿÿÿÿ…ž|ú{€ÿÿÿÿÿÿžèÇ|€ÿÿÿÿÿÿ™ž‘ƒ}€ÿÿÿÿÿÿ£že†`~€ÿÿÿÿÿÿ­žx‰^€ÿÿÿÿÿÿ·ž­ž£ž€ÿÿÿÿÿÿÁž·ž™ž€ÿÿÿÿÿÿËžÁžž€ ÿÿÿÿÿÿ՞˞…ž€!ÿÿÿÿÿÿßžÇ|Ë€"ÿÿÿÿÿÿéž-„d€#ÿÿÿÿÿÿóž‡1‚€$ÿÿÿÿÿÿýž Šƒ€%ÿÿÿÿÿÿŸýžóž€&ÿÿÿÿÿÿŸŸéž€'ÿÿÿÿÿÿŸŸ—€€(ÿÿÿÿÿÿ%ŸŸßž€)ÿÿÿÿÿÿ/Ÿv}~ƒ€*ÿÿÿÿÿÿ9ŸQ-„€+ÿÿÿÿÿÿCŸ"]v€,ÿÿÿÿÿÿMŸ›‡\…€-ÿÿÿÿÿÿWŸŠpu€.ÿÿÿÿÿÿaŸWŸMŸ€/ÿÿÿÿÿÿkŸaŸCŸ€0ÿÿÿÿÿÿuŸkŸ9Ÿ€1ÿÿÿÿÿÿŸuŸ/Ÿ€2ÿÿÿÿÿÿ‰Ÿ0~R†€3ÿÿÿÿÿÿ“Ÿ÷‡€4ÿÿÿÿÿÿŸ"…®‡€5ÿÿÿÿÿÿ§Ÿ#ˆJˆ€6ÿÿÿÿÿÿ±Ÿ‹øˆ€7ÿÿÿÿÿÿ»Ÿ±Ÿ§Ÿ€8ÿÿÿÿÿÿÅŸ»ŸŸ€9ÿÿÿÿÿÿÏŸÅŸ“Ÿ€:ÿÿÿÿÿÿÙŸÏŸ‰Ÿ€;ÿÿÿÿÿÿãŸé~e‰€<ÿÿÿÿÿÿퟺ‚ Š€=ÿÿÿÿÿÿ÷Ÿ¾…O2€>ÿÿÿÿÿÿ «ˆ+‹€?ÿÿÿÿÿÿ  Œ‹Æ‹€@ÿÿÿÿÿÿ    €Aÿÿÿÿÿÿ  ÷Ÿ€Bÿÿÿÿÿÿ)  íŸ€Cÿÿÿÿÿÿ3 ) ãŸ€Dÿÿÿÿÿÿ= 3 ÙŸ€EÿÿÿÿÿÿG = Ÿ€FÿÿÿÿÿÿQ G %Ÿ€Gÿÿÿÿÿÿ[ Q Õž€Hÿÿÿÿÿÿe g4ú{€Iÿÿÿÿÿÿo €Ç|€Jÿÿÿÿÿÿy ¤ƒ}€Kÿÿÿÿÿÿƒ x†`~€Lÿÿÿÿÿÿ ‹‰^€Mÿÿÿÿÿÿ—  ƒ €Nÿÿÿÿÿÿ¡ — y €Oÿÿÿÿÿÿ« ¡ o €Pÿÿÿÿÿÿµ « e €Qÿÿÿÿÿÿ¿ î|Ë€RÿÿÿÿÿÿÉ Ç-—€€SÿÿÿÿÿÿÓ @„d€TÿÿÿÿÿÿÝ ‡1‚€Uÿÿÿÿÿÿç Šƒ€Vÿÿÿÿÿÿñ ç Ý €Wÿÿÿÿÿÿû ñ Ó €Xÿÿÿÿÿÿ¡û É €Yÿÿÿÿÿÿ¡¡¿ €Zÿÿÿÿÿÿ¡}~ƒ€[ÿÿÿÿÿÿ#¡d-„€\ÿÿÿÿÿÿ-¡®‡\…€]ÿÿÿÿÿÿ7¡O2pu€^ÿÿÿÿÿÿA¡7¡-¡€_ÿÿÿÿÿÿK¡A¡v€`ÿÿÿÿÿÿU¡K¡#¡€aÿÿÿÿÿÿ_¡U¡¡€bÿÿÿÿÿÿi¡C~R†€cÿÿÿÿÿÿs¡‚‡€dÿÿÿÿÿÿ}¡?…®‡€eÿÿÿÿÿÿ‡¡-Jˆ€fÿÿÿÿÿÿ‘¡‹øˆ€gÿÿÿÿÿÿ›¡‘¡‡¡€hÿÿÿÿÿÿ¥¡›¡}¡€iÿÿÿÿÿÿ¯¡¥¡s¡€jÿÿÿÿÿÿ¹¡¯¡i¡€kÿÿÿÿÿÿáe‰€lÿÿÿÿÿÿׂ͡ Š€mÿÿÿÿÿÿס·$O2€nÿÿÿÿÿÿ᡾ˆ+‹€oÿÿÿÿÿÿë¡Š.Æ‹€pÿÿÿÿÿÿõ¡ë¡á¡€qÿÿÿÿÿÿÿ¡õ¡×¡€rÿÿÿÿÿÿ ¢ÿ¡Í¡€sÿÿÿÿÿÿ¢ ¢Ã¡€tÿÿÿÿÿÿ¢¢¹¡€uÿÿÿÿÿÿ'¢¢_¡€vÿÿÿÿÿÿ1¢'¢¡€wÿÿÿÿÿÿ;¢1¢µ €xÿÿÿÿÿÿE¢H|ú{€yÿÿÿÿÿÿO¢"€Ç|€zÿÿÿÿÿÿY¢Áƒ}€{ÿÿÿÿÿÿc¢•†`~€|ÿÿÿÿÿÿm¢ž‰^€}ÿÿÿÿÿÿw¢m¢c¢€~ÿÿÿÿÿÿ¢w¢Y¢€ÿÿÿÿÿÿ‹¢¢O¢€€ÿÿÿÿÿÿ•¢‹¢E¢€ÿÿÿÿÿÿŸ¢}Ë€‚ÿÿÿÿÿÿ©¢È€—€€ƒÿÿÿÿÿÿ³¢]„d€„ÿÿÿÿÿÿ½¢0‡1‚€…ÿÿÿÿÿÿÇ¢/Šƒ€†ÿÿÿÿÿÿѢǢ½¢€‡ÿÿÿÿÿÿۢѢ³¢€ˆÿÿÿÿÿÿå¢Û¢©¢€‰ÿÿÿÿÿÿï¢å¢Ÿ¢€Šÿÿÿÿÿÿù¢º}~ƒ€‹ÿÿÿÿÿÿ£-„€Œÿÿÿÿÿÿ £Ë\v€ÿÿÿÿÿÿ£Á‡\…€Žÿÿÿÿÿÿ!£­Špu€ÿÿÿÿÿÿ+£!££€ÿÿÿÿÿÿ5£+£ £€‘ÿÿÿÿÿÿ?£5££€’ÿÿÿÿÿÿI£?£ù¢€“ÿÿÿÿÿÿS£`~R†€”ÿÿÿÿÿÿ]£1‚‡€•ÿÿÿÿÿÿg£\…®‡€–ÿÿÿÿÿÿq£+‹øˆ€—ÿÿÿÿÿÿ{£q£Jˆ€˜ÿÿÿÿÿÿ…£{£g£€™ÿÿÿÿÿÿ£…£]£€šÿÿÿÿÿÿ™££S£€›ÿÿÿÿÿÿ££7e‰€œÿÿÿÿÿÿ­£þ‚ Š€ÿÿÿÿÿÿ·£Û…O2€žÿÿÿÿÿÿÁ£Ûˆ+‹€ŸÿÿÿÿÿÿË£©‹Æ‹€ ÿÿÿÿÿÿգˣÁ£€¡ÿÿÿÿÿÿߣգ·£€¢ÿÿÿÿÿÿé£ß£­£€£ÿÿÿÿÿÿó£é£££€¤ÿÿÿÿÿÿý£ó£™£€¥ÿÿÿÿÿÿ¤ý£I£€¦ÿÿÿÿÿÿ¤¤ï¢€§ÿÿÿÿÿÿ¤¤•¢€¨ÿÿÿÿÿÿ%¤[|ú{€©ÿÿÿÿÿÿ/¤I€Ç|€ªÿÿÿÿÿÿ9¤ët}€«ÿÿÿÿÿÿC¤¨†`~€¬ÿÿÿÿÿÿM¤»‰^€­ÿÿÿÿÿÿW¤M¤C¤€®ÿÿÿÿÿÿa¤W¤9¤€¯ÿÿÿÿÿÿk¤a¤/¤€°ÿÿÿÿÿÿu¤k¤%¤€±ÿÿÿÿÿÿ¤}Ë€²ÿÿÿÿÿÿ‰¤ï€—€€³ÿÿÿÿÿÿ“¤þtd€´ÿÿÿÿÿÿ¤M‡1‚€µÿÿÿÿÿÿ§¤BŠƒ€¶ÿÿÿÿÿÿ±¤§¤¤€·ÿÿÿÿÿÿ»¤±¤“¤€¸ÿÿÿÿÿÿŤ»¤‰¤€¹ÿÿÿÿÿÿϤŤ¤€ºÿÿÿÿÿÿÙ¤Ko~ƒ€»ÿÿÿÿÿÿã¤^o-„€¼ÿÿÿÿÿÿí¤v€½ÿÿÿÿÿÿ÷¤—o\…€¾ÿÿÿÿÿÿ¥Ðopu€¿ÿÿÿÿÿÿ ¥¥÷¤€Àÿÿÿÿÿÿ¥ ¥í¤€Áÿÿÿÿÿÿ¥¥ã¤€Âÿÿÿÿÿÿ)¥¥Ù¤€Ãÿÿÿÿÿÿ3¥‡~R†€Äÿÿÿÿÿÿ=¥X‚‡€ÅÿÿÿÿÿÿG¥7u®‡€ÆÿÿÿÿÿÿQ¥]ˆJˆ€Çÿÿÿÿÿÿ[¥>‹øˆ€Èÿÿÿÿÿÿe¥[¥Q¥€Éÿÿÿÿÿÿo¥e¥G¥€Êÿÿÿÿÿÿy¥o¥=¥€Ëÿÿÿÿÿÿƒ¥y¥3¥€Ìÿÿÿÿÿÿ¥^e‰€Íÿÿÿÿÿÿ—¥ƒ Š€Îÿÿÿÿÿÿ¡¥puO2€Ïÿÿÿÿÿÿ«¥øˆ+‹€Ðÿÿÿÿÿÿµ¥Æ‹«¥€Ñÿÿÿÿÿÿ¿¥µ¥¡¥€ÒÿÿÿÿÿÿÉ¥¿¥—¥€Óÿÿÿÿÿÿӥɥ¥€ÔÿÿÿÿÿÿÝ¥Ó¥ƒ¥€Õÿÿÿÿÿÿç¥Ý¥)¥€Öÿÿÿÿÿÿñ¥ç¥Ï¤€×ÿÿÿÿÿÿû¥ñ¥u¤€Øÿÿÿÿÿÿ¦û¥¤€Ùÿÿÿÿÿÿ¦¦;¢€Úÿÿÿÿÿÿ¦¦[ €Ûÿÿÿÿÿÿ#¦¦{ž€ÜSÿÿÿÿÿÿ-¦2.2.€Ý>ÿÿÿÿÿÿ7¦œ-¦@ÞÿÿÿÿÿÿA¦7¦€ßSÿÿÿÿÿÿJ¦$i$i€à>ÿÿÿÿÿÿT¦~J¦@áÿÿÿÿÿÿ^¦T¦€âSÿÿÿÿÿÿg¦f@f@€ã>ÿÿÿÿÿÿq¦4g¦@äÿÿÿÿÿÿ{¦q¦€åSÿÿÿÿÿÿ„¦¦i¦i€æ>ÿÿÿÿÿÿŽ¦<„¦@çÿÿÿÿÿÿ˜¦Ž¦€èSÿÿÿÿÿÿ¡¦ìiìi€é>ÿÿÿÿÿÿ«¦°¡¦@êÿÿÿÿÿÿµ¦«¦€ëÿÿÿÿÿÿ¾¦µ¦˜¦€ìÿÿÿÿÿÿȦ¾¦{¦€íÿÿÿÿÿÿҦȦ^¦€îÿÿÿÿÿÿܦҦA¦€ïSÿÿÿÿÿÿæ¦ÞhÞh€ð>ÿÿÿÿÿÿð¦œæ¦@ñÿÿÿÿÿÿú¦ð¦€òSÿÿÿÿÿÿ§³-³-€ó>ÿÿÿÿÿÿ §~§@ôÿÿÿÿÿÿ§ §€õSÿÿÿÿÿÿ §x1x1€ö>ÿÿÿÿÿÿ*§4 §@÷ÿÿÿÿÿÿ4§*§€øSÿÿÿÿÿÿ=§ºiºi€ù>ÿÿÿÿÿÿG§<=§@úÿÿÿÿÿÿQ§G§€ûSÿÿÿÿÿÿZ§jj€ü>ÿÿÿÿÿÿd§°Z§@ýÿÿÿÿÿÿn§d§€þÿÿÿÿÿÿw§n§Q§€ÿÿÿÿÿÿÿ§w§4§€ÿÿÿÿÿÿ‹§§§€ÿÿÿÿÿÿ•§‹§ú¦€SÿÿÿÿÿÿŸ§ê'ê'€>ÿÿÿÿÿÿ©§œŸ§@ÿÿÿÿÿÿ³§©§€Sÿÿÿÿÿÿ¼§|$|$€>ÿÿÿÿÿÿƧ~¼§@ÿÿÿÿÿÿЧƧ€SÿÿÿÿÿÿÙ§_$_$€ >ÿÿÿÿÿÿã§<Ù§@ ÿÿÿÿÿÿí§ã§€ Sÿÿÿÿÿÿö§£$£$€ >ÿÿÿÿÿÿ¨°ö§@ ÿÿÿÿÿÿ ¨¨€ÿÿÿÿÿÿ¨ ¨í§€ÿÿÿÿÿÿ¨¨Š.€ÿÿÿÿÿÿ'¨¨Ð§€ÿÿÿÿÿÿ1¨'¨³§€Sÿÿÿÿÿÿ;¨ühüh€>ÿÿÿÿÿÿE¨œ;¨@ÿÿÿÿÿÿO¨E¨€SÿÿÿÿÿÿX¨LiLi€>ÿÿÿÿÿÿb¨~X¨@ÿÿÿÿÿÿl¨b¨€Sÿÿÿÿÿÿu¨¿0¿0€>ÿÿÿÿÿÿ¨4u¨@ÿÿÿÿÿÿ‰¨¨€Sÿÿÿÿÿÿ’¨ú,ú,€>ÿÿÿÿÿÿœ¨<’¨@ÿÿÿÿÿÿ¦¨œ¨€Sÿÿÿÿÿÿ¯¨jj€>ÿÿÿÿÿÿ¹¨°¯¨@ ÿÿÿÿÿÿ蹨€!ÿÿÿÿÿÿ̨覨€"ÿÿÿÿÿÿ̨֨‰¨€#ÿÿÿÿÿÿà¨Ö¨l¨€$ÿÿÿÿÿÿê¨à¨O¨€%Sÿÿÿÿÿÿô¨ii€&>ÿÿÿÿÿÿþ¨œô¨@'ÿÿÿÿÿÿ©þ¨€(Sÿÿÿÿÿÿ©`i`i€)>ÿÿÿÿÿÿ©~©@*ÿÿÿÿÿÿ%©©€+Sÿÿÿÿÿÿ.©;2;2€,>ÿÿÿÿÿÿ8©4.©@-ÿÿÿÿÿÿB©8©€.SÿÿÿÿÿÿK©ØiØi€/>ÿÿÿÿÿÿU©<K©@0ÿÿÿÿÿÿ_©U©€1Sÿÿÿÿÿÿh©v.v.€2>ÿÿÿÿÿÿr©°h©@3ÿÿÿÿÿÿ|©r©€4ÿÿÿÿÿÿ…©|©_©€5ÿÿÿÿÿÿ©…©B©€6ÿÿÿÿÿÿ™©©%©€7ÿÿÿÿÿÿ£©™©©€8ÿÿÿÿÿÿ­©£©ê¨€9ÿÿÿÿÿÿ·©­©1¨€:ÿÿÿÿÿÿÁ©·©•§€;ÿÿÿÿÿÿË©Á©Ü¦€<SÿÿÿÿÿÿÕ©~Þh€=>ÿÿÿÿÿÿß©œÕ©@>ÿÿÿÿÿÿé©ß©€?Sÿÿÿÿÿÿò©4ê'€@>ÿÿÿÿÿÿü©œò©@Aÿÿÿÿÿÿªü©€BSÿÿÿÿÿÿª<üh€C>ÿÿÿÿÿÿªœª@Dÿÿÿÿÿÿ#ªª€ESÿÿÿÿÿÿ,ª°i€F>ÿÿÿÿÿÿ6ªœ,ª@Gÿÿÿÿÿÿ@ª6ª€HÿÿÿÿÿÿIª@ª#ª€IÿÿÿÿÿÿSªIªª€Jÿÿÿÿÿÿ]ªSªé©€Kÿÿÿÿÿÿgª]ª—€LSÿÿÿÿÿÿqªœ$i€M>ÿÿÿÿÿÿ{ª~qª@Nÿÿÿÿÿÿ…ª{ª€OSÿÿÿÿÿÿŽª4|$€P>ÿÿÿÿÿÿ˜ª~Žª@Qÿÿÿÿÿÿ¢ª˜ª€RSÿÿÿÿÿÿ«ª<Li€S>ÿÿÿÿÿÿµª~«ª@Tÿÿÿÿÿÿ¿ªµª€USÿÿÿÿÿÿȪ°`i€V>ÿÿÿÿÿÿÒª~Ȫ@WÿÿÿÿÿÿܪҪ€XÿÿÿÿÿÿåªÜª¿ª€Yÿÿÿÿÿÿïªåª¢ª€ZÿÿÿÿÿÿùªïªÛ—€[ÿÿÿÿÿÿ«ùª…ª€\Sÿÿÿÿÿÿ «œf@€]>ÿÿÿÿÿÿ«4 «@^ÿÿÿÿÿÿ!««€_Sÿÿÿÿÿÿ*«~x1€`>ÿÿÿÿÿÿ4«4*«@aÿÿÿÿÿÿ>«4«€bSÿÿÿÿÿÿG«<¿0€c>ÿÿÿÿÿÿQ«4G«@dÿÿÿÿÿÿ[«Q«€eSÿÿÿÿÿÿd«°;2€f>ÿÿÿÿÿÿn«4d«@gÿÿÿÿÿÿx«n«€hÿÿÿÿÿÿ«x«[«€iÿÿÿÿÿÿ‹««O2€jÿÿÿÿÿÿ•«‹«>«€kÿÿÿÿÿÿŸ«•«!«€lSÿÿÿÿÿÿ©«œ¦i€m>ÿÿÿÿÿÿ³«<©«@nÿÿÿÿÿÿ½«³«€oSÿÿÿÿÿÿÆ«~ºi€p>ÿÿÿÿÿÿЫ<Æ«@qÿÿÿÿÿÿګЫ€rSÿÿÿÿÿÿã«4_$€s>ÿÿÿÿÿÿí«<ã«@tÿÿÿÿÿÿ÷«í«€uSÿÿÿÿÿÿ¬°Øi€v>ÿÿÿÿÿÿ ¬<¬@wÿÿÿÿÿÿ¬ ¬€xÿÿÿÿÿÿ¬¬ö˜€yÿÿÿÿÿÿ'¬¬÷«€zÿÿÿÿÿÿ1¬'¬Ú«€{ÿÿÿÿÿÿ;¬1¬½«€|SÿÿÿÿÿÿE¬œìi€}>ÿÿÿÿÿÿO¬°E¬@~ÿÿÿÿÿÿY¬O¬€Sÿÿÿÿÿÿb¬~j€€>ÿÿÿÿÿÿl¬°b¬@ÿÿÿÿÿÿv¬l¬€‚Sÿÿÿÿÿÿ¬4£$€ƒ>ÿÿÿÿÿÿ‰¬°¬@„ÿÿÿÿÿÿ“¬‰¬€…Sÿÿÿÿÿÿœ¬<j€†>ÿÿÿÿÿÿ¦¬°œ¬@‡ÿÿÿÿÿÿ°¬¦¬€ˆÿÿÿÿÿÿ¹¬Ì™°¬€‰ÿÿÿÿÿÿ칬“¬€Šÿÿÿÿÿÿͬìv¬€‹ÿÿÿÿÿÿ׬ͬY¬€Œÿÿÿÿÿÿá¬×¬;¬€ÿÿÿÿÿÿë¬á¬Ÿ«€Žÿÿÿÿÿÿõ¬ë¬«€ÿÿÿÿÿÿÿ¬õ¬gª€>ÿÿÿÿÿÿ ­~æ¦@‘ÿÿÿÿÿÿ­ ­€’>ÿÿÿÿÿÿ­4Ÿ§@“ÿÿÿÿÿÿ&­­€”>ÿÿÿÿÿÿ/­<;¨@•ÿÿÿÿÿÿ9­/­€–>ÿÿÿÿÿÿB­°ô¨@—ÿÿÿÿÿÿL­B­€˜ÿÿÿÿÿÿU­L­9­€™ÿÿÿÿÿÿ_­U­&­€šÿÿÿÿÿÿi­_­­€›ÿÿÿÿÿÿs­i­A¦€œ>ÿÿÿÿÿÿ}­œJ¦@ÿÿÿÿÿÿ‡­}­€ž>ÿÿÿÿÿÿ­4¼§@Ÿÿÿÿÿÿÿš­­€ >ÿÿÿÿÿÿ£­<X¨@¡ÿÿÿÿÿÿ­­£­€¢>ÿÿÿÿÿÿ¶­°©@£ÿÿÿÿÿÿÀ­¶­€¤ÿÿÿÿÿÿÉ­À­­­€¥ÿÿÿÿÿÿÓ­É­š­€¦ÿÿÿÿÿÿÝ­Ó­§€§ÿÿÿÿÿÿç­Ý­‡­€¨>ÿÿÿÿÿÿñ­œg¦@©ÿÿÿÿÿÿû­ñ­€ª>ÿÿÿÿÿÿ®~ §@«ÿÿÿÿÿÿ®®€¬>ÿÿÿÿÿÿ®<u¨@­ÿÿÿÿÿÿ!®®€®>ÿÿÿÿÿÿ*®°.©@¯ÿÿÿÿÿÿ4®*®€°ÿÿÿÿÿÿ=®4®!®€±ÿÿÿÿÿÿG®=®Š.€²ÿÿÿÿÿÿQ®G®®€³ÿÿÿÿÿÿ[®Q®û­€´>ÿÿÿÿÿÿe®œ„¦@µÿÿÿÿÿÿo®e®€¶>ÿÿÿÿÿÿx®~=§@·ÿÿÿÿÿÿ‚®x®€¸>ÿÿÿÿÿÿ‹®4Ù§@¹ÿÿÿÿÿÿ•®‹®€º>ÿÿÿÿÿÿž®°K©@»ÿÿÿÿÿÿ¨®ž®€¼ÿÿÿÿÿÿ±®¨®¦¨€½ÿÿÿÿÿÿ»®±®•®€¾ÿÿÿÿÿÿÅ®»®‚®€¿ÿÿÿÿÿÿϮŮo®€À>ÿÿÿÿÿÿÙ®œ¡¦@Áÿÿÿÿÿÿã®Ù®€Â>ÿÿÿÿÿÿì®~Z§@Ãÿÿÿÿÿÿö®ì®€Ä>ÿÿÿÿÿÿÿ®4ö§@Åÿÿÿÿÿÿ ¯ÿ®€Æ>ÿÿÿÿÿÿ¯<¯¨@Çÿÿÿÿÿÿ¯¯€Èÿÿÿÿÿÿ%¯|©¯€Éÿÿÿÿÿÿ/¯%¯ ¯€Êÿÿÿÿÿÿ9¯/¯ö®€ËÿÿÿÿÿÿC¯9¯ã®€ÌÿÿÿÿÿÿM¯C¯Ï®€ÍÿÿÿÿÿÿW¯M¯[®€Îÿÿÿÿÿÿa¯W¯ç­€Ïÿÿÿÿÿÿk¯a¯s­€Ðÿÿÿÿÿÿu¯y‹ˆ€Ñÿÿÿÿÿÿ¯u¯kb€Òÿÿÿÿÿÿ‰¯¯„€€Óÿÿÿÿÿÿ“¯‰¯ú{€Ôÿÿÿÿÿÿ¯ð{“¯€Õÿÿÿÿÿÿ§¯Œ‹#ˆ€Öÿÿÿÿÿÿ±¯§¯"]€×ÿÿÿÿÿÿ»¯±¯—€€Øÿÿÿÿÿÿů»¯|€Ùÿÿÿÿÿÿϯ |ů€ÚÿÿÿÿÿÿÙ¯Š.-€Ûÿÿÿÿÿÿã¯Ù¯v€Üÿÿÿÿÿÿí¯ã¯Ç-€Ýÿÿÿÿÿÿ÷¯í¯g4€Þÿÿÿÿÿÿ°òh÷¯€ßÿÿÿÿÿÿ °©‹Jˆ€àÿÿÿÿÿÿ° °Ë\€áÿÿÿÿÿÿ°°È€€âÿÿÿÿÿÿ)°°H|€ãÿÿÿÿÿÿ3°?k)°€äÿÿÿÿÿÿ=°Æ‹]ˆ€åÿÿÿÿÿÿG°=°€æÿÿÿÿÿÿQ°çÿÿÿÿÿÿ[°[|€èÿÿÿÿÿÿe°d|€éÿÿÿÿÿÿo°e°3°€êÿÿÿÿÿÿy°o°°€ëÿÿÿÿÿÿƒ°y°Ï¯€ìÿÿÿÿÿÿ°ƒ°¯€íÿÿÿÿÿÿ—°½|“¯€îÿÿÿÿÿÿ¡°8iů€ïÿÿÿÿÿÿ«°ª€÷¯€ðÿÿÿÿÿÿµ°Ñ€)°€ñÿÿÿÿÿÿ¿°ø€€òÿÿÿÿÿÿÉ°¿°µ°€óÿÿÿÿÿÿÓ°É°«°€ôÿÿÿÿÿÿÝ°Ó°¡°€õÿÿÿÿÿÿç°Ý°—°€öÿÿÿÿÿÿñ°“}“¯€÷ÿÿÿÿÿÿû°~iů€øÿÿÿÿÿÿ±ì÷¯€ùÿÿÿÿÿÿ±À„)°€úÿÿÿÿÿÿ±E2€ûÿÿÿÿÿÿ#±±±€üÿÿÿÿÿÿ-±#±±€ýÿÿÿÿÿÿ7±-±û°€þÿÿÿÿÿÿA±7±ñ°€ÿÿÿÿÿÿÿK±°i“¯€ÿÿÿÿÿÿU±'‚ů€ÿÿÿÿÿÿ_±R…÷¯€ÿÿÿÿÿÿi±@ˆ)°€ÿÿÿÿÿÿs±…k€ÿÿÿÿÿÿ}±s±i±€ÿÿÿÿÿÿ‡±}±_±€ÿÿÿÿÿÿ‘±‡±U±€ÿÿÿÿÿÿ›±‘±K±€ÿÿÿÿÿÿ¥±T“¯€ ÿÿÿÿÿÿ¯± jů€ ÿÿÿÿÿÿ¹±fu÷¯€ ÿÿÿÿÿÿñîˆ)°€ ÿÿÿÿÿÿͱ¼‹€ ÿÿÿÿÿÿױͱñ€ÿÿÿÿÿÿá±×±¹±€ÿÿÿÿÿÿë±á±¯±€ÿÿÿÿÿÿõ±ë±¥±€ÿÿÿÿÿÿÿ±õ±›±€ÿÿÿÿÿÿ ²ÿ±A±€ÿÿÿÿÿÿ² ²ç°€ÿÿÿÿÿÿ²²°€Sÿÿÿÿÿÿ'²$iœ€>ÿÿÿÿÿÿ1²~'²€Sÿÿÿÿÿÿ;²f@œ€>ÿÿÿÿÿÿE²4;²€SÿÿÿÿÿÿO²¦iœ€>ÿÿÿÿÿÿY²<O²€Sÿÿÿÿÿÿc²ìiœ€>ÿÿÿÿÿÿm²°c²€ÿÿÿÿÿÿw²m²Y²€ÿÿÿÿÿÿ²w²E²€ÿÿÿÿÿÿ‹²²1²€ ÿÿÿÿÿÿ•²‹²Rx€!SÿÿÿÿÿÿŸ²Þh~€">ÿÿÿÿÿÿ©²œŸ²€#Sÿÿÿÿÿÿ³²x1~€$>ÿÿÿÿÿÿ½²4³²€%SÿÿÿÿÿÿDzºi~€&>ÿÿÿÿÿÿѲ<Dz€'SÿÿÿÿÿÿÛ²j~€(>ÿÿÿÿÿÿå²°Û²€)ÿÿÿÿÿÿï²å²Ñ²€*ÿÿÿÿÿÿù²ï²½²€+ÿÿÿÿÿÿ³ù²(y€,ÿÿÿÿÿÿ ³³©²€-Sÿÿÿÿÿÿ³ê'4€.>ÿÿÿÿÿÿ!³œ³€/Sÿÿÿÿÿÿ+³|$4€0>ÿÿÿÿÿÿ5³~+³€1Sÿÿÿÿÿÿ?³_$4€2>ÿÿÿÿÿÿI³<?³€3SÿÿÿÿÿÿS³£$4€4>ÿÿÿÿÿÿ]³°S³€5ÿÿÿÿÿÿg³]³I³€6ÿÿÿÿÿÿq³g³­$€7ÿÿÿÿÿÿ{³q³5³€8ÿÿÿÿÿÿ…³{³!³€9Sÿÿÿÿÿÿ³üh<€:>ÿÿÿÿÿÿ™³œ³€;Sÿÿÿÿÿÿ£³Li<€<>ÿÿÿÿÿÿ­³~£³€=Sÿÿÿÿÿÿ·³¿0<€>>ÿÿÿÿÿÿÁ³4·³€?Sÿÿÿÿÿÿ˳j<€@>ÿÿÿÿÿÿÕ³°Ë³€Aÿÿÿÿÿÿß³Õ³·z€Bÿÿÿÿÿÿé³ß³Á³€Cÿÿÿÿÿÿó³é³­³€Dÿÿÿÿÿÿý³ó³™³€ESÿÿÿÿÿÿ´i°€F>ÿÿÿÿÿÿ´œ´€GSÿÿÿÿÿÿ´`i°€H>ÿÿÿÿÿÿ%´~´€ISÿÿÿÿÿÿ/´;2°€J>ÿÿÿÿÿÿ9´4/´€KSÿÿÿÿÿÿC´Øi°€L>ÿÿÿÿÿÿM´<C´€MÿÿÿÿÿÿW´{M´€Nÿÿÿÿÿÿa´W´9´€Oÿÿÿÿÿÿk´a´%´€Pÿÿÿÿÿÿu´k´´€Qÿÿÿÿÿÿ´u´ý³€Rÿÿÿÿÿÿ‰´´…³€Sÿÿÿÿÿÿ“´‰´ ³€Tÿÿÿÿÿÿ´“´•²€Uÿÿÿÿÿÿ§´#{jz€Vÿÿÿÿÿÿ±´§´Îy€Wÿÿÿÿÿÿ»´±´y€XÿÿÿÿÿÿÅ´»´\x€YÿÿÿÿÿÿÏ´@{‡z€ZÿÿÿÿÿÿÙ´Ï´ëy€[ÿÿÿÿÿÿã´Ù´2y€\ÿÿÿÿÿÿí´ã´yx€]ÿÿÿÿÿÿ÷´]{¤z€^ÿÿÿÿÿÿµ÷´·$€_ÿÿÿÿÿÿ µµOy€`ÿÿÿÿÿÿµ µ–x€aÿÿÿÿÿÿµz{Áz€bÿÿÿÿÿÿ)µµz€cÿÿÿÿÿÿ3µ)µly€dÿÿÿÿÿÿ=µ3µ³x€eÿÿÿÿÿÿGµ—{Þz€fÿÿÿÿÿÿQµGµ%z€gÿÿÿÿÿÿ[µQµ‰y€hÿÿÿÿÿÿeµ[µÐx€iÿÿÿÿÿÿoµeµ=µ€jÿÿÿÿÿÿyµoµµ€kÿÿÿÿÿÿƒµyµí´€lÿÿÿÿÿÿµƒµÅ´@mÿÿÿÿÿÿ—µ1²@nÿÿÿÿÿÿ µE²@oÿÿÿÿÿÿ©µY²@pÿÿÿÿÿÿ²µm²€qÿÿÿÿÿÿ»µ²µ©µ€rÿÿÿÿÿÿŵ»µ µ€sÿÿÿÿÿÿϵŵ—µ€tÿÿÿÿÿÿٵϵ\x@uÿÿÿÿÿÿ㵩²@vÿÿÿÿÿÿìµ½²@wÿÿÿÿÿÿõµÑ²@xÿÿÿÿÿÿþµå²€yÿÿÿÿÿÿ¶þµõµ€zÿÿÿÿÿÿ¶¶ìµ€{ÿÿÿÿÿÿ¶¶2y€|ÿÿÿÿÿÿ%¶¶ãµ@}ÿÿÿÿÿÿ/¶!³@~ÿÿÿÿÿÿ8¶5³@ÿÿÿÿÿÿA¶I³@€ÿÿÿÿÿÿJ¶]³€ÿÿÿÿÿÿS¶J¶A¶€‚ÿÿÿÿÿÿ]¶S¶·$€ƒÿÿÿÿÿÿg¶]¶8¶€„ÿÿÿÿÿÿq¶g¶/¶@…ÿÿÿÿÿÿ{¶™³@†ÿÿÿÿÿÿ„¶­³@‡ÿÿÿÿÿÿ¶Á³@ˆÿÿÿÿÿÿ–¶Õ³€‰ÿÿÿÿÿÿŸ¶–¶Áz€Šÿÿÿÿÿÿ©¶Ÿ¶¶€‹ÿÿÿÿÿÿ³¶©¶„¶€Œÿÿÿÿÿÿ½¶³¶{¶@ÿÿÿÿÿÿǶ´@Žÿÿÿÿÿÿж%´@ÿÿÿÿÿÿÙ¶9´@ÿÿÿÿÿÿâ¶M´€‘ÿÿÿÿÿÿ붗{ⶀ’ÿÿÿÿÿÿõ¶ë¶Ù¶€“ÿÿÿÿÿÿÿ¶õ¶Ð¶€”ÿÿÿÿÿÿ ·ÿ¶Ç¶€•ÿÿÿÿÿÿ· ·½¶€–ÿÿÿÿÿÿ··q¶€—ÿÿÿÿÿÿ'··%¶€˜ÿÿÿÿÿÿ1·'·Ùµ€™ÿÿÿÿÿÿ;·¼‹@ˆ€šÿÿÿÿÿÿE·;·ì€›ÿÿÿÿÿÿO·E·8i€œÿÿÿÿÿÿY·O·ð{€ÿÿÿÿÿÿc·Ëª|€žÿÿÿÿÿÿm·~ƒc}€Ÿÿÿÿÿÿÿw·R†~€ ÿÿÿÿÿÿ·e‰Ì~€¡ÿÿÿÿÿÿ‹··w·€¢ÿÿÿÿÿÿ•·‹·m·€£ÿÿÿÿÿÿŸ·•·c·€¤ÿÿÿÿÿÿ©·Ÿ·ú{€¥ÿÿÿÿÿÿ³·„4€¦ÿÿÿÿÿÿ½·í†Ú€§ÿÿÿÿÿÿÇ·ö‰‚€¨ÿÿÿÿÿÿÑ·Ç·½·€©ÿÿÿÿÿÿÛ·Ñ·³·€ªÿÿÿÿÿÿå·Û·„€€«ÿÿÿÿÿÿï·å·õœ€¬ÿÿÿÿÿÿù·4„€­ÿÿÿÿÿÿ¸ˆ‡…€®ÿÿÿÿÿÿ ¸}Š«…€¯ÿÿÿÿÿÿ¸ ¸¸€°ÿÿÿÿÿÿ!¸¸kb€±ÿÿÿÿÿÿ+¸!¸ù·€²ÿÿÿÿÿÿ5¸+¸O€³ÿÿÿÿÿÿ?¸Ú톀´ÿÿÿÿÿÿI¸…ˆ‡€µÿÿÿÿÿÿS¸òŠ˜ˆ€¶ÿÿÿÿÿÿ]¸S¸ˆ€·ÿÿÿÿÿÿg¸]¸I¸€¸ÿÿÿÿÿÿq¸g¸?¸€¹ÿÿÿÿÿÿ{¸q¸©€ºÿÿÿÿÿÿ…¸‚ö‰€»ÿÿÿÿÿÿ¸«…}Š€¼ÿÿÿÿÿÿ™¸˜ˆòŠ€½ÿÿÿÿÿÿ£¸y‹™¸€¾ÿÿÿÿÿÿ­¸£¸¸€¿ÿÿÿÿÿÿ·¸­¸…¸€ÀÿÿÿÿÿÿÁ¸·¸ž€Áÿÿÿÿÿÿ˸Á¸{¸€Âÿÿÿÿÿÿո˸5¸€Ãÿÿÿÿÿÿ߸ոﷀÄÿÿÿÿÿÿé¸ß¸©·€Åÿÿÿÿÿÿ󸑃v}€Æÿÿÿÿÿÿý¸e†0~€Çÿÿÿÿÿÿ¹x‰é~€Èÿÿÿÿÿÿ¹¹ý¸€Éÿÿÿÿÿÿ¹¹ó¸€Êÿÿÿÿÿÿ%¹¹ž€Ëÿÿÿÿÿÿ/¹%¹|€Ìÿÿÿÿÿÿ9¹Ç|è€ÍÿÿÿÿÿÿC¹-„Q€ÎÿÿÿÿÿÿM¹‡÷€ÏÿÿÿÿÿÿW¹ Šº‚€Ðÿÿÿÿÿÿa¹W¹M¹€Ñÿÿÿÿÿÿk¹a¹C¹€Òÿÿÿÿÿÿu¹k¹—€€Óÿÿÿÿÿÿ¹u¹9¹€Ôÿÿÿÿÿÿ‰¹v}‘ƒ€Õÿÿÿÿÿÿ“¹›‡"…€Öÿÿÿÿÿÿ¹Š¾…€×ÿÿÿÿÿÿ§¹¹“¹€Øÿÿÿÿÿÿ±¹§¹"]€Ùÿÿÿÿÿÿ»¹±¹9Ÿ€ÚÿÿÿÿÿÿŹ»¹‰¹€ÛÿÿÿÿÿÿϹ0~e†€ÜÿÿÿÿÿÿÙ¹"…›‡€Ýÿÿÿÿÿÿ㹋«ˆ€Þÿÿÿÿÿÿí¹ã¹#ˆ€ßÿÿÿÿÿÿ÷¹í¹Ù¹€àÿÿÿÿÿÿº÷¹“Ÿ€áÿÿÿÿÿÿ ººÏ¹€âÿÿÿÿÿÿºé~x‰€ãÿÿÿÿÿÿº¾…Š€äÿÿÿÿÿÿ)º«ˆ‹€åÿÿÿÿÿÿ3ºŒ‹)º€æÿÿÿÿÿÿ=º3ºº€çÿÿÿÿÿÿGº=ºíŸ€èÿÿÿÿÿÿQºGºº€éÿÿÿÿÿÿ[ºQº º€êÿÿÿÿÿÿeº[ºÅ¹€ëÿÿÿÿÿÿoºeº¹€ìÿÿÿÿÿÿyºoº/¹€íÿÿÿÿÿÿƒº€î|€îÿÿÿÿÿÿºx†C~€ïÿÿÿÿÿÿ—º‹‰€ðÿÿÿÿÿÿ¡º—ºº€ñÿÿÿÿÿÿ«º¡ºy €òÿÿÿÿÿÿµº«ºƒº€óÿÿÿÿÿÿ¿ºµºg4€ôÿÿÿÿÿÿɺî|€€õÿÿÿÿÿÿÓº‡‚€öÿÿÿÿÿÿݺŠ×‚€÷ÿÿÿÿÿÿçºÝºÓº€øÿÿÿÿÿÿñºçºÓ €ùÿÿÿÿÿÿûºñºÇ-€úÿÿÿÿÿÿ»ûºÉº€ûÿÿÿÿÿÿ»}¤ƒ€üÿÿÿÿÿÿ»d@„€ýÿÿÿÿÿÿ#»®‡?…€þÿÿÿÿÿÿ-»O2·$€ÿÿÿÿÿÿÿ7»-»#»€ÿÿÿÿÿÿA»7»v€ÿÿÿÿÿÿK»A»»€ÿÿÿÿÿÿU»K»»€ÿÿÿÿÿÿ_»C~x†€ÿÿÿÿÿÿi»‚‡€ÿÿÿÿÿÿs»‹¾ˆ€ÿÿÿÿÿÿ}»s»-€ÿÿÿÿÿÿ‡»}»}¡€ÿÿÿÿÿÿ‘»‡»i»€ ÿÿÿÿÿÿ›»‘»_»€ ÿÿÿÿÿÿ¥»‹‰€ ÿÿÿÿÿÿ¯»×‚Š€ ÿÿÿÿÿÿ¹»¾ˆ‹€ ÿÿÿÿÿÿûŠ.¹»€ÿÿÿÿÿÿͻûס€ÿÿÿÿÿÿ׻ͻ¯»€ÿÿÿÿÿÿá»×»¥»€ÿÿÿÿÿÿë»á»›»€ÿÿÿÿÿÿõ»ë»U»€ÿÿÿÿÿÿÿ»õ»»€ÿÿÿÿÿÿ ¼ÿ»¿º€ÿÿÿÿÿÿ¼"€}€ÿÿÿÿÿÿ¼Áƒº}€ÿÿÿÿÿÿ'¼ž‰7€ÿÿÿÿÿÿ1¼'¼c¢€ÿÿÿÿÿÿ;¼1¼¼€ÿÿÿÿÿÿE¼;¼¼€ÿÿÿÿÿÿO¼E¼H|€ÿÿÿÿÿÿY¼}"€€ÿÿÿÿÿÿc¼]„€ÿÿÿÿÿÿm¼/Šþ‚€ÿÿÿÿÿÿw¼m¼½¢€ ÿÿÿÿÿÿ¼w¼c¼€!ÿÿÿÿÿÿ‹¼¼È€€"ÿÿÿÿÿÿ•¼‹¼Y¼€#ÿÿÿÿÿÿŸ¼º}Áƒ€$ÿÿÿÿÿÿ©¼]„€%ÿÿÿÿÿÿ³¼­ŠÛ…€&ÿÿÿÿÿÿ½¼³¼£€'ÿÿÿÿÿÿǼ½¼Ë\€(ÿÿÿÿÿÿѼǼ©¼€)ÿÿÿÿÿÿۼѼŸ¼€*ÿÿÿÿÿÿå¼`~•†€+ÿÿÿÿÿÿï¼1‚0‡€,ÿÿÿÿÿÿù¼\…Á‡€-ÿÿÿÿÿÿ½+‹Ûˆ€.ÿÿÿÿÿÿ ½½Jˆ€/ÿÿÿÿÿÿ½ ½ù¼€0ÿÿÿÿÿÿ!½½ï¼€1ÿÿÿÿÿÿ+½!½å¼€2ÿÿÿÿÿÿ5½7ž‰€3ÿÿÿÿÿÿ?½þ‚/Š€4ÿÿÿÿÿÿI½Û…­Š€5ÿÿÿÿÿÿS½©‹Á£€6ÿÿÿÿÿÿ]½S½I½€7ÿÿÿÿÿÿg½]½?½€8ÿÿÿÿÿÿq½g½5½€9ÿÿÿÿÿÿ{½q½+½€:ÿÿÿÿÿÿ…½{½Û¼€;ÿÿÿÿÿÿ½…½•¼€<ÿÿÿÿÿÿ™½½O¼€=ÿÿÿÿÿÿ£½I€}€>ÿÿÿÿÿÿ­½ëtKo€?ÿÿÿÿÿÿ·½¨†‡~€@ÿÿÿÿÿÿÁ½M¤·½€Aÿÿÿÿÿÿ˽Á½­½€Bÿÿÿÿÿÿս˽£½€Cÿÿÿÿÿÿß½Õ½[|€Dÿÿÿÿÿÿé½}I€€Eÿÿÿÿÿÿó½þt^o€Fÿÿÿÿÿÿý½M‡X‚€Gÿÿÿÿÿÿ¾§¤ý½€Hÿÿÿÿÿÿ¾¾ó½€Iÿÿÿÿÿÿ¾¾ï€€Jÿÿÿÿÿÿ%¾¾é½€Kÿÿÿÿÿÿ/¾Koët€Lÿÿÿÿÿÿ9¾^oþt€MÿÿÿÿÿÿC¾—o7u€NÿÿÿÿÿÿM¾¥C¾€OÿÿÿÿÿÿW¾M¾Ô„€Pÿÿÿÿÿÿa¾W¾9¾€Qÿÿÿÿÿÿk¾a¾/¾€Rÿÿÿÿÿÿu¾‡~¨†€Sÿÿÿÿÿÿ¾X‚M‡€Tÿÿÿÿÿÿ‰¾7u—o€Uÿÿÿÿÿÿ“¾[¥]ˆ€Vÿÿÿÿÿÿ¾“¾‰¾€Wÿÿÿÿÿÿ§¾¾¾€Xÿÿÿÿÿÿ±¾§¾u¾€Yÿÿÿÿÿÿ»¾^»‰€ZÿÿÿÿÿÿžƒBŠ€[ÿÿÿÿÿÿϾpuÐo€\ÿÿÿÿÿÿÙ¾øˆ>‹€]ÿÿÿÿÿÿã¾Æ‹Ù¾€^ÿÿÿÿÿÿí¾ã¾Ï¾€_ÿÿÿÿÿÿ÷¾í¾Å¾€`ÿÿÿÿÿÿ¿÷¾»¾€aÿÿÿÿÿÿ ¿¿±¾€bÿÿÿÿÿÿ¿ ¿k¾€cÿÿÿÿÿÿ¿¿%¾€dÿÿÿÿÿÿ)¿¿ß½€eÿÿÿÿÿÿ3¿)¿™½€fÿÿÿÿÿÿ=¿3¿ ¼€gÿÿÿÿÿÿG¿=¿yº€hÿÿÿÿÿÿQ¿G¿é¸€iÿÿÿÿÿÿ[¿[°)°€jÿÿÿÿÿÿe¿[¿÷¯€kÿÿÿÿÿÿo¿e¿Å¯€lÿÿÿÿÿÿy¿o¿“¯€mÿÿÿÿÿÿƒ¿öi ~€nÿÿÿÿÿÿ¿ƒ¿Y}€oÿÿÿÿÿÿ—¿¿ |€pÿÿÿÿÿÿ¡¿—¿ð{€qÿÿÿÿÿÿ«¿d|?k€rÿÿÿÿÿÿµ¿«¿òh€sÿÿÿÿÿÿ¿¿µ¿ |€tÿÿÿÿÿÿÉ¿¿¿ð{€uÿÿÿÿÿÿÓ¿É¿¡¿€vÿÿÿÿÿÿÝ¿ß~&~€wÿÿÿÿÿÿç¿Ý¿ti€xÿÿÿÿÿÿñ¿ç¿½|€yÿÿÿÿÿÿû¿ñ¿ |€zÿÿÿÿÿÿÀi+€€{ÿÿÿÿÿÿÀÀ€€|ÿÿÿÿÿÿÀÀÞ€}ÿÿÿÿÿÿ#ÀÀ |€~ÿÿÿÿÿÿ-À#Àû¿€ÿÿÿÿÿÿ7Àqk€€ÿÿÿÿÿÿAÀ7À“}€ÿÿÿÿÿÿKÀAÀä|€‚ÿÿÿÿÿÿUÀKÀ]4€ƒÿÿÿÿÿÿ_Àރʃ€„ÿÿÿÿÿÿiÀ_À5k€…ÿÿÿÿÿÿsÀiÀû€†ÿÿÿÿÿÿ}ÀsÀ]4€‡ÿÿÿÿÿÿ‡À}ÀUÀ€ˆÿÿÿÿÿÿ‘À-°i€‰ÿÿÿÿÿÿ›À‘À°}€Šÿÿÿÿÿÿ¥À›ÀIk€‹ÿÿÿÿÿÿ¯À¥À>|€Œÿÿÿÿÿÿ¹À±†‹†€ÿÿÿÿÿÿÃÀ¹À·ƒ€ŽÿÿÿÿÿÿÍÀÃÀèh€ÿÿÿÿÿÿ×ÀÍÀ>|€ÿÿÿÿÿÿáÀ×À¯À€‘ÿÿÿÿÿÿëÀT}~€’ÿÿÿÿÿÿõÀëÀAo€“ÿÿÿÿÿÿÿÀõÀ.i€”ÿÿÿÿÿÿ ÁÿÀ+k€•ÿÿÿÿÿÿÁ±‰i€–ÿÿÿÿÿÿÁÁát€—ÿÿÿÿÿÿ'ÁÁ?€€˜ÿÿÿÿÿÿ1Á'Á+k€™ÿÿÿÿÿÿ;Á1Á Á€šÿÿÿÿÿÿEÁ;ÁáÀ€›ÿÿÿÿÿÿOÁEÁ‡À€œÿÿÿÿÿÿYÁOÁ-À€ÿÿÿÿÿÿcÁYÁÓ¿€žÿÿÿÿÿÿmÁò~Äi€ŸÿÿÿÿÿÿwÁmÁ}€ ÿÿÿÿÿÿÁwÁÐ|€¡ÿÿÿÿÿÿ‹ÁÁ |€¢ÿÿÿÿÿÿ•Á}Vi€£ÿÿÿÿÿÿŸÁ•ÁSk€¤ÿÿÿÿÿÿ©ÁŸÁÐ|€¥ÿÿÿÿÿÿ³Á©Á |€¦ÿÿÿÿÿÿ½Á³Á‹Á€§ÿÿÿÿÿÿÇÁ°‚퀨ÿÿÿÿÿÿÑÁÇÁG€©ÿÿÿÿÿÿÛÁÑÁ8i€ªÿÿÿÿÿÿåÁÛÁÞ€«ÿÿÿÿÿÿïÁø€Ñ€€¬ÿÿÿÿÿÿùÁïÁª€€­ÿÿÿÿÿÿÂùÁ8i€®ÿÿÿÿÿÿ ½|€¯ÿÿÿÿÿÿ ÂåÁ€°ÿÿÿÿÿÿ!ÂÍ‚ ‚€±ÿÿÿÿÿÿ+Â!Â~i€²ÿÿÿÿÿÿ5Â+½-€³ÿÿÿÿÿÿ?Â5Âû€´ÿÿÿÿÿÿIÂp„]k€µÿÿÿÿÿÿSÂIÂBi€¶ÿÿÿÿÿÿ]ÂS½-€·ÿÿÿÿÿÿgÂ]Âä|€¸ÿÿÿÿÿÿqÂgÂ?€¹ÿÿÿÿÿÿ{Âô‚'‚€ºÿÿÿÿÿÿ…Â{Âw€»ÿÿÿÿÿÿ…¾€€¼ÿÿÿÿÿÿ™ÂÂèh€½ÿÿÿÿÿÿ£Âji&‡€¾ÿÿÿÿÿÿ­Â£ÂS„€¿ÿÿÿÿÿÿ·Â­Â¾€€ÀÿÿÿÿÿÿÁ·ÂIk€ÁÿÿÿÿÿÿËÂÁ™€ÂÿÿÿÿÿÿÕ jN‚€ÃÿÿÿÿÿÿßÂÕÂTo€ÄÿÿÿÿÿÿéÂßÂ倀ÅÿÿÿÿÿÿóÂéÂ?€€ÆÿÿÿÿÿÿýÂgkC‡€ÇÿÿÿÿÿÿÃýÂôt€ÈÿÿÿÿÿÿÃÃ倀ÉÿÿÿÿÿÿÃÃ.i€Êÿÿÿÿÿÿ%ÃÃó€Ëÿÿÿÿÿÿ/Ã%ÃË€Ìÿÿÿÿÿÿ9Ã/Ãq€ÍÿÿÿÿÿÿCÃ9ÀÎÿÿÿÿÿÿMÃCýÁ€ÏÿÿÿÿÿÿWÃL~€ÐÿÿÿÿÿÿaÃWÃab€ÑÿÿÿÿÿÿkÃaÃSk€ÒÿÿÿÿÿÿuÃkÃòh€ÓÿÿÿÿÿÿÃœiÃ}€Ôÿÿÿÿÿÿ‰ÃÃab€Õÿÿÿÿÿÿ“ÉÃ}€ÖÿÿÿÿÿÿÓÃY}€×ÿÿÿÿÿÿ§ÃÃuÀØÿÿÿÿÿÿ±Ãà‚Îi€Ùÿÿÿÿÿÿ»Ã±Ã]€ÚÿÿÿÿÿÿÅûꀀÛÿÿÿÿÿÿÏÃÅÀ€ÜÿÿÿÿÿÿÙÞŠ€ÝÿÿÿÿÿÿãÃÙÃ]€ÞÿÿÿÿÿÿíÃãÃG€ßÿÿÿÿÿÿ÷ÃíÃti€àÿÿÿÿÿÿÄ÷ÃÏÀáÿÿÿÿÿÿ Ä­$5…€âÿÿÿÿÿÿÄ Äì€ãÿÿÿÿÿÿÄÄBi€äÿÿÿÿÿÿ)ÄÄ5k€åÿÿÿÿÿÿ3ÄE2À„€æÿÿÿÿÿÿ=Ä3Äì€çÿÿÿÿÿÿGÄ=Ä~i€èÿÿÿÿÿÿQÄGÄ“}€éÿÿÿÿÿÿ[ÄQÄ)Ä€êÿÿÿÿÿÿeÄjR…€ëÿÿÿÿÿÿoÄeÄÁ\€ìÿÿÿÿÿÿyÄoÄS„€íÿÿÿÿÿÿƒÄyÄ·ƒ€îÿÿÿÿÿÿÄÔ‡’i€ïÿÿÿÿÿÿ—ÄÄÁ\€ðÿÿÿÿÿÿ¡Ä—Äw€ñÿÿÿÿÿÿ«Ä¡Ä°}€òÿÿÿÿÿÿµÄ«ÄƒÄ€óÿÿÿÿÿÿ¿Äfu-u€ôÿÿÿÿÿÿÉĿĈi€õÿÿÿÿÿÿÓÄÉÄôt€öÿÿÿÿÿÿÝÄÓÄát€÷ÿÿÿÿÿÿçÄÆoo€øÿÿÿÿÿÿñÄçĈi€ùÿÿÿÿÿÿûÄñÄTo€úÿÿÿÿÿÿÅûÄAo€ûÿÿÿÿÿÿÅÅÝÄ€üÿÿÿÿÿÿÅŵĀýÿÿÿÿÿÿ#ÅÅ[Ä€þÿÿÿÿÿÿ-Å#ÅÄ€ÿÿÿÿÿÿÿ7Å-ŧÀÿÿÿÿÿÿAÅ@i~€ÿÿÿÿÿÿKÅAÅÃ}€ÿÿÿÿÿÿUÅKÅVi€ÿÿÿÿÿÿ_ÅUÅ?k€ÿÿÿÿÿÿiÅ~i~€ÿÿÿÿÿÿsÅiÅL~€ÿÿÿÿÿÿ}ÅsÅÄi€ÿÿÿÿÿÿ‡Å}Å ~€ÿÿÿÿÿÿ‘ŇÅ_Å€ ÿÿÿÿÿÿ›Å(j:‚€ ÿÿÿÿÿÿ¥Å›ÅŠ€ ÿÿÿÿÿÿ¯Å¥ÅÑ€€ ÿÿÿÿÿÿ¹Å¯Å+€€ ÿÿÿÿÿÿÃÅa‚:‚€ÿÿÿÿÿÿÍÅÃÅÎi€ÿÿÿÿÿÿ×ÅÍÅí€ÿÿÿÿÿÿáÅ×Å&~€ÿÿÿÿÿÿëÅáŹŀÿÿÿÿÿÿõÅä…-€ÿÿÿÿÿÿÿÅõÅÀ„€ÿÿÿÿÿÿ ÆÿÅ]k€ÿÿÿÿÿÿÆ Æʃ€ÿÿÿÿÿÿÆo…-€ÿÿÿÿÿÿ'ÆÆ5…€ÿÿÿÿÿÿ1Æ'Æ ‚€ÿÿÿÿÿÿ;Æ1Æqk€ÿÿÿÿÿÿEÆ;ÆÆ€ÿÿÿÿÿÿOÆш@ˆ€ÿÿÿÿÿÿYÆOÆ’i€ÿÿÿÿÿÿcÆYÆ&‡€ÿÿÿÿÿÿmÆcÆ‹†€ÿÿÿÿÿÿwÆ…k@ˆ€ ÿÿÿÿÿÿÆwÆR…€!ÿÿÿÿÿÿ‹ÆÆ'‚€"ÿÿÿÿÿÿ•Æ‹Æ°i€#ÿÿÿÿÿÿŸÆ•ÆmÆ€$ÿÿÿÿÿÿ©Æîˆ{k€%ÿÿÿÿÿÿ³Æ©Æo€&ÿÿÿÿÿÿ½Æ³ÆC‡€'ÿÿÿÿÿÿÇƽÆi€(ÿÿÿÿÿÿÑÆâi{k€)ÿÿÿÿÿÿÛÆÑÆ-u€*ÿÿÿÿÿÿåÆÛÆN‚€+ÿÿÿÿÿÿïÆåÆ}~€,ÿÿÿÿÿÿùÆïÆÇÆ€-ÿÿÿÿÿÿÇùÆŸÆ€.ÿÿÿÿÿÿ ÇÇEÆ€/ÿÿÿÿÿÿÇ ÇëÅ€0ÿÿÿÿÿÿ!ÇÇ‘Å€1ÿÿÿÿÿÿ+Çg~€2ÿÿÿÿÿÿ5Ç+Çœi€3ÿÿÿÿÿÿ?Ç5Ç}€4ÿÿÿÿÿÿIÇ?Çd|€5ÿÿÿÿÿÿSÇg@€6ÿÿÿÿÿÿ]ÇSÇ€7ÿÿÿÿÿÿgÇ]Çò~€8ÿÿÿÿÿÿqÇgÇöi€9ÿÿÿÿÿÿ{ÇqÇIÇ€:ÿÿÿÿÿÿ…ǃa‚€;ÿÿÿÿÿÿÇ…Çž€<ÿÿÿÿÿÿ™ÇÇø€€=ÿÿÿÿÿÿ£Ç™Çi€>ÿÿÿÿÿÿ­Çƒ(j€?ÿÿÿÿÿÿ·Ç­Çà‚€@ÿÿÿÿÿÿÁÇ·Ç°‚€AÿÿÿÿÿÿËÇÁÇß~€BÿÿÿÿÿÿÕÇËǣǀCÿÿÿÿÿÿßÇ€.o…€DÿÿÿÿÿÿéÇßÇE2€EÿÿÿÿÿÿóÇéÇp„€FÿÿÿÿÿÿýÇóÇÞƒ€GÿÿÿÿÿÿÈ€.ä…€HÿÿÿÿÿÿÈÈ­$€IÿÿÿÿÿÿÈÈÍ‚€Jÿÿÿÿÿÿ%ÈÈ€Kÿÿÿÿÿÿ/È%ÈýÇ€Lÿÿÿÿÿÿ9ȉ…k€MÿÿÿÿÿÿCÈ9ÈÔ‡€NÿÿÿÿÿÿMÈCÈji€OÿÿÿÿÿÿWÈMȱ†€Pÿÿÿÿÿÿaȉш€QÿÿÿÿÿÿkÈaÈj€RÿÿÿÿÿÿuÈkÈô‚€SÿÿÿÿÿÿÈuÈ-€Tÿÿÿÿÿÿ‰ÈÈWÈ€Uÿÿÿÿÿÿ“ȼ‹âi€VÿÿÿÿÿÿÈ“ÈÆo€Wÿÿÿÿÿÿ§ÈÈgk€Xÿÿÿÿÿÿ±È§È±‰€Yÿÿÿÿÿÿ»È¼‹îˆ€ZÿÿÿÿÿÿÅÈ»Èfu€[ÿÿÿÿÿÿÏÈÅÈ j€\ÿÿÿÿÿÿÙÈÏÈT€]ÿÿÿÿÿÿãÈÙȱȀ^ÿÿÿÿÿÿíÈãȉȀ_ÿÿÿÿÿÿ÷ÈíÈ/È€`ÿÿÿÿÿÿÉ÷ÈÕÇ€aÿÿÿÿÿÿ ÉÉ{Ç€bÿÿÿÿÿÿÉ É!Ç€cÿÿÿÿÿÿÉÉ7Å€dÿÿÿÿÿÿ)ÉÉMÀeÿÿÿÿÿÿ3É)ÉcÁ€fÿÿÿÿÿÿ=É+k>|€gÿÿÿÿÿÿGÉ=É]4€hÿÿÿÿÿÿQÉGÉ |€iÿÿÿÿÿÿ[ÉQÉð{€jÿÿÿÿÿÿeÉ?€èh€kÿÿÿÿÿÿoÉeÉû€lÿÿÿÿÿÿyÉoÉÞ€mÿÿÿÿÿÿƒÉyÉ |€nÿÿÿÿÿÿÉát·ƒ€oÿÿÿÿÿÿ—ÉÉ5k€pÿÿÿÿÿÿ¡É—É€€qÿÿÿÿÿÿ«É¡Éòh€rÿÿÿÿÿÿµÉi‹†€sÿÿÿÿÿÿ¿ÉµÉʃ€tÿÿÿÿÿÿÉÉ¿É+€€uÿÿÿÿÿÿÓÉÉÉ?k€vÿÿÿÿÿÿÝɱ‰±†€wÿÿÿÿÿÿçÉÝÉÞƒ€xÿÿÿÿÿÿñÉçÉi€yÿÿÿÿÿÿûÉñÉd|€zÿÿÿÿÿÿÊûÉÓÉ€{ÿÿÿÿÿÿÊÊ«É€|ÿÿÿÿÿÿÊʃɀ}ÿÿÿÿÿÿ#ÊÊ[É€~ÿÿÿÿÿÿ-Ê.iIk€ÿÿÿÿÿÿ7Ê-Êä|€€ÿÿÿÿÿÿAÊ7ʽ|€ÿÿÿÿÿÿKÊAÊ |€‚ÿÿÿÿÿÿUÊ倾€€ƒÿÿÿÿÿÿ_ÊUʽ-€„ÿÿÿÿÿÿiÊ_Ê8i€…ÿÿÿÿÿÿsÊiÊÐ|€†ÿÿÿÿÿÿ}ÊôtS„€‡ÿÿÿÿÿÿ‡Ê}ÊBi€ˆÿÿÿÿÿÿ‘ʇʪ€€‰ÿÿÿÿÿÿ›Ê‘ÊSk€Šÿÿÿÿÿÿ¥ÊC‡&‡€‹ÿÿÿÿÿÿ¯Ê¥Ê]k€Œÿÿÿÿÿÿ¹Ê¯ÊÑ€€ÿÿÿÿÿÿÃʹÊVi€ŽÿÿÿÿÿÿÍÊgkji€ÿÿÿÿÿÿ×ÊÍÊp„€ÿÿÿÿÿÿáÊ×Êø€€‘ÿÿÿÿÿÿëÊáÊ}€’ÿÿÿÿÿÿõÊëÊÃÊ€“ÿÿÿÿÿÿÿÊõʛʀ”ÿÿÿÿÿÿ ËÿÊsÊ€•ÿÿÿÿÿÿË ËKÊ€–ÿÿÿÿÿÿËAo°}€—ÿÿÿÿÿÿ'ËË“}€˜ÿÿÿÿÿÿ1Ë'Ëti€™ÿÿÿÿÿÿ;Ë1ËY}€šÿÿÿÿÿÿEËTow€›ÿÿÿÿÿÿOËEË~i€œÿÿÿÿÿÿYËOËG€ÿÿÿÿÿÿcËYË}€žÿÿÿÿÿÿmˈiÁ\€ŸÿÿÿÿÿÿwËmË쀠ÿÿÿÿÿÿËwË]€¡ÿÿÿÿÿÿ‹ËËab€¢ÿÿÿÿÿÿ•Ëo’i€£ÿÿÿÿÿÿŸË•ËÀ„€¤ÿÿÿÿÿÿ©ËŸËŠ€¥ÿÿÿÿÿÿ³Ë©ËÃ}€¦ÿÿÿÿÿÿ½ËÆoÔ‡€§ÿÿÿÿÿÿÇ˽ËE2€¨ÿÿÿÿÿÿÑËÇËž€©ÿÿÿÿÿÿÛËÑËœi€ªÿÿÿÿÿÿåËÛ˳ˀ«ÿÿÿÿÿÿïËåË‹Ë€¬ÿÿÿÿÿÿùËïËcË€­ÿÿÿÿÿÿÌùË;Ë€®ÿÿÿÿÿÿ Ì}~°i€¯ÿÿÿÿÿÿÌ Ìqk€°ÿÿÿÿÿÿ!ÌÌ&~€±ÿÿÿÿÿÿ+Ì!Ì ~€²ÿÿÿÿÿÿ5ÌN‚'‚€³ÿÿÿÿÿÿ?Ì5Ì ‚€´ÿÿÿÿÿÿIÌ?Ì퀵ÿÿÿÿÿÿSÌIÌÄi€¶ÿÿÿÿÿÿ]Ì-uR…€·ÿÿÿÿÿÿgÌ]Ì5…€¸ÿÿÿÿÿÿqÌgÌÎi€¹ÿÿÿÿÿÿ{ÌqÌL~€ºÿÿÿÿÿÿ…Ì{k@ˆ€»ÿÿÿÿÿÿÌ…Ì-€¼ÿÿÿÿÿÿ™ÌÌ:‚€½ÿÿÿÿÿÿ£Ì™Ìi~€¾ÿÿÿÿÿÿ­Ìâi…k€¿ÿÿÿÿÿÿ·Ì­Ìo…€ÀÿÿÿÿÿÿÁÌ·Ìa‚€ÁÿÿÿÿÿÿËÌÁÌ~€ÂÿÿÿÿÿÿÕÌẸ̈̀ÃÿÿÿÿÿÿßÌÕÌ{Ì€ÄÿÿÿÿÿÿéÌßÌSÌ€ÅÿÿÿÿÿÿóÌéÌ+Ì€ÆÿÿÿÿÿÿýÌT-€ÇÿÿÿÿÿÿÍýÌ€ÈÿÿÿÿÿÿÍÍß~€ÉÿÿÿÿÿÿÍÍöi€Êÿÿÿÿÿÿ%Í jô‚€Ëÿÿÿÿÿÿ/Í%ÍÍ‚€Ìÿÿÿÿÿÿ9Í/Í°‚€ÍÿÿÿÿÿÿCÍ9Íò~€ÎÿÿÿÿÿÿMÍfuj€ÏÿÿÿÿÿÿWÍMÍ­$€ÐÿÿÿÿÿÿaÍWÍà‚€ÑÿÿÿÿÿÿkÍaÍ€ÒÿÿÿÿÿÿuÍîˆÑˆ€ÓÿÿÿÿÿÿÍuÍä…€Ôÿÿÿÿÿÿ‰ÍÍ(j€Õÿÿÿÿÿÿ“͉Í@€Öÿÿÿÿÿÿͼ‹‰€×ÿÿÿÿÿÿ§ÍÍ€.€Øÿÿÿÿÿÿ±Í§Íƒ€Ùÿÿÿÿÿÿ»Í±Íg€ÚÿÿÿÿÿÿÅͻ͓̀ÛÿÿÿÿÿÿÏÍÅÍkÍ€ÜÿÿÿÿÿÿÙÍÏÍCÍ€ÝÿÿÿÿÿÿãÍÙÍÍ€ÞÿÿÿÿÿÿíÍãÍóÌ€ßÿÿÿÿÿÿ÷ÍíÍÌ€àÿÿÿÿÿÿÎ÷ÍË€áÿÿÿÿÿÿ ÎÎ#ÊâÿÿÿÿÿÿÎ Î3Éy¿Q¿Y·1·µ´²k¯ÿ¬Ë©#¦›œšç–÷•GŒæ{>xôltlWl"k6ãÿÿÿÿÿÿ5Î ÙÙóØæØÙØÌؿزإؘ؋Ø~ØdØWØJØ=Ø0Ø#ØØ Øü×ï×â×Õ×È׻׮סהׇ×z×m×`×S×F×9×,××××øÖëÖÞÖÑÖªÖÖÖƒÖvÖiÖ\ÖOÖBÖ5Ö(ÖÖÖÖôÕçÕÚÕÍÕÀÕ³Õ¦Õ™ÕŒÕÕeÕKÕ1ÕÕäÚØÚÓËÚ¾Ú±Ú•ÚˆÚ{ÚnÚaÚ/ÑÑûÐáÐÇÐ3Ú&ÚÚØْϸÙPÏ/Ï«Ù³w wwzwgwTwAw.www›vˆvuvbvOv‹Jˆ?…÷~@ÿÿÿÿÿÿÒÆ‹Ûˆ·$º‚Ì~@ ÿÿÿÿÿÿ"Ò%zz·$ëyÎy@ ÿÿÿÿÿÿ/ÒÞzÁz¤z‡zjz@ ÿÿÿÿÿÿ<Ò—{z{]{@{#{@ ÿÿÿÿÿÿIÒðÔãÔÖÔÉÔVÒ@ ÿÿÿÿÿÿVÒµ¦˜¦{¦^¦A¦@ÿÿÿÿÿÿcÒ¼Ô¯Ô¢Ô•ÔpÒ@ÿÿÿÿÿÿpÒ@ª#ªªé©—@ÿÿÿÿÿÿ}ÒˆÔ{ÔnÔaÔŠÒ@ÿÿÿÿÿÿŠÒL­9­&­­A¦@ÿÿÿÿÿÿ—Òñ¹±¯±¥±i±_±U±K±±±û°ñ°µ°«°¡°—°3°°Ï¯¯@ÿÿÿÿÿÿ¸ÒTÔGÔ:Ô-ÔÅÒ@ÿÿÿÿÿÿÅÒm²Y²E²1²Rx@ÿÿÿÿÿÿÒÒ ÔÔÔùÓßÒ@ÿÿÿÿÿÿßÒ#{jzÎyy\x@ÿÿÿÿÿÿìÒìÓßÓÒÓÓùÒ@ÿÿÿÿÿÿùÒ²µ©µ µ—µ\x@ÿÿÿÿÿÿÓ¼‹@ˆì8ið{@ÿÿÿÿÿÿÓþµõµìµ2yãµ@ÿÿÿÿÿÿ ÓÓoÓNÓ-Ó@ÿÿÿÿÿÿ-Óy‹™¸¸…¸žS¸ˆI¸?¸© ¸¸kbù·OÇ·½·³·„€õœ·w·m·c·ú{@ÿÿÿÿÿÿNÓŒ‹)ººíŸºã¹#ˆÙ¹“ŸÏ¹¹“¹"]9Ÿ‰¹W¹M¹C¹—€9¹¹ý¸ó¸ž|@ÿÿÿÿÿÿoÓŠ.¹»×¡¯»¥»s»-}¡i»_»-»#»v»»ÝºÓºÓ Ç-ɺ—ººy ƒºg4@ÿÿÿÿÿÿÓ©‹Á£I½?½5½½Jˆù¼ï¼å¼³¼£Ë\©¼Ÿ¼m¼½¢c¼È€Y¼'¼c¢¼¼H|@ ÿÿÿÿÿÿ±ÓƋپϾž»¾[¥]ˆ‰¾¾u¾¥C¾9¾/¾§¤ý½ó½ï€é½M¤·½­½£½[|@!ÿÿÿÿÿÿÒÓJ¶A¶·$8¶/¶@"ÿÿÿÿÿÿßÓ–¶Áz¶„¶{¶@#ÿÿÿÿÿÿìÓ—{â¶Ù¶Ð¶Ç¶@$ÿÿÿÿÿÿùÓ@{‡zëy2yyx@%ÿÿÿÿÿÿÔ]{¤z·$Oy–x@&ÿÿÿÿÿÿÔz{Ázzly³x@'ÿÿÿÿÿÿ Ô—{Þz%z‰yÐx@(ÿÿÿÿÿÿ-Ôå²Ñ²½²(y©²@)ÿÿÿÿÿÿ:Ô]³I³­$5³!³@*ÿÿÿÿÿÿGÔÕ³·zÁ³­³™³@+ÿÿÿÿÿÿTÔ{M´9´%´´@,ÿÿÿÿÿÿaÔÀ­­­š­§‡­@-ÿÿÿÿÿÿnÔ4®!®Š.®û­@.ÿÿÿÿÿÿ{Ô¨®¦¨•®‚®o®@/ÿÿÿÿÿÿˆÔ|©¯ ¯ö®ã®@0ÿÿÿÿÿÿ•Ôܪ¿ª¢ªÛ—…ª@1ÿÿÿÿÿÿ¢Ôx«[«O2>«!«@2ÿÿÿÿÿÿ¯Ô¬ö˜÷«Ú«½«@3ÿÿÿÿÿÿ¼ÔÌ™°¬“¬v¬Y¬@4ÿÿÿÿÿÿÉÔn§Q§4§§ú¦@5ÿÿÿÿÿÿÖÔ ¨í§Š.Ч³§@6ÿÿÿÿÿÿãÔ覨‰¨l¨O¨@7ÿÿÿÿÿÿðÔ|©_©B©%©©@8ÿÿÿÿÿÿýÔXÕ>Õ$Õ Õ@9ÿÿÿÿÿÿ Õy‹ˆkb„€ú{@:ÿÿÿÿÿÿÕöi ~Y} |ð{@;ÿÿÿÿÿÿ$ÕŒ‹#ˆ"]—€|@<ÿÿÿÿÿÿ1Õd|?kòh |ð{@=ÿÿÿÿÿÿ>ÕŠ.-vÇ-g4@>ÿÿÿÿÿÿKÕß~&~ti½| |@?ÿÿÿÿÿÿXÕ©‹JˆË\È€H|@@ÿÿÿÿÿÿeÕi+€€Þ |@AÿÿÿÿÿÿrÕÆ‹]ˆï€[|@BÿÿÿÿÿÿÕqk“}ä|]4@CÿÿÿÿÿÿŒÕރʃ5kû]4@Dÿÿÿÿÿÿ™Õ-°i°}Ik>|@Eÿÿÿÿÿÿ¦Õ±†‹†·ƒèh>|@Fÿÿÿÿÿÿ³ÕT}~Ao.i+k@GÿÿÿÿÿÿÀÕ±‰iát?€+k@HÿÿÿÿÿÿÍÕò~Äi}Ð| |@IÿÿÿÿÿÿÚÕ}ViSkÐ| |@JÿÿÿÿÿÿçÕ°‚íG8iÞ@KÿÿÿÿÿÿôÕø€Ñ€ª€8i½|@LÿÿÿÿÿÿÖÍ‚ ‚~i½-û@MÿÿÿÿÿÿÖp„]kBi½-ä|@NÿÿÿÿÿÿÖô‚'‚w¾€èh@Oÿÿÿÿÿÿ(Öji&‡S„¾€Ik@Pÿÿÿÿÿÿ5Ö jN‚Toå€?€@QÿÿÿÿÿÿBÖgkC‡ôtå€.i@RÿÿÿÿÿÿOÖL~abSkòh@Sÿÿÿÿÿÿ\ÖœiÃ}ab}Y}@TÿÿÿÿÿÿiÖà‚Îi]ª€€@UÿÿÿÿÿÿvÖžŠ]Gti@VÿÿÿÿÿÿƒÖ­$5…ìBi5k@WÿÿÿÿÿÿÖE2À„ì~i“}@XÿÿÿÿÿÿÖjR…Á\S„·ƒ@YÿÿÿÿÿÿªÖÔ‡’iÁ\w°}@Zÿÿÿÿÿÿ·Öfu-uôtát@[ÿÿÿÿÿÿÄÖÆooToAo@\ÿÿÿÿÿÿÑÖ@i~Ã}Vi?k@]ÿÿÿÿÿÿÞÖ~i~L~Äi ~@^ÿÿÿÿÿÿëÖ(j:‚ŠÑ€+€@_ÿÿÿÿÿÿøÖa‚:‚Îií&~@`ÿÿÿÿÿÿ×ä…-À„]kʃ@aÿÿÿÿÿÿ×o…-5… ‚qk@bÿÿÿÿÿÿ×ш@ˆ’i&‡‹†@cÿÿÿÿÿÿ,×…k@ˆR…'‚°i@dÿÿÿÿÿÿ9×îˆ{koC‡i@eÿÿÿÿÿÿF×âi{k-uN‚}~@fÿÿÿÿÿÿS×g~œi}d|@gÿÿÿÿÿÿ`×g@ò~öi@hÿÿÿÿÿÿm׃a‚žø€i@iÿÿÿÿÿÿz׃(jà‚°‚ß~@jÿÿÿÿÿÿ‡×€.o…E2p„Þƒ@kÿÿÿÿÿÿ”×€.ä…­$Í‚@lÿÿÿÿÿÿ¡×‰…kÔ‡ji±†@mÿÿÿÿÿÿ®×‰Ñˆjô‚-@nÿÿÿÿÿÿ»×¼‹âiÆogk±‰@oÿÿÿÿÿÿÈ×¼‹îˆfu jT@pÿÿÿÿÿÿÕ×+k>|]4 |ð{@qÿÿÿÿÿÿâ×?€èhûÞ |@rÿÿÿÿÿÿï×át·ƒ5k€òh@sÿÿÿÿÿÿü×i‹†Êƒ+€?k@tÿÿÿÿÿÿ ر‰±†Þƒid|@uÿÿÿÿÿÿØ.iIkä|½| |@vÿÿÿÿÿÿ#Ø倾€½-8iÐ|@wÿÿÿÿÿÿ0ØôtS„Biª€Sk@xÿÿÿÿÿÿ=ØC‡&‡]kÑ€Vi@yÿÿÿÿÿÿJØgkjip„ø€}@zÿÿÿÿÿÿWØAo°}“}tiY}@{ÿÿÿÿÿÿdØTow~iG}@|ÿÿÿÿÿÿqØÁ\ì]ab@}ÿÿÿÿÿÿ~Øo’iÀ„ŠÃ}@~ÿÿÿÿÿÿ‹ØÆoÔ‡E2žœi@ÿÿÿÿÿÿ˜Ø}~°iqk&~ ~@€ÿÿÿÿÿÿ¥ØN‚'‚ ‚íÄi@ÿÿÿÿÿÿ²Ø-uR…5…ÎiL~@‚ÿÿÿÿÿÿ¿Ø{k@ˆ-:‚i~@ƒÿÿÿÿÿÿÌØâi…ko…a‚~@„ÿÿÿÿÿÿÙØT-ß~öi@…ÿÿÿÿÿÿæØ jô‚Í‚°‚ò~@†ÿÿÿÿÿÿóØfuj­$à‚@‡ÿÿÿÿÿÿÙîˆÑˆä…(j@@ˆÿÿÿÿÿÿ Ù¼‹‰€.ƒg@‰ÿÿÿÿÿÿÙTÙ…k{kÎiÄiqkœi’i~itigk]kSk8iIki?k5kèh+k@Šÿÿÿÿÿÿ7ÙTÙâi-ÎiÄi°iœi’i~itijiViBi8i.iiiòhèh]4@‹ÿÿÿÿÿÿTÙ€.(jj jöiŒÿÿÿÿÿÿaÙTÙâi-ÎiÄi°iœi’i~itijiViBi8i.iiiòhèh]4@ÿÿÿÿÿÿ}ÙaÙŽÿÿÿÿÿÿ†ÙTÙ…k{kÎiÄiqkœi’i~itigk]kSk8iIki?k5kèh+k@ÿÿÿÿÿÿ¢Ù†Ù@ÿÿÿÿÿÿ«Ù<Ò/Ò"Ò†Ð"Ï‘ÿÿÿÿÿÿ¸Ùø…î…Ñ…Ç…´…y…e…H…+……Ê„„T¶„¬„z„f„I„6„#„èƒÔƒ­ƒšƒ‡ƒ@’ÿÿÿÿÿÿØÙÏ‹²‹Ÿ‹•‹‚‹G‹4‹!‹‹ûŠÀŠ¶ŠO2™Š†ŠKŠ8Š%ŠŠÿ‰Ä‰§‰”‰‰n‰“ÿÿÿÿÿÿùÙ•u•k•a•W•%••••ý”Ë”Á”­”£”q”g”]”S”I”” ””ù“ï“@”ÿÿÿÿÿÿÚùÙDÐ#ÐÐáÏ@•ÿÿÿÿÿÿ&ÚÒÒûÑ<Ñ Ð@–ÿÿÿÿÿÿ3Ú"ÑÑîÐÔкÐ@—ÿÿÿÿÿÿ@ÚÆ‹«¥¡¥—¥¥[¥Q¥G¥=¥3¥¥÷¤vã¤Ù¤§¤¤“¤‰¤¤M¤C¤9¤/¤%¤@˜ÿÿÿÿÿÿaÚ@ڹјÑwÑVÑ@™ÿÿÿÿÿÿnÚðÔãÔÖÔÉÔVÒ@šÿÿÿÿÿÿ{Ú¼Ô¯Ô¢Ô•ÔpÒ@›ÿÿÿÿÿÿˆÚˆÔ{ÔnÔaÔŠÒœÿÿÿÿÿÿ•Úñ¹±¯±¥±i±_±U±K±±±û°ñ°µ°«°¡°—°3°°Ï¯¯@ÿÿÿÿÿÿ±ÚTÔGÔ:Ô-ÔÅÒ@žÿÿÿÿÿÿ¾Ú ÔÔÔùÓßÒ@ŸÿÿÿÿÿÿËÚìÓßÓÒÓÓùÒ ÿÿÿÿÿÿØÚÓoÓNÓ-Ó¡ÿÿÿÿÿÿäÚXÕ>Õ$Õ Õ5¢ÿÿÿÿÿÿðÚ ÙÙóØæØÙØÌؿزإؘ؋Ø~ØdØWØJØ=Ø0Ø#ØØ Øü×ï×â×Õ×È׻׮סהׇ×z×m×`×S×F×9×,××××øÖëÖÞÖÑÖªÖÖÖƒÖvÖiÖ\ÖOÖBÖ5Ö(ÖÖÖÖôÕçÕÚÕÍÕÀÕ³Õ¦Õ™ÕŒÕÕeÕKÕ1ÕÕäÚØÚÓËÚ¾Ú±Ú•ÚˆÚ{ÚnÚaÚ/ÑÑûÐáÐÇÐ3Ú&ÚÚØْϸÙPÏ/Ï«Ù³w wwzwgwTwAw.www›vˆvuvbvOvCHNSX[^addtruefalsenot==>andorxordistinctite=distinctite=distinctiteop1ope4e3e2e1e0R PBoolUIIIIIIII@<P sW_oR PBoolUIIIIIIII@<P PBoolUI P   .>3C(8H1 0 -2 0 127 0 132 0 217 0 247 0 273 0 279 0 316 0 346 0 376 0 402 0 531 0 553 0 559 0 689 0 714 0 740 0 765 0 791 0 817 0 -823 0 -824 0 -825 0 -826 0 -827 0 -828 0 -829 0 -830 0 -831 0 -832 0 -833 0 -834 0 -835 0 -836 0 -837 0 -838 0 -839 0 -840 0 -841 0 -842 0 -843 0 -13 0 -281 0 416 0 436 0 456 0 476 0 497 0 489 0 667 0 -692 0 -844 0 -845 0 -38 0 494 0 672 0 -697 0 -846 0 -847 0 -83 0 503 0 681 0 -706 0 -108 0 508 0 686 0 -711 0 -848 0 -849 0 -850 0 -851 0 -852 0 -853 0 -854 0 -855 0 -856 0 -857 0 -858 0 -859 0 -860 0 -861 0 -862 0 -863 0 -864 0 -865 0 -866 0 -867 0 -868 0 -869 0 -870 0 -871 0 -872 0 -873 0 -874 0 -875 0 -876 0 -877 0 -878 0 -879 0 -880 0 -881 0 -882 0 -883 0 -884 0 -885 0 -886 0 -887 0 -888 0 -889 0 -53 0 675 0 -700 0 -890 0 -891 0 -58 0 498 0 676 0 -701 0 -892 0 -893 0 -63 0 499 0 677 0 -702 0 -68 0 500 0 678 0 -703 0 -894 0 -895 0 -896 0 -897 0 -898 0 -899 0 -900 0 -901 0 -902 0 -903 0 -904 0 -905 0 -906 0 -907 0 -908 0 -909 0 -910 0 -911 0 -912 0 -913 0 -914 0 -123 0 477 0 652 0 -727 0 -124 0 -289 0 418 0 438 0 627 0 -752 0 -125 0 602 0 -778 0 -126 0 577 0 -804 0 -915 0 -916 0 -917 0 -918 0 -919 0 -920 0 14 0 650 0 -742 0 41 0 601 0 -749 0 57 0 567 0 802 0 3 4 5 6 7 0 8 9 10 11 12 0 14 15 13 16 17 0 18 19 20 21 22 0 23 24 25 26 27 0 28 29 30 31 32 0 33 34 35 36 37 0 39 40 38 41 42 0 43 44 45 46 47 0 48 49 50 51 52 0 54 55 53 56 57 0 59 60 58 61 62 0 64 65 63 66 67 0 69 70 68 71 72 0 73 74 75 76 77 0 78 79 80 81 82 0 84 85 83 86 87 0 88 89 90 91 92 0 93 94 95 96 97 0 98 99 100 101 102 0 103 104 105 106 107 0 109 110 108 111 112 0 113 114 115 116 117 0 118 119 120 121 122 0 3 8 13 18 23 0 3 28 53 73 98 0 4 9 14 19 24 0 4 29 54 74 99 0 5 10 15 20 25 0 5 30 55 75 100 0 6 11 16 21 26 0 6 31 56 76 101 0 7 12 17 22 27 0 7 32 57 77 102 0 28 33 38 43 48 0 8 33 58 78 103 0 29 34 39 44 49 0 9 34 59 79 104 0 30 35 40 45 50 0 10 35 60 80 105 0 31 36 41 46 51 0 11 36 61 81 106 0 32 37 42 47 52 0 12 37 62 82 107 0 54 59 64 69 123 0 14 39 84 109 123 0 55 60 65 70 124 0 15 40 85 110 124 0 56 61 66 71 125 0 16 41 86 111 125 0 57 62 67 72 126 0 17 42 87 112 126 0 73 78 83 88 93 0 18 43 63 88 113 0 74 79 84 89 94 0 19 44 64 89 114 0 75 80 85 90 95 0 20 45 65 90 115 0 76 81 86 91 96 0 21 46 66 91 116 0 77 82 87 92 97 0 22 47 67 92 117 0 98 103 108 113 118 0 23 48 68 93 118 0 99 104 109 114 119 0 24 49 69 94 119 0 100 105 110 115 120 0 25 50 70 95 120 0 101 106 111 116 121 0 26 51 71 96 121 0 102 107 112 117 122 0 27 52 72 97 122 0 128 129 130 131 0 -7 -131 0 -37 -131 0 -126 -131 0 -92 -131 0 -122 -131 0 7 37 92 122 126 131 0 -6 -130 0 -36 -130 0 -125 -130 0 -91 -130 0 -121 -130 0 6 36 91 121 125 130 0 -5 -129 0 -35 -129 0 -124 -129 0 -90 -129 0 -120 -129 0 5 35 90 120 124 129 0 -4 -128 0 -34 -128 0 -123 -128 0 -89 -128 0 -119 -128 0 4 34 89 119 123 128 0 133 134 135 136 0 -7 -136 0 -136 137 0 -136 138 0 -136 139 0 -136 140 0 -136 141 0 -37 -136 0 -136 142 0 -136 143 0 -136 144 0 -136 145 0 -136 146 0 -126 -136 0 -136 147 0 -136 148 0 -136 149 0 -136 150 0 -136 151 0 -92 -136 0 -136 152 0 -136 153 0 -136 154 0 -136 155 0 -136 156 0 -122 -136 0 7 37 92 122 126 136 -137 -138 -139 -140 -141 -142 -143 -144 -145 -146 -147 -148 -149 -150 -151 -152 -153 -154 -155 -156 0 117 156 0 97 156 0 -97 -117 -156 0 112 155 0 72 155 0 -72 -112 -155 0 107 154 0 52 154 0 -52 -107 -154 0 102 153 0 27 153 0 -27 -102 -153 0 97 152 0 117 152 0 -97 -117 -152 0 87 151 0 67 151 0 -67 -87 -151 0 82 150 0 47 150 0 -47 -82 -150 0 77 149 0 22 149 0 -22 -77 -149 0 72 148 0 112 148 0 -72 -112 -148 0 67 147 0 87 147 0 -67 -87 -147 0 62 146 0 42 146 0 -42 -62 -146 0 57 145 0 17 145 0 -17 -145 -57 0 52 144 0 107 144 0 -52 -107 -144 0 47 143 0 82 143 0 -47 -82 -143 0 42 142 0 62 142 0 -42 -62 -142 0 32 141 0 12 141 0 -12 -32 -141 0 27 140 0 102 140 0 -27 -102 -140 0 22 139 0 77 139 0 -22 -77 -139 0 17 138 0 57 138 0 -17 -138 -57 0 12 137 0 32 137 0 -12 -32 -137 0 -6 -135 0 -135 157 0 -135 158 0 -135 159 0 -135 160 0 -135 161 0 -36 -135 0 -135 162 0 -135 163 0 -135 164 0 -135 165 0 -135 166 0 -125 -135 0 -135 167 0 -135 168 0 -135 169 0 -135 170 0 -135 171 0 -91 -135 0 -135 172 0 -135 173 0 -135 174 0 -135 175 0 -135 176 0 -121 -135 0 6 36 91 121 125 135 -157 -158 -159 -160 -161 -162 -163 -164 -165 -166 -167 -168 -169 -170 -171 -172 -173 -174 -175 -176 0 116 176 0 96 176 0 -96 -116 -176 0 111 175 0 71 175 0 -71 -111 -175 0 106 174 0 51 174 0 -51 -106 -174 0 101 173 0 26 173 0 -26 -101 -173 0 96 172 0 116 172 0 -96 -116 -172 0 86 171 0 66 171 0 -66 -86 -171 0 81 170 0 46 170 0 -46 -81 -170 0 76 169 0 21 169 0 -21 -76 -169 0 71 168 0 111 168 0 -71 -111 -168 0 66 167 0 86 167 0 -66 -86 -167 0 61 166 0 41 166 0 -61 -166 -41 0 56 165 0 16 165 0 -16 -56 -165 0 51 164 0 106 164 0 -51 -106 -164 0 46 163 0 81 163 0 -46 -81 -163 0 41 162 0 61 162 0 -61 -162 -41 0 31 161 0 11 161 0 -11 -31 -161 0 26 160 0 101 160 0 -26 -101 -160 0 21 159 0 76 159 0 -21 -76 -159 0 16 158 0 56 158 0 -16 -56 -158 0 11 157 0 31 157 0 -11 -31 -157 0 -5 -134 0 -134 177 0 -134 178 0 -134 179 0 -134 180 0 -134 181 0 -35 -134 0 -134 182 0 -134 183 0 -134 184 0 -134 185 0 -134 186 0 -124 -134 0 -134 187 0 -134 188 0 -134 189 0 -134 190 0 -134 191 0 -90 -134 0 -134 192 0 -134 193 0 -134 194 0 -134 195 0 -134 196 0 -120 -134 0 5 35 90 120 124 134 -177 -178 -179 -180 -181 -182 -183 -184 -185 -186 -187 -188 -189 -190 -191 -192 -193 -194 -195 -196 0 115 196 0 95 196 0 -95 -115 -196 0 110 195 0 70 195 0 -70 -110 -195 0 105 194 0 50 194 0 -50 -105 -194 0 100 193 0 25 193 0 -25 -100 -193 0 95 192 0 115 192 0 -95 -115 -192 0 85 191 0 65 191 0 -65 -85 -191 0 80 190 0 45 190 0 -45 -80 -190 0 75 189 0 20 189 0 -20 -75 -189 0 70 188 0 110 188 0 -70 -110 -188 0 65 187 0 85 187 0 -65 -85 -187 0 60 186 0 40 186 0 -40 -60 -186 0 55 185 0 15 185 0 -15 -55 -185 0 50 184 0 105 184 0 -50 -105 -184 0 45 183 0 80 183 0 -45 -80 -183 0 40 182 0 60 182 0 -40 -60 -182 0 30 181 0 10 181 0 -10 -30 -181 0 25 180 0 100 180 0 -25 -100 -180 0 20 179 0 75 179 0 -20 -75 -179 0 15 178 0 55 178 0 -15 -55 -178 0 10 177 0 30 177 0 -10 -30 -177 0 -4 -133 0 -133 197 0 -133 198 0 -133 199 0 -133 200 0 -133 201 0 -34 -133 0 -133 202 0 -133 203 0 -133 204 0 -133 205 0 -133 206 0 -123 -133 0 -133 207 0 -133 208 0 -133 209 0 -133 210 0 -133 211 0 -89 -133 0 -133 212 0 -133 213 0 -133 214 0 -133 215 0 -133 216 0 -119 -133 0 4 34 89 119 123 133 -197 -198 -199 -200 -201 -202 -203 -204 -205 -206 -207 -208 -209 -210 -211 -212 -213 -214 -215 -216 0 114 216 0 94 216 0 -94 -114 -216 0 109 215 0 69 215 0 -69 -109 -215 0 104 214 0 49 214 0 -49 -104 -214 0 99 213 0 24 213 0 -24 -99 -213 0 94 212 0 114 212 0 -94 -114 -212 0 84 211 0 64 211 0 -64 -84 -211 0 79 210 0 44 210 0 -44 -79 -210 0 74 209 0 19 209 0 -19 -74 -209 0 69 208 0 109 208 0 -69 -109 -208 0 64 207 0 84 207 0 -64 -84 -207 0 59 206 0 39 206 0 -39 -59 -206 0 54 205 0 14 205 0 -54 -205 -14 0 49 204 0 104 204 0 -49 -104 -204 0 44 203 0 79 203 0 -44 -79 -203 0 39 202 0 59 202 0 -39 -59 -202 0 29 201 0 9 201 0 -9 -29 -201 0 24 200 0 99 200 0 -24 -99 -200 0 19 199 0 74 199 0 -19 -74 -199 0 14 198 0 54 198 0 -54 -198 -14 0 9 197 0 29 197 0 -9 -29 -197 0 3 34 91 122 124 0 218 219 220 221 222 0 -222 -223 0 -222 -224 0 -222 -225 0 -222 -226 0 -222 -227 0 222 223 224 225 226 227 0 -221 -228 0 -221 -229 0 -221 -230 0 -221 -231 0 -221 -232 0 221 228 229 230 231 232 0 -220 -233 0 -220 -234 0 -15 -220 0 -220 -235 0 -220 -236 0 15 220 233 234 235 236 0 -219 -237 0 -219 -238 0 -219 -239 0 -219 -240 0 -219 -241 0 219 237 238 239 240 241 0 -218 -242 0 -218 -243 0 -218 -244 0 -218 -245 0 -218 -246 0 218 242 243 244 245 246 0 248 249 250 251 252 0 -252 -253 0 -252 -254 0 -252 -255 0 -252 -256 0 -227 -252 0 227 252 253 254 255 256 0 -251 -257 0 -251 -258 0 -251 -259 0 -231 -251 0 -251 -260 0 231 251 257 258 259 260 0 -250 -261 0 -250 -262 0 -15 -250 0 -250 -263 0 -250 -264 0 15 250 261 262 263 264 0 -249 -265 0 -238 -249 0 -249 -266 0 -249 -267 0 -249 -268 0 238 249 265 266 267 268 0 -242 -248 0 -248 -269 0 -248 -270 0 -248 -271 0 -248 -272 0 242 248 269 270 271 272 0 274 275 276 277 278 0 223 -278 0 224 -278 0 225 -278 0 226 -278 0 227 -278 0 -223 -224 -225 -226 -227 278 0 228 -277 0 229 -277 0 230 -277 0 231 -277 0 232 -277 0 -228 -229 -230 -231 -232 277 0 233 -276 0 234 -276 0 15 -276 0 235 -276 0 236 -276 0 -15 -233 -234 -235 -236 276 0 237 -275 0 238 -275 0 239 -275 0 240 -275 0 241 -275 0 -237 -238 -239 -240 -241 275 0 242 -274 0 243 -274 0 244 -274 0 245 -274 0 246 -274 0 -242 -243 -244 -245 -246 274 0 280 282 281 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 0 122 -299 0 -299 300 0 -122 299 -300 0 -300 301 0 -122 -300 0 122 300 -301 0 -301 302 0 -92 -301 0 92 301 -302 0 -302 303 0 -126 -302 0 302 -303 126 0 -7 -303 0 -37 -303 0 7 37 303 0 117 -298 0 -298 304 0 -117 298 -304 0 -304 305 0 -121 -304 0 121 304 -305 0 -305 306 0 -91 -305 0 91 305 -306 0 -306 307 0 -125 -306 0 306 -307 125 0 -6 -307 0 -36 -307 0 6 36 307 0 112 -297 0 -297 308 0 -112 297 -308 0 -308 309 0 -120 -308 0 120 308 -309 0 -309 310 0 -90 -309 0 90 309 -310 0 -310 311 0 -124 -310 0 310 -311 124 0 -5 -311 0 -35 -311 0 5 35 311 0 107 -296 0 -296 312 0 -107 296 -312 0 -312 313 0 -119 -312 0 119 312 -313 0 -313 314 0 -89 -313 0 89 313 -314 0 -314 315 0 -123 -314 0 314 -315 123 0 -4 -315 0 -34 -315 0 4 34 315 0 96 -295 0 -295 300 0 -96 295 -300 0 91 -294 0 -294 304 0 -91 294 -304 0 86 -293 0 -293 308 0 -86 293 -308 0 81 -292 0 -292 312 0 -81 292 -312 0 70 -291 0 -291 300 0 -70 291 -300 0 65 -290 0 -290 304 0 -65 290 -304 0 -289 124 0 -289 308 0 -124 289 -308 0 60 -288 0 -288 312 0 -60 288 -312 0 49 -287 0 -287 300 0 -49 287 -300 0 44 -286 0 -286 304 0 -44 286 -304 0 39 -285 0 -285 308 0 -39 285 -308 0 34 -284 0 -284 312 0 -34 284 -312 0 23 -283 0 -283 300 0 -23 283 -300 0 18 -282 0 -282 304 0 -18 282 -304 0 -281 13 0 -281 308 0 -13 281 -308 0 8 -280 0 -280 312 0 -8 280 -312 0 317 318 319 320 321 0 -321 -322 0 -321 -323 0 -321 -324 0 -321 -325 0 -321 -326 0 321 322 323 324 325 326 0 -320 -327 0 -320 -328 0 -320 -329 0 -320 -330 0 -320 -331 0 320 327 328 329 330 331 0 -319 -332 0 -319 -333 0 -5 -319 0 -319 -334 0 -319 -335 0 5 319 332 333 334 335 0 -318 -336 0 -318 -337 0 -318 -338 0 -318 -339 0 -318 -340 0 318 336 337 338 339 340 0 -317 -341 0 -317 -342 0 -317 -343 0 -317 -344 0 -317 -345 0 317 341 342 343 344 345 0 347 348 349 350 351 0 -351 -352 0 -351 -353 0 -351 -354 0 -351 -355 0 -351 -356 0 351 352 353 354 355 356 0 -350 -357 0 -350 -358 0 -350 -359 0 -350 -360 0 -350 -361 0 350 357 358 359 360 361 0 -349 -362 0 -349 -363 0 -55 -349 0 -349 -364 0 -349 -365 0 55 349 362 363 364 365 0 -348 -366 0 -348 -367 0 -348 -368 0 -348 -369 0 -348 -370 0 348 366 367 368 369 370 0 -347 -371 0 -347 -372 0 -347 -373 0 -347 -374 0 -347 -375 0 347 371 372 373 374 375 0 377 378 379 380 381 0 -381 -382 0 -381 -383 0 -381 -384 0 -381 -385 0 -326 -381 0 326 381 382 383 384 385 0 -380 -386 0 -380 -387 0 -380 -388 0 -330 -380 0 -380 -389 0 330 380 386 387 388 389 0 -379 -390 0 -379 -391 0 -5 -379 0 -379 -392 0 -379 -393 0 5 379 390 391 392 393 0 -378 -394 0 -337 -378 0 -378 -395 0 -378 -396 0 -378 -397 0 337 378 394 395 396 397 0 -341 -377 0 -377 -398 0 -377 -399 0 -377 -400 0 -377 -401 0 341 377 398 399 400 401 0 403 404 405 406 407 0 -407 408 0 -407 409 0 -407 410 0 -407 411 0 140 -407 0 -407 412 0 -407 413 0 -407 414 0 -407 415 0 144 -407 0 -407 416 0 -407 417 0 -407 418 0 -407 419 0 148 -407 0 -407 420 0 -407 421 0 -407 422 0 -407 423 0 152 -407 0 -407 424 0 -407 425 0 -407 426 0 -407 427 0 -122 -407 0 122 -140 -144 -148 -152 407 -408 -409 -410 -411 -412 -413 -414 -415 -416 -417 -418 -419 -420 -421 -422 -423 -424 -425 -426 -427 0 117 427 0 96 427 0 -96 -117 -427 0 112 426 0 70 426 0 -70 -112 -426 0 107 425 0 49 425 0 -49 -107 -425 0 102 424 0 23 424 0 -23 -102 -424 0 92 423 0 91 423 0 -91 -92 -423 0 87 422 0 65 422 0 -65 -87 -422 0 82 421 0 44 421 0 -44 -82 -421 0 77 420 0 18 420 0 -18 -77 -420 0 67 419 0 86 419 0 -67 -86 -419 0 418 126 0 418 124 0 -124 -126 -418 0 62 417 0 39 417 0 -39 -62 -417 0 57 416 0 416 13 0 -13 -57 -416 0 47 415 0 81 415 0 -47 -81 -415 0 42 414 0 60 414 0 -42 -60 -414 0 37 413 0 34 413 0 -34 -37 -413 0 32 412 0 8 412 0 -8 -32 -412 0 22 411 0 76 411 0 -22 -76 -411 0 17 410 0 55 410 0 -17 -55 -410 0 12 409 0 29 409 0 -12 -29 -409 0 7 408 0 3 408 0 -3 -7 -408 0 -406 428 0 -406 429 0 -406 430 0 159 -406 0 -406 431 0 -406 432 0 -406 433 0 -406 434 0 163 -406 0 -406 435 0 -406 436 0 -406 437 0 -406 438 0 167 -406 0 -406 439 0 -406 440 0 -406 441 0 -406 442 0 -91 -406 0 -406 443 0 -406 444 0 -406 445 0 -406 446 0 176 -406 0 -406 447 0 91 -159 -163 -167 -176 406 -428 -429 -430 -431 -432 -433 -434 -435 -436 -437 -438 -439 -440 -441 -442 -443 -444 -445 -446 -447 0 121 447 0 122 447 0 -121 -122 -447 0 111 446 0 70 446 0 -70 -111 -446 0 106 445 0 49 445 0 -49 -106 -445 0 101 444 0 23 444 0 -23 -101 -444 0 96 443 0 117 443 0 -96 -117 -443 0 86 442 0 65 442 0 -65 -86 -442 0 81 441 0 44 441 0 -44 -81 -441 0 76 440 0 18 440 0 -18 -76 -440 0 71 439 0 112 439 0 -71 -112 -439 0 438 125 0 438 124 0 -124 -125 -438 0 61 437 0 39 437 0 -39 -61 -437 0 56 436 0 436 13 0 -13 -56 -436 0 51 435 0 107 435 0 -51 -107 -435 0 41 434 0 60 434 0 -60 -434 -41 0 36 433 0 34 433 0 -34 -36 -433 0 31 432 0 8 432 0 -8 -31 -432 0 26 431 0 102 431 0 -26 -102 -431 0 16 430 0 55 430 0 -16 -55 -430 0 11 429 0 29 429 0 -11 -29 -429 0 6 428 0 3 428 0 -3 -6 -428 0 -405 448 0 -405 449 0 178 -405 0 -405 450 0 -405 451 0 -405 452 0 -405 453 0 182 -405 0 -405 454 0 -405 455 0 -405 456 0 -405 457 0 -124 -405 0 -405 458 0 -405 459 0 -405 460 0 -405 461 0 191 -405 0 -405 462 0 -405 463 0 -405 464 0 -405 465 0 195 -405 0 -405 466 0 -405 467 0 -178 -182 124 -191 -195 405 -448 -449 -450 -451 -452 -453 -454 -455 -456 -457 -458 -459 -460 -461 -462 -463 -464 -465 -466 -467 0 120 467 0 122 467 0 -120 -122 -467 0 115 466 0 96 466 0 -96 -115 -466 0 105 465 0 49 465 0 -49 -105 -465 0 100 464 0 23 464 0 -23 -100 -464 0 95 463 0 117 463 0 -95 -117 -463 0 90 462 0 91 462 0 -90 -91 -462 0 80 461 0 44 461 0 -44 -80 -461 0 75 460 0 18 460 0 -18 -75 -460 0 70 459 0 112 459 0 -70 -112 -459 0 65 458 0 86 458 0 -65 -86 -458 0 60 457 0 39 457 0 -39 -60 -457 0 55 456 0 456 13 0 -13 -55 -456 0 50 455 0 107 455 0 -50 -107 -455 0 45 454 0 81 454 0 -45 -81 -454 0 35 453 0 34 453 0 -34 -35 -453 0 30 452 0 8 452 0 -8 -30 -452 0 25 451 0 102 451 0 -25 -102 -451 0 20 450 0 76 450 0 -20 -76 -450 0 10 449 0 29 449 0 -10 -29 -449 0 5 448 0 3 448 0 -3 -5 -448 0 -404 468 0 197 -404 0 -404 469 0 -404 470 0 -404 471 0 -404 472 0 -34 -404 0 -404 473 0 -404 474 0 -404 475 0 -404 476 0 206 -404 0 -404 477 0 -404 478 0 -404 479 0 -404 480 0 210 -404 0 -404 481 0 -404 482 0 -404 483 0 -404 484 0 214 -404 0 -404 485 0 -404 486 0 -404 487 0 34 -197 -206 -210 -214 404 -468 -469 -470 -471 -472 -473 -474 -475 -476 -477 -478 -479 -480 -481 -482 -483 -484 -485 -486 -487 0 119 487 0 122 487 0 -119 -122 -487 0 114 486 0 96 486 0 -96 -114 -486 0 109 485 0 70 485 0 -70 -109 -485 0 99 484 0 23 484 0 -23 -99 -484 0 94 483 0 117 483 0 -94 -117 -483 0 89 482 0 91 482 0 -89 -91 -482 0 84 481 0 65 481 0 -65 -84 -481 0 74 480 0 18 480 0 -18 -74 -480 0 69 479 0 112 479 0 -69 -112 -479 0 64 478 0 86 478 0 -64 -86 -478 0 477 123 0 477 124 0 -123 -124 -477 0 54 476 0 476 13 0 -13 -54 -476 0 49 475 0 107 475 0 -49 -107 -475 0 44 474 0 81 474 0 -44 -81 -474 0 39 473 0 60 473 0 -39 -60 -473 0 29 472 0 8 472 0 -8 -29 -472 0 24 471 0 102 471 0 -24 -102 -471 0 19 470 0 76 470 0 -19 -76 -470 0 14 469 0 55 469 0 -55 -469 -14 0 4 468 0 3 468 0 -3 -4 -468 0 -3 -403 0 -403 488 0 -403 489 0 -403 490 0 -403 491 0 -403 492 0 -403 493 0 -403 494 0 -403 495 0 -403 496 0 -403 497 0 -403 498 0 -124 -403 0 -403 499 0 -403 500 0 -403 501 0 -403 502 0 -403 503 0 -403 504 0 -403 505 0 -403 506 0 -403 507 0 -403 508 0 -403 509 0 -403 510 0 3 403 124 -488 -489 -490 -491 -492 -493 -494 -495 -496 -497 -498 -499 -500 -501 -502 -503 -504 -505 -506 -507 -508 -509 -510 0 118 510 0 122 510 0 -118 -122 -510 0 113 509 0 96 509 0 -96 -113 -509 0 508 108 0 70 508 0 -70 -108 -508 0 103 507 0 49 507 0 -49 -103 -507 0 98 506 0 23 506 0 -23 -98 -506 0 93 505 0 117 505 0 -93 -117 -505 0 88 504 0 91 504 0 -88 -91 -504 0 503 83 0 65 503 0 -65 -83 -503 0 78 502 0 44 502 0 -44 -78 -502 0 73 501 0 18 501 0 -18 -73 -501 0 500 68 0 112 500 0 -68 -112 -500 0 499 63 0 86 499 0 -63 -86 -499 0 498 58 0 39 498 0 -39 -58 -498 0 497 53 0 497 13 0 -13 -53 -497 0 48 496 0 107 496 0 -48 -107 -496 0 43 495 0 81 495 0 -43 -81 -495 0 494 38 0 60 494 0 -38 -60 -494 0 33 493 0 34 493 0 -33 -34 -493 0 28 492 0 8 492 0 -8 -28 -492 0 23 491 0 102 491 0 -23 -102 -491 0 18 490 0 76 490 0 -18 -76 -490 0 489 13 0 55 489 0 -13 -55 -489 0 8 488 0 29 488 0 -8 -29 -488 0 371 511 512 513 514 0 367 515 516 517 518 0 55 519 520 521 522 0 360 523 524 525 526 0 356 527 528 529 530 0 532 533 534 535 536 0 -536 -537 0 -536 -538 0 -536 -539 0 -536 -540 0 -356 -536 0 356 536 537 538 539 540 0 -535 -541 0 -535 -542 0 -535 -543 0 -360 -535 0 -535 -544 0 360 535 541 542 543 544 0 -3 -534 0 -29 -534 0 -55 -534 0 -76 -534 0 -102 -534 0 3 29 55 76 102 534 0 -533 -545 0 -367 -533 0 -533 -546 0 -533 -547 0 -533 -548 0 367 533 545 546 547 548 0 -371 -532 0 -532 -549 0 -532 -550 0 -532 -551 0 -532 -552 0 371 532 549 550 551 552 0 554 555 556 557 558 0 -98 -558 0 -104 -558 0 -110 -558 0 -116 -558 0 -122 -558 0 98 104 110 116 122 558 0 -73 -557 0 -79 -557 0 -85 -557 0 -91 -557 0 -97 -557 0 73 79 85 91 97 557 0 -53 -556 0 -59 -556 0 -124 -556 0 -66 -556 0 -72 -556 0 59 66 53 72 124 556 0 -28 -555 0 -34 -555 0 -40 -555 0 -46 -555 0 -52 -555 0 28 34 40 46 52 555 0 -3 -554 0 -9 -554 0 -15 -554 0 -21 -554 0 -27 -554 0 3 9 15 21 27 554 0 560 561 562 563 564 0 -564 565 0 -564 566 0 -564 567 0 -564 568 0 -564 569 0 -564 570 0 -564 571 0 -564 572 0 -564 573 0 -564 574 0 -564 575 0 -564 576 0 -564 577 0 -564 578 0 -564 579 0 -564 580 0 -564 581 0 -564 582 0 -564 583 0 -564 584 0 -564 585 0 -564 586 0 -564 587 0 -564 588 0 -564 589 0 564 -565 -566 -567 -568 -569 -570 -571 -572 -573 -574 -575 -576 -577 -578 -579 -580 -581 -582 -583 -584 -585 -586 -587 -588 -589 0 122 589 0 -122 589 0 117 588 0 -97 588 0 97 -117 -588 0 112 587 0 -72 587 0 72 -112 -587 0 107 586 0 -52 586 0 52 -107 -586 0 102 585 0 -27 585 0 27 -102 -585 0 97 584 0 -117 584 0 -97 117 -584 0 92 583 0 -92 583 0 87 582 0 -67 582 0 67 -87 -582 0 82 581 0 -47 581 0 47 -82 -581 0 77 580 0 -22 580 0 22 -77 -580 0 72 579 0 -112 579 0 -72 112 -579 0 67 578 0 -87 578 0 -67 87 -578 0 577 126 0 -126 577 0 62 576 0 -42 576 0 42 -62 -576 0 57 575 0 -17 575 0 17 -575 -57 0 52 574 0 -107 574 0 -52 107 -574 0 47 573 0 -82 573 0 -47 82 -573 0 42 572 0 -62 572 0 -42 62 -572 0 37 571 0 -37 571 0 32 570 0 -12 570 0 12 -32 -570 0 27 569 0 -102 569 0 -27 102 -569 0 22 568 0 -77 568 0 -22 77 -568 0 17 567 0 567 -57 0 -17 57 -567 0 12 566 0 -32 566 0 -12 32 -566 0 7 565 0 -7 565 0 -563 590 0 -563 591 0 -563 592 0 -563 593 0 -563 594 0 -563 595 0 -563 596 0 -563 597 0 -563 598 0 -563 599 0 -563 600 0 -563 601 0 -563 602 0 -563 603 0 -563 604 0 -563 605 0 -563 606 0 -563 607 0 -563 608 0 -563 609 0 -563 610 0 -563 611 0 -563 612 0 -563 613 0 -563 614 0 563 -590 -591 -592 -593 -594 -595 -596 -597 -598 -599 -600 -601 -602 -603 -604 -605 -606 -607 -608 -609 -610 -611 -612 -613 -614 0 121 614 0 -121 614 0 116 613 0 -96 613 0 96 -116 -613 0 111 612 0 -71 612 0 71 -111 -612 0 106 611 0 -51 611 0 51 -106 -611 0 101 610 0 -26 610 0 26 -101 -610 0 96 609 0 -116 609 0 -96 116 -609 0 91 608 0 -91 608 0 86 607 0 -66 607 0 66 -86 -607 0 81 606 0 -46 606 0 46 -81 -606 0 76 605 0 -21 605 0 21 -76 -605 0 71 604 0 -111 604 0 -71 111 -604 0 66 603 0 -86 603 0 -66 86 -603 0 602 125 0 -125 602 0 61 601 0 601 -41 0 41 -61 -601 0 56 600 0 -16 600 0 16 -56 -600 0 51 599 0 -106 599 0 -51 106 -599 0 46 598 0 -81 598 0 -46 81 -598 0 41 597 0 -61 597 0 61 -597 -41 0 36 596 0 -36 596 0 31 595 0 -11 595 0 11 -31 -595 0 26 594 0 -101 594 0 -26 101 -594 0 21 593 0 -76 593 0 -21 76 -593 0 16 592 0 -56 592 0 -16 56 -592 0 11 591 0 -31 591 0 -11 31 -591 0 6 590 0 -6 590 0 -562 615 0 -562 616 0 -562 617 0 -562 618 0 -562 619 0 -562 620 0 -562 621 0 -562 622 0 -562 623 0 -562 624 0 -562 625 0 -562 626 0 -562 627 0 -562 628 0 -562 629 0 -562 630 0 -562 631 0 -562 632 0 -562 633 0 -562 634 0 -562 635 0 -562 636 0 -562 637 0 -562 638 0 -562 639 0 562 -615 -616 -617 -618 -619 -620 -621 -622 -623 -624 -625 -626 -627 -628 -629 -630 -631 -632 -633 -634 -635 -636 -637 -638 -639 0 120 639 0 -120 639 0 115 638 0 -95 638 0 95 -115 -638 0 110 637 0 -70 637 0 70 -110 -637 0 105 636 0 -50 636 0 50 -105 -636 0 100 635 0 -25 635 0 25 -100 -635 0 95 634 0 -115 634 0 -95 115 -634 0 90 633 0 -90 633 0 85 632 0 -65 632 0 65 -85 -632 0 80 631 0 -45 631 0 45 -80 -631 0 75 630 0 -20 630 0 20 -75 -630 0 70 629 0 -110 629 0 -70 110 -629 0 65 628 0 -85 628 0 -65 85 -628 0 627 124 0 -124 627 0 60 626 0 -40 626 0 40 -60 -626 0 55 625 0 -15 625 0 15 -55 -625 0 50 624 0 -105 624 0 -50 105 -624 0 45 623 0 -80 623 0 -45 80 -623 0 40 622 0 -60 622 0 -40 60 -622 0 35 621 0 -35 621 0 30 620 0 -10 620 0 10 -30 -620 0 25 619 0 -100 619 0 -25 100 -619 0 20 618 0 -75 618 0 -20 75 -618 0 15 617 0 -55 617 0 -15 55 -617 0 10 616 0 -30 616 0 -10 30 -616 0 5 615 0 -5 615 0 -561 640 0 -561 641 0 -561 642 0 -561 643 0 -561 644 0 -561 645 0 -561 646 0 -561 647 0 -561 648 0 -561 649 0 -561 650 0 -561 651 0 -561 652 0 -561 653 0 -561 654 0 -561 655 0 -561 656 0 -561 657 0 -561 658 0 -561 659 0 -561 660 0 -561 661 0 -561 662 0 -561 663 0 -561 664 0 561 -640 -641 -642 -643 -644 -645 -646 -647 -648 -649 -650 -651 -652 -653 -654 -655 -656 -657 -658 -659 -660 -661 -662 -663 -664 0 119 664 0 -119 664 0 114 663 0 -94 663 0 94 -114 -663 0 109 662 0 -69 662 0 69 -109 -662 0 104 661 0 -49 661 0 49 -104 -661 0 99 660 0 -24 660 0 24 -99 -660 0 94 659 0 -114 659 0 -94 114 -659 0 89 658 0 -89 658 0 84 657 0 -64 657 0 64 -84 -657 0 79 656 0 -44 656 0 44 -79 -656 0 74 655 0 -19 655 0 19 -74 -655 0 69 654 0 -109 654 0 -69 109 -654 0 64 653 0 -84 653 0 -64 84 -653 0 652 123 0 -123 652 0 59 651 0 -39 651 0 39 -59 -651 0 54 650 0 650 -14 0 14 -54 -650 0 49 649 0 -104 649 0 -49 104 -649 0 44 648 0 -79 648 0 -44 79 -648 0 39 647 0 -59 647 0 -39 59 -647 0 34 646 0 -34 646 0 29 645 0 -9 645 0 9 -29 -645 0 24 644 0 -99 644 0 -24 99 -644 0 19 643 0 -74 643 0 -19 74 -643 0 14 642 0 -54 642 0 54 -642 -14 0 9 641 0 -29 641 0 -9 29 -641 0 4 640 0 -4 640 0 -560 665 0 -560 666 0 -560 667 0 -560 668 0 -560 669 0 -560 670 0 -560 671 0 -560 672 0 -560 673 0 -560 674 0 -560 675 0 -560 676 0 -560 677 0 -560 678 0 -560 679 0 -560 680 0 -560 681 0 -560 682 0 -560 683 0 -560 684 0 -560 685 0 -560 686 0 -560 687 0 -560 688 0 560 -665 -666 -667 -668 -669 -670 -671 -672 -673 -674 -675 -676 -677 -678 -679 -680 -681 -682 -683 -684 -685 -686 -687 -688 0 118 688 0 -118 688 0 113 687 0 -93 687 0 93 -113 -687 0 686 108 0 -68 686 0 -108 68 -686 0 103 685 0 -48 685 0 48 -103 -685 0 98 684 0 -23 684 0 23 -98 -684 0 93 683 0 -113 683 0 -93 113 -683 0 88 682 0 -88 682 0 681 83 0 -63 681 0 -83 63 -681 0 78 680 0 -43 680 0 43 -78 -680 0 73 679 0 -18 679 0 18 -73 -679 0 678 68 0 -108 678 0 -68 -678 108 0 677 63 0 -83 677 0 -63 -677 83 0 676 58 0 -38 676 0 -58 -676 38 0 675 53 0 -13 675 0 -53 -675 13 0 48 674 0 -103 674 0 -48 103 -674 0 43 673 0 -78 673 0 -43 78 -673 0 672 38 0 -58 672 0 -38 58 -672 0 33 671 0 -33 671 0 28 670 0 -8 670 0 8 -28 -670 0 23 669 0 -98 669 0 -23 98 -669 0 18 668 0 -73 668 0 -18 73 -668 0 667 13 0 -53 667 0 -13 53 -667 0 8 666 0 -28 666 0 -8 28 -666 0 3 665 0 -3 665 0 -55 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 0 118 -713 0 -102 -713 0 102 -118 713 0 113 -712 0 -101 -712 0 101 -113 712 0 -711 108 0 -100 -711 0 100 -108 711 0 103 -710 0 -99 -710 0 99 -103 710 0 98 -709 0 -98 -709 0 93 -708 0 -77 -708 0 77 -93 708 0 88 -707 0 -76 -707 0 76 -88 707 0 -706 83 0 -75 -706 0 75 -83 706 0 78 -705 0 -74 -705 0 74 -78 705 0 73 -704 0 -73 -704 0 -703 68 0 -703 -57 0 57 -68 703 0 -702 63 0 -56 -702 0 56 -63 702 0 -701 58 0 -54 -701 0 54 -58 701 0 -700 53 0 -53 -700 0 48 -699 0 -32 -699 0 32 -48 699 0 43 -698 0 -31 -698 0 31 -43 698 0 -697 38 0 -30 -697 0 30 -38 697 0 33 -696 0 -29 -696 0 29 -33 696 0 28 -695 0 -28 -695 0 23 -694 0 -7 -694 0 7 -23 694 0 18 -693 0 -6 -693 0 6 -18 693 0 -692 13 0 -5 -692 0 5 -13 692 0 8 -691 0 -4 -691 0 4 -8 691 0 3 -690 0 -3 -690 0 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 0 119 -739 0 -107 -739 0 107 -119 739 0 114 -738 0 -106 -738 0 106 -114 738 0 109 -737 0 -105 -737 0 105 -109 737 0 104 -736 0 -104 -736 0 99 -735 0 -103 -735 0 -99 103 735 0 94 -734 0 -82 -734 0 82 -94 734 0 89 -733 0 -81 -733 0 81 -89 733 0 84 -732 0 -80 -732 0 80 -84 732 0 79 -731 0 -79 -731 0 74 -730 0 -78 -730 0 -74 78 730 0 69 -729 0 -62 -729 0 62 -69 729 0 64 -728 0 -61 -728 0 61 -64 728 0 -727 123 0 -60 -727 0 60 -123 727 0 59 -726 0 -59 -726 0 54 -725 0 -58 -725 0 -54 725 58 0 49 -724 0 -37 -724 0 37 -49 724 0 44 -723 0 -36 -723 0 36 -44 723 0 39 -722 0 -35 -722 0 35 -39 722 0 34 -721 0 -34 -721 0 29 -720 0 -33 -720 0 -29 33 720 0 24 -719 0 -12 -719 0 12 -24 719 0 19 -718 0 -11 -718 0 11 -19 718 0 14 -717 0 -10 -717 0 10 717 -14 0 9 -716 0 -9 -716 0 4 -715 0 -8 -715 0 -4 8 715 0 741 743 742 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 0 120 -764 0 -112 -764 0 112 -120 764 0 115 -763 0 -111 -763 0 111 -115 763 0 110 -762 0 -110 -762 0 105 -761 0 -109 -761 0 -105 109 761 0 100 -760 0 -108 -760 0 -100 760 108 0 95 -759 0 -87 -759 0 87 -95 759 0 90 -758 0 -86 -758 0 86 -90 758 0 85 -757 0 -85 -757 0 80 -756 0 -84 -756 0 -80 84 756 0 75 -755 0 -83 -755 0 -75 755 83 0 70 -754 0 -126 -754 0 -70 754 126 0 65 -753 0 -125 -753 0 -65 753 125 0 -752 124 0 -124 -752 0 60 -751 0 -123 -751 0 -60 751 123 0 50 -750 0 -42 -750 0 42 -50 750 0 45 -749 0 -749 -41 0 41 -45 749 0 40 -748 0 -40 -748 0 35 -747 0 -39 -747 0 -35 39 747 0 30 -746 0 -38 -746 0 -30 746 38 0 25 -745 0 -17 -745 0 17 -25 745 0 20 -744 0 -16 -744 0 16 -20 744 0 15 -743 0 -15 -743 0 10 -742 0 -742 -14 0 -10 14 742 0 5 -741 0 -13 -741 0 -5 741 13 0 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 0 121 -790 0 -117 -790 0 117 -121 790 0 116 -789 0 -116 -789 0 111 -788 0 -115 -788 0 -111 115 788 0 106 -787 0 -114 -787 0 -106 114 787 0 101 -786 0 -113 -786 0 -101 113 786 0 96 -785 0 -92 -785 0 92 -96 785 0 91 -784 0 -91 -784 0 86 -783 0 -90 -783 0 -86 90 783 0 81 -782 0 -89 -782 0 -81 89 782 0 76 -781 0 -88 -781 0 -76 88 781 0 71 -780 0 -67 -780 0 67 -71 780 0 66 -779 0 -66 -779 0 -778 125 0 -65 -778 0 65 -125 778 0 61 -777 0 -64 -777 0 -61 64 777 0 56 -776 0 -63 -776 0 -56 776 63 0 51 -775 0 -47 -775 0 47 -51 775 0 46 -774 0 -46 -774 0 41 -773 0 -45 -773 0 45 773 -41 0 36 -772 0 -44 -772 0 -36 44 772 0 31 -771 0 -43 -771 0 -31 43 771 0 26 -770 0 -22 -770 0 22 -26 770 0 21 -769 0 -21 -769 0 16 -768 0 -20 -768 0 -16 20 768 0 11 -767 0 -19 -767 0 -11 19 767 0 6 -766 0 -18 -766 0 -6 18 766 0 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 0 122 -816 0 -122 -816 0 117 -815 0 -121 -815 0 -117 121 815 0 112 -814 0 -120 -814 0 -112 120 814 0 107 -813 0 -119 -813 0 -107 119 813 0 102 -812 0 -118 -812 0 -102 118 812 0 97 -811 0 -97 -811 0 92 -810 0 -96 -810 0 -92 96 810 0 87 -809 0 -95 -809 0 -87 95 809 0 82 -808 0 -94 -808 0 -82 94 808 0 77 -807 0 -93 -807 0 -77 93 807 0 72 -806 0 -72 -806 0 67 -805 0 -71 -805 0 -67 71 805 0 -804 126 0 -70 -804 0 70 -126 804 0 62 -803 0 -69 -803 0 -62 69 803 0 57 -802 0 -68 -802 0 802 -57 68 0 52 -801 0 -52 -801 0 47 -800 0 -51 -800 0 -47 51 800 0 42 -799 0 -50 -799 0 -42 50 799 0 37 -798 0 -49 -798 0 -37 49 798 0 32 -797 0 -48 -797 0 -32 48 797 0 27 -796 0 -27 -796 0 22 -795 0 -26 -795 0 -22 26 795 0 17 -794 0 -25 -794 0 -17 25 794 0 12 -793 0 -24 -793 0 -12 24 793 0 7 -792 0 -23 -792 0 -7 23 792 0 818 819 820 821 822 0 -272 -822 0 -268 -822 0 -264 -822 0 -260 -822 0 -227 -822 0 227 260 264 268 272 822 0 -271 -821 0 -267 -821 0 -263 -821 0 -231 -821 0 -256 -821 0 231 256 263 267 271 821 0 -270 -820 0 -266 -820 0 -15 -820 0 -259 -820 0 -255 -820 0 15 255 259 266 270 820 0 -269 -819 0 -238 -819 0 -262 -819 0 -258 -819 0 -254 -819 0 238 254 258 262 269 819 0 -242 -818 0 -265 -818 0 -261 -818 0 -257 -818 0 -253 -818 0 242 253 257 261 265 818 0 -5 -11 -18 -27 -29 -33 -47 -50 -59 -65 -71 -73 -80 -87 -91 -94 -101 -107 -110 -114 -118 0 -5 -11 -18 -27 -28 -35 -47 -49 -59 -65 -71 -74 -82 -85 -91 -93 -101 -103 -112 -114 -120 0 301 0 313 0 305 0 -300 0 -741 0 724 0 opensmt-2.5.2/regression/state-dump/QG-classification_qg5_iso_brn644-split3.osmt2000066400000000000000000010450311445011647600277130ustar00rootroot00000000000000ñI¡õ¸õ ö}öŒö™¼‹‰€.ƒgîˆÑˆä…(j@fuj­$à‚ jô‚Í‚°‚ò~T-ß~öiâi…ko…a‚~{k@ˆ-:‚i~-uR…5…ÎiL~N‚'‚ ‚íÄi}~°iqk&~ ~ÆoÔ‡E2žœio’iÀ„ŠÃ}Tow~iG}Ao°}“}tiY}gkjip„ø€}C‡&‡]kÑ€ViôtS„Biª€Sk倾€½-8iÐ|.iIkä|½| |±‰±†Þƒid|i‹†Êƒ+€?kát·ƒ5k€òh?€èhûÞ |+k>|]4 |ð{Á\ì]abäÚXÕ>Õ$Õ ÕØÚÓoÓNÓ-Ó™¸¸…¸žS¸I¸?¸© ¸¸ù·OÇ·½·³·õœ·w·m·c·)ººíŸºã¹Ù¹“ŸÏ¹¹“¹9Ÿ‰¹W¹M¹C¹9¹¹ý¸ó¸ž¹»×¡¯»¥»s»}¡i»_»-»#»»»ÝºÓºÓ Éº—ººy ƒºÁ£I½?½5½½ù¼ï¼å¼³¼£©¼Ÿ¼m¼½¢c¼Y¼'¼c¢¼¼ËÚìÓßÓÒÓÓùÒm²Y²E²1²Rxå²Ñ²½²(y©²]³I³5³!³Õ³·zÁ³­³™³{M´9´%´´¾Ú ÔÔÔùÓßÒ{`zÄy y6{}záyoxS{šzEyŒxp{þyby©xÔzzyÆx±ÚTÔGÔ:Ô-ÔÅÒ•Úñ¹±¯±¥±i±_±U±K±±±û°ñ°µ°«°¡°—°3°°Ï¯¯“¯‰¯¯u¯Å¯»¯±¯§¯÷¯í¯ã¯Ù¯)°°° °ˆÚˆÔ{ÔnÔaÔŠÒB­/­­ ­7¦¶­£­­ §}­*®®®ñ­ž®œ¨‹®x®e®r©¯ÿ®ì®Ù®{Ú¼Ô¯Ô¢Ô•ÔpÒ6ªªü©ß©û–Òªµª˜ªÑ—{ªn«Q«4«« ¬ì˜í«Ð«³«Â™¦¬‰¬l¬O¬nÚðÔãÔÖÔÉÔVÒ«¦Ž¦q¦T¦d§G§*§ð¦¨ã§Æ§©§¹¨¨b¨E¨U©8©©þ¨aÚ@ڹјÑwÑVÑ+ž!žž žÑǽ³wmcY ÿœÃœ¹œ¯œ¥œ   ÷ŸãŸ±Ÿ§ŸŸ‰ŸWŸMŸCŸ/Ÿýžóžéžßž­ž£ž™ž…žë¡á¡Í¡Ã¡‘¡‡¡s¡i¡7¡-¡#¡¡ç Ý É ¿  ƒ o e Ë£·£­£££q£g£]£S£!£ ££ù¢Ç¢³¢©¢Ÿ¢m¢Y¢O¢E¢«¥¡¥—¥¥[¥Q¥G¥=¥3¥¥÷¤ã¤Ù¤§¤¤“¤‰¤¤M¤C¤9¤/¤%¤Kœ7œ#œœÓ›¿›«›—›[›G›3››ãšÏš»š§škšWšCš/š3Ú"ÑÑîÐÔкÐo—R—5——(˜ ˜î—´— ™Ï˜²˜•˜¥™ˆ™k™N™&ÚÒÒûÑ<Ñ ÐÚùÙDÐ#ÐÐáÏá×Íù‡}si_-#ӌɌ¿ŒµŒ«ŒyŒoŒeŒ[ŒQŒËÁ·­£qg]SI ùŽïŽ½Ž³Ž©ŽŸŽ•ŽcŽYŽOŽEŽ;Ž«‘¡‘—‘‘ƒ‘Q‘G‘=‘3‘)‘÷íÊJãÙ§“‰MC9/%•“‹““w“m“;“1“'“““á’×’Í’Ã’¹’‡’}’s’i’_’-’#’’’’•u•k•a•W•%••••ý”Ë”Á”­”£”q”g”]”S”I”” ””ù“ï“ØÙÏ‹²‹Ÿ‹•‹‚‹G‹4‹!‹‹ûŠÀŠ¶Š™Š†ŠKŠ8Š%ŠŠÿ‰Ä‰§‰”‰‰n‰’Ï ‰äˆÇˆ´ˆ¡ˆfˆSˆ6ˆ,ˆˆÞ‡Ê‡·‡¤‡‘‡V‡9‡‡ ‡ö†»†ž††n†[†¸Ùø…î…Ñ…Ç…´…y…e…H…+……Ê„„T¶„¬„z„f„I„6„#„èƒÔƒ­ƒšƒ‡ƒPÏ$ƒƒê‚¦‚k‚D‚‚‚㨔mZ=Û€´€ €€R€5€€ñÔ/ÏqJ#ü~Õ~š~s~V~9~~×}Í}¦}‰}l}'} }÷|Ú|³|n|Q|4|*||«Ù<Ò/Ò"Ò†Ð"Ï©w–wƒwpw]wJw7w$wwþv‘v~vkvXvEv2vv vùuæuyuSu@uuuÎtatNt;t(tttïsÜsÉs¶sIs6s#ssýrêr×rÄr±ržr röqãqÐq½qªq—q„qqq^qñpÞpËp¸p¥p’pplpYpFpÙo³o ozogo.oÁn®n›nˆnunbnOnHR\fpz„Ž˜¢¬¶ÀÊÔÞèòü$.8BLV`jt~ˆ’œ¦°ºÄÎØâìö (2<FPZdnx‚Œ– ª´¾ÈÒÜæðú",6@JT^hr|†š¤®¸ÂÌÖàêôþ&0:DNXblv€Š”ž¨²¼ÆÐÚäîø  * 4 > H R \ f p z „ Ž ˜ ¢ ¬ ¶ À Ê Ô Þ è ò ü    $ . 8 B L V ` j t ~ ˆ ’ œ ¦ ° º Ä Î Ø â ì ö   ( 2 < F P Z d n x ‚ Œ –   ª ´ ¾ È Ò Ü æ ð ú    " , 6 @ J T ^ h r | † š ¤ ® ¸ Â Ì Ö à ê ô þ    & 0 : D N X b l v € Š ” ž ¨ ² ¼ Æ Ð Ú ä î ø   *4>HR\fpz„Ž˜¢¬¶ÀÊÔÞèòü$.8BLV`jt~ˆ’œ¦°ºÄÎØâìö (2<FPZdnx‚Œ– ª´¾ÈÒÜæðú",6@JT^hr|†š¤®¸ÂÌÖàêôþ&0:DNXblv€Š”ž¨²¼ÆÐÚäîø  *4>HR\fpz„Ž˜¢¬¶ÀÊÔÞèòü$.8BLV`jt~ˆ’œ¦¯¸ÂËÕÞèñû  *3=FPZclv‰’œ¥¯¹ÂËÕÞèñû!*4=GPZcmw€‰’›¤­¶¿ÈÑÚãìõþ"+4=FOXajs|…Ž— ©²»ÄÍÖßèñú '09BKT]foxŠ“œ¥®·ÀÉÒÛäíöÿ#,5>GPYbkt}†˜¡ª³¼ÅÎ×àéòû#-7AKU_is}‡‘›¥¯¹ÃÍ×áëõÿ '1;EOYcmw‹•Ÿ©³½ÇÑÛåïù !+5?IS]gq{…™£­·ÁËÕßéóý%/9CMWaku‰“§±»ÅÏÙãí÷ )3=GQ[eoyƒ—¡«µ¿ÉÓÝçñû#-7AKU_is}‡‘›¥¯¹ÃÍ×áëõÿ   ' 1 ; E O Y c m w ‹ • Ÿ © ³ ½ Ç Ñ Û å ï ù ! !!!!+!5!?!I!S!]!g!q!{!…!!™!£!­!·!Á!Ë!Õ!ß!é!ó!ý!"""%"/"9"C"M"W"a"k"u""‰"“""§"±"»"Å"Ï"Ù"ã"í"÷"# ###'#1#;#D#N#X#b#k#u##‰#’#œ#¦#°#¹#Ã#Í#Ö#à#ê#ô#ý#$$$$$.$8$B$K$U$_$i$s$|$†$$™$£$­$·$À$Ê$Ô$Þ$ç$ñ$û$%%%"%,%6%?%I%S%\%f%p%z%ƒ%%—%¡%ª%´%¾%È%Ñ%Û%å%ï%ù%& &&&)&3&=&F&P&Z&d&m&w&&‹&”&ž&¨&²&¼&Å&Ï&Ù&ã&ì&ö&' '''''1':'D'N'X'a'k'u''ˆ'’'œ'¦'¯'¹'Ã'Í'Ö'à'ê'ô'þ'((($(.(8(B(L(U(_(i(s(|(†((š(¤(­(·(Á(Ê(Ô(Þ(è(ñ(û()))"),)6)@)J)S)])g)p)z)„)Ž)—)¡)«)µ)¾)È)Ò)Ü)æ)ð)ú)***"*,*6*@*J*T*^*h*r*|*†**š*¤*®*¸*Â*Ì*Ö*à*ê*ô*þ*+++&+0+:+D+N+X+b+l+v+€+Š+”+ž+¨+²+¼+Æ+Ð+Ú+ä+î+ø+, ,, ,*,4,>,H,R,\,f,p,z,„,Ž,˜,¢,¬,¶,À,Ê,Ó,Ý,ç,ð,ú,---!-+-5->-H-R-\-e-o-y-ƒ-Œ-–- -©-³-½-Ç-Ð-Ú-ä-î-÷-. ...(.2.<.F.O.Y.c.l.v.€.Š.“..§.±.º.Ä.Î.Ø.á.ë.õ.ÿ. ///&///9/C/M/V/`/j/t/}/‡/‘/›/¤/®/¸/Â/Ì/Õ/ß/é/ò/ü/000#0-070@0J0T0^0g0q0{0…00˜0¢0¬0µ0¿0É0Ó0Ü0æ0ð0ú01 11!1*141>1H1Q1[1e1n1x1‚1Œ1•1Ÿ1©1³1¼1Æ1Ð1Ú1ã1í1÷12 222(212;2E2O2X2b2l2v22‰2“22¦2°2º2Ä2Î2×2á2ë2ô2þ2333%3/393B3L3V3`3i3s3}3‡3‘3š3¤3®3·3Á3Ë3Õ3Þ3è3ò3ü3444#4,464@4J4S4]4g4p4z4„44—4¡4ª4´4¾4Ç4Ñ4Û4ä4î4ø45 555(525<5E5O5X5b5l5v55‰5“5œ5¦5°5º5Ã5Í5Ö5à5ê5ó5ý5666$6.686A6K6T6^6h6q6{6…6Ž6˜6¢6¬6¶6À6Ê6Ô6Þ6è6ò6ü6777$7.787B7L7V7`7j7t7~7ˆ7’7œ7¦7°7º7Ä7Î7Ø7â7ì7ö78 888(828<8F8P8Z8d8n8x8‚8Œ8–8 8ª8´8¾8È8Ò8Ü8æ8ð8ú8999"9,969@9J9T9^9h9r9|9†99š9¤9®9¸9Â9Ì9Ö9à9ê9ô9þ9:::&:0:::D:N:X:b:l:v:€:Š:”:ž:¨:²:¼:Æ:Ð:Ú:ä:î:ø:; ;; ;*;4;>;H;R;\;f;p;z;„;Ž;˜;¢;¬;¶;À;Ê;Ô;Þ;è;ò;ü;<<<$<.<8<B<L<V<`<j<t<~<ˆ<’<œ<¦<°<º<Ä<Î<Ø<â<ì<ö<= ===(=2=<=F=P=Z=d=n=x=‚=Œ=–= =ª=´=¾=È=Ò=Ü=æ=ð=ú=>>>">,>6>@>J>T>^>h>r>|>†>>š>¤>®>¸>Â>Ì>Ö>à>ê>ô>þ>???&?0?:?D?N?X?b?l?v?€?Š?”?ž?¨?²?¼?Æ?Ð?Ú?ä?î?ø?@ @@ @*@4@>@H@R@\@f@p@z@„@Ž@˜@¢@¬@¶@À@Ê@Ô@Þ@è@ò@ü@AAA$A.A8ABALAVA`AjAtA~AˆA’AœA¦A°AºAÄAÎAØAâAìAöAB BBB'B0B:BDBNBWBaBkBuB~BˆB’BœB¥B¯B¹BÃBÌBÖBàBêBóBýBCCC$C.C8CBCKCUC_ChCrC|C†CC™C£C­C·CÀCÊCÔCÞCèCñCûCDDD"D,D5D?DIDSD]DfDpDzD„DŽD—D¡D«D´D¾DÈDÒDÛDåDïDùDE EE E*E4E>EHERE\EfEpEzE„EŽE˜E¢E¬E¶EÀEÊEÔEÞEèEòEüEFFF$F.F8FBFLFVF`FjFtF~FˆF’FœF¦F°FºFÄFÎFØFâFìFöFG GGG(G2GJHJRJ\JfJpJzJ„JŽJ˜J¢J¬J¶JÀJÊJÔJÞJèJòJüJKKK$K.K8KBKLKVK`KjKtK~KˆK’KœK¦K°KºKÄKÎKØKâKìKöKL LLL(L2LOHORO\OfOpOzO„OŽO˜O¢O¬O¶OÀOÊOÔOÞOèOòOüOPPP$P.P8PBPLPVP`PjPtP~PˆP’PœP¦P°PºPÄPÎPØPâPìPöPQ QQQ(Q2QTHTRT\TfTpTzT„TŽT˜T¢T¬T¶TÀTÊTÔTÞTèTòTüTUUU$U.U8UBULUVU`UjUtU~UˆU’UœU¦U°UºUÄUÎUØUâUìUöUV VVV(V2VYHYRY\YfYpYzY„YŽY˜Y¢Y¬Y¶YÀYÊYÔYÞYèYòYüYZZZ$Z.Z8ZBZLZVZ`ZjZtZ~Z‡Z‘ZšZ¤Z®Z·ZÁZËZÔZÞZèZñZûZ[[["[+[5[?[H[R[\[e[o[y[‚[Œ[–[Ÿ[©[²[¼[Æ[Ï[Ù[ã[ì[ö[\ \\\&\0\:\C\M\W\`\j\t\}\‡\‘\š\¤\®\¸\Á\Ë\Ô\Þ\è\ñ\û\]]]"]+]5]?]H]R]\]e]o]y]‚]Œ]–]Ÿ]©]³]¼]Æ]Ð]Ú]ã]í]ö]^ ^^^'^0^:^D^M^W^a^j^t^~^‡^‘^›^¤^®^¸^Á^Ë^Õ^Þ^è^ò^ü^___"_,_5_?_I_R_\_f_o_y_ƒ_Œ_–_ _©_³_½_Æ_Ð_Ú_ã_í_÷_` ```'`1`:`D`N`W`a`k`t`~`ˆ`‘`›`¥`®`¸`Â`Ë`Õ`ß`è`ò`ü`aaa"a,a6a?aIaRa\afaoayaƒaŒa–a a©a³a½aÆaÐaÚaãaía÷ab bbb'b1b:bDbNbXbabkbtb~bˆb‘b›b¥b®b¸bÂbËbÕbßbèbòbübccc"c,c6c?cIcSc\cfcpczcƒcc–c cªc³c½cÇcÐcÚcäcíc÷cd ddd'd1d;dDdNdXdadkdud~dˆd’dœd¥d¯d¸dÂdÌdÕdßdédòdüdeee#e,e6e@eIeSe]efepezeƒee—e eªe´e¾eÈeÑeÛeäeîeøef fff(f2f;fEfOfXfbflfuff‰f’fœf¦f¯f¹fÃfÌfÖfàfêfôfþfggg&g0g:gDgNgXgbglgvg€gŠg”gžg¨g²g¼gÆgÐgÚgägíg÷gh hhh)h3h=hGhQh[hehohyhƒhh—h¡h«hµh¾hÞhèhòhühiii$i.i8iBiLiVi`ijiti~iˆi’iœi¦i°iºiÄiÎiØiâiìiöij jjj(j2jxHxRx\xexoxyx‚xŒx–xŸx©x³x¼xÆxÐxÙxãxíx÷xy yyy(y2y;yEyOyXybylyuyy‰y’yœy¦y°yºyÄyÎy×yáyëyôyþyzzz%z.z8zBzLzVz`zjzsz}z‡zzšz¤z­z·zÁzÊzÔzÞzçzñzûz{{{#{,{6{@{I{S{]{f{p{z{ƒ{{—{ {ª{´{¾{È{Ò{Ü{æ{ð{ú{| || |*|4|>|H|Q|[|d|n|x|‚|Œ|–| |ª|³|½|Ç|Ð|Ú|ä|î|÷|} }}}'}1};}E}O}Y}c}l}v}}‰}“}}¦}°}º}Ã}Í}×}á}ë}õ}ÿ} ~~~&~0~9~C~L~V~`~i~s~}~‡~~š~¤~®~¸~Â~Ì~Õ~ß~é~ò~ü~#-7@JT^gq{…™£­·ÁËÔÞèñû€€€"€+€5€?€I€R€\€f€p€z€„€€—€ €ª€´€¾€È€Ñ€Û€å€ï€ø€  *4=GQZdmwŠ”ž¨²¼ÆÐÚãí÷‚ ‚‚‚'‚1‚:‚D‚N‚X‚a‚k‚u‚‚‰‚“‚‚¦‚°‚º‚Âׂ͂à‚ê‚ô‚þ‚ƒƒƒ$ƒ.ƒ8ƒBƒLƒVƒ`ƒjƒtƒ~ƒ‡ƒ‘ƒšƒ¤ƒ­ƒ·ƒÁƒÊƒÔƒÞƒèƒòƒüƒ„„„#„-„6„@„I„S„]„f„p„z„„„Ž„˜„¢„¬„¶„À„Ê„Ô„Ý„ç„ñ„û„………"…+…5…?…H…R…\…e…o…y…ƒ……—…¡…«…´…¾…Ç…Ñ…Û…ä…î…ø…† †† †*†4†>†H†R†[†e†n†x††‹†•†ž†¨†±†»†Å†Ï†Ù†ã†í†ö†‡ ‡‡‡&‡0‡9‡C‡M‡V‡`‡j‡t‡~‡ˆ‡‘‡›‡¤‡®‡·‡Á‡Ê‡Ô‡Þ‡è‡ò‡ü‡ˆˆˆ#ˆ,ˆ6ˆ@ˆJˆSˆ]ˆfˆpˆzˆ„ˆŽˆ˜ˆ¡ˆ«ˆ´ˆ¾ˆÇˆÑˆÛˆäˆîˆøˆ‰ ‰‰‰)‰3‰=‰G‰Q‰[‰e‰n‰x‰‰‹‰”‰ž‰§‰±‰»‰Ä‰Î‰Ø‰â‰ì‰ö‰ÿ‰ ŠŠŠ%Š/Š8ŠBŠKŠUŠ_ŠiŠsŠ}Š†ŠŠ™Š£Š­Š¶ŠÀŠÊŠÔŠÞŠèŠòŠûŠ‹‹‹!‹+‹4‹>‹G‹Q‹[‹e‹o‹y‹‚‹Œ‹•‹Ÿ‹©‹²‹¼‹Æ‹Ï‹Ù‹ã‹í‹÷‹Œ ŒŒŒ)Œ3Œ=ŒGŒQŒ[ŒeŒoŒyŒƒŒŒ—Œ¡Œ«ŒµŒ¿ŒÉŒÓŒÝŒçŒñŒûŒ#-7AKU_is}‡‘›¥¯¹ÃÍ×áëõÿ ŽŽŽ'Ž1Ž;ŽEŽOŽYŽcŽmŽwŽŽ‹Ž•ŽŸŽ©Ž³Ž½ŽÇŽÑŽÛŽåŽïŽùŽ !+5?IS]gq{…™£­·ÁËÕßéóý%/9CMWaku‰“§±»ÅÏÙãí÷‘ ‘‘‘)‘3‘=‘G‘Q‘[‘e‘o‘y‘ƒ‘‘—‘¡‘«‘µ‘¿‘É‘Ó‘Ý‘ç‘ñ‘û‘’’’#’-’7’A’K’U’_’i’s’}’‡’‘’›’¥’¯’¹’Ã’Í’×’á’ë’õ’ÿ’ “““'“1“;“E“O“Y“c“m“w““‹“•“Ÿ“©“³“½“Ç“Ñ“Û“å“ï“ù“” ””!”+”5”?”I”S”]”g”q”{”…””™”£”­”·”Á”˔Քߔé”ó”ý”•••%•/•9•C•M•W•a•k•u••‰•“••§•±•»•Å•Ï•Ù•ã•í•÷•– –––)–3–=–G–Q–[–e–o–y–ƒ––—–¡–«–µ–¿–É–Ó–Ý–ç–ñ–û–———"—+—5—?—H—R—\—e—o—y—‚—Œ—–— —ª—´—¾—Ç—Ñ—Û—ä—î—ø—˜ ˜˜˜(˜2˜;˜E˜O˜Y˜c˜m˜w˜˜‹˜•˜Ÿ˜¨˜²˜¼˜Å˜Ï˜Ù˜â˜ì˜ö˜ÿ˜ ™™™&™0™:™D™N™X™a™k™u™~™ˆ™’™›™¥™¯™¸™Â™Ì™Õ™ß™é™ó™ý™ššš%š/š9šCšMšWšaškšušš‰š“šš§š±š»šÅšÏšÙšãšíš÷š› ›››)›3›=›G›Q›[›e›o›y›ƒ››—›¡›«›µ›¿›É›Ó›Ý›ç›ñ›û›œœœ#œ-œ7œAœKœUœ_œiœsœ}œ‡œ‘œ›œ¥œ¯œ¹œÃœÍœ×œáœëœõœÿœ '1;EOYcmw‹•Ÿ©³½ÇÑÛåïùž žž!ž+ž5ž?žIžSž]žgžqž{ž…žž™ž£ž­ž·žÁžËžÕžßžéžóžýžŸŸŸ%Ÿ/Ÿ9ŸCŸMŸWŸaŸkŸuŸŸ‰Ÿ“ŸŸ§Ÿ±Ÿ»ŸÅŸÏŸÙŸãŸíŸ÷Ÿ     ) 3 = G Q [ e o y ƒ  — ¡ « µ ¿ É Ó Ý ç ñ û ¡¡¡#¡-¡7¡A¡K¡U¡_¡i¡s¡}¡‡¡‘¡›¡¥¡¯¡¹¡Ã¡Í¡×¡á¡ë¡õ¡ÿ¡ ¢¢¢'¢1¢;¢E¢O¢Y¢c¢m¢w¢¢‹¢•¢Ÿ¢©¢³¢½¢Ç¢Ñ¢Û¢å¢ï¢ù¢£ ££!£+£5£?£I£S£]£g£q£{£…££™£££­£·£Á£Ë£Õ£ß£é£ó£ý£¤¤¤%¤/¤9¤C¤M¤W¤a¤k¤u¤¤‰¤“¤¤§¤±¤»¤Å¤Ï¤Ù¤ã¤í¤÷¤¥ ¥¥¥)¥3¥=¥G¥Q¥[¥e¥o¥y¥ƒ¥¥—¥¡¥«¥µ¥¿¥É¥Ó¥Ý¥ç¥ñ¥û¥¦¦¦#¦-¦7¦A¦J¦T¦^¦g¦q¦{¦„¦Ž¦˜¦¡¦«¦µ¦¾¦È¦Ò¦Ü¦æ¦ð¦ú¦§ §§ §*§4§=§G§Q§Z§d§n§w§§‹§•§Ÿ§©§³§¼§Æ§Ð§Ù§ã§í§ö§¨ ¨¨¨'¨1¨;¨E¨O¨X¨b¨l¨u¨¨‰¨’¨œ¨¦¨¯¨¹¨Ã¨Ì¨Ö¨à¨ê¨ô¨þ¨©©©%©.©8©B©K©U©_©h©r©|©…©©™©£©­©·©Á©Ë©Õ©ß©é©ò©ü©ªªª#ª,ª6ª@ªIªSª]ªgªqª{ª…ªŽª˜ª¢ª«ªµª¿ªÈªÒªÜªåªïªùª« ««!«*«4«>«G«Q«[«d«n«x««‹«•«Ÿ«©«³«½«Æ«Ð«Ú«ã«í«÷«¬ ¬¬¬'¬1¬;¬E¬O¬Y¬b¬l¬v¬¬‰¬“¬œ¬¦¬°¬¹¬Ã¬Í¬×¬á¬ë¬õ¬ÿ¬ ­­­&­/­9­B­L­U­_­i­s­}­‡­­š­£­­­¶­À­É­Ó­Ý­ç­ñ­û­®®®!®*®4®=®G®Q®[®e®o®x®‚®‹®•®ž®¨®±®»®Å®Ï®Ù®ã®ì®ö®ÿ® ¯¯¯%¯/¯9¯C¯M¯W¯a¯k¯u¯¯‰¯“¯¯§¯±¯»¯Å¯Ï¯Ù¯ã¯í¯÷¯° °°°)°3°=°G°Q°[°e°o°y°ƒ°°—°¡°«°µ°¿°É°Ó°Ý°ç°ñ°û°±±±#±-±7±A±K±U±_±i±s±}±‡±‘±›±¥±¯±¹±Ã±Í±×±á±ë±õ±ÿ± ²²²'²1²;²E²O²Y²c²m²w²²‹²•²Ÿ²©²³²½²Ç²Ñ²Û²å²ï²ù²³ ³³!³+³5³?³I³S³]³g³q³{³…³³™³£³­³·³Á³Ë³Õ³ß³é³ó³ý³´´´%´/´9´C´M´W´a´k´u´´‰´“´´§´±´»´Å´Ï´Ù´ã´í´÷´µ µµµ)µ3µ=µGµQµ[µeµoµyµƒµµ—µ µ©µ²µ»µÅµÏµÙµãµìµõµþµ¶¶¶%¶/¶8¶A¶J¶S¶]¶g¶q¶{¶„¶¶–¶Ÿ¶©¶³¶½¶Ç¶Ð¶Ù¶â¶ë¶õ¶ÿ¶ ···'·1·;·E·O·Y·c·m·w··‹·•·Ÿ·©·³·½·Ç·Ñ·Û·å·ï·ù·¸ ¸¸!¸+¸5¸?¸I¸S¸]¸g¸q¸{¸…¸¸™¸£¸­¸·¸Á¸Ë¸Õ¸ß¸é¸ó¸ý¸¹¹¹%¹/¹9¹C¹M¹W¹a¹k¹u¹¹‰¹“¹¹§¹±¹»¹Å¹Ï¹Ù¹ã¹í¹÷¹º ººº)º3º=ºGºQº[ºeºoºyºƒºº—º¡º«ºµº¿ºÉºÓºÝºçºñºûº»»»#»-»7»A»K»U»_»i»s»}»‡»‘»›»¥»¯»¹»Ã»Í»×»á»ë»õ»ÿ» ¼¼¼'¼1¼;¼E¼O¼Y¼c¼m¼w¼¼‹¼•¼Ÿ¼©¼³¼½¼Ç¼Ñ¼Û¼å¼ï¼ù¼½ ½½!½+½5½?½I½S½]½g½q½{½…½½™½£½­½·½Á½Ë½Õ½ß½é½ó½ý½¾¾¾%¾/¾9¾C¾M¾W¾a¾k¾u¾¾‰¾“¾¾§¾±¾»¾Å¾Ï¾Ù¾ã¾í¾÷¾¿ ¿¿¿)¿3¿=¿G¿Q¿[¿e¿o¿y¿ƒ¿¿—¿¡¿«¿µ¿¿¿É¿Ó¿Ý¿ç¿ñ¿û¿ÀÀÀ#À-À7ÀAÀKÀUÀ_ÀiÀsÀ}À‡À‘À›À¥À¯À¹ÀÃÀÍÀ×ÀáÀëÀõÀÿÀ ÁÁÁ'Á1Á;ÁEÁOÁYÁcÁmÁwÁÁ‹Á•ÁŸÁ©Á³Á½ÁÇÁÑÁÛÁåÁïÁùÁ ÂÂ!Â+Â5Â?ÂIÂSÂ]ÂgÂqÂ{…™£­·ÂÁÂËÂÕÂßÂéÂóÂýÂÃÃÃ%Ã/Ã9ÃCÃMÃWÃaÃkÃuÃÉÓÃçñûÃÅÃÏÃÙÃãÃíÃ÷ÃÄ ÄÄÄ)Ä3Ä=ÄGÄQÄ[ÄeÄoÄyăÄėġīĵĿÄÉÄÓÄÝÄçÄñÄûÄÅÅÅ#Å-Å7ÅAÅKÅUÅ_ÅiÅsÅ}ŇőśťůŹÅÃÅÍÅ×ÅáÅëÅõÅÿÅ ÆÆÆ'Æ1Æ;ÆEÆOÆYÆcÆmÆwÆƋƕƟƩƳƽÆÇÆÑÆÛÆåÆïÆùÆÇ ÇÇ!Ç+Ç5Ç?ÇIÇSÇ]ÇgÇqÇ{Ç…ÇǙǣǭǷÇÁÇËÇÕÇßÇéÇóÇýÇÈÈÈ%È/È9ÈCÈMÈWÈaÈkÈuÈȉȓÈȧȱȻÈÅÈÏÈÙÈãÈíÈ÷ÈÉ ÉÉÉ)É3É=ÉGÉQÉ[ÉeÉoÉyɃÉɗɡɫɵɿÉÉÉÓÉÝÉçÉñÉûÉÊÊÊ#Ê-Ê7ÊAÊKÊUÊ_ÊiÊsÊ}ʇʑʛʥʯʹÊÃÊÍÊ×ÊáÊëÊõÊÿÊ ËËË'Ë1Ë;ËEËOËYËcËmËwËˋ˕˟˩˳˽ËÇËÑËÛËåËïËùËÌ ÌÌ!Ì+Ì5Ì?ÌIÌSÌ]ÌgÌqÌ{Ì…Ì̷̙̣̭ÌÁÌËÌÕÌßÌéÌóÌýÌÍÍÍ%Í/Í9ÍCÍMÍWÍaÍkÍuÍ͉͓ÍͧͱͻÍÅÍÏÍÙÍãÍíÍ÷ÍÎ ÎÎ5ÎÏ"Ï/ÏPÏqϒϳÏÔÏáÏÐ#ÐDÐeІГРЭкÐÇÐÔÐáÐîÐûÐÑÑ"Ñ/Ñ<ÑIÑVÑwјѹÑÚÑûÑÒÒ"Ò/Ò<ÒIÒVÒcÒpÒ}ÒŠÒ—Ò¸ÒÅÒÒÒßÒìÒùÒÓÓ Ó-ÓNÓoÓÓ±ÓÒÓßÓìÓùÓÔÔ Ô-Ô:ÔGÔTÔaÔnÔ{ÔˆÔ•Ô¢Ô¯Ô¼ÔÉÔÖÔãÔðÔýÔ ÕÕ$Õ1Õ>ÕKÕXÕeÕrÕՌՙզճÕÀÕÍÕÚÕçÕôÕÖÖÖ(Ö5ÖBÖOÖ\ÖiÖvÖƒÖÖÖªÖ·ÖÄÖÑÖÞÖëÖøÖ×××,×9×F×S×`×m×zׇהס׮׻×È×Õ×â×ï×ü× ØØ#Ø0Ø=ØJØWØdØqØ~؋ؘإزؿØÌØÙØæØóØÙ ÙÙ7ÙTÙaÙ}ن٢٫ٸÙØÙùÙÚ&Ú3Ú@ÚaÚnÚ{ÚˆÚ•Ú±Ú¾ÚËÚØÚäÚðÚÐÛÌÛPZÿÿÿÿÿÿÿÿÿÿÿÿdÿÿÿÿÿÿ€Sÿÿÿÿÿÿaÿÿÿÿÿÿ"€Sÿÿÿÿÿÿ*"^ÿÿÿÿÿÿ4€Sÿÿÿÿÿÿ<4[ÿÿÿÿÿÿF€ SÿÿÿÿÿÿNF XÿÿÿÿÿÿX€ Sÿÿÿÿÿÿ`X€ Sÿÿÿÿÿÿj"€ Sÿÿÿÿÿÿt""€Sÿÿÿÿÿÿ~"4€Sÿÿÿÿÿÿˆ"F€Sÿÿÿÿÿÿ’"X€Sÿÿÿÿÿÿœ4€Sÿÿÿÿÿÿ¦4"€Sÿÿÿÿÿÿ°44€Sÿÿÿÿÿÿº4F€SÿÿÿÿÿÿÄ4X€SÿÿÿÿÿÿÎF€SÿÿÿÿÿÿØF"€SÿÿÿÿÿÿâF4€SÿÿÿÿÿÿìFF€SÿÿÿÿÿÿöFX€SÿÿÿÿÿÿX€Sÿÿÿÿÿÿ X"€SÿÿÿÿÿÿX4€SÿÿÿÿÿÿXF€Sÿÿÿÿÿÿ(XX€ >ÿÿÿÿÿÿ2€!>ÿÿÿÿÿÿ<"€"ÿÿÿÿÿÿF2<€#>ÿÿÿÿÿÿP4€$ÿÿÿÿÿÿZFP€%>ÿÿÿÿÿÿdF€&ÿÿÿÿÿÿnZd€'>ÿÿÿÿÿÿxX€(ÿÿÿÿÿÿ‚nx€)>ÿÿÿÿÿÿŒ*€*>ÿÿÿÿÿÿ–"*€+ÿÿÿÿÿÿ Œ–€,>ÿÿÿÿÿÿª*4€-ÿÿÿÿÿÿ´ ª€.>ÿÿÿÿÿÿ¾*F€/ÿÿÿÿÿÿÈ´¾€0>ÿÿÿÿÿÿÒ*X€1ÿÿÿÿÿÿÜÈÒ€2ÿÿÿÿÿÿæ‚Ü€3>ÿÿÿÿÿÿð<€4>ÿÿÿÿÿÿú"<€5ÿÿÿÿÿÿðú€6>ÿÿÿÿÿÿ4<€7ÿÿÿÿÿÿ€8>ÿÿÿÿÿÿ"<F€9ÿÿÿÿÿÿ,"€:>ÿÿÿÿÿÿ6<X€;ÿÿÿÿÿÿ@,6€<ÿÿÿÿÿÿJæ@€=>ÿÿÿÿÿÿTN€>>ÿÿÿÿÿÿ^"N€?ÿÿÿÿÿÿhT^€@>ÿÿÿÿÿÿr4N€Aÿÿÿÿÿÿ|hr€B>ÿÿÿÿÿÿ†FN€Cÿÿÿÿÿÿ|†€D>ÿÿÿÿÿÿšNX€Eÿÿÿÿÿÿ¤š€Fÿÿÿÿÿÿ®J¤€G>ÿÿÿÿÿÿ¸`€H>ÿÿÿÿÿÿÂ"`€Iÿÿÿÿÿÿ̸€J>ÿÿÿÿÿÿÖ4`€KÿÿÿÿÿÿàÌÖ€L>ÿÿÿÿÿÿêF`€Mÿÿÿÿÿÿôàê€N>ÿÿÿÿÿÿþX`€Oÿÿÿÿÿÿôþ€Pÿÿÿÿÿÿ®€Q>ÿÿÿÿÿÿj€R>ÿÿÿÿÿÿ&"j€Sÿÿÿÿÿÿ0&€T>ÿÿÿÿÿÿ:4j€UÿÿÿÿÿÿD0:€V>ÿÿÿÿÿÿNFj€WÿÿÿÿÿÿXDN€X>ÿÿÿÿÿÿbXj€YÿÿÿÿÿÿlXb€Z>ÿÿÿÿÿÿvt€[>ÿÿÿÿÿÿ€"t€\ÿÿÿÿÿÿŠv€€]>ÿÿÿÿÿÿ”4t€^ÿÿÿÿÿÿžŠ”€_>ÿÿÿÿÿÿ¨Ft€`ÿÿÿÿÿÿ²ž¨€a>ÿÿÿÿÿÿ¼Xt€bÿÿÿÿÿÿƲ¼€cÿÿÿÿÿÿÐlÆ€d>ÿÿÿÿÿÿÚ~€e>ÿÿÿÿÿÿä"~€fÿÿÿÿÿÿîÚä€g>ÿÿÿÿÿÿø4~€hÿÿÿÿÿÿîø€i>ÿÿÿÿÿÿ F~€jÿÿÿÿÿÿ €k>ÿÿÿÿÿÿ X~€lÿÿÿÿÿÿ* €mÿÿÿÿÿÿ4Ð*€n>ÿÿÿÿÿÿ>ˆ€o>ÿÿÿÿÿÿH"ˆ€pÿÿÿÿÿÿR>H€q>ÿÿÿÿÿÿ\4ˆ€rÿÿÿÿÿÿfR\€s>ÿÿÿÿÿÿpFˆ€tÿÿÿÿÿÿzfp€u>ÿÿÿÿÿÿ„Xˆ€vÿÿÿÿÿÿŽz„€wÿÿÿÿÿÿ˜4Ž€x>ÿÿÿÿÿÿ¢’€y>ÿÿÿÿÿÿ¬"’€zÿÿÿÿÿÿ¶¢¬€{>ÿÿÿÿÿÿÀ4’€|ÿÿÿÿÿÿʶÀ€}>ÿÿÿÿÿÿÔF’€~ÿÿÿÿÿÿÞÊÔ€>ÿÿÿÿÿÿèX’€€ÿÿÿÿÿÿòÞè€ÿÿÿÿÿÿü˜ò€‚ÿÿÿÿÿÿü€ƒ>ÿÿÿÿÿÿœ€„>ÿÿÿÿÿÿ"œ€…ÿÿÿÿÿÿ$€†>ÿÿÿÿÿÿ.4œ€‡ÿÿÿÿÿÿ8$.€ˆ>ÿÿÿÿÿÿBFœ€‰ÿÿÿÿÿÿL8B€Š>ÿÿÿÿÿÿVXœ€‹ÿÿÿÿÿÿ`LV€Œ>ÿÿÿÿÿÿj¦€>ÿÿÿÿÿÿt"¦€Žÿÿÿÿÿÿ~jt€>ÿÿÿÿÿÿˆ4¦€ÿÿÿÿÿÿ’~ˆ€‘>ÿÿÿÿÿÿœF¦€’ÿÿÿÿÿÿ¦’œ€“>ÿÿÿÿÿÿ°X¦€”ÿÿÿÿÿÿº¦°€•ÿÿÿÿÿÿÄ`º€–>ÿÿÿÿÿÿΰ€—>ÿÿÿÿÿÿØ"°€˜ÿÿÿÿÿÿâÎØ€™>ÿÿÿÿÿÿì4°€šÿÿÿÿÿÿöâ쀛>ÿÿÿÿÿÿF°€œÿÿÿÿÿÿ ö€>ÿÿÿÿÿÿX°€žÿÿÿÿÿÿ €Ÿÿÿÿÿÿÿ(Ä€ >ÿÿÿÿÿÿ2º€¡>ÿÿÿÿÿÿ<"º€¢ÿÿÿÿÿÿF2<€£>ÿÿÿÿÿÿP4º€¤ÿÿÿÿÿÿZFP€¥>ÿÿÿÿÿÿdFº€¦ÿÿÿÿÿÿnZd€§>ÿÿÿÿÿÿxXº€¨ÿÿÿÿÿÿ‚nx€©ÿÿÿÿÿÿŒ(‚€ª>ÿÿÿÿÿÿ–Ä€«>ÿÿÿÿÿÿ "Ä€¬ÿÿÿÿÿÿª– €­>ÿÿÿÿÿÿ´4Ä€®ÿÿÿÿÿÿ¾ª´€¯>ÿÿÿÿÿÿÈFÄ€°ÿÿÿÿÿÿҾȀ±>ÿÿÿÿÿÿÜXÄ€²ÿÿÿÿÿÿæÒÜ€³ÿÿÿÿÿÿðŒæ€´ÿÿÿÿÿÿúð€µ>ÿÿÿÿÿÿ΀¶>ÿÿÿÿÿÿ"΀·ÿÿÿÿÿÿ€¸>ÿÿÿÿÿÿ"4΀¹ÿÿÿÿÿÿ,"€º>ÿÿÿÿÿÿ6F΀»ÿÿÿÿÿÿ@,6€¼>ÿÿÿÿÿÿJX΀½ÿÿÿÿÿÿT@J€¾>ÿÿÿÿÿÿ^Ø€¿>ÿÿÿÿÿÿh"Ø€Àÿÿÿÿÿÿr^h€Á>ÿÿÿÿÿÿ|4Ø€Âÿÿÿÿÿÿ†r|€Ã>ÿÿÿÿÿÿFØ€Äÿÿÿÿÿÿš†€Å>ÿÿÿÿÿÿ¤XØ€Æÿÿÿÿÿÿ®š¤€Çÿÿÿÿÿÿ¸T®€È>ÿÿÿÿÿÿÂâ€É>ÿÿÿÿÿÿÌ"â€ÊÿÿÿÿÿÿÖÂÌ€Ë>ÿÿÿÿÿÿà4â€ÌÿÿÿÿÿÿêÖà€Í>ÿÿÿÿÿÿôFâ€Îÿÿÿÿÿÿþêô€Ï>ÿÿÿÿÿÿXâ€Ðÿÿÿÿÿÿþ€Ñÿÿÿÿÿÿ¸€Ò>ÿÿÿÿÿÿ&ì€Ó>ÿÿÿÿÿÿ0"ì€Ôÿÿÿÿÿÿ:&0€Õ>ÿÿÿÿÿÿD4ì€ÖÿÿÿÿÿÿN:D€×>ÿÿÿÿÿÿXFì€ØÿÿÿÿÿÿbNX€Ù>ÿÿÿÿÿÿlXì€Úÿÿÿÿÿÿvbl€Ûÿÿÿÿÿÿ€v€Ü>ÿÿÿÿÿÿŠö€Ý>ÿÿÿÿÿÿ”"ö€ÞÿÿÿÿÿÿžŠ”€ß>ÿÿÿÿÿÿ¨4ö€àÿÿÿÿÿÿ²ž¨€á>ÿÿÿÿÿÿ¼Fö€âÿÿÿÿÿÿƲ¼€ã>ÿÿÿÿÿÿÐXö€äÿÿÿÿÿÿÚÆЀåÿÿÿÿÿÿä€Ú€æÿÿÿÿÿÿîúä€ç>ÿÿÿÿÿÿø€è>ÿÿÿÿÿÿ "€éÿÿÿÿÿÿ ø €ê>ÿÿÿÿÿÿ 4€ëÿÿÿÿÿÿ  €ì>ÿÿÿÿÿÿ* F€íÿÿÿÿÿÿ4 * €î>ÿÿÿÿÿÿ> X€ïÿÿÿÿÿÿH 4 > €ð>ÿÿÿÿÿÿR  €ñ>ÿÿÿÿÿÿ\ " €òÿÿÿÿÿÿf R \ €ó>ÿÿÿÿÿÿp 4 €ôÿÿÿÿÿÿz f p €õ>ÿÿÿÿÿÿ„ F €öÿÿÿÿÿÿŽ z „ €÷>ÿÿÿÿÿÿ˜ X €øÿÿÿÿÿÿ¢ Ž ˜ €ùÿÿÿÿÿÿ¬ H ¢ €ú>ÿÿÿÿÿÿ¶ €û>ÿÿÿÿÿÿÀ "€üÿÿÿÿÿÿÊ ¶ À €ý>ÿÿÿÿÿÿÔ 4€þÿÿÿÿÿÿÞ Ê Ô €ÿ>ÿÿÿÿÿÿè F€ÿÿÿÿÿÿò Þ è €>ÿÿÿÿÿÿü X€ÿÿÿÿÿÿ ò ü €ÿÿÿÿÿÿ ¬  €>ÿÿÿÿÿÿ €>ÿÿÿÿÿÿ$ "€ÿÿÿÿÿÿ.  $ €>ÿÿÿÿÿÿ8 4€ÿÿÿÿÿÿB . 8 € >ÿÿÿÿÿÿL F€ ÿÿÿÿÿÿV B L € >ÿÿÿÿÿÿ` X€ ÿÿÿÿÿÿj V ` € ÿÿÿÿÿÿt  j €>ÿÿÿÿÿÿ~ (€>ÿÿÿÿÿÿˆ "(€ÿÿÿÿÿÿ’ ~ ˆ €>ÿÿÿÿÿÿœ 4(€ÿÿÿÿÿÿ¦ ’ œ €>ÿÿÿÿÿÿ° F(€ÿÿÿÿÿÿº ¦ ° €>ÿÿÿÿÿÿÄ X(€ÿÿÿÿÿÿÎ º Ä €ÿÿÿÿÿÿØ t Î €ÿÿÿÿÿÿâ îØ €ÿÿÿÿÿÿì 2Œ€ÿÿÿÿÿÿö ì ð€ÿÿÿÿÿÿ ö T€ÿÿÿÿÿÿ ¸€ÿÿÿÿÿÿ 2€ÿÿÿÿÿÿ  €ÿÿÿÿÿÿ(  € ÿÿÿÿÿÿ2 ( ø€!ÿÿÿÿÿÿ< 2 €"ÿÿÿÿÿÿF <–€#ÿÿÿÿÿÿP F ú€$ÿÿÿÿÿÿZ P ^€%ÿÿÿÿÿÿd Z €&ÿÿÿÿÿÿn <&€'ÿÿÿÿÿÿx n €(ÿÿÿÿÿÿ‚ x €)ÿÿÿÿÿÿŒ ‚  €*ÿÿÿÿÿÿ– d Œ €+ÿÿÿÿÿÿ  < – €,ÿÿÿÿÿÿª Pª€-ÿÿÿÿÿÿ´ ª €.ÿÿÿÿÿÿ¾ ´ r€/ÿÿÿÿÿÿÈ ¾ Ö€0ÿÿÿÿÿÿÒ P:€1ÿÿÿÿÿÿÜ Ò .€2ÿÿÿÿÿÿæ Ü "€3ÿÿÿÿÿÿð æ  €4ÿÿÿÿÿÿú È ð €5ÿÿÿÿÿÿ   ú €6ÿÿÿÿÿÿ d¾€7ÿÿÿÿÿÿ  "€8ÿÿÿÿÿÿ"  †€9ÿÿÿÿÿÿ, " ê€:ÿÿÿÿÿÿ6 dN€;ÿÿÿÿÿÿ@ 6 B€<ÿÿÿÿÿÿJ @ 6€=ÿÿÿÿÿÿT J * €>ÿÿÿÿÿÿ^ , T €?ÿÿÿÿÿÿh  ^ €@ÿÿÿÿÿÿr xÒ€Aÿÿÿÿÿÿ| r 6€Bÿÿÿÿÿÿ† | š€Cÿÿÿÿÿÿ † þ€Dÿÿÿÿÿÿš xb€Eÿÿÿÿÿÿ¤ š V€Fÿÿÿÿÿÿ® ¤ J€Gÿÿÿÿÿÿ¸ ® > €Hÿÿÿÿÿÿ ¸ €IÿÿÿÿÿÿÌ h  €JÿÿÿÿÿÿÖ v€Kÿÿÿÿÿÿà Ö Ú€Lÿÿÿÿÿÿê à >€Mÿÿÿÿÿÿô ê ¢€Nÿÿÿÿÿÿþ Œv€Oÿÿÿÿÿÿ þ j€Pÿÿÿÿÿÿ  ^€Qÿÿÿÿÿÿ  R €Rÿÿÿÿÿÿ& ô  €Sÿÿÿÿÿÿ0 &€€Tÿÿÿÿÿÿ: 0 ä€UÿÿÿÿÿÿD : H€VÿÿÿÿÿÿN D ¬€WÿÿÿÿÿÿX –€€Xÿÿÿÿÿÿb X t€Yÿÿÿÿÿÿl b h€Zÿÿÿÿÿÿv l \ €[ÿÿÿÿÿÿ€ N v €\ÿÿÿÿÿÿŠ & € €]ÿÿÿÿÿÿ” :”€^ÿÿÿÿÿÿž ” ø€_ÿÿÿÿÿÿ¨ ž \€`ÿÿÿÿÿÿ² ¨ À€aÿÿÿÿÿÿ¼ ª”€bÿÿÿÿÿÿÆ ¼ ˆ€cÿÿÿÿÿÿÐ Æ |€dÿÿÿÿÿÿÚ Ð p €eÿÿÿÿÿÿä ² Ú €fÿÿÿÿÿÿî Š ä €gÿÿÿÿÿÿø N¨€hÿÿÿÿÿÿø €iÿÿÿÿÿÿ p€jÿÿÿÿÿÿ Ô€kÿÿÿÿÿÿ ¾¨€lÿÿÿÿÿÿ* œ€mÿÿÿÿÿÿ4*€nÿÿÿÿÿÿ>4„ €oÿÿÿÿÿÿH>€pÿÿÿÿÿÿRî H€qÿÿÿÿÿÿ\b¼€rÿÿÿÿÿÿf\ €sÿÿÿÿÿÿpf„€tÿÿÿÿÿÿzpè€uÿÿÿÿÿÿ„Ò¼€vÿÿÿÿÿÿŽ„°€wÿÿÿÿÿÿ˜Ž¤€xÿÿÿÿÿÿ¢˜˜ €yÿÿÿÿÿÿ¬z¢€zÿÿÿÿÿÿ¶R¬€{ÿÿÿÿÿÿÀÌ ¶€|ÿÿÿÿÿÿÊj€}ÿÿÿÿÿÿÔÊ΀~ÿÿÿÿÿÿÞÔ2€ÿÿÿÿÿÿèÞ–€€ÿÿÿÿÿÿòðÚ€ÿÿÿÿÿÿüò΀‚ÿÿÿÿÿÿü€ƒÿÿÿÿÿÿ¶ €„ÿÿÿÿÿÿ者ÿÿÿÿÿÿ$t€†ÿÿÿÿÿÿ.$Ø€‡ÿÿÿÿÿÿ8.<€ˆÿÿÿÿÿÿB8 €‰ÿÿÿÿÿÿLú䀊ÿÿÿÿÿÿVLØ€‹ÿÿÿÿÿÿ`VÌ€Œÿÿÿÿÿÿj`À €ÿÿÿÿÿÿtBj€Žÿÿÿÿÿÿ~t€ÿÿÿÿÿÿˆ.ˆ€ÿÿÿÿÿÿ’ˆì€‘ÿÿÿÿÿÿœ’P€’ÿÿÿÿÿÿ¦œ´€“ÿÿÿÿÿÿ°ø€”ÿÿÿÿÿÿº°ì€•ÿÿÿÿÿÿÄºà€–ÿÿÿÿÿÿÎÄÔ €—ÿÿÿÿÿÿئ΀˜ÿÿÿÿÿÿâ~Ø€™ÿÿÿÿÿÿìBœ€šÿÿÿÿÿÿö쀛ÿÿÿÿÿÿöd€œÿÿÿÿÿÿ È€ÿÿÿÿÿÿ" €žÿÿÿÿÿÿ€Ÿÿÿÿÿÿÿ(ô€ ÿÿÿÿÿÿ2(è €¡ÿÿÿÿÿÿ< 2€¢ÿÿÿÿÿÿFâ<€£ÿÿÿÿÿÿPV°€¤ÿÿÿÿÿÿZP€¥ÿÿÿÿÿÿdZx€¦ÿÿÿÿÿÿndÜ€§ÿÿÿÿÿÿx6 €¨ÿÿÿÿÿÿ‚x€©ÿÿÿÿÿÿŒ‚€ªÿÿÿÿÿÿ–Œü €«ÿÿÿÿÿÿ n–€¬ÿÿÿÿÿÿªF €­ÿÿÿÿÿÿ´Àª€®ÿÿÿÿÿÿ¾^€¯ÿÿÿÿÿÿȾ€°ÿÿÿÿÿÿÒÈ&€±ÿÿÿÿÿÿÜÒŠ€²ÿÿÿÿÿÿæT>€³ÿÿÿÿÿÿðæ2€´ÿÿÿÿÿÿúð&€µÿÿÿÿÿÿú €¶ÿÿÿÿÿÿÜ€·ÿÿÿÿÿÿh€¸ÿÿÿÿÿÿ"Ì€¹ÿÿÿÿÿÿ,"0€ºÿÿÿÿÿÿ6,”€»ÿÿÿÿÿÿ@^H€¼ÿÿÿÿÿÿJ@<€½ÿÿÿÿÿÿTJ0€¾ÿÿÿÿÿÿ^T$ €¿ÿÿÿÿÿÿh6^€Àÿÿÿÿÿÿrh€Áÿÿÿÿÿÿ|"|€Âÿÿÿÿÿÿ†|à€Ãÿÿÿÿÿÿ†D€Äÿÿÿÿÿÿš¨€Åÿÿÿÿÿÿ¤r\€Æÿÿÿÿÿÿ®¤P€Çÿÿÿÿÿÿ¸®D€Èÿÿÿÿÿÿ¸8 €Éÿÿÿÿÿÿ̚€ÊÿÿÿÿÿÿÖrÌ€Ëÿÿÿÿÿÿà6€Ìÿÿÿÿÿÿêàô€ÍÿÿÿÿÿÿôêX€Îÿÿÿÿÿÿþô¼€Ïÿÿÿÿÿÿ†p€Ðÿÿÿÿÿÿd€ÑÿÿÿÿÿÿX€Òÿÿÿÿÿÿ&L €Óÿÿÿÿÿÿ0þ&€Ôÿÿÿÿÿÿ:Ö0€ÕÿÿÿÿÿÿDJ¤€ÖÿÿÿÿÿÿND€×ÿÿÿÿÿÿXNl€ØÿÿÿÿÿÿbXЀÙÿÿÿÿÿÿlš„€Úÿÿÿÿÿÿvlx€Ûÿÿÿÿÿÿ€vl€ÜÿÿÿÿÿÿŠ€` €Ýÿÿÿÿÿÿ”bŠ€Þÿÿÿÿÿÿž:”€ßÿÿÿÿÿÿ¨´ž€àÿÿÿÿÿÿ²øR €áÿÿÿÿÿÿ¼²¶ €âÿÿÿÿÿÿƼ €ãÿÿÿÿÿÿÐÆ~ €äÿÿÿÿÿÿÚ¸¢€åÿÿÿÿÿÿäÚ–€æÿÿÿÿÿÿî䊀çÿÿÿÿÿÿøî~ €èÿÿÿÿÿÿÐø€éÿÿÿÿÿÿ  \ €êÿÿÿÿÿÿ À €ëÿÿÿÿÿÿ $ €ìÿÿÿÿÿÿ* ˆ €íÿÿÿÿÿÿ4¬€îÿÿÿÿÿÿ>4 €ïÿÿÿÿÿÿH>”€ðÿÿÿÿÿÿRHˆ €ñÿÿÿÿÿÿ\*R€òÿÿÿÿÿÿf\€óÿÿÿÿÿÿp p €ôÿÿÿÿÿÿzpÔ €õÿÿÿÿÿÿ„z8 €öÿÿÿÿÿÿŽ„œ €÷ÿÿÿÿÿÿ˜ÖÀ€øÿÿÿÿÿÿ¢˜´€ùÿÿÿÿÿÿ¬¢¨€úÿÿÿÿÿÿ¶¬œ €ûÿÿÿÿÿÿÀŽ¶€üÿÿÿÿÿÿÊfÀ€ýÿÿÿÿÿÿÔ* „ €þÿÿÿÿÿÿÞÔè €ÿÿÿÿÿÿÿèÞL €ÿÿÿÿÿÿòè° €ÿÿÿÿÿÿüêÔ€ÿÿÿÿÿÿüÈ€ÿÿÿÿÿÿ¼€ÿÿÿÿÿÿ° €ÿÿÿÿÿÿ$ò€ÿÿÿÿÿÿ.Ê$€ÿÿÿÿÿÿ8> ˜ €ÿÿÿÿÿÿB8ü € ÿÿÿÿÿÿLB` € ÿÿÿÿÿÿVLÄ € ÿÿÿÿÿÿ`þè€ ÿÿÿÿÿÿj`Ü€ ÿÿÿÿÿÿtjЀÿÿÿÿÿÿ~tÄ €ÿÿÿÿÿÿˆV~€ÿÿÿÿÿÿ’.ˆ€ÿÿÿÿÿÿœ¨’@ÿÿÿÿÿÿ¦2@ÿÿÿÿÿÿ¯v€ÿÿÿÿÿÿ¸¦¯@ÿÿÿÿÿÿÂ΀ÿÿÿÿÿÿ˸Â@ÿÿÿÿÿÿÕ&€ÿÿÿÿÿÿÞËÕ@ÿÿÿÿÿÿè~ €ÿÿÿÿÿÿñÞè@ÿÿÿÿÿÿû<@ÿÿÿÿÿÿ€€ÿÿÿÿÿÿ û@ÿÿÿÿÿÿØ€ÿÿÿÿÿÿ  @ ÿÿÿÿÿÿ*0€!ÿÿÿÿÿÿ3 *@"ÿÿÿÿÿÿ=ˆ €#ÿÿÿÿÿÿF3=€$ÿÿÿÿÿÿPñF@%ÿÿÿÿÿÿZP@&ÿÿÿÿÿÿc”€'ÿÿÿÿÿÿlZc@(ÿÿÿÿÿÿvì€)ÿÿÿÿÿÿlv@*ÿÿÿÿÿÿ‰D€+ÿÿÿÿÿÿ’‰@,ÿÿÿÿÿÿœœ €-ÿÿÿÿÿÿ¥’œ€.ÿÿÿÿÿÿ¯P¥@/ÿÿÿÿÿÿ¹d@0ÿÿÿÿÿÿ¨€1ÿÿÿÿÿÿ˹Â@2ÿÿÿÿÿÿÕ€3ÿÿÿÿÿÿÞËÕ@4ÿÿÿÿÿÿèX€5ÿÿÿÿÿÿñÞè@6ÿÿÿÿÿÿû° €7ÿÿÿÿÿÿñû€8ÿÿÿÿÿÿ¯@9ÿÿÿÿÿÿx@:ÿÿÿÿÿÿ!¼€;ÿÿÿÿÿÿ*!@<ÿÿÿÿÿÿ4€=ÿÿÿÿÿÿ=*4@>ÿÿÿÿÿÿGl€?ÿÿÿÿÿÿP=G@@ÿÿÿÿÿÿZÄ €AÿÿÿÿÿÿcPZ€Bÿÿÿÿÿÿmc@CÿÿÿÿÿÿwŒ@Dÿÿÿÿÿÿ€@Eÿÿÿÿÿÿ‰ð@Fÿÿÿÿÿÿ’@Gÿÿÿÿÿÿ›T@Hÿÿÿÿÿÿ¤@Iÿÿÿÿÿÿ­¸@Jÿÿÿÿÿÿ¶ø@Kÿÿÿÿÿÿ¿Ú@LÿÿÿÿÿÿÈj@MÿÿÿÿÿÿÑ>@NÿÿÿÿÿÿÚ^@Oÿÿÿÿÿÿã¢@PÿÿÿÿÿÿìR @Qÿÿÿÿÿÿõ2@RÿÿÿÿÿÿþÂ@Sÿÿÿÿÿÿ–@Tÿÿÿÿÿÿ¶ @UÿÿÿÿÿÿŠ@Vÿÿÿÿÿÿ" @Wÿÿÿÿÿÿ+–@Xÿÿÿÿÿÿ4&@Yÿÿÿÿÿÿ=ú@ZÿÿÿÿÿÿF@[ÿÿÿÿÿÿO^@\ÿÿÿÿÿÿX@]ÿÿÿÿÿÿaÂ@^ÿÿÿÿÿÿj @_ÿÿÿÿÿÿsä@`ÿÿÿÿÿÿ|t@aÿÿÿÿÿÿ…H@bÿÿÿÿÿÿŽh@cÿÿÿÿÿÿ—¬@dÿÿÿÿÿÿ \ @eÿÿÿÿÿÿ©<@fÿÿÿÿÿÿ²Ì@gÿÿÿÿÿÿ» @hÿÿÿÿÿÿÄÀ @iÿÿÿÿÿÿÍ”@jÿÿÿÿÿÿÖ$ @kÿÿÿÿÿÿߪ@lÿÿÿÿÿÿè:@mÿÿÿÿÿÿñ@nÿÿÿÿÿÿú.@oÿÿÿÿÿÿr@pÿÿÿÿÿÿ "@qÿÿÿÿÿÿÖ@rÿÿÿÿÿÿ @sÿÿÿÿÿÿ'ø@tÿÿÿÿÿÿ0ˆ@uÿÿÿÿÿÿ9\@vÿÿÿÿÿÿB|@wÿÿÿÿÿÿKÀ@xÿÿÿÿÿÿTp @yÿÿÿÿÿÿ]P@zÿÿÿÿÿÿfà@{ÿÿÿÿÿÿo´@|ÿÿÿÿÿÿxÔ @}ÿÿÿÿÿÿ¨@~ÿÿÿÿÿÿŠ8 @ÿÿÿÿÿÿ“¾@€ÿÿÿÿÿÿœN@ÿÿÿÿÿÿ¥"@‚ÿÿÿÿÿÿ®B@ƒÿÿÿÿÿÿ·†@„ÿÿÿÿÿÿÀ6@…ÿÿÿÿÿÿÉê@†ÿÿÿÿÿÿÒ* @‡ÿÿÿÿÿÿÛ @ˆÿÿÿÿÿÿäœ@‰ÿÿÿÿÿÿíp@Šÿÿÿÿÿÿö@‹ÿÿÿÿÿÿÿÔ@Œÿÿÿÿÿÿ„ @ÿÿÿÿÿÿd@Žÿÿÿÿÿÿô@ÿÿÿÿÿÿ#È@ÿÿÿÿÿÿ,è @‘ÿÿÿÿÿÿ5¼@’ÿÿÿÿÿÿ>L @“ÿÿÿÿÿÿGÒ@”ÿÿÿÿÿÿPb@•ÿÿÿÿÿÿY6@–ÿÿÿÿÿÿbV@—ÿÿÿÿÿÿkš@˜ÿÿÿÿÿÿtJ@™ÿÿÿÿÿÿ}þ@šÿÿÿÿÿÿ†> @›ÿÿÿÿÿÿ @œÿÿÿÿÿÿ˜°@ÿÿÿÿÿÿ¡„@žÿÿÿÿÿÿª¤@Ÿÿÿÿÿÿÿ³è@ ÿÿÿÿÿÿ¼˜ @¡ÿÿÿÿÿÿÅx@¢ÿÿÿÿÿÿÎ@£ÿÿÿÿÿÿ×Ü@¤ÿÿÿÿÿÿàü @¥ÿÿÿÿÿÿéÐ@¦ÿÿÿÿÿÿò` €§ÿÿÿÿÿÿûw€€¨ÿÿÿÿÿÿ¦û€©ÿÿÿÿÿÿ‰’€ªÿÿÿÿÿÿ€«ÿÿÿÿÿÿ#›¤€¬ÿÿÿÿÿÿ-#€­ÿÿÿÿÿÿ7­¶€®ÿÿÿÿÿÿA-7€¯ÿÿÿÿÿÿK€w€°ÿÿÿÿÿÿUK¯€±ÿÿÿÿÿÿ_¿È€²ÿÿÿÿÿÿiU_€³ÿÿÿÿÿÿsÑÚ€´ÿÿÿÿÿÿ}is€µÿÿÿÿÿÿ‡ã쀶ÿÿÿÿÿÿ‘}‡€·ÿÿÿÿÿÿ›A‘€¸ÿÿÿÿÿÿ¥’‰€¹ÿÿÿÿÿÿ¯È¿€ºÿÿÿÿÿÿ¹¥¯€»ÿÿÿÿÿÿù€¼ÿÿÿÿÿÿÍõþ€½ÿÿÿÿÿÿ×ÃÍ€¾ÿÿÿÿÿÿဿÿÿÿÿÿÿë×á€Àÿÿÿÿÿÿõ›ë€Áÿÿÿÿÿÿÿ¤›€Âÿÿÿÿÿÿ ÚÑ€Ãÿÿÿÿÿÿÿ €Äÿÿÿÿÿÿþõ€Åÿÿÿÿÿÿ'€Æÿÿÿÿÿÿ1'Õ€Çÿÿÿÿÿÿ;"€ÈÿÿÿÿÿÿE1;€ÉÿÿÿÿÿÿOõE€ÊÿÿÿÿÿÿY¶­€Ëÿÿÿÿÿÿcìã€ÌÿÿÿÿÿÿmYc€Íÿÿÿÿÿÿw€Îÿÿÿÿÿÿmw€Ïÿÿÿÿÿÿ‹"€Ðÿÿÿÿÿÿ•‹€ÑÿÿÿÿÿÿŸ•è€Òÿÿÿÿÿÿ©OŸ€Óÿÿÿÿÿÿ³+4€Ôÿÿÿÿÿÿ½û³€ÕÿÿÿÿÿÿÇ=F€Öÿÿÿÿÿÿѽǀ×ÿÿÿÿÿÿÛOX€ØÿÿÿÿÿÿåÑÛ€Ùÿÿÿÿÿÿïaj€Úÿÿÿÿÿÿùåï€Ûÿÿÿÿÿÿ4+€Üÿÿÿÿÿÿ €Ýÿÿÿÿÿÿs|€Þÿÿÿÿÿÿ! €ßÿÿÿÿÿÿ+…Ž€àÿÿÿÿÿÿ5!+€áÿÿÿÿÿÿ?— €âÿÿÿÿÿÿI5?€ãÿÿÿÿÿÿSùI€äÿÿÿÿÿÿ]F=€åÿÿÿÿÿÿg|s€æÿÿÿÿÿÿq]g€çÿÿÿÿÿÿ{q€èÿÿÿÿÿÿ…©²€éÿÿÿÿÿÿ{…€êÿÿÿÿÿÿ™»Ä€ëÿÿÿÿÿÿ£™€ìÿÿÿÿÿÿ­S£€íÿÿÿÿÿÿ·XO€îÿÿÿÿÿÿÁŽ…€ïÿÿÿÿÿÿË·Á€ðÿÿÿÿÿÿÕ²©€ñÿÿÿÿÿÿßËÕ€òÿÿÿÿÿÿéß*€óÿÿÿÿÿÿóÍÖ€ôÿÿÿÿÿÿýéó€õÿÿÿÿÿÿ­ý€öÿÿÿÿÿÿja€÷ÿÿÿÿÿÿ —€øÿÿÿÿÿÿ%€ùÿÿÿÿÿÿ/Ä»€úÿÿÿÿÿÿ9%/€ûÿÿÿÿÿÿCÖÍ€üÿÿÿÿÿÿM9C€ýÿÿÿÿÿÿWM=€þÿÿÿÿÿÿaW€ÿÿÿÿÿÿÿk©a€ÿÿÿÿÿÿußè€ÿÿÿÿÿÿZu€ÿÿÿÿÿÿ‰ñú€ÿÿÿÿÿÿ“‰€ÿÿÿÿÿÿ €ÿÿÿÿÿÿ§“€ÿÿÿÿÿÿ±€ÿÿÿÿÿÿ»§±€ÿÿÿÿÿÿÅè߀ ÿÿÿÿÿÿÏÅc€ ÿÿÿÿÿÿÙ'0€ ÿÿÿÿÿÿãÏÙ€ ÿÿÿÿÿÿí9B€ ÿÿÿÿÿÿ÷ãí€ÿÿÿÿÿÿKT€ÿÿÿÿÿÿ ÷€ÿÿÿÿÿÿ» €ÿÿÿÿÿÿúñ€ÿÿÿÿÿÿ)0'€ÿÿÿÿÿÿ3)€ÿÿÿÿÿÿ=3v€ÿÿÿÿÿÿG]f€ÿÿÿÿÿÿQ=G€ÿÿÿÿÿÿ[ox€ÿÿÿÿÿÿeQ[€ÿÿÿÿÿÿoe€ÿÿÿÿÿÿy €ÿÿÿÿÿÿƒB9€ÿÿÿÿÿÿyƒ€ÿÿÿÿÿÿ—f]€ÿÿÿÿÿÿ¡—€ÿÿÿÿÿÿ«¡‰€ ÿÿÿÿÿÿµŠ€!ÿÿÿÿÿÿ¿«µ€"ÿÿÿÿÿÿÉo¿€#ÿÿÿÿÿÿÓ€$ÿÿÿÿÿÿÝTK€%ÿÿÿÿÿÿçÓÝ€&ÿÿÿÿÿÿñxo€'ÿÿÿÿÿÿûçñ€(ÿÿÿÿÿÿŠ€)ÿÿÿÿÿÿû€*ÿÿÿÿÿÿœ€+ÿÿÿÿÿÿ#É€,ÿÿÿÿÿÿ-k#€-ÿÿÿÿÿÿ7“œ€.ÿÿÿÿÿÿA¹7€/ÿÿÿÿÿÿK¥®€0ÿÿÿÿÿÿUAK€1ÿÿÿÿÿÿ_·À€2ÿÿÿÿÿÿiU_€3ÿÿÿÿÿÿsÉÒ€4ÿÿÿÿÿÿ}is€5ÿÿÿÿÿÿ‡œ“€6ÿÿÿÿÿÿ‘‡Â€7ÿÿÿÿÿÿ›Ûä€8ÿÿÿÿÿÿ¥‘›€9ÿÿÿÿÿÿ¯íö€:ÿÿÿÿÿÿ¹¥¯€;ÿÿÿÿÿÿÃÿ€<ÿÿÿÿÿÿ͹À=ÿÿÿÿÿÿ×}Í€>ÿÿÿÿÿÿᮥ€?ÿÿÿÿÿÿëäÛ€@ÿÿÿÿÿÿõáë€AÿÿÿÿÿÿÿõÕ€Bÿÿÿÿÿÿ €Cÿÿÿÿÿÿ ÿ €Dÿÿÿÿÿÿ #,€Eÿÿÿÿÿÿ'   €Fÿÿÿÿÿÿ1 ×' €Gÿÿÿÿÿÿ; À·€HÿÿÿÿÿÿE öí€IÿÿÿÿÿÿO ; E €JÿÿÿÿÿÿY €Kÿÿÿÿÿÿc O Y €Lÿÿÿÿÿÿm c è€Mÿÿÿÿÿÿw 5>€Nÿÿÿÿÿÿ m w €Oÿÿÿÿÿÿ‹ 1 €Pÿÿÿÿÿÿ• ÒÉ€QÿÿÿÿÿÿŸ ÿ€Rÿÿÿÿÿÿ© • Ÿ €Sÿÿÿÿÿÿ³ ,#€Tÿÿÿÿÿÿ½ © ³ €UÿÿÿÿÿÿÇ >5€VÿÿÿÿÿÿÑ ½ Ç €WÿÿÿÿÿÿÛ Ñ û€Xÿÿÿÿÿÿå ‹ Û €Yÿÿÿÿÿÿï -å €Zÿÿÿÿÿÿù GP€[ÿÿÿÿÿÿ!ù €\ÿÿÿÿÿÿ !Yb€]ÿÿÿÿÿÿ!! !€^ÿÿÿÿÿÿ!!kt€_ÿÿÿÿÿÿ+!!!!€`ÿÿÿÿÿÿ5!}†€aÿÿÿÿÿÿ?!+!5!€bÿÿÿÿÿÿI!PG€cÿÿÿÿÿÿS!I!!€dÿÿÿÿÿÿ]!˜€eÿÿÿÿÿÿg!S!]!€fÿÿÿÿÿÿq!¡ª€gÿÿÿÿÿÿ{!g!q!€hÿÿÿÿÿÿ…!³¼€iÿÿÿÿÿÿ!{!…!€jÿÿÿÿÿÿ™!?!!€kÿÿÿÿÿÿ£!bY€lÿÿÿÿÿÿ­!˜€mÿÿÿÿÿÿ·!£!­!€nÿÿÿÿÿÿÁ!·!4€oÿÿÿÿÿÿË!Å΀pÿÿÿÿÿÿÕ!Á!Ë!€qÿÿÿÿÿÿß!×à€rÿÿÿÿÿÿé!Õ!ß!€sÿÿÿÿÿÿó!™!é!€tÿÿÿÿÿÿý!tk€uÿÿÿÿÿÿ"ª¡€vÿÿÿÿÿÿ"ý!"€wÿÿÿÿÿÿ"ÎÅ€xÿÿÿÿÿÿ%"""€yÿÿÿÿÿÿ/"%"G€zÿÿÿÿÿÿ9"éò€{ÿÿÿÿÿÿC"/"9"€|ÿÿÿÿÿÿM"ó!C"€}ÿÿÿÿÿÿW"†}€~ÿÿÿÿÿÿa"¼³€ÿÿÿÿÿÿk"W"a"€€ÿÿÿÿÿÿu"à×€ÿÿÿÿÿÿ"k"u"€‚ÿÿÿÿÿÿ‰"ò逃ÿÿÿÿÿÿ“""‰"€„ÿÿÿÿÿÿ"“"Z€…ÿÿÿÿÿÿ§"M""€†ÿÿÿÿÿÿ±"ï §"€‡ÿÿÿÿÿÿ»"2€€ˆÿÿÿÿÿÿÅ"»"쀉ÿÿÿÿÿÿÏ"Å"X€ŠÿÿÿÿÿÿÙ"Ï"Ä €‹Sÿÿÿÿÿÿã"€Œ>ÿÿÿÿÿÿí"ã"@ÿÿÿÿÿÿ÷"í"€ŽSÿÿÿÿÿÿ#j€>ÿÿÿÿÿÿ #"#@ÿÿÿÿÿÿ# #€‘ÿÿÿÿÿÿ#÷"#€’Sÿÿÿÿÿÿ'#œ€“>ÿÿÿÿÿÿ1#4'#@”ÿÿÿÿÿÿ;#1#€•ÿÿÿÿÿÿD##;#€–SÿÿÿÿÿÿN#΀—>ÿÿÿÿÿÿX#FN#@˜ÿÿÿÿÿÿb#X#€™ÿÿÿÿÿÿk#D#b#€šSÿÿÿÿÿÿu#€›>ÿÿÿÿÿÿ#Xu#@œÿÿÿÿÿÿ‰##€ÿÿÿÿÿÿ’#k#‰#€žSÿÿÿÿÿÿœ#*"€Ÿ>ÿÿÿÿÿÿ¦#œ#@ ÿÿÿÿÿÿ°#¦#€¡Sÿÿÿÿÿÿ¹#t"€¢>ÿÿÿÿÿÿÃ#"¹#@£ÿÿÿÿÿÿÍ#Ã#€¤ÿÿÿÿÿÿÖ#°#Í#€¥Sÿÿÿÿÿÿà#¦"€¦>ÿÿÿÿÿÿê#4à#@§ÿÿÿÿÿÿô#ê#€¨ÿÿÿÿÿÿý#Ö#ô#€©Sÿÿÿÿÿÿ$Ø"€ª>ÿÿÿÿÿÿ$F$@«ÿÿÿÿÿÿ$$€¬ÿÿÿÿÿÿ$$ý#$€­Sÿÿÿÿÿÿ.$ "€®>ÿÿÿÿÿÿ8$X.$@¯ÿÿÿÿÿÿB$8$€°ÿÿÿÿÿÿK$$$B$€±ÿÿÿÿÿÿU$’#K$€²Sÿÿÿÿÿÿ_$<4€³>ÿÿÿÿÿÿi$_$@´ÿÿÿÿÿÿs$i$€µSÿÿÿÿÿÿ|$~4€¶>ÿÿÿÿÿÿ†$"|$@·ÿÿÿÿÿÿ$†$€¸ÿÿÿÿÿÿ™$s$$€¹Sÿÿÿÿÿÿ£$°4€º>ÿÿÿÿÿÿ­$4£$@»ÿÿÿÿÿÿ·$­$€¼ÿÿÿÿÿÿÀ$™$·$€½SÿÿÿÿÿÿÊ$â4€¾>ÿÿÿÿÿÿÔ$FÊ$@¿ÿÿÿÿÿÿÞ$Ô$€Àÿÿÿÿÿÿç$À$Þ$€ÁSÿÿÿÿÿÿñ$4€Â>ÿÿÿÿÿÿû$Xñ$@Ãÿÿÿÿÿÿ%û$€Äÿÿÿÿÿÿ%ç$%€Åÿÿÿÿÿÿ%U$%€ÆSÿÿÿÿÿÿ"%NF€Ç>ÿÿÿÿÿÿ,%"%@Èÿÿÿÿÿÿ6%,%€ÉSÿÿÿÿÿÿ?%ˆF€Ê>ÿÿÿÿÿÿI%"?%@ËÿÿÿÿÿÿS%I%€Ìÿÿÿÿÿÿ\%6%S%€ÍSÿÿÿÿÿÿf%ºF€Î>ÿÿÿÿÿÿp%4f%@Ïÿÿÿÿÿÿz%p%€Ðÿÿÿÿÿÿƒ%\%z%€ÑSÿÿÿÿÿÿ%ìF€Ò>ÿÿÿÿÿÿ—%F%@Óÿÿÿÿÿÿ¡%—%€Ôÿÿÿÿÿÿª%ƒ%¡%€ÕSÿÿÿÿÿÿ´%F€Ö>ÿÿÿÿÿÿ¾%X´%@×ÿÿÿÿÿÿÈ%¾%€ØÿÿÿÿÿÿÑ%ª%È%€ÙÿÿÿÿÿÿÛ%%Ñ%€ÚSÿÿÿÿÿÿå%`X€Û>ÿÿÿÿÿÿï%å%@Üÿÿÿÿÿÿù%ï%€ÝSÿÿÿÿÿÿ&’X€Þ>ÿÿÿÿÿÿ &"&@ßÿÿÿÿÿÿ& &€àÿÿÿÿÿÿ&ù%&€áSÿÿÿÿÿÿ)&ÄX€â>ÿÿÿÿÿÿ3&4)&@ãÿÿÿÿÿÿ=&3&€äÿÿÿÿÿÿF&&=&€åSÿÿÿÿÿÿP&öX€æ>ÿÿÿÿÿÿZ&FP&@çÿÿÿÿÿÿd&Z&€èÿÿÿÿÿÿm&F&d&€éSÿÿÿÿÿÿw&(X€ê>ÿÿÿÿÿÿ&Xw&@ëÿÿÿÿÿÿ‹&&€ìÿÿÿÿÿÿ”&m&‹&€íÿÿÿÿÿÿž&Û%”&€îSÿÿÿÿÿÿ¨&*€ï>ÿÿÿÿÿÿ²&"¨&@ðÿÿÿÿÿÿ¼&²&€ñÿÿÿÿÿÿÅ&÷"¼&€òSÿÿÿÿÿÿÏ&<€ó>ÿÿÿÿÿÿÙ&4Ï&@ôÿÿÿÿÿÿã&Ù&€õÿÿÿÿÿÿì&Å&ã&€öSÿÿÿÿÿÿö&N€÷>ÿÿÿÿÿÿ'Fö&@øÿÿÿÿÿÿ ''€ùÿÿÿÿÿÿ'ì& '€úSÿÿÿÿÿÿ'`€û>ÿÿÿÿÿÿ''X'@üÿÿÿÿÿÿ1'''€ýÿÿÿÿÿÿ:''1'€þSÿÿÿÿÿÿD'j"€ÿ>ÿÿÿÿÿÿN'D'@ÿÿÿÿÿÿX'N'€ÿÿÿÿÿÿa'X'Í#€Sÿÿÿÿÿÿk'~"€>ÿÿÿÿÿÿu'4k'@ÿÿÿÿÿÿ'u'€ÿÿÿÿÿÿˆ'a''€Sÿÿÿÿÿÿ’'ˆ"€>ÿÿÿÿÿÿœ'F’'@ÿÿÿÿÿÿ¦'œ'€ ÿÿÿÿÿÿ¯'ˆ'¦'€ Sÿÿÿÿÿÿ¹'’"€ >ÿÿÿÿÿÿÃ'X¹'@ ÿÿÿÿÿÿÍ'Ã'€ ÿÿÿÿÿÿÖ'¯'Í'€ÿÿÿÿÿÿà':'Ö'€Sÿÿÿÿÿÿê'œ4€>ÿÿÿÿÿÿô'ê'@ÿÿÿÿÿÿþ'ô'€Sÿÿÿÿÿÿ(¦4€>ÿÿÿÿÿÿ("(@ÿÿÿÿÿÿ((€ÿÿÿÿÿÿ$(þ'(€ÿÿÿÿÿÿ.($(·$€Sÿÿÿÿÿÿ8(º4€>ÿÿÿÿÿÿB(F8(@ÿÿÿÿÿÿL(B(€ÿÿÿÿÿÿU(.(L(€Sÿÿÿÿÿÿ_(Ä4€>ÿÿÿÿÿÿi(X_(@ÿÿÿÿÿÿs(i(€ÿÿÿÿÿÿ|(U(s(€ÿÿÿÿÿÿ†(à'|(€ Sÿÿÿÿÿÿ(ÎF€!>ÿÿÿÿÿÿš((@"ÿÿÿÿÿÿ¤(š(€#Sÿÿÿÿÿÿ­(ØF€$>ÿÿÿÿÿÿ·("­(@%ÿÿÿÿÿÿÁ(·(€&ÿÿÿÿÿÿÊ(¤(Á(€'SÿÿÿÿÿÿÔ(âF€(>ÿÿÿÿÿÿÞ(4Ô(@)ÿÿÿÿÿÿè(Þ(€*ÿÿÿÿÿÿñ(Ê(è(€+ÿÿÿÿÿÿû(ñ(¡%€,Sÿÿÿÿÿÿ)öF€->ÿÿÿÿÿÿ)X)@.ÿÿÿÿÿÿ))€/ÿÿÿÿÿÿ")û()€0ÿÿÿÿÿÿ,)†(")€1Sÿÿÿÿÿÿ6)X€2>ÿÿÿÿÿÿ@)6)@3ÿÿÿÿÿÿJ)@)€4SÿÿÿÿÿÿS) X€5>ÿÿÿÿÿÿ])"S)@6ÿÿÿÿÿÿg)])€7ÿÿÿÿÿÿp)J)g)€8Sÿÿÿÿÿÿz)X€9>ÿÿÿÿÿÿ„)4z)@:ÿÿÿÿÿÿŽ)„)€;ÿÿÿÿÿÿ—)p)Ž)€<Sÿÿÿÿÿÿ¡)X€=>ÿÿÿÿÿÿ«)F¡)@>ÿÿÿÿÿÿµ)«)€?ÿÿÿÿÿÿ¾)—)µ)€@ÿÿÿÿÿÿÈ)¾)‹&€AÿÿÿÿÿÿÒ),)È)€BÿÿÿÿÿÿÜ)í" #€Cÿÿÿÿÿÿæ)Ü)1#€Dÿÿÿÿÿÿð)æ)X#€Eÿÿÿÿÿÿú)ð)#€Fÿÿÿÿÿÿ*¦#Ã#€Gÿÿÿÿÿÿ**ê#€Hÿÿÿÿÿÿ**$€Iÿÿÿÿÿÿ"**8$€Jÿÿÿÿÿÿ,*ú)"*€Kÿÿÿÿÿÿ6*i$†$€Lÿÿÿÿÿÿ@*6*­$€MÿÿÿÿÿÿJ*@*Ô$€NÿÿÿÿÿÿT*J*û$€Oÿÿÿÿÿÿ^*,*T*€Pÿÿÿÿÿÿh*,%I%€Qÿÿÿÿÿÿr*h*p%€Rÿÿÿÿÿÿ|*r*—%€Sÿÿÿÿÿÿ†*|*¾%€Tÿÿÿÿÿÿ*^*†*€Uÿÿÿÿÿÿš*ï% &€Vÿÿÿÿÿÿ¤*š*3&€Wÿÿÿÿÿÿ®*¤*Z&€Xÿÿÿÿÿÿ¸*®*&€YÿÿÿÿÿÿÂ**¸*€ZÿÿÿÿÿÿÌ*2ñ€[ÿÿÿÿÿÿÖ*ŒF€\ÿÿÿÿÿÿà*Ì*Ö*€]ÿÿÿÿÿÿê*ð¥€^ÿÿÿÿÿÿô*à*ê*€_ÿÿÿÿÿÿþ*T€`ÿÿÿÿÿÿ+ô*þ*€aÿÿÿÿÿÿ+¸c€bÿÿÿÿÿÿ+++€cÿÿÿÿÿÿ&+&ñ€dÿÿÿÿÿÿ0+€F€eÿÿÿÿÿÿ:+&+0+€fÿÿÿÿÿÿD+䥀gÿÿÿÿÿÿN+:+D+€hÿÿÿÿÿÿX+H€iÿÿÿÿÿÿb+N+X+€jÿÿÿÿÿÿl+¬c€kÿÿÿÿÿÿv+b+l+€lÿÿÿÿÿÿ€++v+€mÿÿÿÿÿÿŠ+.ñ€nÿÿÿÿÿÿ”+ˆF€oÿÿÿÿÿÿž+Š+”+€pÿÿÿÿÿÿ¨+쥀qÿÿÿÿÿÿ²+ž+¨+€rÿÿÿÿÿÿ¼+P€sÿÿÿÿÿÿÆ+²+¼+€tÿÿÿÿÿÿÐ+´c€uÿÿÿÿÿÿÚ+Æ+Ð+€vÿÿÿÿÿÿä+€+Ú+€wÿÿÿÿÿÿî+6ñ€xÿÿÿÿÿÿø+F€yÿÿÿÿÿÿ,î+ø+€zÿÿÿÿÿÿ ,ô¥€{ÿÿÿÿÿÿ,, ,€|ÿÿÿÿÿÿ ,X€}ÿÿÿÿÿÿ*,, ,€~ÿÿÿÿÿÿ4,¼c€ÿÿÿÿÿÿ>,*,4,€€ÿÿÿÿÿÿH,ä+>,€ÿÿÿÿÿÿR,> ñ€‚ÿÿÿÿÿÿ\,˜ F€ƒÿÿÿÿÿÿf,R,\,€„ÿÿÿÿÿÿp,ü ¥€…ÿÿÿÿÿÿz,f,p,€†ÿÿÿÿÿÿ„,` €‡ÿÿÿÿÿÿŽ,z,„,€ˆÿÿÿÿÿÿ˜,Ä c€‰ÿÿÿÿÿÿ¢,Ž,˜,€Šÿÿÿÿÿÿ¬,H,¢,€‹Sÿÿÿÿÿÿ¶,€Œ>ÿÿÿÿÿÿÀ,¶,@ÿÿÿÿÿÿÊ,À,€ŽSÿÿÿÿÿÿÓ,**€>ÿÿÿÿÿÿÝ,"Ó,@ÿÿÿÿÿÿç,Ý,€‘ÿÿÿÿÿÿð,Ê,ç,€’Sÿÿÿÿÿÿú,<<€“>ÿÿÿÿÿÿ-4ú,@”ÿÿÿÿÿÿ--€•ÿÿÿÿÿÿ-ð,-€–Sÿÿÿÿÿÿ!-NN€—>ÿÿÿÿÿÿ+-F!-@˜ÿÿÿÿÿÿ5-+-€™ÿÿÿÿÿÿ>--5-€šSÿÿÿÿÿÿH-``€›>ÿÿÿÿÿÿR-XH-@œÿÿÿÿÿÿ\-R-€ÿÿÿÿÿÿe->-\-€žSÿÿÿÿÿÿo-jj€Ÿ>ÿÿÿÿÿÿy-o-@ ÿÿÿÿÿÿƒ-y-€¡SÿÿÿÿÿÿŒ-tt€¢>ÿÿÿÿÿÿ–-"Œ-@£ÿÿÿÿÿÿ -–-€¤ÿÿÿÿÿÿ©-ƒ- -€¥Sÿÿÿÿÿÿ³-~~€¦>ÿÿÿÿÿÿ½-4³-@§ÿÿÿÿÿÿÇ-½-€¨ÿÿÿÿÿÿÐ-©-Ç-€©SÿÿÿÿÿÿÚ-ˆˆ€ª>ÿÿÿÿÿÿä-FÚ-@«ÿÿÿÿÿÿî-ä-€¬ÿÿÿÿÿÿ÷-Ð-î-€­Sÿÿÿÿÿÿ.’’€®>ÿÿÿÿÿÿ .X.@¯ÿÿÿÿÿÿ. .€°ÿÿÿÿÿÿ.÷-.€±ÿÿÿÿÿÿ(.e-.€²Sÿÿÿÿÿÿ2.œœ€³>ÿÿÿÿÿÿ<.2.@´ÿÿÿÿÿÿF.<.€µSÿÿÿÿÿÿO.¦¦€¶>ÿÿÿÿÿÿY."O.@·ÿÿÿÿÿÿc.Y.€¸ÿÿÿÿÿÿl.F.c.€¹Sÿÿÿÿÿÿv.°°€º>ÿÿÿÿÿÿ€.4v.@»ÿÿÿÿÿÿŠ.€.€¼ÿÿÿÿÿÿ“.l.Š.€½Sÿÿÿÿÿÿ.ºº€¾>ÿÿÿÿÿÿ§.F.@¿ÿÿÿÿÿÿ±.§.€Àÿÿÿÿÿÿº.“.±.€ÁSÿÿÿÿÿÿÄ.ÄÄ€Â>ÿÿÿÿÿÿÎ.XÄ.@ÃÿÿÿÿÿÿØ.Î.€Äÿÿÿÿÿÿá.º.Ø.€Åÿÿÿÿÿÿë.(.á.€ÆSÿÿÿÿÿÿõ.Î΀Ç>ÿÿÿÿÿÿÿ.õ.@Èÿÿÿÿÿÿ /ÿ.€ÉSÿÿÿÿÿÿ/ØØ€Ê>ÿÿÿÿÿÿ/"/@Ëÿÿÿÿÿÿ&//€Ìÿÿÿÿÿÿ// /&/€ÍSÿÿÿÿÿÿ9/ââ€Î>ÿÿÿÿÿÿC/49/@ÏÿÿÿÿÿÿM/C/€ÐÿÿÿÿÿÿV///M/€ÑSÿÿÿÿÿÿ`/ìì€Ò>ÿÿÿÿÿÿj/F`/@Óÿÿÿÿÿÿt/j/€Ôÿÿÿÿÿÿ}/V/t/€ÕSÿÿÿÿÿÿ‡/öö€Ö>ÿÿÿÿÿÿ‘/X‡/@×ÿÿÿÿÿÿ›/‘/€Øÿÿÿÿÿÿ¤/}/›/€Ùÿÿÿÿÿÿ®/ë.¤/€ÚSÿÿÿÿÿÿ¸/€Û>ÿÿÿÿÿÿÂ/¸/@ÜÿÿÿÿÿÿÌ/Â/€ÝSÿÿÿÿÿÿÕ/  €Þ>ÿÿÿÿÿÿß/"Õ/@ßÿÿÿÿÿÿé/ß/€àÿÿÿÿÿÿò/Ì/é/€áSÿÿÿÿÿÿü/€â>ÿÿÿÿÿÿ04ü/@ãÿÿÿÿÿÿ00€äÿÿÿÿÿÿ0ò/0€åSÿÿÿÿÿÿ#0€æ>ÿÿÿÿÿÿ-0F#0@çÿÿÿÿÿÿ70-0€èÿÿÿÿÿÿ@0070€éSÿÿÿÿÿÿJ0((€ê>ÿÿÿÿÿÿT0XJ0@ëÿÿÿÿÿÿ^0T0€ìÿÿÿÿÿÿg0@0^0€íÿÿÿÿÿÿq0®/g0€îSÿÿÿÿÿÿ{0€ï>ÿÿÿÿÿÿ…0{0@ðÿÿÿÿÿÿ0…0€ñSÿÿÿÿÿÿ˜0"*€ò>ÿÿÿÿÿÿ¢0˜0@óÿÿÿÿÿÿ¬0¢0€ôÿÿÿÿÿÿµ00¬0€õSÿÿÿÿÿÿ¿04<€ö>ÿÿÿÿÿÿÉ0¿0@÷ÿÿÿÿÿÿÓ0É0€øÿÿÿÿÿÿÜ0µ0Ó0€ùSÿÿÿÿÿÿæ0FN€ú>ÿÿÿÿÿÿð0æ0@ûÿÿÿÿÿÿú0ð0€üÿÿÿÿÿÿ1Ü0ú0€ýSÿÿÿÿÿÿ 1X`€þ>ÿÿÿÿÿÿ1 1@ÿÿÿÿÿÿÿ!11€ÿÿÿÿÿÿ*11!1€Sÿÿÿÿÿÿ41j€>ÿÿÿÿÿÿ>1"41@ÿÿÿÿÿÿH1>1€SÿÿÿÿÿÿQ1"t€>ÿÿÿÿÿÿ[1"Q1@ÿÿÿÿÿÿe1[1€ÿÿÿÿÿÿn1H1e1€Sÿÿÿÿÿÿx14~€ >ÿÿÿÿÿÿ‚1"x1@ ÿÿÿÿÿÿŒ1‚1€ ÿÿÿÿÿÿ•1n1Œ1€ SÿÿÿÿÿÿŸ1Fˆ€ >ÿÿÿÿÿÿ©1"Ÿ1@ÿÿÿÿÿÿ³1©1€ÿÿÿÿÿÿ¼1•1³1€SÿÿÿÿÿÿÆ1X’€>ÿÿÿÿÿÿÐ1"Æ1@ÿÿÿÿÿÿÚ1Ð1€ÿÿÿÿÿÿã1¼1Ú1€ÿÿÿÿÿÿí1*1ã1€Sÿÿÿÿÿÿ÷1œ€>ÿÿÿÿÿÿ24÷1@ÿÿÿÿÿÿ 22€Sÿÿÿÿÿÿ2"¦€>ÿÿÿÿÿÿ242@ÿÿÿÿÿÿ(22€ÿÿÿÿÿÿ12 2(2€Sÿÿÿÿÿÿ;24°€>ÿÿÿÿÿÿE24;2@ÿÿÿÿÿÿO2E2€ÿÿÿÿÿÿX212O2€ Sÿÿÿÿÿÿb2Fº€!>ÿÿÿÿÿÿl24b2@"ÿÿÿÿÿÿv2l2€#ÿÿÿÿÿÿ2X2v2€$Sÿÿÿÿÿÿ‰2XÄ€%>ÿÿÿÿÿÿ“24‰2@&ÿÿÿÿÿÿ2“2€'ÿÿÿÿÿÿ¦222€(ÿÿÿÿÿÿ°2í1¦2€)Sÿÿÿÿÿÿº2΀*>ÿÿÿÿÿÿÄ2Fº2@+ÿÿÿÿÿÿÎ2Ä2€,Sÿÿÿÿÿÿ×2"Ø€->ÿÿÿÿÿÿá2F×2@.ÿÿÿÿÿÿë2á2€/ÿÿÿÿÿÿô2Î2ë2€0Sÿÿÿÿÿÿþ24â€1>ÿÿÿÿÿÿ3Fþ2@2ÿÿÿÿÿÿ33€3ÿÿÿÿÿÿ3ô23€4Sÿÿÿÿÿÿ%3Fì€5>ÿÿÿÿÿÿ/3F%3@6ÿÿÿÿÿÿ93/3€7ÿÿÿÿÿÿB3393€8SÿÿÿÿÿÿL3Xö€9>ÿÿÿÿÿÿV3FL3@:ÿÿÿÿÿÿ`3V3€;ÿÿÿÿÿÿi3B3`3€<ÿÿÿÿÿÿs3°2i3€=Sÿÿÿÿÿÿ}3€>>ÿÿÿÿÿÿ‡3X}3@?ÿÿÿÿÿÿ‘3‡3€@Sÿÿÿÿÿÿš3" €A>ÿÿÿÿÿÿ¤3Xš3@Bÿÿÿÿÿÿ®3¤3€Cÿÿÿÿÿÿ·3‘3®3€DSÿÿÿÿÿÿÁ34€E>ÿÿÿÿÿÿË3XÁ3@FÿÿÿÿÿÿÕ3Ë3€GÿÿÿÿÿÿÞ3·3Õ3€HSÿÿÿÿÿÿè3F€I>ÿÿÿÿÿÿò3Xè3@Jÿÿÿÿÿÿü3ò3€Kÿÿÿÿÿÿ4Þ3ü3€LSÿÿÿÿÿÿ4X(€M>ÿÿÿÿÿÿ4X4@Nÿÿÿÿÿÿ#44€Oÿÿÿÿÿÿ,44#4€Pÿÿÿÿÿÿ64s3,4€Q>ÿÿÿÿÿÿ@4"o-@RÿÿÿÿÿÿJ4@4€SÿÿÿÿÿÿS4Ê,J4€T>ÿÿÿÿÿÿ]442.@Uÿÿÿÿÿÿg4]4€Vÿÿÿÿÿÿp4S4g4€W>ÿÿÿÿÿÿz4Fõ.@Xÿÿÿÿÿÿ„4z4€Yÿÿÿÿÿÿ4p4„4€Z>ÿÿÿÿÿÿ—4X¸/@[ÿÿÿÿÿÿ¡4—4€\ÿÿÿÿÿÿª44¡4€]>ÿÿÿÿÿÿ´4Ó,@^ÿÿÿÿÿÿ¾4´4€_ÿÿÿÿÿÿÇ4¾4 -€`>ÿÿÿÿÿÿÑ44O.@aÿÿÿÿÿÿÛ4Ñ4€bÿÿÿÿÿÿä4Ç4Û4€c>ÿÿÿÿÿÿî4F/@dÿÿÿÿÿÿø4î4€eÿÿÿÿÿÿ5ä4ø4€f>ÿÿÿÿÿÿ 5XÕ/@gÿÿÿÿÿÿ5 5€hÿÿÿÿÿÿ555€iÿÿÿÿÿÿ(5ª45€j>ÿÿÿÿÿÿ25ú,@kÿÿÿÿÿÿ<525€l>ÿÿÿÿÿÿE5"³-@mÿÿÿÿÿÿO5E5€nÿÿÿÿÿÿX5<5O5€oÿÿÿÿÿÿb5X5Š.€p>ÿÿÿÿÿÿl5F9/@qÿÿÿÿÿÿv5l5€rÿÿÿÿÿÿ5b5v5€s>ÿÿÿÿÿÿ‰5Xü/@tÿÿÿÿÿÿ“5‰5€uÿÿÿÿÿÿœ55“5€vÿÿÿÿÿÿ¦5(5œ5€w>ÿÿÿÿÿÿ°5!-@xÿÿÿÿÿÿº5°5€y>ÿÿÿÿÿÿÃ5"Ú-@zÿÿÿÿÿÿÍ5Ã5€{ÿÿÿÿÿÿÖ5º5Í5€|>ÿÿÿÿÿÿà54.@}ÿÿÿÿÿÿê5à5€~ÿÿÿÿÿÿó5Ö5ê5€ÿÿÿÿÿÿý5ó5t/€€>ÿÿÿÿÿÿ6X#0@ÿÿÿÿÿÿ66€‚ÿÿÿÿÿÿ6ý56€ƒÿÿÿÿÿÿ$6¦56€„>ÿÿÿÿÿÿ.6H-@…ÿÿÿÿÿÿ86.6€†>ÿÿÿÿÿÿA6".@‡ÿÿÿÿÿÿK6A6€ˆÿÿÿÿÿÿT686K6€‰>ÿÿÿÿÿÿ^64Ä.@Šÿÿÿÿÿÿh6^6€‹ÿÿÿÿÿÿq6T6h6€Œ>ÿÿÿÿÿÿ{6F‡/@ÿÿÿÿÿÿ…6{6€ŽÿÿÿÿÿÿŽ6q6…6€ÿÿÿÿÿÿ˜6Ž6^0€ÿÿÿÿÿÿ¢6$6˜6€‘ÿÿÿÿÿÿ¬6w4€’ÿÿÿÿÿÿ¶6¦¬6€“ÿÿÿÿÿÿÀ6‰ú€”ÿÿÿÿÿÿÊ6¶6À6€•ÿÿÿÿÿÿÔ6›À€–ÿÿÿÿÿÿÞ6Ê6Ô6€—ÿÿÿÿÿÿè6­†€˜ÿÿÿÿÿÿò6Þ6è6€™ÿÿÿÿÿÿü6¯€šÿÿÿÿÿÿ7Kü6€›ÿÿÿÿÿÿ7¿0€œÿÿÿÿÿÿ777€ÿÿÿÿÿÿ$7Ñö€žÿÿÿÿÿÿ.77$7€Ÿÿÿÿÿÿÿ87ã¼€ ÿÿÿÿÿÿB7.787€¡ÿÿÿÿÿÿL7ò6B7€¢ÿÿÿÿÿÿV7Ès€£ÿÿÿÿÿÿ`7¥V7€¤ÿÿÿÿÿÿj7Âv€¥ÿÿÿÿÿÿt7`7j7€¦ÿÿÿÿÿÿ~7õ€§ÿÿÿÿÿÿˆ7t7~7€¨ÿÿÿÿÿÿ’7à€©ÿÿÿÿÿÿœ7ˆ7’7€ªÿÿÿÿÿÿ¦7L7œ7€«ÿÿÿÿÿÿ°7Ú…€¬ÿÿÿÿÿÿº7ÿ°7€­ÿÿÿÿÿÿÄ7þ]€®ÿÿÿÿÿÿÎ7º7Ä7€¯ÿÿÿÿÿÿØ7Õ耰ÿÿÿÿÿÿâ7Î7Ø7€±ÿÿÿÿÿÿì7ò€²ÿÿÿÿÿÿö7â7ì7€³ÿÿÿÿÿÿ8¦7ö7€´ÿÿÿÿÿÿ 8ì—€µÿÿÿÿÿÿ8Y 8€¶ÿÿÿÿÿÿ8o€·ÿÿÿÿÿÿ(888€¸ÿÿÿÿÿÿ28"5€¹ÿÿÿÿÿÿ<8(828€ºÿÿÿÿÿÿF8èZ€»ÿÿÿÿÿÿP8<8F8€¼ÿÿÿÿÿÿZ88P8€½ÿÿÿÿÿÿd8û¦€¾ÿÿÿÿÿÿn8d8³€¿ÿÿÿÿÿÿx8=ú€Àÿÿÿÿÿÿ‚8n8x8€ÁÿÿÿÿÿÿŒ8OÀ€Âÿÿÿÿÿÿ–8‚8Œ8€Ãÿÿÿÿÿÿ 8a†€Äÿÿÿÿÿÿª8–8 8€Åÿÿÿÿÿÿ´84w€Æÿÿÿÿÿÿ¾8´8€ÇÿÿÿÿÿÿÈ8s0€ÈÿÿÿÿÿÿÒ8¾8È8€ÉÿÿÿÿÿÿÜ8…ö€Êÿÿÿÿÿÿæ8Ò8Ü8€Ëÿÿÿÿÿÿð8—¼€Ìÿÿÿÿÿÿú8æ8ð8€Íÿÿÿÿÿÿ9ª8ú8€Îÿÿÿÿÿÿ9F‰€Ïÿÿÿÿÿÿ99g€Ðÿÿÿÿÿÿ"9v€Ñÿÿÿÿÿÿ,99"9€Òÿÿÿÿÿÿ69©€Óÿÿÿÿÿÿ@9,969€ÔÿÿÿÿÿÿJ9»à€ÕÿÿÿÿÿÿT9@9J9€Öÿÿÿÿÿÿ^99T9€×ÿÿÿÿÿÿh9X›€Øÿÿÿÿÿÿr9h9Á€Ùÿÿÿÿÿÿ|9²]€Úÿÿÿÿÿÿ†9r9|9€Ûÿÿÿÿÿÿ9*è€Üÿÿÿÿÿÿš9†99€Ýÿÿÿÿÿÿ¤9Íò€Þÿÿÿÿÿÿ®9š9¤9€ßÿÿÿÿÿÿ¸9^9®9€àÿÿÿÿÿÿÂ9j­€áÿÿÿÿÿÿÌ9Â9€âÿÿÿÿÿÿÖ9Äo€ãÿÿÿÿÿÿà9Ì9Ö9€äÿÿÿÿÿÿê9Ö5€åÿÿÿÿÿÿô9à9ê9€æÿÿÿÿÿÿþ9=Z€çÿÿÿÿÿÿ:ô9þ9€èÿÿÿÿÿÿ:¸9:€éÿÿÿÿÿÿ:Z8:€êÿÿÿÿÿÿ&:Z¦€ëÿÿÿÿÿÿ0:ß4€ìÿÿÿÿÿÿ::&:0:€íÿÿÿÿÿÿD:::‰€îÿÿÿÿÿÿN:À€ïÿÿÿÿÿÿX:D:N:€ðÿÿÿÿÿÿb:†€ñÿÿÿÿÿÿl:X:b:€òÿÿÿÿÿÿv:èw€óÿÿÿÿÿÿ€:c€ôÿÿÿÿÿÿŠ:v:€:€õÿÿÿÿÿÿ”:Š:Ù€öÿÿÿÿÿÿž:9ö€÷ÿÿÿÿÿÿ¨:”:ž:€øÿÿÿÿÿÿ²:K¼€ùÿÿÿÿÿÿ¼:¨:²:€úÿÿÿÿÿÿÆ:l:¼:€ûÿÿÿÿÿÿÐ:ú‰€üÿÿÿÿÿÿÚ:0s€ýÿÿÿÿÿÿä:Ð:Ú:€þÿÿÿÿÿÿî:ä:v€ÿÿÿÿÿÿÿø:]€ÿÿÿÿÿÿ;î:ø:€ÿÿÿÿÿÿ ;oà€ÿÿÿÿÿÿ;; ;€ÿÿÿÿÿÿ ;Æ:;€ÿÿÿÿÿÿ*; ›€ÿÿÿÿÿÿ4;B…€ÿÿÿÿÿÿ>;*;4;€ÿÿÿÿÿÿH;>;—€ÿÿÿÿÿÿR;‰è€ ÿÿÿÿÿÿ\;H;R;€ ÿÿÿÿÿÿf;ò€ ÿÿÿÿÿÿp;\;f;€ ÿÿÿÿÿÿz; ;p;€ ÿÿÿÿÿÿ„;­€ÿÿÿÿÿÿŽ;T—€ÿÿÿÿÿÿ˜;„;Ž;€ÿÿÿÿÿÿ¢;˜;ñ€ÿÿÿÿÿÿ¬;Š5€ÿÿÿÿÿÿ¶;¢;¬;€ÿÿÿÿÿÿÀ;œZ€ÿÿÿÿÿÿÊ;¶;À;€ÿÿÿÿÿÿÔ;z;Ê;€ÿÿÿÿÿÿÞ;:Ô;€ÿÿÿÿÿÿè;¹¦€ÿÿÿÿÿÿò;“4€ÿÿÿÿÿÿü;è;ò;€ÿÿÿÿÿÿ<¥ú€ÿÿÿÿÿÿ<ü;<€ÿÿÿÿÿÿ<<_€ÿÿÿÿÿÿ$<Ɇ€ÿÿÿÿÿÿ.<<$<€ÿÿÿÿÿÿ8<œw€ ÿÿÿÿÿÿB<€!ÿÿÿÿÿÿL<8<B<€"ÿÿÿÿÿÿV<Û0€#ÿÿÿÿÿÿ`<L<V<€$ÿÿÿÿÿÿj<`<¯€%ÿÿÿÿÿÿt<ÿ¼€&ÿÿÿÿÿÿ~<j<t<€'ÿÿÿÿÿÿˆ<.<~<€(ÿÿÿÿÿÿ’<®‰€)ÿÿÿÿÿÿœ<äs€*ÿÿÿÿÿÿ¦<’<œ<€+ÿÿÿÿÿÿ°<Õv€,ÿÿÿÿÿÿº<¦<°<€-ÿÿÿÿÿÿÄ<º< €.ÿÿÿÿÿÿÎ<#à€/ÿÿÿÿÿÿØ<Ä<Î<€0ÿÿÿÿÿÿâ<ˆ<Ø<€1ÿÿÿÿÿÿì<À›€2ÿÿÿÿÿÿö<ö…€3ÿÿÿÿÿÿ=ì<ö<€4ÿÿÿÿÿÿ =]€5ÿÿÿÿÿÿ== =€6ÿÿÿÿÿÿ==è€7ÿÿÿÿÿÿ(=5ò€8ÿÿÿÿÿÿ2==(=€9ÿÿÿÿÿÿ<=â<2=€:ÿÿÿÿÿÿF=Ò­€;ÿÿÿÿÿÿP=—€<ÿÿÿÿÿÿZ=F=P=€=ÿÿÿÿÿÿd=,o€>ÿÿÿÿÿÿn=Z=d=€?ÿÿÿÿÿÿx=n=Ç €@ÿÿÿÿÿÿ‚=ûZ€AÿÿÿÿÿÿŒ=x=‚=€Bÿÿÿÿÿÿ–=<=Œ=€Cÿÿÿÿÿÿ =Þ;–=€Dÿÿÿÿÿÿª=¦€Eÿÿÿÿÿÿ´=G4€Fÿÿÿÿÿÿ¾=ª=´=€GÿÿÿÿÿÿÈ=Yú€HÿÿÿÿÿÿÒ=¾=È=€IÿÿÿÿÿÿÜ=kÀ€Jÿÿÿÿÿÿæ=Ò=Ü=€Kÿÿÿÿÿÿð=æ=5!€Lÿÿÿÿÿÿú=Pw€Mÿÿÿÿÿÿ>!€Nÿÿÿÿÿÿ>ú=>€Oÿÿÿÿÿÿ>0€Pÿÿÿÿÿÿ">>>€Qÿÿÿÿÿÿ,>¡ö€Rÿÿÿÿÿÿ6>">,>€Sÿÿÿÿÿÿ@>6>…!€TÿÿÿÿÿÿJ>ð=@>€UÿÿÿÿÿÿT>b‰€Vÿÿÿÿÿÿ^>˜s€Wÿÿÿÿÿÿh>T>^>€Xÿÿÿÿÿÿr>4v€Yÿÿÿÿÿÿ|>h>r>€Zÿÿÿÿÿÿ†>Å€[ÿÿÿÿÿÿ>|>†>€\ÿÿÿÿÿÿš>>ß!€]ÿÿÿÿÿÿ¤>J>š>€^ÿÿÿÿÿÿ®>t›€_ÿÿÿÿÿÿ¸>ª…€`ÿÿÿÿÿÿÂ>®>¸>€aÿÿÿÿÿÿÌ>Î]€bÿÿÿÿÿÿÖ>Â>Ì>€cÿÿÿÿÿÿà>Gè€dÿÿÿÿÿÿê>Ö>à>€eÿÿÿÿÿÿô>ê>9"€fÿÿÿÿÿÿþ>¤>ô>€gÿÿÿÿÿÿ?†­€hÿÿÿÿÿÿ?¼—€iÿÿÿÿÿÿ???€jÿÿÿÿÿÿ&?ào€kÿÿÿÿÿÿ0??&?€lÿÿÿÿÿÿ:?ò5€mÿÿÿÿÿÿD?0?:?€nÿÿÿÿÿÿN?D?Z€oÿÿÿÿÿÿX?þ>N?€pÿÿÿÿÿÿb? =X?€qSÿÿÿÿÿÿl?*€r>ÿÿÿÿÿÿv?"l?€sÿÿÿÿÿÿ€?…0v?€tSÿÿÿÿÿÿŠ?<€u>ÿÿÿÿÿÿ”?4Š?€vÿÿÿÿÿÿž?€?”?€wSÿÿÿÿÿÿ¨?N€x>ÿÿÿÿÿÿ²?F¨?€yÿÿÿÿÿÿ¼?ž?²?€zSÿÿÿÿÿÿÆ?`€{>ÿÿÿÿÿÿÐ?XÆ?€|ÿÿÿÿÿÿÚ?¼?Ð?€}Sÿÿÿÿÿÿä?"j€~>ÿÿÿÿÿÿî?ä?€ÿÿÿÿÿÿø?î?[1€€Sÿÿÿÿÿÿ@"~€>ÿÿÿÿÿÿ @4@€‚ÿÿÿÿÿÿ@ø? @€ƒSÿÿÿÿÿÿ @"ˆ€„>ÿÿÿÿÿÿ*@F @€…ÿÿÿÿÿÿ4@@*@€†Sÿÿÿÿÿÿ>@"’€‡>ÿÿÿÿÿÿH@X>@€ˆÿÿÿÿÿÿR@4@H@€‰ÿÿÿÿÿÿ\@Ú?R@€ŠSÿÿÿÿÿÿf@4œ€‹>ÿÿÿÿÿÿp@f@€ŒSÿÿÿÿÿÿz@4¦€>ÿÿÿÿÿÿ„@"z@€ŽÿÿÿÿÿÿŽ@p@„@€ÿÿÿÿÿÿ˜@Ž@E2€Sÿÿÿÿÿÿ¢@4º€‘>ÿÿÿÿÿÿ¬@F¢@€’ÿÿÿÿÿÿ¶@˜@¬@€“SÿÿÿÿÿÿÀ@4Ä€”>ÿÿÿÿÿÿÊ@XÀ@€•ÿÿÿÿÿÿÔ@¶@Ê@€–ÿÿÿÿÿÿÞ@\@Ô@€—Sÿÿÿÿÿÿè@F΀˜>ÿÿÿÿÿÿò@è@€™Sÿÿÿÿÿÿü@FØ€š>ÿÿÿÿÿÿA"ü@€›ÿÿÿÿÿÿAò@A€œSÿÿÿÿÿÿAFâ€>ÿÿÿÿÿÿ$A4A€žÿÿÿÿÿÿ.AA$A€Ÿÿÿÿÿÿÿ8A.A/3€ SÿÿÿÿÿÿBAFö€¡>ÿÿÿÿÿÿLAXBA€¢ÿÿÿÿÿÿVA8ALA€£ÿÿÿÿÿÿ`AÞ@VA€¤SÿÿÿÿÿÿjAX€¥>ÿÿÿÿÿÿtAjA€¦Sÿÿÿÿÿÿ~AX €§>ÿÿÿÿÿÿˆA"~A€¨ÿÿÿÿÿÿ’AtAˆA€©SÿÿÿÿÿÿœAX€ª>ÿÿÿÿÿÿ¦A4œA€«ÿÿÿÿÿÿ°A’A¦A€¬SÿÿÿÿÿÿºAX€­>ÿÿÿÿÿÿÄAFºA€®ÿÿÿÿÿÿÎA°AÄA€¯ÿÿÿÿÿÿØAÎA4€°ÿÿÿÿÿÿâA`AØA€±SÿÿÿÿÿÿìA"€²>ÿÿÿÿÿÿöA"ìA@³ÿÿÿÿÿÿBöA€´ÿÿÿÿÿÿ B0B€µSÿÿÿÿÿÿB4€¶>ÿÿÿÿÿÿB4B@·ÿÿÿÿÿÿ'BB€¸ÿÿÿÿÿÿ0B B'B€¹Sÿÿÿÿÿÿ:BF€º>ÿÿÿÿÿÿDBF:B@»ÿÿÿÿÿÿNBDB€¼ÿÿÿÿÿÿWB0BNB€½SÿÿÿÿÿÿaBX€¾>ÿÿÿÿÿÿkBXaB@¿ÿÿÿÿÿÿuBkB€Àÿÿÿÿÿÿ~BWBuB€ÁSÿÿÿÿÿÿˆBt€Â>ÿÿÿÿÿÿ’BˆB@ÃÿÿÿÿÿÿœB’B€Äÿÿÿÿÿÿ¥BœBe1€ÅSÿÿÿÿÿÿ¯B4t€Æ>ÿÿÿÿÿÿ¹B4¯B@ÇÿÿÿÿÿÿÃB¹B€ÈÿÿÿÿÿÿÌB¥BÃB€ÉSÿÿÿÿÿÿÖBFt€Ê>ÿÿÿÿÿÿàBFÖB@ËÿÿÿÿÿÿêBàB€ÌÿÿÿÿÿÿóBÌBêB€ÍSÿÿÿÿÿÿýBXt€Î>ÿÿÿÿÿÿCXýB@ÏÿÿÿÿÿÿCC€ÐÿÿÿÿÿÿCóBC€Ñÿÿÿÿÿÿ$C~BC€ÒSÿÿÿÿÿÿ.C°€Ó>ÿÿÿÿÿÿ8C.C@ÔÿÿÿÿÿÿBC8C€ÕSÿÿÿÿÿÿKC"°€Ö>ÿÿÿÿÿÿUC"KC@×ÿÿÿÿÿÿ_CUC€ØÿÿÿÿÿÿhCBC_C€ÙÿÿÿÿÿÿrChCO2€ÚSÿÿÿÿÿÿ|CF°€Û>ÿÿÿÿÿÿ†CF|C@ÜÿÿÿÿÿÿC†C€Ýÿÿÿÿÿÿ™CrCC€ÞSÿÿÿÿÿÿ£CX°€ß>ÿÿÿÿÿÿ­CX£C@àÿÿÿÿÿÿ·C­C€áÿÿÿÿÿÿÀC™C·C€âÿÿÿÿÿÿÊC$CÀC€ãSÿÿÿÿÿÿÔCì€ä>ÿÿÿÿÿÿÞCÔC@åÿÿÿÿÿÿèCÞC€æSÿÿÿÿÿÿñC"ì€ç>ÿÿÿÿÿÿûC"ñC@èÿÿÿÿÿÿDûC€éÿÿÿÿÿÿDèCD€êSÿÿÿÿÿÿD4ì€ë>ÿÿÿÿÿÿ"D4D@ìÿÿÿÿÿÿ,D"D€íÿÿÿÿÿÿ5DD,D€îÿÿÿÿÿÿ?D5D93€ïSÿÿÿÿÿÿIDXì€ð>ÿÿÿÿÿÿSDXID@ñÿÿÿÿÿÿ]DSD€òÿÿÿÿÿÿfD?D]D€óÿÿÿÿÿÿpDÊCfD€ôSÿÿÿÿÿÿzD(€õ>ÿÿÿÿÿÿ„DzD@öÿÿÿÿÿÿŽD„D€÷Sÿÿÿÿÿÿ—D"(€ø>ÿÿÿÿÿÿ¡D"—D@ùÿÿÿÿÿÿ«D¡D€úÿÿÿÿÿÿ´DŽD«D€ûSÿÿÿÿÿÿ¾D4(€ü>ÿÿÿÿÿÿÈD4¾D@ýÿÿÿÿÿÿÒDÈD€þÿÿÿÿÿÿÛD´DÒD€ÿSÿÿÿÿÿÿåDF(€>ÿÿÿÿÿÿïDFåD@ÿÿÿÿÿÿùDïD€ÿÿÿÿÿÿEÛDùD€ÿÿÿÿÿÿ EE#4€ÿÿÿÿÿÿEpD E€ÿÿÿÿÿÿ E¦+€ÿÿÿÿÿÿ*E Eñ€ÿÿÿÿÿÿ4E*E·€ÿÿÿÿÿÿ>E4E}€ ÿÿÿÿÿÿHE€€ ÿÿÿÿÿÿREHE'€ ÿÿÿÿÿÿ\EREí€ ÿÿÿÿÿÿfE\E³€ ÿÿÿÿÿÿpE>EfE€ÿÿÿÿÿÿzE’|€ÿÿÿÿÿÿ„EzEv€ÿÿÿÿÿÿŽE„E€ÿÿÿÿÿÿ˜EŽE×€ÿÿÿÿÿÿ¢EpE˜E€ÿÿÿÿÿÿ¬E¤Ž€ÿÿÿÿÿÿ¶E¬Ef€ÿÿÿÿÿÿÀE¶Eè€ÿÿÿÿÿÿÊEÀEé€ÿÿÿÿÿÿÔE¢EÊE€ÿÿÿÿÿÿÞE¶ €ÿÿÿÿÿÿèEÞEx€ÿÿÿÿÿÿòEèE>€ÿÿÿÿÿÿüEòEZ€ÿÿÿÿÿÿFÔEüE€ÿÿÿÿÿÿF¦2€ÿÿÿÿÿÿFw€ÿÿÿÿÿÿ$FFF€ ÿÿÿÿÿÿ.F‰€!ÿÿÿÿÿÿ8F$F.F€"ÿÿÿÿÿÿBF›€#ÿÿÿÿÿÿLF8FBF€$ÿÿÿÿÿÿVF­ø€%ÿÿÿÿÿÿ`FLFVF€&ÿÿÿÿÿÿjF€Œ€'ÿÿÿÿÿÿtF¯v€(ÿÿÿÿÿÿ~FjFtF€)ÿÿÿÿÿÿˆF¿j€*ÿÿÿÿÿÿ’F~FˆF€+ÿÿÿÿÿÿœFÑ^€,ÿÿÿÿÿÿ¦F’FœF€-ÿÿÿÿÿÿ°FãR €.ÿÿÿÿÿÿºF¦F°F€/ÿÿÿÿÿÿÄF`FºF€0ÿÿÿÿÿÿÎF’ð€1ÿÿÿÿÿÿØFÈÚ€2ÿÿÿÿÿÿâFÎFØF€3ÿÿÿÿÿÿìFÂ΀4ÿÿÿÿÿÿöFâFìF€5ÿÿÿÿÿÿGõ€6ÿÿÿÿÿÿ GöFG€7ÿÿÿÿÿÿG¶ €8ÿÿÿÿÿÿG GG€9ÿÿÿÿÿÿ(GÄFG€:ÿÿÿÿÿÿ2G¤T€;ÿÿÿÿÿÿ€<ÿÿÿÿÿÿFG2GÿÿÿÿÿÿZGFGPG€?ÿÿÿÿÿÿdGÕ&€@ÿÿÿÿÿÿnGZGdG€AÿÿÿÿÿÿxG €Bÿÿÿÿÿÿ‚GnGxG€CÿÿÿÿÿÿŒG(G‚G€Dÿÿÿÿÿÿ–G¶¸€Eÿÿÿÿÿÿ G좀FÿÿÿÿÿÿªG–G G€Gÿÿÿÿÿÿ´G–€Hÿÿÿÿÿÿ¾GªG´G€IÿÿÿÿÿÿÈG"Š€JÿÿÿÿÿÿÒG¾GÈG€KÿÿÿÿÿÿÜGè~ €LÿÿÿÿÿÿæGÒGÜG€MÿÿÿÿÿÿðGŒGæG€NÿÿÿÿÿÿúGû<€OÿÿÿÿÿÿH+&€PÿÿÿÿÿÿHúGH€QÿÿÿÿÿÿH=€Rÿÿÿÿÿÿ"HHH€Sÿÿÿÿÿÿ,HO€Tÿÿÿÿÿÿ6H"H,H€Uÿÿÿÿÿÿ@Ha €VÿÿÿÿÿÿJH6H@H€WÿÿÿÿÿÿTH4–€Xÿÿÿÿÿÿ^H€€YÿÿÿÿÿÿhHTH^H€ZÿÿÿÿÿÿrHst€[ÿÿÿÿÿÿ|HhHrH€\ÿÿÿÿÿÿ†H…h€]ÿÿÿÿÿÿH|H†H€^ÿÿÿÿÿÿšH—\ €_ÿÿÿÿÿÿ¤HHšH€`ÿÿÿÿÿÿ®HJH¤H€aÿÿÿÿÿÿ¸HFú€bÿÿÿÿÿÿÂH|ä€cÿÿÿÿÿÿÌH¸HÂH€dÿÿÿÿÿÿÖHØ€eÿÿÿÿÿÿàHÌHÖH€fÿÿÿÿÿÿêH©Ì€gÿÿÿÿÿÿôHàHêH€hÿÿÿÿÿÿþH»À €iÿÿÿÿÿÿIôHþH€jÿÿÿÿÿÿI®HI€kÿÿÿÿÿÿIX^€lÿÿÿÿÿÿ&IŽH€mÿÿÿÿÿÿ0II&I€nÿÿÿÿÿÿ:I²<€oÿÿÿÿÿÿDI0I:I€pÿÿÿÿÿÿNI*0€qÿÿÿÿÿÿXIDINI€rÿÿÿÿÿÿbIÍ$ €sÿÿÿÿÿÿlIXIbI€tÿÿÿÿÿÿvIIlI€uÿÿÿÿÿÿ€Ij€vÿÿÿÿÿÿŠI ¬€wÿÿÿÿÿÿ”I€IŠI€xÿÿÿÿÿÿžIÄ €yÿÿÿÿÿÿ¨I”IžI€zÿÿÿÿÿÿ²IÖ”€{ÿÿÿÿÿÿ¼I¨I²I€|ÿÿÿÿÿÿÆI=ˆ €}ÿÿÿÿÿÿÐI¼IÆI€~ÿÿÿÿÿÿÚIvIÐI€ÿÿÿÿÿÿäIðGÚI€€ÿÿÿÿÿÿîIZP€ÿÿÿÿÿÿøIß:€‚ÿÿÿÿÿÿJîIøI€ƒÿÿÿÿÿÿ Jñ.€„ÿÿÿÿÿÿJJ J€…ÿÿÿÿÿÿ J"€†ÿÿÿÿÿÿ*JJ J€‡ÿÿÿÿÿÿ4J €ˆÿÿÿÿÿÿ>J*J4J€‰ÿÿÿÿÿÿHJ誀ŠÿÿÿÿÿÿRJc”€‹ÿÿÿÿÿÿ\JHJRJ€ŒÿÿÿÿÿÿfJ'ˆ€ÿÿÿÿÿÿpJ\JfJ€ŽÿÿÿÿÿÿzJ9|€ÿÿÿÿÿÿ„JpJzJ€ÿÿÿÿÿÿŽJKp €‘ÿÿÿÿÿÿ˜J„JŽJ€’ÿÿÿÿÿÿ¢J>J˜J€“ÿÿÿÿÿÿ¬Jú€”ÿÿÿÿÿÿ¶J0ø€•ÿÿÿÿÿÿÀJ¬J¶J€–ÿÿÿÿÿÿÊJv쀗ÿÿÿÿÿÿÔJÀJÊJ€˜ÿÿÿÿÿÿÞJ]à€™ÿÿÿÿÿÿèJÔJÞJ€šÿÿÿÿÿÿòJoÔ €›ÿÿÿÿÿÿüJèJòJ€œÿÿÿÿÿÿK¢JüJ€ÿÿÿÿÿÿK r€žÿÿÿÿÿÿKB\€Ÿÿÿÿÿÿÿ$KKK€ ÿÿÿÿÿÿ.KfP€¡ÿÿÿÿÿÿ8K$K.K€¢ÿÿÿÿÿÿBK‰D€£ÿÿÿÿÿÿLK8KBK€¤ÿÿÿÿÿÿVK8 €¥ÿÿÿÿÿÿ`KLKVK€¦ÿÿÿÿÿÿjKK`K€§ÿÿÿÿÿÿtKÖ€¨ÿÿÿÿÿÿ~KTÀ€©ÿÿÿÿÿÿˆKtK~K€ªÿÿÿÿÿÿ’Kx´€«ÿÿÿÿÿÿœKˆK’K€¬ÿÿÿÿÿÿ¦KŠ¨€­ÿÿÿÿÿÿ°KœK¦K€®ÿÿÿÿÿÿºKœœ €¯ÿÿÿÿÿÿÄK°KºK€°ÿÿÿÿÿÿÎKjKÄK€±ÿÿÿÿÿÿØKäIÎK€²ÿÿÿÿÿÿâK¹d€³ÿÿÿÿÿÿìK“N€´ÿÿÿÿÿÿöKâKìK€µÿÿÿÿÿÿL¥B€¶ÿÿÿÿÿÿ LöKL€·ÿÿÿÿÿÿL·6€¸ÿÿÿÿÿÿL LL€¹ÿÿÿÿÿÿ(LÉ* €ºÿÿÿÿÿÿ2LL(L€»ÿÿÿÿÿÿ¼€ßÿÿÿÿÿÿ¤MMšM€àÿÿÿÿÿÿ®Mû° €áÿÿÿÿÿÿ¸M¤M®M€âÿÿÿÿÿÿÂM^M¸M€ãÿÿÿÿÿÿÌMØKÂM€äÿÿÿÿÿÿÖMx€åÿÿÿÿÿÿàMGb€æÿÿÿÿÿÿêMÖMàM€çÿÿÿÿÿÿôMYV€èÿÿÿÿÿÿþMêMôM€éÿÿÿÿÿÿNkJ€êÿÿÿÿÿÿNþMN€ëÿÿÿÿÿÿN}> €ìÿÿÿÿÿÿ&NNN€íÿÿÿÿÿÿ0NPÒ€îÿÿÿÿÿÿ:N!¼€ïÿÿÿÿÿÿDN0N:N€ðÿÿÿÿÿÿNN°€ñÿÿÿÿÿÿXNDNNN€òÿÿÿÿÿÿbN¡¤€óÿÿÿÿÿÿlNXNbN€ôÿÿÿÿÿÿvN³˜ €õÿÿÿÿÿÿ€NlNvN€öÿÿÿÿÿÿŠN&N€N€÷ÿÿÿÿÿÿ”Nb6€øÿÿÿÿÿÿžN˜ €ùÿÿÿÿÿÿ¨N”NžN€úÿÿÿÿÿÿ²N4€ûÿÿÿÿÿÿ¼N¨N²N€üÿÿÿÿÿÿÆNÅ€ýÿÿÿÿÿÿÐN¼NÆN€þÿÿÿÿÿÿÚN×ü €ÿÿÿÿÿÿÿäNÐNÚN€ÿÿÿÿÿÿîNŠNäN€ÿÿÿÿÿÿøNtš€ÿÿÿÿÿÿOª„€ÿÿÿÿÿÿ OøNO€ÿÿÿÿÿÿOÎx€ÿÿÿÿÿÿ O OO€ÿÿÿÿÿÿ*OGl€ÿÿÿÿÿÿ4O O*O€ÿÿÿÿÿÿ>Oé` € ÿÿÿÿÿÿHO4O>O€ ÿÿÿÿÿÿROîNHO€ ÿÿÿÿÿÿ\O†þ€ ÿÿÿÿÿÿfO¼è€ ÿÿÿÿÿÿpO\OfO€ÿÿÿÿÿÿzOàÜ€ÿÿÿÿÿÿ„OpOzO€ÿÿÿÿÿÿŽOòЀÿÿÿÿÿÿ˜O„OŽO€ÿÿÿÿÿÿ¢OZÄ €ÿÿÿÿÿÿ¬O˜O¢O€ÿÿÿÿÿÿ¶ORO¬O€ÿÿÿÿÿÿÀOÌM¶O€ÿÿÿÿÿÿÊO2¦€ÿÿÿÿÿÿÔOŒû€ÿÿÿÿÿÿÞOÊOÔO€ÿÿÿÿÿÿèOðZ€ÿÿÿÿÿÿòOÞOèO€ÿÿÿÿÿÿüOT¹€ÿÿÿÿÿÿPòOüO€ÿÿÿÿÿÿP¸€ÿÿÿÿÿÿPPP€ÿÿÿÿÿÿ$P€€ ÿÿÿÿÿÿ.Pv4€!ÿÿÿÿÿÿ8P$P.P€"ÿÿÿÿÿÿBPÚè€#ÿÿÿÿÿÿLP8PBP€$ÿÿÿÿÿÿVP>œ€%ÿÿÿÿÿÿ`PLPVP€&ÿÿÿÿÿÿjP¢P€'ÿÿÿÿÿÿtP`PjP€(ÿÿÿÿÿÿ~PPtP€)ÿÿÿÿÿÿˆP’€*ÿÿÿÿÿÿ’PjF€+ÿÿÿÿÿÿœPˆP’P€,ÿÿÿÿÿÿ¦PÎú€-ÿÿÿÿÿÿ°PœP¦P€.ÿÿÿÿÿÿºP2®€/ÿÿÿÿÿÿÄP°PºP€0ÿÿÿÿÿÿÎP–b€1ÿÿÿÿÿÿØPÄPÎP€2ÿÿÿÿÿÿâP~PØP€3ÿÿÿÿÿÿìP¤€4ÿÿÿÿÿÿöP^X€5ÿÿÿÿÿÿQìPöP€6ÿÿÿÿÿÿ Q €7ÿÿÿÿÿÿQQ Q€8ÿÿÿÿÿÿQ&À€9ÿÿÿÿÿÿ(QQQ€:ÿÿÿÿÿÿ2QŠt€;ÿÿÿÿÿÿÿÿÿÿÿÿZQR j€?ÿÿÿÿÿÿdQPQZQ€@ÿÿÿÿÿÿnQ¶ €AÿÿÿÿÿÿxQdQnQ€Bÿÿÿÿÿÿ‚Q Ò€CÿÿÿÿÿÿŒQxQ‚Q€Dÿÿÿÿÿÿ–Q~ †€Eÿÿÿÿÿÿ QŒQ–Q€FÿÿÿÿÿÿªQFQ Q€Gÿÿÿÿÿÿ´Q<w€Hÿÿÿÿÿÿ¾Q–+€IÿÿÿÿÿÿÈQ´Q¾Q€JÿÿÿÿÿÿÒQú߀KÿÿÿÿÿÿÜQÈQÒQ€LÿÿÿÿÿÿæQ^“€MÿÿÿÿÿÿðQÜQæQ€NÿÿÿÿÿÿúQÂG€OÿÿÿÿÿÿRðQúQ€PÿÿÿÿÿÿR&¯€QÿÿÿÿÿÿR€€Rÿÿÿÿÿÿ"RRR€Sÿÿÿÿÿÿ,Räc€Tÿÿÿÿÿÿ6R"R,R€Uÿÿÿÿÿÿ@RH€VÿÿÿÿÿÿJR6R@R€WÿÿÿÿÿÿTR¬!€Xÿÿÿÿÿÿ^RJRTR€YÿÿÿÿÿÿhRR^R€ZÿÿÿÿÿÿrRÈ€[ÿÿÿÿÿÿ|Rt|€\ÿÿÿÿÿÿ†RrR|R€]ÿÿÿÿÿÿRØ0€^ÿÿÿÿÿÿšR†RR€_ÿÿÿÿÿÿ¤R<ä€`ÿÿÿÿÿÿ®RšR¤R€aÿÿÿÿÿÿ¸R ˜€bÿÿÿÿÿÿÂR®R¸R€cÿÿÿÿÿÿÌRhRÂR€dÿÿÿÿÿÿÖRÚ€eÿÿÿÿÿÿàRhŽ€fÿÿÿÿÿÿêRÖRàR€gÿÿÿÿÿÿôRÌB€hÿÿÿÿÿÿþRêRôR€iÿÿÿÿÿÿS0ö€jÿÿÿÿÿÿSþRS€kÿÿÿÿÿÿS”ª€lÿÿÿÿÿÿ&SSS€mÿÿÿÿÿÿ0SÌR&S€nÿÿÿÿÿÿ:S ì€oÿÿÿÿÿÿDS\  €pÿÿÿÿÿÿNS:SDS€qÿÿÿÿÿÿXSÀ T€rÿÿÿÿÿÿbSNSXS€sÿÿÿÿÿÿlS$ €tÿÿÿÿÿÿvSbSlS€uÿÿÿÿÿÿ€Sˆ ¼€vÿÿÿÿÿÿŠSvS€S€wÿÿÿÿÿÿ”S0SŠS€xÿÿÿÿÿÿžSªQ”S€yÿÿÿÿÿÿ¨SP‰€zÿÿÿÿÿÿ²Sª=€{ÿÿÿÿÿÿ¼S¨S²S€|ÿÿÿÿÿÿÆSñ€}ÿÿÿÿÿÿÐS¼SÆS€~ÿÿÿÿÿÿÚSr¥€ÿÿÿÿÿÿäSÐSÚS€€ÿÿÿÿÿÿîSÖY€ÿÿÿÿÿÿøSäSîS€‚ÿÿÿÿÿÿT:¿€ƒÿÿÿÿÿÿ T”s€„ÿÿÿÿÿÿTT T€…ÿÿÿÿÿÿ Tø'€†ÿÿÿÿÿÿ*TT T€‡ÿÿÿÿÿÿ4T\Û€ˆÿÿÿÿÿÿ>T*T4T€‰ÿÿÿÿÿÿHTÀ€ŠÿÿÿÿÿÿRT>THT€‹ÿÿÿÿÿÿ\TøSRT€ŒÿÿÿÿÿÿfT.€ÿÿÿÿÿÿpTˆ€ŽÿÿÿÿÿÿzTfTpT€ÿÿÿÿÿÿ„Tìv€ÿÿÿÿÿÿŽTzT„T€‘ÿÿÿÿÿÿ˜TPÕ€’ÿÿÿÿÿÿ¢TŽT˜T€“ÿÿÿÿÿÿ¬T´4€”ÿÿÿÿÿÿ¶T¢T¬T€•ÿÿÿÿÿÿÀT\T¶T€–ÿÿÿÿÿÿÊT"þ€—ÿÿÿÿÿÿÔT|²€˜ÿÿÿÿÿÿÞTÊTÔT€™ÿÿÿÿÿÿèTàf€šÿÿÿÿÿÿòTÞTèT€›ÿÿÿÿÿÿüTD€œÿÿÿÿÿÿUòTüT€ÿÿÿÿÿÿU¨Î€žÿÿÿÿÿÿUUU€Ÿÿÿÿÿÿÿ$UÀTU€ ÿÿÿÿÿÿ.U €¡ÿÿÿÿÿÿ8Up Ä€¢ÿÿÿÿÿÿBU.U8U€£ÿÿÿÿÿÿLUÔ x€¤ÿÿÿÿÿÿVUBULU€¥ÿÿÿÿÿÿ`U8 ,€¦ÿÿÿÿÿÿjUVU`U€§ÿÿÿÿÿÿtUœ à€¨ÿÿÿÿÿÿ~UjUtU€©ÿÿÿÿÿÿˆU$U~U€ªÿÿÿÿÿÿ’UžSˆU€«ÿÿÿÿÿÿœUd›€¬ÿÿÿÿÿÿ¦U¾O€­ÿÿÿÿÿÿ°UœU¦U€®ÿÿÿÿÿÿºU"€¯ÿÿÿÿÿÿÄU°UºU€°ÿÿÿÿÿÿÎU†·€±ÿÿÿÿÿÿØUÄUÎU€²ÿÿÿÿÿÿâUêk€³ÿÿÿÿÿÿìUØUâU€´ÿÿÿÿÿÿöUNÑ€µÿÿÿÿÿÿV¨…€¶ÿÿÿÿÿÿ VöUV€·ÿÿÿÿÿÿV 9€¸ÿÿÿÿÿÿV VV€¹ÿÿÿÿÿÿ(Vp퀺ÿÿÿÿÿÿ2VV(V€»ÿÿÿÿÿÿ€Øÿÿÿÿÿÿ^WJWTW€ÙÿÿÿÿÿÿhW° ò€ÚÿÿÿÿÿÿrW^WhW€Ûÿÿÿÿÿÿ|WWrW€Üÿÿÿÿÿÿ†W’U|W€ÝÿÿÿÿÿÿWx­€ÞÿÿÿÿÿÿšWÒa€ßÿÿÿÿÿÿ¤WWšW€àÿÿÿÿÿÿ®W6€áÿÿÿÿÿÿ¸W¤W®W€âÿÿÿÿÿÿÂWšÉ€ãÿÿÿÿÿÿÌW¸WÂW€äÿÿÿÿÿÿÖWþ}€åÿÿÿÿÿÿàWÌWÖW€æÿÿÿÿÿÿêWbã€çÿÿÿÿÿÿôW¼—€èÿÿÿÿÿÿþWêWôW€éÿÿÿÿÿÿX K€êÿÿÿÿÿÿXþWX€ëÿÿÿÿÿÿX„ÿ€ìÿÿÿÿÿÿ&XXX€íÿÿÿÿÿÿ0Xè³€îÿÿÿÿÿÿ:X&X0X€ïÿÿÿÿÿÿDXàW:X€ðÿÿÿÿÿÿNXV€ñÿÿÿÿÿÿXX°»€òÿÿÿÿÿÿbXNXXX€óÿÿÿÿÿÿlXo€ôÿÿÿÿÿÿvXbXlX€õÿÿÿÿÿÿ€Xx#€öÿÿÿÿÿÿŠXvX€X€÷ÿÿÿÿÿÿ”XÜ×€øÿÿÿÿÿÿžXŠX”X€ùÿÿÿÿÿÿ¨XDXžX€úÿÿÿÿÿÿ²XJ€ûÿÿÿÿÿÿ¼X¤Í€üÿÿÿÿÿÿÆX²X¼X€ýÿÿÿÿÿÿÐX€þÿÿÿÿÿÿÚXÆXÐX€ÿÿÿÿÿÿÿäXl5€ ÿÿÿÿÿÿîXÚXäX€ ÿÿÿÿÿÿøXÐé€ ÿÿÿÿÿÿYîXøX€ ÿÿÿÿÿÿ Y¨XY€ ÿÿÿÿÿÿY> è€ ÿÿÿÿÿÿ Y˜ =€ ÿÿÿÿÿÿ*YY Y€ ÿÿÿÿÿÿ4Yü œ€ ÿÿÿÿÿÿ>Y*Y4Y€ ÿÿÿÿÿÿHY` û€ ÿÿÿÿÿÿRY>YHY€ ÿÿÿÿÿÿ\YÄ Z€ ÿÿÿÿÿÿfYRY\Y€ ÿÿÿÿÿÿpY YfY€ ÿÿÿÿÿÿzY†WpY€ ÿÿÿÿÿÿ„Y÷"X'€ ÿÿÿÿÿÿŽY„Yþ'€ ÿÿÿÿÿÿ˜YŽY¤(€ ÿÿÿÿÿÿ¢Y˜YJ)€ ÿÿÿÿÿÿ¬Y¼&Í#€ ÿÿÿÿÿÿ¶Y¬Y(€ ÿÿÿÿÿÿÀY¶YÁ(€ ÿÿÿÿÿÿÊYÀYg)€ ÿÿÿÿÿÿÔY¢YÊY€ ÿÿÿÿÿÿÞYã&'€ ÿÿÿÿÿÿèYÞY·$€ ÿÿÿÿÿÿòYèYè(€ ÿÿÿÿÿÿüYòYŽ)€ ÿÿÿÿÿÿZÔYüY€ ÿÿÿÿÿÿZ '¦'€ ÿÿÿÿÿÿZZL(€ ÿÿÿÿÿÿ$ZZ¡%€ ÿÿÿÿÿÿ.Z$Zµ)€! ÿÿÿÿÿÿ8ZZ.Z€" ÿÿÿÿÿÿBZ1'Í'€# ÿÿÿÿÿÿLZBZs(€$ ÿÿÿÿÿÿVZLZ)€% ÿÿÿÿÿÿ`ZVZ‹&€& ÿÿÿÿÿÿjZ8Z`Z€' >ÿÿÿÿÿÿtZj@( ÿÿÿÿÿÿ~ZtZ€) >ÿÿÿÿÿÿ‡Zœ@* ÿÿÿÿÿÿ‘Z‡Z€+ ÿÿÿÿÿÿšZ~Z‘Z€, >ÿÿÿÿÿÿ¤ZÎ@- ÿÿÿÿÿÿ®Z¤Z€. ÿÿÿÿÿÿ·ZšZ®Z€/ >ÿÿÿÿÿÿÁZ@0 ÿÿÿÿÿÿËZÁZ€1 ÿÿÿÿÿÿÔZ·ZËZ€2 >ÿÿÿÿÿÿÞZjœ@3 ÿÿÿÿÿÿèZÞZ€4 ÿÿÿÿÿÿñZÔZèZ€5 >ÿÿÿÿÿÿûZjÎ@6 ÿÿÿÿÿÿ[ûZ€7 ÿÿÿÿÿÿ[ñZ[€8 >ÿÿÿÿÿÿ[j@9 ÿÿÿÿÿÿ"[[€: ÿÿÿÿÿÿ+[["[€; >ÿÿÿÿÿÿ5[œÎ@< ÿÿÿÿÿÿ?[5[€= ÿÿÿÿÿÿH[+[?[€> >ÿÿÿÿÿÿR[œ@? ÿÿÿÿÿÿ\[R[€@ ÿÿÿÿÿÿe[H[\[€A >ÿÿÿÿÿÿo[Î@B ÿÿÿÿÿÿy[o[€C ÿÿÿÿÿÿ‚[e[y[€D >ÿÿÿÿÿÿŒ[*t@E ÿÿÿÿÿÿ–[Œ[€F >ÿÿÿÿÿÿŸ[*¦@G ÿÿÿÿÿÿ©[Ÿ[€H ÿÿÿÿÿÿ²[–[©[€I >ÿÿÿÿÿÿ¼[*Ø@J ÿÿÿÿÿÿÆ[¼[€K ÿÿÿÿÿÿÏ[²[Æ[€L >ÿÿÿÿÿÿÙ[* @M ÿÿÿÿÿÿã[Ù[€N ÿÿÿÿÿÿì[Ï[ã[€O >ÿÿÿÿÿÿö[t¦@P ÿÿÿÿÿÿ\ö[€Q ÿÿÿÿÿÿ \ì[\€R >ÿÿÿÿÿÿ\tØ@S ÿÿÿÿÿÿ\\€T ÿÿÿÿÿÿ&\ \\€U >ÿÿÿÿÿÿ0\t @V ÿÿÿÿÿÿ:\0\€W ÿÿÿÿÿÿC\&\:\€X >ÿÿÿÿÿÿM\¦Ø@Y ÿÿÿÿÿÿW\M\€Z ÿÿÿÿÿÿ`\C\W\€[ >ÿÿÿÿÿÿj\¦ @\ ÿÿÿÿÿÿt\j\€] ÿÿÿÿÿÿ}\`\t\€^ >ÿÿÿÿÿÿ‡\Ø @_ ÿÿÿÿÿÿ‘\‡\€` ÿÿÿÿÿÿš\}\‘\€a ÿÿÿÿÿÿ¤\‚[š\€b >ÿÿÿÿÿÿ®\<~@c ÿÿÿÿÿÿ¸\®\€d >ÿÿÿÿÿÿÁ\<°@e ÿÿÿÿÿÿË\Á\€f ÿÿÿÿÿÿÔ\¸\Ë\€g >ÿÿÿÿÿÿÞ\<â@h ÿÿÿÿÿÿè\Þ\€i ÿÿÿÿÿÿñ\Ô\è\€j >ÿÿÿÿÿÿû\<@k ÿÿÿÿÿÿ]û\€l ÿÿÿÿÿÿ]ñ\]€m >ÿÿÿÿÿÿ]~°@n ÿÿÿÿÿÿ"]]€o ÿÿÿÿÿÿ+]]"]€p >ÿÿÿÿÿÿ5]~â@q ÿÿÿÿÿÿ?]5]€r ÿÿÿÿÿÿH]+]?]€s >ÿÿÿÿÿÿR]~@t ÿÿÿÿÿÿ\]R]€u ÿÿÿÿÿÿe]H]\]€v >ÿÿÿÿÿÿo]°â@w ÿÿÿÿÿÿy]o]€x ÿÿÿÿÿÿ‚]e]y]€y >ÿÿÿÿÿÿŒ]°@z ÿÿÿÿÿÿ–]Œ]€{ ÿÿÿÿÿÿŸ]‚]–]€| >ÿÿÿÿÿÿ©]â@} ÿÿÿÿÿÿ³]©]€~ ÿÿÿÿÿÿ¼]Ÿ]³]€ ÿÿÿÿÿÿÆ]¤\¼]€€ >ÿÿÿÿÿÿÐ]Nˆ@ ÿÿÿÿÿÿÚ]Ð]€‚ >ÿÿÿÿÿÿã]Nº@ƒ ÿÿÿÿÿÿí]ã]€„ ÿÿÿÿÿÿö]Ú]í]€… >ÿÿÿÿÿÿ^Nì@† ÿÿÿÿÿÿ ^^€‡ ÿÿÿÿÿÿ^ö] ^€ˆ >ÿÿÿÿÿÿ^N@‰ ÿÿÿÿÿÿ'^^€Š ÿÿÿÿÿÿ0^^'^€‹ >ÿÿÿÿÿÿ:^ˆº@Œ ÿÿÿÿÿÿD^:^€ ÿÿÿÿÿÿM^0^D^€Ž >ÿÿÿÿÿÿW^ˆì@ ÿÿÿÿÿÿa^W^€ ÿÿÿÿÿÿj^M^a^€‘ >ÿÿÿÿÿÿt^ˆ@’ ÿÿÿÿÿÿ~^t^€“ ÿÿÿÿÿÿ‡^j^~^€” >ÿÿÿÿÿÿ‘^ºì@• ÿÿÿÿÿÿ›^‘^€– ÿÿÿÿÿÿ¤^‡^›^€— >ÿÿÿÿÿÿ®^º@˜ ÿÿÿÿÿÿ¸^®^€™ ÿÿÿÿÿÿÁ^¤^¸^€š >ÿÿÿÿÿÿË^ì@› ÿÿÿÿÿÿÕ^Ë^€œ ÿÿÿÿÿÿÞ^Á^Õ^€ ÿÿÿÿÿÿè^Æ]Þ^€ž >ÿÿÿÿÿÿò^`’@Ÿ ÿÿÿÿÿÿü^ò^€  >ÿÿÿÿÿÿ_`Ä@¡ ÿÿÿÿÿÿ__€¢ ÿÿÿÿÿÿ_ü^_€£ >ÿÿÿÿÿÿ"_`ö@¤ ÿÿÿÿÿÿ,_"_€¥ ÿÿÿÿÿÿ5__,_€¦ >ÿÿÿÿÿÿ?_`(@§ ÿÿÿÿÿÿI_?_€¨ ÿÿÿÿÿÿR_5_I_€© >ÿÿÿÿÿÿ\_’Ä@ª ÿÿÿÿÿÿf_\_€« ÿÿÿÿÿÿo_R_f_€¬ >ÿÿÿÿÿÿy_’ö@­ ÿÿÿÿÿÿƒ_y_€® ÿÿÿÿÿÿŒ_o_ƒ_€¯ >ÿÿÿÿÿÿ–_’(@° ÿÿÿÿÿÿ _–_€± ÿÿÿÿÿÿ©_Œ_ _€² >ÿÿÿÿÿÿ³_Äö@³ ÿÿÿÿÿÿ½_³_€´ ÿÿÿÿÿÿÆ_©_½_€µ >ÿÿÿÿÿÿÐ_Ä(@¶ ÿÿÿÿÿÿÚ_Ð_€· ÿÿÿÿÿÿã_Æ_Ú_€¸ >ÿÿÿÿÿÿí_ö(@¹ ÿÿÿÿÿÿ÷_í_€º ÿÿÿÿÿÿ`ã_÷_€» ÿÿÿÿÿÿ `è^`€¼ >ÿÿÿÿÿÿ`*@½ ÿÿÿÿÿÿ``€¾ >ÿÿÿÿÿÿ'`<@¿ ÿÿÿÿÿÿ1`'`€À ÿÿÿÿÿÿ:``1`€Á >ÿÿÿÿÿÿD`N@ ÿÿÿÿÿÿN`D`€Ã ÿÿÿÿÿÿW`:`N`€Ä >ÿÿÿÿÿÿa``@Å ÿÿÿÿÿÿk`a`€Æ ÿÿÿÿÿÿt`W`k`€Ç >ÿÿÿÿÿÿ~`*<@È ÿÿÿÿÿÿˆ`~`€É ÿÿÿÿÿÿ‘`t`ˆ`€Ê >ÿÿÿÿÿÿ›`*N@Ë ÿÿÿÿÿÿ¥`›`€Ì ÿÿÿÿÿÿ®`‘`¥`€Í >ÿÿÿÿÿÿ¸`*`@Î ÿÿÿÿÿÿÂ`¸`€Ï ÿÿÿÿÿÿË`®`Â`€Ð >ÿÿÿÿÿÿÕ`<N@Ñ ÿÿÿÿÿÿß`Õ`€Ò ÿÿÿÿÿÿè`Ë`ß`€Ó >ÿÿÿÿÿÿò`<`@Ô ÿÿÿÿÿÿü`ò`€Õ ÿÿÿÿÿÿaè`ü`€Ö >ÿÿÿÿÿÿaN`@× ÿÿÿÿÿÿaa€Ø ÿÿÿÿÿÿ"aaa€Ù >ÿÿÿÿÿÿ,ajt@Ú ÿÿÿÿÿÿ6a,a€Û >ÿÿÿÿÿÿ?aj~@Ü ÿÿÿÿÿÿIa?a€Ý ÿÿÿÿÿÿRa6aIa€Þ >ÿÿÿÿÿÿ\ajˆ@ß ÿÿÿÿÿÿfa\a€à ÿÿÿÿÿÿoaRafa€á >ÿÿÿÿÿÿyaj’@â ÿÿÿÿÿÿƒaya€ã ÿÿÿÿÿÿŒaoaƒa€ä >ÿÿÿÿÿÿ–at~@å ÿÿÿÿÿÿ a–a€æ ÿÿÿÿÿÿ©aŒa a€ç >ÿÿÿÿÿÿ³atˆ@è ÿÿÿÿÿÿ½a³a€é ÿÿÿÿÿÿÆa©a½a€ê >ÿÿÿÿÿÿÐat’@ë ÿÿÿÿÿÿÚaÐa€ì ÿÿÿÿÿÿãaÆaÚa€í >ÿÿÿÿÿÿía~ˆ@î ÿÿÿÿÿÿ÷aía€ï ÿÿÿÿÿÿbãa÷a€ð >ÿÿÿÿÿÿ b~’@ñ ÿÿÿÿÿÿb b€ò ÿÿÿÿÿÿbbb€ó >ÿÿÿÿÿÿ'bˆ’@ô ÿÿÿÿÿÿ1b'b€õ ÿÿÿÿÿÿ:bb1b€ö ÿÿÿÿÿÿDb"a:b€÷ >ÿÿÿÿÿÿNbœ¦@ø ÿÿÿÿÿÿXbNb€ù >ÿÿÿÿÿÿabœ°@ú ÿÿÿÿÿÿkbab€û ÿÿÿÿÿÿtbXbkb€ü >ÿÿÿÿÿÿ~bœº@ý ÿÿÿÿÿÿˆb~b€þ ÿÿÿÿÿÿ‘btbˆb€ÿ >ÿÿÿÿÿÿ›bœÄ@ ÿÿÿÿÿÿ¥b›b€ ÿÿÿÿÿÿ®b‘b¥b€ >ÿÿÿÿÿÿ¸b¦°@ ÿÿÿÿÿÿÂb¸b€ ÿÿÿÿÿÿËb®bÂb€ >ÿÿÿÿÿÿÕb¦º@ ÿÿÿÿÿÿßbÕb€ ÿÿÿÿÿÿèbËbßb€ >ÿÿÿÿÿÿòb¦Ä@ ÿÿÿÿÿÿübòb€ ÿÿÿÿÿÿcèbüb€ >ÿÿÿÿÿÿc°º@ ÿÿÿÿÿÿcc€ ÿÿÿÿÿÿ"ccc€ >ÿÿÿÿÿÿ,c°Ä@ ÿÿÿÿÿÿ6c,c€ ÿÿÿÿÿÿ?c"c6c€ >ÿÿÿÿÿÿIcºÄ@ ÿÿÿÿÿÿScIc€ ÿÿÿÿÿÿ\c?cSc€ ÿÿÿÿÿÿfcDb\c€ >ÿÿÿÿÿÿpcÎØ@ ÿÿÿÿÿÿzcpc€ >ÿÿÿÿÿÿƒcÎâ@ ÿÿÿÿÿÿcƒc€ ÿÿÿÿÿÿ–czcc€ >ÿÿÿÿÿÿ cÎì@ ÿÿÿÿÿÿªc c€ ÿÿÿÿÿÿ³c–cªc€ >ÿÿÿÿÿÿ½cÎö@ ÿÿÿÿÿÿÇc½c€ ÿÿÿÿÿÿÐc³cÇc€ >ÿÿÿÿÿÿÚcØâ@! ÿÿÿÿÿÿäcÚc€" ÿÿÿÿÿÿícÐcäc€# >ÿÿÿÿÿÿ÷cØì@$ ÿÿÿÿÿÿd÷c€% ÿÿÿÿÿÿ dícd€& >ÿÿÿÿÿÿdØö@' ÿÿÿÿÿÿdd€( ÿÿÿÿÿÿ'd dd€) >ÿÿÿÿÿÿ1dâì@* ÿÿÿÿÿÿ;d1d€+ ÿÿÿÿÿÿDd'd;d€, >ÿÿÿÿÿÿNdâö@- ÿÿÿÿÿÿXdNd€. ÿÿÿÿÿÿadDdXd€/ >ÿÿÿÿÿÿkdìö@0 ÿÿÿÿÿÿudkd€1 ÿÿÿÿÿÿ~dadud€2 ÿÿÿÿÿÿˆdfc~d€3 >ÿÿÿÿÿÿ’d @4 ÿÿÿÿÿÿœd’d€5 >ÿÿÿÿÿÿ¥d@6 ÿÿÿÿÿÿ¯d¥d€7 ÿÿÿÿÿÿ¸dœd¯d€8 >ÿÿÿÿÿÿÂd@9 ÿÿÿÿÿÿÌdÂd€: ÿÿÿÿÿÿÕd¸dÌd€; >ÿÿÿÿÿÿßd(@< ÿÿÿÿÿÿédßd€= ÿÿÿÿÿÿòdÕdéd€> >ÿÿÿÿÿÿüd @? ÿÿÿÿÿÿeüd€@ ÿÿÿÿÿÿeòde€A >ÿÿÿÿÿÿe @B ÿÿÿÿÿÿ#ee€C ÿÿÿÿÿÿ,ee#e€D >ÿÿÿÿÿÿ6e (@E ÿÿÿÿÿÿ@e6e€F ÿÿÿÿÿÿIe,e@e€G >ÿÿÿÿÿÿSe@H ÿÿÿÿÿÿ]eSe€I ÿÿÿÿÿÿfeIe]e€J >ÿÿÿÿÿÿpe(@K ÿÿÿÿÿÿzepe€L ÿÿÿÿÿÿƒefeze€M >ÿÿÿÿÿÿe(@N ÿÿÿÿÿÿ—ee€O ÿÿÿÿÿÿ eƒe—e€P ÿÿÿÿÿÿªeˆd e€Q ÿÿÿÿÿÿ´e `ªe€R >ÿÿÿÿÿÿ¾e"@S ÿÿÿÿÿÿÈe¾e€T >ÿÿÿÿÿÿÑe4@U ÿÿÿÿÿÿÛeÑe€V ÿÿÿÿÿÿäeÈeÛe€W >ÿÿÿÿÿÿîeF@X ÿÿÿÿÿÿøeîe€Y ÿÿÿÿÿÿfäeøe€Z >ÿÿÿÿÿÿ fX@[ ÿÿÿÿÿÿf f€\ ÿÿÿÿÿÿfff€] >ÿÿÿÿÿÿ(f"4@^ ÿÿÿÿÿÿ2f(f€_ ÿÿÿÿÿÿ;ff2f€` >ÿÿÿÿÿÿEf"F@a ÿÿÿÿÿÿOfEf€b ÿÿÿÿÿÿXf;fOf€c >ÿÿÿÿÿÿbf"X@d ÿÿÿÿÿÿlfbf€e ÿÿÿÿÿÿufXflf€f >ÿÿÿÿÿÿf4F@g ÿÿÿÿÿÿ‰ff€h ÿÿÿÿÿÿ’fuf‰f€i >ÿÿÿÿÿÿœf4X@j ÿÿÿÿÿÿ¦fœf€k ÿÿÿÿÿÿ¯f’f¦f€l >ÿÿÿÿÿÿ¹fFX@m ÿÿÿÿÿÿÃf¹f€n ÿÿÿÿÿÿÌf¯fÃf€o ÿÿÿÿÿÿÖfÎú€p ÿÿÿÿÿÿàfÖf €q ÿÿÿÿÿÿêfàfV€r ÿÿÿÿÿÿôfP¾€s ÿÿÿÿÿÿþfôfú€t ÿÿÿÿÿÿgþfT€u ÿÿÿÿÿÿggþ€v ÿÿÿÿÿÿgg&€w ÿÿÿÿÿÿ&ggv€x ÿÿÿÿÿÿ0g&g €y ÿÿÿÿÿÿ:g0g„€z ÿÿÿÿÿÿDg:gÀ€{ ÿÿÿÿÿÿNgDgV€| ÿÿÿÿÿÿXgNgt€} ÿÿÿÿÿÿbgXg΀~ ÿÿÿÿÿÿlgbgP€ ÿÿÿÿÿÿvglgÈ€€ ÿÿÿÿÿÿ€gvg€ ÿÿÿÿÿÿŠg€g|€‚ ÿÿÿÿÿÿ”gŠg€ƒ ÿÿÿÿÿÿžg”gX€„ ÿÿÿÿÿÿ¨gžg”€… ÿÿÿÿÿÿ²g¨g* €† ÿÿÿÿÿÿ¼g²g˜ €‡ ÿÿÿÿÿÿÆg¼gÔ €ˆ ÿÿÿÿÿÿÐgÆg$ €‰ ÿÿÿÿÿÿÚgÐg~ @Š ÿÿÿÿÿÿägÚg€‹ ÿÿÿÿÿÿígg€Œ ÿÿÿÿÿÿ÷gíg”€ ÿÿÿÿÿÿh÷g €Ž ÿÿÿÿÿÿ hh„€ ÿÿÿÿÿÿh h¬€ ÿÿÿÿÿÿhhV€‘ ÿÿÿÿÿÿ)hht€’ ÿÿÿÿÿÿ3h)h΀“ ÿÿÿÿÿÿ=h3hP€” ÿÿÿÿÿÿGh=hÈ€• ÿÿÿÿÿÿQhGh€– ÿÿÿÿÿÿ[hQh¤€— ÿÿÿÿÿÿeh[hà€˜ ÿÿÿÿÿÿohehX€™ ÿÿÿÿÿÿyhohŠ€š ÿÿÿÿÿÿƒhyh* €› ÿÿÿÿÿÿhƒhR €œ ÿÿÿÿÿÿ—hhü € ÿÿÿÿÿÿ¡h—h$ €ž ÿÿÿÿÿÿ«h¡hœ @Ÿ ÿÿÿÿÿÿµh«h  ÿÿÿÿÿÿ¾hâ œm±"Ù"ž&Ò)Â*¬,q064¢6b?âAEFÀOzYjZ´eÌfêfägµh€¡ SÿÿÿÿÿÿÞhœ~€¢ >ÿÿÿÿÿÿèh<Þh€£ >ÿÿÿÿÿÿòhœê'€¤ Sÿÿÿÿÿÿühœ<€¥ >ÿÿÿÿÿÿi°üh€¦ Sÿÿÿÿÿÿiœ°€§ >ÿÿÿÿÿÿi~i€¨ Sÿÿÿÿÿÿ$i~œ€© >ÿÿÿÿÿÿ.i°$i€ª >ÿÿÿÿÿÿ8i~³-€« >ÿÿÿÿÿÿBi4|$€¬ SÿÿÿÿÿÿLi~<€­ >ÿÿÿÿÿÿViœLi€® Sÿÿÿÿÿÿ`i~°€¯ >ÿÿÿÿÿÿji<`i€° >ÿÿÿÿÿÿti~f@€± >ÿÿÿÿÿÿ~i4x1€² >ÿÿÿÿÿÿˆi°°€³ >ÿÿÿÿÿÿ’i<¿0€´ >ÿÿÿÿÿÿœiœ;2€µ Sÿÿÿÿÿÿ¦i<œ€¶ >ÿÿÿÿÿÿ°i<¦i€· Sÿÿÿÿÿÿºi<~€¸ >ÿÿÿÿÿÿÄiœºi€¹ >ÿÿÿÿÿÿÎi~_$€º SÿÿÿÿÿÿØi<°€» >ÿÿÿÿÿÿâi°Øi€¼ Sÿÿÿÿÿÿìi°œ€½ >ÿÿÿÿÿÿöiœìi€¾ Sÿÿÿÿÿÿj°~€¿ >ÿÿÿÿÿÿ j°j€À >ÿÿÿÿÿÿj<£$€Á Sÿÿÿÿÿÿj°<€Â >ÿÿÿÿÿÿ(j~j€Ã ÿÿÿÿÿÿ2j€.(j€Ä ÿÿÿÿÿÿÿÿÿÿÿÿ+k°2.€Ý >ÿÿÿÿÿÿ5k4ê'€Þ >ÿÿÿÿÿÿ?kœüh€ß >ÿÿÿÿÿÿIk<$i€à >ÿÿÿÿÿÿSkœ|$€á >ÿÿÿÿÿÿ]k4Li€â >ÿÿÿÿÿÿgk°`i€ã >ÿÿÿÿÿÿqk4¦i€ä >ÿÿÿÿÿÿ{k°ú,€å >ÿÿÿÿÿÿ…k<Øi€æ ÿÿÿÿÿÿkPj…k€ç ÿÿÿÿÿÿ™kk{k€è ÿÿÿÿÿÿ£k™kÎi€é ÿÿÿÿÿÿ­k£kÄi€ê ÿÿÿÿÿÿ·k­kqk€ë ÿÿÿÿÿÿÁk·kœi€ì ÿÿÿÿÿÿËkÁk’i€í ÿÿÿÿÿÿÕkËkˆi€î ÿÿÿÿÿÿßkÕk~i€ï ÿÿÿÿÿÿékßkti€ð ÿÿÿÿÿÿókékgk€ñ ÿÿÿÿÿÿýkók]k€ò ÿÿÿÿÿÿlýkSk€ó ÿÿÿÿÿÿll8i€ô ÿÿÿÿÿÿllIk€õ ÿÿÿÿÿÿ%lli€ö ÿÿÿÿÿÿ/l%l?k€÷ ÿÿÿÿÿÿ9l/l5k€ø ÿÿÿÿÿÿCl9lèh€ù ÿÿÿÿÿÿMlCl+k@ú ÿÿÿÿÿÿWl†Ù€û ÿÿÿÿÿÿ`lˆij€ü ÿÿÿÿÿÿjl`lÎi€ý ÿÿÿÿÿÿtljlœi€þ >ÿÿÿÿÿÿ~l~œ@ÿ ÿÿÿÿÿÿˆl~l€ >ÿÿÿÿÿÿ‘l<œ@ ÿÿÿÿÿÿ›l‘l€ ÿÿÿÿÿÿ¤lË\v€ ÿÿÿÿÿÿ®l¤l"]€ ÿÿÿÿÿÿ¸l®lkb€ ÿÿÿÿÿÿÂl¸lñ€ ÿÿÿÿÿÿÌlÂl¸\€ ÿÿÿÿÿÿÖlÌl›l€ ÿÿÿÿÿÿàlÖl'€ ÿÿÿÿÿÿêlàlú€ ÿÿÿÿÿÿôlêlˆl€ >ÿÿÿÿÿÿþl2.Þh@ ÿÿÿÿÿÿmþl€ >ÿÿÿÿÿÿmê'2.@ ÿÿÿÿÿÿmm€ >ÿÿÿÿÿÿ$mê'Þh@ ÿÿÿÿÿÿ.m$m€ >ÿÿÿÿÿÿ7m2.üh@ ÿÿÿÿÿÿAm7m€ >ÿÿÿÿÿÿJmÞhüh@ ÿÿÿÿÿÿTmJm€ >ÿÿÿÿÿÿ]mê'üh@ ÿÿÿÿÿÿgm]m€ >ÿÿÿÿÿÿpm2.i@ ÿÿÿÿÿÿzmpm€ >ÿÿÿÿÿÿƒmÞhi@ ÿÿÿÿÿÿmƒm€ >ÿÿÿÿÿÿ–mê'i@ ÿÿÿÿÿÿ m–m€ >ÿÿÿÿÿÿ©mühi@ ÿÿÿÿÿÿ³m©m€ ÿÿÿÿÿÿ¼m³m m€ ÿÿÿÿÿÿÆm¼mm€! ÿÿÿÿÿÿÐmÆmzm€" ÿÿÿÿÿÿÚmÐmgm€# ÿÿÿÿÿÿämÚmTm€$ ÿÿÿÿÿÿîmämAm€% ÿÿÿÿÿÿømîm.m€& ÿÿÿÿÿÿnømm€' ÿÿÿÿÿÿ nnm€( >ÿÿÿÿÿÿn³-$i@) ÿÿÿÿÿÿ nn€* >ÿÿÿÿÿÿ)n|$$i@+ ÿÿÿÿÿÿ3n)n€, >ÿÿÿÿÿÿÿÿÿÿÿÿOn$iLi@/ ÿÿÿÿÿÿYnOn€0 >ÿÿÿÿÿÿbn³-Li@1 ÿÿÿÿÿÿlnbn€2 >ÿÿÿÿÿÿun|$Li@3 ÿÿÿÿÿÿnun€4 >ÿÿÿÿÿÿˆn$i`i@5 ÿÿÿÿÿÿ’nˆn€6 >ÿÿÿÿÿÿ›n³-`i@7 ÿÿÿÿÿÿ¥n›n€8 >ÿÿÿÿÿÿ®n|$`i@9 ÿÿÿÿÿÿ¸n®n€: >ÿÿÿÿÿÿÁnLi`i@; ÿÿÿÿÿÿËnÁn€< ÿÿÿÿÿÿÔnËn¸n€= ÿÿÿÿÿÿÞnÔn¥n€> ÿÿÿÿÿÿènÞn’n€? ÿÿÿÿÿÿònènn€@ ÿÿÿÿÿÿünònln€A ÿÿÿÿÿÿoünYn€B ÿÿÿÿÿÿooFn€C ÿÿÿÿÿÿoo3n€D ÿÿÿÿÿÿ$oo n€E >ÿÿÿÿÿÿ.ox1f@@F ÿÿÿÿÿÿ8o.o€G >ÿÿÿÿÿÿAo°f@@H ÿÿÿÿÿÿKoAo€I >ÿÿÿÿÿÿTo°x1@J ÿÿÿÿÿÿ^oTo€K >ÿÿÿÿÿÿgo¿0f@@L ÿÿÿÿÿÿqogo€M >ÿÿÿÿÿÿzo¿0x1@N ÿÿÿÿÿÿ„ozo€O >ÿÿÿÿÿÿo°¿0@P ÿÿÿÿÿÿ—oo€Q >ÿÿÿÿÿÿ o;2f@@R ÿÿÿÿÿÿªo o€S >ÿÿÿÿÿÿ³ox1;2@T ÿÿÿÿÿÿ½o³o€U >ÿÿÿÿÿÿÆo°;2@V ÿÿÿÿÿÿÐoÆo€W >ÿÿÿÿÿÿÙo¿0;2@X ÿÿÿÿÿÿãoÙo€Y ÿÿÿÿÿÿìoãoÐo€Z ÿÿÿÿÿÿöoìo½o€[ ÿÿÿÿÿÿpöoªo€\ ÿÿÿÿÿÿ pp—o€] ÿÿÿÿÿÿp p„o€^ ÿÿÿÿÿÿppqo€_ ÿÿÿÿÿÿ(pp^o€` ÿÿÿÿÿÿ2p(pKo€a ÿÿÿÿÿÿÿÿÿÿÿÿFp¦iºi@c ÿÿÿÿÿÿPpFp€d >ÿÿÿÿÿÿYp_$¦i@e ÿÿÿÿÿÿcpYp€f >ÿÿÿÿÿÿlp_$ºi@g ÿÿÿÿÿÿvplp€h >ÿÿÿÿÿÿpú,¦i@i ÿÿÿÿÿÿ‰pp€j >ÿÿÿÿÿÿ’pú,ºi@k ÿÿÿÿÿÿœp’p€l >ÿÿÿÿÿÿ¥p_$ú,@m ÿÿÿÿÿÿ¯p¥p€n >ÿÿÿÿÿÿ¸p¦iØi@o ÿÿÿÿÿÿÂp¸p€p >ÿÿÿÿÿÿËpºiØi@q ÿÿÿÿÿÿÕpËp€r >ÿÿÿÿÿÿÞp_$Øi@s ÿÿÿÿÿÿèpÞp€t >ÿÿÿÿÿÿñpú,Øi@u ÿÿÿÿÿÿûpñp€v ÿÿÿÿÿÿqûpèp€w ÿÿÿÿÿÿqqÕp€x ÿÿÿÿÿÿqqÂp€y ÿÿÿÿÿÿ"qq¯p€z ÿÿÿÿÿÿ,q"qœp€{ ÿÿÿÿÿÿ6q,q‰p€| ÿÿÿÿÿÿ@q6qvp€} ÿÿÿÿÿÿJq@qcp€~ ÿÿÿÿÿÿTqJqPp€ >ÿÿÿÿÿÿ^qìij@€ ÿÿÿÿÿÿhq^q€ >ÿÿÿÿÿÿqq£$ìi@‚ ÿÿÿÿÿÿ{qqq€ƒ >ÿÿÿÿÿÿ„q£$j@„ ÿÿÿÿÿÿŽq„q€… >ÿÿÿÿÿÿ—qìij@† ÿÿÿÿÿÿ¡q—q€‡ >ÿÿÿÿÿÿªqjj@ˆ ÿÿÿÿÿÿ´qªq€‰ >ÿÿÿÿÿÿ½q£$j@Š ÿÿÿÿÿÿÇq½q€‹ >ÿÿÿÿÿÿÐqv.ìi@Œ ÿÿÿÿÿÿÚqÐq€ >ÿÿÿÿÿÿãqv.j@Ž ÿÿÿÿÿÿíqãq€ >ÿÿÿÿÿÿöq£$v.@ ÿÿÿÿÿÿröq€‘ >ÿÿÿÿÿÿ rv.j@’ ÿÿÿÿÿÿr r€“ ÿÿÿÿÿÿrrr€” ÿÿÿÿÿÿ&rríq€• ÿÿÿÿÿÿ0r&rÚq€– ÿÿÿÿÿÿ:r0rÇq€— ÿÿÿÿÿÿDr:r´q€˜ ÿÿÿÿÿÿNrDr¡q€™ ÿÿÿÿÿÿXrNrŽq€š ÿÿÿÿÿÿbrXr{q€› ÿÿÿÿÿÿlrbrhq€œ ÿÿÿÿÿÿvrlrTq€ ÿÿÿÿÿÿ€rvrÿÿÿÿÿÿžr2.$i@¡ ÿÿÿÿÿÿ¨ržr€¢ >ÿÿÿÿÿÿ±r2.f@@£ ÿÿÿÿÿÿ»r±r€¤ >ÿÿÿÿÿÿÄrf@$i@¥ ÿÿÿÿÿÿÎrÄr€¦ >ÿÿÿÿÿÿ×r2.¦i@§ ÿÿÿÿÿÿár×r€¨ >ÿÿÿÿÿÿêr$i¦i@© ÿÿÿÿÿÿôrêr€ª >ÿÿÿÿÿÿýrf@¦i@« ÿÿÿÿÿÿsýr€¬ >ÿÿÿÿÿÿs2.ìi@­ ÿÿÿÿÿÿss€® >ÿÿÿÿÿÿ#s$iìi@¯ ÿÿÿÿÿÿ-s#s€° >ÿÿÿÿÿÿ6sf@ìi@± ÿÿÿÿÿÿ@s6s€² >ÿÿÿÿÿÿIs¦iìi@³ ÿÿÿÿÿÿSsIs€´ ÿÿÿÿÿÿ\sSs@s€µ ÿÿÿÿÿÿfs\s-s€¶ ÿÿÿÿÿÿpsfss€· ÿÿÿÿÿÿzspss€¸ ÿÿÿÿÿÿ„szsôr€¹ ÿÿÿÿÿÿŽs„sár€º ÿÿÿÿÿÿ˜sŽsÎr€» ÿÿÿÿÿÿ¢s˜s»r€¼ ÿÿÿÿÿÿ¬s¢s¨r€½ >ÿÿÿÿÿÿ¶s³-Þh@¾ ÿÿÿÿÿÿÀs¶s€¿ >ÿÿÿÿÿÿÉsx1Þh@À ÿÿÿÿÿÿÓsÉs€Á >ÿÿÿÿÿÿÜs³-x1@ ÿÿÿÿÿÿæsÜs€Ã >ÿÿÿÿÿÿïsÞhºi@Ä ÿÿÿÿÿÿùsïs€Å >ÿÿÿÿÿÿt³-ºi@Æ ÿÿÿÿÿÿ tt€Ç >ÿÿÿÿÿÿtx1ºi@È ÿÿÿÿÿÿtt€É >ÿÿÿÿÿÿ(tÞhj@Ê ÿÿÿÿÿÿ2t(t€Ë >ÿÿÿÿÿÿ;t³-j@Ì ÿÿÿÿÿÿEt;t€Í >ÿÿÿÿÿÿNtx1j@Î ÿÿÿÿÿÿXtNt€Ï >ÿÿÿÿÿÿatºij@Ð ÿÿÿÿÿÿktat€Ñ ÿÿÿÿÿÿttktXt€Ò ÿÿÿÿÿÿ~tttEt€Ó ÿÿÿÿÿÿˆt~t2t€Ô ÿÿÿÿÿÿ’tˆtt€Õ ÿÿÿÿÿÿœt’t t€Ö ÿÿÿÿÿÿ¦tœtùs€× ÿÿÿÿÿÿ°t¦tæs€Ø ÿÿÿÿÿÿºt°tÓs€Ù ÿÿÿÿÿÿÄtºtÀs€Ú >ÿÿÿÿÿÿÎt|$ê'@Û ÿÿÿÿÿÿØtÎt€Ü >ÿÿÿÿÿÿát°ê'@Ý ÿÿÿÿÿÿëtát€Þ >ÿÿÿÿÿÿôt°|$@ß ÿÿÿÿÿÿþtôt€à >ÿÿÿÿÿÿu_$ê'@á ÿÿÿÿÿÿuu€â >ÿÿÿÿÿÿu_$|$@ã ÿÿÿÿÿÿ$uu€ä >ÿÿÿÿÿÿ-u°_$@å ÿÿÿÿÿÿ7u-u€æ >ÿÿÿÿÿÿ@u£$ê'@ç ÿÿÿÿÿÿJu@u€è >ÿÿÿÿÿÿSu|$£$@é ÿÿÿÿÿÿ]uSu€ê >ÿÿÿÿÿÿfu°£$@ë ÿÿÿÿÿÿpufu€ì >ÿÿÿÿÿÿyu_$£$@í ÿÿÿÿÿÿƒuyu€î ÿÿÿÿÿÿŒuƒupu€ï ÿÿÿÿÿÿ–uŒu]u€ð ÿÿÿÿÿÿ u–uJu€ñ ÿÿÿÿÿÿªu u7u€ò ÿÿÿÿÿÿ´uªu$u€ó ÿÿÿÿÿÿ¾u´uu€ô ÿÿÿÿÿÿÈu¾uþt€õ ÿÿÿÿÿÿÒuÈuët€ö ÿÿÿÿÿÿÜuÒuØt€÷ >ÿÿÿÿÿÿæuühLi@ø ÿÿÿÿÿÿðuæu€ù >ÿÿÿÿÿÿùu¿0üh@ú ÿÿÿÿÿÿvùu€û >ÿÿÿÿÿÿ v¿0Li@ü ÿÿÿÿÿÿv v€ý >ÿÿÿÿÿÿvú,üh@þ ÿÿÿÿÿÿ)vv€ÿ >ÿÿÿÿÿÿ2vú,Li@ ÿÿÿÿÿÿÿÿÿÿÿÿEvú,¿0@ ÿÿÿÿÿÿOvEv€ >ÿÿÿÿÿÿXvühj@ ÿÿÿÿÿÿbvXv€ >ÿÿÿÿÿÿkvLij@ ÿÿÿÿÿÿuvkv€ >ÿÿÿÿÿÿ~v¿0j@ ÿÿÿÿÿÿˆv~v€ >ÿÿÿÿÿÿ‘vú,j@ ÿÿÿÿÿÿ›v‘v€ ÿÿÿÿÿÿ¤v›vˆv€ ÿÿÿÿÿÿ®v¤vuv€ ÿÿÿÿÿÿ¸v®vbv€ ÿÿÿÿÿÿÂv¸vOv€ ÿÿÿÿÿÿÌvÂvÿÿÿÿÿÿþvi`i@ ÿÿÿÿÿÿwþv€ >ÿÿÿÿÿÿw;2i@ ÿÿÿÿÿÿww€ >ÿÿÿÿÿÿ$w;2`i@ ÿÿÿÿÿÿ.w$w€ >ÿÿÿÿÿÿ7wiØi@ ÿÿÿÿÿÿAw7w€ >ÿÿÿÿÿÿJw`iØi@ ÿÿÿÿÿÿTwJw€ >ÿÿÿÿÿÿ]w;2Øi@ ÿÿÿÿÿÿgw]w€ >ÿÿÿÿÿÿpwv.i@! ÿÿÿÿÿÿzwpw€" >ÿÿÿÿÿÿƒwv.`i@# ÿÿÿÿÿÿwƒw€$ >ÿÿÿÿÿÿ–wv.;2@% ÿÿÿÿÿÿ w–w€& >ÿÿÿÿÿÿ©wv.Øi@' ÿÿÿÿÿÿ³w©w€( ÿÿÿÿÿÿ¼w³w w€) ÿÿÿÿÿÿÆw¼ww€* ÿÿÿÿÿÿÐwÆwzw€+ ÿÿÿÿÿÿÚwÐwgw€, ÿÿÿÿÿÿäwÚwTw€- ÿÿÿÿÿÿîwäwAw€. ÿÿÿÿÿÿøwîw.w€/ ÿÿÿÿÿÿxøww€0 ÿÿÿÿÿÿ xxw€1 ÿÿÿÿÿÿx xôv€2 ÿÿÿÿÿÿ xxÜu€3 ÿÿÿÿÿÿ*x xÄt€4 ÿÿÿÿÿÿ4x*x¬s€5 ÿÿÿÿÿÿ>x4x”r€6 SÿÿÿÿÿÿHx2.œ€7 >ÿÿÿÿÿÿRxœHx@8 ÿÿÿÿÿÿ\xRx€9 Sÿÿÿÿÿÿex$i~€: >ÿÿÿÿÿÿoxœex@; ÿÿÿÿÿÿyxox€< Sÿÿÿÿÿÿ‚xf@4€= >ÿÿÿÿÿÿŒxœ‚x@> ÿÿÿÿÿÿ–xŒx€? SÿÿÿÿÿÿŸx¦i<€@ >ÿÿÿÿÿÿ©xœŸx@A ÿÿÿÿÿÿ³x©x€B Sÿÿÿÿÿÿ¼xìi°€C >ÿÿÿÿÿÿÆxœ¼x@D ÿÿÿÿÿÿÐxÆx€E ÿÿÿÿÿÿÙxÐx³x€F ÿÿÿÿÿÿãxÙx–x€G ÿÿÿÿÿÿíxãxyx€H ÿÿÿÿÿÿ÷xíx\x€I SÿÿÿÿÿÿyÞhœ€J >ÿÿÿÿÿÿ y~y@K ÿÿÿÿÿÿy y€L Sÿÿÿÿÿÿy³-~€M >ÿÿÿÿÿÿ(y~y@N ÿÿÿÿÿÿ2y(y€O Sÿÿÿÿÿÿ;yx14€P >ÿÿÿÿÿÿEy~;y@Q ÿÿÿÿÿÿOyEy€R SÿÿÿÿÿÿXyºi<€S >ÿÿÿÿÿÿby~Xy@T ÿÿÿÿÿÿlyby€U Sÿÿÿÿÿÿuyj°€V >ÿÿÿÿÿÿy~uy@W ÿÿÿÿÿÿ‰yy€X ÿÿÿÿÿÿ’y‰yly€Y ÿÿÿÿÿÿœy’yOy€Z ÿÿÿÿÿÿ¦yœy2y€[ ÿÿÿÿÿÿ°y¦yy€\ Sÿÿÿÿÿÿºyê'œ€] >ÿÿÿÿÿÿÄy4ºy@^ ÿÿÿÿÿÿÎyÄy€_ Sÿÿÿÿÿÿ×y|$~€` >ÿÿÿÿÿÿáy4×y@a ÿÿÿÿÿÿëyáy€b Sÿÿÿÿÿÿôy_$<€c >ÿÿÿÿÿÿþy4ôy@d ÿÿÿÿÿÿzþy€e Sÿÿÿÿÿÿz£$°€f >ÿÿÿÿÿÿz4z@g ÿÿÿÿÿÿ%zz€h ÿÿÿÿÿÿ.z%zz€i ÿÿÿÿÿÿ8z.z·$€j ÿÿÿÿÿÿBz8zëy€k ÿÿÿÿÿÿLzBzÎy€l SÿÿÿÿÿÿVzühœ€m >ÿÿÿÿÿÿ`z<Vz@n ÿÿÿÿÿÿjz`z€o SÿÿÿÿÿÿszLi~€p >ÿÿÿÿÿÿ}z<sz@q ÿÿÿÿÿÿ‡z}z€r Sÿÿÿÿÿÿz¿04€s >ÿÿÿÿÿÿšz<z@t ÿÿÿÿÿÿ¤zšz€u Sÿÿÿÿÿÿ­zú,<€v >ÿÿÿÿÿÿ·z<­z@w ÿÿÿÿÿÿÁz·z€x SÿÿÿÿÿÿÊzj°€y >ÿÿÿÿÿÿÔz<Êz@z ÿÿÿÿÿÿÞzÔz€{ ÿÿÿÿÿÿçzÞzÁz€| ÿÿÿÿÿÿñzçz¤z€} ÿÿÿÿÿÿûzñz‡z€~ ÿÿÿÿÿÿ{ûzjz€ Sÿÿÿÿÿÿ{iœ€€ >ÿÿÿÿÿÿ{°{@ ÿÿÿÿÿÿ#{{€‚ Sÿÿÿÿÿÿ,{`i~€ƒ >ÿÿÿÿÿÿ6{°,{@„ ÿÿÿÿÿÿ@{6{€… SÿÿÿÿÿÿI{;24€† >ÿÿÿÿÿÿS{°I{@‡ ÿÿÿÿÿÿ]{S{€ˆ Sÿÿÿÿÿÿf{Øi<€‰ >ÿÿÿÿÿÿp{°f{@Š ÿÿÿÿÿÿz{p{€‹ Sÿÿÿÿÿÿƒ{v.°€Œ >ÿÿÿÿÿÿ{°ƒ{@ ÿÿÿÿÿÿ—{{€Ž ÿÿÿÿÿÿ {—{z{€ ÿÿÿÿÿÿª{ {]{€ ÿÿÿÿÿÿ´{ª{@{€‘ ÿÿÿÿÿÿ¾{´{#{€’ ÿÿÿÿÿÿÈ{¾{{€“ ÿÿÿÿÿÿÒ{È{Lz€” ÿÿÿÿÿÿÜ{Ò{°y€• ÿÿÿÿÿÿæ{Ü{÷x€– >ÿÿÿÿÿÿð{œ2.@— ÿÿÿÿÿÿú{ð{€˜ ÿÿÿÿÿÿ|ð{ú{€™ >ÿÿÿÿÿÿ |~2.@š ÿÿÿÿÿÿ| |€› >ÿÿÿÿÿÿ |œÞh€œ ÿÿÿÿÿÿ*| ||€ ÿÿÿÿÿÿ4|òhg4€ž >ÿÿÿÿÿÿ>|<2.@Ÿ ÿÿÿÿÿÿH|>|€  ÿÿÿÿÿÿQ|?kH|@¡ ÿÿÿÿÿÿ[|+k€¢ >ÿÿÿÿÿÿd|œi€£ ÿÿÿÿÿÿn|d|[|€¤ ÿÿÿÿÿÿx|n|Q|€¥ ÿÿÿÿÿÿ‚|x|4|€¦ ÿÿÿÿÿÿŒ|‚|*|€§ ÿÿÿÿÿÿ–|Œ||€¨ >ÿÿÿÿÿÿ |œ$i@© ÿÿÿÿÿÿª| |€ª ÿÿÿÿÿÿ³| |ª|€« >ÿÿÿÿÿÿ½|~$i@¬ ÿÿÿÿÿÿÇ|½|€­ >ÿÿÿÿÿÿÐ|œ³-€® ÿÿÿÿÿÿÚ|Ð|Ç|€¯ >ÿÿÿÿÿÿä|4$i@° ÿÿÿÿÿÿî|ä|€± ÿÿÿÿÿÿ÷|Skî|@² ÿÿÿÿÿÿ}Ik€³ ÿÿÿÿÿÿ }Vi}@´ ÿÿÿÿÿÿ}.i€µ >ÿÿÿÿÿÿ}œ`i€¶ ÿÿÿÿÿÿ'}}}€· ÿÿÿÿÿÿ1}'} }€¸ ÿÿÿÿÿÿ;}1}÷|€¹ ÿÿÿÿÿÿE};}Ú|€º ÿÿÿÿÿÿO}E}³|€» >ÿÿÿÿÿÿY}œf@@¼ ÿÿÿÿÿÿc}Y}€½ ÿÿÿÿÿÿl}Y}c}@¾ ÿÿÿÿÿÿv}ti€¿ >ÿÿÿÿÿÿ}œx1€À ÿÿÿÿÿÿ‰}}v}€Á >ÿÿÿÿÿÿ“}4f@@ ÿÿÿÿÿÿ}“}€Ã ÿÿÿÿÿÿ¦}ab}€Ä >ÿÿÿÿÿÿ°}<f@@Å ÿÿÿÿÿÿº}°}€Æ >ÿÿÿÿÿÿÃ}œ¿0€Ç ÿÿÿÿÿÿÍ}Ã}º}€È ÿÿÿÿÿÿ×}œiKo€É ÿÿÿÿÿÿá}×}Í}€Ê ÿÿÿÿÿÿë}á}¦}€Ë ÿÿÿÿÿÿõ}ë}‰}€Ì ÿÿÿÿÿÿÿ}õ}l}€Í >ÿÿÿÿÿÿ ~œ¦i@Î ÿÿÿÿÿÿ~ ~€Ï ÿÿÿÿÿÿ~ ~~€Ð >ÿÿÿÿÿÿ&~~¦i@Ñ ÿÿÿÿÿÿ0~&~€Ò ÿÿÿÿÿÿ9~Äi0~@Ó ÿÿÿÿÿÿC~qk€Ô >ÿÿÿÿÿÿL~œ_$€Õ ÿÿÿÿÿÿV~L~C~@Ö ÿÿÿÿÿÿ`~°i€× >ÿÿÿÿÿÿi~œú,€Ø ÿÿÿÿÿÿs~i~`~€Ù >ÿÿÿÿÿÿ}~°¦i@Ú ÿÿÿÿÿÿ‡~}~€Û >ÿÿÿÿÿÿ~œØi€Ü ÿÿÿÿÿÿš~~‡~€Ý ÿÿÿÿÿÿ¤~š~s~€Þ ÿÿÿÿÿÿ®~¤~V~€ß ÿÿÿÿÿÿ¸~®~9~€à ÿÿÿÿÿÿÂ~¸~~@á ÿÿÿÿÿÿÌ~öi€â ÿÿÿÿÿÿÕ~öiÌ~€ã >ÿÿÿÿÿÿß~~ìi@ä ÿÿÿÿÿÿé~ß~€å >ÿÿÿÿÿÿò~œj€æ ÿÿÿÿÿÿü~ò~é~€ç >ÿÿÿÿÿÿ4ìi@è ÿÿÿÿÿÿ€é >ÿÿÿÿÿÿœ£$€ê ÿÿÿÿÿÿ#€ë >ÿÿÿÿÿÿ-<ìi@ì ÿÿÿÿÿÿ7-€í >ÿÿÿÿÿÿ@œj€î ÿÿÿÿÿÿJ@7€ï >ÿÿÿÿÿÿT°ìi@ð ÿÿÿÿÿÿ^T€ñ >ÿÿÿÿÿÿgœv.€ò ÿÿÿÿÿÿqg^€ó ÿÿÿÿÿÿ{qJ€ô ÿÿÿÿÿÿ…{#€õ ÿÿÿÿÿÿ…ü~€ö ÿÿÿÿÿÿ™Õ~€÷ ÿÿÿÿÿÿ£™Â~€ø ÿÿÿÿÿÿ­£ÿ}€ù ÿÿÿÿÿÿ·­O}€ú ÿÿÿÿÿÿÁ·–|@û ÿÿÿÿÿÿË |€ü ÿÿÿÿÿÿÔ |Ë€ý >ÿÿÿÿÿÿÞ~Þh@þ ÿÿÿÿÿÿèÞ€ÿ ÿÿÿÿÿÿñÞè€ >ÿÿÿÿÿÿû4Þh@ ÿÿÿÿÿÿ€û€ >ÿÿÿÿÿÿ€~ê'€ ÿÿÿÿÿÿ€€€@ ÿÿÿÿÿÿ"€èh€ >ÿÿÿÿÿÿ+€~üh€ ÿÿÿÿÿÿ5€+€"€€ >ÿÿÿÿÿÿ?€°Þh@ ÿÿÿÿÿÿI€?€€ ÿÿÿÿÿÿR€iI€€ ÿÿÿÿÿÿ\€R€5€€ ÿÿÿÿÿÿf€\€€€ ÿÿÿÿÿÿp€f€ñ€ ÿÿÿÿÿÿz€p€Ô@ ÿÿÿÿÿÿ„€Ð|€ ÿÿÿÿÿÿ€½|„€@ ÿÿÿÿÿÿ—€8i€ ÿÿÿÿÿÿ €8i—€€ >ÿÿÿÿÿÿª€~|$€ ÿÿÿÿÿÿ´€ª€Ç-€ >ÿÿÿÿÿÿ¾€<³-@ ÿÿÿÿÿÿÈ€¾€€ >ÿÿÿÿÿÿÑ€~Li€ ÿÿÿÿÿÿۀрȀ€ >ÿÿÿÿÿÿ倰³-@ ÿÿÿÿÿÿï€å€€ >ÿÿÿÿÿÿø€~`i€ ÿÿÿÿÿÿø€ï€€ ÿÿÿÿÿÿ Û€€ ÿÿÿÿÿÿ ´€€ ÿÿÿÿÿÿ  €€ ÿÿÿÿÿÿ* €@ ÿÿÿÿÿÿ4}€! ÿÿÿÿÿÿ=ti4€" >ÿÿÿÿÿÿG~x1@# ÿÿÿÿÿÿQG€$ ÿÿÿÿÿÿZGQ@% ÿÿÿÿÿÿd~i€& ÿÿÿÿÿÿm]d€' >ÿÿÿÿÿÿw<x1@( ÿÿÿÿÿÿw€) >ÿÿÿÿÿÿŠ~¿0€* ÿÿÿÿÿÿ”Š€+ >ÿÿÿÿÿÿž~;2€, ÿÿÿÿÿÿ¨ž^o€- ÿÿÿÿÿÿ²¨”€. ÿÿÿÿÿÿ¼²m€/ ÿÿÿÿÿÿƼZ€0 ÿÿÿÿÿÿÐÆ=@1 ÿÿÿÿÿÿÚÄi€2 ÿÿÿÿÿÿã&~Ú€3 >ÿÿÿÿÿÿí~ºi@4 ÿÿÿÿÿÿ÷í€5 ÿÿÿÿÿÿ‚í÷€6 >ÿÿÿÿÿÿ ‚4ºi@7 ÿÿÿÿÿÿ‚ ‚€8 ÿÿÿÿÿÿ‚Îi‚€9 >ÿÿÿÿÿÿ'‚<ºi@: ÿÿÿÿÿÿ1‚'‚€; >ÿÿÿÿÿÿ:‚~ú,€< ÿÿÿÿÿÿD‚:‚1‚€= >ÿÿÿÿÿÿN‚°ºi@> ÿÿÿÿÿÿX‚N‚€? >ÿÿÿÿÿÿa‚~Øi€@ ÿÿÿÿÿÿk‚a‚X‚€A ÿÿÿÿÿÿu‚k‚D‚€B ÿÿÿÿÿÿ‚u‚‚€C ÿÿÿÿÿÿ‰‚‚‚€D ÿÿÿÿÿÿ“‚‰‚ã@E ÿÿÿÿÿÿ‚ò~€F ÿÿÿÿÿÿ¦‚ß~‚€G >ÿÿÿÿÿÿ°‚~j@H ÿÿÿÿÿÿº‚°‚€I ÿÿÿÿÿÿ°‚º‚€J >ÿÿÿÿÿÿÍ‚4j@K ÿÿÿÿÿÿׂ͂€L >ÿÿÿÿÿÿà‚~£$€M ÿÿÿÿÿÿê‚à‚ׂ€N >ÿÿÿÿÿÿô‚<j@O ÿÿÿÿÿÿþ‚ô‚€P ÿÿÿÿÿÿƒ(jþ‚@Q ÿÿÿÿÿÿƒ j€R >ÿÿÿÿÿÿƒ~v.€S ÿÿÿÿÿÿ$ƒƒƒ€T ÿÿÿÿÿÿ.ƒ$ƒƒ€U ÿÿÿÿÿÿ8ƒ.ƒê‚€V ÿÿÿÿÿÿBƒ8ƒÃ‚€W ÿÿÿÿÿÿLƒBƒ¦‚€X ÿÿÿÿÿÿVƒLƒ“‚€Y ÿÿÿÿÿÿ`ƒVƒÐ€Z ÿÿÿÿÿÿjƒ`ƒ*€[ ÿÿÿÿÿÿtƒjƒz€@\ ÿÿÿÿÿÿ~ƒòh€] ÿÿÿÿÿÿ‡ƒ]4~ƒ@^ ÿÿÿÿÿÿ‘ƒ€€_ ÿÿÿÿÿÿšƒû‘ƒ@` ÿÿÿÿÿÿ¤ƒ5k€a ÿÿÿÿÿÿ­ƒ5k¤ƒ€b >ÿÿÿÿÿÿ·ƒ<ê'@c ÿÿÿÿÿÿÁƒ·ƒ€d >ÿÿÿÿÿÿʃ4üh€e ÿÿÿÿÿÿԃʃÁƒ€f >ÿÿÿÿÿÿÞƒ4i€g ÿÿÿÿÿÿèƒÞƒët€h ÿÿÿÿÿÿòƒèƒÔƒ€i ÿÿÿÿÿÿüƒòƒ­ƒ€j ÿÿÿÿÿÿ„üƒšƒ€k ÿÿÿÿÿÿ„„‡ƒ@l ÿÿÿÿÿÿ„Sk€m ÿÿÿÿÿÿ#„ä|„@n ÿÿÿÿÿÿ-„ª€€o ÿÿÿÿÿÿ6„½--„@p ÿÿÿÿÿÿ@„Bi€q ÿÿÿÿÿÿI„Bi@„€r >ÿÿÿÿÿÿS„<|$@s ÿÿÿÿÿÿ]„S„€t ÿÿÿÿÿÿf„]k]„€u >ÿÿÿÿÿÿp„4`i€v ÿÿÿÿÿÿz„p„þt€w ÿÿÿÿÿÿ„„z„f„€x ÿÿÿÿÿÿŽ„„„I„€y ÿÿÿÿÿÿ˜„Ž„6„€z ÿÿÿÿÿÿ¢„˜„#„€{ ÿÿÿÿÿÿ¬„“}kb€| ÿÿÿÿÿÿ¶„~i"]€} >ÿÿÿÿÿÿÀ„4¿0€~ ÿÿÿÿÿÿÊ„À„Ë\@ ÿÿÿÿÿÿÔ„€€ ÿÿÿÿÿÿÝ„E2€ ÿÿÿÿÿÿç„Ý„Ê„€‚ ÿÿÿÿÿÿñ„ç„„T€ƒ ÿÿÿÿÿÿû„ñ„¶„€„ ÿÿÿÿÿÿ…û„¬„@… ÿÿÿÿÿÿ…L~€† ÿÿÿÿÿÿ…qk…@‡ ÿÿÿÿÿÿ"…Îi€ˆ ÿÿÿÿÿÿ+… ‚"…€‰ >ÿÿÿÿÿÿ5…4_$@Š ÿÿÿÿÿÿ?…5…€‹ ÿÿÿÿÿÿH…5…?…€Œ >ÿÿÿÿÿÿR…<_$@ ÿÿÿÿÿÿ\…R…€Ž ÿÿÿÿÿÿe…-\…€ >ÿÿÿÿÿÿo…4Øi€ ÿÿÿÿÿÿy…o…7u€‘ ÿÿÿÿÿÿƒ…y…e…€’ ÿÿÿÿÿÿ…ƒ…H…€“ ÿÿÿÿÿÿ—……+…€” ÿÿÿÿÿÿ¡…—……@• ÿÿÿÿÿÿ«…€– ÿÿÿÿÿÿ´…«…@— ÿÿÿÿÿÿ¾…à‚€˜ ÿÿÿÿÿÿÇ…Í‚¾…€™ ÿÿÿÿÿÿÑ…­$·$@š ÿÿÿÿÿÿÛ…j€› >ÿÿÿÿÿÿä…4j€œ ÿÿÿÿÿÿî…ä…Û…€ ÿÿÿÿÿÿø…€.pu€ž ÿÿÿÿÿÿ†ø…î…€Ÿ ÿÿÿÿÿÿ ††Ñ…€  ÿÿÿÿÿÿ† †Ç…€¡ ÿÿÿÿÿÿ ††´…€¢ ÿÿÿÿÿÿ*† †¡…€£ ÿÿÿÿÿÿ4†*†…€¤ ÿÿÿÿÿÿ>†4†¢„€¥ ÿÿÿÿÿÿH†>†„@¦ ÿÿÿÿÿÿR†?k€§ ÿÿÿÿÿÿ[†>|R†@¨ ÿÿÿÿÿÿe†+€€© ÿÿÿÿÿÿn†èhe†@ª ÿÿÿÿÿÿx†Êƒ€« ÿÿÿÿÿÿ†·ƒx†€¬ >ÿÿÿÿÿÿ‹†<üh@­ ÿÿÿÿÿÿ•†‹†€® ÿÿÿÿÿÿž†‹†•†@¯ ÿÿÿÿÿÿ¨†i€° >ÿÿÿÿÿÿ±†<i€± ÿÿÿÿÿÿ»†±†¨†€² ÿÿÿÿÿÿņ»†ž†€³ ÿÿÿÿÿÿφņ†€´ ÿÿÿÿÿÿنφn†€µ ÿÿÿÿÿÿã†Ù†[†@¶ ÿÿÿÿÿÿí†Vi€· ÿÿÿÿÿÿö†Ikí†@¸ ÿÿÿÿÿÿ‡Ñ€€¹ ÿÿÿÿÿÿ ‡¾€‡@º ÿÿÿÿÿÿ‡]k€» ÿÿÿÿÿÿ‡S„‡€¼ >ÿÿÿÿÿÿ&‡<Li@½ ÿÿÿÿÿÿ0‡&‡€¾ ÿÿÿÿÿÿ9‡&‡0‡€¿ >ÿÿÿÿÿÿC‡°Li@À ÿÿÿÿÿÿM‡C‡€Á ÿÿÿÿÿÿV‡jiM‡€Â ÿÿÿÿÿÿ`‡V‡9‡€Ã ÿÿÿÿÿÿj‡`‡‡€Ä ÿÿÿÿÿÿt‡j‡ ‡€Å ÿÿÿÿÿÿ~‡t‡ö†@Æ ÿÿÿÿÿÿˆ‡Ã}€Ç ÿÿÿÿÿÿ‘‡°}ˆ‡@È ÿÿÿÿÿÿ›‡Š€É ÿÿÿÿÿÿ¤‡w›‡@Ê ÿÿÿÿÿÿ®‡À„€Ë ÿÿÿÿÿÿ·‡Á\®‡@Ì ÿÿÿÿÿÿÁ‡’i€Í ÿÿÿÿÿÿʇ’iÁ‡€Î >ÿÿÿÿÿÿÔ‡<;2€Ï ÿÿÿÿÿÿÞ‡Ô‡—o€Ð ÿÿÿÿÿÿè‡Þ‡Ê‡€Ñ ÿÿÿÿÿÿò‡è‡·‡€Ò ÿÿÿÿÿÿü‡ò‡¤‡€Ó ÿÿÿÿÿÿˆü‡‘‡@Ô ÿÿÿÿÿÿˆi~€Õ ÿÿÿÿÿÿˆ°iˆ@Ö ÿÿÿÿÿÿ#ˆ:‚€× ÿÿÿÿÿÿ,ˆ'‚#ˆ€Ø ÿÿÿÿÿÿ6ˆR…-€Ù >ÿÿÿÿÿÿ@ˆ<ú,@Ú ÿÿÿÿÿÿJˆ@ˆ€Û ÿÿÿÿÿÿSˆ@ˆJˆ@Ü ÿÿÿÿÿÿ]ˆ{k€Ý ÿÿÿÿÿÿfˆ…k]ˆ€Þ ÿÿÿÿÿÿpˆfˆSˆ€ß ÿÿÿÿÿÿzˆpˆ6ˆ€à ÿÿÿÿÿÿ„ˆzˆ,ˆ€á ÿÿÿÿÿÿŽˆ„ˆˆ@â ÿÿÿÿÿÿ˜ˆ@€ã ÿÿÿÿÿÿ¡ˆ-˜ˆ@ä ÿÿÿÿÿÿ«ˆ(j€å ÿÿÿÿÿÿ´ˆô‚«ˆ@æ ÿÿÿÿÿÿ¾ˆä…€ç ÿÿÿÿÿÿLjj¾ˆ€è >ÿÿÿÿÿÿш<j@é ÿÿÿÿÿÿۈш€ê ÿÿÿÿÿÿäˆÑˆÛˆ€ë >ÿÿÿÿÿÿj@ì ÿÿÿÿÿÿøˆîˆ€í >ÿÿÿÿÿÿ‰<v.€î ÿÿÿÿÿÿ ‰‰øˆ€ï ÿÿÿÿÿÿ‰ ‰äˆ€ð ÿÿÿÿÿÿ‰‰Çˆ€ñ ÿÿÿÿÿÿ)‰‰´ˆ€ò ÿÿÿÿÿÿ3‰)‰¡ˆ€ó ÿÿÿÿÿÿ=‰3‰Žˆ€ô ÿÿÿÿÿÿG‰=‰ˆ€õ ÿÿÿÿÿÿQ‰G‰~‡€ö ÿÿÿÿÿÿ[‰Q‰ã†@÷ ÿÿÿÿÿÿe‰d|€ø ÿÿÿÿÿÿn‰+ke‰@ù ÿÿÿÿÿÿx‰i€ú ÿÿÿÿÿÿ‰?€x‰@û ÿÿÿÿÿÿ‹‰Þƒ€ü ÿÿÿÿÿÿ”‰át‹‰@ý ÿÿÿÿÿÿž‰±†€þ ÿÿÿÿÿÿ§‰iž‰€ÿ >ÿÿÿÿÿÿ±‰°i@ÿÿÿÿÿÿ»‰±‰€ÿÿÿÿÿÿĉ±‰»‰€ÿÿÿÿÿÿΉĉ§‰€ÿÿÿÿÿÿ؉Ή”‰€ÿÿÿÿÿÿâ‰Ø‰‰€ÿÿÿÿÿÿì‰â‰n‰@ÿÿÿÿÿÿö‰}€ÿÿÿÿÿÿÿ‰.iö‰@ÿÿÿÿÿÿ Šø€€ ÿÿÿÿÿÿŠå€ Š@ ÿÿÿÿÿÿŠp„€ ÿÿÿÿÿÿ%ŠôtŠ@ ÿÿÿÿÿÿ/Šji€ ÿÿÿÿÿÿ8ŠC‡/Š@ÿÿÿÿÿÿBŠgk€ÿÿÿÿÿÿKŠgkBŠ€ÿÿÿÿÿÿUŠKŠ8Š€ÿÿÿÿÿÿ_ŠUŠ%Š€ÿÿÿÿÿÿiŠ_ŠŠ€ÿÿÿÿÿÿsŠiŠÿ‰@ÿÿÿÿÿÿ}Šœi€ÿÿÿÿÿÿ†ŠAo}Š@ÿÿÿÿÿÿŠž€ÿÿÿÿÿÿ™ŠToŠ€ÿÿÿÿÿÿ£ŠO2@ÿÿÿÿÿÿ­ŠÔ‡€ÿÿÿÿÿÿ¶Šo­Š€ÿÿÿÿÿÿÀŠÆoÐo€ÿÿÿÿÿÿÊŠÀŠ¶Š€ÿÿÿÿÿÿÔŠÊŠ£Š€ÿÿÿÿÿÿÞŠÔŠ™Š€ÿÿÿÿÿÿèŠÞŠ†Š@ ÿÿÿÿÿÿòŠ~€!ÿÿÿÿÿÿûŠ}~òŠ@"ÿÿÿÿÿÿ‹a‚€#ÿÿÿÿÿÿ‹N‚‹@$ÿÿÿÿÿÿ‹o…€%ÿÿÿÿÿÿ!‹-u‹@&ÿÿÿÿÿÿ+‹…k€'ÿÿÿÿÿÿ4‹{k+‹@(ÿÿÿÿÿÿ>‹âi€)ÿÿÿÿÿÿG‹âi>‹€*ÿÿÿÿÿÿQ‹G‹4‹€+ÿÿÿÿÿÿ[‹Q‹!‹€,ÿÿÿÿÿÿe‹[‹‹€-ÿÿÿÿÿÿo‹e‹ûŠ@.ÿÿÿÿÿÿy‹g€/ÿÿÿÿÿÿ‚‹Ty‹@0ÿÿÿÿÿÿŒ‹ƒ€1ÿÿÿÿÿÿ•‹ jŒ‹€2ÿÿÿÿÿÿŸ‹fuŠ.@3ÿÿÿÿÿÿ©‹‰€4ÿÿÿÿÿÿ²‹îˆ©‹€5>ÿÿÿÿÿÿ¼‹°v.@6ÿÿÿÿÿÿÆ‹¼‹€7ÿÿÿÿÿÿÏ‹¼‹Æ‹€8ÿÿÿÿÿÿÙ‹Ï‹²‹€9ÿÿÿÿÿÿã‹Ù‹Ÿ‹€:ÿÿÿÿÿÿí‹ã‹•‹€;ÿÿÿÿÿÿ÷‹í‹‚‹€<ÿÿÿÿÿÿŒ÷‹o‹€=ÿÿÿÿÿÿ ŒŒèŠ€>ÿÿÿÿÿÿŒ ŒsŠ€?ÿÿÿÿÿÿŒŒì‰€@ÿÿÿÿÿÿ)ŒŒ[‰€Aÿÿÿÿÿÿ3Œ)ŒH†€Bÿÿÿÿÿÿ=Œ3Œtƒ€CÿÿÿÿÿÿGŒ=ŒÁ€DÿÿÿÿÿÿQŒú{ð{€Eÿÿÿÿÿÿ[ŒË |€FÿÿÿÿÿÿeŒ~ƒY}€GÿÿÿÿÿÿoŒR† ~€HÿÿÿÿÿÿyŒe‰öi€IÿÿÿÿÿÿƒŒyŒoŒ€JÿÿÿÿÿÿŒƒŒeŒ€Kÿÿÿÿÿÿ—ŒŒ[Œ€Lÿÿÿÿÿÿ¡Œ—ŒQŒ€Mÿÿÿÿÿÿ«Œª| |€NÿÿÿÿÿÿµŒ„€Ð|€Oÿÿÿÿÿÿ¿Œ„}€PÿÿÿÿÿÿÉŒí†Äi€QÿÿÿÿÿÿÓŒö‰ò~€Rÿÿÿÿÿÿ݌ӌɌ€SÿÿÿÿÿÿçŒÝŒ¿Œ€TÿÿÿÿÿÿñŒçŒµŒ€UÿÿÿÿÿÿûŒñŒ«Œ€Vÿÿÿÿÿÿc}òh€Wÿÿÿÿÿÿ4Sk€Xÿÿÿÿÿÿkbab€Yÿÿÿÿÿÿ#ˆ‡L~€Zÿÿÿÿÿÿ-}Š€[ÿÿÿÿÿÿ7-#€\ÿÿÿÿÿÿA7€]ÿÿÿÿÿÿKA€^ÿÿÿÿÿÿUK€_ÿÿÿÿÿÿ_~?k€`ÿÿÿÿÿÿiÚVi€aÿÿÿÿÿÿs…Ã}€bÿÿÿÿÿÿ}ˆi~€cÿÿÿÿÿÿ‡òŠ@€dÿÿÿÿÿÿ‘‡}€eÿÿÿÿÿÿ›‘s€fÿÿÿÿÿÿ¥›i€gÿÿÿÿÿÿ¯¥_€hÿÿÿÿÿÿ¹Ì~d|€iÿÿÿÿÿÿÂ}€jÿÿÿÿÿÿÍ«…œi€kÿÿÿÿÿÿטˆ~€lÿÿÿÿÿÿáy‹g€mÿÿÿÿÿÿëá×€nÿÿÿÿÿÿõëÍ€oÿÿÿÿÿÿÿõÀpÿÿÿÿÿÿ Žÿ¹€qÿÿÿÿÿÿŽ Ž¯€rÿÿÿÿÿÿŽŽU€sÿÿÿÿÿÿ'ŽŽûŒ€tÿÿÿÿÿÿ1Ž'Ž¡Œ€uÿÿÿÿÿÿ;Ž| |€vÿÿÿÿÿÿEŽè½|€wÿÿÿÿÿÿOŽ‘ƒti€xÿÿÿÿÿÿYŽe†&~€yÿÿÿÿÿÿcŽx‰ß~€zÿÿÿÿÿÿmŽcŽYŽ€{ÿÿÿÿÿÿwŽmŽOŽ€|ÿÿÿÿÿÿŽwŽEŽ€}ÿÿÿÿÿÿ‹ŽŽ;Ž€~ÿÿÿÿÿÿ•ŽÇ|Þ€ÿÿÿÿÿÿŸŽ—€8i€€ÿÿÿÿÿÿ©Ž-„G€ÿÿÿÿÿÿ³Ž‡í€‚ÿÿÿÿÿÿ½Ž Š°‚€ƒÿÿÿÿÿÿÇŽ½Ž³Ž€„ÿÿÿÿÿÿÑŽÇŽ©Ž€…ÿÿÿÿÿÿÛŽÑŽŸŽ€†ÿÿÿÿÿÿåŽÛŽ•Ž€‡ÿÿÿÿÿÿïŽv}€€ˆÿÿÿÿÿÿùŽQª€€‰ÿÿÿÿÿÿ"]]€Šÿÿÿÿÿÿ ›‡Îi€‹ÿÿÿÿÿÿŠà‚€Œÿÿÿÿÿÿ! €ÿÿÿÿÿÿ+!€Žÿÿÿÿÿÿ5+ùŽ€ÿÿÿÿÿÿ?5ÿÿÿÿÿÿI0~+€€‘ÿÿÿÿÿÿS÷Ñ€€’ÿÿÿÿÿÿ]"…Š€“ÿÿÿÿÿÿg#ˆ:‚€”ÿÿÿÿÿÿq‹(j€•ÿÿÿÿÿÿ{qg€–ÿÿÿÿÿÿ…{]€—ÿÿÿÿÿÿ…S€˜ÿÿÿÿÿÿ™I€™ÿÿÿÿÿÿ£é~i€šÿÿÿÿÿÿ­º‚ø€€›ÿÿÿÿÿÿ·¾…ž€œÿÿÿÿÿÿÁ«ˆa‚€ÿÿÿÿÿÿËŒ‹ƒ€žÿÿÿÿÿÿÕËÁ€ŸÿÿÿÿÿÿßÕ·€ ÿÿÿÿÿÿéß­€¡ÿÿÿÿÿÿó飀¢ÿÿÿÿÿÿý󙀣ÿÿÿÿÿÿý?€¤ÿÿÿÿÿÿ厀¥ÿÿÿÿÿÿ‹Ž€¦ÿÿÿÿÿÿ%g4]4€§ÿÿÿÿÿÿ/€ä|€¨ÿÿÿÿÿÿ9¤ƒ“}€©ÿÿÿÿÿÿCx†qk€ªÿÿÿÿÿÿM‹‰€«ÿÿÿÿÿÿWMC€¬ÿÿÿÿÿÿaW9€­ÿÿÿÿÿÿka/€®ÿÿÿÿÿÿuk%€¯ÿÿÿÿÿÿî|û€°ÿÿÿÿÿÿ‰Ç-½-€±ÿÿÿÿÿÿ“@„~i€²ÿÿÿÿÿÿ‡ ‚€³ÿÿÿÿÿÿ§ŠÍ‚€´ÿÿÿÿÿÿ±§€µÿÿÿÿÿÿ»±“€¶ÿÿÿÿÿÿÅ»‰€·ÿÿÿÿÿÿÏÅ€¸ÿÿÿÿÿÿÙ}5k€¹ÿÿÿÿÿÿãdBi€ºÿÿÿÿÿÿí®‡5…€»ÿÿÿÿÿÿ÷O2­$€¼ÿÿÿÿÿÿ‘÷퀽ÿÿÿÿÿÿ ‘‘ÊJ€¾ÿÿÿÿÿÿ‘ ‘〿ÿÿÿÿÿÿ‘‘Ù€Àÿÿÿÿÿÿ)‘C~ʃ€Áÿÿÿÿÿÿ3‘‚]k€Âÿÿÿÿÿÿ=‘?…À„€ÃÿÿÿÿÿÿG‘--€ÄÿÿÿÿÿÿQ‘‹ä…€Åÿÿÿÿÿÿ[‘Q‘G‘€Æÿÿÿÿÿÿe‘[‘=‘€Çÿÿÿÿÿÿo‘e‘3‘€Èÿÿÿÿÿÿy‘o‘)‘€Éÿÿÿÿÿÿƒ‘Þƒ€Êÿÿÿÿÿÿ‘ׂp„€Ëÿÿÿÿÿÿ—‘·$E2€Ìÿÿÿÿÿÿ¡‘¾ˆo…€Íÿÿÿÿÿÿ«‘Š.€.€Îÿÿÿÿÿÿµ‘«‘¡‘€Ïÿÿÿÿÿÿ¿‘µ‘—‘€ÐÿÿÿÿÿÿÉ‘¿‘‘€ÑÿÿÿÿÿÿÓ‘É‘ƒ‘€ÒÿÿÿÿÿÿÝ‘Ó‘y‘€Óÿÿÿÿÿÿç‘Ý‘‘€Ôÿÿÿÿÿÿñ‘ç‘Ï€Õÿÿÿÿÿÿû‘ñ‘u€Öÿÿÿÿÿÿ’H|>|€×ÿÿÿÿÿÿ’"€Ik€Øÿÿÿÿÿÿ’Áƒ°}€Ùÿÿÿÿÿÿ#’•†°i€Úÿÿÿÿÿÿ-’ž‰-€Ûÿÿÿÿÿÿ7’-’#’€ÜÿÿÿÿÿÿA’7’’€ÝÿÿÿÿÿÿK’A’’€ÞÿÿÿÿÿÿU’K’’€ßÿÿÿÿÿÿ_’}èh€àÿÿÿÿÿÿi’È€¾€€áÿÿÿÿÿÿs’]„w€âÿÿÿÿÿÿ}’0‡'‚€ãÿÿÿÿÿÿ‡’/Šô‚€äÿÿÿÿÿÿ‘’‡’}’€åÿÿÿÿÿÿ›’‘’s’€æÿÿÿÿÿÿ¥’›’i’€çÿÿÿÿÿÿ¯’¥’_’€èÿÿÿÿÿÿ¹’º}·ƒ€éÿÿÿÿÿÿÃ’S„€êÿÿÿÿÿÿÍ’Ë\Á\€ëÿÿÿÿÿÿ×’Á‡R…€ìÿÿÿÿÿÿá’­Šj€íÿÿÿÿÿÿë’á’×’€îÿÿÿÿÿÿõ’ë’Í’€ïÿÿÿÿÿÿÿ’õ’Ã’€ðÿÿÿÿÿÿ “ÿ’¹’€ñÿÿÿÿÿÿ“`~‹†€òÿÿÿÿÿÿ“1‚&‡€óÿÿÿÿÿÿ'“\…’i€ôÿÿÿÿÿÿ1“Jˆ@ˆ€õÿÿÿÿÿÿ;“+‹Ñˆ€öÿÿÿÿÿÿE“;“1“€÷ÿÿÿÿÿÿO“E“'“€øÿÿÿÿÿÿY“O““€ùÿÿÿÿÿÿc“Y““€úÿÿÿÿÿÿm“7±†€ûÿÿÿÿÿÿw“þ‚ji€üÿÿÿÿÿÿ“Û…Ô‡€ýÿÿÿÿÿÿ‹“Ûˆ…k€þÿÿÿÿÿÿ•“©‹‰€ÿÿÿÿÿÿÿŸ“•“‹“€ÿÿÿÿÿÿ©“Ÿ““€ÿÿÿÿÿÿ³“©“w“€ÿÿÿÿÿÿ½“³“m“€ÿÿÿÿÿÿÇ“½“c“€ÿÿÿÿÿÿÑ“Ç“ “€ÿÿÿÿÿÿÛ“Ñ“¯’€ÿÿÿÿÿÿå“Û“U’€ÿÿÿÿÿÿï“[|+k€ÿÿÿÿÿÿù“I€.i€ ÿÿÿÿÿÿ”ëtAo€ ÿÿÿÿÿÿ ”¨†}~€ ÿÿÿÿÿÿ”»‰T€ ÿÿÿÿÿÿ!”” ”€ ÿÿÿÿÿÿ+”!””€ÿÿÿÿÿÿ5”+”ù“€ÿÿÿÿÿÿ?”5”ï“€ÿÿÿÿÿÿI”}?€€ÿÿÿÿÿÿS”ï€å€€ÿÿÿÿÿÿ]”þtTo€ÿÿÿÿÿÿg”M‡N‚€ÿÿÿÿÿÿq”BŠ j€ÿÿÿÿÿÿ{”q”g”€ÿÿÿÿÿÿ…”{”]”€ÿÿÿÿÿÿ”…”S”€ÿÿÿÿÿÿ™””I”€ÿÿÿÿÿÿ£”Koát€ÿÿÿÿÿÿ­”^oôt€ÿÿÿÿÿÿ·”€ÿÿÿÿÿÿÁ”—o-u€ÿÿÿÿÿÿË”Ðofu€ÿÿÿÿÿÿՔ˔Á”€ÿÿÿÿÿÿߔՔ·”€ ÿÿÿÿÿÿé”ß”­”€!ÿÿÿÿÿÿó”锣”€"ÿÿÿÿÿÿý”‡~i€#ÿÿÿÿÿÿ•X‚C‡€$ÿÿÿÿÿÿ•7uo€%ÿÿÿÿÿÿ•]ˆ{k€&ÿÿÿÿÿÿ%•>‹îˆ€'ÿÿÿÿÿÿ/•%••€(ÿÿÿÿÿÿ9•/••€)ÿÿÿÿÿÿC•9••€*ÿÿÿÿÿÿM•C•ý”€+ÿÿÿÿÿÿW•^±‰€,ÿÿÿÿÿÿa•ƒgk€-ÿÿÿÿÿÿk•puÆo€.ÿÿÿÿÿÿu•øˆâi€/ÿÿÿÿÿÿ•Æ‹¼‹€0ÿÿÿÿÿÿ‰••u•€1ÿÿÿÿÿÿ“•‰•k•€2ÿÿÿÿÿÿ•“•a•€3ÿÿÿÿÿÿ§••W•€4ÿÿÿÿÿÿ±•§•M•€5ÿÿÿÿÿÿ»•±•ó”€6ÿÿÿÿÿÿÅ•»•™”€7ÿÿÿÿÿÿÏ•Å•?”€8ÿÿÿÿÿÿÙ•Ï•å“€9ÿÿÿÿÿÿã•Ù•û‘€:ÿÿÿÿÿÿí•ã•€;ÿÿÿÿÿÿ÷•í•1Ž€<ÿÿÿÿÿÿ–»‰•†€=ÿÿÿÿÿÿ ––¤ƒ€>ÿÿÿÿÿÿ– –è€?ÿÿÿÿÿÿ––ú{€@ÿÿÿÿÿÿ)–BŠ0‡€Aÿÿÿÿÿÿ3–)–@„€Bÿÿÿÿÿÿ=–3–—€€CÿÿÿÿÿÿG–=–ª|€DÿÿÿÿÿÿQ–ÐoÁ‡€Eÿÿÿÿÿÿ[–Q–v€Fÿÿÿÿÿÿe–[–Q€Gÿÿÿÿÿÿo–e–c}€Hÿÿÿÿÿÿy–>‹Jˆ€Iÿÿÿÿÿÿƒ–y–?…€Jÿÿÿÿÿÿ–ƒ–÷€Kÿÿÿÿÿÿ—––~€Lÿÿÿÿÿÿ¡–Æ‹Ûˆ€Mÿÿÿÿÿÿ«–¡–·$€Nÿÿÿÿÿÿµ–«–º‚€Oÿÿÿÿÿÿ¿–µ–Ì~€PÿÿÿÿÿÿÉ–¿–—–€QÿÿÿÿÿÿÓ–É–o–€RÿÿÿÿÿÿÝ–Ó–G–€Sÿÿÿÿÿÿç–Ý––€TSÿÿÿÿÿÿñ–œ2.€U>ÿÿÿÿÿÿû–œñ–@Vÿÿÿÿÿÿ—û–€WSÿÿÿÿÿÿ—~2.€X>ÿÿÿÿÿÿ—~—@Yÿÿÿÿÿÿ"——€ZSÿÿÿÿÿÿ+—42.€[>ÿÿÿÿÿÿ5—4+—@\ÿÿÿÿÿÿ?—5—€]SÿÿÿÿÿÿH—<2.€^>ÿÿÿÿÿÿR—<H—@_ÿÿÿÿÿÿ\—R—€`Sÿÿÿÿÿÿe—°2.€a>ÿÿÿÿÿÿo—°e—@bÿÿÿÿÿÿy—o—€cÿÿÿÿÿÿ‚—y—\—€dÿÿÿÿÿÿŒ—‚—?—€eÿÿÿÿÿÿ–—Œ—"—€fÿÿÿÿÿÿ —–——€gSÿÿÿÿÿÿª—œ³-€h>ÿÿÿÿÿÿ´—œª—@iÿÿÿÿÿÿ¾—´—€jSÿÿÿÿÿÿÇ—~³-€k>ÿÿÿÿÿÿÑ—~Ç—@lÿÿÿÿÿÿÛ—Ñ—€mSÿÿÿÿÿÿä—4³-€n>ÿÿÿÿÿÿî—4ä—@oÿÿÿÿÿÿø—î—€pSÿÿÿÿÿÿ˜<³-€q>ÿÿÿÿÿÿ ˜<˜@rÿÿÿÿÿÿ˜ ˜€sSÿÿÿÿÿÿ˜°³-€t>ÿÿÿÿÿÿ(˜°˜@uÿÿÿÿÿÿ2˜(˜€vÿÿÿÿÿÿ;˜2˜˜€wÿÿÿÿÿÿE˜;˜ø—€xÿÿÿÿÿÿO˜E˜Û—€yÿÿÿÿÿÿY˜O˜¾—€zÿÿÿÿÿÿc˜Æ‹+‹€{ÿÿÿÿÿÿm˜c˜O2€|ÿÿÿÿÿÿw˜m˜ Š€}ÿÿÿÿÿÿ˜w˜e‰€~Sÿÿÿÿÿÿ‹˜œú,€>ÿÿÿÿÿÿ•˜œ‹˜@€ÿÿÿÿÿÿŸ˜•˜€Sÿÿÿÿÿÿ¨˜~ú,€‚>ÿÿÿÿÿÿ²˜~¨˜@ƒÿÿÿÿÿÿ¼˜²˜€„SÿÿÿÿÿÿŘ4ú,€…>ÿÿÿÿÿÿϘ4Ř@†ÿÿÿÿÿÿ٘Ϙ€‡Sÿÿÿÿÿÿâ˜<ú,€ˆ>ÿÿÿÿÿÿì˜<â˜@‰ÿÿÿÿÿÿö˜ì˜€ŠSÿÿÿÿÿÿÿ˜°ú,€‹>ÿÿÿÿÿÿ ™°ÿ˜@Œÿÿÿÿÿÿ™ ™€ÿÿÿÿÿÿ™™ö˜€Žÿÿÿÿÿÿ&™™Ù˜€ÿÿÿÿÿÿ0™&™¼˜€ÿÿÿÿÿÿ:™0™Ÿ˜€‘SÿÿÿÿÿÿD™œv.€’>ÿÿÿÿÿÿN™œD™@“ÿÿÿÿÿÿX™N™€”Sÿÿÿÿÿÿa™~v.€•>ÿÿÿÿÿÿk™~a™@–ÿÿÿÿÿÿu™k™€—Sÿÿÿÿÿÿ~™4v.€˜>ÿÿÿÿÿÿˆ™4~™@™ÿÿÿÿÿÿ’™ˆ™€šSÿÿÿÿÿÿ›™<v.€›>ÿÿÿÿÿÿ¥™<›™@œÿÿÿÿÿÿ¯™¥™€Sÿÿÿÿÿÿ¸™°v.€ž>ÿÿÿÿÿÿ™°¸™@Ÿÿÿÿÿÿÿ̙™€ ÿÿÿÿÿÿՙ̙¯™€¡ÿÿÿÿÿÿߙՙ’™€¢ÿÿÿÿÿÿé™ß™u™€£ÿÿÿÿÿÿó™é™X™€¤ÿÿÿÿÿÿý™ó™:™€¥ÿÿÿÿÿÿšý™˜€¦ÿÿÿÿÿÿššY˜€§ÿÿÿÿÿÿšš —€¨Sÿÿÿÿÿÿ%šœÞh€©>ÿÿÿÿÿÿ/š~%š€ªSÿÿÿÿÿÿ9šœê'€«>ÿÿÿÿÿÿCš49š€¬SÿÿÿÿÿÿMšœüh€­>ÿÿÿÿÿÿWš<Mš€®Sÿÿÿÿÿÿašœi€¯>ÿÿÿÿÿÿkš°aš€°ÿÿÿÿÿÿuškšWš€±ÿÿÿÿÿÿšušCš€²ÿÿÿÿÿÿ‰šš/š€³ÿÿÿÿÿÿ“š‰šû–€´Sÿÿÿÿÿÿš~$i€µ>ÿÿÿÿÿÿ§šœš€¶Sÿÿÿÿÿÿ±š~|$€·>ÿÿÿÿÿÿ»š4±š€¸SÿÿÿÿÿÿÅš~Li€¹>ÿÿÿÿÿÿÏš<Åš€ºSÿÿÿÿÿÿÙš~`i€»>ÿÿÿÿÿÿãš°Ùš€¼ÿÿÿÿÿÿíšãšÏš€½ÿÿÿÿÿÿ÷šíš»š€¾ÿÿÿÿÿÿ›÷šÑ—€¿ÿÿÿÿÿÿ ››§š€ÀSÿÿÿÿÿÿ›4f@€Á>ÿÿÿÿÿÿ›œ›€ÂSÿÿÿÿÿÿ)›4x1€Ã>ÿÿÿÿÿÿ3›~)›€ÄSÿÿÿÿÿÿ=›4¿0€Å>ÿÿÿÿÿÿG›<=›€ÆSÿÿÿÿÿÿQ›4;2€Ç>ÿÿÿÿÿÿ[›°Q›€Èÿÿÿÿÿÿe›[›G›€Éÿÿÿÿÿÿo›e›E2€Êÿÿÿÿÿÿy›o›3›€Ëÿÿÿÿÿÿƒ›y››€ÌSÿÿÿÿÿÿ›<¦i€Í>ÿÿÿÿÿÿ—›œ›€ÎSÿÿÿÿÿÿ¡›<ºi€Ï>ÿÿÿÿÿÿ«›~¡›€ÐSÿÿÿÿÿÿµ›<_$€Ñ>ÿÿÿÿÿÿ¿›4µ›€ÒSÿÿÿÿÿÿÉ›<Øi€Ó>ÿÿÿÿÿÿÓ›°É›€Ôÿÿÿÿÿÿݛӛ였Õÿÿÿÿÿÿç›Ý›¿›€Öÿÿÿÿÿÿñ›ç›«›€×ÿÿÿÿÿÿû›ñ›—›€ØSÿÿÿÿÿÿœ°ìi€Ù>ÿÿÿÿÿÿœœœ€ÚSÿÿÿÿÿÿœ°j€Û>ÿÿÿÿÿÿ#œ~œ€ÜSÿÿÿÿÿÿ-œ°£$€Ý>ÿÿÿÿÿÿ7œ4-œ€ÞSÿÿÿÿÿÿAœ°j€ß>ÿÿÿÿÿÿKœ<Aœ€àÿÿÿÿÿÿUœÂ™Kœ€áÿÿÿÿÿÿ_œUœ7œ€âÿÿÿÿÿÿiœ_œ#œ€ãÿÿÿÿÿÿsœiœœ€äÿÿÿÿÿÿ}œsœû›€åÿÿÿÿÿÿ‡œ}œƒ›€æÿÿÿÿÿÿ‘œ‡œ ›€çÿÿÿÿÿÿ›œ‘œ“š€èÿÿÿÿÿÿ¥œËÇ|€éÿÿÿÿÿÿ¯œ~ƒ}€êÿÿÿÿÿÿ¹œR†`~€ëÿÿÿÿÿÿÃœe‰^€ìÿÿÿÿÿÿܹ͜œ€íÿÿÿÿÿÿל͜¯œ€îÿÿÿÿÿÿáœ×œ¥œ€ïÿÿÿÿÿÿëœáœú{€ðÿÿÿÿÿÿõœª|Ë€ñÿÿÿÿÿÿÿœ„€—€€òÿÿÿÿÿÿ „d€óÿÿÿÿÿÿí†1‚€ôÿÿÿÿÿÿö‰ƒ€õÿÿÿÿÿÿ'€öÿÿÿÿÿÿ1' €÷ÿÿÿÿÿÿ;1ÿœ€øÿÿÿÿÿÿE;õœ€ùÿÿÿÿÿÿOc}~ƒ€úÿÿÿÿÿÿY4-„€ûÿÿÿÿÿÿckbv€üÿÿÿÿÿÿmˆ‡\…€ýÿÿÿÿÿÿw}Špu€þÿÿÿÿÿÿwm€ÿÿÿÿÿÿÿ‹c€ÿÿÿÿÿÿ•‹Y€ÿÿÿÿÿÿŸ•O€ÿÿÿÿÿÿ©~R†€ÿÿÿÿÿÿ³Ú‡€ÿÿÿÿÿÿ½…®‡€ÿÿÿÿÿÿLjJˆ€ÿÿÿÿÿÿÑòŠøˆ€ÿÿÿÿÿÿÛÑÇ€ÿÿÿÿÿÿåÛ½€ ÿÿÿÿÿÿïå³€ ÿÿÿÿÿÿùï©€ ÿÿÿÿÿÿžÌ~e‰€ ÿÿÿÿÿÿ ž‚ Š€ ÿÿÿÿÿÿž«…O2€ÿÿÿÿÿÿ!ž˜ˆ+‹€ÿÿÿÿÿÿ+žy‹Æ‹€ÿÿÿÿÿÿ5ž+ž!ž€ÿÿÿÿÿÿ?ž5žž€ÿÿÿÿÿÿIž?ž ž€ÿÿÿÿÿÿSžIžž€ÿÿÿÿÿÿ]žSžù€ÿÿÿÿÿÿgž]žŸ€ÿÿÿÿÿÿqžgžE€ÿÿÿÿÿÿ{žqžëœ€ÿÿÿÿÿÿ…ž|ú{€ÿÿÿÿÿÿžèÇ|€ÿÿÿÿÿÿ™ž‘ƒ}€ÿÿÿÿÿÿ£že†`~€ÿÿÿÿÿÿ­žx‰^€ÿÿÿÿÿÿ·ž­ž£ž€ÿÿÿÿÿÿÁž·ž™ž€ÿÿÿÿÿÿËžÁžž€ ÿÿÿÿÿÿ՞˞…ž€!ÿÿÿÿÿÿßžÇ|Ë€"ÿÿÿÿÿÿéž-„d€#ÿÿÿÿÿÿóž‡1‚€$ÿÿÿÿÿÿýž Šƒ€%ÿÿÿÿÿÿŸýžóž€&ÿÿÿÿÿÿŸŸéž€'ÿÿÿÿÿÿŸŸ—€€(ÿÿÿÿÿÿ%ŸŸßž€)ÿÿÿÿÿÿ/Ÿv}~ƒ€*ÿÿÿÿÿÿ9ŸQ-„€+ÿÿÿÿÿÿCŸ"]v€,ÿÿÿÿÿÿMŸ›‡\…€-ÿÿÿÿÿÿWŸŠpu€.ÿÿÿÿÿÿaŸWŸMŸ€/ÿÿÿÿÿÿkŸaŸCŸ€0ÿÿÿÿÿÿuŸkŸ9Ÿ€1ÿÿÿÿÿÿŸuŸ/Ÿ€2ÿÿÿÿÿÿ‰Ÿ0~R†€3ÿÿÿÿÿÿ“Ÿ÷‡€4ÿÿÿÿÿÿŸ"…®‡€5ÿÿÿÿÿÿ§Ÿ#ˆJˆ€6ÿÿÿÿÿÿ±Ÿ‹øˆ€7ÿÿÿÿÿÿ»Ÿ±Ÿ§Ÿ€8ÿÿÿÿÿÿÅŸ»ŸŸ€9ÿÿÿÿÿÿÏŸÅŸ“Ÿ€:ÿÿÿÿÿÿÙŸÏŸ‰Ÿ€;ÿÿÿÿÿÿãŸé~e‰€<ÿÿÿÿÿÿퟺ‚ Š€=ÿÿÿÿÿÿ÷Ÿ¾…O2€>ÿÿÿÿÿÿ «ˆ+‹€?ÿÿÿÿÿÿ  Œ‹Æ‹€@ÿÿÿÿÿÿ    €Aÿÿÿÿÿÿ  ÷Ÿ€Bÿÿÿÿÿÿ)  íŸ€Cÿÿÿÿÿÿ3 ) ãŸ€Dÿÿÿÿÿÿ= 3 ÙŸ€EÿÿÿÿÿÿG = Ÿ€FÿÿÿÿÿÿQ G %Ÿ€Gÿÿÿÿÿÿ[ Q Õž€Hÿÿÿÿÿÿe g4ú{€Iÿÿÿÿÿÿo €Ç|€Jÿÿÿÿÿÿy ¤ƒ}€Kÿÿÿÿÿÿƒ x†`~€Lÿÿÿÿÿÿ ‹‰^€Mÿÿÿÿÿÿ—  ƒ €Nÿÿÿÿÿÿ¡ — y €Oÿÿÿÿÿÿ« ¡ o €Pÿÿÿÿÿÿµ « e €Qÿÿÿÿÿÿ¿ î|Ë€RÿÿÿÿÿÿÉ Ç-—€€SÿÿÿÿÿÿÓ @„d€TÿÿÿÿÿÿÝ ‡1‚€Uÿÿÿÿÿÿç Šƒ€Vÿÿÿÿÿÿñ ç Ý €Wÿÿÿÿÿÿû ñ Ó €Xÿÿÿÿÿÿ¡û É €Yÿÿÿÿÿÿ¡¡¿ €Zÿÿÿÿÿÿ¡}~ƒ€[ÿÿÿÿÿÿ#¡d-„€\ÿÿÿÿÿÿ-¡®‡\…€]ÿÿÿÿÿÿ7¡O2pu€^ÿÿÿÿÿÿA¡7¡-¡€_ÿÿÿÿÿÿK¡A¡v€`ÿÿÿÿÿÿU¡K¡#¡€aÿÿÿÿÿÿ_¡U¡¡€bÿÿÿÿÿÿi¡C~R†€cÿÿÿÿÿÿs¡‚‡€dÿÿÿÿÿÿ}¡?…®‡€eÿÿÿÿÿÿ‡¡-Jˆ€fÿÿÿÿÿÿ‘¡‹øˆ€gÿÿÿÿÿÿ›¡‘¡‡¡€hÿÿÿÿÿÿ¥¡›¡}¡€iÿÿÿÿÿÿ¯¡¥¡s¡€jÿÿÿÿÿÿ¹¡¯¡i¡€kÿÿÿÿÿÿáe‰€lÿÿÿÿÿÿׂ͡ Š€mÿÿÿÿÿÿס·$O2€nÿÿÿÿÿÿ᡾ˆ+‹€oÿÿÿÿÿÿë¡Š.Æ‹€pÿÿÿÿÿÿõ¡ë¡á¡€qÿÿÿÿÿÿÿ¡õ¡×¡€rÿÿÿÿÿÿ ¢ÿ¡Í¡€sÿÿÿÿÿÿ¢ ¢Ã¡€tÿÿÿÿÿÿ¢¢¹¡€uÿÿÿÿÿÿ'¢¢_¡€vÿÿÿÿÿÿ1¢'¢¡€wÿÿÿÿÿÿ;¢1¢µ €xÿÿÿÿÿÿE¢H|ú{€yÿÿÿÿÿÿO¢"€Ç|€zÿÿÿÿÿÿY¢Áƒ}€{ÿÿÿÿÿÿc¢•†`~€|ÿÿÿÿÿÿm¢ž‰^€}ÿÿÿÿÿÿw¢m¢c¢€~ÿÿÿÿÿÿ¢w¢Y¢€ÿÿÿÿÿÿ‹¢¢O¢€€ÿÿÿÿÿÿ•¢‹¢E¢€ÿÿÿÿÿÿŸ¢}Ë€‚ÿÿÿÿÿÿ©¢È€—€€ƒÿÿÿÿÿÿ³¢]„d€„ÿÿÿÿÿÿ½¢0‡1‚€…ÿÿÿÿÿÿÇ¢/Šƒ€†ÿÿÿÿÿÿѢǢ½¢€‡ÿÿÿÿÿÿۢѢ³¢€ˆÿÿÿÿÿÿå¢Û¢©¢€‰ÿÿÿÿÿÿï¢å¢Ÿ¢€Šÿÿÿÿÿÿù¢º}~ƒ€‹ÿÿÿÿÿÿ£-„€Œÿÿÿÿÿÿ £Ë\v€ÿÿÿÿÿÿ£Á‡\…€Žÿÿÿÿÿÿ!£­Špu€ÿÿÿÿÿÿ+£!££€ÿÿÿÿÿÿ5£+£ £€‘ÿÿÿÿÿÿ?£5££€’ÿÿÿÿÿÿI£?£ù¢€“ÿÿÿÿÿÿS£`~R†€”ÿÿÿÿÿÿ]£1‚‡€•ÿÿÿÿÿÿg£\…®‡€–ÿÿÿÿÿÿq£+‹øˆ€—ÿÿÿÿÿÿ{£q£Jˆ€˜ÿÿÿÿÿÿ…£{£g£€™ÿÿÿÿÿÿ£…£]£€šÿÿÿÿÿÿ™££S£€›ÿÿÿÿÿÿ££7e‰€œÿÿÿÿÿÿ­£þ‚ Š€ÿÿÿÿÿÿ·£Û…O2€žÿÿÿÿÿÿÁ£Ûˆ+‹€ŸÿÿÿÿÿÿË£©‹Æ‹€ ÿÿÿÿÿÿգˣÁ£€¡ÿÿÿÿÿÿߣգ·£€¢ÿÿÿÿÿÿé£ß£­£€£ÿÿÿÿÿÿó£é£££€¤ÿÿÿÿÿÿý£ó£™£€¥ÿÿÿÿÿÿ¤ý£I£€¦ÿÿÿÿÿÿ¤¤ï¢€§ÿÿÿÿÿÿ¤¤•¢€¨ÿÿÿÿÿÿ%¤[|ú{€©ÿÿÿÿÿÿ/¤I€Ç|€ªÿÿÿÿÿÿ9¤ët}€«ÿÿÿÿÿÿC¤¨†`~€¬ÿÿÿÿÿÿM¤»‰^€­ÿÿÿÿÿÿW¤M¤C¤€®ÿÿÿÿÿÿa¤W¤9¤€¯ÿÿÿÿÿÿk¤a¤/¤€°ÿÿÿÿÿÿu¤k¤%¤€±ÿÿÿÿÿÿ¤}Ë€²ÿÿÿÿÿÿ‰¤ï€—€€³ÿÿÿÿÿÿ“¤þtd€´ÿÿÿÿÿÿ¤M‡1‚€µÿÿÿÿÿÿ§¤BŠƒ€¶ÿÿÿÿÿÿ±¤§¤¤€·ÿÿÿÿÿÿ»¤±¤“¤€¸ÿÿÿÿÿÿŤ»¤‰¤€¹ÿÿÿÿÿÿϤŤ¤€ºÿÿÿÿÿÿÙ¤Ko~ƒ€»ÿÿÿÿÿÿã¤^o-„€¼ÿÿÿÿÿÿí¤v€½ÿÿÿÿÿÿ÷¤—o\…€¾ÿÿÿÿÿÿ¥Ðopu€¿ÿÿÿÿÿÿ ¥¥÷¤€Àÿÿÿÿÿÿ¥ ¥í¤€Áÿÿÿÿÿÿ¥¥ã¤€Âÿÿÿÿÿÿ)¥¥Ù¤€Ãÿÿÿÿÿÿ3¥‡~R†€Äÿÿÿÿÿÿ=¥X‚‡€ÅÿÿÿÿÿÿG¥7u®‡€ÆÿÿÿÿÿÿQ¥]ˆJˆ€Çÿÿÿÿÿÿ[¥>‹øˆ€Èÿÿÿÿÿÿe¥[¥Q¥€Éÿÿÿÿÿÿo¥e¥G¥€Êÿÿÿÿÿÿy¥o¥=¥€Ëÿÿÿÿÿÿƒ¥y¥3¥€Ìÿÿÿÿÿÿ¥^e‰€Íÿÿÿÿÿÿ—¥ƒ Š€Îÿÿÿÿÿÿ¡¥puO2€Ïÿÿÿÿÿÿ«¥øˆ+‹€Ðÿÿÿÿÿÿµ¥Æ‹«¥€Ñÿÿÿÿÿÿ¿¥µ¥¡¥€ÒÿÿÿÿÿÿÉ¥¿¥—¥€Óÿÿÿÿÿÿӥɥ¥€ÔÿÿÿÿÿÿÝ¥Ó¥ƒ¥€Õÿÿÿÿÿÿç¥Ý¥)¥€Öÿÿÿÿÿÿñ¥ç¥Ï¤€×ÿÿÿÿÿÿû¥ñ¥u¤€Øÿÿÿÿÿÿ¦û¥¤€Ùÿÿÿÿÿÿ¦¦;¢€Úÿÿÿÿÿÿ¦¦[ €Ûÿÿÿÿÿÿ#¦¦{ž€ÜSÿÿÿÿÿÿ-¦2.2.€Ý>ÿÿÿÿÿÿ7¦œ-¦@ÞÿÿÿÿÿÿA¦7¦€ßSÿÿÿÿÿÿJ¦$i$i€à>ÿÿÿÿÿÿT¦~J¦@áÿÿÿÿÿÿ^¦T¦€âSÿÿÿÿÿÿg¦f@f@€ã>ÿÿÿÿÿÿq¦4g¦@äÿÿÿÿÿÿ{¦q¦€åSÿÿÿÿÿÿ„¦¦i¦i€æ>ÿÿÿÿÿÿŽ¦<„¦@çÿÿÿÿÿÿ˜¦Ž¦€èSÿÿÿÿÿÿ¡¦ìiìi€é>ÿÿÿÿÿÿ«¦°¡¦@êÿÿÿÿÿÿµ¦«¦€ëÿÿÿÿÿÿ¾¦µ¦˜¦€ìÿÿÿÿÿÿȦ¾¦{¦€íÿÿÿÿÿÿҦȦ^¦€îÿÿÿÿÿÿܦҦA¦€ïSÿÿÿÿÿÿæ¦ÞhÞh€ð>ÿÿÿÿÿÿð¦œæ¦@ñÿÿÿÿÿÿú¦ð¦€òSÿÿÿÿÿÿ§³-³-€ó>ÿÿÿÿÿÿ §~§@ôÿÿÿÿÿÿ§ §€õSÿÿÿÿÿÿ §x1x1€ö>ÿÿÿÿÿÿ*§4 §@÷ÿÿÿÿÿÿ4§*§€øSÿÿÿÿÿÿ=§ºiºi€ù>ÿÿÿÿÿÿG§<=§@úÿÿÿÿÿÿQ§G§€ûSÿÿÿÿÿÿZ§jj€ü>ÿÿÿÿÿÿd§°Z§@ýÿÿÿÿÿÿn§d§€þÿÿÿÿÿÿw§n§Q§€ÿÿÿÿÿÿÿ§w§4§€ÿÿÿÿÿÿ‹§§§€ÿÿÿÿÿÿ•§‹§ú¦€SÿÿÿÿÿÿŸ§ê'ê'€>ÿÿÿÿÿÿ©§œŸ§@ÿÿÿÿÿÿ³§©§€Sÿÿÿÿÿÿ¼§|$|$€>ÿÿÿÿÿÿƧ~¼§@ÿÿÿÿÿÿЧƧ€SÿÿÿÿÿÿÙ§_$_$€ >ÿÿÿÿÿÿã§<Ù§@ ÿÿÿÿÿÿí§ã§€ Sÿÿÿÿÿÿö§£$£$€ >ÿÿÿÿÿÿ¨°ö§@ ÿÿÿÿÿÿ ¨¨€ÿÿÿÿÿÿ¨ ¨í§€ÿÿÿÿÿÿ¨¨Š.€ÿÿÿÿÿÿ'¨¨Ð§€ÿÿÿÿÿÿ1¨'¨³§€Sÿÿÿÿÿÿ;¨ühüh€>ÿÿÿÿÿÿE¨œ;¨@ÿÿÿÿÿÿO¨E¨€SÿÿÿÿÿÿX¨LiLi€>ÿÿÿÿÿÿb¨~X¨@ÿÿÿÿÿÿl¨b¨€Sÿÿÿÿÿÿu¨¿0¿0€>ÿÿÿÿÿÿ¨4u¨@ÿÿÿÿÿÿ‰¨¨€Sÿÿÿÿÿÿ’¨ú,ú,€>ÿÿÿÿÿÿœ¨<’¨@ÿÿÿÿÿÿ¦¨œ¨€Sÿÿÿÿÿÿ¯¨jj€>ÿÿÿÿÿÿ¹¨°¯¨@ ÿÿÿÿÿÿ蹨€!ÿÿÿÿÿÿ̨覨€"ÿÿÿÿÿÿ̨֨‰¨€#ÿÿÿÿÿÿà¨Ö¨l¨€$ÿÿÿÿÿÿê¨à¨O¨€%Sÿÿÿÿÿÿô¨ii€&>ÿÿÿÿÿÿþ¨œô¨@'ÿÿÿÿÿÿ©þ¨€(Sÿÿÿÿÿÿ©`i`i€)>ÿÿÿÿÿÿ©~©@*ÿÿÿÿÿÿ%©©€+Sÿÿÿÿÿÿ.©;2;2€,>ÿÿÿÿÿÿ8©4.©@-ÿÿÿÿÿÿB©8©€.SÿÿÿÿÿÿK©ØiØi€/>ÿÿÿÿÿÿU©<K©@0ÿÿÿÿÿÿ_©U©€1Sÿÿÿÿÿÿh©v.v.€2>ÿÿÿÿÿÿr©°h©@3ÿÿÿÿÿÿ|©r©€4ÿÿÿÿÿÿ…©|©_©€5ÿÿÿÿÿÿ©…©B©€6ÿÿÿÿÿÿ™©©%©€7ÿÿÿÿÿÿ£©™©©€8ÿÿÿÿÿÿ­©£©ê¨€9ÿÿÿÿÿÿ·©­©1¨€:ÿÿÿÿÿÿÁ©·©•§€;ÿÿÿÿÿÿË©Á©Ü¦€<SÿÿÿÿÿÿÕ©~Þh€=>ÿÿÿÿÿÿß©œÕ©@>ÿÿÿÿÿÿé©ß©€?Sÿÿÿÿÿÿò©4ê'€@>ÿÿÿÿÿÿü©œò©@Aÿÿÿÿÿÿªü©€BSÿÿÿÿÿÿª<üh€C>ÿÿÿÿÿÿªœª@Dÿÿÿÿÿÿ#ªª€ESÿÿÿÿÿÿ,ª°i€F>ÿÿÿÿÿÿ6ªœ,ª@Gÿÿÿÿÿÿ@ª6ª€HÿÿÿÿÿÿIª@ª#ª€IÿÿÿÿÿÿSªIªª€Jÿÿÿÿÿÿ]ªSªé©€Kÿÿÿÿÿÿgª]ª—€LSÿÿÿÿÿÿqªœ$i€M>ÿÿÿÿÿÿ{ª~qª@Nÿÿÿÿÿÿ…ª{ª€OSÿÿÿÿÿÿŽª4|$€P>ÿÿÿÿÿÿ˜ª~Žª@Qÿÿÿÿÿÿ¢ª˜ª€RSÿÿÿÿÿÿ«ª<Li€S>ÿÿÿÿÿÿµª~«ª@Tÿÿÿÿÿÿ¿ªµª€USÿÿÿÿÿÿȪ°`i€V>ÿÿÿÿÿÿÒª~Ȫ@WÿÿÿÿÿÿܪҪ€XÿÿÿÿÿÿåªÜª¿ª€Yÿÿÿÿÿÿïªåª¢ª€ZÿÿÿÿÿÿùªïªÛ—€[ÿÿÿÿÿÿ«ùª…ª€\Sÿÿÿÿÿÿ «œf@€]>ÿÿÿÿÿÿ«4 «@^ÿÿÿÿÿÿ!««€_Sÿÿÿÿÿÿ*«~x1€`>ÿÿÿÿÿÿ4«4*«@aÿÿÿÿÿÿ>«4«€bSÿÿÿÿÿÿG«<¿0€c>ÿÿÿÿÿÿQ«4G«@dÿÿÿÿÿÿ[«Q«€eSÿÿÿÿÿÿd«°;2€f>ÿÿÿÿÿÿn«4d«@gÿÿÿÿÿÿx«n«€hÿÿÿÿÿÿ«x«[«€iÿÿÿÿÿÿ‹««O2€jÿÿÿÿÿÿ•«‹«>«€kÿÿÿÿÿÿŸ«•«!«€lSÿÿÿÿÿÿ©«œ¦i€m>ÿÿÿÿÿÿ³«<©«@nÿÿÿÿÿÿ½«³«€oSÿÿÿÿÿÿÆ«~ºi€p>ÿÿÿÿÿÿЫ<Æ«@qÿÿÿÿÿÿګЫ€rSÿÿÿÿÿÿã«4_$€s>ÿÿÿÿÿÿí«<ã«@tÿÿÿÿÿÿ÷«í«€uSÿÿÿÿÿÿ¬°Øi€v>ÿÿÿÿÿÿ ¬<¬@wÿÿÿÿÿÿ¬ ¬€xÿÿÿÿÿÿ¬¬ö˜€yÿÿÿÿÿÿ'¬¬÷«€zÿÿÿÿÿÿ1¬'¬Ú«€{ÿÿÿÿÿÿ;¬1¬½«€|SÿÿÿÿÿÿE¬œìi€}>ÿÿÿÿÿÿO¬°E¬@~ÿÿÿÿÿÿY¬O¬€Sÿÿÿÿÿÿb¬~j€€>ÿÿÿÿÿÿl¬°b¬@ÿÿÿÿÿÿv¬l¬€‚Sÿÿÿÿÿÿ¬4£$€ƒ>ÿÿÿÿÿÿ‰¬°¬@„ÿÿÿÿÿÿ“¬‰¬€…Sÿÿÿÿÿÿœ¬<j€†>ÿÿÿÿÿÿ¦¬°œ¬@‡ÿÿÿÿÿÿ°¬¦¬€ˆÿÿÿÿÿÿ¹¬Ì™°¬€‰ÿÿÿÿÿÿ칬“¬€Šÿÿÿÿÿÿͬìv¬€‹ÿÿÿÿÿÿ׬ͬY¬€Œÿÿÿÿÿÿá¬×¬;¬€ÿÿÿÿÿÿë¬á¬Ÿ«€Žÿÿÿÿÿÿõ¬ë¬«€ÿÿÿÿÿÿÿ¬õ¬gª€>ÿÿÿÿÿÿ ­~æ¦@‘ÿÿÿÿÿÿ­ ­€’>ÿÿÿÿÿÿ­4Ÿ§@“ÿÿÿÿÿÿ&­­€”>ÿÿÿÿÿÿ/­<;¨@•ÿÿÿÿÿÿ9­/­€–>ÿÿÿÿÿÿB­°ô¨@—ÿÿÿÿÿÿL­B­€˜ÿÿÿÿÿÿU­L­9­€™ÿÿÿÿÿÿ_­U­&­€šÿÿÿÿÿÿi­_­­€›ÿÿÿÿÿÿs­i­A¦€œ>ÿÿÿÿÿÿ}­œJ¦@ÿÿÿÿÿÿ‡­}­€ž>ÿÿÿÿÿÿ­4¼§@Ÿÿÿÿÿÿÿš­­€ >ÿÿÿÿÿÿ£­<X¨@¡ÿÿÿÿÿÿ­­£­€¢>ÿÿÿÿÿÿ¶­°©@£ÿÿÿÿÿÿÀ­¶­€¤ÿÿÿÿÿÿÉ­À­­­€¥ÿÿÿÿÿÿÓ­É­š­€¦ÿÿÿÿÿÿÝ­Ó­§€§ÿÿÿÿÿÿç­Ý­‡­€¨>ÿÿÿÿÿÿñ­œg¦@©ÿÿÿÿÿÿû­ñ­€ª>ÿÿÿÿÿÿ®~ §@«ÿÿÿÿÿÿ®®€¬>ÿÿÿÿÿÿ®<u¨@­ÿÿÿÿÿÿ!®®€®>ÿÿÿÿÿÿ*®°.©@¯ÿÿÿÿÿÿ4®*®€°ÿÿÿÿÿÿ=®4®!®€±ÿÿÿÿÿÿG®=®Š.€²ÿÿÿÿÿÿQ®G®®€³ÿÿÿÿÿÿ[®Q®û­€´>ÿÿÿÿÿÿe®œ„¦@µÿÿÿÿÿÿo®e®€¶>ÿÿÿÿÿÿx®~=§@·ÿÿÿÿÿÿ‚®x®€¸>ÿÿÿÿÿÿ‹®4Ù§@¹ÿÿÿÿÿÿ•®‹®€º>ÿÿÿÿÿÿž®°K©@»ÿÿÿÿÿÿ¨®ž®€¼ÿÿÿÿÿÿ±®¨®¦¨€½ÿÿÿÿÿÿ»®±®•®€¾ÿÿÿÿÿÿÅ®»®‚®€¿ÿÿÿÿÿÿϮŮo®€À>ÿÿÿÿÿÿÙ®œ¡¦@Áÿÿÿÿÿÿã®Ù®€Â>ÿÿÿÿÿÿì®~Z§@Ãÿÿÿÿÿÿö®ì®€Ä>ÿÿÿÿÿÿÿ®4ö§@Åÿÿÿÿÿÿ ¯ÿ®€Æ>ÿÿÿÿÿÿ¯<¯¨@Çÿÿÿÿÿÿ¯¯€Èÿÿÿÿÿÿ%¯|©¯€Éÿÿÿÿÿÿ/¯%¯ ¯€Êÿÿÿÿÿÿ9¯/¯ö®€ËÿÿÿÿÿÿC¯9¯ã®€ÌÿÿÿÿÿÿM¯C¯Ï®€ÍÿÿÿÿÿÿW¯M¯[®€Îÿÿÿÿÿÿa¯W¯ç­€Ïÿÿÿÿÿÿk¯a¯s­€Ðÿÿÿÿÿÿu¯y‹ˆ€Ñÿÿÿÿÿÿ¯u¯kb€Òÿÿÿÿÿÿ‰¯¯„€€Óÿÿÿÿÿÿ“¯‰¯ú{€Ôÿÿÿÿÿÿ¯ð{“¯€Õÿÿÿÿÿÿ§¯Œ‹#ˆ€Öÿÿÿÿÿÿ±¯§¯"]€×ÿÿÿÿÿÿ»¯±¯—€€Øÿÿÿÿÿÿů»¯|€Ùÿÿÿÿÿÿϯ |ů€ÚÿÿÿÿÿÿÙ¯Š.-€Ûÿÿÿÿÿÿã¯Ù¯v€Üÿÿÿÿÿÿí¯ã¯Ç-€Ýÿÿÿÿÿÿ÷¯í¯g4€Þÿÿÿÿÿÿ°òh÷¯€ßÿÿÿÿÿÿ °©‹Jˆ€àÿÿÿÿÿÿ° °Ë\€áÿÿÿÿÿÿ°°È€€âÿÿÿÿÿÿ)°°H|€ãÿÿÿÿÿÿ3°?k)°€äÿÿÿÿÿÿ=°Æ‹]ˆ€åÿÿÿÿÿÿG°=°€æÿÿÿÿÿÿQ°çÿÿÿÿÿÿ[°[|€èÿÿÿÿÿÿe°d|€éÿÿÿÿÿÿo°e°3°€êÿÿÿÿÿÿy°o°°€ëÿÿÿÿÿÿƒ°y°Ï¯€ìÿÿÿÿÿÿ°ƒ°¯€íÿÿÿÿÿÿ—°½|“¯€îÿÿÿÿÿÿ¡°8iů€ïÿÿÿÿÿÿ«°ª€÷¯€ðÿÿÿÿÿÿµ°Ñ€)°€ñÿÿÿÿÿÿ¿°ø€€òÿÿÿÿÿÿÉ°¿°µ°€óÿÿÿÿÿÿÓ°É°«°€ôÿÿÿÿÿÿÝ°Ó°¡°€õÿÿÿÿÿÿç°Ý°—°€öÿÿÿÿÿÿñ°“}“¯€÷ÿÿÿÿÿÿû°~iů€øÿÿÿÿÿÿ±ì÷¯€ùÿÿÿÿÿÿ±À„)°€úÿÿÿÿÿÿ±E2€ûÿÿÿÿÿÿ#±±±€üÿÿÿÿÿÿ-±#±±€ýÿÿÿÿÿÿ7±-±û°€þÿÿÿÿÿÿA±7±ñ°€ÿÿÿÿÿÿÿK±°i“¯€ÿÿÿÿÿÿU±'‚ů€ÿÿÿÿÿÿ_±R…÷¯€ÿÿÿÿÿÿi±@ˆ)°€ÿÿÿÿÿÿs±…k€ÿÿÿÿÿÿ}±s±i±€ÿÿÿÿÿÿ‡±}±_±€ÿÿÿÿÿÿ‘±‡±U±€ÿÿÿÿÿÿ›±‘±K±€ÿÿÿÿÿÿ¥±T“¯€ ÿÿÿÿÿÿ¯± jů€ ÿÿÿÿÿÿ¹±fu÷¯€ ÿÿÿÿÿÿñîˆ)°€ ÿÿÿÿÿÿͱ¼‹€ ÿÿÿÿÿÿױͱñ€ÿÿÿÿÿÿá±×±¹±€ÿÿÿÿÿÿë±á±¯±€ÿÿÿÿÿÿõ±ë±¥±€ÿÿÿÿÿÿÿ±õ±›±€ÿÿÿÿÿÿ ²ÿ±A±€ÿÿÿÿÿÿ² ²ç°€ÿÿÿÿÿÿ²²°€Sÿÿÿÿÿÿ'²$iœ€>ÿÿÿÿÿÿ1²~'²€Sÿÿÿÿÿÿ;²f@œ€>ÿÿÿÿÿÿE²4;²€SÿÿÿÿÿÿO²¦iœ€>ÿÿÿÿÿÿY²<O²€Sÿÿÿÿÿÿc²ìiœ€>ÿÿÿÿÿÿm²°c²€ÿÿÿÿÿÿw²m²Y²€ÿÿÿÿÿÿ²w²E²€ÿÿÿÿÿÿ‹²²1²€ ÿÿÿÿÿÿ•²‹²Rx€!SÿÿÿÿÿÿŸ²Þh~€">ÿÿÿÿÿÿ©²œŸ²€#Sÿÿÿÿÿÿ³²x1~€$>ÿÿÿÿÿÿ½²4³²€%SÿÿÿÿÿÿDzºi~€&>ÿÿÿÿÿÿѲ<Dz€'SÿÿÿÿÿÿÛ²j~€(>ÿÿÿÿÿÿå²°Û²€)ÿÿÿÿÿÿï²å²Ñ²€*ÿÿÿÿÿÿù²ï²½²€+ÿÿÿÿÿÿ³ù²(y€,ÿÿÿÿÿÿ ³³©²€-Sÿÿÿÿÿÿ³ê'4€.>ÿÿÿÿÿÿ!³œ³€/Sÿÿÿÿÿÿ+³|$4€0>ÿÿÿÿÿÿ5³~+³€1Sÿÿÿÿÿÿ?³_$4€2>ÿÿÿÿÿÿI³<?³€3SÿÿÿÿÿÿS³£$4€4>ÿÿÿÿÿÿ]³°S³€5ÿÿÿÿÿÿg³]³I³€6ÿÿÿÿÿÿq³g³­$€7ÿÿÿÿÿÿ{³q³5³€8ÿÿÿÿÿÿ…³{³!³€9Sÿÿÿÿÿÿ³üh<€:>ÿÿÿÿÿÿ™³œ³€;Sÿÿÿÿÿÿ£³Li<€<>ÿÿÿÿÿÿ­³~£³€=Sÿÿÿÿÿÿ·³¿0<€>>ÿÿÿÿÿÿÁ³4·³€?Sÿÿÿÿÿÿ˳j<€@>ÿÿÿÿÿÿÕ³°Ë³€Aÿÿÿÿÿÿß³Õ³·z€Bÿÿÿÿÿÿé³ß³Á³€Cÿÿÿÿÿÿó³é³­³€Dÿÿÿÿÿÿý³ó³™³€ESÿÿÿÿÿÿ´i°€F>ÿÿÿÿÿÿ´œ´€GSÿÿÿÿÿÿ´`i°€H>ÿÿÿÿÿÿ%´~´€ISÿÿÿÿÿÿ/´;2°€J>ÿÿÿÿÿÿ9´4/´€KSÿÿÿÿÿÿC´Øi°€L>ÿÿÿÿÿÿM´<C´€MÿÿÿÿÿÿW´{M´€Nÿÿÿÿÿÿa´W´9´€Oÿÿÿÿÿÿk´a´%´€Pÿÿÿÿÿÿu´k´´€Qÿÿÿÿÿÿ´u´ý³€Rÿÿÿÿÿÿ‰´´…³€Sÿÿÿÿÿÿ“´‰´ ³€Tÿÿÿÿÿÿ´“´•²€Uÿÿÿÿÿÿ§´#{jz€Vÿÿÿÿÿÿ±´§´Îy€Wÿÿÿÿÿÿ»´±´y€XÿÿÿÿÿÿÅ´»´\x€YÿÿÿÿÿÿÏ´@{‡z€ZÿÿÿÿÿÿÙ´Ï´ëy€[ÿÿÿÿÿÿã´Ù´2y€\ÿÿÿÿÿÿí´ã´yx€]ÿÿÿÿÿÿ÷´]{¤z€^ÿÿÿÿÿÿµ÷´·$€_ÿÿÿÿÿÿ µµOy€`ÿÿÿÿÿÿµ µ–x€aÿÿÿÿÿÿµz{Áz€bÿÿÿÿÿÿ)µµz€cÿÿÿÿÿÿ3µ)µly€dÿÿÿÿÿÿ=µ3µ³x€eÿÿÿÿÿÿGµ—{Þz€fÿÿÿÿÿÿQµGµ%z€gÿÿÿÿÿÿ[µQµ‰y€hÿÿÿÿÿÿeµ[µÐx€iÿÿÿÿÿÿoµeµ=µ€jÿÿÿÿÿÿyµoµµ€kÿÿÿÿÿÿƒµyµí´€lÿÿÿÿÿÿµƒµÅ´@mÿÿÿÿÿÿ—µ1²@nÿÿÿÿÿÿ µE²@oÿÿÿÿÿÿ©µY²@pÿÿÿÿÿÿ²µm²€qÿÿÿÿÿÿ»µ²µ©µ€rÿÿÿÿÿÿŵ»µ µ€sÿÿÿÿÿÿϵŵ—µ€tÿÿÿÿÿÿٵϵ\x@uÿÿÿÿÿÿ㵩²@vÿÿÿÿÿÿìµ½²@wÿÿÿÿÿÿõµÑ²@xÿÿÿÿÿÿþµå²€yÿÿÿÿÿÿ¶þµõµ€zÿÿÿÿÿÿ¶¶ìµ€{ÿÿÿÿÿÿ¶¶2y€|ÿÿÿÿÿÿ%¶¶ãµ@}ÿÿÿÿÿÿ/¶!³@~ÿÿÿÿÿÿ8¶5³@ÿÿÿÿÿÿA¶I³@€ÿÿÿÿÿÿJ¶]³€ÿÿÿÿÿÿS¶J¶A¶€‚ÿÿÿÿÿÿ]¶S¶·$€ƒÿÿÿÿÿÿg¶]¶8¶€„ÿÿÿÿÿÿq¶g¶/¶@…ÿÿÿÿÿÿ{¶™³@†ÿÿÿÿÿÿ„¶­³@‡ÿÿÿÿÿÿ¶Á³@ˆÿÿÿÿÿÿ–¶Õ³€‰ÿÿÿÿÿÿŸ¶–¶Áz€Šÿÿÿÿÿÿ©¶Ÿ¶¶€‹ÿÿÿÿÿÿ³¶©¶„¶€Œÿÿÿÿÿÿ½¶³¶{¶@ÿÿÿÿÿÿǶ´@Žÿÿÿÿÿÿж%´@ÿÿÿÿÿÿÙ¶9´@ÿÿÿÿÿÿâ¶M´€‘ÿÿÿÿÿÿ붗{ⶀ’ÿÿÿÿÿÿõ¶ë¶Ù¶€“ÿÿÿÿÿÿÿ¶õ¶Ð¶€”ÿÿÿÿÿÿ ·ÿ¶Ç¶€•ÿÿÿÿÿÿ· ·½¶€–ÿÿÿÿÿÿ··q¶€—ÿÿÿÿÿÿ'··%¶€˜ÿÿÿÿÿÿ1·'·Ùµ€™ÿÿÿÿÿÿ;·¼‹@ˆ€šÿÿÿÿÿÿE·;·ì€›ÿÿÿÿÿÿO·E·8i€œÿÿÿÿÿÿY·O·ð{€ÿÿÿÿÿÿc·Ëª|€žÿÿÿÿÿÿm·~ƒc}€Ÿÿÿÿÿÿÿw·R†~€ ÿÿÿÿÿÿ·e‰Ì~€¡ÿÿÿÿÿÿ‹··w·€¢ÿÿÿÿÿÿ•·‹·m·€£ÿÿÿÿÿÿŸ·•·c·€¤ÿÿÿÿÿÿ©·Ÿ·ú{€¥ÿÿÿÿÿÿ³·„4€¦ÿÿÿÿÿÿ½·í†Ú€§ÿÿÿÿÿÿÇ·ö‰‚€¨ÿÿÿÿÿÿÑ·Ç·½·€©ÿÿÿÿÿÿÛ·Ñ·³·€ªÿÿÿÿÿÿå·Û·„€€«ÿÿÿÿÿÿï·å·õœ€¬ÿÿÿÿÿÿù·4„€­ÿÿÿÿÿÿ¸ˆ‡…€®ÿÿÿÿÿÿ ¸}Š«…€¯ÿÿÿÿÿÿ¸ ¸¸€°ÿÿÿÿÿÿ!¸¸kb€±ÿÿÿÿÿÿ+¸!¸ù·€²ÿÿÿÿÿÿ5¸+¸O€³ÿÿÿÿÿÿ?¸Ú톀´ÿÿÿÿÿÿI¸…ˆ‡€µÿÿÿÿÿÿS¸òŠ˜ˆ€¶ÿÿÿÿÿÿ]¸S¸ˆ€·ÿÿÿÿÿÿg¸]¸I¸€¸ÿÿÿÿÿÿq¸g¸?¸€¹ÿÿÿÿÿÿ{¸q¸©€ºÿÿÿÿÿÿ…¸‚ö‰€»ÿÿÿÿÿÿ¸«…}Š€¼ÿÿÿÿÿÿ™¸˜ˆòŠ€½ÿÿÿÿÿÿ£¸y‹™¸€¾ÿÿÿÿÿÿ­¸£¸¸€¿ÿÿÿÿÿÿ·¸­¸…¸€ÀÿÿÿÿÿÿÁ¸·¸ž€Áÿÿÿÿÿÿ˸Á¸{¸€Âÿÿÿÿÿÿո˸5¸€Ãÿÿÿÿÿÿ߸ոﷀÄÿÿÿÿÿÿé¸ß¸©·€Åÿÿÿÿÿÿ󸑃v}€Æÿÿÿÿÿÿý¸e†0~€Çÿÿÿÿÿÿ¹x‰é~€Èÿÿÿÿÿÿ¹¹ý¸€Éÿÿÿÿÿÿ¹¹ó¸€Êÿÿÿÿÿÿ%¹¹ž€Ëÿÿÿÿÿÿ/¹%¹|€Ìÿÿÿÿÿÿ9¹Ç|è€ÍÿÿÿÿÿÿC¹-„Q€ÎÿÿÿÿÿÿM¹‡÷€ÏÿÿÿÿÿÿW¹ Šº‚€Ðÿÿÿÿÿÿa¹W¹M¹€Ñÿÿÿÿÿÿk¹a¹C¹€Òÿÿÿÿÿÿu¹k¹—€€Óÿÿÿÿÿÿ¹u¹9¹€Ôÿÿÿÿÿÿ‰¹v}‘ƒ€Õÿÿÿÿÿÿ“¹›‡"…€Öÿÿÿÿÿÿ¹Š¾…€×ÿÿÿÿÿÿ§¹¹“¹€Øÿÿÿÿÿÿ±¹§¹"]€Ùÿÿÿÿÿÿ»¹±¹9Ÿ€ÚÿÿÿÿÿÿŹ»¹‰¹€ÛÿÿÿÿÿÿϹ0~e†€ÜÿÿÿÿÿÿÙ¹"…›‡€Ýÿÿÿÿÿÿ㹋«ˆ€Þÿÿÿÿÿÿí¹ã¹#ˆ€ßÿÿÿÿÿÿ÷¹í¹Ù¹€àÿÿÿÿÿÿº÷¹“Ÿ€áÿÿÿÿÿÿ ººÏ¹€âÿÿÿÿÿÿºé~x‰€ãÿÿÿÿÿÿº¾…Š€äÿÿÿÿÿÿ)º«ˆ‹€åÿÿÿÿÿÿ3ºŒ‹)º€æÿÿÿÿÿÿ=º3ºº€çÿÿÿÿÿÿGº=ºíŸ€èÿÿÿÿÿÿQºGºº€éÿÿÿÿÿÿ[ºQº º€êÿÿÿÿÿÿeº[ºÅ¹€ëÿÿÿÿÿÿoºeº¹€ìÿÿÿÿÿÿyºoº/¹€íÿÿÿÿÿÿƒº€î|€îÿÿÿÿÿÿºx†C~€ïÿÿÿÿÿÿ—º‹‰€ðÿÿÿÿÿÿ¡º—ºº€ñÿÿÿÿÿÿ«º¡ºy €òÿÿÿÿÿÿµº«ºƒº€óÿÿÿÿÿÿ¿ºµºg4€ôÿÿÿÿÿÿɺî|€€õÿÿÿÿÿÿÓº‡‚€öÿÿÿÿÿÿݺŠ×‚€÷ÿÿÿÿÿÿçºÝºÓº€øÿÿÿÿÿÿñºçºÓ €ùÿÿÿÿÿÿûºñºÇ-€úÿÿÿÿÿÿ»ûºÉº€ûÿÿÿÿÿÿ»}¤ƒ€üÿÿÿÿÿÿ»d@„€ýÿÿÿÿÿÿ#»®‡?…€þÿÿÿÿÿÿ-»O2·$€ÿÿÿÿÿÿÿ7»-»#»€ÿÿÿÿÿÿA»7»v€ÿÿÿÿÿÿK»A»»€ÿÿÿÿÿÿU»K»»€ÿÿÿÿÿÿ_»C~x†€ÿÿÿÿÿÿi»‚‡€ÿÿÿÿÿÿs»‹¾ˆ€ÿÿÿÿÿÿ}»s»-€ÿÿÿÿÿÿ‡»}»}¡€ÿÿÿÿÿÿ‘»‡»i»€ ÿÿÿÿÿÿ›»‘»_»€ ÿÿÿÿÿÿ¥»‹‰€ ÿÿÿÿÿÿ¯»×‚Š€ ÿÿÿÿÿÿ¹»¾ˆ‹€ ÿÿÿÿÿÿûŠ.¹»€ÿÿÿÿÿÿͻûס€ÿÿÿÿÿÿ׻ͻ¯»€ÿÿÿÿÿÿá»×»¥»€ÿÿÿÿÿÿë»á»›»€ÿÿÿÿÿÿõ»ë»U»€ÿÿÿÿÿÿÿ»õ»»€ÿÿÿÿÿÿ ¼ÿ»¿º€ÿÿÿÿÿÿ¼"€}€ÿÿÿÿÿÿ¼Áƒº}€ÿÿÿÿÿÿ'¼ž‰7€ÿÿÿÿÿÿ1¼'¼c¢€ÿÿÿÿÿÿ;¼1¼¼€ÿÿÿÿÿÿE¼;¼¼€ÿÿÿÿÿÿO¼E¼H|€ÿÿÿÿÿÿY¼}"€€ÿÿÿÿÿÿc¼]„€ÿÿÿÿÿÿm¼/Šþ‚€ÿÿÿÿÿÿw¼m¼½¢€ ÿÿÿÿÿÿ¼w¼c¼€!ÿÿÿÿÿÿ‹¼¼È€€"ÿÿÿÿÿÿ•¼‹¼Y¼€#ÿÿÿÿÿÿŸ¼º}Áƒ€$ÿÿÿÿÿÿ©¼]„€%ÿÿÿÿÿÿ³¼­ŠÛ…€&ÿÿÿÿÿÿ½¼³¼£€'ÿÿÿÿÿÿǼ½¼Ë\€(ÿÿÿÿÿÿѼǼ©¼€)ÿÿÿÿÿÿۼѼŸ¼€*ÿÿÿÿÿÿå¼`~•†€+ÿÿÿÿÿÿï¼1‚0‡€,ÿÿÿÿÿÿù¼\…Á‡€-ÿÿÿÿÿÿ½+‹Ûˆ€.ÿÿÿÿÿÿ ½½Jˆ€/ÿÿÿÿÿÿ½ ½ù¼€0ÿÿÿÿÿÿ!½½ï¼€1ÿÿÿÿÿÿ+½!½å¼€2ÿÿÿÿÿÿ5½7ž‰€3ÿÿÿÿÿÿ?½þ‚/Š€4ÿÿÿÿÿÿI½Û…­Š€5ÿÿÿÿÿÿS½©‹Á£€6ÿÿÿÿÿÿ]½S½I½€7ÿÿÿÿÿÿg½]½?½€8ÿÿÿÿÿÿq½g½5½€9ÿÿÿÿÿÿ{½q½+½€:ÿÿÿÿÿÿ…½{½Û¼€;ÿÿÿÿÿÿ½…½•¼€<ÿÿÿÿÿÿ™½½O¼€=ÿÿÿÿÿÿ£½I€}€>ÿÿÿÿÿÿ­½ëtKo€?ÿÿÿÿÿÿ·½¨†‡~€@ÿÿÿÿÿÿÁ½M¤·½€Aÿÿÿÿÿÿ˽Á½­½€Bÿÿÿÿÿÿս˽£½€Cÿÿÿÿÿÿß½Õ½[|€Dÿÿÿÿÿÿé½}I€€Eÿÿÿÿÿÿó½þt^o€Fÿÿÿÿÿÿý½M‡X‚€Gÿÿÿÿÿÿ¾§¤ý½€Hÿÿÿÿÿÿ¾¾ó½€Iÿÿÿÿÿÿ¾¾ï€€Jÿÿÿÿÿÿ%¾¾é½€Kÿÿÿÿÿÿ/¾Koët€Lÿÿÿÿÿÿ9¾^oþt€MÿÿÿÿÿÿC¾—o7u€NÿÿÿÿÿÿM¾¥C¾€OÿÿÿÿÿÿW¾M¾Ô„€Pÿÿÿÿÿÿa¾W¾9¾€Qÿÿÿÿÿÿk¾a¾/¾€Rÿÿÿÿÿÿu¾‡~¨†€Sÿÿÿÿÿÿ¾X‚M‡€Tÿÿÿÿÿÿ‰¾7u—o€Uÿÿÿÿÿÿ“¾[¥]ˆ€Vÿÿÿÿÿÿ¾“¾‰¾€Wÿÿÿÿÿÿ§¾¾¾€Xÿÿÿÿÿÿ±¾§¾u¾€Yÿÿÿÿÿÿ»¾^»‰€ZÿÿÿÿÿÿžƒBŠ€[ÿÿÿÿÿÿϾpuÐo€\ÿÿÿÿÿÿÙ¾øˆ>‹€]ÿÿÿÿÿÿã¾Æ‹Ù¾€^ÿÿÿÿÿÿí¾ã¾Ï¾€_ÿÿÿÿÿÿ÷¾í¾Å¾€`ÿÿÿÿÿÿ¿÷¾»¾€aÿÿÿÿÿÿ ¿¿±¾€bÿÿÿÿÿÿ¿ ¿k¾€cÿÿÿÿÿÿ¿¿%¾€dÿÿÿÿÿÿ)¿¿ß½€eÿÿÿÿÿÿ3¿)¿™½€fÿÿÿÿÿÿ=¿3¿ ¼€gÿÿÿÿÿÿG¿=¿yº€hÿÿÿÿÿÿQ¿G¿é¸€iÿÿÿÿÿÿ[¿[°)°€jÿÿÿÿÿÿe¿[¿÷¯€kÿÿÿÿÿÿo¿e¿Å¯€lÿÿÿÿÿÿy¿o¿“¯€mÿÿÿÿÿÿƒ¿öi ~€nÿÿÿÿÿÿ¿ƒ¿Y}€oÿÿÿÿÿÿ—¿¿ |€pÿÿÿÿÿÿ¡¿—¿ð{€qÿÿÿÿÿÿ«¿d|?k€rÿÿÿÿÿÿµ¿«¿òh€sÿÿÿÿÿÿ¿¿µ¿ |€tÿÿÿÿÿÿÉ¿¿¿ð{€uÿÿÿÿÿÿÓ¿É¿¡¿€vÿÿÿÿÿÿÝ¿ß~&~€wÿÿÿÿÿÿç¿Ý¿ti€xÿÿÿÿÿÿñ¿ç¿½|€yÿÿÿÿÿÿû¿ñ¿ |€zÿÿÿÿÿÿÀi+€€{ÿÿÿÿÿÿÀÀ€€|ÿÿÿÿÿÿÀÀÞ€}ÿÿÿÿÿÿ#ÀÀ |€~ÿÿÿÿÿÿ-À#Àû¿€ÿÿÿÿÿÿ7Àqk€€ÿÿÿÿÿÿAÀ7À“}€ÿÿÿÿÿÿKÀAÀä|€‚ÿÿÿÿÿÿUÀKÀ]4€ƒÿÿÿÿÿÿ_Àރʃ€„ÿÿÿÿÿÿiÀ_À5k€…ÿÿÿÿÿÿsÀiÀû€†ÿÿÿÿÿÿ}ÀsÀ]4€‡ÿÿÿÿÿÿ‡À}ÀUÀ€ˆÿÿÿÿÿÿ‘À-°i€‰ÿÿÿÿÿÿ›À‘À°}€Šÿÿÿÿÿÿ¥À›ÀIk€‹ÿÿÿÿÿÿ¯À¥À>|€Œÿÿÿÿÿÿ¹À±†‹†€ÿÿÿÿÿÿÃÀ¹À·ƒ€ŽÿÿÿÿÿÿÍÀÃÀèh€ÿÿÿÿÿÿ×ÀÍÀ>|€ÿÿÿÿÿÿáÀ×À¯À€‘ÿÿÿÿÿÿëÀT}~€’ÿÿÿÿÿÿõÀëÀAo€“ÿÿÿÿÿÿÿÀõÀ.i€”ÿÿÿÿÿÿ ÁÿÀ+k€•ÿÿÿÿÿÿÁ±‰i€–ÿÿÿÿÿÿÁÁát€—ÿÿÿÿÿÿ'ÁÁ?€€˜ÿÿÿÿÿÿ1Á'Á+k€™ÿÿÿÿÿÿ;Á1Á Á€šÿÿÿÿÿÿEÁ;ÁáÀ€›ÿÿÿÿÿÿOÁEÁ‡À€œÿÿÿÿÿÿYÁOÁ-À€ÿÿÿÿÿÿcÁYÁÓ¿€žÿÿÿÿÿÿmÁò~Äi€ŸÿÿÿÿÿÿwÁmÁ}€ ÿÿÿÿÿÿÁwÁÐ|€¡ÿÿÿÿÿÿ‹ÁÁ |€¢ÿÿÿÿÿÿ•Á}Vi€£ÿÿÿÿÿÿŸÁ•ÁSk€¤ÿÿÿÿÿÿ©ÁŸÁÐ|€¥ÿÿÿÿÿÿ³Á©Á |€¦ÿÿÿÿÿÿ½Á³Á‹Á€§ÿÿÿÿÿÿÇÁ°‚퀨ÿÿÿÿÿÿÑÁÇÁG€©ÿÿÿÿÿÿÛÁÑÁ8i€ªÿÿÿÿÿÿåÁÛÁÞ€«ÿÿÿÿÿÿïÁø€Ñ€€¬ÿÿÿÿÿÿùÁïÁª€€­ÿÿÿÿÿÿÂùÁ8i€®ÿÿÿÿÿÿ ½|€¯ÿÿÿÿÿÿ ÂåÁ€°ÿÿÿÿÿÿ!ÂÍ‚ ‚€±ÿÿÿÿÿÿ+Â!Â~i€²ÿÿÿÿÿÿ5Â+½-€³ÿÿÿÿÿÿ?Â5Âû€´ÿÿÿÿÿÿIÂp„]k€µÿÿÿÿÿÿSÂIÂBi€¶ÿÿÿÿÿÿ]ÂS½-€·ÿÿÿÿÿÿgÂ]Âä|€¸ÿÿÿÿÿÿqÂgÂ?€¹ÿÿÿÿÿÿ{Âô‚'‚€ºÿÿÿÿÿÿ…Â{Âw€»ÿÿÿÿÿÿ…¾€€¼ÿÿÿÿÿÿ™ÂÂèh€½ÿÿÿÿÿÿ£Âji&‡€¾ÿÿÿÿÿÿ­Â£ÂS„€¿ÿÿÿÿÿÿ·Â­Â¾€€ÀÿÿÿÿÿÿÁ·ÂIk€ÁÿÿÿÿÿÿËÂÁ™€ÂÿÿÿÿÿÿÕ jN‚€ÃÿÿÿÿÿÿßÂÕÂTo€ÄÿÿÿÿÿÿéÂßÂ倀ÅÿÿÿÿÿÿóÂéÂ?€€ÆÿÿÿÿÿÿýÂgkC‡€ÇÿÿÿÿÿÿÃýÂôt€ÈÿÿÿÿÿÿÃÃ倀ÉÿÿÿÿÿÿÃÃ.i€Êÿÿÿÿÿÿ%ÃÃó€Ëÿÿÿÿÿÿ/Ã%ÃË€Ìÿÿÿÿÿÿ9Ã/Ãq€ÍÿÿÿÿÿÿCÃ9ÀÎÿÿÿÿÿÿMÃCýÁ€ÏÿÿÿÿÿÿWÃL~€ÐÿÿÿÿÿÿaÃWÃab€ÑÿÿÿÿÿÿkÃaÃSk€ÒÿÿÿÿÿÿuÃkÃòh€ÓÿÿÿÿÿÿÃœiÃ}€Ôÿÿÿÿÿÿ‰ÃÃab€Õÿÿÿÿÿÿ“ÉÃ}€ÖÿÿÿÿÿÿÓÃY}€×ÿÿÿÿÿÿ§ÃÃuÀØÿÿÿÿÿÿ±Ãà‚Îi€Ùÿÿÿÿÿÿ»Ã±Ã]€ÚÿÿÿÿÿÿÅûꀀÛÿÿÿÿÿÿÏÃÅÀ€ÜÿÿÿÿÿÿÙÞŠ€ÝÿÿÿÿÿÿãÃÙÃ]€ÞÿÿÿÿÿÿíÃãÃG€ßÿÿÿÿÿÿ÷ÃíÃti€àÿÿÿÿÿÿÄ÷ÃÏÀáÿÿÿÿÿÿ Ä­$5…€âÿÿÿÿÿÿÄ Äì€ãÿÿÿÿÿÿÄÄBi€äÿÿÿÿÿÿ)ÄÄ5k€åÿÿÿÿÿÿ3ÄE2À„€æÿÿÿÿÿÿ=Ä3Äì€çÿÿÿÿÿÿGÄ=Ä~i€èÿÿÿÿÿÿQÄGÄ“}€éÿÿÿÿÿÿ[ÄQÄ)Ä€êÿÿÿÿÿÿeÄjR…€ëÿÿÿÿÿÿoÄeÄÁ\€ìÿÿÿÿÿÿyÄoÄS„€íÿÿÿÿÿÿƒÄyÄ·ƒ€îÿÿÿÿÿÿÄÔ‡’i€ïÿÿÿÿÿÿ—ÄÄÁ\€ðÿÿÿÿÿÿ¡Ä—Äw€ñÿÿÿÿÿÿ«Ä¡Ä°}€òÿÿÿÿÿÿµÄ«ÄƒÄ€óÿÿÿÿÿÿ¿Äfu-u€ôÿÿÿÿÿÿÉĿĈi€õÿÿÿÿÿÿÓÄÉÄôt€öÿÿÿÿÿÿÝÄÓÄát€÷ÿÿÿÿÿÿçÄÆoo€øÿÿÿÿÿÿñÄçĈi€ùÿÿÿÿÿÿûÄñÄTo€úÿÿÿÿÿÿÅûÄAo€ûÿÿÿÿÿÿÅÅÝÄ€üÿÿÿÿÿÿÅŵĀýÿÿÿÿÿÿ#ÅÅ[Ä€þÿÿÿÿÿÿ-Å#ÅÄ€ÿÿÿÿÿÿÿ7Å-ŧÀÿÿÿÿÿÿAÅ@i~€ÿÿÿÿÿÿKÅAÅÃ}€ÿÿÿÿÿÿUÅKÅVi€ÿÿÿÿÿÿ_ÅUÅ?k€ÿÿÿÿÿÿiÅ~i~€ÿÿÿÿÿÿsÅiÅL~€ÿÿÿÿÿÿ}ÅsÅÄi€ÿÿÿÿÿÿ‡Å}Å ~€ÿÿÿÿÿÿ‘ŇÅ_Å€ ÿÿÿÿÿÿ›Å(j:‚€ ÿÿÿÿÿÿ¥Å›ÅŠ€ ÿÿÿÿÿÿ¯Å¥ÅÑ€€ ÿÿÿÿÿÿ¹Å¯Å+€€ ÿÿÿÿÿÿÃÅa‚:‚€ÿÿÿÿÿÿÍÅÃÅÎi€ÿÿÿÿÿÿ×ÅÍÅí€ÿÿÿÿÿÿáÅ×Å&~€ÿÿÿÿÿÿëÅáŹŀÿÿÿÿÿÿõÅä…-€ÿÿÿÿÿÿÿÅõÅÀ„€ÿÿÿÿÿÿ ÆÿÅ]k€ÿÿÿÿÿÿÆ Æʃ€ÿÿÿÿÿÿÆo…-€ÿÿÿÿÿÿ'ÆÆ5…€ÿÿÿÿÿÿ1Æ'Æ ‚€ÿÿÿÿÿÿ;Æ1Æqk€ÿÿÿÿÿÿEÆ;ÆÆ€ÿÿÿÿÿÿOÆш@ˆ€ÿÿÿÿÿÿYÆOÆ’i€ÿÿÿÿÿÿcÆYÆ&‡€ÿÿÿÿÿÿmÆcÆ‹†€ÿÿÿÿÿÿwÆ…k@ˆ€ ÿÿÿÿÿÿÆwÆR…€!ÿÿÿÿÿÿ‹ÆÆ'‚€"ÿÿÿÿÿÿ•Æ‹Æ°i€#ÿÿÿÿÿÿŸÆ•ÆmÆ€$ÿÿÿÿÿÿ©Æîˆ{k€%ÿÿÿÿÿÿ³Æ©Æo€&ÿÿÿÿÿÿ½Æ³ÆC‡€'ÿÿÿÿÿÿÇƽÆi€(ÿÿÿÿÿÿÑÆâi{k€)ÿÿÿÿÿÿÛÆÑÆ-u€*ÿÿÿÿÿÿåÆÛÆN‚€+ÿÿÿÿÿÿïÆåÆ}~€,ÿÿÿÿÿÿùÆïÆÇÆ€-ÿÿÿÿÿÿÇùÆŸÆ€.ÿÿÿÿÿÿ ÇÇEÆ€/ÿÿÿÿÿÿÇ ÇëÅ€0ÿÿÿÿÿÿ!ÇÇ‘Å€1ÿÿÿÿÿÿ+Çg~€2ÿÿÿÿÿÿ5Ç+Çœi€3ÿÿÿÿÿÿ?Ç5Ç}€4ÿÿÿÿÿÿIÇ?Çd|€5ÿÿÿÿÿÿSÇg@€6ÿÿÿÿÿÿ]ÇSÇ€7ÿÿÿÿÿÿgÇ]Çò~€8ÿÿÿÿÿÿqÇgÇöi€9ÿÿÿÿÿÿ{ÇqÇIÇ€:ÿÿÿÿÿÿ…ǃa‚€;ÿÿÿÿÿÿÇ…Çž€<ÿÿÿÿÿÿ™ÇÇø€€=ÿÿÿÿÿÿ£Ç™Çi€>ÿÿÿÿÿÿ­Çƒ(j€?ÿÿÿÿÿÿ·Ç­Çà‚€@ÿÿÿÿÿÿÁÇ·Ç°‚€AÿÿÿÿÿÿËÇÁÇß~€BÿÿÿÿÿÿÕÇËǣǀCÿÿÿÿÿÿßÇ€.o…€DÿÿÿÿÿÿéÇßÇE2€EÿÿÿÿÿÿóÇéÇp„€FÿÿÿÿÿÿýÇóÇÞƒ€GÿÿÿÿÿÿÈ€.ä…€HÿÿÿÿÿÿÈÈ­$€IÿÿÿÿÿÿÈÈÍ‚€Jÿÿÿÿÿÿ%ÈÈ€Kÿÿÿÿÿÿ/È%ÈýÇ€Lÿÿÿÿÿÿ9ȉ…k€MÿÿÿÿÿÿCÈ9ÈÔ‡€NÿÿÿÿÿÿMÈCÈji€OÿÿÿÿÿÿWÈMȱ†€Pÿÿÿÿÿÿaȉш€QÿÿÿÿÿÿkÈaÈj€RÿÿÿÿÿÿuÈkÈô‚€SÿÿÿÿÿÿÈuÈ-€Tÿÿÿÿÿÿ‰ÈÈWÈ€Uÿÿÿÿÿÿ“ȼ‹âi€VÿÿÿÿÿÿÈ“ÈÆo€Wÿÿÿÿÿÿ§ÈÈgk€Xÿÿÿÿÿÿ±È§È±‰€Yÿÿÿÿÿÿ»È¼‹îˆ€ZÿÿÿÿÿÿÅÈ»Èfu€[ÿÿÿÿÿÿÏÈÅÈ j€\ÿÿÿÿÿÿÙÈÏÈT€]ÿÿÿÿÿÿãÈÙȱȀ^ÿÿÿÿÿÿíÈãȉȀ_ÿÿÿÿÿÿ÷ÈíÈ/È€`ÿÿÿÿÿÿÉ÷ÈÕÇ€aÿÿÿÿÿÿ ÉÉ{Ç€bÿÿÿÿÿÿÉ É!Ç€cÿÿÿÿÿÿÉÉ7Å€dÿÿÿÿÿÿ)ÉÉMÀeÿÿÿÿÿÿ3É)ÉcÁ€fÿÿÿÿÿÿ=É+k>|€gÿÿÿÿÿÿGÉ=É]4€hÿÿÿÿÿÿQÉGÉ |€iÿÿÿÿÿÿ[ÉQÉð{€jÿÿÿÿÿÿeÉ?€èh€kÿÿÿÿÿÿoÉeÉû€lÿÿÿÿÿÿyÉoÉÞ€mÿÿÿÿÿÿƒÉyÉ |€nÿÿÿÿÿÿÉát·ƒ€oÿÿÿÿÿÿ—ÉÉ5k€pÿÿÿÿÿÿ¡É—É€€qÿÿÿÿÿÿ«É¡Éòh€rÿÿÿÿÿÿµÉi‹†€sÿÿÿÿÿÿ¿ÉµÉʃ€tÿÿÿÿÿÿÉÉ¿É+€€uÿÿÿÿÿÿÓÉÉÉ?k€vÿÿÿÿÿÿÝɱ‰±†€wÿÿÿÿÿÿçÉÝÉÞƒ€xÿÿÿÿÿÿñÉçÉi€yÿÿÿÿÿÿûÉñÉd|€zÿÿÿÿÿÿÊûÉÓÉ€{ÿÿÿÿÿÿÊÊ«É€|ÿÿÿÿÿÿÊʃɀ}ÿÿÿÿÿÿ#ÊÊ[É€~ÿÿÿÿÿÿ-Ê.iIk€ÿÿÿÿÿÿ7Ê-Êä|€€ÿÿÿÿÿÿAÊ7ʽ|€ÿÿÿÿÿÿKÊAÊ |€‚ÿÿÿÿÿÿUÊ倾€€ƒÿÿÿÿÿÿ_ÊUʽ-€„ÿÿÿÿÿÿiÊ_Ê8i€…ÿÿÿÿÿÿsÊiÊÐ|€†ÿÿÿÿÿÿ}ÊôtS„€‡ÿÿÿÿÿÿ‡Ê}ÊBi€ˆÿÿÿÿÿÿ‘ʇʪ€€‰ÿÿÿÿÿÿ›Ê‘ÊSk€Šÿÿÿÿÿÿ¥ÊC‡&‡€‹ÿÿÿÿÿÿ¯Ê¥Ê]k€Œÿÿÿÿÿÿ¹Ê¯ÊÑ€€ÿÿÿÿÿÿÃʹÊVi€ŽÿÿÿÿÿÿÍÊgkji€ÿÿÿÿÿÿ×ÊÍÊp„€ÿÿÿÿÿÿáÊ×Êø€€‘ÿÿÿÿÿÿëÊáÊ}€’ÿÿÿÿÿÿõÊëÊÃÊ€“ÿÿÿÿÿÿÿÊõʛʀ”ÿÿÿÿÿÿ ËÿÊsÊ€•ÿÿÿÿÿÿË ËKÊ€–ÿÿÿÿÿÿËAo°}€—ÿÿÿÿÿÿ'ËË“}€˜ÿÿÿÿÿÿ1Ë'Ëti€™ÿÿÿÿÿÿ;Ë1ËY}€šÿÿÿÿÿÿEËTow€›ÿÿÿÿÿÿOËEË~i€œÿÿÿÿÿÿYËOËG€ÿÿÿÿÿÿcËYË}€žÿÿÿÿÿÿmˈiÁ\€ŸÿÿÿÿÿÿwËmË쀠ÿÿÿÿÿÿËwË]€¡ÿÿÿÿÿÿ‹ËËab€¢ÿÿÿÿÿÿ•Ëo’i€£ÿÿÿÿÿÿŸË•ËÀ„€¤ÿÿÿÿÿÿ©ËŸËŠ€¥ÿÿÿÿÿÿ³Ë©ËÃ}€¦ÿÿÿÿÿÿ½ËÆoÔ‡€§ÿÿÿÿÿÿÇ˽ËE2€¨ÿÿÿÿÿÿÑËÇËž€©ÿÿÿÿÿÿÛËÑËœi€ªÿÿÿÿÿÿåËÛ˳ˀ«ÿÿÿÿÿÿïËåË‹Ë€¬ÿÿÿÿÿÿùËïËcË€­ÿÿÿÿÿÿÌùË;Ë€®ÿÿÿÿÿÿ Ì}~°i€¯ÿÿÿÿÿÿÌ Ìqk€°ÿÿÿÿÿÿ!ÌÌ&~€±ÿÿÿÿÿÿ+Ì!Ì ~€²ÿÿÿÿÿÿ5ÌN‚'‚€³ÿÿÿÿÿÿ?Ì5Ì ‚€´ÿÿÿÿÿÿIÌ?Ì퀵ÿÿÿÿÿÿSÌIÌÄi€¶ÿÿÿÿÿÿ]Ì-uR…€·ÿÿÿÿÿÿgÌ]Ì5…€¸ÿÿÿÿÿÿqÌgÌÎi€¹ÿÿÿÿÿÿ{ÌqÌL~€ºÿÿÿÿÿÿ…Ì{k@ˆ€»ÿÿÿÿÿÿÌ…Ì-€¼ÿÿÿÿÿÿ™ÌÌ:‚€½ÿÿÿÿÿÿ£Ì™Ìi~€¾ÿÿÿÿÿÿ­Ìâi…k€¿ÿÿÿÿÿÿ·Ì­Ìo…€ÀÿÿÿÿÿÿÁÌ·Ìa‚€ÁÿÿÿÿÿÿËÌÁÌ~€ÂÿÿÿÿÿÿÕÌẸ̈̀ÃÿÿÿÿÿÿßÌÕÌ{Ì€ÄÿÿÿÿÿÿéÌßÌSÌ€ÅÿÿÿÿÿÿóÌéÌ+Ì€ÆÿÿÿÿÿÿýÌT-€ÇÿÿÿÿÿÿÍýÌ€ÈÿÿÿÿÿÿÍÍß~€ÉÿÿÿÿÿÿÍÍöi€Êÿÿÿÿÿÿ%Í jô‚€Ëÿÿÿÿÿÿ/Í%ÍÍ‚€Ìÿÿÿÿÿÿ9Í/Í°‚€ÍÿÿÿÿÿÿCÍ9Íò~€ÎÿÿÿÿÿÿMÍfuj€ÏÿÿÿÿÿÿWÍMÍ­$€ÐÿÿÿÿÿÿaÍWÍà‚€ÑÿÿÿÿÿÿkÍaÍ€ÒÿÿÿÿÿÿuÍîˆÑˆ€ÓÿÿÿÿÿÿÍuÍä…€Ôÿÿÿÿÿÿ‰ÍÍ(j€Õÿÿÿÿÿÿ“͉Í@€Öÿÿÿÿÿÿͼ‹‰€×ÿÿÿÿÿÿ§ÍÍ€.€Øÿÿÿÿÿÿ±Í§Íƒ€Ùÿÿÿÿÿÿ»Í±Íg€ÚÿÿÿÿÿÿÅͻ͓̀ÛÿÿÿÿÿÿÏÍÅÍkÍ€ÜÿÿÿÿÿÿÙÍÏÍCÍ€ÝÿÿÿÿÿÿãÍÙÍÍ€ÞÿÿÿÿÿÿíÍãÍóÌ€ßÿÿÿÿÿÿ÷ÍíÍÌ€àÿÿÿÿÿÿÎ÷ÍË€áÿÿÿÿÿÿ ÎÎ#ÊâÿÿÿÿÿÿÎ Î3Éy¿Q¿Y·1·µ´²k¯ÿ¬Ë©#¦›œšç–÷•GŒæ{>xôltlWl"k6ãÿÿÿÿÿÿ5Î ÙÙóØæØÙØÌؿزإؘ؋Ø~ØdØWØJØ=Ø0Ø#ØØ Øü×ï×â×Õ×È׻׮סהׇ×z×m×`×S×F×9×,××××øÖëÖÞÖÑÖªÖÖÖƒÖvÖiÖ\ÖOÖBÖ5Ö(ÖÖÖÖôÕçÕÚÕÍÕÀÕ³Õ¦Õ™ÕŒÕÕeÕKÕ1ÕÕäÚØÚÓËÚ¾Ú±Ú•ÚˆÚ{ÚnÚaÚ/ÑÑûÐáÐÇÐ3Ú&ÚÚØْϸÙPÏ/Ï«Ù³w wwzwgwTwAw.www›vˆvuvbvOv‹Jˆ?…÷~@ÿÿÿÿÿÿÒÆ‹Ûˆ·$º‚Ì~@ ÿÿÿÿÿÿ"Ò%zz·$ëyÎy@ ÿÿÿÿÿÿ/ÒÞzÁz¤z‡zjz@ ÿÿÿÿÿÿ<Ò—{z{]{@{#{@ ÿÿÿÿÿÿIÒðÔãÔÖÔÉÔVÒ@ ÿÿÿÿÿÿVÒµ¦˜¦{¦^¦A¦@ÿÿÿÿÿÿcÒ¼Ô¯Ô¢Ô•ÔpÒ@ÿÿÿÿÿÿpÒ@ª#ªªé©—@ÿÿÿÿÿÿ}ÒˆÔ{ÔnÔaÔŠÒ@ÿÿÿÿÿÿŠÒL­9­&­­A¦@ÿÿÿÿÿÿ—Òñ¹±¯±¥±i±_±U±K±±±û°ñ°µ°«°¡°—°3°°Ï¯¯@ÿÿÿÿÿÿ¸ÒTÔGÔ:Ô-ÔÅÒ@ÿÿÿÿÿÿÅÒm²Y²E²1²Rx@ÿÿÿÿÿÿÒÒ ÔÔÔùÓßÒ@ÿÿÿÿÿÿßÒ#{jzÎyy\x@ÿÿÿÿÿÿìÒìÓßÓÒÓÓùÒ@ÿÿÿÿÿÿùÒ²µ©µ µ—µ\x@ÿÿÿÿÿÿÓ¼‹@ˆì8ið{@ÿÿÿÿÿÿÓþµõµìµ2yãµ@ÿÿÿÿÿÿ ÓÓoÓNÓ-Ó@ÿÿÿÿÿÿ-Óy‹™¸¸…¸žS¸ˆI¸?¸© ¸¸kbù·OÇ·½·³·„€õœ·w·m·c·ú{@ÿÿÿÿÿÿNÓŒ‹)ººíŸºã¹#ˆÙ¹“ŸÏ¹¹“¹"]9Ÿ‰¹W¹M¹C¹—€9¹¹ý¸ó¸ž|@ÿÿÿÿÿÿoÓŠ.¹»×¡¯»¥»s»-}¡i»_»-»#»v»»ÝºÓºÓ Ç-ɺ—ººy ƒºg4@ÿÿÿÿÿÿÓ©‹Á£I½?½5½½Jˆù¼ï¼å¼³¼£Ë\©¼Ÿ¼m¼½¢c¼È€Y¼'¼c¢¼¼H|@ ÿÿÿÿÿÿ±ÓƋپϾž»¾[¥]ˆ‰¾¾u¾¥C¾9¾/¾§¤ý½ó½ï€é½M¤·½­½£½[|@!ÿÿÿÿÿÿÒÓJ¶A¶·$8¶/¶@"ÿÿÿÿÿÿßÓ–¶Áz¶„¶{¶@#ÿÿÿÿÿÿìÓ—{â¶Ù¶Ð¶Ç¶@$ÿÿÿÿÿÿùÓ@{‡zëy2yyx@%ÿÿÿÿÿÿÔ]{¤z·$Oy–x@&ÿÿÿÿÿÿÔz{Ázzly³x@'ÿÿÿÿÿÿ Ô—{Þz%z‰yÐx@(ÿÿÿÿÿÿ-Ôå²Ñ²½²(y©²@)ÿÿÿÿÿÿ:Ô]³I³­$5³!³@*ÿÿÿÿÿÿGÔÕ³·zÁ³­³™³@+ÿÿÿÿÿÿTÔ{M´9´%´´@,ÿÿÿÿÿÿaÔÀ­­­š­§‡­@-ÿÿÿÿÿÿnÔ4®!®Š.®û­@.ÿÿÿÿÿÿ{Ô¨®¦¨•®‚®o®@/ÿÿÿÿÿÿˆÔ|©¯ ¯ö®ã®@0ÿÿÿÿÿÿ•Ôܪ¿ª¢ªÛ—…ª@1ÿÿÿÿÿÿ¢Ôx«[«O2>«!«@2ÿÿÿÿÿÿ¯Ô¬ö˜÷«Ú«½«@3ÿÿÿÿÿÿ¼ÔÌ™°¬“¬v¬Y¬@4ÿÿÿÿÿÿÉÔn§Q§4§§ú¦@5ÿÿÿÿÿÿÖÔ ¨í§Š.Ч³§@6ÿÿÿÿÿÿãÔ覨‰¨l¨O¨@7ÿÿÿÿÿÿðÔ|©_©B©%©©@8ÿÿÿÿÿÿýÔXÕ>Õ$Õ Õ@9ÿÿÿÿÿÿ Õy‹ˆkb„€ú{@:ÿÿÿÿÿÿÕöi ~Y} |ð{@;ÿÿÿÿÿÿ$ÕŒ‹#ˆ"]—€|@<ÿÿÿÿÿÿ1Õd|?kòh |ð{@=ÿÿÿÿÿÿ>ÕŠ.-vÇ-g4@>ÿÿÿÿÿÿKÕß~&~ti½| |@?ÿÿÿÿÿÿXÕ©‹JˆË\È€H|@@ÿÿÿÿÿÿeÕi+€€Þ |@AÿÿÿÿÿÿrÕÆ‹]ˆï€[|@BÿÿÿÿÿÿÕqk“}ä|]4@CÿÿÿÿÿÿŒÕރʃ5kû]4@Dÿÿÿÿÿÿ™Õ-°i°}Ik>|@Eÿÿÿÿÿÿ¦Õ±†‹†·ƒèh>|@Fÿÿÿÿÿÿ³ÕT}~Ao.i+k@GÿÿÿÿÿÿÀÕ±‰iát?€+k@HÿÿÿÿÿÿÍÕò~Äi}Ð| |@IÿÿÿÿÿÿÚÕ}ViSkÐ| |@JÿÿÿÿÿÿçÕ°‚íG8iÞ@KÿÿÿÿÿÿôÕø€Ñ€ª€8i½|@LÿÿÿÿÿÿÖÍ‚ ‚~i½-û@MÿÿÿÿÿÿÖp„]kBi½-ä|@NÿÿÿÿÿÿÖô‚'‚w¾€èh@Oÿÿÿÿÿÿ(Öji&‡S„¾€Ik@Pÿÿÿÿÿÿ5Ö jN‚Toå€?€@QÿÿÿÿÿÿBÖgkC‡ôtå€.i@RÿÿÿÿÿÿOÖL~abSkòh@Sÿÿÿÿÿÿ\ÖœiÃ}ab}Y}@TÿÿÿÿÿÿiÖà‚Îi]ª€€@UÿÿÿÿÿÿvÖžŠ]Gti@VÿÿÿÿÿÿƒÖ­$5…ìBi5k@WÿÿÿÿÿÿÖE2À„ì~i“}@XÿÿÿÿÿÿÖjR…Á\S„·ƒ@YÿÿÿÿÿÿªÖÔ‡’iÁ\w°}@Zÿÿÿÿÿÿ·Öfu-uôtát@[ÿÿÿÿÿÿÄÖÆooToAo@\ÿÿÿÿÿÿÑÖ@i~Ã}Vi?k@]ÿÿÿÿÿÿÞÖ~i~L~Äi ~@^ÿÿÿÿÿÿëÖ(j:‚ŠÑ€+€@_ÿÿÿÿÿÿøÖa‚:‚Îií&~@`ÿÿÿÿÿÿ×ä…-À„]kʃ@aÿÿÿÿÿÿ×o…-5… ‚qk@bÿÿÿÿÿÿ×ш@ˆ’i&‡‹†@cÿÿÿÿÿÿ,×…k@ˆR…'‚°i@dÿÿÿÿÿÿ9×îˆ{koC‡i@eÿÿÿÿÿÿF×âi{k-uN‚}~@fÿÿÿÿÿÿS×g~œi}d|@gÿÿÿÿÿÿ`×g@ò~öi@hÿÿÿÿÿÿm׃a‚žø€i@iÿÿÿÿÿÿz׃(jà‚°‚ß~@jÿÿÿÿÿÿ‡×€.o…E2p„Þƒ@kÿÿÿÿÿÿ”×€.ä…­$Í‚@lÿÿÿÿÿÿ¡×‰…kÔ‡ji±†@mÿÿÿÿÿÿ®×‰Ñˆjô‚-@nÿÿÿÿÿÿ»×¼‹âiÆogk±‰@oÿÿÿÿÿÿÈ×¼‹îˆfu jT@pÿÿÿÿÿÿÕ×+k>|]4 |ð{@qÿÿÿÿÿÿâ×?€èhûÞ |@rÿÿÿÿÿÿï×át·ƒ5k€òh@sÿÿÿÿÿÿü×i‹†Êƒ+€?k@tÿÿÿÿÿÿ ر‰±†Þƒid|@uÿÿÿÿÿÿØ.iIkä|½| |@vÿÿÿÿÿÿ#Ø倾€½-8iÐ|@wÿÿÿÿÿÿ0ØôtS„Biª€Sk@xÿÿÿÿÿÿ=ØC‡&‡]kÑ€Vi@yÿÿÿÿÿÿJØgkjip„ø€}@zÿÿÿÿÿÿWØAo°}“}tiY}@{ÿÿÿÿÿÿdØTow~iG}@|ÿÿÿÿÿÿqØÁ\ì]ab@}ÿÿÿÿÿÿ~Øo’iÀ„ŠÃ}@~ÿÿÿÿÿÿ‹ØÆoÔ‡E2žœi@ÿÿÿÿÿÿ˜Ø}~°iqk&~ ~@€ÿÿÿÿÿÿ¥ØN‚'‚ ‚íÄi@ÿÿÿÿÿÿ²Ø-uR…5…ÎiL~@‚ÿÿÿÿÿÿ¿Ø{k@ˆ-:‚i~@ƒÿÿÿÿÿÿÌØâi…ko…a‚~@„ÿÿÿÿÿÿÙØT-ß~öi@…ÿÿÿÿÿÿæØ jô‚Í‚°‚ò~@†ÿÿÿÿÿÿóØfuj­$à‚@‡ÿÿÿÿÿÿÙîˆÑˆä…(j@@ˆÿÿÿÿÿÿ Ù¼‹‰€.ƒg@‰ÿÿÿÿÿÿÙTÙ…k{kÎiÄiqkœi’i~itigk]kSk8iIki?k5kèh+k@Šÿÿÿÿÿÿ7ÙTÙâi-ÎiÄi°iœi’i~itijiViBi8i.iiiòhèh]4@‹ÿÿÿÿÿÿTÙ€.(jj jöiŒÿÿÿÿÿÿaÙTÙâi-ÎiÄi°iœi’i~itijiViBi8i.iiiòhèh]4@ÿÿÿÿÿÿ}ÙaÙŽÿÿÿÿÿÿ†ÙTÙ…k{kÎiÄiqkœi’i~itigk]kSk8iIki?k5kèh+k@ÿÿÿÿÿÿ¢Ù†Ù@ÿÿÿÿÿÿ«Ù<Ò/Ò"Ò†Ð"Ï‘ÿÿÿÿÿÿ¸Ùø…î…Ñ…Ç…´…y…e…H…+……Ê„„T¶„¬„z„f„I„6„#„èƒÔƒ­ƒšƒ‡ƒ@’ÿÿÿÿÿÿØÙÏ‹²‹Ÿ‹•‹‚‹G‹4‹!‹‹ûŠÀŠ¶ŠO2™Š†ŠKŠ8Š%ŠŠÿ‰Ä‰§‰”‰‰n‰“ÿÿÿÿÿÿùÙ•u•k•a•W•%••••ý”Ë”Á”­”£”q”g”]”S”I”” ””ù“ï“@”ÿÿÿÿÿÿÚùÙDÐ#ÐÐáÏ@•ÿÿÿÿÿÿ&ÚÒÒûÑ<Ñ Ð@–ÿÿÿÿÿÿ3Ú"ÑÑîÐÔкÐ@—ÿÿÿÿÿÿ@ÚÆ‹«¥¡¥—¥¥[¥Q¥G¥=¥3¥¥÷¤vã¤Ù¤§¤¤“¤‰¤¤M¤C¤9¤/¤%¤@˜ÿÿÿÿÿÿaÚ@ڹјÑwÑVÑ@™ÿÿÿÿÿÿnÚðÔãÔÖÔÉÔVÒ@šÿÿÿÿÿÿ{Ú¼Ô¯Ô¢Ô•ÔpÒ@›ÿÿÿÿÿÿˆÚˆÔ{ÔnÔaÔŠÒœÿÿÿÿÿÿ•Úñ¹±¯±¥±i±_±U±K±±±û°ñ°µ°«°¡°—°3°°Ï¯¯@ÿÿÿÿÿÿ±ÚTÔGÔ:Ô-ÔÅÒ@žÿÿÿÿÿÿ¾Ú ÔÔÔùÓßÒ@ŸÿÿÿÿÿÿËÚìÓßÓÒÓÓùÒ ÿÿÿÿÿÿØÚÓoÓNÓ-Ó¡ÿÿÿÿÿÿäÚXÕ>Õ$Õ Õ5¢ÿÿÿÿÿÿðÚ ÙÙóØæØÙØÌؿزإؘ؋Ø~ØdØWØJØ=Ø0Ø#ØØ Øü×ï×â×Õ×È׻׮סהׇ×z×m×`×S×F×9×,××××øÖëÖÞÖÑÖªÖÖÖƒÖvÖiÖ\ÖOÖBÖ5Ö(ÖÖÖÖôÕçÕÚÕÍÕÀÕ³Õ¦Õ™ÕŒÕÕeÕKÕ1ÕÕäÚØÚÓËÚ¾Ú±Ú•ÚˆÚ{ÚnÚaÚ/ÑÑûÐáÐÇÐ3Ú&ÚÚØْϸÙPÏ/Ï«Ù³w wwzwgwTwAw.www›vˆvuvbvOvCHNSX[^addtruefalsenot==>andorxordistinctite=distinctite=distinctiteop1ope4e3e2e1e0R PBoolUIIIIIIII@<P sW_oR PBoolUIIIIIIII@<P PBoolUI P   .>3C(8H1 0 -2 0 127 0 132 0 217 0 247 0 273 0 279 0 316 0 346 0 376 0 402 0 531 0 553 0 559 0 689 0 714 0 740 0 765 0 791 0 817 0 -823 0 -824 0 -825 0 -826 0 -827 0 -828 0 -829 0 -830 0 -831 0 -832 0 -833 0 -834 0 -835 0 -836 0 -837 0 -838 0 -839 0 -840 0 -841 0 -842 0 -843 0 -13 0 -281 0 416 0 436 0 456 0 476 0 497 0 489 0 667 0 -692 0 -844 0 -845 0 -38 0 494 0 672 0 -697 0 -846 0 -847 0 -83 0 503 0 681 0 -706 0 -108 0 508 0 686 0 -711 0 -848 0 -849 0 -850 0 -851 0 -852 0 -853 0 -854 0 -855 0 -856 0 -857 0 -858 0 -859 0 -860 0 -861 0 -862 0 -863 0 -864 0 -865 0 -866 0 -867 0 -868 0 -869 0 -870 0 -871 0 -872 0 -873 0 -874 0 -875 0 -876 0 -877 0 -878 0 -879 0 -880 0 -881 0 -882 0 -883 0 -884 0 -885 0 -886 0 -887 0 -888 0 -889 0 -53 0 675 0 -700 0 -890 0 -891 0 -58 0 498 0 676 0 -701 0 -892 0 -893 0 -63 0 499 0 677 0 -702 0 -68 0 500 0 678 0 -703 0 -894 0 -895 0 -896 0 -897 0 -898 0 -899 0 -900 0 -901 0 -902 0 -903 0 -904 0 -905 0 -906 0 -907 0 -908 0 -909 0 -910 0 -911 0 -912 0 -913 0 -914 0 -123 0 477 0 652 0 -727 0 -124 0 -289 0 418 0 438 0 627 0 -752 0 -125 0 602 0 -778 0 -126 0 577 0 -804 0 -915 0 -916 0 -917 0 -918 0 -919 0 -920 0 14 0 650 0 -742 0 41 0 601 0 -749 0 57 0 567 0 802 0 3 4 5 6 7 0 8 9 10 11 12 0 14 15 13 16 17 0 18 19 20 21 22 0 23 24 25 26 27 0 28 29 30 31 32 0 33 34 35 36 37 0 39 40 38 41 42 0 43 44 45 46 47 0 48 49 50 51 52 0 54 55 53 56 57 0 59 60 58 61 62 0 64 65 63 66 67 0 69 70 68 71 72 0 73 74 75 76 77 0 78 79 80 81 82 0 84 85 83 86 87 0 88 89 90 91 92 0 93 94 95 96 97 0 98 99 100 101 102 0 103 104 105 106 107 0 109 110 108 111 112 0 113 114 115 116 117 0 118 119 120 121 122 0 3 8 13 18 23 0 3 28 53 73 98 0 4 9 14 19 24 0 4 29 54 74 99 0 5 10 15 20 25 0 5 30 55 75 100 0 6 11 16 21 26 0 6 31 56 76 101 0 7 12 17 22 27 0 7 32 57 77 102 0 28 33 38 43 48 0 8 33 58 78 103 0 29 34 39 44 49 0 9 34 59 79 104 0 30 35 40 45 50 0 10 35 60 80 105 0 31 36 41 46 51 0 11 36 61 81 106 0 32 37 42 47 52 0 12 37 62 82 107 0 54 59 64 69 123 0 14 39 84 109 123 0 55 60 65 70 124 0 15 40 85 110 124 0 56 61 66 71 125 0 16 41 86 111 125 0 57 62 67 72 126 0 17 42 87 112 126 0 73 78 83 88 93 0 18 43 63 88 113 0 74 79 84 89 94 0 19 44 64 89 114 0 75 80 85 90 95 0 20 45 65 90 115 0 76 81 86 91 96 0 21 46 66 91 116 0 77 82 87 92 97 0 22 47 67 92 117 0 98 103 108 113 118 0 23 48 68 93 118 0 99 104 109 114 119 0 24 49 69 94 119 0 100 105 110 115 120 0 25 50 70 95 120 0 101 106 111 116 121 0 26 51 71 96 121 0 102 107 112 117 122 0 27 52 72 97 122 0 128 129 130 131 0 -7 -131 0 -37 -131 0 -126 -131 0 -92 -131 0 -122 -131 0 7 37 92 122 126 131 0 -6 -130 0 -36 -130 0 -125 -130 0 -91 -130 0 -121 -130 0 6 36 91 121 125 130 0 -5 -129 0 -35 -129 0 -124 -129 0 -90 -129 0 -120 -129 0 5 35 90 120 124 129 0 -4 -128 0 -34 -128 0 -123 -128 0 -89 -128 0 -119 -128 0 4 34 89 119 123 128 0 133 134 135 136 0 -7 -136 0 -136 137 0 -136 138 0 -136 139 0 -136 140 0 -136 141 0 -37 -136 0 -136 142 0 -136 143 0 -136 144 0 -136 145 0 -136 146 0 -126 -136 0 -136 147 0 -136 148 0 -136 149 0 -136 150 0 -136 151 0 -92 -136 0 -136 152 0 -136 153 0 -136 154 0 -136 155 0 -136 156 0 -122 -136 0 7 37 92 122 126 136 -137 -138 -139 -140 -141 -142 -143 -144 -145 -146 -147 -148 -149 -150 -151 -152 -153 -154 -155 -156 0 117 156 0 97 156 0 -97 -117 -156 0 112 155 0 72 155 0 -72 -112 -155 0 107 154 0 52 154 0 -52 -107 -154 0 102 153 0 27 153 0 -27 -102 -153 0 97 152 0 117 152 0 -97 -117 -152 0 87 151 0 67 151 0 -67 -87 -151 0 82 150 0 47 150 0 -47 -82 -150 0 77 149 0 22 149 0 -22 -77 -149 0 72 148 0 112 148 0 -72 -112 -148 0 67 147 0 87 147 0 -67 -87 -147 0 62 146 0 42 146 0 -42 -62 -146 0 57 145 0 17 145 0 -17 -145 -57 0 52 144 0 107 144 0 -52 -107 -144 0 47 143 0 82 143 0 -47 -82 -143 0 42 142 0 62 142 0 -42 -62 -142 0 32 141 0 12 141 0 -12 -32 -141 0 27 140 0 102 140 0 -27 -102 -140 0 22 139 0 77 139 0 -22 -77 -139 0 17 138 0 57 138 0 -17 -138 -57 0 12 137 0 32 137 0 -12 -32 -137 0 -6 -135 0 -135 157 0 -135 158 0 -135 159 0 -135 160 0 -135 161 0 -36 -135 0 -135 162 0 -135 163 0 -135 164 0 -135 165 0 -135 166 0 -125 -135 0 -135 167 0 -135 168 0 -135 169 0 -135 170 0 -135 171 0 -91 -135 0 -135 172 0 -135 173 0 -135 174 0 -135 175 0 -135 176 0 -121 -135 0 6 36 91 121 125 135 -157 -158 -159 -160 -161 -162 -163 -164 -165 -166 -167 -168 -169 -170 -171 -172 -173 -174 -175 -176 0 116 176 0 96 176 0 -96 -116 -176 0 111 175 0 71 175 0 -71 -111 -175 0 106 174 0 51 174 0 -51 -106 -174 0 101 173 0 26 173 0 -26 -101 -173 0 96 172 0 116 172 0 -96 -116 -172 0 86 171 0 66 171 0 -66 -86 -171 0 81 170 0 46 170 0 -46 -81 -170 0 76 169 0 21 169 0 -21 -76 -169 0 71 168 0 111 168 0 -71 -111 -168 0 66 167 0 86 167 0 -66 -86 -167 0 61 166 0 41 166 0 -61 -166 -41 0 56 165 0 16 165 0 -16 -56 -165 0 51 164 0 106 164 0 -51 -106 -164 0 46 163 0 81 163 0 -46 -81 -163 0 41 162 0 61 162 0 -61 -162 -41 0 31 161 0 11 161 0 -11 -31 -161 0 26 160 0 101 160 0 -26 -101 -160 0 21 159 0 76 159 0 -21 -76 -159 0 16 158 0 56 158 0 -16 -56 -158 0 11 157 0 31 157 0 -11 -31 -157 0 -5 -134 0 -134 177 0 -134 178 0 -134 179 0 -134 180 0 -134 181 0 -35 -134 0 -134 182 0 -134 183 0 -134 184 0 -134 185 0 -134 186 0 -124 -134 0 -134 187 0 -134 188 0 -134 189 0 -134 190 0 -134 191 0 -90 -134 0 -134 192 0 -134 193 0 -134 194 0 -134 195 0 -134 196 0 -120 -134 0 5 35 90 120 124 134 -177 -178 -179 -180 -181 -182 -183 -184 -185 -186 -187 -188 -189 -190 -191 -192 -193 -194 -195 -196 0 115 196 0 95 196 0 -95 -115 -196 0 110 195 0 70 195 0 -70 -110 -195 0 105 194 0 50 194 0 -50 -105 -194 0 100 193 0 25 193 0 -25 -100 -193 0 95 192 0 115 192 0 -95 -115 -192 0 85 191 0 65 191 0 -65 -85 -191 0 80 190 0 45 190 0 -45 -80 -190 0 75 189 0 20 189 0 -20 -75 -189 0 70 188 0 110 188 0 -70 -110 -188 0 65 187 0 85 187 0 -65 -85 -187 0 60 186 0 40 186 0 -40 -60 -186 0 55 185 0 15 185 0 -15 -55 -185 0 50 184 0 105 184 0 -50 -105 -184 0 45 183 0 80 183 0 -45 -80 -183 0 40 182 0 60 182 0 -40 -60 -182 0 30 181 0 10 181 0 -10 -30 -181 0 25 180 0 100 180 0 -25 -100 -180 0 20 179 0 75 179 0 -20 -75 -179 0 15 178 0 55 178 0 -15 -55 -178 0 10 177 0 30 177 0 -10 -30 -177 0 -4 -133 0 -133 197 0 -133 198 0 -133 199 0 -133 200 0 -133 201 0 -34 -133 0 -133 202 0 -133 203 0 -133 204 0 -133 205 0 -133 206 0 -123 -133 0 -133 207 0 -133 208 0 -133 209 0 -133 210 0 -133 211 0 -89 -133 0 -133 212 0 -133 213 0 -133 214 0 -133 215 0 -133 216 0 -119 -133 0 4 34 89 119 123 133 -197 -198 -199 -200 -201 -202 -203 -204 -205 -206 -207 -208 -209 -210 -211 -212 -213 -214 -215 -216 0 114 216 0 94 216 0 -94 -114 -216 0 109 215 0 69 215 0 -69 -109 -215 0 104 214 0 49 214 0 -49 -104 -214 0 99 213 0 24 213 0 -24 -99 -213 0 94 212 0 114 212 0 -94 -114 -212 0 84 211 0 64 211 0 -64 -84 -211 0 79 210 0 44 210 0 -44 -79 -210 0 74 209 0 19 209 0 -19 -74 -209 0 69 208 0 109 208 0 -69 -109 -208 0 64 207 0 84 207 0 -64 -84 -207 0 59 206 0 39 206 0 -39 -59 -206 0 54 205 0 14 205 0 -54 -205 -14 0 49 204 0 104 204 0 -49 -104 -204 0 44 203 0 79 203 0 -44 -79 -203 0 39 202 0 59 202 0 -39 -59 -202 0 29 201 0 9 201 0 -9 -29 -201 0 24 200 0 99 200 0 -24 -99 -200 0 19 199 0 74 199 0 -19 -74 -199 0 14 198 0 54 198 0 -54 -198 -14 0 9 197 0 29 197 0 -9 -29 -197 0 3 34 91 122 124 0 218 219 220 221 222 0 -222 -223 0 -222 -224 0 -222 -225 0 -222 -226 0 -222 -227 0 222 223 224 225 226 227 0 -221 -228 0 -221 -229 0 -221 -230 0 -221 -231 0 -221 -232 0 221 228 229 230 231 232 0 -220 -233 0 -220 -234 0 -15 -220 0 -220 -235 0 -220 -236 0 15 220 233 234 235 236 0 -219 -237 0 -219 -238 0 -219 -239 0 -219 -240 0 -219 -241 0 219 237 238 239 240 241 0 -218 -242 0 -218 -243 0 -218 -244 0 -218 -245 0 -218 -246 0 218 242 243 244 245 246 0 248 249 250 251 252 0 -252 -253 0 -252 -254 0 -252 -255 0 -252 -256 0 -227 -252 0 227 252 253 254 255 256 0 -251 -257 0 -251 -258 0 -251 -259 0 -231 -251 0 -251 -260 0 231 251 257 258 259 260 0 -250 -261 0 -250 -262 0 -15 -250 0 -250 -263 0 -250 -264 0 15 250 261 262 263 264 0 -249 -265 0 -238 -249 0 -249 -266 0 -249 -267 0 -249 -268 0 238 249 265 266 267 268 0 -242 -248 0 -248 -269 0 -248 -270 0 -248 -271 0 -248 -272 0 242 248 269 270 271 272 0 274 275 276 277 278 0 223 -278 0 224 -278 0 225 -278 0 226 -278 0 227 -278 0 -223 -224 -225 -226 -227 278 0 228 -277 0 229 -277 0 230 -277 0 231 -277 0 232 -277 0 -228 -229 -230 -231 -232 277 0 233 -276 0 234 -276 0 15 -276 0 235 -276 0 236 -276 0 -15 -233 -234 -235 -236 276 0 237 -275 0 238 -275 0 239 -275 0 240 -275 0 241 -275 0 -237 -238 -239 -240 -241 275 0 242 -274 0 243 -274 0 244 -274 0 245 -274 0 246 -274 0 -242 -243 -244 -245 -246 274 0 280 282 281 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 0 122 -299 0 -299 300 0 -122 299 -300 0 -300 301 0 -122 -300 0 122 300 -301 0 -301 302 0 -92 -301 0 92 301 -302 0 -302 303 0 -126 -302 0 302 -303 126 0 -7 -303 0 -37 -303 0 7 37 303 0 117 -298 0 -298 304 0 -117 298 -304 0 -304 305 0 -121 -304 0 121 304 -305 0 -305 306 0 -91 -305 0 91 305 -306 0 -306 307 0 -125 -306 0 306 -307 125 0 -6 -307 0 -36 -307 0 6 36 307 0 112 -297 0 -297 308 0 -112 297 -308 0 -308 309 0 -120 -308 0 120 308 -309 0 -309 310 0 -90 -309 0 90 309 -310 0 -310 311 0 -124 -310 0 310 -311 124 0 -5 -311 0 -35 -311 0 5 35 311 0 107 -296 0 -296 312 0 -107 296 -312 0 -312 313 0 -119 -312 0 119 312 -313 0 -313 314 0 -89 -313 0 89 313 -314 0 -314 315 0 -123 -314 0 314 -315 123 0 -4 -315 0 -34 -315 0 4 34 315 0 96 -295 0 -295 300 0 -96 295 -300 0 91 -294 0 -294 304 0 -91 294 -304 0 86 -293 0 -293 308 0 -86 293 -308 0 81 -292 0 -292 312 0 -81 292 -312 0 70 -291 0 -291 300 0 -70 291 -300 0 65 -290 0 -290 304 0 -65 290 -304 0 -289 124 0 -289 308 0 -124 289 -308 0 60 -288 0 -288 312 0 -60 288 -312 0 49 -287 0 -287 300 0 -49 287 -300 0 44 -286 0 -286 304 0 -44 286 -304 0 39 -285 0 -285 308 0 -39 285 -308 0 34 -284 0 -284 312 0 -34 284 -312 0 23 -283 0 -283 300 0 -23 283 -300 0 18 -282 0 -282 304 0 -18 282 -304 0 -281 13 0 -281 308 0 -13 281 -308 0 8 -280 0 -280 312 0 -8 280 -312 0 317 318 319 320 321 0 -321 -322 0 -321 -323 0 -321 -324 0 -321 -325 0 -321 -326 0 321 322 323 324 325 326 0 -320 -327 0 -320 -328 0 -320 -329 0 -320 -330 0 -320 -331 0 320 327 328 329 330 331 0 -319 -332 0 -319 -333 0 -5 -319 0 -319 -334 0 -319 -335 0 5 319 332 333 334 335 0 -318 -336 0 -318 -337 0 -318 -338 0 -318 -339 0 -318 -340 0 318 336 337 338 339 340 0 -317 -341 0 -317 -342 0 -317 -343 0 -317 -344 0 -317 -345 0 317 341 342 343 344 345 0 347 348 349 350 351 0 -351 -352 0 -351 -353 0 -351 -354 0 -351 -355 0 -351 -356 0 351 352 353 354 355 356 0 -350 -357 0 -350 -358 0 -350 -359 0 -350 -360 0 -350 -361 0 350 357 358 359 360 361 0 -349 -362 0 -349 -363 0 -55 -349 0 -349 -364 0 -349 -365 0 55 349 362 363 364 365 0 -348 -366 0 -348 -367 0 -348 -368 0 -348 -369 0 -348 -370 0 348 366 367 368 369 370 0 -347 -371 0 -347 -372 0 -347 -373 0 -347 -374 0 -347 -375 0 347 371 372 373 374 375 0 377 378 379 380 381 0 -381 -382 0 -381 -383 0 -381 -384 0 -381 -385 0 -326 -381 0 326 381 382 383 384 385 0 -380 -386 0 -380 -387 0 -380 -388 0 -330 -380 0 -380 -389 0 330 380 386 387 388 389 0 -379 -390 0 -379 -391 0 -5 -379 0 -379 -392 0 -379 -393 0 5 379 390 391 392 393 0 -378 -394 0 -337 -378 0 -378 -395 0 -378 -396 0 -378 -397 0 337 378 394 395 396 397 0 -341 -377 0 -377 -398 0 -377 -399 0 -377 -400 0 -377 -401 0 341 377 398 399 400 401 0 403 404 405 406 407 0 -407 408 0 -407 409 0 -407 410 0 -407 411 0 140 -407 0 -407 412 0 -407 413 0 -407 414 0 -407 415 0 144 -407 0 -407 416 0 -407 417 0 -407 418 0 -407 419 0 148 -407 0 -407 420 0 -407 421 0 -407 422 0 -407 423 0 152 -407 0 -407 424 0 -407 425 0 -407 426 0 -407 427 0 -122 -407 0 122 -140 -144 -148 -152 407 -408 -409 -410 -411 -412 -413 -414 -415 -416 -417 -418 -419 -420 -421 -422 -423 -424 -425 -426 -427 0 117 427 0 96 427 0 -96 -117 -427 0 112 426 0 70 426 0 -70 -112 -426 0 107 425 0 49 425 0 -49 -107 -425 0 102 424 0 23 424 0 -23 -102 -424 0 92 423 0 91 423 0 -91 -92 -423 0 87 422 0 65 422 0 -65 -87 -422 0 82 421 0 44 421 0 -44 -82 -421 0 77 420 0 18 420 0 -18 -77 -420 0 67 419 0 86 419 0 -67 -86 -419 0 418 126 0 418 124 0 -124 -126 -418 0 62 417 0 39 417 0 -39 -62 -417 0 57 416 0 416 13 0 -13 -57 -416 0 47 415 0 81 415 0 -47 -81 -415 0 42 414 0 60 414 0 -42 -60 -414 0 37 413 0 34 413 0 -34 -37 -413 0 32 412 0 8 412 0 -8 -32 -412 0 22 411 0 76 411 0 -22 -76 -411 0 17 410 0 55 410 0 -17 -55 -410 0 12 409 0 29 409 0 -12 -29 -409 0 7 408 0 3 408 0 -3 -7 -408 0 -406 428 0 -406 429 0 -406 430 0 159 -406 0 -406 431 0 -406 432 0 -406 433 0 -406 434 0 163 -406 0 -406 435 0 -406 436 0 -406 437 0 -406 438 0 167 -406 0 -406 439 0 -406 440 0 -406 441 0 -406 442 0 -91 -406 0 -406 443 0 -406 444 0 -406 445 0 -406 446 0 176 -406 0 -406 447 0 91 -159 -163 -167 -176 406 -428 -429 -430 -431 -432 -433 -434 -435 -436 -437 -438 -439 -440 -441 -442 -443 -444 -445 -446 -447 0 121 447 0 122 447 0 -121 -122 -447 0 111 446 0 70 446 0 -70 -111 -446 0 106 445 0 49 445 0 -49 -106 -445 0 101 444 0 23 444 0 -23 -101 -444 0 96 443 0 117 443 0 -96 -117 -443 0 86 442 0 65 442 0 -65 -86 -442 0 81 441 0 44 441 0 -44 -81 -441 0 76 440 0 18 440 0 -18 -76 -440 0 71 439 0 112 439 0 -71 -112 -439 0 438 125 0 438 124 0 -124 -125 -438 0 61 437 0 39 437 0 -39 -61 -437 0 56 436 0 436 13 0 -13 -56 -436 0 51 435 0 107 435 0 -51 -107 -435 0 41 434 0 60 434 0 -60 -434 -41 0 36 433 0 34 433 0 -34 -36 -433 0 31 432 0 8 432 0 -8 -31 -432 0 26 431 0 102 431 0 -26 -102 -431 0 16 430 0 55 430 0 -16 -55 -430 0 11 429 0 29 429 0 -11 -29 -429 0 6 428 0 3 428 0 -3 -6 -428 0 -405 448 0 -405 449 0 178 -405 0 -405 450 0 -405 451 0 -405 452 0 -405 453 0 182 -405 0 -405 454 0 -405 455 0 -405 456 0 -405 457 0 -124 -405 0 -405 458 0 -405 459 0 -405 460 0 -405 461 0 191 -405 0 -405 462 0 -405 463 0 -405 464 0 -405 465 0 195 -405 0 -405 466 0 -405 467 0 -178 -182 124 -191 -195 405 -448 -449 -450 -451 -452 -453 -454 -455 -456 -457 -458 -459 -460 -461 -462 -463 -464 -465 -466 -467 0 120 467 0 122 467 0 -120 -122 -467 0 115 466 0 96 466 0 -96 -115 -466 0 105 465 0 49 465 0 -49 -105 -465 0 100 464 0 23 464 0 -23 -100 -464 0 95 463 0 117 463 0 -95 -117 -463 0 90 462 0 91 462 0 -90 -91 -462 0 80 461 0 44 461 0 -44 -80 -461 0 75 460 0 18 460 0 -18 -75 -460 0 70 459 0 112 459 0 -70 -112 -459 0 65 458 0 86 458 0 -65 -86 -458 0 60 457 0 39 457 0 -39 -60 -457 0 55 456 0 456 13 0 -13 -55 -456 0 50 455 0 107 455 0 -50 -107 -455 0 45 454 0 81 454 0 -45 -81 -454 0 35 453 0 34 453 0 -34 -35 -453 0 30 452 0 8 452 0 -8 -30 -452 0 25 451 0 102 451 0 -25 -102 -451 0 20 450 0 76 450 0 -20 -76 -450 0 10 449 0 29 449 0 -10 -29 -449 0 5 448 0 3 448 0 -3 -5 -448 0 -404 468 0 197 -404 0 -404 469 0 -404 470 0 -404 471 0 -404 472 0 -34 -404 0 -404 473 0 -404 474 0 -404 475 0 -404 476 0 206 -404 0 -404 477 0 -404 478 0 -404 479 0 -404 480 0 210 -404 0 -404 481 0 -404 482 0 -404 483 0 -404 484 0 214 -404 0 -404 485 0 -404 486 0 -404 487 0 34 -197 -206 -210 -214 404 -468 -469 -470 -471 -472 -473 -474 -475 -476 -477 -478 -479 -480 -481 -482 -483 -484 -485 -486 -487 0 119 487 0 122 487 0 -119 -122 -487 0 114 486 0 96 486 0 -96 -114 -486 0 109 485 0 70 485 0 -70 -109 -485 0 99 484 0 23 484 0 -23 -99 -484 0 94 483 0 117 483 0 -94 -117 -483 0 89 482 0 91 482 0 -89 -91 -482 0 84 481 0 65 481 0 -65 -84 -481 0 74 480 0 18 480 0 -18 -74 -480 0 69 479 0 112 479 0 -69 -112 -479 0 64 478 0 86 478 0 -64 -86 -478 0 477 123 0 477 124 0 -123 -124 -477 0 54 476 0 476 13 0 -13 -54 -476 0 49 475 0 107 475 0 -49 -107 -475 0 44 474 0 81 474 0 -44 -81 -474 0 39 473 0 60 473 0 -39 -60 -473 0 29 472 0 8 472 0 -8 -29 -472 0 24 471 0 102 471 0 -24 -102 -471 0 19 470 0 76 470 0 -19 -76 -470 0 14 469 0 55 469 0 -55 -469 -14 0 4 468 0 3 468 0 -3 -4 -468 0 -3 -403 0 -403 488 0 -403 489 0 -403 490 0 -403 491 0 -403 492 0 -403 493 0 -403 494 0 -403 495 0 -403 496 0 -403 497 0 -403 498 0 -124 -403 0 -403 499 0 -403 500 0 -403 501 0 -403 502 0 -403 503 0 -403 504 0 -403 505 0 -403 506 0 -403 507 0 -403 508 0 -403 509 0 -403 510 0 3 403 124 -488 -489 -490 -491 -492 -493 -494 -495 -496 -497 -498 -499 -500 -501 -502 -503 -504 -505 -506 -507 -508 -509 -510 0 118 510 0 122 510 0 -118 -122 -510 0 113 509 0 96 509 0 -96 -113 -509 0 508 108 0 70 508 0 -70 -108 -508 0 103 507 0 49 507 0 -49 -103 -507 0 98 506 0 23 506 0 -23 -98 -506 0 93 505 0 117 505 0 -93 -117 -505 0 88 504 0 91 504 0 -88 -91 -504 0 503 83 0 65 503 0 -65 -83 -503 0 78 502 0 44 502 0 -44 -78 -502 0 73 501 0 18 501 0 -18 -73 -501 0 500 68 0 112 500 0 -68 -112 -500 0 499 63 0 86 499 0 -63 -86 -499 0 498 58 0 39 498 0 -39 -58 -498 0 497 53 0 497 13 0 -13 -53 -497 0 48 496 0 107 496 0 -48 -107 -496 0 43 495 0 81 495 0 -43 -81 -495 0 494 38 0 60 494 0 -38 -60 -494 0 33 493 0 34 493 0 -33 -34 -493 0 28 492 0 8 492 0 -8 -28 -492 0 23 491 0 102 491 0 -23 -102 -491 0 18 490 0 76 490 0 -18 -76 -490 0 489 13 0 55 489 0 -13 -55 -489 0 8 488 0 29 488 0 -8 -29 -488 0 371 511 512 513 514 0 367 515 516 517 518 0 55 519 520 521 522 0 360 523 524 525 526 0 356 527 528 529 530 0 532 533 534 535 536 0 -536 -537 0 -536 -538 0 -536 -539 0 -536 -540 0 -356 -536 0 356 536 537 538 539 540 0 -535 -541 0 -535 -542 0 -535 -543 0 -360 -535 0 -535 -544 0 360 535 541 542 543 544 0 -3 -534 0 -29 -534 0 -55 -534 0 -76 -534 0 -102 -534 0 3 29 55 76 102 534 0 -533 -545 0 -367 -533 0 -533 -546 0 -533 -547 0 -533 -548 0 367 533 545 546 547 548 0 -371 -532 0 -532 -549 0 -532 -550 0 -532 -551 0 -532 -552 0 371 532 549 550 551 552 0 554 555 556 557 558 0 -98 -558 0 -104 -558 0 -110 -558 0 -116 -558 0 -122 -558 0 98 104 110 116 122 558 0 -73 -557 0 -79 -557 0 -85 -557 0 -91 -557 0 -97 -557 0 73 79 85 91 97 557 0 -53 -556 0 -59 -556 0 -124 -556 0 -66 -556 0 -72 -556 0 59 66 53 72 124 556 0 -28 -555 0 -34 -555 0 -40 -555 0 -46 -555 0 -52 -555 0 28 34 40 46 52 555 0 -3 -554 0 -9 -554 0 -15 -554 0 -21 -554 0 -27 -554 0 3 9 15 21 27 554 0 560 561 562 563 564 0 -564 565 0 -564 566 0 -564 567 0 -564 568 0 -564 569 0 -564 570 0 -564 571 0 -564 572 0 -564 573 0 -564 574 0 -564 575 0 -564 576 0 -564 577 0 -564 578 0 -564 579 0 -564 580 0 -564 581 0 -564 582 0 -564 583 0 -564 584 0 -564 585 0 -564 586 0 -564 587 0 -564 588 0 -564 589 0 564 -565 -566 -567 -568 -569 -570 -571 -572 -573 -574 -575 -576 -577 -578 -579 -580 -581 -582 -583 -584 -585 -586 -587 -588 -589 0 122 589 0 -122 589 0 117 588 0 -97 588 0 97 -117 -588 0 112 587 0 -72 587 0 72 -112 -587 0 107 586 0 -52 586 0 52 -107 -586 0 102 585 0 -27 585 0 27 -102 -585 0 97 584 0 -117 584 0 -97 117 -584 0 92 583 0 -92 583 0 87 582 0 -67 582 0 67 -87 -582 0 82 581 0 -47 581 0 47 -82 -581 0 77 580 0 -22 580 0 22 -77 -580 0 72 579 0 -112 579 0 -72 112 -579 0 67 578 0 -87 578 0 -67 87 -578 0 577 126 0 -126 577 0 62 576 0 -42 576 0 42 -62 -576 0 57 575 0 -17 575 0 17 -575 -57 0 52 574 0 -107 574 0 -52 107 -574 0 47 573 0 -82 573 0 -47 82 -573 0 42 572 0 -62 572 0 -42 62 -572 0 37 571 0 -37 571 0 32 570 0 -12 570 0 12 -32 -570 0 27 569 0 -102 569 0 -27 102 -569 0 22 568 0 -77 568 0 -22 77 -568 0 17 567 0 567 -57 0 -17 57 -567 0 12 566 0 -32 566 0 -12 32 -566 0 7 565 0 -7 565 0 -563 590 0 -563 591 0 -563 592 0 -563 593 0 -563 594 0 -563 595 0 -563 596 0 -563 597 0 -563 598 0 -563 599 0 -563 600 0 -563 601 0 -563 602 0 -563 603 0 -563 604 0 -563 605 0 -563 606 0 -563 607 0 -563 608 0 -563 609 0 -563 610 0 -563 611 0 -563 612 0 -563 613 0 -563 614 0 563 -590 -591 -592 -593 -594 -595 -596 -597 -598 -599 -600 -601 -602 -603 -604 -605 -606 -607 -608 -609 -610 -611 -612 -613 -614 0 121 614 0 -121 614 0 116 613 0 -96 613 0 96 -116 -613 0 111 612 0 -71 612 0 71 -111 -612 0 106 611 0 -51 611 0 51 -106 -611 0 101 610 0 -26 610 0 26 -101 -610 0 96 609 0 -116 609 0 -96 116 -609 0 91 608 0 -91 608 0 86 607 0 -66 607 0 66 -86 -607 0 81 606 0 -46 606 0 46 -81 -606 0 76 605 0 -21 605 0 21 -76 -605 0 71 604 0 -111 604 0 -71 111 -604 0 66 603 0 -86 603 0 -66 86 -603 0 602 125 0 -125 602 0 61 601 0 601 -41 0 41 -61 -601 0 56 600 0 -16 600 0 16 -56 -600 0 51 599 0 -106 599 0 -51 106 -599 0 46 598 0 -81 598 0 -46 81 -598 0 41 597 0 -61 597 0 61 -597 -41 0 36 596 0 -36 596 0 31 595 0 -11 595 0 11 -31 -595 0 26 594 0 -101 594 0 -26 101 -594 0 21 593 0 -76 593 0 -21 76 -593 0 16 592 0 -56 592 0 -16 56 -592 0 11 591 0 -31 591 0 -11 31 -591 0 6 590 0 -6 590 0 -562 615 0 -562 616 0 -562 617 0 -562 618 0 -562 619 0 -562 620 0 -562 621 0 -562 622 0 -562 623 0 -562 624 0 -562 625 0 -562 626 0 -562 627 0 -562 628 0 -562 629 0 -562 630 0 -562 631 0 -562 632 0 -562 633 0 -562 634 0 -562 635 0 -562 636 0 -562 637 0 -562 638 0 -562 639 0 562 -615 -616 -617 -618 -619 -620 -621 -622 -623 -624 -625 -626 -627 -628 -629 -630 -631 -632 -633 -634 -635 -636 -637 -638 -639 0 120 639 0 -120 639 0 115 638 0 -95 638 0 95 -115 -638 0 110 637 0 -70 637 0 70 -110 -637 0 105 636 0 -50 636 0 50 -105 -636 0 100 635 0 -25 635 0 25 -100 -635 0 95 634 0 -115 634 0 -95 115 -634 0 90 633 0 -90 633 0 85 632 0 -65 632 0 65 -85 -632 0 80 631 0 -45 631 0 45 -80 -631 0 75 630 0 -20 630 0 20 -75 -630 0 70 629 0 -110 629 0 -70 110 -629 0 65 628 0 -85 628 0 -65 85 -628 0 627 124 0 -124 627 0 60 626 0 -40 626 0 40 -60 -626 0 55 625 0 -15 625 0 15 -55 -625 0 50 624 0 -105 624 0 -50 105 -624 0 45 623 0 -80 623 0 -45 80 -623 0 40 622 0 -60 622 0 -40 60 -622 0 35 621 0 -35 621 0 30 620 0 -10 620 0 10 -30 -620 0 25 619 0 -100 619 0 -25 100 -619 0 20 618 0 -75 618 0 -20 75 -618 0 15 617 0 -55 617 0 -15 55 -617 0 10 616 0 -30 616 0 -10 30 -616 0 5 615 0 -5 615 0 -561 640 0 -561 641 0 -561 642 0 -561 643 0 -561 644 0 -561 645 0 -561 646 0 -561 647 0 -561 648 0 -561 649 0 -561 650 0 -561 651 0 -561 652 0 -561 653 0 -561 654 0 -561 655 0 -561 656 0 -561 657 0 -561 658 0 -561 659 0 -561 660 0 -561 661 0 -561 662 0 -561 663 0 -561 664 0 561 -640 -641 -642 -643 -644 -645 -646 -647 -648 -649 -650 -651 -652 -653 -654 -655 -656 -657 -658 -659 -660 -661 -662 -663 -664 0 119 664 0 -119 664 0 114 663 0 -94 663 0 94 -114 -663 0 109 662 0 -69 662 0 69 -109 -662 0 104 661 0 -49 661 0 49 -104 -661 0 99 660 0 -24 660 0 24 -99 -660 0 94 659 0 -114 659 0 -94 114 -659 0 89 658 0 -89 658 0 84 657 0 -64 657 0 64 -84 -657 0 79 656 0 -44 656 0 44 -79 -656 0 74 655 0 -19 655 0 19 -74 -655 0 69 654 0 -109 654 0 -69 109 -654 0 64 653 0 -84 653 0 -64 84 -653 0 652 123 0 -123 652 0 59 651 0 -39 651 0 39 -59 -651 0 54 650 0 650 -14 0 14 -54 -650 0 49 649 0 -104 649 0 -49 104 -649 0 44 648 0 -79 648 0 -44 79 -648 0 39 647 0 -59 647 0 -39 59 -647 0 34 646 0 -34 646 0 29 645 0 -9 645 0 9 -29 -645 0 24 644 0 -99 644 0 -24 99 -644 0 19 643 0 -74 643 0 -19 74 -643 0 14 642 0 -54 642 0 54 -642 -14 0 9 641 0 -29 641 0 -9 29 -641 0 4 640 0 -4 640 0 -560 665 0 -560 666 0 -560 667 0 -560 668 0 -560 669 0 -560 670 0 -560 671 0 -560 672 0 -560 673 0 -560 674 0 -560 675 0 -560 676 0 -560 677 0 -560 678 0 -560 679 0 -560 680 0 -560 681 0 -560 682 0 -560 683 0 -560 684 0 -560 685 0 -560 686 0 -560 687 0 -560 688 0 560 -665 -666 -667 -668 -669 -670 -671 -672 -673 -674 -675 -676 -677 -678 -679 -680 -681 -682 -683 -684 -685 -686 -687 -688 0 118 688 0 -118 688 0 113 687 0 -93 687 0 93 -113 -687 0 686 108 0 -68 686 0 -108 68 -686 0 103 685 0 -48 685 0 48 -103 -685 0 98 684 0 -23 684 0 23 -98 -684 0 93 683 0 -113 683 0 -93 113 -683 0 88 682 0 -88 682 0 681 83 0 -63 681 0 -83 63 -681 0 78 680 0 -43 680 0 43 -78 -680 0 73 679 0 -18 679 0 18 -73 -679 0 678 68 0 -108 678 0 -68 -678 108 0 677 63 0 -83 677 0 -63 -677 83 0 676 58 0 -38 676 0 -58 -676 38 0 675 53 0 -13 675 0 -53 -675 13 0 48 674 0 -103 674 0 -48 103 -674 0 43 673 0 -78 673 0 -43 78 -673 0 672 38 0 -58 672 0 -38 58 -672 0 33 671 0 -33 671 0 28 670 0 -8 670 0 8 -28 -670 0 23 669 0 -98 669 0 -23 98 -669 0 18 668 0 -73 668 0 -18 73 -668 0 667 13 0 -53 667 0 -13 53 -667 0 8 666 0 -28 666 0 -8 28 -666 0 3 665 0 -3 665 0 -55 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 0 118 -713 0 -102 -713 0 102 -118 713 0 113 -712 0 -101 -712 0 101 -113 712 0 -711 108 0 -100 -711 0 100 -108 711 0 103 -710 0 -99 -710 0 99 -103 710 0 98 -709 0 -98 -709 0 93 -708 0 -77 -708 0 77 -93 708 0 88 -707 0 -76 -707 0 76 -88 707 0 -706 83 0 -75 -706 0 75 -83 706 0 78 -705 0 -74 -705 0 74 -78 705 0 73 -704 0 -73 -704 0 -703 68 0 -703 -57 0 57 -68 703 0 -702 63 0 -56 -702 0 56 -63 702 0 -701 58 0 -54 -701 0 54 -58 701 0 -700 53 0 -53 -700 0 48 -699 0 -32 -699 0 32 -48 699 0 43 -698 0 -31 -698 0 31 -43 698 0 -697 38 0 -30 -697 0 30 -38 697 0 33 -696 0 -29 -696 0 29 -33 696 0 28 -695 0 -28 -695 0 23 -694 0 -7 -694 0 7 -23 694 0 18 -693 0 -6 -693 0 6 -18 693 0 -692 13 0 -5 -692 0 5 -13 692 0 8 -691 0 -4 -691 0 4 -8 691 0 3 -690 0 -3 -690 0 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 0 119 -739 0 -107 -739 0 107 -119 739 0 114 -738 0 -106 -738 0 106 -114 738 0 109 -737 0 -105 -737 0 105 -109 737 0 104 -736 0 -104 -736 0 99 -735 0 -103 -735 0 -99 103 735 0 94 -734 0 -82 -734 0 82 -94 734 0 89 -733 0 -81 -733 0 81 -89 733 0 84 -732 0 -80 -732 0 80 -84 732 0 79 -731 0 -79 -731 0 74 -730 0 -78 -730 0 -74 78 730 0 69 -729 0 -62 -729 0 62 -69 729 0 64 -728 0 -61 -728 0 61 -64 728 0 -727 123 0 -60 -727 0 60 -123 727 0 59 -726 0 -59 -726 0 54 -725 0 -58 -725 0 -54 725 58 0 49 -724 0 -37 -724 0 37 -49 724 0 44 -723 0 -36 -723 0 36 -44 723 0 39 -722 0 -35 -722 0 35 -39 722 0 34 -721 0 -34 -721 0 29 -720 0 -33 -720 0 -29 33 720 0 24 -719 0 -12 -719 0 12 -24 719 0 19 -718 0 -11 -718 0 11 -19 718 0 14 -717 0 -10 -717 0 10 717 -14 0 9 -716 0 -9 -716 0 4 -715 0 -8 -715 0 -4 8 715 0 741 743 742 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 0 120 -764 0 -112 -764 0 112 -120 764 0 115 -763 0 -111 -763 0 111 -115 763 0 110 -762 0 -110 -762 0 105 -761 0 -109 -761 0 -105 109 761 0 100 -760 0 -108 -760 0 -100 760 108 0 95 -759 0 -87 -759 0 87 -95 759 0 90 -758 0 -86 -758 0 86 -90 758 0 85 -757 0 -85 -757 0 80 -756 0 -84 -756 0 -80 84 756 0 75 -755 0 -83 -755 0 -75 755 83 0 70 -754 0 -126 -754 0 -70 754 126 0 65 -753 0 -125 -753 0 -65 753 125 0 -752 124 0 -124 -752 0 60 -751 0 -123 -751 0 -60 751 123 0 50 -750 0 -42 -750 0 42 -50 750 0 45 -749 0 -749 -41 0 41 -45 749 0 40 -748 0 -40 -748 0 35 -747 0 -39 -747 0 -35 39 747 0 30 -746 0 -38 -746 0 -30 746 38 0 25 -745 0 -17 -745 0 17 -25 745 0 20 -744 0 -16 -744 0 16 -20 744 0 15 -743 0 -15 -743 0 10 -742 0 -742 -14 0 -10 14 742 0 5 -741 0 -13 -741 0 -5 741 13 0 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 0 121 -790 0 -117 -790 0 117 -121 790 0 116 -789 0 -116 -789 0 111 -788 0 -115 -788 0 -111 115 788 0 106 -787 0 -114 -787 0 -106 114 787 0 101 -786 0 -113 -786 0 -101 113 786 0 96 -785 0 -92 -785 0 92 -96 785 0 91 -784 0 -91 -784 0 86 -783 0 -90 -783 0 -86 90 783 0 81 -782 0 -89 -782 0 -81 89 782 0 76 -781 0 -88 -781 0 -76 88 781 0 71 -780 0 -67 -780 0 67 -71 780 0 66 -779 0 -66 -779 0 -778 125 0 -65 -778 0 65 -125 778 0 61 -777 0 -64 -777 0 -61 64 777 0 56 -776 0 -63 -776 0 -56 776 63 0 51 -775 0 -47 -775 0 47 -51 775 0 46 -774 0 -46 -774 0 41 -773 0 -45 -773 0 45 773 -41 0 36 -772 0 -44 -772 0 -36 44 772 0 31 -771 0 -43 -771 0 -31 43 771 0 26 -770 0 -22 -770 0 22 -26 770 0 21 -769 0 -21 -769 0 16 -768 0 -20 -768 0 -16 20 768 0 11 -767 0 -19 -767 0 -11 19 767 0 6 -766 0 -18 -766 0 -6 18 766 0 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 0 122 -816 0 -122 -816 0 117 -815 0 -121 -815 0 -117 121 815 0 112 -814 0 -120 -814 0 -112 120 814 0 107 -813 0 -119 -813 0 -107 119 813 0 102 -812 0 -118 -812 0 -102 118 812 0 97 -811 0 -97 -811 0 92 -810 0 -96 -810 0 -92 96 810 0 87 -809 0 -95 -809 0 -87 95 809 0 82 -808 0 -94 -808 0 -82 94 808 0 77 -807 0 -93 -807 0 -77 93 807 0 72 -806 0 -72 -806 0 67 -805 0 -71 -805 0 -67 71 805 0 -804 126 0 -70 -804 0 70 -126 804 0 62 -803 0 -69 -803 0 -62 69 803 0 57 -802 0 -68 -802 0 802 -57 68 0 52 -801 0 -52 -801 0 47 -800 0 -51 -800 0 -47 51 800 0 42 -799 0 -50 -799 0 -42 50 799 0 37 -798 0 -49 -798 0 -37 49 798 0 32 -797 0 -48 -797 0 -32 48 797 0 27 -796 0 -27 -796 0 22 -795 0 -26 -795 0 -22 26 795 0 17 -794 0 -25 -794 0 -17 25 794 0 12 -793 0 -24 -793 0 -12 24 793 0 7 -792 0 -23 -792 0 -7 23 792 0 818 819 820 821 822 0 -272 -822 0 -268 -822 0 -264 -822 0 -260 -822 0 -227 -822 0 227 260 264 268 272 822 0 -271 -821 0 -267 -821 0 -263 -821 0 -231 -821 0 -256 -821 0 231 256 263 267 271 821 0 -270 -820 0 -266 -820 0 -15 -820 0 -259 -820 0 -255 -820 0 15 255 259 266 270 820 0 -269 -819 0 -238 -819 0 -262 -819 0 -258 -819 0 -254 -819 0 238 254 258 262 269 819 0 -242 -818 0 -265 -818 0 -261 -818 0 -257 -818 0 -253 -818 0 242 253 257 261 265 818 0 -5 -11 -18 -27 -29 -33 -47 -50 -59 -65 -71 -73 -80 -87 -91 -94 -101 -107 -110 -114 -118 0 -5 -11 -18 -27 -28 -35 -47 -49 -59 -65 -71 -74 -82 -85 -91 -93 -101 -103 -112 -114 -120 0 301 0 313 0 305 0 -300 0 741 0 -135 0 opensmt-2.5.2/regression/state-dump/QG-classification_qg5_iso_brn644-split4.osmt2000066400000000000000000010450311445011647600277140ustar00rootroot00000000000000ñI¡õ¸õ ö}öŒö™¼‹‰€.ƒgîˆÑˆä…(j@fuj­$à‚ jô‚Í‚°‚ò~T-ß~öiâi…ko…a‚~{k@ˆ-:‚i~-uR…5…ÎiL~N‚'‚ ‚íÄi}~°iqk&~ ~ÆoÔ‡E2žœio’iÀ„ŠÃ}Tow~iG}Ao°}“}tiY}gkjip„ø€}C‡&‡]kÑ€ViôtS„Biª€Sk倾€½-8iÐ|.iIkä|½| |±‰±†Þƒid|i‹†Êƒ+€?kát·ƒ5k€òh?€èhûÞ |+k>|]4 |ð{Á\ì]abäÚXÕ>Õ$Õ ÕØÚÓoÓNÓ-Ó™¸¸…¸žS¸I¸?¸© ¸¸ù·OÇ·½·³·õœ·w·m·c·)ººíŸºã¹Ù¹“ŸÏ¹¹“¹9Ÿ‰¹W¹M¹C¹9¹¹ý¸ó¸ž¹»×¡¯»¥»s»}¡i»_»-»#»»»ÝºÓºÓ Éº—ººy ƒºÁ£I½?½5½½ù¼ï¼å¼³¼£©¼Ÿ¼m¼½¢c¼Y¼'¼c¢¼¼ËÚìÓßÓÒÓÓùÒm²Y²E²1²Rxå²Ñ²½²(y©²]³I³5³!³Õ³·zÁ³­³™³{M´9´%´´¾Ú ÔÔÔùÓßÒ{`zÄy y6{}záyoxS{šzEyŒxp{þyby©xÔzzyÆx±ÚTÔGÔ:Ô-ÔÅÒ•Úñ¹±¯±¥±i±_±U±K±±±û°ñ°µ°«°¡°—°3°°Ï¯¯“¯‰¯¯u¯Å¯»¯±¯§¯÷¯í¯ã¯Ù¯)°°° °ˆÚˆÔ{ÔnÔaÔŠÒB­/­­ ­7¦¶­£­­ §}­*®®®ñ­ž®œ¨‹®x®e®r©¯ÿ®ì®Ù®{Ú¼Ô¯Ô¢Ô•ÔpÒ6ªªü©ß©û–Òªµª˜ªÑ—{ªn«Q«4«« ¬ì˜í«Ð«³«Â™¦¬‰¬l¬O¬nÚðÔãÔÖÔÉÔVÒ«¦Ž¦q¦T¦d§G§*§ð¦¨ã§Æ§©§¹¨¨b¨E¨U©8©©þ¨aÚ@ڹјÑwÑVÑ+ž!žž žÑǽ³wmcY ÿœÃœ¹œ¯œ¥œ   ÷ŸãŸ±Ÿ§ŸŸ‰ŸWŸMŸCŸ/Ÿýžóžéžßž­ž£ž™ž…žë¡á¡Í¡Ã¡‘¡‡¡s¡i¡7¡-¡#¡¡ç Ý É ¿  ƒ o e Ë£·£­£££q£g£]£S£!£ ££ù¢Ç¢³¢©¢Ÿ¢m¢Y¢O¢E¢«¥¡¥—¥¥[¥Q¥G¥=¥3¥¥÷¤ã¤Ù¤§¤¤“¤‰¤¤M¤C¤9¤/¤%¤Kœ7œ#œœÓ›¿›«›—›[›G›3››ãšÏš»š§škšWšCš/š3Ú"ÑÑîÐÔкÐo—R—5——(˜ ˜î—´— ™Ï˜²˜•˜¥™ˆ™k™N™&ÚÒÒûÑ<Ñ ÐÚùÙDÐ#ÐÐáÏá×Íù‡}si_-#ӌɌ¿ŒµŒ«ŒyŒoŒeŒ[ŒQŒËÁ·­£qg]SI ùŽïŽ½Ž³Ž©ŽŸŽ•ŽcŽYŽOŽEŽ;Ž«‘¡‘—‘‘ƒ‘Q‘G‘=‘3‘)‘÷íÊJãÙ§“‰MC9/%•“‹““w“m“;“1“'“““á’×’Í’Ã’¹’‡’}’s’i’_’-’#’’’’•u•k•a•W•%••••ý”Ë”Á”­”£”q”g”]”S”I”” ””ù“ï“ØÙÏ‹²‹Ÿ‹•‹‚‹G‹4‹!‹‹ûŠÀŠ¶Š™Š†ŠKŠ8Š%ŠŠÿ‰Ä‰§‰”‰‰n‰’Ï ‰äˆÇˆ´ˆ¡ˆfˆSˆ6ˆ,ˆˆÞ‡Ê‡·‡¤‡‘‡V‡9‡‡ ‡ö†»†ž††n†[†¸Ùø…î…Ñ…Ç…´…y…e…H…+……Ê„„T¶„¬„z„f„I„6„#„èƒÔƒ­ƒšƒ‡ƒPÏ$ƒƒê‚¦‚k‚D‚‚‚㨔mZ=Û€´€ €€R€5€€ñÔ/ÏqJ#ü~Õ~š~s~V~9~~×}Í}¦}‰}l}'} }÷|Ú|³|n|Q|4|*||«Ù<Ò/Ò"Ò†Ð"Ï©w–wƒwpw]wJw7w$wwþv‘v~vkvXvEv2vv vùuæuyuSu@uuuÎtatNt;t(tttïsÜsÉs¶sIs6s#ssýrêr×rÄr±ržr röqãqÐq½qªq—q„qqq^qñpÞpËp¸p¥p’pplpYpFpÙo³o ozogo.oÁn®n›nˆnunbnOnHR\fpz„Ž˜¢¬¶ÀÊÔÞèòü$.8BLV`jt~ˆ’œ¦°ºÄÎØâìö (2<FPZdnx‚Œ– ª´¾ÈÒÜæðú",6@JT^hr|†š¤®¸ÂÌÖàêôþ&0:DNXblv€Š”ž¨²¼ÆÐÚäîø  * 4 > H R \ f p z „ Ž ˜ ¢ ¬ ¶ À Ê Ô Þ è ò ü    $ . 8 B L V ` j t ~ ˆ ’ œ ¦ ° º Ä Î Ø â ì ö   ( 2 < F P Z d n x ‚ Œ –   ª ´ ¾ È Ò Ü æ ð ú    " , 6 @ J T ^ h r | † š ¤ ® ¸ Â Ì Ö à ê ô þ    & 0 : D N X b l v € Š ” ž ¨ ² ¼ Æ Ð Ú ä î ø   *4>HR\fpz„Ž˜¢¬¶ÀÊÔÞèòü$.8BLV`jt~ˆ’œ¦°ºÄÎØâìö (2<FPZdnx‚Œ– ª´¾ÈÒÜæðú",6@JT^hr|†š¤®¸ÂÌÖàêôþ&0:DNXblv€Š”ž¨²¼ÆÐÚäîø  *4>HR\fpz„Ž˜¢¬¶ÀÊÔÞèòü$.8BLV`jt~ˆ’œ¦¯¸ÂËÕÞèñû  *3=FPZclv‰’œ¥¯¹ÂËÕÞèñû!*4=GPZcmw€‰’›¤­¶¿ÈÑÚãìõþ"+4=FOXajs|…Ž— ©²»ÄÍÖßèñú '09BKT]foxŠ“œ¥®·ÀÉÒÛäíöÿ#,5>GPYbkt}†˜¡ª³¼ÅÎ×àéòû#-7AKU_is}‡‘›¥¯¹ÃÍ×áëõÿ '1;EOYcmw‹•Ÿ©³½ÇÑÛåïù !+5?IS]gq{…™£­·ÁËÕßéóý%/9CMWaku‰“§±»ÅÏÙãí÷ )3=GQ[eoyƒ—¡«µ¿ÉÓÝçñû#-7AKU_is}‡‘›¥¯¹ÃÍ×áëõÿ   ' 1 ; E O Y c m w ‹ • Ÿ © ³ ½ Ç Ñ Û å ï ù ! !!!!+!5!?!I!S!]!g!q!{!…!!™!£!­!·!Á!Ë!Õ!ß!é!ó!ý!"""%"/"9"C"M"W"a"k"u""‰"“""§"±"»"Å"Ï"Ù"ã"í"÷"# ###'#1#;#D#N#X#b#k#u##‰#’#œ#¦#°#¹#Ã#Í#Ö#à#ê#ô#ý#$$$$$.$8$B$K$U$_$i$s$|$†$$™$£$­$·$À$Ê$Ô$Þ$ç$ñ$û$%%%"%,%6%?%I%S%\%f%p%z%ƒ%%—%¡%ª%´%¾%È%Ñ%Û%å%ï%ù%& &&&)&3&=&F&P&Z&d&m&w&&‹&”&ž&¨&²&¼&Å&Ï&Ù&ã&ì&ö&' '''''1':'D'N'X'a'k'u''ˆ'’'œ'¦'¯'¹'Ã'Í'Ö'à'ê'ô'þ'((($(.(8(B(L(U(_(i(s(|(†((š(¤(­(·(Á(Ê(Ô(Þ(è(ñ(û()))"),)6)@)J)S)])g)p)z)„)Ž)—)¡)«)µ)¾)È)Ò)Ü)æ)ð)ú)***"*,*6*@*J*T*^*h*r*|*†**š*¤*®*¸*Â*Ì*Ö*à*ê*ô*þ*+++&+0+:+D+N+X+b+l+v+€+Š+”+ž+¨+²+¼+Æ+Ð+Ú+ä+î+ø+, ,, ,*,4,>,H,R,\,f,p,z,„,Ž,˜,¢,¬,¶,À,Ê,Ó,Ý,ç,ð,ú,---!-+-5->-H-R-\-e-o-y-ƒ-Œ-–- -©-³-½-Ç-Ð-Ú-ä-î-÷-. ...(.2.<.F.O.Y.c.l.v.€.Š.“..§.±.º.Ä.Î.Ø.á.ë.õ.ÿ. ///&///9/C/M/V/`/j/t/}/‡/‘/›/¤/®/¸/Â/Ì/Õ/ß/é/ò/ü/000#0-070@0J0T0^0g0q0{0…00˜0¢0¬0µ0¿0É0Ó0Ü0æ0ð0ú01 11!1*141>1H1Q1[1e1n1x1‚1Œ1•1Ÿ1©1³1¼1Æ1Ð1Ú1ã1í1÷12 222(212;2E2O2X2b2l2v22‰2“22¦2°2º2Ä2Î2×2á2ë2ô2þ2333%3/393B3L3V3`3i3s3}3‡3‘3š3¤3®3·3Á3Ë3Õ3Þ3è3ò3ü3444#4,464@4J4S4]4g4p4z4„44—4¡4ª4´4¾4Ç4Ñ4Û4ä4î4ø45 555(525<5E5O5X5b5l5v55‰5“5œ5¦5°5º5Ã5Í5Ö5à5ê5ó5ý5666$6.686A6K6T6^6h6q6{6…6Ž6˜6¢6¬6¶6À6Ê6Ô6Þ6è6ò6ü6777$7.787B7L7V7`7j7t7~7ˆ7’7œ7¦7°7º7Ä7Î7Ø7â7ì7ö78 888(828<8F8P8Z8d8n8x8‚8Œ8–8 8ª8´8¾8È8Ò8Ü8æ8ð8ú8999"9,969@9J9T9^9h9r9|9†99š9¤9®9¸9Â9Ì9Ö9à9ê9ô9þ9:::&:0:::D:N:X:b:l:v:€:Š:”:ž:¨:²:¼:Æ:Ð:Ú:ä:î:ø:; ;; ;*;4;>;H;R;\;f;p;z;„;Ž;˜;¢;¬;¶;À;Ê;Ô;Þ;è;ò;ü;<<<$<.<8<B<L<V<`<j<t<~<ˆ<’<œ<¦<°<º<Ä<Î<Ø<â<ì<ö<= ===(=2=<=F=P=Z=d=n=x=‚=Œ=–= =ª=´=¾=È=Ò=Ü=æ=ð=ú=>>>">,>6>@>J>T>^>h>r>|>†>>š>¤>®>¸>Â>Ì>Ö>à>ê>ô>þ>???&?0?:?D?N?X?b?l?v?€?Š?”?ž?¨?²?¼?Æ?Ð?Ú?ä?î?ø?@ @@ @*@4@>@H@R@\@f@p@z@„@Ž@˜@¢@¬@¶@À@Ê@Ô@Þ@è@ò@ü@AAA$A.A8ABALAVA`AjAtA~AˆA’AœA¦A°AºAÄAÎAØAâAìAöAB BBB'B0B:BDBNBWBaBkBuB~BˆB’BœB¥B¯B¹BÃBÌBÖBàBêBóBýBCCC$C.C8CBCKCUC_ChCrC|C†CC™C£C­C·CÀCÊCÔCÞCèCñCûCDDD"D,D5D?DIDSD]DfDpDzD„DŽD—D¡D«D´D¾DÈDÒDÛDåDïDùDE EE E*E4E>EHERE\EfEpEzE„EŽE˜E¢E¬E¶EÀEÊEÔEÞEèEòEüEFFF$F.F8FBFLFVF`FjFtF~FˆF’FœF¦F°FºFÄFÎFØFâFìFöFG GGG(G2GJHJRJ\JfJpJzJ„JŽJ˜J¢J¬J¶JÀJÊJÔJÞJèJòJüJKKK$K.K8KBKLKVK`KjKtK~KˆK’KœK¦K°KºKÄKÎKØKâKìKöKL LLL(L2LOHORO\OfOpOzO„OŽO˜O¢O¬O¶OÀOÊOÔOÞOèOòOüOPPP$P.P8PBPLPVP`PjPtP~PˆP’PœP¦P°PºPÄPÎPØPâPìPöPQ QQQ(Q2QTHTRT\TfTpTzT„TŽT˜T¢T¬T¶TÀTÊTÔTÞTèTòTüTUUU$U.U8UBULUVU`UjUtU~UˆU’UœU¦U°UºUÄUÎUØUâUìUöUV VVV(V2VYHYRY\YfYpYzY„YŽY˜Y¢Y¬Y¶YÀYÊYÔYÞYèYòYüYZZZ$Z.Z8ZBZLZVZ`ZjZtZ~Z‡Z‘ZšZ¤Z®Z·ZÁZËZÔZÞZèZñZûZ[[["[+[5[?[H[R[\[e[o[y[‚[Œ[–[Ÿ[©[²[¼[Æ[Ï[Ù[ã[ì[ö[\ \\\&\0\:\C\M\W\`\j\t\}\‡\‘\š\¤\®\¸\Á\Ë\Ô\Þ\è\ñ\û\]]]"]+]5]?]H]R]\]e]o]y]‚]Œ]–]Ÿ]©]³]¼]Æ]Ð]Ú]ã]í]ö]^ ^^^'^0^:^D^M^W^a^j^t^~^‡^‘^›^¤^®^¸^Á^Ë^Õ^Þ^è^ò^ü^___"_,_5_?_I_R_\_f_o_y_ƒ_Œ_–_ _©_³_½_Æ_Ð_Ú_ã_í_÷_` ```'`1`:`D`N`W`a`k`t`~`ˆ`‘`›`¥`®`¸`Â`Ë`Õ`ß`è`ò`ü`aaa"a,a6a?aIaRa\afaoayaƒaŒa–a a©a³a½aÆaÐaÚaãaía÷ab bbb'b1b:bDbNbXbabkbtb~bˆb‘b›b¥b®b¸bÂbËbÕbßbèbòbübccc"c,c6c?cIcSc\cfcpczcƒcc–c cªc³c½cÇcÐcÚcäcíc÷cd ddd'd1d;dDdNdXdadkdud~dˆd’dœd¥d¯d¸dÂdÌdÕdßdédòdüdeee#e,e6e@eIeSe]efepezeƒee—e eªe´e¾eÈeÑeÛeäeîeøef fff(f2f;fEfOfXfbflfuff‰f’fœf¦f¯f¹fÃfÌfÖfàfêfôfþfggg&g0g:gDgNgXgbglgvg€gŠg”gžg¨g²g¼gÆgÐgÚgägíg÷gh hhh)h3h=hGhQh[hehohyhƒhh—h¡h«hµh¾hÞhèhòhühiii$i.i8iBiLiVi`ijiti~iˆi’iœi¦i°iºiÄiÎiØiâiìiöij jjj(j2jxHxRx\xexoxyx‚xŒx–xŸx©x³x¼xÆxÐxÙxãxíx÷xy yyy(y2y;yEyOyXybylyuyy‰y’yœy¦y°yºyÄyÎy×yáyëyôyþyzzz%z.z8zBzLzVz`zjzsz}z‡zzšz¤z­z·zÁzÊzÔzÞzçzñzûz{{{#{,{6{@{I{S{]{f{p{z{ƒ{{—{ {ª{´{¾{È{Ò{Ü{æ{ð{ú{| || |*|4|>|H|Q|[|d|n|x|‚|Œ|–| |ª|³|½|Ç|Ð|Ú|ä|î|÷|} }}}'}1};}E}O}Y}c}l}v}}‰}“}}¦}°}º}Ã}Í}×}á}ë}õ}ÿ} ~~~&~0~9~C~L~V~`~i~s~}~‡~~š~¤~®~¸~Â~Ì~Õ~ß~é~ò~ü~#-7@JT^gq{…™£­·ÁËÔÞèñû€€€"€+€5€?€I€R€\€f€p€z€„€€—€ €ª€´€¾€È€Ñ€Û€å€ï€ø€  *4=GQZdmwŠ”ž¨²¼ÆÐÚãí÷‚ ‚‚‚'‚1‚:‚D‚N‚X‚a‚k‚u‚‚‰‚“‚‚¦‚°‚º‚Âׂ͂à‚ê‚ô‚þ‚ƒƒƒ$ƒ.ƒ8ƒBƒLƒVƒ`ƒjƒtƒ~ƒ‡ƒ‘ƒšƒ¤ƒ­ƒ·ƒÁƒÊƒÔƒÞƒèƒòƒüƒ„„„#„-„6„@„I„S„]„f„p„z„„„Ž„˜„¢„¬„¶„À„Ê„Ô„Ý„ç„ñ„û„………"…+…5…?…H…R…\…e…o…y…ƒ……—…¡…«…´…¾…Ç…Ñ…Û…ä…î…ø…† †† †*†4†>†H†R†[†e†n†x††‹†•†ž†¨†±†»†Å†Ï†Ù†ã†í†ö†‡ ‡‡‡&‡0‡9‡C‡M‡V‡`‡j‡t‡~‡ˆ‡‘‡›‡¤‡®‡·‡Á‡Ê‡Ô‡Þ‡è‡ò‡ü‡ˆˆˆ#ˆ,ˆ6ˆ@ˆJˆSˆ]ˆfˆpˆzˆ„ˆŽˆ˜ˆ¡ˆ«ˆ´ˆ¾ˆÇˆÑˆÛˆäˆîˆøˆ‰ ‰‰‰)‰3‰=‰G‰Q‰[‰e‰n‰x‰‰‹‰”‰ž‰§‰±‰»‰Ä‰Î‰Ø‰â‰ì‰ö‰ÿ‰ ŠŠŠ%Š/Š8ŠBŠKŠUŠ_ŠiŠsŠ}Š†ŠŠ™Š£Š­Š¶ŠÀŠÊŠÔŠÞŠèŠòŠûŠ‹‹‹!‹+‹4‹>‹G‹Q‹[‹e‹o‹y‹‚‹Œ‹•‹Ÿ‹©‹²‹¼‹Æ‹Ï‹Ù‹ã‹í‹÷‹Œ ŒŒŒ)Œ3Œ=ŒGŒQŒ[ŒeŒoŒyŒƒŒŒ—Œ¡Œ«ŒµŒ¿ŒÉŒÓŒÝŒçŒñŒûŒ#-7AKU_is}‡‘›¥¯¹ÃÍ×áëõÿ ŽŽŽ'Ž1Ž;ŽEŽOŽYŽcŽmŽwŽŽ‹Ž•ŽŸŽ©Ž³Ž½ŽÇŽÑŽÛŽåŽïŽùŽ !+5?IS]gq{…™£­·ÁËÕßéóý%/9CMWaku‰“§±»ÅÏÙãí÷‘ ‘‘‘)‘3‘=‘G‘Q‘[‘e‘o‘y‘ƒ‘‘—‘¡‘«‘µ‘¿‘É‘Ó‘Ý‘ç‘ñ‘û‘’’’#’-’7’A’K’U’_’i’s’}’‡’‘’›’¥’¯’¹’Ã’Í’×’á’ë’õ’ÿ’ “““'“1“;“E“O“Y“c“m“w““‹“•“Ÿ“©“³“½“Ç“Ñ“Û“å“ï“ù“” ””!”+”5”?”I”S”]”g”q”{”…””™”£”­”·”Á”˔Քߔé”ó”ý”•••%•/•9•C•M•W•a•k•u••‰•“••§•±•»•Å•Ï•Ù•ã•í•÷•– –––)–3–=–G–Q–[–e–o–y–ƒ––—–¡–«–µ–¿–É–Ó–Ý–ç–ñ–û–———"—+—5—?—H—R—\—e—o—y—‚—Œ—–— —ª—´—¾—Ç—Ñ—Û—ä—î—ø—˜ ˜˜˜(˜2˜;˜E˜O˜Y˜c˜m˜w˜˜‹˜•˜Ÿ˜¨˜²˜¼˜Å˜Ï˜Ù˜â˜ì˜ö˜ÿ˜ ™™™&™0™:™D™N™X™a™k™u™~™ˆ™’™›™¥™¯™¸™Â™Ì™Õ™ß™é™ó™ý™ššš%š/š9šCšMšWšaškšušš‰š“šš§š±š»šÅšÏšÙšãšíš÷š› ›››)›3›=›G›Q›[›e›o›y›ƒ››—›¡›«›µ›¿›É›Ó›Ý›ç›ñ›û›œœœ#œ-œ7œAœKœUœ_œiœsœ}œ‡œ‘œ›œ¥œ¯œ¹œÃœÍœ×œáœëœõœÿœ '1;EOYcmw‹•Ÿ©³½ÇÑÛåïùž žž!ž+ž5ž?žIžSž]žgžqž{ž…žž™ž£ž­ž·žÁžËžÕžßžéžóžýžŸŸŸ%Ÿ/Ÿ9ŸCŸMŸWŸaŸkŸuŸŸ‰Ÿ“ŸŸ§Ÿ±Ÿ»ŸÅŸÏŸÙŸãŸíŸ÷Ÿ     ) 3 = G Q [ e o y ƒ  — ¡ « µ ¿ É Ó Ý ç ñ û ¡¡¡#¡-¡7¡A¡K¡U¡_¡i¡s¡}¡‡¡‘¡›¡¥¡¯¡¹¡Ã¡Í¡×¡á¡ë¡õ¡ÿ¡ ¢¢¢'¢1¢;¢E¢O¢Y¢c¢m¢w¢¢‹¢•¢Ÿ¢©¢³¢½¢Ç¢Ñ¢Û¢å¢ï¢ù¢£ ££!£+£5£?£I£S£]£g£q£{£…££™£££­£·£Á£Ë£Õ£ß£é£ó£ý£¤¤¤%¤/¤9¤C¤M¤W¤a¤k¤u¤¤‰¤“¤¤§¤±¤»¤Å¤Ï¤Ù¤ã¤í¤÷¤¥ ¥¥¥)¥3¥=¥G¥Q¥[¥e¥o¥y¥ƒ¥¥—¥¡¥«¥µ¥¿¥É¥Ó¥Ý¥ç¥ñ¥û¥¦¦¦#¦-¦7¦A¦J¦T¦^¦g¦q¦{¦„¦Ž¦˜¦¡¦«¦µ¦¾¦È¦Ò¦Ü¦æ¦ð¦ú¦§ §§ §*§4§=§G§Q§Z§d§n§w§§‹§•§Ÿ§©§³§¼§Æ§Ð§Ù§ã§í§ö§¨ ¨¨¨'¨1¨;¨E¨O¨X¨b¨l¨u¨¨‰¨’¨œ¨¦¨¯¨¹¨Ã¨Ì¨Ö¨à¨ê¨ô¨þ¨©©©%©.©8©B©K©U©_©h©r©|©…©©™©£©­©·©Á©Ë©Õ©ß©é©ò©ü©ªªª#ª,ª6ª@ªIªSª]ªgªqª{ª…ªŽª˜ª¢ª«ªµª¿ªÈªÒªÜªåªïªùª« ««!«*«4«>«G«Q«[«d«n«x««‹«•«Ÿ«©«³«½«Æ«Ð«Ú«ã«í«÷«¬ ¬¬¬'¬1¬;¬E¬O¬Y¬b¬l¬v¬¬‰¬“¬œ¬¦¬°¬¹¬Ã¬Í¬×¬á¬ë¬õ¬ÿ¬ ­­­&­/­9­B­L­U­_­i­s­}­‡­­š­£­­­¶­À­É­Ó­Ý­ç­ñ­û­®®®!®*®4®=®G®Q®[®e®o®x®‚®‹®•®ž®¨®±®»®Å®Ï®Ù®ã®ì®ö®ÿ® ¯¯¯%¯/¯9¯C¯M¯W¯a¯k¯u¯¯‰¯“¯¯§¯±¯»¯Å¯Ï¯Ù¯ã¯í¯÷¯° °°°)°3°=°G°Q°[°e°o°y°ƒ°°—°¡°«°µ°¿°É°Ó°Ý°ç°ñ°û°±±±#±-±7±A±K±U±_±i±s±}±‡±‘±›±¥±¯±¹±Ã±Í±×±á±ë±õ±ÿ± ²²²'²1²;²E²O²Y²c²m²w²²‹²•²Ÿ²©²³²½²Ç²Ñ²Û²å²ï²ù²³ ³³!³+³5³?³I³S³]³g³q³{³…³³™³£³­³·³Á³Ë³Õ³ß³é³ó³ý³´´´%´/´9´C´M´W´a´k´u´´‰´“´´§´±´»´Å´Ï´Ù´ã´í´÷´µ µµµ)µ3µ=µGµQµ[µeµoµyµƒµµ—µ µ©µ²µ»µÅµÏµÙµãµìµõµþµ¶¶¶%¶/¶8¶A¶J¶S¶]¶g¶q¶{¶„¶¶–¶Ÿ¶©¶³¶½¶Ç¶Ð¶Ù¶â¶ë¶õ¶ÿ¶ ···'·1·;·E·O·Y·c·m·w··‹·•·Ÿ·©·³·½·Ç·Ñ·Û·å·ï·ù·¸ ¸¸!¸+¸5¸?¸I¸S¸]¸g¸q¸{¸…¸¸™¸£¸­¸·¸Á¸Ë¸Õ¸ß¸é¸ó¸ý¸¹¹¹%¹/¹9¹C¹M¹W¹a¹k¹u¹¹‰¹“¹¹§¹±¹»¹Å¹Ï¹Ù¹ã¹í¹÷¹º ººº)º3º=ºGºQº[ºeºoºyºƒºº—º¡º«ºµº¿ºÉºÓºÝºçºñºûº»»»#»-»7»A»K»U»_»i»s»}»‡»‘»›»¥»¯»¹»Ã»Í»×»á»ë»õ»ÿ» ¼¼¼'¼1¼;¼E¼O¼Y¼c¼m¼w¼¼‹¼•¼Ÿ¼©¼³¼½¼Ç¼Ñ¼Û¼å¼ï¼ù¼½ ½½!½+½5½?½I½S½]½g½q½{½…½½™½£½­½·½Á½Ë½Õ½ß½é½ó½ý½¾¾¾%¾/¾9¾C¾M¾W¾a¾k¾u¾¾‰¾“¾¾§¾±¾»¾Å¾Ï¾Ù¾ã¾í¾÷¾¿ ¿¿¿)¿3¿=¿G¿Q¿[¿e¿o¿y¿ƒ¿¿—¿¡¿«¿µ¿¿¿É¿Ó¿Ý¿ç¿ñ¿û¿ÀÀÀ#À-À7ÀAÀKÀUÀ_ÀiÀsÀ}À‡À‘À›À¥À¯À¹ÀÃÀÍÀ×ÀáÀëÀõÀÿÀ ÁÁÁ'Á1Á;ÁEÁOÁYÁcÁmÁwÁÁ‹Á•ÁŸÁ©Á³Á½ÁÇÁÑÁÛÁåÁïÁùÁ ÂÂ!Â+Â5Â?ÂIÂSÂ]ÂgÂqÂ{…™£­·ÂÁÂËÂÕÂßÂéÂóÂýÂÃÃÃ%Ã/Ã9ÃCÃMÃWÃaÃkÃuÃÉÓÃçñûÃÅÃÏÃÙÃãÃíÃ÷ÃÄ ÄÄÄ)Ä3Ä=ÄGÄQÄ[ÄeÄoÄyăÄėġīĵĿÄÉÄÓÄÝÄçÄñÄûÄÅÅÅ#Å-Å7ÅAÅKÅUÅ_ÅiÅsÅ}ŇőśťůŹÅÃÅÍÅ×ÅáÅëÅõÅÿÅ ÆÆÆ'Æ1Æ;ÆEÆOÆYÆcÆmÆwÆƋƕƟƩƳƽÆÇÆÑÆÛÆåÆïÆùÆÇ ÇÇ!Ç+Ç5Ç?ÇIÇSÇ]ÇgÇqÇ{Ç…ÇǙǣǭǷÇÁÇËÇÕÇßÇéÇóÇýÇÈÈÈ%È/È9ÈCÈMÈWÈaÈkÈuÈȉȓÈȧȱȻÈÅÈÏÈÙÈãÈíÈ÷ÈÉ ÉÉÉ)É3É=ÉGÉQÉ[ÉeÉoÉyɃÉɗɡɫɵɿÉÉÉÓÉÝÉçÉñÉûÉÊÊÊ#Ê-Ê7ÊAÊKÊUÊ_ÊiÊsÊ}ʇʑʛʥʯʹÊÃÊÍÊ×ÊáÊëÊõÊÿÊ ËËË'Ë1Ë;ËEËOËYËcËmËwËˋ˕˟˩˳˽ËÇËÑËÛËåËïËùËÌ ÌÌ!Ì+Ì5Ì?ÌIÌSÌ]ÌgÌqÌ{Ì…Ì̷̙̣̭ÌÁÌËÌÕÌßÌéÌóÌýÌÍÍÍ%Í/Í9ÍCÍMÍWÍaÍkÍuÍ͉͓ÍͧͱͻÍÅÍÏÍÙÍãÍíÍ÷ÍÎ ÎÎ5ÎÏ"Ï/ÏPÏqϒϳÏÔÏáÏÐ#ÐDÐeІГРЭкÐÇÐÔÐáÐîÐûÐÑÑ"Ñ/Ñ<ÑIÑVÑwјѹÑÚÑûÑÒÒ"Ò/Ò<ÒIÒVÒcÒpÒ}ÒŠÒ—Ò¸ÒÅÒÒÒßÒìÒùÒÓÓ Ó-ÓNÓoÓÓ±ÓÒÓßÓìÓùÓÔÔ Ô-Ô:ÔGÔTÔaÔnÔ{ÔˆÔ•Ô¢Ô¯Ô¼ÔÉÔÖÔãÔðÔýÔ ÕÕ$Õ1Õ>ÕKÕXÕeÕrÕՌՙզճÕÀÕÍÕÚÕçÕôÕÖÖÖ(Ö5ÖBÖOÖ\ÖiÖvÖƒÖÖÖªÖ·ÖÄÖÑÖÞÖëÖøÖ×××,×9×F×S×`×m×zׇהס׮׻×È×Õ×â×ï×ü× ØØ#Ø0Ø=ØJØWØdØqØ~؋ؘإزؿØÌØÙØæØóØÙ ÙÙ7ÙTÙaÙ}ن٢٫ٸÙØÙùÙÚ&Ú3Ú@ÚaÚnÚ{ÚˆÚ•Ú±Ú¾ÚËÚØÚäÚðÚÐÛÌÛPZÿÿÿÿÿÿÿÿÿÿÿÿdÿÿÿÿÿÿ€Sÿÿÿÿÿÿaÿÿÿÿÿÿ"€Sÿÿÿÿÿÿ*"^ÿÿÿÿÿÿ4€Sÿÿÿÿÿÿ<4[ÿÿÿÿÿÿF€ SÿÿÿÿÿÿNF XÿÿÿÿÿÿX€ Sÿÿÿÿÿÿ`X€ Sÿÿÿÿÿÿj"€ Sÿÿÿÿÿÿt""€Sÿÿÿÿÿÿ~"4€Sÿÿÿÿÿÿˆ"F€Sÿÿÿÿÿÿ’"X€Sÿÿÿÿÿÿœ4€Sÿÿÿÿÿÿ¦4"€Sÿÿÿÿÿÿ°44€Sÿÿÿÿÿÿº4F€SÿÿÿÿÿÿÄ4X€SÿÿÿÿÿÿÎF€SÿÿÿÿÿÿØF"€SÿÿÿÿÿÿâF4€SÿÿÿÿÿÿìFF€SÿÿÿÿÿÿöFX€SÿÿÿÿÿÿX€Sÿÿÿÿÿÿ X"€SÿÿÿÿÿÿX4€SÿÿÿÿÿÿXF€Sÿÿÿÿÿÿ(XX€ >ÿÿÿÿÿÿ2€!>ÿÿÿÿÿÿ<"€"ÿÿÿÿÿÿF2<€#>ÿÿÿÿÿÿP4€$ÿÿÿÿÿÿZFP€%>ÿÿÿÿÿÿdF€&ÿÿÿÿÿÿnZd€'>ÿÿÿÿÿÿxX€(ÿÿÿÿÿÿ‚nx€)>ÿÿÿÿÿÿŒ*€*>ÿÿÿÿÿÿ–"*€+ÿÿÿÿÿÿ Œ–€,>ÿÿÿÿÿÿª*4€-ÿÿÿÿÿÿ´ ª€.>ÿÿÿÿÿÿ¾*F€/ÿÿÿÿÿÿÈ´¾€0>ÿÿÿÿÿÿÒ*X€1ÿÿÿÿÿÿÜÈÒ€2ÿÿÿÿÿÿæ‚Ü€3>ÿÿÿÿÿÿð<€4>ÿÿÿÿÿÿú"<€5ÿÿÿÿÿÿðú€6>ÿÿÿÿÿÿ4<€7ÿÿÿÿÿÿ€8>ÿÿÿÿÿÿ"<F€9ÿÿÿÿÿÿ,"€:>ÿÿÿÿÿÿ6<X€;ÿÿÿÿÿÿ@,6€<ÿÿÿÿÿÿJæ@€=>ÿÿÿÿÿÿTN€>>ÿÿÿÿÿÿ^"N€?ÿÿÿÿÿÿhT^€@>ÿÿÿÿÿÿr4N€Aÿÿÿÿÿÿ|hr€B>ÿÿÿÿÿÿ†FN€Cÿÿÿÿÿÿ|†€D>ÿÿÿÿÿÿšNX€Eÿÿÿÿÿÿ¤š€Fÿÿÿÿÿÿ®J¤€G>ÿÿÿÿÿÿ¸`€H>ÿÿÿÿÿÿÂ"`€Iÿÿÿÿÿÿ̸€J>ÿÿÿÿÿÿÖ4`€KÿÿÿÿÿÿàÌÖ€L>ÿÿÿÿÿÿêF`€Mÿÿÿÿÿÿôàê€N>ÿÿÿÿÿÿþX`€Oÿÿÿÿÿÿôþ€Pÿÿÿÿÿÿ®€Q>ÿÿÿÿÿÿj€R>ÿÿÿÿÿÿ&"j€Sÿÿÿÿÿÿ0&€T>ÿÿÿÿÿÿ:4j€UÿÿÿÿÿÿD0:€V>ÿÿÿÿÿÿNFj€WÿÿÿÿÿÿXDN€X>ÿÿÿÿÿÿbXj€YÿÿÿÿÿÿlXb€Z>ÿÿÿÿÿÿvt€[>ÿÿÿÿÿÿ€"t€\ÿÿÿÿÿÿŠv€€]>ÿÿÿÿÿÿ”4t€^ÿÿÿÿÿÿžŠ”€_>ÿÿÿÿÿÿ¨Ft€`ÿÿÿÿÿÿ²ž¨€a>ÿÿÿÿÿÿ¼Xt€bÿÿÿÿÿÿƲ¼€cÿÿÿÿÿÿÐlÆ€d>ÿÿÿÿÿÿÚ~€e>ÿÿÿÿÿÿä"~€fÿÿÿÿÿÿîÚä€g>ÿÿÿÿÿÿø4~€hÿÿÿÿÿÿîø€i>ÿÿÿÿÿÿ F~€jÿÿÿÿÿÿ €k>ÿÿÿÿÿÿ X~€lÿÿÿÿÿÿ* €mÿÿÿÿÿÿ4Ð*€n>ÿÿÿÿÿÿ>ˆ€o>ÿÿÿÿÿÿH"ˆ€pÿÿÿÿÿÿR>H€q>ÿÿÿÿÿÿ\4ˆ€rÿÿÿÿÿÿfR\€s>ÿÿÿÿÿÿpFˆ€tÿÿÿÿÿÿzfp€u>ÿÿÿÿÿÿ„Xˆ€vÿÿÿÿÿÿŽz„€wÿÿÿÿÿÿ˜4Ž€x>ÿÿÿÿÿÿ¢’€y>ÿÿÿÿÿÿ¬"’€zÿÿÿÿÿÿ¶¢¬€{>ÿÿÿÿÿÿÀ4’€|ÿÿÿÿÿÿʶÀ€}>ÿÿÿÿÿÿÔF’€~ÿÿÿÿÿÿÞÊÔ€>ÿÿÿÿÿÿèX’€€ÿÿÿÿÿÿòÞè€ÿÿÿÿÿÿü˜ò€‚ÿÿÿÿÿÿü€ƒ>ÿÿÿÿÿÿœ€„>ÿÿÿÿÿÿ"œ€…ÿÿÿÿÿÿ$€†>ÿÿÿÿÿÿ.4œ€‡ÿÿÿÿÿÿ8$.€ˆ>ÿÿÿÿÿÿBFœ€‰ÿÿÿÿÿÿL8B€Š>ÿÿÿÿÿÿVXœ€‹ÿÿÿÿÿÿ`LV€Œ>ÿÿÿÿÿÿj¦€>ÿÿÿÿÿÿt"¦€Žÿÿÿÿÿÿ~jt€>ÿÿÿÿÿÿˆ4¦€ÿÿÿÿÿÿ’~ˆ€‘>ÿÿÿÿÿÿœF¦€’ÿÿÿÿÿÿ¦’œ€“>ÿÿÿÿÿÿ°X¦€”ÿÿÿÿÿÿº¦°€•ÿÿÿÿÿÿÄ`º€–>ÿÿÿÿÿÿΰ€—>ÿÿÿÿÿÿØ"°€˜ÿÿÿÿÿÿâÎØ€™>ÿÿÿÿÿÿì4°€šÿÿÿÿÿÿöâ쀛>ÿÿÿÿÿÿF°€œÿÿÿÿÿÿ ö€>ÿÿÿÿÿÿX°€žÿÿÿÿÿÿ €Ÿÿÿÿÿÿÿ(Ä€ >ÿÿÿÿÿÿ2º€¡>ÿÿÿÿÿÿ<"º€¢ÿÿÿÿÿÿF2<€£>ÿÿÿÿÿÿP4º€¤ÿÿÿÿÿÿZFP€¥>ÿÿÿÿÿÿdFº€¦ÿÿÿÿÿÿnZd€§>ÿÿÿÿÿÿxXº€¨ÿÿÿÿÿÿ‚nx€©ÿÿÿÿÿÿŒ(‚€ª>ÿÿÿÿÿÿ–Ä€«>ÿÿÿÿÿÿ "Ä€¬ÿÿÿÿÿÿª– €­>ÿÿÿÿÿÿ´4Ä€®ÿÿÿÿÿÿ¾ª´€¯>ÿÿÿÿÿÿÈFÄ€°ÿÿÿÿÿÿҾȀ±>ÿÿÿÿÿÿÜXÄ€²ÿÿÿÿÿÿæÒÜ€³ÿÿÿÿÿÿðŒæ€´ÿÿÿÿÿÿúð€µ>ÿÿÿÿÿÿ΀¶>ÿÿÿÿÿÿ"΀·ÿÿÿÿÿÿ€¸>ÿÿÿÿÿÿ"4΀¹ÿÿÿÿÿÿ,"€º>ÿÿÿÿÿÿ6F΀»ÿÿÿÿÿÿ@,6€¼>ÿÿÿÿÿÿJX΀½ÿÿÿÿÿÿT@J€¾>ÿÿÿÿÿÿ^Ø€¿>ÿÿÿÿÿÿh"Ø€Àÿÿÿÿÿÿr^h€Á>ÿÿÿÿÿÿ|4Ø€Âÿÿÿÿÿÿ†r|€Ã>ÿÿÿÿÿÿFØ€Äÿÿÿÿÿÿš†€Å>ÿÿÿÿÿÿ¤XØ€Æÿÿÿÿÿÿ®š¤€Çÿÿÿÿÿÿ¸T®€È>ÿÿÿÿÿÿÂâ€É>ÿÿÿÿÿÿÌ"â€ÊÿÿÿÿÿÿÖÂÌ€Ë>ÿÿÿÿÿÿà4â€ÌÿÿÿÿÿÿêÖà€Í>ÿÿÿÿÿÿôFâ€Îÿÿÿÿÿÿþêô€Ï>ÿÿÿÿÿÿXâ€Ðÿÿÿÿÿÿþ€Ñÿÿÿÿÿÿ¸€Ò>ÿÿÿÿÿÿ&ì€Ó>ÿÿÿÿÿÿ0"ì€Ôÿÿÿÿÿÿ:&0€Õ>ÿÿÿÿÿÿD4ì€ÖÿÿÿÿÿÿN:D€×>ÿÿÿÿÿÿXFì€ØÿÿÿÿÿÿbNX€Ù>ÿÿÿÿÿÿlXì€Úÿÿÿÿÿÿvbl€Ûÿÿÿÿÿÿ€v€Ü>ÿÿÿÿÿÿŠö€Ý>ÿÿÿÿÿÿ”"ö€ÞÿÿÿÿÿÿžŠ”€ß>ÿÿÿÿÿÿ¨4ö€àÿÿÿÿÿÿ²ž¨€á>ÿÿÿÿÿÿ¼Fö€âÿÿÿÿÿÿƲ¼€ã>ÿÿÿÿÿÿÐXö€äÿÿÿÿÿÿÚÆЀåÿÿÿÿÿÿä€Ú€æÿÿÿÿÿÿîúä€ç>ÿÿÿÿÿÿø€è>ÿÿÿÿÿÿ "€éÿÿÿÿÿÿ ø €ê>ÿÿÿÿÿÿ 4€ëÿÿÿÿÿÿ  €ì>ÿÿÿÿÿÿ* F€íÿÿÿÿÿÿ4 * €î>ÿÿÿÿÿÿ> X€ïÿÿÿÿÿÿH 4 > €ð>ÿÿÿÿÿÿR  €ñ>ÿÿÿÿÿÿ\ " €òÿÿÿÿÿÿf R \ €ó>ÿÿÿÿÿÿp 4 €ôÿÿÿÿÿÿz f p €õ>ÿÿÿÿÿÿ„ F €öÿÿÿÿÿÿŽ z „ €÷>ÿÿÿÿÿÿ˜ X €øÿÿÿÿÿÿ¢ Ž ˜ €ùÿÿÿÿÿÿ¬ H ¢ €ú>ÿÿÿÿÿÿ¶ €û>ÿÿÿÿÿÿÀ "€üÿÿÿÿÿÿÊ ¶ À €ý>ÿÿÿÿÿÿÔ 4€þÿÿÿÿÿÿÞ Ê Ô €ÿ>ÿÿÿÿÿÿè F€ÿÿÿÿÿÿò Þ è €>ÿÿÿÿÿÿü X€ÿÿÿÿÿÿ ò ü €ÿÿÿÿÿÿ ¬  €>ÿÿÿÿÿÿ €>ÿÿÿÿÿÿ$ "€ÿÿÿÿÿÿ.  $ €>ÿÿÿÿÿÿ8 4€ÿÿÿÿÿÿB . 8 € >ÿÿÿÿÿÿL F€ ÿÿÿÿÿÿV B L € >ÿÿÿÿÿÿ` X€ ÿÿÿÿÿÿj V ` € ÿÿÿÿÿÿt  j €>ÿÿÿÿÿÿ~ (€>ÿÿÿÿÿÿˆ "(€ÿÿÿÿÿÿ’ ~ ˆ €>ÿÿÿÿÿÿœ 4(€ÿÿÿÿÿÿ¦ ’ œ €>ÿÿÿÿÿÿ° F(€ÿÿÿÿÿÿº ¦ ° €>ÿÿÿÿÿÿÄ X(€ÿÿÿÿÿÿÎ º Ä €ÿÿÿÿÿÿØ t Î €ÿÿÿÿÿÿâ îØ €ÿÿÿÿÿÿì 2Œ€ÿÿÿÿÿÿö ì ð€ÿÿÿÿÿÿ ö T€ÿÿÿÿÿÿ ¸€ÿÿÿÿÿÿ 2€ÿÿÿÿÿÿ  €ÿÿÿÿÿÿ(  € ÿÿÿÿÿÿ2 ( ø€!ÿÿÿÿÿÿ< 2 €"ÿÿÿÿÿÿF <–€#ÿÿÿÿÿÿP F ú€$ÿÿÿÿÿÿZ P ^€%ÿÿÿÿÿÿd Z €&ÿÿÿÿÿÿn <&€'ÿÿÿÿÿÿx n €(ÿÿÿÿÿÿ‚ x €)ÿÿÿÿÿÿŒ ‚  €*ÿÿÿÿÿÿ– d Œ €+ÿÿÿÿÿÿ  < – €,ÿÿÿÿÿÿª Pª€-ÿÿÿÿÿÿ´ ª €.ÿÿÿÿÿÿ¾ ´ r€/ÿÿÿÿÿÿÈ ¾ Ö€0ÿÿÿÿÿÿÒ P:€1ÿÿÿÿÿÿÜ Ò .€2ÿÿÿÿÿÿæ Ü "€3ÿÿÿÿÿÿð æ  €4ÿÿÿÿÿÿú È ð €5ÿÿÿÿÿÿ   ú €6ÿÿÿÿÿÿ d¾€7ÿÿÿÿÿÿ  "€8ÿÿÿÿÿÿ"  †€9ÿÿÿÿÿÿ, " ê€:ÿÿÿÿÿÿ6 dN€;ÿÿÿÿÿÿ@ 6 B€<ÿÿÿÿÿÿJ @ 6€=ÿÿÿÿÿÿT J * €>ÿÿÿÿÿÿ^ , T €?ÿÿÿÿÿÿh  ^ €@ÿÿÿÿÿÿr xÒ€Aÿÿÿÿÿÿ| r 6€Bÿÿÿÿÿÿ† | š€Cÿÿÿÿÿÿ † þ€Dÿÿÿÿÿÿš xb€Eÿÿÿÿÿÿ¤ š V€Fÿÿÿÿÿÿ® ¤ J€Gÿÿÿÿÿÿ¸ ® > €Hÿÿÿÿÿÿ ¸ €IÿÿÿÿÿÿÌ h  €JÿÿÿÿÿÿÖ v€Kÿÿÿÿÿÿà Ö Ú€Lÿÿÿÿÿÿê à >€Mÿÿÿÿÿÿô ê ¢€Nÿÿÿÿÿÿþ Œv€Oÿÿÿÿÿÿ þ j€Pÿÿÿÿÿÿ  ^€Qÿÿÿÿÿÿ  R €Rÿÿÿÿÿÿ& ô  €Sÿÿÿÿÿÿ0 &€€Tÿÿÿÿÿÿ: 0 ä€UÿÿÿÿÿÿD : H€VÿÿÿÿÿÿN D ¬€WÿÿÿÿÿÿX –€€Xÿÿÿÿÿÿb X t€Yÿÿÿÿÿÿl b h€Zÿÿÿÿÿÿv l \ €[ÿÿÿÿÿÿ€ N v €\ÿÿÿÿÿÿŠ & € €]ÿÿÿÿÿÿ” :”€^ÿÿÿÿÿÿž ” ø€_ÿÿÿÿÿÿ¨ ž \€`ÿÿÿÿÿÿ² ¨ À€aÿÿÿÿÿÿ¼ ª”€bÿÿÿÿÿÿÆ ¼ ˆ€cÿÿÿÿÿÿÐ Æ |€dÿÿÿÿÿÿÚ Ð p €eÿÿÿÿÿÿä ² Ú €fÿÿÿÿÿÿî Š ä €gÿÿÿÿÿÿø N¨€hÿÿÿÿÿÿø €iÿÿÿÿÿÿ p€jÿÿÿÿÿÿ Ô€kÿÿÿÿÿÿ ¾¨€lÿÿÿÿÿÿ* œ€mÿÿÿÿÿÿ4*€nÿÿÿÿÿÿ>4„ €oÿÿÿÿÿÿH>€pÿÿÿÿÿÿRî H€qÿÿÿÿÿÿ\b¼€rÿÿÿÿÿÿf\ €sÿÿÿÿÿÿpf„€tÿÿÿÿÿÿzpè€uÿÿÿÿÿÿ„Ò¼€vÿÿÿÿÿÿŽ„°€wÿÿÿÿÿÿ˜Ž¤€xÿÿÿÿÿÿ¢˜˜ €yÿÿÿÿÿÿ¬z¢€zÿÿÿÿÿÿ¶R¬€{ÿÿÿÿÿÿÀÌ ¶€|ÿÿÿÿÿÿÊj€}ÿÿÿÿÿÿÔÊ΀~ÿÿÿÿÿÿÞÔ2€ÿÿÿÿÿÿèÞ–€€ÿÿÿÿÿÿòðÚ€ÿÿÿÿÿÿüò΀‚ÿÿÿÿÿÿü€ƒÿÿÿÿÿÿ¶ €„ÿÿÿÿÿÿ者ÿÿÿÿÿÿ$t€†ÿÿÿÿÿÿ.$Ø€‡ÿÿÿÿÿÿ8.<€ˆÿÿÿÿÿÿB8 €‰ÿÿÿÿÿÿLú䀊ÿÿÿÿÿÿVLØ€‹ÿÿÿÿÿÿ`VÌ€Œÿÿÿÿÿÿj`À €ÿÿÿÿÿÿtBj€Žÿÿÿÿÿÿ~t€ÿÿÿÿÿÿˆ.ˆ€ÿÿÿÿÿÿ’ˆì€‘ÿÿÿÿÿÿœ’P€’ÿÿÿÿÿÿ¦œ´€“ÿÿÿÿÿÿ°ø€”ÿÿÿÿÿÿº°ì€•ÿÿÿÿÿÿÄºà€–ÿÿÿÿÿÿÎÄÔ €—ÿÿÿÿÿÿئ΀˜ÿÿÿÿÿÿâ~Ø€™ÿÿÿÿÿÿìBœ€šÿÿÿÿÿÿö쀛ÿÿÿÿÿÿöd€œÿÿÿÿÿÿ È€ÿÿÿÿÿÿ" €žÿÿÿÿÿÿ€Ÿÿÿÿÿÿÿ(ô€ ÿÿÿÿÿÿ2(è €¡ÿÿÿÿÿÿ< 2€¢ÿÿÿÿÿÿFâ<€£ÿÿÿÿÿÿPV°€¤ÿÿÿÿÿÿZP€¥ÿÿÿÿÿÿdZx€¦ÿÿÿÿÿÿndÜ€§ÿÿÿÿÿÿx6 €¨ÿÿÿÿÿÿ‚x€©ÿÿÿÿÿÿŒ‚€ªÿÿÿÿÿÿ–Œü €«ÿÿÿÿÿÿ n–€¬ÿÿÿÿÿÿªF €­ÿÿÿÿÿÿ´Àª€®ÿÿÿÿÿÿ¾^€¯ÿÿÿÿÿÿȾ€°ÿÿÿÿÿÿÒÈ&€±ÿÿÿÿÿÿÜÒŠ€²ÿÿÿÿÿÿæT>€³ÿÿÿÿÿÿðæ2€´ÿÿÿÿÿÿúð&€µÿÿÿÿÿÿú €¶ÿÿÿÿÿÿÜ€·ÿÿÿÿÿÿh€¸ÿÿÿÿÿÿ"Ì€¹ÿÿÿÿÿÿ,"0€ºÿÿÿÿÿÿ6,”€»ÿÿÿÿÿÿ@^H€¼ÿÿÿÿÿÿJ@<€½ÿÿÿÿÿÿTJ0€¾ÿÿÿÿÿÿ^T$ €¿ÿÿÿÿÿÿh6^€Àÿÿÿÿÿÿrh€Áÿÿÿÿÿÿ|"|€Âÿÿÿÿÿÿ†|à€Ãÿÿÿÿÿÿ†D€Äÿÿÿÿÿÿš¨€Åÿÿÿÿÿÿ¤r\€Æÿÿÿÿÿÿ®¤P€Çÿÿÿÿÿÿ¸®D€Èÿÿÿÿÿÿ¸8 €Éÿÿÿÿÿÿ̚€ÊÿÿÿÿÿÿÖrÌ€Ëÿÿÿÿÿÿà6€Ìÿÿÿÿÿÿêàô€ÍÿÿÿÿÿÿôêX€Îÿÿÿÿÿÿþô¼€Ïÿÿÿÿÿÿ†p€Ðÿÿÿÿÿÿd€ÑÿÿÿÿÿÿX€Òÿÿÿÿÿÿ&L €Óÿÿÿÿÿÿ0þ&€Ôÿÿÿÿÿÿ:Ö0€ÕÿÿÿÿÿÿDJ¤€ÖÿÿÿÿÿÿND€×ÿÿÿÿÿÿXNl€ØÿÿÿÿÿÿbXЀÙÿÿÿÿÿÿlš„€Úÿÿÿÿÿÿvlx€Ûÿÿÿÿÿÿ€vl€ÜÿÿÿÿÿÿŠ€` €Ýÿÿÿÿÿÿ”bŠ€Þÿÿÿÿÿÿž:”€ßÿÿÿÿÿÿ¨´ž€àÿÿÿÿÿÿ²øR €áÿÿÿÿÿÿ¼²¶ €âÿÿÿÿÿÿƼ €ãÿÿÿÿÿÿÐÆ~ €äÿÿÿÿÿÿÚ¸¢€åÿÿÿÿÿÿäÚ–€æÿÿÿÿÿÿî䊀çÿÿÿÿÿÿøî~ €èÿÿÿÿÿÿÐø€éÿÿÿÿÿÿ  \ €êÿÿÿÿÿÿ À €ëÿÿÿÿÿÿ $ €ìÿÿÿÿÿÿ* ˆ €íÿÿÿÿÿÿ4¬€îÿÿÿÿÿÿ>4 €ïÿÿÿÿÿÿH>”€ðÿÿÿÿÿÿRHˆ €ñÿÿÿÿÿÿ\*R€òÿÿÿÿÿÿf\€óÿÿÿÿÿÿp p €ôÿÿÿÿÿÿzpÔ €õÿÿÿÿÿÿ„z8 €öÿÿÿÿÿÿŽ„œ €÷ÿÿÿÿÿÿ˜ÖÀ€øÿÿÿÿÿÿ¢˜´€ùÿÿÿÿÿÿ¬¢¨€úÿÿÿÿÿÿ¶¬œ €ûÿÿÿÿÿÿÀŽ¶€üÿÿÿÿÿÿÊfÀ€ýÿÿÿÿÿÿÔ* „ €þÿÿÿÿÿÿÞÔè €ÿÿÿÿÿÿÿèÞL €ÿÿÿÿÿÿòè° €ÿÿÿÿÿÿüêÔ€ÿÿÿÿÿÿüÈ€ÿÿÿÿÿÿ¼€ÿÿÿÿÿÿ° €ÿÿÿÿÿÿ$ò€ÿÿÿÿÿÿ.Ê$€ÿÿÿÿÿÿ8> ˜ €ÿÿÿÿÿÿB8ü € ÿÿÿÿÿÿLB` € ÿÿÿÿÿÿVLÄ € ÿÿÿÿÿÿ`þè€ ÿÿÿÿÿÿj`Ü€ ÿÿÿÿÿÿtjЀÿÿÿÿÿÿ~tÄ €ÿÿÿÿÿÿˆV~€ÿÿÿÿÿÿ’.ˆ€ÿÿÿÿÿÿœ¨’@ÿÿÿÿÿÿ¦2@ÿÿÿÿÿÿ¯v€ÿÿÿÿÿÿ¸¦¯@ÿÿÿÿÿÿÂ΀ÿÿÿÿÿÿ˸Â@ÿÿÿÿÿÿÕ&€ÿÿÿÿÿÿÞËÕ@ÿÿÿÿÿÿè~ €ÿÿÿÿÿÿñÞè@ÿÿÿÿÿÿû<@ÿÿÿÿÿÿ€€ÿÿÿÿÿÿ û@ÿÿÿÿÿÿØ€ÿÿÿÿÿÿ  @ ÿÿÿÿÿÿ*0€!ÿÿÿÿÿÿ3 *@"ÿÿÿÿÿÿ=ˆ €#ÿÿÿÿÿÿF3=€$ÿÿÿÿÿÿPñF@%ÿÿÿÿÿÿZP@&ÿÿÿÿÿÿc”€'ÿÿÿÿÿÿlZc@(ÿÿÿÿÿÿvì€)ÿÿÿÿÿÿlv@*ÿÿÿÿÿÿ‰D€+ÿÿÿÿÿÿ’‰@,ÿÿÿÿÿÿœœ €-ÿÿÿÿÿÿ¥’œ€.ÿÿÿÿÿÿ¯P¥@/ÿÿÿÿÿÿ¹d@0ÿÿÿÿÿÿ¨€1ÿÿÿÿÿÿ˹Â@2ÿÿÿÿÿÿÕ€3ÿÿÿÿÿÿÞËÕ@4ÿÿÿÿÿÿèX€5ÿÿÿÿÿÿñÞè@6ÿÿÿÿÿÿû° €7ÿÿÿÿÿÿñû€8ÿÿÿÿÿÿ¯@9ÿÿÿÿÿÿx@:ÿÿÿÿÿÿ!¼€;ÿÿÿÿÿÿ*!@<ÿÿÿÿÿÿ4€=ÿÿÿÿÿÿ=*4@>ÿÿÿÿÿÿGl€?ÿÿÿÿÿÿP=G@@ÿÿÿÿÿÿZÄ €AÿÿÿÿÿÿcPZ€Bÿÿÿÿÿÿmc@CÿÿÿÿÿÿwŒ@Dÿÿÿÿÿÿ€@Eÿÿÿÿÿÿ‰ð@Fÿÿÿÿÿÿ’@Gÿÿÿÿÿÿ›T@Hÿÿÿÿÿÿ¤@Iÿÿÿÿÿÿ­¸@Jÿÿÿÿÿÿ¶ø@Kÿÿÿÿÿÿ¿Ú@LÿÿÿÿÿÿÈj@MÿÿÿÿÿÿÑ>@NÿÿÿÿÿÿÚ^@Oÿÿÿÿÿÿã¢@PÿÿÿÿÿÿìR @Qÿÿÿÿÿÿõ2@RÿÿÿÿÿÿþÂ@Sÿÿÿÿÿÿ–@Tÿÿÿÿÿÿ¶ @UÿÿÿÿÿÿŠ@Vÿÿÿÿÿÿ" @Wÿÿÿÿÿÿ+–@Xÿÿÿÿÿÿ4&@Yÿÿÿÿÿÿ=ú@ZÿÿÿÿÿÿF@[ÿÿÿÿÿÿO^@\ÿÿÿÿÿÿX@]ÿÿÿÿÿÿaÂ@^ÿÿÿÿÿÿj @_ÿÿÿÿÿÿsä@`ÿÿÿÿÿÿ|t@aÿÿÿÿÿÿ…H@bÿÿÿÿÿÿŽh@cÿÿÿÿÿÿ—¬@dÿÿÿÿÿÿ \ @eÿÿÿÿÿÿ©<@fÿÿÿÿÿÿ²Ì@gÿÿÿÿÿÿ» @hÿÿÿÿÿÿÄÀ @iÿÿÿÿÿÿÍ”@jÿÿÿÿÿÿÖ$ @kÿÿÿÿÿÿߪ@lÿÿÿÿÿÿè:@mÿÿÿÿÿÿñ@nÿÿÿÿÿÿú.@oÿÿÿÿÿÿr@pÿÿÿÿÿÿ "@qÿÿÿÿÿÿÖ@rÿÿÿÿÿÿ @sÿÿÿÿÿÿ'ø@tÿÿÿÿÿÿ0ˆ@uÿÿÿÿÿÿ9\@vÿÿÿÿÿÿB|@wÿÿÿÿÿÿKÀ@xÿÿÿÿÿÿTp @yÿÿÿÿÿÿ]P@zÿÿÿÿÿÿfà@{ÿÿÿÿÿÿo´@|ÿÿÿÿÿÿxÔ @}ÿÿÿÿÿÿ¨@~ÿÿÿÿÿÿŠ8 @ÿÿÿÿÿÿ“¾@€ÿÿÿÿÿÿœN@ÿÿÿÿÿÿ¥"@‚ÿÿÿÿÿÿ®B@ƒÿÿÿÿÿÿ·†@„ÿÿÿÿÿÿÀ6@…ÿÿÿÿÿÿÉê@†ÿÿÿÿÿÿÒ* @‡ÿÿÿÿÿÿÛ @ˆÿÿÿÿÿÿäœ@‰ÿÿÿÿÿÿíp@Šÿÿÿÿÿÿö@‹ÿÿÿÿÿÿÿÔ@Œÿÿÿÿÿÿ„ @ÿÿÿÿÿÿd@Žÿÿÿÿÿÿô@ÿÿÿÿÿÿ#È@ÿÿÿÿÿÿ,è @‘ÿÿÿÿÿÿ5¼@’ÿÿÿÿÿÿ>L @“ÿÿÿÿÿÿGÒ@”ÿÿÿÿÿÿPb@•ÿÿÿÿÿÿY6@–ÿÿÿÿÿÿbV@—ÿÿÿÿÿÿkš@˜ÿÿÿÿÿÿtJ@™ÿÿÿÿÿÿ}þ@šÿÿÿÿÿÿ†> @›ÿÿÿÿÿÿ @œÿÿÿÿÿÿ˜°@ÿÿÿÿÿÿ¡„@žÿÿÿÿÿÿª¤@Ÿÿÿÿÿÿÿ³è@ ÿÿÿÿÿÿ¼˜ @¡ÿÿÿÿÿÿÅx@¢ÿÿÿÿÿÿÎ@£ÿÿÿÿÿÿ×Ü@¤ÿÿÿÿÿÿàü @¥ÿÿÿÿÿÿéÐ@¦ÿÿÿÿÿÿò` €§ÿÿÿÿÿÿûw€€¨ÿÿÿÿÿÿ¦û€©ÿÿÿÿÿÿ‰’€ªÿÿÿÿÿÿ€«ÿÿÿÿÿÿ#›¤€¬ÿÿÿÿÿÿ-#€­ÿÿÿÿÿÿ7­¶€®ÿÿÿÿÿÿA-7€¯ÿÿÿÿÿÿK€w€°ÿÿÿÿÿÿUK¯€±ÿÿÿÿÿÿ_¿È€²ÿÿÿÿÿÿiU_€³ÿÿÿÿÿÿsÑÚ€´ÿÿÿÿÿÿ}is€µÿÿÿÿÿÿ‡ã쀶ÿÿÿÿÿÿ‘}‡€·ÿÿÿÿÿÿ›A‘€¸ÿÿÿÿÿÿ¥’‰€¹ÿÿÿÿÿÿ¯È¿€ºÿÿÿÿÿÿ¹¥¯€»ÿÿÿÿÿÿù€¼ÿÿÿÿÿÿÍõþ€½ÿÿÿÿÿÿ×ÃÍ€¾ÿÿÿÿÿÿဿÿÿÿÿÿÿë×á€Àÿÿÿÿÿÿõ›ë€Áÿÿÿÿÿÿÿ¤›€Âÿÿÿÿÿÿ ÚÑ€Ãÿÿÿÿÿÿÿ €Äÿÿÿÿÿÿþõ€Åÿÿÿÿÿÿ'€Æÿÿÿÿÿÿ1'Õ€Çÿÿÿÿÿÿ;"€ÈÿÿÿÿÿÿE1;€ÉÿÿÿÿÿÿOõE€ÊÿÿÿÿÿÿY¶­€Ëÿÿÿÿÿÿcìã€ÌÿÿÿÿÿÿmYc€Íÿÿÿÿÿÿw€Îÿÿÿÿÿÿmw€Ïÿÿÿÿÿÿ‹"€Ðÿÿÿÿÿÿ•‹€ÑÿÿÿÿÿÿŸ•è€Òÿÿÿÿÿÿ©OŸ€Óÿÿÿÿÿÿ³+4€Ôÿÿÿÿÿÿ½û³€ÕÿÿÿÿÿÿÇ=F€Öÿÿÿÿÿÿѽǀ×ÿÿÿÿÿÿÛOX€ØÿÿÿÿÿÿåÑÛ€Ùÿÿÿÿÿÿïaj€Úÿÿÿÿÿÿùåï€Ûÿÿÿÿÿÿ4+€Üÿÿÿÿÿÿ €Ýÿÿÿÿÿÿs|€Þÿÿÿÿÿÿ! €ßÿÿÿÿÿÿ+…Ž€àÿÿÿÿÿÿ5!+€áÿÿÿÿÿÿ?— €âÿÿÿÿÿÿI5?€ãÿÿÿÿÿÿSùI€äÿÿÿÿÿÿ]F=€åÿÿÿÿÿÿg|s€æÿÿÿÿÿÿq]g€çÿÿÿÿÿÿ{q€èÿÿÿÿÿÿ…©²€éÿÿÿÿÿÿ{…€êÿÿÿÿÿÿ™»Ä€ëÿÿÿÿÿÿ£™€ìÿÿÿÿÿÿ­S£€íÿÿÿÿÿÿ·XO€îÿÿÿÿÿÿÁŽ…€ïÿÿÿÿÿÿË·Á€ðÿÿÿÿÿÿÕ²©€ñÿÿÿÿÿÿßËÕ€òÿÿÿÿÿÿéß*€óÿÿÿÿÿÿóÍÖ€ôÿÿÿÿÿÿýéó€õÿÿÿÿÿÿ­ý€öÿÿÿÿÿÿja€÷ÿÿÿÿÿÿ —€øÿÿÿÿÿÿ%€ùÿÿÿÿÿÿ/Ä»€úÿÿÿÿÿÿ9%/€ûÿÿÿÿÿÿCÖÍ€üÿÿÿÿÿÿM9C€ýÿÿÿÿÿÿWM=€þÿÿÿÿÿÿaW€ÿÿÿÿÿÿÿk©a€ÿÿÿÿÿÿußè€ÿÿÿÿÿÿZu€ÿÿÿÿÿÿ‰ñú€ÿÿÿÿÿÿ“‰€ÿÿÿÿÿÿ €ÿÿÿÿÿÿ§“€ÿÿÿÿÿÿ±€ÿÿÿÿÿÿ»§±€ÿÿÿÿÿÿÅè߀ ÿÿÿÿÿÿÏÅc€ ÿÿÿÿÿÿÙ'0€ ÿÿÿÿÿÿãÏÙ€ ÿÿÿÿÿÿí9B€ ÿÿÿÿÿÿ÷ãí€ÿÿÿÿÿÿKT€ÿÿÿÿÿÿ ÷€ÿÿÿÿÿÿ» €ÿÿÿÿÿÿúñ€ÿÿÿÿÿÿ)0'€ÿÿÿÿÿÿ3)€ÿÿÿÿÿÿ=3v€ÿÿÿÿÿÿG]f€ÿÿÿÿÿÿQ=G€ÿÿÿÿÿÿ[ox€ÿÿÿÿÿÿeQ[€ÿÿÿÿÿÿoe€ÿÿÿÿÿÿy €ÿÿÿÿÿÿƒB9€ÿÿÿÿÿÿyƒ€ÿÿÿÿÿÿ—f]€ÿÿÿÿÿÿ¡—€ÿÿÿÿÿÿ«¡‰€ ÿÿÿÿÿÿµŠ€!ÿÿÿÿÿÿ¿«µ€"ÿÿÿÿÿÿÉo¿€#ÿÿÿÿÿÿÓ€$ÿÿÿÿÿÿÝTK€%ÿÿÿÿÿÿçÓÝ€&ÿÿÿÿÿÿñxo€'ÿÿÿÿÿÿûçñ€(ÿÿÿÿÿÿŠ€)ÿÿÿÿÿÿû€*ÿÿÿÿÿÿœ€+ÿÿÿÿÿÿ#É€,ÿÿÿÿÿÿ-k#€-ÿÿÿÿÿÿ7“œ€.ÿÿÿÿÿÿA¹7€/ÿÿÿÿÿÿK¥®€0ÿÿÿÿÿÿUAK€1ÿÿÿÿÿÿ_·À€2ÿÿÿÿÿÿiU_€3ÿÿÿÿÿÿsÉÒ€4ÿÿÿÿÿÿ}is€5ÿÿÿÿÿÿ‡œ“€6ÿÿÿÿÿÿ‘‡Â€7ÿÿÿÿÿÿ›Ûä€8ÿÿÿÿÿÿ¥‘›€9ÿÿÿÿÿÿ¯íö€:ÿÿÿÿÿÿ¹¥¯€;ÿÿÿÿÿÿÃÿ€<ÿÿÿÿÿÿ͹À=ÿÿÿÿÿÿ×}Í€>ÿÿÿÿÿÿᮥ€?ÿÿÿÿÿÿëäÛ€@ÿÿÿÿÿÿõáë€AÿÿÿÿÿÿÿõÕ€Bÿÿÿÿÿÿ €Cÿÿÿÿÿÿ ÿ €Dÿÿÿÿÿÿ #,€Eÿÿÿÿÿÿ'   €Fÿÿÿÿÿÿ1 ×' €Gÿÿÿÿÿÿ; À·€HÿÿÿÿÿÿE öí€IÿÿÿÿÿÿO ; E €JÿÿÿÿÿÿY €Kÿÿÿÿÿÿc O Y €Lÿÿÿÿÿÿm c è€Mÿÿÿÿÿÿw 5>€Nÿÿÿÿÿÿ m w €Oÿÿÿÿÿÿ‹ 1 €Pÿÿÿÿÿÿ• ÒÉ€QÿÿÿÿÿÿŸ ÿ€Rÿÿÿÿÿÿ© • Ÿ €Sÿÿÿÿÿÿ³ ,#€Tÿÿÿÿÿÿ½ © ³ €UÿÿÿÿÿÿÇ >5€VÿÿÿÿÿÿÑ ½ Ç €WÿÿÿÿÿÿÛ Ñ û€Xÿÿÿÿÿÿå ‹ Û €Yÿÿÿÿÿÿï -å €Zÿÿÿÿÿÿù GP€[ÿÿÿÿÿÿ!ù €\ÿÿÿÿÿÿ !Yb€]ÿÿÿÿÿÿ!! !€^ÿÿÿÿÿÿ!!kt€_ÿÿÿÿÿÿ+!!!!€`ÿÿÿÿÿÿ5!}†€aÿÿÿÿÿÿ?!+!5!€bÿÿÿÿÿÿI!PG€cÿÿÿÿÿÿS!I!!€dÿÿÿÿÿÿ]!˜€eÿÿÿÿÿÿg!S!]!€fÿÿÿÿÿÿq!¡ª€gÿÿÿÿÿÿ{!g!q!€hÿÿÿÿÿÿ…!³¼€iÿÿÿÿÿÿ!{!…!€jÿÿÿÿÿÿ™!?!!€kÿÿÿÿÿÿ£!bY€lÿÿÿÿÿÿ­!˜€mÿÿÿÿÿÿ·!£!­!€nÿÿÿÿÿÿÁ!·!4€oÿÿÿÿÿÿË!Å΀pÿÿÿÿÿÿÕ!Á!Ë!€qÿÿÿÿÿÿß!×à€rÿÿÿÿÿÿé!Õ!ß!€sÿÿÿÿÿÿó!™!é!€tÿÿÿÿÿÿý!tk€uÿÿÿÿÿÿ"ª¡€vÿÿÿÿÿÿ"ý!"€wÿÿÿÿÿÿ"ÎÅ€xÿÿÿÿÿÿ%"""€yÿÿÿÿÿÿ/"%"G€zÿÿÿÿÿÿ9"éò€{ÿÿÿÿÿÿC"/"9"€|ÿÿÿÿÿÿM"ó!C"€}ÿÿÿÿÿÿW"†}€~ÿÿÿÿÿÿa"¼³€ÿÿÿÿÿÿk"W"a"€€ÿÿÿÿÿÿu"à×€ÿÿÿÿÿÿ"k"u"€‚ÿÿÿÿÿÿ‰"ò逃ÿÿÿÿÿÿ“""‰"€„ÿÿÿÿÿÿ"“"Z€…ÿÿÿÿÿÿ§"M""€†ÿÿÿÿÿÿ±"ï §"€‡ÿÿÿÿÿÿ»"2€€ˆÿÿÿÿÿÿÅ"»"쀉ÿÿÿÿÿÿÏ"Å"X€ŠÿÿÿÿÿÿÙ"Ï"Ä €‹Sÿÿÿÿÿÿã"€Œ>ÿÿÿÿÿÿí"ã"@ÿÿÿÿÿÿ÷"í"€ŽSÿÿÿÿÿÿ#j€>ÿÿÿÿÿÿ #"#@ÿÿÿÿÿÿ# #€‘ÿÿÿÿÿÿ#÷"#€’Sÿÿÿÿÿÿ'#œ€“>ÿÿÿÿÿÿ1#4'#@”ÿÿÿÿÿÿ;#1#€•ÿÿÿÿÿÿD##;#€–SÿÿÿÿÿÿN#΀—>ÿÿÿÿÿÿX#FN#@˜ÿÿÿÿÿÿb#X#€™ÿÿÿÿÿÿk#D#b#€šSÿÿÿÿÿÿu#€›>ÿÿÿÿÿÿ#Xu#@œÿÿÿÿÿÿ‰##€ÿÿÿÿÿÿ’#k#‰#€žSÿÿÿÿÿÿœ#*"€Ÿ>ÿÿÿÿÿÿ¦#œ#@ ÿÿÿÿÿÿ°#¦#€¡Sÿÿÿÿÿÿ¹#t"€¢>ÿÿÿÿÿÿÃ#"¹#@£ÿÿÿÿÿÿÍ#Ã#€¤ÿÿÿÿÿÿÖ#°#Í#€¥Sÿÿÿÿÿÿà#¦"€¦>ÿÿÿÿÿÿê#4à#@§ÿÿÿÿÿÿô#ê#€¨ÿÿÿÿÿÿý#Ö#ô#€©Sÿÿÿÿÿÿ$Ø"€ª>ÿÿÿÿÿÿ$F$@«ÿÿÿÿÿÿ$$€¬ÿÿÿÿÿÿ$$ý#$€­Sÿÿÿÿÿÿ.$ "€®>ÿÿÿÿÿÿ8$X.$@¯ÿÿÿÿÿÿB$8$€°ÿÿÿÿÿÿK$$$B$€±ÿÿÿÿÿÿU$’#K$€²Sÿÿÿÿÿÿ_$<4€³>ÿÿÿÿÿÿi$_$@´ÿÿÿÿÿÿs$i$€µSÿÿÿÿÿÿ|$~4€¶>ÿÿÿÿÿÿ†$"|$@·ÿÿÿÿÿÿ$†$€¸ÿÿÿÿÿÿ™$s$$€¹Sÿÿÿÿÿÿ£$°4€º>ÿÿÿÿÿÿ­$4£$@»ÿÿÿÿÿÿ·$­$€¼ÿÿÿÿÿÿÀ$™$·$€½SÿÿÿÿÿÿÊ$â4€¾>ÿÿÿÿÿÿÔ$FÊ$@¿ÿÿÿÿÿÿÞ$Ô$€Àÿÿÿÿÿÿç$À$Þ$€ÁSÿÿÿÿÿÿñ$4€Â>ÿÿÿÿÿÿû$Xñ$@Ãÿÿÿÿÿÿ%û$€Äÿÿÿÿÿÿ%ç$%€Åÿÿÿÿÿÿ%U$%€ÆSÿÿÿÿÿÿ"%NF€Ç>ÿÿÿÿÿÿ,%"%@Èÿÿÿÿÿÿ6%,%€ÉSÿÿÿÿÿÿ?%ˆF€Ê>ÿÿÿÿÿÿI%"?%@ËÿÿÿÿÿÿS%I%€Ìÿÿÿÿÿÿ\%6%S%€ÍSÿÿÿÿÿÿf%ºF€Î>ÿÿÿÿÿÿp%4f%@Ïÿÿÿÿÿÿz%p%€Ðÿÿÿÿÿÿƒ%\%z%€ÑSÿÿÿÿÿÿ%ìF€Ò>ÿÿÿÿÿÿ—%F%@Óÿÿÿÿÿÿ¡%—%€Ôÿÿÿÿÿÿª%ƒ%¡%€ÕSÿÿÿÿÿÿ´%F€Ö>ÿÿÿÿÿÿ¾%X´%@×ÿÿÿÿÿÿÈ%¾%€ØÿÿÿÿÿÿÑ%ª%È%€ÙÿÿÿÿÿÿÛ%%Ñ%€ÚSÿÿÿÿÿÿå%`X€Û>ÿÿÿÿÿÿï%å%@Üÿÿÿÿÿÿù%ï%€ÝSÿÿÿÿÿÿ&’X€Þ>ÿÿÿÿÿÿ &"&@ßÿÿÿÿÿÿ& &€àÿÿÿÿÿÿ&ù%&€áSÿÿÿÿÿÿ)&ÄX€â>ÿÿÿÿÿÿ3&4)&@ãÿÿÿÿÿÿ=&3&€äÿÿÿÿÿÿF&&=&€åSÿÿÿÿÿÿP&öX€æ>ÿÿÿÿÿÿZ&FP&@çÿÿÿÿÿÿd&Z&€èÿÿÿÿÿÿm&F&d&€éSÿÿÿÿÿÿw&(X€ê>ÿÿÿÿÿÿ&Xw&@ëÿÿÿÿÿÿ‹&&€ìÿÿÿÿÿÿ”&m&‹&€íÿÿÿÿÿÿž&Û%”&€îSÿÿÿÿÿÿ¨&*€ï>ÿÿÿÿÿÿ²&"¨&@ðÿÿÿÿÿÿ¼&²&€ñÿÿÿÿÿÿÅ&÷"¼&€òSÿÿÿÿÿÿÏ&<€ó>ÿÿÿÿÿÿÙ&4Ï&@ôÿÿÿÿÿÿã&Ù&€õÿÿÿÿÿÿì&Å&ã&€öSÿÿÿÿÿÿö&N€÷>ÿÿÿÿÿÿ'Fö&@øÿÿÿÿÿÿ ''€ùÿÿÿÿÿÿ'ì& '€úSÿÿÿÿÿÿ'`€û>ÿÿÿÿÿÿ''X'@üÿÿÿÿÿÿ1'''€ýÿÿÿÿÿÿ:''1'€þSÿÿÿÿÿÿD'j"€ÿ>ÿÿÿÿÿÿN'D'@ÿÿÿÿÿÿX'N'€ÿÿÿÿÿÿa'X'Í#€Sÿÿÿÿÿÿk'~"€>ÿÿÿÿÿÿu'4k'@ÿÿÿÿÿÿ'u'€ÿÿÿÿÿÿˆ'a''€Sÿÿÿÿÿÿ’'ˆ"€>ÿÿÿÿÿÿœ'F’'@ÿÿÿÿÿÿ¦'œ'€ ÿÿÿÿÿÿ¯'ˆ'¦'€ Sÿÿÿÿÿÿ¹'’"€ >ÿÿÿÿÿÿÃ'X¹'@ ÿÿÿÿÿÿÍ'Ã'€ ÿÿÿÿÿÿÖ'¯'Í'€ÿÿÿÿÿÿà':'Ö'€Sÿÿÿÿÿÿê'œ4€>ÿÿÿÿÿÿô'ê'@ÿÿÿÿÿÿþ'ô'€Sÿÿÿÿÿÿ(¦4€>ÿÿÿÿÿÿ("(@ÿÿÿÿÿÿ((€ÿÿÿÿÿÿ$(þ'(€ÿÿÿÿÿÿ.($(·$€Sÿÿÿÿÿÿ8(º4€>ÿÿÿÿÿÿB(F8(@ÿÿÿÿÿÿL(B(€ÿÿÿÿÿÿU(.(L(€Sÿÿÿÿÿÿ_(Ä4€>ÿÿÿÿÿÿi(X_(@ÿÿÿÿÿÿs(i(€ÿÿÿÿÿÿ|(U(s(€ÿÿÿÿÿÿ†(à'|(€ Sÿÿÿÿÿÿ(ÎF€!>ÿÿÿÿÿÿš((@"ÿÿÿÿÿÿ¤(š(€#Sÿÿÿÿÿÿ­(ØF€$>ÿÿÿÿÿÿ·("­(@%ÿÿÿÿÿÿÁ(·(€&ÿÿÿÿÿÿÊ(¤(Á(€'SÿÿÿÿÿÿÔ(âF€(>ÿÿÿÿÿÿÞ(4Ô(@)ÿÿÿÿÿÿè(Þ(€*ÿÿÿÿÿÿñ(Ê(è(€+ÿÿÿÿÿÿû(ñ(¡%€,Sÿÿÿÿÿÿ)öF€->ÿÿÿÿÿÿ)X)@.ÿÿÿÿÿÿ))€/ÿÿÿÿÿÿ")û()€0ÿÿÿÿÿÿ,)†(")€1Sÿÿÿÿÿÿ6)X€2>ÿÿÿÿÿÿ@)6)@3ÿÿÿÿÿÿJ)@)€4SÿÿÿÿÿÿS) X€5>ÿÿÿÿÿÿ])"S)@6ÿÿÿÿÿÿg)])€7ÿÿÿÿÿÿp)J)g)€8Sÿÿÿÿÿÿz)X€9>ÿÿÿÿÿÿ„)4z)@:ÿÿÿÿÿÿŽ)„)€;ÿÿÿÿÿÿ—)p)Ž)€<Sÿÿÿÿÿÿ¡)X€=>ÿÿÿÿÿÿ«)F¡)@>ÿÿÿÿÿÿµ)«)€?ÿÿÿÿÿÿ¾)—)µ)€@ÿÿÿÿÿÿÈ)¾)‹&€AÿÿÿÿÿÿÒ),)È)€BÿÿÿÿÿÿÜ)í" #€Cÿÿÿÿÿÿæ)Ü)1#€Dÿÿÿÿÿÿð)æ)X#€Eÿÿÿÿÿÿú)ð)#€Fÿÿÿÿÿÿ*¦#Ã#€Gÿÿÿÿÿÿ**ê#€Hÿÿÿÿÿÿ**$€Iÿÿÿÿÿÿ"**8$€Jÿÿÿÿÿÿ,*ú)"*€Kÿÿÿÿÿÿ6*i$†$€Lÿÿÿÿÿÿ@*6*­$€MÿÿÿÿÿÿJ*@*Ô$€NÿÿÿÿÿÿT*J*û$€Oÿÿÿÿÿÿ^*,*T*€Pÿÿÿÿÿÿh*,%I%€Qÿÿÿÿÿÿr*h*p%€Rÿÿÿÿÿÿ|*r*—%€Sÿÿÿÿÿÿ†*|*¾%€Tÿÿÿÿÿÿ*^*†*€Uÿÿÿÿÿÿš*ï% &€Vÿÿÿÿÿÿ¤*š*3&€Wÿÿÿÿÿÿ®*¤*Z&€Xÿÿÿÿÿÿ¸*®*&€YÿÿÿÿÿÿÂ**¸*€ZÿÿÿÿÿÿÌ*2ñ€[ÿÿÿÿÿÿÖ*ŒF€\ÿÿÿÿÿÿà*Ì*Ö*€]ÿÿÿÿÿÿê*ð¥€^ÿÿÿÿÿÿô*à*ê*€_ÿÿÿÿÿÿþ*T€`ÿÿÿÿÿÿ+ô*þ*€aÿÿÿÿÿÿ+¸c€bÿÿÿÿÿÿ+++€cÿÿÿÿÿÿ&+&ñ€dÿÿÿÿÿÿ0+€F€eÿÿÿÿÿÿ:+&+0+€fÿÿÿÿÿÿD+䥀gÿÿÿÿÿÿN+:+D+€hÿÿÿÿÿÿX+H€iÿÿÿÿÿÿb+N+X+€jÿÿÿÿÿÿl+¬c€kÿÿÿÿÿÿv+b+l+€lÿÿÿÿÿÿ€++v+€mÿÿÿÿÿÿŠ+.ñ€nÿÿÿÿÿÿ”+ˆF€oÿÿÿÿÿÿž+Š+”+€pÿÿÿÿÿÿ¨+쥀qÿÿÿÿÿÿ²+ž+¨+€rÿÿÿÿÿÿ¼+P€sÿÿÿÿÿÿÆ+²+¼+€tÿÿÿÿÿÿÐ+´c€uÿÿÿÿÿÿÚ+Æ+Ð+€vÿÿÿÿÿÿä+€+Ú+€wÿÿÿÿÿÿî+6ñ€xÿÿÿÿÿÿø+F€yÿÿÿÿÿÿ,î+ø+€zÿÿÿÿÿÿ ,ô¥€{ÿÿÿÿÿÿ,, ,€|ÿÿÿÿÿÿ ,X€}ÿÿÿÿÿÿ*,, ,€~ÿÿÿÿÿÿ4,¼c€ÿÿÿÿÿÿ>,*,4,€€ÿÿÿÿÿÿH,ä+>,€ÿÿÿÿÿÿR,> ñ€‚ÿÿÿÿÿÿ\,˜ F€ƒÿÿÿÿÿÿf,R,\,€„ÿÿÿÿÿÿp,ü ¥€…ÿÿÿÿÿÿz,f,p,€†ÿÿÿÿÿÿ„,` €‡ÿÿÿÿÿÿŽ,z,„,€ˆÿÿÿÿÿÿ˜,Ä c€‰ÿÿÿÿÿÿ¢,Ž,˜,€Šÿÿÿÿÿÿ¬,H,¢,€‹Sÿÿÿÿÿÿ¶,€Œ>ÿÿÿÿÿÿÀ,¶,@ÿÿÿÿÿÿÊ,À,€ŽSÿÿÿÿÿÿÓ,**€>ÿÿÿÿÿÿÝ,"Ó,@ÿÿÿÿÿÿç,Ý,€‘ÿÿÿÿÿÿð,Ê,ç,€’Sÿÿÿÿÿÿú,<<€“>ÿÿÿÿÿÿ-4ú,@”ÿÿÿÿÿÿ--€•ÿÿÿÿÿÿ-ð,-€–Sÿÿÿÿÿÿ!-NN€—>ÿÿÿÿÿÿ+-F!-@˜ÿÿÿÿÿÿ5-+-€™ÿÿÿÿÿÿ>--5-€šSÿÿÿÿÿÿH-``€›>ÿÿÿÿÿÿR-XH-@œÿÿÿÿÿÿ\-R-€ÿÿÿÿÿÿe->-\-€žSÿÿÿÿÿÿo-jj€Ÿ>ÿÿÿÿÿÿy-o-@ ÿÿÿÿÿÿƒ-y-€¡SÿÿÿÿÿÿŒ-tt€¢>ÿÿÿÿÿÿ–-"Œ-@£ÿÿÿÿÿÿ -–-€¤ÿÿÿÿÿÿ©-ƒ- -€¥Sÿÿÿÿÿÿ³-~~€¦>ÿÿÿÿÿÿ½-4³-@§ÿÿÿÿÿÿÇ-½-€¨ÿÿÿÿÿÿÐ-©-Ç-€©SÿÿÿÿÿÿÚ-ˆˆ€ª>ÿÿÿÿÿÿä-FÚ-@«ÿÿÿÿÿÿî-ä-€¬ÿÿÿÿÿÿ÷-Ð-î-€­Sÿÿÿÿÿÿ.’’€®>ÿÿÿÿÿÿ .X.@¯ÿÿÿÿÿÿ. .€°ÿÿÿÿÿÿ.÷-.€±ÿÿÿÿÿÿ(.e-.€²Sÿÿÿÿÿÿ2.œœ€³>ÿÿÿÿÿÿ<.2.@´ÿÿÿÿÿÿF.<.€µSÿÿÿÿÿÿO.¦¦€¶>ÿÿÿÿÿÿY."O.@·ÿÿÿÿÿÿc.Y.€¸ÿÿÿÿÿÿl.F.c.€¹Sÿÿÿÿÿÿv.°°€º>ÿÿÿÿÿÿ€.4v.@»ÿÿÿÿÿÿŠ.€.€¼ÿÿÿÿÿÿ“.l.Š.€½Sÿÿÿÿÿÿ.ºº€¾>ÿÿÿÿÿÿ§.F.@¿ÿÿÿÿÿÿ±.§.€Àÿÿÿÿÿÿº.“.±.€ÁSÿÿÿÿÿÿÄ.ÄÄ€Â>ÿÿÿÿÿÿÎ.XÄ.@ÃÿÿÿÿÿÿØ.Î.€Äÿÿÿÿÿÿá.º.Ø.€Åÿÿÿÿÿÿë.(.á.€ÆSÿÿÿÿÿÿõ.Î΀Ç>ÿÿÿÿÿÿÿ.õ.@Èÿÿÿÿÿÿ /ÿ.€ÉSÿÿÿÿÿÿ/ØØ€Ê>ÿÿÿÿÿÿ/"/@Ëÿÿÿÿÿÿ&//€Ìÿÿÿÿÿÿ// /&/€ÍSÿÿÿÿÿÿ9/ââ€Î>ÿÿÿÿÿÿC/49/@ÏÿÿÿÿÿÿM/C/€ÐÿÿÿÿÿÿV///M/€ÑSÿÿÿÿÿÿ`/ìì€Ò>ÿÿÿÿÿÿj/F`/@Óÿÿÿÿÿÿt/j/€Ôÿÿÿÿÿÿ}/V/t/€ÕSÿÿÿÿÿÿ‡/öö€Ö>ÿÿÿÿÿÿ‘/X‡/@×ÿÿÿÿÿÿ›/‘/€Øÿÿÿÿÿÿ¤/}/›/€Ùÿÿÿÿÿÿ®/ë.¤/€ÚSÿÿÿÿÿÿ¸/€Û>ÿÿÿÿÿÿÂ/¸/@ÜÿÿÿÿÿÿÌ/Â/€ÝSÿÿÿÿÿÿÕ/  €Þ>ÿÿÿÿÿÿß/"Õ/@ßÿÿÿÿÿÿé/ß/€àÿÿÿÿÿÿò/Ì/é/€áSÿÿÿÿÿÿü/€â>ÿÿÿÿÿÿ04ü/@ãÿÿÿÿÿÿ00€äÿÿÿÿÿÿ0ò/0€åSÿÿÿÿÿÿ#0€æ>ÿÿÿÿÿÿ-0F#0@çÿÿÿÿÿÿ70-0€èÿÿÿÿÿÿ@0070€éSÿÿÿÿÿÿJ0((€ê>ÿÿÿÿÿÿT0XJ0@ëÿÿÿÿÿÿ^0T0€ìÿÿÿÿÿÿg0@0^0€íÿÿÿÿÿÿq0®/g0€îSÿÿÿÿÿÿ{0€ï>ÿÿÿÿÿÿ…0{0@ðÿÿÿÿÿÿ0…0€ñSÿÿÿÿÿÿ˜0"*€ò>ÿÿÿÿÿÿ¢0˜0@óÿÿÿÿÿÿ¬0¢0€ôÿÿÿÿÿÿµ00¬0€õSÿÿÿÿÿÿ¿04<€ö>ÿÿÿÿÿÿÉ0¿0@÷ÿÿÿÿÿÿÓ0É0€øÿÿÿÿÿÿÜ0µ0Ó0€ùSÿÿÿÿÿÿæ0FN€ú>ÿÿÿÿÿÿð0æ0@ûÿÿÿÿÿÿú0ð0€üÿÿÿÿÿÿ1Ü0ú0€ýSÿÿÿÿÿÿ 1X`€þ>ÿÿÿÿÿÿ1 1@ÿÿÿÿÿÿÿ!11€ÿÿÿÿÿÿ*11!1€Sÿÿÿÿÿÿ41j€>ÿÿÿÿÿÿ>1"41@ÿÿÿÿÿÿH1>1€SÿÿÿÿÿÿQ1"t€>ÿÿÿÿÿÿ[1"Q1@ÿÿÿÿÿÿe1[1€ÿÿÿÿÿÿn1H1e1€Sÿÿÿÿÿÿx14~€ >ÿÿÿÿÿÿ‚1"x1@ ÿÿÿÿÿÿŒ1‚1€ ÿÿÿÿÿÿ•1n1Œ1€ SÿÿÿÿÿÿŸ1Fˆ€ >ÿÿÿÿÿÿ©1"Ÿ1@ÿÿÿÿÿÿ³1©1€ÿÿÿÿÿÿ¼1•1³1€SÿÿÿÿÿÿÆ1X’€>ÿÿÿÿÿÿÐ1"Æ1@ÿÿÿÿÿÿÚ1Ð1€ÿÿÿÿÿÿã1¼1Ú1€ÿÿÿÿÿÿí1*1ã1€Sÿÿÿÿÿÿ÷1œ€>ÿÿÿÿÿÿ24÷1@ÿÿÿÿÿÿ 22€Sÿÿÿÿÿÿ2"¦€>ÿÿÿÿÿÿ242@ÿÿÿÿÿÿ(22€ÿÿÿÿÿÿ12 2(2€Sÿÿÿÿÿÿ;24°€>ÿÿÿÿÿÿE24;2@ÿÿÿÿÿÿO2E2€ÿÿÿÿÿÿX212O2€ Sÿÿÿÿÿÿb2Fº€!>ÿÿÿÿÿÿl24b2@"ÿÿÿÿÿÿv2l2€#ÿÿÿÿÿÿ2X2v2€$Sÿÿÿÿÿÿ‰2XÄ€%>ÿÿÿÿÿÿ“24‰2@&ÿÿÿÿÿÿ2“2€'ÿÿÿÿÿÿ¦222€(ÿÿÿÿÿÿ°2í1¦2€)Sÿÿÿÿÿÿº2΀*>ÿÿÿÿÿÿÄ2Fº2@+ÿÿÿÿÿÿÎ2Ä2€,Sÿÿÿÿÿÿ×2"Ø€->ÿÿÿÿÿÿá2F×2@.ÿÿÿÿÿÿë2á2€/ÿÿÿÿÿÿô2Î2ë2€0Sÿÿÿÿÿÿþ24â€1>ÿÿÿÿÿÿ3Fþ2@2ÿÿÿÿÿÿ33€3ÿÿÿÿÿÿ3ô23€4Sÿÿÿÿÿÿ%3Fì€5>ÿÿÿÿÿÿ/3F%3@6ÿÿÿÿÿÿ93/3€7ÿÿÿÿÿÿB3393€8SÿÿÿÿÿÿL3Xö€9>ÿÿÿÿÿÿV3FL3@:ÿÿÿÿÿÿ`3V3€;ÿÿÿÿÿÿi3B3`3€<ÿÿÿÿÿÿs3°2i3€=Sÿÿÿÿÿÿ}3€>>ÿÿÿÿÿÿ‡3X}3@?ÿÿÿÿÿÿ‘3‡3€@Sÿÿÿÿÿÿš3" €A>ÿÿÿÿÿÿ¤3Xš3@Bÿÿÿÿÿÿ®3¤3€Cÿÿÿÿÿÿ·3‘3®3€DSÿÿÿÿÿÿÁ34€E>ÿÿÿÿÿÿË3XÁ3@FÿÿÿÿÿÿÕ3Ë3€GÿÿÿÿÿÿÞ3·3Õ3€HSÿÿÿÿÿÿè3F€I>ÿÿÿÿÿÿò3Xè3@Jÿÿÿÿÿÿü3ò3€Kÿÿÿÿÿÿ4Þ3ü3€LSÿÿÿÿÿÿ4X(€M>ÿÿÿÿÿÿ4X4@Nÿÿÿÿÿÿ#44€Oÿÿÿÿÿÿ,44#4€Pÿÿÿÿÿÿ64s3,4€Q>ÿÿÿÿÿÿ@4"o-@RÿÿÿÿÿÿJ4@4€SÿÿÿÿÿÿS4Ê,J4€T>ÿÿÿÿÿÿ]442.@Uÿÿÿÿÿÿg4]4€Vÿÿÿÿÿÿp4S4g4€W>ÿÿÿÿÿÿz4Fõ.@Xÿÿÿÿÿÿ„4z4€Yÿÿÿÿÿÿ4p4„4€Z>ÿÿÿÿÿÿ—4X¸/@[ÿÿÿÿÿÿ¡4—4€\ÿÿÿÿÿÿª44¡4€]>ÿÿÿÿÿÿ´4Ó,@^ÿÿÿÿÿÿ¾4´4€_ÿÿÿÿÿÿÇ4¾4 -€`>ÿÿÿÿÿÿÑ44O.@aÿÿÿÿÿÿÛ4Ñ4€bÿÿÿÿÿÿä4Ç4Û4€c>ÿÿÿÿÿÿî4F/@dÿÿÿÿÿÿø4î4€eÿÿÿÿÿÿ5ä4ø4€f>ÿÿÿÿÿÿ 5XÕ/@gÿÿÿÿÿÿ5 5€hÿÿÿÿÿÿ555€iÿÿÿÿÿÿ(5ª45€j>ÿÿÿÿÿÿ25ú,@kÿÿÿÿÿÿ<525€l>ÿÿÿÿÿÿE5"³-@mÿÿÿÿÿÿO5E5€nÿÿÿÿÿÿX5<5O5€oÿÿÿÿÿÿb5X5Š.€p>ÿÿÿÿÿÿl5F9/@qÿÿÿÿÿÿv5l5€rÿÿÿÿÿÿ5b5v5€s>ÿÿÿÿÿÿ‰5Xü/@tÿÿÿÿÿÿ“5‰5€uÿÿÿÿÿÿœ55“5€vÿÿÿÿÿÿ¦5(5œ5€w>ÿÿÿÿÿÿ°5!-@xÿÿÿÿÿÿº5°5€y>ÿÿÿÿÿÿÃ5"Ú-@zÿÿÿÿÿÿÍ5Ã5€{ÿÿÿÿÿÿÖ5º5Í5€|>ÿÿÿÿÿÿà54.@}ÿÿÿÿÿÿê5à5€~ÿÿÿÿÿÿó5Ö5ê5€ÿÿÿÿÿÿý5ó5t/€€>ÿÿÿÿÿÿ6X#0@ÿÿÿÿÿÿ66€‚ÿÿÿÿÿÿ6ý56€ƒÿÿÿÿÿÿ$6¦56€„>ÿÿÿÿÿÿ.6H-@…ÿÿÿÿÿÿ86.6€†>ÿÿÿÿÿÿA6".@‡ÿÿÿÿÿÿK6A6€ˆÿÿÿÿÿÿT686K6€‰>ÿÿÿÿÿÿ^64Ä.@Šÿÿÿÿÿÿh6^6€‹ÿÿÿÿÿÿq6T6h6€Œ>ÿÿÿÿÿÿ{6F‡/@ÿÿÿÿÿÿ…6{6€ŽÿÿÿÿÿÿŽ6q6…6€ÿÿÿÿÿÿ˜6Ž6^0€ÿÿÿÿÿÿ¢6$6˜6€‘ÿÿÿÿÿÿ¬6w4€’ÿÿÿÿÿÿ¶6¦¬6€“ÿÿÿÿÿÿÀ6‰ú€”ÿÿÿÿÿÿÊ6¶6À6€•ÿÿÿÿÿÿÔ6›À€–ÿÿÿÿÿÿÞ6Ê6Ô6€—ÿÿÿÿÿÿè6­†€˜ÿÿÿÿÿÿò6Þ6è6€™ÿÿÿÿÿÿü6¯€šÿÿÿÿÿÿ7Kü6€›ÿÿÿÿÿÿ7¿0€œÿÿÿÿÿÿ777€ÿÿÿÿÿÿ$7Ñö€žÿÿÿÿÿÿ.77$7€Ÿÿÿÿÿÿÿ87ã¼€ ÿÿÿÿÿÿB7.787€¡ÿÿÿÿÿÿL7ò6B7€¢ÿÿÿÿÿÿV7Ès€£ÿÿÿÿÿÿ`7¥V7€¤ÿÿÿÿÿÿj7Âv€¥ÿÿÿÿÿÿt7`7j7€¦ÿÿÿÿÿÿ~7õ€§ÿÿÿÿÿÿˆ7t7~7€¨ÿÿÿÿÿÿ’7à€©ÿÿÿÿÿÿœ7ˆ7’7€ªÿÿÿÿÿÿ¦7L7œ7€«ÿÿÿÿÿÿ°7Ú…€¬ÿÿÿÿÿÿº7ÿ°7€­ÿÿÿÿÿÿÄ7þ]€®ÿÿÿÿÿÿÎ7º7Ä7€¯ÿÿÿÿÿÿØ7Õ耰ÿÿÿÿÿÿâ7Î7Ø7€±ÿÿÿÿÿÿì7ò€²ÿÿÿÿÿÿö7â7ì7€³ÿÿÿÿÿÿ8¦7ö7€´ÿÿÿÿÿÿ 8ì—€µÿÿÿÿÿÿ8Y 8€¶ÿÿÿÿÿÿ8o€·ÿÿÿÿÿÿ(888€¸ÿÿÿÿÿÿ28"5€¹ÿÿÿÿÿÿ<8(828€ºÿÿÿÿÿÿF8èZ€»ÿÿÿÿÿÿP8<8F8€¼ÿÿÿÿÿÿZ88P8€½ÿÿÿÿÿÿd8û¦€¾ÿÿÿÿÿÿn8d8³€¿ÿÿÿÿÿÿx8=ú€Àÿÿÿÿÿÿ‚8n8x8€ÁÿÿÿÿÿÿŒ8OÀ€Âÿÿÿÿÿÿ–8‚8Œ8€Ãÿÿÿÿÿÿ 8a†€Äÿÿÿÿÿÿª8–8 8€Åÿÿÿÿÿÿ´84w€Æÿÿÿÿÿÿ¾8´8€ÇÿÿÿÿÿÿÈ8s0€ÈÿÿÿÿÿÿÒ8¾8È8€ÉÿÿÿÿÿÿÜ8…ö€Êÿÿÿÿÿÿæ8Ò8Ü8€Ëÿÿÿÿÿÿð8—¼€Ìÿÿÿÿÿÿú8æ8ð8€Íÿÿÿÿÿÿ9ª8ú8€Îÿÿÿÿÿÿ9F‰€Ïÿÿÿÿÿÿ99g€Ðÿÿÿÿÿÿ"9v€Ñÿÿÿÿÿÿ,99"9€Òÿÿÿÿÿÿ69©€Óÿÿÿÿÿÿ@9,969€ÔÿÿÿÿÿÿJ9»à€ÕÿÿÿÿÿÿT9@9J9€Öÿÿÿÿÿÿ^99T9€×ÿÿÿÿÿÿh9X›€Øÿÿÿÿÿÿr9h9Á€Ùÿÿÿÿÿÿ|9²]€Úÿÿÿÿÿÿ†9r9|9€Ûÿÿÿÿÿÿ9*è€Üÿÿÿÿÿÿš9†99€Ýÿÿÿÿÿÿ¤9Íò€Þÿÿÿÿÿÿ®9š9¤9€ßÿÿÿÿÿÿ¸9^9®9€àÿÿÿÿÿÿÂ9j­€áÿÿÿÿÿÿÌ9Â9€âÿÿÿÿÿÿÖ9Äo€ãÿÿÿÿÿÿà9Ì9Ö9€äÿÿÿÿÿÿê9Ö5€åÿÿÿÿÿÿô9à9ê9€æÿÿÿÿÿÿþ9=Z€çÿÿÿÿÿÿ:ô9þ9€èÿÿÿÿÿÿ:¸9:€éÿÿÿÿÿÿ:Z8:€êÿÿÿÿÿÿ&:Z¦€ëÿÿÿÿÿÿ0:ß4€ìÿÿÿÿÿÿ::&:0:€íÿÿÿÿÿÿD:::‰€îÿÿÿÿÿÿN:À€ïÿÿÿÿÿÿX:D:N:€ðÿÿÿÿÿÿb:†€ñÿÿÿÿÿÿl:X:b:€òÿÿÿÿÿÿv:èw€óÿÿÿÿÿÿ€:c€ôÿÿÿÿÿÿŠ:v:€:€õÿÿÿÿÿÿ”:Š:Ù€öÿÿÿÿÿÿž:9ö€÷ÿÿÿÿÿÿ¨:”:ž:€øÿÿÿÿÿÿ²:K¼€ùÿÿÿÿÿÿ¼:¨:²:€úÿÿÿÿÿÿÆ:l:¼:€ûÿÿÿÿÿÿÐ:ú‰€üÿÿÿÿÿÿÚ:0s€ýÿÿÿÿÿÿä:Ð:Ú:€þÿÿÿÿÿÿî:ä:v€ÿÿÿÿÿÿÿø:]€ÿÿÿÿÿÿ;î:ø:€ÿÿÿÿÿÿ ;oà€ÿÿÿÿÿÿ;; ;€ÿÿÿÿÿÿ ;Æ:;€ÿÿÿÿÿÿ*; ›€ÿÿÿÿÿÿ4;B…€ÿÿÿÿÿÿ>;*;4;€ÿÿÿÿÿÿH;>;—€ÿÿÿÿÿÿR;‰è€ ÿÿÿÿÿÿ\;H;R;€ ÿÿÿÿÿÿf;ò€ ÿÿÿÿÿÿp;\;f;€ ÿÿÿÿÿÿz; ;p;€ ÿÿÿÿÿÿ„;­€ÿÿÿÿÿÿŽ;T—€ÿÿÿÿÿÿ˜;„;Ž;€ÿÿÿÿÿÿ¢;˜;ñ€ÿÿÿÿÿÿ¬;Š5€ÿÿÿÿÿÿ¶;¢;¬;€ÿÿÿÿÿÿÀ;œZ€ÿÿÿÿÿÿÊ;¶;À;€ÿÿÿÿÿÿÔ;z;Ê;€ÿÿÿÿÿÿÞ;:Ô;€ÿÿÿÿÿÿè;¹¦€ÿÿÿÿÿÿò;“4€ÿÿÿÿÿÿü;è;ò;€ÿÿÿÿÿÿ<¥ú€ÿÿÿÿÿÿ<ü;<€ÿÿÿÿÿÿ<<_€ÿÿÿÿÿÿ$<Ɇ€ÿÿÿÿÿÿ.<<$<€ÿÿÿÿÿÿ8<œw€ ÿÿÿÿÿÿB<€!ÿÿÿÿÿÿL<8<B<€"ÿÿÿÿÿÿV<Û0€#ÿÿÿÿÿÿ`<L<V<€$ÿÿÿÿÿÿj<`<¯€%ÿÿÿÿÿÿt<ÿ¼€&ÿÿÿÿÿÿ~<j<t<€'ÿÿÿÿÿÿˆ<.<~<€(ÿÿÿÿÿÿ’<®‰€)ÿÿÿÿÿÿœ<äs€*ÿÿÿÿÿÿ¦<’<œ<€+ÿÿÿÿÿÿ°<Õv€,ÿÿÿÿÿÿº<¦<°<€-ÿÿÿÿÿÿÄ<º< €.ÿÿÿÿÿÿÎ<#à€/ÿÿÿÿÿÿØ<Ä<Î<€0ÿÿÿÿÿÿâ<ˆ<Ø<€1ÿÿÿÿÿÿì<À›€2ÿÿÿÿÿÿö<ö…€3ÿÿÿÿÿÿ=ì<ö<€4ÿÿÿÿÿÿ =]€5ÿÿÿÿÿÿ== =€6ÿÿÿÿÿÿ==è€7ÿÿÿÿÿÿ(=5ò€8ÿÿÿÿÿÿ2==(=€9ÿÿÿÿÿÿ<=â<2=€:ÿÿÿÿÿÿF=Ò­€;ÿÿÿÿÿÿP=—€<ÿÿÿÿÿÿZ=F=P=€=ÿÿÿÿÿÿd=,o€>ÿÿÿÿÿÿn=Z=d=€?ÿÿÿÿÿÿx=n=Ç €@ÿÿÿÿÿÿ‚=ûZ€AÿÿÿÿÿÿŒ=x=‚=€Bÿÿÿÿÿÿ–=<=Œ=€Cÿÿÿÿÿÿ =Þ;–=€Dÿÿÿÿÿÿª=¦€Eÿÿÿÿÿÿ´=G4€Fÿÿÿÿÿÿ¾=ª=´=€GÿÿÿÿÿÿÈ=Yú€HÿÿÿÿÿÿÒ=¾=È=€IÿÿÿÿÿÿÜ=kÀ€Jÿÿÿÿÿÿæ=Ò=Ü=€Kÿÿÿÿÿÿð=æ=5!€Lÿÿÿÿÿÿú=Pw€Mÿÿÿÿÿÿ>!€Nÿÿÿÿÿÿ>ú=>€Oÿÿÿÿÿÿ>0€Pÿÿÿÿÿÿ">>>€Qÿÿÿÿÿÿ,>¡ö€Rÿÿÿÿÿÿ6>">,>€Sÿÿÿÿÿÿ@>6>…!€TÿÿÿÿÿÿJ>ð=@>€UÿÿÿÿÿÿT>b‰€Vÿÿÿÿÿÿ^>˜s€Wÿÿÿÿÿÿh>T>^>€Xÿÿÿÿÿÿr>4v€Yÿÿÿÿÿÿ|>h>r>€Zÿÿÿÿÿÿ†>Å€[ÿÿÿÿÿÿ>|>†>€\ÿÿÿÿÿÿš>>ß!€]ÿÿÿÿÿÿ¤>J>š>€^ÿÿÿÿÿÿ®>t›€_ÿÿÿÿÿÿ¸>ª…€`ÿÿÿÿÿÿÂ>®>¸>€aÿÿÿÿÿÿÌ>Î]€bÿÿÿÿÿÿÖ>Â>Ì>€cÿÿÿÿÿÿà>Gè€dÿÿÿÿÿÿê>Ö>à>€eÿÿÿÿÿÿô>ê>9"€fÿÿÿÿÿÿþ>¤>ô>€gÿÿÿÿÿÿ?†­€hÿÿÿÿÿÿ?¼—€iÿÿÿÿÿÿ???€jÿÿÿÿÿÿ&?ào€kÿÿÿÿÿÿ0??&?€lÿÿÿÿÿÿ:?ò5€mÿÿÿÿÿÿD?0?:?€nÿÿÿÿÿÿN?D?Z€oÿÿÿÿÿÿX?þ>N?€pÿÿÿÿÿÿb? =X?€qSÿÿÿÿÿÿl?*€r>ÿÿÿÿÿÿv?"l?€sÿÿÿÿÿÿ€?…0v?€tSÿÿÿÿÿÿŠ?<€u>ÿÿÿÿÿÿ”?4Š?€vÿÿÿÿÿÿž?€?”?€wSÿÿÿÿÿÿ¨?N€x>ÿÿÿÿÿÿ²?F¨?€yÿÿÿÿÿÿ¼?ž?²?€zSÿÿÿÿÿÿÆ?`€{>ÿÿÿÿÿÿÐ?XÆ?€|ÿÿÿÿÿÿÚ?¼?Ð?€}Sÿÿÿÿÿÿä?"j€~>ÿÿÿÿÿÿî?ä?€ÿÿÿÿÿÿø?î?[1€€Sÿÿÿÿÿÿ@"~€>ÿÿÿÿÿÿ @4@€‚ÿÿÿÿÿÿ@ø? @€ƒSÿÿÿÿÿÿ @"ˆ€„>ÿÿÿÿÿÿ*@F @€…ÿÿÿÿÿÿ4@@*@€†Sÿÿÿÿÿÿ>@"’€‡>ÿÿÿÿÿÿH@X>@€ˆÿÿÿÿÿÿR@4@H@€‰ÿÿÿÿÿÿ\@Ú?R@€ŠSÿÿÿÿÿÿf@4œ€‹>ÿÿÿÿÿÿp@f@€ŒSÿÿÿÿÿÿz@4¦€>ÿÿÿÿÿÿ„@"z@€ŽÿÿÿÿÿÿŽ@p@„@€ÿÿÿÿÿÿ˜@Ž@E2€Sÿÿÿÿÿÿ¢@4º€‘>ÿÿÿÿÿÿ¬@F¢@€’ÿÿÿÿÿÿ¶@˜@¬@€“SÿÿÿÿÿÿÀ@4Ä€”>ÿÿÿÿÿÿÊ@XÀ@€•ÿÿÿÿÿÿÔ@¶@Ê@€–ÿÿÿÿÿÿÞ@\@Ô@€—Sÿÿÿÿÿÿè@F΀˜>ÿÿÿÿÿÿò@è@€™Sÿÿÿÿÿÿü@FØ€š>ÿÿÿÿÿÿA"ü@€›ÿÿÿÿÿÿAò@A€œSÿÿÿÿÿÿAFâ€>ÿÿÿÿÿÿ$A4A€žÿÿÿÿÿÿ.AA$A€Ÿÿÿÿÿÿÿ8A.A/3€ SÿÿÿÿÿÿBAFö€¡>ÿÿÿÿÿÿLAXBA€¢ÿÿÿÿÿÿVA8ALA€£ÿÿÿÿÿÿ`AÞ@VA€¤SÿÿÿÿÿÿjAX€¥>ÿÿÿÿÿÿtAjA€¦Sÿÿÿÿÿÿ~AX €§>ÿÿÿÿÿÿˆA"~A€¨ÿÿÿÿÿÿ’AtAˆA€©SÿÿÿÿÿÿœAX€ª>ÿÿÿÿÿÿ¦A4œA€«ÿÿÿÿÿÿ°A’A¦A€¬SÿÿÿÿÿÿºAX€­>ÿÿÿÿÿÿÄAFºA€®ÿÿÿÿÿÿÎA°AÄA€¯ÿÿÿÿÿÿØAÎA4€°ÿÿÿÿÿÿâA`AØA€±SÿÿÿÿÿÿìA"€²>ÿÿÿÿÿÿöA"ìA@³ÿÿÿÿÿÿBöA€´ÿÿÿÿÿÿ B0B€µSÿÿÿÿÿÿB4€¶>ÿÿÿÿÿÿB4B@·ÿÿÿÿÿÿ'BB€¸ÿÿÿÿÿÿ0B B'B€¹Sÿÿÿÿÿÿ:BF€º>ÿÿÿÿÿÿDBF:B@»ÿÿÿÿÿÿNBDB€¼ÿÿÿÿÿÿWB0BNB€½SÿÿÿÿÿÿaBX€¾>ÿÿÿÿÿÿkBXaB@¿ÿÿÿÿÿÿuBkB€Àÿÿÿÿÿÿ~BWBuB€ÁSÿÿÿÿÿÿˆBt€Â>ÿÿÿÿÿÿ’BˆB@ÃÿÿÿÿÿÿœB’B€Äÿÿÿÿÿÿ¥BœBe1€ÅSÿÿÿÿÿÿ¯B4t€Æ>ÿÿÿÿÿÿ¹B4¯B@ÇÿÿÿÿÿÿÃB¹B€ÈÿÿÿÿÿÿÌB¥BÃB€ÉSÿÿÿÿÿÿÖBFt€Ê>ÿÿÿÿÿÿàBFÖB@ËÿÿÿÿÿÿêBàB€ÌÿÿÿÿÿÿóBÌBêB€ÍSÿÿÿÿÿÿýBXt€Î>ÿÿÿÿÿÿCXýB@ÏÿÿÿÿÿÿCC€ÐÿÿÿÿÿÿCóBC€Ñÿÿÿÿÿÿ$C~BC€ÒSÿÿÿÿÿÿ.C°€Ó>ÿÿÿÿÿÿ8C.C@ÔÿÿÿÿÿÿBC8C€ÕSÿÿÿÿÿÿKC"°€Ö>ÿÿÿÿÿÿUC"KC@×ÿÿÿÿÿÿ_CUC€ØÿÿÿÿÿÿhCBC_C€ÙÿÿÿÿÿÿrChCO2€ÚSÿÿÿÿÿÿ|CF°€Û>ÿÿÿÿÿÿ†CF|C@ÜÿÿÿÿÿÿC†C€Ýÿÿÿÿÿÿ™CrCC€ÞSÿÿÿÿÿÿ£CX°€ß>ÿÿÿÿÿÿ­CX£C@àÿÿÿÿÿÿ·C­C€áÿÿÿÿÿÿÀC™C·C€âÿÿÿÿÿÿÊC$CÀC€ãSÿÿÿÿÿÿÔCì€ä>ÿÿÿÿÿÿÞCÔC@åÿÿÿÿÿÿèCÞC€æSÿÿÿÿÿÿñC"ì€ç>ÿÿÿÿÿÿûC"ñC@èÿÿÿÿÿÿDûC€éÿÿÿÿÿÿDèCD€êSÿÿÿÿÿÿD4ì€ë>ÿÿÿÿÿÿ"D4D@ìÿÿÿÿÿÿ,D"D€íÿÿÿÿÿÿ5DD,D€îÿÿÿÿÿÿ?D5D93€ïSÿÿÿÿÿÿIDXì€ð>ÿÿÿÿÿÿSDXID@ñÿÿÿÿÿÿ]DSD€òÿÿÿÿÿÿfD?D]D€óÿÿÿÿÿÿpDÊCfD€ôSÿÿÿÿÿÿzD(€õ>ÿÿÿÿÿÿ„DzD@öÿÿÿÿÿÿŽD„D€÷Sÿÿÿÿÿÿ—D"(€ø>ÿÿÿÿÿÿ¡D"—D@ùÿÿÿÿÿÿ«D¡D€úÿÿÿÿÿÿ´DŽD«D€ûSÿÿÿÿÿÿ¾D4(€ü>ÿÿÿÿÿÿÈD4¾D@ýÿÿÿÿÿÿÒDÈD€þÿÿÿÿÿÿÛD´DÒD€ÿSÿÿÿÿÿÿåDF(€>ÿÿÿÿÿÿïDFåD@ÿÿÿÿÿÿùDïD€ÿÿÿÿÿÿEÛDùD€ÿÿÿÿÿÿ EE#4€ÿÿÿÿÿÿEpD E€ÿÿÿÿÿÿ E¦+€ÿÿÿÿÿÿ*E Eñ€ÿÿÿÿÿÿ4E*E·€ÿÿÿÿÿÿ>E4E}€ ÿÿÿÿÿÿHE€€ ÿÿÿÿÿÿREHE'€ ÿÿÿÿÿÿ\EREí€ ÿÿÿÿÿÿfE\E³€ ÿÿÿÿÿÿpE>EfE€ÿÿÿÿÿÿzE’|€ÿÿÿÿÿÿ„EzEv€ÿÿÿÿÿÿŽE„E€ÿÿÿÿÿÿ˜EŽE×€ÿÿÿÿÿÿ¢EpE˜E€ÿÿÿÿÿÿ¬E¤Ž€ÿÿÿÿÿÿ¶E¬Ef€ÿÿÿÿÿÿÀE¶Eè€ÿÿÿÿÿÿÊEÀEé€ÿÿÿÿÿÿÔE¢EÊE€ÿÿÿÿÿÿÞE¶ €ÿÿÿÿÿÿèEÞEx€ÿÿÿÿÿÿòEèE>€ÿÿÿÿÿÿüEòEZ€ÿÿÿÿÿÿFÔEüE€ÿÿÿÿÿÿF¦2€ÿÿÿÿÿÿFw€ÿÿÿÿÿÿ$FFF€ ÿÿÿÿÿÿ.F‰€!ÿÿÿÿÿÿ8F$F.F€"ÿÿÿÿÿÿBF›€#ÿÿÿÿÿÿLF8FBF€$ÿÿÿÿÿÿVF­ø€%ÿÿÿÿÿÿ`FLFVF€&ÿÿÿÿÿÿjF€Œ€'ÿÿÿÿÿÿtF¯v€(ÿÿÿÿÿÿ~FjFtF€)ÿÿÿÿÿÿˆF¿j€*ÿÿÿÿÿÿ’F~FˆF€+ÿÿÿÿÿÿœFÑ^€,ÿÿÿÿÿÿ¦F’FœF€-ÿÿÿÿÿÿ°FãR €.ÿÿÿÿÿÿºF¦F°F€/ÿÿÿÿÿÿÄF`FºF€0ÿÿÿÿÿÿÎF’ð€1ÿÿÿÿÿÿØFÈÚ€2ÿÿÿÿÿÿâFÎFØF€3ÿÿÿÿÿÿìFÂ΀4ÿÿÿÿÿÿöFâFìF€5ÿÿÿÿÿÿGõ€6ÿÿÿÿÿÿ GöFG€7ÿÿÿÿÿÿG¶ €8ÿÿÿÿÿÿG GG€9ÿÿÿÿÿÿ(GÄFG€:ÿÿÿÿÿÿ2G¤T€;ÿÿÿÿÿÿ€<ÿÿÿÿÿÿFG2GÿÿÿÿÿÿZGFGPG€?ÿÿÿÿÿÿdGÕ&€@ÿÿÿÿÿÿnGZGdG€AÿÿÿÿÿÿxG €Bÿÿÿÿÿÿ‚GnGxG€CÿÿÿÿÿÿŒG(G‚G€Dÿÿÿÿÿÿ–G¶¸€Eÿÿÿÿÿÿ G좀FÿÿÿÿÿÿªG–G G€Gÿÿÿÿÿÿ´G–€Hÿÿÿÿÿÿ¾GªG´G€IÿÿÿÿÿÿÈG"Š€JÿÿÿÿÿÿÒG¾GÈG€KÿÿÿÿÿÿÜGè~ €LÿÿÿÿÿÿæGÒGÜG€MÿÿÿÿÿÿðGŒGæG€NÿÿÿÿÿÿúGû<€OÿÿÿÿÿÿH+&€PÿÿÿÿÿÿHúGH€QÿÿÿÿÿÿH=€Rÿÿÿÿÿÿ"HHH€Sÿÿÿÿÿÿ,HO€Tÿÿÿÿÿÿ6H"H,H€Uÿÿÿÿÿÿ@Ha €VÿÿÿÿÿÿJH6H@H€WÿÿÿÿÿÿTH4–€Xÿÿÿÿÿÿ^H€€YÿÿÿÿÿÿhHTH^H€ZÿÿÿÿÿÿrHst€[ÿÿÿÿÿÿ|HhHrH€\ÿÿÿÿÿÿ†H…h€]ÿÿÿÿÿÿH|H†H€^ÿÿÿÿÿÿšH—\ €_ÿÿÿÿÿÿ¤HHšH€`ÿÿÿÿÿÿ®HJH¤H€aÿÿÿÿÿÿ¸HFú€bÿÿÿÿÿÿÂH|ä€cÿÿÿÿÿÿÌH¸HÂH€dÿÿÿÿÿÿÖHØ€eÿÿÿÿÿÿàHÌHÖH€fÿÿÿÿÿÿêH©Ì€gÿÿÿÿÿÿôHàHêH€hÿÿÿÿÿÿþH»À €iÿÿÿÿÿÿIôHþH€jÿÿÿÿÿÿI®HI€kÿÿÿÿÿÿIX^€lÿÿÿÿÿÿ&IŽH€mÿÿÿÿÿÿ0II&I€nÿÿÿÿÿÿ:I²<€oÿÿÿÿÿÿDI0I:I€pÿÿÿÿÿÿNI*0€qÿÿÿÿÿÿXIDINI€rÿÿÿÿÿÿbIÍ$ €sÿÿÿÿÿÿlIXIbI€tÿÿÿÿÿÿvIIlI€uÿÿÿÿÿÿ€Ij€vÿÿÿÿÿÿŠI ¬€wÿÿÿÿÿÿ”I€IŠI€xÿÿÿÿÿÿžIÄ €yÿÿÿÿÿÿ¨I”IžI€zÿÿÿÿÿÿ²IÖ”€{ÿÿÿÿÿÿ¼I¨I²I€|ÿÿÿÿÿÿÆI=ˆ €}ÿÿÿÿÿÿÐI¼IÆI€~ÿÿÿÿÿÿÚIvIÐI€ÿÿÿÿÿÿäIðGÚI€€ÿÿÿÿÿÿîIZP€ÿÿÿÿÿÿøIß:€‚ÿÿÿÿÿÿJîIøI€ƒÿÿÿÿÿÿ Jñ.€„ÿÿÿÿÿÿJJ J€…ÿÿÿÿÿÿ J"€†ÿÿÿÿÿÿ*JJ J€‡ÿÿÿÿÿÿ4J €ˆÿÿÿÿÿÿ>J*J4J€‰ÿÿÿÿÿÿHJ誀ŠÿÿÿÿÿÿRJc”€‹ÿÿÿÿÿÿ\JHJRJ€ŒÿÿÿÿÿÿfJ'ˆ€ÿÿÿÿÿÿpJ\JfJ€ŽÿÿÿÿÿÿzJ9|€ÿÿÿÿÿÿ„JpJzJ€ÿÿÿÿÿÿŽJKp €‘ÿÿÿÿÿÿ˜J„JŽJ€’ÿÿÿÿÿÿ¢J>J˜J€“ÿÿÿÿÿÿ¬Jú€”ÿÿÿÿÿÿ¶J0ø€•ÿÿÿÿÿÿÀJ¬J¶J€–ÿÿÿÿÿÿÊJv쀗ÿÿÿÿÿÿÔJÀJÊJ€˜ÿÿÿÿÿÿÞJ]à€™ÿÿÿÿÿÿèJÔJÞJ€šÿÿÿÿÿÿòJoÔ €›ÿÿÿÿÿÿüJèJòJ€œÿÿÿÿÿÿK¢JüJ€ÿÿÿÿÿÿK r€žÿÿÿÿÿÿKB\€Ÿÿÿÿÿÿÿ$KKK€ ÿÿÿÿÿÿ.KfP€¡ÿÿÿÿÿÿ8K$K.K€¢ÿÿÿÿÿÿBK‰D€£ÿÿÿÿÿÿLK8KBK€¤ÿÿÿÿÿÿVK8 €¥ÿÿÿÿÿÿ`KLKVK€¦ÿÿÿÿÿÿjKK`K€§ÿÿÿÿÿÿtKÖ€¨ÿÿÿÿÿÿ~KTÀ€©ÿÿÿÿÿÿˆKtK~K€ªÿÿÿÿÿÿ’Kx´€«ÿÿÿÿÿÿœKˆK’K€¬ÿÿÿÿÿÿ¦KŠ¨€­ÿÿÿÿÿÿ°KœK¦K€®ÿÿÿÿÿÿºKœœ €¯ÿÿÿÿÿÿÄK°KºK€°ÿÿÿÿÿÿÎKjKÄK€±ÿÿÿÿÿÿØKäIÎK€²ÿÿÿÿÿÿâK¹d€³ÿÿÿÿÿÿìK“N€´ÿÿÿÿÿÿöKâKìK€µÿÿÿÿÿÿL¥B€¶ÿÿÿÿÿÿ LöKL€·ÿÿÿÿÿÿL·6€¸ÿÿÿÿÿÿL LL€¹ÿÿÿÿÿÿ(LÉ* €ºÿÿÿÿÿÿ2LL(L€»ÿÿÿÿÿÿ¼€ßÿÿÿÿÿÿ¤MMšM€àÿÿÿÿÿÿ®Mû° €áÿÿÿÿÿÿ¸M¤M®M€âÿÿÿÿÿÿÂM^M¸M€ãÿÿÿÿÿÿÌMØKÂM€äÿÿÿÿÿÿÖMx€åÿÿÿÿÿÿàMGb€æÿÿÿÿÿÿêMÖMàM€çÿÿÿÿÿÿôMYV€èÿÿÿÿÿÿþMêMôM€éÿÿÿÿÿÿNkJ€êÿÿÿÿÿÿNþMN€ëÿÿÿÿÿÿN}> €ìÿÿÿÿÿÿ&NNN€íÿÿÿÿÿÿ0NPÒ€îÿÿÿÿÿÿ:N!¼€ïÿÿÿÿÿÿDN0N:N€ðÿÿÿÿÿÿNN°€ñÿÿÿÿÿÿXNDNNN€òÿÿÿÿÿÿbN¡¤€óÿÿÿÿÿÿlNXNbN€ôÿÿÿÿÿÿvN³˜ €õÿÿÿÿÿÿ€NlNvN€öÿÿÿÿÿÿŠN&N€N€÷ÿÿÿÿÿÿ”Nb6€øÿÿÿÿÿÿžN˜ €ùÿÿÿÿÿÿ¨N”NžN€úÿÿÿÿÿÿ²N4€ûÿÿÿÿÿÿ¼N¨N²N€üÿÿÿÿÿÿÆNÅ€ýÿÿÿÿÿÿÐN¼NÆN€þÿÿÿÿÿÿÚN×ü €ÿÿÿÿÿÿÿäNÐNÚN€ÿÿÿÿÿÿîNŠNäN€ÿÿÿÿÿÿøNtš€ÿÿÿÿÿÿOª„€ÿÿÿÿÿÿ OøNO€ÿÿÿÿÿÿOÎx€ÿÿÿÿÿÿ O OO€ÿÿÿÿÿÿ*OGl€ÿÿÿÿÿÿ4O O*O€ÿÿÿÿÿÿ>Oé` € ÿÿÿÿÿÿHO4O>O€ ÿÿÿÿÿÿROîNHO€ ÿÿÿÿÿÿ\O†þ€ ÿÿÿÿÿÿfO¼è€ ÿÿÿÿÿÿpO\OfO€ÿÿÿÿÿÿzOàÜ€ÿÿÿÿÿÿ„OpOzO€ÿÿÿÿÿÿŽOòЀÿÿÿÿÿÿ˜O„OŽO€ÿÿÿÿÿÿ¢OZÄ €ÿÿÿÿÿÿ¬O˜O¢O€ÿÿÿÿÿÿ¶ORO¬O€ÿÿÿÿÿÿÀOÌM¶O€ÿÿÿÿÿÿÊO2¦€ÿÿÿÿÿÿÔOŒû€ÿÿÿÿÿÿÞOÊOÔO€ÿÿÿÿÿÿèOðZ€ÿÿÿÿÿÿòOÞOèO€ÿÿÿÿÿÿüOT¹€ÿÿÿÿÿÿPòOüO€ÿÿÿÿÿÿP¸€ÿÿÿÿÿÿPPP€ÿÿÿÿÿÿ$P€€ ÿÿÿÿÿÿ.Pv4€!ÿÿÿÿÿÿ8P$P.P€"ÿÿÿÿÿÿBPÚè€#ÿÿÿÿÿÿLP8PBP€$ÿÿÿÿÿÿVP>œ€%ÿÿÿÿÿÿ`PLPVP€&ÿÿÿÿÿÿjP¢P€'ÿÿÿÿÿÿtP`PjP€(ÿÿÿÿÿÿ~PPtP€)ÿÿÿÿÿÿˆP’€*ÿÿÿÿÿÿ’PjF€+ÿÿÿÿÿÿœPˆP’P€,ÿÿÿÿÿÿ¦PÎú€-ÿÿÿÿÿÿ°PœP¦P€.ÿÿÿÿÿÿºP2®€/ÿÿÿÿÿÿÄP°PºP€0ÿÿÿÿÿÿÎP–b€1ÿÿÿÿÿÿØPÄPÎP€2ÿÿÿÿÿÿâP~PØP€3ÿÿÿÿÿÿìP¤€4ÿÿÿÿÿÿöP^X€5ÿÿÿÿÿÿQìPöP€6ÿÿÿÿÿÿ Q €7ÿÿÿÿÿÿQQ Q€8ÿÿÿÿÿÿQ&À€9ÿÿÿÿÿÿ(QQQ€:ÿÿÿÿÿÿ2QŠt€;ÿÿÿÿÿÿÿÿÿÿÿÿZQR j€?ÿÿÿÿÿÿdQPQZQ€@ÿÿÿÿÿÿnQ¶ €AÿÿÿÿÿÿxQdQnQ€Bÿÿÿÿÿÿ‚Q Ò€CÿÿÿÿÿÿŒQxQ‚Q€Dÿÿÿÿÿÿ–Q~ †€Eÿÿÿÿÿÿ QŒQ–Q€FÿÿÿÿÿÿªQFQ Q€Gÿÿÿÿÿÿ´Q<w€Hÿÿÿÿÿÿ¾Q–+€IÿÿÿÿÿÿÈQ´Q¾Q€JÿÿÿÿÿÿÒQú߀KÿÿÿÿÿÿÜQÈQÒQ€LÿÿÿÿÿÿæQ^“€MÿÿÿÿÿÿðQÜQæQ€NÿÿÿÿÿÿúQÂG€OÿÿÿÿÿÿRðQúQ€PÿÿÿÿÿÿR&¯€QÿÿÿÿÿÿR€€Rÿÿÿÿÿÿ"RRR€Sÿÿÿÿÿÿ,Räc€Tÿÿÿÿÿÿ6R"R,R€Uÿÿÿÿÿÿ@RH€VÿÿÿÿÿÿJR6R@R€WÿÿÿÿÿÿTR¬!€Xÿÿÿÿÿÿ^RJRTR€YÿÿÿÿÿÿhRR^R€ZÿÿÿÿÿÿrRÈ€[ÿÿÿÿÿÿ|Rt|€\ÿÿÿÿÿÿ†RrR|R€]ÿÿÿÿÿÿRØ0€^ÿÿÿÿÿÿšR†RR€_ÿÿÿÿÿÿ¤R<ä€`ÿÿÿÿÿÿ®RšR¤R€aÿÿÿÿÿÿ¸R ˜€bÿÿÿÿÿÿÂR®R¸R€cÿÿÿÿÿÿÌRhRÂR€dÿÿÿÿÿÿÖRÚ€eÿÿÿÿÿÿàRhŽ€fÿÿÿÿÿÿêRÖRàR€gÿÿÿÿÿÿôRÌB€hÿÿÿÿÿÿþRêRôR€iÿÿÿÿÿÿS0ö€jÿÿÿÿÿÿSþRS€kÿÿÿÿÿÿS”ª€lÿÿÿÿÿÿ&SSS€mÿÿÿÿÿÿ0SÌR&S€nÿÿÿÿÿÿ:S ì€oÿÿÿÿÿÿDS\  €pÿÿÿÿÿÿNS:SDS€qÿÿÿÿÿÿXSÀ T€rÿÿÿÿÿÿbSNSXS€sÿÿÿÿÿÿlS$ €tÿÿÿÿÿÿvSbSlS€uÿÿÿÿÿÿ€Sˆ ¼€vÿÿÿÿÿÿŠSvS€S€wÿÿÿÿÿÿ”S0SŠS€xÿÿÿÿÿÿžSªQ”S€yÿÿÿÿÿÿ¨SP‰€zÿÿÿÿÿÿ²Sª=€{ÿÿÿÿÿÿ¼S¨S²S€|ÿÿÿÿÿÿÆSñ€}ÿÿÿÿÿÿÐS¼SÆS€~ÿÿÿÿÿÿÚSr¥€ÿÿÿÿÿÿäSÐSÚS€€ÿÿÿÿÿÿîSÖY€ÿÿÿÿÿÿøSäSîS€‚ÿÿÿÿÿÿT:¿€ƒÿÿÿÿÿÿ T”s€„ÿÿÿÿÿÿTT T€…ÿÿÿÿÿÿ Tø'€†ÿÿÿÿÿÿ*TT T€‡ÿÿÿÿÿÿ4T\Û€ˆÿÿÿÿÿÿ>T*T4T€‰ÿÿÿÿÿÿHTÀ€ŠÿÿÿÿÿÿRT>THT€‹ÿÿÿÿÿÿ\TøSRT€ŒÿÿÿÿÿÿfT.€ÿÿÿÿÿÿpTˆ€ŽÿÿÿÿÿÿzTfTpT€ÿÿÿÿÿÿ„Tìv€ÿÿÿÿÿÿŽTzT„T€‘ÿÿÿÿÿÿ˜TPÕ€’ÿÿÿÿÿÿ¢TŽT˜T€“ÿÿÿÿÿÿ¬T´4€”ÿÿÿÿÿÿ¶T¢T¬T€•ÿÿÿÿÿÿÀT\T¶T€–ÿÿÿÿÿÿÊT"þ€—ÿÿÿÿÿÿÔT|²€˜ÿÿÿÿÿÿÞTÊTÔT€™ÿÿÿÿÿÿèTàf€šÿÿÿÿÿÿòTÞTèT€›ÿÿÿÿÿÿüTD€œÿÿÿÿÿÿUòTüT€ÿÿÿÿÿÿU¨Î€žÿÿÿÿÿÿUUU€Ÿÿÿÿÿÿÿ$UÀTU€ ÿÿÿÿÿÿ.U €¡ÿÿÿÿÿÿ8Up Ä€¢ÿÿÿÿÿÿBU.U8U€£ÿÿÿÿÿÿLUÔ x€¤ÿÿÿÿÿÿVUBULU€¥ÿÿÿÿÿÿ`U8 ,€¦ÿÿÿÿÿÿjUVU`U€§ÿÿÿÿÿÿtUœ à€¨ÿÿÿÿÿÿ~UjUtU€©ÿÿÿÿÿÿˆU$U~U€ªÿÿÿÿÿÿ’UžSˆU€«ÿÿÿÿÿÿœUd›€¬ÿÿÿÿÿÿ¦U¾O€­ÿÿÿÿÿÿ°UœU¦U€®ÿÿÿÿÿÿºU"€¯ÿÿÿÿÿÿÄU°UºU€°ÿÿÿÿÿÿÎU†·€±ÿÿÿÿÿÿØUÄUÎU€²ÿÿÿÿÿÿâUêk€³ÿÿÿÿÿÿìUØUâU€´ÿÿÿÿÿÿöUNÑ€µÿÿÿÿÿÿV¨…€¶ÿÿÿÿÿÿ VöUV€·ÿÿÿÿÿÿV 9€¸ÿÿÿÿÿÿV VV€¹ÿÿÿÿÿÿ(Vp퀺ÿÿÿÿÿÿ2VV(V€»ÿÿÿÿÿÿ€Øÿÿÿÿÿÿ^WJWTW€ÙÿÿÿÿÿÿhW° ò€ÚÿÿÿÿÿÿrW^WhW€Ûÿÿÿÿÿÿ|WWrW€Üÿÿÿÿÿÿ†W’U|W€ÝÿÿÿÿÿÿWx­€ÞÿÿÿÿÿÿšWÒa€ßÿÿÿÿÿÿ¤WWšW€àÿÿÿÿÿÿ®W6€áÿÿÿÿÿÿ¸W¤W®W€âÿÿÿÿÿÿÂWšÉ€ãÿÿÿÿÿÿÌW¸WÂW€äÿÿÿÿÿÿÖWþ}€åÿÿÿÿÿÿàWÌWÖW€æÿÿÿÿÿÿêWbã€çÿÿÿÿÿÿôW¼—€èÿÿÿÿÿÿþWêWôW€éÿÿÿÿÿÿX K€êÿÿÿÿÿÿXþWX€ëÿÿÿÿÿÿX„ÿ€ìÿÿÿÿÿÿ&XXX€íÿÿÿÿÿÿ0Xè³€îÿÿÿÿÿÿ:X&X0X€ïÿÿÿÿÿÿDXàW:X€ðÿÿÿÿÿÿNXV€ñÿÿÿÿÿÿXX°»€òÿÿÿÿÿÿbXNXXX€óÿÿÿÿÿÿlXo€ôÿÿÿÿÿÿvXbXlX€õÿÿÿÿÿÿ€Xx#€öÿÿÿÿÿÿŠXvX€X€÷ÿÿÿÿÿÿ”XÜ×€øÿÿÿÿÿÿžXŠX”X€ùÿÿÿÿÿÿ¨XDXžX€úÿÿÿÿÿÿ²XJ€ûÿÿÿÿÿÿ¼X¤Í€üÿÿÿÿÿÿÆX²X¼X€ýÿÿÿÿÿÿÐX€þÿÿÿÿÿÿÚXÆXÐX€ÿÿÿÿÿÿÿäXl5€ ÿÿÿÿÿÿîXÚXäX€ ÿÿÿÿÿÿøXÐé€ ÿÿÿÿÿÿYîXøX€ ÿÿÿÿÿÿ Y¨XY€ ÿÿÿÿÿÿY> è€ ÿÿÿÿÿÿ Y˜ =€ ÿÿÿÿÿÿ*YY Y€ ÿÿÿÿÿÿ4Yü œ€ ÿÿÿÿÿÿ>Y*Y4Y€ ÿÿÿÿÿÿHY` û€ ÿÿÿÿÿÿRY>YHY€ ÿÿÿÿÿÿ\YÄ Z€ ÿÿÿÿÿÿfYRY\Y€ ÿÿÿÿÿÿpY YfY€ ÿÿÿÿÿÿzY†WpY€ ÿÿÿÿÿÿ„Y÷"X'€ ÿÿÿÿÿÿŽY„Yþ'€ ÿÿÿÿÿÿ˜YŽY¤(€ ÿÿÿÿÿÿ¢Y˜YJ)€ ÿÿÿÿÿÿ¬Y¼&Í#€ ÿÿÿÿÿÿ¶Y¬Y(€ ÿÿÿÿÿÿÀY¶YÁ(€ ÿÿÿÿÿÿÊYÀYg)€ ÿÿÿÿÿÿÔY¢YÊY€ ÿÿÿÿÿÿÞYã&'€ ÿÿÿÿÿÿèYÞY·$€ ÿÿÿÿÿÿòYèYè(€ ÿÿÿÿÿÿüYòYŽ)€ ÿÿÿÿÿÿZÔYüY€ ÿÿÿÿÿÿZ '¦'€ ÿÿÿÿÿÿZZL(€ ÿÿÿÿÿÿ$ZZ¡%€ ÿÿÿÿÿÿ.Z$Zµ)€! ÿÿÿÿÿÿ8ZZ.Z€" ÿÿÿÿÿÿBZ1'Í'€# ÿÿÿÿÿÿLZBZs(€$ ÿÿÿÿÿÿVZLZ)€% ÿÿÿÿÿÿ`ZVZ‹&€& ÿÿÿÿÿÿjZ8Z`Z€' >ÿÿÿÿÿÿtZj@( ÿÿÿÿÿÿ~ZtZ€) >ÿÿÿÿÿÿ‡Zœ@* ÿÿÿÿÿÿ‘Z‡Z€+ ÿÿÿÿÿÿšZ~Z‘Z€, >ÿÿÿÿÿÿ¤ZÎ@- ÿÿÿÿÿÿ®Z¤Z€. ÿÿÿÿÿÿ·ZšZ®Z€/ >ÿÿÿÿÿÿÁZ@0 ÿÿÿÿÿÿËZÁZ€1 ÿÿÿÿÿÿÔZ·ZËZ€2 >ÿÿÿÿÿÿÞZjœ@3 ÿÿÿÿÿÿèZÞZ€4 ÿÿÿÿÿÿñZÔZèZ€5 >ÿÿÿÿÿÿûZjÎ@6 ÿÿÿÿÿÿ[ûZ€7 ÿÿÿÿÿÿ[ñZ[€8 >ÿÿÿÿÿÿ[j@9 ÿÿÿÿÿÿ"[[€: ÿÿÿÿÿÿ+[["[€; >ÿÿÿÿÿÿ5[œÎ@< ÿÿÿÿÿÿ?[5[€= ÿÿÿÿÿÿH[+[?[€> >ÿÿÿÿÿÿR[œ@? ÿÿÿÿÿÿ\[R[€@ ÿÿÿÿÿÿe[H[\[€A >ÿÿÿÿÿÿo[Î@B ÿÿÿÿÿÿy[o[€C ÿÿÿÿÿÿ‚[e[y[€D >ÿÿÿÿÿÿŒ[*t@E ÿÿÿÿÿÿ–[Œ[€F >ÿÿÿÿÿÿŸ[*¦@G ÿÿÿÿÿÿ©[Ÿ[€H ÿÿÿÿÿÿ²[–[©[€I >ÿÿÿÿÿÿ¼[*Ø@J ÿÿÿÿÿÿÆ[¼[€K ÿÿÿÿÿÿÏ[²[Æ[€L >ÿÿÿÿÿÿÙ[* @M ÿÿÿÿÿÿã[Ù[€N ÿÿÿÿÿÿì[Ï[ã[€O >ÿÿÿÿÿÿö[t¦@P ÿÿÿÿÿÿ\ö[€Q ÿÿÿÿÿÿ \ì[\€R >ÿÿÿÿÿÿ\tØ@S ÿÿÿÿÿÿ\\€T ÿÿÿÿÿÿ&\ \\€U >ÿÿÿÿÿÿ0\t @V ÿÿÿÿÿÿ:\0\€W ÿÿÿÿÿÿC\&\:\€X >ÿÿÿÿÿÿM\¦Ø@Y ÿÿÿÿÿÿW\M\€Z ÿÿÿÿÿÿ`\C\W\€[ >ÿÿÿÿÿÿj\¦ @\ ÿÿÿÿÿÿt\j\€] ÿÿÿÿÿÿ}\`\t\€^ >ÿÿÿÿÿÿ‡\Ø @_ ÿÿÿÿÿÿ‘\‡\€` ÿÿÿÿÿÿš\}\‘\€a ÿÿÿÿÿÿ¤\‚[š\€b >ÿÿÿÿÿÿ®\<~@c ÿÿÿÿÿÿ¸\®\€d >ÿÿÿÿÿÿÁ\<°@e ÿÿÿÿÿÿË\Á\€f ÿÿÿÿÿÿÔ\¸\Ë\€g >ÿÿÿÿÿÿÞ\<â@h ÿÿÿÿÿÿè\Þ\€i ÿÿÿÿÿÿñ\Ô\è\€j >ÿÿÿÿÿÿû\<@k ÿÿÿÿÿÿ]û\€l ÿÿÿÿÿÿ]ñ\]€m >ÿÿÿÿÿÿ]~°@n ÿÿÿÿÿÿ"]]€o ÿÿÿÿÿÿ+]]"]€p >ÿÿÿÿÿÿ5]~â@q ÿÿÿÿÿÿ?]5]€r ÿÿÿÿÿÿH]+]?]€s >ÿÿÿÿÿÿR]~@t ÿÿÿÿÿÿ\]R]€u ÿÿÿÿÿÿe]H]\]€v >ÿÿÿÿÿÿo]°â@w ÿÿÿÿÿÿy]o]€x ÿÿÿÿÿÿ‚]e]y]€y >ÿÿÿÿÿÿŒ]°@z ÿÿÿÿÿÿ–]Œ]€{ ÿÿÿÿÿÿŸ]‚]–]€| >ÿÿÿÿÿÿ©]â@} ÿÿÿÿÿÿ³]©]€~ ÿÿÿÿÿÿ¼]Ÿ]³]€ ÿÿÿÿÿÿÆ]¤\¼]€€ >ÿÿÿÿÿÿÐ]Nˆ@ ÿÿÿÿÿÿÚ]Ð]€‚ >ÿÿÿÿÿÿã]Nº@ƒ ÿÿÿÿÿÿí]ã]€„ ÿÿÿÿÿÿö]Ú]í]€… >ÿÿÿÿÿÿ^Nì@† ÿÿÿÿÿÿ ^^€‡ ÿÿÿÿÿÿ^ö] ^€ˆ >ÿÿÿÿÿÿ^N@‰ ÿÿÿÿÿÿ'^^€Š ÿÿÿÿÿÿ0^^'^€‹ >ÿÿÿÿÿÿ:^ˆº@Œ ÿÿÿÿÿÿD^:^€ ÿÿÿÿÿÿM^0^D^€Ž >ÿÿÿÿÿÿW^ˆì@ ÿÿÿÿÿÿa^W^€ ÿÿÿÿÿÿj^M^a^€‘ >ÿÿÿÿÿÿt^ˆ@’ ÿÿÿÿÿÿ~^t^€“ ÿÿÿÿÿÿ‡^j^~^€” >ÿÿÿÿÿÿ‘^ºì@• ÿÿÿÿÿÿ›^‘^€– ÿÿÿÿÿÿ¤^‡^›^€— >ÿÿÿÿÿÿ®^º@˜ ÿÿÿÿÿÿ¸^®^€™ ÿÿÿÿÿÿÁ^¤^¸^€š >ÿÿÿÿÿÿË^ì@› ÿÿÿÿÿÿÕ^Ë^€œ ÿÿÿÿÿÿÞ^Á^Õ^€ ÿÿÿÿÿÿè^Æ]Þ^€ž >ÿÿÿÿÿÿò^`’@Ÿ ÿÿÿÿÿÿü^ò^€  >ÿÿÿÿÿÿ_`Ä@¡ ÿÿÿÿÿÿ__€¢ ÿÿÿÿÿÿ_ü^_€£ >ÿÿÿÿÿÿ"_`ö@¤ ÿÿÿÿÿÿ,_"_€¥ ÿÿÿÿÿÿ5__,_€¦ >ÿÿÿÿÿÿ?_`(@§ ÿÿÿÿÿÿI_?_€¨ ÿÿÿÿÿÿR_5_I_€© >ÿÿÿÿÿÿ\_’Ä@ª ÿÿÿÿÿÿf_\_€« ÿÿÿÿÿÿo_R_f_€¬ >ÿÿÿÿÿÿy_’ö@­ ÿÿÿÿÿÿƒ_y_€® ÿÿÿÿÿÿŒ_o_ƒ_€¯ >ÿÿÿÿÿÿ–_’(@° ÿÿÿÿÿÿ _–_€± ÿÿÿÿÿÿ©_Œ_ _€² >ÿÿÿÿÿÿ³_Äö@³ ÿÿÿÿÿÿ½_³_€´ ÿÿÿÿÿÿÆ_©_½_€µ >ÿÿÿÿÿÿÐ_Ä(@¶ ÿÿÿÿÿÿÚ_Ð_€· ÿÿÿÿÿÿã_Æ_Ú_€¸ >ÿÿÿÿÿÿí_ö(@¹ ÿÿÿÿÿÿ÷_í_€º ÿÿÿÿÿÿ`ã_÷_€» ÿÿÿÿÿÿ `è^`€¼ >ÿÿÿÿÿÿ`*@½ ÿÿÿÿÿÿ``€¾ >ÿÿÿÿÿÿ'`<@¿ ÿÿÿÿÿÿ1`'`€À ÿÿÿÿÿÿ:``1`€Á >ÿÿÿÿÿÿD`N@ ÿÿÿÿÿÿN`D`€Ã ÿÿÿÿÿÿW`:`N`€Ä >ÿÿÿÿÿÿa``@Å ÿÿÿÿÿÿk`a`€Æ ÿÿÿÿÿÿt`W`k`€Ç >ÿÿÿÿÿÿ~`*<@È ÿÿÿÿÿÿˆ`~`€É ÿÿÿÿÿÿ‘`t`ˆ`€Ê >ÿÿÿÿÿÿ›`*N@Ë ÿÿÿÿÿÿ¥`›`€Ì ÿÿÿÿÿÿ®`‘`¥`€Í >ÿÿÿÿÿÿ¸`*`@Î ÿÿÿÿÿÿÂ`¸`€Ï ÿÿÿÿÿÿË`®`Â`€Ð >ÿÿÿÿÿÿÕ`<N@Ñ ÿÿÿÿÿÿß`Õ`€Ò ÿÿÿÿÿÿè`Ë`ß`€Ó >ÿÿÿÿÿÿò`<`@Ô ÿÿÿÿÿÿü`ò`€Õ ÿÿÿÿÿÿaè`ü`€Ö >ÿÿÿÿÿÿaN`@× ÿÿÿÿÿÿaa€Ø ÿÿÿÿÿÿ"aaa€Ù >ÿÿÿÿÿÿ,ajt@Ú ÿÿÿÿÿÿ6a,a€Û >ÿÿÿÿÿÿ?aj~@Ü ÿÿÿÿÿÿIa?a€Ý ÿÿÿÿÿÿRa6aIa€Þ >ÿÿÿÿÿÿ\ajˆ@ß ÿÿÿÿÿÿfa\a€à ÿÿÿÿÿÿoaRafa€á >ÿÿÿÿÿÿyaj’@â ÿÿÿÿÿÿƒaya€ã ÿÿÿÿÿÿŒaoaƒa€ä >ÿÿÿÿÿÿ–at~@å ÿÿÿÿÿÿ a–a€æ ÿÿÿÿÿÿ©aŒa a€ç >ÿÿÿÿÿÿ³atˆ@è ÿÿÿÿÿÿ½a³a€é ÿÿÿÿÿÿÆa©a½a€ê >ÿÿÿÿÿÿÐat’@ë ÿÿÿÿÿÿÚaÐa€ì ÿÿÿÿÿÿãaÆaÚa€í >ÿÿÿÿÿÿía~ˆ@î ÿÿÿÿÿÿ÷aía€ï ÿÿÿÿÿÿbãa÷a€ð >ÿÿÿÿÿÿ b~’@ñ ÿÿÿÿÿÿb b€ò ÿÿÿÿÿÿbbb€ó >ÿÿÿÿÿÿ'bˆ’@ô ÿÿÿÿÿÿ1b'b€õ ÿÿÿÿÿÿ:bb1b€ö ÿÿÿÿÿÿDb"a:b€÷ >ÿÿÿÿÿÿNbœ¦@ø ÿÿÿÿÿÿXbNb€ù >ÿÿÿÿÿÿabœ°@ú ÿÿÿÿÿÿkbab€û ÿÿÿÿÿÿtbXbkb€ü >ÿÿÿÿÿÿ~bœº@ý ÿÿÿÿÿÿˆb~b€þ ÿÿÿÿÿÿ‘btbˆb€ÿ >ÿÿÿÿÿÿ›bœÄ@ ÿÿÿÿÿÿ¥b›b€ ÿÿÿÿÿÿ®b‘b¥b€ >ÿÿÿÿÿÿ¸b¦°@ ÿÿÿÿÿÿÂb¸b€ ÿÿÿÿÿÿËb®bÂb€ >ÿÿÿÿÿÿÕb¦º@ ÿÿÿÿÿÿßbÕb€ ÿÿÿÿÿÿèbËbßb€ >ÿÿÿÿÿÿòb¦Ä@ ÿÿÿÿÿÿübòb€ ÿÿÿÿÿÿcèbüb€ >ÿÿÿÿÿÿc°º@ ÿÿÿÿÿÿcc€ ÿÿÿÿÿÿ"ccc€ >ÿÿÿÿÿÿ,c°Ä@ ÿÿÿÿÿÿ6c,c€ ÿÿÿÿÿÿ?c"c6c€ >ÿÿÿÿÿÿIcºÄ@ ÿÿÿÿÿÿScIc€ ÿÿÿÿÿÿ\c?cSc€ ÿÿÿÿÿÿfcDb\c€ >ÿÿÿÿÿÿpcÎØ@ ÿÿÿÿÿÿzcpc€ >ÿÿÿÿÿÿƒcÎâ@ ÿÿÿÿÿÿcƒc€ ÿÿÿÿÿÿ–czcc€ >ÿÿÿÿÿÿ cÎì@ ÿÿÿÿÿÿªc c€ ÿÿÿÿÿÿ³c–cªc€ >ÿÿÿÿÿÿ½cÎö@ ÿÿÿÿÿÿÇc½c€ ÿÿÿÿÿÿÐc³cÇc€ >ÿÿÿÿÿÿÚcØâ@! ÿÿÿÿÿÿäcÚc€" ÿÿÿÿÿÿícÐcäc€# >ÿÿÿÿÿÿ÷cØì@$ ÿÿÿÿÿÿd÷c€% ÿÿÿÿÿÿ dícd€& >ÿÿÿÿÿÿdØö@' ÿÿÿÿÿÿdd€( ÿÿÿÿÿÿ'd dd€) >ÿÿÿÿÿÿ1dâì@* ÿÿÿÿÿÿ;d1d€+ ÿÿÿÿÿÿDd'd;d€, >ÿÿÿÿÿÿNdâö@- ÿÿÿÿÿÿXdNd€. ÿÿÿÿÿÿadDdXd€/ >ÿÿÿÿÿÿkdìö@0 ÿÿÿÿÿÿudkd€1 ÿÿÿÿÿÿ~dadud€2 ÿÿÿÿÿÿˆdfc~d€3 >ÿÿÿÿÿÿ’d @4 ÿÿÿÿÿÿœd’d€5 >ÿÿÿÿÿÿ¥d@6 ÿÿÿÿÿÿ¯d¥d€7 ÿÿÿÿÿÿ¸dœd¯d€8 >ÿÿÿÿÿÿÂd@9 ÿÿÿÿÿÿÌdÂd€: ÿÿÿÿÿÿÕd¸dÌd€; >ÿÿÿÿÿÿßd(@< ÿÿÿÿÿÿédßd€= ÿÿÿÿÿÿòdÕdéd€> >ÿÿÿÿÿÿüd @? ÿÿÿÿÿÿeüd€@ ÿÿÿÿÿÿeòde€A >ÿÿÿÿÿÿe @B ÿÿÿÿÿÿ#ee€C ÿÿÿÿÿÿ,ee#e€D >ÿÿÿÿÿÿ6e (@E ÿÿÿÿÿÿ@e6e€F ÿÿÿÿÿÿIe,e@e€G >ÿÿÿÿÿÿSe@H ÿÿÿÿÿÿ]eSe€I ÿÿÿÿÿÿfeIe]e€J >ÿÿÿÿÿÿpe(@K ÿÿÿÿÿÿzepe€L ÿÿÿÿÿÿƒefeze€M >ÿÿÿÿÿÿe(@N ÿÿÿÿÿÿ—ee€O ÿÿÿÿÿÿ eƒe—e€P ÿÿÿÿÿÿªeˆd e€Q ÿÿÿÿÿÿ´e `ªe€R >ÿÿÿÿÿÿ¾e"@S ÿÿÿÿÿÿÈe¾e€T >ÿÿÿÿÿÿÑe4@U ÿÿÿÿÿÿÛeÑe€V ÿÿÿÿÿÿäeÈeÛe€W >ÿÿÿÿÿÿîeF@X ÿÿÿÿÿÿøeîe€Y ÿÿÿÿÿÿfäeøe€Z >ÿÿÿÿÿÿ fX@[ ÿÿÿÿÿÿf f€\ ÿÿÿÿÿÿfff€] >ÿÿÿÿÿÿ(f"4@^ ÿÿÿÿÿÿ2f(f€_ ÿÿÿÿÿÿ;ff2f€` >ÿÿÿÿÿÿEf"F@a ÿÿÿÿÿÿOfEf€b ÿÿÿÿÿÿXf;fOf€c >ÿÿÿÿÿÿbf"X@d ÿÿÿÿÿÿlfbf€e ÿÿÿÿÿÿufXflf€f >ÿÿÿÿÿÿf4F@g ÿÿÿÿÿÿ‰ff€h ÿÿÿÿÿÿ’fuf‰f€i >ÿÿÿÿÿÿœf4X@j ÿÿÿÿÿÿ¦fœf€k ÿÿÿÿÿÿ¯f’f¦f€l >ÿÿÿÿÿÿ¹fFX@m ÿÿÿÿÿÿÃf¹f€n ÿÿÿÿÿÿÌf¯fÃf€o ÿÿÿÿÿÿÖfÎú€p ÿÿÿÿÿÿàfÖf €q ÿÿÿÿÿÿêfàfV€r ÿÿÿÿÿÿôfP¾€s ÿÿÿÿÿÿþfôfú€t ÿÿÿÿÿÿgþfT€u ÿÿÿÿÿÿggþ€v ÿÿÿÿÿÿgg&€w ÿÿÿÿÿÿ&ggv€x ÿÿÿÿÿÿ0g&g €y ÿÿÿÿÿÿ:g0g„€z ÿÿÿÿÿÿDg:gÀ€{ ÿÿÿÿÿÿNgDgV€| ÿÿÿÿÿÿXgNgt€} ÿÿÿÿÿÿbgXg΀~ ÿÿÿÿÿÿlgbgP€ ÿÿÿÿÿÿvglgÈ€€ ÿÿÿÿÿÿ€gvg€ ÿÿÿÿÿÿŠg€g|€‚ ÿÿÿÿÿÿ”gŠg€ƒ ÿÿÿÿÿÿžg”gX€„ ÿÿÿÿÿÿ¨gžg”€… ÿÿÿÿÿÿ²g¨g* €† ÿÿÿÿÿÿ¼g²g˜ €‡ ÿÿÿÿÿÿÆg¼gÔ €ˆ ÿÿÿÿÿÿÐgÆg$ €‰ ÿÿÿÿÿÿÚgÐg~ @Š ÿÿÿÿÿÿägÚg€‹ ÿÿÿÿÿÿígg€Œ ÿÿÿÿÿÿ÷gíg”€ ÿÿÿÿÿÿh÷g €Ž ÿÿÿÿÿÿ hh„€ ÿÿÿÿÿÿh h¬€ ÿÿÿÿÿÿhhV€‘ ÿÿÿÿÿÿ)hht€’ ÿÿÿÿÿÿ3h)h΀“ ÿÿÿÿÿÿ=h3hP€” ÿÿÿÿÿÿGh=hÈ€• ÿÿÿÿÿÿQhGh€– ÿÿÿÿÿÿ[hQh¤€— ÿÿÿÿÿÿeh[hà€˜ ÿÿÿÿÿÿohehX€™ ÿÿÿÿÿÿyhohŠ€š ÿÿÿÿÿÿƒhyh* €› ÿÿÿÿÿÿhƒhR €œ ÿÿÿÿÿÿ—hhü € ÿÿÿÿÿÿ¡h—h$ €ž ÿÿÿÿÿÿ«h¡hœ @Ÿ ÿÿÿÿÿÿµh«h  ÿÿÿÿÿÿ¾hâ œm±"Ù"ž&Ò)Â*¬,q064¢6b?âAEFÀOzYjZ´eÌfêfägµh€¡ SÿÿÿÿÿÿÞhœ~€¢ >ÿÿÿÿÿÿèh<Þh€£ >ÿÿÿÿÿÿòhœê'€¤ Sÿÿÿÿÿÿühœ<€¥ >ÿÿÿÿÿÿi°üh€¦ Sÿÿÿÿÿÿiœ°€§ >ÿÿÿÿÿÿi~i€¨ Sÿÿÿÿÿÿ$i~œ€© >ÿÿÿÿÿÿ.i°$i€ª >ÿÿÿÿÿÿ8i~³-€« >ÿÿÿÿÿÿBi4|$€¬ SÿÿÿÿÿÿLi~<€­ >ÿÿÿÿÿÿViœLi€® Sÿÿÿÿÿÿ`i~°€¯ >ÿÿÿÿÿÿji<`i€° >ÿÿÿÿÿÿti~f@€± >ÿÿÿÿÿÿ~i4x1€² >ÿÿÿÿÿÿˆi°°€³ >ÿÿÿÿÿÿ’i<¿0€´ >ÿÿÿÿÿÿœiœ;2€µ Sÿÿÿÿÿÿ¦i<œ€¶ >ÿÿÿÿÿÿ°i<¦i€· Sÿÿÿÿÿÿºi<~€¸ >ÿÿÿÿÿÿÄiœºi€¹ >ÿÿÿÿÿÿÎi~_$€º SÿÿÿÿÿÿØi<°€» >ÿÿÿÿÿÿâi°Øi€¼ Sÿÿÿÿÿÿìi°œ€½ >ÿÿÿÿÿÿöiœìi€¾ Sÿÿÿÿÿÿj°~€¿ >ÿÿÿÿÿÿ j°j€À >ÿÿÿÿÿÿj<£$€Á Sÿÿÿÿÿÿj°<€Â >ÿÿÿÿÿÿ(j~j€Ã ÿÿÿÿÿÿ2j€.(j€Ä ÿÿÿÿÿÿÿÿÿÿÿÿ+k°2.€Ý >ÿÿÿÿÿÿ5k4ê'€Þ >ÿÿÿÿÿÿ?kœüh€ß >ÿÿÿÿÿÿIk<$i€à >ÿÿÿÿÿÿSkœ|$€á >ÿÿÿÿÿÿ]k4Li€â >ÿÿÿÿÿÿgk°`i€ã >ÿÿÿÿÿÿqk4¦i€ä >ÿÿÿÿÿÿ{k°ú,€å >ÿÿÿÿÿÿ…k<Øi€æ ÿÿÿÿÿÿkPj…k€ç ÿÿÿÿÿÿ™kk{k€è ÿÿÿÿÿÿ£k™kÎi€é ÿÿÿÿÿÿ­k£kÄi€ê ÿÿÿÿÿÿ·k­kqk€ë ÿÿÿÿÿÿÁk·kœi€ì ÿÿÿÿÿÿËkÁk’i€í ÿÿÿÿÿÿÕkËkˆi€î ÿÿÿÿÿÿßkÕk~i€ï ÿÿÿÿÿÿékßkti€ð ÿÿÿÿÿÿókékgk€ñ ÿÿÿÿÿÿýkók]k€ò ÿÿÿÿÿÿlýkSk€ó ÿÿÿÿÿÿll8i€ô ÿÿÿÿÿÿllIk€õ ÿÿÿÿÿÿ%lli€ö ÿÿÿÿÿÿ/l%l?k€÷ ÿÿÿÿÿÿ9l/l5k€ø ÿÿÿÿÿÿCl9lèh€ù ÿÿÿÿÿÿMlCl+k@ú ÿÿÿÿÿÿWl†Ù€û ÿÿÿÿÿÿ`lˆij€ü ÿÿÿÿÿÿjl`lÎi€ý ÿÿÿÿÿÿtljlœi€þ >ÿÿÿÿÿÿ~l~œ@ÿ ÿÿÿÿÿÿˆl~l€ >ÿÿÿÿÿÿ‘l<œ@ ÿÿÿÿÿÿ›l‘l€ ÿÿÿÿÿÿ¤lË\v€ ÿÿÿÿÿÿ®l¤l"]€ ÿÿÿÿÿÿ¸l®lkb€ ÿÿÿÿÿÿÂl¸lñ€ ÿÿÿÿÿÿÌlÂl¸\€ ÿÿÿÿÿÿÖlÌl›l€ ÿÿÿÿÿÿàlÖl'€ ÿÿÿÿÿÿêlàlú€ ÿÿÿÿÿÿôlêlˆl€ >ÿÿÿÿÿÿþl2.Þh@ ÿÿÿÿÿÿmþl€ >ÿÿÿÿÿÿmê'2.@ ÿÿÿÿÿÿmm€ >ÿÿÿÿÿÿ$mê'Þh@ ÿÿÿÿÿÿ.m$m€ >ÿÿÿÿÿÿ7m2.üh@ ÿÿÿÿÿÿAm7m€ >ÿÿÿÿÿÿJmÞhüh@ ÿÿÿÿÿÿTmJm€ >ÿÿÿÿÿÿ]mê'üh@ ÿÿÿÿÿÿgm]m€ >ÿÿÿÿÿÿpm2.i@ ÿÿÿÿÿÿzmpm€ >ÿÿÿÿÿÿƒmÞhi@ ÿÿÿÿÿÿmƒm€ >ÿÿÿÿÿÿ–mê'i@ ÿÿÿÿÿÿ m–m€ >ÿÿÿÿÿÿ©mühi@ ÿÿÿÿÿÿ³m©m€ ÿÿÿÿÿÿ¼m³m m€ ÿÿÿÿÿÿÆm¼mm€! ÿÿÿÿÿÿÐmÆmzm€" ÿÿÿÿÿÿÚmÐmgm€# ÿÿÿÿÿÿämÚmTm€$ ÿÿÿÿÿÿîmämAm€% ÿÿÿÿÿÿømîm.m€& ÿÿÿÿÿÿnømm€' ÿÿÿÿÿÿ nnm€( >ÿÿÿÿÿÿn³-$i@) ÿÿÿÿÿÿ nn€* >ÿÿÿÿÿÿ)n|$$i@+ ÿÿÿÿÿÿ3n)n€, >ÿÿÿÿÿÿÿÿÿÿÿÿOn$iLi@/ ÿÿÿÿÿÿYnOn€0 >ÿÿÿÿÿÿbn³-Li@1 ÿÿÿÿÿÿlnbn€2 >ÿÿÿÿÿÿun|$Li@3 ÿÿÿÿÿÿnun€4 >ÿÿÿÿÿÿˆn$i`i@5 ÿÿÿÿÿÿ’nˆn€6 >ÿÿÿÿÿÿ›n³-`i@7 ÿÿÿÿÿÿ¥n›n€8 >ÿÿÿÿÿÿ®n|$`i@9 ÿÿÿÿÿÿ¸n®n€: >ÿÿÿÿÿÿÁnLi`i@; ÿÿÿÿÿÿËnÁn€< ÿÿÿÿÿÿÔnËn¸n€= ÿÿÿÿÿÿÞnÔn¥n€> ÿÿÿÿÿÿènÞn’n€? ÿÿÿÿÿÿònènn€@ ÿÿÿÿÿÿünònln€A ÿÿÿÿÿÿoünYn€B ÿÿÿÿÿÿooFn€C ÿÿÿÿÿÿoo3n€D ÿÿÿÿÿÿ$oo n€E >ÿÿÿÿÿÿ.ox1f@@F ÿÿÿÿÿÿ8o.o€G >ÿÿÿÿÿÿAo°f@@H ÿÿÿÿÿÿKoAo€I >ÿÿÿÿÿÿTo°x1@J ÿÿÿÿÿÿ^oTo€K >ÿÿÿÿÿÿgo¿0f@@L ÿÿÿÿÿÿqogo€M >ÿÿÿÿÿÿzo¿0x1@N ÿÿÿÿÿÿ„ozo€O >ÿÿÿÿÿÿo°¿0@P ÿÿÿÿÿÿ—oo€Q >ÿÿÿÿÿÿ o;2f@@R ÿÿÿÿÿÿªo o€S >ÿÿÿÿÿÿ³ox1;2@T ÿÿÿÿÿÿ½o³o€U >ÿÿÿÿÿÿÆo°;2@V ÿÿÿÿÿÿÐoÆo€W >ÿÿÿÿÿÿÙo¿0;2@X ÿÿÿÿÿÿãoÙo€Y ÿÿÿÿÿÿìoãoÐo€Z ÿÿÿÿÿÿöoìo½o€[ ÿÿÿÿÿÿpöoªo€\ ÿÿÿÿÿÿ pp—o€] ÿÿÿÿÿÿp p„o€^ ÿÿÿÿÿÿppqo€_ ÿÿÿÿÿÿ(pp^o€` ÿÿÿÿÿÿ2p(pKo€a ÿÿÿÿÿÿÿÿÿÿÿÿFp¦iºi@c ÿÿÿÿÿÿPpFp€d >ÿÿÿÿÿÿYp_$¦i@e ÿÿÿÿÿÿcpYp€f >ÿÿÿÿÿÿlp_$ºi@g ÿÿÿÿÿÿvplp€h >ÿÿÿÿÿÿpú,¦i@i ÿÿÿÿÿÿ‰pp€j >ÿÿÿÿÿÿ’pú,ºi@k ÿÿÿÿÿÿœp’p€l >ÿÿÿÿÿÿ¥p_$ú,@m ÿÿÿÿÿÿ¯p¥p€n >ÿÿÿÿÿÿ¸p¦iØi@o ÿÿÿÿÿÿÂp¸p€p >ÿÿÿÿÿÿËpºiØi@q ÿÿÿÿÿÿÕpËp€r >ÿÿÿÿÿÿÞp_$Øi@s ÿÿÿÿÿÿèpÞp€t >ÿÿÿÿÿÿñpú,Øi@u ÿÿÿÿÿÿûpñp€v ÿÿÿÿÿÿqûpèp€w ÿÿÿÿÿÿqqÕp€x ÿÿÿÿÿÿqqÂp€y ÿÿÿÿÿÿ"qq¯p€z ÿÿÿÿÿÿ,q"qœp€{ ÿÿÿÿÿÿ6q,q‰p€| ÿÿÿÿÿÿ@q6qvp€} ÿÿÿÿÿÿJq@qcp€~ ÿÿÿÿÿÿTqJqPp€ >ÿÿÿÿÿÿ^qìij@€ ÿÿÿÿÿÿhq^q€ >ÿÿÿÿÿÿqq£$ìi@‚ ÿÿÿÿÿÿ{qqq€ƒ >ÿÿÿÿÿÿ„q£$j@„ ÿÿÿÿÿÿŽq„q€… >ÿÿÿÿÿÿ—qìij@† ÿÿÿÿÿÿ¡q—q€‡ >ÿÿÿÿÿÿªqjj@ˆ ÿÿÿÿÿÿ´qªq€‰ >ÿÿÿÿÿÿ½q£$j@Š ÿÿÿÿÿÿÇq½q€‹ >ÿÿÿÿÿÿÐqv.ìi@Œ ÿÿÿÿÿÿÚqÐq€ >ÿÿÿÿÿÿãqv.j@Ž ÿÿÿÿÿÿíqãq€ >ÿÿÿÿÿÿöq£$v.@ ÿÿÿÿÿÿröq€‘ >ÿÿÿÿÿÿ rv.j@’ ÿÿÿÿÿÿr r€“ ÿÿÿÿÿÿrrr€” ÿÿÿÿÿÿ&rríq€• ÿÿÿÿÿÿ0r&rÚq€– ÿÿÿÿÿÿ:r0rÇq€— ÿÿÿÿÿÿDr:r´q€˜ ÿÿÿÿÿÿNrDr¡q€™ ÿÿÿÿÿÿXrNrŽq€š ÿÿÿÿÿÿbrXr{q€› ÿÿÿÿÿÿlrbrhq€œ ÿÿÿÿÿÿvrlrTq€ ÿÿÿÿÿÿ€rvrÿÿÿÿÿÿžr2.$i@¡ ÿÿÿÿÿÿ¨ržr€¢ >ÿÿÿÿÿÿ±r2.f@@£ ÿÿÿÿÿÿ»r±r€¤ >ÿÿÿÿÿÿÄrf@$i@¥ ÿÿÿÿÿÿÎrÄr€¦ >ÿÿÿÿÿÿ×r2.¦i@§ ÿÿÿÿÿÿár×r€¨ >ÿÿÿÿÿÿêr$i¦i@© ÿÿÿÿÿÿôrêr€ª >ÿÿÿÿÿÿýrf@¦i@« ÿÿÿÿÿÿsýr€¬ >ÿÿÿÿÿÿs2.ìi@­ ÿÿÿÿÿÿss€® >ÿÿÿÿÿÿ#s$iìi@¯ ÿÿÿÿÿÿ-s#s€° >ÿÿÿÿÿÿ6sf@ìi@± ÿÿÿÿÿÿ@s6s€² >ÿÿÿÿÿÿIs¦iìi@³ ÿÿÿÿÿÿSsIs€´ ÿÿÿÿÿÿ\sSs@s€µ ÿÿÿÿÿÿfs\s-s€¶ ÿÿÿÿÿÿpsfss€· ÿÿÿÿÿÿzspss€¸ ÿÿÿÿÿÿ„szsôr€¹ ÿÿÿÿÿÿŽs„sár€º ÿÿÿÿÿÿ˜sŽsÎr€» ÿÿÿÿÿÿ¢s˜s»r€¼ ÿÿÿÿÿÿ¬s¢s¨r€½ >ÿÿÿÿÿÿ¶s³-Þh@¾ ÿÿÿÿÿÿÀs¶s€¿ >ÿÿÿÿÿÿÉsx1Þh@À ÿÿÿÿÿÿÓsÉs€Á >ÿÿÿÿÿÿÜs³-x1@ ÿÿÿÿÿÿæsÜs€Ã >ÿÿÿÿÿÿïsÞhºi@Ä ÿÿÿÿÿÿùsïs€Å >ÿÿÿÿÿÿt³-ºi@Æ ÿÿÿÿÿÿ tt€Ç >ÿÿÿÿÿÿtx1ºi@È ÿÿÿÿÿÿtt€É >ÿÿÿÿÿÿ(tÞhj@Ê ÿÿÿÿÿÿ2t(t€Ë >ÿÿÿÿÿÿ;t³-j@Ì ÿÿÿÿÿÿEt;t€Í >ÿÿÿÿÿÿNtx1j@Î ÿÿÿÿÿÿXtNt€Ï >ÿÿÿÿÿÿatºij@Ð ÿÿÿÿÿÿktat€Ñ ÿÿÿÿÿÿttktXt€Ò ÿÿÿÿÿÿ~tttEt€Ó ÿÿÿÿÿÿˆt~t2t€Ô ÿÿÿÿÿÿ’tˆtt€Õ ÿÿÿÿÿÿœt’t t€Ö ÿÿÿÿÿÿ¦tœtùs€× ÿÿÿÿÿÿ°t¦tæs€Ø ÿÿÿÿÿÿºt°tÓs€Ù ÿÿÿÿÿÿÄtºtÀs€Ú >ÿÿÿÿÿÿÎt|$ê'@Û ÿÿÿÿÿÿØtÎt€Ü >ÿÿÿÿÿÿát°ê'@Ý ÿÿÿÿÿÿëtát€Þ >ÿÿÿÿÿÿôt°|$@ß ÿÿÿÿÿÿþtôt€à >ÿÿÿÿÿÿu_$ê'@á ÿÿÿÿÿÿuu€â >ÿÿÿÿÿÿu_$|$@ã ÿÿÿÿÿÿ$uu€ä >ÿÿÿÿÿÿ-u°_$@å ÿÿÿÿÿÿ7u-u€æ >ÿÿÿÿÿÿ@u£$ê'@ç ÿÿÿÿÿÿJu@u€è >ÿÿÿÿÿÿSu|$£$@é ÿÿÿÿÿÿ]uSu€ê >ÿÿÿÿÿÿfu°£$@ë ÿÿÿÿÿÿpufu€ì >ÿÿÿÿÿÿyu_$£$@í ÿÿÿÿÿÿƒuyu€î ÿÿÿÿÿÿŒuƒupu€ï ÿÿÿÿÿÿ–uŒu]u€ð ÿÿÿÿÿÿ u–uJu€ñ ÿÿÿÿÿÿªu u7u€ò ÿÿÿÿÿÿ´uªu$u€ó ÿÿÿÿÿÿ¾u´uu€ô ÿÿÿÿÿÿÈu¾uþt€õ ÿÿÿÿÿÿÒuÈuët€ö ÿÿÿÿÿÿÜuÒuØt€÷ >ÿÿÿÿÿÿæuühLi@ø ÿÿÿÿÿÿðuæu€ù >ÿÿÿÿÿÿùu¿0üh@ú ÿÿÿÿÿÿvùu€û >ÿÿÿÿÿÿ v¿0Li@ü ÿÿÿÿÿÿv v€ý >ÿÿÿÿÿÿvú,üh@þ ÿÿÿÿÿÿ)vv€ÿ >ÿÿÿÿÿÿ2vú,Li@ ÿÿÿÿÿÿÿÿÿÿÿÿEvú,¿0@ ÿÿÿÿÿÿOvEv€ >ÿÿÿÿÿÿXvühj@ ÿÿÿÿÿÿbvXv€ >ÿÿÿÿÿÿkvLij@ ÿÿÿÿÿÿuvkv€ >ÿÿÿÿÿÿ~v¿0j@ ÿÿÿÿÿÿˆv~v€ >ÿÿÿÿÿÿ‘vú,j@ ÿÿÿÿÿÿ›v‘v€ ÿÿÿÿÿÿ¤v›vˆv€ ÿÿÿÿÿÿ®v¤vuv€ ÿÿÿÿÿÿ¸v®vbv€ ÿÿÿÿÿÿÂv¸vOv€ ÿÿÿÿÿÿÌvÂvÿÿÿÿÿÿþvi`i@ ÿÿÿÿÿÿwþv€ >ÿÿÿÿÿÿw;2i@ ÿÿÿÿÿÿww€ >ÿÿÿÿÿÿ$w;2`i@ ÿÿÿÿÿÿ.w$w€ >ÿÿÿÿÿÿ7wiØi@ ÿÿÿÿÿÿAw7w€ >ÿÿÿÿÿÿJw`iØi@ ÿÿÿÿÿÿTwJw€ >ÿÿÿÿÿÿ]w;2Øi@ ÿÿÿÿÿÿgw]w€ >ÿÿÿÿÿÿpwv.i@! ÿÿÿÿÿÿzwpw€" >ÿÿÿÿÿÿƒwv.`i@# ÿÿÿÿÿÿwƒw€$ >ÿÿÿÿÿÿ–wv.;2@% ÿÿÿÿÿÿ w–w€& >ÿÿÿÿÿÿ©wv.Øi@' ÿÿÿÿÿÿ³w©w€( ÿÿÿÿÿÿ¼w³w w€) ÿÿÿÿÿÿÆw¼ww€* ÿÿÿÿÿÿÐwÆwzw€+ ÿÿÿÿÿÿÚwÐwgw€, ÿÿÿÿÿÿäwÚwTw€- ÿÿÿÿÿÿîwäwAw€. ÿÿÿÿÿÿøwîw.w€/ ÿÿÿÿÿÿxøww€0 ÿÿÿÿÿÿ xxw€1 ÿÿÿÿÿÿx xôv€2 ÿÿÿÿÿÿ xxÜu€3 ÿÿÿÿÿÿ*x xÄt€4 ÿÿÿÿÿÿ4x*x¬s€5 ÿÿÿÿÿÿ>x4x”r€6 SÿÿÿÿÿÿHx2.œ€7 >ÿÿÿÿÿÿRxœHx@8 ÿÿÿÿÿÿ\xRx€9 Sÿÿÿÿÿÿex$i~€: >ÿÿÿÿÿÿoxœex@; ÿÿÿÿÿÿyxox€< Sÿÿÿÿÿÿ‚xf@4€= >ÿÿÿÿÿÿŒxœ‚x@> ÿÿÿÿÿÿ–xŒx€? SÿÿÿÿÿÿŸx¦i<€@ >ÿÿÿÿÿÿ©xœŸx@A ÿÿÿÿÿÿ³x©x€B Sÿÿÿÿÿÿ¼xìi°€C >ÿÿÿÿÿÿÆxœ¼x@D ÿÿÿÿÿÿÐxÆx€E ÿÿÿÿÿÿÙxÐx³x€F ÿÿÿÿÿÿãxÙx–x€G ÿÿÿÿÿÿíxãxyx€H ÿÿÿÿÿÿ÷xíx\x€I SÿÿÿÿÿÿyÞhœ€J >ÿÿÿÿÿÿ y~y@K ÿÿÿÿÿÿy y€L Sÿÿÿÿÿÿy³-~€M >ÿÿÿÿÿÿ(y~y@N ÿÿÿÿÿÿ2y(y€O Sÿÿÿÿÿÿ;yx14€P >ÿÿÿÿÿÿEy~;y@Q ÿÿÿÿÿÿOyEy€R SÿÿÿÿÿÿXyºi<€S >ÿÿÿÿÿÿby~Xy@T ÿÿÿÿÿÿlyby€U Sÿÿÿÿÿÿuyj°€V >ÿÿÿÿÿÿy~uy@W ÿÿÿÿÿÿ‰yy€X ÿÿÿÿÿÿ’y‰yly€Y ÿÿÿÿÿÿœy’yOy€Z ÿÿÿÿÿÿ¦yœy2y€[ ÿÿÿÿÿÿ°y¦yy€\ Sÿÿÿÿÿÿºyê'œ€] >ÿÿÿÿÿÿÄy4ºy@^ ÿÿÿÿÿÿÎyÄy€_ Sÿÿÿÿÿÿ×y|$~€` >ÿÿÿÿÿÿáy4×y@a ÿÿÿÿÿÿëyáy€b Sÿÿÿÿÿÿôy_$<€c >ÿÿÿÿÿÿþy4ôy@d ÿÿÿÿÿÿzþy€e Sÿÿÿÿÿÿz£$°€f >ÿÿÿÿÿÿz4z@g ÿÿÿÿÿÿ%zz€h ÿÿÿÿÿÿ.z%zz€i ÿÿÿÿÿÿ8z.z·$€j ÿÿÿÿÿÿBz8zëy€k ÿÿÿÿÿÿLzBzÎy€l SÿÿÿÿÿÿVzühœ€m >ÿÿÿÿÿÿ`z<Vz@n ÿÿÿÿÿÿjz`z€o SÿÿÿÿÿÿszLi~€p >ÿÿÿÿÿÿ}z<sz@q ÿÿÿÿÿÿ‡z}z€r Sÿÿÿÿÿÿz¿04€s >ÿÿÿÿÿÿšz<z@t ÿÿÿÿÿÿ¤zšz€u Sÿÿÿÿÿÿ­zú,<€v >ÿÿÿÿÿÿ·z<­z@w ÿÿÿÿÿÿÁz·z€x SÿÿÿÿÿÿÊzj°€y >ÿÿÿÿÿÿÔz<Êz@z ÿÿÿÿÿÿÞzÔz€{ ÿÿÿÿÿÿçzÞzÁz€| ÿÿÿÿÿÿñzçz¤z€} ÿÿÿÿÿÿûzñz‡z€~ ÿÿÿÿÿÿ{ûzjz€ Sÿÿÿÿÿÿ{iœ€€ >ÿÿÿÿÿÿ{°{@ ÿÿÿÿÿÿ#{{€‚ Sÿÿÿÿÿÿ,{`i~€ƒ >ÿÿÿÿÿÿ6{°,{@„ ÿÿÿÿÿÿ@{6{€… SÿÿÿÿÿÿI{;24€† >ÿÿÿÿÿÿS{°I{@‡ ÿÿÿÿÿÿ]{S{€ˆ Sÿÿÿÿÿÿf{Øi<€‰ >ÿÿÿÿÿÿp{°f{@Š ÿÿÿÿÿÿz{p{€‹ Sÿÿÿÿÿÿƒ{v.°€Œ >ÿÿÿÿÿÿ{°ƒ{@ ÿÿÿÿÿÿ—{{€Ž ÿÿÿÿÿÿ {—{z{€ ÿÿÿÿÿÿª{ {]{€ ÿÿÿÿÿÿ´{ª{@{€‘ ÿÿÿÿÿÿ¾{´{#{€’ ÿÿÿÿÿÿÈ{¾{{€“ ÿÿÿÿÿÿÒ{È{Lz€” ÿÿÿÿÿÿÜ{Ò{°y€• ÿÿÿÿÿÿæ{Ü{÷x€– >ÿÿÿÿÿÿð{œ2.@— ÿÿÿÿÿÿú{ð{€˜ ÿÿÿÿÿÿ|ð{ú{€™ >ÿÿÿÿÿÿ |~2.@š ÿÿÿÿÿÿ| |€› >ÿÿÿÿÿÿ |œÞh€œ ÿÿÿÿÿÿ*| ||€ ÿÿÿÿÿÿ4|òhg4€ž >ÿÿÿÿÿÿ>|<2.@Ÿ ÿÿÿÿÿÿH|>|€  ÿÿÿÿÿÿQ|?kH|@¡ ÿÿÿÿÿÿ[|+k€¢ >ÿÿÿÿÿÿd|œi€£ ÿÿÿÿÿÿn|d|[|€¤ ÿÿÿÿÿÿx|n|Q|€¥ ÿÿÿÿÿÿ‚|x|4|€¦ ÿÿÿÿÿÿŒ|‚|*|€§ ÿÿÿÿÿÿ–|Œ||€¨ >ÿÿÿÿÿÿ |œ$i@© ÿÿÿÿÿÿª| |€ª ÿÿÿÿÿÿ³| |ª|€« >ÿÿÿÿÿÿ½|~$i@¬ ÿÿÿÿÿÿÇ|½|€­ >ÿÿÿÿÿÿÐ|œ³-€® ÿÿÿÿÿÿÚ|Ð|Ç|€¯ >ÿÿÿÿÿÿä|4$i@° ÿÿÿÿÿÿî|ä|€± ÿÿÿÿÿÿ÷|Skî|@² ÿÿÿÿÿÿ}Ik€³ ÿÿÿÿÿÿ }Vi}@´ ÿÿÿÿÿÿ}.i€µ >ÿÿÿÿÿÿ}œ`i€¶ ÿÿÿÿÿÿ'}}}€· ÿÿÿÿÿÿ1}'} }€¸ ÿÿÿÿÿÿ;}1}÷|€¹ ÿÿÿÿÿÿE};}Ú|€º ÿÿÿÿÿÿO}E}³|€» >ÿÿÿÿÿÿY}œf@@¼ ÿÿÿÿÿÿc}Y}€½ ÿÿÿÿÿÿl}Y}c}@¾ ÿÿÿÿÿÿv}ti€¿ >ÿÿÿÿÿÿ}œx1€À ÿÿÿÿÿÿ‰}}v}€Á >ÿÿÿÿÿÿ“}4f@@ ÿÿÿÿÿÿ}“}€Ã ÿÿÿÿÿÿ¦}ab}€Ä >ÿÿÿÿÿÿ°}<f@@Å ÿÿÿÿÿÿº}°}€Æ >ÿÿÿÿÿÿÃ}œ¿0€Ç ÿÿÿÿÿÿÍ}Ã}º}€È ÿÿÿÿÿÿ×}œiKo€É ÿÿÿÿÿÿá}×}Í}€Ê ÿÿÿÿÿÿë}á}¦}€Ë ÿÿÿÿÿÿõ}ë}‰}€Ì ÿÿÿÿÿÿÿ}õ}l}€Í >ÿÿÿÿÿÿ ~œ¦i@Î ÿÿÿÿÿÿ~ ~€Ï ÿÿÿÿÿÿ~ ~~€Ð >ÿÿÿÿÿÿ&~~¦i@Ñ ÿÿÿÿÿÿ0~&~€Ò ÿÿÿÿÿÿ9~Äi0~@Ó ÿÿÿÿÿÿC~qk€Ô >ÿÿÿÿÿÿL~œ_$€Õ ÿÿÿÿÿÿV~L~C~@Ö ÿÿÿÿÿÿ`~°i€× >ÿÿÿÿÿÿi~œú,€Ø ÿÿÿÿÿÿs~i~`~€Ù >ÿÿÿÿÿÿ}~°¦i@Ú ÿÿÿÿÿÿ‡~}~€Û >ÿÿÿÿÿÿ~œØi€Ü ÿÿÿÿÿÿš~~‡~€Ý ÿÿÿÿÿÿ¤~š~s~€Þ ÿÿÿÿÿÿ®~¤~V~€ß ÿÿÿÿÿÿ¸~®~9~€à ÿÿÿÿÿÿÂ~¸~~@á ÿÿÿÿÿÿÌ~öi€â ÿÿÿÿÿÿÕ~öiÌ~€ã >ÿÿÿÿÿÿß~~ìi@ä ÿÿÿÿÿÿé~ß~€å >ÿÿÿÿÿÿò~œj€æ ÿÿÿÿÿÿü~ò~é~€ç >ÿÿÿÿÿÿ4ìi@è ÿÿÿÿÿÿ€é >ÿÿÿÿÿÿœ£$€ê ÿÿÿÿÿÿ#€ë >ÿÿÿÿÿÿ-<ìi@ì ÿÿÿÿÿÿ7-€í >ÿÿÿÿÿÿ@œj€î ÿÿÿÿÿÿJ@7€ï >ÿÿÿÿÿÿT°ìi@ð ÿÿÿÿÿÿ^T€ñ >ÿÿÿÿÿÿgœv.€ò ÿÿÿÿÿÿqg^€ó ÿÿÿÿÿÿ{qJ€ô ÿÿÿÿÿÿ…{#€õ ÿÿÿÿÿÿ…ü~€ö ÿÿÿÿÿÿ™Õ~€÷ ÿÿÿÿÿÿ£™Â~€ø ÿÿÿÿÿÿ­£ÿ}€ù ÿÿÿÿÿÿ·­O}€ú ÿÿÿÿÿÿÁ·–|@û ÿÿÿÿÿÿË |€ü ÿÿÿÿÿÿÔ |Ë€ý >ÿÿÿÿÿÿÞ~Þh@þ ÿÿÿÿÿÿèÞ€ÿ ÿÿÿÿÿÿñÞè€ >ÿÿÿÿÿÿû4Þh@ ÿÿÿÿÿÿ€û€ >ÿÿÿÿÿÿ€~ê'€ ÿÿÿÿÿÿ€€€@ ÿÿÿÿÿÿ"€èh€ >ÿÿÿÿÿÿ+€~üh€ ÿÿÿÿÿÿ5€+€"€€ >ÿÿÿÿÿÿ?€°Þh@ ÿÿÿÿÿÿI€?€€ ÿÿÿÿÿÿR€iI€€ ÿÿÿÿÿÿ\€R€5€€ ÿÿÿÿÿÿf€\€€€ ÿÿÿÿÿÿp€f€ñ€ ÿÿÿÿÿÿz€p€Ô@ ÿÿÿÿÿÿ„€Ð|€ ÿÿÿÿÿÿ€½|„€@ ÿÿÿÿÿÿ—€8i€ ÿÿÿÿÿÿ €8i—€€ >ÿÿÿÿÿÿª€~|$€ ÿÿÿÿÿÿ´€ª€Ç-€ >ÿÿÿÿÿÿ¾€<³-@ ÿÿÿÿÿÿÈ€¾€€ >ÿÿÿÿÿÿÑ€~Li€ ÿÿÿÿÿÿۀрȀ€ >ÿÿÿÿÿÿ倰³-@ ÿÿÿÿÿÿï€å€€ >ÿÿÿÿÿÿø€~`i€ ÿÿÿÿÿÿø€ï€€ ÿÿÿÿÿÿ Û€€ ÿÿÿÿÿÿ ´€€ ÿÿÿÿÿÿ  €€ ÿÿÿÿÿÿ* €@ ÿÿÿÿÿÿ4}€! ÿÿÿÿÿÿ=ti4€" >ÿÿÿÿÿÿG~x1@# ÿÿÿÿÿÿQG€$ ÿÿÿÿÿÿZGQ@% ÿÿÿÿÿÿd~i€& ÿÿÿÿÿÿm]d€' >ÿÿÿÿÿÿw<x1@( ÿÿÿÿÿÿw€) >ÿÿÿÿÿÿŠ~¿0€* ÿÿÿÿÿÿ”Š€+ >ÿÿÿÿÿÿž~;2€, ÿÿÿÿÿÿ¨ž^o€- ÿÿÿÿÿÿ²¨”€. ÿÿÿÿÿÿ¼²m€/ ÿÿÿÿÿÿƼZ€0 ÿÿÿÿÿÿÐÆ=@1 ÿÿÿÿÿÿÚÄi€2 ÿÿÿÿÿÿã&~Ú€3 >ÿÿÿÿÿÿí~ºi@4 ÿÿÿÿÿÿ÷í€5 ÿÿÿÿÿÿ‚í÷€6 >ÿÿÿÿÿÿ ‚4ºi@7 ÿÿÿÿÿÿ‚ ‚€8 ÿÿÿÿÿÿ‚Îi‚€9 >ÿÿÿÿÿÿ'‚<ºi@: ÿÿÿÿÿÿ1‚'‚€; >ÿÿÿÿÿÿ:‚~ú,€< ÿÿÿÿÿÿD‚:‚1‚€= >ÿÿÿÿÿÿN‚°ºi@> ÿÿÿÿÿÿX‚N‚€? >ÿÿÿÿÿÿa‚~Øi€@ ÿÿÿÿÿÿk‚a‚X‚€A ÿÿÿÿÿÿu‚k‚D‚€B ÿÿÿÿÿÿ‚u‚‚€C ÿÿÿÿÿÿ‰‚‚‚€D ÿÿÿÿÿÿ“‚‰‚ã@E ÿÿÿÿÿÿ‚ò~€F ÿÿÿÿÿÿ¦‚ß~‚€G >ÿÿÿÿÿÿ°‚~j@H ÿÿÿÿÿÿº‚°‚€I ÿÿÿÿÿÿ°‚º‚€J >ÿÿÿÿÿÿÍ‚4j@K ÿÿÿÿÿÿׂ͂€L >ÿÿÿÿÿÿà‚~£$€M ÿÿÿÿÿÿê‚à‚ׂ€N >ÿÿÿÿÿÿô‚<j@O ÿÿÿÿÿÿþ‚ô‚€P ÿÿÿÿÿÿƒ(jþ‚@Q ÿÿÿÿÿÿƒ j€R >ÿÿÿÿÿÿƒ~v.€S ÿÿÿÿÿÿ$ƒƒƒ€T ÿÿÿÿÿÿ.ƒ$ƒƒ€U ÿÿÿÿÿÿ8ƒ.ƒê‚€V ÿÿÿÿÿÿBƒ8ƒÃ‚€W ÿÿÿÿÿÿLƒBƒ¦‚€X ÿÿÿÿÿÿVƒLƒ“‚€Y ÿÿÿÿÿÿ`ƒVƒÐ€Z ÿÿÿÿÿÿjƒ`ƒ*€[ ÿÿÿÿÿÿtƒjƒz€@\ ÿÿÿÿÿÿ~ƒòh€] ÿÿÿÿÿÿ‡ƒ]4~ƒ@^ ÿÿÿÿÿÿ‘ƒ€€_ ÿÿÿÿÿÿšƒû‘ƒ@` ÿÿÿÿÿÿ¤ƒ5k€a ÿÿÿÿÿÿ­ƒ5k¤ƒ€b >ÿÿÿÿÿÿ·ƒ<ê'@c ÿÿÿÿÿÿÁƒ·ƒ€d >ÿÿÿÿÿÿʃ4üh€e ÿÿÿÿÿÿԃʃÁƒ€f >ÿÿÿÿÿÿÞƒ4i€g ÿÿÿÿÿÿèƒÞƒët€h ÿÿÿÿÿÿòƒèƒÔƒ€i ÿÿÿÿÿÿüƒòƒ­ƒ€j ÿÿÿÿÿÿ„üƒšƒ€k ÿÿÿÿÿÿ„„‡ƒ@l ÿÿÿÿÿÿ„Sk€m ÿÿÿÿÿÿ#„ä|„@n ÿÿÿÿÿÿ-„ª€€o ÿÿÿÿÿÿ6„½--„@p ÿÿÿÿÿÿ@„Bi€q ÿÿÿÿÿÿI„Bi@„€r >ÿÿÿÿÿÿS„<|$@s ÿÿÿÿÿÿ]„S„€t ÿÿÿÿÿÿf„]k]„€u >ÿÿÿÿÿÿp„4`i€v ÿÿÿÿÿÿz„p„þt€w ÿÿÿÿÿÿ„„z„f„€x ÿÿÿÿÿÿŽ„„„I„€y ÿÿÿÿÿÿ˜„Ž„6„€z ÿÿÿÿÿÿ¢„˜„#„€{ ÿÿÿÿÿÿ¬„“}kb€| ÿÿÿÿÿÿ¶„~i"]€} >ÿÿÿÿÿÿÀ„4¿0€~ ÿÿÿÿÿÿÊ„À„Ë\@ ÿÿÿÿÿÿÔ„€€ ÿÿÿÿÿÿÝ„E2€ ÿÿÿÿÿÿç„Ý„Ê„€‚ ÿÿÿÿÿÿñ„ç„„T€ƒ ÿÿÿÿÿÿû„ñ„¶„€„ ÿÿÿÿÿÿ…û„¬„@… ÿÿÿÿÿÿ…L~€† ÿÿÿÿÿÿ…qk…@‡ ÿÿÿÿÿÿ"…Îi€ˆ ÿÿÿÿÿÿ+… ‚"…€‰ >ÿÿÿÿÿÿ5…4_$@Š ÿÿÿÿÿÿ?…5…€‹ ÿÿÿÿÿÿH…5…?…€Œ >ÿÿÿÿÿÿR…<_$@ ÿÿÿÿÿÿ\…R…€Ž ÿÿÿÿÿÿe…-\…€ >ÿÿÿÿÿÿo…4Øi€ ÿÿÿÿÿÿy…o…7u€‘ ÿÿÿÿÿÿƒ…y…e…€’ ÿÿÿÿÿÿ…ƒ…H…€“ ÿÿÿÿÿÿ—……+…€” ÿÿÿÿÿÿ¡…—……@• ÿÿÿÿÿÿ«…€– ÿÿÿÿÿÿ´…«…@— ÿÿÿÿÿÿ¾…à‚€˜ ÿÿÿÿÿÿÇ…Í‚¾…€™ ÿÿÿÿÿÿÑ…­$·$@š ÿÿÿÿÿÿÛ…j€› >ÿÿÿÿÿÿä…4j€œ ÿÿÿÿÿÿî…ä…Û…€ ÿÿÿÿÿÿø…€.pu€ž ÿÿÿÿÿÿ†ø…î…€Ÿ ÿÿÿÿÿÿ ††Ñ…€  ÿÿÿÿÿÿ† †Ç…€¡ ÿÿÿÿÿÿ ††´…€¢ ÿÿÿÿÿÿ*† †¡…€£ ÿÿÿÿÿÿ4†*†…€¤ ÿÿÿÿÿÿ>†4†¢„€¥ ÿÿÿÿÿÿH†>†„@¦ ÿÿÿÿÿÿR†?k€§ ÿÿÿÿÿÿ[†>|R†@¨ ÿÿÿÿÿÿe†+€€© ÿÿÿÿÿÿn†èhe†@ª ÿÿÿÿÿÿx†Êƒ€« ÿÿÿÿÿÿ†·ƒx†€¬ >ÿÿÿÿÿÿ‹†<üh@­ ÿÿÿÿÿÿ•†‹†€® ÿÿÿÿÿÿž†‹†•†@¯ ÿÿÿÿÿÿ¨†i€° >ÿÿÿÿÿÿ±†<i€± ÿÿÿÿÿÿ»†±†¨†€² ÿÿÿÿÿÿņ»†ž†€³ ÿÿÿÿÿÿφņ†€´ ÿÿÿÿÿÿنφn†€µ ÿÿÿÿÿÿã†Ù†[†@¶ ÿÿÿÿÿÿí†Vi€· ÿÿÿÿÿÿö†Ikí†@¸ ÿÿÿÿÿÿ‡Ñ€€¹ ÿÿÿÿÿÿ ‡¾€‡@º ÿÿÿÿÿÿ‡]k€» ÿÿÿÿÿÿ‡S„‡€¼ >ÿÿÿÿÿÿ&‡<Li@½ ÿÿÿÿÿÿ0‡&‡€¾ ÿÿÿÿÿÿ9‡&‡0‡€¿ >ÿÿÿÿÿÿC‡°Li@À ÿÿÿÿÿÿM‡C‡€Á ÿÿÿÿÿÿV‡jiM‡€Â ÿÿÿÿÿÿ`‡V‡9‡€Ã ÿÿÿÿÿÿj‡`‡‡€Ä ÿÿÿÿÿÿt‡j‡ ‡€Å ÿÿÿÿÿÿ~‡t‡ö†@Æ ÿÿÿÿÿÿˆ‡Ã}€Ç ÿÿÿÿÿÿ‘‡°}ˆ‡@È ÿÿÿÿÿÿ›‡Š€É ÿÿÿÿÿÿ¤‡w›‡@Ê ÿÿÿÿÿÿ®‡À„€Ë ÿÿÿÿÿÿ·‡Á\®‡@Ì ÿÿÿÿÿÿÁ‡’i€Í ÿÿÿÿÿÿʇ’iÁ‡€Î >ÿÿÿÿÿÿÔ‡<;2€Ï ÿÿÿÿÿÿÞ‡Ô‡—o€Ð ÿÿÿÿÿÿè‡Þ‡Ê‡€Ñ ÿÿÿÿÿÿò‡è‡·‡€Ò ÿÿÿÿÿÿü‡ò‡¤‡€Ó ÿÿÿÿÿÿˆü‡‘‡@Ô ÿÿÿÿÿÿˆi~€Õ ÿÿÿÿÿÿˆ°iˆ@Ö ÿÿÿÿÿÿ#ˆ:‚€× ÿÿÿÿÿÿ,ˆ'‚#ˆ€Ø ÿÿÿÿÿÿ6ˆR…-€Ù >ÿÿÿÿÿÿ@ˆ<ú,@Ú ÿÿÿÿÿÿJˆ@ˆ€Û ÿÿÿÿÿÿSˆ@ˆJˆ@Ü ÿÿÿÿÿÿ]ˆ{k€Ý ÿÿÿÿÿÿfˆ…k]ˆ€Þ ÿÿÿÿÿÿpˆfˆSˆ€ß ÿÿÿÿÿÿzˆpˆ6ˆ€à ÿÿÿÿÿÿ„ˆzˆ,ˆ€á ÿÿÿÿÿÿŽˆ„ˆˆ@â ÿÿÿÿÿÿ˜ˆ@€ã ÿÿÿÿÿÿ¡ˆ-˜ˆ@ä ÿÿÿÿÿÿ«ˆ(j€å ÿÿÿÿÿÿ´ˆô‚«ˆ@æ ÿÿÿÿÿÿ¾ˆä…€ç ÿÿÿÿÿÿLjj¾ˆ€è >ÿÿÿÿÿÿш<j@é ÿÿÿÿÿÿۈш€ê ÿÿÿÿÿÿäˆÑˆÛˆ€ë >ÿÿÿÿÿÿj@ì ÿÿÿÿÿÿøˆîˆ€í >ÿÿÿÿÿÿ‰<v.€î ÿÿÿÿÿÿ ‰‰øˆ€ï ÿÿÿÿÿÿ‰ ‰äˆ€ð ÿÿÿÿÿÿ‰‰Çˆ€ñ ÿÿÿÿÿÿ)‰‰´ˆ€ò ÿÿÿÿÿÿ3‰)‰¡ˆ€ó ÿÿÿÿÿÿ=‰3‰Žˆ€ô ÿÿÿÿÿÿG‰=‰ˆ€õ ÿÿÿÿÿÿQ‰G‰~‡€ö ÿÿÿÿÿÿ[‰Q‰ã†@÷ ÿÿÿÿÿÿe‰d|€ø ÿÿÿÿÿÿn‰+ke‰@ù ÿÿÿÿÿÿx‰i€ú ÿÿÿÿÿÿ‰?€x‰@û ÿÿÿÿÿÿ‹‰Þƒ€ü ÿÿÿÿÿÿ”‰át‹‰@ý ÿÿÿÿÿÿž‰±†€þ ÿÿÿÿÿÿ§‰iž‰€ÿ >ÿÿÿÿÿÿ±‰°i@ÿÿÿÿÿÿ»‰±‰€ÿÿÿÿÿÿĉ±‰»‰€ÿÿÿÿÿÿΉĉ§‰€ÿÿÿÿÿÿ؉Ή”‰€ÿÿÿÿÿÿâ‰Ø‰‰€ÿÿÿÿÿÿì‰â‰n‰@ÿÿÿÿÿÿö‰}€ÿÿÿÿÿÿÿ‰.iö‰@ÿÿÿÿÿÿ Šø€€ ÿÿÿÿÿÿŠå€ Š@ ÿÿÿÿÿÿŠp„€ ÿÿÿÿÿÿ%ŠôtŠ@ ÿÿÿÿÿÿ/Šji€ ÿÿÿÿÿÿ8ŠC‡/Š@ÿÿÿÿÿÿBŠgk€ÿÿÿÿÿÿKŠgkBŠ€ÿÿÿÿÿÿUŠKŠ8Š€ÿÿÿÿÿÿ_ŠUŠ%Š€ÿÿÿÿÿÿiŠ_ŠŠ€ÿÿÿÿÿÿsŠiŠÿ‰@ÿÿÿÿÿÿ}Šœi€ÿÿÿÿÿÿ†ŠAo}Š@ÿÿÿÿÿÿŠž€ÿÿÿÿÿÿ™ŠToŠ€ÿÿÿÿÿÿ£ŠO2@ÿÿÿÿÿÿ­ŠÔ‡€ÿÿÿÿÿÿ¶Šo­Š€ÿÿÿÿÿÿÀŠÆoÐo€ÿÿÿÿÿÿÊŠÀŠ¶Š€ÿÿÿÿÿÿÔŠÊŠ£Š€ÿÿÿÿÿÿÞŠÔŠ™Š€ÿÿÿÿÿÿèŠÞŠ†Š@ ÿÿÿÿÿÿòŠ~€!ÿÿÿÿÿÿûŠ}~òŠ@"ÿÿÿÿÿÿ‹a‚€#ÿÿÿÿÿÿ‹N‚‹@$ÿÿÿÿÿÿ‹o…€%ÿÿÿÿÿÿ!‹-u‹@&ÿÿÿÿÿÿ+‹…k€'ÿÿÿÿÿÿ4‹{k+‹@(ÿÿÿÿÿÿ>‹âi€)ÿÿÿÿÿÿG‹âi>‹€*ÿÿÿÿÿÿQ‹G‹4‹€+ÿÿÿÿÿÿ[‹Q‹!‹€,ÿÿÿÿÿÿe‹[‹‹€-ÿÿÿÿÿÿo‹e‹ûŠ@.ÿÿÿÿÿÿy‹g€/ÿÿÿÿÿÿ‚‹Ty‹@0ÿÿÿÿÿÿŒ‹ƒ€1ÿÿÿÿÿÿ•‹ jŒ‹€2ÿÿÿÿÿÿŸ‹fuŠ.@3ÿÿÿÿÿÿ©‹‰€4ÿÿÿÿÿÿ²‹îˆ©‹€5>ÿÿÿÿÿÿ¼‹°v.@6ÿÿÿÿÿÿÆ‹¼‹€7ÿÿÿÿÿÿÏ‹¼‹Æ‹€8ÿÿÿÿÿÿÙ‹Ï‹²‹€9ÿÿÿÿÿÿã‹Ù‹Ÿ‹€:ÿÿÿÿÿÿí‹ã‹•‹€;ÿÿÿÿÿÿ÷‹í‹‚‹€<ÿÿÿÿÿÿŒ÷‹o‹€=ÿÿÿÿÿÿ ŒŒèŠ€>ÿÿÿÿÿÿŒ ŒsŠ€?ÿÿÿÿÿÿŒŒì‰€@ÿÿÿÿÿÿ)ŒŒ[‰€Aÿÿÿÿÿÿ3Œ)ŒH†€Bÿÿÿÿÿÿ=Œ3Œtƒ€CÿÿÿÿÿÿGŒ=ŒÁ€DÿÿÿÿÿÿQŒú{ð{€Eÿÿÿÿÿÿ[ŒË |€FÿÿÿÿÿÿeŒ~ƒY}€GÿÿÿÿÿÿoŒR† ~€HÿÿÿÿÿÿyŒe‰öi€IÿÿÿÿÿÿƒŒyŒoŒ€JÿÿÿÿÿÿŒƒŒeŒ€Kÿÿÿÿÿÿ—ŒŒ[Œ€Lÿÿÿÿÿÿ¡Œ—ŒQŒ€Mÿÿÿÿÿÿ«Œª| |€NÿÿÿÿÿÿµŒ„€Ð|€Oÿÿÿÿÿÿ¿Œ„}€PÿÿÿÿÿÿÉŒí†Äi€QÿÿÿÿÿÿÓŒö‰ò~€Rÿÿÿÿÿÿ݌ӌɌ€SÿÿÿÿÿÿçŒÝŒ¿Œ€TÿÿÿÿÿÿñŒçŒµŒ€UÿÿÿÿÿÿûŒñŒ«Œ€Vÿÿÿÿÿÿc}òh€Wÿÿÿÿÿÿ4Sk€Xÿÿÿÿÿÿkbab€Yÿÿÿÿÿÿ#ˆ‡L~€Zÿÿÿÿÿÿ-}Š€[ÿÿÿÿÿÿ7-#€\ÿÿÿÿÿÿA7€]ÿÿÿÿÿÿKA€^ÿÿÿÿÿÿUK€_ÿÿÿÿÿÿ_~?k€`ÿÿÿÿÿÿiÚVi€aÿÿÿÿÿÿs…Ã}€bÿÿÿÿÿÿ}ˆi~€cÿÿÿÿÿÿ‡òŠ@€dÿÿÿÿÿÿ‘‡}€eÿÿÿÿÿÿ›‘s€fÿÿÿÿÿÿ¥›i€gÿÿÿÿÿÿ¯¥_€hÿÿÿÿÿÿ¹Ì~d|€iÿÿÿÿÿÿÂ}€jÿÿÿÿÿÿÍ«…œi€kÿÿÿÿÿÿטˆ~€lÿÿÿÿÿÿáy‹g€mÿÿÿÿÿÿëá×€nÿÿÿÿÿÿõëÍ€oÿÿÿÿÿÿÿõÀpÿÿÿÿÿÿ Žÿ¹€qÿÿÿÿÿÿŽ Ž¯€rÿÿÿÿÿÿŽŽU€sÿÿÿÿÿÿ'ŽŽûŒ€tÿÿÿÿÿÿ1Ž'Ž¡Œ€uÿÿÿÿÿÿ;Ž| |€vÿÿÿÿÿÿEŽè½|€wÿÿÿÿÿÿOŽ‘ƒti€xÿÿÿÿÿÿYŽe†&~€yÿÿÿÿÿÿcŽx‰ß~€zÿÿÿÿÿÿmŽcŽYŽ€{ÿÿÿÿÿÿwŽmŽOŽ€|ÿÿÿÿÿÿŽwŽEŽ€}ÿÿÿÿÿÿ‹ŽŽ;Ž€~ÿÿÿÿÿÿ•ŽÇ|Þ€ÿÿÿÿÿÿŸŽ—€8i€€ÿÿÿÿÿÿ©Ž-„G€ÿÿÿÿÿÿ³Ž‡í€‚ÿÿÿÿÿÿ½Ž Š°‚€ƒÿÿÿÿÿÿÇŽ½Ž³Ž€„ÿÿÿÿÿÿÑŽÇŽ©Ž€…ÿÿÿÿÿÿÛŽÑŽŸŽ€†ÿÿÿÿÿÿåŽÛŽ•Ž€‡ÿÿÿÿÿÿïŽv}€€ˆÿÿÿÿÿÿùŽQª€€‰ÿÿÿÿÿÿ"]]€Šÿÿÿÿÿÿ ›‡Îi€‹ÿÿÿÿÿÿŠà‚€Œÿÿÿÿÿÿ! €ÿÿÿÿÿÿ+!€Žÿÿÿÿÿÿ5+ùŽ€ÿÿÿÿÿÿ?5ÿÿÿÿÿÿI0~+€€‘ÿÿÿÿÿÿS÷Ñ€€’ÿÿÿÿÿÿ]"…Š€“ÿÿÿÿÿÿg#ˆ:‚€”ÿÿÿÿÿÿq‹(j€•ÿÿÿÿÿÿ{qg€–ÿÿÿÿÿÿ…{]€—ÿÿÿÿÿÿ…S€˜ÿÿÿÿÿÿ™I€™ÿÿÿÿÿÿ£é~i€šÿÿÿÿÿÿ­º‚ø€€›ÿÿÿÿÿÿ·¾…ž€œÿÿÿÿÿÿÁ«ˆa‚€ÿÿÿÿÿÿËŒ‹ƒ€žÿÿÿÿÿÿÕËÁ€ŸÿÿÿÿÿÿßÕ·€ ÿÿÿÿÿÿéß­€¡ÿÿÿÿÿÿó飀¢ÿÿÿÿÿÿý󙀣ÿÿÿÿÿÿý?€¤ÿÿÿÿÿÿ厀¥ÿÿÿÿÿÿ‹Ž€¦ÿÿÿÿÿÿ%g4]4€§ÿÿÿÿÿÿ/€ä|€¨ÿÿÿÿÿÿ9¤ƒ“}€©ÿÿÿÿÿÿCx†qk€ªÿÿÿÿÿÿM‹‰€«ÿÿÿÿÿÿWMC€¬ÿÿÿÿÿÿaW9€­ÿÿÿÿÿÿka/€®ÿÿÿÿÿÿuk%€¯ÿÿÿÿÿÿî|û€°ÿÿÿÿÿÿ‰Ç-½-€±ÿÿÿÿÿÿ“@„~i€²ÿÿÿÿÿÿ‡ ‚€³ÿÿÿÿÿÿ§ŠÍ‚€´ÿÿÿÿÿÿ±§€µÿÿÿÿÿÿ»±“€¶ÿÿÿÿÿÿÅ»‰€·ÿÿÿÿÿÿÏÅ€¸ÿÿÿÿÿÿÙ}5k€¹ÿÿÿÿÿÿãdBi€ºÿÿÿÿÿÿí®‡5…€»ÿÿÿÿÿÿ÷O2­$€¼ÿÿÿÿÿÿ‘÷퀽ÿÿÿÿÿÿ ‘‘ÊJ€¾ÿÿÿÿÿÿ‘ ‘〿ÿÿÿÿÿÿ‘‘Ù€Àÿÿÿÿÿÿ)‘C~ʃ€Áÿÿÿÿÿÿ3‘‚]k€Âÿÿÿÿÿÿ=‘?…À„€ÃÿÿÿÿÿÿG‘--€ÄÿÿÿÿÿÿQ‘‹ä…€Åÿÿÿÿÿÿ[‘Q‘G‘€Æÿÿÿÿÿÿe‘[‘=‘€Çÿÿÿÿÿÿo‘e‘3‘€Èÿÿÿÿÿÿy‘o‘)‘€Éÿÿÿÿÿÿƒ‘Þƒ€Êÿÿÿÿÿÿ‘ׂp„€Ëÿÿÿÿÿÿ—‘·$E2€Ìÿÿÿÿÿÿ¡‘¾ˆo…€Íÿÿÿÿÿÿ«‘Š.€.€Îÿÿÿÿÿÿµ‘«‘¡‘€Ïÿÿÿÿÿÿ¿‘µ‘—‘€ÐÿÿÿÿÿÿÉ‘¿‘‘€ÑÿÿÿÿÿÿÓ‘É‘ƒ‘€ÒÿÿÿÿÿÿÝ‘Ó‘y‘€Óÿÿÿÿÿÿç‘Ý‘‘€Ôÿÿÿÿÿÿñ‘ç‘Ï€Õÿÿÿÿÿÿû‘ñ‘u€Öÿÿÿÿÿÿ’H|>|€×ÿÿÿÿÿÿ’"€Ik€Øÿÿÿÿÿÿ’Áƒ°}€Ùÿÿÿÿÿÿ#’•†°i€Úÿÿÿÿÿÿ-’ž‰-€Ûÿÿÿÿÿÿ7’-’#’€ÜÿÿÿÿÿÿA’7’’€ÝÿÿÿÿÿÿK’A’’€ÞÿÿÿÿÿÿU’K’’€ßÿÿÿÿÿÿ_’}èh€àÿÿÿÿÿÿi’È€¾€€áÿÿÿÿÿÿs’]„w€âÿÿÿÿÿÿ}’0‡'‚€ãÿÿÿÿÿÿ‡’/Šô‚€äÿÿÿÿÿÿ‘’‡’}’€åÿÿÿÿÿÿ›’‘’s’€æÿÿÿÿÿÿ¥’›’i’€çÿÿÿÿÿÿ¯’¥’_’€èÿÿÿÿÿÿ¹’º}·ƒ€éÿÿÿÿÿÿÃ’S„€êÿÿÿÿÿÿÍ’Ë\Á\€ëÿÿÿÿÿÿ×’Á‡R…€ìÿÿÿÿÿÿá’­Šj€íÿÿÿÿÿÿë’á’×’€îÿÿÿÿÿÿõ’ë’Í’€ïÿÿÿÿÿÿÿ’õ’Ã’€ðÿÿÿÿÿÿ “ÿ’¹’€ñÿÿÿÿÿÿ“`~‹†€òÿÿÿÿÿÿ“1‚&‡€óÿÿÿÿÿÿ'“\…’i€ôÿÿÿÿÿÿ1“Jˆ@ˆ€õÿÿÿÿÿÿ;“+‹Ñˆ€öÿÿÿÿÿÿE“;“1“€÷ÿÿÿÿÿÿO“E“'“€øÿÿÿÿÿÿY“O““€ùÿÿÿÿÿÿc“Y““€úÿÿÿÿÿÿm“7±†€ûÿÿÿÿÿÿw“þ‚ji€üÿÿÿÿÿÿ“Û…Ô‡€ýÿÿÿÿÿÿ‹“Ûˆ…k€þÿÿÿÿÿÿ•“©‹‰€ÿÿÿÿÿÿÿŸ“•“‹“€ÿÿÿÿÿÿ©“Ÿ““€ÿÿÿÿÿÿ³“©“w“€ÿÿÿÿÿÿ½“³“m“€ÿÿÿÿÿÿÇ“½“c“€ÿÿÿÿÿÿÑ“Ç“ “€ÿÿÿÿÿÿÛ“Ñ“¯’€ÿÿÿÿÿÿå“Û“U’€ÿÿÿÿÿÿï“[|+k€ÿÿÿÿÿÿù“I€.i€ ÿÿÿÿÿÿ”ëtAo€ ÿÿÿÿÿÿ ”¨†}~€ ÿÿÿÿÿÿ”»‰T€ ÿÿÿÿÿÿ!”” ”€ ÿÿÿÿÿÿ+”!””€ÿÿÿÿÿÿ5”+”ù“€ÿÿÿÿÿÿ?”5”ï“€ÿÿÿÿÿÿI”}?€€ÿÿÿÿÿÿS”ï€å€€ÿÿÿÿÿÿ]”þtTo€ÿÿÿÿÿÿg”M‡N‚€ÿÿÿÿÿÿq”BŠ j€ÿÿÿÿÿÿ{”q”g”€ÿÿÿÿÿÿ…”{”]”€ÿÿÿÿÿÿ”…”S”€ÿÿÿÿÿÿ™””I”€ÿÿÿÿÿÿ£”Koát€ÿÿÿÿÿÿ­”^oôt€ÿÿÿÿÿÿ·”€ÿÿÿÿÿÿÁ”—o-u€ÿÿÿÿÿÿË”Ðofu€ÿÿÿÿÿÿՔ˔Á”€ÿÿÿÿÿÿߔՔ·”€ ÿÿÿÿÿÿé”ß”­”€!ÿÿÿÿÿÿó”锣”€"ÿÿÿÿÿÿý”‡~i€#ÿÿÿÿÿÿ•X‚C‡€$ÿÿÿÿÿÿ•7uo€%ÿÿÿÿÿÿ•]ˆ{k€&ÿÿÿÿÿÿ%•>‹îˆ€'ÿÿÿÿÿÿ/•%••€(ÿÿÿÿÿÿ9•/••€)ÿÿÿÿÿÿC•9••€*ÿÿÿÿÿÿM•C•ý”€+ÿÿÿÿÿÿW•^±‰€,ÿÿÿÿÿÿa•ƒgk€-ÿÿÿÿÿÿk•puÆo€.ÿÿÿÿÿÿu•øˆâi€/ÿÿÿÿÿÿ•Æ‹¼‹€0ÿÿÿÿÿÿ‰••u•€1ÿÿÿÿÿÿ“•‰•k•€2ÿÿÿÿÿÿ•“•a•€3ÿÿÿÿÿÿ§••W•€4ÿÿÿÿÿÿ±•§•M•€5ÿÿÿÿÿÿ»•±•ó”€6ÿÿÿÿÿÿÅ•»•™”€7ÿÿÿÿÿÿÏ•Å•?”€8ÿÿÿÿÿÿÙ•Ï•å“€9ÿÿÿÿÿÿã•Ù•û‘€:ÿÿÿÿÿÿí•ã•€;ÿÿÿÿÿÿ÷•í•1Ž€<ÿÿÿÿÿÿ–»‰•†€=ÿÿÿÿÿÿ ––¤ƒ€>ÿÿÿÿÿÿ– –è€?ÿÿÿÿÿÿ––ú{€@ÿÿÿÿÿÿ)–BŠ0‡€Aÿÿÿÿÿÿ3–)–@„€Bÿÿÿÿÿÿ=–3–—€€CÿÿÿÿÿÿG–=–ª|€DÿÿÿÿÿÿQ–ÐoÁ‡€Eÿÿÿÿÿÿ[–Q–v€Fÿÿÿÿÿÿe–[–Q€Gÿÿÿÿÿÿo–e–c}€Hÿÿÿÿÿÿy–>‹Jˆ€Iÿÿÿÿÿÿƒ–y–?…€Jÿÿÿÿÿÿ–ƒ–÷€Kÿÿÿÿÿÿ—––~€Lÿÿÿÿÿÿ¡–Æ‹Ûˆ€Mÿÿÿÿÿÿ«–¡–·$€Nÿÿÿÿÿÿµ–«–º‚€Oÿÿÿÿÿÿ¿–µ–Ì~€PÿÿÿÿÿÿÉ–¿–—–€QÿÿÿÿÿÿÓ–É–o–€RÿÿÿÿÿÿÝ–Ó–G–€Sÿÿÿÿÿÿç–Ý––€TSÿÿÿÿÿÿñ–œ2.€U>ÿÿÿÿÿÿû–œñ–@Vÿÿÿÿÿÿ—û–€WSÿÿÿÿÿÿ—~2.€X>ÿÿÿÿÿÿ—~—@Yÿÿÿÿÿÿ"——€ZSÿÿÿÿÿÿ+—42.€[>ÿÿÿÿÿÿ5—4+—@\ÿÿÿÿÿÿ?—5—€]SÿÿÿÿÿÿH—<2.€^>ÿÿÿÿÿÿR—<H—@_ÿÿÿÿÿÿ\—R—€`Sÿÿÿÿÿÿe—°2.€a>ÿÿÿÿÿÿo—°e—@bÿÿÿÿÿÿy—o—€cÿÿÿÿÿÿ‚—y—\—€dÿÿÿÿÿÿŒ—‚—?—€eÿÿÿÿÿÿ–—Œ—"—€fÿÿÿÿÿÿ —–——€gSÿÿÿÿÿÿª—œ³-€h>ÿÿÿÿÿÿ´—œª—@iÿÿÿÿÿÿ¾—´—€jSÿÿÿÿÿÿÇ—~³-€k>ÿÿÿÿÿÿÑ—~Ç—@lÿÿÿÿÿÿÛ—Ñ—€mSÿÿÿÿÿÿä—4³-€n>ÿÿÿÿÿÿî—4ä—@oÿÿÿÿÿÿø—î—€pSÿÿÿÿÿÿ˜<³-€q>ÿÿÿÿÿÿ ˜<˜@rÿÿÿÿÿÿ˜ ˜€sSÿÿÿÿÿÿ˜°³-€t>ÿÿÿÿÿÿ(˜°˜@uÿÿÿÿÿÿ2˜(˜€vÿÿÿÿÿÿ;˜2˜˜€wÿÿÿÿÿÿE˜;˜ø—€xÿÿÿÿÿÿO˜E˜Û—€yÿÿÿÿÿÿY˜O˜¾—€zÿÿÿÿÿÿc˜Æ‹+‹€{ÿÿÿÿÿÿm˜c˜O2€|ÿÿÿÿÿÿw˜m˜ Š€}ÿÿÿÿÿÿ˜w˜e‰€~Sÿÿÿÿÿÿ‹˜œú,€>ÿÿÿÿÿÿ•˜œ‹˜@€ÿÿÿÿÿÿŸ˜•˜€Sÿÿÿÿÿÿ¨˜~ú,€‚>ÿÿÿÿÿÿ²˜~¨˜@ƒÿÿÿÿÿÿ¼˜²˜€„SÿÿÿÿÿÿŘ4ú,€…>ÿÿÿÿÿÿϘ4Ř@†ÿÿÿÿÿÿ٘Ϙ€‡Sÿÿÿÿÿÿâ˜<ú,€ˆ>ÿÿÿÿÿÿì˜<â˜@‰ÿÿÿÿÿÿö˜ì˜€ŠSÿÿÿÿÿÿÿ˜°ú,€‹>ÿÿÿÿÿÿ ™°ÿ˜@Œÿÿÿÿÿÿ™ ™€ÿÿÿÿÿÿ™™ö˜€Žÿÿÿÿÿÿ&™™Ù˜€ÿÿÿÿÿÿ0™&™¼˜€ÿÿÿÿÿÿ:™0™Ÿ˜€‘SÿÿÿÿÿÿD™œv.€’>ÿÿÿÿÿÿN™œD™@“ÿÿÿÿÿÿX™N™€”Sÿÿÿÿÿÿa™~v.€•>ÿÿÿÿÿÿk™~a™@–ÿÿÿÿÿÿu™k™€—Sÿÿÿÿÿÿ~™4v.€˜>ÿÿÿÿÿÿˆ™4~™@™ÿÿÿÿÿÿ’™ˆ™€šSÿÿÿÿÿÿ›™<v.€›>ÿÿÿÿÿÿ¥™<›™@œÿÿÿÿÿÿ¯™¥™€Sÿÿÿÿÿÿ¸™°v.€ž>ÿÿÿÿÿÿ™°¸™@Ÿÿÿÿÿÿÿ̙™€ ÿÿÿÿÿÿՙ̙¯™€¡ÿÿÿÿÿÿߙՙ’™€¢ÿÿÿÿÿÿé™ß™u™€£ÿÿÿÿÿÿó™é™X™€¤ÿÿÿÿÿÿý™ó™:™€¥ÿÿÿÿÿÿšý™˜€¦ÿÿÿÿÿÿššY˜€§ÿÿÿÿÿÿšš —€¨Sÿÿÿÿÿÿ%šœÞh€©>ÿÿÿÿÿÿ/š~%š€ªSÿÿÿÿÿÿ9šœê'€«>ÿÿÿÿÿÿCš49š€¬SÿÿÿÿÿÿMšœüh€­>ÿÿÿÿÿÿWš<Mš€®Sÿÿÿÿÿÿašœi€¯>ÿÿÿÿÿÿkš°aš€°ÿÿÿÿÿÿuškšWš€±ÿÿÿÿÿÿšušCš€²ÿÿÿÿÿÿ‰šš/š€³ÿÿÿÿÿÿ“š‰šû–€´Sÿÿÿÿÿÿš~$i€µ>ÿÿÿÿÿÿ§šœš€¶Sÿÿÿÿÿÿ±š~|$€·>ÿÿÿÿÿÿ»š4±š€¸SÿÿÿÿÿÿÅš~Li€¹>ÿÿÿÿÿÿÏš<Åš€ºSÿÿÿÿÿÿÙš~`i€»>ÿÿÿÿÿÿãš°Ùš€¼ÿÿÿÿÿÿíšãšÏš€½ÿÿÿÿÿÿ÷šíš»š€¾ÿÿÿÿÿÿ›÷šÑ—€¿ÿÿÿÿÿÿ ››§š€ÀSÿÿÿÿÿÿ›4f@€Á>ÿÿÿÿÿÿ›œ›€ÂSÿÿÿÿÿÿ)›4x1€Ã>ÿÿÿÿÿÿ3›~)›€ÄSÿÿÿÿÿÿ=›4¿0€Å>ÿÿÿÿÿÿG›<=›€ÆSÿÿÿÿÿÿQ›4;2€Ç>ÿÿÿÿÿÿ[›°Q›€Èÿÿÿÿÿÿe›[›G›€Éÿÿÿÿÿÿo›e›E2€Êÿÿÿÿÿÿy›o›3›€Ëÿÿÿÿÿÿƒ›y››€ÌSÿÿÿÿÿÿ›<¦i€Í>ÿÿÿÿÿÿ—›œ›€ÎSÿÿÿÿÿÿ¡›<ºi€Ï>ÿÿÿÿÿÿ«›~¡›€ÐSÿÿÿÿÿÿµ›<_$€Ñ>ÿÿÿÿÿÿ¿›4µ›€ÒSÿÿÿÿÿÿÉ›<Øi€Ó>ÿÿÿÿÿÿÓ›°É›€Ôÿÿÿÿÿÿݛӛ였Õÿÿÿÿÿÿç›Ý›¿›€Öÿÿÿÿÿÿñ›ç›«›€×ÿÿÿÿÿÿû›ñ›—›€ØSÿÿÿÿÿÿœ°ìi€Ù>ÿÿÿÿÿÿœœœ€ÚSÿÿÿÿÿÿœ°j€Û>ÿÿÿÿÿÿ#œ~œ€ÜSÿÿÿÿÿÿ-œ°£$€Ý>ÿÿÿÿÿÿ7œ4-œ€ÞSÿÿÿÿÿÿAœ°j€ß>ÿÿÿÿÿÿKœ<Aœ€àÿÿÿÿÿÿUœÂ™Kœ€áÿÿÿÿÿÿ_œUœ7œ€âÿÿÿÿÿÿiœ_œ#œ€ãÿÿÿÿÿÿsœiœœ€äÿÿÿÿÿÿ}œsœû›€åÿÿÿÿÿÿ‡œ}œƒ›€æÿÿÿÿÿÿ‘œ‡œ ›€çÿÿÿÿÿÿ›œ‘œ“š€èÿÿÿÿÿÿ¥œËÇ|€éÿÿÿÿÿÿ¯œ~ƒ}€êÿÿÿÿÿÿ¹œR†`~€ëÿÿÿÿÿÿÃœe‰^€ìÿÿÿÿÿÿܹ͜œ€íÿÿÿÿÿÿל͜¯œ€îÿÿÿÿÿÿáœ×œ¥œ€ïÿÿÿÿÿÿëœáœú{€ðÿÿÿÿÿÿõœª|Ë€ñÿÿÿÿÿÿÿœ„€—€€òÿÿÿÿÿÿ „d€óÿÿÿÿÿÿí†1‚€ôÿÿÿÿÿÿö‰ƒ€õÿÿÿÿÿÿ'€öÿÿÿÿÿÿ1' €÷ÿÿÿÿÿÿ;1ÿœ€øÿÿÿÿÿÿE;õœ€ùÿÿÿÿÿÿOc}~ƒ€úÿÿÿÿÿÿY4-„€ûÿÿÿÿÿÿckbv€üÿÿÿÿÿÿmˆ‡\…€ýÿÿÿÿÿÿw}Špu€þÿÿÿÿÿÿwm€ÿÿÿÿÿÿÿ‹c€ÿÿÿÿÿÿ•‹Y€ÿÿÿÿÿÿŸ•O€ÿÿÿÿÿÿ©~R†€ÿÿÿÿÿÿ³Ú‡€ÿÿÿÿÿÿ½…®‡€ÿÿÿÿÿÿLjJˆ€ÿÿÿÿÿÿÑòŠøˆ€ÿÿÿÿÿÿÛÑÇ€ÿÿÿÿÿÿåÛ½€ ÿÿÿÿÿÿïå³€ ÿÿÿÿÿÿùï©€ ÿÿÿÿÿÿžÌ~e‰€ ÿÿÿÿÿÿ ž‚ Š€ ÿÿÿÿÿÿž«…O2€ÿÿÿÿÿÿ!ž˜ˆ+‹€ÿÿÿÿÿÿ+žy‹Æ‹€ÿÿÿÿÿÿ5ž+ž!ž€ÿÿÿÿÿÿ?ž5žž€ÿÿÿÿÿÿIž?ž ž€ÿÿÿÿÿÿSžIžž€ÿÿÿÿÿÿ]žSžù€ÿÿÿÿÿÿgž]žŸ€ÿÿÿÿÿÿqžgžE€ÿÿÿÿÿÿ{žqžëœ€ÿÿÿÿÿÿ…ž|ú{€ÿÿÿÿÿÿžèÇ|€ÿÿÿÿÿÿ™ž‘ƒ}€ÿÿÿÿÿÿ£že†`~€ÿÿÿÿÿÿ­žx‰^€ÿÿÿÿÿÿ·ž­ž£ž€ÿÿÿÿÿÿÁž·ž™ž€ÿÿÿÿÿÿËžÁžž€ ÿÿÿÿÿÿ՞˞…ž€!ÿÿÿÿÿÿßžÇ|Ë€"ÿÿÿÿÿÿéž-„d€#ÿÿÿÿÿÿóž‡1‚€$ÿÿÿÿÿÿýž Šƒ€%ÿÿÿÿÿÿŸýžóž€&ÿÿÿÿÿÿŸŸéž€'ÿÿÿÿÿÿŸŸ—€€(ÿÿÿÿÿÿ%ŸŸßž€)ÿÿÿÿÿÿ/Ÿv}~ƒ€*ÿÿÿÿÿÿ9ŸQ-„€+ÿÿÿÿÿÿCŸ"]v€,ÿÿÿÿÿÿMŸ›‡\…€-ÿÿÿÿÿÿWŸŠpu€.ÿÿÿÿÿÿaŸWŸMŸ€/ÿÿÿÿÿÿkŸaŸCŸ€0ÿÿÿÿÿÿuŸkŸ9Ÿ€1ÿÿÿÿÿÿŸuŸ/Ÿ€2ÿÿÿÿÿÿ‰Ÿ0~R†€3ÿÿÿÿÿÿ“Ÿ÷‡€4ÿÿÿÿÿÿŸ"…®‡€5ÿÿÿÿÿÿ§Ÿ#ˆJˆ€6ÿÿÿÿÿÿ±Ÿ‹øˆ€7ÿÿÿÿÿÿ»Ÿ±Ÿ§Ÿ€8ÿÿÿÿÿÿÅŸ»ŸŸ€9ÿÿÿÿÿÿÏŸÅŸ“Ÿ€:ÿÿÿÿÿÿÙŸÏŸ‰Ÿ€;ÿÿÿÿÿÿãŸé~e‰€<ÿÿÿÿÿÿퟺ‚ Š€=ÿÿÿÿÿÿ÷Ÿ¾…O2€>ÿÿÿÿÿÿ «ˆ+‹€?ÿÿÿÿÿÿ  Œ‹Æ‹€@ÿÿÿÿÿÿ    €Aÿÿÿÿÿÿ  ÷Ÿ€Bÿÿÿÿÿÿ)  íŸ€Cÿÿÿÿÿÿ3 ) ãŸ€Dÿÿÿÿÿÿ= 3 ÙŸ€EÿÿÿÿÿÿG = Ÿ€FÿÿÿÿÿÿQ G %Ÿ€Gÿÿÿÿÿÿ[ Q Õž€Hÿÿÿÿÿÿe g4ú{€Iÿÿÿÿÿÿo €Ç|€Jÿÿÿÿÿÿy ¤ƒ}€Kÿÿÿÿÿÿƒ x†`~€Lÿÿÿÿÿÿ ‹‰^€Mÿÿÿÿÿÿ—  ƒ €Nÿÿÿÿÿÿ¡ — y €Oÿÿÿÿÿÿ« ¡ o €Pÿÿÿÿÿÿµ « e €Qÿÿÿÿÿÿ¿ î|Ë€RÿÿÿÿÿÿÉ Ç-—€€SÿÿÿÿÿÿÓ @„d€TÿÿÿÿÿÿÝ ‡1‚€Uÿÿÿÿÿÿç Šƒ€Vÿÿÿÿÿÿñ ç Ý €Wÿÿÿÿÿÿû ñ Ó €Xÿÿÿÿÿÿ¡û É €Yÿÿÿÿÿÿ¡¡¿ €Zÿÿÿÿÿÿ¡}~ƒ€[ÿÿÿÿÿÿ#¡d-„€\ÿÿÿÿÿÿ-¡®‡\…€]ÿÿÿÿÿÿ7¡O2pu€^ÿÿÿÿÿÿA¡7¡-¡€_ÿÿÿÿÿÿK¡A¡v€`ÿÿÿÿÿÿU¡K¡#¡€aÿÿÿÿÿÿ_¡U¡¡€bÿÿÿÿÿÿi¡C~R†€cÿÿÿÿÿÿs¡‚‡€dÿÿÿÿÿÿ}¡?…®‡€eÿÿÿÿÿÿ‡¡-Jˆ€fÿÿÿÿÿÿ‘¡‹øˆ€gÿÿÿÿÿÿ›¡‘¡‡¡€hÿÿÿÿÿÿ¥¡›¡}¡€iÿÿÿÿÿÿ¯¡¥¡s¡€jÿÿÿÿÿÿ¹¡¯¡i¡€kÿÿÿÿÿÿáe‰€lÿÿÿÿÿÿׂ͡ Š€mÿÿÿÿÿÿס·$O2€nÿÿÿÿÿÿ᡾ˆ+‹€oÿÿÿÿÿÿë¡Š.Æ‹€pÿÿÿÿÿÿõ¡ë¡á¡€qÿÿÿÿÿÿÿ¡õ¡×¡€rÿÿÿÿÿÿ ¢ÿ¡Í¡€sÿÿÿÿÿÿ¢ ¢Ã¡€tÿÿÿÿÿÿ¢¢¹¡€uÿÿÿÿÿÿ'¢¢_¡€vÿÿÿÿÿÿ1¢'¢¡€wÿÿÿÿÿÿ;¢1¢µ €xÿÿÿÿÿÿE¢H|ú{€yÿÿÿÿÿÿO¢"€Ç|€zÿÿÿÿÿÿY¢Áƒ}€{ÿÿÿÿÿÿc¢•†`~€|ÿÿÿÿÿÿm¢ž‰^€}ÿÿÿÿÿÿw¢m¢c¢€~ÿÿÿÿÿÿ¢w¢Y¢€ÿÿÿÿÿÿ‹¢¢O¢€€ÿÿÿÿÿÿ•¢‹¢E¢€ÿÿÿÿÿÿŸ¢}Ë€‚ÿÿÿÿÿÿ©¢È€—€€ƒÿÿÿÿÿÿ³¢]„d€„ÿÿÿÿÿÿ½¢0‡1‚€…ÿÿÿÿÿÿÇ¢/Šƒ€†ÿÿÿÿÿÿѢǢ½¢€‡ÿÿÿÿÿÿۢѢ³¢€ˆÿÿÿÿÿÿå¢Û¢©¢€‰ÿÿÿÿÿÿï¢å¢Ÿ¢€Šÿÿÿÿÿÿù¢º}~ƒ€‹ÿÿÿÿÿÿ£-„€Œÿÿÿÿÿÿ £Ë\v€ÿÿÿÿÿÿ£Á‡\…€Žÿÿÿÿÿÿ!£­Špu€ÿÿÿÿÿÿ+£!££€ÿÿÿÿÿÿ5£+£ £€‘ÿÿÿÿÿÿ?£5££€’ÿÿÿÿÿÿI£?£ù¢€“ÿÿÿÿÿÿS£`~R†€”ÿÿÿÿÿÿ]£1‚‡€•ÿÿÿÿÿÿg£\…®‡€–ÿÿÿÿÿÿq£+‹øˆ€—ÿÿÿÿÿÿ{£q£Jˆ€˜ÿÿÿÿÿÿ…£{£g£€™ÿÿÿÿÿÿ£…£]£€šÿÿÿÿÿÿ™££S£€›ÿÿÿÿÿÿ££7e‰€œÿÿÿÿÿÿ­£þ‚ Š€ÿÿÿÿÿÿ·£Û…O2€žÿÿÿÿÿÿÁ£Ûˆ+‹€ŸÿÿÿÿÿÿË£©‹Æ‹€ ÿÿÿÿÿÿգˣÁ£€¡ÿÿÿÿÿÿߣգ·£€¢ÿÿÿÿÿÿé£ß£­£€£ÿÿÿÿÿÿó£é£££€¤ÿÿÿÿÿÿý£ó£™£€¥ÿÿÿÿÿÿ¤ý£I£€¦ÿÿÿÿÿÿ¤¤ï¢€§ÿÿÿÿÿÿ¤¤•¢€¨ÿÿÿÿÿÿ%¤[|ú{€©ÿÿÿÿÿÿ/¤I€Ç|€ªÿÿÿÿÿÿ9¤ët}€«ÿÿÿÿÿÿC¤¨†`~€¬ÿÿÿÿÿÿM¤»‰^€­ÿÿÿÿÿÿW¤M¤C¤€®ÿÿÿÿÿÿa¤W¤9¤€¯ÿÿÿÿÿÿk¤a¤/¤€°ÿÿÿÿÿÿu¤k¤%¤€±ÿÿÿÿÿÿ¤}Ë€²ÿÿÿÿÿÿ‰¤ï€—€€³ÿÿÿÿÿÿ“¤þtd€´ÿÿÿÿÿÿ¤M‡1‚€µÿÿÿÿÿÿ§¤BŠƒ€¶ÿÿÿÿÿÿ±¤§¤¤€·ÿÿÿÿÿÿ»¤±¤“¤€¸ÿÿÿÿÿÿŤ»¤‰¤€¹ÿÿÿÿÿÿϤŤ¤€ºÿÿÿÿÿÿÙ¤Ko~ƒ€»ÿÿÿÿÿÿã¤^o-„€¼ÿÿÿÿÿÿí¤v€½ÿÿÿÿÿÿ÷¤—o\…€¾ÿÿÿÿÿÿ¥Ðopu€¿ÿÿÿÿÿÿ ¥¥÷¤€Àÿÿÿÿÿÿ¥ ¥í¤€Áÿÿÿÿÿÿ¥¥ã¤€Âÿÿÿÿÿÿ)¥¥Ù¤€Ãÿÿÿÿÿÿ3¥‡~R†€Äÿÿÿÿÿÿ=¥X‚‡€ÅÿÿÿÿÿÿG¥7u®‡€ÆÿÿÿÿÿÿQ¥]ˆJˆ€Çÿÿÿÿÿÿ[¥>‹øˆ€Èÿÿÿÿÿÿe¥[¥Q¥€Éÿÿÿÿÿÿo¥e¥G¥€Êÿÿÿÿÿÿy¥o¥=¥€Ëÿÿÿÿÿÿƒ¥y¥3¥€Ìÿÿÿÿÿÿ¥^e‰€Íÿÿÿÿÿÿ—¥ƒ Š€Îÿÿÿÿÿÿ¡¥puO2€Ïÿÿÿÿÿÿ«¥øˆ+‹€Ðÿÿÿÿÿÿµ¥Æ‹«¥€Ñÿÿÿÿÿÿ¿¥µ¥¡¥€ÒÿÿÿÿÿÿÉ¥¿¥—¥€Óÿÿÿÿÿÿӥɥ¥€ÔÿÿÿÿÿÿÝ¥Ó¥ƒ¥€Õÿÿÿÿÿÿç¥Ý¥)¥€Öÿÿÿÿÿÿñ¥ç¥Ï¤€×ÿÿÿÿÿÿû¥ñ¥u¤€Øÿÿÿÿÿÿ¦û¥¤€Ùÿÿÿÿÿÿ¦¦;¢€Úÿÿÿÿÿÿ¦¦[ €Ûÿÿÿÿÿÿ#¦¦{ž€ÜSÿÿÿÿÿÿ-¦2.2.€Ý>ÿÿÿÿÿÿ7¦œ-¦@ÞÿÿÿÿÿÿA¦7¦€ßSÿÿÿÿÿÿJ¦$i$i€à>ÿÿÿÿÿÿT¦~J¦@áÿÿÿÿÿÿ^¦T¦€âSÿÿÿÿÿÿg¦f@f@€ã>ÿÿÿÿÿÿq¦4g¦@äÿÿÿÿÿÿ{¦q¦€åSÿÿÿÿÿÿ„¦¦i¦i€æ>ÿÿÿÿÿÿŽ¦<„¦@çÿÿÿÿÿÿ˜¦Ž¦€èSÿÿÿÿÿÿ¡¦ìiìi€é>ÿÿÿÿÿÿ«¦°¡¦@êÿÿÿÿÿÿµ¦«¦€ëÿÿÿÿÿÿ¾¦µ¦˜¦€ìÿÿÿÿÿÿȦ¾¦{¦€íÿÿÿÿÿÿҦȦ^¦€îÿÿÿÿÿÿܦҦA¦€ïSÿÿÿÿÿÿæ¦ÞhÞh€ð>ÿÿÿÿÿÿð¦œæ¦@ñÿÿÿÿÿÿú¦ð¦€òSÿÿÿÿÿÿ§³-³-€ó>ÿÿÿÿÿÿ §~§@ôÿÿÿÿÿÿ§ §€õSÿÿÿÿÿÿ §x1x1€ö>ÿÿÿÿÿÿ*§4 §@÷ÿÿÿÿÿÿ4§*§€øSÿÿÿÿÿÿ=§ºiºi€ù>ÿÿÿÿÿÿG§<=§@úÿÿÿÿÿÿQ§G§€ûSÿÿÿÿÿÿZ§jj€ü>ÿÿÿÿÿÿd§°Z§@ýÿÿÿÿÿÿn§d§€þÿÿÿÿÿÿw§n§Q§€ÿÿÿÿÿÿÿ§w§4§€ÿÿÿÿÿÿ‹§§§€ÿÿÿÿÿÿ•§‹§ú¦€SÿÿÿÿÿÿŸ§ê'ê'€>ÿÿÿÿÿÿ©§œŸ§@ÿÿÿÿÿÿ³§©§€Sÿÿÿÿÿÿ¼§|$|$€>ÿÿÿÿÿÿƧ~¼§@ÿÿÿÿÿÿЧƧ€SÿÿÿÿÿÿÙ§_$_$€ >ÿÿÿÿÿÿã§<Ù§@ ÿÿÿÿÿÿí§ã§€ Sÿÿÿÿÿÿö§£$£$€ >ÿÿÿÿÿÿ¨°ö§@ ÿÿÿÿÿÿ ¨¨€ÿÿÿÿÿÿ¨ ¨í§€ÿÿÿÿÿÿ¨¨Š.€ÿÿÿÿÿÿ'¨¨Ð§€ÿÿÿÿÿÿ1¨'¨³§€Sÿÿÿÿÿÿ;¨ühüh€>ÿÿÿÿÿÿE¨œ;¨@ÿÿÿÿÿÿO¨E¨€SÿÿÿÿÿÿX¨LiLi€>ÿÿÿÿÿÿb¨~X¨@ÿÿÿÿÿÿl¨b¨€Sÿÿÿÿÿÿu¨¿0¿0€>ÿÿÿÿÿÿ¨4u¨@ÿÿÿÿÿÿ‰¨¨€Sÿÿÿÿÿÿ’¨ú,ú,€>ÿÿÿÿÿÿœ¨<’¨@ÿÿÿÿÿÿ¦¨œ¨€Sÿÿÿÿÿÿ¯¨jj€>ÿÿÿÿÿÿ¹¨°¯¨@ ÿÿÿÿÿÿ蹨€!ÿÿÿÿÿÿ̨覨€"ÿÿÿÿÿÿ̨֨‰¨€#ÿÿÿÿÿÿà¨Ö¨l¨€$ÿÿÿÿÿÿê¨à¨O¨€%Sÿÿÿÿÿÿô¨ii€&>ÿÿÿÿÿÿþ¨œô¨@'ÿÿÿÿÿÿ©þ¨€(Sÿÿÿÿÿÿ©`i`i€)>ÿÿÿÿÿÿ©~©@*ÿÿÿÿÿÿ%©©€+Sÿÿÿÿÿÿ.©;2;2€,>ÿÿÿÿÿÿ8©4.©@-ÿÿÿÿÿÿB©8©€.SÿÿÿÿÿÿK©ØiØi€/>ÿÿÿÿÿÿU©<K©@0ÿÿÿÿÿÿ_©U©€1Sÿÿÿÿÿÿh©v.v.€2>ÿÿÿÿÿÿr©°h©@3ÿÿÿÿÿÿ|©r©€4ÿÿÿÿÿÿ…©|©_©€5ÿÿÿÿÿÿ©…©B©€6ÿÿÿÿÿÿ™©©%©€7ÿÿÿÿÿÿ£©™©©€8ÿÿÿÿÿÿ­©£©ê¨€9ÿÿÿÿÿÿ·©­©1¨€:ÿÿÿÿÿÿÁ©·©•§€;ÿÿÿÿÿÿË©Á©Ü¦€<SÿÿÿÿÿÿÕ©~Þh€=>ÿÿÿÿÿÿß©œÕ©@>ÿÿÿÿÿÿé©ß©€?Sÿÿÿÿÿÿò©4ê'€@>ÿÿÿÿÿÿü©œò©@Aÿÿÿÿÿÿªü©€BSÿÿÿÿÿÿª<üh€C>ÿÿÿÿÿÿªœª@Dÿÿÿÿÿÿ#ªª€ESÿÿÿÿÿÿ,ª°i€F>ÿÿÿÿÿÿ6ªœ,ª@Gÿÿÿÿÿÿ@ª6ª€HÿÿÿÿÿÿIª@ª#ª€IÿÿÿÿÿÿSªIªª€Jÿÿÿÿÿÿ]ªSªé©€Kÿÿÿÿÿÿgª]ª—€LSÿÿÿÿÿÿqªœ$i€M>ÿÿÿÿÿÿ{ª~qª@Nÿÿÿÿÿÿ…ª{ª€OSÿÿÿÿÿÿŽª4|$€P>ÿÿÿÿÿÿ˜ª~Žª@Qÿÿÿÿÿÿ¢ª˜ª€RSÿÿÿÿÿÿ«ª<Li€S>ÿÿÿÿÿÿµª~«ª@Tÿÿÿÿÿÿ¿ªµª€USÿÿÿÿÿÿȪ°`i€V>ÿÿÿÿÿÿÒª~Ȫ@WÿÿÿÿÿÿܪҪ€XÿÿÿÿÿÿåªÜª¿ª€Yÿÿÿÿÿÿïªåª¢ª€ZÿÿÿÿÿÿùªïªÛ—€[ÿÿÿÿÿÿ«ùª…ª€\Sÿÿÿÿÿÿ «œf@€]>ÿÿÿÿÿÿ«4 «@^ÿÿÿÿÿÿ!««€_Sÿÿÿÿÿÿ*«~x1€`>ÿÿÿÿÿÿ4«4*«@aÿÿÿÿÿÿ>«4«€bSÿÿÿÿÿÿG«<¿0€c>ÿÿÿÿÿÿQ«4G«@dÿÿÿÿÿÿ[«Q«€eSÿÿÿÿÿÿd«°;2€f>ÿÿÿÿÿÿn«4d«@gÿÿÿÿÿÿx«n«€hÿÿÿÿÿÿ«x«[«€iÿÿÿÿÿÿ‹««O2€jÿÿÿÿÿÿ•«‹«>«€kÿÿÿÿÿÿŸ«•«!«€lSÿÿÿÿÿÿ©«œ¦i€m>ÿÿÿÿÿÿ³«<©«@nÿÿÿÿÿÿ½«³«€oSÿÿÿÿÿÿÆ«~ºi€p>ÿÿÿÿÿÿЫ<Æ«@qÿÿÿÿÿÿګЫ€rSÿÿÿÿÿÿã«4_$€s>ÿÿÿÿÿÿí«<ã«@tÿÿÿÿÿÿ÷«í«€uSÿÿÿÿÿÿ¬°Øi€v>ÿÿÿÿÿÿ ¬<¬@wÿÿÿÿÿÿ¬ ¬€xÿÿÿÿÿÿ¬¬ö˜€yÿÿÿÿÿÿ'¬¬÷«€zÿÿÿÿÿÿ1¬'¬Ú«€{ÿÿÿÿÿÿ;¬1¬½«€|SÿÿÿÿÿÿE¬œìi€}>ÿÿÿÿÿÿO¬°E¬@~ÿÿÿÿÿÿY¬O¬€Sÿÿÿÿÿÿb¬~j€€>ÿÿÿÿÿÿl¬°b¬@ÿÿÿÿÿÿv¬l¬€‚Sÿÿÿÿÿÿ¬4£$€ƒ>ÿÿÿÿÿÿ‰¬°¬@„ÿÿÿÿÿÿ“¬‰¬€…Sÿÿÿÿÿÿœ¬<j€†>ÿÿÿÿÿÿ¦¬°œ¬@‡ÿÿÿÿÿÿ°¬¦¬€ˆÿÿÿÿÿÿ¹¬Ì™°¬€‰ÿÿÿÿÿÿ칬“¬€Šÿÿÿÿÿÿͬìv¬€‹ÿÿÿÿÿÿ׬ͬY¬€Œÿÿÿÿÿÿá¬×¬;¬€ÿÿÿÿÿÿë¬á¬Ÿ«€Žÿÿÿÿÿÿõ¬ë¬«€ÿÿÿÿÿÿÿ¬õ¬gª€>ÿÿÿÿÿÿ ­~æ¦@‘ÿÿÿÿÿÿ­ ­€’>ÿÿÿÿÿÿ­4Ÿ§@“ÿÿÿÿÿÿ&­­€”>ÿÿÿÿÿÿ/­<;¨@•ÿÿÿÿÿÿ9­/­€–>ÿÿÿÿÿÿB­°ô¨@—ÿÿÿÿÿÿL­B­€˜ÿÿÿÿÿÿU­L­9­€™ÿÿÿÿÿÿ_­U­&­€šÿÿÿÿÿÿi­_­­€›ÿÿÿÿÿÿs­i­A¦€œ>ÿÿÿÿÿÿ}­œJ¦@ÿÿÿÿÿÿ‡­}­€ž>ÿÿÿÿÿÿ­4¼§@Ÿÿÿÿÿÿÿš­­€ >ÿÿÿÿÿÿ£­<X¨@¡ÿÿÿÿÿÿ­­£­€¢>ÿÿÿÿÿÿ¶­°©@£ÿÿÿÿÿÿÀ­¶­€¤ÿÿÿÿÿÿÉ­À­­­€¥ÿÿÿÿÿÿÓ­É­š­€¦ÿÿÿÿÿÿÝ­Ó­§€§ÿÿÿÿÿÿç­Ý­‡­€¨>ÿÿÿÿÿÿñ­œg¦@©ÿÿÿÿÿÿû­ñ­€ª>ÿÿÿÿÿÿ®~ §@«ÿÿÿÿÿÿ®®€¬>ÿÿÿÿÿÿ®<u¨@­ÿÿÿÿÿÿ!®®€®>ÿÿÿÿÿÿ*®°.©@¯ÿÿÿÿÿÿ4®*®€°ÿÿÿÿÿÿ=®4®!®€±ÿÿÿÿÿÿG®=®Š.€²ÿÿÿÿÿÿQ®G®®€³ÿÿÿÿÿÿ[®Q®û­€´>ÿÿÿÿÿÿe®œ„¦@µÿÿÿÿÿÿo®e®€¶>ÿÿÿÿÿÿx®~=§@·ÿÿÿÿÿÿ‚®x®€¸>ÿÿÿÿÿÿ‹®4Ù§@¹ÿÿÿÿÿÿ•®‹®€º>ÿÿÿÿÿÿž®°K©@»ÿÿÿÿÿÿ¨®ž®€¼ÿÿÿÿÿÿ±®¨®¦¨€½ÿÿÿÿÿÿ»®±®•®€¾ÿÿÿÿÿÿÅ®»®‚®€¿ÿÿÿÿÿÿϮŮo®€À>ÿÿÿÿÿÿÙ®œ¡¦@Áÿÿÿÿÿÿã®Ù®€Â>ÿÿÿÿÿÿì®~Z§@Ãÿÿÿÿÿÿö®ì®€Ä>ÿÿÿÿÿÿÿ®4ö§@Åÿÿÿÿÿÿ ¯ÿ®€Æ>ÿÿÿÿÿÿ¯<¯¨@Çÿÿÿÿÿÿ¯¯€Èÿÿÿÿÿÿ%¯|©¯€Éÿÿÿÿÿÿ/¯%¯ ¯€Êÿÿÿÿÿÿ9¯/¯ö®€ËÿÿÿÿÿÿC¯9¯ã®€ÌÿÿÿÿÿÿM¯C¯Ï®€ÍÿÿÿÿÿÿW¯M¯[®€Îÿÿÿÿÿÿa¯W¯ç­€Ïÿÿÿÿÿÿk¯a¯s­€Ðÿÿÿÿÿÿu¯y‹ˆ€Ñÿÿÿÿÿÿ¯u¯kb€Òÿÿÿÿÿÿ‰¯¯„€€Óÿÿÿÿÿÿ“¯‰¯ú{€Ôÿÿÿÿÿÿ¯ð{“¯€Õÿÿÿÿÿÿ§¯Œ‹#ˆ€Öÿÿÿÿÿÿ±¯§¯"]€×ÿÿÿÿÿÿ»¯±¯—€€Øÿÿÿÿÿÿů»¯|€Ùÿÿÿÿÿÿϯ |ů€ÚÿÿÿÿÿÿÙ¯Š.-€Ûÿÿÿÿÿÿã¯Ù¯v€Üÿÿÿÿÿÿí¯ã¯Ç-€Ýÿÿÿÿÿÿ÷¯í¯g4€Þÿÿÿÿÿÿ°òh÷¯€ßÿÿÿÿÿÿ °©‹Jˆ€àÿÿÿÿÿÿ° °Ë\€áÿÿÿÿÿÿ°°È€€âÿÿÿÿÿÿ)°°H|€ãÿÿÿÿÿÿ3°?k)°€äÿÿÿÿÿÿ=°Æ‹]ˆ€åÿÿÿÿÿÿG°=°€æÿÿÿÿÿÿQ°çÿÿÿÿÿÿ[°[|€èÿÿÿÿÿÿe°d|€éÿÿÿÿÿÿo°e°3°€êÿÿÿÿÿÿy°o°°€ëÿÿÿÿÿÿƒ°y°Ï¯€ìÿÿÿÿÿÿ°ƒ°¯€íÿÿÿÿÿÿ—°½|“¯€îÿÿÿÿÿÿ¡°8iů€ïÿÿÿÿÿÿ«°ª€÷¯€ðÿÿÿÿÿÿµ°Ñ€)°€ñÿÿÿÿÿÿ¿°ø€€òÿÿÿÿÿÿÉ°¿°µ°€óÿÿÿÿÿÿÓ°É°«°€ôÿÿÿÿÿÿÝ°Ó°¡°€õÿÿÿÿÿÿç°Ý°—°€öÿÿÿÿÿÿñ°“}“¯€÷ÿÿÿÿÿÿû°~iů€øÿÿÿÿÿÿ±ì÷¯€ùÿÿÿÿÿÿ±À„)°€úÿÿÿÿÿÿ±E2€ûÿÿÿÿÿÿ#±±±€üÿÿÿÿÿÿ-±#±±€ýÿÿÿÿÿÿ7±-±û°€þÿÿÿÿÿÿA±7±ñ°€ÿÿÿÿÿÿÿK±°i“¯€ÿÿÿÿÿÿU±'‚ů€ÿÿÿÿÿÿ_±R…÷¯€ÿÿÿÿÿÿi±@ˆ)°€ÿÿÿÿÿÿs±…k€ÿÿÿÿÿÿ}±s±i±€ÿÿÿÿÿÿ‡±}±_±€ÿÿÿÿÿÿ‘±‡±U±€ÿÿÿÿÿÿ›±‘±K±€ÿÿÿÿÿÿ¥±T“¯€ ÿÿÿÿÿÿ¯± jů€ ÿÿÿÿÿÿ¹±fu÷¯€ ÿÿÿÿÿÿñîˆ)°€ ÿÿÿÿÿÿͱ¼‹€ ÿÿÿÿÿÿױͱñ€ÿÿÿÿÿÿá±×±¹±€ÿÿÿÿÿÿë±á±¯±€ÿÿÿÿÿÿõ±ë±¥±€ÿÿÿÿÿÿÿ±õ±›±€ÿÿÿÿÿÿ ²ÿ±A±€ÿÿÿÿÿÿ² ²ç°€ÿÿÿÿÿÿ²²°€Sÿÿÿÿÿÿ'²$iœ€>ÿÿÿÿÿÿ1²~'²€Sÿÿÿÿÿÿ;²f@œ€>ÿÿÿÿÿÿE²4;²€SÿÿÿÿÿÿO²¦iœ€>ÿÿÿÿÿÿY²<O²€Sÿÿÿÿÿÿc²ìiœ€>ÿÿÿÿÿÿm²°c²€ÿÿÿÿÿÿw²m²Y²€ÿÿÿÿÿÿ²w²E²€ÿÿÿÿÿÿ‹²²1²€ ÿÿÿÿÿÿ•²‹²Rx€!SÿÿÿÿÿÿŸ²Þh~€">ÿÿÿÿÿÿ©²œŸ²€#Sÿÿÿÿÿÿ³²x1~€$>ÿÿÿÿÿÿ½²4³²€%SÿÿÿÿÿÿDzºi~€&>ÿÿÿÿÿÿѲ<Dz€'SÿÿÿÿÿÿÛ²j~€(>ÿÿÿÿÿÿå²°Û²€)ÿÿÿÿÿÿï²å²Ñ²€*ÿÿÿÿÿÿù²ï²½²€+ÿÿÿÿÿÿ³ù²(y€,ÿÿÿÿÿÿ ³³©²€-Sÿÿÿÿÿÿ³ê'4€.>ÿÿÿÿÿÿ!³œ³€/Sÿÿÿÿÿÿ+³|$4€0>ÿÿÿÿÿÿ5³~+³€1Sÿÿÿÿÿÿ?³_$4€2>ÿÿÿÿÿÿI³<?³€3SÿÿÿÿÿÿS³£$4€4>ÿÿÿÿÿÿ]³°S³€5ÿÿÿÿÿÿg³]³I³€6ÿÿÿÿÿÿq³g³­$€7ÿÿÿÿÿÿ{³q³5³€8ÿÿÿÿÿÿ…³{³!³€9Sÿÿÿÿÿÿ³üh<€:>ÿÿÿÿÿÿ™³œ³€;Sÿÿÿÿÿÿ£³Li<€<>ÿÿÿÿÿÿ­³~£³€=Sÿÿÿÿÿÿ·³¿0<€>>ÿÿÿÿÿÿÁ³4·³€?Sÿÿÿÿÿÿ˳j<€@>ÿÿÿÿÿÿÕ³°Ë³€Aÿÿÿÿÿÿß³Õ³·z€Bÿÿÿÿÿÿé³ß³Á³€Cÿÿÿÿÿÿó³é³­³€Dÿÿÿÿÿÿý³ó³™³€ESÿÿÿÿÿÿ´i°€F>ÿÿÿÿÿÿ´œ´€GSÿÿÿÿÿÿ´`i°€H>ÿÿÿÿÿÿ%´~´€ISÿÿÿÿÿÿ/´;2°€J>ÿÿÿÿÿÿ9´4/´€KSÿÿÿÿÿÿC´Øi°€L>ÿÿÿÿÿÿM´<C´€MÿÿÿÿÿÿW´{M´€Nÿÿÿÿÿÿa´W´9´€Oÿÿÿÿÿÿk´a´%´€Pÿÿÿÿÿÿu´k´´€Qÿÿÿÿÿÿ´u´ý³€Rÿÿÿÿÿÿ‰´´…³€Sÿÿÿÿÿÿ“´‰´ ³€Tÿÿÿÿÿÿ´“´•²€Uÿÿÿÿÿÿ§´#{jz€Vÿÿÿÿÿÿ±´§´Îy€Wÿÿÿÿÿÿ»´±´y€XÿÿÿÿÿÿÅ´»´\x€YÿÿÿÿÿÿÏ´@{‡z€ZÿÿÿÿÿÿÙ´Ï´ëy€[ÿÿÿÿÿÿã´Ù´2y€\ÿÿÿÿÿÿí´ã´yx€]ÿÿÿÿÿÿ÷´]{¤z€^ÿÿÿÿÿÿµ÷´·$€_ÿÿÿÿÿÿ µµOy€`ÿÿÿÿÿÿµ µ–x€aÿÿÿÿÿÿµz{Áz€bÿÿÿÿÿÿ)µµz€cÿÿÿÿÿÿ3µ)µly€dÿÿÿÿÿÿ=µ3µ³x€eÿÿÿÿÿÿGµ—{Þz€fÿÿÿÿÿÿQµGµ%z€gÿÿÿÿÿÿ[µQµ‰y€hÿÿÿÿÿÿeµ[µÐx€iÿÿÿÿÿÿoµeµ=µ€jÿÿÿÿÿÿyµoµµ€kÿÿÿÿÿÿƒµyµí´€lÿÿÿÿÿÿµƒµÅ´@mÿÿÿÿÿÿ—µ1²@nÿÿÿÿÿÿ µE²@oÿÿÿÿÿÿ©µY²@pÿÿÿÿÿÿ²µm²€qÿÿÿÿÿÿ»µ²µ©µ€rÿÿÿÿÿÿŵ»µ µ€sÿÿÿÿÿÿϵŵ—µ€tÿÿÿÿÿÿٵϵ\x@uÿÿÿÿÿÿ㵩²@vÿÿÿÿÿÿìµ½²@wÿÿÿÿÿÿõµÑ²@xÿÿÿÿÿÿþµå²€yÿÿÿÿÿÿ¶þµõµ€zÿÿÿÿÿÿ¶¶ìµ€{ÿÿÿÿÿÿ¶¶2y€|ÿÿÿÿÿÿ%¶¶ãµ@}ÿÿÿÿÿÿ/¶!³@~ÿÿÿÿÿÿ8¶5³@ÿÿÿÿÿÿA¶I³@€ÿÿÿÿÿÿJ¶]³€ÿÿÿÿÿÿS¶J¶A¶€‚ÿÿÿÿÿÿ]¶S¶·$€ƒÿÿÿÿÿÿg¶]¶8¶€„ÿÿÿÿÿÿq¶g¶/¶@…ÿÿÿÿÿÿ{¶™³@†ÿÿÿÿÿÿ„¶­³@‡ÿÿÿÿÿÿ¶Á³@ˆÿÿÿÿÿÿ–¶Õ³€‰ÿÿÿÿÿÿŸ¶–¶Áz€Šÿÿÿÿÿÿ©¶Ÿ¶¶€‹ÿÿÿÿÿÿ³¶©¶„¶€Œÿÿÿÿÿÿ½¶³¶{¶@ÿÿÿÿÿÿǶ´@Žÿÿÿÿÿÿж%´@ÿÿÿÿÿÿÙ¶9´@ÿÿÿÿÿÿâ¶M´€‘ÿÿÿÿÿÿ붗{ⶀ’ÿÿÿÿÿÿõ¶ë¶Ù¶€“ÿÿÿÿÿÿÿ¶õ¶Ð¶€”ÿÿÿÿÿÿ ·ÿ¶Ç¶€•ÿÿÿÿÿÿ· ·½¶€–ÿÿÿÿÿÿ··q¶€—ÿÿÿÿÿÿ'··%¶€˜ÿÿÿÿÿÿ1·'·Ùµ€™ÿÿÿÿÿÿ;·¼‹@ˆ€šÿÿÿÿÿÿE·;·ì€›ÿÿÿÿÿÿO·E·8i€œÿÿÿÿÿÿY·O·ð{€ÿÿÿÿÿÿc·Ëª|€žÿÿÿÿÿÿm·~ƒc}€Ÿÿÿÿÿÿÿw·R†~€ ÿÿÿÿÿÿ·e‰Ì~€¡ÿÿÿÿÿÿ‹··w·€¢ÿÿÿÿÿÿ•·‹·m·€£ÿÿÿÿÿÿŸ·•·c·€¤ÿÿÿÿÿÿ©·Ÿ·ú{€¥ÿÿÿÿÿÿ³·„4€¦ÿÿÿÿÿÿ½·í†Ú€§ÿÿÿÿÿÿÇ·ö‰‚€¨ÿÿÿÿÿÿÑ·Ç·½·€©ÿÿÿÿÿÿÛ·Ñ·³·€ªÿÿÿÿÿÿå·Û·„€€«ÿÿÿÿÿÿï·å·õœ€¬ÿÿÿÿÿÿù·4„€­ÿÿÿÿÿÿ¸ˆ‡…€®ÿÿÿÿÿÿ ¸}Š«…€¯ÿÿÿÿÿÿ¸ ¸¸€°ÿÿÿÿÿÿ!¸¸kb€±ÿÿÿÿÿÿ+¸!¸ù·€²ÿÿÿÿÿÿ5¸+¸O€³ÿÿÿÿÿÿ?¸Ú톀´ÿÿÿÿÿÿI¸…ˆ‡€µÿÿÿÿÿÿS¸òŠ˜ˆ€¶ÿÿÿÿÿÿ]¸S¸ˆ€·ÿÿÿÿÿÿg¸]¸I¸€¸ÿÿÿÿÿÿq¸g¸?¸€¹ÿÿÿÿÿÿ{¸q¸©€ºÿÿÿÿÿÿ…¸‚ö‰€»ÿÿÿÿÿÿ¸«…}Š€¼ÿÿÿÿÿÿ™¸˜ˆòŠ€½ÿÿÿÿÿÿ£¸y‹™¸€¾ÿÿÿÿÿÿ­¸£¸¸€¿ÿÿÿÿÿÿ·¸­¸…¸€ÀÿÿÿÿÿÿÁ¸·¸ž€Áÿÿÿÿÿÿ˸Á¸{¸€Âÿÿÿÿÿÿո˸5¸€Ãÿÿÿÿÿÿ߸ոﷀÄÿÿÿÿÿÿé¸ß¸©·€Åÿÿÿÿÿÿ󸑃v}€Æÿÿÿÿÿÿý¸e†0~€Çÿÿÿÿÿÿ¹x‰é~€Èÿÿÿÿÿÿ¹¹ý¸€Éÿÿÿÿÿÿ¹¹ó¸€Êÿÿÿÿÿÿ%¹¹ž€Ëÿÿÿÿÿÿ/¹%¹|€Ìÿÿÿÿÿÿ9¹Ç|è€ÍÿÿÿÿÿÿC¹-„Q€ÎÿÿÿÿÿÿM¹‡÷€ÏÿÿÿÿÿÿW¹ Šº‚€Ðÿÿÿÿÿÿa¹W¹M¹€Ñÿÿÿÿÿÿk¹a¹C¹€Òÿÿÿÿÿÿu¹k¹—€€Óÿÿÿÿÿÿ¹u¹9¹€Ôÿÿÿÿÿÿ‰¹v}‘ƒ€Õÿÿÿÿÿÿ“¹›‡"…€Öÿÿÿÿÿÿ¹Š¾…€×ÿÿÿÿÿÿ§¹¹“¹€Øÿÿÿÿÿÿ±¹§¹"]€Ùÿÿÿÿÿÿ»¹±¹9Ÿ€ÚÿÿÿÿÿÿŹ»¹‰¹€ÛÿÿÿÿÿÿϹ0~e†€ÜÿÿÿÿÿÿÙ¹"…›‡€Ýÿÿÿÿÿÿ㹋«ˆ€Þÿÿÿÿÿÿí¹ã¹#ˆ€ßÿÿÿÿÿÿ÷¹í¹Ù¹€àÿÿÿÿÿÿº÷¹“Ÿ€áÿÿÿÿÿÿ ººÏ¹€âÿÿÿÿÿÿºé~x‰€ãÿÿÿÿÿÿº¾…Š€äÿÿÿÿÿÿ)º«ˆ‹€åÿÿÿÿÿÿ3ºŒ‹)º€æÿÿÿÿÿÿ=º3ºº€çÿÿÿÿÿÿGº=ºíŸ€èÿÿÿÿÿÿQºGºº€éÿÿÿÿÿÿ[ºQº º€êÿÿÿÿÿÿeº[ºÅ¹€ëÿÿÿÿÿÿoºeº¹€ìÿÿÿÿÿÿyºoº/¹€íÿÿÿÿÿÿƒº€î|€îÿÿÿÿÿÿºx†C~€ïÿÿÿÿÿÿ—º‹‰€ðÿÿÿÿÿÿ¡º—ºº€ñÿÿÿÿÿÿ«º¡ºy €òÿÿÿÿÿÿµº«ºƒº€óÿÿÿÿÿÿ¿ºµºg4€ôÿÿÿÿÿÿɺî|€€õÿÿÿÿÿÿÓº‡‚€öÿÿÿÿÿÿݺŠ×‚€÷ÿÿÿÿÿÿçºÝºÓº€øÿÿÿÿÿÿñºçºÓ €ùÿÿÿÿÿÿûºñºÇ-€úÿÿÿÿÿÿ»ûºÉº€ûÿÿÿÿÿÿ»}¤ƒ€üÿÿÿÿÿÿ»d@„€ýÿÿÿÿÿÿ#»®‡?…€þÿÿÿÿÿÿ-»O2·$€ÿÿÿÿÿÿÿ7»-»#»€ÿÿÿÿÿÿA»7»v€ÿÿÿÿÿÿK»A»»€ÿÿÿÿÿÿU»K»»€ÿÿÿÿÿÿ_»C~x†€ÿÿÿÿÿÿi»‚‡€ÿÿÿÿÿÿs»‹¾ˆ€ÿÿÿÿÿÿ}»s»-€ÿÿÿÿÿÿ‡»}»}¡€ÿÿÿÿÿÿ‘»‡»i»€ ÿÿÿÿÿÿ›»‘»_»€ ÿÿÿÿÿÿ¥»‹‰€ ÿÿÿÿÿÿ¯»×‚Š€ ÿÿÿÿÿÿ¹»¾ˆ‹€ ÿÿÿÿÿÿûŠ.¹»€ÿÿÿÿÿÿͻûס€ÿÿÿÿÿÿ׻ͻ¯»€ÿÿÿÿÿÿá»×»¥»€ÿÿÿÿÿÿë»á»›»€ÿÿÿÿÿÿõ»ë»U»€ÿÿÿÿÿÿÿ»õ»»€ÿÿÿÿÿÿ ¼ÿ»¿º€ÿÿÿÿÿÿ¼"€}€ÿÿÿÿÿÿ¼Áƒº}€ÿÿÿÿÿÿ'¼ž‰7€ÿÿÿÿÿÿ1¼'¼c¢€ÿÿÿÿÿÿ;¼1¼¼€ÿÿÿÿÿÿE¼;¼¼€ÿÿÿÿÿÿO¼E¼H|€ÿÿÿÿÿÿY¼}"€€ÿÿÿÿÿÿc¼]„€ÿÿÿÿÿÿm¼/Šþ‚€ÿÿÿÿÿÿw¼m¼½¢€ ÿÿÿÿÿÿ¼w¼c¼€!ÿÿÿÿÿÿ‹¼¼È€€"ÿÿÿÿÿÿ•¼‹¼Y¼€#ÿÿÿÿÿÿŸ¼º}Áƒ€$ÿÿÿÿÿÿ©¼]„€%ÿÿÿÿÿÿ³¼­ŠÛ…€&ÿÿÿÿÿÿ½¼³¼£€'ÿÿÿÿÿÿǼ½¼Ë\€(ÿÿÿÿÿÿѼǼ©¼€)ÿÿÿÿÿÿۼѼŸ¼€*ÿÿÿÿÿÿå¼`~•†€+ÿÿÿÿÿÿï¼1‚0‡€,ÿÿÿÿÿÿù¼\…Á‡€-ÿÿÿÿÿÿ½+‹Ûˆ€.ÿÿÿÿÿÿ ½½Jˆ€/ÿÿÿÿÿÿ½ ½ù¼€0ÿÿÿÿÿÿ!½½ï¼€1ÿÿÿÿÿÿ+½!½å¼€2ÿÿÿÿÿÿ5½7ž‰€3ÿÿÿÿÿÿ?½þ‚/Š€4ÿÿÿÿÿÿI½Û…­Š€5ÿÿÿÿÿÿS½©‹Á£€6ÿÿÿÿÿÿ]½S½I½€7ÿÿÿÿÿÿg½]½?½€8ÿÿÿÿÿÿq½g½5½€9ÿÿÿÿÿÿ{½q½+½€:ÿÿÿÿÿÿ…½{½Û¼€;ÿÿÿÿÿÿ½…½•¼€<ÿÿÿÿÿÿ™½½O¼€=ÿÿÿÿÿÿ£½I€}€>ÿÿÿÿÿÿ­½ëtKo€?ÿÿÿÿÿÿ·½¨†‡~€@ÿÿÿÿÿÿÁ½M¤·½€Aÿÿÿÿÿÿ˽Á½­½€Bÿÿÿÿÿÿս˽£½€Cÿÿÿÿÿÿß½Õ½[|€Dÿÿÿÿÿÿé½}I€€Eÿÿÿÿÿÿó½þt^o€Fÿÿÿÿÿÿý½M‡X‚€Gÿÿÿÿÿÿ¾§¤ý½€Hÿÿÿÿÿÿ¾¾ó½€Iÿÿÿÿÿÿ¾¾ï€€Jÿÿÿÿÿÿ%¾¾é½€Kÿÿÿÿÿÿ/¾Koët€Lÿÿÿÿÿÿ9¾^oþt€MÿÿÿÿÿÿC¾—o7u€NÿÿÿÿÿÿM¾¥C¾€OÿÿÿÿÿÿW¾M¾Ô„€Pÿÿÿÿÿÿa¾W¾9¾€Qÿÿÿÿÿÿk¾a¾/¾€Rÿÿÿÿÿÿu¾‡~¨†€Sÿÿÿÿÿÿ¾X‚M‡€Tÿÿÿÿÿÿ‰¾7u—o€Uÿÿÿÿÿÿ“¾[¥]ˆ€Vÿÿÿÿÿÿ¾“¾‰¾€Wÿÿÿÿÿÿ§¾¾¾€Xÿÿÿÿÿÿ±¾§¾u¾€Yÿÿÿÿÿÿ»¾^»‰€ZÿÿÿÿÿÿžƒBŠ€[ÿÿÿÿÿÿϾpuÐo€\ÿÿÿÿÿÿÙ¾øˆ>‹€]ÿÿÿÿÿÿã¾Æ‹Ù¾€^ÿÿÿÿÿÿí¾ã¾Ï¾€_ÿÿÿÿÿÿ÷¾í¾Å¾€`ÿÿÿÿÿÿ¿÷¾»¾€aÿÿÿÿÿÿ ¿¿±¾€bÿÿÿÿÿÿ¿ ¿k¾€cÿÿÿÿÿÿ¿¿%¾€dÿÿÿÿÿÿ)¿¿ß½€eÿÿÿÿÿÿ3¿)¿™½€fÿÿÿÿÿÿ=¿3¿ ¼€gÿÿÿÿÿÿG¿=¿yº€hÿÿÿÿÿÿQ¿G¿é¸€iÿÿÿÿÿÿ[¿[°)°€jÿÿÿÿÿÿe¿[¿÷¯€kÿÿÿÿÿÿo¿e¿Å¯€lÿÿÿÿÿÿy¿o¿“¯€mÿÿÿÿÿÿƒ¿öi ~€nÿÿÿÿÿÿ¿ƒ¿Y}€oÿÿÿÿÿÿ—¿¿ |€pÿÿÿÿÿÿ¡¿—¿ð{€qÿÿÿÿÿÿ«¿d|?k€rÿÿÿÿÿÿµ¿«¿òh€sÿÿÿÿÿÿ¿¿µ¿ |€tÿÿÿÿÿÿÉ¿¿¿ð{€uÿÿÿÿÿÿÓ¿É¿¡¿€vÿÿÿÿÿÿÝ¿ß~&~€wÿÿÿÿÿÿç¿Ý¿ti€xÿÿÿÿÿÿñ¿ç¿½|€yÿÿÿÿÿÿû¿ñ¿ |€zÿÿÿÿÿÿÀi+€€{ÿÿÿÿÿÿÀÀ€€|ÿÿÿÿÿÿÀÀÞ€}ÿÿÿÿÿÿ#ÀÀ |€~ÿÿÿÿÿÿ-À#Àû¿€ÿÿÿÿÿÿ7Àqk€€ÿÿÿÿÿÿAÀ7À“}€ÿÿÿÿÿÿKÀAÀä|€‚ÿÿÿÿÿÿUÀKÀ]4€ƒÿÿÿÿÿÿ_Àރʃ€„ÿÿÿÿÿÿiÀ_À5k€…ÿÿÿÿÿÿsÀiÀû€†ÿÿÿÿÿÿ}ÀsÀ]4€‡ÿÿÿÿÿÿ‡À}ÀUÀ€ˆÿÿÿÿÿÿ‘À-°i€‰ÿÿÿÿÿÿ›À‘À°}€Šÿÿÿÿÿÿ¥À›ÀIk€‹ÿÿÿÿÿÿ¯À¥À>|€Œÿÿÿÿÿÿ¹À±†‹†€ÿÿÿÿÿÿÃÀ¹À·ƒ€ŽÿÿÿÿÿÿÍÀÃÀèh€ÿÿÿÿÿÿ×ÀÍÀ>|€ÿÿÿÿÿÿáÀ×À¯À€‘ÿÿÿÿÿÿëÀT}~€’ÿÿÿÿÿÿõÀëÀAo€“ÿÿÿÿÿÿÿÀõÀ.i€”ÿÿÿÿÿÿ ÁÿÀ+k€•ÿÿÿÿÿÿÁ±‰i€–ÿÿÿÿÿÿÁÁát€—ÿÿÿÿÿÿ'ÁÁ?€€˜ÿÿÿÿÿÿ1Á'Á+k€™ÿÿÿÿÿÿ;Á1Á Á€šÿÿÿÿÿÿEÁ;ÁáÀ€›ÿÿÿÿÿÿOÁEÁ‡À€œÿÿÿÿÿÿYÁOÁ-À€ÿÿÿÿÿÿcÁYÁÓ¿€žÿÿÿÿÿÿmÁò~Äi€ŸÿÿÿÿÿÿwÁmÁ}€ ÿÿÿÿÿÿÁwÁÐ|€¡ÿÿÿÿÿÿ‹ÁÁ |€¢ÿÿÿÿÿÿ•Á}Vi€£ÿÿÿÿÿÿŸÁ•ÁSk€¤ÿÿÿÿÿÿ©ÁŸÁÐ|€¥ÿÿÿÿÿÿ³Á©Á |€¦ÿÿÿÿÿÿ½Á³Á‹Á€§ÿÿÿÿÿÿÇÁ°‚퀨ÿÿÿÿÿÿÑÁÇÁG€©ÿÿÿÿÿÿÛÁÑÁ8i€ªÿÿÿÿÿÿåÁÛÁÞ€«ÿÿÿÿÿÿïÁø€Ñ€€¬ÿÿÿÿÿÿùÁïÁª€€­ÿÿÿÿÿÿÂùÁ8i€®ÿÿÿÿÿÿ ½|€¯ÿÿÿÿÿÿ ÂåÁ€°ÿÿÿÿÿÿ!ÂÍ‚ ‚€±ÿÿÿÿÿÿ+Â!Â~i€²ÿÿÿÿÿÿ5Â+½-€³ÿÿÿÿÿÿ?Â5Âû€´ÿÿÿÿÿÿIÂp„]k€µÿÿÿÿÿÿSÂIÂBi€¶ÿÿÿÿÿÿ]ÂS½-€·ÿÿÿÿÿÿgÂ]Âä|€¸ÿÿÿÿÿÿqÂgÂ?€¹ÿÿÿÿÿÿ{Âô‚'‚€ºÿÿÿÿÿÿ…Â{Âw€»ÿÿÿÿÿÿ…¾€€¼ÿÿÿÿÿÿ™ÂÂèh€½ÿÿÿÿÿÿ£Âji&‡€¾ÿÿÿÿÿÿ­Â£ÂS„€¿ÿÿÿÿÿÿ·Â­Â¾€€ÀÿÿÿÿÿÿÁ·ÂIk€ÁÿÿÿÿÿÿËÂÁ™€ÂÿÿÿÿÿÿÕ jN‚€ÃÿÿÿÿÿÿßÂÕÂTo€ÄÿÿÿÿÿÿéÂßÂ倀ÅÿÿÿÿÿÿóÂéÂ?€€ÆÿÿÿÿÿÿýÂgkC‡€ÇÿÿÿÿÿÿÃýÂôt€ÈÿÿÿÿÿÿÃÃ倀ÉÿÿÿÿÿÿÃÃ.i€Êÿÿÿÿÿÿ%ÃÃó€Ëÿÿÿÿÿÿ/Ã%ÃË€Ìÿÿÿÿÿÿ9Ã/Ãq€ÍÿÿÿÿÿÿCÃ9ÀÎÿÿÿÿÿÿMÃCýÁ€ÏÿÿÿÿÿÿWÃL~€ÐÿÿÿÿÿÿaÃWÃab€ÑÿÿÿÿÿÿkÃaÃSk€ÒÿÿÿÿÿÿuÃkÃòh€ÓÿÿÿÿÿÿÃœiÃ}€Ôÿÿÿÿÿÿ‰ÃÃab€Õÿÿÿÿÿÿ“ÉÃ}€ÖÿÿÿÿÿÿÓÃY}€×ÿÿÿÿÿÿ§ÃÃuÀØÿÿÿÿÿÿ±Ãà‚Îi€Ùÿÿÿÿÿÿ»Ã±Ã]€ÚÿÿÿÿÿÿÅûꀀÛÿÿÿÿÿÿÏÃÅÀ€ÜÿÿÿÿÿÿÙÞŠ€ÝÿÿÿÿÿÿãÃÙÃ]€ÞÿÿÿÿÿÿíÃãÃG€ßÿÿÿÿÿÿ÷ÃíÃti€àÿÿÿÿÿÿÄ÷ÃÏÀáÿÿÿÿÿÿ Ä­$5…€âÿÿÿÿÿÿÄ Äì€ãÿÿÿÿÿÿÄÄBi€äÿÿÿÿÿÿ)ÄÄ5k€åÿÿÿÿÿÿ3ÄE2À„€æÿÿÿÿÿÿ=Ä3Äì€çÿÿÿÿÿÿGÄ=Ä~i€èÿÿÿÿÿÿQÄGÄ“}€éÿÿÿÿÿÿ[ÄQÄ)Ä€êÿÿÿÿÿÿeÄjR…€ëÿÿÿÿÿÿoÄeÄÁ\€ìÿÿÿÿÿÿyÄoÄS„€íÿÿÿÿÿÿƒÄyÄ·ƒ€îÿÿÿÿÿÿÄÔ‡’i€ïÿÿÿÿÿÿ—ÄÄÁ\€ðÿÿÿÿÿÿ¡Ä—Äw€ñÿÿÿÿÿÿ«Ä¡Ä°}€òÿÿÿÿÿÿµÄ«ÄƒÄ€óÿÿÿÿÿÿ¿Äfu-u€ôÿÿÿÿÿÿÉĿĈi€õÿÿÿÿÿÿÓÄÉÄôt€öÿÿÿÿÿÿÝÄÓÄát€÷ÿÿÿÿÿÿçÄÆoo€øÿÿÿÿÿÿñÄçĈi€ùÿÿÿÿÿÿûÄñÄTo€úÿÿÿÿÿÿÅûÄAo€ûÿÿÿÿÿÿÅÅÝÄ€üÿÿÿÿÿÿÅŵĀýÿÿÿÿÿÿ#ÅÅ[Ä€þÿÿÿÿÿÿ-Å#ÅÄ€ÿÿÿÿÿÿÿ7Å-ŧÀÿÿÿÿÿÿAÅ@i~€ÿÿÿÿÿÿKÅAÅÃ}€ÿÿÿÿÿÿUÅKÅVi€ÿÿÿÿÿÿ_ÅUÅ?k€ÿÿÿÿÿÿiÅ~i~€ÿÿÿÿÿÿsÅiÅL~€ÿÿÿÿÿÿ}ÅsÅÄi€ÿÿÿÿÿÿ‡Å}Å ~€ÿÿÿÿÿÿ‘ŇÅ_Å€ ÿÿÿÿÿÿ›Å(j:‚€ ÿÿÿÿÿÿ¥Å›ÅŠ€ ÿÿÿÿÿÿ¯Å¥ÅÑ€€ ÿÿÿÿÿÿ¹Å¯Å+€€ ÿÿÿÿÿÿÃÅa‚:‚€ÿÿÿÿÿÿÍÅÃÅÎi€ÿÿÿÿÿÿ×ÅÍÅí€ÿÿÿÿÿÿáÅ×Å&~€ÿÿÿÿÿÿëÅáŹŀÿÿÿÿÿÿõÅä…-€ÿÿÿÿÿÿÿÅõÅÀ„€ÿÿÿÿÿÿ ÆÿÅ]k€ÿÿÿÿÿÿÆ Æʃ€ÿÿÿÿÿÿÆo…-€ÿÿÿÿÿÿ'ÆÆ5…€ÿÿÿÿÿÿ1Æ'Æ ‚€ÿÿÿÿÿÿ;Æ1Æqk€ÿÿÿÿÿÿEÆ;ÆÆ€ÿÿÿÿÿÿOÆш@ˆ€ÿÿÿÿÿÿYÆOÆ’i€ÿÿÿÿÿÿcÆYÆ&‡€ÿÿÿÿÿÿmÆcÆ‹†€ÿÿÿÿÿÿwÆ…k@ˆ€ ÿÿÿÿÿÿÆwÆR…€!ÿÿÿÿÿÿ‹ÆÆ'‚€"ÿÿÿÿÿÿ•Æ‹Æ°i€#ÿÿÿÿÿÿŸÆ•ÆmÆ€$ÿÿÿÿÿÿ©Æîˆ{k€%ÿÿÿÿÿÿ³Æ©Æo€&ÿÿÿÿÿÿ½Æ³ÆC‡€'ÿÿÿÿÿÿÇƽÆi€(ÿÿÿÿÿÿÑÆâi{k€)ÿÿÿÿÿÿÛÆÑÆ-u€*ÿÿÿÿÿÿåÆÛÆN‚€+ÿÿÿÿÿÿïÆåÆ}~€,ÿÿÿÿÿÿùÆïÆÇÆ€-ÿÿÿÿÿÿÇùÆŸÆ€.ÿÿÿÿÿÿ ÇÇEÆ€/ÿÿÿÿÿÿÇ ÇëÅ€0ÿÿÿÿÿÿ!ÇÇ‘Å€1ÿÿÿÿÿÿ+Çg~€2ÿÿÿÿÿÿ5Ç+Çœi€3ÿÿÿÿÿÿ?Ç5Ç}€4ÿÿÿÿÿÿIÇ?Çd|€5ÿÿÿÿÿÿSÇg@€6ÿÿÿÿÿÿ]ÇSÇ€7ÿÿÿÿÿÿgÇ]Çò~€8ÿÿÿÿÿÿqÇgÇöi€9ÿÿÿÿÿÿ{ÇqÇIÇ€:ÿÿÿÿÿÿ…ǃa‚€;ÿÿÿÿÿÿÇ…Çž€<ÿÿÿÿÿÿ™ÇÇø€€=ÿÿÿÿÿÿ£Ç™Çi€>ÿÿÿÿÿÿ­Çƒ(j€?ÿÿÿÿÿÿ·Ç­Çà‚€@ÿÿÿÿÿÿÁÇ·Ç°‚€AÿÿÿÿÿÿËÇÁÇß~€BÿÿÿÿÿÿÕÇËǣǀCÿÿÿÿÿÿßÇ€.o…€DÿÿÿÿÿÿéÇßÇE2€EÿÿÿÿÿÿóÇéÇp„€FÿÿÿÿÿÿýÇóÇÞƒ€GÿÿÿÿÿÿÈ€.ä…€HÿÿÿÿÿÿÈÈ­$€IÿÿÿÿÿÿÈÈÍ‚€Jÿÿÿÿÿÿ%ÈÈ€Kÿÿÿÿÿÿ/È%ÈýÇ€Lÿÿÿÿÿÿ9ȉ…k€MÿÿÿÿÿÿCÈ9ÈÔ‡€NÿÿÿÿÿÿMÈCÈji€OÿÿÿÿÿÿWÈMȱ†€Pÿÿÿÿÿÿaȉш€QÿÿÿÿÿÿkÈaÈj€RÿÿÿÿÿÿuÈkÈô‚€SÿÿÿÿÿÿÈuÈ-€Tÿÿÿÿÿÿ‰ÈÈWÈ€Uÿÿÿÿÿÿ“ȼ‹âi€VÿÿÿÿÿÿÈ“ÈÆo€Wÿÿÿÿÿÿ§ÈÈgk€Xÿÿÿÿÿÿ±È§È±‰€Yÿÿÿÿÿÿ»È¼‹îˆ€ZÿÿÿÿÿÿÅÈ»Èfu€[ÿÿÿÿÿÿÏÈÅÈ j€\ÿÿÿÿÿÿÙÈÏÈT€]ÿÿÿÿÿÿãÈÙȱȀ^ÿÿÿÿÿÿíÈãȉȀ_ÿÿÿÿÿÿ÷ÈíÈ/È€`ÿÿÿÿÿÿÉ÷ÈÕÇ€aÿÿÿÿÿÿ ÉÉ{Ç€bÿÿÿÿÿÿÉ É!Ç€cÿÿÿÿÿÿÉÉ7Å€dÿÿÿÿÿÿ)ÉÉMÀeÿÿÿÿÿÿ3É)ÉcÁ€fÿÿÿÿÿÿ=É+k>|€gÿÿÿÿÿÿGÉ=É]4€hÿÿÿÿÿÿQÉGÉ |€iÿÿÿÿÿÿ[ÉQÉð{€jÿÿÿÿÿÿeÉ?€èh€kÿÿÿÿÿÿoÉeÉû€lÿÿÿÿÿÿyÉoÉÞ€mÿÿÿÿÿÿƒÉyÉ |€nÿÿÿÿÿÿÉát·ƒ€oÿÿÿÿÿÿ—ÉÉ5k€pÿÿÿÿÿÿ¡É—É€€qÿÿÿÿÿÿ«É¡Éòh€rÿÿÿÿÿÿµÉi‹†€sÿÿÿÿÿÿ¿ÉµÉʃ€tÿÿÿÿÿÿÉÉ¿É+€€uÿÿÿÿÿÿÓÉÉÉ?k€vÿÿÿÿÿÿÝɱ‰±†€wÿÿÿÿÿÿçÉÝÉÞƒ€xÿÿÿÿÿÿñÉçÉi€yÿÿÿÿÿÿûÉñÉd|€zÿÿÿÿÿÿÊûÉÓÉ€{ÿÿÿÿÿÿÊÊ«É€|ÿÿÿÿÿÿÊʃɀ}ÿÿÿÿÿÿ#ÊÊ[É€~ÿÿÿÿÿÿ-Ê.iIk€ÿÿÿÿÿÿ7Ê-Êä|€€ÿÿÿÿÿÿAÊ7ʽ|€ÿÿÿÿÿÿKÊAÊ |€‚ÿÿÿÿÿÿUÊ倾€€ƒÿÿÿÿÿÿ_ÊUʽ-€„ÿÿÿÿÿÿiÊ_Ê8i€…ÿÿÿÿÿÿsÊiÊÐ|€†ÿÿÿÿÿÿ}ÊôtS„€‡ÿÿÿÿÿÿ‡Ê}ÊBi€ˆÿÿÿÿÿÿ‘ʇʪ€€‰ÿÿÿÿÿÿ›Ê‘ÊSk€Šÿÿÿÿÿÿ¥ÊC‡&‡€‹ÿÿÿÿÿÿ¯Ê¥Ê]k€Œÿÿÿÿÿÿ¹Ê¯ÊÑ€€ÿÿÿÿÿÿÃʹÊVi€ŽÿÿÿÿÿÿÍÊgkji€ÿÿÿÿÿÿ×ÊÍÊp„€ÿÿÿÿÿÿáÊ×Êø€€‘ÿÿÿÿÿÿëÊáÊ}€’ÿÿÿÿÿÿõÊëÊÃÊ€“ÿÿÿÿÿÿÿÊõʛʀ”ÿÿÿÿÿÿ ËÿÊsÊ€•ÿÿÿÿÿÿË ËKÊ€–ÿÿÿÿÿÿËAo°}€—ÿÿÿÿÿÿ'ËË“}€˜ÿÿÿÿÿÿ1Ë'Ëti€™ÿÿÿÿÿÿ;Ë1ËY}€šÿÿÿÿÿÿEËTow€›ÿÿÿÿÿÿOËEË~i€œÿÿÿÿÿÿYËOËG€ÿÿÿÿÿÿcËYË}€žÿÿÿÿÿÿmˈiÁ\€ŸÿÿÿÿÿÿwËmË쀠ÿÿÿÿÿÿËwË]€¡ÿÿÿÿÿÿ‹ËËab€¢ÿÿÿÿÿÿ•Ëo’i€£ÿÿÿÿÿÿŸË•ËÀ„€¤ÿÿÿÿÿÿ©ËŸËŠ€¥ÿÿÿÿÿÿ³Ë©ËÃ}€¦ÿÿÿÿÿÿ½ËÆoÔ‡€§ÿÿÿÿÿÿÇ˽ËE2€¨ÿÿÿÿÿÿÑËÇËž€©ÿÿÿÿÿÿÛËÑËœi€ªÿÿÿÿÿÿåËÛ˳ˀ«ÿÿÿÿÿÿïËåË‹Ë€¬ÿÿÿÿÿÿùËïËcË€­ÿÿÿÿÿÿÌùË;Ë€®ÿÿÿÿÿÿ Ì}~°i€¯ÿÿÿÿÿÿÌ Ìqk€°ÿÿÿÿÿÿ!ÌÌ&~€±ÿÿÿÿÿÿ+Ì!Ì ~€²ÿÿÿÿÿÿ5ÌN‚'‚€³ÿÿÿÿÿÿ?Ì5Ì ‚€´ÿÿÿÿÿÿIÌ?Ì퀵ÿÿÿÿÿÿSÌIÌÄi€¶ÿÿÿÿÿÿ]Ì-uR…€·ÿÿÿÿÿÿgÌ]Ì5…€¸ÿÿÿÿÿÿqÌgÌÎi€¹ÿÿÿÿÿÿ{ÌqÌL~€ºÿÿÿÿÿÿ…Ì{k@ˆ€»ÿÿÿÿÿÿÌ…Ì-€¼ÿÿÿÿÿÿ™ÌÌ:‚€½ÿÿÿÿÿÿ£Ì™Ìi~€¾ÿÿÿÿÿÿ­Ìâi…k€¿ÿÿÿÿÿÿ·Ì­Ìo…€ÀÿÿÿÿÿÿÁÌ·Ìa‚€ÁÿÿÿÿÿÿËÌÁÌ~€ÂÿÿÿÿÿÿÕÌẸ̈̀ÃÿÿÿÿÿÿßÌÕÌ{Ì€ÄÿÿÿÿÿÿéÌßÌSÌ€ÅÿÿÿÿÿÿóÌéÌ+Ì€ÆÿÿÿÿÿÿýÌT-€ÇÿÿÿÿÿÿÍýÌ€ÈÿÿÿÿÿÿÍÍß~€ÉÿÿÿÿÿÿÍÍöi€Êÿÿÿÿÿÿ%Í jô‚€Ëÿÿÿÿÿÿ/Í%ÍÍ‚€Ìÿÿÿÿÿÿ9Í/Í°‚€ÍÿÿÿÿÿÿCÍ9Íò~€ÎÿÿÿÿÿÿMÍfuj€ÏÿÿÿÿÿÿWÍMÍ­$€ÐÿÿÿÿÿÿaÍWÍà‚€ÑÿÿÿÿÿÿkÍaÍ€ÒÿÿÿÿÿÿuÍîˆÑˆ€ÓÿÿÿÿÿÿÍuÍä…€Ôÿÿÿÿÿÿ‰ÍÍ(j€Õÿÿÿÿÿÿ“͉Í@€Öÿÿÿÿÿÿͼ‹‰€×ÿÿÿÿÿÿ§ÍÍ€.€Øÿÿÿÿÿÿ±Í§Íƒ€Ùÿÿÿÿÿÿ»Í±Íg€ÚÿÿÿÿÿÿÅͻ͓̀ÛÿÿÿÿÿÿÏÍÅÍkÍ€ÜÿÿÿÿÿÿÙÍÏÍCÍ€ÝÿÿÿÿÿÿãÍÙÍÍ€ÞÿÿÿÿÿÿíÍãÍóÌ€ßÿÿÿÿÿÿ÷ÍíÍÌ€àÿÿÿÿÿÿÎ÷ÍË€áÿÿÿÿÿÿ ÎÎ#ÊâÿÿÿÿÿÿÎ Î3Éy¿Q¿Y·1·µ´²k¯ÿ¬Ë©#¦›œšç–÷•GŒæ{>xôltlWl"k6ãÿÿÿÿÿÿ5Î ÙÙóØæØÙØÌؿزإؘ؋Ø~ØdØWØJØ=Ø0Ø#ØØ Øü×ï×â×Õ×È׻׮סהׇ×z×m×`×S×F×9×,××××øÖëÖÞÖÑÖªÖÖÖƒÖvÖiÖ\ÖOÖBÖ5Ö(ÖÖÖÖôÕçÕÚÕÍÕÀÕ³Õ¦Õ™ÕŒÕÕeÕKÕ1ÕÕäÚØÚÓËÚ¾Ú±Ú•ÚˆÚ{ÚnÚaÚ/ÑÑûÐáÐÇÐ3Ú&ÚÚØْϸÙPÏ/Ï«Ù³w wwzwgwTwAw.www›vˆvuvbvOv‹Jˆ?…÷~@ÿÿÿÿÿÿÒÆ‹Ûˆ·$º‚Ì~@ ÿÿÿÿÿÿ"Ò%zz·$ëyÎy@ ÿÿÿÿÿÿ/ÒÞzÁz¤z‡zjz@ ÿÿÿÿÿÿ<Ò—{z{]{@{#{@ ÿÿÿÿÿÿIÒðÔãÔÖÔÉÔVÒ@ ÿÿÿÿÿÿVÒµ¦˜¦{¦^¦A¦@ÿÿÿÿÿÿcÒ¼Ô¯Ô¢Ô•ÔpÒ@ÿÿÿÿÿÿpÒ@ª#ªªé©—@ÿÿÿÿÿÿ}ÒˆÔ{ÔnÔaÔŠÒ@ÿÿÿÿÿÿŠÒL­9­&­­A¦@ÿÿÿÿÿÿ—Òñ¹±¯±¥±i±_±U±K±±±û°ñ°µ°«°¡°—°3°°Ï¯¯@ÿÿÿÿÿÿ¸ÒTÔGÔ:Ô-ÔÅÒ@ÿÿÿÿÿÿÅÒm²Y²E²1²Rx@ÿÿÿÿÿÿÒÒ ÔÔÔùÓßÒ@ÿÿÿÿÿÿßÒ#{jzÎyy\x@ÿÿÿÿÿÿìÒìÓßÓÒÓÓùÒ@ÿÿÿÿÿÿùÒ²µ©µ µ—µ\x@ÿÿÿÿÿÿÓ¼‹@ˆì8ið{@ÿÿÿÿÿÿÓþµõµìµ2yãµ@ÿÿÿÿÿÿ ÓÓoÓNÓ-Ó@ÿÿÿÿÿÿ-Óy‹™¸¸…¸žS¸ˆI¸?¸© ¸¸kbù·OÇ·½·³·„€õœ·w·m·c·ú{@ÿÿÿÿÿÿNÓŒ‹)ººíŸºã¹#ˆÙ¹“ŸÏ¹¹“¹"]9Ÿ‰¹W¹M¹C¹—€9¹¹ý¸ó¸ž|@ÿÿÿÿÿÿoÓŠ.¹»×¡¯»¥»s»-}¡i»_»-»#»v»»ÝºÓºÓ Ç-ɺ—ººy ƒºg4@ÿÿÿÿÿÿÓ©‹Á£I½?½5½½Jˆù¼ï¼å¼³¼£Ë\©¼Ÿ¼m¼½¢c¼È€Y¼'¼c¢¼¼H|@ ÿÿÿÿÿÿ±ÓƋپϾž»¾[¥]ˆ‰¾¾u¾¥C¾9¾/¾§¤ý½ó½ï€é½M¤·½­½£½[|@!ÿÿÿÿÿÿÒÓJ¶A¶·$8¶/¶@"ÿÿÿÿÿÿßÓ–¶Áz¶„¶{¶@#ÿÿÿÿÿÿìÓ—{â¶Ù¶Ð¶Ç¶@$ÿÿÿÿÿÿùÓ@{‡zëy2yyx@%ÿÿÿÿÿÿÔ]{¤z·$Oy–x@&ÿÿÿÿÿÿÔz{Ázzly³x@'ÿÿÿÿÿÿ Ô—{Þz%z‰yÐx@(ÿÿÿÿÿÿ-Ôå²Ñ²½²(y©²@)ÿÿÿÿÿÿ:Ô]³I³­$5³!³@*ÿÿÿÿÿÿGÔÕ³·zÁ³­³™³@+ÿÿÿÿÿÿTÔ{M´9´%´´@,ÿÿÿÿÿÿaÔÀ­­­š­§‡­@-ÿÿÿÿÿÿnÔ4®!®Š.®û­@.ÿÿÿÿÿÿ{Ô¨®¦¨•®‚®o®@/ÿÿÿÿÿÿˆÔ|©¯ ¯ö®ã®@0ÿÿÿÿÿÿ•Ôܪ¿ª¢ªÛ—…ª@1ÿÿÿÿÿÿ¢Ôx«[«O2>«!«@2ÿÿÿÿÿÿ¯Ô¬ö˜÷«Ú«½«@3ÿÿÿÿÿÿ¼ÔÌ™°¬“¬v¬Y¬@4ÿÿÿÿÿÿÉÔn§Q§4§§ú¦@5ÿÿÿÿÿÿÖÔ ¨í§Š.Ч³§@6ÿÿÿÿÿÿãÔ覨‰¨l¨O¨@7ÿÿÿÿÿÿðÔ|©_©B©%©©@8ÿÿÿÿÿÿýÔXÕ>Õ$Õ Õ@9ÿÿÿÿÿÿ Õy‹ˆkb„€ú{@:ÿÿÿÿÿÿÕöi ~Y} |ð{@;ÿÿÿÿÿÿ$ÕŒ‹#ˆ"]—€|@<ÿÿÿÿÿÿ1Õd|?kòh |ð{@=ÿÿÿÿÿÿ>ÕŠ.-vÇ-g4@>ÿÿÿÿÿÿKÕß~&~ti½| |@?ÿÿÿÿÿÿXÕ©‹JˆË\È€H|@@ÿÿÿÿÿÿeÕi+€€Þ |@AÿÿÿÿÿÿrÕÆ‹]ˆï€[|@BÿÿÿÿÿÿÕqk“}ä|]4@CÿÿÿÿÿÿŒÕރʃ5kû]4@Dÿÿÿÿÿÿ™Õ-°i°}Ik>|@Eÿÿÿÿÿÿ¦Õ±†‹†·ƒèh>|@Fÿÿÿÿÿÿ³ÕT}~Ao.i+k@GÿÿÿÿÿÿÀÕ±‰iát?€+k@HÿÿÿÿÿÿÍÕò~Äi}Ð| |@IÿÿÿÿÿÿÚÕ}ViSkÐ| |@JÿÿÿÿÿÿçÕ°‚íG8iÞ@KÿÿÿÿÿÿôÕø€Ñ€ª€8i½|@LÿÿÿÿÿÿÖÍ‚ ‚~i½-û@MÿÿÿÿÿÿÖp„]kBi½-ä|@NÿÿÿÿÿÿÖô‚'‚w¾€èh@Oÿÿÿÿÿÿ(Öji&‡S„¾€Ik@Pÿÿÿÿÿÿ5Ö jN‚Toå€?€@QÿÿÿÿÿÿBÖgkC‡ôtå€.i@RÿÿÿÿÿÿOÖL~abSkòh@Sÿÿÿÿÿÿ\ÖœiÃ}ab}Y}@TÿÿÿÿÿÿiÖà‚Îi]ª€€@UÿÿÿÿÿÿvÖžŠ]Gti@VÿÿÿÿÿÿƒÖ­$5…ìBi5k@WÿÿÿÿÿÿÖE2À„ì~i“}@XÿÿÿÿÿÿÖjR…Á\S„·ƒ@YÿÿÿÿÿÿªÖÔ‡’iÁ\w°}@Zÿÿÿÿÿÿ·Öfu-uôtát@[ÿÿÿÿÿÿÄÖÆooToAo@\ÿÿÿÿÿÿÑÖ@i~Ã}Vi?k@]ÿÿÿÿÿÿÞÖ~i~L~Äi ~@^ÿÿÿÿÿÿëÖ(j:‚ŠÑ€+€@_ÿÿÿÿÿÿøÖa‚:‚Îií&~@`ÿÿÿÿÿÿ×ä…-À„]kʃ@aÿÿÿÿÿÿ×o…-5… ‚qk@bÿÿÿÿÿÿ×ш@ˆ’i&‡‹†@cÿÿÿÿÿÿ,×…k@ˆR…'‚°i@dÿÿÿÿÿÿ9×îˆ{koC‡i@eÿÿÿÿÿÿF×âi{k-uN‚}~@fÿÿÿÿÿÿS×g~œi}d|@gÿÿÿÿÿÿ`×g@ò~öi@hÿÿÿÿÿÿm׃a‚žø€i@iÿÿÿÿÿÿz׃(jà‚°‚ß~@jÿÿÿÿÿÿ‡×€.o…E2p„Þƒ@kÿÿÿÿÿÿ”×€.ä…­$Í‚@lÿÿÿÿÿÿ¡×‰…kÔ‡ji±†@mÿÿÿÿÿÿ®×‰Ñˆjô‚-@nÿÿÿÿÿÿ»×¼‹âiÆogk±‰@oÿÿÿÿÿÿÈ×¼‹îˆfu jT@pÿÿÿÿÿÿÕ×+k>|]4 |ð{@qÿÿÿÿÿÿâ×?€èhûÞ |@rÿÿÿÿÿÿï×át·ƒ5k€òh@sÿÿÿÿÿÿü×i‹†Êƒ+€?k@tÿÿÿÿÿÿ ر‰±†Þƒid|@uÿÿÿÿÿÿØ.iIkä|½| |@vÿÿÿÿÿÿ#Ø倾€½-8iÐ|@wÿÿÿÿÿÿ0ØôtS„Biª€Sk@xÿÿÿÿÿÿ=ØC‡&‡]kÑ€Vi@yÿÿÿÿÿÿJØgkjip„ø€}@zÿÿÿÿÿÿWØAo°}“}tiY}@{ÿÿÿÿÿÿdØTow~iG}@|ÿÿÿÿÿÿqØÁ\ì]ab@}ÿÿÿÿÿÿ~Øo’iÀ„ŠÃ}@~ÿÿÿÿÿÿ‹ØÆoÔ‡E2žœi@ÿÿÿÿÿÿ˜Ø}~°iqk&~ ~@€ÿÿÿÿÿÿ¥ØN‚'‚ ‚íÄi@ÿÿÿÿÿÿ²Ø-uR…5…ÎiL~@‚ÿÿÿÿÿÿ¿Ø{k@ˆ-:‚i~@ƒÿÿÿÿÿÿÌØâi…ko…a‚~@„ÿÿÿÿÿÿÙØT-ß~öi@…ÿÿÿÿÿÿæØ jô‚Í‚°‚ò~@†ÿÿÿÿÿÿóØfuj­$à‚@‡ÿÿÿÿÿÿÙîˆÑˆä…(j@@ˆÿÿÿÿÿÿ Ù¼‹‰€.ƒg@‰ÿÿÿÿÿÿÙTÙ…k{kÎiÄiqkœi’i~itigk]kSk8iIki?k5kèh+k@Šÿÿÿÿÿÿ7ÙTÙâi-ÎiÄi°iœi’i~itijiViBi8i.iiiòhèh]4@‹ÿÿÿÿÿÿTÙ€.(jj jöiŒÿÿÿÿÿÿaÙTÙâi-ÎiÄi°iœi’i~itijiViBi8i.iiiòhèh]4@ÿÿÿÿÿÿ}ÙaÙŽÿÿÿÿÿÿ†ÙTÙ…k{kÎiÄiqkœi’i~itigk]kSk8iIki?k5kèh+k@ÿÿÿÿÿÿ¢Ù†Ù@ÿÿÿÿÿÿ«Ù<Ò/Ò"Ò†Ð"Ï‘ÿÿÿÿÿÿ¸Ùø…î…Ñ…Ç…´…y…e…H…+……Ê„„T¶„¬„z„f„I„6„#„èƒÔƒ­ƒšƒ‡ƒ@’ÿÿÿÿÿÿØÙÏ‹²‹Ÿ‹•‹‚‹G‹4‹!‹‹ûŠÀŠ¶ŠO2™Š†ŠKŠ8Š%ŠŠÿ‰Ä‰§‰”‰‰n‰“ÿÿÿÿÿÿùÙ•u•k•a•W•%••••ý”Ë”Á”­”£”q”g”]”S”I”” ””ù“ï“@”ÿÿÿÿÿÿÚùÙDÐ#ÐÐáÏ@•ÿÿÿÿÿÿ&ÚÒÒûÑ<Ñ Ð@–ÿÿÿÿÿÿ3Ú"ÑÑîÐÔкÐ@—ÿÿÿÿÿÿ@ÚÆ‹«¥¡¥—¥¥[¥Q¥G¥=¥3¥¥÷¤vã¤Ù¤§¤¤“¤‰¤¤M¤C¤9¤/¤%¤@˜ÿÿÿÿÿÿaÚ@ڹјÑwÑVÑ@™ÿÿÿÿÿÿnÚðÔãÔÖÔÉÔVÒ@šÿÿÿÿÿÿ{Ú¼Ô¯Ô¢Ô•ÔpÒ@›ÿÿÿÿÿÿˆÚˆÔ{ÔnÔaÔŠÒœÿÿÿÿÿÿ•Úñ¹±¯±¥±i±_±U±K±±±û°ñ°µ°«°¡°—°3°°Ï¯¯@ÿÿÿÿÿÿ±ÚTÔGÔ:Ô-ÔÅÒ@žÿÿÿÿÿÿ¾Ú ÔÔÔùÓßÒ@ŸÿÿÿÿÿÿËÚìÓßÓÒÓÓùÒ ÿÿÿÿÿÿØÚÓoÓNÓ-Ó¡ÿÿÿÿÿÿäÚXÕ>Õ$Õ Õ5¢ÿÿÿÿÿÿðÚ ÙÙóØæØÙØÌؿزإؘ؋Ø~ØdØWØJØ=Ø0Ø#ØØ Øü×ï×â×Õ×È׻׮סהׇ×z×m×`×S×F×9×,××××øÖëÖÞÖÑÖªÖÖÖƒÖvÖiÖ\ÖOÖBÖ5Ö(ÖÖÖÖôÕçÕÚÕÍÕÀÕ³Õ¦Õ™ÕŒÕÕeÕKÕ1ÕÕäÚØÚÓËÚ¾Ú±Ú•ÚˆÚ{ÚnÚaÚ/ÑÑûÐáÐÇÐ3Ú&ÚÚØْϸÙPÏ/Ï«Ù³w wwzwgwTwAw.www›vˆvuvbvOvCHNSX[^addtruefalsenot==>andorxordistinctite=distinctite=distinctiteop1ope4e3e2e1e0R PBoolUIIIIIIII@<P sW_oR PBoolUIIIIIIII@<P PBoolUI P   .>3C(8H1 0 -2 0 127 0 132 0 217 0 247 0 273 0 279 0 316 0 346 0 376 0 402 0 531 0 553 0 559 0 689 0 714 0 740 0 765 0 791 0 817 0 -823 0 -824 0 -825 0 -826 0 -827 0 -828 0 -829 0 -830 0 -831 0 -832 0 -833 0 -834 0 -835 0 -836 0 -837 0 -838 0 -839 0 -840 0 -841 0 -842 0 -843 0 -13 0 -281 0 416 0 436 0 456 0 476 0 497 0 489 0 667 0 -692 0 -844 0 -845 0 -38 0 494 0 672 0 -697 0 -846 0 -847 0 -83 0 503 0 681 0 -706 0 -108 0 508 0 686 0 -711 0 -848 0 -849 0 -850 0 -851 0 -852 0 -853 0 -854 0 -855 0 -856 0 -857 0 -858 0 -859 0 -860 0 -861 0 -862 0 -863 0 -864 0 -865 0 -866 0 -867 0 -868 0 -869 0 -870 0 -871 0 -872 0 -873 0 -874 0 -875 0 -876 0 -877 0 -878 0 -879 0 -880 0 -881 0 -882 0 -883 0 -884 0 -885 0 -886 0 -887 0 -888 0 -889 0 -53 0 675 0 -700 0 -890 0 -891 0 -58 0 498 0 676 0 -701 0 -892 0 -893 0 -63 0 499 0 677 0 -702 0 -68 0 500 0 678 0 -703 0 -894 0 -895 0 -896 0 -897 0 -898 0 -899 0 -900 0 -901 0 -902 0 -903 0 -904 0 -905 0 -906 0 -907 0 -908 0 -909 0 -910 0 -911 0 -912 0 -913 0 -914 0 -123 0 477 0 652 0 -727 0 -124 0 -289 0 418 0 438 0 627 0 -752 0 -125 0 602 0 -778 0 -126 0 577 0 -804 0 -915 0 -916 0 -917 0 -918 0 -919 0 -920 0 14 0 650 0 -742 0 41 0 601 0 -749 0 57 0 567 0 802 0 3 4 5 6 7 0 8 9 10 11 12 0 14 15 13 16 17 0 18 19 20 21 22 0 23 24 25 26 27 0 28 29 30 31 32 0 33 34 35 36 37 0 39 40 38 41 42 0 43 44 45 46 47 0 48 49 50 51 52 0 54 55 53 56 57 0 59 60 58 61 62 0 64 65 63 66 67 0 69 70 68 71 72 0 73 74 75 76 77 0 78 79 80 81 82 0 84 85 83 86 87 0 88 89 90 91 92 0 93 94 95 96 97 0 98 99 100 101 102 0 103 104 105 106 107 0 109 110 108 111 112 0 113 114 115 116 117 0 118 119 120 121 122 0 3 8 13 18 23 0 3 28 53 73 98 0 4 9 14 19 24 0 4 29 54 74 99 0 5 10 15 20 25 0 5 30 55 75 100 0 6 11 16 21 26 0 6 31 56 76 101 0 7 12 17 22 27 0 7 32 57 77 102 0 28 33 38 43 48 0 8 33 58 78 103 0 29 34 39 44 49 0 9 34 59 79 104 0 30 35 40 45 50 0 10 35 60 80 105 0 31 36 41 46 51 0 11 36 61 81 106 0 32 37 42 47 52 0 12 37 62 82 107 0 54 59 64 69 123 0 14 39 84 109 123 0 55 60 65 70 124 0 15 40 85 110 124 0 56 61 66 71 125 0 16 41 86 111 125 0 57 62 67 72 126 0 17 42 87 112 126 0 73 78 83 88 93 0 18 43 63 88 113 0 74 79 84 89 94 0 19 44 64 89 114 0 75 80 85 90 95 0 20 45 65 90 115 0 76 81 86 91 96 0 21 46 66 91 116 0 77 82 87 92 97 0 22 47 67 92 117 0 98 103 108 113 118 0 23 48 68 93 118 0 99 104 109 114 119 0 24 49 69 94 119 0 100 105 110 115 120 0 25 50 70 95 120 0 101 106 111 116 121 0 26 51 71 96 121 0 102 107 112 117 122 0 27 52 72 97 122 0 128 129 130 131 0 -7 -131 0 -37 -131 0 -126 -131 0 -92 -131 0 -122 -131 0 7 37 92 122 126 131 0 -6 -130 0 -36 -130 0 -125 -130 0 -91 -130 0 -121 -130 0 6 36 91 121 125 130 0 -5 -129 0 -35 -129 0 -124 -129 0 -90 -129 0 -120 -129 0 5 35 90 120 124 129 0 -4 -128 0 -34 -128 0 -123 -128 0 -89 -128 0 -119 -128 0 4 34 89 119 123 128 0 133 134 135 136 0 -7 -136 0 -136 137 0 -136 138 0 -136 139 0 -136 140 0 -136 141 0 -37 -136 0 -136 142 0 -136 143 0 -136 144 0 -136 145 0 -136 146 0 -126 -136 0 -136 147 0 -136 148 0 -136 149 0 -136 150 0 -136 151 0 -92 -136 0 -136 152 0 -136 153 0 -136 154 0 -136 155 0 -136 156 0 -122 -136 0 7 37 92 122 126 136 -137 -138 -139 -140 -141 -142 -143 -144 -145 -146 -147 -148 -149 -150 -151 -152 -153 -154 -155 -156 0 117 156 0 97 156 0 -97 -117 -156 0 112 155 0 72 155 0 -72 -112 -155 0 107 154 0 52 154 0 -52 -107 -154 0 102 153 0 27 153 0 -27 -102 -153 0 97 152 0 117 152 0 -97 -117 -152 0 87 151 0 67 151 0 -67 -87 -151 0 82 150 0 47 150 0 -47 -82 -150 0 77 149 0 22 149 0 -22 -77 -149 0 72 148 0 112 148 0 -72 -112 -148 0 67 147 0 87 147 0 -67 -87 -147 0 62 146 0 42 146 0 -42 -62 -146 0 57 145 0 17 145 0 -17 -145 -57 0 52 144 0 107 144 0 -52 -107 -144 0 47 143 0 82 143 0 -47 -82 -143 0 42 142 0 62 142 0 -42 -62 -142 0 32 141 0 12 141 0 -12 -32 -141 0 27 140 0 102 140 0 -27 -102 -140 0 22 139 0 77 139 0 -22 -77 -139 0 17 138 0 57 138 0 -17 -138 -57 0 12 137 0 32 137 0 -12 -32 -137 0 -6 -135 0 -135 157 0 -135 158 0 -135 159 0 -135 160 0 -135 161 0 -36 -135 0 -135 162 0 -135 163 0 -135 164 0 -135 165 0 -135 166 0 -125 -135 0 -135 167 0 -135 168 0 -135 169 0 -135 170 0 -135 171 0 -91 -135 0 -135 172 0 -135 173 0 -135 174 0 -135 175 0 -135 176 0 -121 -135 0 6 36 91 121 125 135 -157 -158 -159 -160 -161 -162 -163 -164 -165 -166 -167 -168 -169 -170 -171 -172 -173 -174 -175 -176 0 116 176 0 96 176 0 -96 -116 -176 0 111 175 0 71 175 0 -71 -111 -175 0 106 174 0 51 174 0 -51 -106 -174 0 101 173 0 26 173 0 -26 -101 -173 0 96 172 0 116 172 0 -96 -116 -172 0 86 171 0 66 171 0 -66 -86 -171 0 81 170 0 46 170 0 -46 -81 -170 0 76 169 0 21 169 0 -21 -76 -169 0 71 168 0 111 168 0 -71 -111 -168 0 66 167 0 86 167 0 -66 -86 -167 0 61 166 0 41 166 0 -61 -166 -41 0 56 165 0 16 165 0 -16 -56 -165 0 51 164 0 106 164 0 -51 -106 -164 0 46 163 0 81 163 0 -46 -81 -163 0 41 162 0 61 162 0 -61 -162 -41 0 31 161 0 11 161 0 -11 -31 -161 0 26 160 0 101 160 0 -26 -101 -160 0 21 159 0 76 159 0 -21 -76 -159 0 16 158 0 56 158 0 -16 -56 -158 0 11 157 0 31 157 0 -11 -31 -157 0 -5 -134 0 -134 177 0 -134 178 0 -134 179 0 -134 180 0 -134 181 0 -35 -134 0 -134 182 0 -134 183 0 -134 184 0 -134 185 0 -134 186 0 -124 -134 0 -134 187 0 -134 188 0 -134 189 0 -134 190 0 -134 191 0 -90 -134 0 -134 192 0 -134 193 0 -134 194 0 -134 195 0 -134 196 0 -120 -134 0 5 35 90 120 124 134 -177 -178 -179 -180 -181 -182 -183 -184 -185 -186 -187 -188 -189 -190 -191 -192 -193 -194 -195 -196 0 115 196 0 95 196 0 -95 -115 -196 0 110 195 0 70 195 0 -70 -110 -195 0 105 194 0 50 194 0 -50 -105 -194 0 100 193 0 25 193 0 -25 -100 -193 0 95 192 0 115 192 0 -95 -115 -192 0 85 191 0 65 191 0 -65 -85 -191 0 80 190 0 45 190 0 -45 -80 -190 0 75 189 0 20 189 0 -20 -75 -189 0 70 188 0 110 188 0 -70 -110 -188 0 65 187 0 85 187 0 -65 -85 -187 0 60 186 0 40 186 0 -40 -60 -186 0 55 185 0 15 185 0 -15 -55 -185 0 50 184 0 105 184 0 -50 -105 -184 0 45 183 0 80 183 0 -45 -80 -183 0 40 182 0 60 182 0 -40 -60 -182 0 30 181 0 10 181 0 -10 -30 -181 0 25 180 0 100 180 0 -25 -100 -180 0 20 179 0 75 179 0 -20 -75 -179 0 15 178 0 55 178 0 -15 -55 -178 0 10 177 0 30 177 0 -10 -30 -177 0 -4 -133 0 -133 197 0 -133 198 0 -133 199 0 -133 200 0 -133 201 0 -34 -133 0 -133 202 0 -133 203 0 -133 204 0 -133 205 0 -133 206 0 -123 -133 0 -133 207 0 -133 208 0 -133 209 0 -133 210 0 -133 211 0 -89 -133 0 -133 212 0 -133 213 0 -133 214 0 -133 215 0 -133 216 0 -119 -133 0 4 34 89 119 123 133 -197 -198 -199 -200 -201 -202 -203 -204 -205 -206 -207 -208 -209 -210 -211 -212 -213 -214 -215 -216 0 114 216 0 94 216 0 -94 -114 -216 0 109 215 0 69 215 0 -69 -109 -215 0 104 214 0 49 214 0 -49 -104 -214 0 99 213 0 24 213 0 -24 -99 -213 0 94 212 0 114 212 0 -94 -114 -212 0 84 211 0 64 211 0 -64 -84 -211 0 79 210 0 44 210 0 -44 -79 -210 0 74 209 0 19 209 0 -19 -74 -209 0 69 208 0 109 208 0 -69 -109 -208 0 64 207 0 84 207 0 -64 -84 -207 0 59 206 0 39 206 0 -39 -59 -206 0 54 205 0 14 205 0 -54 -205 -14 0 49 204 0 104 204 0 -49 -104 -204 0 44 203 0 79 203 0 -44 -79 -203 0 39 202 0 59 202 0 -39 -59 -202 0 29 201 0 9 201 0 -9 -29 -201 0 24 200 0 99 200 0 -24 -99 -200 0 19 199 0 74 199 0 -19 -74 -199 0 14 198 0 54 198 0 -54 -198 -14 0 9 197 0 29 197 0 -9 -29 -197 0 3 34 91 122 124 0 218 219 220 221 222 0 -222 -223 0 -222 -224 0 -222 -225 0 -222 -226 0 -222 -227 0 222 223 224 225 226 227 0 -221 -228 0 -221 -229 0 -221 -230 0 -221 -231 0 -221 -232 0 221 228 229 230 231 232 0 -220 -233 0 -220 -234 0 -15 -220 0 -220 -235 0 -220 -236 0 15 220 233 234 235 236 0 -219 -237 0 -219 -238 0 -219 -239 0 -219 -240 0 -219 -241 0 219 237 238 239 240 241 0 -218 -242 0 -218 -243 0 -218 -244 0 -218 -245 0 -218 -246 0 218 242 243 244 245 246 0 248 249 250 251 252 0 -252 -253 0 -252 -254 0 -252 -255 0 -252 -256 0 -227 -252 0 227 252 253 254 255 256 0 -251 -257 0 -251 -258 0 -251 -259 0 -231 -251 0 -251 -260 0 231 251 257 258 259 260 0 -250 -261 0 -250 -262 0 -15 -250 0 -250 -263 0 -250 -264 0 15 250 261 262 263 264 0 -249 -265 0 -238 -249 0 -249 -266 0 -249 -267 0 -249 -268 0 238 249 265 266 267 268 0 -242 -248 0 -248 -269 0 -248 -270 0 -248 -271 0 -248 -272 0 242 248 269 270 271 272 0 274 275 276 277 278 0 223 -278 0 224 -278 0 225 -278 0 226 -278 0 227 -278 0 -223 -224 -225 -226 -227 278 0 228 -277 0 229 -277 0 230 -277 0 231 -277 0 232 -277 0 -228 -229 -230 -231 -232 277 0 233 -276 0 234 -276 0 15 -276 0 235 -276 0 236 -276 0 -15 -233 -234 -235 -236 276 0 237 -275 0 238 -275 0 239 -275 0 240 -275 0 241 -275 0 -237 -238 -239 -240 -241 275 0 242 -274 0 243 -274 0 244 -274 0 245 -274 0 246 -274 0 -242 -243 -244 -245 -246 274 0 280 282 281 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 0 122 -299 0 -299 300 0 -122 299 -300 0 -300 301 0 -122 -300 0 122 300 -301 0 -301 302 0 -92 -301 0 92 301 -302 0 -302 303 0 -126 -302 0 302 -303 126 0 -7 -303 0 -37 -303 0 7 37 303 0 117 -298 0 -298 304 0 -117 298 -304 0 -304 305 0 -121 -304 0 121 304 -305 0 -305 306 0 -91 -305 0 91 305 -306 0 -306 307 0 -125 -306 0 306 -307 125 0 -6 -307 0 -36 -307 0 6 36 307 0 112 -297 0 -297 308 0 -112 297 -308 0 -308 309 0 -120 -308 0 120 308 -309 0 -309 310 0 -90 -309 0 90 309 -310 0 -310 311 0 -124 -310 0 310 -311 124 0 -5 -311 0 -35 -311 0 5 35 311 0 107 -296 0 -296 312 0 -107 296 -312 0 -312 313 0 -119 -312 0 119 312 -313 0 -313 314 0 -89 -313 0 89 313 -314 0 -314 315 0 -123 -314 0 314 -315 123 0 -4 -315 0 -34 -315 0 4 34 315 0 96 -295 0 -295 300 0 -96 295 -300 0 91 -294 0 -294 304 0 -91 294 -304 0 86 -293 0 -293 308 0 -86 293 -308 0 81 -292 0 -292 312 0 -81 292 -312 0 70 -291 0 -291 300 0 -70 291 -300 0 65 -290 0 -290 304 0 -65 290 -304 0 -289 124 0 -289 308 0 -124 289 -308 0 60 -288 0 -288 312 0 -60 288 -312 0 49 -287 0 -287 300 0 -49 287 -300 0 44 -286 0 -286 304 0 -44 286 -304 0 39 -285 0 -285 308 0 -39 285 -308 0 34 -284 0 -284 312 0 -34 284 -312 0 23 -283 0 -283 300 0 -23 283 -300 0 18 -282 0 -282 304 0 -18 282 -304 0 -281 13 0 -281 308 0 -13 281 -308 0 8 -280 0 -280 312 0 -8 280 -312 0 317 318 319 320 321 0 -321 -322 0 -321 -323 0 -321 -324 0 -321 -325 0 -321 -326 0 321 322 323 324 325 326 0 -320 -327 0 -320 -328 0 -320 -329 0 -320 -330 0 -320 -331 0 320 327 328 329 330 331 0 -319 -332 0 -319 -333 0 -5 -319 0 -319 -334 0 -319 -335 0 5 319 332 333 334 335 0 -318 -336 0 -318 -337 0 -318 -338 0 -318 -339 0 -318 -340 0 318 336 337 338 339 340 0 -317 -341 0 -317 -342 0 -317 -343 0 -317 -344 0 -317 -345 0 317 341 342 343 344 345 0 347 348 349 350 351 0 -351 -352 0 -351 -353 0 -351 -354 0 -351 -355 0 -351 -356 0 351 352 353 354 355 356 0 -350 -357 0 -350 -358 0 -350 -359 0 -350 -360 0 -350 -361 0 350 357 358 359 360 361 0 -349 -362 0 -349 -363 0 -55 -349 0 -349 -364 0 -349 -365 0 55 349 362 363 364 365 0 -348 -366 0 -348 -367 0 -348 -368 0 -348 -369 0 -348 -370 0 348 366 367 368 369 370 0 -347 -371 0 -347 -372 0 -347 -373 0 -347 -374 0 -347 -375 0 347 371 372 373 374 375 0 377 378 379 380 381 0 -381 -382 0 -381 -383 0 -381 -384 0 -381 -385 0 -326 -381 0 326 381 382 383 384 385 0 -380 -386 0 -380 -387 0 -380 -388 0 -330 -380 0 -380 -389 0 330 380 386 387 388 389 0 -379 -390 0 -379 -391 0 -5 -379 0 -379 -392 0 -379 -393 0 5 379 390 391 392 393 0 -378 -394 0 -337 -378 0 -378 -395 0 -378 -396 0 -378 -397 0 337 378 394 395 396 397 0 -341 -377 0 -377 -398 0 -377 -399 0 -377 -400 0 -377 -401 0 341 377 398 399 400 401 0 403 404 405 406 407 0 -407 408 0 -407 409 0 -407 410 0 -407 411 0 140 -407 0 -407 412 0 -407 413 0 -407 414 0 -407 415 0 144 -407 0 -407 416 0 -407 417 0 -407 418 0 -407 419 0 148 -407 0 -407 420 0 -407 421 0 -407 422 0 -407 423 0 152 -407 0 -407 424 0 -407 425 0 -407 426 0 -407 427 0 -122 -407 0 122 -140 -144 -148 -152 407 -408 -409 -410 -411 -412 -413 -414 -415 -416 -417 -418 -419 -420 -421 -422 -423 -424 -425 -426 -427 0 117 427 0 96 427 0 -96 -117 -427 0 112 426 0 70 426 0 -70 -112 -426 0 107 425 0 49 425 0 -49 -107 -425 0 102 424 0 23 424 0 -23 -102 -424 0 92 423 0 91 423 0 -91 -92 -423 0 87 422 0 65 422 0 -65 -87 -422 0 82 421 0 44 421 0 -44 -82 -421 0 77 420 0 18 420 0 -18 -77 -420 0 67 419 0 86 419 0 -67 -86 -419 0 418 126 0 418 124 0 -124 -126 -418 0 62 417 0 39 417 0 -39 -62 -417 0 57 416 0 416 13 0 -13 -57 -416 0 47 415 0 81 415 0 -47 -81 -415 0 42 414 0 60 414 0 -42 -60 -414 0 37 413 0 34 413 0 -34 -37 -413 0 32 412 0 8 412 0 -8 -32 -412 0 22 411 0 76 411 0 -22 -76 -411 0 17 410 0 55 410 0 -17 -55 -410 0 12 409 0 29 409 0 -12 -29 -409 0 7 408 0 3 408 0 -3 -7 -408 0 -406 428 0 -406 429 0 -406 430 0 159 -406 0 -406 431 0 -406 432 0 -406 433 0 -406 434 0 163 -406 0 -406 435 0 -406 436 0 -406 437 0 -406 438 0 167 -406 0 -406 439 0 -406 440 0 -406 441 0 -406 442 0 -91 -406 0 -406 443 0 -406 444 0 -406 445 0 -406 446 0 176 -406 0 -406 447 0 91 -159 -163 -167 -176 406 -428 -429 -430 -431 -432 -433 -434 -435 -436 -437 -438 -439 -440 -441 -442 -443 -444 -445 -446 -447 0 121 447 0 122 447 0 -121 -122 -447 0 111 446 0 70 446 0 -70 -111 -446 0 106 445 0 49 445 0 -49 -106 -445 0 101 444 0 23 444 0 -23 -101 -444 0 96 443 0 117 443 0 -96 -117 -443 0 86 442 0 65 442 0 -65 -86 -442 0 81 441 0 44 441 0 -44 -81 -441 0 76 440 0 18 440 0 -18 -76 -440 0 71 439 0 112 439 0 -71 -112 -439 0 438 125 0 438 124 0 -124 -125 -438 0 61 437 0 39 437 0 -39 -61 -437 0 56 436 0 436 13 0 -13 -56 -436 0 51 435 0 107 435 0 -51 -107 -435 0 41 434 0 60 434 0 -60 -434 -41 0 36 433 0 34 433 0 -34 -36 -433 0 31 432 0 8 432 0 -8 -31 -432 0 26 431 0 102 431 0 -26 -102 -431 0 16 430 0 55 430 0 -16 -55 -430 0 11 429 0 29 429 0 -11 -29 -429 0 6 428 0 3 428 0 -3 -6 -428 0 -405 448 0 -405 449 0 178 -405 0 -405 450 0 -405 451 0 -405 452 0 -405 453 0 182 -405 0 -405 454 0 -405 455 0 -405 456 0 -405 457 0 -124 -405 0 -405 458 0 -405 459 0 -405 460 0 -405 461 0 191 -405 0 -405 462 0 -405 463 0 -405 464 0 -405 465 0 195 -405 0 -405 466 0 -405 467 0 -178 -182 124 -191 -195 405 -448 -449 -450 -451 -452 -453 -454 -455 -456 -457 -458 -459 -460 -461 -462 -463 -464 -465 -466 -467 0 120 467 0 122 467 0 -120 -122 -467 0 115 466 0 96 466 0 -96 -115 -466 0 105 465 0 49 465 0 -49 -105 -465 0 100 464 0 23 464 0 -23 -100 -464 0 95 463 0 117 463 0 -95 -117 -463 0 90 462 0 91 462 0 -90 -91 -462 0 80 461 0 44 461 0 -44 -80 -461 0 75 460 0 18 460 0 -18 -75 -460 0 70 459 0 112 459 0 -70 -112 -459 0 65 458 0 86 458 0 -65 -86 -458 0 60 457 0 39 457 0 -39 -60 -457 0 55 456 0 456 13 0 -13 -55 -456 0 50 455 0 107 455 0 -50 -107 -455 0 45 454 0 81 454 0 -45 -81 -454 0 35 453 0 34 453 0 -34 -35 -453 0 30 452 0 8 452 0 -8 -30 -452 0 25 451 0 102 451 0 -25 -102 -451 0 20 450 0 76 450 0 -20 -76 -450 0 10 449 0 29 449 0 -10 -29 -449 0 5 448 0 3 448 0 -3 -5 -448 0 -404 468 0 197 -404 0 -404 469 0 -404 470 0 -404 471 0 -404 472 0 -34 -404 0 -404 473 0 -404 474 0 -404 475 0 -404 476 0 206 -404 0 -404 477 0 -404 478 0 -404 479 0 -404 480 0 210 -404 0 -404 481 0 -404 482 0 -404 483 0 -404 484 0 214 -404 0 -404 485 0 -404 486 0 -404 487 0 34 -197 -206 -210 -214 404 -468 -469 -470 -471 -472 -473 -474 -475 -476 -477 -478 -479 -480 -481 -482 -483 -484 -485 -486 -487 0 119 487 0 122 487 0 -119 -122 -487 0 114 486 0 96 486 0 -96 -114 -486 0 109 485 0 70 485 0 -70 -109 -485 0 99 484 0 23 484 0 -23 -99 -484 0 94 483 0 117 483 0 -94 -117 -483 0 89 482 0 91 482 0 -89 -91 -482 0 84 481 0 65 481 0 -65 -84 -481 0 74 480 0 18 480 0 -18 -74 -480 0 69 479 0 112 479 0 -69 -112 -479 0 64 478 0 86 478 0 -64 -86 -478 0 477 123 0 477 124 0 -123 -124 -477 0 54 476 0 476 13 0 -13 -54 -476 0 49 475 0 107 475 0 -49 -107 -475 0 44 474 0 81 474 0 -44 -81 -474 0 39 473 0 60 473 0 -39 -60 -473 0 29 472 0 8 472 0 -8 -29 -472 0 24 471 0 102 471 0 -24 -102 -471 0 19 470 0 76 470 0 -19 -76 -470 0 14 469 0 55 469 0 -55 -469 -14 0 4 468 0 3 468 0 -3 -4 -468 0 -3 -403 0 -403 488 0 -403 489 0 -403 490 0 -403 491 0 -403 492 0 -403 493 0 -403 494 0 -403 495 0 -403 496 0 -403 497 0 -403 498 0 -124 -403 0 -403 499 0 -403 500 0 -403 501 0 -403 502 0 -403 503 0 -403 504 0 -403 505 0 -403 506 0 -403 507 0 -403 508 0 -403 509 0 -403 510 0 3 403 124 -488 -489 -490 -491 -492 -493 -494 -495 -496 -497 -498 -499 -500 -501 -502 -503 -504 -505 -506 -507 -508 -509 -510 0 118 510 0 122 510 0 -118 -122 -510 0 113 509 0 96 509 0 -96 -113 -509 0 508 108 0 70 508 0 -70 -108 -508 0 103 507 0 49 507 0 -49 -103 -507 0 98 506 0 23 506 0 -23 -98 -506 0 93 505 0 117 505 0 -93 -117 -505 0 88 504 0 91 504 0 -88 -91 -504 0 503 83 0 65 503 0 -65 -83 -503 0 78 502 0 44 502 0 -44 -78 -502 0 73 501 0 18 501 0 -18 -73 -501 0 500 68 0 112 500 0 -68 -112 -500 0 499 63 0 86 499 0 -63 -86 -499 0 498 58 0 39 498 0 -39 -58 -498 0 497 53 0 497 13 0 -13 -53 -497 0 48 496 0 107 496 0 -48 -107 -496 0 43 495 0 81 495 0 -43 -81 -495 0 494 38 0 60 494 0 -38 -60 -494 0 33 493 0 34 493 0 -33 -34 -493 0 28 492 0 8 492 0 -8 -28 -492 0 23 491 0 102 491 0 -23 -102 -491 0 18 490 0 76 490 0 -18 -76 -490 0 489 13 0 55 489 0 -13 -55 -489 0 8 488 0 29 488 0 -8 -29 -488 0 371 511 512 513 514 0 367 515 516 517 518 0 55 519 520 521 522 0 360 523 524 525 526 0 356 527 528 529 530 0 532 533 534 535 536 0 -536 -537 0 -536 -538 0 -536 -539 0 -536 -540 0 -356 -536 0 356 536 537 538 539 540 0 -535 -541 0 -535 -542 0 -535 -543 0 -360 -535 0 -535 -544 0 360 535 541 542 543 544 0 -3 -534 0 -29 -534 0 -55 -534 0 -76 -534 0 -102 -534 0 3 29 55 76 102 534 0 -533 -545 0 -367 -533 0 -533 -546 0 -533 -547 0 -533 -548 0 367 533 545 546 547 548 0 -371 -532 0 -532 -549 0 -532 -550 0 -532 -551 0 -532 -552 0 371 532 549 550 551 552 0 554 555 556 557 558 0 -98 -558 0 -104 -558 0 -110 -558 0 -116 -558 0 -122 -558 0 98 104 110 116 122 558 0 -73 -557 0 -79 -557 0 -85 -557 0 -91 -557 0 -97 -557 0 73 79 85 91 97 557 0 -53 -556 0 -59 -556 0 -124 -556 0 -66 -556 0 -72 -556 0 59 66 53 72 124 556 0 -28 -555 0 -34 -555 0 -40 -555 0 -46 -555 0 -52 -555 0 28 34 40 46 52 555 0 -3 -554 0 -9 -554 0 -15 -554 0 -21 -554 0 -27 -554 0 3 9 15 21 27 554 0 560 561 562 563 564 0 -564 565 0 -564 566 0 -564 567 0 -564 568 0 -564 569 0 -564 570 0 -564 571 0 -564 572 0 -564 573 0 -564 574 0 -564 575 0 -564 576 0 -564 577 0 -564 578 0 -564 579 0 -564 580 0 -564 581 0 -564 582 0 -564 583 0 -564 584 0 -564 585 0 -564 586 0 -564 587 0 -564 588 0 -564 589 0 564 -565 -566 -567 -568 -569 -570 -571 -572 -573 -574 -575 -576 -577 -578 -579 -580 -581 -582 -583 -584 -585 -586 -587 -588 -589 0 122 589 0 -122 589 0 117 588 0 -97 588 0 97 -117 -588 0 112 587 0 -72 587 0 72 -112 -587 0 107 586 0 -52 586 0 52 -107 -586 0 102 585 0 -27 585 0 27 -102 -585 0 97 584 0 -117 584 0 -97 117 -584 0 92 583 0 -92 583 0 87 582 0 -67 582 0 67 -87 -582 0 82 581 0 -47 581 0 47 -82 -581 0 77 580 0 -22 580 0 22 -77 -580 0 72 579 0 -112 579 0 -72 112 -579 0 67 578 0 -87 578 0 -67 87 -578 0 577 126 0 -126 577 0 62 576 0 -42 576 0 42 -62 -576 0 57 575 0 -17 575 0 17 -575 -57 0 52 574 0 -107 574 0 -52 107 -574 0 47 573 0 -82 573 0 -47 82 -573 0 42 572 0 -62 572 0 -42 62 -572 0 37 571 0 -37 571 0 32 570 0 -12 570 0 12 -32 -570 0 27 569 0 -102 569 0 -27 102 -569 0 22 568 0 -77 568 0 -22 77 -568 0 17 567 0 567 -57 0 -17 57 -567 0 12 566 0 -32 566 0 -12 32 -566 0 7 565 0 -7 565 0 -563 590 0 -563 591 0 -563 592 0 -563 593 0 -563 594 0 -563 595 0 -563 596 0 -563 597 0 -563 598 0 -563 599 0 -563 600 0 -563 601 0 -563 602 0 -563 603 0 -563 604 0 -563 605 0 -563 606 0 -563 607 0 -563 608 0 -563 609 0 -563 610 0 -563 611 0 -563 612 0 -563 613 0 -563 614 0 563 -590 -591 -592 -593 -594 -595 -596 -597 -598 -599 -600 -601 -602 -603 -604 -605 -606 -607 -608 -609 -610 -611 -612 -613 -614 0 121 614 0 -121 614 0 116 613 0 -96 613 0 96 -116 -613 0 111 612 0 -71 612 0 71 -111 -612 0 106 611 0 -51 611 0 51 -106 -611 0 101 610 0 -26 610 0 26 -101 -610 0 96 609 0 -116 609 0 -96 116 -609 0 91 608 0 -91 608 0 86 607 0 -66 607 0 66 -86 -607 0 81 606 0 -46 606 0 46 -81 -606 0 76 605 0 -21 605 0 21 -76 -605 0 71 604 0 -111 604 0 -71 111 -604 0 66 603 0 -86 603 0 -66 86 -603 0 602 125 0 -125 602 0 61 601 0 601 -41 0 41 -61 -601 0 56 600 0 -16 600 0 16 -56 -600 0 51 599 0 -106 599 0 -51 106 -599 0 46 598 0 -81 598 0 -46 81 -598 0 41 597 0 -61 597 0 61 -597 -41 0 36 596 0 -36 596 0 31 595 0 -11 595 0 11 -31 -595 0 26 594 0 -101 594 0 -26 101 -594 0 21 593 0 -76 593 0 -21 76 -593 0 16 592 0 -56 592 0 -16 56 -592 0 11 591 0 -31 591 0 -11 31 -591 0 6 590 0 -6 590 0 -562 615 0 -562 616 0 -562 617 0 -562 618 0 -562 619 0 -562 620 0 -562 621 0 -562 622 0 -562 623 0 -562 624 0 -562 625 0 -562 626 0 -562 627 0 -562 628 0 -562 629 0 -562 630 0 -562 631 0 -562 632 0 -562 633 0 -562 634 0 -562 635 0 -562 636 0 -562 637 0 -562 638 0 -562 639 0 562 -615 -616 -617 -618 -619 -620 -621 -622 -623 -624 -625 -626 -627 -628 -629 -630 -631 -632 -633 -634 -635 -636 -637 -638 -639 0 120 639 0 -120 639 0 115 638 0 -95 638 0 95 -115 -638 0 110 637 0 -70 637 0 70 -110 -637 0 105 636 0 -50 636 0 50 -105 -636 0 100 635 0 -25 635 0 25 -100 -635 0 95 634 0 -115 634 0 -95 115 -634 0 90 633 0 -90 633 0 85 632 0 -65 632 0 65 -85 -632 0 80 631 0 -45 631 0 45 -80 -631 0 75 630 0 -20 630 0 20 -75 -630 0 70 629 0 -110 629 0 -70 110 -629 0 65 628 0 -85 628 0 -65 85 -628 0 627 124 0 -124 627 0 60 626 0 -40 626 0 40 -60 -626 0 55 625 0 -15 625 0 15 -55 -625 0 50 624 0 -105 624 0 -50 105 -624 0 45 623 0 -80 623 0 -45 80 -623 0 40 622 0 -60 622 0 -40 60 -622 0 35 621 0 -35 621 0 30 620 0 -10 620 0 10 -30 -620 0 25 619 0 -100 619 0 -25 100 -619 0 20 618 0 -75 618 0 -20 75 -618 0 15 617 0 -55 617 0 -15 55 -617 0 10 616 0 -30 616 0 -10 30 -616 0 5 615 0 -5 615 0 -561 640 0 -561 641 0 -561 642 0 -561 643 0 -561 644 0 -561 645 0 -561 646 0 -561 647 0 -561 648 0 -561 649 0 -561 650 0 -561 651 0 -561 652 0 -561 653 0 -561 654 0 -561 655 0 -561 656 0 -561 657 0 -561 658 0 -561 659 0 -561 660 0 -561 661 0 -561 662 0 -561 663 0 -561 664 0 561 -640 -641 -642 -643 -644 -645 -646 -647 -648 -649 -650 -651 -652 -653 -654 -655 -656 -657 -658 -659 -660 -661 -662 -663 -664 0 119 664 0 -119 664 0 114 663 0 -94 663 0 94 -114 -663 0 109 662 0 -69 662 0 69 -109 -662 0 104 661 0 -49 661 0 49 -104 -661 0 99 660 0 -24 660 0 24 -99 -660 0 94 659 0 -114 659 0 -94 114 -659 0 89 658 0 -89 658 0 84 657 0 -64 657 0 64 -84 -657 0 79 656 0 -44 656 0 44 -79 -656 0 74 655 0 -19 655 0 19 -74 -655 0 69 654 0 -109 654 0 -69 109 -654 0 64 653 0 -84 653 0 -64 84 -653 0 652 123 0 -123 652 0 59 651 0 -39 651 0 39 -59 -651 0 54 650 0 650 -14 0 14 -54 -650 0 49 649 0 -104 649 0 -49 104 -649 0 44 648 0 -79 648 0 -44 79 -648 0 39 647 0 -59 647 0 -39 59 -647 0 34 646 0 -34 646 0 29 645 0 -9 645 0 9 -29 -645 0 24 644 0 -99 644 0 -24 99 -644 0 19 643 0 -74 643 0 -19 74 -643 0 14 642 0 -54 642 0 54 -642 -14 0 9 641 0 -29 641 0 -9 29 -641 0 4 640 0 -4 640 0 -560 665 0 -560 666 0 -560 667 0 -560 668 0 -560 669 0 -560 670 0 -560 671 0 -560 672 0 -560 673 0 -560 674 0 -560 675 0 -560 676 0 -560 677 0 -560 678 0 -560 679 0 -560 680 0 -560 681 0 -560 682 0 -560 683 0 -560 684 0 -560 685 0 -560 686 0 -560 687 0 -560 688 0 560 -665 -666 -667 -668 -669 -670 -671 -672 -673 -674 -675 -676 -677 -678 -679 -680 -681 -682 -683 -684 -685 -686 -687 -688 0 118 688 0 -118 688 0 113 687 0 -93 687 0 93 -113 -687 0 686 108 0 -68 686 0 -108 68 -686 0 103 685 0 -48 685 0 48 -103 -685 0 98 684 0 -23 684 0 23 -98 -684 0 93 683 0 -113 683 0 -93 113 -683 0 88 682 0 -88 682 0 681 83 0 -63 681 0 -83 63 -681 0 78 680 0 -43 680 0 43 -78 -680 0 73 679 0 -18 679 0 18 -73 -679 0 678 68 0 -108 678 0 -68 -678 108 0 677 63 0 -83 677 0 -63 -677 83 0 676 58 0 -38 676 0 -58 -676 38 0 675 53 0 -13 675 0 -53 -675 13 0 48 674 0 -103 674 0 -48 103 -674 0 43 673 0 -78 673 0 -43 78 -673 0 672 38 0 -58 672 0 -38 58 -672 0 33 671 0 -33 671 0 28 670 0 -8 670 0 8 -28 -670 0 23 669 0 -98 669 0 -23 98 -669 0 18 668 0 -73 668 0 -18 73 -668 0 667 13 0 -53 667 0 -13 53 -667 0 8 666 0 -28 666 0 -8 28 -666 0 3 665 0 -3 665 0 -55 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 0 118 -713 0 -102 -713 0 102 -118 713 0 113 -712 0 -101 -712 0 101 -113 712 0 -711 108 0 -100 -711 0 100 -108 711 0 103 -710 0 -99 -710 0 99 -103 710 0 98 -709 0 -98 -709 0 93 -708 0 -77 -708 0 77 -93 708 0 88 -707 0 -76 -707 0 76 -88 707 0 -706 83 0 -75 -706 0 75 -83 706 0 78 -705 0 -74 -705 0 74 -78 705 0 73 -704 0 -73 -704 0 -703 68 0 -703 -57 0 57 -68 703 0 -702 63 0 -56 -702 0 56 -63 702 0 -701 58 0 -54 -701 0 54 -58 701 0 -700 53 0 -53 -700 0 48 -699 0 -32 -699 0 32 -48 699 0 43 -698 0 -31 -698 0 31 -43 698 0 -697 38 0 -30 -697 0 30 -38 697 0 33 -696 0 -29 -696 0 29 -33 696 0 28 -695 0 -28 -695 0 23 -694 0 -7 -694 0 7 -23 694 0 18 -693 0 -6 -693 0 6 -18 693 0 -692 13 0 -5 -692 0 5 -13 692 0 8 -691 0 -4 -691 0 4 -8 691 0 3 -690 0 -3 -690 0 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 0 119 -739 0 -107 -739 0 107 -119 739 0 114 -738 0 -106 -738 0 106 -114 738 0 109 -737 0 -105 -737 0 105 -109 737 0 104 -736 0 -104 -736 0 99 -735 0 -103 -735 0 -99 103 735 0 94 -734 0 -82 -734 0 82 -94 734 0 89 -733 0 -81 -733 0 81 -89 733 0 84 -732 0 -80 -732 0 80 -84 732 0 79 -731 0 -79 -731 0 74 -730 0 -78 -730 0 -74 78 730 0 69 -729 0 -62 -729 0 62 -69 729 0 64 -728 0 -61 -728 0 61 -64 728 0 -727 123 0 -60 -727 0 60 -123 727 0 59 -726 0 -59 -726 0 54 -725 0 -58 -725 0 -54 725 58 0 49 -724 0 -37 -724 0 37 -49 724 0 44 -723 0 -36 -723 0 36 -44 723 0 39 -722 0 -35 -722 0 35 -39 722 0 34 -721 0 -34 -721 0 29 -720 0 -33 -720 0 -29 33 720 0 24 -719 0 -12 -719 0 12 -24 719 0 19 -718 0 -11 -718 0 11 -19 718 0 14 -717 0 -10 -717 0 10 717 -14 0 9 -716 0 -9 -716 0 4 -715 0 -8 -715 0 -4 8 715 0 741 743 742 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 0 120 -764 0 -112 -764 0 112 -120 764 0 115 -763 0 -111 -763 0 111 -115 763 0 110 -762 0 -110 -762 0 105 -761 0 -109 -761 0 -105 109 761 0 100 -760 0 -108 -760 0 -100 760 108 0 95 -759 0 -87 -759 0 87 -95 759 0 90 -758 0 -86 -758 0 86 -90 758 0 85 -757 0 -85 -757 0 80 -756 0 -84 -756 0 -80 84 756 0 75 -755 0 -83 -755 0 -75 755 83 0 70 -754 0 -126 -754 0 -70 754 126 0 65 -753 0 -125 -753 0 -65 753 125 0 -752 124 0 -124 -752 0 60 -751 0 -123 -751 0 -60 751 123 0 50 -750 0 -42 -750 0 42 -50 750 0 45 -749 0 -749 -41 0 41 -45 749 0 40 -748 0 -40 -748 0 35 -747 0 -39 -747 0 -35 39 747 0 30 -746 0 -38 -746 0 -30 746 38 0 25 -745 0 -17 -745 0 17 -25 745 0 20 -744 0 -16 -744 0 16 -20 744 0 15 -743 0 -15 -743 0 10 -742 0 -742 -14 0 -10 14 742 0 5 -741 0 -13 -741 0 -5 741 13 0 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 0 121 -790 0 -117 -790 0 117 -121 790 0 116 -789 0 -116 -789 0 111 -788 0 -115 -788 0 -111 115 788 0 106 -787 0 -114 -787 0 -106 114 787 0 101 -786 0 -113 -786 0 -101 113 786 0 96 -785 0 -92 -785 0 92 -96 785 0 91 -784 0 -91 -784 0 86 -783 0 -90 -783 0 -86 90 783 0 81 -782 0 -89 -782 0 -81 89 782 0 76 -781 0 -88 -781 0 -76 88 781 0 71 -780 0 -67 -780 0 67 -71 780 0 66 -779 0 -66 -779 0 -778 125 0 -65 -778 0 65 -125 778 0 61 -777 0 -64 -777 0 -61 64 777 0 56 -776 0 -63 -776 0 -56 776 63 0 51 -775 0 -47 -775 0 47 -51 775 0 46 -774 0 -46 -774 0 41 -773 0 -45 -773 0 45 773 -41 0 36 -772 0 -44 -772 0 -36 44 772 0 31 -771 0 -43 -771 0 -31 43 771 0 26 -770 0 -22 -770 0 22 -26 770 0 21 -769 0 -21 -769 0 16 -768 0 -20 -768 0 -16 20 768 0 11 -767 0 -19 -767 0 -11 19 767 0 6 -766 0 -18 -766 0 -6 18 766 0 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 0 122 -816 0 -122 -816 0 117 -815 0 -121 -815 0 -117 121 815 0 112 -814 0 -120 -814 0 -112 120 814 0 107 -813 0 -119 -813 0 -107 119 813 0 102 -812 0 -118 -812 0 -102 118 812 0 97 -811 0 -97 -811 0 92 -810 0 -96 -810 0 -92 96 810 0 87 -809 0 -95 -809 0 -87 95 809 0 82 -808 0 -94 -808 0 -82 94 808 0 77 -807 0 -93 -807 0 -77 93 807 0 72 -806 0 -72 -806 0 67 -805 0 -71 -805 0 -67 71 805 0 -804 126 0 -70 -804 0 70 -126 804 0 62 -803 0 -69 -803 0 -62 69 803 0 57 -802 0 -68 -802 0 802 -57 68 0 52 -801 0 -52 -801 0 47 -800 0 -51 -800 0 -47 51 800 0 42 -799 0 -50 -799 0 -42 50 799 0 37 -798 0 -49 -798 0 -37 49 798 0 32 -797 0 -48 -797 0 -32 48 797 0 27 -796 0 -27 -796 0 22 -795 0 -26 -795 0 -22 26 795 0 17 -794 0 -25 -794 0 -17 25 794 0 12 -793 0 -24 -793 0 -12 24 793 0 7 -792 0 -23 -792 0 -7 23 792 0 818 819 820 821 822 0 -272 -822 0 -268 -822 0 -264 -822 0 -260 -822 0 -227 -822 0 227 260 264 268 272 822 0 -271 -821 0 -267 -821 0 -263 -821 0 -231 -821 0 -256 -821 0 231 256 263 267 271 821 0 -270 -820 0 -266 -820 0 -15 -820 0 -259 -820 0 -255 -820 0 15 255 259 266 270 820 0 -269 -819 0 -238 -819 0 -262 -819 0 -258 -819 0 -254 -819 0 238 254 258 262 269 819 0 -242 -818 0 -265 -818 0 -261 -818 0 -257 -818 0 -253 -818 0 242 253 257 261 265 818 0 -5 -11 -18 -27 -29 -33 -47 -50 -59 -65 -71 -73 -80 -87 -91 -94 -101 -107 -110 -114 -118 0 -5 -11 -18 -27 -28 -35 -47 -49 -59 -65 -71 -74 -82 -85 -91 -93 -101 -103 -112 -114 -120 0 301 0 313 0 305 0 -300 0 -741 0 -724 0 opensmt-2.5.2/regression/state-dump/QG-classification_qg5_iso_brn644-split5.osmt2000066400000000000000000010447701445011647600277260ustar00rootroot00000000000000ñI¡õ¸õ ö}öŒö™¼‹‰€.ƒgîˆÑˆä…(j@fuj­$à‚ jô‚Í‚°‚ò~T-ß~öiâi…ko…a‚~{k@ˆ-:‚i~-uR…5…ÎiL~N‚'‚ ‚íÄi}~°iqk&~ ~ÆoÔ‡E2žœio’iÀ„ŠÃ}Tow~iG}Ao°}“}tiY}gkjip„ø€}C‡&‡]kÑ€ViôtS„Biª€Sk倾€½-8iÐ|.iIkä|½| |±‰±†Þƒid|i‹†Êƒ+€?kát·ƒ5k€òh?€èhûÞ |+k>|]4 |ð{Á\ì]abäÚXÕ>Õ$Õ ÕØÚÓoÓNÓ-Ó™¸¸…¸žS¸I¸?¸© ¸¸ù·OÇ·½·³·õœ·w·m·c·)ººíŸºã¹Ù¹“ŸÏ¹¹“¹9Ÿ‰¹W¹M¹C¹9¹¹ý¸ó¸ž¹»×¡¯»¥»s»}¡i»_»-»#»»»ÝºÓºÓ Éº—ººy ƒºÁ£I½?½5½½ù¼ï¼å¼³¼£©¼Ÿ¼m¼½¢c¼Y¼'¼c¢¼¼ËÚìÓßÓÒÓÓùÒm²Y²E²1²Rxå²Ñ²½²(y©²]³I³5³!³Õ³·zÁ³­³™³{M´9´%´´¾Ú ÔÔÔùÓßÒ{`zÄy y6{}záyoxS{šzEyŒxp{þyby©xÔzzyÆx±ÚTÔGÔ:Ô-ÔÅÒ•Úñ¹±¯±¥±i±_±U±K±±±û°ñ°µ°«°¡°—°3°°Ï¯¯“¯‰¯¯u¯Å¯»¯±¯§¯÷¯í¯ã¯Ù¯)°°° °ˆÚˆÔ{ÔnÔaÔŠÒB­/­­ ­7¦¶­£­­ §}­*®®®ñ­ž®œ¨‹®x®e®r©¯ÿ®ì®Ù®{Ú¼Ô¯Ô¢Ô•ÔpÒ6ªªü©ß©û–Òªµª˜ªÑ—{ªn«Q«4«« ¬ì˜í«Ð«³«Â™¦¬‰¬l¬O¬nÚðÔãÔÖÔÉÔVÒ«¦Ž¦q¦T¦d§G§*§ð¦¨ã§Æ§©§¹¨¨b¨E¨U©8©©þ¨aÚ@ڹјÑwÑVÑ+ž!žž žÑǽ³wmcY ÿœÃœ¹œ¯œ¥œ   ÷ŸãŸ±Ÿ§ŸŸ‰ŸWŸMŸCŸ/Ÿýžóžéžßž­ž£ž™ž…žë¡á¡Í¡Ã¡‘¡‡¡s¡i¡7¡-¡#¡¡ç Ý É ¿  ƒ o e Ë£·£­£££q£g£]£S£!£ ££ù¢Ç¢³¢©¢Ÿ¢m¢Y¢O¢E¢«¥¡¥—¥¥[¥Q¥G¥=¥3¥¥÷¤ã¤Ù¤§¤¤“¤‰¤¤M¤C¤9¤/¤%¤Kœ7œ#œœÓ›¿›«›—›[›G›3››ãšÏš»š§škšWšCš/š3Ú"ÑÑîÐÔкÐo—R—5——(˜ ˜î—´— ™Ï˜²˜•˜¥™ˆ™k™N™&ÚÒÒûÑ<Ñ ÐÚùÙDÐ#ÐÐáÏá×Íù‡}si_-#ӌɌ¿ŒµŒ«ŒyŒoŒeŒ[ŒQŒËÁ·­£qg]SI ùŽïŽ½Ž³Ž©ŽŸŽ•ŽcŽYŽOŽEŽ;Ž«‘¡‘—‘‘ƒ‘Q‘G‘=‘3‘)‘÷íÊJãÙ§“‰MC9/%•“‹““w“m“;“1“'“““á’×’Í’Ã’¹’‡’}’s’i’_’-’#’’’’•u•k•a•W•%••••ý”Ë”Á”­”£”q”g”]”S”I”” ””ù“ï“ØÙÏ‹²‹Ÿ‹•‹‚‹G‹4‹!‹‹ûŠÀŠ¶Š™Š†ŠKŠ8Š%ŠŠÿ‰Ä‰§‰”‰‰n‰’Ï ‰äˆÇˆ´ˆ¡ˆfˆSˆ6ˆ,ˆˆÞ‡Ê‡·‡¤‡‘‡V‡9‡‡ ‡ö†»†ž††n†[†¸Ùø…î…Ñ…Ç…´…y…e…H…+……Ê„„T¶„¬„z„f„I„6„#„èƒÔƒ­ƒšƒ‡ƒPÏ$ƒƒê‚¦‚k‚D‚‚‚㨔mZ=Û€´€ €€R€5€€ñÔ/ÏqJ#ü~Õ~š~s~V~9~~×}Í}¦}‰}l}'} }÷|Ú|³|n|Q|4|*||«Ù<Ò/Ò"Ò†Ð"Ï©w–wƒwpw]wJw7w$wwþv‘v~vkvXvEv2vv vùuæuyuSu@uuuÎtatNt;t(tttïsÜsÉs¶sIs6s#ssýrêr×rÄr±ržr röqãqÐq½qªq—q„qqq^qñpÞpËp¸p¥p’pplpYpFpÙo³o ozogo.oÁn®n›nˆnunbnOnHR\fpz„Ž˜¢¬¶ÀÊÔÞèòü$.8BLV`jt~ˆ’œ¦°ºÄÎØâìö (2<FPZdnx‚Œ– ª´¾ÈÒÜæðú",6@JT^hr|†š¤®¸ÂÌÖàêôþ&0:DNXblv€Š”ž¨²¼ÆÐÚäîø  * 4 > H R \ f p z „ Ž ˜ ¢ ¬ ¶ À Ê Ô Þ è ò ü    $ . 8 B L V ` j t ~ ˆ ’ œ ¦ ° º Ä Î Ø â ì ö   ( 2 < F P Z d n x ‚ Œ –   ª ´ ¾ È Ò Ü æ ð ú    " , 6 @ J T ^ h r | † š ¤ ® ¸ Â Ì Ö à ê ô þ    & 0 : D N X b l v € Š ” ž ¨ ² ¼ Æ Ð Ú ä î ø   *4>HR\fpz„Ž˜¢¬¶ÀÊÔÞèòü$.8BLV`jt~ˆ’œ¦°ºÄÎØâìö (2<FPZdnx‚Œ– ª´¾ÈÒÜæðú",6@JT^hr|†š¤®¸ÂÌÖàêôþ&0:DNXblv€Š”ž¨²¼ÆÐÚäîø  *4>HR\fpz„Ž˜¢¬¶ÀÊÔÞèòü$.8BLV`jt~ˆ’œ¦¯¸ÂËÕÞèñû  *3=FPZclv‰’œ¥¯¹ÂËÕÞèñû!*4=GPZcmw€‰’›¤­¶¿ÈÑÚãìõþ"+4=FOXajs|…Ž— ©²»ÄÍÖßèñú '09BKT]foxŠ“œ¥®·ÀÉÒÛäíöÿ#,5>GPYbkt}†˜¡ª³¼ÅÎ×àéòû#-7AKU_is}‡‘›¥¯¹ÃÍ×áëõÿ '1;EOYcmw‹•Ÿ©³½ÇÑÛåïù !+5?IS]gq{…™£­·ÁËÕßéóý%/9CMWaku‰“§±»ÅÏÙãí÷ )3=GQ[eoyƒ—¡«µ¿ÉÓÝçñû#-7AKU_is}‡‘›¥¯¹ÃÍ×áëõÿ   ' 1 ; E O Y c m w ‹ • Ÿ © ³ ½ Ç Ñ Û å ï ù ! !!!!+!5!?!I!S!]!g!q!{!…!!™!£!­!·!Á!Ë!Õ!ß!é!ó!ý!"""%"/"9"C"M"W"a"k"u""‰"“""§"±"»"Å"Ï"Ù"ã"í"÷"# ###'#1#;#D#N#X#b#k#u##‰#’#œ#¦#°#¹#Ã#Í#Ö#à#ê#ô#ý#$$$$$.$8$B$K$U$_$i$s$|$†$$™$£$­$·$À$Ê$Ô$Þ$ç$ñ$û$%%%"%,%6%?%I%S%\%f%p%z%ƒ%%—%¡%ª%´%¾%È%Ñ%Û%å%ï%ù%& &&&)&3&=&F&P&Z&d&m&w&&‹&”&ž&¨&²&¼&Å&Ï&Ù&ã&ì&ö&' '''''1':'D'N'X'a'k'u''ˆ'’'œ'¦'¯'¹'Ã'Í'Ö'à'ê'ô'þ'((($(.(8(B(L(U(_(i(s(|(†((š(¤(­(·(Á(Ê(Ô(Þ(è(ñ(û()))"),)6)@)J)S)])g)p)z)„)Ž)—)¡)«)µ)¾)È)Ò)Ü)æ)ð)ú)***"*,*6*@*J*T*^*h*r*|*†**š*¤*®*¸*Â*Ì*Ö*à*ê*ô*þ*+++&+0+:+D+N+X+b+l+v+€+Š+”+ž+¨+²+¼+Æ+Ð+Ú+ä+î+ø+, ,, ,*,4,>,H,R,\,f,p,z,„,Ž,˜,¢,¬,¶,À,Ê,Ó,Ý,ç,ð,ú,---!-+-5->-H-R-\-e-o-y-ƒ-Œ-–- -©-³-½-Ç-Ð-Ú-ä-î-÷-. ...(.2.<.F.O.Y.c.l.v.€.Š.“..§.±.º.Ä.Î.Ø.á.ë.õ.ÿ. ///&///9/C/M/V/`/j/t/}/‡/‘/›/¤/®/¸/Â/Ì/Õ/ß/é/ò/ü/000#0-070@0J0T0^0g0q0{0…00˜0¢0¬0µ0¿0É0Ó0Ü0æ0ð0ú01 11!1*141>1H1Q1[1e1n1x1‚1Œ1•1Ÿ1©1³1¼1Æ1Ð1Ú1ã1í1÷12 222(212;2E2O2X2b2l2v22‰2“22¦2°2º2Ä2Î2×2á2ë2ô2þ2333%3/393B3L3V3`3i3s3}3‡3‘3š3¤3®3·3Á3Ë3Õ3Þ3è3ò3ü3444#4,464@4J4S4]4g4p4z4„44—4¡4ª4´4¾4Ç4Ñ4Û4ä4î4ø45 555(525<5E5O5X5b5l5v55‰5“5œ5¦5°5º5Ã5Í5Ö5à5ê5ó5ý5666$6.686A6K6T6^6h6q6{6…6Ž6˜6¢6¬6¶6À6Ê6Ô6Þ6è6ò6ü6777$7.787B7L7V7`7j7t7~7ˆ7’7œ7¦7°7º7Ä7Î7Ø7â7ì7ö78 888(828<8F8P8Z8d8n8x8‚8Œ8–8 8ª8´8¾8È8Ò8Ü8æ8ð8ú8999"9,969@9J9T9^9h9r9|9†99š9¤9®9¸9Â9Ì9Ö9à9ê9ô9þ9:::&:0:::D:N:X:b:l:v:€:Š:”:ž:¨:²:¼:Æ:Ð:Ú:ä:î:ø:; ;; ;*;4;>;H;R;\;f;p;z;„;Ž;˜;¢;¬;¶;À;Ê;Ô;Þ;è;ò;ü;<<<$<.<8<B<L<V<`<j<t<~<ˆ<’<œ<¦<°<º<Ä<Î<Ø<â<ì<ö<= ===(=2=<=F=P=Z=d=n=x=‚=Œ=–= =ª=´=¾=È=Ò=Ü=æ=ð=ú=>>>">,>6>@>J>T>^>h>r>|>†>>š>¤>®>¸>Â>Ì>Ö>à>ê>ô>þ>???&?0?:?D?N?X?b?l?v?€?Š?”?ž?¨?²?¼?Æ?Ð?Ú?ä?î?ø?@ @@ @*@4@>@H@R@\@f@p@z@„@Ž@˜@¢@¬@¶@À@Ê@Ô@Þ@è@ò@ü@AAA$A.A8ABALAVA`AjAtA~AˆA’AœA¦A°AºAÄAÎAØAâAìAöAB BBB'B0B:BDBNBWBaBkBuB~BˆB’BœB¥B¯B¹BÃBÌBÖBàBêBóBýBCCC$C.C8CBCKCUC_ChCrC|C†CC™C£C­C·CÀCÊCÔCÞCèCñCûCDDD"D,D5D?DIDSD]DfDpDzD„DŽD—D¡D«D´D¾DÈDÒDÛDåDïDùDE EE E*E4E>EHERE\EfEpEzE„EŽE˜E¢E¬E¶EÀEÊEÔEÞEèEòEüEFFF$F.F8FBFLFVF`FjFtF~FˆF’FœF¦F°FºFÄFÎFØFâFìFöFG GGG(G2GJHJRJ\JfJpJzJ„JŽJ˜J¢J¬J¶JÀJÊJÔJÞJèJòJüJKKK$K.K8KBKLKVK`KjKtK~KˆK’KœK¦K°KºKÄKÎKØKâKìKöKL LLL(L2LOHORO\OfOpOzO„OŽO˜O¢O¬O¶OÀOÊOÔOÞOèOòOüOPPP$P.P8PBPLPVP`PjPtP~PˆP’PœP¦P°PºPÄPÎPØPâPìPöPQ QQQ(Q2QTHTRT\TfTpTzT„TŽT˜T¢T¬T¶TÀTÊTÔTÞTèTòTüTUUU$U.U8UBULUVU`UjUtU~UˆU’UœU¦U°UºUÄUÎUØUâUìUöUV VVV(V2VYHYRY\YfYpYzY„YŽY˜Y¢Y¬Y¶YÀYÊYÔYÞYèYòYüYZZZ$Z.Z8ZBZLZVZ`ZjZtZ~Z‡Z‘ZšZ¤Z®Z·ZÁZËZÔZÞZèZñZûZ[[["[+[5[?[H[R[\[e[o[y[‚[Œ[–[Ÿ[©[²[¼[Æ[Ï[Ù[ã[ì[ö[\ \\\&\0\:\C\M\W\`\j\t\}\‡\‘\š\¤\®\¸\Á\Ë\Ô\Þ\è\ñ\û\]]]"]+]5]?]H]R]\]e]o]y]‚]Œ]–]Ÿ]©]³]¼]Æ]Ð]Ú]ã]í]ö]^ ^^^'^0^:^D^M^W^a^j^t^~^‡^‘^›^¤^®^¸^Á^Ë^Õ^Þ^è^ò^ü^___"_,_5_?_I_R_\_f_o_y_ƒ_Œ_–_ _©_³_½_Æ_Ð_Ú_ã_í_÷_` ```'`1`:`D`N`W`a`k`t`~`ˆ`‘`›`¥`®`¸`Â`Ë`Õ`ß`è`ò`ü`aaa"a,a6a?aIaRa\afaoayaƒaŒa–a a©a³a½aÆaÐaÚaãaía÷ab bbb'b1b:bDbNbXbabkbtb~bˆb‘b›b¥b®b¸bÂbËbÕbßbèbòbübccc"c,c6c?cIcSc\cfcpczcƒcc–c cªc³c½cÇcÐcÚcäcíc÷cd ddd'd1d;dDdNdXdadkdud~dˆd’dœd¥d¯d¸dÂdÌdÕdßdédòdüdeee#e,e6e@eIeSe]efepezeƒee—e eªe´e¾eÈeÑeÛeäeîeøef fff(f2f;fEfOfXfbflfuff‰f’fœf¦f¯f¹fÃfÌfÖfàfêfôfþfggg&g0g:gDgNgXgbglgvg€gŠg”gžg¨g²g¼gÆgÐgÚgägíg÷gh hhh)h3h=hGhQh[hehohyhƒhh—h¡h«hµh¾hÞhèhòhühiii$i.i8iBiLiVi`ijiti~iˆi’iœi¦i°iºiÄiÎiØiâiìiöij jjj(j2jxHxRx\xexoxyx‚xŒx–xŸx©x³x¼xÆxÐxÙxãxíx÷xy yyy(y2y;yEyOyXybylyuyy‰y’yœy¦y°yºyÄyÎy×yáyëyôyþyzzz%z.z8zBzLzVz`zjzsz}z‡zzšz¤z­z·zÁzÊzÔzÞzçzñzûz{{{#{,{6{@{I{S{]{f{p{z{ƒ{{—{ {ª{´{¾{È{Ò{Ü{æ{ð{ú{| || |*|4|>|H|Q|[|d|n|x|‚|Œ|–| |ª|³|½|Ç|Ð|Ú|ä|î|÷|} }}}'}1};}E}O}Y}c}l}v}}‰}“}}¦}°}º}Ã}Í}×}á}ë}õ}ÿ} ~~~&~0~9~C~L~V~`~i~s~}~‡~~š~¤~®~¸~Â~Ì~Õ~ß~é~ò~ü~#-7@JT^gq{…™£­·ÁËÔÞèñû€€€"€+€5€?€I€R€\€f€p€z€„€€—€ €ª€´€¾€È€Ñ€Û€å€ï€ø€  *4=GQZdmwŠ”ž¨²¼ÆÐÚãí÷‚ ‚‚‚'‚1‚:‚D‚N‚X‚a‚k‚u‚‚‰‚“‚‚¦‚°‚º‚Âׂ͂à‚ê‚ô‚þ‚ƒƒƒ$ƒ.ƒ8ƒBƒLƒVƒ`ƒjƒtƒ~ƒ‡ƒ‘ƒšƒ¤ƒ­ƒ·ƒÁƒÊƒÔƒÞƒèƒòƒüƒ„„„#„-„6„@„I„S„]„f„p„z„„„Ž„˜„¢„¬„¶„À„Ê„Ô„Ý„ç„ñ„û„………"…+…5…?…H…R…\…e…o…y…ƒ……—…¡…«…´…¾…Ç…Ñ…Û…ä…î…ø…† †† †*†4†>†H†R†[†e†n†x††‹†•†ž†¨†±†»†Å†Ï†Ù†ã†í†ö†‡ ‡‡‡&‡0‡9‡C‡M‡V‡`‡j‡t‡~‡ˆ‡‘‡›‡¤‡®‡·‡Á‡Ê‡Ô‡Þ‡è‡ò‡ü‡ˆˆˆ#ˆ,ˆ6ˆ@ˆJˆSˆ]ˆfˆpˆzˆ„ˆŽˆ˜ˆ¡ˆ«ˆ´ˆ¾ˆÇˆÑˆÛˆäˆîˆøˆ‰ ‰‰‰)‰3‰=‰G‰Q‰[‰e‰n‰x‰‰‹‰”‰ž‰§‰±‰»‰Ä‰Î‰Ø‰â‰ì‰ö‰ÿ‰ ŠŠŠ%Š/Š8ŠBŠKŠUŠ_ŠiŠsŠ}Š†ŠŠ™Š£Š­Š¶ŠÀŠÊŠÔŠÞŠèŠòŠûŠ‹‹‹!‹+‹4‹>‹G‹Q‹[‹e‹o‹y‹‚‹Œ‹•‹Ÿ‹©‹²‹¼‹Æ‹Ï‹Ù‹ã‹í‹÷‹Œ ŒŒŒ)Œ3Œ=ŒGŒQŒ[ŒeŒoŒyŒƒŒŒ—Œ¡Œ«ŒµŒ¿ŒÉŒÓŒÝŒçŒñŒûŒ#-7AKU_is}‡‘›¥¯¹ÃÍ×áëõÿ ŽŽŽ'Ž1Ž;ŽEŽOŽYŽcŽmŽwŽŽ‹Ž•ŽŸŽ©Ž³Ž½ŽÇŽÑŽÛŽåŽïŽùŽ !+5?IS]gq{…™£­·ÁËÕßéóý%/9CMWaku‰“§±»ÅÏÙãí÷‘ ‘‘‘)‘3‘=‘G‘Q‘[‘e‘o‘y‘ƒ‘‘—‘¡‘«‘µ‘¿‘É‘Ó‘Ý‘ç‘ñ‘û‘’’’#’-’7’A’K’U’_’i’s’}’‡’‘’›’¥’¯’¹’Ã’Í’×’á’ë’õ’ÿ’ “““'“1“;“E“O“Y“c“m“w““‹“•“Ÿ“©“³“½“Ç“Ñ“Û“å“ï“ù“” ””!”+”5”?”I”S”]”g”q”{”…””™”£”­”·”Á”˔Քߔé”ó”ý”•••%•/•9•C•M•W•a•k•u••‰•“••§•±•»•Å•Ï•Ù•ã•í•÷•– –––)–3–=–G–Q–[–e–o–y–ƒ––—–¡–«–µ–¿–É–Ó–Ý–ç–ñ–û–———"—+—5—?—H—R—\—e—o—y—‚—Œ—–— —ª—´—¾—Ç—Ñ—Û—ä—î—ø—˜ ˜˜˜(˜2˜;˜E˜O˜Y˜c˜m˜w˜˜‹˜•˜Ÿ˜¨˜²˜¼˜Å˜Ï˜Ù˜â˜ì˜ö˜ÿ˜ ™™™&™0™:™D™N™X™a™k™u™~™ˆ™’™›™¥™¯™¸™Â™Ì™Õ™ß™é™ó™ý™ššš%š/š9šCšMšWšaškšušš‰š“šš§š±š»šÅšÏšÙšãšíš÷š› ›››)›3›=›G›Q›[›e›o›y›ƒ››—›¡›«›µ›¿›É›Ó›Ý›ç›ñ›û›œœœ#œ-œ7œAœKœUœ_œiœsœ}œ‡œ‘œ›œ¥œ¯œ¹œÃœÍœ×œáœëœõœÿœ '1;EOYcmw‹•Ÿ©³½ÇÑÛåïùž žž!ž+ž5ž?žIžSž]žgžqž{ž…žž™ž£ž­ž·žÁžËžÕžßžéžóžýžŸŸŸ%Ÿ/Ÿ9ŸCŸMŸWŸaŸkŸuŸŸ‰Ÿ“ŸŸ§Ÿ±Ÿ»ŸÅŸÏŸÙŸãŸíŸ÷Ÿ     ) 3 = G Q [ e o y ƒ  — ¡ « µ ¿ É Ó Ý ç ñ û ¡¡¡#¡-¡7¡A¡K¡U¡_¡i¡s¡}¡‡¡‘¡›¡¥¡¯¡¹¡Ã¡Í¡×¡á¡ë¡õ¡ÿ¡ ¢¢¢'¢1¢;¢E¢O¢Y¢c¢m¢w¢¢‹¢•¢Ÿ¢©¢³¢½¢Ç¢Ñ¢Û¢å¢ï¢ù¢£ ££!£+£5£?£I£S£]£g£q£{£…££™£££­£·£Á£Ë£Õ£ß£é£ó£ý£¤¤¤%¤/¤9¤C¤M¤W¤a¤k¤u¤¤‰¤“¤¤§¤±¤»¤Å¤Ï¤Ù¤ã¤í¤÷¤¥ ¥¥¥)¥3¥=¥G¥Q¥[¥e¥o¥y¥ƒ¥¥—¥¡¥«¥µ¥¿¥É¥Ó¥Ý¥ç¥ñ¥û¥¦¦¦#¦-¦7¦A¦J¦T¦^¦g¦q¦{¦„¦Ž¦˜¦¡¦«¦µ¦¾¦È¦Ò¦Ü¦æ¦ð¦ú¦§ §§ §*§4§=§G§Q§Z§d§n§w§§‹§•§Ÿ§©§³§¼§Æ§Ð§Ù§ã§í§ö§¨ ¨¨¨'¨1¨;¨E¨O¨X¨b¨l¨u¨¨‰¨’¨œ¨¦¨¯¨¹¨Ã¨Ì¨Ö¨à¨ê¨ô¨þ¨©©©%©.©8©B©K©U©_©h©r©|©…©©™©£©­©·©Á©Ë©Õ©ß©é©ò©ü©ªªª#ª,ª6ª@ªIªSª]ªgªqª{ª…ªŽª˜ª¢ª«ªµª¿ªÈªÒªÜªåªïªùª« ««!«*«4«>«G«Q«[«d«n«x««‹«•«Ÿ«©«³«½«Æ«Ð«Ú«ã«í«÷«¬ ¬¬¬'¬1¬;¬E¬O¬Y¬b¬l¬v¬¬‰¬“¬œ¬¦¬°¬¹¬Ã¬Í¬×¬á¬ë¬õ¬ÿ¬ ­­­&­/­9­B­L­U­_­i­s­}­‡­­š­£­­­¶­À­É­Ó­Ý­ç­ñ­û­®®®!®*®4®=®G®Q®[®e®o®x®‚®‹®•®ž®¨®±®»®Å®Ï®Ù®ã®ì®ö®ÿ® ¯¯¯%¯/¯9¯C¯M¯W¯a¯k¯u¯¯‰¯“¯¯§¯±¯»¯Å¯Ï¯Ù¯ã¯í¯÷¯° °°°)°3°=°G°Q°[°e°o°y°ƒ°°—°¡°«°µ°¿°É°Ó°Ý°ç°ñ°û°±±±#±-±7±A±K±U±_±i±s±}±‡±‘±›±¥±¯±¹±Ã±Í±×±á±ë±õ±ÿ± ²²²'²1²;²E²O²Y²c²m²w²²‹²•²Ÿ²©²³²½²Ç²Ñ²Û²å²ï²ù²³ ³³!³+³5³?³I³S³]³g³q³{³…³³™³£³­³·³Á³Ë³Õ³ß³é³ó³ý³´´´%´/´9´C´M´W´a´k´u´´‰´“´´§´±´»´Å´Ï´Ù´ã´í´÷´µ µµµ)µ3µ=µGµQµ[µeµoµyµƒµµ—µ µ©µ²µ»µÅµÏµÙµãµìµõµþµ¶¶¶%¶/¶8¶A¶J¶S¶]¶g¶q¶{¶„¶¶–¶Ÿ¶©¶³¶½¶Ç¶Ð¶Ù¶â¶ë¶õ¶ÿ¶ ···'·1·;·E·O·Y·c·m·w··‹·•·Ÿ·©·³·½·Ç·Ñ·Û·å·ï·ù·¸ ¸¸!¸+¸5¸?¸I¸S¸]¸g¸q¸{¸…¸¸™¸£¸­¸·¸Á¸Ë¸Õ¸ß¸é¸ó¸ý¸¹¹¹%¹/¹9¹C¹M¹W¹a¹k¹u¹¹‰¹“¹¹§¹±¹»¹Å¹Ï¹Ù¹ã¹í¹÷¹º ººº)º3º=ºGºQº[ºeºoºyºƒºº—º¡º«ºµº¿ºÉºÓºÝºçºñºûº»»»#»-»7»A»K»U»_»i»s»}»‡»‘»›»¥»¯»¹»Ã»Í»×»á»ë»õ»ÿ» ¼¼¼'¼1¼;¼E¼O¼Y¼c¼m¼w¼¼‹¼•¼Ÿ¼©¼³¼½¼Ç¼Ñ¼Û¼å¼ï¼ù¼½ ½½!½+½5½?½I½S½]½g½q½{½…½½™½£½­½·½Á½Ë½Õ½ß½é½ó½ý½¾¾¾%¾/¾9¾C¾M¾W¾a¾k¾u¾¾‰¾“¾¾§¾±¾»¾Å¾Ï¾Ù¾ã¾í¾÷¾¿ ¿¿¿)¿3¿=¿G¿Q¿[¿e¿o¿y¿ƒ¿¿—¿¡¿«¿µ¿¿¿É¿Ó¿Ý¿ç¿ñ¿û¿ÀÀÀ#À-À7ÀAÀKÀUÀ_ÀiÀsÀ}À‡À‘À›À¥À¯À¹ÀÃÀÍÀ×ÀáÀëÀõÀÿÀ ÁÁÁ'Á1Á;ÁEÁOÁYÁcÁmÁwÁÁ‹Á•ÁŸÁ©Á³Á½ÁÇÁÑÁÛÁåÁïÁùÁ ÂÂ!Â+Â5Â?ÂIÂSÂ]ÂgÂqÂ{…™£­·ÂÁÂËÂÕÂßÂéÂóÂýÂÃÃÃ%Ã/Ã9ÃCÃMÃWÃaÃkÃuÃÉÓÃçñûÃÅÃÏÃÙÃãÃíÃ÷ÃÄ ÄÄÄ)Ä3Ä=ÄGÄQÄ[ÄeÄoÄyăÄėġīĵĿÄÉÄÓÄÝÄçÄñÄûÄÅÅÅ#Å-Å7ÅAÅKÅUÅ_ÅiÅsÅ}ŇőśťůŹÅÃÅÍÅ×ÅáÅëÅõÅÿÅ ÆÆÆ'Æ1Æ;ÆEÆOÆYÆcÆmÆwÆƋƕƟƩƳƽÆÇÆÑÆÛÆåÆïÆùÆÇ ÇÇ!Ç+Ç5Ç?ÇIÇSÇ]ÇgÇqÇ{Ç…ÇǙǣǭǷÇÁÇËÇÕÇßÇéÇóÇýÇÈÈÈ%È/È9ÈCÈMÈWÈaÈkÈuÈȉȓÈȧȱȻÈÅÈÏÈÙÈãÈíÈ÷ÈÉ ÉÉÉ)É3É=ÉGÉQÉ[ÉeÉoÉyɃÉɗɡɫɵɿÉÉÉÓÉÝÉçÉñÉûÉÊÊÊ#Ê-Ê7ÊAÊKÊUÊ_ÊiÊsÊ}ʇʑʛʥʯʹÊÃÊÍÊ×ÊáÊëÊõÊÿÊ ËËË'Ë1Ë;ËEËOËYËcËmËwËˋ˕˟˩˳˽ËÇËÑËÛËåËïËùËÌ ÌÌ!Ì+Ì5Ì?ÌIÌSÌ]ÌgÌqÌ{Ì…Ì̷̙̣̭ÌÁÌËÌÕÌßÌéÌóÌýÌÍÍÍ%Í/Í9ÍCÍMÍWÍaÍkÍuÍ͉͓ÍͧͱͻÍÅÍÏÍÙÍãÍíÍ÷ÍÎ ÎÎ5ÎÏ"Ï/ÏPÏqϒϳÏÔÏáÏÐ#ÐDÐeІГРЭкÐÇÐÔÐáÐîÐûÐÑÑ"Ñ/Ñ<ÑIÑVÑwјѹÑÚÑûÑÒÒ"Ò/Ò<ÒIÒVÒcÒpÒ}ÒŠÒ—Ò¸ÒÅÒÒÒßÒìÒùÒÓÓ Ó-ÓNÓoÓÓ±ÓÒÓßÓìÓùÓÔÔ Ô-Ô:ÔGÔTÔaÔnÔ{ÔˆÔ•Ô¢Ô¯Ô¼ÔÉÔÖÔãÔðÔýÔ ÕÕ$Õ1Õ>ÕKÕXÕeÕrÕՌՙզճÕÀÕÍÕÚÕçÕôÕÖÖÖ(Ö5ÖBÖOÖ\ÖiÖvÖƒÖÖÖªÖ·ÖÄÖÑÖÞÖëÖøÖ×××,×9×F×S×`×m×zׇהס׮׻×È×Õ×â×ï×ü× ØØ#Ø0Ø=ØJØWØdØqØ~؋ؘإزؿØÌØÙØæØóØÙ ÙÙ7ÙTÙaÙ}ن٢٫ٸÙØÙùÙÚ&Ú3Ú@ÚaÚnÚ{ÚˆÚ•Ú±Ú¾ÚËÚØÚäÚðÚÐÛÌÛPZÿÿÿÿÿÿÿÿÿÿÿÿdÿÿÿÿÿÿ€Sÿÿÿÿÿÿaÿÿÿÿÿÿ"€Sÿÿÿÿÿÿ*"^ÿÿÿÿÿÿ4€Sÿÿÿÿÿÿ<4[ÿÿÿÿÿÿF€ SÿÿÿÿÿÿNF XÿÿÿÿÿÿX€ Sÿÿÿÿÿÿ`X€ Sÿÿÿÿÿÿj"€ Sÿÿÿÿÿÿt""€Sÿÿÿÿÿÿ~"4€Sÿÿÿÿÿÿˆ"F€Sÿÿÿÿÿÿ’"X€Sÿÿÿÿÿÿœ4€Sÿÿÿÿÿÿ¦4"€Sÿÿÿÿÿÿ°44€Sÿÿÿÿÿÿº4F€SÿÿÿÿÿÿÄ4X€SÿÿÿÿÿÿÎF€SÿÿÿÿÿÿØF"€SÿÿÿÿÿÿâF4€SÿÿÿÿÿÿìFF€SÿÿÿÿÿÿöFX€SÿÿÿÿÿÿX€Sÿÿÿÿÿÿ X"€SÿÿÿÿÿÿX4€SÿÿÿÿÿÿXF€Sÿÿÿÿÿÿ(XX€ >ÿÿÿÿÿÿ2€!>ÿÿÿÿÿÿ<"€"ÿÿÿÿÿÿF2<€#>ÿÿÿÿÿÿP4€$ÿÿÿÿÿÿZFP€%>ÿÿÿÿÿÿdF€&ÿÿÿÿÿÿnZd€'>ÿÿÿÿÿÿxX€(ÿÿÿÿÿÿ‚nx€)>ÿÿÿÿÿÿŒ*€*>ÿÿÿÿÿÿ–"*€+ÿÿÿÿÿÿ Œ–€,>ÿÿÿÿÿÿª*4€-ÿÿÿÿÿÿ´ ª€.>ÿÿÿÿÿÿ¾*F€/ÿÿÿÿÿÿÈ´¾€0>ÿÿÿÿÿÿÒ*X€1ÿÿÿÿÿÿÜÈÒ€2ÿÿÿÿÿÿæ‚Ü€3>ÿÿÿÿÿÿð<€4>ÿÿÿÿÿÿú"<€5ÿÿÿÿÿÿðú€6>ÿÿÿÿÿÿ4<€7ÿÿÿÿÿÿ€8>ÿÿÿÿÿÿ"<F€9ÿÿÿÿÿÿ,"€:>ÿÿÿÿÿÿ6<X€;ÿÿÿÿÿÿ@,6€<ÿÿÿÿÿÿJæ@€=>ÿÿÿÿÿÿTN€>>ÿÿÿÿÿÿ^"N€?ÿÿÿÿÿÿhT^€@>ÿÿÿÿÿÿr4N€Aÿÿÿÿÿÿ|hr€B>ÿÿÿÿÿÿ†FN€Cÿÿÿÿÿÿ|†€D>ÿÿÿÿÿÿšNX€Eÿÿÿÿÿÿ¤š€Fÿÿÿÿÿÿ®J¤€G>ÿÿÿÿÿÿ¸`€H>ÿÿÿÿÿÿÂ"`€Iÿÿÿÿÿÿ̸€J>ÿÿÿÿÿÿÖ4`€KÿÿÿÿÿÿàÌÖ€L>ÿÿÿÿÿÿêF`€Mÿÿÿÿÿÿôàê€N>ÿÿÿÿÿÿþX`€Oÿÿÿÿÿÿôþ€Pÿÿÿÿÿÿ®€Q>ÿÿÿÿÿÿj€R>ÿÿÿÿÿÿ&"j€Sÿÿÿÿÿÿ0&€T>ÿÿÿÿÿÿ:4j€UÿÿÿÿÿÿD0:€V>ÿÿÿÿÿÿNFj€WÿÿÿÿÿÿXDN€X>ÿÿÿÿÿÿbXj€YÿÿÿÿÿÿlXb€Z>ÿÿÿÿÿÿvt€[>ÿÿÿÿÿÿ€"t€\ÿÿÿÿÿÿŠv€€]>ÿÿÿÿÿÿ”4t€^ÿÿÿÿÿÿžŠ”€_>ÿÿÿÿÿÿ¨Ft€`ÿÿÿÿÿÿ²ž¨€a>ÿÿÿÿÿÿ¼Xt€bÿÿÿÿÿÿƲ¼€cÿÿÿÿÿÿÐlÆ€d>ÿÿÿÿÿÿÚ~€e>ÿÿÿÿÿÿä"~€fÿÿÿÿÿÿîÚä€g>ÿÿÿÿÿÿø4~€hÿÿÿÿÿÿîø€i>ÿÿÿÿÿÿ F~€jÿÿÿÿÿÿ €k>ÿÿÿÿÿÿ X~€lÿÿÿÿÿÿ* €mÿÿÿÿÿÿ4Ð*€n>ÿÿÿÿÿÿ>ˆ€o>ÿÿÿÿÿÿH"ˆ€pÿÿÿÿÿÿR>H€q>ÿÿÿÿÿÿ\4ˆ€rÿÿÿÿÿÿfR\€s>ÿÿÿÿÿÿpFˆ€tÿÿÿÿÿÿzfp€u>ÿÿÿÿÿÿ„Xˆ€vÿÿÿÿÿÿŽz„€wÿÿÿÿÿÿ˜4Ž€x>ÿÿÿÿÿÿ¢’€y>ÿÿÿÿÿÿ¬"’€zÿÿÿÿÿÿ¶¢¬€{>ÿÿÿÿÿÿÀ4’€|ÿÿÿÿÿÿʶÀ€}>ÿÿÿÿÿÿÔF’€~ÿÿÿÿÿÿÞÊÔ€>ÿÿÿÿÿÿèX’€€ÿÿÿÿÿÿòÞè€ÿÿÿÿÿÿü˜ò€‚ÿÿÿÿÿÿü€ƒ>ÿÿÿÿÿÿœ€„>ÿÿÿÿÿÿ"œ€…ÿÿÿÿÿÿ$€†>ÿÿÿÿÿÿ.4œ€‡ÿÿÿÿÿÿ8$.€ˆ>ÿÿÿÿÿÿBFœ€‰ÿÿÿÿÿÿL8B€Š>ÿÿÿÿÿÿVXœ€‹ÿÿÿÿÿÿ`LV€Œ>ÿÿÿÿÿÿj¦€>ÿÿÿÿÿÿt"¦€Žÿÿÿÿÿÿ~jt€>ÿÿÿÿÿÿˆ4¦€ÿÿÿÿÿÿ’~ˆ€‘>ÿÿÿÿÿÿœF¦€’ÿÿÿÿÿÿ¦’œ€“>ÿÿÿÿÿÿ°X¦€”ÿÿÿÿÿÿº¦°€•ÿÿÿÿÿÿÄ`º€–>ÿÿÿÿÿÿΰ€—>ÿÿÿÿÿÿØ"°€˜ÿÿÿÿÿÿâÎØ€™>ÿÿÿÿÿÿì4°€šÿÿÿÿÿÿöâ쀛>ÿÿÿÿÿÿF°€œÿÿÿÿÿÿ ö€>ÿÿÿÿÿÿX°€žÿÿÿÿÿÿ €Ÿÿÿÿÿÿÿ(Ä€ >ÿÿÿÿÿÿ2º€¡>ÿÿÿÿÿÿ<"º€¢ÿÿÿÿÿÿF2<€£>ÿÿÿÿÿÿP4º€¤ÿÿÿÿÿÿZFP€¥>ÿÿÿÿÿÿdFº€¦ÿÿÿÿÿÿnZd€§>ÿÿÿÿÿÿxXº€¨ÿÿÿÿÿÿ‚nx€©ÿÿÿÿÿÿŒ(‚€ª>ÿÿÿÿÿÿ–Ä€«>ÿÿÿÿÿÿ "Ä€¬ÿÿÿÿÿÿª– €­>ÿÿÿÿÿÿ´4Ä€®ÿÿÿÿÿÿ¾ª´€¯>ÿÿÿÿÿÿÈFÄ€°ÿÿÿÿÿÿҾȀ±>ÿÿÿÿÿÿÜXÄ€²ÿÿÿÿÿÿæÒÜ€³ÿÿÿÿÿÿðŒæ€´ÿÿÿÿÿÿúð€µ>ÿÿÿÿÿÿ΀¶>ÿÿÿÿÿÿ"΀·ÿÿÿÿÿÿ€¸>ÿÿÿÿÿÿ"4΀¹ÿÿÿÿÿÿ,"€º>ÿÿÿÿÿÿ6F΀»ÿÿÿÿÿÿ@,6€¼>ÿÿÿÿÿÿJX΀½ÿÿÿÿÿÿT@J€¾>ÿÿÿÿÿÿ^Ø€¿>ÿÿÿÿÿÿh"Ø€Àÿÿÿÿÿÿr^h€Á>ÿÿÿÿÿÿ|4Ø€Âÿÿÿÿÿÿ†r|€Ã>ÿÿÿÿÿÿFØ€Äÿÿÿÿÿÿš†€Å>ÿÿÿÿÿÿ¤XØ€Æÿÿÿÿÿÿ®š¤€Çÿÿÿÿÿÿ¸T®€È>ÿÿÿÿÿÿÂâ€É>ÿÿÿÿÿÿÌ"â€ÊÿÿÿÿÿÿÖÂÌ€Ë>ÿÿÿÿÿÿà4â€ÌÿÿÿÿÿÿêÖà€Í>ÿÿÿÿÿÿôFâ€Îÿÿÿÿÿÿþêô€Ï>ÿÿÿÿÿÿXâ€Ðÿÿÿÿÿÿþ€Ñÿÿÿÿÿÿ¸€Ò>ÿÿÿÿÿÿ&ì€Ó>ÿÿÿÿÿÿ0"ì€Ôÿÿÿÿÿÿ:&0€Õ>ÿÿÿÿÿÿD4ì€ÖÿÿÿÿÿÿN:D€×>ÿÿÿÿÿÿXFì€ØÿÿÿÿÿÿbNX€Ù>ÿÿÿÿÿÿlXì€Úÿÿÿÿÿÿvbl€Ûÿÿÿÿÿÿ€v€Ü>ÿÿÿÿÿÿŠö€Ý>ÿÿÿÿÿÿ”"ö€ÞÿÿÿÿÿÿžŠ”€ß>ÿÿÿÿÿÿ¨4ö€àÿÿÿÿÿÿ²ž¨€á>ÿÿÿÿÿÿ¼Fö€âÿÿÿÿÿÿƲ¼€ã>ÿÿÿÿÿÿÐXö€äÿÿÿÿÿÿÚÆЀåÿÿÿÿÿÿä€Ú€æÿÿÿÿÿÿîúä€ç>ÿÿÿÿÿÿø€è>ÿÿÿÿÿÿ "€éÿÿÿÿÿÿ ø €ê>ÿÿÿÿÿÿ 4€ëÿÿÿÿÿÿ  €ì>ÿÿÿÿÿÿ* F€íÿÿÿÿÿÿ4 * €î>ÿÿÿÿÿÿ> X€ïÿÿÿÿÿÿH 4 > €ð>ÿÿÿÿÿÿR  €ñ>ÿÿÿÿÿÿ\ " €òÿÿÿÿÿÿf R \ €ó>ÿÿÿÿÿÿp 4 €ôÿÿÿÿÿÿz f p €õ>ÿÿÿÿÿÿ„ F €öÿÿÿÿÿÿŽ z „ €÷>ÿÿÿÿÿÿ˜ X €øÿÿÿÿÿÿ¢ Ž ˜ €ùÿÿÿÿÿÿ¬ H ¢ €ú>ÿÿÿÿÿÿ¶ €û>ÿÿÿÿÿÿÀ "€üÿÿÿÿÿÿÊ ¶ À €ý>ÿÿÿÿÿÿÔ 4€þÿÿÿÿÿÿÞ Ê Ô €ÿ>ÿÿÿÿÿÿè F€ÿÿÿÿÿÿò Þ è €>ÿÿÿÿÿÿü X€ÿÿÿÿÿÿ ò ü €ÿÿÿÿÿÿ ¬  €>ÿÿÿÿÿÿ €>ÿÿÿÿÿÿ$ "€ÿÿÿÿÿÿ.  $ €>ÿÿÿÿÿÿ8 4€ÿÿÿÿÿÿB . 8 € >ÿÿÿÿÿÿL F€ ÿÿÿÿÿÿV B L € >ÿÿÿÿÿÿ` X€ ÿÿÿÿÿÿj V ` € ÿÿÿÿÿÿt  j €>ÿÿÿÿÿÿ~ (€>ÿÿÿÿÿÿˆ "(€ÿÿÿÿÿÿ’ ~ ˆ €>ÿÿÿÿÿÿœ 4(€ÿÿÿÿÿÿ¦ ’ œ €>ÿÿÿÿÿÿ° F(€ÿÿÿÿÿÿº ¦ ° €>ÿÿÿÿÿÿÄ X(€ÿÿÿÿÿÿÎ º Ä €ÿÿÿÿÿÿØ t Î €ÿÿÿÿÿÿâ îØ €ÿÿÿÿÿÿì 2Œ€ÿÿÿÿÿÿö ì ð€ÿÿÿÿÿÿ ö T€ÿÿÿÿÿÿ ¸€ÿÿÿÿÿÿ 2€ÿÿÿÿÿÿ  €ÿÿÿÿÿÿ(  € ÿÿÿÿÿÿ2 ( ø€!ÿÿÿÿÿÿ< 2 €"ÿÿÿÿÿÿF <–€#ÿÿÿÿÿÿP F ú€$ÿÿÿÿÿÿZ P ^€%ÿÿÿÿÿÿd Z €&ÿÿÿÿÿÿn <&€'ÿÿÿÿÿÿx n €(ÿÿÿÿÿÿ‚ x €)ÿÿÿÿÿÿŒ ‚  €*ÿÿÿÿÿÿ– d Œ €+ÿÿÿÿÿÿ  < – €,ÿÿÿÿÿÿª Pª€-ÿÿÿÿÿÿ´ ª €.ÿÿÿÿÿÿ¾ ´ r€/ÿÿÿÿÿÿÈ ¾ Ö€0ÿÿÿÿÿÿÒ P:€1ÿÿÿÿÿÿÜ Ò .€2ÿÿÿÿÿÿæ Ü "€3ÿÿÿÿÿÿð æ  €4ÿÿÿÿÿÿú È ð €5ÿÿÿÿÿÿ   ú €6ÿÿÿÿÿÿ d¾€7ÿÿÿÿÿÿ  "€8ÿÿÿÿÿÿ"  †€9ÿÿÿÿÿÿ, " ê€:ÿÿÿÿÿÿ6 dN€;ÿÿÿÿÿÿ@ 6 B€<ÿÿÿÿÿÿJ @ 6€=ÿÿÿÿÿÿT J * €>ÿÿÿÿÿÿ^ , T €?ÿÿÿÿÿÿh  ^ €@ÿÿÿÿÿÿr xÒ€Aÿÿÿÿÿÿ| r 6€Bÿÿÿÿÿÿ† | š€Cÿÿÿÿÿÿ † þ€Dÿÿÿÿÿÿš xb€Eÿÿÿÿÿÿ¤ š V€Fÿÿÿÿÿÿ® ¤ J€Gÿÿÿÿÿÿ¸ ® > €Hÿÿÿÿÿÿ ¸ €IÿÿÿÿÿÿÌ h  €JÿÿÿÿÿÿÖ v€Kÿÿÿÿÿÿà Ö Ú€Lÿÿÿÿÿÿê à >€Mÿÿÿÿÿÿô ê ¢€Nÿÿÿÿÿÿþ Œv€Oÿÿÿÿÿÿ þ j€Pÿÿÿÿÿÿ  ^€Qÿÿÿÿÿÿ  R €Rÿÿÿÿÿÿ& ô  €Sÿÿÿÿÿÿ0 &€€Tÿÿÿÿÿÿ: 0 ä€UÿÿÿÿÿÿD : H€VÿÿÿÿÿÿN D ¬€WÿÿÿÿÿÿX –€€Xÿÿÿÿÿÿb X t€Yÿÿÿÿÿÿl b h€Zÿÿÿÿÿÿv l \ €[ÿÿÿÿÿÿ€ N v €\ÿÿÿÿÿÿŠ & € €]ÿÿÿÿÿÿ” :”€^ÿÿÿÿÿÿž ” ø€_ÿÿÿÿÿÿ¨ ž \€`ÿÿÿÿÿÿ² ¨ À€aÿÿÿÿÿÿ¼ ª”€bÿÿÿÿÿÿÆ ¼ ˆ€cÿÿÿÿÿÿÐ Æ |€dÿÿÿÿÿÿÚ Ð p €eÿÿÿÿÿÿä ² Ú €fÿÿÿÿÿÿî Š ä €gÿÿÿÿÿÿø N¨€hÿÿÿÿÿÿø €iÿÿÿÿÿÿ p€jÿÿÿÿÿÿ Ô€kÿÿÿÿÿÿ ¾¨€lÿÿÿÿÿÿ* œ€mÿÿÿÿÿÿ4*€nÿÿÿÿÿÿ>4„ €oÿÿÿÿÿÿH>€pÿÿÿÿÿÿRî H€qÿÿÿÿÿÿ\b¼€rÿÿÿÿÿÿf\ €sÿÿÿÿÿÿpf„€tÿÿÿÿÿÿzpè€uÿÿÿÿÿÿ„Ò¼€vÿÿÿÿÿÿŽ„°€wÿÿÿÿÿÿ˜Ž¤€xÿÿÿÿÿÿ¢˜˜ €yÿÿÿÿÿÿ¬z¢€zÿÿÿÿÿÿ¶R¬€{ÿÿÿÿÿÿÀÌ ¶€|ÿÿÿÿÿÿÊj€}ÿÿÿÿÿÿÔÊ΀~ÿÿÿÿÿÿÞÔ2€ÿÿÿÿÿÿèÞ–€€ÿÿÿÿÿÿòðÚ€ÿÿÿÿÿÿüò΀‚ÿÿÿÿÿÿü€ƒÿÿÿÿÿÿ¶ €„ÿÿÿÿÿÿ者ÿÿÿÿÿÿ$t€†ÿÿÿÿÿÿ.$Ø€‡ÿÿÿÿÿÿ8.<€ˆÿÿÿÿÿÿB8 €‰ÿÿÿÿÿÿLú䀊ÿÿÿÿÿÿVLØ€‹ÿÿÿÿÿÿ`VÌ€Œÿÿÿÿÿÿj`À €ÿÿÿÿÿÿtBj€Žÿÿÿÿÿÿ~t€ÿÿÿÿÿÿˆ.ˆ€ÿÿÿÿÿÿ’ˆì€‘ÿÿÿÿÿÿœ’P€’ÿÿÿÿÿÿ¦œ´€“ÿÿÿÿÿÿ°ø€”ÿÿÿÿÿÿº°ì€•ÿÿÿÿÿÿÄºà€–ÿÿÿÿÿÿÎÄÔ €—ÿÿÿÿÿÿئ΀˜ÿÿÿÿÿÿâ~Ø€™ÿÿÿÿÿÿìBœ€šÿÿÿÿÿÿö쀛ÿÿÿÿÿÿöd€œÿÿÿÿÿÿ È€ÿÿÿÿÿÿ" €žÿÿÿÿÿÿ€Ÿÿÿÿÿÿÿ(ô€ ÿÿÿÿÿÿ2(è €¡ÿÿÿÿÿÿ< 2€¢ÿÿÿÿÿÿFâ<€£ÿÿÿÿÿÿPV°€¤ÿÿÿÿÿÿZP€¥ÿÿÿÿÿÿdZx€¦ÿÿÿÿÿÿndÜ€§ÿÿÿÿÿÿx6 €¨ÿÿÿÿÿÿ‚x€©ÿÿÿÿÿÿŒ‚€ªÿÿÿÿÿÿ–Œü €«ÿÿÿÿÿÿ n–€¬ÿÿÿÿÿÿªF €­ÿÿÿÿÿÿ´Àª€®ÿÿÿÿÿÿ¾^€¯ÿÿÿÿÿÿȾ€°ÿÿÿÿÿÿÒÈ&€±ÿÿÿÿÿÿÜÒŠ€²ÿÿÿÿÿÿæT>€³ÿÿÿÿÿÿðæ2€´ÿÿÿÿÿÿúð&€µÿÿÿÿÿÿú €¶ÿÿÿÿÿÿÜ€·ÿÿÿÿÿÿh€¸ÿÿÿÿÿÿ"Ì€¹ÿÿÿÿÿÿ,"0€ºÿÿÿÿÿÿ6,”€»ÿÿÿÿÿÿ@^H€¼ÿÿÿÿÿÿJ@<€½ÿÿÿÿÿÿTJ0€¾ÿÿÿÿÿÿ^T$ €¿ÿÿÿÿÿÿh6^€Àÿÿÿÿÿÿrh€Áÿÿÿÿÿÿ|"|€Âÿÿÿÿÿÿ†|à€Ãÿÿÿÿÿÿ†D€Äÿÿÿÿÿÿš¨€Åÿÿÿÿÿÿ¤r\€Æÿÿÿÿÿÿ®¤P€Çÿÿÿÿÿÿ¸®D€Èÿÿÿÿÿÿ¸8 €Éÿÿÿÿÿÿ̚€ÊÿÿÿÿÿÿÖrÌ€Ëÿÿÿÿÿÿà6€Ìÿÿÿÿÿÿêàô€ÍÿÿÿÿÿÿôêX€Îÿÿÿÿÿÿþô¼€Ïÿÿÿÿÿÿ†p€Ðÿÿÿÿÿÿd€ÑÿÿÿÿÿÿX€Òÿÿÿÿÿÿ&L €Óÿÿÿÿÿÿ0þ&€Ôÿÿÿÿÿÿ:Ö0€ÕÿÿÿÿÿÿDJ¤€ÖÿÿÿÿÿÿND€×ÿÿÿÿÿÿXNl€ØÿÿÿÿÿÿbXЀÙÿÿÿÿÿÿlš„€Úÿÿÿÿÿÿvlx€Ûÿÿÿÿÿÿ€vl€ÜÿÿÿÿÿÿŠ€` €Ýÿÿÿÿÿÿ”bŠ€Þÿÿÿÿÿÿž:”€ßÿÿÿÿÿÿ¨´ž€àÿÿÿÿÿÿ²øR €áÿÿÿÿÿÿ¼²¶ €âÿÿÿÿÿÿƼ €ãÿÿÿÿÿÿÐÆ~ €äÿÿÿÿÿÿÚ¸¢€åÿÿÿÿÿÿäÚ–€æÿÿÿÿÿÿî䊀çÿÿÿÿÿÿøî~ €èÿÿÿÿÿÿÐø€éÿÿÿÿÿÿ  \ €êÿÿÿÿÿÿ À €ëÿÿÿÿÿÿ $ €ìÿÿÿÿÿÿ* ˆ €íÿÿÿÿÿÿ4¬€îÿÿÿÿÿÿ>4 €ïÿÿÿÿÿÿH>”€ðÿÿÿÿÿÿRHˆ €ñÿÿÿÿÿÿ\*R€òÿÿÿÿÿÿf\€óÿÿÿÿÿÿp p €ôÿÿÿÿÿÿzpÔ €õÿÿÿÿÿÿ„z8 €öÿÿÿÿÿÿŽ„œ €÷ÿÿÿÿÿÿ˜ÖÀ€øÿÿÿÿÿÿ¢˜´€ùÿÿÿÿÿÿ¬¢¨€úÿÿÿÿÿÿ¶¬œ €ûÿÿÿÿÿÿÀŽ¶€üÿÿÿÿÿÿÊfÀ€ýÿÿÿÿÿÿÔ* „ €þÿÿÿÿÿÿÞÔè €ÿÿÿÿÿÿÿèÞL €ÿÿÿÿÿÿòè° €ÿÿÿÿÿÿüêÔ€ÿÿÿÿÿÿüÈ€ÿÿÿÿÿÿ¼€ÿÿÿÿÿÿ° €ÿÿÿÿÿÿ$ò€ÿÿÿÿÿÿ.Ê$€ÿÿÿÿÿÿ8> ˜ €ÿÿÿÿÿÿB8ü € ÿÿÿÿÿÿLB` € ÿÿÿÿÿÿVLÄ € ÿÿÿÿÿÿ`þè€ ÿÿÿÿÿÿj`Ü€ ÿÿÿÿÿÿtjЀÿÿÿÿÿÿ~tÄ €ÿÿÿÿÿÿˆV~€ÿÿÿÿÿÿ’.ˆ€ÿÿÿÿÿÿœ¨’@ÿÿÿÿÿÿ¦2@ÿÿÿÿÿÿ¯v€ÿÿÿÿÿÿ¸¦¯@ÿÿÿÿÿÿÂ΀ÿÿÿÿÿÿ˸Â@ÿÿÿÿÿÿÕ&€ÿÿÿÿÿÿÞËÕ@ÿÿÿÿÿÿè~ €ÿÿÿÿÿÿñÞè@ÿÿÿÿÿÿû<@ÿÿÿÿÿÿ€€ÿÿÿÿÿÿ û@ÿÿÿÿÿÿØ€ÿÿÿÿÿÿ  @ ÿÿÿÿÿÿ*0€!ÿÿÿÿÿÿ3 *@"ÿÿÿÿÿÿ=ˆ €#ÿÿÿÿÿÿF3=€$ÿÿÿÿÿÿPñF@%ÿÿÿÿÿÿZP@&ÿÿÿÿÿÿc”€'ÿÿÿÿÿÿlZc@(ÿÿÿÿÿÿvì€)ÿÿÿÿÿÿlv@*ÿÿÿÿÿÿ‰D€+ÿÿÿÿÿÿ’‰@,ÿÿÿÿÿÿœœ €-ÿÿÿÿÿÿ¥’œ€.ÿÿÿÿÿÿ¯P¥@/ÿÿÿÿÿÿ¹d@0ÿÿÿÿÿÿ¨€1ÿÿÿÿÿÿ˹Â@2ÿÿÿÿÿÿÕ€3ÿÿÿÿÿÿÞËÕ@4ÿÿÿÿÿÿèX€5ÿÿÿÿÿÿñÞè@6ÿÿÿÿÿÿû° €7ÿÿÿÿÿÿñû€8ÿÿÿÿÿÿ¯@9ÿÿÿÿÿÿx@:ÿÿÿÿÿÿ!¼€;ÿÿÿÿÿÿ*!@<ÿÿÿÿÿÿ4€=ÿÿÿÿÿÿ=*4@>ÿÿÿÿÿÿGl€?ÿÿÿÿÿÿP=G@@ÿÿÿÿÿÿZÄ €AÿÿÿÿÿÿcPZ€Bÿÿÿÿÿÿmc@CÿÿÿÿÿÿwŒ@Dÿÿÿÿÿÿ€@Eÿÿÿÿÿÿ‰ð@Fÿÿÿÿÿÿ’@Gÿÿÿÿÿÿ›T@Hÿÿÿÿÿÿ¤@Iÿÿÿÿÿÿ­¸@Jÿÿÿÿÿÿ¶ø@Kÿÿÿÿÿÿ¿Ú@LÿÿÿÿÿÿÈj@MÿÿÿÿÿÿÑ>@NÿÿÿÿÿÿÚ^@Oÿÿÿÿÿÿã¢@PÿÿÿÿÿÿìR @Qÿÿÿÿÿÿõ2@RÿÿÿÿÿÿþÂ@Sÿÿÿÿÿÿ–@Tÿÿÿÿÿÿ¶ @UÿÿÿÿÿÿŠ@Vÿÿÿÿÿÿ" @Wÿÿÿÿÿÿ+–@Xÿÿÿÿÿÿ4&@Yÿÿÿÿÿÿ=ú@ZÿÿÿÿÿÿF@[ÿÿÿÿÿÿO^@\ÿÿÿÿÿÿX@]ÿÿÿÿÿÿaÂ@^ÿÿÿÿÿÿj @_ÿÿÿÿÿÿsä@`ÿÿÿÿÿÿ|t@aÿÿÿÿÿÿ…H@bÿÿÿÿÿÿŽh@cÿÿÿÿÿÿ—¬@dÿÿÿÿÿÿ \ @eÿÿÿÿÿÿ©<@fÿÿÿÿÿÿ²Ì@gÿÿÿÿÿÿ» @hÿÿÿÿÿÿÄÀ @iÿÿÿÿÿÿÍ”@jÿÿÿÿÿÿÖ$ @kÿÿÿÿÿÿߪ@lÿÿÿÿÿÿè:@mÿÿÿÿÿÿñ@nÿÿÿÿÿÿú.@oÿÿÿÿÿÿr@pÿÿÿÿÿÿ "@qÿÿÿÿÿÿÖ@rÿÿÿÿÿÿ @sÿÿÿÿÿÿ'ø@tÿÿÿÿÿÿ0ˆ@uÿÿÿÿÿÿ9\@vÿÿÿÿÿÿB|@wÿÿÿÿÿÿKÀ@xÿÿÿÿÿÿTp @yÿÿÿÿÿÿ]P@zÿÿÿÿÿÿfà@{ÿÿÿÿÿÿo´@|ÿÿÿÿÿÿxÔ @}ÿÿÿÿÿÿ¨@~ÿÿÿÿÿÿŠ8 @ÿÿÿÿÿÿ“¾@€ÿÿÿÿÿÿœN@ÿÿÿÿÿÿ¥"@‚ÿÿÿÿÿÿ®B@ƒÿÿÿÿÿÿ·†@„ÿÿÿÿÿÿÀ6@…ÿÿÿÿÿÿÉê@†ÿÿÿÿÿÿÒ* @‡ÿÿÿÿÿÿÛ @ˆÿÿÿÿÿÿäœ@‰ÿÿÿÿÿÿíp@Šÿÿÿÿÿÿö@‹ÿÿÿÿÿÿÿÔ@Œÿÿÿÿÿÿ„ @ÿÿÿÿÿÿd@Žÿÿÿÿÿÿô@ÿÿÿÿÿÿ#È@ÿÿÿÿÿÿ,è @‘ÿÿÿÿÿÿ5¼@’ÿÿÿÿÿÿ>L @“ÿÿÿÿÿÿGÒ@”ÿÿÿÿÿÿPb@•ÿÿÿÿÿÿY6@–ÿÿÿÿÿÿbV@—ÿÿÿÿÿÿkš@˜ÿÿÿÿÿÿtJ@™ÿÿÿÿÿÿ}þ@šÿÿÿÿÿÿ†> @›ÿÿÿÿÿÿ @œÿÿÿÿÿÿ˜°@ÿÿÿÿÿÿ¡„@žÿÿÿÿÿÿª¤@Ÿÿÿÿÿÿÿ³è@ ÿÿÿÿÿÿ¼˜ @¡ÿÿÿÿÿÿÅx@¢ÿÿÿÿÿÿÎ@£ÿÿÿÿÿÿ×Ü@¤ÿÿÿÿÿÿàü @¥ÿÿÿÿÿÿéÐ@¦ÿÿÿÿÿÿò` €§ÿÿÿÿÿÿûw€€¨ÿÿÿÿÿÿ¦û€©ÿÿÿÿÿÿ‰’€ªÿÿÿÿÿÿ€«ÿÿÿÿÿÿ#›¤€¬ÿÿÿÿÿÿ-#€­ÿÿÿÿÿÿ7­¶€®ÿÿÿÿÿÿA-7€¯ÿÿÿÿÿÿK€w€°ÿÿÿÿÿÿUK¯€±ÿÿÿÿÿÿ_¿È€²ÿÿÿÿÿÿiU_€³ÿÿÿÿÿÿsÑÚ€´ÿÿÿÿÿÿ}is€µÿÿÿÿÿÿ‡ã쀶ÿÿÿÿÿÿ‘}‡€·ÿÿÿÿÿÿ›A‘€¸ÿÿÿÿÿÿ¥’‰€¹ÿÿÿÿÿÿ¯È¿€ºÿÿÿÿÿÿ¹¥¯€»ÿÿÿÿÿÿù€¼ÿÿÿÿÿÿÍõþ€½ÿÿÿÿÿÿ×ÃÍ€¾ÿÿÿÿÿÿဿÿÿÿÿÿÿë×á€Àÿÿÿÿÿÿõ›ë€Áÿÿÿÿÿÿÿ¤›€Âÿÿÿÿÿÿ ÚÑ€Ãÿÿÿÿÿÿÿ €Äÿÿÿÿÿÿþõ€Åÿÿÿÿÿÿ'€Æÿÿÿÿÿÿ1'Õ€Çÿÿÿÿÿÿ;"€ÈÿÿÿÿÿÿE1;€ÉÿÿÿÿÿÿOõE€ÊÿÿÿÿÿÿY¶­€Ëÿÿÿÿÿÿcìã€ÌÿÿÿÿÿÿmYc€Íÿÿÿÿÿÿw€Îÿÿÿÿÿÿmw€Ïÿÿÿÿÿÿ‹"€Ðÿÿÿÿÿÿ•‹€ÑÿÿÿÿÿÿŸ•è€Òÿÿÿÿÿÿ©OŸ€Óÿÿÿÿÿÿ³+4€Ôÿÿÿÿÿÿ½û³€ÕÿÿÿÿÿÿÇ=F€Öÿÿÿÿÿÿѽǀ×ÿÿÿÿÿÿÛOX€ØÿÿÿÿÿÿåÑÛ€Ùÿÿÿÿÿÿïaj€Úÿÿÿÿÿÿùåï€Ûÿÿÿÿÿÿ4+€Üÿÿÿÿÿÿ €Ýÿÿÿÿÿÿs|€Þÿÿÿÿÿÿ! €ßÿÿÿÿÿÿ+…Ž€àÿÿÿÿÿÿ5!+€áÿÿÿÿÿÿ?— €âÿÿÿÿÿÿI5?€ãÿÿÿÿÿÿSùI€äÿÿÿÿÿÿ]F=€åÿÿÿÿÿÿg|s€æÿÿÿÿÿÿq]g€çÿÿÿÿÿÿ{q€èÿÿÿÿÿÿ…©²€éÿÿÿÿÿÿ{…€êÿÿÿÿÿÿ™»Ä€ëÿÿÿÿÿÿ£™€ìÿÿÿÿÿÿ­S£€íÿÿÿÿÿÿ·XO€îÿÿÿÿÿÿÁŽ…€ïÿÿÿÿÿÿË·Á€ðÿÿÿÿÿÿÕ²©€ñÿÿÿÿÿÿßËÕ€òÿÿÿÿÿÿéß*€óÿÿÿÿÿÿóÍÖ€ôÿÿÿÿÿÿýéó€õÿÿÿÿÿÿ­ý€öÿÿÿÿÿÿja€÷ÿÿÿÿÿÿ —€øÿÿÿÿÿÿ%€ùÿÿÿÿÿÿ/Ä»€úÿÿÿÿÿÿ9%/€ûÿÿÿÿÿÿCÖÍ€üÿÿÿÿÿÿM9C€ýÿÿÿÿÿÿWM=€þÿÿÿÿÿÿaW€ÿÿÿÿÿÿÿk©a€ÿÿÿÿÿÿußè€ÿÿÿÿÿÿZu€ÿÿÿÿÿÿ‰ñú€ÿÿÿÿÿÿ“‰€ÿÿÿÿÿÿ €ÿÿÿÿÿÿ§“€ÿÿÿÿÿÿ±€ÿÿÿÿÿÿ»§±€ÿÿÿÿÿÿÅè߀ ÿÿÿÿÿÿÏÅc€ ÿÿÿÿÿÿÙ'0€ ÿÿÿÿÿÿãÏÙ€ ÿÿÿÿÿÿí9B€ ÿÿÿÿÿÿ÷ãí€ÿÿÿÿÿÿKT€ÿÿÿÿÿÿ ÷€ÿÿÿÿÿÿ» €ÿÿÿÿÿÿúñ€ÿÿÿÿÿÿ)0'€ÿÿÿÿÿÿ3)€ÿÿÿÿÿÿ=3v€ÿÿÿÿÿÿG]f€ÿÿÿÿÿÿQ=G€ÿÿÿÿÿÿ[ox€ÿÿÿÿÿÿeQ[€ÿÿÿÿÿÿoe€ÿÿÿÿÿÿy €ÿÿÿÿÿÿƒB9€ÿÿÿÿÿÿyƒ€ÿÿÿÿÿÿ—f]€ÿÿÿÿÿÿ¡—€ÿÿÿÿÿÿ«¡‰€ ÿÿÿÿÿÿµŠ€!ÿÿÿÿÿÿ¿«µ€"ÿÿÿÿÿÿÉo¿€#ÿÿÿÿÿÿÓ€$ÿÿÿÿÿÿÝTK€%ÿÿÿÿÿÿçÓÝ€&ÿÿÿÿÿÿñxo€'ÿÿÿÿÿÿûçñ€(ÿÿÿÿÿÿŠ€)ÿÿÿÿÿÿû€*ÿÿÿÿÿÿœ€+ÿÿÿÿÿÿ#É€,ÿÿÿÿÿÿ-k#€-ÿÿÿÿÿÿ7“œ€.ÿÿÿÿÿÿA¹7€/ÿÿÿÿÿÿK¥®€0ÿÿÿÿÿÿUAK€1ÿÿÿÿÿÿ_·À€2ÿÿÿÿÿÿiU_€3ÿÿÿÿÿÿsÉÒ€4ÿÿÿÿÿÿ}is€5ÿÿÿÿÿÿ‡œ“€6ÿÿÿÿÿÿ‘‡Â€7ÿÿÿÿÿÿ›Ûä€8ÿÿÿÿÿÿ¥‘›€9ÿÿÿÿÿÿ¯íö€:ÿÿÿÿÿÿ¹¥¯€;ÿÿÿÿÿÿÃÿ€<ÿÿÿÿÿÿ͹À=ÿÿÿÿÿÿ×}Í€>ÿÿÿÿÿÿᮥ€?ÿÿÿÿÿÿëäÛ€@ÿÿÿÿÿÿõáë€AÿÿÿÿÿÿÿõÕ€Bÿÿÿÿÿÿ €Cÿÿÿÿÿÿ ÿ €Dÿÿÿÿÿÿ #,€Eÿÿÿÿÿÿ'   €Fÿÿÿÿÿÿ1 ×' €Gÿÿÿÿÿÿ; À·€HÿÿÿÿÿÿE öí€IÿÿÿÿÿÿO ; E €JÿÿÿÿÿÿY €Kÿÿÿÿÿÿc O Y €Lÿÿÿÿÿÿm c è€Mÿÿÿÿÿÿw 5>€Nÿÿÿÿÿÿ m w €Oÿÿÿÿÿÿ‹ 1 €Pÿÿÿÿÿÿ• ÒÉ€QÿÿÿÿÿÿŸ ÿ€Rÿÿÿÿÿÿ© • Ÿ €Sÿÿÿÿÿÿ³ ,#€Tÿÿÿÿÿÿ½ © ³ €UÿÿÿÿÿÿÇ >5€VÿÿÿÿÿÿÑ ½ Ç €WÿÿÿÿÿÿÛ Ñ û€Xÿÿÿÿÿÿå ‹ Û €Yÿÿÿÿÿÿï -å €Zÿÿÿÿÿÿù GP€[ÿÿÿÿÿÿ!ù €\ÿÿÿÿÿÿ !Yb€]ÿÿÿÿÿÿ!! !€^ÿÿÿÿÿÿ!!kt€_ÿÿÿÿÿÿ+!!!!€`ÿÿÿÿÿÿ5!}†€aÿÿÿÿÿÿ?!+!5!€bÿÿÿÿÿÿI!PG€cÿÿÿÿÿÿS!I!!€dÿÿÿÿÿÿ]!˜€eÿÿÿÿÿÿg!S!]!€fÿÿÿÿÿÿq!¡ª€gÿÿÿÿÿÿ{!g!q!€hÿÿÿÿÿÿ…!³¼€iÿÿÿÿÿÿ!{!…!€jÿÿÿÿÿÿ™!?!!€kÿÿÿÿÿÿ£!bY€lÿÿÿÿÿÿ­!˜€mÿÿÿÿÿÿ·!£!­!€nÿÿÿÿÿÿÁ!·!4€oÿÿÿÿÿÿË!Å΀pÿÿÿÿÿÿÕ!Á!Ë!€qÿÿÿÿÿÿß!×à€rÿÿÿÿÿÿé!Õ!ß!€sÿÿÿÿÿÿó!™!é!€tÿÿÿÿÿÿý!tk€uÿÿÿÿÿÿ"ª¡€vÿÿÿÿÿÿ"ý!"€wÿÿÿÿÿÿ"ÎÅ€xÿÿÿÿÿÿ%"""€yÿÿÿÿÿÿ/"%"G€zÿÿÿÿÿÿ9"éò€{ÿÿÿÿÿÿC"/"9"€|ÿÿÿÿÿÿM"ó!C"€}ÿÿÿÿÿÿW"†}€~ÿÿÿÿÿÿa"¼³€ÿÿÿÿÿÿk"W"a"€€ÿÿÿÿÿÿu"à×€ÿÿÿÿÿÿ"k"u"€‚ÿÿÿÿÿÿ‰"ò逃ÿÿÿÿÿÿ“""‰"€„ÿÿÿÿÿÿ"“"Z€…ÿÿÿÿÿÿ§"M""€†ÿÿÿÿÿÿ±"ï §"€‡ÿÿÿÿÿÿ»"2€€ˆÿÿÿÿÿÿÅ"»"쀉ÿÿÿÿÿÿÏ"Å"X€ŠÿÿÿÿÿÿÙ"Ï"Ä €‹Sÿÿÿÿÿÿã"€Œ>ÿÿÿÿÿÿí"ã"@ÿÿÿÿÿÿ÷"í"€ŽSÿÿÿÿÿÿ#j€>ÿÿÿÿÿÿ #"#@ÿÿÿÿÿÿ# #€‘ÿÿÿÿÿÿ#÷"#€’Sÿÿÿÿÿÿ'#œ€“>ÿÿÿÿÿÿ1#4'#@”ÿÿÿÿÿÿ;#1#€•ÿÿÿÿÿÿD##;#€–SÿÿÿÿÿÿN#΀—>ÿÿÿÿÿÿX#FN#@˜ÿÿÿÿÿÿb#X#€™ÿÿÿÿÿÿk#D#b#€šSÿÿÿÿÿÿu#€›>ÿÿÿÿÿÿ#Xu#@œÿÿÿÿÿÿ‰##€ÿÿÿÿÿÿ’#k#‰#€žSÿÿÿÿÿÿœ#*"€Ÿ>ÿÿÿÿÿÿ¦#œ#@ ÿÿÿÿÿÿ°#¦#€¡Sÿÿÿÿÿÿ¹#t"€¢>ÿÿÿÿÿÿÃ#"¹#@£ÿÿÿÿÿÿÍ#Ã#€¤ÿÿÿÿÿÿÖ#°#Í#€¥Sÿÿÿÿÿÿà#¦"€¦>ÿÿÿÿÿÿê#4à#@§ÿÿÿÿÿÿô#ê#€¨ÿÿÿÿÿÿý#Ö#ô#€©Sÿÿÿÿÿÿ$Ø"€ª>ÿÿÿÿÿÿ$F$@«ÿÿÿÿÿÿ$$€¬ÿÿÿÿÿÿ$$ý#$€­Sÿÿÿÿÿÿ.$ "€®>ÿÿÿÿÿÿ8$X.$@¯ÿÿÿÿÿÿB$8$€°ÿÿÿÿÿÿK$$$B$€±ÿÿÿÿÿÿU$’#K$€²Sÿÿÿÿÿÿ_$<4€³>ÿÿÿÿÿÿi$_$@´ÿÿÿÿÿÿs$i$€µSÿÿÿÿÿÿ|$~4€¶>ÿÿÿÿÿÿ†$"|$@·ÿÿÿÿÿÿ$†$€¸ÿÿÿÿÿÿ™$s$$€¹Sÿÿÿÿÿÿ£$°4€º>ÿÿÿÿÿÿ­$4£$@»ÿÿÿÿÿÿ·$­$€¼ÿÿÿÿÿÿÀ$™$·$€½SÿÿÿÿÿÿÊ$â4€¾>ÿÿÿÿÿÿÔ$FÊ$@¿ÿÿÿÿÿÿÞ$Ô$€Àÿÿÿÿÿÿç$À$Þ$€ÁSÿÿÿÿÿÿñ$4€Â>ÿÿÿÿÿÿû$Xñ$@Ãÿÿÿÿÿÿ%û$€Äÿÿÿÿÿÿ%ç$%€Åÿÿÿÿÿÿ%U$%€ÆSÿÿÿÿÿÿ"%NF€Ç>ÿÿÿÿÿÿ,%"%@Èÿÿÿÿÿÿ6%,%€ÉSÿÿÿÿÿÿ?%ˆF€Ê>ÿÿÿÿÿÿI%"?%@ËÿÿÿÿÿÿS%I%€Ìÿÿÿÿÿÿ\%6%S%€ÍSÿÿÿÿÿÿf%ºF€Î>ÿÿÿÿÿÿp%4f%@Ïÿÿÿÿÿÿz%p%€Ðÿÿÿÿÿÿƒ%\%z%€ÑSÿÿÿÿÿÿ%ìF€Ò>ÿÿÿÿÿÿ—%F%@Óÿÿÿÿÿÿ¡%—%€Ôÿÿÿÿÿÿª%ƒ%¡%€ÕSÿÿÿÿÿÿ´%F€Ö>ÿÿÿÿÿÿ¾%X´%@×ÿÿÿÿÿÿÈ%¾%€ØÿÿÿÿÿÿÑ%ª%È%€ÙÿÿÿÿÿÿÛ%%Ñ%€ÚSÿÿÿÿÿÿå%`X€Û>ÿÿÿÿÿÿï%å%@Üÿÿÿÿÿÿù%ï%€ÝSÿÿÿÿÿÿ&’X€Þ>ÿÿÿÿÿÿ &"&@ßÿÿÿÿÿÿ& &€àÿÿÿÿÿÿ&ù%&€áSÿÿÿÿÿÿ)&ÄX€â>ÿÿÿÿÿÿ3&4)&@ãÿÿÿÿÿÿ=&3&€äÿÿÿÿÿÿF&&=&€åSÿÿÿÿÿÿP&öX€æ>ÿÿÿÿÿÿZ&FP&@çÿÿÿÿÿÿd&Z&€èÿÿÿÿÿÿm&F&d&€éSÿÿÿÿÿÿw&(X€ê>ÿÿÿÿÿÿ&Xw&@ëÿÿÿÿÿÿ‹&&€ìÿÿÿÿÿÿ”&m&‹&€íÿÿÿÿÿÿž&Û%”&€îSÿÿÿÿÿÿ¨&*€ï>ÿÿÿÿÿÿ²&"¨&@ðÿÿÿÿÿÿ¼&²&€ñÿÿÿÿÿÿÅ&÷"¼&€òSÿÿÿÿÿÿÏ&<€ó>ÿÿÿÿÿÿÙ&4Ï&@ôÿÿÿÿÿÿã&Ù&€õÿÿÿÿÿÿì&Å&ã&€öSÿÿÿÿÿÿö&N€÷>ÿÿÿÿÿÿ'Fö&@øÿÿÿÿÿÿ ''€ùÿÿÿÿÿÿ'ì& '€úSÿÿÿÿÿÿ'`€û>ÿÿÿÿÿÿ''X'@üÿÿÿÿÿÿ1'''€ýÿÿÿÿÿÿ:''1'€þSÿÿÿÿÿÿD'j"€ÿ>ÿÿÿÿÿÿN'D'@ÿÿÿÿÿÿX'N'€ÿÿÿÿÿÿa'X'Í#€Sÿÿÿÿÿÿk'~"€>ÿÿÿÿÿÿu'4k'@ÿÿÿÿÿÿ'u'€ÿÿÿÿÿÿˆ'a''€Sÿÿÿÿÿÿ’'ˆ"€>ÿÿÿÿÿÿœ'F’'@ÿÿÿÿÿÿ¦'œ'€ ÿÿÿÿÿÿ¯'ˆ'¦'€ Sÿÿÿÿÿÿ¹'’"€ >ÿÿÿÿÿÿÃ'X¹'@ ÿÿÿÿÿÿÍ'Ã'€ ÿÿÿÿÿÿÖ'¯'Í'€ÿÿÿÿÿÿà':'Ö'€Sÿÿÿÿÿÿê'œ4€>ÿÿÿÿÿÿô'ê'@ÿÿÿÿÿÿþ'ô'€Sÿÿÿÿÿÿ(¦4€>ÿÿÿÿÿÿ("(@ÿÿÿÿÿÿ((€ÿÿÿÿÿÿ$(þ'(€ÿÿÿÿÿÿ.($(·$€Sÿÿÿÿÿÿ8(º4€>ÿÿÿÿÿÿB(F8(@ÿÿÿÿÿÿL(B(€ÿÿÿÿÿÿU(.(L(€Sÿÿÿÿÿÿ_(Ä4€>ÿÿÿÿÿÿi(X_(@ÿÿÿÿÿÿs(i(€ÿÿÿÿÿÿ|(U(s(€ÿÿÿÿÿÿ†(à'|(€ Sÿÿÿÿÿÿ(ÎF€!>ÿÿÿÿÿÿš((@"ÿÿÿÿÿÿ¤(š(€#Sÿÿÿÿÿÿ­(ØF€$>ÿÿÿÿÿÿ·("­(@%ÿÿÿÿÿÿÁ(·(€&ÿÿÿÿÿÿÊ(¤(Á(€'SÿÿÿÿÿÿÔ(âF€(>ÿÿÿÿÿÿÞ(4Ô(@)ÿÿÿÿÿÿè(Þ(€*ÿÿÿÿÿÿñ(Ê(è(€+ÿÿÿÿÿÿû(ñ(¡%€,Sÿÿÿÿÿÿ)öF€->ÿÿÿÿÿÿ)X)@.ÿÿÿÿÿÿ))€/ÿÿÿÿÿÿ")û()€0ÿÿÿÿÿÿ,)†(")€1Sÿÿÿÿÿÿ6)X€2>ÿÿÿÿÿÿ@)6)@3ÿÿÿÿÿÿJ)@)€4SÿÿÿÿÿÿS) X€5>ÿÿÿÿÿÿ])"S)@6ÿÿÿÿÿÿg)])€7ÿÿÿÿÿÿp)J)g)€8Sÿÿÿÿÿÿz)X€9>ÿÿÿÿÿÿ„)4z)@:ÿÿÿÿÿÿŽ)„)€;ÿÿÿÿÿÿ—)p)Ž)€<Sÿÿÿÿÿÿ¡)X€=>ÿÿÿÿÿÿ«)F¡)@>ÿÿÿÿÿÿµ)«)€?ÿÿÿÿÿÿ¾)—)µ)€@ÿÿÿÿÿÿÈ)¾)‹&€AÿÿÿÿÿÿÒ),)È)€BÿÿÿÿÿÿÜ)í" #€Cÿÿÿÿÿÿæ)Ü)1#€Dÿÿÿÿÿÿð)æ)X#€Eÿÿÿÿÿÿú)ð)#€Fÿÿÿÿÿÿ*¦#Ã#€Gÿÿÿÿÿÿ**ê#€Hÿÿÿÿÿÿ**$€Iÿÿÿÿÿÿ"**8$€Jÿÿÿÿÿÿ,*ú)"*€Kÿÿÿÿÿÿ6*i$†$€Lÿÿÿÿÿÿ@*6*­$€MÿÿÿÿÿÿJ*@*Ô$€NÿÿÿÿÿÿT*J*û$€Oÿÿÿÿÿÿ^*,*T*€Pÿÿÿÿÿÿh*,%I%€Qÿÿÿÿÿÿr*h*p%€Rÿÿÿÿÿÿ|*r*—%€Sÿÿÿÿÿÿ†*|*¾%€Tÿÿÿÿÿÿ*^*†*€Uÿÿÿÿÿÿš*ï% &€Vÿÿÿÿÿÿ¤*š*3&€Wÿÿÿÿÿÿ®*¤*Z&€Xÿÿÿÿÿÿ¸*®*&€YÿÿÿÿÿÿÂ**¸*€ZÿÿÿÿÿÿÌ*2ñ€[ÿÿÿÿÿÿÖ*ŒF€\ÿÿÿÿÿÿà*Ì*Ö*€]ÿÿÿÿÿÿê*ð¥€^ÿÿÿÿÿÿô*à*ê*€_ÿÿÿÿÿÿþ*T€`ÿÿÿÿÿÿ+ô*þ*€aÿÿÿÿÿÿ+¸c€bÿÿÿÿÿÿ+++€cÿÿÿÿÿÿ&+&ñ€dÿÿÿÿÿÿ0+€F€eÿÿÿÿÿÿ:+&+0+€fÿÿÿÿÿÿD+䥀gÿÿÿÿÿÿN+:+D+€hÿÿÿÿÿÿX+H€iÿÿÿÿÿÿb+N+X+€jÿÿÿÿÿÿl+¬c€kÿÿÿÿÿÿv+b+l+€lÿÿÿÿÿÿ€++v+€mÿÿÿÿÿÿŠ+.ñ€nÿÿÿÿÿÿ”+ˆF€oÿÿÿÿÿÿž+Š+”+€pÿÿÿÿÿÿ¨+쥀qÿÿÿÿÿÿ²+ž+¨+€rÿÿÿÿÿÿ¼+P€sÿÿÿÿÿÿÆ+²+¼+€tÿÿÿÿÿÿÐ+´c€uÿÿÿÿÿÿÚ+Æ+Ð+€vÿÿÿÿÿÿä+€+Ú+€wÿÿÿÿÿÿî+6ñ€xÿÿÿÿÿÿø+F€yÿÿÿÿÿÿ,î+ø+€zÿÿÿÿÿÿ ,ô¥€{ÿÿÿÿÿÿ,, ,€|ÿÿÿÿÿÿ ,X€}ÿÿÿÿÿÿ*,, ,€~ÿÿÿÿÿÿ4,¼c€ÿÿÿÿÿÿ>,*,4,€€ÿÿÿÿÿÿH,ä+>,€ÿÿÿÿÿÿR,> ñ€‚ÿÿÿÿÿÿ\,˜ F€ƒÿÿÿÿÿÿf,R,\,€„ÿÿÿÿÿÿp,ü ¥€…ÿÿÿÿÿÿz,f,p,€†ÿÿÿÿÿÿ„,` €‡ÿÿÿÿÿÿŽ,z,„,€ˆÿÿÿÿÿÿ˜,Ä c€‰ÿÿÿÿÿÿ¢,Ž,˜,€Šÿÿÿÿÿÿ¬,H,¢,€‹Sÿÿÿÿÿÿ¶,€Œ>ÿÿÿÿÿÿÀ,¶,@ÿÿÿÿÿÿÊ,À,€ŽSÿÿÿÿÿÿÓ,**€>ÿÿÿÿÿÿÝ,"Ó,@ÿÿÿÿÿÿç,Ý,€‘ÿÿÿÿÿÿð,Ê,ç,€’Sÿÿÿÿÿÿú,<<€“>ÿÿÿÿÿÿ-4ú,@”ÿÿÿÿÿÿ--€•ÿÿÿÿÿÿ-ð,-€–Sÿÿÿÿÿÿ!-NN€—>ÿÿÿÿÿÿ+-F!-@˜ÿÿÿÿÿÿ5-+-€™ÿÿÿÿÿÿ>--5-€šSÿÿÿÿÿÿH-``€›>ÿÿÿÿÿÿR-XH-@œÿÿÿÿÿÿ\-R-€ÿÿÿÿÿÿe->-\-€žSÿÿÿÿÿÿo-jj€Ÿ>ÿÿÿÿÿÿy-o-@ ÿÿÿÿÿÿƒ-y-€¡SÿÿÿÿÿÿŒ-tt€¢>ÿÿÿÿÿÿ–-"Œ-@£ÿÿÿÿÿÿ -–-€¤ÿÿÿÿÿÿ©-ƒ- -€¥Sÿÿÿÿÿÿ³-~~€¦>ÿÿÿÿÿÿ½-4³-@§ÿÿÿÿÿÿÇ-½-€¨ÿÿÿÿÿÿÐ-©-Ç-€©SÿÿÿÿÿÿÚ-ˆˆ€ª>ÿÿÿÿÿÿä-FÚ-@«ÿÿÿÿÿÿî-ä-€¬ÿÿÿÿÿÿ÷-Ð-î-€­Sÿÿÿÿÿÿ.’’€®>ÿÿÿÿÿÿ .X.@¯ÿÿÿÿÿÿ. .€°ÿÿÿÿÿÿ.÷-.€±ÿÿÿÿÿÿ(.e-.€²Sÿÿÿÿÿÿ2.œœ€³>ÿÿÿÿÿÿ<.2.@´ÿÿÿÿÿÿF.<.€µSÿÿÿÿÿÿO.¦¦€¶>ÿÿÿÿÿÿY."O.@·ÿÿÿÿÿÿc.Y.€¸ÿÿÿÿÿÿl.F.c.€¹Sÿÿÿÿÿÿv.°°€º>ÿÿÿÿÿÿ€.4v.@»ÿÿÿÿÿÿŠ.€.€¼ÿÿÿÿÿÿ“.l.Š.€½Sÿÿÿÿÿÿ.ºº€¾>ÿÿÿÿÿÿ§.F.@¿ÿÿÿÿÿÿ±.§.€Àÿÿÿÿÿÿº.“.±.€ÁSÿÿÿÿÿÿÄ.ÄÄ€Â>ÿÿÿÿÿÿÎ.XÄ.@ÃÿÿÿÿÿÿØ.Î.€Äÿÿÿÿÿÿá.º.Ø.€Åÿÿÿÿÿÿë.(.á.€ÆSÿÿÿÿÿÿõ.Î΀Ç>ÿÿÿÿÿÿÿ.õ.@Èÿÿÿÿÿÿ /ÿ.€ÉSÿÿÿÿÿÿ/ØØ€Ê>ÿÿÿÿÿÿ/"/@Ëÿÿÿÿÿÿ&//€Ìÿÿÿÿÿÿ// /&/€ÍSÿÿÿÿÿÿ9/ââ€Î>ÿÿÿÿÿÿC/49/@ÏÿÿÿÿÿÿM/C/€ÐÿÿÿÿÿÿV///M/€ÑSÿÿÿÿÿÿ`/ìì€Ò>ÿÿÿÿÿÿj/F`/@Óÿÿÿÿÿÿt/j/€Ôÿÿÿÿÿÿ}/V/t/€ÕSÿÿÿÿÿÿ‡/öö€Ö>ÿÿÿÿÿÿ‘/X‡/@×ÿÿÿÿÿÿ›/‘/€Øÿÿÿÿÿÿ¤/}/›/€Ùÿÿÿÿÿÿ®/ë.¤/€ÚSÿÿÿÿÿÿ¸/€Û>ÿÿÿÿÿÿÂ/¸/@ÜÿÿÿÿÿÿÌ/Â/€ÝSÿÿÿÿÿÿÕ/  €Þ>ÿÿÿÿÿÿß/"Õ/@ßÿÿÿÿÿÿé/ß/€àÿÿÿÿÿÿò/Ì/é/€áSÿÿÿÿÿÿü/€â>ÿÿÿÿÿÿ04ü/@ãÿÿÿÿÿÿ00€äÿÿÿÿÿÿ0ò/0€åSÿÿÿÿÿÿ#0€æ>ÿÿÿÿÿÿ-0F#0@çÿÿÿÿÿÿ70-0€èÿÿÿÿÿÿ@0070€éSÿÿÿÿÿÿJ0((€ê>ÿÿÿÿÿÿT0XJ0@ëÿÿÿÿÿÿ^0T0€ìÿÿÿÿÿÿg0@0^0€íÿÿÿÿÿÿq0®/g0€îSÿÿÿÿÿÿ{0€ï>ÿÿÿÿÿÿ…0{0@ðÿÿÿÿÿÿ0…0€ñSÿÿÿÿÿÿ˜0"*€ò>ÿÿÿÿÿÿ¢0˜0@óÿÿÿÿÿÿ¬0¢0€ôÿÿÿÿÿÿµ00¬0€õSÿÿÿÿÿÿ¿04<€ö>ÿÿÿÿÿÿÉ0¿0@÷ÿÿÿÿÿÿÓ0É0€øÿÿÿÿÿÿÜ0µ0Ó0€ùSÿÿÿÿÿÿæ0FN€ú>ÿÿÿÿÿÿð0æ0@ûÿÿÿÿÿÿú0ð0€üÿÿÿÿÿÿ1Ü0ú0€ýSÿÿÿÿÿÿ 1X`€þ>ÿÿÿÿÿÿ1 1@ÿÿÿÿÿÿÿ!11€ÿÿÿÿÿÿ*11!1€Sÿÿÿÿÿÿ41j€>ÿÿÿÿÿÿ>1"41@ÿÿÿÿÿÿH1>1€SÿÿÿÿÿÿQ1"t€>ÿÿÿÿÿÿ[1"Q1@ÿÿÿÿÿÿe1[1€ÿÿÿÿÿÿn1H1e1€Sÿÿÿÿÿÿx14~€ >ÿÿÿÿÿÿ‚1"x1@ ÿÿÿÿÿÿŒ1‚1€ ÿÿÿÿÿÿ•1n1Œ1€ SÿÿÿÿÿÿŸ1Fˆ€ >ÿÿÿÿÿÿ©1"Ÿ1@ÿÿÿÿÿÿ³1©1€ÿÿÿÿÿÿ¼1•1³1€SÿÿÿÿÿÿÆ1X’€>ÿÿÿÿÿÿÐ1"Æ1@ÿÿÿÿÿÿÚ1Ð1€ÿÿÿÿÿÿã1¼1Ú1€ÿÿÿÿÿÿí1*1ã1€Sÿÿÿÿÿÿ÷1œ€>ÿÿÿÿÿÿ24÷1@ÿÿÿÿÿÿ 22€Sÿÿÿÿÿÿ2"¦€>ÿÿÿÿÿÿ242@ÿÿÿÿÿÿ(22€ÿÿÿÿÿÿ12 2(2€Sÿÿÿÿÿÿ;24°€>ÿÿÿÿÿÿE24;2@ÿÿÿÿÿÿO2E2€ÿÿÿÿÿÿX212O2€ Sÿÿÿÿÿÿb2Fº€!>ÿÿÿÿÿÿl24b2@"ÿÿÿÿÿÿv2l2€#ÿÿÿÿÿÿ2X2v2€$Sÿÿÿÿÿÿ‰2XÄ€%>ÿÿÿÿÿÿ“24‰2@&ÿÿÿÿÿÿ2“2€'ÿÿÿÿÿÿ¦222€(ÿÿÿÿÿÿ°2í1¦2€)Sÿÿÿÿÿÿº2΀*>ÿÿÿÿÿÿÄ2Fº2@+ÿÿÿÿÿÿÎ2Ä2€,Sÿÿÿÿÿÿ×2"Ø€->ÿÿÿÿÿÿá2F×2@.ÿÿÿÿÿÿë2á2€/ÿÿÿÿÿÿô2Î2ë2€0Sÿÿÿÿÿÿþ24â€1>ÿÿÿÿÿÿ3Fþ2@2ÿÿÿÿÿÿ33€3ÿÿÿÿÿÿ3ô23€4Sÿÿÿÿÿÿ%3Fì€5>ÿÿÿÿÿÿ/3F%3@6ÿÿÿÿÿÿ93/3€7ÿÿÿÿÿÿB3393€8SÿÿÿÿÿÿL3Xö€9>ÿÿÿÿÿÿV3FL3@:ÿÿÿÿÿÿ`3V3€;ÿÿÿÿÿÿi3B3`3€<ÿÿÿÿÿÿs3°2i3€=Sÿÿÿÿÿÿ}3€>>ÿÿÿÿÿÿ‡3X}3@?ÿÿÿÿÿÿ‘3‡3€@Sÿÿÿÿÿÿš3" €A>ÿÿÿÿÿÿ¤3Xš3@Bÿÿÿÿÿÿ®3¤3€Cÿÿÿÿÿÿ·3‘3®3€DSÿÿÿÿÿÿÁ34€E>ÿÿÿÿÿÿË3XÁ3@FÿÿÿÿÿÿÕ3Ë3€GÿÿÿÿÿÿÞ3·3Õ3€HSÿÿÿÿÿÿè3F€I>ÿÿÿÿÿÿò3Xè3@Jÿÿÿÿÿÿü3ò3€Kÿÿÿÿÿÿ4Þ3ü3€LSÿÿÿÿÿÿ4X(€M>ÿÿÿÿÿÿ4X4@Nÿÿÿÿÿÿ#44€Oÿÿÿÿÿÿ,44#4€Pÿÿÿÿÿÿ64s3,4€Q>ÿÿÿÿÿÿ@4"o-@RÿÿÿÿÿÿJ4@4€SÿÿÿÿÿÿS4Ê,J4€T>ÿÿÿÿÿÿ]442.@Uÿÿÿÿÿÿg4]4€Vÿÿÿÿÿÿp4S4g4€W>ÿÿÿÿÿÿz4Fõ.@Xÿÿÿÿÿÿ„4z4€Yÿÿÿÿÿÿ4p4„4€Z>ÿÿÿÿÿÿ—4X¸/@[ÿÿÿÿÿÿ¡4—4€\ÿÿÿÿÿÿª44¡4€]>ÿÿÿÿÿÿ´4Ó,@^ÿÿÿÿÿÿ¾4´4€_ÿÿÿÿÿÿÇ4¾4 -€`>ÿÿÿÿÿÿÑ44O.@aÿÿÿÿÿÿÛ4Ñ4€bÿÿÿÿÿÿä4Ç4Û4€c>ÿÿÿÿÿÿî4F/@dÿÿÿÿÿÿø4î4€eÿÿÿÿÿÿ5ä4ø4€f>ÿÿÿÿÿÿ 5XÕ/@gÿÿÿÿÿÿ5 5€hÿÿÿÿÿÿ555€iÿÿÿÿÿÿ(5ª45€j>ÿÿÿÿÿÿ25ú,@kÿÿÿÿÿÿ<525€l>ÿÿÿÿÿÿE5"³-@mÿÿÿÿÿÿO5E5€nÿÿÿÿÿÿX5<5O5€oÿÿÿÿÿÿb5X5Š.€p>ÿÿÿÿÿÿl5F9/@qÿÿÿÿÿÿv5l5€rÿÿÿÿÿÿ5b5v5€s>ÿÿÿÿÿÿ‰5Xü/@tÿÿÿÿÿÿ“5‰5€uÿÿÿÿÿÿœ55“5€vÿÿÿÿÿÿ¦5(5œ5€w>ÿÿÿÿÿÿ°5!-@xÿÿÿÿÿÿº5°5€y>ÿÿÿÿÿÿÃ5"Ú-@zÿÿÿÿÿÿÍ5Ã5€{ÿÿÿÿÿÿÖ5º5Í5€|>ÿÿÿÿÿÿà54.@}ÿÿÿÿÿÿê5à5€~ÿÿÿÿÿÿó5Ö5ê5€ÿÿÿÿÿÿý5ó5t/€€>ÿÿÿÿÿÿ6X#0@ÿÿÿÿÿÿ66€‚ÿÿÿÿÿÿ6ý56€ƒÿÿÿÿÿÿ$6¦56€„>ÿÿÿÿÿÿ.6H-@…ÿÿÿÿÿÿ86.6€†>ÿÿÿÿÿÿA6".@‡ÿÿÿÿÿÿK6A6€ˆÿÿÿÿÿÿT686K6€‰>ÿÿÿÿÿÿ^64Ä.@Šÿÿÿÿÿÿh6^6€‹ÿÿÿÿÿÿq6T6h6€Œ>ÿÿÿÿÿÿ{6F‡/@ÿÿÿÿÿÿ…6{6€ŽÿÿÿÿÿÿŽ6q6…6€ÿÿÿÿÿÿ˜6Ž6^0€ÿÿÿÿÿÿ¢6$6˜6€‘ÿÿÿÿÿÿ¬6w4€’ÿÿÿÿÿÿ¶6¦¬6€“ÿÿÿÿÿÿÀ6‰ú€”ÿÿÿÿÿÿÊ6¶6À6€•ÿÿÿÿÿÿÔ6›À€–ÿÿÿÿÿÿÞ6Ê6Ô6€—ÿÿÿÿÿÿè6­†€˜ÿÿÿÿÿÿò6Þ6è6€™ÿÿÿÿÿÿü6¯€šÿÿÿÿÿÿ7Kü6€›ÿÿÿÿÿÿ7¿0€œÿÿÿÿÿÿ777€ÿÿÿÿÿÿ$7Ñö€žÿÿÿÿÿÿ.77$7€Ÿÿÿÿÿÿÿ87ã¼€ ÿÿÿÿÿÿB7.787€¡ÿÿÿÿÿÿL7ò6B7€¢ÿÿÿÿÿÿV7Ès€£ÿÿÿÿÿÿ`7¥V7€¤ÿÿÿÿÿÿj7Âv€¥ÿÿÿÿÿÿt7`7j7€¦ÿÿÿÿÿÿ~7õ€§ÿÿÿÿÿÿˆ7t7~7€¨ÿÿÿÿÿÿ’7à€©ÿÿÿÿÿÿœ7ˆ7’7€ªÿÿÿÿÿÿ¦7L7œ7€«ÿÿÿÿÿÿ°7Ú…€¬ÿÿÿÿÿÿº7ÿ°7€­ÿÿÿÿÿÿÄ7þ]€®ÿÿÿÿÿÿÎ7º7Ä7€¯ÿÿÿÿÿÿØ7Õ耰ÿÿÿÿÿÿâ7Î7Ø7€±ÿÿÿÿÿÿì7ò€²ÿÿÿÿÿÿö7â7ì7€³ÿÿÿÿÿÿ8¦7ö7€´ÿÿÿÿÿÿ 8ì—€µÿÿÿÿÿÿ8Y 8€¶ÿÿÿÿÿÿ8o€·ÿÿÿÿÿÿ(888€¸ÿÿÿÿÿÿ28"5€¹ÿÿÿÿÿÿ<8(828€ºÿÿÿÿÿÿF8èZ€»ÿÿÿÿÿÿP8<8F8€¼ÿÿÿÿÿÿZ88P8€½ÿÿÿÿÿÿd8û¦€¾ÿÿÿÿÿÿn8d8³€¿ÿÿÿÿÿÿx8=ú€Àÿÿÿÿÿÿ‚8n8x8€ÁÿÿÿÿÿÿŒ8OÀ€Âÿÿÿÿÿÿ–8‚8Œ8€Ãÿÿÿÿÿÿ 8a†€Äÿÿÿÿÿÿª8–8 8€Åÿÿÿÿÿÿ´84w€Æÿÿÿÿÿÿ¾8´8€ÇÿÿÿÿÿÿÈ8s0€ÈÿÿÿÿÿÿÒ8¾8È8€ÉÿÿÿÿÿÿÜ8…ö€Êÿÿÿÿÿÿæ8Ò8Ü8€Ëÿÿÿÿÿÿð8—¼€Ìÿÿÿÿÿÿú8æ8ð8€Íÿÿÿÿÿÿ9ª8ú8€Îÿÿÿÿÿÿ9F‰€Ïÿÿÿÿÿÿ99g€Ðÿÿÿÿÿÿ"9v€Ñÿÿÿÿÿÿ,99"9€Òÿÿÿÿÿÿ69©€Óÿÿÿÿÿÿ@9,969€ÔÿÿÿÿÿÿJ9»à€ÕÿÿÿÿÿÿT9@9J9€Öÿÿÿÿÿÿ^99T9€×ÿÿÿÿÿÿh9X›€Øÿÿÿÿÿÿr9h9Á€Ùÿÿÿÿÿÿ|9²]€Úÿÿÿÿÿÿ†9r9|9€Ûÿÿÿÿÿÿ9*è€Üÿÿÿÿÿÿš9†99€Ýÿÿÿÿÿÿ¤9Íò€Þÿÿÿÿÿÿ®9š9¤9€ßÿÿÿÿÿÿ¸9^9®9€àÿÿÿÿÿÿÂ9j­€áÿÿÿÿÿÿÌ9Â9€âÿÿÿÿÿÿÖ9Äo€ãÿÿÿÿÿÿà9Ì9Ö9€äÿÿÿÿÿÿê9Ö5€åÿÿÿÿÿÿô9à9ê9€æÿÿÿÿÿÿþ9=Z€çÿÿÿÿÿÿ:ô9þ9€èÿÿÿÿÿÿ:¸9:€éÿÿÿÿÿÿ:Z8:€êÿÿÿÿÿÿ&:Z¦€ëÿÿÿÿÿÿ0:ß4€ìÿÿÿÿÿÿ::&:0:€íÿÿÿÿÿÿD:::‰€îÿÿÿÿÿÿN:À€ïÿÿÿÿÿÿX:D:N:€ðÿÿÿÿÿÿb:†€ñÿÿÿÿÿÿl:X:b:€òÿÿÿÿÿÿv:èw€óÿÿÿÿÿÿ€:c€ôÿÿÿÿÿÿŠ:v:€:€õÿÿÿÿÿÿ”:Š:Ù€öÿÿÿÿÿÿž:9ö€÷ÿÿÿÿÿÿ¨:”:ž:€øÿÿÿÿÿÿ²:K¼€ùÿÿÿÿÿÿ¼:¨:²:€úÿÿÿÿÿÿÆ:l:¼:€ûÿÿÿÿÿÿÐ:ú‰€üÿÿÿÿÿÿÚ:0s€ýÿÿÿÿÿÿä:Ð:Ú:€þÿÿÿÿÿÿî:ä:v€ÿÿÿÿÿÿÿø:]€ÿÿÿÿÿÿ;î:ø:€ÿÿÿÿÿÿ ;oà€ÿÿÿÿÿÿ;; ;€ÿÿÿÿÿÿ ;Æ:;€ÿÿÿÿÿÿ*; ›€ÿÿÿÿÿÿ4;B…€ÿÿÿÿÿÿ>;*;4;€ÿÿÿÿÿÿH;>;—€ÿÿÿÿÿÿR;‰è€ ÿÿÿÿÿÿ\;H;R;€ ÿÿÿÿÿÿf;ò€ ÿÿÿÿÿÿp;\;f;€ ÿÿÿÿÿÿz; ;p;€ ÿÿÿÿÿÿ„;­€ÿÿÿÿÿÿŽ;T—€ÿÿÿÿÿÿ˜;„;Ž;€ÿÿÿÿÿÿ¢;˜;ñ€ÿÿÿÿÿÿ¬;Š5€ÿÿÿÿÿÿ¶;¢;¬;€ÿÿÿÿÿÿÀ;œZ€ÿÿÿÿÿÿÊ;¶;À;€ÿÿÿÿÿÿÔ;z;Ê;€ÿÿÿÿÿÿÞ;:Ô;€ÿÿÿÿÿÿè;¹¦€ÿÿÿÿÿÿò;“4€ÿÿÿÿÿÿü;è;ò;€ÿÿÿÿÿÿ<¥ú€ÿÿÿÿÿÿ<ü;<€ÿÿÿÿÿÿ<<_€ÿÿÿÿÿÿ$<Ɇ€ÿÿÿÿÿÿ.<<$<€ÿÿÿÿÿÿ8<œw€ ÿÿÿÿÿÿB<€!ÿÿÿÿÿÿL<8<B<€"ÿÿÿÿÿÿV<Û0€#ÿÿÿÿÿÿ`<L<V<€$ÿÿÿÿÿÿj<`<¯€%ÿÿÿÿÿÿt<ÿ¼€&ÿÿÿÿÿÿ~<j<t<€'ÿÿÿÿÿÿˆ<.<~<€(ÿÿÿÿÿÿ’<®‰€)ÿÿÿÿÿÿœ<äs€*ÿÿÿÿÿÿ¦<’<œ<€+ÿÿÿÿÿÿ°<Õv€,ÿÿÿÿÿÿº<¦<°<€-ÿÿÿÿÿÿÄ<º< €.ÿÿÿÿÿÿÎ<#à€/ÿÿÿÿÿÿØ<Ä<Î<€0ÿÿÿÿÿÿâ<ˆ<Ø<€1ÿÿÿÿÿÿì<À›€2ÿÿÿÿÿÿö<ö…€3ÿÿÿÿÿÿ=ì<ö<€4ÿÿÿÿÿÿ =]€5ÿÿÿÿÿÿ== =€6ÿÿÿÿÿÿ==è€7ÿÿÿÿÿÿ(=5ò€8ÿÿÿÿÿÿ2==(=€9ÿÿÿÿÿÿ<=â<2=€:ÿÿÿÿÿÿF=Ò­€;ÿÿÿÿÿÿP=—€<ÿÿÿÿÿÿZ=F=P=€=ÿÿÿÿÿÿd=,o€>ÿÿÿÿÿÿn=Z=d=€?ÿÿÿÿÿÿx=n=Ç €@ÿÿÿÿÿÿ‚=ûZ€AÿÿÿÿÿÿŒ=x=‚=€Bÿÿÿÿÿÿ–=<=Œ=€Cÿÿÿÿÿÿ =Þ;–=€Dÿÿÿÿÿÿª=¦€Eÿÿÿÿÿÿ´=G4€Fÿÿÿÿÿÿ¾=ª=´=€GÿÿÿÿÿÿÈ=Yú€HÿÿÿÿÿÿÒ=¾=È=€IÿÿÿÿÿÿÜ=kÀ€Jÿÿÿÿÿÿæ=Ò=Ü=€Kÿÿÿÿÿÿð=æ=5!€Lÿÿÿÿÿÿú=Pw€Mÿÿÿÿÿÿ>!€Nÿÿÿÿÿÿ>ú=>€Oÿÿÿÿÿÿ>0€Pÿÿÿÿÿÿ">>>€Qÿÿÿÿÿÿ,>¡ö€Rÿÿÿÿÿÿ6>">,>€Sÿÿÿÿÿÿ@>6>…!€TÿÿÿÿÿÿJ>ð=@>€UÿÿÿÿÿÿT>b‰€Vÿÿÿÿÿÿ^>˜s€Wÿÿÿÿÿÿh>T>^>€Xÿÿÿÿÿÿr>4v€Yÿÿÿÿÿÿ|>h>r>€Zÿÿÿÿÿÿ†>Å€[ÿÿÿÿÿÿ>|>†>€\ÿÿÿÿÿÿš>>ß!€]ÿÿÿÿÿÿ¤>J>š>€^ÿÿÿÿÿÿ®>t›€_ÿÿÿÿÿÿ¸>ª…€`ÿÿÿÿÿÿÂ>®>¸>€aÿÿÿÿÿÿÌ>Î]€bÿÿÿÿÿÿÖ>Â>Ì>€cÿÿÿÿÿÿà>Gè€dÿÿÿÿÿÿê>Ö>à>€eÿÿÿÿÿÿô>ê>9"€fÿÿÿÿÿÿþ>¤>ô>€gÿÿÿÿÿÿ?†­€hÿÿÿÿÿÿ?¼—€iÿÿÿÿÿÿ???€jÿÿÿÿÿÿ&?ào€kÿÿÿÿÿÿ0??&?€lÿÿÿÿÿÿ:?ò5€mÿÿÿÿÿÿD?0?:?€nÿÿÿÿÿÿN?D?Z€oÿÿÿÿÿÿX?þ>N?€pÿÿÿÿÿÿb? =X?€qSÿÿÿÿÿÿl?*€r>ÿÿÿÿÿÿv?"l?€sÿÿÿÿÿÿ€?…0v?€tSÿÿÿÿÿÿŠ?<€u>ÿÿÿÿÿÿ”?4Š?€vÿÿÿÿÿÿž?€?”?€wSÿÿÿÿÿÿ¨?N€x>ÿÿÿÿÿÿ²?F¨?€yÿÿÿÿÿÿ¼?ž?²?€zSÿÿÿÿÿÿÆ?`€{>ÿÿÿÿÿÿÐ?XÆ?€|ÿÿÿÿÿÿÚ?¼?Ð?€}Sÿÿÿÿÿÿä?"j€~>ÿÿÿÿÿÿî?ä?€ÿÿÿÿÿÿø?î?[1€€Sÿÿÿÿÿÿ@"~€>ÿÿÿÿÿÿ @4@€‚ÿÿÿÿÿÿ@ø? @€ƒSÿÿÿÿÿÿ @"ˆ€„>ÿÿÿÿÿÿ*@F @€…ÿÿÿÿÿÿ4@@*@€†Sÿÿÿÿÿÿ>@"’€‡>ÿÿÿÿÿÿH@X>@€ˆÿÿÿÿÿÿR@4@H@€‰ÿÿÿÿÿÿ\@Ú?R@€ŠSÿÿÿÿÿÿf@4œ€‹>ÿÿÿÿÿÿp@f@€ŒSÿÿÿÿÿÿz@4¦€>ÿÿÿÿÿÿ„@"z@€ŽÿÿÿÿÿÿŽ@p@„@€ÿÿÿÿÿÿ˜@Ž@E2€Sÿÿÿÿÿÿ¢@4º€‘>ÿÿÿÿÿÿ¬@F¢@€’ÿÿÿÿÿÿ¶@˜@¬@€“SÿÿÿÿÿÿÀ@4Ä€”>ÿÿÿÿÿÿÊ@XÀ@€•ÿÿÿÿÿÿÔ@¶@Ê@€–ÿÿÿÿÿÿÞ@\@Ô@€—Sÿÿÿÿÿÿè@F΀˜>ÿÿÿÿÿÿò@è@€™Sÿÿÿÿÿÿü@FØ€š>ÿÿÿÿÿÿA"ü@€›ÿÿÿÿÿÿAò@A€œSÿÿÿÿÿÿAFâ€>ÿÿÿÿÿÿ$A4A€žÿÿÿÿÿÿ.AA$A€Ÿÿÿÿÿÿÿ8A.A/3€ SÿÿÿÿÿÿBAFö€¡>ÿÿÿÿÿÿLAXBA€¢ÿÿÿÿÿÿVA8ALA€£ÿÿÿÿÿÿ`AÞ@VA€¤SÿÿÿÿÿÿjAX€¥>ÿÿÿÿÿÿtAjA€¦Sÿÿÿÿÿÿ~AX €§>ÿÿÿÿÿÿˆA"~A€¨ÿÿÿÿÿÿ’AtAˆA€©SÿÿÿÿÿÿœAX€ª>ÿÿÿÿÿÿ¦A4œA€«ÿÿÿÿÿÿ°A’A¦A€¬SÿÿÿÿÿÿºAX€­>ÿÿÿÿÿÿÄAFºA€®ÿÿÿÿÿÿÎA°AÄA€¯ÿÿÿÿÿÿØAÎA4€°ÿÿÿÿÿÿâA`AØA€±SÿÿÿÿÿÿìA"€²>ÿÿÿÿÿÿöA"ìA@³ÿÿÿÿÿÿBöA€´ÿÿÿÿÿÿ B0B€µSÿÿÿÿÿÿB4€¶>ÿÿÿÿÿÿB4B@·ÿÿÿÿÿÿ'BB€¸ÿÿÿÿÿÿ0B B'B€¹Sÿÿÿÿÿÿ:BF€º>ÿÿÿÿÿÿDBF:B@»ÿÿÿÿÿÿNBDB€¼ÿÿÿÿÿÿWB0BNB€½SÿÿÿÿÿÿaBX€¾>ÿÿÿÿÿÿkBXaB@¿ÿÿÿÿÿÿuBkB€Àÿÿÿÿÿÿ~BWBuB€ÁSÿÿÿÿÿÿˆBt€Â>ÿÿÿÿÿÿ’BˆB@ÃÿÿÿÿÿÿœB’B€Äÿÿÿÿÿÿ¥BœBe1€ÅSÿÿÿÿÿÿ¯B4t€Æ>ÿÿÿÿÿÿ¹B4¯B@ÇÿÿÿÿÿÿÃB¹B€ÈÿÿÿÿÿÿÌB¥BÃB€ÉSÿÿÿÿÿÿÖBFt€Ê>ÿÿÿÿÿÿàBFÖB@ËÿÿÿÿÿÿêBàB€ÌÿÿÿÿÿÿóBÌBêB€ÍSÿÿÿÿÿÿýBXt€Î>ÿÿÿÿÿÿCXýB@ÏÿÿÿÿÿÿCC€ÐÿÿÿÿÿÿCóBC€Ñÿÿÿÿÿÿ$C~BC€ÒSÿÿÿÿÿÿ.C°€Ó>ÿÿÿÿÿÿ8C.C@ÔÿÿÿÿÿÿBC8C€ÕSÿÿÿÿÿÿKC"°€Ö>ÿÿÿÿÿÿUC"KC@×ÿÿÿÿÿÿ_CUC€ØÿÿÿÿÿÿhCBC_C€ÙÿÿÿÿÿÿrChCO2€ÚSÿÿÿÿÿÿ|CF°€Û>ÿÿÿÿÿÿ†CF|C@ÜÿÿÿÿÿÿC†C€Ýÿÿÿÿÿÿ™CrCC€ÞSÿÿÿÿÿÿ£CX°€ß>ÿÿÿÿÿÿ­CX£C@àÿÿÿÿÿÿ·C­C€áÿÿÿÿÿÿÀC™C·C€âÿÿÿÿÿÿÊC$CÀC€ãSÿÿÿÿÿÿÔCì€ä>ÿÿÿÿÿÿÞCÔC@åÿÿÿÿÿÿèCÞC€æSÿÿÿÿÿÿñC"ì€ç>ÿÿÿÿÿÿûC"ñC@èÿÿÿÿÿÿDûC€éÿÿÿÿÿÿDèCD€êSÿÿÿÿÿÿD4ì€ë>ÿÿÿÿÿÿ"D4D@ìÿÿÿÿÿÿ,D"D€íÿÿÿÿÿÿ5DD,D€îÿÿÿÿÿÿ?D5D93€ïSÿÿÿÿÿÿIDXì€ð>ÿÿÿÿÿÿSDXID@ñÿÿÿÿÿÿ]DSD€òÿÿÿÿÿÿfD?D]D€óÿÿÿÿÿÿpDÊCfD€ôSÿÿÿÿÿÿzD(€õ>ÿÿÿÿÿÿ„DzD@öÿÿÿÿÿÿŽD„D€÷Sÿÿÿÿÿÿ—D"(€ø>ÿÿÿÿÿÿ¡D"—D@ùÿÿÿÿÿÿ«D¡D€úÿÿÿÿÿÿ´DŽD«D€ûSÿÿÿÿÿÿ¾D4(€ü>ÿÿÿÿÿÿÈD4¾D@ýÿÿÿÿÿÿÒDÈD€þÿÿÿÿÿÿÛD´DÒD€ÿSÿÿÿÿÿÿåDF(€>ÿÿÿÿÿÿïDFåD@ÿÿÿÿÿÿùDïD€ÿÿÿÿÿÿEÛDùD€ÿÿÿÿÿÿ EE#4€ÿÿÿÿÿÿEpD E€ÿÿÿÿÿÿ E¦+€ÿÿÿÿÿÿ*E Eñ€ÿÿÿÿÿÿ4E*E·€ÿÿÿÿÿÿ>E4E}€ ÿÿÿÿÿÿHE€€ ÿÿÿÿÿÿREHE'€ ÿÿÿÿÿÿ\EREí€ ÿÿÿÿÿÿfE\E³€ ÿÿÿÿÿÿpE>EfE€ÿÿÿÿÿÿzE’|€ÿÿÿÿÿÿ„EzEv€ÿÿÿÿÿÿŽE„E€ÿÿÿÿÿÿ˜EŽE×€ÿÿÿÿÿÿ¢EpE˜E€ÿÿÿÿÿÿ¬E¤Ž€ÿÿÿÿÿÿ¶E¬Ef€ÿÿÿÿÿÿÀE¶Eè€ÿÿÿÿÿÿÊEÀEé€ÿÿÿÿÿÿÔE¢EÊE€ÿÿÿÿÿÿÞE¶ €ÿÿÿÿÿÿèEÞEx€ÿÿÿÿÿÿòEèE>€ÿÿÿÿÿÿüEòEZ€ÿÿÿÿÿÿFÔEüE€ÿÿÿÿÿÿF¦2€ÿÿÿÿÿÿFw€ÿÿÿÿÿÿ$FFF€ ÿÿÿÿÿÿ.F‰€!ÿÿÿÿÿÿ8F$F.F€"ÿÿÿÿÿÿBF›€#ÿÿÿÿÿÿLF8FBF€$ÿÿÿÿÿÿVF­ø€%ÿÿÿÿÿÿ`FLFVF€&ÿÿÿÿÿÿjF€Œ€'ÿÿÿÿÿÿtF¯v€(ÿÿÿÿÿÿ~FjFtF€)ÿÿÿÿÿÿˆF¿j€*ÿÿÿÿÿÿ’F~FˆF€+ÿÿÿÿÿÿœFÑ^€,ÿÿÿÿÿÿ¦F’FœF€-ÿÿÿÿÿÿ°FãR €.ÿÿÿÿÿÿºF¦F°F€/ÿÿÿÿÿÿÄF`FºF€0ÿÿÿÿÿÿÎF’ð€1ÿÿÿÿÿÿØFÈÚ€2ÿÿÿÿÿÿâFÎFØF€3ÿÿÿÿÿÿìFÂ΀4ÿÿÿÿÿÿöFâFìF€5ÿÿÿÿÿÿGõ€6ÿÿÿÿÿÿ GöFG€7ÿÿÿÿÿÿG¶ €8ÿÿÿÿÿÿG GG€9ÿÿÿÿÿÿ(GÄFG€:ÿÿÿÿÿÿ2G¤T€;ÿÿÿÿÿÿ€<ÿÿÿÿÿÿFG2GÿÿÿÿÿÿZGFGPG€?ÿÿÿÿÿÿdGÕ&€@ÿÿÿÿÿÿnGZGdG€AÿÿÿÿÿÿxG €Bÿÿÿÿÿÿ‚GnGxG€CÿÿÿÿÿÿŒG(G‚G€Dÿÿÿÿÿÿ–G¶¸€Eÿÿÿÿÿÿ G좀FÿÿÿÿÿÿªG–G G€Gÿÿÿÿÿÿ´G–€Hÿÿÿÿÿÿ¾GªG´G€IÿÿÿÿÿÿÈG"Š€JÿÿÿÿÿÿÒG¾GÈG€KÿÿÿÿÿÿÜGè~ €LÿÿÿÿÿÿæGÒGÜG€MÿÿÿÿÿÿðGŒGæG€NÿÿÿÿÿÿúGû<€OÿÿÿÿÿÿH+&€PÿÿÿÿÿÿHúGH€QÿÿÿÿÿÿH=€Rÿÿÿÿÿÿ"HHH€Sÿÿÿÿÿÿ,HO€Tÿÿÿÿÿÿ6H"H,H€Uÿÿÿÿÿÿ@Ha €VÿÿÿÿÿÿJH6H@H€WÿÿÿÿÿÿTH4–€Xÿÿÿÿÿÿ^H€€YÿÿÿÿÿÿhHTH^H€ZÿÿÿÿÿÿrHst€[ÿÿÿÿÿÿ|HhHrH€\ÿÿÿÿÿÿ†H…h€]ÿÿÿÿÿÿH|H†H€^ÿÿÿÿÿÿšH—\ €_ÿÿÿÿÿÿ¤HHšH€`ÿÿÿÿÿÿ®HJH¤H€aÿÿÿÿÿÿ¸HFú€bÿÿÿÿÿÿÂH|ä€cÿÿÿÿÿÿÌH¸HÂH€dÿÿÿÿÿÿÖHØ€eÿÿÿÿÿÿàHÌHÖH€fÿÿÿÿÿÿêH©Ì€gÿÿÿÿÿÿôHàHêH€hÿÿÿÿÿÿþH»À €iÿÿÿÿÿÿIôHþH€jÿÿÿÿÿÿI®HI€kÿÿÿÿÿÿIX^€lÿÿÿÿÿÿ&IŽH€mÿÿÿÿÿÿ0II&I€nÿÿÿÿÿÿ:I²<€oÿÿÿÿÿÿDI0I:I€pÿÿÿÿÿÿNI*0€qÿÿÿÿÿÿXIDINI€rÿÿÿÿÿÿbIÍ$ €sÿÿÿÿÿÿlIXIbI€tÿÿÿÿÿÿvIIlI€uÿÿÿÿÿÿ€Ij€vÿÿÿÿÿÿŠI ¬€wÿÿÿÿÿÿ”I€IŠI€xÿÿÿÿÿÿžIÄ €yÿÿÿÿÿÿ¨I”IžI€zÿÿÿÿÿÿ²IÖ”€{ÿÿÿÿÿÿ¼I¨I²I€|ÿÿÿÿÿÿÆI=ˆ €}ÿÿÿÿÿÿÐI¼IÆI€~ÿÿÿÿÿÿÚIvIÐI€ÿÿÿÿÿÿäIðGÚI€€ÿÿÿÿÿÿîIZP€ÿÿÿÿÿÿøIß:€‚ÿÿÿÿÿÿJîIøI€ƒÿÿÿÿÿÿ Jñ.€„ÿÿÿÿÿÿJJ J€…ÿÿÿÿÿÿ J"€†ÿÿÿÿÿÿ*JJ J€‡ÿÿÿÿÿÿ4J €ˆÿÿÿÿÿÿ>J*J4J€‰ÿÿÿÿÿÿHJ誀ŠÿÿÿÿÿÿRJc”€‹ÿÿÿÿÿÿ\JHJRJ€ŒÿÿÿÿÿÿfJ'ˆ€ÿÿÿÿÿÿpJ\JfJ€ŽÿÿÿÿÿÿzJ9|€ÿÿÿÿÿÿ„JpJzJ€ÿÿÿÿÿÿŽJKp €‘ÿÿÿÿÿÿ˜J„JŽJ€’ÿÿÿÿÿÿ¢J>J˜J€“ÿÿÿÿÿÿ¬Jú€”ÿÿÿÿÿÿ¶J0ø€•ÿÿÿÿÿÿÀJ¬J¶J€–ÿÿÿÿÿÿÊJv쀗ÿÿÿÿÿÿÔJÀJÊJ€˜ÿÿÿÿÿÿÞJ]à€™ÿÿÿÿÿÿèJÔJÞJ€šÿÿÿÿÿÿòJoÔ €›ÿÿÿÿÿÿüJèJòJ€œÿÿÿÿÿÿK¢JüJ€ÿÿÿÿÿÿK r€žÿÿÿÿÿÿKB\€Ÿÿÿÿÿÿÿ$KKK€ ÿÿÿÿÿÿ.KfP€¡ÿÿÿÿÿÿ8K$K.K€¢ÿÿÿÿÿÿBK‰D€£ÿÿÿÿÿÿLK8KBK€¤ÿÿÿÿÿÿVK8 €¥ÿÿÿÿÿÿ`KLKVK€¦ÿÿÿÿÿÿjKK`K€§ÿÿÿÿÿÿtKÖ€¨ÿÿÿÿÿÿ~KTÀ€©ÿÿÿÿÿÿˆKtK~K€ªÿÿÿÿÿÿ’Kx´€«ÿÿÿÿÿÿœKˆK’K€¬ÿÿÿÿÿÿ¦KŠ¨€­ÿÿÿÿÿÿ°KœK¦K€®ÿÿÿÿÿÿºKœœ €¯ÿÿÿÿÿÿÄK°KºK€°ÿÿÿÿÿÿÎKjKÄK€±ÿÿÿÿÿÿØKäIÎK€²ÿÿÿÿÿÿâK¹d€³ÿÿÿÿÿÿìK“N€´ÿÿÿÿÿÿöKâKìK€µÿÿÿÿÿÿL¥B€¶ÿÿÿÿÿÿ LöKL€·ÿÿÿÿÿÿL·6€¸ÿÿÿÿÿÿL LL€¹ÿÿÿÿÿÿ(LÉ* €ºÿÿÿÿÿÿ2LL(L€»ÿÿÿÿÿÿ¼€ßÿÿÿÿÿÿ¤MMšM€àÿÿÿÿÿÿ®Mû° €áÿÿÿÿÿÿ¸M¤M®M€âÿÿÿÿÿÿÂM^M¸M€ãÿÿÿÿÿÿÌMØKÂM€äÿÿÿÿÿÿÖMx€åÿÿÿÿÿÿàMGb€æÿÿÿÿÿÿêMÖMàM€çÿÿÿÿÿÿôMYV€èÿÿÿÿÿÿþMêMôM€éÿÿÿÿÿÿNkJ€êÿÿÿÿÿÿNþMN€ëÿÿÿÿÿÿN}> €ìÿÿÿÿÿÿ&NNN€íÿÿÿÿÿÿ0NPÒ€îÿÿÿÿÿÿ:N!¼€ïÿÿÿÿÿÿDN0N:N€ðÿÿÿÿÿÿNN°€ñÿÿÿÿÿÿXNDNNN€òÿÿÿÿÿÿbN¡¤€óÿÿÿÿÿÿlNXNbN€ôÿÿÿÿÿÿvN³˜ €õÿÿÿÿÿÿ€NlNvN€öÿÿÿÿÿÿŠN&N€N€÷ÿÿÿÿÿÿ”Nb6€øÿÿÿÿÿÿžN˜ €ùÿÿÿÿÿÿ¨N”NžN€úÿÿÿÿÿÿ²N4€ûÿÿÿÿÿÿ¼N¨N²N€üÿÿÿÿÿÿÆNÅ€ýÿÿÿÿÿÿÐN¼NÆN€þÿÿÿÿÿÿÚN×ü €ÿÿÿÿÿÿÿäNÐNÚN€ÿÿÿÿÿÿîNŠNäN€ÿÿÿÿÿÿøNtš€ÿÿÿÿÿÿOª„€ÿÿÿÿÿÿ OøNO€ÿÿÿÿÿÿOÎx€ÿÿÿÿÿÿ O OO€ÿÿÿÿÿÿ*OGl€ÿÿÿÿÿÿ4O O*O€ÿÿÿÿÿÿ>Oé` € ÿÿÿÿÿÿHO4O>O€ ÿÿÿÿÿÿROîNHO€ ÿÿÿÿÿÿ\O†þ€ ÿÿÿÿÿÿfO¼è€ ÿÿÿÿÿÿpO\OfO€ÿÿÿÿÿÿzOàÜ€ÿÿÿÿÿÿ„OpOzO€ÿÿÿÿÿÿŽOòЀÿÿÿÿÿÿ˜O„OŽO€ÿÿÿÿÿÿ¢OZÄ €ÿÿÿÿÿÿ¬O˜O¢O€ÿÿÿÿÿÿ¶ORO¬O€ÿÿÿÿÿÿÀOÌM¶O€ÿÿÿÿÿÿÊO2¦€ÿÿÿÿÿÿÔOŒû€ÿÿÿÿÿÿÞOÊOÔO€ÿÿÿÿÿÿèOðZ€ÿÿÿÿÿÿòOÞOèO€ÿÿÿÿÿÿüOT¹€ÿÿÿÿÿÿPòOüO€ÿÿÿÿÿÿP¸€ÿÿÿÿÿÿPPP€ÿÿÿÿÿÿ$P€€ ÿÿÿÿÿÿ.Pv4€!ÿÿÿÿÿÿ8P$P.P€"ÿÿÿÿÿÿBPÚè€#ÿÿÿÿÿÿLP8PBP€$ÿÿÿÿÿÿVP>œ€%ÿÿÿÿÿÿ`PLPVP€&ÿÿÿÿÿÿjP¢P€'ÿÿÿÿÿÿtP`PjP€(ÿÿÿÿÿÿ~PPtP€)ÿÿÿÿÿÿˆP’€*ÿÿÿÿÿÿ’PjF€+ÿÿÿÿÿÿœPˆP’P€,ÿÿÿÿÿÿ¦PÎú€-ÿÿÿÿÿÿ°PœP¦P€.ÿÿÿÿÿÿºP2®€/ÿÿÿÿÿÿÄP°PºP€0ÿÿÿÿÿÿÎP–b€1ÿÿÿÿÿÿØPÄPÎP€2ÿÿÿÿÿÿâP~PØP€3ÿÿÿÿÿÿìP¤€4ÿÿÿÿÿÿöP^X€5ÿÿÿÿÿÿQìPöP€6ÿÿÿÿÿÿ Q €7ÿÿÿÿÿÿQQ Q€8ÿÿÿÿÿÿQ&À€9ÿÿÿÿÿÿ(QQQ€:ÿÿÿÿÿÿ2QŠt€;ÿÿÿÿÿÿÿÿÿÿÿÿZQR j€?ÿÿÿÿÿÿdQPQZQ€@ÿÿÿÿÿÿnQ¶ €AÿÿÿÿÿÿxQdQnQ€Bÿÿÿÿÿÿ‚Q Ò€CÿÿÿÿÿÿŒQxQ‚Q€Dÿÿÿÿÿÿ–Q~ †€Eÿÿÿÿÿÿ QŒQ–Q€FÿÿÿÿÿÿªQFQ Q€Gÿÿÿÿÿÿ´Q<w€Hÿÿÿÿÿÿ¾Q–+€IÿÿÿÿÿÿÈQ´Q¾Q€JÿÿÿÿÿÿÒQú߀KÿÿÿÿÿÿÜQÈQÒQ€LÿÿÿÿÿÿæQ^“€MÿÿÿÿÿÿðQÜQæQ€NÿÿÿÿÿÿúQÂG€OÿÿÿÿÿÿRðQúQ€PÿÿÿÿÿÿR&¯€QÿÿÿÿÿÿR€€Rÿÿÿÿÿÿ"RRR€Sÿÿÿÿÿÿ,Räc€Tÿÿÿÿÿÿ6R"R,R€Uÿÿÿÿÿÿ@RH€VÿÿÿÿÿÿJR6R@R€WÿÿÿÿÿÿTR¬!€Xÿÿÿÿÿÿ^RJRTR€YÿÿÿÿÿÿhRR^R€ZÿÿÿÿÿÿrRÈ€[ÿÿÿÿÿÿ|Rt|€\ÿÿÿÿÿÿ†RrR|R€]ÿÿÿÿÿÿRØ0€^ÿÿÿÿÿÿšR†RR€_ÿÿÿÿÿÿ¤R<ä€`ÿÿÿÿÿÿ®RšR¤R€aÿÿÿÿÿÿ¸R ˜€bÿÿÿÿÿÿÂR®R¸R€cÿÿÿÿÿÿÌRhRÂR€dÿÿÿÿÿÿÖRÚ€eÿÿÿÿÿÿàRhŽ€fÿÿÿÿÿÿêRÖRàR€gÿÿÿÿÿÿôRÌB€hÿÿÿÿÿÿþRêRôR€iÿÿÿÿÿÿS0ö€jÿÿÿÿÿÿSþRS€kÿÿÿÿÿÿS”ª€lÿÿÿÿÿÿ&SSS€mÿÿÿÿÿÿ0SÌR&S€nÿÿÿÿÿÿ:S ì€oÿÿÿÿÿÿDS\  €pÿÿÿÿÿÿNS:SDS€qÿÿÿÿÿÿXSÀ T€rÿÿÿÿÿÿbSNSXS€sÿÿÿÿÿÿlS$ €tÿÿÿÿÿÿvSbSlS€uÿÿÿÿÿÿ€Sˆ ¼€vÿÿÿÿÿÿŠSvS€S€wÿÿÿÿÿÿ”S0SŠS€xÿÿÿÿÿÿžSªQ”S€yÿÿÿÿÿÿ¨SP‰€zÿÿÿÿÿÿ²Sª=€{ÿÿÿÿÿÿ¼S¨S²S€|ÿÿÿÿÿÿÆSñ€}ÿÿÿÿÿÿÐS¼SÆS€~ÿÿÿÿÿÿÚSr¥€ÿÿÿÿÿÿäSÐSÚS€€ÿÿÿÿÿÿîSÖY€ÿÿÿÿÿÿøSäSîS€‚ÿÿÿÿÿÿT:¿€ƒÿÿÿÿÿÿ T”s€„ÿÿÿÿÿÿTT T€…ÿÿÿÿÿÿ Tø'€†ÿÿÿÿÿÿ*TT T€‡ÿÿÿÿÿÿ4T\Û€ˆÿÿÿÿÿÿ>T*T4T€‰ÿÿÿÿÿÿHTÀ€ŠÿÿÿÿÿÿRT>THT€‹ÿÿÿÿÿÿ\TøSRT€ŒÿÿÿÿÿÿfT.€ÿÿÿÿÿÿpTˆ€ŽÿÿÿÿÿÿzTfTpT€ÿÿÿÿÿÿ„Tìv€ÿÿÿÿÿÿŽTzT„T€‘ÿÿÿÿÿÿ˜TPÕ€’ÿÿÿÿÿÿ¢TŽT˜T€“ÿÿÿÿÿÿ¬T´4€”ÿÿÿÿÿÿ¶T¢T¬T€•ÿÿÿÿÿÿÀT\T¶T€–ÿÿÿÿÿÿÊT"þ€—ÿÿÿÿÿÿÔT|²€˜ÿÿÿÿÿÿÞTÊTÔT€™ÿÿÿÿÿÿèTàf€šÿÿÿÿÿÿòTÞTèT€›ÿÿÿÿÿÿüTD€œÿÿÿÿÿÿUòTüT€ÿÿÿÿÿÿU¨Î€žÿÿÿÿÿÿUUU€Ÿÿÿÿÿÿÿ$UÀTU€ ÿÿÿÿÿÿ.U €¡ÿÿÿÿÿÿ8Up Ä€¢ÿÿÿÿÿÿBU.U8U€£ÿÿÿÿÿÿLUÔ x€¤ÿÿÿÿÿÿVUBULU€¥ÿÿÿÿÿÿ`U8 ,€¦ÿÿÿÿÿÿjUVU`U€§ÿÿÿÿÿÿtUœ à€¨ÿÿÿÿÿÿ~UjUtU€©ÿÿÿÿÿÿˆU$U~U€ªÿÿÿÿÿÿ’UžSˆU€«ÿÿÿÿÿÿœUd›€¬ÿÿÿÿÿÿ¦U¾O€­ÿÿÿÿÿÿ°UœU¦U€®ÿÿÿÿÿÿºU"€¯ÿÿÿÿÿÿÄU°UºU€°ÿÿÿÿÿÿÎU†·€±ÿÿÿÿÿÿØUÄUÎU€²ÿÿÿÿÿÿâUêk€³ÿÿÿÿÿÿìUØUâU€´ÿÿÿÿÿÿöUNÑ€µÿÿÿÿÿÿV¨…€¶ÿÿÿÿÿÿ VöUV€·ÿÿÿÿÿÿV 9€¸ÿÿÿÿÿÿV VV€¹ÿÿÿÿÿÿ(Vp퀺ÿÿÿÿÿÿ2VV(V€»ÿÿÿÿÿÿ€Øÿÿÿÿÿÿ^WJWTW€ÙÿÿÿÿÿÿhW° ò€ÚÿÿÿÿÿÿrW^WhW€Ûÿÿÿÿÿÿ|WWrW€Üÿÿÿÿÿÿ†W’U|W€ÝÿÿÿÿÿÿWx­€ÞÿÿÿÿÿÿšWÒa€ßÿÿÿÿÿÿ¤WWšW€àÿÿÿÿÿÿ®W6€áÿÿÿÿÿÿ¸W¤W®W€âÿÿÿÿÿÿÂWšÉ€ãÿÿÿÿÿÿÌW¸WÂW€äÿÿÿÿÿÿÖWþ}€åÿÿÿÿÿÿàWÌWÖW€æÿÿÿÿÿÿêWbã€çÿÿÿÿÿÿôW¼—€èÿÿÿÿÿÿþWêWôW€éÿÿÿÿÿÿX K€êÿÿÿÿÿÿXþWX€ëÿÿÿÿÿÿX„ÿ€ìÿÿÿÿÿÿ&XXX€íÿÿÿÿÿÿ0Xè³€îÿÿÿÿÿÿ:X&X0X€ïÿÿÿÿÿÿDXàW:X€ðÿÿÿÿÿÿNXV€ñÿÿÿÿÿÿXX°»€òÿÿÿÿÿÿbXNXXX€óÿÿÿÿÿÿlXo€ôÿÿÿÿÿÿvXbXlX€õÿÿÿÿÿÿ€Xx#€öÿÿÿÿÿÿŠXvX€X€÷ÿÿÿÿÿÿ”XÜ×€øÿÿÿÿÿÿžXŠX”X€ùÿÿÿÿÿÿ¨XDXžX€úÿÿÿÿÿÿ²XJ€ûÿÿÿÿÿÿ¼X¤Í€üÿÿÿÿÿÿÆX²X¼X€ýÿÿÿÿÿÿÐX€þÿÿÿÿÿÿÚXÆXÐX€ÿÿÿÿÿÿÿäXl5€ ÿÿÿÿÿÿîXÚXäX€ ÿÿÿÿÿÿøXÐé€ ÿÿÿÿÿÿYîXøX€ ÿÿÿÿÿÿ Y¨XY€ ÿÿÿÿÿÿY> è€ ÿÿÿÿÿÿ Y˜ =€ ÿÿÿÿÿÿ*YY Y€ ÿÿÿÿÿÿ4Yü œ€ ÿÿÿÿÿÿ>Y*Y4Y€ ÿÿÿÿÿÿHY` û€ ÿÿÿÿÿÿRY>YHY€ ÿÿÿÿÿÿ\YÄ Z€ ÿÿÿÿÿÿfYRY\Y€ ÿÿÿÿÿÿpY YfY€ ÿÿÿÿÿÿzY†WpY€ ÿÿÿÿÿÿ„Y÷"X'€ ÿÿÿÿÿÿŽY„Yþ'€ ÿÿÿÿÿÿ˜YŽY¤(€ ÿÿÿÿÿÿ¢Y˜YJ)€ ÿÿÿÿÿÿ¬Y¼&Í#€ ÿÿÿÿÿÿ¶Y¬Y(€ ÿÿÿÿÿÿÀY¶YÁ(€ ÿÿÿÿÿÿÊYÀYg)€ ÿÿÿÿÿÿÔY¢YÊY€ ÿÿÿÿÿÿÞYã&'€ ÿÿÿÿÿÿèYÞY·$€ ÿÿÿÿÿÿòYèYè(€ ÿÿÿÿÿÿüYòYŽ)€ ÿÿÿÿÿÿZÔYüY€ ÿÿÿÿÿÿZ '¦'€ ÿÿÿÿÿÿZZL(€ ÿÿÿÿÿÿ$ZZ¡%€ ÿÿÿÿÿÿ.Z$Zµ)€! ÿÿÿÿÿÿ8ZZ.Z€" ÿÿÿÿÿÿBZ1'Í'€# ÿÿÿÿÿÿLZBZs(€$ ÿÿÿÿÿÿVZLZ)€% ÿÿÿÿÿÿ`ZVZ‹&€& ÿÿÿÿÿÿjZ8Z`Z€' >ÿÿÿÿÿÿtZj@( ÿÿÿÿÿÿ~ZtZ€) >ÿÿÿÿÿÿ‡Zœ@* ÿÿÿÿÿÿ‘Z‡Z€+ ÿÿÿÿÿÿšZ~Z‘Z€, >ÿÿÿÿÿÿ¤ZÎ@- ÿÿÿÿÿÿ®Z¤Z€. ÿÿÿÿÿÿ·ZšZ®Z€/ >ÿÿÿÿÿÿÁZ@0 ÿÿÿÿÿÿËZÁZ€1 ÿÿÿÿÿÿÔZ·ZËZ€2 >ÿÿÿÿÿÿÞZjœ@3 ÿÿÿÿÿÿèZÞZ€4 ÿÿÿÿÿÿñZÔZèZ€5 >ÿÿÿÿÿÿûZjÎ@6 ÿÿÿÿÿÿ[ûZ€7 ÿÿÿÿÿÿ[ñZ[€8 >ÿÿÿÿÿÿ[j@9 ÿÿÿÿÿÿ"[[€: ÿÿÿÿÿÿ+[["[€; >ÿÿÿÿÿÿ5[œÎ@< ÿÿÿÿÿÿ?[5[€= ÿÿÿÿÿÿH[+[?[€> >ÿÿÿÿÿÿR[œ@? ÿÿÿÿÿÿ\[R[€@ ÿÿÿÿÿÿe[H[\[€A >ÿÿÿÿÿÿo[Î@B ÿÿÿÿÿÿy[o[€C ÿÿÿÿÿÿ‚[e[y[€D >ÿÿÿÿÿÿŒ[*t@E ÿÿÿÿÿÿ–[Œ[€F >ÿÿÿÿÿÿŸ[*¦@G ÿÿÿÿÿÿ©[Ÿ[€H ÿÿÿÿÿÿ²[–[©[€I >ÿÿÿÿÿÿ¼[*Ø@J ÿÿÿÿÿÿÆ[¼[€K ÿÿÿÿÿÿÏ[²[Æ[€L >ÿÿÿÿÿÿÙ[* @M ÿÿÿÿÿÿã[Ù[€N ÿÿÿÿÿÿì[Ï[ã[€O >ÿÿÿÿÿÿö[t¦@P ÿÿÿÿÿÿ\ö[€Q ÿÿÿÿÿÿ \ì[\€R >ÿÿÿÿÿÿ\tØ@S ÿÿÿÿÿÿ\\€T ÿÿÿÿÿÿ&\ \\€U >ÿÿÿÿÿÿ0\t @V ÿÿÿÿÿÿ:\0\€W ÿÿÿÿÿÿC\&\:\€X >ÿÿÿÿÿÿM\¦Ø@Y ÿÿÿÿÿÿW\M\€Z ÿÿÿÿÿÿ`\C\W\€[ >ÿÿÿÿÿÿj\¦ @\ ÿÿÿÿÿÿt\j\€] ÿÿÿÿÿÿ}\`\t\€^ >ÿÿÿÿÿÿ‡\Ø @_ ÿÿÿÿÿÿ‘\‡\€` ÿÿÿÿÿÿš\}\‘\€a ÿÿÿÿÿÿ¤\‚[š\€b >ÿÿÿÿÿÿ®\<~@c ÿÿÿÿÿÿ¸\®\€d >ÿÿÿÿÿÿÁ\<°@e ÿÿÿÿÿÿË\Á\€f ÿÿÿÿÿÿÔ\¸\Ë\€g >ÿÿÿÿÿÿÞ\<â@h ÿÿÿÿÿÿè\Þ\€i ÿÿÿÿÿÿñ\Ô\è\€j >ÿÿÿÿÿÿû\<@k ÿÿÿÿÿÿ]û\€l ÿÿÿÿÿÿ]ñ\]€m >ÿÿÿÿÿÿ]~°@n ÿÿÿÿÿÿ"]]€o ÿÿÿÿÿÿ+]]"]€p >ÿÿÿÿÿÿ5]~â@q ÿÿÿÿÿÿ?]5]€r ÿÿÿÿÿÿH]+]?]€s >ÿÿÿÿÿÿR]~@t ÿÿÿÿÿÿ\]R]€u ÿÿÿÿÿÿe]H]\]€v >ÿÿÿÿÿÿo]°â@w ÿÿÿÿÿÿy]o]€x ÿÿÿÿÿÿ‚]e]y]€y >ÿÿÿÿÿÿŒ]°@z ÿÿÿÿÿÿ–]Œ]€{ ÿÿÿÿÿÿŸ]‚]–]€| >ÿÿÿÿÿÿ©]â@} ÿÿÿÿÿÿ³]©]€~ ÿÿÿÿÿÿ¼]Ÿ]³]€ ÿÿÿÿÿÿÆ]¤\¼]€€ >ÿÿÿÿÿÿÐ]Nˆ@ ÿÿÿÿÿÿÚ]Ð]€‚ >ÿÿÿÿÿÿã]Nº@ƒ ÿÿÿÿÿÿí]ã]€„ ÿÿÿÿÿÿö]Ú]í]€… >ÿÿÿÿÿÿ^Nì@† ÿÿÿÿÿÿ ^^€‡ ÿÿÿÿÿÿ^ö] ^€ˆ >ÿÿÿÿÿÿ^N@‰ ÿÿÿÿÿÿ'^^€Š ÿÿÿÿÿÿ0^^'^€‹ >ÿÿÿÿÿÿ:^ˆº@Œ ÿÿÿÿÿÿD^:^€ ÿÿÿÿÿÿM^0^D^€Ž >ÿÿÿÿÿÿW^ˆì@ ÿÿÿÿÿÿa^W^€ ÿÿÿÿÿÿj^M^a^€‘ >ÿÿÿÿÿÿt^ˆ@’ ÿÿÿÿÿÿ~^t^€“ ÿÿÿÿÿÿ‡^j^~^€” >ÿÿÿÿÿÿ‘^ºì@• ÿÿÿÿÿÿ›^‘^€– ÿÿÿÿÿÿ¤^‡^›^€— >ÿÿÿÿÿÿ®^º@˜ ÿÿÿÿÿÿ¸^®^€™ ÿÿÿÿÿÿÁ^¤^¸^€š >ÿÿÿÿÿÿË^ì@› ÿÿÿÿÿÿÕ^Ë^€œ ÿÿÿÿÿÿÞ^Á^Õ^€ ÿÿÿÿÿÿè^Æ]Þ^€ž >ÿÿÿÿÿÿò^`’@Ÿ ÿÿÿÿÿÿü^ò^€  >ÿÿÿÿÿÿ_`Ä@¡ ÿÿÿÿÿÿ__€¢ ÿÿÿÿÿÿ_ü^_€£ >ÿÿÿÿÿÿ"_`ö@¤ ÿÿÿÿÿÿ,_"_€¥ ÿÿÿÿÿÿ5__,_€¦ >ÿÿÿÿÿÿ?_`(@§ ÿÿÿÿÿÿI_?_€¨ ÿÿÿÿÿÿR_5_I_€© >ÿÿÿÿÿÿ\_’Ä@ª ÿÿÿÿÿÿf_\_€« ÿÿÿÿÿÿo_R_f_€¬ >ÿÿÿÿÿÿy_’ö@­ ÿÿÿÿÿÿƒ_y_€® ÿÿÿÿÿÿŒ_o_ƒ_€¯ >ÿÿÿÿÿÿ–_’(@° ÿÿÿÿÿÿ _–_€± ÿÿÿÿÿÿ©_Œ_ _€² >ÿÿÿÿÿÿ³_Äö@³ ÿÿÿÿÿÿ½_³_€´ ÿÿÿÿÿÿÆ_©_½_€µ >ÿÿÿÿÿÿÐ_Ä(@¶ ÿÿÿÿÿÿÚ_Ð_€· ÿÿÿÿÿÿã_Æ_Ú_€¸ >ÿÿÿÿÿÿí_ö(@¹ ÿÿÿÿÿÿ÷_í_€º ÿÿÿÿÿÿ`ã_÷_€» ÿÿÿÿÿÿ `è^`€¼ >ÿÿÿÿÿÿ`*@½ ÿÿÿÿÿÿ``€¾ >ÿÿÿÿÿÿ'`<@¿ ÿÿÿÿÿÿ1`'`€À ÿÿÿÿÿÿ:``1`€Á >ÿÿÿÿÿÿD`N@ ÿÿÿÿÿÿN`D`€Ã ÿÿÿÿÿÿW`:`N`€Ä >ÿÿÿÿÿÿa``@Å ÿÿÿÿÿÿk`a`€Æ ÿÿÿÿÿÿt`W`k`€Ç >ÿÿÿÿÿÿ~`*<@È ÿÿÿÿÿÿˆ`~`€É ÿÿÿÿÿÿ‘`t`ˆ`€Ê >ÿÿÿÿÿÿ›`*N@Ë ÿÿÿÿÿÿ¥`›`€Ì ÿÿÿÿÿÿ®`‘`¥`€Í >ÿÿÿÿÿÿ¸`*`@Î ÿÿÿÿÿÿÂ`¸`€Ï ÿÿÿÿÿÿË`®`Â`€Ð >ÿÿÿÿÿÿÕ`<N@Ñ ÿÿÿÿÿÿß`Õ`€Ò ÿÿÿÿÿÿè`Ë`ß`€Ó >ÿÿÿÿÿÿò`<`@Ô ÿÿÿÿÿÿü`ò`€Õ ÿÿÿÿÿÿaè`ü`€Ö >ÿÿÿÿÿÿaN`@× ÿÿÿÿÿÿaa€Ø ÿÿÿÿÿÿ"aaa€Ù >ÿÿÿÿÿÿ,ajt@Ú ÿÿÿÿÿÿ6a,a€Û >ÿÿÿÿÿÿ?aj~@Ü ÿÿÿÿÿÿIa?a€Ý ÿÿÿÿÿÿRa6aIa€Þ >ÿÿÿÿÿÿ\ajˆ@ß ÿÿÿÿÿÿfa\a€à ÿÿÿÿÿÿoaRafa€á >ÿÿÿÿÿÿyaj’@â ÿÿÿÿÿÿƒaya€ã ÿÿÿÿÿÿŒaoaƒa€ä >ÿÿÿÿÿÿ–at~@å ÿÿÿÿÿÿ a–a€æ ÿÿÿÿÿÿ©aŒa a€ç >ÿÿÿÿÿÿ³atˆ@è ÿÿÿÿÿÿ½a³a€é ÿÿÿÿÿÿÆa©a½a€ê >ÿÿÿÿÿÿÐat’@ë ÿÿÿÿÿÿÚaÐa€ì ÿÿÿÿÿÿãaÆaÚa€í >ÿÿÿÿÿÿía~ˆ@î ÿÿÿÿÿÿ÷aía€ï ÿÿÿÿÿÿbãa÷a€ð >ÿÿÿÿÿÿ b~’@ñ ÿÿÿÿÿÿb b€ò ÿÿÿÿÿÿbbb€ó >ÿÿÿÿÿÿ'bˆ’@ô ÿÿÿÿÿÿ1b'b€õ ÿÿÿÿÿÿ:bb1b€ö ÿÿÿÿÿÿDb"a:b€÷ >ÿÿÿÿÿÿNbœ¦@ø ÿÿÿÿÿÿXbNb€ù >ÿÿÿÿÿÿabœ°@ú ÿÿÿÿÿÿkbab€û ÿÿÿÿÿÿtbXbkb€ü >ÿÿÿÿÿÿ~bœº@ý ÿÿÿÿÿÿˆb~b€þ ÿÿÿÿÿÿ‘btbˆb€ÿ >ÿÿÿÿÿÿ›bœÄ@ ÿÿÿÿÿÿ¥b›b€ ÿÿÿÿÿÿ®b‘b¥b€ >ÿÿÿÿÿÿ¸b¦°@ ÿÿÿÿÿÿÂb¸b€ ÿÿÿÿÿÿËb®bÂb€ >ÿÿÿÿÿÿÕb¦º@ ÿÿÿÿÿÿßbÕb€ ÿÿÿÿÿÿèbËbßb€ >ÿÿÿÿÿÿòb¦Ä@ ÿÿÿÿÿÿübòb€ ÿÿÿÿÿÿcèbüb€ >ÿÿÿÿÿÿc°º@ ÿÿÿÿÿÿcc€ ÿÿÿÿÿÿ"ccc€ >ÿÿÿÿÿÿ,c°Ä@ ÿÿÿÿÿÿ6c,c€ ÿÿÿÿÿÿ?c"c6c€ >ÿÿÿÿÿÿIcºÄ@ ÿÿÿÿÿÿScIc€ ÿÿÿÿÿÿ\c?cSc€ ÿÿÿÿÿÿfcDb\c€ >ÿÿÿÿÿÿpcÎØ@ ÿÿÿÿÿÿzcpc€ >ÿÿÿÿÿÿƒcÎâ@ ÿÿÿÿÿÿcƒc€ ÿÿÿÿÿÿ–czcc€ >ÿÿÿÿÿÿ cÎì@ ÿÿÿÿÿÿªc c€ ÿÿÿÿÿÿ³c–cªc€ >ÿÿÿÿÿÿ½cÎö@ ÿÿÿÿÿÿÇc½c€ ÿÿÿÿÿÿÐc³cÇc€ >ÿÿÿÿÿÿÚcØâ@! ÿÿÿÿÿÿäcÚc€" ÿÿÿÿÿÿícÐcäc€# >ÿÿÿÿÿÿ÷cØì@$ ÿÿÿÿÿÿd÷c€% ÿÿÿÿÿÿ dícd€& >ÿÿÿÿÿÿdØö@' ÿÿÿÿÿÿdd€( ÿÿÿÿÿÿ'd dd€) >ÿÿÿÿÿÿ1dâì@* ÿÿÿÿÿÿ;d1d€+ ÿÿÿÿÿÿDd'd;d€, >ÿÿÿÿÿÿNdâö@- ÿÿÿÿÿÿXdNd€. ÿÿÿÿÿÿadDdXd€/ >ÿÿÿÿÿÿkdìö@0 ÿÿÿÿÿÿudkd€1 ÿÿÿÿÿÿ~dadud€2 ÿÿÿÿÿÿˆdfc~d€3 >ÿÿÿÿÿÿ’d @4 ÿÿÿÿÿÿœd’d€5 >ÿÿÿÿÿÿ¥d@6 ÿÿÿÿÿÿ¯d¥d€7 ÿÿÿÿÿÿ¸dœd¯d€8 >ÿÿÿÿÿÿÂd@9 ÿÿÿÿÿÿÌdÂd€: ÿÿÿÿÿÿÕd¸dÌd€; >ÿÿÿÿÿÿßd(@< ÿÿÿÿÿÿédßd€= ÿÿÿÿÿÿòdÕdéd€> >ÿÿÿÿÿÿüd @? ÿÿÿÿÿÿeüd€@ ÿÿÿÿÿÿeòde€A >ÿÿÿÿÿÿe @B ÿÿÿÿÿÿ#ee€C ÿÿÿÿÿÿ,ee#e€D >ÿÿÿÿÿÿ6e (@E ÿÿÿÿÿÿ@e6e€F ÿÿÿÿÿÿIe,e@e€G >ÿÿÿÿÿÿSe@H ÿÿÿÿÿÿ]eSe€I ÿÿÿÿÿÿfeIe]e€J >ÿÿÿÿÿÿpe(@K ÿÿÿÿÿÿzepe€L ÿÿÿÿÿÿƒefeze€M >ÿÿÿÿÿÿe(@N ÿÿÿÿÿÿ—ee€O ÿÿÿÿÿÿ eƒe—e€P ÿÿÿÿÿÿªeˆd e€Q ÿÿÿÿÿÿ´e `ªe€R >ÿÿÿÿÿÿ¾e"@S ÿÿÿÿÿÿÈe¾e€T >ÿÿÿÿÿÿÑe4@U ÿÿÿÿÿÿÛeÑe€V ÿÿÿÿÿÿäeÈeÛe€W >ÿÿÿÿÿÿîeF@X ÿÿÿÿÿÿøeîe€Y ÿÿÿÿÿÿfäeøe€Z >ÿÿÿÿÿÿ fX@[ ÿÿÿÿÿÿf f€\ ÿÿÿÿÿÿfff€] >ÿÿÿÿÿÿ(f"4@^ ÿÿÿÿÿÿ2f(f€_ ÿÿÿÿÿÿ;ff2f€` >ÿÿÿÿÿÿEf"F@a ÿÿÿÿÿÿOfEf€b ÿÿÿÿÿÿXf;fOf€c >ÿÿÿÿÿÿbf"X@d ÿÿÿÿÿÿlfbf€e ÿÿÿÿÿÿufXflf€f >ÿÿÿÿÿÿf4F@g ÿÿÿÿÿÿ‰ff€h ÿÿÿÿÿÿ’fuf‰f€i >ÿÿÿÿÿÿœf4X@j ÿÿÿÿÿÿ¦fœf€k ÿÿÿÿÿÿ¯f’f¦f€l >ÿÿÿÿÿÿ¹fFX@m ÿÿÿÿÿÿÃf¹f€n ÿÿÿÿÿÿÌf¯fÃf€o ÿÿÿÿÿÿÖfÎú€p ÿÿÿÿÿÿàfÖf €q ÿÿÿÿÿÿêfàfV€r ÿÿÿÿÿÿôfP¾€s ÿÿÿÿÿÿþfôfú€t ÿÿÿÿÿÿgþfT€u ÿÿÿÿÿÿggþ€v ÿÿÿÿÿÿgg&€w ÿÿÿÿÿÿ&ggv€x ÿÿÿÿÿÿ0g&g €y ÿÿÿÿÿÿ:g0g„€z ÿÿÿÿÿÿDg:gÀ€{ ÿÿÿÿÿÿNgDgV€| ÿÿÿÿÿÿXgNgt€} ÿÿÿÿÿÿbgXg΀~ ÿÿÿÿÿÿlgbgP€ ÿÿÿÿÿÿvglgÈ€€ ÿÿÿÿÿÿ€gvg€ ÿÿÿÿÿÿŠg€g|€‚ ÿÿÿÿÿÿ”gŠg€ƒ ÿÿÿÿÿÿžg”gX€„ ÿÿÿÿÿÿ¨gžg”€… ÿÿÿÿÿÿ²g¨g* €† ÿÿÿÿÿÿ¼g²g˜ €‡ ÿÿÿÿÿÿÆg¼gÔ €ˆ ÿÿÿÿÿÿÐgÆg$ €‰ ÿÿÿÿÿÿÚgÐg~ @Š ÿÿÿÿÿÿägÚg€‹ ÿÿÿÿÿÿígg€Œ ÿÿÿÿÿÿ÷gíg”€ ÿÿÿÿÿÿh÷g €Ž ÿÿÿÿÿÿ hh„€ ÿÿÿÿÿÿh h¬€ ÿÿÿÿÿÿhhV€‘ ÿÿÿÿÿÿ)hht€’ ÿÿÿÿÿÿ3h)h΀“ ÿÿÿÿÿÿ=h3hP€” ÿÿÿÿÿÿGh=hÈ€• ÿÿÿÿÿÿQhGh€– ÿÿÿÿÿÿ[hQh¤€— ÿÿÿÿÿÿeh[hà€˜ ÿÿÿÿÿÿohehX€™ ÿÿÿÿÿÿyhohŠ€š ÿÿÿÿÿÿƒhyh* €› ÿÿÿÿÿÿhƒhR €œ ÿÿÿÿÿÿ—hhü € ÿÿÿÿÿÿ¡h—h$ €ž ÿÿÿÿÿÿ«h¡hœ @Ÿ ÿÿÿÿÿÿµh«h  ÿÿÿÿÿÿ¾hâ œm±"Ù"ž&Ò)Â*¬,q064¢6b?âAEFÀOzYjZ´eÌfêfägµh€¡ SÿÿÿÿÿÿÞhœ~€¢ >ÿÿÿÿÿÿèh<Þh€£ >ÿÿÿÿÿÿòhœê'€¤ Sÿÿÿÿÿÿühœ<€¥ >ÿÿÿÿÿÿi°üh€¦ Sÿÿÿÿÿÿiœ°€§ >ÿÿÿÿÿÿi~i€¨ Sÿÿÿÿÿÿ$i~œ€© >ÿÿÿÿÿÿ.i°$i€ª >ÿÿÿÿÿÿ8i~³-€« >ÿÿÿÿÿÿBi4|$€¬ SÿÿÿÿÿÿLi~<€­ >ÿÿÿÿÿÿViœLi€® Sÿÿÿÿÿÿ`i~°€¯ >ÿÿÿÿÿÿji<`i€° >ÿÿÿÿÿÿti~f@€± >ÿÿÿÿÿÿ~i4x1€² >ÿÿÿÿÿÿˆi°°€³ >ÿÿÿÿÿÿ’i<¿0€´ >ÿÿÿÿÿÿœiœ;2€µ Sÿÿÿÿÿÿ¦i<œ€¶ >ÿÿÿÿÿÿ°i<¦i€· Sÿÿÿÿÿÿºi<~€¸ >ÿÿÿÿÿÿÄiœºi€¹ >ÿÿÿÿÿÿÎi~_$€º SÿÿÿÿÿÿØi<°€» >ÿÿÿÿÿÿâi°Øi€¼ Sÿÿÿÿÿÿìi°œ€½ >ÿÿÿÿÿÿöiœìi€¾ Sÿÿÿÿÿÿj°~€¿ >ÿÿÿÿÿÿ j°j€À >ÿÿÿÿÿÿj<£$€Á Sÿÿÿÿÿÿj°<€Â >ÿÿÿÿÿÿ(j~j€Ã ÿÿÿÿÿÿ2j€.(j€Ä ÿÿÿÿÿÿÿÿÿÿÿÿ+k°2.€Ý >ÿÿÿÿÿÿ5k4ê'€Þ >ÿÿÿÿÿÿ?kœüh€ß >ÿÿÿÿÿÿIk<$i€à >ÿÿÿÿÿÿSkœ|$€á >ÿÿÿÿÿÿ]k4Li€â >ÿÿÿÿÿÿgk°`i€ã >ÿÿÿÿÿÿqk4¦i€ä >ÿÿÿÿÿÿ{k°ú,€å >ÿÿÿÿÿÿ…k<Øi€æ ÿÿÿÿÿÿkPj…k€ç ÿÿÿÿÿÿ™kk{k€è ÿÿÿÿÿÿ£k™kÎi€é ÿÿÿÿÿÿ­k£kÄi€ê ÿÿÿÿÿÿ·k­kqk€ë ÿÿÿÿÿÿÁk·kœi€ì ÿÿÿÿÿÿËkÁk’i€í ÿÿÿÿÿÿÕkËkˆi€î ÿÿÿÿÿÿßkÕk~i€ï ÿÿÿÿÿÿékßkti€ð ÿÿÿÿÿÿókékgk€ñ ÿÿÿÿÿÿýkók]k€ò ÿÿÿÿÿÿlýkSk€ó ÿÿÿÿÿÿll8i€ô ÿÿÿÿÿÿllIk€õ ÿÿÿÿÿÿ%lli€ö ÿÿÿÿÿÿ/l%l?k€÷ ÿÿÿÿÿÿ9l/l5k€ø ÿÿÿÿÿÿCl9lèh€ù ÿÿÿÿÿÿMlCl+k@ú ÿÿÿÿÿÿWl†Ù€û ÿÿÿÿÿÿ`lˆij€ü ÿÿÿÿÿÿjl`lÎi€ý ÿÿÿÿÿÿtljlœi€þ >ÿÿÿÿÿÿ~l~œ@ÿ ÿÿÿÿÿÿˆl~l€ >ÿÿÿÿÿÿ‘l<œ@ ÿÿÿÿÿÿ›l‘l€ ÿÿÿÿÿÿ¤lË\v€ ÿÿÿÿÿÿ®l¤l"]€ ÿÿÿÿÿÿ¸l®lkb€ ÿÿÿÿÿÿÂl¸lñ€ ÿÿÿÿÿÿÌlÂl¸\€ ÿÿÿÿÿÿÖlÌl›l€ ÿÿÿÿÿÿàlÖl'€ ÿÿÿÿÿÿêlàlú€ ÿÿÿÿÿÿôlêlˆl€ >ÿÿÿÿÿÿþl2.Þh@ ÿÿÿÿÿÿmþl€ >ÿÿÿÿÿÿmê'2.@ ÿÿÿÿÿÿmm€ >ÿÿÿÿÿÿ$mê'Þh@ ÿÿÿÿÿÿ.m$m€ >ÿÿÿÿÿÿ7m2.üh@ ÿÿÿÿÿÿAm7m€ >ÿÿÿÿÿÿJmÞhüh@ ÿÿÿÿÿÿTmJm€ >ÿÿÿÿÿÿ]mê'üh@ ÿÿÿÿÿÿgm]m€ >ÿÿÿÿÿÿpm2.i@ ÿÿÿÿÿÿzmpm€ >ÿÿÿÿÿÿƒmÞhi@ ÿÿÿÿÿÿmƒm€ >ÿÿÿÿÿÿ–mê'i@ ÿÿÿÿÿÿ m–m€ >ÿÿÿÿÿÿ©mühi@ ÿÿÿÿÿÿ³m©m€ ÿÿÿÿÿÿ¼m³m m€ ÿÿÿÿÿÿÆm¼mm€! ÿÿÿÿÿÿÐmÆmzm€" ÿÿÿÿÿÿÚmÐmgm€# ÿÿÿÿÿÿämÚmTm€$ ÿÿÿÿÿÿîmämAm€% ÿÿÿÿÿÿømîm.m€& ÿÿÿÿÿÿnømm€' ÿÿÿÿÿÿ nnm€( >ÿÿÿÿÿÿn³-$i@) ÿÿÿÿÿÿ nn€* >ÿÿÿÿÿÿ)n|$$i@+ ÿÿÿÿÿÿ3n)n€, >ÿÿÿÿÿÿÿÿÿÿÿÿOn$iLi@/ ÿÿÿÿÿÿYnOn€0 >ÿÿÿÿÿÿbn³-Li@1 ÿÿÿÿÿÿlnbn€2 >ÿÿÿÿÿÿun|$Li@3 ÿÿÿÿÿÿnun€4 >ÿÿÿÿÿÿˆn$i`i@5 ÿÿÿÿÿÿ’nˆn€6 >ÿÿÿÿÿÿ›n³-`i@7 ÿÿÿÿÿÿ¥n›n€8 >ÿÿÿÿÿÿ®n|$`i@9 ÿÿÿÿÿÿ¸n®n€: >ÿÿÿÿÿÿÁnLi`i@; ÿÿÿÿÿÿËnÁn€< ÿÿÿÿÿÿÔnËn¸n€= ÿÿÿÿÿÿÞnÔn¥n€> ÿÿÿÿÿÿènÞn’n€? ÿÿÿÿÿÿònènn€@ ÿÿÿÿÿÿünònln€A ÿÿÿÿÿÿoünYn€B ÿÿÿÿÿÿooFn€C ÿÿÿÿÿÿoo3n€D ÿÿÿÿÿÿ$oo n€E >ÿÿÿÿÿÿ.ox1f@@F ÿÿÿÿÿÿ8o.o€G >ÿÿÿÿÿÿAo°f@@H ÿÿÿÿÿÿKoAo€I >ÿÿÿÿÿÿTo°x1@J ÿÿÿÿÿÿ^oTo€K >ÿÿÿÿÿÿgo¿0f@@L ÿÿÿÿÿÿqogo€M >ÿÿÿÿÿÿzo¿0x1@N ÿÿÿÿÿÿ„ozo€O >ÿÿÿÿÿÿo°¿0@P ÿÿÿÿÿÿ—oo€Q >ÿÿÿÿÿÿ o;2f@@R ÿÿÿÿÿÿªo o€S >ÿÿÿÿÿÿ³ox1;2@T ÿÿÿÿÿÿ½o³o€U >ÿÿÿÿÿÿÆo°;2@V ÿÿÿÿÿÿÐoÆo€W >ÿÿÿÿÿÿÙo¿0;2@X ÿÿÿÿÿÿãoÙo€Y ÿÿÿÿÿÿìoãoÐo€Z ÿÿÿÿÿÿöoìo½o€[ ÿÿÿÿÿÿpöoªo€\ ÿÿÿÿÿÿ pp—o€] ÿÿÿÿÿÿp p„o€^ ÿÿÿÿÿÿppqo€_ ÿÿÿÿÿÿ(pp^o€` ÿÿÿÿÿÿ2p(pKo€a ÿÿÿÿÿÿÿÿÿÿÿÿFp¦iºi@c ÿÿÿÿÿÿPpFp€d >ÿÿÿÿÿÿYp_$¦i@e ÿÿÿÿÿÿcpYp€f >ÿÿÿÿÿÿlp_$ºi@g ÿÿÿÿÿÿvplp€h >ÿÿÿÿÿÿpú,¦i@i ÿÿÿÿÿÿ‰pp€j >ÿÿÿÿÿÿ’pú,ºi@k ÿÿÿÿÿÿœp’p€l >ÿÿÿÿÿÿ¥p_$ú,@m ÿÿÿÿÿÿ¯p¥p€n >ÿÿÿÿÿÿ¸p¦iØi@o ÿÿÿÿÿÿÂp¸p€p >ÿÿÿÿÿÿËpºiØi@q ÿÿÿÿÿÿÕpËp€r >ÿÿÿÿÿÿÞp_$Øi@s ÿÿÿÿÿÿèpÞp€t >ÿÿÿÿÿÿñpú,Øi@u ÿÿÿÿÿÿûpñp€v ÿÿÿÿÿÿqûpèp€w ÿÿÿÿÿÿqqÕp€x ÿÿÿÿÿÿqqÂp€y ÿÿÿÿÿÿ"qq¯p€z ÿÿÿÿÿÿ,q"qœp€{ ÿÿÿÿÿÿ6q,q‰p€| ÿÿÿÿÿÿ@q6qvp€} ÿÿÿÿÿÿJq@qcp€~ ÿÿÿÿÿÿTqJqPp€ >ÿÿÿÿÿÿ^qìij@€ ÿÿÿÿÿÿhq^q€ >ÿÿÿÿÿÿqq£$ìi@‚ ÿÿÿÿÿÿ{qqq€ƒ >ÿÿÿÿÿÿ„q£$j@„ ÿÿÿÿÿÿŽq„q€… >ÿÿÿÿÿÿ—qìij@† ÿÿÿÿÿÿ¡q—q€‡ >ÿÿÿÿÿÿªqjj@ˆ ÿÿÿÿÿÿ´qªq€‰ >ÿÿÿÿÿÿ½q£$j@Š ÿÿÿÿÿÿÇq½q€‹ >ÿÿÿÿÿÿÐqv.ìi@Œ ÿÿÿÿÿÿÚqÐq€ >ÿÿÿÿÿÿãqv.j@Ž ÿÿÿÿÿÿíqãq€ >ÿÿÿÿÿÿöq£$v.@ ÿÿÿÿÿÿröq€‘ >ÿÿÿÿÿÿ rv.j@’ ÿÿÿÿÿÿr r€“ ÿÿÿÿÿÿrrr€” ÿÿÿÿÿÿ&rríq€• ÿÿÿÿÿÿ0r&rÚq€– ÿÿÿÿÿÿ:r0rÇq€— ÿÿÿÿÿÿDr:r´q€˜ ÿÿÿÿÿÿNrDr¡q€™ ÿÿÿÿÿÿXrNrŽq€š ÿÿÿÿÿÿbrXr{q€› ÿÿÿÿÿÿlrbrhq€œ ÿÿÿÿÿÿvrlrTq€ ÿÿÿÿÿÿ€rvrÿÿÿÿÿÿžr2.$i@¡ ÿÿÿÿÿÿ¨ržr€¢ >ÿÿÿÿÿÿ±r2.f@@£ ÿÿÿÿÿÿ»r±r€¤ >ÿÿÿÿÿÿÄrf@$i@¥ ÿÿÿÿÿÿÎrÄr€¦ >ÿÿÿÿÿÿ×r2.¦i@§ ÿÿÿÿÿÿár×r€¨ >ÿÿÿÿÿÿêr$i¦i@© ÿÿÿÿÿÿôrêr€ª >ÿÿÿÿÿÿýrf@¦i@« ÿÿÿÿÿÿsýr€¬ >ÿÿÿÿÿÿs2.ìi@­ ÿÿÿÿÿÿss€® >ÿÿÿÿÿÿ#s$iìi@¯ ÿÿÿÿÿÿ-s#s€° >ÿÿÿÿÿÿ6sf@ìi@± ÿÿÿÿÿÿ@s6s€² >ÿÿÿÿÿÿIs¦iìi@³ ÿÿÿÿÿÿSsIs€´ ÿÿÿÿÿÿ\sSs@s€µ ÿÿÿÿÿÿfs\s-s€¶ ÿÿÿÿÿÿpsfss€· ÿÿÿÿÿÿzspss€¸ ÿÿÿÿÿÿ„szsôr€¹ ÿÿÿÿÿÿŽs„sár€º ÿÿÿÿÿÿ˜sŽsÎr€» ÿÿÿÿÿÿ¢s˜s»r€¼ ÿÿÿÿÿÿ¬s¢s¨r€½ >ÿÿÿÿÿÿ¶s³-Þh@¾ ÿÿÿÿÿÿÀs¶s€¿ >ÿÿÿÿÿÿÉsx1Þh@À ÿÿÿÿÿÿÓsÉs€Á >ÿÿÿÿÿÿÜs³-x1@ ÿÿÿÿÿÿæsÜs€Ã >ÿÿÿÿÿÿïsÞhºi@Ä ÿÿÿÿÿÿùsïs€Å >ÿÿÿÿÿÿt³-ºi@Æ ÿÿÿÿÿÿ tt€Ç >ÿÿÿÿÿÿtx1ºi@È ÿÿÿÿÿÿtt€É >ÿÿÿÿÿÿ(tÞhj@Ê ÿÿÿÿÿÿ2t(t€Ë >ÿÿÿÿÿÿ;t³-j@Ì ÿÿÿÿÿÿEt;t€Í >ÿÿÿÿÿÿNtx1j@Î ÿÿÿÿÿÿXtNt€Ï >ÿÿÿÿÿÿatºij@Ð ÿÿÿÿÿÿktat€Ñ ÿÿÿÿÿÿttktXt€Ò ÿÿÿÿÿÿ~tttEt€Ó ÿÿÿÿÿÿˆt~t2t€Ô ÿÿÿÿÿÿ’tˆtt€Õ ÿÿÿÿÿÿœt’t t€Ö ÿÿÿÿÿÿ¦tœtùs€× ÿÿÿÿÿÿ°t¦tæs€Ø ÿÿÿÿÿÿºt°tÓs€Ù ÿÿÿÿÿÿÄtºtÀs€Ú >ÿÿÿÿÿÿÎt|$ê'@Û ÿÿÿÿÿÿØtÎt€Ü >ÿÿÿÿÿÿát°ê'@Ý ÿÿÿÿÿÿëtát€Þ >ÿÿÿÿÿÿôt°|$@ß ÿÿÿÿÿÿþtôt€à >ÿÿÿÿÿÿu_$ê'@á ÿÿÿÿÿÿuu€â >ÿÿÿÿÿÿu_$|$@ã ÿÿÿÿÿÿ$uu€ä >ÿÿÿÿÿÿ-u°_$@å ÿÿÿÿÿÿ7u-u€æ >ÿÿÿÿÿÿ@u£$ê'@ç ÿÿÿÿÿÿJu@u€è >ÿÿÿÿÿÿSu|$£$@é ÿÿÿÿÿÿ]uSu€ê >ÿÿÿÿÿÿfu°£$@ë ÿÿÿÿÿÿpufu€ì >ÿÿÿÿÿÿyu_$£$@í ÿÿÿÿÿÿƒuyu€î ÿÿÿÿÿÿŒuƒupu€ï ÿÿÿÿÿÿ–uŒu]u€ð ÿÿÿÿÿÿ u–uJu€ñ ÿÿÿÿÿÿªu u7u€ò ÿÿÿÿÿÿ´uªu$u€ó ÿÿÿÿÿÿ¾u´uu€ô ÿÿÿÿÿÿÈu¾uþt€õ ÿÿÿÿÿÿÒuÈuët€ö ÿÿÿÿÿÿÜuÒuØt€÷ >ÿÿÿÿÿÿæuühLi@ø ÿÿÿÿÿÿðuæu€ù >ÿÿÿÿÿÿùu¿0üh@ú ÿÿÿÿÿÿvùu€û >ÿÿÿÿÿÿ v¿0Li@ü ÿÿÿÿÿÿv v€ý >ÿÿÿÿÿÿvú,üh@þ ÿÿÿÿÿÿ)vv€ÿ >ÿÿÿÿÿÿ2vú,Li@ ÿÿÿÿÿÿÿÿÿÿÿÿEvú,¿0@ ÿÿÿÿÿÿOvEv€ >ÿÿÿÿÿÿXvühj@ ÿÿÿÿÿÿbvXv€ >ÿÿÿÿÿÿkvLij@ ÿÿÿÿÿÿuvkv€ >ÿÿÿÿÿÿ~v¿0j@ ÿÿÿÿÿÿˆv~v€ >ÿÿÿÿÿÿ‘vú,j@ ÿÿÿÿÿÿ›v‘v€ ÿÿÿÿÿÿ¤v›vˆv€ ÿÿÿÿÿÿ®v¤vuv€ ÿÿÿÿÿÿ¸v®vbv€ ÿÿÿÿÿÿÂv¸vOv€ ÿÿÿÿÿÿÌvÂvÿÿÿÿÿÿþvi`i@ ÿÿÿÿÿÿwþv€ >ÿÿÿÿÿÿw;2i@ ÿÿÿÿÿÿww€ >ÿÿÿÿÿÿ$w;2`i@ ÿÿÿÿÿÿ.w$w€ >ÿÿÿÿÿÿ7wiØi@ ÿÿÿÿÿÿAw7w€ >ÿÿÿÿÿÿJw`iØi@ ÿÿÿÿÿÿTwJw€ >ÿÿÿÿÿÿ]w;2Øi@ ÿÿÿÿÿÿgw]w€ >ÿÿÿÿÿÿpwv.i@! ÿÿÿÿÿÿzwpw€" >ÿÿÿÿÿÿƒwv.`i@# ÿÿÿÿÿÿwƒw€$ >ÿÿÿÿÿÿ–wv.;2@% ÿÿÿÿÿÿ w–w€& >ÿÿÿÿÿÿ©wv.Øi@' ÿÿÿÿÿÿ³w©w€( ÿÿÿÿÿÿ¼w³w w€) ÿÿÿÿÿÿÆw¼ww€* ÿÿÿÿÿÿÐwÆwzw€+ ÿÿÿÿÿÿÚwÐwgw€, ÿÿÿÿÿÿäwÚwTw€- ÿÿÿÿÿÿîwäwAw€. ÿÿÿÿÿÿøwîw.w€/ ÿÿÿÿÿÿxøww€0 ÿÿÿÿÿÿ xxw€1 ÿÿÿÿÿÿx xôv€2 ÿÿÿÿÿÿ xxÜu€3 ÿÿÿÿÿÿ*x xÄt€4 ÿÿÿÿÿÿ4x*x¬s€5 ÿÿÿÿÿÿ>x4x”r€6 SÿÿÿÿÿÿHx2.œ€7 >ÿÿÿÿÿÿRxœHx@8 ÿÿÿÿÿÿ\xRx€9 Sÿÿÿÿÿÿex$i~€: >ÿÿÿÿÿÿoxœex@; ÿÿÿÿÿÿyxox€< Sÿÿÿÿÿÿ‚xf@4€= >ÿÿÿÿÿÿŒxœ‚x@> ÿÿÿÿÿÿ–xŒx€? SÿÿÿÿÿÿŸx¦i<€@ >ÿÿÿÿÿÿ©xœŸx@A ÿÿÿÿÿÿ³x©x€B Sÿÿÿÿÿÿ¼xìi°€C >ÿÿÿÿÿÿÆxœ¼x@D ÿÿÿÿÿÿÐxÆx€E ÿÿÿÿÿÿÙxÐx³x€F ÿÿÿÿÿÿãxÙx–x€G ÿÿÿÿÿÿíxãxyx€H ÿÿÿÿÿÿ÷xíx\x€I SÿÿÿÿÿÿyÞhœ€J >ÿÿÿÿÿÿ y~y@K ÿÿÿÿÿÿy y€L Sÿÿÿÿÿÿy³-~€M >ÿÿÿÿÿÿ(y~y@N ÿÿÿÿÿÿ2y(y€O Sÿÿÿÿÿÿ;yx14€P >ÿÿÿÿÿÿEy~;y@Q ÿÿÿÿÿÿOyEy€R SÿÿÿÿÿÿXyºi<€S >ÿÿÿÿÿÿby~Xy@T ÿÿÿÿÿÿlyby€U Sÿÿÿÿÿÿuyj°€V >ÿÿÿÿÿÿy~uy@W ÿÿÿÿÿÿ‰yy€X ÿÿÿÿÿÿ’y‰yly€Y ÿÿÿÿÿÿœy’yOy€Z ÿÿÿÿÿÿ¦yœy2y€[ ÿÿÿÿÿÿ°y¦yy€\ Sÿÿÿÿÿÿºyê'œ€] >ÿÿÿÿÿÿÄy4ºy@^ ÿÿÿÿÿÿÎyÄy€_ Sÿÿÿÿÿÿ×y|$~€` >ÿÿÿÿÿÿáy4×y@a ÿÿÿÿÿÿëyáy€b Sÿÿÿÿÿÿôy_$<€c >ÿÿÿÿÿÿþy4ôy@d ÿÿÿÿÿÿzþy€e Sÿÿÿÿÿÿz£$°€f >ÿÿÿÿÿÿz4z@g ÿÿÿÿÿÿ%zz€h ÿÿÿÿÿÿ.z%zz€i ÿÿÿÿÿÿ8z.z·$€j ÿÿÿÿÿÿBz8zëy€k ÿÿÿÿÿÿLzBzÎy€l SÿÿÿÿÿÿVzühœ€m >ÿÿÿÿÿÿ`z<Vz@n ÿÿÿÿÿÿjz`z€o SÿÿÿÿÿÿszLi~€p >ÿÿÿÿÿÿ}z<sz@q ÿÿÿÿÿÿ‡z}z€r Sÿÿÿÿÿÿz¿04€s >ÿÿÿÿÿÿšz<z@t ÿÿÿÿÿÿ¤zšz€u Sÿÿÿÿÿÿ­zú,<€v >ÿÿÿÿÿÿ·z<­z@w ÿÿÿÿÿÿÁz·z€x SÿÿÿÿÿÿÊzj°€y >ÿÿÿÿÿÿÔz<Êz@z ÿÿÿÿÿÿÞzÔz€{ ÿÿÿÿÿÿçzÞzÁz€| ÿÿÿÿÿÿñzçz¤z€} ÿÿÿÿÿÿûzñz‡z€~ ÿÿÿÿÿÿ{ûzjz€ Sÿÿÿÿÿÿ{iœ€€ >ÿÿÿÿÿÿ{°{@ ÿÿÿÿÿÿ#{{€‚ Sÿÿÿÿÿÿ,{`i~€ƒ >ÿÿÿÿÿÿ6{°,{@„ ÿÿÿÿÿÿ@{6{€… SÿÿÿÿÿÿI{;24€† >ÿÿÿÿÿÿS{°I{@‡ ÿÿÿÿÿÿ]{S{€ˆ Sÿÿÿÿÿÿf{Øi<€‰ >ÿÿÿÿÿÿp{°f{@Š ÿÿÿÿÿÿz{p{€‹ Sÿÿÿÿÿÿƒ{v.°€Œ >ÿÿÿÿÿÿ{°ƒ{@ ÿÿÿÿÿÿ—{{€Ž ÿÿÿÿÿÿ {—{z{€ ÿÿÿÿÿÿª{ {]{€ ÿÿÿÿÿÿ´{ª{@{€‘ ÿÿÿÿÿÿ¾{´{#{€’ ÿÿÿÿÿÿÈ{¾{{€“ ÿÿÿÿÿÿÒ{È{Lz€” ÿÿÿÿÿÿÜ{Ò{°y€• ÿÿÿÿÿÿæ{Ü{÷x€– >ÿÿÿÿÿÿð{œ2.@— ÿÿÿÿÿÿú{ð{€˜ ÿÿÿÿÿÿ|ð{ú{€™ >ÿÿÿÿÿÿ |~2.@š ÿÿÿÿÿÿ| |€› >ÿÿÿÿÿÿ |œÞh€œ ÿÿÿÿÿÿ*| ||€ ÿÿÿÿÿÿ4|òhg4€ž >ÿÿÿÿÿÿ>|<2.@Ÿ ÿÿÿÿÿÿH|>|€  ÿÿÿÿÿÿQ|?kH|@¡ ÿÿÿÿÿÿ[|+k€¢ >ÿÿÿÿÿÿd|œi€£ ÿÿÿÿÿÿn|d|[|€¤ ÿÿÿÿÿÿx|n|Q|€¥ ÿÿÿÿÿÿ‚|x|4|€¦ ÿÿÿÿÿÿŒ|‚|*|€§ ÿÿÿÿÿÿ–|Œ||€¨ >ÿÿÿÿÿÿ |œ$i@© ÿÿÿÿÿÿª| |€ª ÿÿÿÿÿÿ³| |ª|€« >ÿÿÿÿÿÿ½|~$i@¬ ÿÿÿÿÿÿÇ|½|€­ >ÿÿÿÿÿÿÐ|œ³-€® ÿÿÿÿÿÿÚ|Ð|Ç|€¯ >ÿÿÿÿÿÿä|4$i@° ÿÿÿÿÿÿî|ä|€± ÿÿÿÿÿÿ÷|Skî|@² ÿÿÿÿÿÿ}Ik€³ ÿÿÿÿÿÿ }Vi}@´ ÿÿÿÿÿÿ}.i€µ >ÿÿÿÿÿÿ}œ`i€¶ ÿÿÿÿÿÿ'}}}€· ÿÿÿÿÿÿ1}'} }€¸ ÿÿÿÿÿÿ;}1}÷|€¹ ÿÿÿÿÿÿE};}Ú|€º ÿÿÿÿÿÿO}E}³|€» >ÿÿÿÿÿÿY}œf@@¼ ÿÿÿÿÿÿc}Y}€½ ÿÿÿÿÿÿl}Y}c}@¾ ÿÿÿÿÿÿv}ti€¿ >ÿÿÿÿÿÿ}œx1€À ÿÿÿÿÿÿ‰}}v}€Á >ÿÿÿÿÿÿ“}4f@@ ÿÿÿÿÿÿ}“}€Ã ÿÿÿÿÿÿ¦}ab}€Ä >ÿÿÿÿÿÿ°}<f@@Å ÿÿÿÿÿÿº}°}€Æ >ÿÿÿÿÿÿÃ}œ¿0€Ç ÿÿÿÿÿÿÍ}Ã}º}€È ÿÿÿÿÿÿ×}œiKo€É ÿÿÿÿÿÿá}×}Í}€Ê ÿÿÿÿÿÿë}á}¦}€Ë ÿÿÿÿÿÿõ}ë}‰}€Ì ÿÿÿÿÿÿÿ}õ}l}€Í >ÿÿÿÿÿÿ ~œ¦i@Î ÿÿÿÿÿÿ~ ~€Ï ÿÿÿÿÿÿ~ ~~€Ð >ÿÿÿÿÿÿ&~~¦i@Ñ ÿÿÿÿÿÿ0~&~€Ò ÿÿÿÿÿÿ9~Äi0~@Ó ÿÿÿÿÿÿC~qk€Ô >ÿÿÿÿÿÿL~œ_$€Õ ÿÿÿÿÿÿV~L~C~@Ö ÿÿÿÿÿÿ`~°i€× >ÿÿÿÿÿÿi~œú,€Ø ÿÿÿÿÿÿs~i~`~€Ù >ÿÿÿÿÿÿ}~°¦i@Ú ÿÿÿÿÿÿ‡~}~€Û >ÿÿÿÿÿÿ~œØi€Ü ÿÿÿÿÿÿš~~‡~€Ý ÿÿÿÿÿÿ¤~š~s~€Þ ÿÿÿÿÿÿ®~¤~V~€ß ÿÿÿÿÿÿ¸~®~9~€à ÿÿÿÿÿÿÂ~¸~~@á ÿÿÿÿÿÿÌ~öi€â ÿÿÿÿÿÿÕ~öiÌ~€ã >ÿÿÿÿÿÿß~~ìi@ä ÿÿÿÿÿÿé~ß~€å >ÿÿÿÿÿÿò~œj€æ ÿÿÿÿÿÿü~ò~é~€ç >ÿÿÿÿÿÿ4ìi@è ÿÿÿÿÿÿ€é >ÿÿÿÿÿÿœ£$€ê ÿÿÿÿÿÿ#€ë >ÿÿÿÿÿÿ-<ìi@ì ÿÿÿÿÿÿ7-€í >ÿÿÿÿÿÿ@œj€î ÿÿÿÿÿÿJ@7€ï >ÿÿÿÿÿÿT°ìi@ð ÿÿÿÿÿÿ^T€ñ >ÿÿÿÿÿÿgœv.€ò ÿÿÿÿÿÿqg^€ó ÿÿÿÿÿÿ{qJ€ô ÿÿÿÿÿÿ…{#€õ ÿÿÿÿÿÿ…ü~€ö ÿÿÿÿÿÿ™Õ~€÷ ÿÿÿÿÿÿ£™Â~€ø ÿÿÿÿÿÿ­£ÿ}€ù ÿÿÿÿÿÿ·­O}€ú ÿÿÿÿÿÿÁ·–|@û ÿÿÿÿÿÿË |€ü ÿÿÿÿÿÿÔ |Ë€ý >ÿÿÿÿÿÿÞ~Þh@þ ÿÿÿÿÿÿèÞ€ÿ ÿÿÿÿÿÿñÞè€ >ÿÿÿÿÿÿû4Þh@ ÿÿÿÿÿÿ€û€ >ÿÿÿÿÿÿ€~ê'€ ÿÿÿÿÿÿ€€€@ ÿÿÿÿÿÿ"€èh€ >ÿÿÿÿÿÿ+€~üh€ ÿÿÿÿÿÿ5€+€"€€ >ÿÿÿÿÿÿ?€°Þh@ ÿÿÿÿÿÿI€?€€ ÿÿÿÿÿÿR€iI€€ ÿÿÿÿÿÿ\€R€5€€ ÿÿÿÿÿÿf€\€€€ ÿÿÿÿÿÿp€f€ñ€ ÿÿÿÿÿÿz€p€Ô@ ÿÿÿÿÿÿ„€Ð|€ ÿÿÿÿÿÿ€½|„€@ ÿÿÿÿÿÿ—€8i€ ÿÿÿÿÿÿ €8i—€€ >ÿÿÿÿÿÿª€~|$€ ÿÿÿÿÿÿ´€ª€Ç-€ >ÿÿÿÿÿÿ¾€<³-@ ÿÿÿÿÿÿÈ€¾€€ >ÿÿÿÿÿÿÑ€~Li€ ÿÿÿÿÿÿۀрȀ€ >ÿÿÿÿÿÿ倰³-@ ÿÿÿÿÿÿï€å€€ >ÿÿÿÿÿÿø€~`i€ ÿÿÿÿÿÿø€ï€€ ÿÿÿÿÿÿ Û€€ ÿÿÿÿÿÿ ´€€ ÿÿÿÿÿÿ  €€ ÿÿÿÿÿÿ* €@ ÿÿÿÿÿÿ4}€! ÿÿÿÿÿÿ=ti4€" >ÿÿÿÿÿÿG~x1@# ÿÿÿÿÿÿQG€$ ÿÿÿÿÿÿZGQ@% ÿÿÿÿÿÿd~i€& ÿÿÿÿÿÿm]d€' >ÿÿÿÿÿÿw<x1@( ÿÿÿÿÿÿw€) >ÿÿÿÿÿÿŠ~¿0€* ÿÿÿÿÿÿ”Š€+ >ÿÿÿÿÿÿž~;2€, ÿÿÿÿÿÿ¨ž^o€- ÿÿÿÿÿÿ²¨”€. ÿÿÿÿÿÿ¼²m€/ ÿÿÿÿÿÿƼZ€0 ÿÿÿÿÿÿÐÆ=@1 ÿÿÿÿÿÿÚÄi€2 ÿÿÿÿÿÿã&~Ú€3 >ÿÿÿÿÿÿí~ºi@4 ÿÿÿÿÿÿ÷í€5 ÿÿÿÿÿÿ‚í÷€6 >ÿÿÿÿÿÿ ‚4ºi@7 ÿÿÿÿÿÿ‚ ‚€8 ÿÿÿÿÿÿ‚Îi‚€9 >ÿÿÿÿÿÿ'‚<ºi@: ÿÿÿÿÿÿ1‚'‚€; >ÿÿÿÿÿÿ:‚~ú,€< ÿÿÿÿÿÿD‚:‚1‚€= >ÿÿÿÿÿÿN‚°ºi@> ÿÿÿÿÿÿX‚N‚€? >ÿÿÿÿÿÿa‚~Øi€@ ÿÿÿÿÿÿk‚a‚X‚€A ÿÿÿÿÿÿu‚k‚D‚€B ÿÿÿÿÿÿ‚u‚‚€C ÿÿÿÿÿÿ‰‚‚‚€D ÿÿÿÿÿÿ“‚‰‚ã@E ÿÿÿÿÿÿ‚ò~€F ÿÿÿÿÿÿ¦‚ß~‚€G >ÿÿÿÿÿÿ°‚~j@H ÿÿÿÿÿÿº‚°‚€I ÿÿÿÿÿÿ°‚º‚€J >ÿÿÿÿÿÿÍ‚4j@K ÿÿÿÿÿÿׂ͂€L >ÿÿÿÿÿÿà‚~£$€M ÿÿÿÿÿÿê‚à‚ׂ€N >ÿÿÿÿÿÿô‚<j@O ÿÿÿÿÿÿþ‚ô‚€P ÿÿÿÿÿÿƒ(jþ‚@Q ÿÿÿÿÿÿƒ j€R >ÿÿÿÿÿÿƒ~v.€S ÿÿÿÿÿÿ$ƒƒƒ€T ÿÿÿÿÿÿ.ƒ$ƒƒ€U ÿÿÿÿÿÿ8ƒ.ƒê‚€V ÿÿÿÿÿÿBƒ8ƒÃ‚€W ÿÿÿÿÿÿLƒBƒ¦‚€X ÿÿÿÿÿÿVƒLƒ“‚€Y ÿÿÿÿÿÿ`ƒVƒÐ€Z ÿÿÿÿÿÿjƒ`ƒ*€[ ÿÿÿÿÿÿtƒjƒz€@\ ÿÿÿÿÿÿ~ƒòh€] ÿÿÿÿÿÿ‡ƒ]4~ƒ@^ ÿÿÿÿÿÿ‘ƒ€€_ ÿÿÿÿÿÿšƒû‘ƒ@` ÿÿÿÿÿÿ¤ƒ5k€a ÿÿÿÿÿÿ­ƒ5k¤ƒ€b >ÿÿÿÿÿÿ·ƒ<ê'@c ÿÿÿÿÿÿÁƒ·ƒ€d >ÿÿÿÿÿÿʃ4üh€e ÿÿÿÿÿÿԃʃÁƒ€f >ÿÿÿÿÿÿÞƒ4i€g ÿÿÿÿÿÿèƒÞƒët€h ÿÿÿÿÿÿòƒèƒÔƒ€i ÿÿÿÿÿÿüƒòƒ­ƒ€j ÿÿÿÿÿÿ„üƒšƒ€k ÿÿÿÿÿÿ„„‡ƒ@l ÿÿÿÿÿÿ„Sk€m ÿÿÿÿÿÿ#„ä|„@n ÿÿÿÿÿÿ-„ª€€o ÿÿÿÿÿÿ6„½--„@p ÿÿÿÿÿÿ@„Bi€q ÿÿÿÿÿÿI„Bi@„€r >ÿÿÿÿÿÿS„<|$@s ÿÿÿÿÿÿ]„S„€t ÿÿÿÿÿÿf„]k]„€u >ÿÿÿÿÿÿp„4`i€v ÿÿÿÿÿÿz„p„þt€w ÿÿÿÿÿÿ„„z„f„€x ÿÿÿÿÿÿŽ„„„I„€y ÿÿÿÿÿÿ˜„Ž„6„€z ÿÿÿÿÿÿ¢„˜„#„€{ ÿÿÿÿÿÿ¬„“}kb€| ÿÿÿÿÿÿ¶„~i"]€} >ÿÿÿÿÿÿÀ„4¿0€~ ÿÿÿÿÿÿÊ„À„Ë\@ ÿÿÿÿÿÿÔ„€€ ÿÿÿÿÿÿÝ„E2€ ÿÿÿÿÿÿç„Ý„Ê„€‚ ÿÿÿÿÿÿñ„ç„„T€ƒ ÿÿÿÿÿÿû„ñ„¶„€„ ÿÿÿÿÿÿ…û„¬„@… ÿÿÿÿÿÿ…L~€† ÿÿÿÿÿÿ…qk…@‡ ÿÿÿÿÿÿ"…Îi€ˆ ÿÿÿÿÿÿ+… ‚"…€‰ >ÿÿÿÿÿÿ5…4_$@Š ÿÿÿÿÿÿ?…5…€‹ ÿÿÿÿÿÿH…5…?…€Œ >ÿÿÿÿÿÿR…<_$@ ÿÿÿÿÿÿ\…R…€Ž ÿÿÿÿÿÿe…-\…€ >ÿÿÿÿÿÿo…4Øi€ ÿÿÿÿÿÿy…o…7u€‘ ÿÿÿÿÿÿƒ…y…e…€’ ÿÿÿÿÿÿ…ƒ…H…€“ ÿÿÿÿÿÿ—……+…€” ÿÿÿÿÿÿ¡…—……@• ÿÿÿÿÿÿ«…€– ÿÿÿÿÿÿ´…«…@— ÿÿÿÿÿÿ¾…à‚€˜ ÿÿÿÿÿÿÇ…Í‚¾…€™ ÿÿÿÿÿÿÑ…­$·$@š ÿÿÿÿÿÿÛ…j€› >ÿÿÿÿÿÿä…4j€œ ÿÿÿÿÿÿî…ä…Û…€ ÿÿÿÿÿÿø…€.pu€ž ÿÿÿÿÿÿ†ø…î…€Ÿ ÿÿÿÿÿÿ ††Ñ…€  ÿÿÿÿÿÿ† †Ç…€¡ ÿÿÿÿÿÿ ††´…€¢ ÿÿÿÿÿÿ*† †¡…€£ ÿÿÿÿÿÿ4†*†…€¤ ÿÿÿÿÿÿ>†4†¢„€¥ ÿÿÿÿÿÿH†>†„@¦ ÿÿÿÿÿÿR†?k€§ ÿÿÿÿÿÿ[†>|R†@¨ ÿÿÿÿÿÿe†+€€© ÿÿÿÿÿÿn†èhe†@ª ÿÿÿÿÿÿx†Êƒ€« ÿÿÿÿÿÿ†·ƒx†€¬ >ÿÿÿÿÿÿ‹†<üh@­ ÿÿÿÿÿÿ•†‹†€® ÿÿÿÿÿÿž†‹†•†@¯ ÿÿÿÿÿÿ¨†i€° >ÿÿÿÿÿÿ±†<i€± ÿÿÿÿÿÿ»†±†¨†€² ÿÿÿÿÿÿņ»†ž†€³ ÿÿÿÿÿÿφņ†€´ ÿÿÿÿÿÿنφn†€µ ÿÿÿÿÿÿã†Ù†[†@¶ ÿÿÿÿÿÿí†Vi€· ÿÿÿÿÿÿö†Ikí†@¸ ÿÿÿÿÿÿ‡Ñ€€¹ ÿÿÿÿÿÿ ‡¾€‡@º ÿÿÿÿÿÿ‡]k€» ÿÿÿÿÿÿ‡S„‡€¼ >ÿÿÿÿÿÿ&‡<Li@½ ÿÿÿÿÿÿ0‡&‡€¾ ÿÿÿÿÿÿ9‡&‡0‡€¿ >ÿÿÿÿÿÿC‡°Li@À ÿÿÿÿÿÿM‡C‡€Á ÿÿÿÿÿÿV‡jiM‡€Â ÿÿÿÿÿÿ`‡V‡9‡€Ã ÿÿÿÿÿÿj‡`‡‡€Ä ÿÿÿÿÿÿt‡j‡ ‡€Å ÿÿÿÿÿÿ~‡t‡ö†@Æ ÿÿÿÿÿÿˆ‡Ã}€Ç ÿÿÿÿÿÿ‘‡°}ˆ‡@È ÿÿÿÿÿÿ›‡Š€É ÿÿÿÿÿÿ¤‡w›‡@Ê ÿÿÿÿÿÿ®‡À„€Ë ÿÿÿÿÿÿ·‡Á\®‡@Ì ÿÿÿÿÿÿÁ‡’i€Í ÿÿÿÿÿÿʇ’iÁ‡€Î >ÿÿÿÿÿÿÔ‡<;2€Ï ÿÿÿÿÿÿÞ‡Ô‡—o€Ð ÿÿÿÿÿÿè‡Þ‡Ê‡€Ñ ÿÿÿÿÿÿò‡è‡·‡€Ò ÿÿÿÿÿÿü‡ò‡¤‡€Ó ÿÿÿÿÿÿˆü‡‘‡@Ô ÿÿÿÿÿÿˆi~€Õ ÿÿÿÿÿÿˆ°iˆ@Ö ÿÿÿÿÿÿ#ˆ:‚€× ÿÿÿÿÿÿ,ˆ'‚#ˆ€Ø ÿÿÿÿÿÿ6ˆR…-€Ù >ÿÿÿÿÿÿ@ˆ<ú,@Ú ÿÿÿÿÿÿJˆ@ˆ€Û ÿÿÿÿÿÿSˆ@ˆJˆ@Ü ÿÿÿÿÿÿ]ˆ{k€Ý ÿÿÿÿÿÿfˆ…k]ˆ€Þ ÿÿÿÿÿÿpˆfˆSˆ€ß ÿÿÿÿÿÿzˆpˆ6ˆ€à ÿÿÿÿÿÿ„ˆzˆ,ˆ€á ÿÿÿÿÿÿŽˆ„ˆˆ@â ÿÿÿÿÿÿ˜ˆ@€ã ÿÿÿÿÿÿ¡ˆ-˜ˆ@ä ÿÿÿÿÿÿ«ˆ(j€å ÿÿÿÿÿÿ´ˆô‚«ˆ@æ ÿÿÿÿÿÿ¾ˆä…€ç ÿÿÿÿÿÿLjj¾ˆ€è >ÿÿÿÿÿÿш<j@é ÿÿÿÿÿÿۈш€ê ÿÿÿÿÿÿäˆÑˆÛˆ€ë >ÿÿÿÿÿÿj@ì ÿÿÿÿÿÿøˆîˆ€í >ÿÿÿÿÿÿ‰<v.€î ÿÿÿÿÿÿ ‰‰øˆ€ï ÿÿÿÿÿÿ‰ ‰äˆ€ð ÿÿÿÿÿÿ‰‰Çˆ€ñ ÿÿÿÿÿÿ)‰‰´ˆ€ò ÿÿÿÿÿÿ3‰)‰¡ˆ€ó ÿÿÿÿÿÿ=‰3‰Žˆ€ô ÿÿÿÿÿÿG‰=‰ˆ€õ ÿÿÿÿÿÿQ‰G‰~‡€ö ÿÿÿÿÿÿ[‰Q‰ã†@÷ ÿÿÿÿÿÿe‰d|€ø ÿÿÿÿÿÿn‰+ke‰@ù ÿÿÿÿÿÿx‰i€ú ÿÿÿÿÿÿ‰?€x‰@û ÿÿÿÿÿÿ‹‰Þƒ€ü ÿÿÿÿÿÿ”‰át‹‰@ý ÿÿÿÿÿÿž‰±†€þ ÿÿÿÿÿÿ§‰iž‰€ÿ >ÿÿÿÿÿÿ±‰°i@ÿÿÿÿÿÿ»‰±‰€ÿÿÿÿÿÿĉ±‰»‰€ÿÿÿÿÿÿΉĉ§‰€ÿÿÿÿÿÿ؉Ή”‰€ÿÿÿÿÿÿâ‰Ø‰‰€ÿÿÿÿÿÿì‰â‰n‰@ÿÿÿÿÿÿö‰}€ÿÿÿÿÿÿÿ‰.iö‰@ÿÿÿÿÿÿ Šø€€ ÿÿÿÿÿÿŠå€ Š@ ÿÿÿÿÿÿŠp„€ ÿÿÿÿÿÿ%ŠôtŠ@ ÿÿÿÿÿÿ/Šji€ ÿÿÿÿÿÿ8ŠC‡/Š@ÿÿÿÿÿÿBŠgk€ÿÿÿÿÿÿKŠgkBŠ€ÿÿÿÿÿÿUŠKŠ8Š€ÿÿÿÿÿÿ_ŠUŠ%Š€ÿÿÿÿÿÿiŠ_ŠŠ€ÿÿÿÿÿÿsŠiŠÿ‰@ÿÿÿÿÿÿ}Šœi€ÿÿÿÿÿÿ†ŠAo}Š@ÿÿÿÿÿÿŠž€ÿÿÿÿÿÿ™ŠToŠ€ÿÿÿÿÿÿ£ŠO2@ÿÿÿÿÿÿ­ŠÔ‡€ÿÿÿÿÿÿ¶Šo­Š€ÿÿÿÿÿÿÀŠÆoÐo€ÿÿÿÿÿÿÊŠÀŠ¶Š€ÿÿÿÿÿÿÔŠÊŠ£Š€ÿÿÿÿÿÿÞŠÔŠ™Š€ÿÿÿÿÿÿèŠÞŠ†Š@ ÿÿÿÿÿÿòŠ~€!ÿÿÿÿÿÿûŠ}~òŠ@"ÿÿÿÿÿÿ‹a‚€#ÿÿÿÿÿÿ‹N‚‹@$ÿÿÿÿÿÿ‹o…€%ÿÿÿÿÿÿ!‹-u‹@&ÿÿÿÿÿÿ+‹…k€'ÿÿÿÿÿÿ4‹{k+‹@(ÿÿÿÿÿÿ>‹âi€)ÿÿÿÿÿÿG‹âi>‹€*ÿÿÿÿÿÿQ‹G‹4‹€+ÿÿÿÿÿÿ[‹Q‹!‹€,ÿÿÿÿÿÿe‹[‹‹€-ÿÿÿÿÿÿo‹e‹ûŠ@.ÿÿÿÿÿÿy‹g€/ÿÿÿÿÿÿ‚‹Ty‹@0ÿÿÿÿÿÿŒ‹ƒ€1ÿÿÿÿÿÿ•‹ jŒ‹€2ÿÿÿÿÿÿŸ‹fuŠ.@3ÿÿÿÿÿÿ©‹‰€4ÿÿÿÿÿÿ²‹îˆ©‹€5>ÿÿÿÿÿÿ¼‹°v.@6ÿÿÿÿÿÿÆ‹¼‹€7ÿÿÿÿÿÿÏ‹¼‹Æ‹€8ÿÿÿÿÿÿÙ‹Ï‹²‹€9ÿÿÿÿÿÿã‹Ù‹Ÿ‹€:ÿÿÿÿÿÿí‹ã‹•‹€;ÿÿÿÿÿÿ÷‹í‹‚‹€<ÿÿÿÿÿÿŒ÷‹o‹€=ÿÿÿÿÿÿ ŒŒèŠ€>ÿÿÿÿÿÿŒ ŒsŠ€?ÿÿÿÿÿÿŒŒì‰€@ÿÿÿÿÿÿ)ŒŒ[‰€Aÿÿÿÿÿÿ3Œ)ŒH†€Bÿÿÿÿÿÿ=Œ3Œtƒ€CÿÿÿÿÿÿGŒ=ŒÁ€DÿÿÿÿÿÿQŒú{ð{€Eÿÿÿÿÿÿ[ŒË |€FÿÿÿÿÿÿeŒ~ƒY}€GÿÿÿÿÿÿoŒR† ~€HÿÿÿÿÿÿyŒe‰öi€IÿÿÿÿÿÿƒŒyŒoŒ€JÿÿÿÿÿÿŒƒŒeŒ€Kÿÿÿÿÿÿ—ŒŒ[Œ€Lÿÿÿÿÿÿ¡Œ—ŒQŒ€Mÿÿÿÿÿÿ«Œª| |€NÿÿÿÿÿÿµŒ„€Ð|€Oÿÿÿÿÿÿ¿Œ„}€PÿÿÿÿÿÿÉŒí†Äi€QÿÿÿÿÿÿÓŒö‰ò~€Rÿÿÿÿÿÿ݌ӌɌ€SÿÿÿÿÿÿçŒÝŒ¿Œ€TÿÿÿÿÿÿñŒçŒµŒ€UÿÿÿÿÿÿûŒñŒ«Œ€Vÿÿÿÿÿÿc}òh€Wÿÿÿÿÿÿ4Sk€Xÿÿÿÿÿÿkbab€Yÿÿÿÿÿÿ#ˆ‡L~€Zÿÿÿÿÿÿ-}Š€[ÿÿÿÿÿÿ7-#€\ÿÿÿÿÿÿA7€]ÿÿÿÿÿÿKA€^ÿÿÿÿÿÿUK€_ÿÿÿÿÿÿ_~?k€`ÿÿÿÿÿÿiÚVi€aÿÿÿÿÿÿs…Ã}€bÿÿÿÿÿÿ}ˆi~€cÿÿÿÿÿÿ‡òŠ@€dÿÿÿÿÿÿ‘‡}€eÿÿÿÿÿÿ›‘s€fÿÿÿÿÿÿ¥›i€gÿÿÿÿÿÿ¯¥_€hÿÿÿÿÿÿ¹Ì~d|€iÿÿÿÿÿÿÂ}€jÿÿÿÿÿÿÍ«…œi€kÿÿÿÿÿÿטˆ~€lÿÿÿÿÿÿáy‹g€mÿÿÿÿÿÿëá×€nÿÿÿÿÿÿõëÍ€oÿÿÿÿÿÿÿõÀpÿÿÿÿÿÿ Žÿ¹€qÿÿÿÿÿÿŽ Ž¯€rÿÿÿÿÿÿŽŽU€sÿÿÿÿÿÿ'ŽŽûŒ€tÿÿÿÿÿÿ1Ž'Ž¡Œ€uÿÿÿÿÿÿ;Ž| |€vÿÿÿÿÿÿEŽè½|€wÿÿÿÿÿÿOŽ‘ƒti€xÿÿÿÿÿÿYŽe†&~€yÿÿÿÿÿÿcŽx‰ß~€zÿÿÿÿÿÿmŽcŽYŽ€{ÿÿÿÿÿÿwŽmŽOŽ€|ÿÿÿÿÿÿŽwŽEŽ€}ÿÿÿÿÿÿ‹ŽŽ;Ž€~ÿÿÿÿÿÿ•ŽÇ|Þ€ÿÿÿÿÿÿŸŽ—€8i€€ÿÿÿÿÿÿ©Ž-„G€ÿÿÿÿÿÿ³Ž‡í€‚ÿÿÿÿÿÿ½Ž Š°‚€ƒÿÿÿÿÿÿÇŽ½Ž³Ž€„ÿÿÿÿÿÿÑŽÇŽ©Ž€…ÿÿÿÿÿÿÛŽÑŽŸŽ€†ÿÿÿÿÿÿåŽÛŽ•Ž€‡ÿÿÿÿÿÿïŽv}€€ˆÿÿÿÿÿÿùŽQª€€‰ÿÿÿÿÿÿ"]]€Šÿÿÿÿÿÿ ›‡Îi€‹ÿÿÿÿÿÿŠà‚€Œÿÿÿÿÿÿ! €ÿÿÿÿÿÿ+!€Žÿÿÿÿÿÿ5+ùŽ€ÿÿÿÿÿÿ?5ÿÿÿÿÿÿI0~+€€‘ÿÿÿÿÿÿS÷Ñ€€’ÿÿÿÿÿÿ]"…Š€“ÿÿÿÿÿÿg#ˆ:‚€”ÿÿÿÿÿÿq‹(j€•ÿÿÿÿÿÿ{qg€–ÿÿÿÿÿÿ…{]€—ÿÿÿÿÿÿ…S€˜ÿÿÿÿÿÿ™I€™ÿÿÿÿÿÿ£é~i€šÿÿÿÿÿÿ­º‚ø€€›ÿÿÿÿÿÿ·¾…ž€œÿÿÿÿÿÿÁ«ˆa‚€ÿÿÿÿÿÿËŒ‹ƒ€žÿÿÿÿÿÿÕËÁ€ŸÿÿÿÿÿÿßÕ·€ ÿÿÿÿÿÿéß­€¡ÿÿÿÿÿÿó飀¢ÿÿÿÿÿÿý󙀣ÿÿÿÿÿÿý?€¤ÿÿÿÿÿÿ厀¥ÿÿÿÿÿÿ‹Ž€¦ÿÿÿÿÿÿ%g4]4€§ÿÿÿÿÿÿ/€ä|€¨ÿÿÿÿÿÿ9¤ƒ“}€©ÿÿÿÿÿÿCx†qk€ªÿÿÿÿÿÿM‹‰€«ÿÿÿÿÿÿWMC€¬ÿÿÿÿÿÿaW9€­ÿÿÿÿÿÿka/€®ÿÿÿÿÿÿuk%€¯ÿÿÿÿÿÿî|û€°ÿÿÿÿÿÿ‰Ç-½-€±ÿÿÿÿÿÿ“@„~i€²ÿÿÿÿÿÿ‡ ‚€³ÿÿÿÿÿÿ§ŠÍ‚€´ÿÿÿÿÿÿ±§€µÿÿÿÿÿÿ»±“€¶ÿÿÿÿÿÿÅ»‰€·ÿÿÿÿÿÿÏÅ€¸ÿÿÿÿÿÿÙ}5k€¹ÿÿÿÿÿÿãdBi€ºÿÿÿÿÿÿí®‡5…€»ÿÿÿÿÿÿ÷O2­$€¼ÿÿÿÿÿÿ‘÷퀽ÿÿÿÿÿÿ ‘‘ÊJ€¾ÿÿÿÿÿÿ‘ ‘〿ÿÿÿÿÿÿ‘‘Ù€Àÿÿÿÿÿÿ)‘C~ʃ€Áÿÿÿÿÿÿ3‘‚]k€Âÿÿÿÿÿÿ=‘?…À„€ÃÿÿÿÿÿÿG‘--€ÄÿÿÿÿÿÿQ‘‹ä…€Åÿÿÿÿÿÿ[‘Q‘G‘€Æÿÿÿÿÿÿe‘[‘=‘€Çÿÿÿÿÿÿo‘e‘3‘€Èÿÿÿÿÿÿy‘o‘)‘€Éÿÿÿÿÿÿƒ‘Þƒ€Êÿÿÿÿÿÿ‘ׂp„€Ëÿÿÿÿÿÿ—‘·$E2€Ìÿÿÿÿÿÿ¡‘¾ˆo…€Íÿÿÿÿÿÿ«‘Š.€.€Îÿÿÿÿÿÿµ‘«‘¡‘€Ïÿÿÿÿÿÿ¿‘µ‘—‘€ÐÿÿÿÿÿÿÉ‘¿‘‘€ÑÿÿÿÿÿÿÓ‘É‘ƒ‘€ÒÿÿÿÿÿÿÝ‘Ó‘y‘€Óÿÿÿÿÿÿç‘Ý‘‘€Ôÿÿÿÿÿÿñ‘ç‘Ï€Õÿÿÿÿÿÿû‘ñ‘u€Öÿÿÿÿÿÿ’H|>|€×ÿÿÿÿÿÿ’"€Ik€Øÿÿÿÿÿÿ’Áƒ°}€Ùÿÿÿÿÿÿ#’•†°i€Úÿÿÿÿÿÿ-’ž‰-€Ûÿÿÿÿÿÿ7’-’#’€ÜÿÿÿÿÿÿA’7’’€ÝÿÿÿÿÿÿK’A’’€ÞÿÿÿÿÿÿU’K’’€ßÿÿÿÿÿÿ_’}èh€àÿÿÿÿÿÿi’È€¾€€áÿÿÿÿÿÿs’]„w€âÿÿÿÿÿÿ}’0‡'‚€ãÿÿÿÿÿÿ‡’/Šô‚€äÿÿÿÿÿÿ‘’‡’}’€åÿÿÿÿÿÿ›’‘’s’€æÿÿÿÿÿÿ¥’›’i’€çÿÿÿÿÿÿ¯’¥’_’€èÿÿÿÿÿÿ¹’º}·ƒ€éÿÿÿÿÿÿÃ’S„€êÿÿÿÿÿÿÍ’Ë\Á\€ëÿÿÿÿÿÿ×’Á‡R…€ìÿÿÿÿÿÿá’­Šj€íÿÿÿÿÿÿë’á’×’€îÿÿÿÿÿÿõ’ë’Í’€ïÿÿÿÿÿÿÿ’õ’Ã’€ðÿÿÿÿÿÿ “ÿ’¹’€ñÿÿÿÿÿÿ“`~‹†€òÿÿÿÿÿÿ“1‚&‡€óÿÿÿÿÿÿ'“\…’i€ôÿÿÿÿÿÿ1“Jˆ@ˆ€õÿÿÿÿÿÿ;“+‹Ñˆ€öÿÿÿÿÿÿE“;“1“€÷ÿÿÿÿÿÿO“E“'“€øÿÿÿÿÿÿY“O““€ùÿÿÿÿÿÿc“Y““€úÿÿÿÿÿÿm“7±†€ûÿÿÿÿÿÿw“þ‚ji€üÿÿÿÿÿÿ“Û…Ô‡€ýÿÿÿÿÿÿ‹“Ûˆ…k€þÿÿÿÿÿÿ•“©‹‰€ÿÿÿÿÿÿÿŸ“•“‹“€ÿÿÿÿÿÿ©“Ÿ““€ÿÿÿÿÿÿ³“©“w“€ÿÿÿÿÿÿ½“³“m“€ÿÿÿÿÿÿÇ“½“c“€ÿÿÿÿÿÿÑ“Ç“ “€ÿÿÿÿÿÿÛ“Ñ“¯’€ÿÿÿÿÿÿå“Û“U’€ÿÿÿÿÿÿï“[|+k€ÿÿÿÿÿÿù“I€.i€ ÿÿÿÿÿÿ”ëtAo€ ÿÿÿÿÿÿ ”¨†}~€ ÿÿÿÿÿÿ”»‰T€ ÿÿÿÿÿÿ!”” ”€ ÿÿÿÿÿÿ+”!””€ÿÿÿÿÿÿ5”+”ù“€ÿÿÿÿÿÿ?”5”ï“€ÿÿÿÿÿÿI”}?€€ÿÿÿÿÿÿS”ï€å€€ÿÿÿÿÿÿ]”þtTo€ÿÿÿÿÿÿg”M‡N‚€ÿÿÿÿÿÿq”BŠ j€ÿÿÿÿÿÿ{”q”g”€ÿÿÿÿÿÿ…”{”]”€ÿÿÿÿÿÿ”…”S”€ÿÿÿÿÿÿ™””I”€ÿÿÿÿÿÿ£”Koát€ÿÿÿÿÿÿ­”^oôt€ÿÿÿÿÿÿ·”€ÿÿÿÿÿÿÁ”—o-u€ÿÿÿÿÿÿË”Ðofu€ÿÿÿÿÿÿՔ˔Á”€ÿÿÿÿÿÿߔՔ·”€ ÿÿÿÿÿÿé”ß”­”€!ÿÿÿÿÿÿó”锣”€"ÿÿÿÿÿÿý”‡~i€#ÿÿÿÿÿÿ•X‚C‡€$ÿÿÿÿÿÿ•7uo€%ÿÿÿÿÿÿ•]ˆ{k€&ÿÿÿÿÿÿ%•>‹îˆ€'ÿÿÿÿÿÿ/•%••€(ÿÿÿÿÿÿ9•/••€)ÿÿÿÿÿÿC•9••€*ÿÿÿÿÿÿM•C•ý”€+ÿÿÿÿÿÿW•^±‰€,ÿÿÿÿÿÿa•ƒgk€-ÿÿÿÿÿÿk•puÆo€.ÿÿÿÿÿÿu•øˆâi€/ÿÿÿÿÿÿ•Æ‹¼‹€0ÿÿÿÿÿÿ‰••u•€1ÿÿÿÿÿÿ“•‰•k•€2ÿÿÿÿÿÿ•“•a•€3ÿÿÿÿÿÿ§••W•€4ÿÿÿÿÿÿ±•§•M•€5ÿÿÿÿÿÿ»•±•ó”€6ÿÿÿÿÿÿÅ•»•™”€7ÿÿÿÿÿÿÏ•Å•?”€8ÿÿÿÿÿÿÙ•Ï•å“€9ÿÿÿÿÿÿã•Ù•û‘€:ÿÿÿÿÿÿí•ã•€;ÿÿÿÿÿÿ÷•í•1Ž€<ÿÿÿÿÿÿ–»‰•†€=ÿÿÿÿÿÿ ––¤ƒ€>ÿÿÿÿÿÿ– –è€?ÿÿÿÿÿÿ––ú{€@ÿÿÿÿÿÿ)–BŠ0‡€Aÿÿÿÿÿÿ3–)–@„€Bÿÿÿÿÿÿ=–3–—€€CÿÿÿÿÿÿG–=–ª|€DÿÿÿÿÿÿQ–ÐoÁ‡€Eÿÿÿÿÿÿ[–Q–v€Fÿÿÿÿÿÿe–[–Q€Gÿÿÿÿÿÿo–e–c}€Hÿÿÿÿÿÿy–>‹Jˆ€Iÿÿÿÿÿÿƒ–y–?…€Jÿÿÿÿÿÿ–ƒ–÷€Kÿÿÿÿÿÿ—––~€Lÿÿÿÿÿÿ¡–Æ‹Ûˆ€Mÿÿÿÿÿÿ«–¡–·$€Nÿÿÿÿÿÿµ–«–º‚€Oÿÿÿÿÿÿ¿–µ–Ì~€PÿÿÿÿÿÿÉ–¿–—–€QÿÿÿÿÿÿÓ–É–o–€RÿÿÿÿÿÿÝ–Ó–G–€Sÿÿÿÿÿÿç–Ý––€TSÿÿÿÿÿÿñ–œ2.€U>ÿÿÿÿÿÿû–œñ–@Vÿÿÿÿÿÿ—û–€WSÿÿÿÿÿÿ—~2.€X>ÿÿÿÿÿÿ—~—@Yÿÿÿÿÿÿ"——€ZSÿÿÿÿÿÿ+—42.€[>ÿÿÿÿÿÿ5—4+—@\ÿÿÿÿÿÿ?—5—€]SÿÿÿÿÿÿH—<2.€^>ÿÿÿÿÿÿR—<H—@_ÿÿÿÿÿÿ\—R—€`Sÿÿÿÿÿÿe—°2.€a>ÿÿÿÿÿÿo—°e—@bÿÿÿÿÿÿy—o—€cÿÿÿÿÿÿ‚—y—\—€dÿÿÿÿÿÿŒ—‚—?—€eÿÿÿÿÿÿ–—Œ—"—€fÿÿÿÿÿÿ —–——€gSÿÿÿÿÿÿª—œ³-€h>ÿÿÿÿÿÿ´—œª—@iÿÿÿÿÿÿ¾—´—€jSÿÿÿÿÿÿÇ—~³-€k>ÿÿÿÿÿÿÑ—~Ç—@lÿÿÿÿÿÿÛ—Ñ—€mSÿÿÿÿÿÿä—4³-€n>ÿÿÿÿÿÿî—4ä—@oÿÿÿÿÿÿø—î—€pSÿÿÿÿÿÿ˜<³-€q>ÿÿÿÿÿÿ ˜<˜@rÿÿÿÿÿÿ˜ ˜€sSÿÿÿÿÿÿ˜°³-€t>ÿÿÿÿÿÿ(˜°˜@uÿÿÿÿÿÿ2˜(˜€vÿÿÿÿÿÿ;˜2˜˜€wÿÿÿÿÿÿE˜;˜ø—€xÿÿÿÿÿÿO˜E˜Û—€yÿÿÿÿÿÿY˜O˜¾—€zÿÿÿÿÿÿc˜Æ‹+‹€{ÿÿÿÿÿÿm˜c˜O2€|ÿÿÿÿÿÿw˜m˜ Š€}ÿÿÿÿÿÿ˜w˜e‰€~Sÿÿÿÿÿÿ‹˜œú,€>ÿÿÿÿÿÿ•˜œ‹˜@€ÿÿÿÿÿÿŸ˜•˜€Sÿÿÿÿÿÿ¨˜~ú,€‚>ÿÿÿÿÿÿ²˜~¨˜@ƒÿÿÿÿÿÿ¼˜²˜€„SÿÿÿÿÿÿŘ4ú,€…>ÿÿÿÿÿÿϘ4Ř@†ÿÿÿÿÿÿ٘Ϙ€‡Sÿÿÿÿÿÿâ˜<ú,€ˆ>ÿÿÿÿÿÿì˜<â˜@‰ÿÿÿÿÿÿö˜ì˜€ŠSÿÿÿÿÿÿÿ˜°ú,€‹>ÿÿÿÿÿÿ ™°ÿ˜@Œÿÿÿÿÿÿ™ ™€ÿÿÿÿÿÿ™™ö˜€Žÿÿÿÿÿÿ&™™Ù˜€ÿÿÿÿÿÿ0™&™¼˜€ÿÿÿÿÿÿ:™0™Ÿ˜€‘SÿÿÿÿÿÿD™œv.€’>ÿÿÿÿÿÿN™œD™@“ÿÿÿÿÿÿX™N™€”Sÿÿÿÿÿÿa™~v.€•>ÿÿÿÿÿÿk™~a™@–ÿÿÿÿÿÿu™k™€—Sÿÿÿÿÿÿ~™4v.€˜>ÿÿÿÿÿÿˆ™4~™@™ÿÿÿÿÿÿ’™ˆ™€šSÿÿÿÿÿÿ›™<v.€›>ÿÿÿÿÿÿ¥™<›™@œÿÿÿÿÿÿ¯™¥™€Sÿÿÿÿÿÿ¸™°v.€ž>ÿÿÿÿÿÿ™°¸™@Ÿÿÿÿÿÿÿ̙™€ ÿÿÿÿÿÿՙ̙¯™€¡ÿÿÿÿÿÿߙՙ’™€¢ÿÿÿÿÿÿé™ß™u™€£ÿÿÿÿÿÿó™é™X™€¤ÿÿÿÿÿÿý™ó™:™€¥ÿÿÿÿÿÿšý™˜€¦ÿÿÿÿÿÿššY˜€§ÿÿÿÿÿÿšš —€¨Sÿÿÿÿÿÿ%šœÞh€©>ÿÿÿÿÿÿ/š~%š€ªSÿÿÿÿÿÿ9šœê'€«>ÿÿÿÿÿÿCš49š€¬SÿÿÿÿÿÿMšœüh€­>ÿÿÿÿÿÿWš<Mš€®Sÿÿÿÿÿÿašœi€¯>ÿÿÿÿÿÿkš°aš€°ÿÿÿÿÿÿuškšWš€±ÿÿÿÿÿÿšušCš€²ÿÿÿÿÿÿ‰šš/š€³ÿÿÿÿÿÿ“š‰šû–€´Sÿÿÿÿÿÿš~$i€µ>ÿÿÿÿÿÿ§šœš€¶Sÿÿÿÿÿÿ±š~|$€·>ÿÿÿÿÿÿ»š4±š€¸SÿÿÿÿÿÿÅš~Li€¹>ÿÿÿÿÿÿÏš<Åš€ºSÿÿÿÿÿÿÙš~`i€»>ÿÿÿÿÿÿãš°Ùš€¼ÿÿÿÿÿÿíšãšÏš€½ÿÿÿÿÿÿ÷šíš»š€¾ÿÿÿÿÿÿ›÷šÑ—€¿ÿÿÿÿÿÿ ››§š€ÀSÿÿÿÿÿÿ›4f@€Á>ÿÿÿÿÿÿ›œ›€ÂSÿÿÿÿÿÿ)›4x1€Ã>ÿÿÿÿÿÿ3›~)›€ÄSÿÿÿÿÿÿ=›4¿0€Å>ÿÿÿÿÿÿG›<=›€ÆSÿÿÿÿÿÿQ›4;2€Ç>ÿÿÿÿÿÿ[›°Q›€Èÿÿÿÿÿÿe›[›G›€Éÿÿÿÿÿÿo›e›E2€Êÿÿÿÿÿÿy›o›3›€Ëÿÿÿÿÿÿƒ›y››€ÌSÿÿÿÿÿÿ›<¦i€Í>ÿÿÿÿÿÿ—›œ›€ÎSÿÿÿÿÿÿ¡›<ºi€Ï>ÿÿÿÿÿÿ«›~¡›€ÐSÿÿÿÿÿÿµ›<_$€Ñ>ÿÿÿÿÿÿ¿›4µ›€ÒSÿÿÿÿÿÿÉ›<Øi€Ó>ÿÿÿÿÿÿÓ›°É›€Ôÿÿÿÿÿÿݛӛ였Õÿÿÿÿÿÿç›Ý›¿›€Öÿÿÿÿÿÿñ›ç›«›€×ÿÿÿÿÿÿû›ñ›—›€ØSÿÿÿÿÿÿœ°ìi€Ù>ÿÿÿÿÿÿœœœ€ÚSÿÿÿÿÿÿœ°j€Û>ÿÿÿÿÿÿ#œ~œ€ÜSÿÿÿÿÿÿ-œ°£$€Ý>ÿÿÿÿÿÿ7œ4-œ€ÞSÿÿÿÿÿÿAœ°j€ß>ÿÿÿÿÿÿKœ<Aœ€àÿÿÿÿÿÿUœÂ™Kœ€áÿÿÿÿÿÿ_œUœ7œ€âÿÿÿÿÿÿiœ_œ#œ€ãÿÿÿÿÿÿsœiœœ€äÿÿÿÿÿÿ}œsœû›€åÿÿÿÿÿÿ‡œ}œƒ›€æÿÿÿÿÿÿ‘œ‡œ ›€çÿÿÿÿÿÿ›œ‘œ“š€èÿÿÿÿÿÿ¥œËÇ|€éÿÿÿÿÿÿ¯œ~ƒ}€êÿÿÿÿÿÿ¹œR†`~€ëÿÿÿÿÿÿÃœe‰^€ìÿÿÿÿÿÿܹ͜œ€íÿÿÿÿÿÿל͜¯œ€îÿÿÿÿÿÿáœ×œ¥œ€ïÿÿÿÿÿÿëœáœú{€ðÿÿÿÿÿÿõœª|Ë€ñÿÿÿÿÿÿÿœ„€—€€òÿÿÿÿÿÿ „d€óÿÿÿÿÿÿí†1‚€ôÿÿÿÿÿÿö‰ƒ€õÿÿÿÿÿÿ'€öÿÿÿÿÿÿ1' €÷ÿÿÿÿÿÿ;1ÿœ€øÿÿÿÿÿÿE;õœ€ùÿÿÿÿÿÿOc}~ƒ€úÿÿÿÿÿÿY4-„€ûÿÿÿÿÿÿckbv€üÿÿÿÿÿÿmˆ‡\…€ýÿÿÿÿÿÿw}Špu€þÿÿÿÿÿÿwm€ÿÿÿÿÿÿÿ‹c€ÿÿÿÿÿÿ•‹Y€ÿÿÿÿÿÿŸ•O€ÿÿÿÿÿÿ©~R†€ÿÿÿÿÿÿ³Ú‡€ÿÿÿÿÿÿ½…®‡€ÿÿÿÿÿÿLjJˆ€ÿÿÿÿÿÿÑòŠøˆ€ÿÿÿÿÿÿÛÑÇ€ÿÿÿÿÿÿåÛ½€ ÿÿÿÿÿÿïå³€ ÿÿÿÿÿÿùï©€ ÿÿÿÿÿÿžÌ~e‰€ ÿÿÿÿÿÿ ž‚ Š€ ÿÿÿÿÿÿž«…O2€ÿÿÿÿÿÿ!ž˜ˆ+‹€ÿÿÿÿÿÿ+žy‹Æ‹€ÿÿÿÿÿÿ5ž+ž!ž€ÿÿÿÿÿÿ?ž5žž€ÿÿÿÿÿÿIž?ž ž€ÿÿÿÿÿÿSžIžž€ÿÿÿÿÿÿ]žSžù€ÿÿÿÿÿÿgž]žŸ€ÿÿÿÿÿÿqžgžE€ÿÿÿÿÿÿ{žqžëœ€ÿÿÿÿÿÿ…ž|ú{€ÿÿÿÿÿÿžèÇ|€ÿÿÿÿÿÿ™ž‘ƒ}€ÿÿÿÿÿÿ£že†`~€ÿÿÿÿÿÿ­žx‰^€ÿÿÿÿÿÿ·ž­ž£ž€ÿÿÿÿÿÿÁž·ž™ž€ÿÿÿÿÿÿËžÁžž€ ÿÿÿÿÿÿ՞˞…ž€!ÿÿÿÿÿÿßžÇ|Ë€"ÿÿÿÿÿÿéž-„d€#ÿÿÿÿÿÿóž‡1‚€$ÿÿÿÿÿÿýž Šƒ€%ÿÿÿÿÿÿŸýžóž€&ÿÿÿÿÿÿŸŸéž€'ÿÿÿÿÿÿŸŸ—€€(ÿÿÿÿÿÿ%ŸŸßž€)ÿÿÿÿÿÿ/Ÿv}~ƒ€*ÿÿÿÿÿÿ9ŸQ-„€+ÿÿÿÿÿÿCŸ"]v€,ÿÿÿÿÿÿMŸ›‡\…€-ÿÿÿÿÿÿWŸŠpu€.ÿÿÿÿÿÿaŸWŸMŸ€/ÿÿÿÿÿÿkŸaŸCŸ€0ÿÿÿÿÿÿuŸkŸ9Ÿ€1ÿÿÿÿÿÿŸuŸ/Ÿ€2ÿÿÿÿÿÿ‰Ÿ0~R†€3ÿÿÿÿÿÿ“Ÿ÷‡€4ÿÿÿÿÿÿŸ"…®‡€5ÿÿÿÿÿÿ§Ÿ#ˆJˆ€6ÿÿÿÿÿÿ±Ÿ‹øˆ€7ÿÿÿÿÿÿ»Ÿ±Ÿ§Ÿ€8ÿÿÿÿÿÿÅŸ»ŸŸ€9ÿÿÿÿÿÿÏŸÅŸ“Ÿ€:ÿÿÿÿÿÿÙŸÏŸ‰Ÿ€;ÿÿÿÿÿÿãŸé~e‰€<ÿÿÿÿÿÿퟺ‚ Š€=ÿÿÿÿÿÿ÷Ÿ¾…O2€>ÿÿÿÿÿÿ «ˆ+‹€?ÿÿÿÿÿÿ  Œ‹Æ‹€@ÿÿÿÿÿÿ    €Aÿÿÿÿÿÿ  ÷Ÿ€Bÿÿÿÿÿÿ)  íŸ€Cÿÿÿÿÿÿ3 ) ãŸ€Dÿÿÿÿÿÿ= 3 ÙŸ€EÿÿÿÿÿÿG = Ÿ€FÿÿÿÿÿÿQ G %Ÿ€Gÿÿÿÿÿÿ[ Q Õž€Hÿÿÿÿÿÿe g4ú{€Iÿÿÿÿÿÿo €Ç|€Jÿÿÿÿÿÿy ¤ƒ}€Kÿÿÿÿÿÿƒ x†`~€Lÿÿÿÿÿÿ ‹‰^€Mÿÿÿÿÿÿ—  ƒ €Nÿÿÿÿÿÿ¡ — y €Oÿÿÿÿÿÿ« ¡ o €Pÿÿÿÿÿÿµ « e €Qÿÿÿÿÿÿ¿ î|Ë€RÿÿÿÿÿÿÉ Ç-—€€SÿÿÿÿÿÿÓ @„d€TÿÿÿÿÿÿÝ ‡1‚€Uÿÿÿÿÿÿç Šƒ€Vÿÿÿÿÿÿñ ç Ý €Wÿÿÿÿÿÿû ñ Ó €Xÿÿÿÿÿÿ¡û É €Yÿÿÿÿÿÿ¡¡¿ €Zÿÿÿÿÿÿ¡}~ƒ€[ÿÿÿÿÿÿ#¡d-„€\ÿÿÿÿÿÿ-¡®‡\…€]ÿÿÿÿÿÿ7¡O2pu€^ÿÿÿÿÿÿA¡7¡-¡€_ÿÿÿÿÿÿK¡A¡v€`ÿÿÿÿÿÿU¡K¡#¡€aÿÿÿÿÿÿ_¡U¡¡€bÿÿÿÿÿÿi¡C~R†€cÿÿÿÿÿÿs¡‚‡€dÿÿÿÿÿÿ}¡?…®‡€eÿÿÿÿÿÿ‡¡-Jˆ€fÿÿÿÿÿÿ‘¡‹øˆ€gÿÿÿÿÿÿ›¡‘¡‡¡€hÿÿÿÿÿÿ¥¡›¡}¡€iÿÿÿÿÿÿ¯¡¥¡s¡€jÿÿÿÿÿÿ¹¡¯¡i¡€kÿÿÿÿÿÿáe‰€lÿÿÿÿÿÿׂ͡ Š€mÿÿÿÿÿÿס·$O2€nÿÿÿÿÿÿ᡾ˆ+‹€oÿÿÿÿÿÿë¡Š.Æ‹€pÿÿÿÿÿÿõ¡ë¡á¡€qÿÿÿÿÿÿÿ¡õ¡×¡€rÿÿÿÿÿÿ ¢ÿ¡Í¡€sÿÿÿÿÿÿ¢ ¢Ã¡€tÿÿÿÿÿÿ¢¢¹¡€uÿÿÿÿÿÿ'¢¢_¡€vÿÿÿÿÿÿ1¢'¢¡€wÿÿÿÿÿÿ;¢1¢µ €xÿÿÿÿÿÿE¢H|ú{€yÿÿÿÿÿÿO¢"€Ç|€zÿÿÿÿÿÿY¢Áƒ}€{ÿÿÿÿÿÿc¢•†`~€|ÿÿÿÿÿÿm¢ž‰^€}ÿÿÿÿÿÿw¢m¢c¢€~ÿÿÿÿÿÿ¢w¢Y¢€ÿÿÿÿÿÿ‹¢¢O¢€€ÿÿÿÿÿÿ•¢‹¢E¢€ÿÿÿÿÿÿŸ¢}Ë€‚ÿÿÿÿÿÿ©¢È€—€€ƒÿÿÿÿÿÿ³¢]„d€„ÿÿÿÿÿÿ½¢0‡1‚€…ÿÿÿÿÿÿÇ¢/Šƒ€†ÿÿÿÿÿÿѢǢ½¢€‡ÿÿÿÿÿÿۢѢ³¢€ˆÿÿÿÿÿÿå¢Û¢©¢€‰ÿÿÿÿÿÿï¢å¢Ÿ¢€Šÿÿÿÿÿÿù¢º}~ƒ€‹ÿÿÿÿÿÿ£-„€Œÿÿÿÿÿÿ £Ë\v€ÿÿÿÿÿÿ£Á‡\…€Žÿÿÿÿÿÿ!£­Špu€ÿÿÿÿÿÿ+£!££€ÿÿÿÿÿÿ5£+£ £€‘ÿÿÿÿÿÿ?£5££€’ÿÿÿÿÿÿI£?£ù¢€“ÿÿÿÿÿÿS£`~R†€”ÿÿÿÿÿÿ]£1‚‡€•ÿÿÿÿÿÿg£\…®‡€–ÿÿÿÿÿÿq£+‹øˆ€—ÿÿÿÿÿÿ{£q£Jˆ€˜ÿÿÿÿÿÿ…£{£g£€™ÿÿÿÿÿÿ£…£]£€šÿÿÿÿÿÿ™££S£€›ÿÿÿÿÿÿ££7e‰€œÿÿÿÿÿÿ­£þ‚ Š€ÿÿÿÿÿÿ·£Û…O2€žÿÿÿÿÿÿÁ£Ûˆ+‹€ŸÿÿÿÿÿÿË£©‹Æ‹€ ÿÿÿÿÿÿգˣÁ£€¡ÿÿÿÿÿÿߣգ·£€¢ÿÿÿÿÿÿé£ß£­£€£ÿÿÿÿÿÿó£é£££€¤ÿÿÿÿÿÿý£ó£™£€¥ÿÿÿÿÿÿ¤ý£I£€¦ÿÿÿÿÿÿ¤¤ï¢€§ÿÿÿÿÿÿ¤¤•¢€¨ÿÿÿÿÿÿ%¤[|ú{€©ÿÿÿÿÿÿ/¤I€Ç|€ªÿÿÿÿÿÿ9¤ët}€«ÿÿÿÿÿÿC¤¨†`~€¬ÿÿÿÿÿÿM¤»‰^€­ÿÿÿÿÿÿW¤M¤C¤€®ÿÿÿÿÿÿa¤W¤9¤€¯ÿÿÿÿÿÿk¤a¤/¤€°ÿÿÿÿÿÿu¤k¤%¤€±ÿÿÿÿÿÿ¤}Ë€²ÿÿÿÿÿÿ‰¤ï€—€€³ÿÿÿÿÿÿ“¤þtd€´ÿÿÿÿÿÿ¤M‡1‚€µÿÿÿÿÿÿ§¤BŠƒ€¶ÿÿÿÿÿÿ±¤§¤¤€·ÿÿÿÿÿÿ»¤±¤“¤€¸ÿÿÿÿÿÿŤ»¤‰¤€¹ÿÿÿÿÿÿϤŤ¤€ºÿÿÿÿÿÿÙ¤Ko~ƒ€»ÿÿÿÿÿÿã¤^o-„€¼ÿÿÿÿÿÿí¤v€½ÿÿÿÿÿÿ÷¤—o\…€¾ÿÿÿÿÿÿ¥Ðopu€¿ÿÿÿÿÿÿ ¥¥÷¤€Àÿÿÿÿÿÿ¥ ¥í¤€Áÿÿÿÿÿÿ¥¥ã¤€Âÿÿÿÿÿÿ)¥¥Ù¤€Ãÿÿÿÿÿÿ3¥‡~R†€Äÿÿÿÿÿÿ=¥X‚‡€ÅÿÿÿÿÿÿG¥7u®‡€ÆÿÿÿÿÿÿQ¥]ˆJˆ€Çÿÿÿÿÿÿ[¥>‹øˆ€Èÿÿÿÿÿÿe¥[¥Q¥€Éÿÿÿÿÿÿo¥e¥G¥€Êÿÿÿÿÿÿy¥o¥=¥€Ëÿÿÿÿÿÿƒ¥y¥3¥€Ìÿÿÿÿÿÿ¥^e‰€Íÿÿÿÿÿÿ—¥ƒ Š€Îÿÿÿÿÿÿ¡¥puO2€Ïÿÿÿÿÿÿ«¥øˆ+‹€Ðÿÿÿÿÿÿµ¥Æ‹«¥€Ñÿÿÿÿÿÿ¿¥µ¥¡¥€ÒÿÿÿÿÿÿÉ¥¿¥—¥€Óÿÿÿÿÿÿӥɥ¥€ÔÿÿÿÿÿÿÝ¥Ó¥ƒ¥€Õÿÿÿÿÿÿç¥Ý¥)¥€Öÿÿÿÿÿÿñ¥ç¥Ï¤€×ÿÿÿÿÿÿû¥ñ¥u¤€Øÿÿÿÿÿÿ¦û¥¤€Ùÿÿÿÿÿÿ¦¦;¢€Úÿÿÿÿÿÿ¦¦[ €Ûÿÿÿÿÿÿ#¦¦{ž€ÜSÿÿÿÿÿÿ-¦2.2.€Ý>ÿÿÿÿÿÿ7¦œ-¦@ÞÿÿÿÿÿÿA¦7¦€ßSÿÿÿÿÿÿJ¦$i$i€à>ÿÿÿÿÿÿT¦~J¦@áÿÿÿÿÿÿ^¦T¦€âSÿÿÿÿÿÿg¦f@f@€ã>ÿÿÿÿÿÿq¦4g¦@äÿÿÿÿÿÿ{¦q¦€åSÿÿÿÿÿÿ„¦¦i¦i€æ>ÿÿÿÿÿÿŽ¦<„¦@çÿÿÿÿÿÿ˜¦Ž¦€èSÿÿÿÿÿÿ¡¦ìiìi€é>ÿÿÿÿÿÿ«¦°¡¦@êÿÿÿÿÿÿµ¦«¦€ëÿÿÿÿÿÿ¾¦µ¦˜¦€ìÿÿÿÿÿÿȦ¾¦{¦€íÿÿÿÿÿÿҦȦ^¦€îÿÿÿÿÿÿܦҦA¦€ïSÿÿÿÿÿÿæ¦ÞhÞh€ð>ÿÿÿÿÿÿð¦œæ¦@ñÿÿÿÿÿÿú¦ð¦€òSÿÿÿÿÿÿ§³-³-€ó>ÿÿÿÿÿÿ §~§@ôÿÿÿÿÿÿ§ §€õSÿÿÿÿÿÿ §x1x1€ö>ÿÿÿÿÿÿ*§4 §@÷ÿÿÿÿÿÿ4§*§€øSÿÿÿÿÿÿ=§ºiºi€ù>ÿÿÿÿÿÿG§<=§@úÿÿÿÿÿÿQ§G§€ûSÿÿÿÿÿÿZ§jj€ü>ÿÿÿÿÿÿd§°Z§@ýÿÿÿÿÿÿn§d§€þÿÿÿÿÿÿw§n§Q§€ÿÿÿÿÿÿÿ§w§4§€ÿÿÿÿÿÿ‹§§§€ÿÿÿÿÿÿ•§‹§ú¦€SÿÿÿÿÿÿŸ§ê'ê'€>ÿÿÿÿÿÿ©§œŸ§@ÿÿÿÿÿÿ³§©§€Sÿÿÿÿÿÿ¼§|$|$€>ÿÿÿÿÿÿƧ~¼§@ÿÿÿÿÿÿЧƧ€SÿÿÿÿÿÿÙ§_$_$€ >ÿÿÿÿÿÿã§<Ù§@ ÿÿÿÿÿÿí§ã§€ Sÿÿÿÿÿÿö§£$£$€ >ÿÿÿÿÿÿ¨°ö§@ ÿÿÿÿÿÿ ¨¨€ÿÿÿÿÿÿ¨ ¨í§€ÿÿÿÿÿÿ¨¨Š.€ÿÿÿÿÿÿ'¨¨Ð§€ÿÿÿÿÿÿ1¨'¨³§€Sÿÿÿÿÿÿ;¨ühüh€>ÿÿÿÿÿÿE¨œ;¨@ÿÿÿÿÿÿO¨E¨€SÿÿÿÿÿÿX¨LiLi€>ÿÿÿÿÿÿb¨~X¨@ÿÿÿÿÿÿl¨b¨€Sÿÿÿÿÿÿu¨¿0¿0€>ÿÿÿÿÿÿ¨4u¨@ÿÿÿÿÿÿ‰¨¨€Sÿÿÿÿÿÿ’¨ú,ú,€>ÿÿÿÿÿÿœ¨<’¨@ÿÿÿÿÿÿ¦¨œ¨€Sÿÿÿÿÿÿ¯¨jj€>ÿÿÿÿÿÿ¹¨°¯¨@ ÿÿÿÿÿÿ蹨€!ÿÿÿÿÿÿ̨覨€"ÿÿÿÿÿÿ̨֨‰¨€#ÿÿÿÿÿÿà¨Ö¨l¨€$ÿÿÿÿÿÿê¨à¨O¨€%Sÿÿÿÿÿÿô¨ii€&>ÿÿÿÿÿÿþ¨œô¨@'ÿÿÿÿÿÿ©þ¨€(Sÿÿÿÿÿÿ©`i`i€)>ÿÿÿÿÿÿ©~©@*ÿÿÿÿÿÿ%©©€+Sÿÿÿÿÿÿ.©;2;2€,>ÿÿÿÿÿÿ8©4.©@-ÿÿÿÿÿÿB©8©€.SÿÿÿÿÿÿK©ØiØi€/>ÿÿÿÿÿÿU©<K©@0ÿÿÿÿÿÿ_©U©€1Sÿÿÿÿÿÿh©v.v.€2>ÿÿÿÿÿÿr©°h©@3ÿÿÿÿÿÿ|©r©€4ÿÿÿÿÿÿ…©|©_©€5ÿÿÿÿÿÿ©…©B©€6ÿÿÿÿÿÿ™©©%©€7ÿÿÿÿÿÿ£©™©©€8ÿÿÿÿÿÿ­©£©ê¨€9ÿÿÿÿÿÿ·©­©1¨€:ÿÿÿÿÿÿÁ©·©•§€;ÿÿÿÿÿÿË©Á©Ü¦€<SÿÿÿÿÿÿÕ©~Þh€=>ÿÿÿÿÿÿß©œÕ©@>ÿÿÿÿÿÿé©ß©€?Sÿÿÿÿÿÿò©4ê'€@>ÿÿÿÿÿÿü©œò©@Aÿÿÿÿÿÿªü©€BSÿÿÿÿÿÿª<üh€C>ÿÿÿÿÿÿªœª@Dÿÿÿÿÿÿ#ªª€ESÿÿÿÿÿÿ,ª°i€F>ÿÿÿÿÿÿ6ªœ,ª@Gÿÿÿÿÿÿ@ª6ª€HÿÿÿÿÿÿIª@ª#ª€IÿÿÿÿÿÿSªIªª€Jÿÿÿÿÿÿ]ªSªé©€Kÿÿÿÿÿÿgª]ª—€LSÿÿÿÿÿÿqªœ$i€M>ÿÿÿÿÿÿ{ª~qª@Nÿÿÿÿÿÿ…ª{ª€OSÿÿÿÿÿÿŽª4|$€P>ÿÿÿÿÿÿ˜ª~Žª@Qÿÿÿÿÿÿ¢ª˜ª€RSÿÿÿÿÿÿ«ª<Li€S>ÿÿÿÿÿÿµª~«ª@Tÿÿÿÿÿÿ¿ªµª€USÿÿÿÿÿÿȪ°`i€V>ÿÿÿÿÿÿÒª~Ȫ@WÿÿÿÿÿÿܪҪ€XÿÿÿÿÿÿåªÜª¿ª€Yÿÿÿÿÿÿïªåª¢ª€ZÿÿÿÿÿÿùªïªÛ—€[ÿÿÿÿÿÿ«ùª…ª€\Sÿÿÿÿÿÿ «œf@€]>ÿÿÿÿÿÿ«4 «@^ÿÿÿÿÿÿ!««€_Sÿÿÿÿÿÿ*«~x1€`>ÿÿÿÿÿÿ4«4*«@aÿÿÿÿÿÿ>«4«€bSÿÿÿÿÿÿG«<¿0€c>ÿÿÿÿÿÿQ«4G«@dÿÿÿÿÿÿ[«Q«€eSÿÿÿÿÿÿd«°;2€f>ÿÿÿÿÿÿn«4d«@gÿÿÿÿÿÿx«n«€hÿÿÿÿÿÿ«x«[«€iÿÿÿÿÿÿ‹««O2€jÿÿÿÿÿÿ•«‹«>«€kÿÿÿÿÿÿŸ«•«!«€lSÿÿÿÿÿÿ©«œ¦i€m>ÿÿÿÿÿÿ³«<©«@nÿÿÿÿÿÿ½«³«€oSÿÿÿÿÿÿÆ«~ºi€p>ÿÿÿÿÿÿЫ<Æ«@qÿÿÿÿÿÿګЫ€rSÿÿÿÿÿÿã«4_$€s>ÿÿÿÿÿÿí«<ã«@tÿÿÿÿÿÿ÷«í«€uSÿÿÿÿÿÿ¬°Øi€v>ÿÿÿÿÿÿ ¬<¬@wÿÿÿÿÿÿ¬ ¬€xÿÿÿÿÿÿ¬¬ö˜€yÿÿÿÿÿÿ'¬¬÷«€zÿÿÿÿÿÿ1¬'¬Ú«€{ÿÿÿÿÿÿ;¬1¬½«€|SÿÿÿÿÿÿE¬œìi€}>ÿÿÿÿÿÿO¬°E¬@~ÿÿÿÿÿÿY¬O¬€Sÿÿÿÿÿÿb¬~j€€>ÿÿÿÿÿÿl¬°b¬@ÿÿÿÿÿÿv¬l¬€‚Sÿÿÿÿÿÿ¬4£$€ƒ>ÿÿÿÿÿÿ‰¬°¬@„ÿÿÿÿÿÿ“¬‰¬€…Sÿÿÿÿÿÿœ¬<j€†>ÿÿÿÿÿÿ¦¬°œ¬@‡ÿÿÿÿÿÿ°¬¦¬€ˆÿÿÿÿÿÿ¹¬Ì™°¬€‰ÿÿÿÿÿÿ칬“¬€Šÿÿÿÿÿÿͬìv¬€‹ÿÿÿÿÿÿ׬ͬY¬€Œÿÿÿÿÿÿá¬×¬;¬€ÿÿÿÿÿÿë¬á¬Ÿ«€Žÿÿÿÿÿÿõ¬ë¬«€ÿÿÿÿÿÿÿ¬õ¬gª€>ÿÿÿÿÿÿ ­~æ¦@‘ÿÿÿÿÿÿ­ ­€’>ÿÿÿÿÿÿ­4Ÿ§@“ÿÿÿÿÿÿ&­­€”>ÿÿÿÿÿÿ/­<;¨@•ÿÿÿÿÿÿ9­/­€–>ÿÿÿÿÿÿB­°ô¨@—ÿÿÿÿÿÿL­B­€˜ÿÿÿÿÿÿU­L­9­€™ÿÿÿÿÿÿ_­U­&­€šÿÿÿÿÿÿi­_­­€›ÿÿÿÿÿÿs­i­A¦€œ>ÿÿÿÿÿÿ}­œJ¦@ÿÿÿÿÿÿ‡­}­€ž>ÿÿÿÿÿÿ­4¼§@Ÿÿÿÿÿÿÿš­­€ >ÿÿÿÿÿÿ£­<X¨@¡ÿÿÿÿÿÿ­­£­€¢>ÿÿÿÿÿÿ¶­°©@£ÿÿÿÿÿÿÀ­¶­€¤ÿÿÿÿÿÿÉ­À­­­€¥ÿÿÿÿÿÿÓ­É­š­€¦ÿÿÿÿÿÿÝ­Ó­§€§ÿÿÿÿÿÿç­Ý­‡­€¨>ÿÿÿÿÿÿñ­œg¦@©ÿÿÿÿÿÿû­ñ­€ª>ÿÿÿÿÿÿ®~ §@«ÿÿÿÿÿÿ®®€¬>ÿÿÿÿÿÿ®<u¨@­ÿÿÿÿÿÿ!®®€®>ÿÿÿÿÿÿ*®°.©@¯ÿÿÿÿÿÿ4®*®€°ÿÿÿÿÿÿ=®4®!®€±ÿÿÿÿÿÿG®=®Š.€²ÿÿÿÿÿÿQ®G®®€³ÿÿÿÿÿÿ[®Q®û­€´>ÿÿÿÿÿÿe®œ„¦@µÿÿÿÿÿÿo®e®€¶>ÿÿÿÿÿÿx®~=§@·ÿÿÿÿÿÿ‚®x®€¸>ÿÿÿÿÿÿ‹®4Ù§@¹ÿÿÿÿÿÿ•®‹®€º>ÿÿÿÿÿÿž®°K©@»ÿÿÿÿÿÿ¨®ž®€¼ÿÿÿÿÿÿ±®¨®¦¨€½ÿÿÿÿÿÿ»®±®•®€¾ÿÿÿÿÿÿÅ®»®‚®€¿ÿÿÿÿÿÿϮŮo®€À>ÿÿÿÿÿÿÙ®œ¡¦@Áÿÿÿÿÿÿã®Ù®€Â>ÿÿÿÿÿÿì®~Z§@Ãÿÿÿÿÿÿö®ì®€Ä>ÿÿÿÿÿÿÿ®4ö§@Åÿÿÿÿÿÿ ¯ÿ®€Æ>ÿÿÿÿÿÿ¯<¯¨@Çÿÿÿÿÿÿ¯¯€Èÿÿÿÿÿÿ%¯|©¯€Éÿÿÿÿÿÿ/¯%¯ ¯€Êÿÿÿÿÿÿ9¯/¯ö®€ËÿÿÿÿÿÿC¯9¯ã®€ÌÿÿÿÿÿÿM¯C¯Ï®€ÍÿÿÿÿÿÿW¯M¯[®€Îÿÿÿÿÿÿa¯W¯ç­€Ïÿÿÿÿÿÿk¯a¯s­€Ðÿÿÿÿÿÿu¯y‹ˆ€Ñÿÿÿÿÿÿ¯u¯kb€Òÿÿÿÿÿÿ‰¯¯„€€Óÿÿÿÿÿÿ“¯‰¯ú{€Ôÿÿÿÿÿÿ¯ð{“¯€Õÿÿÿÿÿÿ§¯Œ‹#ˆ€Öÿÿÿÿÿÿ±¯§¯"]€×ÿÿÿÿÿÿ»¯±¯—€€Øÿÿÿÿÿÿů»¯|€Ùÿÿÿÿÿÿϯ |ů€ÚÿÿÿÿÿÿÙ¯Š.-€Ûÿÿÿÿÿÿã¯Ù¯v€Üÿÿÿÿÿÿí¯ã¯Ç-€Ýÿÿÿÿÿÿ÷¯í¯g4€Þÿÿÿÿÿÿ°òh÷¯€ßÿÿÿÿÿÿ °©‹Jˆ€àÿÿÿÿÿÿ° °Ë\€áÿÿÿÿÿÿ°°È€€âÿÿÿÿÿÿ)°°H|€ãÿÿÿÿÿÿ3°?k)°€äÿÿÿÿÿÿ=°Æ‹]ˆ€åÿÿÿÿÿÿG°=°€æÿÿÿÿÿÿQ°çÿÿÿÿÿÿ[°[|€èÿÿÿÿÿÿe°d|€éÿÿÿÿÿÿo°e°3°€êÿÿÿÿÿÿy°o°°€ëÿÿÿÿÿÿƒ°y°Ï¯€ìÿÿÿÿÿÿ°ƒ°¯€íÿÿÿÿÿÿ—°½|“¯€îÿÿÿÿÿÿ¡°8iů€ïÿÿÿÿÿÿ«°ª€÷¯€ðÿÿÿÿÿÿµ°Ñ€)°€ñÿÿÿÿÿÿ¿°ø€€òÿÿÿÿÿÿÉ°¿°µ°€óÿÿÿÿÿÿÓ°É°«°€ôÿÿÿÿÿÿÝ°Ó°¡°€õÿÿÿÿÿÿç°Ý°—°€öÿÿÿÿÿÿñ°“}“¯€÷ÿÿÿÿÿÿû°~iů€øÿÿÿÿÿÿ±ì÷¯€ùÿÿÿÿÿÿ±À„)°€úÿÿÿÿÿÿ±E2€ûÿÿÿÿÿÿ#±±±€üÿÿÿÿÿÿ-±#±±€ýÿÿÿÿÿÿ7±-±û°€þÿÿÿÿÿÿA±7±ñ°€ÿÿÿÿÿÿÿK±°i“¯€ÿÿÿÿÿÿU±'‚ů€ÿÿÿÿÿÿ_±R…÷¯€ÿÿÿÿÿÿi±@ˆ)°€ÿÿÿÿÿÿs±…k€ÿÿÿÿÿÿ}±s±i±€ÿÿÿÿÿÿ‡±}±_±€ÿÿÿÿÿÿ‘±‡±U±€ÿÿÿÿÿÿ›±‘±K±€ÿÿÿÿÿÿ¥±T“¯€ ÿÿÿÿÿÿ¯± jů€ ÿÿÿÿÿÿ¹±fu÷¯€ ÿÿÿÿÿÿñîˆ)°€ ÿÿÿÿÿÿͱ¼‹€ ÿÿÿÿÿÿױͱñ€ÿÿÿÿÿÿá±×±¹±€ÿÿÿÿÿÿë±á±¯±€ÿÿÿÿÿÿõ±ë±¥±€ÿÿÿÿÿÿÿ±õ±›±€ÿÿÿÿÿÿ ²ÿ±A±€ÿÿÿÿÿÿ² ²ç°€ÿÿÿÿÿÿ²²°€Sÿÿÿÿÿÿ'²$iœ€>ÿÿÿÿÿÿ1²~'²€Sÿÿÿÿÿÿ;²f@œ€>ÿÿÿÿÿÿE²4;²€SÿÿÿÿÿÿO²¦iœ€>ÿÿÿÿÿÿY²<O²€Sÿÿÿÿÿÿc²ìiœ€>ÿÿÿÿÿÿm²°c²€ÿÿÿÿÿÿw²m²Y²€ÿÿÿÿÿÿ²w²E²€ÿÿÿÿÿÿ‹²²1²€ ÿÿÿÿÿÿ•²‹²Rx€!SÿÿÿÿÿÿŸ²Þh~€">ÿÿÿÿÿÿ©²œŸ²€#Sÿÿÿÿÿÿ³²x1~€$>ÿÿÿÿÿÿ½²4³²€%SÿÿÿÿÿÿDzºi~€&>ÿÿÿÿÿÿѲ<Dz€'SÿÿÿÿÿÿÛ²j~€(>ÿÿÿÿÿÿå²°Û²€)ÿÿÿÿÿÿï²å²Ñ²€*ÿÿÿÿÿÿù²ï²½²€+ÿÿÿÿÿÿ³ù²(y€,ÿÿÿÿÿÿ ³³©²€-Sÿÿÿÿÿÿ³ê'4€.>ÿÿÿÿÿÿ!³œ³€/Sÿÿÿÿÿÿ+³|$4€0>ÿÿÿÿÿÿ5³~+³€1Sÿÿÿÿÿÿ?³_$4€2>ÿÿÿÿÿÿI³<?³€3SÿÿÿÿÿÿS³£$4€4>ÿÿÿÿÿÿ]³°S³€5ÿÿÿÿÿÿg³]³I³€6ÿÿÿÿÿÿq³g³­$€7ÿÿÿÿÿÿ{³q³5³€8ÿÿÿÿÿÿ…³{³!³€9Sÿÿÿÿÿÿ³üh<€:>ÿÿÿÿÿÿ™³œ³€;Sÿÿÿÿÿÿ£³Li<€<>ÿÿÿÿÿÿ­³~£³€=Sÿÿÿÿÿÿ·³¿0<€>>ÿÿÿÿÿÿÁ³4·³€?Sÿÿÿÿÿÿ˳j<€@>ÿÿÿÿÿÿÕ³°Ë³€Aÿÿÿÿÿÿß³Õ³·z€Bÿÿÿÿÿÿé³ß³Á³€Cÿÿÿÿÿÿó³é³­³€Dÿÿÿÿÿÿý³ó³™³€ESÿÿÿÿÿÿ´i°€F>ÿÿÿÿÿÿ´œ´€GSÿÿÿÿÿÿ´`i°€H>ÿÿÿÿÿÿ%´~´€ISÿÿÿÿÿÿ/´;2°€J>ÿÿÿÿÿÿ9´4/´€KSÿÿÿÿÿÿC´Øi°€L>ÿÿÿÿÿÿM´<C´€MÿÿÿÿÿÿW´{M´€Nÿÿÿÿÿÿa´W´9´€Oÿÿÿÿÿÿk´a´%´€Pÿÿÿÿÿÿu´k´´€Qÿÿÿÿÿÿ´u´ý³€Rÿÿÿÿÿÿ‰´´…³€Sÿÿÿÿÿÿ“´‰´ ³€Tÿÿÿÿÿÿ´“´•²€Uÿÿÿÿÿÿ§´#{jz€Vÿÿÿÿÿÿ±´§´Îy€Wÿÿÿÿÿÿ»´±´y€XÿÿÿÿÿÿÅ´»´\x€YÿÿÿÿÿÿÏ´@{‡z€ZÿÿÿÿÿÿÙ´Ï´ëy€[ÿÿÿÿÿÿã´Ù´2y€\ÿÿÿÿÿÿí´ã´yx€]ÿÿÿÿÿÿ÷´]{¤z€^ÿÿÿÿÿÿµ÷´·$€_ÿÿÿÿÿÿ µµOy€`ÿÿÿÿÿÿµ µ–x€aÿÿÿÿÿÿµz{Áz€bÿÿÿÿÿÿ)µµz€cÿÿÿÿÿÿ3µ)µly€dÿÿÿÿÿÿ=µ3µ³x€eÿÿÿÿÿÿGµ—{Þz€fÿÿÿÿÿÿQµGµ%z€gÿÿÿÿÿÿ[µQµ‰y€hÿÿÿÿÿÿeµ[µÐx€iÿÿÿÿÿÿoµeµ=µ€jÿÿÿÿÿÿyµoµµ€kÿÿÿÿÿÿƒµyµí´€lÿÿÿÿÿÿµƒµÅ´@mÿÿÿÿÿÿ—µ1²@nÿÿÿÿÿÿ µE²@oÿÿÿÿÿÿ©µY²@pÿÿÿÿÿÿ²µm²€qÿÿÿÿÿÿ»µ²µ©µ€rÿÿÿÿÿÿŵ»µ µ€sÿÿÿÿÿÿϵŵ—µ€tÿÿÿÿÿÿٵϵ\x@uÿÿÿÿÿÿ㵩²@vÿÿÿÿÿÿìµ½²@wÿÿÿÿÿÿõµÑ²@xÿÿÿÿÿÿþµå²€yÿÿÿÿÿÿ¶þµõµ€zÿÿÿÿÿÿ¶¶ìµ€{ÿÿÿÿÿÿ¶¶2y€|ÿÿÿÿÿÿ%¶¶ãµ@}ÿÿÿÿÿÿ/¶!³@~ÿÿÿÿÿÿ8¶5³@ÿÿÿÿÿÿA¶I³@€ÿÿÿÿÿÿJ¶]³€ÿÿÿÿÿÿS¶J¶A¶€‚ÿÿÿÿÿÿ]¶S¶·$€ƒÿÿÿÿÿÿg¶]¶8¶€„ÿÿÿÿÿÿq¶g¶/¶@…ÿÿÿÿÿÿ{¶™³@†ÿÿÿÿÿÿ„¶­³@‡ÿÿÿÿÿÿ¶Á³@ˆÿÿÿÿÿÿ–¶Õ³€‰ÿÿÿÿÿÿŸ¶–¶Áz€Šÿÿÿÿÿÿ©¶Ÿ¶¶€‹ÿÿÿÿÿÿ³¶©¶„¶€Œÿÿÿÿÿÿ½¶³¶{¶@ÿÿÿÿÿÿǶ´@Žÿÿÿÿÿÿж%´@ÿÿÿÿÿÿÙ¶9´@ÿÿÿÿÿÿâ¶M´€‘ÿÿÿÿÿÿ붗{ⶀ’ÿÿÿÿÿÿõ¶ë¶Ù¶€“ÿÿÿÿÿÿÿ¶õ¶Ð¶€”ÿÿÿÿÿÿ ·ÿ¶Ç¶€•ÿÿÿÿÿÿ· ·½¶€–ÿÿÿÿÿÿ··q¶€—ÿÿÿÿÿÿ'··%¶€˜ÿÿÿÿÿÿ1·'·Ùµ€™ÿÿÿÿÿÿ;·¼‹@ˆ€šÿÿÿÿÿÿE·;·ì€›ÿÿÿÿÿÿO·E·8i€œÿÿÿÿÿÿY·O·ð{€ÿÿÿÿÿÿc·Ëª|€žÿÿÿÿÿÿm·~ƒc}€Ÿÿÿÿÿÿÿw·R†~€ ÿÿÿÿÿÿ·e‰Ì~€¡ÿÿÿÿÿÿ‹··w·€¢ÿÿÿÿÿÿ•·‹·m·€£ÿÿÿÿÿÿŸ·•·c·€¤ÿÿÿÿÿÿ©·Ÿ·ú{€¥ÿÿÿÿÿÿ³·„4€¦ÿÿÿÿÿÿ½·í†Ú€§ÿÿÿÿÿÿÇ·ö‰‚€¨ÿÿÿÿÿÿÑ·Ç·½·€©ÿÿÿÿÿÿÛ·Ñ·³·€ªÿÿÿÿÿÿå·Û·„€€«ÿÿÿÿÿÿï·å·õœ€¬ÿÿÿÿÿÿù·4„€­ÿÿÿÿÿÿ¸ˆ‡…€®ÿÿÿÿÿÿ ¸}Š«…€¯ÿÿÿÿÿÿ¸ ¸¸€°ÿÿÿÿÿÿ!¸¸kb€±ÿÿÿÿÿÿ+¸!¸ù·€²ÿÿÿÿÿÿ5¸+¸O€³ÿÿÿÿÿÿ?¸Ú톀´ÿÿÿÿÿÿI¸…ˆ‡€µÿÿÿÿÿÿS¸òŠ˜ˆ€¶ÿÿÿÿÿÿ]¸S¸ˆ€·ÿÿÿÿÿÿg¸]¸I¸€¸ÿÿÿÿÿÿq¸g¸?¸€¹ÿÿÿÿÿÿ{¸q¸©€ºÿÿÿÿÿÿ…¸‚ö‰€»ÿÿÿÿÿÿ¸«…}Š€¼ÿÿÿÿÿÿ™¸˜ˆòŠ€½ÿÿÿÿÿÿ£¸y‹™¸€¾ÿÿÿÿÿÿ­¸£¸¸€¿ÿÿÿÿÿÿ·¸­¸…¸€ÀÿÿÿÿÿÿÁ¸·¸ž€Áÿÿÿÿÿÿ˸Á¸{¸€Âÿÿÿÿÿÿո˸5¸€Ãÿÿÿÿÿÿ߸ոﷀÄÿÿÿÿÿÿé¸ß¸©·€Åÿÿÿÿÿÿ󸑃v}€Æÿÿÿÿÿÿý¸e†0~€Çÿÿÿÿÿÿ¹x‰é~€Èÿÿÿÿÿÿ¹¹ý¸€Éÿÿÿÿÿÿ¹¹ó¸€Êÿÿÿÿÿÿ%¹¹ž€Ëÿÿÿÿÿÿ/¹%¹|€Ìÿÿÿÿÿÿ9¹Ç|è€ÍÿÿÿÿÿÿC¹-„Q€ÎÿÿÿÿÿÿM¹‡÷€ÏÿÿÿÿÿÿW¹ Šº‚€Ðÿÿÿÿÿÿa¹W¹M¹€Ñÿÿÿÿÿÿk¹a¹C¹€Òÿÿÿÿÿÿu¹k¹—€€Óÿÿÿÿÿÿ¹u¹9¹€Ôÿÿÿÿÿÿ‰¹v}‘ƒ€Õÿÿÿÿÿÿ“¹›‡"…€Öÿÿÿÿÿÿ¹Š¾…€×ÿÿÿÿÿÿ§¹¹“¹€Øÿÿÿÿÿÿ±¹§¹"]€Ùÿÿÿÿÿÿ»¹±¹9Ÿ€ÚÿÿÿÿÿÿŹ»¹‰¹€ÛÿÿÿÿÿÿϹ0~e†€ÜÿÿÿÿÿÿÙ¹"…›‡€Ýÿÿÿÿÿÿ㹋«ˆ€Þÿÿÿÿÿÿí¹ã¹#ˆ€ßÿÿÿÿÿÿ÷¹í¹Ù¹€àÿÿÿÿÿÿº÷¹“Ÿ€áÿÿÿÿÿÿ ººÏ¹€âÿÿÿÿÿÿºé~x‰€ãÿÿÿÿÿÿº¾…Š€äÿÿÿÿÿÿ)º«ˆ‹€åÿÿÿÿÿÿ3ºŒ‹)º€æÿÿÿÿÿÿ=º3ºº€çÿÿÿÿÿÿGº=ºíŸ€èÿÿÿÿÿÿQºGºº€éÿÿÿÿÿÿ[ºQº º€êÿÿÿÿÿÿeº[ºÅ¹€ëÿÿÿÿÿÿoºeº¹€ìÿÿÿÿÿÿyºoº/¹€íÿÿÿÿÿÿƒº€î|€îÿÿÿÿÿÿºx†C~€ïÿÿÿÿÿÿ—º‹‰€ðÿÿÿÿÿÿ¡º—ºº€ñÿÿÿÿÿÿ«º¡ºy €òÿÿÿÿÿÿµº«ºƒº€óÿÿÿÿÿÿ¿ºµºg4€ôÿÿÿÿÿÿɺî|€€õÿÿÿÿÿÿÓº‡‚€öÿÿÿÿÿÿݺŠ×‚€÷ÿÿÿÿÿÿçºÝºÓº€øÿÿÿÿÿÿñºçºÓ €ùÿÿÿÿÿÿûºñºÇ-€úÿÿÿÿÿÿ»ûºÉº€ûÿÿÿÿÿÿ»}¤ƒ€üÿÿÿÿÿÿ»d@„€ýÿÿÿÿÿÿ#»®‡?…€þÿÿÿÿÿÿ-»O2·$€ÿÿÿÿÿÿÿ7»-»#»€ÿÿÿÿÿÿA»7»v€ÿÿÿÿÿÿK»A»»€ÿÿÿÿÿÿU»K»»€ÿÿÿÿÿÿ_»C~x†€ÿÿÿÿÿÿi»‚‡€ÿÿÿÿÿÿs»‹¾ˆ€ÿÿÿÿÿÿ}»s»-€ÿÿÿÿÿÿ‡»}»}¡€ÿÿÿÿÿÿ‘»‡»i»€ ÿÿÿÿÿÿ›»‘»_»€ ÿÿÿÿÿÿ¥»‹‰€ ÿÿÿÿÿÿ¯»×‚Š€ ÿÿÿÿÿÿ¹»¾ˆ‹€ ÿÿÿÿÿÿûŠ.¹»€ÿÿÿÿÿÿͻûס€ÿÿÿÿÿÿ׻ͻ¯»€ÿÿÿÿÿÿá»×»¥»€ÿÿÿÿÿÿë»á»›»€ÿÿÿÿÿÿõ»ë»U»€ÿÿÿÿÿÿÿ»õ»»€ÿÿÿÿÿÿ ¼ÿ»¿º€ÿÿÿÿÿÿ¼"€}€ÿÿÿÿÿÿ¼Áƒº}€ÿÿÿÿÿÿ'¼ž‰7€ÿÿÿÿÿÿ1¼'¼c¢€ÿÿÿÿÿÿ;¼1¼¼€ÿÿÿÿÿÿE¼;¼¼€ÿÿÿÿÿÿO¼E¼H|€ÿÿÿÿÿÿY¼}"€€ÿÿÿÿÿÿc¼]„€ÿÿÿÿÿÿm¼/Šþ‚€ÿÿÿÿÿÿw¼m¼½¢€ ÿÿÿÿÿÿ¼w¼c¼€!ÿÿÿÿÿÿ‹¼¼È€€"ÿÿÿÿÿÿ•¼‹¼Y¼€#ÿÿÿÿÿÿŸ¼º}Áƒ€$ÿÿÿÿÿÿ©¼]„€%ÿÿÿÿÿÿ³¼­ŠÛ…€&ÿÿÿÿÿÿ½¼³¼£€'ÿÿÿÿÿÿǼ½¼Ë\€(ÿÿÿÿÿÿѼǼ©¼€)ÿÿÿÿÿÿۼѼŸ¼€*ÿÿÿÿÿÿå¼`~•†€+ÿÿÿÿÿÿï¼1‚0‡€,ÿÿÿÿÿÿù¼\…Á‡€-ÿÿÿÿÿÿ½+‹Ûˆ€.ÿÿÿÿÿÿ ½½Jˆ€/ÿÿÿÿÿÿ½ ½ù¼€0ÿÿÿÿÿÿ!½½ï¼€1ÿÿÿÿÿÿ+½!½å¼€2ÿÿÿÿÿÿ5½7ž‰€3ÿÿÿÿÿÿ?½þ‚/Š€4ÿÿÿÿÿÿI½Û…­Š€5ÿÿÿÿÿÿS½©‹Á£€6ÿÿÿÿÿÿ]½S½I½€7ÿÿÿÿÿÿg½]½?½€8ÿÿÿÿÿÿq½g½5½€9ÿÿÿÿÿÿ{½q½+½€:ÿÿÿÿÿÿ…½{½Û¼€;ÿÿÿÿÿÿ½…½•¼€<ÿÿÿÿÿÿ™½½O¼€=ÿÿÿÿÿÿ£½I€}€>ÿÿÿÿÿÿ­½ëtKo€?ÿÿÿÿÿÿ·½¨†‡~€@ÿÿÿÿÿÿÁ½M¤·½€Aÿÿÿÿÿÿ˽Á½­½€Bÿÿÿÿÿÿս˽£½€Cÿÿÿÿÿÿß½Õ½[|€Dÿÿÿÿÿÿé½}I€€Eÿÿÿÿÿÿó½þt^o€Fÿÿÿÿÿÿý½M‡X‚€Gÿÿÿÿÿÿ¾§¤ý½€Hÿÿÿÿÿÿ¾¾ó½€Iÿÿÿÿÿÿ¾¾ï€€Jÿÿÿÿÿÿ%¾¾é½€Kÿÿÿÿÿÿ/¾Koët€Lÿÿÿÿÿÿ9¾^oþt€MÿÿÿÿÿÿC¾—o7u€NÿÿÿÿÿÿM¾¥C¾€OÿÿÿÿÿÿW¾M¾Ô„€Pÿÿÿÿÿÿa¾W¾9¾€Qÿÿÿÿÿÿk¾a¾/¾€Rÿÿÿÿÿÿu¾‡~¨†€Sÿÿÿÿÿÿ¾X‚M‡€Tÿÿÿÿÿÿ‰¾7u—o€Uÿÿÿÿÿÿ“¾[¥]ˆ€Vÿÿÿÿÿÿ¾“¾‰¾€Wÿÿÿÿÿÿ§¾¾¾€Xÿÿÿÿÿÿ±¾§¾u¾€Yÿÿÿÿÿÿ»¾^»‰€ZÿÿÿÿÿÿžƒBŠ€[ÿÿÿÿÿÿϾpuÐo€\ÿÿÿÿÿÿÙ¾øˆ>‹€]ÿÿÿÿÿÿã¾Æ‹Ù¾€^ÿÿÿÿÿÿí¾ã¾Ï¾€_ÿÿÿÿÿÿ÷¾í¾Å¾€`ÿÿÿÿÿÿ¿÷¾»¾€aÿÿÿÿÿÿ ¿¿±¾€bÿÿÿÿÿÿ¿ ¿k¾€cÿÿÿÿÿÿ¿¿%¾€dÿÿÿÿÿÿ)¿¿ß½€eÿÿÿÿÿÿ3¿)¿™½€fÿÿÿÿÿÿ=¿3¿ ¼€gÿÿÿÿÿÿG¿=¿yº€hÿÿÿÿÿÿQ¿G¿é¸€iÿÿÿÿÿÿ[¿[°)°€jÿÿÿÿÿÿe¿[¿÷¯€kÿÿÿÿÿÿo¿e¿Å¯€lÿÿÿÿÿÿy¿o¿“¯€mÿÿÿÿÿÿƒ¿öi ~€nÿÿÿÿÿÿ¿ƒ¿Y}€oÿÿÿÿÿÿ—¿¿ |€pÿÿÿÿÿÿ¡¿—¿ð{€qÿÿÿÿÿÿ«¿d|?k€rÿÿÿÿÿÿµ¿«¿òh€sÿÿÿÿÿÿ¿¿µ¿ |€tÿÿÿÿÿÿÉ¿¿¿ð{€uÿÿÿÿÿÿÓ¿É¿¡¿€vÿÿÿÿÿÿÝ¿ß~&~€wÿÿÿÿÿÿç¿Ý¿ti€xÿÿÿÿÿÿñ¿ç¿½|€yÿÿÿÿÿÿû¿ñ¿ |€zÿÿÿÿÿÿÀi+€€{ÿÿÿÿÿÿÀÀ€€|ÿÿÿÿÿÿÀÀÞ€}ÿÿÿÿÿÿ#ÀÀ |€~ÿÿÿÿÿÿ-À#Àû¿€ÿÿÿÿÿÿ7Àqk€€ÿÿÿÿÿÿAÀ7À“}€ÿÿÿÿÿÿKÀAÀä|€‚ÿÿÿÿÿÿUÀKÀ]4€ƒÿÿÿÿÿÿ_Àރʃ€„ÿÿÿÿÿÿiÀ_À5k€…ÿÿÿÿÿÿsÀiÀû€†ÿÿÿÿÿÿ}ÀsÀ]4€‡ÿÿÿÿÿÿ‡À}ÀUÀ€ˆÿÿÿÿÿÿ‘À-°i€‰ÿÿÿÿÿÿ›À‘À°}€Šÿÿÿÿÿÿ¥À›ÀIk€‹ÿÿÿÿÿÿ¯À¥À>|€Œÿÿÿÿÿÿ¹À±†‹†€ÿÿÿÿÿÿÃÀ¹À·ƒ€ŽÿÿÿÿÿÿÍÀÃÀèh€ÿÿÿÿÿÿ×ÀÍÀ>|€ÿÿÿÿÿÿáÀ×À¯À€‘ÿÿÿÿÿÿëÀT}~€’ÿÿÿÿÿÿõÀëÀAo€“ÿÿÿÿÿÿÿÀõÀ.i€”ÿÿÿÿÿÿ ÁÿÀ+k€•ÿÿÿÿÿÿÁ±‰i€–ÿÿÿÿÿÿÁÁát€—ÿÿÿÿÿÿ'ÁÁ?€€˜ÿÿÿÿÿÿ1Á'Á+k€™ÿÿÿÿÿÿ;Á1Á Á€šÿÿÿÿÿÿEÁ;ÁáÀ€›ÿÿÿÿÿÿOÁEÁ‡À€œÿÿÿÿÿÿYÁOÁ-À€ÿÿÿÿÿÿcÁYÁÓ¿€žÿÿÿÿÿÿmÁò~Äi€ŸÿÿÿÿÿÿwÁmÁ}€ ÿÿÿÿÿÿÁwÁÐ|€¡ÿÿÿÿÿÿ‹ÁÁ |€¢ÿÿÿÿÿÿ•Á}Vi€£ÿÿÿÿÿÿŸÁ•ÁSk€¤ÿÿÿÿÿÿ©ÁŸÁÐ|€¥ÿÿÿÿÿÿ³Á©Á |€¦ÿÿÿÿÿÿ½Á³Á‹Á€§ÿÿÿÿÿÿÇÁ°‚퀨ÿÿÿÿÿÿÑÁÇÁG€©ÿÿÿÿÿÿÛÁÑÁ8i€ªÿÿÿÿÿÿåÁÛÁÞ€«ÿÿÿÿÿÿïÁø€Ñ€€¬ÿÿÿÿÿÿùÁïÁª€€­ÿÿÿÿÿÿÂùÁ8i€®ÿÿÿÿÿÿ ½|€¯ÿÿÿÿÿÿ ÂåÁ€°ÿÿÿÿÿÿ!ÂÍ‚ ‚€±ÿÿÿÿÿÿ+Â!Â~i€²ÿÿÿÿÿÿ5Â+½-€³ÿÿÿÿÿÿ?Â5Âû€´ÿÿÿÿÿÿIÂp„]k€µÿÿÿÿÿÿSÂIÂBi€¶ÿÿÿÿÿÿ]ÂS½-€·ÿÿÿÿÿÿgÂ]Âä|€¸ÿÿÿÿÿÿqÂgÂ?€¹ÿÿÿÿÿÿ{Âô‚'‚€ºÿÿÿÿÿÿ…Â{Âw€»ÿÿÿÿÿÿ…¾€€¼ÿÿÿÿÿÿ™ÂÂèh€½ÿÿÿÿÿÿ£Âji&‡€¾ÿÿÿÿÿÿ­Â£ÂS„€¿ÿÿÿÿÿÿ·Â­Â¾€€ÀÿÿÿÿÿÿÁ·ÂIk€ÁÿÿÿÿÿÿËÂÁ™€ÂÿÿÿÿÿÿÕ jN‚€ÃÿÿÿÿÿÿßÂÕÂTo€ÄÿÿÿÿÿÿéÂßÂ倀ÅÿÿÿÿÿÿóÂéÂ?€€ÆÿÿÿÿÿÿýÂgkC‡€ÇÿÿÿÿÿÿÃýÂôt€ÈÿÿÿÿÿÿÃÃ倀ÉÿÿÿÿÿÿÃÃ.i€Êÿÿÿÿÿÿ%ÃÃó€Ëÿÿÿÿÿÿ/Ã%ÃË€Ìÿÿÿÿÿÿ9Ã/Ãq€ÍÿÿÿÿÿÿCÃ9ÀÎÿÿÿÿÿÿMÃCýÁ€ÏÿÿÿÿÿÿWÃL~€ÐÿÿÿÿÿÿaÃWÃab€ÑÿÿÿÿÿÿkÃaÃSk€ÒÿÿÿÿÿÿuÃkÃòh€ÓÿÿÿÿÿÿÃœiÃ}€Ôÿÿÿÿÿÿ‰ÃÃab€Õÿÿÿÿÿÿ“ÉÃ}€ÖÿÿÿÿÿÿÓÃY}€×ÿÿÿÿÿÿ§ÃÃuÀØÿÿÿÿÿÿ±Ãà‚Îi€Ùÿÿÿÿÿÿ»Ã±Ã]€ÚÿÿÿÿÿÿÅûꀀÛÿÿÿÿÿÿÏÃÅÀ€ÜÿÿÿÿÿÿÙÞŠ€ÝÿÿÿÿÿÿãÃÙÃ]€ÞÿÿÿÿÿÿíÃãÃG€ßÿÿÿÿÿÿ÷ÃíÃti€àÿÿÿÿÿÿÄ÷ÃÏÀáÿÿÿÿÿÿ Ä­$5…€âÿÿÿÿÿÿÄ Äì€ãÿÿÿÿÿÿÄÄBi€äÿÿÿÿÿÿ)ÄÄ5k€åÿÿÿÿÿÿ3ÄE2À„€æÿÿÿÿÿÿ=Ä3Äì€çÿÿÿÿÿÿGÄ=Ä~i€èÿÿÿÿÿÿQÄGÄ“}€éÿÿÿÿÿÿ[ÄQÄ)Ä€êÿÿÿÿÿÿeÄjR…€ëÿÿÿÿÿÿoÄeÄÁ\€ìÿÿÿÿÿÿyÄoÄS„€íÿÿÿÿÿÿƒÄyÄ·ƒ€îÿÿÿÿÿÿÄÔ‡’i€ïÿÿÿÿÿÿ—ÄÄÁ\€ðÿÿÿÿÿÿ¡Ä—Äw€ñÿÿÿÿÿÿ«Ä¡Ä°}€òÿÿÿÿÿÿµÄ«ÄƒÄ€óÿÿÿÿÿÿ¿Äfu-u€ôÿÿÿÿÿÿÉĿĈi€õÿÿÿÿÿÿÓÄÉÄôt€öÿÿÿÿÿÿÝÄÓÄát€÷ÿÿÿÿÿÿçÄÆoo€øÿÿÿÿÿÿñÄçĈi€ùÿÿÿÿÿÿûÄñÄTo€úÿÿÿÿÿÿÅûÄAo€ûÿÿÿÿÿÿÅÅÝÄ€üÿÿÿÿÿÿÅŵĀýÿÿÿÿÿÿ#ÅÅ[Ä€þÿÿÿÿÿÿ-Å#ÅÄ€ÿÿÿÿÿÿÿ7Å-ŧÀÿÿÿÿÿÿAÅ@i~€ÿÿÿÿÿÿKÅAÅÃ}€ÿÿÿÿÿÿUÅKÅVi€ÿÿÿÿÿÿ_ÅUÅ?k€ÿÿÿÿÿÿiÅ~i~€ÿÿÿÿÿÿsÅiÅL~€ÿÿÿÿÿÿ}ÅsÅÄi€ÿÿÿÿÿÿ‡Å}Å ~€ÿÿÿÿÿÿ‘ŇÅ_Å€ ÿÿÿÿÿÿ›Å(j:‚€ ÿÿÿÿÿÿ¥Å›ÅŠ€ ÿÿÿÿÿÿ¯Å¥ÅÑ€€ ÿÿÿÿÿÿ¹Å¯Å+€€ ÿÿÿÿÿÿÃÅa‚:‚€ÿÿÿÿÿÿÍÅÃÅÎi€ÿÿÿÿÿÿ×ÅÍÅí€ÿÿÿÿÿÿáÅ×Å&~€ÿÿÿÿÿÿëÅáŹŀÿÿÿÿÿÿõÅä…-€ÿÿÿÿÿÿÿÅõÅÀ„€ÿÿÿÿÿÿ ÆÿÅ]k€ÿÿÿÿÿÿÆ Æʃ€ÿÿÿÿÿÿÆo…-€ÿÿÿÿÿÿ'ÆÆ5…€ÿÿÿÿÿÿ1Æ'Æ ‚€ÿÿÿÿÿÿ;Æ1Æqk€ÿÿÿÿÿÿEÆ;ÆÆ€ÿÿÿÿÿÿOÆш@ˆ€ÿÿÿÿÿÿYÆOÆ’i€ÿÿÿÿÿÿcÆYÆ&‡€ÿÿÿÿÿÿmÆcÆ‹†€ÿÿÿÿÿÿwÆ…k@ˆ€ ÿÿÿÿÿÿÆwÆR…€!ÿÿÿÿÿÿ‹ÆÆ'‚€"ÿÿÿÿÿÿ•Æ‹Æ°i€#ÿÿÿÿÿÿŸÆ•ÆmÆ€$ÿÿÿÿÿÿ©Æîˆ{k€%ÿÿÿÿÿÿ³Æ©Æo€&ÿÿÿÿÿÿ½Æ³ÆC‡€'ÿÿÿÿÿÿÇƽÆi€(ÿÿÿÿÿÿÑÆâi{k€)ÿÿÿÿÿÿÛÆÑÆ-u€*ÿÿÿÿÿÿåÆÛÆN‚€+ÿÿÿÿÿÿïÆåÆ}~€,ÿÿÿÿÿÿùÆïÆÇÆ€-ÿÿÿÿÿÿÇùÆŸÆ€.ÿÿÿÿÿÿ ÇÇEÆ€/ÿÿÿÿÿÿÇ ÇëÅ€0ÿÿÿÿÿÿ!ÇÇ‘Å€1ÿÿÿÿÿÿ+Çg~€2ÿÿÿÿÿÿ5Ç+Çœi€3ÿÿÿÿÿÿ?Ç5Ç}€4ÿÿÿÿÿÿIÇ?Çd|€5ÿÿÿÿÿÿSÇg@€6ÿÿÿÿÿÿ]ÇSÇ€7ÿÿÿÿÿÿgÇ]Çò~€8ÿÿÿÿÿÿqÇgÇöi€9ÿÿÿÿÿÿ{ÇqÇIÇ€:ÿÿÿÿÿÿ…ǃa‚€;ÿÿÿÿÿÿÇ…Çž€<ÿÿÿÿÿÿ™ÇÇø€€=ÿÿÿÿÿÿ£Ç™Çi€>ÿÿÿÿÿÿ­Çƒ(j€?ÿÿÿÿÿÿ·Ç­Çà‚€@ÿÿÿÿÿÿÁÇ·Ç°‚€AÿÿÿÿÿÿËÇÁÇß~€BÿÿÿÿÿÿÕÇËǣǀCÿÿÿÿÿÿßÇ€.o…€DÿÿÿÿÿÿéÇßÇE2€EÿÿÿÿÿÿóÇéÇp„€FÿÿÿÿÿÿýÇóÇÞƒ€GÿÿÿÿÿÿÈ€.ä…€HÿÿÿÿÿÿÈÈ­$€IÿÿÿÿÿÿÈÈÍ‚€Jÿÿÿÿÿÿ%ÈÈ€Kÿÿÿÿÿÿ/È%ÈýÇ€Lÿÿÿÿÿÿ9ȉ…k€MÿÿÿÿÿÿCÈ9ÈÔ‡€NÿÿÿÿÿÿMÈCÈji€OÿÿÿÿÿÿWÈMȱ†€Pÿÿÿÿÿÿaȉш€QÿÿÿÿÿÿkÈaÈj€RÿÿÿÿÿÿuÈkÈô‚€SÿÿÿÿÿÿÈuÈ-€Tÿÿÿÿÿÿ‰ÈÈWÈ€Uÿÿÿÿÿÿ“ȼ‹âi€VÿÿÿÿÿÿÈ“ÈÆo€Wÿÿÿÿÿÿ§ÈÈgk€Xÿÿÿÿÿÿ±È§È±‰€Yÿÿÿÿÿÿ»È¼‹îˆ€ZÿÿÿÿÿÿÅÈ»Èfu€[ÿÿÿÿÿÿÏÈÅÈ j€\ÿÿÿÿÿÿÙÈÏÈT€]ÿÿÿÿÿÿãÈÙȱȀ^ÿÿÿÿÿÿíÈãȉȀ_ÿÿÿÿÿÿ÷ÈíÈ/È€`ÿÿÿÿÿÿÉ÷ÈÕÇ€aÿÿÿÿÿÿ ÉÉ{Ç€bÿÿÿÿÿÿÉ É!Ç€cÿÿÿÿÿÿÉÉ7Å€dÿÿÿÿÿÿ)ÉÉMÀeÿÿÿÿÿÿ3É)ÉcÁ€fÿÿÿÿÿÿ=É+k>|€gÿÿÿÿÿÿGÉ=É]4€hÿÿÿÿÿÿQÉGÉ |€iÿÿÿÿÿÿ[ÉQÉð{€jÿÿÿÿÿÿeÉ?€èh€kÿÿÿÿÿÿoÉeÉû€lÿÿÿÿÿÿyÉoÉÞ€mÿÿÿÿÿÿƒÉyÉ |€nÿÿÿÿÿÿÉát·ƒ€oÿÿÿÿÿÿ—ÉÉ5k€pÿÿÿÿÿÿ¡É—É€€qÿÿÿÿÿÿ«É¡Éòh€rÿÿÿÿÿÿµÉi‹†€sÿÿÿÿÿÿ¿ÉµÉʃ€tÿÿÿÿÿÿÉÉ¿É+€€uÿÿÿÿÿÿÓÉÉÉ?k€vÿÿÿÿÿÿÝɱ‰±†€wÿÿÿÿÿÿçÉÝÉÞƒ€xÿÿÿÿÿÿñÉçÉi€yÿÿÿÿÿÿûÉñÉd|€zÿÿÿÿÿÿÊûÉÓÉ€{ÿÿÿÿÿÿÊÊ«É€|ÿÿÿÿÿÿÊʃɀ}ÿÿÿÿÿÿ#ÊÊ[É€~ÿÿÿÿÿÿ-Ê.iIk€ÿÿÿÿÿÿ7Ê-Êä|€€ÿÿÿÿÿÿAÊ7ʽ|€ÿÿÿÿÿÿKÊAÊ |€‚ÿÿÿÿÿÿUÊ倾€€ƒÿÿÿÿÿÿ_ÊUʽ-€„ÿÿÿÿÿÿiÊ_Ê8i€…ÿÿÿÿÿÿsÊiÊÐ|€†ÿÿÿÿÿÿ}ÊôtS„€‡ÿÿÿÿÿÿ‡Ê}ÊBi€ˆÿÿÿÿÿÿ‘ʇʪ€€‰ÿÿÿÿÿÿ›Ê‘ÊSk€Šÿÿÿÿÿÿ¥ÊC‡&‡€‹ÿÿÿÿÿÿ¯Ê¥Ê]k€Œÿÿÿÿÿÿ¹Ê¯ÊÑ€€ÿÿÿÿÿÿÃʹÊVi€ŽÿÿÿÿÿÿÍÊgkji€ÿÿÿÿÿÿ×ÊÍÊp„€ÿÿÿÿÿÿáÊ×Êø€€‘ÿÿÿÿÿÿëÊáÊ}€’ÿÿÿÿÿÿõÊëÊÃÊ€“ÿÿÿÿÿÿÿÊõʛʀ”ÿÿÿÿÿÿ ËÿÊsÊ€•ÿÿÿÿÿÿË ËKÊ€–ÿÿÿÿÿÿËAo°}€—ÿÿÿÿÿÿ'ËË“}€˜ÿÿÿÿÿÿ1Ë'Ëti€™ÿÿÿÿÿÿ;Ë1ËY}€šÿÿÿÿÿÿEËTow€›ÿÿÿÿÿÿOËEË~i€œÿÿÿÿÿÿYËOËG€ÿÿÿÿÿÿcËYË}€žÿÿÿÿÿÿmˈiÁ\€ŸÿÿÿÿÿÿwËmË쀠ÿÿÿÿÿÿËwË]€¡ÿÿÿÿÿÿ‹ËËab€¢ÿÿÿÿÿÿ•Ëo’i€£ÿÿÿÿÿÿŸË•ËÀ„€¤ÿÿÿÿÿÿ©ËŸËŠ€¥ÿÿÿÿÿÿ³Ë©ËÃ}€¦ÿÿÿÿÿÿ½ËÆoÔ‡€§ÿÿÿÿÿÿÇ˽ËE2€¨ÿÿÿÿÿÿÑËÇËž€©ÿÿÿÿÿÿÛËÑËœi€ªÿÿÿÿÿÿåËÛ˳ˀ«ÿÿÿÿÿÿïËåË‹Ë€¬ÿÿÿÿÿÿùËïËcË€­ÿÿÿÿÿÿÌùË;Ë€®ÿÿÿÿÿÿ Ì}~°i€¯ÿÿÿÿÿÿÌ Ìqk€°ÿÿÿÿÿÿ!ÌÌ&~€±ÿÿÿÿÿÿ+Ì!Ì ~€²ÿÿÿÿÿÿ5ÌN‚'‚€³ÿÿÿÿÿÿ?Ì5Ì ‚€´ÿÿÿÿÿÿIÌ?Ì퀵ÿÿÿÿÿÿSÌIÌÄi€¶ÿÿÿÿÿÿ]Ì-uR…€·ÿÿÿÿÿÿgÌ]Ì5…€¸ÿÿÿÿÿÿqÌgÌÎi€¹ÿÿÿÿÿÿ{ÌqÌL~€ºÿÿÿÿÿÿ…Ì{k@ˆ€»ÿÿÿÿÿÿÌ…Ì-€¼ÿÿÿÿÿÿ™ÌÌ:‚€½ÿÿÿÿÿÿ£Ì™Ìi~€¾ÿÿÿÿÿÿ­Ìâi…k€¿ÿÿÿÿÿÿ·Ì­Ìo…€ÀÿÿÿÿÿÿÁÌ·Ìa‚€ÁÿÿÿÿÿÿËÌÁÌ~€ÂÿÿÿÿÿÿÕÌẸ̈̀ÃÿÿÿÿÿÿßÌÕÌ{Ì€ÄÿÿÿÿÿÿéÌßÌSÌ€ÅÿÿÿÿÿÿóÌéÌ+Ì€ÆÿÿÿÿÿÿýÌT-€ÇÿÿÿÿÿÿÍýÌ€ÈÿÿÿÿÿÿÍÍß~€ÉÿÿÿÿÿÿÍÍöi€Êÿÿÿÿÿÿ%Í jô‚€Ëÿÿÿÿÿÿ/Í%ÍÍ‚€Ìÿÿÿÿÿÿ9Í/Í°‚€ÍÿÿÿÿÿÿCÍ9Íò~€ÎÿÿÿÿÿÿMÍfuj€ÏÿÿÿÿÿÿWÍMÍ­$€ÐÿÿÿÿÿÿaÍWÍà‚€ÑÿÿÿÿÿÿkÍaÍ€ÒÿÿÿÿÿÿuÍîˆÑˆ€ÓÿÿÿÿÿÿÍuÍä…€Ôÿÿÿÿÿÿ‰ÍÍ(j€Õÿÿÿÿÿÿ“͉Í@€Öÿÿÿÿÿÿͼ‹‰€×ÿÿÿÿÿÿ§ÍÍ€.€Øÿÿÿÿÿÿ±Í§Íƒ€Ùÿÿÿÿÿÿ»Í±Íg€ÚÿÿÿÿÿÿÅͻ͓̀ÛÿÿÿÿÿÿÏÍÅÍkÍ€ÜÿÿÿÿÿÿÙÍÏÍCÍ€ÝÿÿÿÿÿÿãÍÙÍÍ€ÞÿÿÿÿÿÿíÍãÍóÌ€ßÿÿÿÿÿÿ÷ÍíÍÌ€àÿÿÿÿÿÿÎ÷ÍË€áÿÿÿÿÿÿ ÎÎ#ÊâÿÿÿÿÿÿÎ Î3Éy¿Q¿Y·1·µ´²k¯ÿ¬Ë©#¦›œšç–÷•GŒæ{>xôltlWl"k6ãÿÿÿÿÿÿ5Î ÙÙóØæØÙØÌؿزإؘ؋Ø~ØdØWØJØ=Ø0Ø#ØØ Øü×ï×â×Õ×È׻׮סהׇ×z×m×`×S×F×9×,××××øÖëÖÞÖÑÖªÖÖÖƒÖvÖiÖ\ÖOÖBÖ5Ö(ÖÖÖÖôÕçÕÚÕÍÕÀÕ³Õ¦Õ™ÕŒÕÕeÕKÕ1ÕÕäÚØÚÓËÚ¾Ú±Ú•ÚˆÚ{ÚnÚaÚ/ÑÑûÐáÐÇÐ3Ú&ÚÚØْϸÙPÏ/Ï«Ù³w wwzwgwTwAw.www›vˆvuvbvOv‹Jˆ?…÷~@ÿÿÿÿÿÿÒÆ‹Ûˆ·$º‚Ì~@ ÿÿÿÿÿÿ"Ò%zz·$ëyÎy@ ÿÿÿÿÿÿ/ÒÞzÁz¤z‡zjz@ ÿÿÿÿÿÿ<Ò—{z{]{@{#{@ ÿÿÿÿÿÿIÒðÔãÔÖÔÉÔVÒ@ ÿÿÿÿÿÿVÒµ¦˜¦{¦^¦A¦@ÿÿÿÿÿÿcÒ¼Ô¯Ô¢Ô•ÔpÒ@ÿÿÿÿÿÿpÒ@ª#ªªé©—@ÿÿÿÿÿÿ}ÒˆÔ{ÔnÔaÔŠÒ@ÿÿÿÿÿÿŠÒL­9­&­­A¦@ÿÿÿÿÿÿ—Òñ¹±¯±¥±i±_±U±K±±±û°ñ°µ°«°¡°—°3°°Ï¯¯@ÿÿÿÿÿÿ¸ÒTÔGÔ:Ô-ÔÅÒ@ÿÿÿÿÿÿÅÒm²Y²E²1²Rx@ÿÿÿÿÿÿÒÒ ÔÔÔùÓßÒ@ÿÿÿÿÿÿßÒ#{jzÎyy\x@ÿÿÿÿÿÿìÒìÓßÓÒÓÓùÒ@ÿÿÿÿÿÿùÒ²µ©µ µ—µ\x@ÿÿÿÿÿÿÓ¼‹@ˆì8ið{@ÿÿÿÿÿÿÓþµõµìµ2yãµ@ÿÿÿÿÿÿ ÓÓoÓNÓ-Ó@ÿÿÿÿÿÿ-Óy‹™¸¸…¸žS¸ˆI¸?¸© ¸¸kbù·OÇ·½·³·„€õœ·w·m·c·ú{@ÿÿÿÿÿÿNÓŒ‹)ººíŸºã¹#ˆÙ¹“ŸÏ¹¹“¹"]9Ÿ‰¹W¹M¹C¹—€9¹¹ý¸ó¸ž|@ÿÿÿÿÿÿoÓŠ.¹»×¡¯»¥»s»-}¡i»_»-»#»v»»ÝºÓºÓ Ç-ɺ—ººy ƒºg4@ÿÿÿÿÿÿÓ©‹Á£I½?½5½½Jˆù¼ï¼å¼³¼£Ë\©¼Ÿ¼m¼½¢c¼È€Y¼'¼c¢¼¼H|@ ÿÿÿÿÿÿ±ÓƋپϾž»¾[¥]ˆ‰¾¾u¾¥C¾9¾/¾§¤ý½ó½ï€é½M¤·½­½£½[|@!ÿÿÿÿÿÿÒÓJ¶A¶·$8¶/¶@"ÿÿÿÿÿÿßÓ–¶Áz¶„¶{¶@#ÿÿÿÿÿÿìÓ—{â¶Ù¶Ð¶Ç¶@$ÿÿÿÿÿÿùÓ@{‡zëy2yyx@%ÿÿÿÿÿÿÔ]{¤z·$Oy–x@&ÿÿÿÿÿÿÔz{Ázzly³x@'ÿÿÿÿÿÿ Ô—{Þz%z‰yÐx@(ÿÿÿÿÿÿ-Ôå²Ñ²½²(y©²@)ÿÿÿÿÿÿ:Ô]³I³­$5³!³@*ÿÿÿÿÿÿGÔÕ³·zÁ³­³™³@+ÿÿÿÿÿÿTÔ{M´9´%´´@,ÿÿÿÿÿÿaÔÀ­­­š­§‡­@-ÿÿÿÿÿÿnÔ4®!®Š.®û­@.ÿÿÿÿÿÿ{Ô¨®¦¨•®‚®o®@/ÿÿÿÿÿÿˆÔ|©¯ ¯ö®ã®@0ÿÿÿÿÿÿ•Ôܪ¿ª¢ªÛ—…ª@1ÿÿÿÿÿÿ¢Ôx«[«O2>«!«@2ÿÿÿÿÿÿ¯Ô¬ö˜÷«Ú«½«@3ÿÿÿÿÿÿ¼ÔÌ™°¬“¬v¬Y¬@4ÿÿÿÿÿÿÉÔn§Q§4§§ú¦@5ÿÿÿÿÿÿÖÔ ¨í§Š.Ч³§@6ÿÿÿÿÿÿãÔ覨‰¨l¨O¨@7ÿÿÿÿÿÿðÔ|©_©B©%©©@8ÿÿÿÿÿÿýÔXÕ>Õ$Õ Õ@9ÿÿÿÿÿÿ Õy‹ˆkb„€ú{@:ÿÿÿÿÿÿÕöi ~Y} |ð{@;ÿÿÿÿÿÿ$ÕŒ‹#ˆ"]—€|@<ÿÿÿÿÿÿ1Õd|?kòh |ð{@=ÿÿÿÿÿÿ>ÕŠ.-vÇ-g4@>ÿÿÿÿÿÿKÕß~&~ti½| |@?ÿÿÿÿÿÿXÕ©‹JˆË\È€H|@@ÿÿÿÿÿÿeÕi+€€Þ |@AÿÿÿÿÿÿrÕÆ‹]ˆï€[|@BÿÿÿÿÿÿÕqk“}ä|]4@CÿÿÿÿÿÿŒÕރʃ5kû]4@Dÿÿÿÿÿÿ™Õ-°i°}Ik>|@Eÿÿÿÿÿÿ¦Õ±†‹†·ƒèh>|@Fÿÿÿÿÿÿ³ÕT}~Ao.i+k@GÿÿÿÿÿÿÀÕ±‰iát?€+k@HÿÿÿÿÿÿÍÕò~Äi}Ð| |@IÿÿÿÿÿÿÚÕ}ViSkÐ| |@JÿÿÿÿÿÿçÕ°‚íG8iÞ@KÿÿÿÿÿÿôÕø€Ñ€ª€8i½|@LÿÿÿÿÿÿÖÍ‚ ‚~i½-û@MÿÿÿÿÿÿÖp„]kBi½-ä|@NÿÿÿÿÿÿÖô‚'‚w¾€èh@Oÿÿÿÿÿÿ(Öji&‡S„¾€Ik@Pÿÿÿÿÿÿ5Ö jN‚Toå€?€@QÿÿÿÿÿÿBÖgkC‡ôtå€.i@RÿÿÿÿÿÿOÖL~abSkòh@Sÿÿÿÿÿÿ\ÖœiÃ}ab}Y}@TÿÿÿÿÿÿiÖà‚Îi]ª€€@UÿÿÿÿÿÿvÖžŠ]Gti@VÿÿÿÿÿÿƒÖ­$5…ìBi5k@WÿÿÿÿÿÿÖE2À„ì~i“}@XÿÿÿÿÿÿÖjR…Á\S„·ƒ@YÿÿÿÿÿÿªÖÔ‡’iÁ\w°}@Zÿÿÿÿÿÿ·Öfu-uôtát@[ÿÿÿÿÿÿÄÖÆooToAo@\ÿÿÿÿÿÿÑÖ@i~Ã}Vi?k@]ÿÿÿÿÿÿÞÖ~i~L~Äi ~@^ÿÿÿÿÿÿëÖ(j:‚ŠÑ€+€@_ÿÿÿÿÿÿøÖa‚:‚Îií&~@`ÿÿÿÿÿÿ×ä…-À„]kʃ@aÿÿÿÿÿÿ×o…-5… ‚qk@bÿÿÿÿÿÿ×ш@ˆ’i&‡‹†@cÿÿÿÿÿÿ,×…k@ˆR…'‚°i@dÿÿÿÿÿÿ9×îˆ{koC‡i@eÿÿÿÿÿÿF×âi{k-uN‚}~@fÿÿÿÿÿÿS×g~œi}d|@gÿÿÿÿÿÿ`×g@ò~öi@hÿÿÿÿÿÿm׃a‚žø€i@iÿÿÿÿÿÿz׃(jà‚°‚ß~@jÿÿÿÿÿÿ‡×€.o…E2p„Þƒ@kÿÿÿÿÿÿ”×€.ä…­$Í‚@lÿÿÿÿÿÿ¡×‰…kÔ‡ji±†@mÿÿÿÿÿÿ®×‰Ñˆjô‚-@nÿÿÿÿÿÿ»×¼‹âiÆogk±‰@oÿÿÿÿÿÿÈ×¼‹îˆfu jT@pÿÿÿÿÿÿÕ×+k>|]4 |ð{@qÿÿÿÿÿÿâ×?€èhûÞ |@rÿÿÿÿÿÿï×át·ƒ5k€òh@sÿÿÿÿÿÿü×i‹†Êƒ+€?k@tÿÿÿÿÿÿ ر‰±†Þƒid|@uÿÿÿÿÿÿØ.iIkä|½| |@vÿÿÿÿÿÿ#Ø倾€½-8iÐ|@wÿÿÿÿÿÿ0ØôtS„Biª€Sk@xÿÿÿÿÿÿ=ØC‡&‡]kÑ€Vi@yÿÿÿÿÿÿJØgkjip„ø€}@zÿÿÿÿÿÿWØAo°}“}tiY}@{ÿÿÿÿÿÿdØTow~iG}@|ÿÿÿÿÿÿqØÁ\ì]ab@}ÿÿÿÿÿÿ~Øo’iÀ„ŠÃ}@~ÿÿÿÿÿÿ‹ØÆoÔ‡E2žœi@ÿÿÿÿÿÿ˜Ø}~°iqk&~ ~@€ÿÿÿÿÿÿ¥ØN‚'‚ ‚íÄi@ÿÿÿÿÿÿ²Ø-uR…5…ÎiL~@‚ÿÿÿÿÿÿ¿Ø{k@ˆ-:‚i~@ƒÿÿÿÿÿÿÌØâi…ko…a‚~@„ÿÿÿÿÿÿÙØT-ß~öi@…ÿÿÿÿÿÿæØ jô‚Í‚°‚ò~@†ÿÿÿÿÿÿóØfuj­$à‚@‡ÿÿÿÿÿÿÙîˆÑˆä…(j@@ˆÿÿÿÿÿÿ Ù¼‹‰€.ƒg@‰ÿÿÿÿÿÿÙTÙ…k{kÎiÄiqkœi’i~itigk]kSk8iIki?k5kèh+k@Šÿÿÿÿÿÿ7ÙTÙâi-ÎiÄi°iœi’i~itijiViBi8i.iiiòhèh]4@‹ÿÿÿÿÿÿTÙ€.(jj jöiŒÿÿÿÿÿÿaÙTÙâi-ÎiÄi°iœi’i~itijiViBi8i.iiiòhèh]4@ÿÿÿÿÿÿ}ÙaÙŽÿÿÿÿÿÿ†ÙTÙ…k{kÎiÄiqkœi’i~itigk]kSk8iIki?k5kèh+k@ÿÿÿÿÿÿ¢Ù†Ù@ÿÿÿÿÿÿ«Ù<Ò/Ò"Ò†Ð"Ï‘ÿÿÿÿÿÿ¸Ùø…î…Ñ…Ç…´…y…e…H…+……Ê„„T¶„¬„z„f„I„6„#„èƒÔƒ­ƒšƒ‡ƒ@’ÿÿÿÿÿÿØÙÏ‹²‹Ÿ‹•‹‚‹G‹4‹!‹‹ûŠÀŠ¶ŠO2™Š†ŠKŠ8Š%ŠŠÿ‰Ä‰§‰”‰‰n‰“ÿÿÿÿÿÿùÙ•u•k•a•W•%••••ý”Ë”Á”­”£”q”g”]”S”I”” ””ù“ï“@”ÿÿÿÿÿÿÚùÙDÐ#ÐÐáÏ@•ÿÿÿÿÿÿ&ÚÒÒûÑ<Ñ Ð@–ÿÿÿÿÿÿ3Ú"ÑÑîÐÔкÐ@—ÿÿÿÿÿÿ@ÚÆ‹«¥¡¥—¥¥[¥Q¥G¥=¥3¥¥÷¤vã¤Ù¤§¤¤“¤‰¤¤M¤C¤9¤/¤%¤@˜ÿÿÿÿÿÿaÚ@ڹјÑwÑVÑ@™ÿÿÿÿÿÿnÚðÔãÔÖÔÉÔVÒ@šÿÿÿÿÿÿ{Ú¼Ô¯Ô¢Ô•ÔpÒ@›ÿÿÿÿÿÿˆÚˆÔ{ÔnÔaÔŠÒœÿÿÿÿÿÿ•Úñ¹±¯±¥±i±_±U±K±±±û°ñ°µ°«°¡°—°3°°Ï¯¯@ÿÿÿÿÿÿ±ÚTÔGÔ:Ô-ÔÅÒ@žÿÿÿÿÿÿ¾Ú ÔÔÔùÓßÒ@ŸÿÿÿÿÿÿËÚìÓßÓÒÓÓùÒ ÿÿÿÿÿÿØÚÓoÓNÓ-Ó¡ÿÿÿÿÿÿäÚXÕ>Õ$Õ Õ5¢ÿÿÿÿÿÿðÚ ÙÙóØæØÙØÌؿزإؘ؋Ø~ØdØWØJØ=Ø0Ø#ØØ Øü×ï×â×Õ×È׻׮סהׇ×z×m×`×S×F×9×,××××øÖëÖÞÖÑÖªÖÖÖƒÖvÖiÖ\ÖOÖBÖ5Ö(ÖÖÖÖôÕçÕÚÕÍÕÀÕ³Õ¦Õ™ÕŒÕÕeÕKÕ1ÕÕäÚØÚÓËÚ¾Ú±Ú•ÚˆÚ{ÚnÚaÚ/ÑÑûÐáÐÇÐ3Ú&ÚÚØْϸÙPÏ/Ï«Ù³w wwzwgwTwAw.www›vˆvuvbvOvCHNSX[^addtruefalsenot==>andorxordistinctite=distinctite=distinctiteop1ope4e3e2e1e0R PBoolUIIIIIIII@<P sW_oR PBoolUIIIIIIII@<P PBoolUI P   .>3C(8H1 0 -2 0 127 0 132 0 217 0 247 0 273 0 279 0 316 0 346 0 376 0 402 0 531 0 553 0 559 0 689 0 714 0 740 0 765 0 791 0 817 0 -823 0 -824 0 -825 0 -826 0 -827 0 -828 0 -829 0 -830 0 -831 0 -832 0 -833 0 -834 0 -835 0 -836 0 -837 0 -838 0 -839 0 -840 0 -841 0 -842 0 -843 0 -13 0 -281 0 416 0 436 0 456 0 476 0 497 0 489 0 667 0 -692 0 -844 0 -845 0 -38 0 494 0 672 0 -697 0 -846 0 -847 0 -83 0 503 0 681 0 -706 0 -108 0 508 0 686 0 -711 0 -848 0 -849 0 -850 0 -851 0 -852 0 -853 0 -854 0 -855 0 -856 0 -857 0 -858 0 -859 0 -860 0 -861 0 -862 0 -863 0 -864 0 -865 0 -866 0 -867 0 -868 0 -869 0 -870 0 -871 0 -872 0 -873 0 -874 0 -875 0 -876 0 -877 0 -878 0 -879 0 -880 0 -881 0 -882 0 -883 0 -884 0 -885 0 -886 0 -887 0 -888 0 -889 0 -53 0 675 0 -700 0 -890 0 -891 0 -58 0 498 0 676 0 -701 0 -892 0 -893 0 -63 0 499 0 677 0 -702 0 -68 0 500 0 678 0 -703 0 -894 0 -895 0 -896 0 -897 0 -898 0 -899 0 -900 0 -901 0 -902 0 -903 0 -904 0 -905 0 -906 0 -907 0 -908 0 -909 0 -910 0 -911 0 -912 0 -913 0 -914 0 -123 0 477 0 652 0 -727 0 -124 0 -289 0 418 0 438 0 627 0 -752 0 -125 0 602 0 -778 0 -126 0 577 0 -804 0 -915 0 -916 0 -917 0 -918 0 -919 0 -920 0 14 0 650 0 -742 0 41 0 601 0 -749 0 57 0 567 0 802 0 3 4 5 6 7 0 8 9 10 11 12 0 14 15 13 16 17 0 18 19 20 21 22 0 23 24 25 26 27 0 28 29 30 31 32 0 33 34 35 36 37 0 39 40 38 41 42 0 43 44 45 46 47 0 48 49 50 51 52 0 54 55 53 56 57 0 59 60 58 61 62 0 64 65 63 66 67 0 69 70 68 71 72 0 73 74 75 76 77 0 78 79 80 81 82 0 84 85 83 86 87 0 88 89 90 91 92 0 93 94 95 96 97 0 98 99 100 101 102 0 103 104 105 106 107 0 109 110 108 111 112 0 113 114 115 116 117 0 118 119 120 121 122 0 3 8 13 18 23 0 3 28 53 73 98 0 4 9 14 19 24 0 4 29 54 74 99 0 5 10 15 20 25 0 5 30 55 75 100 0 6 11 16 21 26 0 6 31 56 76 101 0 7 12 17 22 27 0 7 32 57 77 102 0 28 33 38 43 48 0 8 33 58 78 103 0 29 34 39 44 49 0 9 34 59 79 104 0 30 35 40 45 50 0 10 35 60 80 105 0 31 36 41 46 51 0 11 36 61 81 106 0 32 37 42 47 52 0 12 37 62 82 107 0 54 59 64 69 123 0 14 39 84 109 123 0 55 60 65 70 124 0 15 40 85 110 124 0 56 61 66 71 125 0 16 41 86 111 125 0 57 62 67 72 126 0 17 42 87 112 126 0 73 78 83 88 93 0 18 43 63 88 113 0 74 79 84 89 94 0 19 44 64 89 114 0 75 80 85 90 95 0 20 45 65 90 115 0 76 81 86 91 96 0 21 46 66 91 116 0 77 82 87 92 97 0 22 47 67 92 117 0 98 103 108 113 118 0 23 48 68 93 118 0 99 104 109 114 119 0 24 49 69 94 119 0 100 105 110 115 120 0 25 50 70 95 120 0 101 106 111 116 121 0 26 51 71 96 121 0 102 107 112 117 122 0 27 52 72 97 122 0 128 129 130 131 0 -7 -131 0 -37 -131 0 -126 -131 0 -92 -131 0 -122 -131 0 7 37 92 122 126 131 0 -6 -130 0 -36 -130 0 -125 -130 0 -91 -130 0 -121 -130 0 6 36 91 121 125 130 0 -5 -129 0 -35 -129 0 -124 -129 0 -90 -129 0 -120 -129 0 5 35 90 120 124 129 0 -4 -128 0 -34 -128 0 -123 -128 0 -89 -128 0 -119 -128 0 4 34 89 119 123 128 0 133 134 135 136 0 -7 -136 0 -136 137 0 -136 138 0 -136 139 0 -136 140 0 -136 141 0 -37 -136 0 -136 142 0 -136 143 0 -136 144 0 -136 145 0 -136 146 0 -126 -136 0 -136 147 0 -136 148 0 -136 149 0 -136 150 0 -136 151 0 -92 -136 0 -136 152 0 -136 153 0 -136 154 0 -136 155 0 -136 156 0 -122 -136 0 7 37 92 122 126 136 -137 -138 -139 -140 -141 -142 -143 -144 -145 -146 -147 -148 -149 -150 -151 -152 -153 -154 -155 -156 0 117 156 0 97 156 0 -97 -117 -156 0 112 155 0 72 155 0 -72 -112 -155 0 107 154 0 52 154 0 -52 -107 -154 0 102 153 0 27 153 0 -27 -102 -153 0 97 152 0 117 152 0 -97 -117 -152 0 87 151 0 67 151 0 -67 -87 -151 0 82 150 0 47 150 0 -47 -82 -150 0 77 149 0 22 149 0 -22 -77 -149 0 72 148 0 112 148 0 -72 -112 -148 0 67 147 0 87 147 0 -67 -87 -147 0 62 146 0 42 146 0 -42 -62 -146 0 57 145 0 17 145 0 -17 -145 -57 0 52 144 0 107 144 0 -52 -107 -144 0 47 143 0 82 143 0 -47 -82 -143 0 42 142 0 62 142 0 -42 -62 -142 0 32 141 0 12 141 0 -12 -32 -141 0 27 140 0 102 140 0 -27 -102 -140 0 22 139 0 77 139 0 -22 -77 -139 0 17 138 0 57 138 0 -17 -138 -57 0 12 137 0 32 137 0 -12 -32 -137 0 -6 -135 0 -135 157 0 -135 158 0 -135 159 0 -135 160 0 -135 161 0 -36 -135 0 -135 162 0 -135 163 0 -135 164 0 -135 165 0 -135 166 0 -125 -135 0 -135 167 0 -135 168 0 -135 169 0 -135 170 0 -135 171 0 -91 -135 0 -135 172 0 -135 173 0 -135 174 0 -135 175 0 -135 176 0 -121 -135 0 6 36 91 121 125 135 -157 -158 -159 -160 -161 -162 -163 -164 -165 -166 -167 -168 -169 -170 -171 -172 -173 -174 -175 -176 0 116 176 0 96 176 0 -96 -116 -176 0 111 175 0 71 175 0 -71 -111 -175 0 106 174 0 51 174 0 -51 -106 -174 0 101 173 0 26 173 0 -26 -101 -173 0 96 172 0 116 172 0 -96 -116 -172 0 86 171 0 66 171 0 -66 -86 -171 0 81 170 0 46 170 0 -46 -81 -170 0 76 169 0 21 169 0 -21 -76 -169 0 71 168 0 111 168 0 -71 -111 -168 0 66 167 0 86 167 0 -66 -86 -167 0 61 166 0 41 166 0 -61 -166 -41 0 56 165 0 16 165 0 -16 -56 -165 0 51 164 0 106 164 0 -51 -106 -164 0 46 163 0 81 163 0 -46 -81 -163 0 41 162 0 61 162 0 -61 -162 -41 0 31 161 0 11 161 0 -11 -31 -161 0 26 160 0 101 160 0 -26 -101 -160 0 21 159 0 76 159 0 -21 -76 -159 0 16 158 0 56 158 0 -16 -56 -158 0 11 157 0 31 157 0 -11 -31 -157 0 -5 -134 0 -134 177 0 -134 178 0 -134 179 0 -134 180 0 -134 181 0 -35 -134 0 -134 182 0 -134 183 0 -134 184 0 -134 185 0 -134 186 0 -124 -134 0 -134 187 0 -134 188 0 -134 189 0 -134 190 0 -134 191 0 -90 -134 0 -134 192 0 -134 193 0 -134 194 0 -134 195 0 -134 196 0 -120 -134 0 5 35 90 120 124 134 -177 -178 -179 -180 -181 -182 -183 -184 -185 -186 -187 -188 -189 -190 -191 -192 -193 -194 -195 -196 0 115 196 0 95 196 0 -95 -115 -196 0 110 195 0 70 195 0 -70 -110 -195 0 105 194 0 50 194 0 -50 -105 -194 0 100 193 0 25 193 0 -25 -100 -193 0 95 192 0 115 192 0 -95 -115 -192 0 85 191 0 65 191 0 -65 -85 -191 0 80 190 0 45 190 0 -45 -80 -190 0 75 189 0 20 189 0 -20 -75 -189 0 70 188 0 110 188 0 -70 -110 -188 0 65 187 0 85 187 0 -65 -85 -187 0 60 186 0 40 186 0 -40 -60 -186 0 55 185 0 15 185 0 -15 -55 -185 0 50 184 0 105 184 0 -50 -105 -184 0 45 183 0 80 183 0 -45 -80 -183 0 40 182 0 60 182 0 -40 -60 -182 0 30 181 0 10 181 0 -10 -30 -181 0 25 180 0 100 180 0 -25 -100 -180 0 20 179 0 75 179 0 -20 -75 -179 0 15 178 0 55 178 0 -15 -55 -178 0 10 177 0 30 177 0 -10 -30 -177 0 -4 -133 0 -133 197 0 -133 198 0 -133 199 0 -133 200 0 -133 201 0 -34 -133 0 -133 202 0 -133 203 0 -133 204 0 -133 205 0 -133 206 0 -123 -133 0 -133 207 0 -133 208 0 -133 209 0 -133 210 0 -133 211 0 -89 -133 0 -133 212 0 -133 213 0 -133 214 0 -133 215 0 -133 216 0 -119 -133 0 4 34 89 119 123 133 -197 -198 -199 -200 -201 -202 -203 -204 -205 -206 -207 -208 -209 -210 -211 -212 -213 -214 -215 -216 0 114 216 0 94 216 0 -94 -114 -216 0 109 215 0 69 215 0 -69 -109 -215 0 104 214 0 49 214 0 -49 -104 -214 0 99 213 0 24 213 0 -24 -99 -213 0 94 212 0 114 212 0 -94 -114 -212 0 84 211 0 64 211 0 -64 -84 -211 0 79 210 0 44 210 0 -44 -79 -210 0 74 209 0 19 209 0 -19 -74 -209 0 69 208 0 109 208 0 -69 -109 -208 0 64 207 0 84 207 0 -64 -84 -207 0 59 206 0 39 206 0 -39 -59 -206 0 54 205 0 14 205 0 -54 -205 -14 0 49 204 0 104 204 0 -49 -104 -204 0 44 203 0 79 203 0 -44 -79 -203 0 39 202 0 59 202 0 -39 -59 -202 0 29 201 0 9 201 0 -9 -29 -201 0 24 200 0 99 200 0 -24 -99 -200 0 19 199 0 74 199 0 -19 -74 -199 0 14 198 0 54 198 0 -54 -198 -14 0 9 197 0 29 197 0 -9 -29 -197 0 3 34 91 122 124 0 218 219 220 221 222 0 -222 -223 0 -222 -224 0 -222 -225 0 -222 -226 0 -222 -227 0 222 223 224 225 226 227 0 -221 -228 0 -221 -229 0 -221 -230 0 -221 -231 0 -221 -232 0 221 228 229 230 231 232 0 -220 -233 0 -220 -234 0 -15 -220 0 -220 -235 0 -220 -236 0 15 220 233 234 235 236 0 -219 -237 0 -219 -238 0 -219 -239 0 -219 -240 0 -219 -241 0 219 237 238 239 240 241 0 -218 -242 0 -218 -243 0 -218 -244 0 -218 -245 0 -218 -246 0 218 242 243 244 245 246 0 248 249 250 251 252 0 -252 -253 0 -252 -254 0 -252 -255 0 -252 -256 0 -227 -252 0 227 252 253 254 255 256 0 -251 -257 0 -251 -258 0 -251 -259 0 -231 -251 0 -251 -260 0 231 251 257 258 259 260 0 -250 -261 0 -250 -262 0 -15 -250 0 -250 -263 0 -250 -264 0 15 250 261 262 263 264 0 -249 -265 0 -238 -249 0 -249 -266 0 -249 -267 0 -249 -268 0 238 249 265 266 267 268 0 -242 -248 0 -248 -269 0 -248 -270 0 -248 -271 0 -248 -272 0 242 248 269 270 271 272 0 274 275 276 277 278 0 223 -278 0 224 -278 0 225 -278 0 226 -278 0 227 -278 0 -223 -224 -225 -226 -227 278 0 228 -277 0 229 -277 0 230 -277 0 231 -277 0 232 -277 0 -228 -229 -230 -231 -232 277 0 233 -276 0 234 -276 0 15 -276 0 235 -276 0 236 -276 0 -15 -233 -234 -235 -236 276 0 237 -275 0 238 -275 0 239 -275 0 240 -275 0 241 -275 0 -237 -238 -239 -240 -241 275 0 242 -274 0 243 -274 0 244 -274 0 245 -274 0 246 -274 0 -242 -243 -244 -245 -246 274 0 280 282 281 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 0 122 -299 0 -299 300 0 -122 299 -300 0 -300 301 0 -122 -300 0 122 300 -301 0 -301 302 0 -92 -301 0 92 301 -302 0 -302 303 0 -126 -302 0 302 -303 126 0 -7 -303 0 -37 -303 0 7 37 303 0 117 -298 0 -298 304 0 -117 298 -304 0 -304 305 0 -121 -304 0 121 304 -305 0 -305 306 0 -91 -305 0 91 305 -306 0 -306 307 0 -125 -306 0 306 -307 125 0 -6 -307 0 -36 -307 0 6 36 307 0 112 -297 0 -297 308 0 -112 297 -308 0 -308 309 0 -120 -308 0 120 308 -309 0 -309 310 0 -90 -309 0 90 309 -310 0 -310 311 0 -124 -310 0 310 -311 124 0 -5 -311 0 -35 -311 0 5 35 311 0 107 -296 0 -296 312 0 -107 296 -312 0 -312 313 0 -119 -312 0 119 312 -313 0 -313 314 0 -89 -313 0 89 313 -314 0 -314 315 0 -123 -314 0 314 -315 123 0 -4 -315 0 -34 -315 0 4 34 315 0 96 -295 0 -295 300 0 -96 295 -300 0 91 -294 0 -294 304 0 -91 294 -304 0 86 -293 0 -293 308 0 -86 293 -308 0 81 -292 0 -292 312 0 -81 292 -312 0 70 -291 0 -291 300 0 -70 291 -300 0 65 -290 0 -290 304 0 -65 290 -304 0 -289 124 0 -289 308 0 -124 289 -308 0 60 -288 0 -288 312 0 -60 288 -312 0 49 -287 0 -287 300 0 -49 287 -300 0 44 -286 0 -286 304 0 -44 286 -304 0 39 -285 0 -285 308 0 -39 285 -308 0 34 -284 0 -284 312 0 -34 284 -312 0 23 -283 0 -283 300 0 -23 283 -300 0 18 -282 0 -282 304 0 -18 282 -304 0 -281 13 0 -281 308 0 -13 281 -308 0 8 -280 0 -280 312 0 -8 280 -312 0 317 318 319 320 321 0 -321 -322 0 -321 -323 0 -321 -324 0 -321 -325 0 -321 -326 0 321 322 323 324 325 326 0 -320 -327 0 -320 -328 0 -320 -329 0 -320 -330 0 -320 -331 0 320 327 328 329 330 331 0 -319 -332 0 -319 -333 0 -5 -319 0 -319 -334 0 -319 -335 0 5 319 332 333 334 335 0 -318 -336 0 -318 -337 0 -318 -338 0 -318 -339 0 -318 -340 0 318 336 337 338 339 340 0 -317 -341 0 -317 -342 0 -317 -343 0 -317 -344 0 -317 -345 0 317 341 342 343 344 345 0 347 348 349 350 351 0 -351 -352 0 -351 -353 0 -351 -354 0 -351 -355 0 -351 -356 0 351 352 353 354 355 356 0 -350 -357 0 -350 -358 0 -350 -359 0 -350 -360 0 -350 -361 0 350 357 358 359 360 361 0 -349 -362 0 -349 -363 0 -55 -349 0 -349 -364 0 -349 -365 0 55 349 362 363 364 365 0 -348 -366 0 -348 -367 0 -348 -368 0 -348 -369 0 -348 -370 0 348 366 367 368 369 370 0 -347 -371 0 -347 -372 0 -347 -373 0 -347 -374 0 -347 -375 0 347 371 372 373 374 375 0 377 378 379 380 381 0 -381 -382 0 -381 -383 0 -381 -384 0 -381 -385 0 -326 -381 0 326 381 382 383 384 385 0 -380 -386 0 -380 -387 0 -380 -388 0 -330 -380 0 -380 -389 0 330 380 386 387 388 389 0 -379 -390 0 -379 -391 0 -5 -379 0 -379 -392 0 -379 -393 0 5 379 390 391 392 393 0 -378 -394 0 -337 -378 0 -378 -395 0 -378 -396 0 -378 -397 0 337 378 394 395 396 397 0 -341 -377 0 -377 -398 0 -377 -399 0 -377 -400 0 -377 -401 0 341 377 398 399 400 401 0 403 404 405 406 407 0 -407 408 0 -407 409 0 -407 410 0 -407 411 0 140 -407 0 -407 412 0 -407 413 0 -407 414 0 -407 415 0 144 -407 0 -407 416 0 -407 417 0 -407 418 0 -407 419 0 148 -407 0 -407 420 0 -407 421 0 -407 422 0 -407 423 0 152 -407 0 -407 424 0 -407 425 0 -407 426 0 -407 427 0 -122 -407 0 122 -140 -144 -148 -152 407 -408 -409 -410 -411 -412 -413 -414 -415 -416 -417 -418 -419 -420 -421 -422 -423 -424 -425 -426 -427 0 117 427 0 96 427 0 -96 -117 -427 0 112 426 0 70 426 0 -70 -112 -426 0 107 425 0 49 425 0 -49 -107 -425 0 102 424 0 23 424 0 -23 -102 -424 0 92 423 0 91 423 0 -91 -92 -423 0 87 422 0 65 422 0 -65 -87 -422 0 82 421 0 44 421 0 -44 -82 -421 0 77 420 0 18 420 0 -18 -77 -420 0 67 419 0 86 419 0 -67 -86 -419 0 418 126 0 418 124 0 -124 -126 -418 0 62 417 0 39 417 0 -39 -62 -417 0 57 416 0 416 13 0 -13 -57 -416 0 47 415 0 81 415 0 -47 -81 -415 0 42 414 0 60 414 0 -42 -60 -414 0 37 413 0 34 413 0 -34 -37 -413 0 32 412 0 8 412 0 -8 -32 -412 0 22 411 0 76 411 0 -22 -76 -411 0 17 410 0 55 410 0 -17 -55 -410 0 12 409 0 29 409 0 -12 -29 -409 0 7 408 0 3 408 0 -3 -7 -408 0 -406 428 0 -406 429 0 -406 430 0 159 -406 0 -406 431 0 -406 432 0 -406 433 0 -406 434 0 163 -406 0 -406 435 0 -406 436 0 -406 437 0 -406 438 0 167 -406 0 -406 439 0 -406 440 0 -406 441 0 -406 442 0 -91 -406 0 -406 443 0 -406 444 0 -406 445 0 -406 446 0 176 -406 0 -406 447 0 91 -159 -163 -167 -176 406 -428 -429 -430 -431 -432 -433 -434 -435 -436 -437 -438 -439 -440 -441 -442 -443 -444 -445 -446 -447 0 121 447 0 122 447 0 -121 -122 -447 0 111 446 0 70 446 0 -70 -111 -446 0 106 445 0 49 445 0 -49 -106 -445 0 101 444 0 23 444 0 -23 -101 -444 0 96 443 0 117 443 0 -96 -117 -443 0 86 442 0 65 442 0 -65 -86 -442 0 81 441 0 44 441 0 -44 -81 -441 0 76 440 0 18 440 0 -18 -76 -440 0 71 439 0 112 439 0 -71 -112 -439 0 438 125 0 438 124 0 -124 -125 -438 0 61 437 0 39 437 0 -39 -61 -437 0 56 436 0 436 13 0 -13 -56 -436 0 51 435 0 107 435 0 -51 -107 -435 0 41 434 0 60 434 0 -60 -434 -41 0 36 433 0 34 433 0 -34 -36 -433 0 31 432 0 8 432 0 -8 -31 -432 0 26 431 0 102 431 0 -26 -102 -431 0 16 430 0 55 430 0 -16 -55 -430 0 11 429 0 29 429 0 -11 -29 -429 0 6 428 0 3 428 0 -3 -6 -428 0 -405 448 0 -405 449 0 178 -405 0 -405 450 0 -405 451 0 -405 452 0 -405 453 0 182 -405 0 -405 454 0 -405 455 0 -405 456 0 -405 457 0 -124 -405 0 -405 458 0 -405 459 0 -405 460 0 -405 461 0 191 -405 0 -405 462 0 -405 463 0 -405 464 0 -405 465 0 195 -405 0 -405 466 0 -405 467 0 -178 -182 124 -191 -195 405 -448 -449 -450 -451 -452 -453 -454 -455 -456 -457 -458 -459 -460 -461 -462 -463 -464 -465 -466 -467 0 120 467 0 122 467 0 -120 -122 -467 0 115 466 0 96 466 0 -96 -115 -466 0 105 465 0 49 465 0 -49 -105 -465 0 100 464 0 23 464 0 -23 -100 -464 0 95 463 0 117 463 0 -95 -117 -463 0 90 462 0 91 462 0 -90 -91 -462 0 80 461 0 44 461 0 -44 -80 -461 0 75 460 0 18 460 0 -18 -75 -460 0 70 459 0 112 459 0 -70 -112 -459 0 65 458 0 86 458 0 -65 -86 -458 0 60 457 0 39 457 0 -39 -60 -457 0 55 456 0 456 13 0 -13 -55 -456 0 50 455 0 107 455 0 -50 -107 -455 0 45 454 0 81 454 0 -45 -81 -454 0 35 453 0 34 453 0 -34 -35 -453 0 30 452 0 8 452 0 -8 -30 -452 0 25 451 0 102 451 0 -25 -102 -451 0 20 450 0 76 450 0 -20 -76 -450 0 10 449 0 29 449 0 -10 -29 -449 0 5 448 0 3 448 0 -3 -5 -448 0 -404 468 0 197 -404 0 -404 469 0 -404 470 0 -404 471 0 -404 472 0 -34 -404 0 -404 473 0 -404 474 0 -404 475 0 -404 476 0 206 -404 0 -404 477 0 -404 478 0 -404 479 0 -404 480 0 210 -404 0 -404 481 0 -404 482 0 -404 483 0 -404 484 0 214 -404 0 -404 485 0 -404 486 0 -404 487 0 34 -197 -206 -210 -214 404 -468 -469 -470 -471 -472 -473 -474 -475 -476 -477 -478 -479 -480 -481 -482 -483 -484 -485 -486 -487 0 119 487 0 122 487 0 -119 -122 -487 0 114 486 0 96 486 0 -96 -114 -486 0 109 485 0 70 485 0 -70 -109 -485 0 99 484 0 23 484 0 -23 -99 -484 0 94 483 0 117 483 0 -94 -117 -483 0 89 482 0 91 482 0 -89 -91 -482 0 84 481 0 65 481 0 -65 -84 -481 0 74 480 0 18 480 0 -18 -74 -480 0 69 479 0 112 479 0 -69 -112 -479 0 64 478 0 86 478 0 -64 -86 -478 0 477 123 0 477 124 0 -123 -124 -477 0 54 476 0 476 13 0 -13 -54 -476 0 49 475 0 107 475 0 -49 -107 -475 0 44 474 0 81 474 0 -44 -81 -474 0 39 473 0 60 473 0 -39 -60 -473 0 29 472 0 8 472 0 -8 -29 -472 0 24 471 0 102 471 0 -24 -102 -471 0 19 470 0 76 470 0 -19 -76 -470 0 14 469 0 55 469 0 -55 -469 -14 0 4 468 0 3 468 0 -3 -4 -468 0 -3 -403 0 -403 488 0 -403 489 0 -403 490 0 -403 491 0 -403 492 0 -403 493 0 -403 494 0 -403 495 0 -403 496 0 -403 497 0 -403 498 0 -124 -403 0 -403 499 0 -403 500 0 -403 501 0 -403 502 0 -403 503 0 -403 504 0 -403 505 0 -403 506 0 -403 507 0 -403 508 0 -403 509 0 -403 510 0 3 403 124 -488 -489 -490 -491 -492 -493 -494 -495 -496 -497 -498 -499 -500 -501 -502 -503 -504 -505 -506 -507 -508 -509 -510 0 118 510 0 122 510 0 -118 -122 -510 0 113 509 0 96 509 0 -96 -113 -509 0 508 108 0 70 508 0 -70 -108 -508 0 103 507 0 49 507 0 -49 -103 -507 0 98 506 0 23 506 0 -23 -98 -506 0 93 505 0 117 505 0 -93 -117 -505 0 88 504 0 91 504 0 -88 -91 -504 0 503 83 0 65 503 0 -65 -83 -503 0 78 502 0 44 502 0 -44 -78 -502 0 73 501 0 18 501 0 -18 -73 -501 0 500 68 0 112 500 0 -68 -112 -500 0 499 63 0 86 499 0 -63 -86 -499 0 498 58 0 39 498 0 -39 -58 -498 0 497 53 0 497 13 0 -13 -53 -497 0 48 496 0 107 496 0 -48 -107 -496 0 43 495 0 81 495 0 -43 -81 -495 0 494 38 0 60 494 0 -38 -60 -494 0 33 493 0 34 493 0 -33 -34 -493 0 28 492 0 8 492 0 -8 -28 -492 0 23 491 0 102 491 0 -23 -102 -491 0 18 490 0 76 490 0 -18 -76 -490 0 489 13 0 55 489 0 -13 -55 -489 0 8 488 0 29 488 0 -8 -29 -488 0 371 511 512 513 514 0 367 515 516 517 518 0 55 519 520 521 522 0 360 523 524 525 526 0 356 527 528 529 530 0 532 533 534 535 536 0 -536 -537 0 -536 -538 0 -536 -539 0 -536 -540 0 -356 -536 0 356 536 537 538 539 540 0 -535 -541 0 -535 -542 0 -535 -543 0 -360 -535 0 -535 -544 0 360 535 541 542 543 544 0 -3 -534 0 -29 -534 0 -55 -534 0 -76 -534 0 -102 -534 0 3 29 55 76 102 534 0 -533 -545 0 -367 -533 0 -533 -546 0 -533 -547 0 -533 -548 0 367 533 545 546 547 548 0 -371 -532 0 -532 -549 0 -532 -550 0 -532 -551 0 -532 -552 0 371 532 549 550 551 552 0 554 555 556 557 558 0 -98 -558 0 -104 -558 0 -110 -558 0 -116 -558 0 -122 -558 0 98 104 110 116 122 558 0 -73 -557 0 -79 -557 0 -85 -557 0 -91 -557 0 -97 -557 0 73 79 85 91 97 557 0 -53 -556 0 -59 -556 0 -124 -556 0 -66 -556 0 -72 -556 0 59 66 53 72 124 556 0 -28 -555 0 -34 -555 0 -40 -555 0 -46 -555 0 -52 -555 0 28 34 40 46 52 555 0 -3 -554 0 -9 -554 0 -15 -554 0 -21 -554 0 -27 -554 0 3 9 15 21 27 554 0 560 561 562 563 564 0 -564 565 0 -564 566 0 -564 567 0 -564 568 0 -564 569 0 -564 570 0 -564 571 0 -564 572 0 -564 573 0 -564 574 0 -564 575 0 -564 576 0 -564 577 0 -564 578 0 -564 579 0 -564 580 0 -564 581 0 -564 582 0 -564 583 0 -564 584 0 -564 585 0 -564 586 0 -564 587 0 -564 588 0 -564 589 0 564 -565 -566 -567 -568 -569 -570 -571 -572 -573 -574 -575 -576 -577 -578 -579 -580 -581 -582 -583 -584 -585 -586 -587 -588 -589 0 122 589 0 -122 589 0 117 588 0 -97 588 0 97 -117 -588 0 112 587 0 -72 587 0 72 -112 -587 0 107 586 0 -52 586 0 52 -107 -586 0 102 585 0 -27 585 0 27 -102 -585 0 97 584 0 -117 584 0 -97 117 -584 0 92 583 0 -92 583 0 87 582 0 -67 582 0 67 -87 -582 0 82 581 0 -47 581 0 47 -82 -581 0 77 580 0 -22 580 0 22 -77 -580 0 72 579 0 -112 579 0 -72 112 -579 0 67 578 0 -87 578 0 -67 87 -578 0 577 126 0 -126 577 0 62 576 0 -42 576 0 42 -62 -576 0 57 575 0 -17 575 0 17 -575 -57 0 52 574 0 -107 574 0 -52 107 -574 0 47 573 0 -82 573 0 -47 82 -573 0 42 572 0 -62 572 0 -42 62 -572 0 37 571 0 -37 571 0 32 570 0 -12 570 0 12 -32 -570 0 27 569 0 -102 569 0 -27 102 -569 0 22 568 0 -77 568 0 -22 77 -568 0 17 567 0 567 -57 0 -17 57 -567 0 12 566 0 -32 566 0 -12 32 -566 0 7 565 0 -7 565 0 -563 590 0 -563 591 0 -563 592 0 -563 593 0 -563 594 0 -563 595 0 -563 596 0 -563 597 0 -563 598 0 -563 599 0 -563 600 0 -563 601 0 -563 602 0 -563 603 0 -563 604 0 -563 605 0 -563 606 0 -563 607 0 -563 608 0 -563 609 0 -563 610 0 -563 611 0 -563 612 0 -563 613 0 -563 614 0 563 -590 -591 -592 -593 -594 -595 -596 -597 -598 -599 -600 -601 -602 -603 -604 -605 -606 -607 -608 -609 -610 -611 -612 -613 -614 0 121 614 0 -121 614 0 116 613 0 -96 613 0 96 -116 -613 0 111 612 0 -71 612 0 71 -111 -612 0 106 611 0 -51 611 0 51 -106 -611 0 101 610 0 -26 610 0 26 -101 -610 0 96 609 0 -116 609 0 -96 116 -609 0 91 608 0 -91 608 0 86 607 0 -66 607 0 66 -86 -607 0 81 606 0 -46 606 0 46 -81 -606 0 76 605 0 -21 605 0 21 -76 -605 0 71 604 0 -111 604 0 -71 111 -604 0 66 603 0 -86 603 0 -66 86 -603 0 602 125 0 -125 602 0 61 601 0 601 -41 0 41 -61 -601 0 56 600 0 -16 600 0 16 -56 -600 0 51 599 0 -106 599 0 -51 106 -599 0 46 598 0 -81 598 0 -46 81 -598 0 41 597 0 -61 597 0 61 -597 -41 0 36 596 0 -36 596 0 31 595 0 -11 595 0 11 -31 -595 0 26 594 0 -101 594 0 -26 101 -594 0 21 593 0 -76 593 0 -21 76 -593 0 16 592 0 -56 592 0 -16 56 -592 0 11 591 0 -31 591 0 -11 31 -591 0 6 590 0 -6 590 0 -562 615 0 -562 616 0 -562 617 0 -562 618 0 -562 619 0 -562 620 0 -562 621 0 -562 622 0 -562 623 0 -562 624 0 -562 625 0 -562 626 0 -562 627 0 -562 628 0 -562 629 0 -562 630 0 -562 631 0 -562 632 0 -562 633 0 -562 634 0 -562 635 0 -562 636 0 -562 637 0 -562 638 0 -562 639 0 562 -615 -616 -617 -618 -619 -620 -621 -622 -623 -624 -625 -626 -627 -628 -629 -630 -631 -632 -633 -634 -635 -636 -637 -638 -639 0 120 639 0 -120 639 0 115 638 0 -95 638 0 95 -115 -638 0 110 637 0 -70 637 0 70 -110 -637 0 105 636 0 -50 636 0 50 -105 -636 0 100 635 0 -25 635 0 25 -100 -635 0 95 634 0 -115 634 0 -95 115 -634 0 90 633 0 -90 633 0 85 632 0 -65 632 0 65 -85 -632 0 80 631 0 -45 631 0 45 -80 -631 0 75 630 0 -20 630 0 20 -75 -630 0 70 629 0 -110 629 0 -70 110 -629 0 65 628 0 -85 628 0 -65 85 -628 0 627 124 0 -124 627 0 60 626 0 -40 626 0 40 -60 -626 0 55 625 0 -15 625 0 15 -55 -625 0 50 624 0 -105 624 0 -50 105 -624 0 45 623 0 -80 623 0 -45 80 -623 0 40 622 0 -60 622 0 -40 60 -622 0 35 621 0 -35 621 0 30 620 0 -10 620 0 10 -30 -620 0 25 619 0 -100 619 0 -25 100 -619 0 20 618 0 -75 618 0 -20 75 -618 0 15 617 0 -55 617 0 -15 55 -617 0 10 616 0 -30 616 0 -10 30 -616 0 5 615 0 -5 615 0 -561 640 0 -561 641 0 -561 642 0 -561 643 0 -561 644 0 -561 645 0 -561 646 0 -561 647 0 -561 648 0 -561 649 0 -561 650 0 -561 651 0 -561 652 0 -561 653 0 -561 654 0 -561 655 0 -561 656 0 -561 657 0 -561 658 0 -561 659 0 -561 660 0 -561 661 0 -561 662 0 -561 663 0 -561 664 0 561 -640 -641 -642 -643 -644 -645 -646 -647 -648 -649 -650 -651 -652 -653 -654 -655 -656 -657 -658 -659 -660 -661 -662 -663 -664 0 119 664 0 -119 664 0 114 663 0 -94 663 0 94 -114 -663 0 109 662 0 -69 662 0 69 -109 -662 0 104 661 0 -49 661 0 49 -104 -661 0 99 660 0 -24 660 0 24 -99 -660 0 94 659 0 -114 659 0 -94 114 -659 0 89 658 0 -89 658 0 84 657 0 -64 657 0 64 -84 -657 0 79 656 0 -44 656 0 44 -79 -656 0 74 655 0 -19 655 0 19 -74 -655 0 69 654 0 -109 654 0 -69 109 -654 0 64 653 0 -84 653 0 -64 84 -653 0 652 123 0 -123 652 0 59 651 0 -39 651 0 39 -59 -651 0 54 650 0 650 -14 0 14 -54 -650 0 49 649 0 -104 649 0 -49 104 -649 0 44 648 0 -79 648 0 -44 79 -648 0 39 647 0 -59 647 0 -39 59 -647 0 34 646 0 -34 646 0 29 645 0 -9 645 0 9 -29 -645 0 24 644 0 -99 644 0 -24 99 -644 0 19 643 0 -74 643 0 -19 74 -643 0 14 642 0 -54 642 0 54 -642 -14 0 9 641 0 -29 641 0 -9 29 -641 0 4 640 0 -4 640 0 -560 665 0 -560 666 0 -560 667 0 -560 668 0 -560 669 0 -560 670 0 -560 671 0 -560 672 0 -560 673 0 -560 674 0 -560 675 0 -560 676 0 -560 677 0 -560 678 0 -560 679 0 -560 680 0 -560 681 0 -560 682 0 -560 683 0 -560 684 0 -560 685 0 -560 686 0 -560 687 0 -560 688 0 560 -665 -666 -667 -668 -669 -670 -671 -672 -673 -674 -675 -676 -677 -678 -679 -680 -681 -682 -683 -684 -685 -686 -687 -688 0 118 688 0 -118 688 0 113 687 0 -93 687 0 93 -113 -687 0 686 108 0 -68 686 0 -108 68 -686 0 103 685 0 -48 685 0 48 -103 -685 0 98 684 0 -23 684 0 23 -98 -684 0 93 683 0 -113 683 0 -93 113 -683 0 88 682 0 -88 682 0 681 83 0 -63 681 0 -83 63 -681 0 78 680 0 -43 680 0 43 -78 -680 0 73 679 0 -18 679 0 18 -73 -679 0 678 68 0 -108 678 0 -68 -678 108 0 677 63 0 -83 677 0 -63 -677 83 0 676 58 0 -38 676 0 -58 -676 38 0 675 53 0 -13 675 0 -53 -675 13 0 48 674 0 -103 674 0 -48 103 -674 0 43 673 0 -78 673 0 -43 78 -673 0 672 38 0 -58 672 0 -38 58 -672 0 33 671 0 -33 671 0 28 670 0 -8 670 0 8 -28 -670 0 23 669 0 -98 669 0 -23 98 -669 0 18 668 0 -73 668 0 -18 73 -668 0 667 13 0 -53 667 0 -13 53 -667 0 8 666 0 -28 666 0 -8 28 -666 0 3 665 0 -3 665 0 -55 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 0 118 -713 0 -102 -713 0 102 -118 713 0 113 -712 0 -101 -712 0 101 -113 712 0 -711 108 0 -100 -711 0 100 -108 711 0 103 -710 0 -99 -710 0 99 -103 710 0 98 -709 0 -98 -709 0 93 -708 0 -77 -708 0 77 -93 708 0 88 -707 0 -76 -707 0 76 -88 707 0 -706 83 0 -75 -706 0 75 -83 706 0 78 -705 0 -74 -705 0 74 -78 705 0 73 -704 0 -73 -704 0 -703 68 0 -703 -57 0 57 -68 703 0 -702 63 0 -56 -702 0 56 -63 702 0 -701 58 0 -54 -701 0 54 -58 701 0 -700 53 0 -53 -700 0 48 -699 0 -32 -699 0 32 -48 699 0 43 -698 0 -31 -698 0 31 -43 698 0 -697 38 0 -30 -697 0 30 -38 697 0 33 -696 0 -29 -696 0 29 -33 696 0 28 -695 0 -28 -695 0 23 -694 0 -7 -694 0 7 -23 694 0 18 -693 0 -6 -693 0 6 -18 693 0 -692 13 0 -5 -692 0 5 -13 692 0 8 -691 0 -4 -691 0 4 -8 691 0 3 -690 0 -3 -690 0 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 0 119 -739 0 -107 -739 0 107 -119 739 0 114 -738 0 -106 -738 0 106 -114 738 0 109 -737 0 -105 -737 0 105 -109 737 0 104 -736 0 -104 -736 0 99 -735 0 -103 -735 0 -99 103 735 0 94 -734 0 -82 -734 0 82 -94 734 0 89 -733 0 -81 -733 0 81 -89 733 0 84 -732 0 -80 -732 0 80 -84 732 0 79 -731 0 -79 -731 0 74 -730 0 -78 -730 0 -74 78 730 0 69 -729 0 -62 -729 0 62 -69 729 0 64 -728 0 -61 -728 0 61 -64 728 0 -727 123 0 -60 -727 0 60 -123 727 0 59 -726 0 -59 -726 0 54 -725 0 -58 -725 0 -54 725 58 0 49 -724 0 -37 -724 0 37 -49 724 0 44 -723 0 -36 -723 0 36 -44 723 0 39 -722 0 -35 -722 0 35 -39 722 0 34 -721 0 -34 -721 0 29 -720 0 -33 -720 0 -29 33 720 0 24 -719 0 -12 -719 0 12 -24 719 0 19 -718 0 -11 -718 0 11 -19 718 0 14 -717 0 -10 -717 0 10 717 -14 0 9 -716 0 -9 -716 0 4 -715 0 -8 -715 0 -4 8 715 0 741 743 742 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 0 120 -764 0 -112 -764 0 112 -120 764 0 115 -763 0 -111 -763 0 111 -115 763 0 110 -762 0 -110 -762 0 105 -761 0 -109 -761 0 -105 109 761 0 100 -760 0 -108 -760 0 -100 760 108 0 95 -759 0 -87 -759 0 87 -95 759 0 90 -758 0 -86 -758 0 86 -90 758 0 85 -757 0 -85 -757 0 80 -756 0 -84 -756 0 -80 84 756 0 75 -755 0 -83 -755 0 -75 755 83 0 70 -754 0 -126 -754 0 -70 754 126 0 65 -753 0 -125 -753 0 -65 753 125 0 -752 124 0 -124 -752 0 60 -751 0 -123 -751 0 -60 751 123 0 50 -750 0 -42 -750 0 42 -50 750 0 45 -749 0 -749 -41 0 41 -45 749 0 40 -748 0 -40 -748 0 35 -747 0 -39 -747 0 -35 39 747 0 30 -746 0 -38 -746 0 -30 746 38 0 25 -745 0 -17 -745 0 17 -25 745 0 20 -744 0 -16 -744 0 16 -20 744 0 15 -743 0 -15 -743 0 10 -742 0 -742 -14 0 -10 14 742 0 5 -741 0 -13 -741 0 -5 741 13 0 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 0 121 -790 0 -117 -790 0 117 -121 790 0 116 -789 0 -116 -789 0 111 -788 0 -115 -788 0 -111 115 788 0 106 -787 0 -114 -787 0 -106 114 787 0 101 -786 0 -113 -786 0 -101 113 786 0 96 -785 0 -92 -785 0 92 -96 785 0 91 -784 0 -91 -784 0 86 -783 0 -90 -783 0 -86 90 783 0 81 -782 0 -89 -782 0 -81 89 782 0 76 -781 0 -88 -781 0 -76 88 781 0 71 -780 0 -67 -780 0 67 -71 780 0 66 -779 0 -66 -779 0 -778 125 0 -65 -778 0 65 -125 778 0 61 -777 0 -64 -777 0 -61 64 777 0 56 -776 0 -63 -776 0 -56 776 63 0 51 -775 0 -47 -775 0 47 -51 775 0 46 -774 0 -46 -774 0 41 -773 0 -45 -773 0 45 773 -41 0 36 -772 0 -44 -772 0 -36 44 772 0 31 -771 0 -43 -771 0 -31 43 771 0 26 -770 0 -22 -770 0 22 -26 770 0 21 -769 0 -21 -769 0 16 -768 0 -20 -768 0 -16 20 768 0 11 -767 0 -19 -767 0 -11 19 767 0 6 -766 0 -18 -766 0 -6 18 766 0 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 0 122 -816 0 -122 -816 0 117 -815 0 -121 -815 0 -117 121 815 0 112 -814 0 -120 -814 0 -112 120 814 0 107 -813 0 -119 -813 0 -107 119 813 0 102 -812 0 -118 -812 0 -102 118 812 0 97 -811 0 -97 -811 0 92 -810 0 -96 -810 0 -92 96 810 0 87 -809 0 -95 -809 0 -87 95 809 0 82 -808 0 -94 -808 0 -82 94 808 0 77 -807 0 -93 -807 0 -77 93 807 0 72 -806 0 -72 -806 0 67 -805 0 -71 -805 0 -67 71 805 0 -804 126 0 -70 -804 0 70 -126 804 0 62 -803 0 -69 -803 0 -62 69 803 0 57 -802 0 -68 -802 0 802 -57 68 0 52 -801 0 -52 -801 0 47 -800 0 -51 -800 0 -47 51 800 0 42 -799 0 -50 -799 0 -42 50 799 0 37 -798 0 -49 -798 0 -37 49 798 0 32 -797 0 -48 -797 0 -32 48 797 0 27 -796 0 -27 -796 0 22 -795 0 -26 -795 0 -22 26 795 0 17 -794 0 -25 -794 0 -17 25 794 0 12 -793 0 -24 -793 0 -12 24 793 0 7 -792 0 -23 -792 0 -7 23 792 0 818 819 820 821 822 0 -272 -822 0 -268 -822 0 -264 -822 0 -260 -822 0 -227 -822 0 227 260 264 268 272 822 0 -271 -821 0 -267 -821 0 -263 -821 0 -231 -821 0 -256 -821 0 231 256 263 267 271 821 0 -270 -820 0 -266 -820 0 -15 -820 0 -259 -820 0 -255 -820 0 15 255 259 266 270 820 0 -269 -819 0 -238 -819 0 -262 -819 0 -258 -819 0 -254 -819 0 238 254 258 262 269 819 0 -242 -818 0 -265 -818 0 -261 -818 0 -257 -818 0 -253 -818 0 242 253 257 261 265 818 0 -5 -11 -18 -27 -29 -33 -47 -50 -59 -65 -71 -73 -80 -87 -91 -94 -101 -107 -110 -114 -118 0 -5 -11 -18 -27 -28 -35 -47 -49 -59 -65 -71 -74 -82 -85 -91 -93 -101 -103 -112 -114 -120 0 301 0 opensmt-2.5.2/regression/state-dump/bar-00.smt2.expected.err000066400000000000000000000000001445011647600236250ustar00rootroot00000000000000opensmt-2.5.2/regression/state-dump/bar-00.smt2.expected.out000066400000000000000000000000061445011647600236520ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/state-dump/bar-00.smt2.expected.time000066400000000000000000000000351445011647600240030ustar00rootroot00000000000000real 0.87 user 0.86 sys 0.01 opensmt-2.5.2/regression/state-dump/bar-01.smt2.expected.err000066400000000000000000000000001445011647600236260ustar00rootroot00000000000000opensmt-2.5.2/regression/state-dump/bar-01.smt2.expected.out000066400000000000000000000000061445011647600236530ustar00rootroot00000000000000unsat opensmt-2.5.2/regression/state-dump/bar-01.smt2.expected.time000066400000000000000000000000351445011647600240040ustar00rootroot00000000000000real 2.05 user 2.04 sys 0.01 opensmt-2.5.2/regression/state-dump/constraints-temporal-machine-shop-2-3-A40_0.smt2.expected.err000066400000000000000000000000001445011647600324450ustar00rootroot00000000000000opensmt-2.5.2/regression/state-dump/constraints-temporal-machine-shop-2-3-A40_0.smt2.expected.out000066400000000000000000000000101445011647600324650ustar00rootroot00000000000000unknown opensmt-2.5.2/regression/state-dump/constraints-temporal-machine-shop-2-3-A40_0.smt2.expected.time000066400000000000000000000000351445011647600326230ustar00rootroot00000000000000real 1.11 user 1.09 sys 0.02 opensmt-2.5.2/regression/state-dump/constraints-temporal-machine-shop-2-3-A40_1.smt2.expected.err000066400000000000000000000000001445011647600324460ustar00rootroot00000000000000opensmt-2.5.2/regression/state-dump/constraints-temporal-machine-shop-2-3-A40_1.smt2.expected.out000066400000000000000000000000041445011647600324710ustar00rootroot00000000000000sat opensmt-2.5.2/regression/state-dump/constraints-temporal-machine-shop-2-3-A40_1.smt2.expected.time000066400000000000000000000000351445011647600326240ustar00rootroot00000000000000real 0.05 user 0.04 sys 0.00 opensmt-2.5.2/regression/state-dump/constraints-temporal-machine-shop-2-3-A40_2.smt2.expected.err000066400000000000000000000000001445011647600324470ustar00rootroot00000000000000opensmt-2.5.2/regression/state-dump/constraints-temporal-machine-shop-2-3-A40_2.smt2.expected.out000066400000000000000000000000041445011647600324720ustar00rootroot00000000000000sat opensmt-2.5.2/regression/state-dump/constraints-temporal-machine-shop-2-3-A40_2.smt2.expected.time000066400000000000000000000000351445011647600326250ustar00rootroot00000000000000real 0.05 user 0.04 sys 0.01 opensmt-2.5.2/regression/state-dump/out.osmt2-00.osmt2000066400000000000000000001136651445011647600225510ustar00rootroot00000000000000xœl ˜e÷¾w>†|5$iHÒ¤!†“ÆÄ$¤ÉWC’BB’& !I“&I’W’4$ i’$!!IòJ’IBÒÿZíkýöý×å8ÎÃ{¼s­ýìµÍÞÏs¯çÞ%êŠD"M G"ŽDÖ&ã"‘-`/hˆÿßþ˜3ÿ‚Hd Xv# P¡H¤¨ €– +&ƒ\°¬ÛÀA‡ÌxR@ÐŒãAX ÀNpÒC‘H¤@áfxÏ7‚.`8˜Þ›À/ xz$r5H÷€QàE° |ŽÒ7ã߸ôO€Yà°üÊ5Dê€6à~0¼Ö€ï@™‘È• )¸ Œ/€%àKp\˜ßÉàfÐ<f‚ŸÁ_ Ò-‘È àNð0x¼¾ÿ%[â¹·€ûÀ“àU°|þ—ÝŠ×èÏ·Áàpa«HäÐôÃÁDð(?€â­ñœtp˜ÞÇÁEmðZÁYpz:¡`*X 6àD[ü[ fƒU`78*ÞŽ÷6Ð SÀ"°Å3ñ¼æ &€yàc°»ÿ@3Ð < –_A™v‘H{ðø\ÖÏèÏ·ÁàpaÈÁ$°¬@‘¾xA膀±`X vƒÂ÷ãw¸tOƒ%à D?¼§€ÏŸ€‡·ÚnøüÚ¥dìç"A5€"¼¥Eð«;‚_1üs‹àåÁSADdpš™f‚¹`XÖ‚`;Ø àœÕ¹S9PTuAcдY è†l0L³.ˆ‹­äùØfž“íçyÙ)ž›• ÎÏjò­)ÏÓÚñ\­7Ï×F‚œà¼mÏÝ–ñümÏáöð<î88œÏ%ðœ.™çué<·ëÄó»~`hpž7•çzóx¾·‚ç|›xÞ·ÎÿJð° Ïëñ\0ƒçƒ]@¯à¼p Ï §óüpÏWñ΀"%bçÍÕxîÜçÏ­xÝçÑC‚sé)<ŸžËsêå<¯ÞÈsë½àPpŽ]¼dô<»2ϵëò|»9Ϲ³@àÜ;›çßÓx>Ÿçá+y.¾ì ÎÉOñ¼¼ÏÍ«òü¼ÏÑ[‚vÁ¹ú ž¯çðœ=—çí yî¾lÛ‚óøã<—+=ŸOà9}2ÏëÓƒsûî<¿Êsüñ<ÏÏã¹þb°"8çßÉóþÃ<÷”‰žÿ—ç5€$P/¸Éë½xM`¯ LâµÙ`Ap`=¯ì浂c¼^Pä¢è5ƒŠ Zpí ×:ðB_^GÅk SÀL07¸®°–׶óúÂ!^c8Çë å‚k uy½¡9¯9dñºC^{ȃkóyb%¯Elæõˆý¼&q *»6Q•×'ðEK^§èÊkƒÀÈàšE.¯[,䵋5¼~±×0‚ãÁµŒx^ÏHä5^×hÃkÝA?0ŒãÁTæÅ`(›ÀN°'Aäbô”U@¨RAÈ]@/0ŒcÀ$0Ì @>XÖƒ­`78Ž3 HyôTÕ@-ФV èú‚!`¦€™`.X–ƒµ`#Øö‚Cà8Š_‚þƒÊ :¨ ƒæ -È=@0 dƒ‰`˜æƒ%`%X6ƒ]`?8NBÐPT5Aдí@WÐ #A˜ rÁ°,kÀ° ìÁqpÄ]Šþƒ’A Hm@'ÐôCÁh0Ly`X V€° ìûÀapòÒ臲 <¨’@= 2@&èz`&é`6XòÁ*°l»Áp œE.CÿAEP Ô Ah:€n /Fq` ˜ æ‚E`9X 6‚í`/8N€s xú*ƒê .h šƒ¶ ôýÁ0 &‚i`˜–€•`Ø výà8 UBÿAPÔ @Sд]Ao0Œ9`2ÈsÀB° ¬À6°ÇÁYWý $ƒÚ€N ;膂Ñ`<˜ òÀ<°¬`Ø öÃà$ˆ\Žþƒò  Hõ@*È™  è‚` ˜¦ƒÙ`È«Àz°ìÀ1p©‚þƒŠ ¨‚4Ð tÝ@_0ŒãÀ0Ì‹Àr°lÛÁ^pœç@ñ+ÐPTuAcдY è†l0L³À|°¬ëÀf° ìGÀ)P¨*ú*€ª &hš‚– è zƒA`$È“A.˜‚e` ض=à 8΂¸+ÑA2Hé  èºƒ~`( ƃ© Ì‹Á P6`8 N^=!+ʃ* Ô© d‚. F€1`˜fƒ ¬ëÁV°ÇÀPä*ôTÕ@-ФV è zƒAWE¯Ùç€É —×ï‚e` ØÀëù{ÀApœåõýxA2¯÷§ƒ6 èÎëÿCƒ5€©\˜Çµ€\ØÄ5}à08 þůÆë TWƒdšÖ èú€Á`$ÈÏ€`6XÞ‚u`óÕѵ‡ý\8 U®CTU¹Ñ4åºD;Е냂5ŠÉ\§˜ÃµŠe\¯ØÀ5‹=ÁºÅY®]Äsý"‘k)\Çh:ëC¹¦1žëy\ÛXÌõ°)Xç8̵ŽHRt½£<×<’¸î‘ 2‚õ^\ÁuI\ ™Íõ|°*XÙ͵‘c\)R#ºFR‘ë$µ@CZö +¸ ÃA6˜¦‚—À\ðXÆu– \kÙrÍå,×]âAHäL ×aÚ€N ;×d†r]f<˜ ò¸F³˜ë4`ØÉ5›Ã\·‰\‹çíÚØúM×pR¹Ž“ɵœ^\ϬéLçºÎ®í¬âúÎV®ñÇ‚µž2\ï©Æ5Ÿ†\÷iŵŸn o°4Žë@3¹´ˆëAk¹&´ì Ö†Îq}¨׈ªs¨1׊ڂ¬`Íh×&ríh×–p iØ vëI§¸¦TŠëJU¹¶Ô€ëK-ƒ5¦Þ\gɵ¦É\ošÃ5§e`M°ö´‡ëOǹW'º•Àµ¨d¬IuâºT?®MæúÔT®QÍ‹ƒµªM\¯ÚÇ5«“\·*Áµ«* )XÃÊà:V®e äzÖ®iM³Á®o­â×°‹k]GÀ\ó* Êsí+ \Ç5° -×Âz€¸&ö8ϵ±<ð:×ÈÞk¹V¶|Ï5³ßÀY®ÅƒË¸†V4äZZ+Оkj}¸®6<Éõµ`6×ÙòÁ‡\oÛvqÝíøƒëo%Ay®Ã%ë¸×´åº\ð×çã¹N—^çzÝû`-×í¶ƒï¹~÷8 âD×ò¸žW4äº^+Оë{}À ®óå€g¸Þ÷*XÀu¿UàS®ÿ} ösð¸àúèzà%  ×ë&\¼dq°?x˜ë…ÀT®Îoƒ÷¹†ø×÷‚Ÿ¹žøˆk]WLWq}±Hã:cp7׃‘\wœ fpýñMÏuÈõ` ×#G¸.Y¨Ž©Qt}ò ÄuÊTЂë•AПk—Ù\¿|äqs1xŸë™_€í\×<~ãúf±SJt3Ôæzg3ЊëžÝ@®> r¸š ^åzèR°Šë¢[Á·\= Nq´¸\Á5Óú\7Í·sý´'èÏuÔl0ë©/ƒy\W]>æúê°—ë¬'À_\o- ¸îš qýµ5èÀuؾ`0×cÇ‚É\—Þäúìj°låZí®×ž…šD×m+€+¸~[¤r7tæzî0ŒëºÁó\ß},æ:oø‚ë½?€C\÷=Š¥F×+D®§€f\îºq]xx”ëÃÏrxx“kÅ«Áz®ï?ríø4(tct ¹¸‚kÉõA*×”3Ag®-øÆ<<ϵæ7Àb®9€/¸öü8Ä5ès XÓèZt%’¹.ε鎠ר‡€G¹Vý,ÈåšõB°”kן­\Ã>Žr-»ðM8¦›¢kÚUA ®mß2¸ÆÝôäZ÷pÍ5ïiàe®}¿Vp |Ø~àzøï\/ž†cJ‹®_ ’¹FžZs­üЗkæ£ÀX®¿æp }X͵ô¯Àn®©§¹¶^Tà{MPŸkí·€L®¹÷¸öþ˜¦q~>×â?\“ß ~àÚüïà×èËJ\«¯R¸fßtäÚýý`×ðÇg¹–ÿXÈ5ý5à3®ípÿ (|st­ÿRP•kþ Àà®ÿßÅ€`8gžÓ80¼ÃÙ€OÀ&Îì¿pVàoP¼ytf 2¸š³7€tÎt÷p–à!0Š3SÀ‹œ-x ,ãŒÁðg ~ÇÀP¤Etö "ç® 8‡ÐÜÁy„ûÀ@Î%ŒOs>á0Ÿs +Á'œWøìãÜÂIð7ç.•9ÇPÜÀy†Û@'Î5ôq¾á)0…ssÁ[à=ðø| ¾ç Äoœƒ(v ^ã·Dç!®u8q3¸ó÷‚8'ñ8˜Ày‰—Áœ›ø|Âù‰oÀ9Gñ¸ etžâpç*êƒ9_q¸‹s‚G8oñ ˜Á¹‹7ÁRÎ_|¾âÆOàWÎc½5¹èÖè\ÆU 6ç3šÖœÓ¸ÜÏyÇÀSœÛx ¼Îù÷ÁÇœãØ~à<ÇïàoÎu\ .ç|Çu  ç¹-:Ç’’9Ï’Úp®¥;èÇù–Ñ`<ç\òÀ<λ¬œ{Ù öqþåämÑEw›ƒ)ªp¦Hå\L&èÂù˜`çd&霗Yò97³låüÌpŒs4EnÇï‚Û£ó4Õ@-ÎÕ¤Vœ¯éúrÎfÇy›™`.çn–ƒµœ¿Ùörç8Çyœr 2çrê‚ÆœÏi ²8§ÓŸ³:Ùœ×yäqng1xŸó;_€íœã9~q¦§,HàlO2hÄŸÖ g}ú‚ÁàQ0–³?/‚9`!ç€Ö€ÏÀWà;ðgƒþEÚEg„*‚+Áµàzp¸•³CwƒÞ` rÀd 怅`)X >_ï8sô+玊¶Çkº}tþè*P›sHÍ@kÎ#Ýîç\Òcà)Î'½^çœÒûàcÎ+í?pnéwð7ç—.—sŽé:ЄóL·ƒÎœk†s¾éiðçœþÞå¼Ó§` çž~G9ÿT¸#ÞK;Fç ®×rê&p+ç¢î}8õ(Ë9©Ákœ—z|Ĺ©¯Á÷œŸú üÅ9ª² ç©ê€8Wu¸“óUpÆêqÎYM/qÞêm°œsWÁל¿úg9‹.ãLVmгY­@{ÎhõƒÀHÙ­\ð*x“ó[«Áz°ì8ÓuΊÎv] ª‚š h Zræ«+¸<O‚gÀ ð*xäƒU`=Ø vsVìçÅŠtÆkºstn¬¨Åù±4ЊsdÝ@_Γã8W6Ìå|Ùr°–sfÛÁ^Λç8wVTæüY]ИshmAçÑúƒaœK›¦q>m>XÂ9µu`3çÕöƒ#œ[+t>_ß_« jrŽ­)hÉy¶® 7çÚF‚ηå‚9œs[ÖpÞmØù·ãà,çßâAçà’A çáÚ€Nœ‹ëÇٸќ{ÌäœÜ"ðçå>Û87wü þä ÝE "géjë9Sw+hÇÙºÞàAðx’³v3Àl°€sw«À§` øüÈY¼Ó P·èL^p¨êƒÁ-œÕ» ôÁ0LÓÁl°¼ >Ÿ‚-à[Îøåœ_á{ðš¾':ïw%¸–s7[9ÿw7èÃ9ÀGÁXξ^ã\à{à#Î~ ¾çœàoà/Î –•87XÜÀùÁÛÀœ#|<Ìy àyξÞá|á'àKÎþüó†Ü‹Ï…÷Fç¯58x#¸…sˆwû8øx’s‰3À«œO\ VsNñ+ðçrnñ"pçkƒFœcl :ržñ~Î4>ƹÆ)àEÎ7¾–qÎqøŠóŽ?cà gË€K9y-hÀYÈ–àÎDÞ‚` g$§ƒWÀ8/ù!X6ƒ]`?g(O zEg)/U@¨RAg,»€ž`žOƒÀ+à?` X ÖÍ`g3p>³Ð}xMßÓ¬ jr^³)hɹͮ 7ç7G‚Îqæ‚9œç\Öp®sØÃùÎãà,ç<ãAç=“A ç>Û€Nœÿì†rt<˜ÊyÐy`1çB À&·î‡9'éƒÏ…}¢ó¢U@çFSAçG»€^œ#Æpžt:˜Í¹Ò|°Šó¥[ÁnΙg8oZTäÜi-Ðó§­@Ρöå,ê(Σ> r9—º,å|êg`+çT€£à4gVKƒ œ]­ ês†õÉYÖ^`žàlë `˜Ï9וàð%øü—³¯Ü\µØòàrp ¸4-8ÛôýÁ0 &‚i`˜ÞŸ‚ëûãw¸Ü€GÁ0¼Þ/Áwàp€×<¸ \n·»Àý`8 ž¯‚·Á‡àsð ø ü Äï6p¨ š€[Áà>ðx< ^o‚÷Á§àkð_ð+ø”~¿#A дíÁ½àAðx¼ÞKÁÇ` øüü .„ßàjP4·ƒ»Áàðx¼Þ«Áà[ð3øŒÏ£àJPÜZƒÎ x< ž¯€·Àà3°ü~ ÁïLp9¸ÜnAO0<ž/ÿ€÷À'à+ð8 þ%Âï^p èÞ'A“¡x­€OÀ&°ì?ƒãàO0`z 2#e#çÿùûï¿/Ä¿Ãÿÿ‚HtV;üïŃÿ^(úëàÿûïñüoÙüÙöçý÷ŠüïñÄþ½Îóª9EENÍ ÇÝ8pïy^ƒ §˜ÈI rܵcìvž—ä\(rÚ9î–wçe9%EN÷ ÇÝRüß¡×/È)-r†9ýè•Þ(zÕèšw‘ðÆ^5zñ›x è•ÞÌÀË WNxs/‹ÞÅÂ[x~¼å…·œ^ƒàx/ÞÚÀóã­ ¼çÇ{©ð¶žoEáí =¿_ȼÚÂ[BÏï)2/9ý·z+éù}=æÕyë‚<^ꊼÍôüþ ó®y»‚<þꉼýôü>#óꋼ#Až?Ï DÞ)z~¿’y׋<»‡Éó¼ E^)z~ß“yD^…B±¾Õd^ŠðªÒ«x7ˆº5éù=Væ5y èù=eæ5yMÝ+½W˼T‘×2Èó¾Ý(òÚÑó{¾²™u~^× Ïûv“ÈëMÏï3/Mä ò¼oÍDÞHz~šyé‘è{fèåг>¤w³¨;9èo*ë6^nÐ_÷ZˆÇ7‡žß—Íçûü¼…ôy·ˆ¼eôüÞ:óZŠ¼5ôüÞCónyèù=zæµyÛ‚<ïok‘·‡žßëg^‘w0ÈóþÞ&òŽÓó{Ík+ú{–žõù8½ÛE]»×ÐûÛ–u3…_8Ö_÷î/žßÃh^;‘—X8Ö_Ïk/ò’éù½æuy)ô2‚¼Ž"/žßSi^'‘׆žß£jÞ"¯=¿73›þùy݃<ïog‘מßãi^Ñß¡ô¬ÏýèÝ%êŽúÛu» o|Ð_÷îo*=¿çÔ¼n"//è¯çÝ#òæÑó{W³éŸŸ·8è¯çÝ+òVÐó{`Íë!ò èey=EÞ&z~/­y½DÞNz݃þÞ'òöÑó{rÍë-ú{˜žõy½>¢îÉ ¿CX·¯ðþ9gÝ»_<¾ôüálÏùyå‹Äúëyˆ¼*ôü^cóú‹¼¤"±þzÞ‘Wžß³lÞ@‘—Z$Ö_Ï{PäeÐó{ŸÍ$ò2éõ ò‹¼.~E¢÷PgÓ?¿¿½èYŸ»Ð{HÔX$ÖßQ¬;Tx#‚þº÷°x|cèù=Ýæ y“‚þzÞp‘7žßnÞ‘7;è¯ç="òÐó{ÌÍ)òòƒþzÞ£"o=¿W=›þùyëƒþzÞc"o+=¿çݼÑ"owзqÌ{\x‚¾¹—-ê£ç÷×›ó„È;ôÍóƈ<»/ßþø}úæ=)òÊõÍórD^Ez~¿¿ycE^µ¢±¾yÞ8‘W‹žï`ÞS"¯aÑXß-¼nEcýuo’x|}éù~æ=#ò†õ×ó&‹¼Qô|_óžyã‚þzÞ‘7…žïÏ`Þs"ofÐ_Ï›*òæÒó}Ì{^ä- úëyÓDÞrz¾_„y/ˆþ®¥g}^Noº¨»1èïLÖ!¼íAÝËo/=߿¼EÞ¡ ¿ž7Sä çû`˜÷’È;ô×óòDžíŸa|? ó^yåâbýõ¼Y"¯2=ߗüWD^õ¸X=o¶È«KÏ÷÷0ïUÑßÆô¬ÏuéÍu›ÇÅú;—u_^Û¸XÝ›+_=ßoļ×E^¸X=ožÈëïÏs\tßóÞyÃâbýõ¼ù"/›Þÿí‚ÿý‘71è¯ç-yÓèù>*æ½)òfýõ¼…"o>=ßż·D—г>ϧ·HÔ]ôwë¾-¼uAÝ[,ßfz¾?Œy]A=o‰ÈÛOÏ÷™1ï]‘w$è¯ç勼Sô|¿ó–Š<ÛÃÆûëyËD^)z¾ïy Åbýõ¼å"¯*=ß?Ǽ÷EkÒ³>W¥·Bx èÙçèšô>¯)½x>.óV ¯%½j÷¡8Žvô|ÏóV‰¼®ôy«E^oz¾wykDÞ zAÞG"o$=߃ȼµ"/'xxÞÇ"o2=ßËȼ‘—¼<ï‘7‡žï‰dÞ:‘·0èÛZæ}*¼eAßÜ[/ꮡçû/™÷™ÈÛôÍó6ˆ¼mô|'ó>y{‚¾yÞF‘wžïeÞ"ïxÐ7ÏÛ$òÎÒó}¥ÌûRäÅõÍó6‹¼xz¾?•y["ÿþw™@ÏúOo«¨›X<Ö߬û•ð’‹ÇúëÞ6ñøRèù~Yæ}-òÒ‹ÇúëyÛE^z¾ï–y;D^§â±þzÞN‘מïßeÞ7"¯_ñX=o—ÈJÏ÷3ï[‘7:è¯çíyãéù~bæ}'ú;•^÷3o¨›ôw;ë~/¼yAÝÛ+ßbz¾¿™y?ˆ¼A=oŸÈ+ çû¤™÷_‘·)è¯çíy;éù~kæý(òöýõ¼"ï0=߷ͼŸDÞÉ ¿žwPäý3܉íÿfÞÏ¢¿%èýÓç £Þ!Q·ü…±þîeÝ_„WåÂXÝ;,_=ßμÿ‰¼zÆúëyGD^*=ß×μ£"/ãÂX=ï˜Èˤçûã™÷«Èëra¬¿žw\äõ¢çûì™÷›Èxa¬¿žwBä çûõ™÷»èïzÖçôNŠº“‚þbÝ?„7=è¯{§Äã›MÏ÷4ï´È[ô×óΈ¼|z¾¡yŠ¼UA=ï¬È[OÏ÷34ï/‘·5è¯çy»éù¾ˆæý-òýõ<Ðû×õ?z¾¿¢y\ðïþž¡g}>F¯ðl_ÆžçbÑ}Í+|¸þW"ö:8ÁÇWDxKÄ^îÇQžï i^œÈ«å/È+&òzÝѽ%Í+.òÒJÄ^žw¡ÈkEÏ÷¨4¯„ÈëP"ö:ð¼’"¯=ßëÒ¼R"¯o‰ØëÀóJ‹¼!ô|ÏLóʈ¼QAßÎ1ï"á úæ^¼¨;…žïÏi^Y‘73è›ç•yséù>Ÿæ],ò}ó¼ò"o9=ß/Ô¼KDÞÚ ožWAäm¤çûŽšw©ÈÛôÍó*Š¼½ô|ÿRó.ÿ.ѳ>綾 êžú[œó>•„w.è¯{•Åã+Î=›}?Uó.yåJÆúëyUD^eßšû²šw…È«^2Ö_Ï«*òêÒóý]Í»Rä5.ë¯çUyÍéù>±æ]%òÚ–Œõ×óE^=ßoÖ¼«E{г>gÑ«.êö/ëo9Ö½FxÃJÆúë^’x|Ùôþoÿ[üï"obÐ_Ï«)ò¦Ñó}tÍ»VäÍ úëyµDÞ|z¾¯yµEÞ’ ¿ž—,òVÒó}}Í«#òÖýõ¼º"o3=ßؼëDwÑëÁ=„Í«'êîú[Ùçÿ„w$è¯{ Äã;EÏ÷+6ïz‘g{{=¯¡È+EÏ÷=6¯‘È«P*Ö_ÏKyUéùþÉæÝ òj–Šõ×ó‹¼ô|f󚈼¦¥býõ¼T‘×ÒŸîçlÞ¢¿íèYŸ[Òk*êv-ëouÖ½Ix½KÅúë^šx|ƒèùþÒæ5y#ƒþz^ºÈË¡çûT›w³È›ô×󚋼\z¾ßµy-DÞœ ¿ž—!òÒó}³Í»Eä- úëy-EÞz¾ÿ¶y·Šþn g}^C¯•ð¶Ñ³ÏÑèµoOð:¨ËÇ×Fxƒ×{·‰ã8NÏ÷ 7¯­È;¼<ïv‘g{Ûß{ܼL‘_:ö:ð¼;D^=ßÃܼv"/±tìuàyíE^2=ß Ý¼"/¥tìuàyE^:=ßSݼN"¯MéXß3ïNáu*ë›{Y¢nwz¾»yE^¿Ò±¾y^‘7”žïoÞ]"otÐ7Ïë*òÆÓóýäÍ»[äM úæyÝD^=ß—Þ¼{DÞ¼ ož×]ä-¦çûÛ›w¯øw¹‚^:÷À7¯‡¨[ô·9ëöÞ¦ ¿îõo'=ßoß¼ûDÞ¾ ¿ž×[ä¦çûö›×Gä úëy}EÞ?7‰Ebûÿ›w¿È+Q&Ö_Ïë'òÊÓóï0ï‘W¥L¬¿ž×_ä%Ñóï#0o€èo=zÖç$zEÝÔ2±þ¶eÝ…—Q&Ö_÷‰Ç—IÏ¿Á¼Á"¯K™X=oˆÈëEÏ¿gÁ¼‡DÞÀ2±þzÞP‘7‚ž_ƒy‹¼1A=o˜È›DÏ¿÷Á¼á"ozÐ_Ï!òfÓóï0ïÑßô¬Ï³éuóƒþf±î£Â[ô×½Qâñ­§çßgaÞc"okÐ_Ï-òvÓóïÅ0ïq‘w è¯çe‹¼côüû5Ì{Bä úëycDž}/‡ýñïé0ïI‘Wæ¢X=/GäU¤çß÷aÞXÑßjô¬Ïéuk]ëoÖ}Jx /Šõ×½ñâñ¥Ñóï1o‚ÈkuQ¬¿ž7Qäu çßcbÞÓ"¯ÛE±þzÞ$‘×—žŠyψ¼!Åúëy“EÞ(zþ½*æ=+òÆýõ¼)"o =ÿ~óžýéýàw¸˜7UxséÙçè™ôžoQð:èÏÇ7Mx˃×{/ˆãXKÏ¿SƼé"ocð:ð¼"o;=ÿnórEÞÞàuày/Š¼Côü;nÌ›)òN¯Ï{Iä£çß•c^žÈ+{xÞË"¯=ÿÎóf‰¼Êñ±¾ cÞ+«ë›{³Eݺôüû}Ì{Uä5ŽõÍó戼æôü{‚Ì{MäµõÍó押,zþ}Cæ½.òzÄÇúæyóD^÷â£ß[dÞ"oXÐ7Ï›/ò²éýß÷áÿGü»œHÏúœMo¨;-èo6ë¾)¼YAÝ[(ß|zþ}Læ½%ò–ýõ¼E"o%=ÿ^'óÞyë‚þzÞb‘·™ž?”y]A=o‰ÈÛOÏ¿gʼwEÞ‘ ¿ž—/òNÑóï«2o©èo!nb}>Eo™¨[ªl¬¿Y÷=áU(ë¯{ËÅã«JÏ¿?˼÷E^Ͳ±þzÞ ‘×€ž—yˆ¼¦ecýõ¼•"¯¥×å÷y™÷¡ÈkW6Ö_Ï[%òºÒóï3oµÈë]6Ö_Ï[#òÑóï3ï#Ñß‘ô ñ;ÈÌ[+êæýƺ orÐ_÷ ÄãË¥çßwfÞ'"oNÐ_Ï['òÒóïM3ïS‘·,è¯ç­ykèù÷¯™÷™ÈÛô×ó6ˆ¼môü{ÜÌû\äí úëyEÞAzþ}pæ}!ú{œžõù ½M¢îÙ ¿³X÷KáÙwÍyÝÛ,_<=ÿ~:󶈼„r±þzÞV‘—HÏ¿çμ¯D^r¹X=o›ÈK¡çß—gÞ×"/½\¬¿ž·]䵡çß»gÞ‘ש\¬¿ž·Säu§çßßgÞ7¢¿ýèYŸ»ÓÛ%¼¡ôìst?zߊº£éÙgÛSÁ¼ÝÂOÏüÉô¾ÞTzæÇñ¾Ô=ÂË£gþhzß o=óOÒÛ+¼ÅÁqؽ‹æý ¼ôÌoʹ×}Â+ g~®wÿWx›è™¿‡×Ç÷ o'=óñsö¢oûèÙqïd߈¼Ãô쳃ïƒñ“ðNÒ3ß÷S8(¼6WŠD¿ûÑïËÿYx%è™ï÷w^yzÿøìÇ/«rqì8ü~ÓÃÂK¢g¾ÏÕÿOxõè™ïóCG„—JÏ|_'9*¼ zæûùà1Ñ·LzvÜö3æý*¼.ô¬Ï™ôŽ‹º½èÙ{ŸïKò›ðÒ3ß÷·8!¼ôÌ÷}~Þzæûýö'…7‰žù~ßö›‡ßÿ{Jx³é™ï÷9œÞzæû<×áåÓ3ß×­þÞ*zæûùùYÑ·õôì¸W±o o+=ëózzçDÝÝôìw·ïó·ðÐ3ß÷± øþuýžù¾oÅÂ;CÏ|ßÿ ðì{Yíù~}aá•);ŽÙôŠ¯"=óý¾“¢Â«FÏ|Ÿ¯‹^-zæû:b1á5¤g¾_/)^èß}K£gÇm?cÞ…ÂkEÏúœF¯„¨Ûžýîñ}{J ¯=ó}ÿ—RÂëKÏ|ßG¤´ð†Ð3ß÷£(#¼QôÌ÷} .Þ¸à8üþøxáM¡g¾ßTVx3é™ïóŽå„7—žù¾®{±ðÑ3߯_•}[NÏŽ{ûv‰ðÖÒ³>/§WAÔÝHÏþíø>J— o;=ó}?žŠÂÛKÏ|ß×å2á¢g¾ï’ ¼ôÌ÷}&* ï\p¾_AeáÙ÷'Ûóý¾¬Ë…WŽžù>ZEx•é™ïëìW¯:=óýzbUÑ·ºôì¸ígÌ»RxéYŸëÒ«&ê6§gŸ%wóy¹Jxmé™ß÷E' /‹žùé]-¼ôÌoÎû4« ¯?=óWÒ»FxÃèÙkØ#IxÙôÌ_ÈþÖÞDzæbk o=óÛ°¿× o=ó+³¿µDßæÓëÏïã6¯¶È[BÏ>Kú>ÉÂ[IÏ|ßO¡ŽðÖÑ3ßï˯+¼ÍôÌ÷û»¯Þ.zæû}Âõ„·Ÿž½Öý8ê ï=óý¾ÅÂ;EÏ|ŸÏ¾^xöæöÇ|ŸCi(¼RôÌ÷ëíDß*г㶟1/ExUéYŸ+лAÔ­IÏ>Kú¾$…×€žù¾¿Eá5¥g¾ï“*¼–ôÌ÷ûío^;zæû}ÛM…×ÕëŠÇMÂëMÏ|¿4Mxƒè™ïóòÍ„7’žù>”.¼zæûúÇÍ¢o“éµãwÙ›×\x¹ôªòûîÍk!êΡgŸ%}Ÿ˜ á-¤g¾ï7r‹ð–Ñ3ß÷­h)¼5ôÌ÷ýnÞzæû}ô­„·Í_…bÇÑZx{è™ï÷õ¶ÞAzæûý · ï8=ó}N«­ðÎÒ3ß×£n}‹»4êÙqŸeß2…OÏúl?cÞ¢n=û,éûö´^"=ó}ÿ—öÂK¦g¾ï#ÒAx)ôÌ÷ý(: /žù¾¯A'ᵡgŸíý8î^'zæû}ÖYÂëNÏ|¿Ÿ¤³ðúÑ3ßçæºo(=ó}}ð.Ñ·Ñô츇²o]…7žžõy4½»EÝ©ô쳤ï£ÔMxyôÌ÷ýxîÞý…—DÏü ÷„¨{†^×`_’1Â+rYÔ3ß÷·xRxeè™ïû$ä¯"=óý~û±Â«FÏ|¿o{œðjѳkÞþùþ)á5¤g¾Çxá¥Ñ3ßïGœ ¼VôÌ÷¹ë‰Âë@Ï|Ÿ/yZô­=;nûó& ¯/=ës7zψºCè ö‰™,¼QôÌ÷ýFžÞ8zæû¾S„7…žù¾ÿÁs›IÏ|¿~ªðæÒ³kÞþùþyá-¢778ŽiÂ[NÏ|¿?ôá­¥g¾ÏÁOÞFzæû¼Ï Ñ·íôì¸7²o¹ÂÛKÏú¼Þ‹¢î!z9Á¾=3…w‚žù¾ÿËKÂ;GÏ|ßG$OxÅ¢žù¾ÅËÂ+GÏ|ß×`–ð*Ó³kÞþùþáU§g¾ÇláÕ¥g¾ß¯ûªðÓ3ßïK˜#¼æôÌ÷ù«×DßÚҳ㶟1o®ð²èYŸÛÒ{]ÔíA/7ØGižðúÓ3ß÷ãyCxÃè™ïûºÌ^6=ó}ÿo"=ó}Ÿ‰›FÏ®yûçû7…7‹Þ´à8 o>=óýþé·„·„žù~ŸÈ"á­¤g¾Ïý-ú¶Žž÷Jöm±ð6Ó³>¯£÷ŽðvѳÏÑ›é-o?=›=ðë¬ï ï=óýód¾ðNÑ3¿?Ÿ¿¥Â+T)ꙿŸÞ2á•¢g~W®¯¾'¼ ôlį{/^Uzæûçû÷…W“žù~+„×€žù©|| ¼¦ôÌ/Åy©•¢o-éÙqÛϘ÷¡ÈkG¯b°Æ*áu¥g¾ž\-¼ÞôÌ÷ûò×o=óýþî„7’žù~ŸðZáåгY¿îý±ð&Ó3ß?ß/—Þäà8>Þzæû}Të„·žù>/ú©èÛ2zvÜ Ù·õÂ[CÏú¼ŒÞg¢îzµ‚}I6o=óýóäçÂÛCÏ|ß'a£ðÒ3ßï·ÿBxÇé™ï÷moÞYz6 â×½¿^\å¨g¾¾ß,¼xzæûql^=óý¾¶­ÂK¤g¾Ïï~%ú–LÏŽÛ~ƼmÂK¡g}N¦÷µ¨›N/-Ø'f»ðÚÐ3ß?Oî^'zæû¾;…מù¾ÿÁ7ÂëGÏ|¿~—ð†Ò³Y¿îý­ðFÓ3ß?ßïÞxz£ƒãøNxSé™ï÷î^=ó}žú{Ñ·yôì¸óØ·½Â[ìÇ‹¿çÑûAÔ]A¯C°oÏ>áÐ3ß?OþWx›è™ïûˆìÞNzæû~? o=ó}_ƒÂ;쯫±ëÞ? ï$=óýóýAáýóe~øs28ŽŸ…W‚žù~ßç!ᕧg¾Ï·ÿ"úV…ž·ýŒy‡…—DÏú\…ÞÿDÝzôúû(^*=óýóäQáeÐ3ß÷u9&¼Lzæûþ ¿ ¯ =ó}Ÿ‰ãÂëEÏfAüº÷oÂHÏ|ÿ|Bx#è Žãwá¡g¾ß‡{Rx“è™ï÷ü!ú6ž÷$öí”ðfÓ³>O§wZx èÙçèÙôΈǗOÏfr}þàOá­¢g¾_g=+¼õôÌ÷Ï“ o+=óóéÞnzæ×âÜÒßÂ;@Ïf¤}ľ`÷|ï=óýº÷Â;CÏ|ÿ|_HxEªD½3Áq^zæçðuP¤ð¿ûV‘ž·ýŒyEE^5z6“ëóq«EÏ|¿ÎZLx é™ïŸ'‹ /žù~÷…ÂkEÏ|¿O¸„ð:гiŸ))¼nôÌ÷ëÞ¥„×—žùþù¾´ð†ÐëGá¢g¾ßs‘èÛ8zvܣطxáM¡g}G¯¬¨;“žÍäúüA9áÍ¥g¾_g½Xx‹è™ïŸ'Ë o9=óý~ûK„·–žù~ßvám¤g3Ò>r©ð¶Ó3߯{WÞ^zæûçûË„wˆÞÞà8„w‚žù~T%Ñ·sôì¸O°o•…WüŠ¨g}>GïrQ·½ø`Ÿ˜*«LÏ|¿Îz…ðªÓ3ß?OV^]zæûþW ¯1=óý>újÂkNÏf¤}ä*áµ¥g¾_÷N^=óýóýÕÂëA/+8ŽêÂëOÏ|¿_íÑ·aôì¸ígÌK^6=ëó0z5D݉ôƒ}{j o=óý:ëµÂ›EÏ|ÿG¢—._=»WÍçroÞdzæûüAsáåÒ3߯³¶ÞzæûçÉ á-¤gþYz·o=»wÐç¤[ o =ó}äVám g¾_÷n%¼môÌ÷Ï÷­…·‡Þ¶à8Úˆ¾¤gǽ‡}»Mä§g÷ªù\n[á¥g¾ÏÜ.¼¸+£žù~5SxñôÌ÷Ï“w/žù~Ÿp;á%Ò‹‰ÍI·^2=ó}¤ƒðRè™ï×½; /žùþù¾“ðÚÐKŽãNÑ·Nôì¸ígÌË^wzÖçNô:‹ºýèÙ½j>—ÛExCé™ïów o4=óý:kWá§g¾ž¼[xSé™ï÷mw^=»wÐç¤ïÞGûÏL,Ýß#ô:ð¿YÎÓøïíÏûï]ùßmÿ•¬7Ix½é™ϼg„7ˆžåöfÞäÂbÿï î zÏŠ¼~ƒÇ7Ex“ƒÇWï9áåÒ³ÜÉÌ›*ßœ n.½çEzð÷zÓDÝeôÇñ‚ðÖÇÑ€Ç1]xèYîæÍDZ-¨»^®8Ž=ôìx¶Ñ{QÔ=H/#8Ž™Â;Gã%á¥g¹Ç™—'Ž#.1V÷,½—ÅqÄӳ㱟1o–¨›@/+8ŽW„—˜;Ž,Çlá%Ó³ÜDÖ}UGJP7™ÞqéôìxRè½&궡×/8Ž¹ÂëG?ÇëÂëNÏr;±îz–»“yïŠþ¦g}¶ŸIÃÿ·wžw’ží‹dÎRáüMÇï3^&ê¿:êXÞ߬÷žÈ*GÏgí—‹¬Jt,Ó|Ëz_d]MÏçMVˆ¬d:–y5³>Y)ôüšëJ‘ÕŒŽe¦0ëC‘ÕšžîX%²:бÌÖÌZ oÀy^7zþÞ¾FünèCÇ\ó,ë#‘5˜ž¿¯Y#é˜[Y‹¬zþ^X ²ž¡cnf}"²fÐó÷£u"k6s3˜õ©ÈZ@ÏßÖ‹¬w阛ŬÏDÖ‡ôü÷ò‘µŽŽ¹î}.¼Íô¬WÖ'ó6Šß»o3½/DÞ~zÖ¯Áô6‰¼#·ŸÞ—âõxŠžÕ?Bo³¨[¨zÔ³ÞæÐÛ"ê– <û󶊺èYýRô¾u«Ò³×Á ÖÝ&êÖ ¼ªÌûZÔm@Ïêפ·]ÔmJÏ^3 Xw‡¨Û2ðš2o§¨ÛŽžÕoIïQ·+={}}Ⱥ»DÝÞוyߊºƒèYýÞôv«Ïÿôì÷ˆ¿N¿^½j·G¼_M¦g¹9¬û½ÈËõç%ÈÛ+òæгÜ\æý òÒËòö‰¼eô,w!óþ+òÖÐË òö‹¼ ô,w ó~TŸÿéõ òˆ¼=ô,wó~yƒ¾ùÂ;ôͽŸEݳô,÷8ëRŸÿ¯‰õÍó~yñô,×~ƼÃ"/ášXß<ï"/‘žå&0ïˆÈK¾&Ö7Ï;*òRèYn2󎉼ôkb}ó¼_E^z–›Î¼ãâße'zÖç6ô~u»ûñFb¿wO¨Ïÿ×ÄúëÞïâñ ¥g¹ýX÷¤úüô×óþyãéYîhæySƒþzÞi‘—GÏr§2ïŒÈ›ô×óþy‹éYî<æy+‚þzÞ_"¯€žå®`Þ9ÑßMô¬ÏôþVŸÿƒþúû[¤ˆøþŸ ¿î]PD\ÿ§g¹ûX·È;ô×ó ‹¼HRԳܓÌ+"òJ$ÅúëyEE^yz–k?c^œÈ«’ë¯çyIô,· 󊋼zI±þzÞ…"/•žåÖc^‰"âú?=ës*½’¢nfR¬¿þ9¢”ðº$Åúë^iñøzѳÜ.¬[Fä LŠõ×ó.y#èYî@æÅ‹¼1A=¯¬È›DÏrÇ0¯œÈ›ô×ó.y³éYîtæ•y ‚þzÞ%"/Ÿžå.`^ÑßU~¼ø;ŸÞ¥¢îú ¿þy­¢ð¶ýuï2ñøvӳܭ¬› òýõ¼J"ï=Ë=À¼Ê"ïLÐ_Ï»\ä©õ,÷ 󪈼25býõ¼+D^Ez–k?c^U‘W­F¬¿žw¥È«EÏr«1¯šèoCzÖçZô®^=ûm?“†ÿoðy^«±×9WÃyø<§ýyNu‘ÓµFìubÎ5"ç¾óœ$‘3°FìõaN ‘3ü<§¦ÈÉ®{]˜s­È™pžSKäL ^æÔ9/ç$‹œ¹ÁëÀœ:"ç­À±¾Ö-"®ÿÓ±¾µgÿ¯¯»5AÏ–Ñ«'ò6г¬VôꋼmAÞz Äën=«¿Þõ¢îAzöº¹^CQ÷xðš9H¯‘È;KϲºÒKyq5cygéÝ Ž#žžÕ·Ÿ1¯±ðèÙqÇÓk"_"={}gÝTñø’éÙk;‘y7Š¼z–5yME^z—¼›Äq´¡gõÓé¥ ¯=;î6ôš‰Çמý;œÀÇ—._?zöo°;ónyCéý“żæ"ot7”y-ÄqŒ§gõGÓËÞTzvÜãéÝ"_=û}ñ_KñøæѳßyÌ»Uä-¦gYS™×Jä­ò3¯µ8ŽzV½6ÂÛäÇ¿ èÝ&ßNzö{í->¾¶âñíóçìdÞí"ï0=˚˼L‘w2È;̼;ÄqD®zVÿ$½vÂ+AïŸã¾6êµuËÓ³ßþ{²ƒðªÐ«xÅû}=˭ºD^=z ‚¼;E^*=˭Ǽ,‘—A/#Èë,ò2éYn󺈼.ô²‚¼»D^/z–Û…y]EÞÀkcýõ¼»EÞz–;yÝDÞ˜ oþ¾pð&}s¯»¨;žåNbÝ{EÞì ož×Cä- g¹³™×Säå}ó¼^"o=ËÍgÞ}"o}Ð7Ïë-ò¶Ò³ÜõÌë#òv}ó¼¾"ï=ËÝͼûÅ¿Ëcô¬ÏèõuÏýõ÷Á„W¤V¬¿îõ¯ =˵Ÿ1o€È«X+Ö_Ï(òªÑ³ÜŠÌ{PäÕªë¯ç y ý8ðw-æ yiµbýõ¼!"¯=ËMcÞC"¯C­X=o¨ÈëFÏr;0ïaÑß¾ô¬ÏÝè u‡ÔŠõ×ß÷‡ oTÐ_÷FˆÇ7ŽžåŽbÝGDÞ” ¿ž7Räͤg¹S˜÷¨È›ô×óF‰¼Eô,w.óy˃þzÞh‘·–žå.gÞã"ocÐ_ÏËyÛéYîFæ=!ú»—žõy;½1¢î¡ ¿þ9çIáúë^Žx|çèYî Ö+òŠ×Žõ×óƉ¼rô,×~Ƽ§D^åÚ±þzÞx‘WžåVfÞ‘W·v¬¿ž7Qä5¦g¹u™÷´Èk^;Ö_Ï›$òÚÒ³ÜæÌ{Fô7‹žõ¹-½É¢nÚ±þúçºg…׿v¬¿îMo=ËíϺω¼ì ¿ž7UäM¤g¹ÙÌ{^äM úëyÓDÞ,z–;y/ˆ¼ùA=oºÈ[BÏrç3o†È[ô×órEÞ:z–»’y/ŠþnöLJ¿×Ñ›)¼]ôìsôfz/‰Ç·?xøu‹<á ^î½,Žã=Ë=º³D^¡äØëÀó^y¥èY®ýŒy³E^…äØëÀó^yUéYnæÍy5“c¯Ï{Mä5 g¹5™7Wä5MŽ½<ïu‘×ÒŸüÝ”yóD^»äXßü:ÍÂëšë›{óEÝÞô,·+ëþGä úæy DÞHz–;ˆyoŠ¼œ ož·PäM¦g¹9Ì{Käå}ó¼E"o=ËÍeÞÛ"oaÐ7Ï[,ò–ѳ܅Ì{Gü»\CÏú¼ŒÞQwCÐ_¿.õ®ð¶ýu/_<¾=ô,wë.yƒþzÞ2‘wœžådÞ{"ïlÐ_Ï[.òâêD=Ë=˼÷E^|X=o…ÈK g¹ö3æ} òëÄúëy+E^2=ËMdÞ‡¢¿)ô¬ÏÉôV‰ºéubýõëp«…צN¬¿î­¯=Ëmú‰¼îubýõ¼µ"¯=ËíμEÞÐ:±þz^ÈíÏ3þʼODÞø ¿ž·NäM¥g¹ã™÷©ÈË úëyëEÞÏ£·AÔ]ôׯ;~.¼‚ ¿îmo=Ë-`Ý/DÞΠ¿ž·Iäí£g¹;™÷¥È;ô×ó6‹¼“ô,÷0󶈼HÝX=o«È+AïŸÜºQï+‘W¾n¬¿ž·MäU¡g¹å™÷µèo=ëszÛEÝzucýõë¬;„—Z7Ö_÷vŠÇ—AÏrSY÷‘—Y7Ö_ÏÛ%òºÐ³ÜLæ}+òz¹äíyéYn/æ}'òFýõ¼="o =ËÁ¼ïEÞ¤ ¿ž·WäM§g¹“˜÷ƒèïlzÖçéôö o=û=›ÞÅã˧gÛÝŠD×÷ù÷,÷*zùÌúQd}d-gÖ‘µ…Þ§ÌúI<þ]t¬îzEÍýAͬù³¨y„Þ~f5ÿðç ¡÷‹¨yÁu±šuy¿ÀaQ³$=ó-ë¢fy:V»$½#¢f• fÖ<*j&ѫ¬c¢æut¬v½_EÍ&ôFý<.j¶ ×„Y¿‰šméXíôNˆšYAMïçï¢fzYÌ:)j>@Çj÷ ÷‡¨ùpPÓûyJÔ|œÞÃÌ:-jŽ§cµ§wFÔœÔô~þ)jæћʬ³¢æët¬v½¿DÍ·é-žÛs¢æûôÞfÖߢæZ:Vû}z‘¢âú_PÓŸÛ Šþ»ævz™U¨è¿k~OÇjo§WXÔü9¨éÏmQó7z?3«¨¨y–ŽÕþ^œ¨W/ꎳ˜¨OÏ|Ë*.j^FÇjÇÓ»PÔ¼*¨éÇYBÔ¬Mï*f•5Ò±Úµé•5ÓèÙ1zÍÒ¢f+ziÌ*#j¶§cµ[Ñ»HÔ¼›ž-¥Ž‹DkÆ‹š}èÝͬ²"kPµ–YåDÖHzƒ˜u±xüOÒ±º#é•5Ÿ jžcÍKDÍôžaVQs6«=ƒÞ¥¢æ‚ fcö©¢¨™Oo³.5?¤cµóé%ˆšŸ5‡±f%Qs ½O™UYÔÜEÇjo¡w¹¨¹ŸÞ¸ ŸUDÍ#ôö3ë Qó:Vû½ª¢æõc5½ŸWŠš%é™oYÕDÍòt¬vIzW‰šU‚šÞÏDQ3‰^f]-j^GÇj'Ñ«.j6 jz?¯5[Ðk¬$Q³-«Ý‚^ Q3‹ÞÚ๭)jö —ŬkEÍèXíôj‰š5ý¹­-j>Nïaf%‹šãéXíÇéÕ5§5ý¹­+jæћʬëDÍ×éXí½·™Õ@Ô\KÇj¿OïzõþÔôãl¨ÞÿémdV#õþïÏþÞN/E½ÿÓ³côš7¨÷z?3«±zÿ§cµ£×Dxq ¢ž½§¥—*[<½T0%}l7ŠÇ–@Ï|ËjªÞÿƒ¬ÌºI½ÿÓ»ŠYiêýŸŽÕ­M¯™zÿjçs›®Þÿé¥1ëfõþOÇj·¢×\½ÿ5›³f õþOïnfeˆšƒ¼Oø»½[DÍ‘AÍlÖl)jæÐɬ[EÍgèXíz­DÍô¦ýl-j¾Jo³Úˆš èXíWéÝ&jæ5½ŸmEÍUôò™u»¨ù)«½Š^¦¨¹%¨éý¼CÔü–Þfµ5÷Ó±ÚßÒk/j jz?;ˆš§èaVGQó‚룎Õ>E¯“¨Y’ÞÆ๽SÔ¼„žù–•%jV¡cµ/¡×YÔL júsÛEÔ¬G/‰Yw‰šMèXízôºŠš-‚šþÜÞ-jÞN¯³º‰šYt¬öíôî5{гçÕ³»¨ÙŸ^fÝ+j>LÇj÷§×CÔ|<¨éÇÙSÔœ@ïqfõ5§Ò±ÚèÝ'jæÑkÔì-jΣ—Ǭ>¢æÛt¬ö={O{›Þýâ±}L¯-˜‰>¶~â±}Aïcf= ²¶YÛ™Õ_dí¥·YÄãÿ™ŽÕÝKo ¨ù[P³ŸÛEÍ¿èýƬAêý¿aÔ±ÚѬÞÿÆj¶eÍ!êýŸžù–õ¨y«@o¨¨Y;¨9‘55ѫͬa¢f«ÝˆÞpQ³½™A?GˆšèµbÖ#¢æÝt¬vz#EÍ>AMï磢æ`z}˜5JÔIÇj¦÷˜¨™Ôô~Ž5'ÓËaÖã¢æ :V{2½lQóÕ ¦÷ó QóMz¯2kŒ¨™OÇj¿IïIQs½íÁs›#j®§·ŠYcEÍ-t¬özzãDÍoƒšþÜ>%jþHï[f5бÚ?Ò› jž jús;QÔ,Ô(êbÖÓ¢fI:VÛ|ó&‰š—гçÕóQó z—0k²¨™DÇj_AïYQ³^PÓsŠ¨™J¯³ž5[бکô¦Šš·ÓkÔ|^ÔìLïvfM5{бÚé½ ¼þôì=­½éâ± £×ÌDÛ ñزé cV®ÈšdíeÖ‹"ëyz˜5S<þ<:V÷yz/‰šó‚š•ùÜ扚‹éÍcÖËêýŸŽÕ^Lo–zÿjf±æ+êýŸÞÇÌš-jn÷>áï/è½*jî jNcÍ9¢æ!z{™õš¨ù«}ˆÞ\Qó/zsƒ~¾.jK‰z1kž¨OÇj›oÞ¢fBJ¬¦÷s¾¨™H/Yÿ5kÓ±Ú‰ôˆš‚šÞÏ7EÍfô1k¡¨ÙŠŽÕnFï-Q³CPÓû¹HÔìF¯³Þ5ûбÚÝè-5ÓÛ<·ïˆšÒ̬%¢f«ý(½wEÍÉAMnóEÍ\z“™µTÔ|•ŽÕÎ¥·LÔ|3¨éÏí{¢æRzo2k¹¨¹ŠŽÕ^Jï}Qs=={^ý8Wˆš[é­gÖ¢æ·t¬öVz+E̓š~œŠšGéýȬU¢æ):Vû(½Õ¢f¡¢^VPs¨YŠžù–õ‘¨y «]ŠÞZá]AÏÞÓ.¡÷±xl5è ‹"ÑÇV [}z5˜õ‰ÈJ ²1kÈÊ —ʬOÅã¿ŽÕÍ ·^ÔìÔ¬Îçö3Q³'½ÎÌÚ ÞÿéXížô>WïÿAͬ¹Q½ÿÓƬ/DÍ Þ'sèm5ŸjÎbÍ/EÍ—é=Ϭ͢æ<:Vûez[DÍÅôýÜ*j® ·˜Y_‰šÓ±Ú+èm5¿jz?¿5wÐû‚YÛEͽt¬öz;DÍCAMïçNQó½CÌúFÔü‹ŽÕ>Ao—¨Y¬q¬¦÷ó[Q³,=ó-k·¨™@Çj—¥÷¨™HïPðÜî5“é%2ë{Q³«Lo¯¨Ù,¨éÏí¢fkz͘µOÔì@Çj·¦÷_Q³[PÓŸÛý¢f_zݘõ£¨9˜ŽÕîKù(={^ý85ÇÒ{”YEÍÉt¬öXz?‹š¹AM?ÎC¢æz¹ÌúEÔ|“ŽÕžCï°¨¹”^ æÿDÍÕô–2눨¹žŽÕ^Mï¨ð¶Ò³÷´õôŽ‰Ç¶›žÍ½Ù\=¶_Åc;@o7³Ž‹¬£AV*³~Y§éeÖ ñø 5‰:V÷4½ßEÍRMb5Û²æIQ³=ó-ëõþOÇjW wJ½ÿ5»³æiõþO¯³Îˆš©t¬v}zŠšAÍ!¬yVÔ̤—Á¬¿DÍÎt¬v&½s¢fOz5ƒ~þ-j ×“Y&œ_s«=€Þqÿ®™Ôô~Šûw͉ô²™UXÔ|žŽÕžH¯ˆ¨ùrPÓûYTÔ|ƒÞËÌŠ5Ó±ÚoÐ+&j®jz?‹‹šôV0ëBQó :V»€^ Qs‡÷=xnKŠš?ÐÛÁ¬R¢æ!:Vûz¥EÍAMnˈšçè`ÖE¢f±Ô¨cµÏÑ‹5˦Æjús[VÔ¬DÏ|Ë*'j&Ò±Ú•è],j&ÓkgyQ3…^2³.5›Ñ±Ú)ô*ˆš­ƒš~œ—ŠšéµfVEQ³«Ý‘Þe¢f_z݃š ¢æz}™UIÔ|”ŽÕB¯²¨9–žÍòú|âå¢æ³ôÆ2«ŠÈÊ ²|>ä ‘5‡^.³ªŠÇÿ&«;‡Þ•¢æÒ ¦¯ãU5WÓ[ʬ«DÍõt¬öjz‰¢æÖ ¦_o½ZÔÜMo+³ª‹š?Ò±Ú»é]#j júyq’¨yšÞQfÕ5 Ýu¬öiz5EÍRôÆý¼VÔ¬@Ï|˪%j^AÇjW W[Ô¬Ôô~&‹šõéÕ`VQ3•ŽÕ®O¯®¨™Ôô~^'jfÒË`V=Q³3«I¯¾¨Ù3¨éýl j ×“Y׫÷:V{½†êýŸÞ”à¹m¤Þÿée3+E½ÿÓ±ÚéÝ ÞÿƒšþÜ6Vïÿô^fVõþOÇj¿A/U½ÿ5ý¹½Q½ÿÓ[Á¬¦êýŸŽÕ. w“zÿ§738Î4õþOo³š©÷:Vûzéêý?¨éÇy³zÿ§w‚YÍÕûÓ¨cµÏÑk¡ÞÿéÍ jf¨÷zæ[Ö-êýŸŽÕ®D¯¥ð’éÙ{Z"½[ÅcK¡g÷N¬åck%[:½fµVïÿA–ϳµQïÿôZ3ë6õþOÇêv¤×V½ÿ5}îàvõþO¯/³2Õû?«=„Þêý?¨¹—5Û©÷zc™Õ^ÔÌõ>áïgéu5ç5ý:^GQs!½9Ìê$j.¥cµÒ»SÔ\MomÐÏ,Qó3z«™ÕYÔÜJÇjF¯‹¨¹;¨éý¼KÔ<@o7³ºŠšGéXíôî5O5½ŸÝDÍÂ7E½Ó̺GÔ,EÇj›o^wQ³ÂM±šÞÏ{Eͪô*0«‡¨YƒŽÕ®J¯§¨YŸÞÆà¹í%jÞH¯>³î53èXíéõ53ƒšþÜö5»ÐËdV_Q³'«Ý…Þý¢æ€ ¦?·ýDÍáô0ëQ3›ŽÕN¯¿¨9‘Þöà8ˆšÓèMdÖ@Qóe:V{½EÍ7‚š~œƒDÍwè½Á¬Á¢æ :VûzCDÍz{ƒš‰š›è0k¨¨¹ƒŽÕÞDïaáý@ÏÞÓvÐ&Û/ôNDb÷’ íwz¿0k„È:dù,ï#"«xZÔ;Ǭ‘âñ—¥cuÍ7ïQQ³RZ¬¦Ï\5¯¦W‰Y©÷:Vûjz£ÕûPÓ×ÆWïÿôR˜•-j¶¦cµÓé=!jv júÆQóz™õ¤¨Ù—ŽÕ¾‡^Ž¨9Äûôs¬¨9ŠÞf5ÇÒ±Ú£è=%j>Ôô~Ž5_¤÷,³&ˆšsèXíéM55½ŸO‹šËè-dÖ$Qs5«½ŒÞ3¢ægAMïçdQó+zŸ1ëYQs7«ý½)¢æzÖKnŸ5Ñ;À¬©¢æi:Vû½çEÍÂÍb5ý¹&j–¦g¾e½ jV cµKÓ›.jV jús;CÔ¬I¯*³rEÍút¬vMz/Šš7Ò+çLQóz72ë%Q3“ŽÕ¾…^ž¨Ù%¨éÇù²¨Ù‹^fÍ5бڽè½"j§W9¨9[Ô|‚Þpf½*jN¤cµŸ 7GxÓèÙ{ÚDz¯‰Ç6‹žÝwí÷îÍm>½YÌz]d½dù½óDÖôÞaÖÿ¯½óŽ’ªèÞu‹$A¢J4 *q:÷¨ ’³d%H0'@Ä ˜Ãg³ ‚€‰¨€ATDÀLTTTT@½û=õÖ¯ëêëýãþuïZ߬µ‡á̳÷sNÕ>ÕÕ0Ó-Îxß$÷¬p® œþg\ŸÎMäÖ±ÖóêñŸ ܛȽ ÿ§ÿY¤™êñŸÜÖš%œúy²?!÷¢p–l–wúÿ3~I8+’Z/ gu2pW$7[8k“;-˜Ï9ÂÙˆ\mÖzE8sdànDn®p6 œ~>ç grÍXk¾pö wr¯ gÿÀéçó5áA®?k½.œcÈÀ=‚ÜÂyMàôóù¦pN&w k-ΩdàžLn¡p>H®E0¶‹„s¹Yk±pÎ$÷ rK„s~àôc»T8—›ÏZo ç*2p/!÷¶pnœ~l— çVrXk¹pn'÷Vr+„ór‚ë|G8ûµV çáÍ÷r«„³Ló¼Ó_çjá¬LÎ ÓÿÃGÂy¹ ¬õ±zü'÷mä6©ÇÿÀéÞôõøOîQÖÚ,œ³ý<ÙŸÏ’ûT8ß œþ炶çrro²ÖVá\Gîåä¶ ç&r—óù™p~Ink}.œ{ÈÀý%¹/„ó—ÀéçóKáü‹Ü/¬õ•p–lá¸ÿ"÷µpVl‘wúùüF8%µ¶ gm2pKn‡p6 œ~>w g!¹F¬µK8›‘»Ünáì@n|0¶{„³'¹¬õ­pö'wOrß çˆÀéÇv¯pŽ%7‚µ¾ÎkÈÀ=–ÜÂ99pú±ýQ8§‘›ÌZû„óA2pO#÷“pÎ wkp? ç,r3XëáœOîYäö ç’Àé¯óWá\Mn ký&œÈÀ½šÜ﹕Ü=ó€pî ·•µ çdàÞAîàÃcÚäþ\Ñ–ŽÃÏ3 ÷§¸†²äðz›5cüY5q UÈG­X‰Ö:1¨•b­ÃJü³V=r'²V‘ÿ<ÿxë‘;\8›ÎVtÎ6äš°V1áìBî6äŠ gŸÀé߯„p!ׇµJ ç(2p!w„p^8ý{ê•Ήä®`­ÒÂy¸'’;R8ï%W3˜Ï2Âù¹{Y«¬p>KîÇÈ•Î9ÓÏgyá\@nkUÎådà^@®¢p¾8ý|%œŸ{µŽÎ/ÉÀý ¹c„óÛÀéç³’pî'÷-kUοÈÀ½Ÿ\á<¢•ãRÁØVΣÈG­jÂy,¸"W]8ëN?¶Ç g¹:¬uœp’»€ÜñÂÙ<΂«'¸¥äÀ¿Êzõ·†x_¯à> êù÷(m(¸Ïn)½ÄØí"çgä D½Ÿ‚zþüâ¢ÞÁ¸üÄz 1Î%Z;þ?È%…·Bë¼w ¹”ðV'9àÒÂ[›üÕÉe„·QàýÞ¬ð\#ÖË osrð’+ÞŽ­ó}àûå4á=§u~Þ:²ÞéÂ{>9øÏ!w†ð^x}¿4ÞKƒë½€õšïõä࿔ܙÂ{KàõóÛTxï¸[Xï,á}„üw“k&¼Ïõü}Ô\xg“ó ëµÞ7ÉÁ?›\Ká]x}_µRÿäÀ,g½ÖÂû 9øß#×Fx¿ úÅ÷U[áý.¸Þ¯X¯ðþJþïȵÞÃÚä½¾¯:oirèä€ë(¼Çƒ¿4¹NÂ{BàõëÕÙÂ{j›ü|œÀz…7IþSÉuÞÆ×÷sWámÝ&?¿Y¯›Úÿ“ƒ¿5¹îÂÛ'ðú~î!¼CÈ¡ú°^OáMþ!äÎÞ+¯ïçs…÷†€»’õz ïäà¿\oá½?èßÏ}„÷‰àzïg½¾Âû9øŸ wžðÎ ¼¾Ÿû ïâ ¯æ±^á]EþÅäï†Àëûù|áÝôÕÖ(¼;ÈÁ¿•Ü áý1ðú~,¼ƒùý‘õ†o±¶Žƒÿ ¹¡Â[®mÞëûy˜ðV 8ä€.¼'‘ƒ¿*¹ÂÛ ¨çûy¤ðfÉáÜ°ÞÂ{9ø³ä.ÞöA=ßÏ oàüÚ³Þ(áíOþäF ïˆÀëûùbáÛ6ßW#Xïá½–ücÉÞ›¯ï«±Â{gÀÝÄzã„÷?äà¿“Ü¥ÂûTPÏÏïeÂû9ŒÉS¬w¹ð¾Nþ—È]!¼oãçç÷Já]po³ÞUÂû19ø×’»Zx¿êùù½Fx÷ãòë]+¼¿ƒ¹ë„÷¯Àë׫ë…÷ˆvŽóëÞ£ÈÁp„÷¸vy¯ï«‰Â{29ÌÅq¬wƒðÆÉÁ2¹IÂ{zàõëÕÂÛ²]¾¯Ng½ÉÂ{69ø[’»Ix{^ßÏ7 ï r“^¬w‹ð^DþAänõ.Æ×ÒÔ¾¾­„øùr—³Öí¢Ö­A¼ÊZwˆZ÷»•µ¦¨ý?xï!7U8Ÿ Î Ó„s6¹gXëNá|ƒ ܳÉÝ%œËÈù5λ…s¹e¬uºÿÉÀ½ŽÜ½ÂùEpÒyŸpî!÷kÝ/œ?“{¹÷'9ðÈ=(έdûü¼ûzHœ[EràQë?ÂY ÜÉ=,œµÉ- æýálD®6k=*œ92p7"÷˜p6kŸŸw grÍXë áìAîä¦ gÿà:ý¼ÏÎäú³Ö“Â9† Ü#È=%¸kÈ÷÷ÞÓ‚›L¼Ÿ«gÄ5L úÃÏÕ³â"7µžÎdà~ˆÜó‚›E|ûÚŽ{AœÛ«Á¹ùñ)Îm)¹Wéœ%œ«ÉÀ½”Ü‹‚ÛH¼_g^Ü6rƒ¾|Yp;Ém Æd¶¸Ö}Aÿúy˜#®õ¹}¬õŠÚÿwp ܇ÈÍÎräÖý;O8«’Zó…³&¸«’{UpõÉ÷kêk‚ËïïÁ××”xßKo®9ð~LÞcÒ½C~ü˜,cÒ\w^ëBáFî~ä îràýš¿XpW“ï׈%‚»‘xßëK7•ÜÁœ½%¸ÉM ®ãmuÿ“Ãþ9»ebìf‘;y¬«µ\ì¹æ“Áÿ7œË½í Á-!~>ÏíÁ­&Þ×[)¸A=¸Á­ܶ€[BïjÑO;ýu˜s¹5¢Þ¾ÐËó{WÔ;ŒË>Ö[+æ¢xGÇÁˆÜ:á-ß1ï]Mî=á­F rÀ½/¼µÈÁ_ÜÂÛ0ðn¤w½ðæ®!ëmÞfäàÏ‘Û(¼:æûÀ÷ˇÂÛ³c~Þ:°ÞGÂ;€ü=É},¼#¯ï—MÂ;.¸Þ‘¬÷‰ð^Gþqä6 ïÍ×Ïï§Â{WÀÝÌz[„÷arðßEn«ð>Ôó÷Ñ6á}Ù³ÅÓ¬÷™Úÿ“ƒÿerŸ ï²Àëûê á]GÌ2ÖûRx7‘ƒ¹¯„÷Ë _|_}-¼ß×û%ë}#¼ûÉÁÿ-¹í½˜ ½¾¯vo)rÑ:ØÉq;…÷hrð—"·Kx¼~½Ú-¼§tÊÏÇñ¬·Gxäà?…Ü·Â{Fàõýüð¶ê”Ÿß3Xo¯ðv&+rß oïðzcŽûAx“Côf½…w9ø“Û'¼W^ßÏ? ïÄ€»‚õ~ÞÛÉÁ?‘Ü/Â{_Ð/¾Ÿ÷ ïãÁõÞÇz¿ ïóäàœÜoÂ;7ðú~þ]x}5—õïJrð/"wPx×^ßχ„wKÐWëYïáÝNþ-äþÞ¯ïç¿„÷@0¿?°^¬¤øù¿³ÿr‡•ü§·ìÙÁõÆW¤ä?½U9àÞšäà¯B®¨ðÖêù~.&¼r8·ú¬W\x›’ƒ?C®„ð¶ êù~.)¼ÝƒókÇzGo?rðw'WJx‡^ßÏ¥…wÌÙù¾ÎzG ï5äàC®ŒðN¼¾¯Ê ï´€›Ìzå„÷!rðO#W^xŸ êùù­ ¼/’Ø<Éz…÷5rð¿Hî(á}+??¿G ï»÷ë#¼‘ƒÿ]r•„÷󠞟ßÊ»;—ÏY¯ŠðþLþÝäª ïŸ×¯WÕ„·dgzù“õª oErð#ܱÂ{lç¼×÷ÕqÂ[‡æâXÖ;^x ÈÁ_‡Ü Â{ZàõëU ámÑ9ßW§±Þ‰ÂÛ‰ü-ÈÕÞs¯ïç“„w ¹h=e½ZÂ{!9ø’«-ê]Œß>—®SòŸÏ¥Ç“»ŒµNµn z`>k"jÝMîÖ:UœÿÃdཛ\]á|:8ÿÕtÖΗÉ=ÍZõ…óu2p¿L®p¾í¯3–¿Î†Â¹–ÜÛ¬ÕHÝÿdà^K®@8?®s#qáÜMîsÖJçOdàÞM.)¸?ÈO.%έD—ü¼ûJ‹s«@ºRx_"æ)Ö»JíÿÉÁÿ¹«…÷íÀëûêá]KÌÛ¬w­ð~Lþµä®Þ/‚~ñ}u½ðî ®÷ Ö/¼¿ƒ¹ ÂûWàõ}5Qxèî8ôÀ_¬wƒðE~䀛$¼ÇuÏ{ýzu£ðžÜ=?DZÞdᓃÿdr7 ïé×÷óÍÂÛ²{~~Og½[„÷lrð·$w«ðö ¼¾ŸoÞAäнXïvὈüƒÈÝ!¼—^ßÏS„wBÀ]ÎzS…÷6rðO 7Mxï úÅ÷óÂûXp½÷²Þ]Âû9ø#w·ð¾x}?ß#¼ ƒ¾z…õîÞwÈÁ¿Ü}ÂûAàõý|¿ð~ôÕ¬÷€ð~CþOÉ=(¼ß^ßÏ ïïÁü~ÏzÿÞÃ{8þßÉ=,¼ezä½¾ŸÞʇpªý?9ø+“{Lxëõ|??.¼ir8·z¬÷„Úÿ“ƒ?Mnºð¶ êù~ž¡öÿÁùµe½'…÷c½W„÷'rðï"7Wxÿ¼~½š'¼%z:̬7_x+ƒ9à^Þê=ó^ßW¯ omr˜‹ê¬÷ºð6"mrooaàõëÕ›ÂÛ¼g¾¯ Yoðv$sr …÷œÀëûy‘ðžOcrë-Þ ÈÁ>¹%¢Þ¥Áø-æsé¥â¹ôõä.e­·D­›ƒ˜ÇZo‹Zw‘»™µ–©ý?xï"·\8Ÿ Î+„ó%rO±Ö;Âù¸_"·R8ß"ç×x8W ç»äÞb­Õêþ'÷»äÖçgÁun ó]áÜEî3ÖZ+œûÈÀ½‹Ü:Á"þzrï‰s+~N~Þ}½/έ<9ð¨õpV%wyrë…ó$r‹ƒyß œ ÈÄZ…3Cîä>ΦçäçÝ_çGÂÙŽ\SÖúX8»‘»¹MÂy^p~Þ?ÎaäÎc­ÍÂy1¸‡‘ûTpW‘ïï½-‚›D¼Ÿ«­â¦ýáçj›¸†ÈMa­Ï„ó 2p?@îsÁ½@|mþ{íâÜæçæÇ÷Kqn‹ÉÍ£ó+á\IîÅä¾Üzràý:óà¶[ôåvÁm'·%“âZú×ÏÃNq­ÈýÀZ»Ôþÿ\ÇÀ}€Üná,CnUп{„³29ð¨õ­pÖ werß ®.9ð~MÝ+¸9ðþü^pMÈ÷½ôƒàÚïÇäG1&]ÏÍσ“}bLú’ëÊkýI8‡»/¹Ÿ7šx¿æÿ"¸+É÷kÄ~ÁÝ@¼ïõ_w¹‚9ûMp÷“»#¸ŽßÕýOûä`숱{ÜlþÛÿA±çšëç5æÞÜ!Á-"~.ÏíÁ­$Þ×ûSpëƒz)r nKÀ-¢7vÄ?ûi;98·;ìñóA=~ED½Á¸üÀz‡!þÿ¯—ãà?@®¨ð–í•÷®$WLx«ƒpÅ…·&9ø«+!¼õïzzK o&àê³ÞÂÛ”ür¥„·]¯|ø~)-¼Ý{åç­ë)¼ýÈÁß\áx}¿”Þ1Áõg½rÂ{ 9øÇ+/¼“¯Ÿß Â;-à&³^Eá}ˆüÓÈ%¼Oõü}t´ð¾HÌ“¬wŒð¾FþÉUÞ·¯ï«ÊÂû.90o±^áýˆüï’«*¼Ÿýâûªšðî®÷sÖ«.¼?“ƒ7¹c…÷ÏÀëûê8á-ÙÛqè?Yïxá­H~ä€;Axí÷úõª†ðÖéŸcYïDá- r5…÷´Àëûù$ámÑ;?¿§±^-áíDþäj ï¹×÷sáH=p.ë,¼’ƒ ¹S„÷²ÀëûùTáp—±^]ὕüãÉÕÞ{‚~ñý\_x ®÷Ök ¼Ï’ƒÿQr …wNàõýÜHx}5‡õ „w9ø‹ ïû×÷sBx7}õ>ë%…÷krðo&—Þ½×÷sZx æw/ëe„·HÇÁÿ¹¬ðÙ'ïõýœÞJ‡p…Â[ƒü•È&¼uƒz¾ŸOÞ9œ[]Ö;Cx›ƒ?E®±ð¶ êù~n"¼]ƒókÃzg o_rðw%×Tx‡^ßÏg ïÅ}ò}5”õš ïUä࿘\sáx}_µÞ)7‰õZ ïäàŸB®•ðNêùùm-¼3ÉaL¦³^áOþ™äÚ ï’`üüü¶ÞÕ·„õÚ ïFrð¯&×Ax·õüüvÞÁ¸lc½N»ü;É-¼‡¯_¯: oñ¾Žsˆõºoyrð#\Wá­Ö7ïõ}ÕMxk‘Ã\Tc½îÂÛüµÈõÞ\àõëUOámÖ7ßW9Ö;Gx;ƒ¿¹s…·gàõýÜKxØôd½ÞÂ;’üÈõõÆ㷈ϥûñÏçÒבÇZç‰Z7=0—µú‰Zw’»‰µú«ý?xï$7@8Ÿ Î%ç ç‹äžd­Âù*¸_$7H8—’ók<œƒ…s ¹¥¬5DÝÿdà^Cn¨pn ®s=Äs'¹m¬5\8$÷Nr#wøëÈçVì¼ü¼ûº@œ[9ràQëBá¬Bîrä.Κäó>J8ë“«ÉZ£…3Mîúä.Î3ÏËÏ»¿ÎK„³-¹3YkŒpv%w[rc…³op~ÞÇ çPr}YëRáMî¡ä.Ü•äÀû{ïrÁÝ@¼Ÿ«+Ä5Üô‡Ÿ«+Å5ÜOîÖºJ8'÷ýä®ÜóäÀWä¿×^#Îmnpn~|¯綈Ü\:¯ÎwÈÀ½ˆÜõ‚û€x¿ÎŒܧä>úr‚à¾!÷i0&ŵ~ô¯Ÿ‡ĵþNî{Öš¤öÿý÷ïänÎ#É­ úw²pV"µnÎÈÀ]‰ÜÍ‚;•x¿¦Þ"¸$9ðþ¼UpÉ÷½t›àZ“ïÇäv1&]úåçÁÉbLúëÂk"œƒÉÀ݇ÜTÁ"Þ¯ùÓw9ð~¸SpÉ÷½~—àn'71˜³»w¹Ûƒë¸GÝÿä°¿AÆî^1vÏ“ÛÏû¿Oì¹^!SÓbrÌq÷ n!9ð¯ðÜÜ;äÀûz ^Mr îÓ€[HïD?}CÎOÉ=,ê}Ôóç÷ˆ¨÷{0.ß³Þ£b.ïï8ø'÷˜ð–éŸ÷¾Cîqá­L rÀ=!¼'’ƒ¿2¹éÂ[/ð~@ï áM\=Ö{RxÏ$šÜSÂÛ¶¾|¿<-¼Ýúçç­-ë=#¼ç‘ƒ¿¹g…wXàõýòœð^\ï0Ö{^x¯&ÿ%ä^Þ¯Ÿß™Â;5ànd½YÂû 9ø§’{Qxgõü}ô’ðÎ"f뽬öÿäàŸEn¶ð. ¼¾¯æïr`–²Þ+Âû!9ø×›+¼Ÿýâûjžðî ®÷3Ö›/¼?‘ƒ¹W…÷Àëûê5á-1Àqè?Xïuá­@~ä€{Cx«È{ýzõ¦ð֟ꬷ@x‘ƒ¿6¹…Â[x}?/Þæòó[Èz‹…·#9ø›“["¼ç^ßÏK…÷|rèsXï-á½€üç“{[x/ ¼¾Ÿ— ïõw)ë-Þ[ÈÁ=¹Â{7¹w‚uòá}$¸Þ»Yo¥ð>CþGÈ­ÞÙ×÷ójá}“˜Ù¬·Fx—“ƒÿMrï ï{×÷óZáý„æâ=Ö['¼_‘ƒÿrï ïw×÷óûÂûk0¿ß±ÞÂ{ØùŽƒÿWrë…·ôùy¯ïç Â{LÀ!ÜFµÿ'ÿ1ä>ÞSƒz¾Ÿ?Þ$9œÛ©¬÷±Úÿ“ƒ?In“ð¶êù~þDíÿƒókÍz›…·9ø»ûTx‡^ßÏ[„w49ŒÉÖÛªžÿ“ƒ4¹mÂ{Càõ}õ™zþp7°ÞçÂ{?9øï ÷…ð>Ôóóû¥ð¾@còë}%¼óÈÁÿ¹¯…wq0~~~¿ÞU·˜õ¶ ïrð¯"·Cx·õüüîÞÁ¸le½]Âû#9øwÛ-¼¯_¯öo±Žsõ¾ÞräàG¸ï„·êÀ¼×÷Õ^á=‰æ¢*ë}/¼ ÈÁ¹„7xýzõ£ðž50ßWYÖÛ'¼íÉÁ¹Ÿ„·Gàõýü³ðö'‡1éÁz¿ïrð÷'·_ÔŒßB>—þU<—¾–ÜXÖúMÔšôÀ+¬õ»¨5Ís¬u@íÿÉÀ;ÜA᜜ÿ;tÎYäf°ÖÂ9Ÿ ܳÈý)œKÈù5ο„s5¹%¬+%î2p¯&wX©:·×ùEJ‰÷ÿ%·•µÎÈÀ½ƒ\QÁ þZrÅĹ”ŸwßCÅŹ•%µJge2p—%WR8O$·0˜÷#„³¹Y«”p¦ÈÀ]\iál2(?ïþ:Î6äš°VáìBî6äÊ gŸà:ý¼—Î!äú°VyáEî!ä*î ràý½WQpÉ÷su”¸†Ûƒþðsu´¸†ûÈÝÎZÇçcdà¾\%Á=Gü_µWYœÛ+Á¹ùñ­"Îm!¹Wè¬*œ+ÈÀ½\5Á½O¼_gª n3¹÷ƒ¾çUbŽKn9ðsxnIÁ­ Þ×K îý ^yriÁm¸ôfD?}MÎÍä²¢ÞÞ ž?¿œ¨÷[0.{Y¯PÌE‘!Žƒÿ7r§ ï‘CòÞäNÞJäÀ ÜÂ[ƒü•È5Þº÷}z›o*àê²Þ™ÂÛ„ü)rM…·Í|ø~9Kx»ÉÏ[Ök&¼}ÉÁß•\sáx}¿´Þ‹ƒëÊz-…÷*rð_L®•ðN ¼~~[ ›Äzm„÷rðO!×Vx§õü}ÔNxg’3õÚ ï|rðÏ$×Ax—^ßW…w590KX¯“ðn$ÿjrg ﶠ_|_uÞÁõnc½.»ü;ÉuÞC×÷U7á->ÔqèC¬×]xË“ƒ9àzoµ¡y¯_¯z o­¡ùù¨ÆzçoCrð×"w®ðæ¯ïç^ÂÛlh~~s¬×[x;ƒ¿¹>ÂÛ3ðú~î+¼È¡z²ÞyÂ;’üÈõÞq×÷sá½.àƱÞá½™üב;_xï úÅ÷ó@á}8¸Þ»Xoð>Mþ‡É Þ—¯ïç!ÂûFÐW/³ÞPá]Fþ7È Þu×÷ópáÝôÕ:Ö!¼_’ƒ¹‘Âûmàõý|ðîæ÷[Ö»PxcÃÿ~r o©ay¯ïçQÂ{tÀ!Ühµÿ'ÿÑä.ÞS‚z¾Ÿ/Þ9œÛ)¬7FíÿÉÁŸ 7Vx[õ|?SûÿàüZ±Þ¥ÂÛ›üÉ]&¼ƒ¯ïçË…wÔ°|_ f½+Ôórð"w¥ðN ¼¾¯®RÏÿn"ë]-¼÷‘ƒÿvr×ïãA=?¿× ïóä0&³ÞuÂ;—üÏ“»^xãççw¼ð® ¸E¬7Axדƒ%¹‰Â»%¨çç÷áÝŒËÖ›$¼?ƒ;¹…÷@àõëÕdá-:Üq`°ÞMÂ[–üÈw³ðVž÷ú¾ºExk’‹žÏ°Þ­Â[Ÿü5ÉÝ&¼™Àë׫ۅ·éð|_eXïámGþ¦ä¦o÷Àëûyªðö#‡1éÎzÓ„w89øû‘»SÔŒ®¥©}}—x.} ¹1¬u·¨ucÐsXëQk*¹Yë^µÿ'ïTr÷ çôàüWÐy¿pÎ$7µÎydàžIîAá\Lίñp>$œ«È-f­ÿ¨ûŸ Ü«È=,œ[‚ë|ŸÎG„s;¹-¬õ¨p~OîíäÜïäÀ_Cîqqn‡ÈÏ»ï¡'Ĺ•!µ¦ g%2p—!7C8k[Ìû“ÂY—\ ÖzJ8“dà®Kîiál<"?ïþ:ŸÎÖä³Ö³ÂÙ™ Ü­É='œ½ƒëôóþ¼p&×›µ^΋ÈÀ=˜ÜLÁ]N¼¿÷f n9ð~®^×p[Ð~®^×p/¹ÛXëeá|” Ü÷’›-¸gÉß_ËqsÄ¹Í ÎÍï+âÜ›Cç\á\Nîäæ î=ràý:3_pŸ{/èËW÷¹O‚1yM\ëwAÿúyx]\ë¯ä¾c­7Ôþ¤càþ•Ü›ÂYŠÜŠ çÑäÀ£ÖBá<Ž ÜG“[$¸“É÷kêbÁÅÉ÷÷àÁN¼ï¥¥‚kI¼“·Ä˜œ=2?~LÞcÒ‹ÜÙ¼ÖeÂ9 ܽÈ-Ü…äÀû5…à.#Þ¯ïn<9ð¾×W îVrãƒ9[%¸{ÈÝ\Çjuÿ“Ãþ9»5bìžõ^üÛÿá±Ø»¢Öl2ã*Ú>é${¾ksÛ½¶Õ<ÕÖØÛŸ¶´u¯•E»O»Úšz®ïgë´Íêï‹­ußaݪcc±ÒŒ±ÇP‹/,6X,·xÕâ9‹ÿXÜaq½Å%ƒ,zX´¶(´¨gqœE9‹Ã,~º$ûÆâc‹UoZ̲xÌâN‹,.µfÑË¢½Ec‹F'ZeQÌâ׋c±]ŸZ¬µXl1Ûb†Å½7Y\iqÅyg[œe‘´¨mQÙ⋃£m°øÌâ‹·-æYaãgÑÎb˜ÅU÷[̵øÀb¯Eé¤Õ±hi1Ðâz‹‡-^·øÈâ'‹j)«cÑÎb˜Å$‹',Y|jñ›Å1éX,aq¶Å…·X´(iì±-˜÷‘È{Šyc,ç‹iOZ¼fñn}—÷±È{…yêÙc¾qU,ê[4µèμM"o)ó&ZÞí[̵Xi±¥žËûDä½Ç¼£9Þ"aÑÊ¢·Å(æmy[™·ò›_‹í,ÊÚcIÍS]Þ§"oó:ÛÛb”ÅD‹û,ž?Ååmy¿3oÓÉv¿Zì·(eüñ æmyxÌÃÇãGZ\gq—ÅÓoœìò¶‰¼c˜·Ó?÷Y7¶šEC‹fÌûLäļ«,g’Å3-–Xl¬ãò>yqæ]gë7[o‡È»›yG›osq÷;ˆW™¯Õ©Æ¼"ï æ½kÜiæšcQ×\Ó+äóv‰¼—˜3ߊâîw‚‡š/cuŠ3o·È[ȼ׌«c®G-*™kJ…|Þ‘·†yûíyÈ‚âîwÁûš¯¾Õ9TÁå}+ò>aÞ‹Æk®{,Ž4~R…|Þw"oó6™ïÑâîõ0š˜¯l9×kÈÛ+ò~a^®ŒÝ«Ç—µ±)ëòÐÛÈû^äaÏe滵¸{šºæ;PÖõò~y˜WË\wY”2~bY—7†¾EÞ Ì{Ù|—w¯ UÉ|Û˺^CÞ>‘×€yåÍuÅ~‹Qe]^?ú~y§3ïaó ,î^§­ˆùÖ—u½†¼ŸE^[æ2v¤¹¾´è]Öåµ£ï‘wón6_§âîu÷–¶û°¬ë5äíyC˜·Ó|=͵΢UY——¡ïW‘7–y×™¯…ùðº™_›onY×kÈûMäM`Þ6óu0×2‹3ʺ¼úôý.ò¦2o€ùêw¯)¼¢´ëµ¡ôy0ÿ_ŽÇÿN¥]zë/òŠ¼˜×Á|‹»×ôžSÚõZWú‰¼×™‡Ÿ_Á¿ãœVÚå¡·§Ó÷‡È{‡y9óýY̽žþ£¥]¯5¡ïO‘÷!óðódøwÔ:¥]z{ }‰¼¯ü}d¾ÝÅÜ{YÜZÚõZ]úb¥ÿ™÷#óð³øÿ‹Š¥]zû*úyùûÈ|sï-sYi×k•è+"òð<øÙjü"Æyèí¡ô.òª3¯8þ§˜{o¡ K»^;’¾¢"ïTæágêñȸG‘‡ÞîK_1‘—eÞN;ðb1÷Þkè5¬‡xÌF^q‘×’yØctñ’.½õ{ä•yݘ·Ñ`^sÍ,áòÐÛXo§¯‚ÈûÌσÈs½†õÙ—ÑWQä}Ǽ•E]zë/öØÇ"ï(‘wÐσ¨YÌõÖCeÞŠÃ\¯a=Äc6ö•ïÒWKäí òÐÛX±GÀ>öhúj‹¼_™7ç0×kXñ˜}åkôÕyøŸ‡ÞÆú‹=ö±1úNyG1ïÙÃ\¯a=Äc6ö•/ÒwŠÈ;1ÈCocýÅûX<×BÞ©"¯óñyž+âù)žûçáuE^cæMâs¾é|n»ºBþyU=‘מyØ«`„=öØ{úýn}‘׋y÷ð¹æ>§Þ\>¿i ò†1÷6Ö¬aX7–Ï?>4y—2cŽyFo¡Ÿqùû¶‘È»yØóãyžÛàùÔ˜àycÈ»“ysùe=Ÿ‹àsNäÅEÞcÌÃþ{NìsGñ¹#žC /!òf1oŸ}Éç€Øgϼ¤È{“yX/±FäóÇ»ø<y)‘·ŠyècÜ;¸_±F`]Ê1/-ò>fö¨C¹ŸÂçþyNFä}ü¯¹§Æ>Ïð|¥ ó²"ï'æao|Ÿ<Êç:x~…¼œÈÃÿGâãgîå±çÀº€½k'押rÌ»†Ïâó·ø¼y§‰¼ã˜‡µëÖ@¬»Xë‡3ït‘Wy·s÷<÷«ëƒ}ù"¯yØaˆ}'öºØ_b^c‘ךysÿø÷É_òùòšˆ¼ÌÃ>{Oìw±ÇÉçÈ;Sä bÞLî[Ws¾ÏC×Tä]Â<¬·Xãñ¸‚Ç2<~>ÀýÙY"ïzæ-à¾c3÷WØÓù}d3‘wó°Àžû¤Ë¸|”û‰æ"ï?Ì{—ûÝÜ×a/Y‡y-DÞsÌþ{¥1Ü>Ľ/òZŠ¼W™·…û¬ÜOb›a^+‘·œyx Ãã&«±?Àžd%ÿZ‹¼ ÌÛÏÇI<6c?€=ˆß÷´y_0ï:>Æ>̽Ä2î™×Vä}Ï<ñxÏv¼:ÞËï+Ž÷øÆûm㽯+ó=¡»ñ½’§ò=„×ð½uKð=g›ó½Xý{š¾Ä÷üÜÅcåù>íøþŒwñØ|ÃÅ|¿À<†÷˜Ã{ª¡F;28†÷OCÍa|B08†1é,Æd?ÇÄ¿ÞS ïo…÷šÂû>á=˜ð~Hxo"¼OPI¾N ÿ¾2|¿•|¼'H%¾WFW¾‡Ä¾·Âj¾ç@q¾3¾F½­÷ùZè;y¬_ÿ¸-_·úN»Ÿ¯í¼ˆ¯£\ŸÇðÚ»x­YÔhKÇ𺲨9”¯Ï Ç0&]Ęà÷Çñá_ß´2_÷³_s*_'r _?±Ä÷º‚͸×ÛÃkß=2À½&^Ÿí×îuËðbx=/¼¶^ç ¯9…×Âk1áu‘ðEx½ ¼v ¼V^Ï`•åëB´áëyLã±ûøš ùúõx ¯I€ßÁG6dp ¿ošCøº`p cÒUŒÉxŽ‰ÿ½ïJü}è®ü=á)üýÙÕü½Òâü}Ëfü=Äëøûyoð÷Öð;dGów«:ówŽnçïâ¬äï¨åïn4åï4øß ˜ÉŸßÎceøó²­ùsÎSyì^þ,ðþÜm]ÃÏjâgQ£5ÃÏ!¢æ`þ*øúèàëc‚¯+_W¾®â¿.âž— þ^ío¯üý8ž;æó€qÃ5Á:Ç[ØÃ@싆¶ÄÅlÙˆ~7ÅÚ6fOqcö”.ú½TÛöÇðv_¶ÕÙV4fÛ»è×ýmëÃ០/µ¸ÚbܘK‡Ä†žáØ!±Q£ÇÅÇ7‰?jplô˜ØƒGŒ7bÔ q±ã†Ø7ÿO}qÜ"6$’Š IƆ$bCâ±!±± ŠãSŸ’ø”ŠÕ¸”×Z™×ˆyòýÞlôèè'íéV¬íÿEàº{õþí£È¿ÿû=ä?þ~ù¿ßKþãï÷“ÿøû=å?þ~_ùuoá£Ô¿/ý/Çü—ãeþåxÙ9^î_Žßscq•ÅD‹»b®Ïþ;ÏÿûÇÿïóŒóÖç™Çò<‡›ŒÃü¼ɯý|ø?‹ÒU.øº4¿Æ˜`lBëas~k$ÖF¬‰ñ¥$ìS"^ˆÏ‰‚ès<úO$£Ï)€ø²A*ƒÏ9à âÉDôG6Õ‰çÀ&£ìè;‰d”LEŸÓÑg¤'²Ññlt²ûÆn$»‰ìα»&ºcìF±[Æn »9ì6‰në~»9ìÆ°›Ânèž°®·ÛÀÚÜîký¨í­Í­©­Ë­§­É£æ·Þµ¾µF¶ÎŽzÜZÔ:غךԺ6ê߸µa¼Ãd´ˆul<êÓ¸õ`ÜÚ1^€£6\ȨYã6„q ® jc‹ÁŒÚ1nOà¨å$0ê|ÌY܆8nCO€0 s<꺸 q܆4nã·ŽGÍ·qŽÛ(Çm˜ã6òqæxÔ5qó¸uE܆6©éœ»~¡‹..Ohàè8Í5ľ‡»&7ZXÏ°Ú%Ü€ 3Ñ nca´MŠ:7'nZ B*µB´®'¢f‰¾eÍpÓ‹Uwm4a‰hýŒ»g56©6`™è†Á¢æGK´´ë†h K¹'7xhŠF,õP"Ú¨Dk^ÔÇ)®“ѪÝ@ÑòˆÁ·¡‹Æ?ç{#Ë·sÊ j%ÝÀD7T¢kW´ÚF}œ‰ÖÓh¥v’u#gâ¤kªDüVûŒk‘h%Ž6X1'x¬³QtÎœk“è ÙŒ_ãmðm=ɸcXQÝ£O"ZÇ’\©Ón-ˆó;I×Yp¤£ásË¥[•Ýz­…þÃÆ=Ëúíæ¢G´~´î'ÝŠÆß„ÙxtÌŸ[ù Ü#La.ZÛ± $¢ýeÔ]fÇ\Øàa*¸öÇÝ£Ht‡&Ý’mZ³nТo¤ÜýmáÜãNA´²Dã‘Ëù´>CÇ£U¨ Ú‰%0ãØVa±›Šö‰$¾²#),ÿÖÛ––ˆ6 «‘°VK¤°3C ߉®Íz+aó“°¦LX·$ÒدEÕ¬‡¸÷Ò8j¹¸[¢ÝU"êlËC#e°§³œŒûŽñ¸ClÔÖ ŒeÔ± ›—„z"‡½Ÿ9´môœÞæ#ac”À¨âÆļGÏ’X0 ñ€†ïØ#J¶‹ÑL¡lî’hN{$+…qL¢1¨6†Ieñ)‡OQêan³˜Ûl†|5$iHÒ¤!†“ÆÄ$¤ÉWC’BB’& !I“&I’W’„4 i’$!!IòJ’IBÒÿZíkýöý×å8ÎÃ{¼s­ýìµÍÞÏs¯çÞ%ëŠD"M G"ŽDÖ&ã"‘-`/hˆÿßþ˜3ÿ‚Hd Xv# P¡H¤¨ €– +&ƒ\°¬ÛÀA‡ÌxR@ÐŒãAX ÀNpÒC‘H¤Øö“ ü…‘HPd€.` ˜¦ƒ`Ø €2%"‘Š H@_0 Œ3Á"°l'À9P®$Ž4mA0 L³À°ìG@¡R8~P4]Ao0LsÀr°gA|i?Hm@'ÐŒSÁ© ªƒÆ -è†i`XÖ]à(UÇj‚¦ è rÀd0,ÀpÄ•‹D@2HÀÈ«à‚m .Ï èFƒñ ,`'Øu5êƒRÕQ´½ÁHrÁB°lÁqw jƒdºƒ~`4˜ æ|°ì'A‰$<÷ È]À@0L Àz°g@™ø·Ö€mà8ˆ«‰º ô£Á<ö“ üµ¨ê Ð cÀ$0,ëÁnp©…×:¨Ò@0ŒSÀ\°l‡À P¼6z ê‚æ è²Á40¬ûÁP(}5ASÐtƒ@È Á° gA|¼ÖA:hºƒ¡`<Èù ì‡A¤.žP¤‚LÐ Œ“ÀRð)Ø.¸Ïh²ÀÃ`*xl?ƒ¸z‘ÈU Ü gÀð)Ø.¨Ðd‡ÁTð6Ø~ñ ÒÀÝ`$˜–‚-à(y=~Gƒ xäÁvðˆo‰Ô­@^«À·à¸¤ŽÜ† `øì„”H¤èƒÉàM°ü ݉ԩ 3ž‹Áà(Ö½Í@7ð(ÈËÀnp”j‚z‚lð2È;À P6¯kÐôcA.X¶‚£ ÔÈ 'È/ƒ|°œe›âß=h ú‚±`X vƒÓ ÂM‘H} €‰à P~ç@¥4䀎`x,Ÿ p3¼gƒA0Ìï€MàP<=¹¤ƒ{À(ð"X¾Ç@é›ñïÜz'À,ðØ ~åšG"u@p?^kÀw L‹HäJÐÜF€Àð%8 .ÌÀïdp3è3ÁÏà/Pé–Häp'x<Þ_‚ÿ’-ñ܃[À}àIð*X ¾‚ËnÅë tçÀÛà ð ¸°U$r hz‚á`"x€@ñÖxÎ@:¸Lïãà¢6x­‚ƒà,H¸ =ÀP0,›ÀaP¢-þ- Ð Œ³Á*°œoÇ{膀)`Øâ™xÞ@sÐ À<ð1Ø ŠÝ èžËÁ¯ L»H¤=ø ü .kçtçÀÛà ð ¸°ž#ÐôO€WÀ‡à[p\Ú1¹´ƒÁ³à-ð9øë„çÜ îƒñàu°|âîÄï"î“Á2p ”ÎÂïfpœ;ã9À0,Á!P¼ ž#ÐôÙ`X vS Â]ø| ÚA`2X6€ƒ ®+žCºƒ¡à)0|ö€¢wãýܺ‚gÀRp”ê†CàGp\zž#Ð Ï‚·ÀçàgP¬;ž#p3¸<^€oÀà’{ñ{ÜÏ€7Ágà'P´žCÐ ÜãÀk` ø鉛 )¸ Lï‚# d/üûÁ)Pá>Ø N‚ò}ð{d‚`XÖƒ H_<‡ tCÀX0¬»Aáûñ» ܺ€§Áð?P¢ÞSÀçOÀÃ[m7|~íR2vŽƒs‘Š ÀG‘ÞÒ"øÕÁ¯˜þ¹EðrŠà© "2Œ8MŠL3Á\°¬kÁF°ì‡À pÎjáÜ©¨ ªƒº 1hÚ‚,ÐôÃ@6˜¦YÄÎÅVò|l3ÏÉöó¼ìÏÍJçg5yŽÖ”çiíx®Ö›çk#ANpÞ6‡çnËyþ¶çp{xwœ ÎçxN—ÌóºtžÛuâù]?048Ï›Ês½y<ßËç9ß&ž÷퇃ó¿<¬ÂóÀz<Ìàù`Ð+8/ÃsÃé™çõéÁ¹}wžßå9þxžççñ\1ÈÎùwò¼ÿ0Ïý#e¢çÿåy Ô ®dòz@/^Áë“xm`6X\#XÏë»y­à¯¹(zÍ "¨\;Hãõƒ¼†Ð—×FñZÂ0Ì ®+¬åµ…í¼¾pˆ×Îñ:C¹àZC]^ohÎkY¼îПײÁÄàÄ|^‡XÉk›y=b?¯Iœ…ÊÆ®MTåõ‰¼FÑ’×)ºòZÅ 02¸f‘Ëë yíb ¯_lã5Œƒàxp-#ž×3yM#…×5ÚðÚFwÐ £Áx0äy`1È`Ø öÃà$ˆ\Œþƒò  Hõ@*È™  è‚` ˜¦ƒÙ`X Võ`+Ø €cà (RýA5P 4i 躾`Æ)`&˜ `-ضƒ½à8Îâ— ÿ 2¨ê‚Æ 9h ²@Ð Ù`"˜fù` X ÖÍ`ØŽ€S PôTUAMÐ4-A;ÐôƒÀH&ƒ\0,ËÁ°l{ÀApœq—¢ÿ $‚dÒAÐ týÀP0ŒSA˜ƒ|P6`8 N^ýPV”U@¨RAÈ]@/0ŒcÀ$0Ì ÀR° ¬[Ánpg@‘ËÐPTµ@CZ è †€Q`˜f‚¹`XÖ‚`;Ø à(ž€þƒÊ :¨ ƒæ -È=@0 dƒ‰`˜æƒ%`%X6ƒ]`?8NB•ÐPT5Aдí@WÐ #A˜ rÁ°,kÀ° ìÁqpÄUFÿAHÉ ¤ƒ6 èú¡`4¦‚<0,ù l;Á>pœ‘ËÑPTI H t½À@0Œ“Àt0,KÁ*°l»Áp œEª ÿ "¨j† ´@7Ð £À80ÌsÁ"°¬Áv°'À9Pü ôTÕA]Ð4mAèúƒa LÓÀ,0,+Á:°ìûÁp ªŠþƒ  *¨ €¦ %hº‚Þ` rÀd 怅`9X6€m`8Žƒ³ îJô$€D R@:h:î  Fƒñ`*ÈóÀb À&°ì‡ÁÉ+£'d%@yP$z d€LÐôÁ0LÓÁl°,«Àz°ìÀ1p¹ ýA5P 4i 躂Þ`ÐUÑkö9`2Èåõû…`9X6ðzþpgy}?$€DÌëýé  èºóúÿÐ` `*×æq- Ÿë›¸&°'Áß øÕxJàj R@3ÐtÝ@0Œ9à0Ì À»àC°l¾:ºö°Ÿë§@¡êÑuˆ  *×#€¦\—hºr}bP°F1™ës¸V±œë¸f±'X·8˵‹x®_$r #…ëm@§`=c(×4Æs]#k‹¹¾Q6뇹ÖIŠ®w”çšG×=RAF°þÑ‹k #¸2‰k!³¹²¬ ÖEvsmä×GŠÔˆ®‘Tä:I-ФV =è îÁp &€©à%0¼–se×Zö€ƒ\s9Ëu—x¹“Âu˜6 èÎ5™¡\—¦‚<®Ñ,æ:MØvrÍæ0×m"×ây»6¶~“Ä5œT®ãdr-§×sFk:Ó¹®³€k;«¸¾³•k<À±`­§ ×{ªqͧ!×}Zqí§è¬ã:ÐL®-âzÐZ® m{ƒµ¡s\*Ç5¢ê\'j̵¢¶ +X3Æu£‰\;šÅõ£%\CZ6ƒ]ÁzÒ)®)•âºRU®-5àúRË`©7×™Fr­i2×›æpÍi9X¬=íáúÓq®AÅÕ‰®C%p-*¤kR¸.ÕkS£¹>5•kTóÀâ`­j׫öqÍê$×­Jpíª H Ö°2¸ŽÕ…kY¹ž5†kZÓÁl°€ë[«¸ÆµìâZ×ð×¼J‚ò\ûJ×q ¬h˵°à®‰=Æsm,¼Î5²÷ÁZ®•mßsÍì7p–kgñà2®¡Õ ¹–Ö ´çšZ®«Or}m˜Íu¶¥àC®·m»¸îvüÁõ·’ <×á’Àu\kÚr]®x€ësƒñ\§Ë¯s½î}°–ëvÛÁ÷\¿û œq ¢ky \Ï« r]¯hÏõ½>`×ùrÀ3\ï{,àºß*ð)×ÿ¾û¹x \p}t=ðP…ë‚õ@®Þ²¸NØ<Ìõ `*× ç·Áû\Cü‚ëˆ{ÁÏ\Oü Ä5Œ®+&€«¸¾Ø¤q±¸›ëƒÁH®;N3¸þø&XÊuÈõ` ×#G¸.Y¨Ž©Qt}ò ÄuÊTЂë•AПk—Ù\¿|äqs1xŸë™_€í\×<~ãúf±SJt3Ôæzg3ЊëžÝ@®> r¸š ^åzè2°Šë¢[Á·\= Nq´¸\Á5Óú\7Í·sý´'èÏuÔl0ë©/ƒy\WÍs}uØËuÖà/®·– \wM¸þÚtà:l_0˜ë±cÁd®ËÎor}v5X¶r­ö×kOƒBM¢ë¶À\¿­R¹Ž› :s=wÆu݉ày®ï¾s·|ÁõÞÀ!®ûžÅR£ë¿•@"×S@3®wݸ.<<Êõág¹F<¼ÉµâÕ`=׌wƒ¹v|º1º†\\Áµäú •kÊ™ 3×–€a\cžžçZó`1ל À\{þâô9P¬it-ºHÉ\—NçÚtGÐkÔCÀ£\«~ärÍz!XƵëÏÀV®aG¹–]ø&ÓMÑ5íª ׶o\ãîzr­{8Èæš÷4ð2×¾ßù\ßv€¸þ;×Ä‹§á˜Ò¢kãWƒd®‘§ƒÖ\+¿ôåšù(0–kç/‚9\C_Vs-ý+°›kêÇÀi®­—¸Æ^ÔçZû- “kî½À®½?&‚i\‡ŸÏµø@×äw‚¸6ÿ;8Ç5úr ×ê뀮ٷ¹v?Â5üqàY®å¿rM øŒkûß\ã? ß]ë¿Tåšp#¸…ëÿwq` ÎY€§Á4ÎÌïp6à°‰3ûÀ/œøo¨ ®æìÀ 3À=œ%xŒâLÁð"g ÞË9c°|ÅYƒŸÀ1pi=¨ÈùƒkAÎ!´wpá>0s cÀÓœOxÌçœÂJð ç¾û8·püÍù…‹AeÎ1Ô7pžá6Љs ýÀCœox LáœÃ\ðx|>_ƒï9ñç ŠÝ‚×ø-Ñyˆ«AÎEÜ nã|ĽàÎI<&p^âeðç&>Ÿp~âð_ÎQü.h§¸\Á¹ŠúàFÎWÜîâœÅƒàÎ[<fpîâM°ŒóŸ¯8‡ñø•óEoD.º5:—q¨ÍùŒf 5ç4î÷s^ã1ðç6^¯s~ã}ð1ç8v€8Ïñ;ø›sƒË9ßqhÂ9ÛAgÎ{ àÌÇœû˜^æüÇ; Ÿs ›À΃üN€sœ )*qF¤Há¬HБ3#÷ƒ!`Ç’™à5ðçI>À6°äŒÉYP´MtÖä2P Ô AhÅ”n  cÁ³àEðx ,kÀ° ìáìÊqίÄ݆Ï'·EçXA2çYÒAεtý8ß2ŒçœK˜Çy—|PÀ¹—`ç_NÞ]t·9˜ò  çaêTÎÅd‚.œFpNf˜Îy™`)çfÖƒ­œŸ9ŽqŽ¦Èíø]p{tž¦¨Å¹š4Њó5Ý@_ÎÙŒã8o3ÌåÜÍ °–ó7ÛÁ^Îáœç8STæ\N]Иó9mAçtúsV'›ó:σ<Îí,ïs~ç °s<‡Àoà/Îô” œíI8ãÓtà¬O_0< ÆröçE0,äÐðø |~âlП H»èŒPEp%¸\n·rvènÐ #A˜ rÁ°,«Ágà+ðgŽ~åÜQÑöxM·Î]js©hÍy¤{ÀýœKz <Åù¤—ÀëœSz|Ìy¥àÎ-ýþæüÒÅàrÎ1]špžévЙsMÀpÎ7= ^àœÓÀ»œwúláÜÓà(çŸ wÄ{iÇèÔ•àZÎCÝnå\ÔÝ ç£c9'õ"xóRï87õ5øžóS¿¿8GUTâ` r8³• ^or~k5X¶‚ÝàgºÎ€ÂYÑÙ®KAUP4MAKÎ|u÷Á#àIð ˜^o‚¥`X¶‚Ýœ;Æy±"ñšî«jq~, ´âY7Зód£À8ΕÍs9_¶¬åœÙv°—óf'À9Ε•9V4æZ[Åy´þ`çÒ&‚iœO›–pNmØÌyµýàçÖ Ý…Ï×wEçת‚šœck Zrž­+è͹¶‘ ‡óm¹`çÜ–ƒ5œwÛöpîí88Ëù·xÀ9¸dÂy¸6 çâúq6n4çãž39'·¼Çy¹ÏÁ6ÎÍ¿‚?9Cw¨ÈYºZàzÎÔÝ Úq¶®7x<žä¬Ý 0,àÜÝ*ð)ؾ?rï4(Ô-:“W\j€úàFp gõî½À@0Œ“Àt0,ï‚Á§` ø–3~G9çWø¼¦ï‰Îû] ®åÜßMàVÎÿÝ úpðQ0–ó€/‚×8øøˆó_ƒï9'øø‹ó‚eA%Î Ö7p~ð6p'çsžpxžs…o€w8_ø ø’s†ÿÿã¼á÷âsá½Ñ¹Ã+@ ÎÞnáâ]à>Î#>žä\â ð*ç—ÕœSü |ÇyÅ_ÁŸœ[¼\ÆùÅÚ ç[ƒŽœg¼Ÿ3q®q x‘óoåœsܾâ¼ãOà8ÃÙÇ2àRÎ@^ p²%¸ƒ3‘÷`ÃÉéàðÎK~ÖÍ`ØÏÊSà‚^ÑYÊK@êTÁË. '†ƒ'ÀÓàð øXV‚u`3ØÅÙÌ#œÏ,t^Ó÷Eç4«‚šœ×l Zrn³+èÍùÍ‘ ‡sœ¹`ç9—ƒ5œëÜöp¾ó88Ë9ÏxÀyÏd¹Ï6 ç?û¡œ¦rtX̹а‰ó¡ûÀaΉFúàsaŸè¼hĹÑTÁùÑ. çHG€1œ'fs®t)XÅùÒ­`7çL3œ7-*rî´hÈùÓV çPûruçQŸ¹œK]–q>õ3°•sªÀQpš3«¥AήÖõ9Ãz Èä,k/0 Op¶õ0 ÌçœëJð ø|þËÙ×?î®Ú lyp9¸\š€œí z€þ`ÈÁ40 Ìï€OÁõýñ;ÜîÀ£`˜^ï‚À—à;ð 8 Š Àk\®7ÛÀ]à~0ŒσWÁÛàCð9øü~…âw¸ÔMÀ­àNpx<ž/ƒ7ÁûàSð5ø/øü J?ˆß‘ hZ€öà^ð x < ^o€eàc°|þþÂï p5¨šÛÁÝàðx ¼^ï€Õà ð-øüŠÆçQp%¨n­AgÐ< žÏWÀ[àðØ~¿ †àw&¸\ n·€Ž ' Ï€—ÀÀ{àðø’áw/¸ô ÉP¼VÀ'`Øö‚ŸÁqð'0 ½™‘²‘óÿüý÷ßâßáÿA$:«þ÷âÁ/ýuðÿý÷xþ·lþlûóþ{Eþ÷xbŠ€^çyÕ‚œ¢"§fãn¸÷<¯ASLä¤9îÚ1v;ÏËr.9mƒwK€»Î󲂜’"§{ãn)þïÐëä”9C‚œ~ôÊo½jtÍ»Hx㯽xáM ¼ôÊ ofàeÐ+'¼¹—Eïbá- è¯{w‹Ç7•žßsj^7‘—ô×óîyóèù½«ÙôÏÏ[ô×óîyùôüXózˆ¼zYA^O‘·‰žßKk^/‘·“^÷ ¿÷‰¼}ôüž\óz‹þ¦g}ÞG¯¨{2èïÖí+¼NÆÙ_÷î¯=¿G8›Çs~^ù"±þzÞ"¯ =¿×ؼþ"/©H¬¿ž7@äÕ£ç÷,›7P䥉õ×óyôüÞgó‰¼Lzý‚¼Á"¯‹G‘è=ÔÙôÏïo/zÖç.ôu‰õwëÞˆ ¿î=,ßz~O·yÃDÞ¤ ¿ž7\äM§ç÷†›7BäÍúëyˆ¼ôüsóFŠ¼¥A=ïQ‘·Šžß«žMÿü¼õA=ï1‘·•žßónÞh‘·;èÛ8æ=.¼AßÜËuÑóûëÍyBä úæycDžÝ—oü>}óžyeŠÆúæy9"¯"=¿ßß¼±"¯ZÑXßæ=/òýõ¼i"o=ß/¼D×Ò³>¯ 7]ÔÝôw&ëÎÞö ¿îåŠÇ·—žï_aÞ‹"ïPÐ_Ï›)òNÐó}0Ì{Iä úëyy"ÏöÏ°?¾Ÿ†y/‹¼rq±þzÞ,‘W™žïËaÞ+"¯z\¬¿ž7[äÕ¥çû{˜÷ªèoczÖçºô戺Íãbý˺¯ ¯m\¬¿îÍ/‹žï7bÞë"¯G\¬¿ž7Oäõ÷ç9.ºo‰yoˆ¼aq±þzÞ|‘—Mïÿö?ÁÿþÈ›ô×óˆ¼iô|óÞy³‚þzÞB‘7ŸžïÇbÞ[¢¿KèYŸçÓ[$ê® ú»ˆußÞº ¿î-o3=ßƼwDÞ® ¿ž·Däí§çû̘÷®È;ô×󖊼Sô|¿ó–‰<ÛÃÆûëyËE^)z¾ïy Åbýõ¼"¯*=ß?Ǽ÷EkÒ³>W¥—/¼ôìstMzˆÇ×”^<—y+…×’^µÀûPG;z¾çy«D^Wz ‚¼Õ"¯7=ß;ȼ5"o½Œ ï#‘7’žïAdÞZ‘—¼<ïc‘7™žïed^ÈË ^ž÷‰È›CÏ÷D2oÈ[ôm-ó>Þò oî­u×Ðóý—ÌûLämúæyDÞ6z¾“yŸ‹¼=AßiæýWäm úëyûEÞNz¾ßšy?Š¼}A=ï€È;LÏ÷m3ï'‘w2è¯çyÿ ·Dbû¿™÷³èo zÿôù¨wHÔ-a¬¿{Y÷áU¹0Ö_÷‹Ç—DÏ÷£3ï"¯Þ…±þzÞ‘—JÏ÷µ3ï¨È˸0Ö_Ï;&ò2éùþxæý*òº\ë¯çy½èù>{æý&ò^ë¯çy#èù~}æý.ú;†žõy½“¢î¤ ¿‡X÷áMúëÞ)ñøfÓóýÍ;-òýõ¼3"o)=߇м?EÞª ¿žwVä­§çûš÷—ÈÛô×óΉ¼Ýô|_Dóþy‚þzž èýëú=ß_Ѽ .øwÏг>£WHx¶/ã?Ïs±è>æ¾@\ÿ+{œàã+"¼Š%b¯÷ŠŠã¨FÏ÷„4/NäÕòÇäy ½n‰èÞ’æyi%b¯Ï»Päµ¢ç{TšWBäu({x^I‘מïui^)‘×·Dìuày¥EÞz¾g¦yeDÞ¨ oç˜w‘ðÆ}s/^ÔBÏ÷ç4¯¬È›ôÍóʉ¼¹ô|ŸOó.y‹‚¾y^y‘·‚žïjÞ%"omÐ7Ï« ò6Òó}GÍ»TämúæyEÞ^z¾©y—‰—‡èYŸ÷ÒKuOý-ÎyŸJÂ;ô×½ÊâñçžÍ¾Ÿªy—‹¼r%cýõ¼*"¯²ïÍ}YÍ»BäU/ë¯çUyuéùþ®æ])ò—Œõ×󪉼æô|ŸXó®ymKÆúëy‰"/‹žï7kÞÕ¢¿=èYŸ³èUuû—Œõ·ë^#¼a%cýu/I<¾lzÿ·ÿ-þw ‘71è¯çÕyÓèù>ºæ]+òfýõ¼Z"o>=ß×¼Ú"oIÐ_ÏKy+éù¾¾æÕyë‚þz^]‘·™žïlÞu¢¿»èõàÂæÕu÷ý­ìóÂ;ô×½âñ¢çû›w½È³=Œ½¿ž×Pä•¢çû›×HäU(ë¯ç¥ˆ¼ªô|ÿdóny5KÅúëyE^z¾³yMD^ÓR±þz^ªÈkéÏ ÷s6ïFÑßvô¬Ï-é5u»–Šõ·:ëÞ$¼Þ¥býu/M<¾Aô|i󚉼‘A=/]äåÐó}ªÍ»YäMúëyÍE^.=ßïÚ¼"oNÐ_ÏËy éù¾ÙæÝ"ò–ýõ¼–"o =ßÛ¼[E7г>¯¡×JxÛèÙçè ôZ‹Ç·'xÔåãk#¼ƒÁëÀ½ÛÄq§ç{†›×Vä ^žw»È³½Æíï=n^¦È‹/{xÞ"/žïan^;‘—X:ö:ð¼ö"/™žï…n^‘—R:ö:ð¼Ž"/žï©n^'‘צt¬o™w§ð:•Žõͽ,Q·;=߿ݼÎ"¯_éXß<¯‹ÈJÏ÷7ï.‘7:è›çuyãéù~òæÝ-ò¦}ó¼n"/žïKoÞ="o^Ð7Ïë.òÓóýíÍ»Wü»Ì§—Î=ðÍë!êýmκ=…·)è¯{½ÄãÛIÏ÷Û7ï>‘·/è¯çõy‡éù¾ýæõy'ƒþz^_‘÷ÏMb‘ØþÿæÝ/òJ”‰õ×óú‰¼òôü{Ì{@äU)ë¯çõyIôüûÌ ú[žõ9‰Þ@Q7µL¬¿mY÷Aáe”‰õ×½AâñeÒóïG0o°ÈëR&Ö_Ï"òzÑóïY0ï!‘7°L¬¿ž7Tä çß×`ÞÃ"oLÐ_Ï&ò&Ñóï}0o¸È›ô×óFˆ¼Ùôüû#Ì{Dôw=ëólz#EÝ¥A³X÷Qá­ úëÞ(ñøÖÓóï³0ï1‘·5è¯çy»éù÷b˜÷¸È;ô×ó²EÞ1zþýæ=!òÎýõ¼1"Ͼ—Ãþø÷t˜÷¤È+sQ¬¿ž—#ò*Òóïû0o¬èo5zÖçŠôƉºµ.Šõ·ë>%¼†ÅúëÞxñøÒèù÷˜7A䵺(Ö_Ï›(ò:Ðóï11ïi‘×í¢X=o’ÈëKÏ¿żgDÞ‹býõ¼É"o=ÿ^óžyã‚þzÞ‘7…ž?‹yωþÎô~ð;\Ì›*¼¹ôìsôLzÏ‹Ç·(xôçã›&¼ÁëÀ½Äq¬¥çß)cÞt‘·1xxÞ ‘·ž7y¹"ooð:ð¼EÞ!zþ7æÍy'‚×ç½$òÎÑóïÊ1/Oä½<ïe‘WŽžçŽy³D^åøX߆1ïáUõͽ٢n]zþý>æ½*òÇÇúæysD^szþ=Aæ½&òÚÆÇúæysE^=ÿ¾!ó^y=âc}ó¼y"¯¿{ñÑï-2ï ‘7,è›çÍyÙôþïûð¿ÿ#þ]N¤g}Φ·@Ôô7›ußÞ¬ ¿î-o>=ÿ>&óÞyK‚þzÞ"‘·’ž¯“yo‹¼uA=o±ÈÛLÏ¿ʼwDÞ® ¿ž·Däí§çß3eÞ»"ïHÐ_Ï[*òNÑóï«2o™èo!nb}>Eo¹¨[ªl¬¿Y÷=áU(ë¯{+Äã«JÏ¿?˼÷E^Ͳ±þz^¾Èk@Ï¿‡Ë¼D^Ó²±þzÞJ‘×Òëòû¼ÌûPäµ+ë¯ç­y]éù÷‚™·Zäõ.ë¯ç­yƒèù÷‹™÷‘èïHz…ødæ­us‚þNcÝ…79è¯{âñåÒóï;3ï‘7'è¯ç­y éù÷¦™÷©È[ô×óÖ‹¼5ôüû×ÌûLämúëyDÞ6zþ=næ}.òöýõ¼"ï =ÿ>8ó¾ý=NÏú|Þ&Q÷lÐßY¬û¥ðì»æ¼¿îm/žž?y[D^B¹X=o«ÈK¤çßsgÞW"/¹\¬¿ž·Mä¥ÐóïË3ïk‘—^.Ö_ÏÛ.òÚÐóïÝ3o‡ÈëT.Ö_ÏÛ)òºÓóïï3ïÑß~ô¬ÏÝéíÞPzö9º½oEÝÑôì3í©`Þná§gþdzß o*=óãx_êáåÑ34½ï…7žù'éíÞâà8ìÞEó~^>=ó›rîuŸð è™_†ëÝÿÞ&zæïáõñýÂÛIÏüEüœý£èÛ>zvÜ;Ù·"ï0=ûìàû`ü$¼“ôÌ÷ý ïŸÍ•"Ñï~ôûò^ zæûý݇„WžÞ?>ûñ‹ðª\;¿ßô°ð’è™ïsõÿ^=zæûüÐá¥Ò3ß×IŽ /ƒžù~>xLô-“ž·ýŒy¿ ¯ =ës&½ã¢n/zöÞçû’ü&¼ôÌ÷ý-No=ó}Ÿ„ß…7†žù~¿ýIáM¢g¾ß·ý‡ð¦Çá÷ÿžÞlzæû}§…·€žù>ÏuFxKé™ïëV o=óýüü¬èÛzzvÜ«Ø·¿„·•žõy=½s¢înzö»Û÷‰ù[xè™ïûØ|ÿºþGÏ|ß·âá¡g¾ïPHxö½¬öÇ|¿¾°ðÊ”ÇlzE„W‘žù~ßIQáU£g¾Ï×Å ¯=ó}±˜ðÒ3߯—/ôﾥѳ㶟1ïBáµ¢g}N£WBÔí@Ï~÷ø¾=%…מù¾ÿK)áõ¥g¾ï#RZxCè™ïûQ”Þ(zæû¾ o\p~|¼ð¦Ð3ßï*+¼™ôÌ÷yÇr›KÏ|_×½Xx‹è™ïׯʋ¾­ gǽˆ}»DxkéYŸWЫ ên¤gÿv|¥K…·žù¾OEáí¥g¾ïër™ðÑ3ß÷IÞ zæû>•„w.8߯ ²ðìû“íù~_ÖåÂ+GÏ|Ÿ?­"¼ÊôÌ÷uö+„Wžù~=±ªè[]zvÜö3æ])¼Æô¬ÏuéUu›Ó³Ï’»ù¼\%¼¶ôÌïÀû¢…—EÏüô®^zæ7ç}šÕ…ןžù+é]#¼aôì5ìÇ‘$¼lzæ/dko"=óG±¿5…7žùmØßk…7‹žù•ÙßZ¢oóéõç÷q›W[ä-¡gŸ%}Œdá­¤g¾ï§PGxëè™ï÷å×ÞfzæûýÝ× o=óý>ázÂÛOÏ^ë~õ…w„žù~ßbá¢g¾Ïg_/<ûsûc¾Ï¡4^)zæûõöF¢oèÙqÛϘ—"¼ªô¬ÏèÝ êÖ¤gŸ%}_’ÆÂk@Ï|ßߢ‰ðšÒ3ß÷IH^Kzæûýö7 ¯=óý¾í¦Âëêu ÅŽã&áõ¦g¾ßGš&¼AôÌ÷yùfÂIÏ|Ÿ J^=ó}ýãfÑ·ÉôÚñ»ìÍk.¼\zUù}÷æµuçгϒ¾OL†ðÒ3ß÷¹ExËé™ïûV´Þzæûþ· o=óý>úVÂÛ毃B±ãh-¼=ôÌ÷ûzÛï =óýþ…Û„wœžù>§ÕVxgé™ïëQ·‹¾Å]õì¸Ï²o™Â‹§g}¶Ÿ1ïQ7ž}–ô}{Ú /‘žù¾ÿK{á%Ó3ß÷é ¼zæû~…—NÏ|ß× “ðÚгÏö~w ¯=óý>ë,áu§g¾ßOÒYxýè™ïss]„7”žù¾>x—èÛhzvÜCÙ·®ÂOÏú<šÞÝ¢îTzöYÒ÷Qê&¼zæûcoá¦g¾¯×ö};IÏŽû0ûÖWxnÐo}>Iï~á• ÷ÏçèŠQ¯Ÿx|åéÙ5Vÿ<ù€ðªÐ3?‘Ï_á%Ñ3?ÞáÕ£g~yÞ·8Px©ôÌŸDïAáeгkÞþù~ð2éeÇ1Xx]虂¯ƒ!ÂëEÏü¾Þ@zæOãë`¨èÛzvÜÙ·‡EÞz-ƒ}0† o=ó}?…á›NÏ|¿/„ðfÓ3ßïï~Dx è™ï÷ ÞRzvÍÛ?ß?*¼Uô–Ç1Jxëé™ï÷¿=&¼­ôÌ÷9ßÑÂÛMÏ|Ÿgx\ôí=;îÝì[¶ðŽÑ³> ÷„¨{†^×`_’1Â+rYÔ3ß÷·xRxeè™ïû$ä¯"=óý~û±Â«FÏ|¿o{œðjѳkÞþùþ)á5¤g¾Çxá¥Ñ3ßïGœ ¼VôÌ÷¹ë‰Âë@Ï|Ÿ/yZô­=;nûó& ¯/=ës7zψºCè ö‰™,¼QôÌ÷ýFžÞ8zæû¾S„7…žù¾ÿÁs›IÏ|¿~ªðæÒ³kÞþùþyá-¢778ŽiÂ[AÏ|¿?ôá­¥g¾ÏÁOÞFzæû¼Ï Ñ·íôì¸7²o¹ÂÛKÏú¼Þ‹¢î!z9Á¾=3…w‚žù¾ÿËKÂ;GÏ|ßG$OxÅ¢žù¾ÅËÂ+GÏ|ß×`–ð*Ó³kÞþùþáU§g¾ÇláÕ¥g¾ß¯ûªðÓ3ßïK˜#¼æôÌ÷ù«×DßÚҳ㶟1o®ð²èYŸÛÒ{]ÔíA/7ØGižðúÓ3ß÷ãyCxÃè™ïûºÌ^6=ó}ÿo"=ó}Ÿ‰›FÏ®yûçû7…7‹Þ´à8 o>=óýþé·„·„žù~ŸÈ"á­¤g¾Ïý-ú¶Žž÷Jöm±ð6Ó³>¯£÷ŽðvѳÏÑ›é-o?=›=ðë¬ï ï=óýóäRá¢g~>Ë„W¨RÔ3?½åÂ+EÏü®\_}OxèÙ,ˆ_÷^!¼ªôÌ÷Ï÷ï ¯&=óý8ò…×€žù©|| ¼¦ôÌ/Åy©•¢o-éÙqÛϘ÷¡ÈkG¯b°Æ*áu¥g¾ž\-¼ÞôÌ÷ûò×o=óýþî„7’žù~ŸðZáåгY¿îý±ð&Ó3ß?ß/—Þäà8>Þzæû}Të„·žù>/ú©èÛrzvÜ Ù·õÂ[CÏú¼œÞg¢îzµ‚}I6o=óýóäçÂÛCÏ|ß'a£ðÒ3ßï·ÿBxÇé™ï÷moÞYz6 â×½¿^\å¨g¾¾ß,¼xzæûql^=óý¾¶­ÂK¤g¾Ïï~%ú–LÏŽÛ~ƼmÂK¡g}N¦÷µ¨›N/-Ø'f»ðÚÐ3ß?Oî^'zæû¾;…מù¾ÿÁ7ÂëGÏ|¿~—ð†Ò³Y¿îý­ðFÓ3ß?ßïÞxz£ƒãøNxSé™ï÷î^=ó}žú{Ñ·yôì¸óØ·½Â[ìÇ‹¿çÑûAÔͧ×!Ø·gŸð è™ïŸ'ÿ+¼MôÌ÷}Dö o'=ó}?Š…·žù¾¯Ááö×UáØuw’žùþùþ ðþù2?ü9ÇÏÂ+AÏ|¿ïóðÊÓ3ßçÛ}«BÏŽÛ~ƼÃÂK¢g}®Bï¢n=z}ƒ}”Ž/•žùþyò¨ð2è™ïûº^&=ó}_…×…žù¾ÏÄqáõ¢g³ ~Ýû7á ¤g¾¾?!¼ôÇñ»ðÆÐ3ßïÃ=)¼IôÌ÷û þ}›NÏŽ{ûvJx³éYŸ§Ó;-¼ôìsôlzgÄã[JÏfr}þàOá­¢g¾_g=+¼õôÌ÷Ï“ o+=ó—Ò;'¼Ýô̯Ź¥¿…w€žÍHû<ˆ}ÁîùÞ1zæûuï „w†žùþù¾ðŠT‰zg‚ã(,¼2ôÌÏáë Há÷­"=;nû󊊼jôl&×çâ„W‹žù~µ˜ðÒ3ß?O^=óýþî …×Šžù~Ÿp áu g3Ò>RRxÝè™ï×½K ¯/=óýó}iá ¡×78Ž2ÂEÏ|¿ç"Ñ·qôì¸G±oñ›BÏú<Ž^YQw&=›Éõùƒr›KÏ|¿Îz±ðÑ3ß?O–Þ zæûýö—o-=óý¾í ÂÛHÏf¤}äRám§g¾_÷®(¼½ôÌ÷Ï÷— ï½½Áq$ï=óýþ¨J¢oçèÙqŸ`ß* ¯øQÏú|ŽÞå¢n9zñÁ>1U„W™žù~õ áU§g¾ž¬*¼ºôÌ÷ý®^czæû}ôՄלžÍHû<ÈUÂkKÏ|¿î(¼,zæûçû«…׃^VpՅןžù~¿Ú5¢oÃèÙqÛϘ—$¼lzÖçaôjˆºé%ûöÔÞ4zæûuÖk…7‹žùþy²–ðæÓ3ß÷£¨-¼%ôÌ÷} ’…·’žÍHûJ …WŠžù~µ‘ð*Ð3ß?O¦¯*=ó}„W“žù¾ÏDcá5 g3Ò>ÒDxMé™ï×½S…×’žùÿ·ÿŸðÚÑkGSáu¥g¾ßÏy“è[ozvÜö3æ¥ o=ësozÍ„7’ž}ŽD/]<¾zv¯šÏåÞ,¼ÉôÌ÷ùƒæÂË¥g¾_gm!¼9ôÌ÷Ï“Â[HÏü³ônÞrzvï ÏI·Þzæû<È­ÂÛ@Ï|¿îÝJxÛè™ïŸï[ o½mÁq´};HÏŽ{ûv›È;NÏîUó¹Ü¶Â;KÏ|Ÿ?¸]xqWF=óý:k¦ðâé™ïŸ'ï^=óý>ávÂK¤)›“n/¼dzæû—Û[x‡é™ïó}„w’žù~µ¯ðþ¹ÁÌ÷Ï“÷ ¯=óý>ú~Â+OÏîô9é„W…žù>Ò_xIôÌ÷ëÞ„WÏëV‹}¾(¼Tzõ‚ãxPô-ƒž·ýŒyƒ„—IÏúœAo°¨Û…žÝ«æs¹C„׋žù>ððÒ3߯³Þzæûçɇ…7†žù¾¯Á0áM¢g÷úœôpáM§g¾ÏƒŒÞlzæûuïG„·€žùþù~¤ð–Ò[Ç£¢o«èÙq/eßF o==ëó*z‰º[éöQ-¼ÝôÌ÷ùƒÇ…w€žù~5[xÇè™ïŸ'ŸÞzæû>c„Wä*o‘Øœô“Â+CÏ|ŸÉ^Ezæûuï±Â«FÏ|ÿ|?Nxµè™ïÇñ”è[CzvÜö3æ^=ësCz„׊ž}ŽöŸ™X8º¿Gèu೜§ñßÛŸ÷ß»ò¿Ûþ+Xo’ðzÓ3'žyÏo=ËíͼɅÅþßAÝAôžy9þüoŠð&¯ßsÂË¥g¹“™7U<¾9AÝ\zÏ‹>,ô>àï9ô¦‰ºËé5Žãá­ Ž£cºð6гÜ5Ì›!Žc[Pw½\q{èÙñl£÷¢¨{^Fp3…w<8Ž ÇKÂ;KÏr3/OG\b¬îYz/‹ãˆ§gÇc?cÞ,Q7^Vp¯/11vY<ŽÙÂK¦g¹‰¬ûª8Ž” n2½9â8ÒéÙñ¤Ð{MÔmC¯_ps…×)8Ž~<Ž×…מåvbÝyâ8úu»Ó{CÇPzv<ýèÍy£ýxƒãøðÆÓ ,¿—§Ò³Üñ¬û¦ÈË£þ»\(òæѳÜ<æ½%ò¯SÏ[$òòéYîbæ½-ò Äët±ÈÛDÏr ˜÷ŽÈÛ)^/KDÞ>z–»“yïŠþ¦g}¶ŸIÃÿ^ /î<ï$=ÛÉœeÂù›Žßg¼\Ô+~uÔ±¼¿Yï=‘UŽžÏÚ¯Y•èX¦ù–õ¾ÈºšžÏ›ä‹¬d:–y5³>Y)ôüšëJ‘ÕŒŽe¦0ëC‘ÕšžîX%²:бÌÖÌZ oÀy^7zþÞ¾FünèCÇ\ó,ë#‘5˜ž¿¯Y#é˜[Y‹¬zþ^X ²ž¡cnf}"²fÐó÷£u"k6s3˜õ©ÈZ@ÏßÖ‹¬w阛ŬÏDÖ‡ôü÷ò‘µŽŽ¹î}.¼Íô¬WÖ'ó6Šß»o3½/DÞ~zÖ¯Áô6‰¼#·ŸÞ—âõxŠžÕ?Bo³¨[¨zÔ³ÞæÐÛ"ê– <û󶊺èYýRô¾u«Ò³×Á ÖÝ&êÖ ¼ªÌûZÔm@Ïêפ·]ÔmJÏ^3 Xw‡¨Û2ðš2o§¨ÛŽžÕoIïQ·+={}}Ⱥ»DÝÞוyߊºƒèYýÞôv«Ïÿôì÷ˆ¿N¿^½j·G¼_M¦g¹9¬û½ÈËõç%ÈÛ+òæгÜ\æý òÒËòö‰¼åô,w!óþ+òÖÐË òö‹¼ ô,w ó~TŸÿéõ òˆ¼=ô,wó~yƒ¾ùÂ;ôͽŸEݳô,÷8ëRŸÿ¯‰õÍó~yñô,×~ƼÃ"/ášXß<ï"/‘žå&0ïˆÈK¾&Ö7Ï;*òRèYn2󎉼ôkb}ó¼_E^z–›Î¼ãâße'zÖç6ô~u»ûñFb¿wO¨Ïÿ×ÄúëÞïâñ ¥g¹ýX÷¤úüô×óþyãéYîhæySƒþzÞi‘—GÏr§2ïŒÈ›ô×óþy‹éYî<æyùA=ï/‘W@Ïró™wNôw=ës½¿Õçÿ ¿þþ)"¾ÿ'è¯{×ÿéYî>Ö-$òNýõ¼Â"/’õ,÷$󊈼I±þz^Q‘WžžåÚϘ'òª$ÅúëyÅD^=˭¼â"¯^R¬¿žw¡ÈK¥g¹õ˜W¢ˆ¸þOÏúœJ¯¤¨›™ë¯Ž(%¼.I±þºWZ<¾^ô,· ë–y“býõ¼‹DÞz–;yñ"oLÐ_Ï++ò&ѳÜ1Ì+'ò¦ýõ¼‹EÞlz–;yåEÞ‚ ¿žw‰È[JÏr0¯‚èï*?^ü½”Þ¥¢îú ¿þy­¢ð¶ýuï2ñøvӳܭ¬› òýõ¼J"ï=Ë=À¼Ê"ïLÐ_Ï»\ä©õ,÷ 󪈼25býõ¼+D^Ez–k?c^U‘W­F¬¿žw¥È«EÏr«1¯šèoCzÖçZô®^=ûm?“†ÿoðy^«±×9WÃyø<§ýyNu‘ÓµFìubÎ5"ç¾óœ$‘3°FìõaN ‘3ü<§¦ÈÉ®{]˜s­È™pžSKäL ^æÔ9/ç$‹œ¹ÁëÀœ:"ç­À±¾Ö-"®ÿÓ±¾µgÿ¯¯»5AÏ–Ó«'ò6г¬VôꋼmAÞz Äën=«¿Þõ¢îAzöº¹^CQ÷xðš9H¯‘È;KϲºÒKyq5cygéÝ Ž#žžÕ·Ÿ1¯±ðèÙqÇÓk"_"={}gÝTñø’éÙk;‘y7Š¼z–5yME^z—¼›Äq´¡gõÓé¥ ¯=;î6ôš‰Çמý;œÀÇ—._?zöo°;ónyCéý“żæ"ot7”y-ÄqŒ§gõGÓËÞTzvÜãéÝ"_=û}ñ_KñøæѳßyÌ»Uä-¦gYS™×Jäåy‹™×ZG=«ŸO¯ð6ùqàïz·‰Ç·“žý^{‹¯­x|ûüy;™w»È;Lϲæ2/Sä ò3ïq‘k£žÕ?I¯ðJÐû縯zíEÝòôì÷Ÿÿžì ¼*ôª^Gñ~ŸDÏr«°n'‘W^ƒ ïN‘—JÏrë1/KäeÐËò:‹¼Lz–›Á¼."¯ ½¬ ï.‘׋žåva^W‘7ðÚX=ïn‘7‚žåd^7‘7&蛿/Ü#¼IAßÜë.êN§g¹“X÷^‘7;è›çõy èYîlæõyKƒ¾y^/‘·Šžå.eÞ}"o}Ð7Ïë-ò¶Ò³ÜõÌë#òv}ó¼¾"ï=ËÝͼûÅ¿Ëcô¬ÏèõuÏýõ÷Á„W¤V¬¿îõ¯ =˵Ÿ1o€È«X+Ö_Ï(òªÑ³ÜŠÌ{PäÕªë¯ç y ý8ðw-æ yiµbýõ¼!"¯=ËMcÞC"¯C­X=o¨ÈëFÏr;0ïaÑß¾ô¬ÏÝè u‡ÔŠõ×ß÷‡ oTÐ_÷FˆÇ7ŽžåŽbÝGDÞ” ¿ž7Räͤg¹S˜÷¨È›ô×óF‰¼Eô,w.óy+‚þzÞh‘·–žå®`Þã"ocÐ_ÏËyÛéYîFæ=!ú»—žõy;½1¢î¡ ¿þ9çIáúë^Žx|çèYî Ö+òŠ×Žõ×óƉ¼rô,×~Ƽ§D^åÚ±þzÞx‘WžåVfÞ‘W·v¬¿ž7Qä5¦g¹u™÷´Èk^;Ö_Ï›$òÚÒ³ÜæÌ{Fô7‹žõ¹-½É¢nÚ±þúçºg…׿v¬¿îMo=ËíϺω¼ì ¿ž7UäM¤g¹ÙÌ{^äM úëyÓDÞ,z–;y/ˆ¼ùA=oºÈ[BÏrç3o†È[ô×órEÞ:z–»’y/ŠþnöLJ¿×Ñ›)¼]ôìsôfz/‰Ç·?xøu‹<á ^î½,Žã=Ë=º³D^¡äØëÀó^y¥èY®ýŒy³E^…äØëÀó^yUéYnæÍy5“c¯Ï{Mä5 g¹5™7Wä5MŽ½<ïu‘×ÒŸüÝ”yóD^»äXßü:ÍÂëšë›{óEÝÞô,·+ëþGä úæy DÞHz–;ˆyoŠ¼œ ož·PäM¦g¹9Ì{Käå}ó¼E"o=ËÍeÞÛ"oaÐ7Ï[,ò–ӳ܅Ì{Gü»\CÏú¼œÞQwCÐ_¿.õ®ð¶ýuo©x|{èYî6Ö]&òýõ¼å"ï8=Ë=ȼ÷DÞÙ ¿ž·BäÅÕ‰z–{–yø:±þz^¾ÈK g¹ö3æ} òëÄúëy+E^2=ËMdÞ‡¢¿)ô¬ÏÉôV‰ºéubýõëp«…צN¬¿î­¯=Ëmú‰¼îubýõ¼µ"¯=ËíμEÞÐ:±þz^ÈíÏ3þʼODÞø ¿ž·NäM¥g¹ã™÷©ÈË úëyëEÞÏ£·AÔÍúë×?^AÐ_÷6ŠÇ·‰žå°î"ogÐ_ÏÛ$òöѳÜÌûRäúëy›EÞIz–{˜y[D^¤n¬¿ž·Uä• ÷Onݨ÷•È+_7Ö_ÏÛ&òªÐ³ÜòÌûZô7‰žõ¹ ½í¢n½º±þúuÖÂK­ë¯{;ÅãË g¹©¬ûÈˬë¯çíy]èYn&ó¾y½Ü òv‹¼ô,·ó¾y#‚þzÞ‘7†žåŽ`Þ÷"oRÐ_ÏÛ+ò¦Ó³ÜIÌûAôw6=ëótzû„·€ž}ŽžMï¿âñ-¥gÛÝŠD×÷ù÷,÷*zK™õ£Èú4ÈZÁ¬"k ½O™õ“xü»èXÝ-ôŠšûƒš'XógQó½ýÌ:$jþáÏþ>BïQó‚ëb5ëò~âfIzæ[ÖÿDÍòt¬vIzGDÍ*AÍþ¬yTÔL¢W…YÇDÍëèXí$z¿ŠšMè úy\ÔlA¯ ³~5ÛÒ±Ú-è5³‚šÞÏßEÍô²˜uRÔ|€ŽÕîAïQóá ¦÷ó”¨ù8½‡™uZÔOÇj?N95¨éýüSÔÌ£7•YgEÍ×éXíÔ<Çš—ˆš3è=ì ¢æl:V{½KEÍAÍÆìSEQs)½̺LÔüŽÕ^J/AÔü4¨9Œ5+‰š[è}ʬʢæ.:V{ ½ËEÍýôÆý¬"j¡·ŸYWˆšбÚGèU5/¨«éý¼RÔ,IÏ|˪&j–§cµKÒ»JÔ¬Ôô~&ŠšIôª0ëjQó::V;‰^uQ³IPÓûy¨Ù‚^f%‰šméXíôjˆšYôÖÏmMQ³½,f]+j>@Çj÷ WKÔ|8¨éÏmmQóqz3+YÔOÇj?N¯Ž¨95¨éÏm]Q3ÞTf]'j¾NÇjçÑ«'j¾Mï\pœõEÍ÷é½Í¬¢æZ:Vû}z׫÷ÿ ¦gCõþOo#³©÷Îð÷vz)êýŸž£×¼A½ÿÓû™YÕû?«ý½&‹kõì=í,½TñØâ饂)‘èc»Q<¶zæ[VSõþdmdÖMêýŸÞUÌJSïÿt¬nmzÍÔûP³8ŸÛtõþO/Y7«÷:V»½æêý?¨Ùœ5[¨÷zw3+CÔä}Âß}èÝ"jŽ jf³fKQ3‡ÞHfÝ*j>CÇjçÐk%jΠ7%ègkQóUz3˜ÕFÔ\@Çj¿Jï6QsiPÓûÙVÔ\Eo)³n5?¥cµWÑË5·5½ŸwˆšßÒÛ¬v¢æ~:Vû[zíEÍ#AMïgQó½#Ìê(j^p}Ô±Ú§èu5KÒÛ<·wŠš—Ð3ß²²DÍ*t¬ö%ô:‹šIAMn»ˆšõè%1ë.Q³ «]^WQ³EPÓŸÛ»EÍÛéµ`V7Q3‹ŽÕ¾Þ=¢fzö¼úqv5ûÓëÁ¬{E͇éXíþôzˆš5ý8{Ššè=ά^¢æT:V{½ûDÍ!j¾IïUf5—Ò±ÚoÒ{RÔ\Eo{ðÜ戚ëé­bÖXQs «½žÞ8QóÛ ¦?·O‰š?Òû–YãEÍ#t¬öô&ˆš§‚šþÜN5 5Šz§˜õ´¨Y’ŽÕ6ß¼I¢æ%ôìyõã|FÔ¼‚Þ%Ìš,j&ѱÚWÐ{VÔ¬Ôôãœ"j¦Ò«Ç¬çDÍt¬v*½©¢æíôÚ5Ÿ5;Ó»YÓDÍt¬vgz/¯?={OëAoºxlÃèus#ÑÇ6C<¶lzØ•+²&Y{™õ¢ÈzžÞfÍ?ŽÕ}žÞK¢æ¼ fe>·y¢æbzó˜õ²zÿ§cµÓ›¥ÞÿƒšY¬ùŠzÿ§÷1³f‹šÛ½Oøû z¯Šš{ƒšÓXsŽ¨yˆÞ^f½&jþFÇj¢7WÔü‹ÞÜ Ÿ¯‹šÅR¢Þ_Ìš'jÆÓ±Úæ›÷†¨™«éýœ/j&ÒK`ÖDÍÚt¬v"½¢f£ ¦÷óMQ³½FÌZ(j¶¢cµ›Ñ{KÔìÔô~.5»ÑëÀ¬·EÍ>t¬v7z‹EÍÁôöÏí;¢æ£ô3k‰¨™CÇj?Jï]QsrPÓŸÛ¥¢f.½ÉÌZ&j¾JÇjçÒ[.j¾Ôôçö=Qs½7™µBÔ\EÇj/£÷¾¨¹žž=¯~œù¢æVzë™õ¨ù-«½•ÞJQóÇ ¦燢æQz?2k•¨yŠŽÕ>Joµ¨Y膨—Ô\#j–¢g¾e}$j^BÇj—¢·VxWг÷´Kè},[ zCÀ¢Hô±ˆÇVŸ^ f}"²Rƒ¬CÌZ'²2è¥2ëSñøo§cu3è­5;5«ó¹ýLÔìI¯3³6¨÷:V»'½ÏÕûP³knTïÿô†1ë Qs‚÷Éz›DÍ烚³XóKQóezÏ3k³¨9ŽÕ~™ÞQs1½EA?·Ššùô3ë+Qóc:V;ŸÞ6Qó‹ ¦÷ókQs½/˜µ]ÔÜKÇjï ·CÔ<Ôô~î5OÐ;ĬoDÍ¿èXíôv‰šÅÇjz?¿5ËÒ3ß²v‹š t¬vYz߉š‰ôÏíQ3™^"³¾5ѱÚÉôöŠšÍ‚šþÜþ j¶¦×ŒYûDÍt¬vkzÿ5»5ý¹Ý/jö¥×Y?ŠšƒéXí¾ôˆšÒ³çÕó'Qs,½G™uPÔœLÇj¥÷³¨™Ôôã<$jΡ—ˬ_DÍ7éXí9ô‹šËèõjþOÔ\Mo³ŽˆšëéXíÕôŽ o+={O[Oï˜xl»éÙÜ›ÍØcûU<¶ôv3ë¸È:d¥2ë7‘ušÞQf¿P“¨cuOÓû]Ô,Õ$V³-kž5+Ð3ß²þPïÿt¬vz§ÔûP³;kžVïÿôj0댨™JÇjק÷§¨™ÔšgEÍLzÌúKÔìLÇjgÒ;'jö¤W3èçߢæz=™eÂù5‡Ñ±Úè]÷ïšÙAMïg¡¸לH/›Y…EÍçéXí‰ôŠˆš/5½ŸEEÍ7è½Ì¬8Qs1«ý½b¢f~PÓûY\Ô, —Ϭ EÍ/èXíz%DÍÞ÷à¹-)jþ@o³J‰š‡èXíè•5O5ý¹-#jž£w‚Y‰šÅR£ŽÕ>G/^Ô,›«éÏmYQ³=ó-«œ¨™HÇjW¢w±¨™L¯mpœåEÍzÉ̺DÔlFÇj§Ð« j¶júq^*jv¤×šYEÍnt¬vGz—‰š}éuj&ˆšCèõeV%QóQ:V{½Ê¢æXz6Ëëó‰—‹šÏÒˬ*"+7Èòù+DÖz¹Ìª*ÿ›t¬îzWŠšË‚š¾ŽWMÔ\Mo³®5×Ó±Ú«é%Šš[ƒš~½õjQs7½­Ìª.jþHÇjï¦w¨y4¨éçÅI¢æizG™UCÔ,tcÔ±Ú§éÕ5KÑôóZQ³=ó-«–¨y«]^mQ³FPÓû™,jÖ§WƒYuDÍT:V»>½º¢fFPÓûy¨™I/ƒYõDÍÎt¬v&½ú¢fÏ ¦÷³¨9€^Of]¯ÞÿéXíôª÷zS‚綑zÿ§—ͬõþOÇjO¤wƒzÿjúsÛX½ÿÓ{™YMÔû?«ý½TõþÔôçöFõþO/ŸYMÕû?«]@ï&õþOofpœiêýŸÞf5Sïÿt¬öôÒÕûPÓófõþOﳚ«÷ÿ¦QÇjŸ£×B½ÿÓ›ÔÌPïÿôÌ·¬[Ôû?«]‰^Ká%Ó³÷´Dz·ŠÇ–BÏîXËÇÖJ<¶tz)Ìj­Þÿƒ,Ÿgk£ÞÿéµfÖmêýŸŽÕíH¯­zÿjúÜÁíêýŸ^_feª÷:V{½;ÔûPs/k¶SïÿôÆ2«½¨™ë}ÂßÏÒë jÎ júu¼Ž¢æBzs˜ÕIÔ\FÇj/¤w§¨¹šÞÚ ŸY¢ægôV3«³¨¹•ŽÕþŒ^QswPÓûy—¨y€Þnfu5Ò±ÚèÝ-jžjz?»‰š…oŠz§™u¨YŠŽÕ6ß¼î¢f…›b5½Ÿ÷ŠšUéU`VQ³«]•^OQ³>½ÁsÛKÔ¼‘^}fÝ'jfбÚ7Òë-jf5ý¹í#jv¡—ɬ¾¢fO:V» ½ûEÍAMnû‰šÃé `Ö¢f6«=œ^Qs"½íÁq5§Ñ›È¬¢æËt¬ö4zŠšo5ý8‰šïÐ{ƒYƒEÍ|:VûzCDÍz{ƒš‰š›è0k¨¨¹ƒŽÕÞDïaáý@ÏÞÓvÐ&Û/ôNDb÷’ íwz¿0k„È:dù,ï#"«xZÔ;Ǭ‘âñ—¥cuÍ7ïQQ³RZ¬¦Ï\5¯¦W‰Y©÷:Vûjz£ÕûPÓ×ÆWïÿôR˜•-j¶¦cµÓé=!jv júÆQóz™õ¤¨Ù—ŽÕ¾‡^Ž¨9Äûôs¬¨9ŠÞf5ÇÒ±Ú£è=%j>Ôô~Ž5_¤÷,³&ˆšsèXíéM55½ŸO‹šËé-dÖ$Qs5«½œÞ3¢ægAMïçdQó+zŸ1ëYQs7«ý½)¢æzÖKnŸ5Ñ;À¬©¢æi:Vû½çEÍÂÍb5ý¹&j–¦g¾e½ jV cµKÓ›.jV jús;CÔ¬I¯*³rEÍút¬vMz/Šš7Ò+çLQóz72ë%Q3“ŽÕ¾…^ž¨Ù%¨éÇù²¨Ù‹^fÍ5бڽè½"j§W9¨9[Ô|‚Þpf½*jN¤cµŸ 7GxÓèÙ{ÚDz¯‰Ç6‹žÝwí÷îÍm>½YÌz]d½dù½óDÖôÞaÖÿ¯½óŽ’ªèÞu‹$A¢J4 *q:÷¨ ’³d%H0'@Ä ˜Ãg³ ‚€‰¨€ATDÀLTTTT@½û=õÖ¯ëêëýãþuïZ߬µ‡á̳÷sNÕ>ÕÕ0Ó-Îxß$÷¬p® œþg\ŸÎMäÖ±ÖóêñŸ ܛȽ ÿ§ÿY¤™êñŸÜÖš%œúy²?!÷¢p–l–wúÿ3~I8+’Z/ gu2pW$7[8k“;-˜Ï9ÂÙˆ\mÖzE8sdànDn®p6 œ~>ç grÍXk¾pö wr¯ gÿÀéçó5áA®?k½.œcÈÀ=‚ÜÂyMàôóù¦pN&w k-ΩdàžLn¡p>H®E0¶‹„s¹Yk±pÎ$÷ rK„s~àôc»T8—›ÏZo ç*2p/!÷¶pnœ~l— çVrXk¹pn'÷Vr+„ór‚ë|G8ûµV çáÍ÷r«„³Ló¼Ó_çjá¬LÎ ÓÿÃGÂy¹ ¬õ±zü'÷mä6©ÇÿÀéÞôõøOîQÖÚ,œ³ý<ÙŸÏ’ûT8ß œþ炶çrro²ÖVá\Gîåä¶ ç&r—óù™p~Ink}.œ{ÈÀý%¹/„ó—ÀéçóKáü‹Ü/¬õ•p–lá¸ÿ"÷µpVl‘wúùüF8%µ¶ gm2pKn‡p6 œ~>w g!¹F¬µK8›‘»Ünáì@n|0¶{„³'¹¬õ­pö'wOrß çˆÀéÇv¯pŽ%7‚µ¾ÎkÈÀ=–ÜÂ99pú±ýQ8§‘›ÌZû„óA2pO#÷“pÎ wkp? ç,r3XëáœOîYäö ç’Àé¯óWá\Mn ký&œÈÀ½šÜ﹕Ü=ó€pî ·•µ çdàÞAîàÃcÚäþ\Ñ–ŽÃÏ3 ÷§¸†²äðz›5cüY5q UÈG­X‰Ö:1¨•b­ÃJü³V=r'²V‘ÿ<ÿxë‘;\8›ÎVtÎ6äš°V1áìBî6äŠ gŸÀé߯„p!ׇµJ ç(2p!w„p^8ý{ê•Ήä®`­ÒÂy¸'’;R8ï%W3˜Ï2Âù¹{Y«¬p>KîÇÈ•Î9ÓÏgyá\@nkUÎådà^@®¢p¾8ý|%œŸ{µŽÎ/ÉÀý ¹c„óÛÀéç³’pî'÷-kUοÈÀ½Ÿ\á<¢•ãRÁØVΣÈG­jÂy,¸"W]8ëN?¶Ç g¹:¬uœp’»€ÜñÂÙ<΂«'¸¥äÀ¿Êzõ·†x_¯à> êù÷(m(¸Ïn)½ÄØí"çgä D½Ÿ‚zþüâ¢ÞÁ¸üÄz 1Î%Z;þ?È%…·Bë¼w ¹”ðV'9àÒÂ[›üÕÉe„·QàýÞ¬ð\#ÖË osrð’+ÞŽ­ó}àûå4á=§u~Þ:²ÞéÂ{>9øÏ!w†ð^x}¿4ÞKƒë½€õšïõä࿔ܙÂ{KàõóÛTxï¸[Xï,á}„üw“k&¼Ïõü}Ô\xg“ó ëµÞ7ÉÁ?›\Ká]x}_µRÿäÀ,g½ÖÂû 9øß#×Fx¿ úÅ÷U[áý.¸Þ¯X¯ðþJþïȵÞÃÚä½¾¯:oirèä€ë(¼Çƒ¿4¹NÂ{BàõëÕÙÂ{j›ü|œÀz…7IþSÉuÞÆ×÷sWámÝ&?¿Y¯›Úÿ“ƒ¿5¹îÂÛ'ðú~î!¼CÈ¡ú°^OáMþ!äÎÞ+¯ïçs…÷†€»’õz ïäà¿\oá½?èßÏ}„÷‰àzïg½¾Âû9øŸ wžðÎ ¼¾Ÿû ïâ ¯æ±^á]EþÅäï†Àëûù|áÝôÕÖ(¼;ÈÁ¿•Ü áý1ðú~,¼ƒùý‘õ†o±¶Žƒÿ ¹¡Â[®mÞëûy˜ðV 8ä€.¼'‘ƒ¿*¹ÂÛ ¨çûy¤ðfÉáÜ°ÞÂ{9ø³ä.ÞöA=ßÏ oàüÚ³Þ(áíOþäF ïˆÀëûùbáÛ6ßW#Xïá½–ücÉÞ›¯ï«±Â{gÀÝÄzã„÷?äà¿“Ü¥ÂûTPÏÏïeÂû9ŒÉS¬w¹ð¾Nþ—È]!¼oãçç÷Já]po³ÞUÂû19ø×’»Zx¿êùù½Fx÷ãòë]+¼¿ƒ¹ë„÷¯Àë׫ë…÷ˆvŽóëÞ£ÈÁp„÷¸vy¯ï«‰Â{29ÌÅq¬wƒðÆÉÁ2¹IÂ{zàõëÕÂÛ²]¾¯Ng½ÉÂ{69ø[’»Ix{^ßÏ7 ï r“^¬w‹ð^DþAänõ.Æ×ÒÔ¾¾­„øùr—³Öí¢Ö­A¼ÊZwˆZ÷»•µ¦¨ý?xï!7U8Ÿ Î Ó„s6¹gXëNá|ƒ ܳÉÝ%œËÈù5λ…s¹e¬uºÿÉÀ½ŽÜ½ÂùEpÒyŸpî!÷kÝ/œ?“{¹÷'9ðÈ=(έdûü¼ûzHœ[EràQë?ÂY ÜÉ=,œµÉ- æýálD®6k=*œ92p7"÷˜p6kŸŸw grÍXë áìAîä¦ gÿà:ý¼ÏÎäú³Ö“Â9† Ü#È=%¸kÈ÷÷ÞÓ‚›L¼Ÿ«gÄ5L úÃÏÕ³â"7µžÎdà~ˆÜó‚›E|ûÚŽ{AœÛ«Á¹ùñ)Îm)¹Wéœ%œ«ÉÀ½”Ü‹‚ÛH¼_g^Ü6rƒ¾|Yp;Ém Æd¶¸Ö}Aÿúy˜#®õ¹}¬õŠÚÿwp ܇ÈÍÎräÖý;O8«’Zó…³&¸«’{UpõÉ÷kêk‚ËïïÁ××”xßKo®9ð~LÞcÒ½C~ü˜,cÒ\w^ëBáFî~ä îràýš¿XpW“ï׈%‚»‘xßëK7•ÜÁœ½%¸ÉM ®ãmuÿ“Ãþ9»ebìf‘;y¬«µ\ì¹æ“Áÿ7œË½í Á-!~>ÏíÁ­&Þ×[)¸A=¸Á­ܶ€[BïjÑO;ýu˜s¹5¢Þ¾ÐËó{WÔ;ŒË>Ö[+æ¢xGÇÁˆÜ:á-ß1ï]Mî=á­F rÀ½/¼µÈÁ_ÜÂÛ0ðn¤w½ðæ®!ëmÞfäàÏ‘Û(¼:æûÀ÷ˇÂÛ³c~Þ:°ÞGÂ;€ü=É},¼#¯ï—MÂ;.¸Þ‘¬÷‰ð^Gþqä6 ïÍ×Ïï§Â{WÀÝÌz[„÷arðßEn«ð>Ôó÷Ñ6á}Ù³ÅÓ¬÷™Úÿ“ƒÿerŸ ï²Àëûê á]GÌ2ÖûRx7‘ƒ¹¯„÷Ë _|_}-¼ß×û%ë}#¼ûÉÁÿ-¹í½˜ ½¾¯vo)rÑ:ØÉq;…÷hrð—"·Kx¼~½Ú-¼§tÊÏÇñ¬·Gxäà?…Ü·Â{Fàõýüð¶ê”Ÿß3Xo¯ðv&+rß oïðzcŽûAx“Côf½…w9ø“Û'¼W^ßÏ? ïÄ€»‚õ~ÞÛÉÁ?‘Ü/Â{_Ð/¾Ÿ÷ ïãÁõÞÇz¿ ïóäàœÜoÂ;7ðú~þ]x}5—õïJrð/"wPx×^ßχ„wKÐWëYïáÝNþ-äþÞ¯ïç¿„÷@0¿?°^¬¤øù¿³ÿr‡•ü§·ìÙÁõÆW¤ä?½U9àÞšäà¯B®¨ðÖêù~.&¼r8·ú¬W\x›’ƒ?C®„ð¶ êù~.)¼ÝƒókÇzGo?rðw'WJx‡^ßÏ¥…wÌÙù¾ÎzG ï5äàC®ŒðN¼¾¯Ê ï´€›Ìzå„÷!rðO#W^xŸ êùù­ ¼/’Ø<Éz…÷5rð¿Hî(á}+??¿G ï»÷ë#¼‘ƒÿ]r•„÷󠞟ßÊ»;—ÏY¯ŠðþLþÝäª ïŸ×¯WÕ„·dgzù“õª oErð#ܱÂ{lç¼×÷ÕqÂ[‡æâXÖ;^x ÈÁ_‡Ü Â{ZàõëU ámÑ9ßW§±Þ‰ÂÛ‰ü-ÈÕÞs¯ïç“„w ¹h=e½ZÂ{!9ø’«-ê]Œß>—®SòŸÏ¥Ç“»ŒµNµn z`>k"jÝMîÖ:UœÿÃdཛ\]á|:8ÿÕtÖΗÉ=ÍZõ…óu2p¿L®p¾í¯3–¿Î†Â¹–ÜÛ¬ÕHÝÿdà^K®@8?®s#qáÜMîsÖJçOdàÞM.)¸?ÈO.%έD—ü¼ûJ‹s«@ºRx_"æ)Ö»JíÿÉÁÿ¹«…÷íÀëûêá]KÌÛ¬w­ð~Lþµä®Þ/‚~ñ}u½ðî ®÷ Ö/¼¿ƒ¹ ÂûWàõ}5Qxèî8ôÀ_¬wƒðE~䀛$¼ÇuÏ{ýzu£ðžÜ=?DZÞdᓃÿdr7 ïé×÷óÍÂÛ²{~~Og½[„÷lrð·$w«ðö ¼¾ŸoÞAäнXïvὈüƒÈÝ!¼—^ßÏS„wBÀ]ÎzS…÷6rðO 7Mxï úÅ÷óÂûXp½÷²Þ]Âû9ø#w·ð¾x}?ß#¼ ƒ¾z…õîÞwÈÁ¿Ü}ÂûAàõý|¿ð~ôÕ¬÷€ð~CþOÉ=(¼ß^ßÏ ïïÁü~ÏzÿÞÃ{8þßÉ=,¼ezä½¾ŸÞʇpªý?9ø+“{Lxëõ|??.¼ir8·z¬÷„Úÿ“ƒ?Mnºð¶ êù~ž¡öÿÁùµe½'…÷c½W„÷'rðï"7Wxÿ¼~½š'¼%z:̬7_x+ƒ9à^Þê=ó^ßW¯ omr˜‹ê¬÷ºð6"mrooaàõëÕ›ÂÛ¼g¾¯ Yoðv$sr …÷œÀëûy‘ðžOcrë-Þ ÈÁ>¹%¢Þ¥Áø-æsé¥â¹ôõä.e­·D­›ƒ˜ÇZo‹Zw‘»™µ–©ý?xï"·\8Ÿ Î+„ó%rO±Ö;Âù¸_"·R8ß"ç×x8W ç»äÞb­Õêþ'÷»äÖçgÁun ó]áÜEî3ÖZ+œûÈÀ½‹Ü:Á"þzrï‰s+~N~Þ}½/έ<9ð¨õpV%wyrë…ó$r‹ƒyß œ ÈÄZ…3Cîä>ΦçäçÝ_çGÂÙŽ\SÖúX8»‘»¹MÂy^p~Þ?ÎaäÎc­ÍÂy1¸‡‘ûTpW‘ïï½-‚›D¼Ÿ«­â¦ýáçj›¸†ÈMa­Ï„ó 2p?@îsÁ½@|mþ{íâÜæçæÇ÷Kqn‹ÉÍ£ó+á\IîÅä¾Üzràý:óà¶[ôåvÁm'·%“âZú×ÏÃNq­ÈýÀZ»Ôþÿ\ÇÀ}€Üná,CnUп{„³29ð¨õ­pÖ werß ®.9ð~MÝ+¸9ðþü^pMÈ÷½ôƒàÚïÇäG1&]ÏÍσ“}bLú’ëÊkýI8‡»/¹Ÿ7šx¿æÿ"¸+É÷kÄ~ÁÝ@¼ïõ_w¹‚9ûMp÷“»#¸ŽßÕýOûä`숱{ÜlþÛÿA±çšëç5æÞÜ!Á-"~.ÏíÁ­$Þ×ûSpëƒz)r nKÀ-¢7vÄ?ûi;98·;ìñóA=~ED½Á¸üÀz‡!þÿ¯—ãà?@®¨ð–í•÷®$WLx«ƒpÅ…·&9ø«+!¼õïzzK o&àê³ÞÂÛ”ür¥„·]¯|ø~)-¼Ý{åç­ë)¼ýÈÁß\áx}¿”Þ1Áõg½rÂ{ 9øÇ+/¼“¯Ÿß Â;-à&³^Eá}ˆüÓÈ%¼Oõü}t´ð¾HÌ“¬wŒð¾FþÉUÞ·¯ï«ÊÂû.90o±^áýˆüï’«*¼Ÿýâûªšðî®÷sÖ«.¼?“ƒ7¹c…÷ÏÀëûê8á-ÙÛqè?Yïxá­H~ä€;Axí÷úõª†ðÖéŸcYïDá- r5…÷´Àëûù$ámÑ;?¿§±^-áíDþäj ï¹×÷sáH=p.ë,¼’ƒ ¹S„÷²ÀëûùTáp—±^]ὕüãÉÕÞ{‚~ñý\_x ®÷Ök ¼Ï’ƒÿQr …wNàõýÜHx}5‡õ „w9ø‹ ïû×÷sBx7}õ>ë%…÷krðo&—Þ½×÷sZx æw/ëe„·HÇÁÿ¹¬ðÙ'ïõýœÞJ‡p…Â[ƒü•È&¼uƒz¾ŸOÞ9œ[]Ö;Cx›ƒ?E®±ð¶ êù~n"¼]ƒókÃzg o_rðw%×Tx‡^ßÏg ïÅ}ò}5”õš ïUä࿘\sáx}_µÞ)7‰õZ ïäàŸB®•ðNêùùm-¼3ÉaL¦³^áOþ™äÚ ï’`üüü¶ÞÕ·„õÚ ïFrð¯&×Ax·õüüvÞÁ¸lc½N»ü;É-¼‡¯_¯: oñ¾Žsˆõºoyrð#\Wá­Ö7ïõ}ÕMxk‘Ã\Tc½îÂÛüµÈõÞ\àõëUOámÖ7ßW9Ö;Gx;ƒ¿¹s…·gàõýÜKxØôd½ÞÂ;’üÈõõÆ㷈ϥûñÏçÒבÇZç‰Z7=0—µú‰Zw’»‰µú«ý?xï$7@8Ÿ Î%ç ç‹äžd­Âù*¸_$7H8—’ók<œƒ…s ¹¥¬5DÝÿdà^Cn¨pn ®s=Äs'¹m¬5\8$÷Nr#wøëÈçVì¼ü¼ûº@œ[9ràQëBá¬Bîrä.Κäó>J8ë“«ÉZ£…3Mîúä.Î3ÏËÏ»¿ÎK„³-¹3YkŒpv%w[rc…³op~ÞÇ çPr}YëRáMî¡ä.Ü•äÀû{ïrÁÝ@¼Ÿ«+Ä5Üô‡Ÿ«+Å5ÜOîÖºJ8'÷ýä®ÜóäÀWä¿×^#Îmnpn~|¯綈Ü\:¯ÎwÈÀ½ˆÜõ‚û€x¿ÎŒܧä>úr‚à¾!÷i0&ŵ~ô¯Ÿ‡ĵþNî{Öš¤öÿý÷ïänÎ#É­ úw²pV"µnÎÈÀ]‰ÜÍ‚;•x¿¦Þ"¸$9ðþ¼UpÉ÷½t›àZ“ïÇäv1&]úåçÁÉbLúëÂk"œƒÉÀ݇ÜTÁ"Þ¯ùÓw9ð~¸SpÉ÷½~—àn'71˜³»w¹Ûƒë¸GÝÿä°¿AÆî^1vÏ“ÛÏû¿Oì¹^!SÓbrÌq÷ n!9ð¯ðÜÜ;äÀûz ^Mr îÓ€[HïD?}CÎOÉ=,ê}Ôóç÷ˆ¨÷{0.ß³Þ£b.ïï8ø'÷˜ð–éŸ÷¾Cîqá­L rÀ=!¼'’ƒ¿2¹éÂ[/ð~@ï áM\=Ö{RxÏ$šÜSÂÛ¶¾|¿<-¼Ýúçç­-ë=#¼ç‘ƒ¿¹g…wXàõýòœð^\ï0Ö{^x¯&ÿ%ä^Þ¯Ÿß™Â;5ànd½YÂû 9ø§’{Qxgõü}ô’ðÎ"f뽬öÿäàŸEn¶ð. ¼¾¯æïr`–²Þ+Âû!9ø×›+¼Ÿýâûjžðî ®÷3Ö›/¼?‘ƒ¹W…÷Àëûê5á-1Àqè?Xïuá­@~ä€{Cx«È{ýzõ¦ð֟ꬷ@x‘ƒ¿6¹…Â[x}?/Þæòó[Èz‹…·#9ø›“["¼ç^ßÏK…÷|rèsXï-á½€üç“{[x/ ¼¾Ÿ— ïõw)ë-Þ[ÈÁ=¹Â{7¹w‚uòá}$¸Þ»Yo¥ð>CþGÈ­ÞÙ×÷ójá}“˜Ù¬·Fx—“ƒÿMrï ï{×÷óZáý„æâ=Ö['¼_‘ƒÿrï ïw×÷óûÂûk0¿ß±ÞÂ{ØùŽƒÿWrë…·ôùy¯ïç Â{LÀ!ÜFµÿ'ÿ1ä>ÞSƒz¾Ÿ?Þ$9œÛ©¬÷±Úÿ“ƒ?In“ð¶êù~þDíÿƒókÍz›…·9ø»ûTx‡^ßÏ[„w49ŒÉÖÛªžÿ“ƒ4¹mÂ{Càõ}õ™zþp7°ÞçÂ{?9øï ÷…ð>Ôóóû¥ð¾@còë}%¼óÈÁÿ¹¯…wq0~~~¿ÞU·˜õ¶ ïrð¯"·Cx·õüüîÞÁ¸le½]Âû#9øwÛ-¼¯_¯öo±Žsõ¾ÞräàG¸ï„·êÀ¼×÷Õ^á=‰æ¢*ë}/¼ ÈÁ¹„7xýzõ£ðž50ßWYÖÛ'¼íÉÁ¹Ÿ„·Gàõýü³ðö'‡1éÁz¿ïrð÷'·_ÔŒßB>—þU<—¾–ÜXÖúMÔšôÀ+¬õ»¨5Ís¬u@íÿÉÀ;ÜA᜜ÿ;tÎYäf°ÖÂ9Ÿ ܳÈý)œKÈù5ο„s5¹%¬+%î2p¯&wX©:·×ùEJ‰÷ÿ%·•µÎÈÀ½ƒ\QÁ þZrÅĹ”ŸwßCÅŹ•%µJge2p—%WR8O$·0˜÷#„³¹Y«”p¦ÈÀ]\iál2(?ïþ:Î6äš°VáìBî6äÊ gŸà:ý¼—Î!äú°VyáEî!ä*î ràý½WQpÉ÷su”¸†Ûƒþðsu´¸†ûÈÝÎZÇçcdà¾\%Á=Gü_µWYœÛ+Á¹ùñ­"Îm!¹Wè¬*œ+ÈÀ½\5Á½O¼_gª n3¹÷ƒ¾çUbŽKn9ðsxnIÁ­ Þ×K îý ^yriÁm¸ôfD?}MÎÍä²¢ÞÞ ž?¿œ¨÷[0.{Y¯PÌE‘!Žƒÿ7r§ ï‘CòÞäNÞJäÀ ÜÂ[ƒü•È5Þº÷}z›o*àê²Þ™ÂÛ„ü)rM…·Í|ø~9Kx»ÉÏ[Ök&¼}ÉÁß•\sáx}¿´Þ‹ƒëÊz-…÷*rð_L®•ðN ¼~~[ ›Äzm„÷rðO!×Vx§õü}ÔNxg’3õÚ ï|rðÏ$×Ax—^ßW…w590KX¯“ðn$ÿjrg ﶠ_|_uÞÁõnc½.»ü;ÉuÞC×÷U7á->ÔqèC¬×]xË“ƒ9àzoµ¡y¯_¯z o­¡ùù¨ÆzçoCrð×"w®ðæ¯ïç^ÂÛlh~~s¬×[x;ƒ¿¹>ÂÛ3ðú~î+¼È¡z²ÞyÂ;’üÈõÞq×÷sá½.àƱÞá½™üב;_xï úÅ÷ó@á}8¸Þ»Xoð>Mþ‡É Þ—¯ïç!ÂûFÐW/³ÞPá]Fþ7È Þu×÷ópáÝôÕ:Ö!¼_’ƒ¹‘Âûmàõý|ðîæ÷[Ö»PxcÃÿ~r o©ay¯ïçQÂ{tÀ!Ühµÿ'ÿÑä.ÞS‚z¾Ÿ/Þ9œÛ)¬7FíÿÉÁŸ 7Vx[õ|?SûÿàüZ±Þ¥ÂÛ›üÉ]&¼ƒ¯ïçË…wÔ°|_ f½+Ôórð"w¥ðN ¼¾¯®RÏÿn"ë]-¼÷‘ƒÿvr×ïãA=?¿× ïóä0&³ÞuÂ;—üÏ“»^xãççw¼ð® ¸E¬7Axדƒ%¹‰Â»%¨çç÷áÝŒËÖ›$¼?ƒ;¹…÷@àõëÕdá-:Üq`°ÞMÂ[–üÈw³ðVž÷ú¾ºExk’‹žÏ°Þ­Â[Ÿü5ÉÝ&¼™Àë׫ۅ·éð|_eXïámGþ¦ä¦o÷Àëûyªðö#‡1éÎzÓ„w89øû‘»SÔŒ®¥©}}—x.} ¹1¬u·¨ucÐsXëQk*¹Yë^µÿ'ïTr÷ çôàüWÐy¿pÎ$7µÎydàžIîAá\Lίñp>$œ«È-f­ÿ¨ûŸ Ü«È=,œ[‚ë|ŸÎG„s;¹-¬õ¨p~OîíäÜïäÀ_Cîqqn‡ÈÏ»ï¡'Ĺ•!µ¦ g%2p—!7C8k[Ìû“ÂY—\ ÖzJ8“dà®Kîiál<"?ïþ:ŸÎÖä³Ö³ÂÙ™ Ü­É='œ½ƒëôóþ¼p&×›µ^΋ÈÀ=˜ÜLÁ]N¼¿÷f n9ð~®^×p[Ð~®^×p/¹ÛXëeá|” Ü÷’›-¸gÉß_ËqsÄ¹Í ÎÍï+âÜ›Cç\á\Nîäæ î=ràý:3_pŸ{/èËW÷¹O‚1yM\ëwAÿúyx]\ë¯ä¾c­7Ôþ¤càþ•Ü›ÂYŠÜŠ çÑäÀ£ÖBá<Ž ÜG“[$¸“É÷kêbÁÅÉ÷÷àÁN¼ï¥¥‚kI¼“·Ä˜œ=2?~LÞcÒ‹ÜÙ¼ÖeÂ9 ܽÈ-Ü…äÀû5…à.#Þ¯ïn<9ð¾×W îVrãƒ9[%¸{ÈÝ\Çjuÿ“Ãþ9»5bìžõ^üÛÿá±Ø»¢Öl2ã*Ú>é${¾ksÛ½¶Õ<ÕÖØÛŸ¶´u¯•E»O»Úšz®ïgë´Íêï‹­ußaݪcc±ÒŒ±ÇP‹/,6X,·xÕâ9‹ÿXÜaq½Å%ƒ,zX´¶(´¨gqœE9‹Ã,~º$ûÆâc‹UoZ̲xÌâN‹,.µfÑË¢½Ec‹F'ZeQÌâ׋c±]ŸZ¬µXl1Ûb†Å½7Y\iqÅyg[œe‘´¨mQÙ⋃£m°øÌâ‹·-æYaãgÑÎb˜ÅU÷[̵øÀb¯Eé¤Õ±hi1Ðâz‹‡-^·øÈâ'‹j)«cÑÎb˜Å$‹',Y|jñ›Å1éX,aq¶Å…·X´(iì±-˜÷‘È{Šyc,ç‹iOZ¼fñn}—÷±È{…yêÙc¾qU,ê[4µèμM"o)ó&ZÞí[̵Xi±¥žËûDä½Ç¼£9Þ"aÑÊ¢·Å(æmy[™·ò›_‹í,ÊÚcIÍS]Þ§"oó:ÛÛb”ÅD‹û,ž?Ååmy¿3oÓÉv¿Zì·(eüñ æmyxÌÃÇãGZ\gq—ÅÓoœìò¶‰¼c˜·Ó?÷Y7¶šEC‹fÌûLäļ«,g’Å3-–Xl¬ãò>yqæ]gë7[o‡È»›yG›osq÷;ˆW™¯Õ©Æ¼"ï æ½kÜiæšcQ×\Ó+äóv‰¼—˜3ߊâîw‚‡š/cuŠ3o·È[ȼ׌«c®G-*™kJ…|Þ‘·†yûíyÈ‚âîwÁûš¯¾Õ9TÁå}+ò>aÞ‹Æk®{,Ž4~R…|Þw"oó6™ïÑâîõ0š˜¯l9×kÈÛ+ò~a^®ŒÝ«Ç—µ±)ëòÐÛÈû^äaÏe滵¸{šºæ;PÖõò~y˜WË\wY”2~bY—7†¾EÞ Ì{Ù|—w¯ UÉ|Û˺^CÞ>‘×€yåÍuÅ~‹Qe]^?ú~y§3ïaó ,î^§­ˆùÖ—u½†¼ŸE^[æ2v¤¹¾´è]Öåµ£ï‘wón6_§âîu÷–¶û°¬ë5äíyC˜·Ó|=͵΢UY——¡ïW‘7–y×™¯…ùðº™_›onY×kÈûMäM`Þ6óu0×2‹3ʺ¼úôý.ò¦2o€ùêw¯)¼¢´ëµ¡ôy0ÿ_ŽÇÿN¥]zë/òŠ¼˜×Á|‹»×ôžSÚõZWú‰¼×™‡Ÿ_Á¿ãœVÚå¡·§Ó÷‡È{‡y9óýY̽žþ£¥]¯5¡ïO‘÷!óðódøwÔ:¥]z{ }‰¼¯ü}d¾ÝÅÜ{YÜZÚõZ]úb¥ÿ™÷#óð³øÿ‹Š¥]zû*úyùûÈ|sï-sYi×k•è+"òð<øÙjü"Æyèí¡ô.òª3¯8þ§˜{o¡ K»^;’¾¢"ïTæágêñȸG‘‡ÞîK_1‘—eÞN;ðb1÷Þkè5¬‡xÌF^q‘×’yØctñ’.½õ{ä•yݘ·Ñ`^sÍ,áòÐÛXo§¯‚ÈûÌσÈs½†õÙ—ÑWQä}Ǽ•E]zë/öØÇ"ï(‘wÐσ¨YÌõÖCeÞŠÃ\¯a=Äc6ö•ïÒWKäí òÐÛX±GÀ>öhúj‹¼_™7ç0×kXñ˜}åkôÕyøŸ‡ÞÆú‹=ö±1úNyG1ïÙÃ\¯a=Äc6ö•/ÒwŠÈ;1ÈCocýÅûX<×BÞ©"¯óñyž+âù)žûçáuE^cæMâs¾é|n»ºBþyU=‘מyØ«`„=öØ{úýn}‘׋y÷ð¹æ>§Þ\>¿i ò†1÷6Ö¬aX7–Ï?>4y—2cŽyFo¡Ÿqùû¶‘È»yØóãyžÛàùÔ˜àycÈ»“ysùe=Ÿ‹àsNäÅEÞcÌÃþ{NìsGñ¹#žC /!òf1oŸ}Éç€Øgϼ¤È{“yX/±FäóÇ»ø<y)‘·ŠyècÜ;¸_±F`]Ê1/-ò>fö¨C¹ŸÂçþyNFä}ü¯¹§Æ>Ïð|¥ ó²"ï'æao|Ÿ<Êç:x~…¼œÈÃÿGâãgîå±çÀº€½k'押rÌ»†Ïâó·ø¼y§‰¼ã˜‡µëÖ@¬»Xë‡3ït‘Wy·s÷<÷«ëƒ}ù"¯yØaˆ}'öºØ_b^c‘ךysÿø÷É_òùòšˆ¼ÌÃ>{Oìw±ÇÉçÈ;Sä bÞLî[Ws¾ÏC×Tä]Â<¬·Xãñ¸‚Ç2<~>ÀýÙY"ïzæ-à¾c3÷WØÓù}d3‘wó°Àžû¤Ë¸|”û‰æ"ï?Ì{—ûÝÜ×a/Y‡y-DÞsÌþ{¥1Ü>Ľ/òZŠ¼W™·…û¬ÜOb›a^+‘·œyx Ãã&«±?Àžd%ÿZ‹¼ ÌÛÏÇI<6c?€=ˆß÷´y_0ï:>Æ>̽Ä2î™×Vä}Ï<ñxÏv¼:ÞËï+Ž÷øÆûm㽯+ó=¡»ñ½’§ò=„×ð½uKð=g›ó½Xý{š¾Ä÷üÜÅcåù>íøþŒwñØ|ÃÅ|¿À<†÷˜Ã{ª¡F;28†÷OCÍa|B08†1é,Æd?ÇÄ¿ÞS ïo…÷šÂû>á=˜ð~Hxo"¼OPI¾N ÿ¾2|¿•|¼'H%¾WFW¾‡Ä¾·Âj¾ç@q¾3¾F½­÷ùZè;y¬_ÿ¸-_·úN»Ÿ¯í¼ˆ¯£\ŸÇðÚ»x­YÔhKÇ𺲨9”¯Ï Ç0&]Ęà÷Çñá_ß´2_÷³_s*_'r _?±Ä÷º‚͸×ÛÃkß=2À½&^Ÿí×îuËðbx=/¼¶^ç ¯9…×Âk1áu‘ðEx½ ¼v ¼V^Ï`•åëB´áëyLã±ûøš ùúõx ¯I€ßÁG6dp ¿ošCøº`p cÒUŒÉxŽ‰ÿ½ïJü}è®ü=á)üýÙÕü½Òâü}Ëfü=Äëøûyoð÷Öð;dGów«:ówŽnçïâ¬äï¨åïn4åï4øß ˜ÉŸßÎceøó²­ùsÎSyì^þ,ðþÜm]ÃÏjâgQ£5ÃÏ!¢æ`þ*øúèàëc‚¯+_W¾®â¿.âž— þ^ío¯üý8ž;æó€qÃ5Á:Ç[ØÃ@싆¶ÄÅlÙˆ~7ÅÚ6fOqcö”.ú½TÛöÇðv_¶ÕÙV4fÛ»è×ýmëÃ០/µ¸ÚbܘK‡Ä†žáØ!±Q£ÇÅÇ7‰?jplô˜ØƒGŒ7bÔ q±ã†Ø7ÿO}qÜ"6$’Š IƆ$bCâ±!±± ŠãSŸ’ø”ŠÅ/åµVæ5bž|¿7=:úÉE{ºkû¸îÞA½û(ò/Çÿ~ù¿ßGþãï÷’ÿøûýä?þ~Où¿ßWþCÝ[ø(õ/ÇKÿËñ#ÿåx™9^ö_Ž—û—ã÷ÅÜX\e1Ñ⮘ë³ÿÎóÿþñÿû<ãü£õù_æ±<Ïáßæã…Ç0?/Gòk?þÏ¢t• ¾.ͯ1&X›ÇzØœßɵkb¼FA© û”ˆâs¢ ú>GÇÉès ¾lÊàsxƒx2ý‘MGuâ9°É(;úN"e'SÑçtôé‰lt<’Yw<}Žêd£3ÊEg”‹j梚¹(7çÎ(uäÜÑY%3î¸û#áþHº?\^&íþȸ?\•Œ«’qU²®JÖUɺ*YW%몸ëNf]•¬«’uU²®JÎUɹ*9W%çªðr®JÎUɹ*9WÅs²ÐU)tU ]•BW¥ÐU)tU ]•BW¥ÐU)Œª¤ Üq÷GÂýáfµ åþH»?2î¬û#çþpUâ®JÜU‰»*qW%îªÄ]•¸«wUâ®JÜUI¸* W%áª$\×m©„«’pU®JÂUI¸*IW%骸nL%]•¤«’tU’®JÒUIº*IW%媤\•”«’rUR®JÊUqÍŸJ¹*)W%媤]•´«’vUÒ®JÚUI»*iWÅõnÊõnÊõnÊõnÊõnÊõn*Ã;ÏUq½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›r½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›v½›ˆÎºTºFªF¶F®þbcc£d£g#g£†$* )—h lDìÂmlLl<nM¯a×m—g×kW]®]—]¨]ˆ]§]Ut}v²vIvv)vQÑ%ØIÚ™Ù9ÚIGWa'h7–ÝTv'Ù=ÝHvãØdw‘Ý:vÛD·ŒÝ)vÏØ=aw‡Ý'Ñcíow‡ÝvWØ=ÝÖövXŸÛm`½õ½õ¹uµµ¹5µuyÔýÖ¼Ö¸ÖÉÖÚQ“[Z [ûZ—ZÛF ·>Œ`˜Œ¶±–G·&Œ[?Æ pÔ† uk܆0ŽÁµAcl1˜Q?Æm@ã µœFƒI‹ÛÇmHã ¦³aŽGm·!ŽÛÆmœã6Ðñ¨›â6Îqå¸ sÜF>nÃÚ&nc·¶ˆÛÇmÀã6úñhœã6òq÷xG,×>5I<¿kÃO£,?Z×â6øñ úÁrlRâ6 ñhåŠÛøÇm2â6ñ ¾c5¢%*n·‰‰ÛlÄm^âÑr·©ˆçpÄØŽ-Fq›¸ÍKÜf(žÃQ‘æ(ns·9‰ÛDÅmõ‰ºïà+ãmªâ6o ÌK´Ô$l.hbëX›©„M\"ZSq|•«‘ˆã¨åØŒ%¢5$a³“°KÄqÔr£…Â&(‰1±;#º×­©0liÌjt†É趰B)ÜQZt9jÓ çkD—os„ Äuã.J»>ÅtØ<¥£þˆG뮵f<;Î&¹¹tAÔS˜Ìœ;jµnTë„è aà ÚäÚìgÝ}nÝÝ® Œ»/snœ­rQ‹Ú fçÇ=™‰î¾h1ŠZ­aCoß±‰+t·¢%Úl[³D]—‹!êŸBßÓéèÚ¬¬SlÜÒ~Fsɨ¹¢› ^#Zºl¸ìʬ“¬e¬Û¢GÖ”ëCŒ&Z Ý-Ño×eãf%°2d}ÿFѸ³¢¡LE‹I&Zo¬'£E÷eÂu”#F5z¨ÎE·~.ºÇ1ÏîF¶‹îwKÚõDËÖ’\´ -­Ý\ã¼ÝwÜ­ëÚ“l½–ã ò?÷”ÍF5u¯[M £‹-t Lô åØ£j3WènÃhá²™¶<Ü0Ñò“tG£»+Hat“¦ýf3lern‘Š¬1¢™hx¢;Çz7\·@%Ýâe%zh(äíÝJñÑGÂÕ M‰u§›pëžûÆÇ&5swbÂ/tÑÂÅå =§¹†Ø7ð0c×äF ëV»„»âÑPa&ºÁmÌ!ŒöIQçãæÄM‹AH¥£VˆÖõDÔ,Ñ·¬¹nz±Jâ®&,­Ÿq÷´Æ&Õ,Ý0XÔÜáhÉ–vÝ-a)÷ìMшe£JD;•hÍ‹ú8Åu² Z£(Z1ø6tÑøç|odyƒàvN¹QA­¤¸‚è†JríŠVÛ¨3Ñz­Ôn@²näLœtM•ˆÿÏjŸq-­ÄÑ«#æu6ŠÎ™sm=bàq!›ñk¼ ¾­'w +ª{ôIDëX’+uÚ­³q~'é: î‚t4|n¹t«²[¯£õ£Ð?bظgÙaX×£í\ô¨€ÖÖý¤[±£±Àø›0Ž¹ñs+{„)ÌEk;”D´ÁŒºËì˜ hŬd1ÁÙhn­ì«èXôUŸ²ø”ç(õ0·YÌm6!|…Œxô¼ÖjY›Ú¬MeÖ&6kóšµ&Ê&ðD.mý -ç ¬ÏÆÙŒfÝ3ël…ñà€¡Ì&Q7‰ºIœIg’Ä™¤p&)œ f/›Œ™Êb ³˜Û,æ6‹1Îb´³˜Ñ,æ6‹ÉÌbn³˜‹,º!‹yÌbn³˜Û,æ6‹ùÎbn³™è¤ì281»lhm^³6­Y x2 100) :named S11)) (assert (! (= res4 (- x2 10)) :named S12)) (assert (! (and (= x2 xm1) (= resm5 res4)) :named S1RET)) (assert (! (= xm6 resm5) :named M3)) (assert (! (> x7 100) :named S21)) (assert (! (= res9 (- x7 10)) :named S22)) (assert (! (and (= x7 xm6) (= resm10 res9)) :named S2RET)) (assert (! (= res11 resm10) :named M4)) (assert (! (and (<= x_1 101) (distinct res11 91)) :named ERR)) (check-sat) ;unsat (get-interpolants M1 M2 (and S11 S12) S1RET M3 (and S21 S22) S2RET M4 ERR) ;((<= x_1 100) ; (<= xm1 111) ; true ; (<= res4 (- x2 10)) ; (<= resm5 101) ; (<= xm6 101) ; (>= x7 101) ; (and (>= res9 91) (<= res9 (- x7 10))) ; (= resm10 91) ; (= res11 91)) opensmt-2.5.2/regression_itp/LIA/lia_itp_split.smt2000066400000000000000000000003641445011647600223240ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-logic QF_LIA) (declare-fun x () Int) (declare-fun y () Int) (assert (! (and (>= (- (* 3 y) (* 2 x)) 0) (>= (- (* 2 x) y) 2)) :named A)) (assert (! (<= y 1) :named B)) (check-sat) (get-interpolants A B) opensmt-2.5.2/regression_itp/LIA/lia_itp_test.smt2000066400000000000000000000004701445011647600221460ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-logic QF_LIA) (declare-fun x () Int) (declare-fun y () Int) (declare-fun z () Int) (assert (! (<= (+ (* 4 x) (* 2 y)) 3) :named A)) (assert (! (>= (+ (* 8 x) (* 4 y)) 5) :named B)) ;(assert (= x (* 2 y))) ;(assert (= x (+ (* 2 z) 1))) (check-sat) (get-interpolants A B) opensmt-2.5.2/regression_itp/LIA/lia_itp_test2.smt2000066400000000000000000000004001445011647600222210ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-logic QF_LIA) (declare-fun x () Int) (declare-fun y () Int) (assert (! (and (<= (* 5 x) 4) (<= (+ (* (- 3) x) (* 2 y)) 1)) :named A)) (assert (! (<= (* (- 1) y) (- 1)) :named B)) (check-sat) (get-interpolants A B) opensmt-2.5.2/regression_itp/LIA/lia_itp_test3.smt2000066400000000000000000000004351445011647600222320ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-logic QF_LIA) (declare-fun x () Int) (declare-fun y () Int) ;not (0 <= x - y) with label A; not (1 <= y - x) with label B (assert (! (not (<= 0 (- x y))) :named A)) (assert (! (not (<= 1 (- y x))) :named B)) (check-sat) (get-interpolants A B) opensmt-2.5.2/regression_itp/bug_mask_ite.smt2000066400000000000000000000004661445011647600215170ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-option :certify-interpolants 1) (set-logic QF_LRA) (declare-fun x () Real) (declare-fun y () Real) (declare-fun z () Real) (assert (! (= z (ite (<= 0 x) x y)) :named a)) (assert (! (not (or (< y 0) (<= 0 z))) :named b)) (check-sat) (get-interpolants a b) (exit) opensmt-2.5.2/regression_itp/bug_mask_ite_nested.smt2000066400000000000000000000047761445011647600230710ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-option :certify-interpolants 1) (set-logic QF_LRA) (declare-fun |state::state.pc| () Real) (declare-fun |state::state.old| () Real) (declare-fun |state::state.new| () Real) (declare-fun |state::state.ht!5!assimilated| () Bool) (declare-fun |state::state.ht!4!assimilated| () Bool) (declare-fun |state::state.ht!3!assimilated| () Bool) (declare-fun |state::state.ht!2!assimilated| () Bool) (declare-fun |state::state.ht!1!assimilated| () Bool) (declare-fun |state::state.ht!0!assimilated| () Bool) (declare-fun |state::next.ht!0!assimilated| () Bool) (declare-fun |state::state.ht!5!num_to_migrate| () Real) (declare-fun |state::state.ht!4!num_to_migrate| () Real) (declare-fun |state::state.ht!3!num_to_migrate| () Real) (declare-fun |state::state.ht!2!num_to_migrate| () Real) (declare-fun |state::state.ht!1!num_to_migrate| () Real) (declare-fun |state::state.ht!0!num_to_migrate| () Real) (declare-fun |state::next.ht!0!num_entries| () Real) (declare-fun |state::state.ht!5!num_entries| () Real) (declare-fun |state::state.ht!4!num_entries| () Real) (declare-fun |state::state.ht!3!num_entries| () Real) (declare-fun |state::state.ht!2!num_entries| () Real) (declare-fun |state::state.ht!1!num_entries| () Real) (declare-fun |state::state.ht!0!num_entries| () Real) (declare-fun |state::next.ht!0!num_to_migrate| () Real) (declare-fun |state::next.ht!1!assimilated| () Bool) (declare-fun |state::next.ht!1!num_entries| () Real) (declare-fun |state::next.ht!1!num_to_migrate| () Real) (declare-fun |state::next.ht!2!assimilated| () Bool) (declare-fun |state::next.ht!2!num_entries| () Real) (declare-fun |state::next.ht!2!num_to_migrate| () Real) (declare-fun |state::next.ht!3!assimilated| () Bool) (declare-fun |state::next.ht!3!num_entries| () Real) (declare-fun |state::next.ht!3!num_to_migrate| () Real) (declare-fun |state::next.ht!4!assimilated| () Bool) (declare-fun |state::next.ht!4!num_entries| () Real) (declare-fun |state::next.ht!4!num_to_migrate| () Real) (declare-fun |state::next.ht!5!assimilated| () Bool) (declare-fun |state::next.ht!5!num_entries| () Real) (declare-fun |state::next.ht!5!num_to_migrate| () Real) (declare-fun |state::next.pc| () Real) (declare-fun |state::next.K| () Real) (declare-fun |state::state.K| () Real) (declare-fun |state::next.new| () Real) (declare-fun x () Real) (declare-fun y () Real) (declare-fun z () Real) (assert (! (= z (ite (<= 0 x) x (ite (<= 0 y) y (- y)))) :named a)) (assert (! (not (<= 0 z)) :named b)) (check-sat) (get-interpolants a b) (exit) opensmt-2.5.2/regression_itp/dec-far1.smt2000066400000000000000000000010701445011647600204400ustar00rootroot00000000000000(set-option :produce-interpolants true) (set-option :certify-interpolants 1) (set-logic QF_LRA) (set-option :interpolation-lra-algorithm 4) ; decomposed Farkas (declare-fun x1 () Real) (declare-fun x2 () Real) (declare-fun x3 () Real) (assert (!(<= 0 (+ x1 x2 ) ) :named A)) (assert (!(<= 0 (+ x1 x3)) :named B)) (assert (!(<= 0 ( * (- 1) x1 ) ) :named C)) (assert (!(<= 1 (+ (* (- 1) x2 ) ( * (- 1) x3 ))) :named D)) (check-sat) (get-interpolants (and A B C) D) (get-interpolants A (and B C D)) (get-interpolants B (and A C D)) (get-interpolants C (and A B D)) opensmt-2.5.2/regression_itp/dec-far2.smt2000066400000000000000000000010121445011647600204350ustar00rootroot00000000000000(set-option :produce-interpolants true) (set-option :certify-interpolants 1) (set-logic QF_LRA) (set-option :interpolation-lra-algorithm 4) ; decomposed Farkas (declare-fun x1 () Real) (declare-fun x2 () Real) (declare-fun x3 () Real) (declare-fun x4 () Real) (declare-fun x5 () Real) (assert (!(and (<= 0 (+ x1 x2 )) (<= 0 (+ (- x1) x3)) (<= 0 (+ x1 x4)) (<= 0 (+ (- x1) x5)) ) :named A)) (assert (!(<= 1 (+ (* (- 1) x2 ) ( * (- 1) x3 ) (* (- 1) x4 ) (* (- 1) x5 ))) :named B)) (check-sat) (get-interpolants A B) opensmt-2.5.2/regression_itp/distinct_unsat.smt2000066400000000000000000000005431445011647600221150ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-option :certify-interpolants 1) (set-logic QF_LRA) (set-info :status unsat) (declare-fun a () Real) (declare-fun b () Real) (declare-fun c () Real) (assert (!(and (not (distinct a b c)) (not (= a b)) (not (= a c)) ):named A)) (assert (! (not (= b c)) :named B)) (check-sat) (get-interpolants A B) (exit) opensmt-2.5.2/regression_itp/incremental/000077500000000000000000000000001445011647600205525ustar00rootroot00000000000000opensmt-2.5.2/regression_itp/incremental/inc_itp_theory_prop.smt2000066400000000000000000000003111445011647600254330ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-logic QF_LRA) (declare-fun x () Real) (push 1) (assert (! (>= x 0) :named A)) (push 1) (assert (! (<= x (- 10)) :named B)) (check-sat) (get-interpolants A B) opensmt-2.5.2/regression_itp/incremental/incremental_itp.smt2000066400000000000000000000002731445011647600245400ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-logic QF_LRA) (declare-fun b () Bool) (assert (! b :named p1)) (push 1) (assert (! (not b) :named p2)) (check-sat) (get-interpolants p1 p2) opensmt-2.5.2/regression_itp/incremental/incremental_itp2.smt2000066400000000000000000000004141445011647600246170ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-logic QF_LRA) (declare-fun a () Real) (assert (! (and (= a 0) ) :named p1)) (push 1) (assert (! (and (= a 1) ) :named p2)) (check-sat) (get-interpolants p1 p2) (pop 1) (push 1) (assert (! (= a 2) :named p3)) (check-sat) opensmt-2.5.2/regression_itp/incremental/incremental_itp3.smt2000066400000000000000000000005431445011647600246230ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-logic QF_LRA) (declare-fun a () Bool) (declare-fun b () Bool) (declare-fun c () Bool) (assert (! (and (or (not a) b) (or (not a) (not b)) ) :named p1)) (push 1) (assert (! (or a c) :named p2)) (check-sat) (push 1) (assert (! (or a (not c)) :named p3)) (check-sat) (get-interpolants p1 (and p2 p3)) opensmt-2.5.2/regression_itp/incremental/incremental_itp4.smt2000066400000000000000000000010251445011647600246200ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-logic QF_UF) (declare-fun a () Bool) (declare-fun b () Bool) (declare-fun c () Bool) (declare-fun d () Bool) (assert (! (and (or (not a) b) (or (not a) (not b)) ) :named p1)) (push 1) (assert (! (or a c) :named p2)) (check-sat) (push 1) (assert (! (or a (not c)) :named p3)) (check-sat) (get-interpolants p1 (and p2 p3)) (pop 1) (assert (! (or (not c) d) :named p4)) (push 1) (assert (! (or (not c) (not d)) :named p5)) (check-sat) (get-interpolants p1 (and p2 p4 p5)) opensmt-2.5.2/regression_itp/incremental/incremental_itp5.smt2000066400000000000000000000010101445011647600246130ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-logic QF_UF) (declare-fun a () Bool) (declare-fun b () Bool) (declare-fun c () Bool) (declare-fun d () Bool) (assert (! (and (or (not a) b) (or (not a) (not b)) ) :named p1)) (push 1) (assert (! (or a c) :named p2)) (check-sat) (push 1) (assert (! (or a (not c)) :named p3)) (check-sat) (get-interpolants (and p1 p2) p3) (pop 1) (assert (! (or (not c) d) :named p4)) (push 1) (assert (! (not d) :named p5)) (check-sat) (get-interpolants (and p1 p2 p4) p5) opensmt-2.5.2/regression_itp/incremental/issue152_itp.smt2000066400000000000000000000003301445011647600236110ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-logic QF_LRA) (declare-fun r11 () Real) (check-sat) (check-sat) (assert (!(> r11 0.0) :named A)) (push 1) (assert (!(> 0.0 r11) :named B)) (check-sat) (get-interpolants A B) opensmt-2.5.2/regression_itp/incremental/itp_inc_bug_minimized.smt2000066400000000000000000000021541445011647600257120ustar00rootroot00000000000000;(set-option :produce-proofs true) (set-option :produce-interpolants true) (set-logic QF_LRA) (declare-fun |state_type::state.x| () Real) (declare-fun |state_type::state.y| () Real) (declare-fun |state_type::state.z| () Real) (assert (! (let ((l0 (/ 9 10))) (let ((l1 (- l0))) (let ((l2 (= |state_type::state.x| l1))) (let ((l3 (= |state_type::state.y| 0))) (let ((l4 (= |state_type::state.z| l0))) (let ((l5 (and l2 l3 l4))) l5)))))) :named p1)) (push 1) (assert (! (let ((l0 (* (/ (- 104647) 164745) |state_type::state.x|))) (let ((l1 (* (/ (- 19666) 128135) |state_type::state.y|))) (let ((l2 (* (/ 105892 230643) |state_type::state.z|))) (let ((l3 (+ (/ (- 35559) 36610) l0 l1 l2))) (let ((l4 (>= l3 0))) (let ((l5 (not l4))) l5)))))) :named p6)) (check-sat) (get-interpolants p1 p6) (pop 1) (push 1) (assert (! (let ((l0 (* (/ (- 104647) 694575) |state_type::state.x|))) (let ((l1 (* (/ (- 19666) 540225) |state_type::state.y|))) (let ((l2 (* (/ 105892 972405) |state_type::state.z|))) (let ((l3 (+ (/ (- 81) 490) l0 l1 l2))) (let ((l4 (>= l3 0))) (let ((l5 (not l4))) l5)))))) :named p7)) (check-sat) (get-interpolants p1 p7) opensmt-2.5.2/regression_itp/incremental/itp_inc_theory_clause_issue.smt2000066400000000000000000000010261445011647600271430ustar00rootroot00000000000000;(set-option :produce-proofs true) (set-option :produce-interpolants true) (set-logic QF_LRA) (declare-fun x () Real) (declare-fun y () Real) (declare-fun a () Real) (declare-fun b () Real) (assert (! (>= x 0) :named p1)) (assert (! (>= y 0) :named p2)) (push 1) (assert (! (>= (- 10) (+ x y)) :named p3)) (check-sat) (get-interpolants p1 (and p2 p3)) (pop 1) (push 1) (assert (! (>= a x) :named p4)) (assert (! (>= b y) :named p5)) (assert (! (>= (- 20) (+ a b)) :named p6)) (check-sat) (get-interpolants (and p1 p4 p6) (and p2 p5)) opensmt-2.5.2/regression_itp/incremental/lia_splits.smt2000066400000000000000000000007201445011647600235230ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-logic QF_LIA) (declare-fun x () Int) (declare-fun y () Int) (declare-fun z () Int) (declare-fun b () Bool) (push 1) (assert (!(<= 2 (+ (* 4 x) y)):named A)) (assert (!(<= 1 (- (* 3 y) x)):named B)) (assert (!(>= 2 (+ (* 3 y) x)):named C)) (check-sat) (pop 1) (assert (!(and (=> (>= y 1) (>= z 0)) (=> (<= y 0) (>= z 0))):named D)) (assert (!(and (<= z (- 5)) (=> b (<= y 0)) ):named E)) (check-sat) (get-interpolants D E) opensmt-2.5.2/regression_itp/incremental/lia_splits2.smt2000066400000000000000000000006731445011647600236140ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-logic QF_LIA) (declare-fun x () Int) (declare-fun y () Int) (declare-fun z () Int) (declare-fun b () Bool) (push 1) (assert (!(<= 2 (+ (* 4 x) y)):named A)) (assert (!(<= 1 (- (* 3 y) x)):named B)) (assert (!(>= 2 (+ (* 3 y) x)):named C)) (check-sat) (pop 1) (assert (!(=> (>= y 1) (>= z 0)) :named D)) (assert (!(and (<= z (- 5)) (=> (<= y 0) (>= z 0)) ):named E)) (check-sat) (get-interpolants D E) opensmt-2.5.2/regression_itp/itp_bug.smt2000066400000000000000000000277511445011647600205250ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-option :certify-interpolants 1) (set-logic QF_LRA) (declare-fun |state_type::state.delta| () Real) (declare-fun |state_type::state.v!0| () Real) (declare-fun |state_type::state.v!1| () Real) (declare-fun |state_type::state.v!2| () Real) (declare-fun |state_type::state.v!3| () Real) (declare-fun |state_type::state.v!4| () Real) (declare-fun |state_type::state.p!0!0| () Real) (declare-fun |state_type::state.p!0!1| () Real) (declare-fun |state_type::state.p!0!2| () Real) (declare-fun |state_type::state.p!0!3| () Real) (declare-fun |state_type::state.p!0!4| () Real) (declare-fun |state_type::state.p!1!0| () Real) (declare-fun |state_type::state.p!1!1| () Real) (declare-fun |state_type::state.p!1!2| () Real) (declare-fun |state_type::state.p!1!3| () Real) (declare-fun |state_type::state.p!1!4| () Real) (declare-fun |state_type::state.p!2!0| () Real) (declare-fun |state_type::state.p!2!1| () Real) (declare-fun |state_type::state.p!2!2| () Real) (declare-fun |state_type::state.p!2!3| () Real) (declare-fun |state_type::state.p!2!4| () Real) (declare-fun |state_type::state.p!3!0| () Real) (declare-fun |state_type::state.p!3!1| () Real) (declare-fun |state_type::state.p!3!2| () Real) (declare-fun |state_type::state.p!3!3| () Real) (declare-fun |state_type::state.p!3!4| () Real) (declare-fun |state_type::state.p!4!0| () Real) (declare-fun |state_type::state.p!4!1| () Real) (declare-fun |state_type::state.p!4!2| () Real) (declare-fun |state_type::state.p!4!3| () Real) (declare-fun |state_type::state.p!4!4| () Real) (declare-fun |state_type::state.round| () Real) (declare-fun |state_type::state.status!0| () Real) (declare-fun |state_type::state.status!1| () Real) (declare-fun |state_type::state.status!2| () Real) (declare-fun |state_type::state.status!3| () Real) (declare-fun |state_type::state.status!4| () Real) (declare-fun |state_type::state.n!0| () Real) (declare-fun |state_type::state.n!1| () Real) (declare-fun |state_type::state.n!2| () Real) (declare-fun |state_type::state.n!3| () Real) (declare-fun |state_type::state.n!4| () Real) (assert (! (and (and (> |state_type::state.delta| 0) (and (not (<= |state_type::state.v!0| 0)) (not (<= |state_type::state.v!1| 0)) (not (<= |state_type::state.v!2| 0)) (not (<= |state_type::state.v!3| 0)) (not (<= |state_type::state.v!4| 0)) (<= (- |state_type::state.v!0| |state_type::state.v!0|) |state_type::state.delta|) (<= (- |state_type::state.v!1| |state_type::state.v!0|) |state_type::state.delta|) (<= (- |state_type::state.v!2| |state_type::state.v!0|) |state_type::state.delta|) (<= (- |state_type::state.v!3| |state_type::state.v!0|) |state_type::state.delta|) (<= (- |state_type::state.v!4| |state_type::state.v!0|) |state_type::state.delta|) (<= (- |state_type::state.v!0| |state_type::state.v!1|) |state_type::state.delta|) (<= (- |state_type::state.v!1| |state_type::state.v!1|) |state_type::state.delta|) (<= (- |state_type::state.v!2| |state_type::state.v!1|) |state_type::state.delta|) (<= (- |state_type::state.v!3| |state_type::state.v!1|) |state_type::state.delta|) (<= (- |state_type::state.v!4| |state_type::state.v!1|) |state_type::state.delta|) (<= (- |state_type::state.v!0| |state_type::state.v!2|) |state_type::state.delta|) (<= (- |state_type::state.v!1| |state_type::state.v!2|) |state_type::state.delta|) (<= (- |state_type::state.v!2| |state_type::state.v!2|) |state_type::state.delta|) (<= (- |state_type::state.v!3| |state_type::state.v!2|) |state_type::state.delta|) (<= (- |state_type::state.v!4| |state_type::state.v!2|) |state_type::state.delta|) (<= (- |state_type::state.v!0| |state_type::state.v!3|) |state_type::state.delta|) (<= (- |state_type::state.v!1| |state_type::state.v!3|) |state_type::state.delta|) (<= (- |state_type::state.v!2| |state_type::state.v!3|) |state_type::state.delta|) (<= (- |state_type::state.v!3| |state_type::state.v!3|) |state_type::state.delta|) (<= (- |state_type::state.v!4| |state_type::state.v!3|) |state_type::state.delta|) (<= (- |state_type::state.v!0| |state_type::state.v!4|) |state_type::state.delta|) (<= (- |state_type::state.v!1| |state_type::state.v!4|) |state_type::state.delta|) (<= (- |state_type::state.v!2| |state_type::state.v!4|) |state_type::state.delta|) (<= (- |state_type::state.v!3| |state_type::state.v!4|) |state_type::state.delta|) (<= (- |state_type::state.v!4| |state_type::state.v!4|) |state_type::state.delta|)) (= |state_type::state.p!0!0| 1) (= |state_type::state.p!0!1| 2) (= |state_type::state.p!0!2| 3) (= |state_type::state.p!0!3| 4) (= |state_type::state.p!0!4| 5) (= |state_type::state.p!1!0| 1) (= |state_type::state.p!1!1| 2) (= |state_type::state.p!1!2| 3) (= |state_type::state.p!1!3| 4) (= |state_type::state.p!1!4| 5) (= |state_type::state.p!2!0| 1) (= |state_type::state.p!2!1| 2) (= |state_type::state.p!2!2| 3) (= |state_type::state.p!2!3| 4) (= |state_type::state.p!2!4| 5) (= |state_type::state.p!3!0| 1) (= |state_type::state.p!3!1| 2) (= |state_type::state.p!3!2| 3) (= |state_type::state.p!3!3| 4) (= |state_type::state.p!3!4| 5) (= |state_type::state.p!4!0| 1) (= |state_type::state.p!4!1| 2) (= |state_type::state.p!4!2| 3) (= |state_type::state.p!4!3| 4) (= |state_type::state.p!4!4| 5) (= |state_type::state.round| 0) (and (= |state_type::state.status!0| 4) (= |state_type::state.status!1| 2) (= |state_type::state.status!2| 0) (= |state_type::state.status!3| 0) (= |state_type::state.status!4| 0))) (and (or (= |state_type::state.p!0!0| 1) (= |state_type::state.p!0!0| 2) (= |state_type::state.p!0!0| 3) (= |state_type::state.p!0!0| 4) (= |state_type::state.p!0!0| 5)) (or (= |state_type::state.p!0!1| 1) (= |state_type::state.p!0!1| 2) (= |state_type::state.p!0!1| 3) (= |state_type::state.p!0!1| 4) (= |state_type::state.p!0!1| 5)) (or (= |state_type::state.p!0!2| 1) (= |state_type::state.p!0!2| 2) (= |state_type::state.p!0!2| 3) (= |state_type::state.p!0!2| 4) (= |state_type::state.p!0!2| 5)) (or (= |state_type::state.p!0!3| 1) (= |state_type::state.p!0!3| 2) (= |state_type::state.p!0!3| 3) (= |state_type::state.p!0!3| 4) (= |state_type::state.p!0!3| 5)) (or (= |state_type::state.p!0!4| 1) (= |state_type::state.p!0!4| 2) (= |state_type::state.p!0!4| 3) (= |state_type::state.p!0!4| 4) (= |state_type::state.p!0!4| 5)) (or (= |state_type::state.p!1!0| 1) (= |state_type::state.p!1!0| 2) (= |state_type::state.p!1!0| 3) (= |state_type::state.p!1!0| 4) (= |state_type::state.p!1!0| 5)) (or (= |state_type::state.p!1!1| 1) (= |state_type::state.p!1!1| 2) (= |state_type::state.p!1!1| 3) (= |state_type::state.p!1!1| 4) (= |state_type::state.p!1!1| 5)) (or (= |state_type::state.p!1!2| 1) (= |state_type::state.p!1!2| 2) (= |state_type::state.p!1!2| 3) (= |state_type::state.p!1!2| 4) (= |state_type::state.p!1!2| 5)) (or (= |state_type::state.p!1!3| 1) (= |state_type::state.p!1!3| 2) (= |state_type::state.p!1!3| 3) (= |state_type::state.p!1!3| 4) (= |state_type::state.p!1!3| 5)) (or (= |state_type::state.p!1!4| 1) (= |state_type::state.p!1!4| 2) (= |state_type::state.p!1!4| 3) (= |state_type::state.p!1!4| 4) (= |state_type::state.p!1!4| 5)) (or (= |state_type::state.p!2!0| 1) (= |state_type::state.p!2!0| 2) (= |state_type::state.p!2!0| 3) (= |state_type::state.p!2!0| 4) (= |state_type::state.p!2!0| 5)) (or (= |state_type::state.p!2!1| 1) (= |state_type::state.p!2!1| 2) (= |state_type::state.p!2!1| 3) (= |state_type::state.p!2!1| 4) (= |state_type::state.p!2!1| 5)) (or (= |state_type::state.p!2!2| 1) (= |state_type::state.p!2!2| 2) (= |state_type::state.p!2!2| 3) (= |state_type::state.p!2!2| 4) (= |state_type::state.p!2!2| 5)) (or (= |state_type::state.p!2!3| 1) (= |state_type::state.p!2!3| 2) (= |state_type::state.p!2!3| 3) (= |state_type::state.p!2!3| 4) (= |state_type::state.p!2!3| 5)) (or (= |state_type::state.p!2!4| 1) (= |state_type::state.p!2!4| 2) (= |state_type::state.p!2!4| 3) (= |state_type::state.p!2!4| 4) (= |state_type::state.p!2!4| 5)) (or (= |state_type::state.p!3!0| 1) (= |state_type::state.p!3!0| 2) (= |state_type::state.p!3!0| 3) (= |state_type::state.p!3!0| 4) (= |state_type::state.p!3!0| 5)) (or (= |state_type::state.p!3!1| 1) (= |state_type::state.p!3!1| 2) (= |state_type::state.p!3!1| 3) (= |state_type::state.p!3!1| 4) (= |state_type::state.p!3!1| 5)) (or (= |state_type::state.p!3!2| 1) (= |state_type::state.p!3!2| 2) (= |state_type::state.p!3!2| 3) (= |state_type::state.p!3!2| 4) (= |state_type::state.p!3!2| 5)) (or (= |state_type::state.p!3!3| 1) (= |state_type::state.p!3!3| 2) (= |state_type::state.p!3!3| 3) (= |state_type::state.p!3!3| 4) (= |state_type::state.p!3!3| 5)) (or (= |state_type::state.p!3!4| 1) (= |state_type::state.p!3!4| 2) (= |state_type::state.p!3!4| 3) (= |state_type::state.p!3!4| 4) (= |state_type::state.p!3!4| 5)) (or (= |state_type::state.p!4!0| 1) (= |state_type::state.p!4!0| 2) (= |state_type::state.p!4!0| 3) (= |state_type::state.p!4!0| 4) (= |state_type::state.p!4!0| 5)) (or (= |state_type::state.p!4!1| 1) (= |state_type::state.p!4!1| 2) (= |state_type::state.p!4!1| 3) (= |state_type::state.p!4!1| 4) (= |state_type::state.p!4!1| 5)) (or (= |state_type::state.p!4!2| 1) (= |state_type::state.p!4!2| 2) (= |state_type::state.p!4!2| 3) (= |state_type::state.p!4!2| 4) (= |state_type::state.p!4!2| 5)) (or (= |state_type::state.p!4!3| 1) (= |state_type::state.p!4!3| 2) (= |state_type::state.p!4!3| 3) (= |state_type::state.p!4!3| 4) (= |state_type::state.p!4!3| 5)) (or (= |state_type::state.p!4!4| 1) (= |state_type::state.p!4!4| 2) (= |state_type::state.p!4!4| 3) (= |state_type::state.p!4!4| 4) (= |state_type::state.p!4!4| 5)) (or (= |state_type::state.n!0| 0) (= |state_type::state.n!0| 1) (= |state_type::state.n!0| 2) (= |state_type::state.n!0| 3) (= |state_type::state.n!0| 4) (= |state_type::state.n!0| 5)) (or (= |state_type::state.n!1| 0) (= |state_type::state.n!1| 1) (= |state_type::state.n!1| 2) (= |state_type::state.n!1| 3) (= |state_type::state.n!1| 4) (= |state_type::state.n!1| 5)) (or (= |state_type::state.n!2| 0) (= |state_type::state.n!2| 1) (= |state_type::state.n!2| 2) (= |state_type::state.n!2| 3) (= |state_type::state.n!2| 4) (= |state_type::state.n!2| 5)) (or (= |state_type::state.n!3| 0) (= |state_type::state.n!3| 1) (= |state_type::state.n!3| 2) (= |state_type::state.n!3| 3) (= |state_type::state.n!3| 4) (= |state_type::state.n!3| 5)) (or (= |state_type::state.n!4| 0) (= |state_type::state.n!4| 1) (= |state_type::state.n!4| 2) (= |state_type::state.n!4| 3) (= |state_type::state.n!4| 4) (= |state_type::state.n!4| 5)))) :named a)) (assert (! (and (= |state_type::state.p!0!0| 1) (= |state_type::state.p!1!0| 1) (= |state_type::state.p!2!0| 1) (= |state_type::state.p!3!0| 1) (= |state_type::state.p!4!0| 1) (= |state_type::state.p!0!1| 1) (= |state_type::state.p!0!2| 1) (= |state_type::state.p!0!3| 1) (= |state_type::state.p!0!4| 1) (= |state_type::state.p!1!1| 1) (= |state_type::state.p!1!2| 1) (= |state_type::state.p!1!3| 1) (= |state_type::state.p!1!4| 1) (= |state_type::state.p!2!1| 1) (= |state_type::state.p!2!2| 1) (= |state_type::state.p!2!3| 1) (= |state_type::state.p!2!4| 1) (= |state_type::state.p!3!1| 1) (= |state_type::state.p!3!2| 1) (= |state_type::state.p!3!3| 1) (= |state_type::state.p!3!4| 1) (= |state_type::state.p!4!1| 1) (= |state_type::state.p!4!2| 1) (= |state_type::state.p!4!3| 1) (= |state_type::state.p!4!4| 1) (= |state_type::state.n!0| 0) (= |state_type::state.n!1| 0) (= |state_type::state.n!2| 0) (= |state_type::state.n!3| 0) (= |state_type::state.n!4| 0) (not (>= (* (- 1) |state_type::state.status!1|) 0)) (= |state_type::state.v!0| 0) (= |state_type::state.v!3| 0) (not (>= (+ (- 3) (* 1 |state_type::state.status!2|)) 0)) (not (>= (+ (- 3) (* 1 |state_type::state.status!4|)) 0)) (not (>= (+ (- 3) (* 1 |state_type::state.status!1|)) 0)) (not (>= (* (- 1) |state_type::state.status!4|) 0)) (not (>= (+ (- 2) (* 1 |state_type::state.status!2|)) 0)) (not (>= (+ (- 2) (* 1 |state_type::state.status!1|)) 0)) (not (>= (* (- 1) |state_type::state.status!2|) 0)) (not (>= (+ (- 1) (* 1 |state_type::state.status!1|)) 0)) (not (>= (+ (- 2) (* 1 |state_type::state.status!4|)) 0)) (not (>= (+ (- 1) (* 1 |state_type::state.status!4|)) 0)) (not (>= (+ (- 1) (* 1 |state_type::state.status!2|)) 0))) :named b)) (check-sat) (get-interpolants a b) (exit) opensmt-2.5.2/regression_itp/itp_bug_small.smt2000066400000000000000000000003301445011647600216750ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-option :certify-interpolants 1) (set-logic QF_LRA) (declare-fun x () Bool) (assert (! (not x) :named a)) (assert (! x :named b)) (check-sat) (get-interpolants a b) (exit) opensmt-2.5.2/regression_itp/part_bug.smt2000066400000000000000000000064101445011647600206640ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-option :certify-interpolants 1) (set-logic QF_LRA) (declare-fun |hifrog::fun_start!0#3| () Bool) (declare-fun |hifrog::fun_end!0#3| () Bool) (declare-fun |getchar::1::x!0#2| () Real) (declare-fun |symex::nondet#1| () Real) (declare-fun |getchar::$tmp::return_value!0#1| () Real) (declare-fun |getchar::#return_value!0#1| () Real) (declare-fun |hifrog::fun_start!0#2| () Bool) (declare-fun |hifrog::fun_end!0#2| () Bool) (declare-fun |hifrog::?err!0#1| () Bool) (declare-fun |main::1::x!0#2| () Real) (declare-fun |goto_symex::guard#1| () Bool) (declare-fun |goto_symex::guard#2| () Bool) (declare-fun |goto_symex::guard#3| () Bool) (declare-fun |goto_symex::guard#4| () Bool) (declare-fun |main::1::t!0#11| () Real) (declare-fun .oite0 () Real) (declare-fun |main::1::t!0#12| () Real) (declare-fun .oite1 () Real) (declare-fun |main::1::t!0#13| () Real) (declare-fun .oite2 () Real) (declare-fun |main::1::t!0#14| () Real) (declare-fun .oite3 () Real) (declare-fun |hifrog::fun_start!0#1| () Bool) (declare-fun |hifrog::fun_end!0#1| () Bool) (declare-fun |nil| () Bool) (declare-fun |return'!0#1| () Real) (declare-fun |symex::io::0| () Real) ; XXX oite symbol: (0 out of 3) .oite0 (assert (! (and (or (not |goto_symex::guard#4|) (= (- 2) .oite0)) (or |goto_symex::guard#4| (= 10 .oite0))) :named i1) ) ; XXX oite symbol: (1 out of 3) .oite1 (assert (!(and (or (not |goto_symex::guard#3|) (= 5 .oite1)) (or |goto_symex::guard#3| (= |main::1::t!0#11| .oite1))) :named i2) ) ; XXX oite symbol: (2 out of 3) .oite2 (assert (!(and (or (not |goto_symex::guard#2|) (= 3 .oite2)) (or |goto_symex::guard#2| (= |main::1::t!0#12| .oite2))) :named i3) ) ; XXX oite symbol: (3 out of 3) .oite3 (assert (!(and (or (not |goto_symex::guard#1|) (= 1 .oite3)) (or |goto_symex::guard#1| (= |main::1::t!0#13| .oite3))) :named i4) ) ; XXX Partition: 3 (assert (! (and (and (<= (- 2147483648) |symex::nondet#1|) (<= (- 2147483647) (* |symex::nondet#1| (- 1)))) (= |getchar::1::x!0#2| |symex::nondet#1|) (= |getchar::1::x!0#2| |getchar::$tmp::return_value!0#1|) (= |getchar::$tmp::return_value!0#1| |getchar::#return_value!0#1|) (or (not |hifrog::fun_end!0#3|) (and (<= (- 1) |getchar::1::x!0#2|) (and |hifrog::fun_start!0#3| (not (<= 256 |getchar::1::x!0#2|)))))) :named part3)) ; XXX Partition: 2 (assert (! (and (= |getchar::#return_value!0#1| |main::1::x!0#2|) (= |goto_symex::guard#1| (= 1 |main::1::x!0#2|)) (= |goto_symex::guard#2| (= |main::1::x!0#2| 2)) (= |goto_symex::guard#3| (= |main::1::x!0#2| 3)) (= |goto_symex::guard#4| (= |main::1::x!0#2| (- 2))) (= |main::1::t!0#11| .oite0) (= |main::1::t!0#12| .oite1) (= |main::1::t!0#13| .oite2) (= |main::1::t!0#14| .oite3) (= |hifrog::fun_start!0#2| |hifrog::fun_start!0#3|) (= (not (or (not (and |hifrog::fun_end!0#3| |hifrog::fun_start!0#2|)) (not (= (- 2) |main::1::t!0#14|)))) |hifrog::?err!0#1|) (or (not |hifrog::fun_end!0#2|) (and |hifrog::fun_end!0#3| |hifrog::fun_start!0#2|))) :named part2)) ; XXX Partition: 1 (assert (! (or |hifrog::fun_start!0#1| (not |hifrog::fun_end!0#1|)) :named part1)) ; XXX Partition: 0 (assert (! (and |hifrog::?err!0#1| |hifrog::fun_start!0#1| (= |hifrog::fun_end!0#1| |hifrog::fun_start!0#2|) (= |return'!0#1| |symex::io::0|)) :named part0)) (check-sat) (get-interpolants (and i1 i2 i3 i4 part2 part1 part0) part3) opensmt-2.5.2/regression_itp/preint-options.smt2000066400000000000000000000001541445011647600220520ustar00rootroot00000000000000(set-logic QF_LRA) (set-option :produce-interpolants true) (set-option :certify-interpolants 1) (check-sat) opensmt-2.5.2/regression_itp/proof_duplicate_literals.smt2000066400000000000000000000011341445011647600241350ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-option :proof-reduce 1) ;(set-option :proof-check 1) ;(set-option :verbosity 2) (set-option :certify-interpolants 1) (set-logic QF_UF) (declare-fun a () Bool) (declare-fun b () Bool) (declare-fun c () Bool) (declare-fun d () Bool) (declare-fun e () Bool) (declare-fun f () Bool) (assert (!(not a) :named A)) (assert (!(and (or a (or a b)) (and (not c) (or e (or a b)))) :named B)) (assert (!(and (or a d e) (or a (not d) e) (or a d f) (or a (not d) f) (or a (not e) (not f) (not b) c) ) :named C)) (check-sat) (get-interpolants A B C) opensmt-2.5.2/regression_itp/run-tests.sh000077500000000000000000000043371445011647600205630ustar00rootroot00000000000000#!/bin/bash echo "This is the script for running regression tests" echo " - date: $(date '+%Y-%m-%d at %H:%M.%S')" echo " - host name $(hostname -f)" echo " - script path: $(readlink -f $0)" opensmt=../opensmt if [[ ! $# -eq 0 ]] ; then #echo 'Setting path to' $1 opensmt=$1 fi # run the interpolating version of OpenSMT opensmt=${opensmt}' -i' picky=./utils/picky.smt2 lookahead=./utils/lookahead.smt2 tmpfolder=log-$(date '+%Y-%m-%d-%H-%M-%S') mkdir ${tmpfolder} export outmod=false export errmod=false export rtmod=false export err=false for file in $(find . -name '*.smt2' |sort); do name=$(basename $file) dir=$(dirname $file) sh -c "ulimit -St 60; ${opensmt} $dir/$name > $tmpfolder/$name.out 2>$tmpfolder/$name.err.tmp" 2>/dev/null grep -v '^;' $tmpfolder/$name.err.tmp > $tmpfolder/$name.err if [ -s "$tmpfolder/$name.err" ]; then echo "stderr not empty for benchmark $file"; err=true; fi sh -c "ulimit -St 60; ${opensmt} $picky $dir/$name > $tmpfolder/$name.out 2>$tmpfolder/$name.err.tmp" 2>/dev/null grep -v '^;' $tmpfolder/$name.err.tmp > $tmpfolder/$name.err if [ -s "$tmpfolder/$name.err" ]; then echo "stderr not empty for picky benchmark $file"; err=true; fi sh -c "ulimit -St 60; ${opensmt} $lookahead $dir/$name > $tmpfolder/$name.out 2>$tmpfolder/$name.err.tmp" 2>/dev/null grep -v '^;' $tmpfolder/$name.err.tmp > $tmpfolder/$name.err if [ -s "$tmpfolder/$name.err" ]; then echo "stderr not empty for lookahead benchmark $file"; err=true; fi #diff -q ${tmpfolder}/${name}.out ${dir}/${name}.expected.out #if [ $? != 0 ]; then # echo "stdout differs for benchmark $file"; # outmod=true; # diff ${tmpfolder}/${name}.out ${dir}/${name}.expected.out #fi #diff -q ${tmpfolder}/${name}.err ${dir}/${name}.expected.err #if [ $? != 0 ]; then # echo "stderr differs for benchmark $file"; # errmod=true; # diff ${tmpfolder}/${name}.err ${dir}/${name}.expected.err #fi done #echo "Stdout differs: ${outmod}, stderr differs: ${errmod}" if [[ ${err} == true ]]; then echo "There were anomalies: check logs in ${tmpfolder}" exit 1 else rm -rf ${tmpfolder} fi opensmt-2.5.2/regression_itp/trivial-proof-A.smt2000066400000000000000000000003131445011647600220300ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-option :certify-interpolants 1) (set-logic QF_UF) (declare-fun x () Bool) (assert (! false :named A)) (assert (! x :named B)) (check-sat) (get-interpolants A B) opensmt-2.5.2/regression_itp/trivial-proof-B.smt2000066400000000000000000000003131445011647600220310ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-option :certify-interpolants 1) (set-logic QF_UF) (declare-fun x () Bool) (assert (! x :named A)) (assert (! false :named B)) (check-sat) (get-interpolants A B) opensmt-2.5.2/regression_itp/uf-itp-edge-split.smt2000066400000000000000000000010271445011647600223170ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-option :certify-interpolants 1) (set-logic QF_UF) (declare-sort U 0) (declare-fun p () Bool) (declare-fun q () Bool) (declare-fun r () Bool) (declare-fun s () U) (declare-fun u () U) (declare-fun v () U) (declare-fun x () U) (declare-fun C (Bool U) U) (assert (! (and (= x (C p u)) p) :named A1)) (assert (! (and q r) :named B1)) (assert (! (and (= u s)) :named A2)) (assert (! (and (= s (C q u)) (= v (C r u)) (not (= u v))) :named B2)) (check-sat) (get-interpolants (and A1 A2) (and B1 B2)) opensmt-2.5.2/regression_itp/uf_bug.smt2000066400000000000000000000005221445011647600203260ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-option :certify-interpolants 1) (set-logic QF_UF) (declare-sort U 0) (declare-fun e () U) (declare-fun f () U) (declare-fun g () U) (declare-const c () U) (declare-const d () U) (assert (! (= e c) :named a)) (assert (! (and (= f d) (= e f)) :named b)) (check-sat) (get-interpolants a b) (exit) opensmt-2.5.2/regression_itp/uf_duplicates.smt2000066400000000000000000000201511445011647600217060ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-option :certify-interpolants 1) (set-logic QF_UF) (declare-sort Real 0) (declare-fun .uf-not () Bool) (declare-fun ite (Bool Real Real ) Real) (declare-fun - (Real ) Real) (declare-fun * (Real Real ) Real) (declare-fun / (Real Real ) Real) (declare-fun + (Real Real ) Real) (declare-fun - (Real Real ) Real) (declare-fun < (Real Real ) Bool) (declare-fun <= (Real Real ) Bool) (declare-fun > (Real Real ) Bool) (declare-fun >= (Real Real ) Bool) (declare-fun |hifrog::fun_start!0#5| () Bool) (declare-fun |hifrog::fun_end!0#5| () Bool) (declare-fun |goto_symex::guard#3| () Bool) (declare-fun |func::a!0#4| () Real) (declare-fun |func::a!0#2| () Real) (declare-fun |func::b!0#4| () Real) (declare-fun |func::b!0#2| () Real) (declare-const 1 () Real) (declare-fun |func::$tmp::return_value!0#5| () Real) (declare-const 2 () Real) (declare-fun |func::1::m!0#16| () Real) (declare-fun |hifrog::c::unsupported_op2varsignedbv!0#0| () Real) (declare-fun uns_mod (Real Real ) Real) (declare-fun |func::1::m!0#17| () Real) (declare-fun |func::1::m!0#18| () Real) (declare-fun |func::1::m!0#19| () Real) (declare-fun |func::1::m!0#20| () Real) (declare-fun |func::1::m!0#21| () Real) (declare-fun |func::1::m!0#22| () Real) (declare-fun |func::1::m!0#23| () Real) (declare-fun |func::1::m!0#24| () Real) (declare-fun |func::1::m!0#25| () Real) (declare-fun |func::$tmp::return_value!0#7| () Real) (declare-fun |func::$tmp::return_value!0#8| () Real) (declare-fun .oite0 () Real) (declare-fun |func::#return_value!0#2| () Real) (declare-fun |hifrog::fun_start!0#4| () Bool) (declare-fun |hifrog::fun_end!0#4| () Bool) (declare-fun |goto_symex::guard#2| () Bool) (declare-fun |func::a!0#3| () Real) (declare-fun |func::a!0#1| () Real) (declare-fun |func::b!0#3| () Real) (declare-fun |func::b!0#1| () Real) (declare-fun |func::$tmp::return_value!0#1| () Real) (declare-fun |func::1::m!0#3| () Real) (declare-fun |hifrog::c::unsupported_op2varsignedbv!0#1| () Real) (declare-fun |func::1::m!0#4| () Real) (declare-fun |func::1::m!0#5| () Real) (declare-fun |func::1::m!0#6| () Real) (declare-fun |func::1::m!0#7| () Real) (declare-fun |func::1::m!0#8| () Real) (declare-fun |func::1::m!0#9| () Real) (declare-fun |func::1::m!0#10| () Real) (declare-fun |func::1::m!0#11| () Real) (declare-fun |func::1::m!0#12| () Real) (declare-fun |func::$tmp::return_value!0#3| () Real) (declare-fun |func::$tmp::return_value!0#4| () Real) (declare-fun .oite1 () Real) (declare-fun |func::#return_value!0#1| () Real) (declare-fun |hifrog::fun_start!0#3| () Bool) (declare-fun |hifrog::fun_end!0#3| () Bool) (declare-fun |hifrog::?err!0#2| () Bool) (declare-fun |main::1::a!0#2| () Real) (declare-fun |symex::nondet#0| () Real) (declare-fun |main::1::b!0#2| () Real) (declare-fun |symex::nondet#1| () Real) (declare-fun |main::1::c!0#2| () Real) (declare-fun |main::1::d!0#2| () Real) (declare-fun |main::1::p!0#2| () Real) (declare-fun |main::1::q!0#2| () Real) (declare-const -999 () Real) (declare-const 1000 () Real) (declare-fun |hifrog::fun_start!0#2| () Bool) (declare-fun |hifrog::fun_end!0#2| () Bool) (declare-fun |hifrog::fun_start!0#1| () Bool) (declare-fun |hifrog::fun_end!0#1| () Bool) (declare-fun |hifrog::?err!0#1| () Bool) (declare-fun |return'!0#1| () Real) (declare-fun |symex::io::0| () Real) ; XXX oite symbol: (0 out of 1) .oite0 (assert (!(and (or (not |goto_symex::guard#3|) (= |func::$tmp::return_value!0#5| .oite0)) (or |goto_symex::guard#3| (= |func::$tmp::return_value!0#7| .oite0))) :named a)) ; XXX oite symbol: (1 out of 1) .oite1 (assert (!(and (or (not |goto_symex::guard#2|) (= |func::$tmp::return_value!0#1| .oite1)) (or |goto_symex::guard#2| (= |func::$tmp::return_value!0#3| .oite1))) :named b)) ; XXX Partition: 4 (assert (! (and (= |func::a!0#4| |func::a!0#2|) (= |func::b!0#4| |func::b!0#2|) (= |goto_symex::guard#3| (>= (+ |func::a!0#4| |func::b!0#4|) 1)) (= |func::$tmp::return_value!0#5| (/ (+ |func::a!0#4| |func::b!0#4|) 2)) (= |hifrog::c::unsupported_op2varsignedbv!0#0| (uns_mod |func::a!0#4| |func::b!0#4|)) (= |func::1::m!0#16| (+ 1 |hifrog::c::unsupported_op2varsignedbv!0#0|)) (= |func::1::m!0#17| (+ |hifrog::c::unsupported_op2varsignedbv!0#0| |func::1::m!0#16|)) (= |func::1::m!0#18| (+ |hifrog::c::unsupported_op2varsignedbv!0#0| |func::1::m!0#17|)) (= |func::1::m!0#19| (+ |hifrog::c::unsupported_op2varsignedbv!0#0| |func::1::m!0#18|)) (= |func::1::m!0#20| (+ |hifrog::c::unsupported_op2varsignedbv!0#0| |func::1::m!0#19|)) (= |func::1::m!0#21| (+ |hifrog::c::unsupported_op2varsignedbv!0#0| |func::1::m!0#20|)) (= |func::1::m!0#22| (+ |hifrog::c::unsupported_op2varsignedbv!0#0| |func::1::m!0#21|)) (= |func::1::m!0#23| (+ |hifrog::c::unsupported_op2varsignedbv!0#0| |func::1::m!0#22|)) (= |func::1::m!0#24| (+ |hifrog::c::unsupported_op2varsignedbv!0#0| |func::1::m!0#23|)) (= |func::1::m!0#25| (+ |hifrog::c::unsupported_op2varsignedbv!0#0| |func::1::m!0#24|)) (= |func::1::m!0#25| |func::$tmp::return_value!0#7|) (= |func::$tmp::return_value!0#8| .oite0) (= |func::$tmp::return_value!0#8| |func::#return_value!0#2|) (or |hifrog::fun_start!0#5| (not |hifrog::fun_end!0#5|))) :named c)) ; XXX Partition: 3 (assert (! (and (= |func::a!0#3| |func::a!0#1|) (= |func::b!0#3| |func::b!0#1|) (= |goto_symex::guard#2| (>= (+ |func::a!0#3| |func::b!0#3|) 1)) (= |func::$tmp::return_value!0#1| (/ (+ |func::a!0#3| |func::b!0#3|) 2)) (= |hifrog::c::unsupported_op2varsignedbv!0#1| (uns_mod |func::a!0#3| |func::b!0#3|)) (= |func::1::m!0#3| (+ 1 |hifrog::c::unsupported_op2varsignedbv!0#1|)) (= |func::1::m!0#4| (+ |hifrog::c::unsupported_op2varsignedbv!0#1| |func::1::m!0#3|)) (= |func::1::m!0#5| (+ |hifrog::c::unsupported_op2varsignedbv!0#1| |func::1::m!0#4|)) (= |func::1::m!0#6| (+ |hifrog::c::unsupported_op2varsignedbv!0#1| |func::1::m!0#5|)) (= |func::1::m!0#7| (+ |hifrog::c::unsupported_op2varsignedbv!0#1| |func::1::m!0#6|)) (= |func::1::m!0#8| (+ |hifrog::c::unsupported_op2varsignedbv!0#1| |func::1::m!0#7|)) (= |func::1::m!0#9| (+ |hifrog::c::unsupported_op2varsignedbv!0#1| |func::1::m!0#8|)) (= |func::1::m!0#10| (+ |hifrog::c::unsupported_op2varsignedbv!0#1| |func::1::m!0#9|)) (= |func::1::m!0#11| (+ |hifrog::c::unsupported_op2varsignedbv!0#1| |func::1::m!0#10|)) (= |func::1::m!0#12| (+ |hifrog::c::unsupported_op2varsignedbv!0#1| |func::1::m!0#11|)) (= |func::1::m!0#12| |func::$tmp::return_value!0#3|) (= |func::$tmp::return_value!0#4| .oite1) (= |func::$tmp::return_value!0#4| |func::#return_value!0#1|) (or |hifrog::fun_start!0#4| (not |hifrog::fun_end!0#4|))) :named d)) ; XXX Partition: 2 (assert (! (and (= |main::1::a!0#2| |symex::nondet#0|) (= |main::1::b!0#2| |symex::nondet#1|) (= |main::1::a!0#2| |main::1::c!0#2|) (= |main::1::b!0#2| |main::1::d!0#2|) (= |func::a!0#1| |main::1::a!0#2|) (= |func::b!0#1| |main::1::b!0#2|) (= |func::#return_value!0#1| |main::1::p!0#2|) (= |func::a!0#2| |main::1::c!0#2|) (= |func::b!0#2| |main::1::d!0#2|) (= |func::#return_value!0#2| |main::1::q!0#2|) (= (and (and (>= |main::1::b!0#2| -999) (not (>= |main::1::b!0#2| 1000))) (and |hifrog::fun_start!0#3| (and (>= |main::1::a!0#2| -999) (not (>= |main::1::a!0#2| 1000))))) |hifrog::fun_start!0#4|) (= (and |hifrog::fun_end!0#4| (and (and (>= |main::1::b!0#2| -999) (not (>= |main::1::b!0#2| 1000))) (and |hifrog::fun_start!0#3| (and (>= |main::1::a!0#2| -999) (not (>= |main::1::a!0#2| 1000)))))) |hifrog::fun_start!0#5|) (= (not (or (not (and |hifrog::fun_end!0#5| (and |hifrog::fun_end!0#4| (and (and (>= |main::1::b!0#2| -999) (not (>= |main::1::b!0#2| 1000))) (and |hifrog::fun_start!0#3| (and (>= |main::1::a!0#2| -999) (not (>= |main::1::a!0#2| 1000)))))))) (= |main::1::p!0#2| |main::1::q!0#2|))) |hifrog::?err!0#2|) (or (not |hifrog::fun_end!0#3|) (and |hifrog::fun_end!0#5| (and |hifrog::fun_end!0#4| (and (and (>= |main::1::b!0#2| -999) (not (>= |main::1::b!0#2| 1000))) (and |hifrog::fun_start!0#3| (and (>= |main::1::a!0#2| -999) (not (>= |main::1::a!0#2| 1000))))))))) :named e)) ; XXX Partition: 1 (assert (! (or |hifrog::fun_start!0#2| (not |hifrog::fun_end!0#2|)) :named f)) ; XXX Partition: 0 (assert (! (and |hifrog::?err!0#2| |hifrog::fun_start!0#2| (= |hifrog::fun_end!0#2| |hifrog::fun_start!0#3|) (= |return'!0#1| |symex::io::0|)) :named g)) (check-sat) (get-interpolants d (and a b c e f g)) opensmt-2.5.2/regression_itp/uf_itp_problem.smt2000066400000000000000000000011201445011647600220600ustar00rootroot00000000000000(set-option :produce-interpolants true) (set-option :certify-interpolants 1) (set-logic QF_UF) (declare-sort Real 0) (declare-fun g (Real Real ) Real) (declare-fun a () Real) (declare-fun b () Real) (declare-fun c () Real) (declare-fun d () Real) (declare-fun x () Real) (declare-fun y () Real) (declare-fun k () Real) (assert (! (= x c) :named A1 )) (assert (! (= y d) :named A2 )) (assert (! (= a c) :named B1 )) (assert (! (= b d) :named B2 )) (assert (! (not (= (g x y) k)) :named A3 )) (assert (! (= (g a b) k) :named B3)) (check-sat) (get-interpolants (and A1 A2 A3) (and B1 B2 B3)) opensmt-2.5.2/regression_itp/uf_local_colors_insufficient.smt2000066400000000000000000000010221445011647600247660ustar00rootroot00000000000000(set-option :produce-interpolants 1) (set-option :certify-interpolants 1) (set-logic QF_UF) (declare-sort U 0) (declare-fun f (U U) U) (declare-fun P (U) Bool) (declare-fun x () U) (declare-fun y () U) (declare-fun r1 () U) (declare-fun r2 () U) (declare-fun a1 () U) (declare-fun a2 () U) (declare-fun b1 () U) (declare-fun b2 () U) (assert (! (and (= r1 (f a1 b1)) (= r2 (f a2 b2))) :named B)) (assert (! (and (P (f x y)) (= a1 x) (= b1 y) (= a2 x) (= b2 y) (not (= r1 r2))) :named A)) (check-sat) (get-interpolants A B) opensmt-2.5.2/regression_itp/utils/000077500000000000000000000000001445011647600174115ustar00rootroot00000000000000opensmt-2.5.2/regression_itp/utils/lookahead.smt2000066400000000000000000000000411445011647600221420ustar00rootroot00000000000000(set-option :pure-lookahead true)opensmt-2.5.2/regression_itp/utils/picky.smt2000066400000000000000000000000611445011647600213340ustar00rootroot00000000000000(set-option :picky true) (set-option :picky_w 10)opensmt-2.5.2/regression_models/000077500000000000000000000000001445011647600167405ustar00rootroot00000000000000opensmt-2.5.2/regression_models/.gitignore000066400000000000000000000000251445011647600207250ustar00rootroot00000000000000data/__pycache__ env opensmt-2.5.2/regression_models/README.md000066400000000000000000000033231445011647600202200ustar00rootroot00000000000000# Model validation regression tests OpenSMT's model validation regression test suite runs OpenSMT on model production enabled and checks the resulting models for correctness. Currently there are two systems side-by-side, one used in SMT comp and the other more easily compliable in recent OSs. The main components are - smt-comp `scrambler` used for annotating instances for model production, shared by both systems, - smt-comp `ModelValidator`, a python script that uses `pySMT` to check whether an input instance conjoined with a model simplifies to `true`, used in the smt-comp based setup - dolmen's model validation (from github), the modern variant ## Setting up This directory contains scripts for setting up the model validation environment locally. If the output produced by the scripts is not present, the system assumes that the tools are available in the path. ### Setup for smt-comp The following external packages are needed to set up the smt-comp environment. - `pip3` - `cython` To set up the environment, run ``` ./regression_models/bin/setup-env-smtcomp.sh ``` The version of pySMT to be used is give in `./regression_models/data/requirements.txt`. The ModelValidator script from smt-comp is included in the repository, in `./regression_models/data/ModelValidator.py`. ### Setup for dolmen The following external packages are needed to set up the dolmen environment. - `opam` To set up the environment, run ``` ./regression_models/bin/setup-env-dolmen.sh ``` ### Usage (smt-comp) To run the tests, run ``` ./regression_models/bin/run-tests-smtcomp.sh ``` ### Usage (dolmen) To run the tests with dolmen, run ``` ./regression_models/bin/run-tests-dolmen.sh ``` opensmt-2.5.2/regression_models/bin/000077500000000000000000000000001445011647600175105ustar00rootroot00000000000000opensmt-2.5.2/regression_models/bin/run-and-validate.sh000077500000000000000000000062311445011647600232040ustar00rootroot00000000000000#!/bin/bash function get_abs_path { echo $(cd $(dirname $1); pwd)/$(basename $1) } function runChecker { tmpin=$1 tmpout=$2 if [ x"$smtcomp" == x"true" ]; then ${checker} --smt2 ${tmpin} --model ${tmpout} \ > ${output} 2>&1 if (! $(grep "model_validator_status=VALID" ${output} >/dev/null) ); then return 1 fi else ${checker} --check-model=true -r ${tmpout} ${tmpin} \ > ${output} 2>&1 return $?; fi } SCRIPT_ROOT=$(get_abs_path $(dirname $0)) DEFAULTOUTDIR=./out/ DEFAULTPRESERVE=false usage="Usage: $0 [-h] -m ( smtcomp | dolmen ) -o -s -c [ -d ] [-p ] " while [ $# -gt 0 ]; do case $1 in -h|--help) echo "${usage}" exit 1 ;; -m|--mode) if [ x"$2" == x"smtcomp" ]; then smtcomp=true elif [ x"$2" == x"dolmen" ]; then smtcomp=false else echo "Please specify a mode, either smtcomp or dolmen" exit 1 fi ;; -o|--osmt-binary) binary=$2 ;; -s|--scrambler) scrambler=$2 ;; -c|--checker) checker=$2 ;; -d|--out-dir) outdir=$2 ;; -p|--preserve-tmp-output) preserve=$2 ;; -*) echo "Error: invalid option '$1'" exit 1 ;; *) break esac shift; shift done if [ $# == 0 ]; then echo $usage; exit 1 fi if [ -z ${binary} ]; then echo "Error: $0: no opensmt binary provided"; exit 1 exit 1 fi if [ -z ${scrambler} ]; then echo "Error: $0: no scrambler provided"; exit 1 fi if [ -z ${checker} ]; then echo "Error: $0: no checker provided"; exit 1 fi if [ -z ${outdir} ]; then outdir=${DEFAULTOUTDIR} fi if [ -z ${preserve} ]; then preserve=${DEFAULTPRESERVE} fi [ -x ${scrambler} ] || \ (echo "Scrambler not found or not executable: ${scrambler}"; exit 1) [ -x ${checker} ] || \ (echo "Checker not found or not executable: ${checker}"; exit 1) output=${outdir}/$(basename $1 .smt2).out tmpin=${TMPDIR}file.smt2 tmpout=${TMPDIR}file.rsmt2 TMPDIR=$(mktemp -d) trap "[ ${preserve} == "true" ] && (\ printf 'Left the annotated instance the model, and validation output to \n - %s\n - %s\n - %s\n' ${tmpin} ${tmpout} ${output}) \ || rm -rf ${output} ${tmpin} ${tmpout} ${TMPDIR}" EXIT mkdir -p ${outdir} ${scrambler} -seed "0" -gen-model-val true < $1 2>&1 > ${tmpin} \ | grep "ERROR: " >/dev/null && \ echo "Error parsing input file $1" && \ exit 1 sh -c "\ ulimit -St 10; ${binary} ${tmpin}" \ > ${tmpout} 2>/dev/null output=${outdir}/$(basename $1 .rsmt2).out if [[ $(grep '^sat' ${tmpout}) ]]; then runChecker ${tmpin} ${tmpout} > ${output} 2>&1 if [ ! $? -eq 0 ]; then echo "Invalid model: $1"; exit 1 fi else echo "Not shown satisfiable: $1" exit 1 fi if [[ ${preserve} == "true" ]]; then echo "Left the annotated instance and the model to ${tmpin} and ${tmpout}" echo "Left the model validation output to ${output}" fi opensmt-2.5.2/regression_models/bin/run-tests-dolmen.sh000077500000000000000000000002751445011647600232730ustar00rootroot00000000000000#!/bin/bash if [ $# != 1 ]; then echo "Usage: $0 " exit 1 fi eval $(opam env) scriptdir=$(cd $(dirname "$0"); pwd) ${scriptdir}/run-tests.sh $1 dolmen exit $? opensmt-2.5.2/regression_models/bin/run-tests-smtcomp.sh000077500000000000000000000002541445011647600234740ustar00rootroot00000000000000#!/bin/bash if [ $# != 1 ]; then echo "Usage: $0 " exit 1 fi scriptdir=$(cd $(dirname "$0"); pwd) ${scriptdir}/run-tests.sh $1 smtcomp exit $? opensmt-2.5.2/regression_models/bin/run-tests.sh000077500000000000000000000033421445011647600220150ustar00rootroot00000000000000#!/bin/bash usage="Usage: $0 (dolmen | smtcomp)" if [ $# != 2 ]; then echo $usage exit 1 fi opensmt=$1; mode=$2; scriptdir=$(cd $(dirname "$0"); pwd) echo "Locating tools for model validation" if ! [ -x "${opensmt}" ]; then echo "Opensmt ${opensmt} is not usable" exit 1 fi if [ x"$mode" == x"smtcomp" ]; then if [ -x "${scriptdir}/../env/bin/ModelValidator" ]; then modelvalidator="${scriptdir}/../env/bin/ModelValidator" elif [ -x "$(command -v ModelValidator)" ]; then modelvalidator="$(command -v ModelValidator)" else echo "Could not find usable ModelValidator" exit 1 fi elif [ x"$mode" == x"dolmen" ]; then if [ -x "${scriptdir}/../env/bin/dolmen" ]; then modelvalidator="${scriptdir}/../env/bin/dolmen" elif [ -x "$(command -v dolmen)" ]; then modelvalidator="$(command -v dolmen)" else echo "Could not find usable dolmen" exit 1 fi else echo "Specify the mode, either dolmen or smtcomp" echo $usage exit 1 fi # Model validator found echo "Using model validator $modelvalidator" if [ -x ${scriptdir}/../env/bin/scrambler ]; then scrambler=${scriptdir}/../env/bin/scrambler elif [ -x "$(command -v scrambler)" ]; then scrambler=$(command -v scrambler); else echo "Could not find usable scrambler" exit 1 fi # Scrambler is found echo "Using scrambler $scrambler" echo "Running model validation tests" errors=false for file in ${scriptdir}/../instances/*.smt2; do ${scriptdir}/run-and-validate.sh \ -m ${mode} \ -o ${opensmt} \ -s ${scrambler} \ -c ${modelvalidator} \ ${file} || errors=true done if [ $errors == "true" ]; then exit 1; fi opensmt-2.5.2/regression_models/bin/setup-env-dolmen.sh000077500000000000000000000010031445011647600232430ustar00rootroot00000000000000#!/bin/bash if [ $# != 1 ]; then echo "Usage: $0 " exit 1 fi envdir=$1 datadir=$2 mkdir -p ${envdir} mkdir -p ${envdir}/bin if [ ! -x $(which opam) ]; then echo "Please install opam first: https://opam.ocaml.org/doc/Install.html#Using-your-distribution-39-s-package-system" exit 1; fi mkdir -p ${envdir} mkdir -p ${envdir}/bin cd ${envdir} [[ -d dolmen ]] || git clone --single-branch https://github.com/Gbury/dolmen.git cd dolmen opam pin add -y . opam install -y --deps-only . make opensmt-2.5.2/regression_models/bin/setup-env-modern.sh000077500000000000000000000006251445011647600232620ustar00rootroot00000000000000#!/bin/bash scriptdir=$(cd $(dirname $0); pwd) envdir=${scriptdir}/../env datadir=${scriptdir}/../data if [ ! -x $(which opam) ]; then echo "Please install opam first: https://opam.ocaml.org/doc/Install.html#Using-your-distribution-39-s-package-system" exit 1; fi ${scriptdir}/setup-env-scrambler.sh $envdir ${scriptdir}/setup-env-dolmen.sh $envdir mkdir -p $datadir touch $datadir/ENV-MODERN opensmt-2.5.2/regression_models/bin/setup-env-pysmt.sh000077500000000000000000000004451445011647600231520ustar00rootroot00000000000000#!/bin/bash if [ $# != 2 ]; then echo "Usage: $0 " exit 1 fi envdir=$1 datadir=$2 mkdir -p ${envdir} mkdir -p ${envdir}/bin cd ${envdir} pip3 install -r ${datadir}/requirements.txt pyinstaller -F ${datadir}/ModelValidator.py cp dist/ModelValidator ${envdir}/bin opensmt-2.5.2/regression_models/bin/setup-env-scrambler.sh000077500000000000000000000004631445011647600237500ustar00rootroot00000000000000#!/bin/bash if [ $# != 1 ]; then echo "Usage: $0 " exit 1 fi envdir=$1 mkdir -p ${envdir} mkdir -p ${envdir}/bin cd ${envdir} mkdir -p src; cd src; [[ -d scrambler ]] || git clone --single-branch https://github.com/SMT-COMP/scrambler.git cd scrambler make; cp ./scrambler ${envdir}/bin opensmt-2.5.2/regression_models/bin/setup-env-smtcomp.sh000077500000000000000000000003641445011647600234600ustar00rootroot00000000000000#!/bin/bash scriptdir=$(cd $(dirname $0); pwd) envdir=${scriptdir}/../env datadir=${scriptdir}/../data ${scriptdir}/setup-env-scrambler.sh $envdir ${scriptdir}/setup-env-pysmt.sh $envdir $datadir mkdir -p $datadir touch $datadir/ENV-SMTCOMP opensmt-2.5.2/regression_models/data/000077500000000000000000000000001445011647600176515ustar00rootroot00000000000000opensmt-2.5.2/regression_models/data/ModelValidator.py000066400000000000000000000123471445011647600231400ustar00rootroot00000000000000import sys import argparse from os import path from pysmt.shortcuts import get_env from pysmt.smtlib.parser import SmtLibParser, Tokenizer from pysmt.exceptions import PysmtSyntaxError from pysmt.smtlib.utils import SmtLibModelValidationSimplifier get_env().allow_empty_var_names = True def readModel(parser, modelFile, inputFile): with open(modelFile) as script: lino = 0 for line in script: lino += 1 read_status = line.strip() if read_status != 'success': break if (read_status == "unknown"): print ("model_validator_status=UNKNOWN") print ("model_validator_error=solver_returned_unknown") sys.exit(0) if (read_status == "unsat"): status = None with open(inputFile, 'r') as infile: for line in infile: if ":status" in line: if "unsat" in line: status = "unsat" print ("model_validator_status=UNKNOWN") print ("model_validator_error=the_problem_status_is_unsatisfiable") elif "sat" in line: status = "sat" print ("model_validator_status=INVALID") print ("model_validator_error=the_problem_status_is_satisfiable") elif "unknown" in line: print ("model_validator_status=UNKNOWN") print ("model_validator_error=the_problem_status_is_unknown") status = "unknown" break # the benchmark scrambler removes the status line, in case of a # benchmark without status line we assume satisfiability if not status: print ("model_validator_status=INVALID") print ("model_validator_error=solver_returned_unsat") sys.exit(0) if (read_status != "sat"): raise PysmtSyntaxError("'sat' expected at line %d" % lino) # Return UNKNOWN if the output is only "sat" and does not contain a model model, interpretation = parser.parse_model(script) return model, interpretation def readSmtFile(parser, smtFile): with open(smtFile) as stream: script = parser.get_script(stream) formula = script.get_strict_formula() return (formula, script.get_declared_symbols()) def checkFullModel(model, interpretation, symbols): if len(model) + len(interpretation) > len(symbols): print ("model_validator_status=UNKNOWN") print ("model_validator_error=more_variables_in_model_than_input") sys.exit(0) for symbol in symbols: if symbol not in model and symbol not in interpretation: print ("model_validator_status=UNKNOWN") print ("model_validator_error=missing_model_value") sys.exit(0) def validateModel(smtFile, modelFile, inputFile): try: if not path.exists(smtFile): raise Exception("File not found: {}".format(smtFile)) if not path.exists(modelFile): raise Exception("File not found: {}".format(modelFile)) if path.getsize(modelFile) == 0: print ("model_validator_status=UNKNOWN") print ("model_validator_error=no_output") sys.exit(0) parser = SmtLibParser() (formula, symbols) = readSmtFile(parser, smtFile) model, interpretation = readModel(parser, modelFile, inputFile) checkFullModel(model, interpretation, symbols) simplifier = SmtLibModelValidationSimplifier() result = simplifier.simplify(formula.substitute(model, interpretation)) if result.is_false(): print ("model_validator_status=INVALID") print ("model_validator_error=model_evaluates_to_false") elif result.is_true(): print ("model_validator_status=VALID") print ("model_validator_error=none") print ("starexec-result=sat") else: print ("model_validator_status=UNKNOWN") print ("model_validator_error=not_full_model") except Exception as e: print ("model_validator_status=UNKNOWN") print ("model_validator_error=unhandled_exception") print ("model_validator_exception=\"{}\"".format(str(e).replace("'", "\\'").replace('"', '\\"').replace('\n',' '))) sys.exit(0) def main(): parser = argparse.ArgumentParser(description='Model validator for QF logics with bit-vectors and linear arithemetic.') parser.add_argument('--smt2', type=str, help='SMT-LIB v2 benchmark', required = True) parser.add_argument('--model', type=str, help='The full model returned by the SMT solver', required = True) args = parser.parse_args() validateModel(args.smt2, args.model, args.smt2) try: main() except Exception as e: print ("model_validator_status=UNKNOWN") print ("model_validator_error=toplevel_unhandled_exception") print ("model_validator_exception=\"{}\"".format(str(e).replace("'", "\\'").replace('"', '\\"').replace('\n',' '))) sys.exit(0) opensmt-2.5.2/regression_models/data/requirements.txt000066400000000000000000000001071445011647600231330ustar00rootroot00000000000000git+https://github.com/pysmt/pysmt.git configparser==4.0.2 pyinstaller opensmt-2.5.2/regression_models/instances/000077500000000000000000000000001445011647600207275ustar00rootroot00000000000000opensmt-2.5.2/regression_models/instances/QF_UF_anderson.1.prop1_ab_reg_max.smt2000066400000000000000000000105121445011647600276710ustar00rootroot00000000000000(set-logic QF_UF) (set-info :source | Generated by: Aman Goel (amangoel@umich.edu), Karem A. Sakallah (karem@umich.edu) Generated on: 2018-04-06 Generated by the tool Averroes 2 (successor of [1]) which implements safety property verification on hardware systems. This SMT problem belongs to a set of SMT problems generated by applying Averroes 2 to benchmarks derived from [2-5]. A total of 412 systems (345 from [2], 19 from [3], 26 from [4], 22 from [5]) were syntactically converted from their original formats (using [6, 7]), and given to Averroes 2 to perform property checking with abstraction (wide bit-vectors -> terms, wide operators -> UF) using SMT solvers [8, 9]. [1] Lee S., Sakallah K.A. (2014) Unbounded Scalable Verification Based on Approximate Property-Directed Reachability and Datapath Abstraction. In: Biere A., Bloem R. (eds) Computer Aided Verification. CAV 2014. Lecture Notes in Computer Science, vol 8559. Springer, Cham [2] http://fmv.jku.at/aiger/index.html#beem [3] http://www.cs.cmu.edu/~modelcheck/vcegar [4] http://www.cprover.org/hardware/v2c [5] http://github.com/aman-goel/verilogbench [6] http://www.clifford.at/yosys [7] http://github.com/chengyinwu/V3 [8] http://github.com/Z3Prover/z3 [9] http://github.com/SRI-CSL/yices2 id: anderson.1.prop1 query-maker: "Yices 2" query-time: 0.019000 ms query-class: abstract query-category: oneshot query-type: regular status: sat |) (set-info :license "https://creativecommons.org/licenses/by/4.0/") (set-info :category "industrial") ; (set-info :status sat) (declare-sort utt$8 0) (declare-sort utt$32 0) (declare-fun Add_32_32_32 (utt$32 utt$32 ) utt$32) (declare-fun GrEq_1_32_32 (utt$32 utt$32 ) Bool) (declare-fun y$1 () Bool) (declare-fun y$11 () Bool) (declare-fun y$13 () Bool) (declare-fun y$15 () Bool) (declare-fun y$17 () Bool) (declare-fun y$19 () Bool) (declare-fun y$21 () Bool) (declare-fun y$24 () Bool) (declare-fun y$26 () Bool) (declare-fun y$28 () Bool) (declare-fun y$3 () Bool) (declare-fun y$30 () Bool) (declare-fun y$32 () Bool) (declare-fun y$5 () Bool) (declare-fun y$7 () Bool) (declare-fun y$720 () Bool) (declare-fun y$723 () Bool) (declare-fun y$724 () Bool) (declare-fun y$743 () Bool) (declare-fun y$759 () Bool) (declare-fun y$9 () Bool) (declare-fun y$a_CS_P_0 () Bool) (declare-fun y$a_CS_P_1 () Bool) (declare-fun y$a_NCS_P_0 () Bool) (declare-fun y$a_NCS_P_1 () Bool) (declare-fun y$a_p1_P_0 () Bool) (declare-fun y$a_p1_P_1 () Bool) (declare-fun y$a_p2_P_0 () Bool) (declare-fun y$a_p2_P_1 () Bool) (declare-fun y$a_p3_P_0 () Bool) (declare-fun y$a_p3_P_1 () Bool) (declare-fun y$dve_invalid () Bool) (declare-fun y$id24 () Bool) (declare-fun y$id24_op () Bool) (declare-fun y$n0s32 () utt$32) (declare-fun y$n0s8 () utt$8) (declare-fun y$n1s32 () utt$32) (declare-fun y$n1s8 () utt$8) (declare-fun y$n2s32 () utt$32) (declare-fun y$prop () Bool) (declare-fun y$v3_19_op () utt$32) (declare-fun y$v3_20_op () utt$32) (declare-fun y$v3_21_op () utt$32) (declare-fun y$v3_22_op () Bool) (declare-fun y$v_Slot_0 () utt$8) (declare-fun y$v_Slot_1 () utt$8) (declare-fun y$v_my_place_P_0 () utt$8) (declare-fun y$v_my_place_P_1 () utt$8) (declare-fun y$v_next () utt$8) (assert (not (= y$n0s8 y$n1s8))) (assert (distinct y$n0s32 y$n1s32 y$n2s32)) (assert (= y$a_CS_P_0 (not y$1))) (assert (= y$a_CS_P_1 (not y$3))) (assert (= y$a_NCS_P_0 (not y$5))) (assert (= y$a_NCS_P_1 (not y$7))) (assert (= y$a_p1_P_0 (not y$9))) (assert (= y$a_p1_P_1 (not y$11))) (assert (= y$a_p2_P_0 (not y$13))) (assert (= y$a_p2_P_1 (not y$15))) (assert (= y$a_p3_P_0 (not y$17))) (assert (= y$a_p3_P_1 (not y$19))) (assert (= y$dve_invalid (not y$21))) (assert (= y$24 (= y$n0s8 y$v_Slot_0))) (assert (= y$26 (= y$n0s8 y$v_Slot_1))) (assert (= y$28 (= y$n0s8 y$v_my_place_P_0))) (assert (= y$30 (= y$n0s8 y$v_my_place_P_1))) (assert (= y$32 (= y$n0s8 y$v_next))) (assert (= y$prop (not y$743))) (assert (= y$v3_19_op (ite y$a_CS_P_0 y$n1s32 y$n0s32))) (assert (= y$v3_20_op (ite y$a_CS_P_1 y$n1s32 y$n0s32))) (assert (= y$v3_21_op (Add_32_32_32 y$v3_19_op y$v3_20_op))) (assert (= y$v3_22_op (GrEq_1_32_32 y$n1s32 y$v3_21_op))) (assert (= y$v3_22_op (not y$720))) (assert (= y$id24_op (and y$21 y$720))) (assert (= y$id24_op (not y$723))) (assert (= y$724 (= y$prop y$723))) (assert (= y$759 (and y$1 y$3 y$5 y$7 y$9 y$11 y$13 y$15 y$17 y$19 y$21 y$24 y$26 y$28 y$30 y$32 y$743 y$724))) (assert y$759) (check-sat) (exit) opensmt-2.5.2/regression_models/instances/declare_const_lia.smt2000066400000000000000000000002131445011647600251640ustar00rootroot00000000000000(set-logic QF_LIA) (set-info :status sat) (declare-const a Int) (declare-const b Int) (assert (= a 1)) (assert (= b 1)) (check-sat) (exit) opensmt-2.5.2/regression_models/instances/declare_const_qfuf.smt2000066400000000000000000000002431445011647600253630ustar00rootroot00000000000000(set-logic QF_UF) (set-info :status sat) (declare-sort U 0) (declare-const a U) (declare-fun f (U) U) (declare-fun x () U) (assert (= x (f a))) (check-sat) (exit) opensmt-2.5.2/regression_models/instances/different_default_sorts.smt2000066400000000000000000000003701445011647600264420ustar00rootroot00000000000000(set-option :print-success false) (set-logic QF_UF) (declare-sort x4 0) (declare-sort x1 0) (declare-fun x2 () x1) (declare-fun x6 (x4) x1) (declare-fun x3 (x1) x4) (declare-fun x5 () x4) (assert (= (x3 x2) x5)) (assert (= (x6 x5) x2)) (check-sat) opensmt-2.5.2/regression_models/instances/distinct_sat.smt2000066400000000000000000000002471445011647600242310ustar00rootroot00000000000000(set-option :print-success false) (set-logic QF_LIA) (declare-fun a () Int) (declare-fun b () Int) (declare-fun c () Int) (assert (distinct a b c)) (check-sat) (exit) opensmt-2.5.2/regression_models/instances/distinct_sat_lra.smt2000066400000000000000000000002521445011647600250630ustar00rootroot00000000000000(set-option :print-success false) (set-logic QF_LRA) (declare-fun a () Real) (declare-fun b () Real) (declare-fun c () Real) (assert (distinct a b c)) (check-sat) (exit) opensmt-2.5.2/regression_models/instances/function-application-with-rewritten-arguments.smt2000066400000000000000000000005421445011647600326620ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort u 0) (declare-fun f (u u) u) (declare-fun b () Bool) (declare-fun v6 () u) (declare-fun v5 () u) (declare-fun v4 () u) (declare-fun v3 () u) (declare-fun v1 () u) (declare-fun v2 () u) (assert (= v3 (f v5 v1))) (assert (= v2 (f v3 v3))) (assert (= v3 v6)) (assert (= b (and (= v5 v4) (= v5 v1)))) (assert b) (check-sat) opensmt-2.5.2/regression_models/instances/issue247.smt2000066400000000000000000000006131445011647600231230ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun v1 () Real) (declare-fun v2 () Real) (declare-fun v3 () Real) (declare-fun v4 () Real) (declare-fun b1 () Bool) (declare-fun b2 () Bool) (declare-fun b3 () Bool) (declare-fun b4 () Bool) (assert (= (+ v2 (ite b1 v2 v3)) v1)) (assert (= b2 (<= v4 v1))) (assert (= b3 (not b2))) (assert (= b4 (and b3 (not b1)))) (assert b4) (assert (distinct v2 v3)) (check-sat) opensmt-2.5.2/regression_models/instances/main_problem_simplifies_away.smt2000066400000000000000000000004061445011647600274470ustar00rootroot00000000000000(set-logic QF_UF) (set-info :status sat) (declare-sort U 0) (declare-fun Add (U) U) (declare-fun b () Bool) (declare-fun u () U) (declare-fun t () U) (declare-fun z () U) (assert (= t (Add u))) (assert (= b (not (= u z)))) (assert (not b)) (check-sat) (exit) opensmt-2.5.2/regression_models/instances/name_clash.smt2000066400000000000000000000001771445011647600236350ustar00rootroot00000000000000(set-logic QF_UFLRA) (declare-fun x0 () Real) (declare-fun f (Real Real) Real) (assert (distinct 0.0 (f 1.0 0.0))) (check-sat) opensmt-2.5.2/regression_models/instances/name_clash2.smt2000066400000000000000000000002031445011647600237050ustar00rootroot00000000000000(set-logic QF_UFLRA) (declare-fun r0 () Real) (declare-fun x!0 (Real Real) Real) (assert (distinct 0.0 (x!0 1.0 0.0))) (check-sat) opensmt-2.5.2/regression_models/instances/name_clash3.smt2000066400000000000000000000002351445011647600237130ustar00rootroot00000000000000(set-logic QF_UFLRA) (declare-fun r0 () Real) (declare-fun y!0 () Real) (declare-fun x!0 (Real Real) Real) (assert (distinct 0.0 (x!0 1.0 0.0))) (check-sat) opensmt-2.5.2/regression_models/instances/uflia_basic.smt2000066400000000000000000000001761445011647600240030ustar00rootroot00000000000000(set-info :status sat) (set-logic QF_UFLIA) (declare-fun x () Int) (declare-fun f (Int) Int) (assert (> x (f x))) (check-sat) opensmt-2.5.2/regression_models/instances/uflra_basic.smt2000066400000000000000000000002021445011647600240020ustar00rootroot00000000000000(set-info :status sat) (set-logic QF_UFLRA) (declare-fun x () Real) (declare-fun f (Real) Real) (assert (>= x (f x))) (check-sat) opensmt-2.5.2/regression_models/instances/uflra_printing.smt2000066400000000000000000000002071445011647600245600ustar00rootroot00000000000000(set-info :status sat) (set-logic QF_UFLRA) (declare-fun x () Real) (declare-fun f (Real) Real) (assert (= (/ 1 2) (f x))) (check-sat) opensmt-2.5.2/regression_models/instances/uflra_regression_1.smt2000066400000000000000000000001241445011647600253240ustar00rootroot00000000000000(set-logic QF_UFLRA) (declare-fun f (Real) Real) (assert (< (f 0.0) 0)) (check-sat) opensmt-2.5.2/regression_models/instances/uflra_regression_2.smt2000066400000000000000000000001521445011647600253260ustar00rootroot00000000000000(set-logic QF_UFLRA) (declare-fun f (Real) Real) (declare-fun x () Real) (assert (< 0 (f x))) (check-sat) opensmt-2.5.2/regression_models/instances/uflra_regression_3.smt2000066400000000000000000000002021445011647600253230ustar00rootroot00000000000000(set-logic QF_UFLRA) (declare-fun x (Real) Real) (assert (and (= 1.0 (x 1.0)) (> 0 (x 0.0)) (= 0.0 (x (- (x 0.0)))))) (check-sat) opensmt-2.5.2/regression_models/instances/uflra_regression_4.smt2000066400000000000000000000003751445011647600253370ustar00rootroot00000000000000(set-logic QF_UFLRA) (declare-fun f (Real) Real) (declare-fun x7 () Real) (declare-fun h (Real Real) Real) (declare-fun g (Real Real) Real) (assert (and (> 0 (f 0.0)) (> 0 (g 0.0 0.0)) (< (h 0 x7) (h 0.0 0.0)) (< (f (h 0 x7)) (h 0.0 0.0)))) (check-sat) opensmt-2.5.2/regression_models/instances/uflra_regression_5.smt2000066400000000000000000000005211445011647600253310ustar00rootroot00000000000000(set-logic QF_UFLRA) (declare-const x7 Bool) (declare-fun f (Real) Real) (declare-fun g (Real Real) Real) (declare-fun x2 () Real) (declare-fun x () Real) (assert (and (= 0 (f x2)) (= 1 (f 1.0)) (or x7 (< 0 (g 1 0.0))) (or (= x2 0) (= x (g 0.0 0.0))) (= (f 1.0) (f 0.0)) (or x7 (= (g 1.0 0.0) (- (f 1.0)))) (or x7 (= 0 x)))) (check-sat) opensmt-2.5.2/regression_models/instances/unused_function_model.smt2000066400000000000000000000003361445011647600261300ustar00rootroot00000000000000(set-logic QF_UF) ;(set-option :produce-models true) (declare-sort I 0) (declare-sort J 0) (declare-fun f (I I) Bool) (declare-fun f1 (I J) J) (declare-fun g (I I I) I) (declare-fun a () I) (check-sat) ;(get-model) (exit) opensmt-2.5.2/regression_pipe/000077500000000000000000000000001445011647600164125ustar00rootroot00000000000000opensmt-2.5.2/regression_pipe/add-instance.sh000077500000000000000000000017331445011647600213070ustar00rootroot00000000000000#!/bin/bash usage="Usage: $0 [-h] -b [instance [instance [...]]]" while [ $# -gt 0 ]; do case $1 in -h|--help) echo "${usage}" exit 1 ;; -b|--binary) osmt=$2 ;; -*) echo "Error: invalid option '$1'" exit 1 ;; *) break esac shift; shift done if [ -z ${osmt} ]; then echo "Error: opensmt not specified. Use -b " exit 1 fi echo "Adding as follows:" echo " - osmt: ${osmt} ($(date -r ${osmt}))" echo " - files: $@" echo "Is this ok?" read -p "y/N? " if [[ ${REPLY} != y ]]; then echo "Aborting." exit 1 fi while [ $# -gt 0 ]; do echo $1; if [[ -a $1 ]]; then sh -c "ulimit -St 60; cat $1 |${osmt} -p > $1.expected.out 2> $1.expected.err.tmp"; grep -v '^;' $1.expected.err.tmp > $1.expected.err; rm $1.expected.err.tmp else echo "File does not exist" fi; shift; done opensmt-2.5.2/regression_pipe/negative/000077500000000000000000000000001445011647600202145ustar00rootroot00000000000000opensmt-2.5.2/regression_pipe/negative/comment3.smt2000066400000000000000000000001751445011647600225530ustar00rootroot00000000000000(set-logic QF_LRA)(declare-fun X () Real)(assert (< 1 X)) (check-sat) (get-value (X)); comment) (assert (> 0 X))(check-sat)) opensmt-2.5.2/regression_pipe/negative/comment3.smt2.expected.err000066400000000000000000000000001445011647600251250ustar00rootroot00000000000000opensmt-2.5.2/regression_pipe/negative/comment3.smt2.expected.out000066400000000000000000000001011445011647600251460ustar00rootroot00000000000000sat ((X 2)) unsat (error "pipe reader: unbalanced parentheses") opensmt-2.5.2/regression_pipe/positive/000077500000000000000000000000001445011647600202545ustar00rootroot00000000000000opensmt-2.5.2/regression_pipe/positive/233.smt2000066400000000000000000000001261445011647600213710ustar00rootroot00000000000000(set-logic QF_LRA)(declare-fun X () Real)(assert (= 1 X)) (check-sat) (get-value (X)) opensmt-2.5.2/regression_pipe/positive/233.smt2.expected.err000066400000000000000000000000001445011647600237470ustar00rootroot00000000000000opensmt-2.5.2/regression_pipe/positive/233.smt2.expected.out000066400000000000000000000000141445011647600237730ustar00rootroot00000000000000sat ((X 1)) opensmt-2.5.2/regression_pipe/positive/comment.smt2000066400000000000000000000001451445011647600225250ustar00rootroot00000000000000(set-logic QF_LRA)(declare-fun X () Real)(assert (= 1 X)) (check-sat) (get-value (X)); comment((asse opensmt-2.5.2/regression_pipe/positive/comment.smt2.expected.err000066400000000000000000000000001445011647600251020ustar00rootroot00000000000000opensmt-2.5.2/regression_pipe/positive/comment.smt2.expected.out000066400000000000000000000000141445011647600251260ustar00rootroot00000000000000sat ((X 1)) opensmt-2.5.2/regression_pipe/positive/comment2.smt2000066400000000000000000000001741445011647600226110ustar00rootroot00000000000000(set-logic QF_LRA)(declare-fun X () Real)(assert (= 1 X)) (check-sat) (get-value (X)); comment) (assert (> 0 X))(check-sat) opensmt-2.5.2/regression_pipe/positive/comment2.smt2.expected.err000066400000000000000000000000001445011647600251640ustar00rootroot00000000000000opensmt-2.5.2/regression_pipe/positive/comment2.smt2.expected.out000066400000000000000000000000221445011647600252070ustar00rootroot00000000000000sat ((X 1)) unsat opensmt-2.5.2/regression_pipe/positive/comment4.smt2000066400000000000000000000002261445011647600226110ustar00rootroot00000000000000(set-logic QF_LRA)(declare-fun X () Real)(assert (= 1 X)) (check-sat) (get-value (X)); comment((asse (check-sat) ; Another comment (check-sat) (exit) opensmt-2.5.2/regression_pipe/positive/comment4.smt2.expected.err000066400000000000000000000000001445011647600251660ustar00rootroot00000000000000opensmt-2.5.2/regression_pipe/positive/comment4.smt2.expected.out000066400000000000000000000000241445011647600252130ustar00rootroot00000000000000sat ((X 1)) sat sat opensmt-2.5.2/regression_pipe/positive/quoted-symbol.smt2000066400000000000000000000001011445011647600236570ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun |X)| () Real) (check-sat) (exit) opensmt-2.5.2/regression_pipe/positive/quoted-symbol.smt2.expected.err000066400000000000000000000000001445011647600262440ustar00rootroot00000000000000opensmt-2.5.2/regression_pipe/positive/quoted-symbol.smt2.expected.out000066400000000000000000000000041445011647600262670ustar00rootroot00000000000000sat opensmt-2.5.2/regression_pipe/positive/quoted-symbol2.smt2000066400000000000000000000001021445011647600237420ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun |X")| () Real) (check-sat) (exit) opensmt-2.5.2/regression_pipe/positive/quoted-symbol2.smt2.expected.err000066400000000000000000000000001445011647600263260ustar00rootroot00000000000000opensmt-2.5.2/regression_pipe/positive/quoted-symbol2.smt2.expected.out000066400000000000000000000000041445011647600263510ustar00rootroot00000000000000sat opensmt-2.5.2/regression_pipe/positive/string-literal.smt2000066400000000000000000000001121445011647600240150ustar00rootroot00000000000000(set-logic QF_LRA) (set-option :foo "bar)") (get-option :foo) (check-sat) opensmt-2.5.2/regression_pipe/positive/string-literal.smt2.expected.err000066400000000000000000000000001445011647600264000ustar00rootroot00000000000000opensmt-2.5.2/regression_pipe/positive/string-literal.smt2.expected.out000066400000000000000000000000111445011647600264210ustar00rootroot00000000000000bar) sat opensmt-2.5.2/regression_pipe/positive/string-literal2.smt2000066400000000000000000000001131445011647600241000ustar00rootroot00000000000000(set-logic QF_LRA) (set-option :foo "|bar)") (get-option :foo) (check-sat) opensmt-2.5.2/regression_pipe/positive/string-literal2.smt2.expected.err000066400000000000000000000000001445011647600264620ustar00rootroot00000000000000opensmt-2.5.2/regression_pipe/positive/string-literal2.smt2.expected.out000066400000000000000000000000121445011647600265040ustar00rootroot00000000000000|bar) sat opensmt-2.5.2/regression_pipe/positive/string-literal3.smt2000066400000000000000000000001111445011647600240770ustar00rootroot00000000000000(set-logic QF_LRA) (set-option :foo "bar") (get-option :foo) (check-sat) opensmt-2.5.2/regression_pipe/positive/string-literal3.smt2.expected.err000066400000000000000000000000001445011647600264630ustar00rootroot00000000000000opensmt-2.5.2/regression_pipe/positive/string-literal3.smt2.expected.out000066400000000000000000000000101445011647600265030ustar00rootroot00000000000000bar sat opensmt-2.5.2/regression_pipe/positive/unbalanced-symbol.smt2000066400000000000000000000001161445011647600244600ustar00rootroot00000000000000(set-logic QF_LRA) (declare-fun |X)| () Real) (assert (< 1 |X)|)) (check-sat) opensmt-2.5.2/regression_pipe/positive/unbalanced-symbol.smt2.expected.err000066400000000000000000000000001445011647600270370ustar00rootroot00000000000000opensmt-2.5.2/regression_pipe/positive/unbalanced-symbol.smt2.expected.out000066400000000000000000000000041445011647600270620ustar00rootroot00000000000000sat opensmt-2.5.2/regression_pipe/run-tests.sh000077500000000000000000000033761445011647600207260ustar00rootroot00000000000000#!/bin/bash get_abs_filename() { echo "$(cd "$(dirname "$1")" && pwd)/$(basename "$1")" } usage="Usage: $0 [-h] " while [ $# -gt 0 ]; do case $1 in -h|--help) echo "${usage}" exit 1 ;; -*) echo "Error: invalid option '$1'" exit 1 ;; *) break esac shift; shift done opensmt=$1 if [ -z ${opensmt} ]; then echo "Opensmt binary not specified" exit 1 fi echo "This is the script for running regression tests" echo " - date: $(date '+%Y-%m-%d at %H:%M.%S')" echo " - host name $(hostname -f)" echo " - script path: $(get_abs_filename $0)" tmpfolder=log-$(date '+%Y-%m-%d-%H-%M-%S') mkdir ${tmpfolder} export outmod=false export errmod=false for file in $(find . -name '*.smt2' |sort); do name=$(basename $file) dir=$(dirname $file) sh -c "ulimit -St 60; cat $dir/$name |${opensmt} -p $(echo ${options}) > $tmpfolder/$name.out 2>$tmpfolder/$name.err.tmp" 2>/dev/null grep -v '^;' $tmpfolder/$name.err.tmp > $tmpfolder/$name.err diff -q ${tmpfolder}/${name}.out ${dir}/${name}.expected.out if [ $? != 0 ]; then echo "stdout differs for benchmark $file"; outmod=true; diff ${tmpfolder}/${name}.out ${dir}/${name}.expected.out fi diff -q ${tmpfolder}/${name}.err ${dir}/${name}.expected.err if [ $? != 0 ]; then echo "stderr differs for benchmark $file"; errmod=true; diff ${tmpfolder}/${name}.err ${dir}/${name}.expected.err fi done echo "Stdout differs: ${outmod}, stderr differs: ${errmod}" if [[ ${outmod} == true || ${errmod} == true ]]; then echo "There were anomalies: check logs in ${tmpfolder}" exit 1 else rm -rf ${tmpfolder} fi opensmt-2.5.2/regression_splitting/000077500000000000000000000000001445011647600174725ustar00rootroot00000000000000opensmt-2.5.2/regression_splitting/base-instances/000077500000000000000000000000001445011647600223715ustar00rootroot00000000000000opensmt-2.5.2/regression_splitting/base-instances/init_unsat.smt2.bz2000066400000000000000000000060251445011647600260540ustar00rootroot00000000000000BZh91AY&SYî´Oœ ÿ€|Ð{ÿ÷õ<¿ïßd` %÷£¹³I5«ãw€2;2$›b”@A¦¦L€DÊ42£C@Ј™‰F¥~¢h@æ0`0z©M§ªi d2iˆÓOI¦M`&0Bh DÔf¡ 4hmK @PO÷Ü¿‡^þMÝ]‡§nîñ*Öµ­jõÝ}ÝÝŒ¥UU±÷µI?À‡„¶üiª®D„®’¦Bî)ZVÞ¡ê "Ýõ¸ @èû :¾î14™L”`ý’A³&Å&Q‘&EgQm'ˆ±“¦/|{s•¥+‘{›u`¹6µ«œ3.h\Üž(&ö^%!]‡h«¸º§²½÷íôÂ6%¢LùM4x{9½Æ¡ãi‰†ïžv"q }:9Éc‚bÆíu¢ KA@ô)æEj =ˆòÚ«&œé“¶ âTw‚rVí£ îæÆ¢Ž5ø:á%åI §[T„–€œq@=¢†ûRÝhDã9$«ZKÞöµ€¨âãÒÝÛòÂf–Ђu€t‚ÔéòéÎî¯é¾zÕ´À÷Lö8G dŠ]ý}QY™^}'wºä‘G<ÍqMì @%P‰IÍ€”-2³FFÀ³®’¨èÔu}µ`”©é:=ë;ÞÁ¤ýlÖ §8¼éB ÓVŽ×m9ÞòúÑQЄïøqAh/m‚O<öz`q#E:ÙÂbCVĹL‡>j™÷:CY‚JÒ5”p†ŽŒ›m‡`Ǹó*K;ÐÛ‰3åy xƒA–î={(Šº‰~QŸ}goG åNðܤÛÄ…Á`AÅïè‚W½EDô`ճԠР ß°=yÏ``˜‡½wÖr€—æìW¢ VÞ\`ÀzM‰žó›Ô"ªª*¬ßjßK½rµÔõaB$FЭ8´C›rs× Èô€ho:A{Eí·YÅÍø¾¼i8 €wwR—3Jâcé¡„â+Fi¢¿.üõöxú¿KXN¾J¿!MçÅ(«~ø«8Y/Œ±Å˾~ æ”Õ®©~³î&ùBˆMï !6̹,qötI$Š6Ib@øóʆoI3:ÇfX°¢|ÀNîuÉ—@S…¤ÄSÞŸ=lˆ™Ü£Ç@7 “\Í ÎË1;‰ƒycØÔUÍ„7½ZŒN))ppꨥÈðÆø½ó)^¨2›sÑØi%Ä«3©ÚÅ­g~+=ݵ}Ù™™™™™“™«‰HJBfcë×,˜>¤ÝõÓ笿~ü§.Åç›Ç¾_«¯³øZ«oä¡5ˆ²j6 š5L‹2¢+LÖ © h­U_Ä­eªÚkªÖëÌ€1Û¿ÔÏtòáwãu1ŒŽ—TW‡å]™–Jm›Äð5 `áÁJZ ¶·ªªªª«+' 0߬÷U$ª À '‰‡dCYC¹Â†^Y:ä«á ý$,,^´ —"dAq¡Ä  Tˆ&ˆz+˜y\„ü\wrO(U.H[|pÕ€Q«YÍ!ÀÐEÝŒ-‘{‰'‰FØ0PBø*`ÈXCk·Œä05‡m¸³À‰á,úò"”­Ò[]#¦º÷ˆ9771S•-3{ÿ¸DpÀ$»&^?c]-ó“3€q}z§z®Eä¬S×ÞÞ)¨î?ræô8˜ PÒD=µ6¬×pLIƒµ‚ÎXPOïËš9;O ”buÆÕr82“»‹ÃœöZÊx‹áõ–qqÙg°]<ó8m†êÀÆ$¿"ÞCcò$¼ÒYI¸tÝp)Ü™‡x)qœ8aòWRµO8Ê0if½·{àµ@lÉ*¨´?%F.^¤@:S\\ËÃÔ-ÉEå¨iQ*Ì>ÞÈ:ƒ½mPÐtˆ»w—œBrYU• “f3Q\ @š îþ}ù÷õ¦?®Ápopensmt-2.5.2/regression_splitting/base-instances/iso_brn164.smt2.bz2000066400000000000000000000106171445011647600255670ustar00rootroot00000000000000BZh91AY&SYXdåµ _€|Pcÿò "¿ïÿå`ž÷¾Ÿ}ÖŒñVè«ï-óÕ&‡ÖN©²RóäïñïœÐͶ1Ù·ƒ90´]ËÜv÷›fìѾ( (!šI =L0&ÀJhЈ’R=L¦#À4§´’aª('ª’JhÄÐÉ h21M ¡©dÚšb“M¦¦Ôi¡ I²&¡#MHTÐÐÐLŒƒM6ª»òŦ™›4Ù¤eY+ë×ëô».~}ADQ]í[šüÜê±´k–¸à4ÚHȧ¼#A£N;[•@ï8‚·tfÿ^¡ÓÔT*©•E*’¨*Ð0Ù¤jeÞæ}ò[ŸåËÈ$¯À¦|!ч–:&žß/eŽ#†^:¨íÀ†ÛAa7.¼ILÏ…aç¢g´x™ó±§ ¦ ‘9dtnäw‘¨—ž–x@â,Ñ’9… èÑìP”hö(N¡:(OPöÈ<äB‚.<˜ÐŒ s 4@äŽhÊG#áò‡E3žŽÑÚ,ãÅeŠŒ£<åøó #ʼnΘ@äŽ"<6Ql¢7_rO 9„˜@äx@匼Íj"!(ØtqËQç$­u1ÚÊwxˆìžyAÞW^•õ{¿{ bŠ$îõÄ å~D ¢6Ü‚’KO΂¬«OC*Ë«—)‚‹ºuº®h¶ªXÑ¢—jä¥%Il–¥)-%²Z’Ô’R–’Ù-JRXD‚"2@ºPX)<çÇÇÆûì‹.+’ï7ѬWJâÚK¦àP.Š ¡’™JÀÞ|Ÿ%W¿®sçÓÕÚuI%J…I$®¶©%´©q%z¥IL:zw{Ý¥ÝR§··wmw™™xó;Îns‹œçx’«BT©R_ôÀÍõ~˜ô;kRk‡aß{ß Ñš­ò‹.Þ©QÝœ·Ž1OWÓ°^MSaUbÔó‹š:з̛"ŒÎRÙ¢÷lqîÜÒÂo9Ämšï#x£Ï »yß%;åéfzôîî £»å£}Vo•Î¹Þ}ñ±9HÈß2PáåÁk=† žéºNeé$Ë}®ÌιˆêÀvl25@×P ×,¨)(h;£I%Àr\Ép%À9º¶Ý_EÛœçBI$HUDUUV‚ˆ}ÿïü º½D©¾Å²TDá÷^Mæ*û³&¯¶2«­ž2¨¤‹š¥èªD/Y^Ô‹íÕ):ªíö­„íoq‰7…ß+ˆ…y\I§âõjHŽÜˆíÉ=1äÊ}ù©'á2WÇ ›ß¾|‚|³ rI9"‹Ì‹Y½R¼î©wQÄöäY5J—2{`‡fóÎW¿zßQóÁIó'Vµ£w­h2·#™gšŠv¤Qs"‹©žôY.ùñ‰ßu~®°óóUKH‘=9˜L3ÅE;R(¼È¡òd“ÔÏÇùŽ1Ãæ§à4úò;ì•4U»uÙ¸o‘ñDjí陽ü»©×Ì{-; ;߬ÌÞ¹=9PAõóÙû,Åø"ñYx¢"¬¿•JyÏqC^žî=ë"ËÇœÜsÉKdé'LÇÏŸ3$ÎÔÕ³2\÷#11ëÝK{ˆ:x/kÞ»C11­êF71{KG>wV1ÉáÈ÷Î Dî[ÔC0bËìùê†0ò!ÈeQ$àÃßË:ßY†¯ß0³â÷$Æ/ÂíoÔðÛ®ÈÂq"dbcÜP窓™½hºúlÇôÙoÖü5/ª¨ƒ½ùï+¼ü鳓÷³0¢öÒOrŒöÛ&þÍŒùU©ýy }œf¥ç;% Ù¹$äÉ'¹ó5±ýüæŽì™8Ç“$±äȹóZ&~kTß"¸pó‘ÜíŸ,©Ü‹v]ȼñÕR“š¥ÝÔœ9ÍE:R(º‘CÔÉà{pn|ï#Ìîaç•z&~kGÍ“ßW·×íõû}>¿JJwI%˜ "f'fÙ:„ó”øpy¾s”kg8Q"4«ÑxR‘&Ñ„ˆB$X„"¢Iù$ÖQ=G;Û«›|µ;•s-ç¿´=Ѐ² Ù¾»¶U_u²ªIz]f»ž½z¤¡'t’HL‚8ñZtÖ:\ymqm¬U9j£²N,àiÎ(.Œ+”[*‰:Š:!B\UÓð‹®á•3o»õõôˆwf†fLä=¾çzÔ³6ôï;Úï}z¤¡'t’IpѰѱÇpqÇ,CŽAAWÕ=ÅÊLË!¥(nÔVTUçTHûŽjÞeÔºÞ u™v]­)‡õëÓ°Ìϳœ#—pí;–f}»ï{óÏ<õIBNé$¶'ÛðÙgt‘J„!"´çI*Kë1•Dœ…âª&**,.ÇÙ¼!åÇT‹+‹JÛÃÂ30ÌÉ–ë2óëè,ãåpZ+»T Ž8]zþ,\&§E÷•È£DYÉ(d’!|4b,š¥E"ôÈ{Å–[¥%ѼF¤­ß1qM]²Œ˜mº«‰—æùeÚëZÙ›ê§4Óßy±þÿ¿åþ ü¢Á”P"}â0 "IÖªû(x Çóøé¦Æši¦›§Nœpb)¦±ŒcÆ1ŒcÆ1Œc«V®5·›Ä×Lm|Ås²“9s‘Ò@Òt”ÎöTÒ˜—)\¬I‰s”Ä  Πˆâˆ„¢ -îóðÆî1±àß||í÷Nöª&kI•tó *Š9»²I²í-Ì%¥+SSBZ½R¼7œ*Þ!æÞµ®R§Ü-Û«‘KÔUV»IBÇ…q“wµ5KÉû1ô73Þ?ˆ»»VÓVq)œ™»Ëm·5iUͳâ²ñ¶Ý;jÕÌ|B¢ñæ6Û&í5s¡PÝÞ+š–¬e;·ñ$H]ÜÌÌÈ2¤‡’“•(…TNªŠ’†`.]Ùµut&©4›Nr(‰.¹.ÇWI."(» c’®ÁÑL)D ̘"Z((¢"ƒ‘«•P’欥—F®[q46Ò(c˜Hc’‘@âI(mŽ(’Û„Åsm’!,¬(E̸¹,e™vÀ¹…wrÌÁ–)b(³-&PÐ…RX‚#0©H ¶2Å1-,L5ª¼E-„,­Q† ˆ¢‚˜"š€[3‰ÛÄ+}_}ÖÞú®ê¶íã§×Ü|qãuÕø÷Êã׎ßÞžn¸Û¦Þ8éñ“\ôéíÍíJ ¾ê:£M²åÞ¾=¾.ûµÞ«oO}׎ß<î¸Ûãoe PX,ãÆi†_~nõ "É!)ã%UÆKHx›IÄ'i¤8À¦h2ÙC M*ÃL)!¡ïšÛm¶Ûm¶Ûw mÌÛ•¥CcÂt™·å^ù^mÎ×'og3™ošª{4ðø4;ÆdÂ’_‹é_\KæøšÃÁ’[À%)™¾Õ;ÖÒ̶“ÌIÓê*¹J»³·UzÊÚ¤ÒÖd½»§•QS$¹K´èån]³nË»fß9'zÛé]»‘UtV]LÊA•Ui½¼ÎõÎWpËÛçza¥.*›¶LÌ:ªã}í\ó™›{µ¼ˆJ!G߈ûý$þþßûþ]ýÌý’¿—¯¤¡ö?à'ŸvõôûûŠ¹¾BKxÞì¹–ÊíM§Jƒg Så¾ xè$„Ѿûîž™<ô‰ä‡O /ÄåQ9$a…ã15VXñÄ^H'FV`©«(0Xa–Ò?ÔýóVs}ëíü«oç'MÏ£ÀÌÉ€‰sÕæw“”ì7] +º)ž‡hf!ëó ÑÓg sS;ï6pâ®ÎgtÞQYmþá$îáÃOof©™*ªQXæë~½zÍùèXpá«œ8]Š{4J#M4Ñæ)Õi¦šm∕¨™©ÓM4½€ÝZiFšI¨NÍVº÷Úô}ß9Þï¸w%˜3S‘ëóZŒP4Uó“[î”-4†UÙ߯,Ó} Eª²›HEªÄ†Å°†ªÄË%Pš«5ˆMªÄ†Š¢¥,[J2J‚1©M“Tl3b©W\÷]ÜW{tÂN– Þèé€ë|5J*’M×q@ìñD¡7±î(í„LXöú5 <×íöÞyS:zPmÊDÎÐmHi¦”Ä;†f Ä2lÖšišƒlÌ`ç %»TELÏy+œÞäê/Ìòq˜U’1)Ä·YÜ[q²Ð÷wÆ(ä=D<<<Ï'½Îoƒ·tÍ©4¦Å©±™cX–Ka5-‚¢%1¶RR6F„›H)HŠDÃŽ9§4/3‡‡‡J! 眹ç9;åÉîŠVFÏ£(sÑú{ƒvcªœLʈ5 \ôéW®€ùƒ˜a‡Ž]Ì€õc–Yg. ‹›,²Ë-Žn.æÍ–Ye±Ç6åÍÉcÐìpsqdòÍÜƇ+x³:!ûáëö ˆ€Æòfû€7yUS9™Ž m7T­QwvòŒºo ",ƒX¡FIYaC¡™A Ì2-$ŒAQQR‰›ó×;õë~¸xa¦ž“°iÁ k•n¹œåG¢¾jip±ŒôôÍ ôÊGä’ædsû>æWH”iÃÓÓ*ÉIµDJ%è4»Fíi¦šl£.gT’ê“$ÓFƒv`Y¢4Ór1 S3Íæ–fóWwªLÍoŽÀ3wO¬ì+¢NÙ ßy¼½Ö÷¹Ù“kWRªÛª’ƒUÓn®û™În]»™‰a%f)’Y²¦6ÊJIbfa2‚ReL”D â±e’iÑž‰{ÛÏ<²Š.­^]rùÎsžÏn­¾UóEÍ$m-ãÇò,jÒ),F'18 MÍÌç…fõ»KNonùˆ„¡ók2EWp=Ü„o!èfµ4Pˆ%¬³€¬ÂÑ…7ITÎêfo®¼ç9æDG9—|9x¨+˜aÃ83oÞ^Fä’B2'#šÖµ!¾7®)`ÌÖG®r"8³2ñÝ–Lf]Ý”ààÌ6õÃ2ÄXY‚„#W„ oO3[—¥y˜‹â‡Œéãz5̘Šeó;xðÝeVÏ ¼ªÃ ¤¨¡¶$Æ6å1Œ¤RrûÏ:ûsÉß5z­sq\ʽÅÕV¹ÀßK""F`l"íÌ4Q"‹”ckfÌ)«œÎnbËÌðó"ˆpK¾s-‹˜gpîqç”øU+DD<<îbÖm%½ª™ä›Î^b…nô³2’„ÒIe¸;8ÎÃ3’¼¨6Q£6X!4a½¤–¹)bË2‘ˆ&íÛ‰žy~dôžT“Æœ±ŒnfXÆ7*XÆ73$ù7yÛîtÝÕ'““æñf:¼ãÛÝu»´4 fg§È"®Ð÷(3$£°2ŒÆe™fY–e™fY–e˜Ò¬Ë2̳,Ë2̲2̳U™fY–e™fY–e™fY*̳,Ë2̳,Ë2̳,Æ•fY–e™fY–e™fY–QJ³U˜Ò¬‹6²,ÚÈÙU"ͬ‹6³U˜Ò¬Æ›Y›d*efVef,ª™Y•™Y•™Y–e™Y–edlª™Y•™YŠÌ¬TÃ0Ì3+2 ™Y•™Y•™fY–e™f4«2̬Ë2³+2̳,Ë2ȳk2̳,Ê̳,…HTË2Ìiµ™fY ™fY–e™fYƒ2ŒÃ0Ì3 Ã0Ì3 Ã0þ?ÆY’˜ôEAáËåçÔ  ¨xúf¯ãåõû·eôòíÛóòòëÍA@ÏD7lC˜"‚qù¡Àùtâ¯0dìÞÞkûë˳¸ý·}wí ×g/nHjÇ.½z—\((‡X § pϦ€¢”(m5ï×=⢜û~ÜÀE9ðn tÇ×[ÕÕ7p÷`³VÞñAqBÈ«t oí«y€° Ï íüV±ˆµ£.‡r‹¹"œ(HA‚¾ä€opensmt-2.5.2/regression_splitting/base-instances/p2-zenonumeric_s6.smt2.bz2000066400000000000000000000227141445011647600271670ustar00rootroot00000000000000BZh91AY&SYv&ç5©ß€@P{ÿ÷96=¿ÿßå`>_yÀǽ ß{ |êÇoh (>íØúJ 6zLÑ€ óîꧭŽr«ë‡Ð­ ùä¨>÷’2ËÞ }ï¢ï}>µ—¾«ëÖ}ð§¯Yîʾùð^ß}÷mo P{¾´ï%PÏ_aïR*nöϤ©ù£ R• €4§‚"R•IúdhЧ½QD”ý5Q dd4Чê‰RjjŸêS@hB¤#HÔôÉ’'¤biÍM4¢DeEI£ ¦ŒC¡Uù÷çß¿yç7žyçŸ~ùçß<ýWð~e!ƒôÔ¢Š(¿ß2JJJJlh ›ôa3o–^ð;ªõ¬»Wjâ%½ÕõWá«ê¯u{©oÍkì×5Íseùûµò×5Í—5Õ~¿-õê2÷WÞµêåõ±—ª¾*Y•r®UõWÑ-õWº¾ª÷WßàÌ–ø«´æ¹¯¾ì}5ø5Ís]º€|î„|-{m¯Žº?·¦¿1¯ÅZ2bø~rÜWÎýÛ˜~þp¾°Ú•ë–[€í ‘ì³@}´4¶€s↖Ñ[P ¤€çjãEÔ'œå÷¤;ˆåJùÙ–å×Nê=õ§œG¿¼Ïë|Ÿ8‡ºû ýßcïë|‚Ð{ÓìÚ‡[òsAÃçxjÙ=”´ûœSÝ|ž¸z}ž¸ž~sˆ÷‡ÛÛˆ÷‡wËHu‡DlcÇ°uóðøÀ9«ŒÓ\®aéŠf>s8§0=¾\Oe9¡Õöà¶ZŽ˜u¨óμGßœœCÍù8÷Ǿ uÌâZ]q-C­µO¼àuÅ9×Õ<ëƒhdYøƒ¾ a÷¼5CégYˆ.çS©ö642ëå ÌÔà Sžc Ÿ#–†BçÙ>Z-òS«E¹#Üup[ }F©Äî–Ú,'{š,WØ×ap®§A€ê:Éëq`sìu&ƒuX ’¾Fƒ|•î4¥%:œ0ÊR瘺¥ÔÛP-9j—ȨÔ. <—AŽáØнÀu’°C¨;Dö:ï0Iê_‘©Ô& ÈvÑ%²rtISälj={)òÐ#ɸ4ä©ò :€}Ÿ·;ƒ¨ íöÐ! ƒ–ùÎõÖ:òî^çG˜àÇØä”1ò¬ÉGÈÚù(÷²'S‚^A‰$u#©Sí©ò4žbiöäj]Àõ#¡˜00g7̺^Båä.'Ë>ÂåÈ\„Û ;€:€(ÈG.#çfêu u±Ê€=ëlÌGñ9–%}¶Pî~în`~9ùGeh A‰B%•b €"" E)@¤A(D¤JQZQiAH•R…¤¤@ˆV$…¡J˜!ª©…ŒH’12±’)…f ‹0°È™ €TÂ)"LŒˆ`Tˆa™Dde…‘fH JV‚ i¤¥3#1‰‹0¨©2H°ŠË¿•wwóåÝUßÊø}^÷ãMm¶Û’T’I$’I$’J’I"à²û°ÛRkîîé$’}ªY$™îﯭ¶I$2dôõý9ÁÞ91‹óöºïN8¸¼½7wwwwww‚åkmç½¾ô’I$’}ÁüŽOËŸ›ìÄ–_Íûçç㿯Ÿžîï|þJÊÚù¯½€O 2‹5X»´Ûu¡ ÝÝ?Ù]]“7rÙµ¾­V¬Éwi¶ëCA¹™~€)ؤBmååúË««««¨ë«oÙÁ'éú6Ûmÿ‚I'm¶É$¿€À8?ðÐD~ß?£üð //Ùú¿/?Ey±¾æèh­cst4±»cjˆlùgkÁ4V±¹ºXݱ±QÓ`ºl_)§º+Ȇä16n†œâ¸†àhblÝ Š.×”WÜ M›¡§(¦!¸®&ÛP CgÓ;^ ¢µÆÆÁtÚ€bž9Q¥oÎx{ŸŸZöûž¼£­w½»îp¶Îç¬Í&æ·C9»¸øx!ȱÜcié9ŒP?$NÊ>µ0˜æs×”užSvpC…· 0¤9¢÷C9»¬g\c¤Hr;®¦·-÷ Ìæ1@({Ó¼Hú×°˜âž~=”÷Ó¤Ý÷8[sU™â£LtFn†swqåu¶42Gxè×W Û’ò.÷j$æA@aÅŽ9á:GÖ½„ÇžžG*j&ï¸!ÂÛšV/ö³PsFn†swqåu[ƒC$wŽë«…®¯ ˜·0Š:§aÔ¢Zpã@Fo’Û°uöNØZU†Ôl/UÜÝîì]57ïyã_U¹ÇvNî_$I©!@ah‰6ÒÜNŸ<tW|éØŽåÖËã–jñö¶A•Jäæùˆ÷KÇ÷¿¼$é0aÀÀ“}þ%NprG1ö·ørágP¿‹æ¦ÇÜ `ǘ<Ý-Ê­%A‹JihI¦s䈩#îÜž.Ë×±ç¼ñ¥ƒny<—–÷äžS|—ØÝI¤ÒÕÚ¸’Buu«ôÉ=‰45¤‡Äa&y/{æIõºD>?4ZËÅÍ•_Dm¡Dz Hù!¤a)}ÕóQóò}ò:—Än"F$¼„vMj¥‘qÕæ¾JU"v§j¤šÕz-8«‰_žMo<]d«£ðñ^_g‡µXw»Þ¶ß’I$¤’l’N’hÙÞFZØíÉ$‘Ê’FÛn›q$•$¤’G.I$¦U×(ûsmr݉¹4ÈõÉ#m·$’I$’I$’I'‚\’’I'«çÏŠ|ôr Ñî @;ƒÉØ°lŸdÉ9f|ï@y(¾B÷ ÉN¥sÌÙOwùÞ s˜îà=uˆÖÉ^ù‚쯻‚û)ö;ö©O%>Ê{ì§ÉäBr’û첿 =”öSÙO`=„öØOeöØ`}€öS'첞Êl°žÂ{#ì¢?$ä ¦Êû(¾Â¯²"}€%vÈWä(ý€2Gìùˆù’È{ Ül’7¡oÍ"Uf}v‰‘øç ‰æ†2ÚöP@mq–`Øž:D±ß)ÝõÃweön 1`>. 1!ÎV€ ðp‹Ç€}ß—»öp5©1ÁïV=kàõ%/w'ÄÙ/¿XDóßsª¸‡¾û×¼ó¾²»ë€|ójÕ>È¿bààWƒŸpsÏí¤õ·Ù÷~Ì“º4œAú¦½Ûª,'áÎsœ¦ovOOª›ëmµÆNÓñ.h TXKÏlíì$ë„ù\~™/pÝÝÝÇ1kRîI$’I$’I$’uó}nî /SXº’ÅÔ¥,{er‡Uù¶8UÞ‹ƒ9‚¶k'™åÓöE™´B®œ5–u•j,7u™„æff_IîÕ9Š&É#NnôÃtîfv:ÆdÄP†Ö'Mî•aÆ8lw[œ“ç6Ò6†Dƒ§Nd¤òºõuìC&”{´á´çNá†îVñ‘{œ•bÌ°LLH$¤ÄĤÄı"K겪¿ÃôÕ{ÇÏïÞÿWÃßü¿–ãâòöol¾ßg¼{N—³§C§ggNÆÿR9rI$Dï#ñÝSºË©u|QÓ"أѤƒe²Ûi‚h6ÚM´Ëm`Á`R{¤½sv„’AÜþ*Þ_нêCÜï/:þTI[l˜’K¤•ó¶Hò>Ñ è\×|¥„×8Þ£„“¤á<:íFbÇ—*3)}ÛsF"¦Ó7m݌ڟTŒ@‡ µ€õ… ÿ7 sHçHy&\‚&€ùò|¨>I¿pMŸ:AD4¢8!†G!ç)ç=ÔˆÝ÷s{{ùôÉ$úª¾.í¾õ,w—CvïY”ºI%x’êîûWz^&XqlJ;ŒC%Ön+¶ÒMµ1ܲ×mÈPeÈâ›h¶’XeÈö²õæ(j¹[W àË$Š±lu"dn%ÂÓ`âpÆ™d”S\e°Ø™„9ͬ6’÷½Ë™°³{3zß^zõ¹ëYy–¦éÈ—–Ó€KUîµ×{½w›¦\ÌÒíÛ½+  e( e( `)H9n`f&Ì-,0´„5˜e*Ýûo½½ìîo½xìfÀ`6Û|ç™­Þe*–LÂe”4HГòùÍæoÓœ!* ¹‡9Çœ£*”,Ì1@9{›Öo”ܹÃ1ÎsxðÌ@2ÅÍæ+9'9335•mÌ›™ŒæUU¥ ffffffs&f›wfq#œ€[ÈŽMÜÝà rùóz·xëɾ½7h×]uï{ÞÕi0 ƒ&*7¬¬»ã~ÝöjìíqÀgs™Í8o2¶ª@‹wvÄCÝM¯®†½h”ïÒN$ÿE*}÷½ïz¦_Á¿*yϻ߷=Ò=Ðz19ŽFêS Ù™íËçk÷|Ýíç‡+±Eϱ8> AÑèf mŵîH'RÏI*¥I¥Äõë¬C-m»$’Im¼®Ô­ÓNfD²á§3"YpŒ¹–ÚíK¹™n*!ÄûÑÚÊ+†vóÌC–;æîê>J'aÉr;òûÞV¬w_kñò¾MšBÌ ®¼xk’€o“q¤–d¢’J6Òâ $òÚ,‘¤RI$:ñnKŠÚí ¶ l™%1È”î\élÖ÷zýÁÎúO¹ÆÙC $6¦ ˜ÒIРIx¼É9Îw}óh©›yo%––Ú™Žç9pª£'Œ{ÞwläuØn+FÉÍÌΈ(1kØ!•ÉƜˋ3 •«ÝåºnÛÀåIQÎkØ9J˼êÕs-2‡jjƒÂÜÊÔlzù½[»¶š(—wpAd"s·”[&Íh’ÃLÍPˆpÂ%p ˆ\/œ—7?MfXs+ÏÉ /~!•'ß{ÞóAÝlʧu—^º“²ºNâü'+n¬3)¥‰!62Á ›M6(”›mA]3-OÞ}¯,ï}Øäù¦K§†Ìñ–Ú¶Þˆ-½<°ÌµkZ%,h•­¸Û¸“m¤› ’ fHÎÖ,t©ÖWøpž™=&Ü’F{Ÿ´£¸hn×kÇǵ¼Ç‰5‰8‚™˜ËeÊL †äÍÜÛ¸‚71rÖdÄ,U”ƒ‚Z*Ñ ³‰æS†¢‚~jü)"Ãá„’xÎíë#)Y™ßV€ œ±¥£DCíßÞ»ºçO9ÑÑtaÔenîÝuïp$“Ææf]fldFj)Õu99RaÓ2Ì}·y©…fëº`glíë‚ÈQ縒J–Ô2+§KÄ–Zke¸Ä ÝÝÝŸæõk2¶V¶ç$ë¿wnc2dÙŲРm·vÛ½ëÞ7t¶ÛRI0LL6· r/9&m 5ºi2²D[-Ò`±KhhKµ&VÊ Ýx·§-zÎ9[=÷{É}ÖÜ*I÷Þ÷ª÷¢OÖ§q iÈ€d@aw²ÜöîYßw;›ß? }D÷æ0Áˆ/$’U—Z °Ó8ä…)9)1T%–*¥R¥PµAR¨Z ©ZÁªRRµƒT©XÃméÝÑ£kV3µc^[ÑÈ^g ß› òI·M¾÷ÝgÇ\¨ÈJ¿˜\# v+ª"¸ð2ÜEÇ (¨€-Sn0bã­‡¹ss´nînivá3bfá²äl,ÂÁaS·ÕüH/ƒŒ”Ø`ðõY—›¾%ÉŒ€Äm¶·Ša@Žp/¿%Âm®AâD¤€X–7®§]:ÌÊR `´[c.fb•™ˆ²ä¶î`)Ï¥ãt-4ÑwÐa&§ 8ÖeqãsY–îÒMÝ•M%RNr1¹¼³™pÚå‹jŠ«m´TÜ™–îbÅNL².2s’wß_cÞÞßzØb.÷w­Õ‹@Û$!ÔœäëÃs»wrÌMÜó%ÞëO[•‘+nnˆ'Ë9Ѷ.ð9›p‚3,@haKOÓ·§ h¿§ÉŸ7öl©$ûïy­Òå ù^»y|W¦™w]gÊùÅc&ÜëÊyáÄ“+å$æñ&Þö»âL12&’ÆÚ®ÆÛL¹¦dl¥]ÈÆ`6É•9‰Ós,µ;qˆŽ`™˜Æ#™31Œ<Ìb À˜9“(£ LfL‚ŒTM­µ›`£çGFš†–4( ˆ¯»½ûÝ6Üo#*Û.{‚ìhÚ‡†w†Ü+r;Ç:ëv[oXËhʽ¦f³31°ÈE$’E" $– ׎ºvëÏÍü2€K°Ýr0ÆŠNrö37˜‰wtÌIXŸ‘… òèÌrÆ”ˆ³2^ <àãß7‚IŠrpðI$”Š@âyÀ™vïed|¹Õb¶ji%Q¹¥ ¦ÉemSI¶cv¾Ý熔5"O,ÙIm66H'ò~(½ô6ÿð~$ɆH$’O¾õÏ ±TQê¤{ë3*XÛt÷Á4[LI$ÝïwÙ™™s}䟯8/8~^|a†cÀŸ±\²`Âs‘VÙm=ovHjÌÍÝË™i«R³Š¥eMÅR—18êÄ­ÍÙ+Å©[»²fDž·fîÉŠÆë¬ÅcuÖb¹îùpO¾¬û¿/’U´ç$ɽêJ>E¹1ÈÛ‘Ö°è»Vu–@oF¥#Ì%3V؋Š©ao%W(x¤äLŒ1È£/#%¸èjÊ›.FKq‰ ¥ØâI#²7 -¸"‘ºÂµ³k ÚØ´6’µº”H¦Âh6ÛmÐÛ ¤DÞ‚±M íºçrfbpéN†÷—9Ϻ÷I²·fHšHÉm²–íLZR}|ïÁ­ÜâÀ›ÝœI”e—:»m É*­±Ë/³­lNRåŽ-çví»¹Ÿ=Þ;7at!vÒm%–’ÒñÒñ%–“(»»šs§k7vR[±E¶îüüoÁÍÜâ ‰i“ÎÉ w7=ù¹6÷rt3;¹š“T™$’Oz$T†z®QR@ðŠ£–lœ7¹‡7à™AVƒÙ]…ÈØK¹$ô¹Ðx¾ÆÂa¼ö÷3tÒIL’W‰8Ÿb¸³¹™’›mËm³-·$’ $”Mž6Mß<^%c EZ6±.í¾,=pÄ>}ÁÁï%"õ¿}[?#!]³sÒt´•Fû†¥Ü˜Yeîkknž²N]©%×™»4ź¤På¬BZQ°õ¾â²Ûi²9Úí¶C"m±ÉIl¥ÙãiÉ2NÊU¶RØLĤŽHÙ „QÇ $„Zè,°zú¶Q«.®ïwã×ÏÖý“uËqšLÙÎæ·v‰„÷wŽìÞê®ÞÞ,§áïݱW“œ½keÊÆrÇA qwuÙ±¥-Ûo½TñXd{vÙ‰ŽYae4åI]üùÎu@õ×]2u×N§S¨lK m¸eËuç½ïºÊ¼Ê«l¶‘i(– …²Ûx¼C¾í–ÙíÛ-Ìb\åR…PxÌÉ‘-[Ëg-–Kg‚DÌú»“/¹?I$’}ò“$’IMæA³¹¾©ùo{¾ê bï[¥j)I$»»#A1’GwœöfsÕðË”©R¥Hˆn­ÄFd²#Cé]¨[^Q‘C ýŠ4aZ«­MyªÕ¯Zšôé§Vµ¸lÝmœ#5½Ð÷wt$˜’F•`›bȃ¬)òÓ¿J›öIï{$ìÌóå`eúÍ %š\OV–ní¤¾Õ­ÞÈBÍîŒoPh=i5$Ãmä“’VØrHÛyd‚»w@Öyb]Ü Ò$’Â)jIQÌÌÌÍÝÝÑÙ7̲ÛÛ$Ëm²›m¯vÛ¸Ü2µÍ‚äÒw[ÞÀVÏÎ8 ç ôZåeèÉs#2$åc…âÉM)CM9†{×9ÕÎpqäÂ$y»ïo¼Ì£/y'Ÿ.nï;*E¡T[hx™™3‰jÞY«,vˆ»ç|åsyÇ 0Íær¹€\Ë•ž€’&᳄tØ—vs$K¶!{_„ØU?žˆCúBF@L!‚a”H$p ` eˆ!öÿ~@ˆýäùþéöï¯ð¿„â øsÿßùÙô( þ§QGû~wÚ*€†>£sßgXŠ ÷Û¯»¯ÙëQçöS…EÄíü}]ŠŠ7Þ /ÃðTQæ?’ž??çæ  ‡Ÿ‡€x‡ëTQ§§——¯ûßÃó÷{'ã<½>ïˆ<¼=——þýÿ§_•óF öeE»¯¿¿œñì=}Kßñ¼qÕQGæåÙÝúU›ŸëýÓ¯ Di¹û?0Dzˆ*¡åÚ}?'z ¢>ξ?¶wˆ*¡EY¼¼Uk3ÝÜy* !¸ðí½ž|ýB¨x'/‹è;EPœp*€‡©QÕë\ëºr=S®ðãŸ=:|>~ïE_ww/“³ÇŽï_/Ýôÿñw$S… wbnpopensmt-2.5.2/regression_splitting/base-instances/small.smt2.bz2000066400000000000000000000010331445011647600250010ustar00rootroot00000000000000BZh91AY&SYEù=óI_€P¶=7|p¿ÿßd@ÝÖGNÁ¨Òeh‘“C@Ñ£MPõ™MFj= ¦ƒ "a&Ó&M4¢4&š›L‘€jhda2i’jÅ2ŽüŠ!äÇ5B ÏV½”Í’âVo¹²Š©à®¿xey?boœ§™K áF£»<â\ O#FR8½/(s*¯Dò¾‰~-[è@î\¢* ùÔÀg³^v“±í^×hdÉ+òº‘2t³X \ÒÚ0¿}¥™­Ô½°‘¤ Î ÐBELw©Æ« PC¥ÐÈ ª‹îÔáÈ6" 8 ?“”ó H©±Î ÔmòÝyì&ûÃu¯Prþ'hiRzšöø—.¢]«ºšªè„ôqÉÂa©ÅñŸ¤}(€HgãžÀ:5¼8…ÊúÒV·icdxFúØŽ ô‘‚l†-^.ùiË× ¸¾õ­ýüVþœ;íà íkÚØig9Lj~.U–Fä1á¶Ù´ÈkÜ9†Ö6,`9ÆðÜãa¸©PË"Æ,¡p.÷“iZ\ZøÝÌœ(´ozŽ§‹¾ù£+• 7Þ£O·$ƒ¤€XøE¢¹:Ò`®TɽŽzo ^¢·Z0Òî^†¸ÔQW“œ#³‚-Çïë„tÚ¼xå[ÖHpçJvöP¶0IV*³—½íkQÄÚÍ·ïØŠ`]Y:DtŒôÅ"DSOL[Ž¹ƒ£¶3zÛ<Øq—Gäûö†â‘ÙmQ´À-µûù«Y¼.¼3Šªiû¤7â½=,û©¿l„R@$Iº •íhüaÌØÌ¿'Le`h¿—æ ¦}’¶ô°€Ë=Ùìð…ZÓàaê-¬a&I¢%&¢z¹ p‹ \³£ˆ.±¢[ÝØÐAzú¸„!Ty„—ròB»#E:ÙÂbCVĹL‡z¦~'Hk0IXA‚˜¦hÊI“®·"U*ñõWÎrÜvºÏ†ˆQåü‡þ)\]˜uÃb&¦-`¾[kŠÞ¯©°Ø6•aTôßs»n¡D`Ád¼ý^õ顨ZµÜ)¹¶•¾¤üƵ‹ óÄÎ*©p÷{Í+=gÆ%5Åü™‘c+¦^Âê_*xqÿ|Ëì[áóßÔsÍÜwç-æÆP =6\± ðÁ8Çe» *Ô×[݈q—Þ¬°A ¦d8J‘¶²ÒAÚ.puÖœ@}9Õ©vè(!C(d·@Ý·*Û ð\ô®”c4»Ãu&ÞA(\8G ø{×ðú,½£DüU,G{1:ܬ­[‰¹ç ¯ÊÎÁnÌ[k…0ÞoŒ8Ÿnûä %þNî›øJÀ{3>+bbYšU­8ÝÜ»½§¶5ÓõŽÛœ‹ Ëk3D¾8Þ!ɹ1®MÈó€fi9Áw‹¾½-@΢ú• (;÷bD bM•­È°(-"´â‘J#µé¾ù¡ôú?k ž¿>˜ì÷õð™ÚÁöùÿ:=­â÷w¯ŸÐ/W‰ ßÕ÷ãJg£µHó9®¯ô1«s,G<ÔÄ˪«Õ’+L »$’F&’F@ëËlîºÕ-«K-iZJ€úBk®‰y—@S…”ÈSÙXç>]±«ßUu·`ÂA%}å›IbÄ¥‹±‹ ©‰”ÄÝÌÓVíWf@P—Ü»—R€Ç¦ûoZá›X!yaågÏyÉo,ã\¯5©”ëS>dæÝæ:ßxˆˆˆˆˆƒÅÅ™…™„3]8Í%J`öO‰ëK}^¹×k^¨Uî¦gUïïý`‚?µ’ X‹&£`É¢ÑfE™¶Š1¬Í`ÚÖµª¾Ù à­ôˆ ǧÕë¾ÏMwé½€!`ÉÓ—šŸ/1ìééÂp½ÀºÆÁ€g,ƒ ÈI$’NÀ ÉÈ 7é=ÔµQ.àO³TÉäÈdCiù…’^Y:éWÄ+ôD°±zÐ$‚\‰‘Ƈ&R š!èH®ÃÕП—;¹<Pª4\=!mó†¬\jÎÒ ]ØÂÙ±H’y"HÛ& _ ˜2ÚÇmã:öÜYà‰âYõäE"¹|¢ç¦U2´©i‹ßýÉÉ  me2ø?£]-øtÌÖÅôîÝîº/eb˜ù/¸Öòšcû.oC‰€°% $AsëVlϬLŽ‰ã‚Ïf§~ç¾tfÕð"õ;»çNœ­h(Äëªèá”ØÜ^^p™ÂØSÄgAëlââ .²Î l®ž{:"IWº 1² .øŽÞöõUá~´®“iâ7uÀ¦wrfà¥Ìî$|•Ç)Zǧœe šY¯mÞøZ 6dí)ödÖºE°­( ¤ÅAƒ8’†¡¥Dª0õ°kˆŽâLŽˆŠ§yy±R,Î؇Š Ji™`¡… g‚`€yðÿ_Žÿkó÷w xcÕw»ø¾)x¾“êuUus‹¸×%ÁrìéâD° @°Òw$+«8,¡:gCõ6èlº]:j÷ØU‰h öÔ€bI߀NW ,)9qgàP¸ï6»÷ãÊê^7jñÚÌȦR€PI ’H ’—‹Ð6ݦ´µj׋¹NO½4Õf4ó©>ÀH -öl!fà ›ºwd°6âÇEPóU ±RHitN½¶;‘-D3?#Âø¸2€ P Üš´Ëvd­®f¶2¶¢©¹ÄÛ[‹›j6É«F`d  €.¦ú|Þºu¾¯îôÕz-½cI‘mEúIˆ§¢KÄ—o l&°c@XEû¼ …O Ë„Ú$qCWmŠ´Ä‰Ð‰®d€Hb À’X š¸ÊbÔlL6(® IFÈXÕEb©‰¢€ij‡¸qѵ»wï^½Ç·|-¯ÒŽa„=Þ¸ÕJì[½ ’PÇ#Pö ø•Ôx ª^©0« ó ÛáàCÈŒ80&à÷|òÒö}ò8Ë$ F”)P‹’H‹ʼnS)ØÍ…Ù›ìÒVÅÁ·'0â”3ˆb ²  – Õ÷`˜3eØ"D—Ī›__´…îÞ~Þ_7n»×WŸÉuq;]d1 °ff‰™S$.9×w<½üsÇ]ÕÙËjš[¥Ýk 0dÅ™k(”²rC‹•!]Ì8DFH³ÁïŒS@wéËÅæviL% Êf™L˜‚ ±  &A%§7jjy£g4ò'raÅ¥µLjØ"‹5Î-P$UPüÅóA„ÐèrnÚ¨Õ'¢ONýóPš™fje¦Y¦dJw¯ÝkW½YZþ«Ž7ÆçÜhˆŽ.7‹fѦZ4ËqqcXµ®s•¹În8ÚºˆÄFˆÁÆ#ш£DF#F1#ˆ°b"ÅŠŠŒhѱŒj""4PDF6#ˆ¢"“QQƒHˆÄDDDDDTDcˆˆÔF1ŠŒQFÆ"ŒPcÆ1QDDc¬ŒlZ Š(¨ÑFˆÆ±,b#b"4F(¢,b*5*51ˆ¯—ÿúzÚôùùéZ×wëú¬˜ØQ›j$H­F˜š´6mRE²­–M5´l²iµBÊL¥ªMm ÕCd˜«F¢¢!’²™ (ȱ!R”m²˜ÒÌh±­ ‹l¡a À•£Ó%1™j4ÉJ06(4„FHJ``¤‰12&Dƒ-Œ¶°¥ jÅ•*Ø› Ú&d‚ýõùO{ÈQõ?-xŸ±yîñ¶ªÍý~ˆÄ£œD5àØAøO/ÈAÏ·:ì)8zƒØ õߟ3_/Ýü@M<¤`Œ„ ÊÂ Ä Ìœ²žb …ô£0DžØrÂ1ÿ! ¨¼ðF³pI¯ ܾ?UúäçdxëÜ{ðÙä" ‘ÛpöO>72ÓKËw4w÷m:ùù¨ˆ½Ù¢ ô£ÿrE8P˜ «,opensmt-2.5.2/regression_splitting/base-instances/unsat.smt2.bz2000066400000000000000000000003521445011647600250260ustar00rootroot00000000000000BZh91AY&SY›òý„õ_€@b"¯ížð0A¨ SýUSòHz Ú†0R„¦Ój=SÔ43PÞ©œbŒc ùûÇN?ª¹Z—T´ b8ªºg·NÚ­ª¸ÎÛ€ª¬çp3Uœîj³ÀÌ1HP$£LÓJ$•;Zââãbç‹Uj­Uª».`@JAÄsg ß½|zïƒá¶mÑ)1ŸèÕßǵmŠøŽ½+õ1è „X`sÒø®@ϸ6³g*ý@ÄSµâîH§ ~_°€opensmt-2.5.2/regression_splitting/bin/000077500000000000000000000000001445011647600202425ustar00rootroot00000000000000opensmt-2.5.2/regression_splitting/bin/check_result.py000077500000000000000000000051261445011647600232760ustar00rootroot00000000000000#!/usr/bin/env python3 import sys import re def die(s): print("Error in the split tree") print(s) sys.exit(1) def getLinesFromOutput(file): lines = map(lambda x: x.strip(), open(file).readlines()) lines = filter(lambda x: re.search("; [-]?[0-9][0-9]*", x), lines) lines = map(lambda x: x.split(), map(lambda x: x[2:], lines)) lines = [list(map(lambda x: int(x), l)) for l in lines] for line in lines: abses = set(map(abs, line)) if len(abses) != len(line): die("inconsistent path or duplicates in a path") return lines def getTree(lines): root = [{}, 0, 0] max_depth = -1 for path in lines: max_depth = max(max_depth, len(path)) curr = root for i in range(0, len(path)): lit = path[i] curr[2] += 1 if lit not in curr[0]: curr[0][lit] = [{}, lit, 0] curr = curr[0][lit] return root, max_depth def checkNode(node, depth, max_depth): if not (len(node[0]) == 2 or len(node[0]) == 0): die("Not a binary tree") children = list(node[0]) if len(children) == 2: if children[0] != -children[1]: die("Children are not mutually exclusive") if (depth != max_depth) and (node[2] == 0): die("Not a balanced tree") if (max_depth > depth): if (node[2] != 2**(max_depth-depth)): die("Incorrect descendant count on node %s" % node) else: if (node[2] != 0): die("Incorrect descendant count on node %s" % node) def checkTree(root, max_depth): queue = [[root, 0]] while len(queue) != 0: (node, depth) = queue.pop() checkNode(node, depth, max_depth) for key in node[0]: queue.append((node[0][key], depth+1)) if __name__ == '__main__': if len(sys.argv) != 3: print("Usage: %s " % sys.argv[0]) sys.exit(1) lines = getLinesFromOutput(sys.argv[1]) expected = sys.argv[2] if len(lines) == 0 and expected == 'unknown': die("Expected a split") if len(lines) != 0 and expected != 'unknown': die("Expected %s but got splits" % expected) if expected != 'unknown': s = open(sys.argv[1]).read() mo = re.search('^(sat|unsat)', s) if not mo: die("Expected %s but found no result" % expected) if mo.group(1) != expected: die("Expected %s but got %s" % (expected, mo.group(1))) else: assert(expected == 'unknown') root, max_depth = getTree(lines) checkTree(root, max_depth) sys.exit(0) opensmt-2.5.2/regression_splitting/bin/construct-split-instance.sh000077500000000000000000000020401445011647600255540ustar00rootroot00000000000000#!/bin/bash usage="Usage: $0 [-h] -i -s -o " while [ $# -gt 0 ]; do case $1 in -h|--help) echo "$usage" exit 1 ;; -i|--input) base=$2 ;; -s|--split) split=$2 ;; -o|--output) output=$2 ;; -*) echo "Error: invalid option '$1'" exit 1 ;; *) break esac shift; shift done if [ -z $base ] || [ ! -f $base ]; then echo "Basefile not provided or not accessible: $base" echo $usage exit 1 fi if [ -z $split ] || [ ! -f $split ]; then echo "Split file not provided or not accessible: $split" echo $usage exit $1 fi if [ -z $output ]; then echo "Outputfile not provided" output=/dev/stdout echo "Using $output" fi bunzip2 -c $base |grep -v '^(check-sat)\|(exit)\|(set-info :status \(sat\|unsat\))$' > $output cat $split >> $output cat << __EOF__ >> $output (check-sat) (exit) __EOF__ opensmt-2.5.2/regression_splitting/bin/process-instance.sh000077500000000000000000000020571445011647600240650ustar00rootroot00000000000000#!/bin/bash usage="Usage: $0 [-h] -i -p -o " while [ $# -gt 0 ]; do case $1 in -h|--help) echo "$usage" exit 1 ;; -i|--input) base=$2 ;; -p|--patch) patch=$2 ;; -o|--output) output=$2 ;; -*) echo "Error: invalid option '$1'" exit 1 ;; *) break esac shift; shift done if [ -z $base ] || [ ! -f $base ]; then echo "Basefile not provided or not accessible: $base" echo $usage exit 1 fi if [ -z $patch ] || [ ! -f $patch ]; then echo "Patch file not provided or not accessible: $patch" echo $usage exit $1 fi if [ -z $output ]; then echo "Outputfile not provided" output=/dev/stdout echo "Using $output" fi TMPDIR=$(mktemp -d) uncompressed=${TMPDIR}/file.smt2 trap "rm -rf ${uncompressed} ${TMPDIR}" EXIT bunzip2 -c $base > $uncompressed patch $uncompressed -i $patch -o $output > /dev/null opensmt-2.5.2/regression_splitting/bin/run-tests.sh000077500000000000000000000067761445011647600225650ustar00rootroot00000000000000#!/usr/bin/env bash RESULTCHECKER=./bin/check_result.py INSTANCECONSTRUCT=./bin/process-instance.sh RUNSPLITTER=./bin/split-and-solve.sh SOLVER=${1} ok=true function run_solver () { smtfile=$1 patch=$2 expected=$3 TMPDIR=$(mktemp -d) inputfile=${TMPDIR}/input.smt2 ${INSTANCECONSTRUCT} \ -i ${smtfile} \ -p ${patch} \ -o ${inputfile} outfile=${TMPDIR}/output.out ${SOLVER} ${inputfile} > ${outfile} 2> /dev/null if [[ $? != 0 ]]; then echo "Error running the solver on ${inputfile} ($smtfile and $patch)" ok=false return 1 fi ${RESULTCHECKER} ${outfile} ${expected} if [[ $? != 0 ]]; then echo "Error in result on ${smtfile} and ${patch}" ok=false return 1 fi rm ${inputfile} rm ${outfile} rm -rf ${TMPDIR} return 0 } function run_splitter () { smtfile=$1 patch=$2 expected=$3 output=$($RUNSPLITTER -b ${SOLVER} -i $smtfile -p $patch) if [ x"$output" == x"$expected" ]; then return 0; else echo "Error running the solver on $smtfile and $patch" ok=false return 1 fi } if [[ $# != 1 ]]; then echo "Usage: $0 " exit 1 fi run_solver ./base-instances/init_unsat.smt2.bz2 ./patches/init_unsat-lookahead.smt2 unsat run_solver ./base-instances/init_unsat.smt2.bz2 ./patches/init_unsat-deep.smt2 unsat run_solver ./base-instances/iso_brn164.smt2.bz2 ./patches/iso_brn164-deep.smt2 sat run_solver ./base-instances/iso_brn164.smt2.bz2 ./patches/iso_brn164-lookahead.smt2 sat run_solver ./base-instances/meti-tarski_sqrt_1mcosq_7_sqrt-1mcosq-7-chunk-0100.smt2.bz2 ./patches/meti-tarski_sqrt_1mcosq_7_sqrt-1mcosq-7-chunk-0100-deep.smt2 sat run_solver ./base-instances/meti-tarski_sqrt_1mcosq_7_sqrt-1mcosq-7-chunk-0100.smt2.bz2 ./patches/meti-tarski_sqrt_1mcosq_7_sqrt-1mcosq-7-chunk-0100-lookahead.smt2 sat run_solver ./base-instances/p2-zenonumeric_s6.smt2.bz2 ./patches/p2-zenonumeric_s6-lookahead.smt2 unknown run_solver ./base-instances/p2-zenonumeric_s6.smt2.bz2 ./patches/p2-zenonumeric_s6-deep.smt2 unknown run_solver ./base-instances/small.smt2.bz2 ./patches/small-deep.smt2 sat run_solver ./base-instances/small.smt2.bz2 ./patches/small-lookahead.smt2 sat run_solver ./base-instances/tta_startup_simple_startup_3nodes.synchro.base.smt2.bz2 ./patches/tta_startup_simple_startup_3nodes.synchro.base-deep.smt2 unsat run_solver ./base-instances/tta_startup_simple_startup_3nodes.synchro.base.smt2.bz2 ./patches/tta_startup_simple_startup_3nodes.synchro.base-deep.smt2 unsat run_splitter ./base-instances/init_unsat.smt2.bz2 patches/init_unsat-scatter.smt2 unsat run_splitter ./base-instances/iso_brn164.smt2.bz2 patches/iso_brn164-scatter.smt2 sat run_splitter ./base-instances/meti-tarski_sqrt_1mcosq_7_sqrt-1mcosq-7-chunk-0100.smt2.bz2 patches/meti-tarski_sqrt_1mcosq_7_sqrt-1mcosq-7-chunk-0100-scatter.smt2 sat run_splitter ./base-instances/p2-zenonumeric_s6.smt2.bz2 patches/p2-zenonumeric_s6-scatter.smt2 sat run_splitter ./base-instances/small.smt2.bz2 ./patches/small-scatter.smt2 sat run_splitter ./base-instances/tta_startup_simple_startup_3nodes.synchro.base.smt2.bz2 patches/tta_startup_simple_startup_3nodes.synchro.base-scatter.smt2 unsat run_splitter ./base-instances/unsat.smt2.bz2 patches/unsat-2-incremental-scatter.smt2 unsat run_splitter ./base-instances/unsat.smt2.bz2 patches/unsat-2-scatter.smt2 unsat run_splitter ./base-instances/unsat.smt2.bz2 patches/unsat-4-scatter.smt2 unsat if [[ ${ok} == true ]]; then exit 0; else exit 1; fi opensmt-2.5.2/regression_splitting/bin/solve-split-instance.sh000077500000000000000000000035221445011647600246660ustar00rootroot00000000000000#!/bin/bash CONSTRUCTSPLIT=./bin/construct-split-instance.sh usage="Usage: $0 [-h] -i -s -b " while [ $# -gt 0 ]; do case $1 in -h|--help) echo "$usage" exit 1 ;; -i|--input) base=$2 ;; -s|--splits) inputs=$2 ;; -b|--binary) solver=$2 ;; -*) echo "Error: invalid option '$1'" exit 1 ;; *) break esac shift; shift done if [ -z $base ] || [ ! -f $base ]; then echo "Base file not provided or not accessible: '$base'" echo $usage exit $1 fi if [ -z $inputs ] || [ ! -d $inputs ]; then echo "Instance directory not provided or not accessible: '$inputs'" echo $usage exit 1 fi if [ -z $solver ] || [ ! -f $solver ]; then echo "Solver file not provided or not accessible: '$solver'" echo $usage exit $1 fi TMPDIR=$(mktemp -d) # Note: set to `true' to prevent deletion of temporary files keep=false trap "if [ x$keep == xtrue ]; then echo 'keeping output in ${TMPDIR}'; else rm -rf ${TMPDIR}; fi" EXIT numSplits=$(ls $inputs/*.smt2 |wc -l) if [ $numSplits -eq 0 ]; then echo "Error: no splits found" exit 1 fi numSat=0 numUnsat=0 for split in $inputs/*.smt2; do $CONSTRUCTSPLIT -i $base -s $split -o $TMPDIR/split.smt2 splitResult=$($solver $TMPDIR/split.smt2 2>/dev/null) if [ x"$splitResult" == x"sat" ]; then numSat=$((numSat+1)) elif [ x"$splitResult" == x"unsat" ]; then numUnsat=$((numUnsat+1)) else echo "Unexpected result while solving a split '$TMPDIR/split.smt2': '$splitResult'" fi done if [ $numUnsat -eq $numSplits ]; then echo "unsat" elif [ $numSat -gt 0 ]; then echo "sat" else echo "unknown" exit 1 fi opensmt-2.5.2/regression_splitting/bin/split-and-solve.sh000077500000000000000000000047461445011647600236350ustar00rootroot00000000000000#!/usr/bin/env bash INSTANCECONSTRUCT=./bin/process-instance.sh SPLITSOLVER=./bin/solve-split-instance.sh # Note: symlinkPath needs to match with the output directory in the instance symlinkPath=split_and_solve_work usage="Usage: $0 [-h] -b -i -p " if [ -e $symlinkPath ]; then echo "Symbolic link path exists as a directory or file. Please remove '$symlinkPath'" >&2 echo "$usage" >&2 exit 1 fi TMPDIR=$(mktemp -d) # Note: set to `true' to prevent deletion of temporary files keep=false trap "if [ x$keep == xtrue ]; then echo 'keeping output in ${TMPDIR}' >&2; else rm -rf ${TMPDIR}; fi" EXIT if [ -L $symlinkPath ] && [ x$keep == xfalse ]; then rm $symlinkPath fi function constructInstance () { smtfile=$1 patch=$2 inputfile=${TMPDIR}/input.smt2 ${INSTANCECONSTRUCT} \ -i ${smtfile} \ -p ${patch} \ -o ${inputfile} echo $inputfile } while [ $# -gt 0 ]; do case $1 in -h|--help) echo "$usage" >&2 exit 1 ;; -b|--binary) solver=$2 ;; -i|--input) base=$2 ;; -p|--patch) patch=$2 ;; -*) echo "Error: invalid option '$1'" >&2 exit 1 ;; *) break esac shift; shift done if [ -z $solver ] || [ ! -f $solver ]; then echo "Solver not provided or does not exist: '$solver'" >&2 echo $usage >&2 exit 1 fi if [ -z $base ] || [ ! -f $base ]; then echo "Basefile not provided or not accessible: '$base'" >&2 echo $usage >&2 exit 1 fi if [ -z $patch ] || [ ! -f $patch ]; then echo "Patch file not provided or not accessible: '$patch'" >&2 echo $usage >&2 exit 1 fi mkdir $TMPDIR/$symlinkPath ln -s $TMPDIR/$symlinkPath $symlinkPath || exit 1 file=$(constructInstance $base $patch) solverResult=$($solver $file 2>/dev/null | grep -v '^;') if [ x"$solverResult" != x"unknown" ]; then if [ x"$solverResult" == x"unsat" ]; then echo $solverResult elif [ x"$solverResult" == x"sat" ]; then echo $solverResult else echo "Unexepected solver output: '$solverResult'" >&2 fi else numSplits=$(ls $symlinkPath/*.smt2 |wc -l) if [ $numSplits -eq 0 ]; then echo "Error: no splits found but result was unknown" >&2 exit 1 fi $SPLITSOLVER -i $base -s $symlinkPath -b $solver fi if [ x$keep != xtrue ]; then rm $symlinkPath fi opensmt-2.5.2/regression_splitting/patches/000077500000000000000000000000001445011647600211215ustar00rootroot00000000000000opensmt-2.5.2/regression_splitting/patches/init_unsat-deep.smt2000066400000000000000000000004121445011647600250150ustar00rootroot000000000000000a1,7 > (set-option :lookahead-split) > (set-option :lookahead-score-deep) > (set-option :split-num 64) > (set-option :output-dir "splits_here") > (set-option :test_cube_and_conquer true) > (set-option :split-format-length "brief") > (set-option :split-format smt2) opensmt-2.5.2/regression_splitting/patches/init_unsat-lookahead.smt2000066400000000000000000000003451445011647600260340ustar00rootroot000000000000000a1,6 > (set-option :lookahead-split) > (set-option :split-num 64) > (set-option :output-dir "splits_here") > (set-option :test_cube_and_conquer true) > (set-option :split-format-length "brief") > (set-option :split-format smt2) opensmt-2.5.2/regression_splitting/patches/init_unsat-scatter.smt2000066400000000000000000000001621445011647600255470ustar00rootroot000000000000000a1,3 > (set-option :scatter-split) > (set-option :split-num 2) > (set-option :output-dir "split_and_solve_work") opensmt-2.5.2/regression_splitting/patches/iso_brn164-deep.smt2000066400000000000000000000003521445011647600245310ustar00rootroot000000000000000a1 > (set-option :lookahead-split) 5a7,13 > > (set-option :lookahead-score-deep) > (set-option :split-num 16) > (set-option :output-dir "splits_here") > > (set-option :split-format-length "brief") > (set-option :split-format smt2) opensmt-2.5.2/regression_splitting/patches/iso_brn164-lookahead.smt2000066400000000000000000000003051445011647600255410ustar00rootroot000000000000000a1 > (set-option :lookahead-split) 5a7,12 > > (set-option :split-num 16) > (set-option :output-dir "splits_here") > > (set-option :split-format-length "brief") > (set-option :split-format smt2) opensmt-2.5.2/regression_splitting/patches/iso_brn164-scatter.smt2000066400000000000000000000001621445011647600252600ustar00rootroot000000000000000a1,3 > (set-option :scatter-split) > (set-option :split-num 2) > (set-option :output-dir "split_and_solve_work") meti-tarski_sqrt_1mcosq_7_sqrt-1mcosq-7-chunk-0100-deep.smt2000066400000000000000000000004121445011647600336760ustar00rootroot00000000000000opensmt-2.5.2/regression_splitting/patches0a1,7 > (set-option :lookahead-split) > (set-option :lookahead-score-deep) > (set-option :split-num 64) > (set-option :output-dir "splits_here") > (set-option :test_cube_and_conquer true) > (set-option :split-format-length "brief") > (set-option :split-format smt2) meti-tarski_sqrt_1mcosq_7_sqrt-1mcosq-7-chunk-0100-lookahead.smt2000066400000000000000000000003451445011647600347150ustar00rootroot00000000000000opensmt-2.5.2/regression_splitting/patches0a1,6 > (set-option :lookahead-split) > (set-option :split-num 64) > (set-option :output-dir "splits_here") > (set-option :test_cube_and_conquer true) > (set-option :split-format-length "brief") > (set-option :split-format smt2) meti-tarski_sqrt_1mcosq_7_sqrt-1mcosq-7-chunk-0100-scatter.smt2000066400000000000000000000001621445011647600344300ustar00rootroot00000000000000opensmt-2.5.2/regression_splitting/patches0a1,3 > (set-option :scatter-split) > (set-option :split-num 2) > (set-option :output-dir "split_and_solve_work") opensmt-2.5.2/regression_splitting/patches/p2-zenonumeric_s6-deep.smt2000066400000000000000000000003521445011647600261300ustar00rootroot000000000000000a1,7 > (set-option :lookahead-split) > (set-option :lookahead-score-deep) > (set-option :split-num 8) > (set-option :output-dir "split_and_solve_work") > > (set-option :split-format-length "brief") > (set-option :split-format smt2) opensmt-2.5.2/regression_splitting/patches/p2-zenonumeric_s6-lookahead.smt2000066400000000000000000000003051445011647600271400ustar00rootroot000000000000000a1,6 > (set-option :lookahead-split) > (set-option :split-num 8) > (set-option :output-dir "split_and_solve_work") > > (set-option :split-format-length "brief") > (set-option :split-format smt2) opensmt-2.5.2/regression_splitting/patches/p2-zenonumeric_s6-scatter.smt2000066400000000000000000000001621445011647600266570ustar00rootroot000000000000000a1,3 > (set-option :scatter-split) > (set-option :split-num 2) > (set-option :output-dir "split_and_solve_work") opensmt-2.5.2/regression_splitting/patches/small-deep.smt2000066400000000000000000000003021445011647600237460ustar00rootroot000000000000000a1,5 > (set-option :lookahead-split) > (set-option :lookahead-score-deep) > (set-option :output-dir "splits_here") > (set-option :split-format-length "brief") > (set-option :split-format smt2) opensmt-2.5.2/regression_splitting/patches/small-lookahead.smt2000066400000000000000000000002331445011647600247630ustar00rootroot000000000000000a4 > (set-option :lookahead-split) > (set-option :output-dir "splits_here") > (set-option :split-format-length "brief") > (set-option :split-format smt2) opensmt-2.5.2/regression_splitting/patches/small-scatter.smt2000066400000000000000000000001621445011647600245020ustar00rootroot000000000000000a1,3 > (set-option :scatter-split) > (set-option :split-num 2) > (set-option :output-dir "split_and_solve_work") opensmt-2.5.2/regression_splitting/patches/tta_startup_simple_startup_3nodes.synchro.base-deep.smt2000066400000000000000000000004121445011647600342150ustar00rootroot000000000000000a1,7 > (set-option :lookahead-split) > (set-option :lookahead-score-deep) > (set-option :split-num 64) > (set-option :output-dir "splits_here") > (set-option :test_cube_and_conquer true) > (set-option :split-format-length "brief") > (set-option :split-format smt2) tta_startup_simple_startup_3nodes.synchro.base-lookahead.smt2000066400000000000000000000003451445011647600351550ustar00rootroot00000000000000opensmt-2.5.2/regression_splitting/patches0a1,6 > (set-option :lookahead-split) > (set-option :split-num 64) > (set-option :output-dir "splits_here") > (set-option :test_cube_and_conquer true) > (set-option :split-format-length "brief") > (set-option :split-format smt2) tta_startup_simple_startup_3nodes.synchro.base-scatter.smt2000066400000000000000000000001621445011647600346700ustar00rootroot00000000000000opensmt-2.5.2/regression_splitting/patches0a1,3 > (set-option :scatter-split) > (set-option :split-num 2) > (set-option :output-dir "split_and_solve_work") opensmt-2.5.2/regression_splitting/patches/unsat-2-incremental-scatter.smt2000066400000000000000000000002321445011647600271600ustar00rootroot000000000000000a1,4 > > (set-option :scatter-split) > (set-option :split-num 2) > (set-option :output-dir "split_and_solve_work") 9c13,14 < --- > (push 1) > (push 1) opensmt-2.5.2/regression_splitting/patches/unsat-2-scatter.smt2000066400000000000000000000001621445011647600246630ustar00rootroot000000000000000a1,3 > (set-option :scatter-split) > (set-option :split-num 2) > (set-option :output-dir "split_and_solve_work") opensmt-2.5.2/regression_splitting/patches/unsat-4-scatter.smt2000066400000000000000000000001621445011647600246650ustar00rootroot000000000000000a1,3 > (set-option :scatter-split) > (set-option :split-num 4) > (set-option :output-dir "split_and_solve_work") opensmt-2.5.2/sample/000077500000000000000000000000001445011647600144765ustar00rootroot00000000000000opensmt-2.5.2/sample/README000066400000000000000000000000051445011647600153510ustar00rootroot00000000000000... opensmt-2.5.2/sample/sample.sh000077500000000000000000000031251445011647600163170ustar00rootroot00000000000000#!/bin/sh SERVER_OUT='./server.out' OPENSMT_OUT='./opensmt.out' PYTHON='python' # this should be the command to python 2.7 workers=2 split=2 mode='_lookahead' show_help() { echo "Usage $0 [-R][-S][-n WORKER_NUMBER=$workers][-s SPLIT_NUMBER=$split][-p PYTHON2.7_PATH=$python] FILE1.smt2 [FILE2.smt [...]]" echo echo "-R : use clause sharing" echo "-S : use scattering (default lookahead)" exit 0 } while getopts "hRSn:s:" opt; do case "$opt" in h|\?) show_help ;; R) ;; S) mode='_scattering' ;; n) workers=$OPTARG ;; s) split=$OPTARG ;; esac done shift $((OPTIND-1)) if [ $# -le 0 ]; then echo '.smt2 file(s) missing!' show_help exit fi echo '#' echo '# ! PLEASE READ THE README FIRST !' echo '#' echo "# number of opensmt solvers: $workers" echo "# number of splits: $split" echo "# split mode: $mode" echo '#' echo "# SERVER stdout will be redirected to $SERVER_OUT" echo "# OPENSMT solvers stdout and stderr will be redirected to $OPENSMT_OUT" echo '#' echo '# starting server... ' $PYTHON ../wserver/sserver.py -d -f ../wserver/$mode -s $split -o ../opensmt > $SERVER_OUT 2>/dev/null & server_pid=$! sleep 1 echo '# done' echo '# sending the files to the server... ' $PYTHON ../wserver/command.py 127.0.0.1 $@ > /dev/null echo '# done' for i in $(seq $workers) do echo "# starting opensmt solver $i... " ../opensmt -s127.0.0.1:3000 > $OPENSMT_OUT 2>&1 & echo '# done' done echo '# waiting for all the problem to be solved... ' wait $server_pid echo '# done' echo "# The results are in $SERVER_OUT" echo '# bye' opensmt-2.5.2/src/000077500000000000000000000000001445011647600140045ustar00rootroot00000000000000opensmt-2.5.2/src/CMakeLists.txt000066400000000000000000000011061445011647600165420ustar00rootroot00000000000000add_subdirectory(proof) add_subdirectory(common) add_subdirectory(cnfizers) add_subdirectory(pterms) add_subdirectory(symbols) add_subdirectory(sorts) add_subdirectory(options) add_subdirectory(api) add_subdirectory(minisat) add_subdirectory(models) add_subdirectory(logics) add_subdirectory(tsolvers) add_subdirectory(simplifiers) add_subdirectory(smtsolvers) add_subdirectory(parsers) add_subdirectory(itehandler) add_subdirectory(rewriters) add_subdirectory(interpolation) if (BUILD_EXECUTABLES) add_subdirectory(bin) endif() if (PARALLEL) add_subdirectory(parallel) endif()opensmt-2.5.2/src/PySMT/000077500000000000000000000000001445011647600147605ustar00rootroot00000000000000opensmt-2.5.2/src/PySMT/opensmt_python.i000066400000000000000000000050011445011647600202140ustar00rootroot00000000000000/* -*- swig -*- */ /* SWIG interface file to create the Python API for OpenSMT */ %include "typemaps.i" /***************************************************************************/ /* Convert a python sequence to an array of arguments */ %typemap(in) osmt_expr * { int i, sz; osmt_expr *tmp; void *ptr; int r; if (!PySequence_Check($input)) { PyErr_SetString(PyExc_TypeError, "Sequence object required"); return NULL; } sz = PySequence_Size($input); tmp = malloc(sizeof(osmt_expr) * sz); for (i = 0; i < sz; ++i) { PyObject *p = PySequence_ITEM($input, i); r = SWIG_ConvertPtr(p, &ptr, SWIGTYPE_p_osmt_expr, 0); Py_DECREF(p); if (!SWIG_IsOK(r)) { free(tmp); PyErr_SetString(PyExc_TypeError, "Invalid type for argument, " \ "osmt_expr object expected"); return NULL; } else { tmp[i] = *((osmt_expr *)(ptr)); } } $1 = tmp; } /* Free the argument? */ /* %typemap(freearg) osmt_expr * { if ($1) msat_free($1); } */ /* Create the wrappers in python for more pleasant use. */ %pythoncode %{ def mkContext(l): return osmt_mk_context(l) def printTerm(ctx, expr): return osmt_print_expr(ctx, expr); def push(ctx, expr): return osmt_push(ctx, expr) def check(ctx): return osmt_check(ctx) def mkTrue(ctx): return osmt_mk_true(ctx) def mkFalse(ctx): return osmt_mk_false(ctx) def mkBool(ctx, n): return osmt_mk_bool_var(ctx, n) def mkReal(ctx, n): return osmt_mk_real_var(ctx, n) def mkOr(ctx, expr): return osmt_mk_or(ctx, expr, len(expr)) def mkAnd(ctx, expr): return osmt_mk_and(ctx, expr, len(expr)) def mkEq(ctx, e1, e2): return osmt_mk_eq(ctx, e1, e2) def mkIte(ctx, i, t, e): return osmt_mk_ite(ctx, i, t, e) def mkNot(ctx, e): return osmt_mk_not(ctx, e) def mkImpl(ctx, e1, e2): return osmt_mk_impl(ctx, e1, e2) def mkXor(ctx, e1, e2): return osmt_mk_xor(ctx, e1, e2) def mkNum(ctx, arg): if type(arg) is str: return osmt_mk_num_from_string(ctx, arg) elif type(arg) is int: return osmt_mk_num_from_num(ctx, arg) def mkLeq(ctx, e1, e2): return osmt_mk_leq(ctx, e1, e2) %} /* EXTRA_SWIG_CODE_TAG */ %module opensmt %{ #include "opensmt_c.h" /* EXTRA_C_INCLUDE_TAG */ %} %include "opensmt_c.h" /* EXTRA_SWIG_INCLUDE_TAG */ %{ /* EXTRA_C_STATIC_CODE_TAG */ %} %inline %{ /* EXTRA_C_INLINE_CODE_TAG */ %} /* %pythoncode %{ ## EXTRA_PYTHON_CODE_TAG %} */ opensmt-2.5.2/src/PySMT/setup.py000066400000000000000000000033511445011647600164740ustar00rootroot00000000000000import sys import os from setuptools import setup from distutils.extension import Extension from datetime import datetime short_description="OpenSMT2 SMT-Solver Wrapper" long_description=\ """ ========================== Opensmt SMT-Solver Wrapper ========================== Provides a basic wrapping around the OpenSMT2 SMT Solver. OpenSMT2 is developed at Universita' della Svizzera italiana. For more information see http://verify.inf.usi.ch/opensmt. """ if __name__ == '__main__': if len(sys.argv) < 2: print "Usage: %s " % sys.argv[0] exit(1) OPENSMT_DIR = sys.argv[1] del sys.argv[1] opensmt_ext = Extension('_opensmt', ['src/PySMT/opensmt_python_wrap.c'], include_dirs=[os.path.join(OPENSMT_DIR, "include/opensmt")], library_dirs=[os.path.join(OPENSMT_DIR, "lib")], libraries=['opensmt2c','gmp','gmpxx', 'z'], language='c', ) setup(name='popensmt', version="0.1dev1", author='PySMT Team', author_email='info@pysmt.org', url='https://github.com/pysmt/popensmt/', license='BSD', description=short_description, long_description=long_description, ext_modules=[opensmt_ext], py_modules=['opensmt'], classifiers = [ "Programming Language :: Python", "Programming Language :: Python :: 3", "Development Status :: 4 - Beta", "Intended Audience :: Developers", "Topic :: Software Development :: Libraries :: Python Modules", ], ) opensmt-2.5.2/src/api/000077500000000000000000000000001445011647600145555ustar00rootroot00000000000000opensmt-2.5.2/src/api/CMakeLists.txt000066400000000000000000000056751445011647600173320ustar00rootroot00000000000000set(OBJECTS_TO_ADD $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ ) add_library(api OBJECT "") set(PRIVATE_SOURCES_TO_ADD "${CMAKE_CURRENT_SOURCE_DIR}/MainSolver.cc" "${CMAKE_CURRENT_SOURCE_DIR}/PartitionManager.cc" "${CMAKE_CURRENT_SOURCE_DIR}/Interpret.cc" ) set(PUBLIC_SOURCES_TO_ADD "${CMAKE_CURRENT_SOURCE_DIR}/MainSolver.h" "${CMAKE_CURRENT_SOURCE_DIR}/PartitionManager.h" "${CMAKE_CURRENT_SOURCE_DIR}/smt2tokens.h" "${CMAKE_CURRENT_SOURCE_DIR}/Interpret.h" "${CMAKE_CURRENT_SOURCE_DIR}/Opensmt.cc" ) target_sources(api PRIVATE ${PRIVATE_SOURCES_TO_ADD} PUBLIC ${PUBLIC_SOURCES_TO_ADD} ) set(OBJECTS_TO_ADD $ ${OBJECTS_TO_ADD}) if (BUILD_SHARED_LIBS) add_library(OpenSMT SHARED ${OBJECTS_TO_ADD}) set_target_properties(OpenSMT PROPERTIES NO_SYSTEM_FROM_IMPORTED true VERSION ${OPENSMT_VERSION} OUTPUT_NAME opensmt LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib" ) target_link_libraries(OpenSMT PUBLIC GMP::GMP Threads::Threads) install(TARGETS OpenSMT EXPORT OpenSMTTargets LIBRARY DESTINATION lib ARCHIVE DESTINATION lib RUNTIME DESTINATION bin INCLUDES DESTINATION include ) install(EXPORT OpenSMTTargets FILE OpenSMTTargets.cmake NAMESPACE OpenSMT:: DESTINATION lib/cmake/opensmt ) include(CMakePackageConfigHelpers) write_basic_package_version_file( "${CMAKE_CURRENT_BINARY_DIR}/OpenSMTConfigVersion.cmake" VERSION ${OPENSMT_VERSION} COMPATIBILITY SameMajorVersion # SameMinorVersion available only from CMake 3.11 ) configure_package_config_file(OpenSMTConfig.cmake.in "${CMAKE_CURRENT_BINARY_DIR}/OpenSMTConfig.cmake" INSTALL_DESTINATION lib/cmake/opensmt ) install(FILES "${CMAKE_CURRENT_BINARY_DIR}/OpenSMTConfigVersion.cmake" "${CMAKE_CURRENT_BINARY_DIR}/OpenSMTConfig.cmake" "${PROJECT_SOURCE_DIR}/cmake_modules/FindGMP.cmake" DESTINATION lib/cmake/opensmt ) endif() if (BUILD_STATIC_LIBS) add_library(OpenSMT-static STATIC ${OBJECTS_TO_ADD}) set_target_properties(OpenSMT-static PROPERTIES OUTPUT_NAME opensmt NO_SYSTEM_FROM_IMPORTED true VERSION ${OPENSMT_VERSION} ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib" ) target_link_libraries(OpenSMT-static PUBLIC GMP::GMP Threads::Threads) install(TARGETS OpenSMT-static ARCHIVE DESTINATION lib) endif() install(FILES Opensmt.h smt2tokens.h MainSolver.h PartitionManager.h Interpret.h DESTINATION ${INSTALL_HEADERS_DIR} ) opensmt-2.5.2/src/api/DimacsParser.h000066400000000000000000000122011445011647600172770ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ /********************************************************************* Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson Copyright (c) 2007-2010, Niklas Sorensson 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. **********************************************************************/ #ifndef DimacsParser_h #define DimacsParser_h #include #include #include #include "SimpSMTSolver.h" class DimacsParser { static inline bool isEof(const char* in) { return *in == '\0'; } static void skipWhitespace(const char*& in) { while ((*in >= 9 && *in <= 13) || *in == 32) ++in; } static void skipLine(const char*& in) { for (;;){ if (isEof(in)) return; if (*in == '\n') { ++in; return; } ++in; } } static int parseInt(const char*& in) { int val = 0; bool neg = false; skipWhitespace(in); if (*in == '-') neg = true, ++in; else if (*in == '+') ++in; if (*in < '0' || *in > '9') { std::cerr << "PARSE ERROR! Unexpected char: " << *in << std::endl; exit(3); } while (*in >= '0' && *in <= '9') val = val*10 + (*in - '0'), ++in; return neg ? -val : val; } // String matching: in case of a match the input iterator will be advanced // the corresponding number of characters. static bool match(const char*& in, const char* str) { int i; for (i = 0; str[i] != '\0'; i++) if (in[i] != str[i]) return false; in += i; return true; } // String matching: consumes characters eagerly, but does not require // random access iterator. static bool eagerMatch(const char*& in, const char* str) { for (; *str != '\0'; ++str, ++in) if (*str != *in) return false; return true; } static void readClause(const char*& in, SimpSMTSolver& S, vec& lits) { int parsed_lit, var; lits.clear(); for (;;) { parsed_lit = parseInt(in); if (parsed_lit == 0) break; var = abs(parsed_lit)-1; assert(var < S.nVars()); while (var >= S.nVars()) S.newVar(); lits.push( (parsed_lit > 0) ? mkLit(var) : ~mkLit(var) ); } } public: static void parse_DIMACS_main(const char* in, SimpSMTSolver& S) { vec lits; for (;;){ skipWhitespace(in); if (isEof(in)) break; else if (*in == 'p'){ if (!match(in, "p cnf")) { std::cerr << "PARSE ERROR! Unexpected char: " << *in << endl; exit(3); } } else if (*in == 'c' || *in == 'p') skipLine(in); else readClause(in, S, lits), S.addOriginalClause(lits); } } }; #endif opensmt-2.5.2/src/api/Interpret.cc000066400000000000000000001353721445011647600170530ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ #include "Interpret.h" #include "smt2tokens.h" #include "ArithLogic.h" #include "LogicFactory.h" #include "Substitutor.h" #include #include #include #include /*********************************************************** * Class defining interpreter ***********************************************************/ Interpret::~Interpret() { for (int i = 0; i < term_names.size(); ++i) { free(term_names[i]); } } PTRef Interpret::getParsedFormula() { PTRef root = main_solver->getLogic().mkAnd(assertions); return root; } void Interpret::setInfo(ASTNode& n) { assert(n.getType() == UATTR_T || n.getType() == PATTR_T); char* name = NULL; if (n.getValue() == NULL) { ASTNode& an = **(n.children->begin()); assert(an.getType() == UATTR_T || an.getType() == PATTR_T); name = strdup(an.getValue()); } else // Normal option name = strdup(n.getValue()); Info value(n); config.setInfo(name, value); free(name); } void Interpret::getInfo(ASTNode& n) { assert(n.getType() == INFO_T); const char* name; if (n.getValue() != NULL) name = n.getValue(); else { assert(n.children != NULL); name = (**(n.children->begin())).getValue(); } const Info& value = config.getInfo(name); if (value.isEmpty()) notify_formatted(true, "no value for info %s", name); else { auto val_str = value.toString(); notify_formatted(false, "%s %s", name, val_str.c_str()); } } void Interpret::setOption(ASTNode& n) { assert(n.getType() == OPTION_T); char* name = NULL; if (n.getValue() == NULL) { // Attribute ASTNode& an = **(n.children->begin()); assert(an.getType() == UATTR_T || an.getType() == PATTR_T); name = strdup(an.getValue()); } else // Normal option name = strdup(n.getValue()); SMTOption value(n); const char* msg = "ok"; bool rval = config.setOption(name, value, msg); if (rval == false) notify_formatted(true, "set-option failed for %s: %s", name, msg); free(name); } void Interpret::getOption(ASTNode& n) { assert(n.getType() == UATTR_T || n.getType() == PATTR_T ); assert(n.getValue() != NULL); const char* name = n.getValue(); const SMTOption& value = config.getOption(name); if (value.isEmpty()) notify_formatted(true, "No value for attr %s", name); else { auto str_val = value.toString(); notify_formatted(false, "%s",str_val.c_str()); } } void Interpret::exit() { f_exit = true; } using opensmt::Logic_t; using opensmt::getLogicFromString; using namespace osmttokens; void Interpret::interp(ASTNode& n) { assert(n.getType() == CMD_T); const smt2token cmd = n.getToken(); try { switch (cmd.x) { case t_setlogic: { ASTNode &logic_n = **(n.children->begin()); const char *logic_name = logic_n.getValue(); if (isInitialized()) { notify_formatted(true, "logic has already been set to %s", main_solver->getLogic().getName().data()); } else { auto logic_type = getLogicFromString(logic_name); if (logic_type == Logic_t::UNDEF) { notify_formatted(true, "unknown logic %s", logic_name); break; } initializeLogic(logic_type); main_solver = createMainSolver(logic_name); main_solver->initialize(); notify_success(); } break; } case t_setinfo: { setInfo(**(n.children->begin())); notify_success(); break; } case t_getinfo: { getInfo(**(n.children->begin())); break; } case t_setoption: { setOption(**(n.children->begin())); notify_success(); break; } case t_getoption: { getOption(**(n.children->begin())); break; } case t_declaresort: { if (isInitialized()) { assert(n.children and n.children->size() == 2); auto it = n.children->begin(); ASTNode & symbolNode = **it; assert(symbolNode.getType() == SYM_T or symbolNode.getType() == QSYM_T); ++it; ASTNode & numNode = **it; assert(numNode.getType() == NUM_T); int arity = atoi(numNode.getValue()); // MB: TODO: take care of out-of-range input SortSymbol symbol(symbolNode.getValue(), arity); SSymRef ssref; if (logic->peekSortSymbol(symbol, ssref)) { notify_formatted(true, "sort %s already declared", symbolNode.getValue()); } else { logic->declareSortSymbol(std::move(symbol)); notify_success(); } } else notify_formatted(true, "illegal command before set-logic: declare-sort"); break; } case t_declarefun: { if (isInitialized()) { if (declareFun(n)) notify_success(); } else notify_formatted(true, "Illegal command before set-logic: declare-fun"); break; } case t_declareconst: { if (isInitialized()) { declareConst(n); } else notify_formatted(true, "Illegal command before set-logic: declare-const"); break; } case t_assert: { if (isInitialized()) { sstat status; ASTNode &asrt = **(n.children->begin()); LetRecords letRecords; PTRef tr = parseTerm(asrt, letRecords); if (tr == PTRef_Undef) notify_formatted(true, "assertion returns an unknown sort"); else { assertions.push(tr); char *err_msg = NULL; status = main_solver->insertFormula(tr, &err_msg); if (status == s_Error) notify_formatted(true, "Error"); else if (status == s_Undef) notify_success(); else if (status == s_False) notify_success(); if (err_msg != NULL && status == s_Error) notify_formatted(true, err_msg); if (err_msg != NULL && status != s_Error) comment_formatted(err_msg); free(err_msg); } } else { notify_formatted(true, "Illegal command before set-logic: assert"); } break; } case t_definefun: { if (isInitialized()) { defineFun(n); } else { notify_formatted(true, "Illegal command before set-logic: define-fun"); } break; } case t_simplify: { if (isInitialized()) { sstat status = main_solver->simplifyFormulas(); if (status == s_Error) notify_formatted(true, "Simplify"); } else { notify_formatted(true, "Illegal command before set-logic: simplify"); } break; } case t_checksat: { if (isInitialized()) { checkSat(); } else { notify_formatted(true, "Illegal command before set-logic: check-sat"); } break; } case t_getinterpolants: { if (config.produce_inter()) { if (isInitialized()) { getInterpolants(n); } else { notify_formatted(true, "Illegal command before set-logic: get-interpolants"); } } else { notify_formatted(true, "Option to produce interpolants has not been set, skipping this command ..."); } break; } case t_getassignment: { if (isInitialized()) { getAssignment(); } else { notify_formatted(true, "Illegal command before set-logic: get-assignment"); } break; } case t_getvalue: { if (not isInitialized()) { notify_formatted(true, "Illegal command before set-logic: get-value"); } else if (main_solver->getStatus() != s_True) { notify_formatted(true, "Command get-value called, but solver is not in SAT state"); } else { assert(n.children); getValue(*n.children); } break; } case t_getmodel: { if (not isInitialized()) { notify_formatted(true, "Illegal command before set-logic: get-model"); } else if (main_solver->getStatus() != s_True) { notify_formatted(true, "Command get-model called, but solver is not in SAT state"); } else { getModel(); } break; } case t_writestate: { if (not isInitialized()) { notify_formatted(true, "Illegal command before set-logic: write-state"); } else { if (main_solver->solverEmpty()) { sstat status = main_solver->simplifyFormulas(); if (status == s_Error) notify_formatted(true, "write-state"); } else { writeState((**(n.children->begin())).getValue()); } } break; } case t_echo: { const char *str = (**(n.children->begin())).getValue(); notify_formatted(false, "%s", str); break; } case t_push: { if (not isInitialized()) { notify_formatted(true, "Illegal command before set-logic: push"); } else { try { int num = std::stoi((**(n.children->begin())).getValue()); push(num); } catch (std::out_of_range const & e) { notify_formatted(true, "Illegal push command: %s", e.what()); } } break; } case t_pop: { if (not isInitialized()) { notify_formatted(true, "Illegal command before set-logic: pop"); } else { try { std::string str((**(n.children->begin())).getValue()); int num = std::stoi(str); pop(num); } catch (std::out_of_range const &ex) { notify_formatted(true, "Illegal pop command: %s", ex.what()); } } break; } case t_exit: { exit(); notify_success(); break; } default: { notify_formatted(true, "Unknown command encountered: %s", tokenToName.at(cmd.x).c_str()); } } } catch (OsmtApiException const &e) { notify_formatted(true, e.what()); } } bool Interpret::addLetFrame(ASTNode const & bindingsNode, LetRecords & letRecords) { std::vector> bindings; // First read the term declarations in the let statement for (ASTNode const* vb : *bindingsNode.children) { PTRef let_tr = parseTerm(**(vb->children->begin()), letRecords); if (let_tr == PTRef_Undef) return false; bindings.push_back({let_tr, vb->getValue()}); } // Only then insert them to the table for (auto const & [arg, name] : bindings) { if (logic->hasSym(name.c_str()) and logic->getSym(logic->symNameToRef(name.c_str())[0]).noScoping()) { notify_formatted(true, "Names marked as no scoping cannot be overloaded with let variables: %s", name.c_str()); return false; } letRecords.addBinding(name, arg); } return true; } // // Determine whether the term refers to some let definition // PTRef Interpret::letNameResolve(const char* s, const LetRecords& letRecords) const { return letRecords.getOrUndef(s); } PTRef Interpret::resolveQualifiedIdentifier(const char * name, ASTNode const & sort, bool isQuoted) { SRef sr = sortFromASTNode(sort); PTRef tr = PTRef_Undef; try { tr = resolveTerm(name, {}, sr, isQuoted ? SymbolMatcher::Uninterpreted : SymbolMatcher::Any); } catch (OsmtApiException & e) { reportError(e.what()); } return tr; } PTRef Interpret::resolveTerm(const char* s, vec&& args, SRef sortRef, SymbolMatcher symbolMatcher) { if (defined_functions.has(s)) { auto const & tpl = defined_functions[s]; return logic->instantiateFunctionTemplate(tpl, std::move(args)); } return logic->resolveTerm(s, std::move(args), sortRef, symbolMatcher); } PTRef Interpret::parseTerm(const ASTNode& term, LetRecords& letRecords) { ASTType t = term.getType(); if (t == TERM_T) { const char* name = (**(term.children->begin())).getValue(); // comment_formatted("Processing term %s", name); PTRef tr = PTRef_Undef; try { tr = logic->mkConst(name); } catch (OsmtApiException const & e) { comment_formatted("While processing %s: %s", name, e.what()); } return tr; } else if (t == QID_T) { if ((**(term.children->begin())).getType() == AS_T) { auto const & as_node = **(term.children->begin()); ASTNode const * symbolNode = (*as_node.children)[0]; bool isQuoted = symbolNode->getType() == QSYM_T; const char * name = (*as_node.children)[0]->getValue(); ASTNode const & sortNode = *(*as_node.children)[1]; assert(name != nullptr); PTRef tr = resolveQualifiedIdentifier(name, sortNode, isQuoted); return tr; } else { ASTNode const * symbolNode = (*(term.children->begin())); char const * name = symbolNode->getValue(); bool isQuoted = symbolNode->getType() == QSYM_T; assert(name != nullptr); PTRef tr = letNameResolve(name, letRecords); if (tr != PTRef_Undef) { return tr; } try { tr = resolveTerm(name, {}, SRef_Undef, isQuoted ? SymbolMatcher::Uninterpreted : SymbolMatcher::Any); } catch (OsmtApiException & e) { reportError(e.what()); } return tr; } } else if ( t == LQID_T ) { // Multi-argument term auto node_iter = term.children->begin(); vec args; const char* name = (**node_iter).getValue(); node_iter++; // Parse the arguments for (; node_iter != term.children->end(); node_iter++) { PTRef arg_term = parseTerm(**node_iter, letRecords); if (arg_term == PTRef_Undef) return PTRef_Undef; else args.push(arg_term); } assert(args.size() > 0); PTRef tr = PTRef_Undef; try { tr = resolveTerm(name, std::move(args)); } catch (ArithDivisionByZeroException &ex) { reportError(ex.what()); } catch (OsmtApiException &e) { reportError(e.what()); } return tr; } else if (t == LET_T) { // use RAII idiom to guard the scope of new LetFrame (and ensure the cleaup of names) class Guard { LetRecords& rec; public: Guard(LetRecords& rec): rec(rec) { rec.pushFrame(); } ~Guard() { rec.popFrame(); } } scopeGuard(letRecords); auto ch = term.children->begin(); bool success = addLetFrame(**ch, letRecords); if (not success) { comment_formatted("Let name addition failed"); return PTRef_Undef; } ch++; // This is now constructed with the let declarations context in let_branch PTRef tr = parseTerm(**(ch), letRecords); if (tr == PTRef_Undef) { comment_formatted("Failed in parsing the let scoped term"); return PTRef_Undef; } return tr; } else if (t == BANG_T) { assert(term.children->size() == 2); auto ch = term.children->begin(); ASTNode& named_term = **ch; ASTNode& attr_l = **(++ ch); assert(attr_l.getType() == GATTRL_T); assert(attr_l.children->size() == 1); ASTNode& name_attr = **(attr_l.children->begin()); PTRef tr = parseTerm(named_term, letRecords); if (tr == PTRef_Undef) return tr; if (strcmp(name_attr.getValue(), ":named") == 0) { ASTNode& sym = **(name_attr.children->begin()); assert(sym.getType() == SYM_T or sym.getType() == QSYM_T); if (nameToTerm.has(sym.getValue())) { notify_formatted(true, "name %s already exists", sym.getValue()); return PTRef_Undef; } char* name = strdup(sym.getValue()); // MB: term_names becomes the owner of the string and is responsible for deleting term_names.push(name); nameToTerm.insert(name, tr); if (!termToNames.has(tr)) { vec v; termToNames.insert(tr, v); } termToNames[tr].push(name); } return tr; } else comment_formatted("Unknown term type"); return PTRef_Undef; } sstat Interpret::checkSat() { sstat res; res = main_solver->check(); if (res == s_True) { notify_formatted(false, "sat"); } else if (res == s_False) notify_formatted(false, "unsat"); else notify_formatted(false, "unknown"); const Info& status = config.getInfo(":status"); if (!status.isEmpty()) { std::string statusString = status.toString(); if ((statusString.compare("sat") == 0) && (res == s_False)) { notify_formatted(false, "(error \"check status which says sat\")"); } else if ((statusString.compare("unsat") == 0) && (res == s_True)) { notify_formatted(false, "(error \"check status which says unsat\")"); } } if (res == s_Undef) { const SMTOption& o_dump_state = config.getOption(":dump-state"); const SpType o_split = config.sat_split_type(); char* name = config.dump_state(); if (!o_dump_state.isEmpty() && o_split == spt_none) writeState(name); free(name); } return res; } void Interpret::push(int n) { if (not config.isIncremental()) { notify_formatted(true, "push encountered but solver not in incremental mode"); } else { if (n < 0) { notify_formatted(true, "Incorrect push command, value is negative."); } else { while (n--) { defined_functions.pushScope(); main_solver->push(); } notify_success(); } } } void Interpret::pop(int n) { if (config.isIncremental()) { if (n < 0) { notify_formatted(true, "Incorrect pop command, value is negative."); } else { bool success = true; while (n-- and success) { success = main_solver->pop(); if (success) { defined_functions.popScope(); } } if (success) { notify_success(); } else { notify_formatted(true, "Attempt to pop beyond the top of the stack"); } } } else { notify_formatted(true, "pop encountered but solver not in incremental mode"); } } bool Interpret::getAssignment() { if (not isInitialized()) { notify_formatted(true, "Illegal command before set-logic"); return false; } if (main_solver->getStatus() != s_True) { notify_formatted(true, "Last solver call not satisfiable"); return false; } std::stringstream ss; ss << '('; for (int i = 0; i < term_names.size(); i++) { const char* name = term_names[i]; PTRef tr = nameToTerm[name]; lbool val = main_solver->getTermValue(tr); ss << '(' << name << ' ' << (val == l_True ? "true" : (val == l_False ? "false" : "unknown")) << ')' << (i < term_names.size() - 1 ? " " : ""); } ss << ')'; const std::string& out = ss.str(); notify_formatted(false, out.c_str()); return true; } namespace { // Helper for get-value command void printAstTermNode(ASTNode const & astNode) { ASTType t = astNode.getType(); if (t == TERM_T) { const char* name = (**(astNode.children->begin())).getValue(); std::cout << name; } else if (t == QID_T) { ASTNode const * symbolNode = (*(astNode.children->begin())); char const * name = symbolNode->getValue(); std::cout << name; } else if ( t == LQID_T ) { // Multi-argument term auto node_iter = astNode.children->begin(); const char* name = (**node_iter).getValue(); node_iter++; std::cout << "("; std::cout << name << " "; bool first = true; for (; node_iter != astNode.children->end(); node_iter++) { if (not first) { std::cout << " "; } printAstTermNode(**node_iter); first = false; } std::cout << ")"; } else if (t == BANG_T) { assert(astNode.children->size() == 2); auto ch = astNode.children->begin(); ASTNode& named_term = **ch; ASTNode& attr_l = **(++ ch); assert(attr_l.getType() == GATTRL_T); assert(attr_l.children->size() == 1); ASTNode& name_attr = **(attr_l.children->begin()); std::cout << "(!"; printAstTermNode(named_term); std::cout << " " << name_attr.getValue(); ASTNode const & sym = **(name_attr.children->begin()); assert(sym.getType() == SYM_T or sym.getType() == QSYM_T); std::cout << " " << sym.getValue(); std::cout << ')'; } else if (t == LET_T) { std::cout << "(let "; auto ch = astNode.children->begin(); // print bindings std::cout << '('; bool first = true; for (ASTNode const* vb : *(**ch).children) { if (not first) { std::cout << ' '; }; first = false; std::cout << "(" << vb->getValue() << " "; printAstTermNode(**vb->children->begin()); std::cout << ")"; } std::cout << ')'; // print final term ch++; std::cout << ' '; printAstTermNode(**ch); std::cout << ')'; } else { throw std::logic_error("Unsupported term type"); } } } void Interpret::getValue(std::vector const & terms) { auto model = main_solver->getModel(); Logic & logic = main_solver->getLogic(); using ValPair = opensmt::pair; std::vector values; for (auto termNode : terms) { ASTNode const & term = *termNode; LetRecords tmp; PTRef tr = parseTerm(term, tmp); if (tr != PTRef_Undef) { values.push_back({termNode, model->evaluate(tr)}); auto pt_str = logic.printTerm(tr); comment_formatted("Found the term %s", pt_str.c_str()); } else comment_formatted("Error parsing the term %s", (**(term.children->begin())).getValue()); } try { std::cout << '('; for (auto const & valPair : values) { std::cout << '('; printAstTermNode(*valPair.first); auto value = logic.printTerm(valPair.second); std::cout << " " << value << ')'; } std::cout << ')' << std::endl; } catch (std::logic_error & e) { reportError("Error in evaluating (get-value) command"); } } namespace { /* * This is a helper class to work around the limitation of ModelValidator * which does not like formal parameter with the same name as a variable already defined in the model previously. */ class NameClashResolver { public: NameClashResolver(Logic & logic) : logic(logic) {} void addForbiddenVar(PTRef var) { assert(logic.isVar(var)); forbiddenVars.insert(var); } void addFunction(SymRef sym) { functionsToCheck.insert(sym); } std::vector getSafeTemplates(Model const & model) { std::vector res; unsigned num = 0; for (SymRef symRef : functionsToCheck) { auto const & modelTemplate = model.getDefinition(symRef); if (hasClash(modelTemplate)) { auto const & oldArgs = modelTemplate.getArgs(); vec newArgs; newArgs.capacity(oldArgs.size()); Logic::SubstMap substMap; for (PTRef oldArg : oldArgs) { std::string name; PTRef var = PTRef_Undef; do { name = getSafePrefix(symRef) + std::to_string(num++); var = logic.mkVar(logic.getSortRef(oldArg), name.c_str()); } while (forbiddenVars.find(var) != forbiddenVars.end()); newArgs.push(var); substMap.insert(oldArg, var); } FunctionSignature templateSig(logic.protectName(symRef), std::move(newArgs), logic.getSortRef(symRef)); PTRef newBody = Substitutor(logic, substMap).rewrite(modelTemplate.getBody()); res.emplace_back(std::move(templateSig), newBody); } else { res.push_back(modelTemplate); } } return res; } private: Logic & logic; std::unordered_set forbiddenVars; std::unordered_set functionsToCheck; bool hasClash(TemplateFunction const & templateFunction) { auto const & args = templateFunction.getArgs(); return std::any_of(args.begin(), args.end(), [this](PTRef arg) { return forbiddenVars.find(arg) != forbiddenVars.end(); }); } std::string getSafePrefix(SymRef symref) { return logic.getSymName(symref)[0] == 'x' ? "y!" : "x!"; } }; } void Interpret::getModel() { auto model = main_solver->getModel(); NameClashResolver resolver(*logic); std::stringstream ss; ss << "(\n"; for (SymRef symref : user_declarations) { const Symbol & sym = logic->getSym(symref); if (sym.nargs() == 0) { // variable, just get its value const char* s = logic->getSymName(symref); SRef symSort = sym.rsort(); PTRef term = logic->mkVar(symSort, s); resolver.addForbiddenVar(term); PTRef val = model->evaluate(term); ss << printDefinitionSmtlib(term, val); } else { // function resolver.addFunction(symref); } } for (auto const & safeTempl : resolver.getSafeTemplates(*model)) { ss << printDefinitionSmtlib(safeTempl); } ss << ')'; std::cout << ss.str() << std::endl; } /** * * @param tr the term to print * @param val its value * @return the term value in an smtlib2 compliant format * Example: * (; U is sort of cardinality 2 * (define-fun a () U * (as @0 U)) * (define-fun b () U * (as @1 U)) * (define-fun f ((x U)) U * (ite (= x (as @1 U)) (as @0 U) * (as @1 U)) * ) * ) */ std::string Interpret::printDefinitionSmtlib(PTRef tr, PTRef val) { std::stringstream ss; auto s = logic->protectName(logic->getSymRef(tr)); SRef sortRef = logic->getSym(tr).rsort(); ss << " (define-fun " << s << " () " << logic->printSort(sortRef) << '\n'; ss << " " << logic->printTerm(val) << ")\n"; return ss.str(); } std::string Interpret::printDefinitionSmtlib(TemplateFunction const & templateFun) const { std::stringstream ss; ss << " (define-fun " << templateFun.getName() << " ("; vec const & args = templateFun.getArgs(); for (int i = 0; i < args.size(); i++) { auto sortString = logic->printSort(logic->getSortRef(args[i])); ss << "(" << logic->protectName(logic->getSymRef(args[i])) << " " << sortString << ")" << (i == args.size()-1 ? "" : " "); } ss << ")" << " " << logic->printSort(templateFun.getRetSort()) << "\n"; ss << " " << logic->printTerm(templateFun.getBody()) << ")\n"; return ss.str(); } void Interpret::writeState(const char* filename) { char* msg; bool rval; rval = main_solver->writeSolverState_smtlib2(filename, &msg); if (!rval) { notify_formatted("%s", msg); } } bool Interpret::declareFun(ASTNode const & n) // (const char* fname, const vec& args) { auto it = n.children->begin(); ASTNode const & name_node = **(it++); ASTNode const & args_node = **(it++); ASTNode const & ret_node = **(it++); assert(it == n.children->end()); const char* fname = name_node.getValue(); vec args; SRef retSort = sortFromASTNode(ret_node); if (retSort != SRef_Undef) { args.push(retSort); } else { notify_formatted(true, "Unknown return sort %s of %s", sortSymbolFromASTNode(ret_node).name.c_str(), fname); return false; } for (auto childNode : *(args_node.children)) { SRef argSort = sortFromASTNode(*childNode); if (argSort != SRef_Undef) { args.push(argSort); } else { notify_formatted(true, "Undefined sort %s in function %s", sortSymbolFromASTNode(*childNode).name.c_str(), fname); return false; } } SRef rsort = args[0]; vec args2; for (int i = 1; i < args.size(); i++) args2.push(args[i]); SymRef rval = logic->declareFun(fname, rsort, args2); if (rval == SymRef_Undef) { comment_formatted("Error while declare-fun %s", fname); return false; } user_declarations.push(rval); return true; } bool Interpret::declareConst(ASTNode& n) //(const char* fname, const SRef ret_sort) { assert(n.children and n.children->size() == 3); auto it = n.children->begin(); ASTNode const & name_node = **(it++); it++; // args_node ASTNode const & ret_node = **(it++); const char* fname = name_node.getValue(); SRef ret_sort = sortFromASTNode(ret_node); if (ret_sort == SRef_Undef) { notify_formatted(true, "Failed to declare constant %s", fname); notify_formatted(true, "Unknown return sort %s of %s", sortSymbolFromASTNode(ret_node).name.c_str(), fname); return false; } SymRef rval = logic->declareFun(fname, ret_sort, {}); if (rval == SymRef_Undef) { comment_formatted("Error while declare-const %s", fname); return false; } user_declarations.push(rval); notify_success(); return true; } bool Interpret::defineFun(const ASTNode& n) { auto it = n.children->begin(); ASTNode const & name_node = **(it++); ASTNode const & args_node = **(it++); ASTNode const & ret_node = **(it++); ASTNode const & term_node = **(it++); assert(it == n.children->end()); const char* fname = name_node.getValue(); // Get the argument sorts struct DefineFunArg { PTRef inner; std::string formalName; }; std::vector args; for (auto childNodePtr : *args_node.children) { ASTNode const & childNode = *childNodePtr; assert(childNode.children->size() == 1); ASTNode const & sortNode = **(childNode.children->begin()); SRef sortRef = sortFromASTNode(sortNode); if (sortRef == SRef_Undef) { notify_formatted(true, "Undefined sort %s in function %s", sortSymbolFromASTNode(sortNode).name.c_str(), fname); return false; } PTRef pvar = logic->mkVar(sortRef, TemplateFunction::nextFreeArgumentName().c_str()); std::string formalName = childNode.getValue(); args.push_back({.inner = pvar, .formalName = std::move(formalName)}); } // The return sort SRef ret_sort = sortFromASTNode(ret_node); if (ret_sort == SRef_Undef) { notify_formatted(true, "Unknown return sort %s of %s", sortSymbolFromASTNode(ret_node).name.c_str(), fname); return false; } sstat status; LetRecords letRecords; for (auto const & arg : args) { letRecords.addBinding(arg.formalName, arg.inner); } PTRef tr = parseTerm(term_node, letRecords); if (tr == PTRef_Undef) { notify_formatted(true, "define-fun returns an unknown sort"); return false; } else if (logic->getSortRef(tr) != ret_sort) { notify_formatted(true, "define-fun term and return sort do not match: %s and %s\n", logic->printSort(logic->getSortRef(tr)).c_str(), logic->printSort(ret_sort).c_str()); return false; } vec argTerms; argTerms.capacity(args.size()); for (auto const & arg : args) { argTerms.push(arg.inner); } bool rval = storeDefinedFun(fname, argTerms, ret_sort, tr); if (rval) notify_success(); else { notify_formatted(true, "define-fun failed"); return false; } return rval; } bool Interpret::storeDefinedFun(std::string const & fname, const vec & args, SRef ret_sort, const PTRef tr) { if (defined_functions.has(fname)) { return false; } bool scoped = not config.declarations_are_global(); defined_functions.insert(fname, TemplateFunction(fname, args, ret_sort, tr), scoped); return true; } void Interpret::comment_formatted(const char* fmt_str, ...) const { va_list ap; int d; char c1, *t; if (config.verbosity() < 2) return; std::cout << "; "; va_start(ap, fmt_str); while (true) { c1 = *fmt_str++; if (c1 == '%') { switch (*fmt_str++) { case 's': t = va_arg(ap, char *); std::cout << t; break; case 'd': d = va_arg(ap, int); std::cout << d; break; case '%': std::cout << '%'; break; } } else if (c1 != '\0') std::cout << c1; else break; } va_end(ap); std::cout << std::endl; } void Interpret::notify_formatted(bool error, const char* fmt_str, ...) { va_list ap; int d; char c1, *t; if (error) std::cout << "(error \""; va_start(ap, fmt_str); while (true) { c1 = *fmt_str++; if (c1 == '%') { switch (*fmt_str++) { case 's': t = va_arg(ap, char *); std::cout << t; break; case 'd': d = va_arg(ap, int); std::cout << d; break; case '%': std::cout << '%'; break; } } else if (c1 != '\0') std::cout << c1; else break; } va_end(ap); if (error) std::cout << "\")" << '\n'; std::cout << std::endl; } void Interpret::notify_success() { if (config.printSuccess()) { std::cout << "success" << std::endl; } } void Interpret::execute(const ASTNode* r) { auto i = r->children->begin(); for (; i != r->children->end() && !f_exit; i++) { interp(**i); delete *i; *i = nullptr; } } int Interpret::interpFile(FILE* in) { Smt2newContext context(in); int rval = smt2newparse(&context); if (rval != 0) return rval; const ASTNode* r = context.getRoot(); execute(r); return rval; } int Interpret::interpFile(char *content){ Smt2newContext context(content); int rval = smt2newparse(&context); if (rval != 0) return rval; const ASTNode* r = context.getRoot(); execute(r); return rval; } // For reading from pipe int Interpret::interpPipe() { int buf_sz = 16; char* buf = (char*) malloc(sizeof(char)*buf_sz); int rd_head = 0; int par = 0; int i = 0; bool inComment = false; bool inString = false; bool inQuotedSymbol = false; bool done = false; buf[0] = '\0'; while (!done) { assert(i >= 0 and i <= rd_head); assert(buf[rd_head] == '\0'); assert(rd_head < buf_sz); if (rd_head == buf_sz - 1) { buf_sz *= 2; buf = (char*) realloc(buf, sizeof(char)*buf_sz); } int rd_chunk = buf_sz - rd_head - 1; assert(rd_chunk > 0); int bts_rd = read(STDIN_FILENO, &buf[rd_head], rd_chunk); if (bts_rd == 0) { // Read EOF break; } if (bts_rd < 0) { // obtain the error string char const * err_str = strerror(errno); // format the error notify_formatted(true, err_str); break; } rd_head += bts_rd; buf[rd_head] = '\0'; for (; i < rd_head; i++) { char c = buf[i]; if (inComment || (not inQuotedSymbol and not inString and c == ';')) { inComment = (c != '\n'); } if (inComment) { continue; } assert(not inComment); if (inQuotedSymbol) { inQuotedSymbol = (c != '|'); } else if (not inString and c == '|') { inQuotedSymbol = true; } if (inQuotedSymbol) { continue; } assert (not inComment and not inQuotedSymbol); if (inString) { inString = (c != '\"'); } else if (c == '\"') { inString = true; } if (inString) { continue; } if (c == '(') { par ++; } else if (c == ')') { par --; if (par == 0) { // prepare parse buffer char* buf_out = (char*) malloc(sizeof(char)*i+2); // copy contents to the parse buffer for (int j = 0; j <= i; j++) buf_out[j] = buf[j]; buf_out[i+1] = '\0'; // copy the part after a top-level balanced parenthesis to the start of buf for (int j = i+1; j < rd_head; j++) buf[j-i-1] = buf[j]; buf[rd_head-i-1] = '\0'; // update the end position of buf to reflect the removal of the string to be parsed rd_head = rd_head-i-1; i = -1; // will be incremented to 0 by the loop condition. Smt2newContext context(buf_out); int rval = smt2newparse(&context); if (rval != 0) notify_formatted(true, "scanner"); else { const ASTNode* r = context.getRoot(); execute(r); done = f_exit; } free(buf_out); } if (par < 0) { notify_formatted(true, "pipe reader: unbalanced parentheses"); done = true; } } } } free(buf); return 0; } SortSymbol Interpret::sortSymbolFromASTNode(ASTNode const & node) { auto type = node.getType(); if (type == SYM_T or type == QSYM_T) { return {node.getValue(), 0}; } else { assert(type == LID_T and node.children and not node.children->empty()); ASTNode const & name = **(node.children->begin()); return {name.getValue(), static_cast(node.children->size() - 1)}; } } SRef Interpret::sortFromASTNode(ASTNode const & node) const { auto type = node.getType(); if (type == SYM_T or type == QSYM_T) { SortSymbol symbol(node.getValue(), 0); SSymRef symRef; bool known = logic->peekSortSymbol(symbol, symRef); if (not known) { return SRef_Undef; } return logic->getSort(symRef, {}); } else { assert(type == LID_T and node.children and not node.children->empty()); ASTNode const & name = **(node.children->begin()); SortSymbol symbol(name.getValue(), node.children->size() - 1); SSymRef symRef; bool known = logic->peekSortSymbol(symbol, symRef); if (not known) { return SRef_Undef; } vec args; for (auto it = node.children->begin() + 1; it != node.children->end(); ++it) { SRef argSortRef = sortFromASTNode(**it); if (argSortRef == SRef_Undef) { return SRef_Undef; } args.push(argSortRef); } return logic->getSort(symRef, std::move(args)); } assert(type == LID_T and node.children and not node.children->empty()); ASTNode const & name = **(node.children->begin()); SortSymbol symbol(name.getValue(), node.children->size() - 1); SSymRef symRef; bool known = logic->peekSortSymbol(symbol, symRef); if (not known) { return SRef_Undef; } vec args; for (auto it = node.children->begin() + 1; it != node.children->end(); ++it) { SRef argSortRef = sortFromASTNode(**it); if (argSortRef == SRef_Undef) { return SRef_Undef; } args.push(argSortRef); } return logic->getSort(symRef, std::move(args)); } void Interpret::getInterpolants(const ASTNode& n) { auto exps = *n.children; vec grouping; // Consists of PTRefs that we want to group LetRecords letRecords; letRecords.pushFrame(); for (auto key : nameToTerm.getKeys()) { letRecords.addBinding(key, nameToTerm[key]); } for (auto e : exps) { ASTNode& c = *e; PTRef tr = parseTerm(c, letRecords); // printf("Itp'ing a term %s\n", logic->pp(tr)); grouping.push(tr); } letRecords.popFrame(); if (!(config.produce_inter() > 0)) throw OsmtApiException("Cannot interpolate"); assert(grouping.size() >= 2); std::vector partitionings; ipartitions_t p = 0; // We assume that together the groupings cover all query, so we ignore the last argument, since that should contain all that was missing at that point for (int i = 0; i < grouping.size() - 1; i++) { PTRef group = grouping[i]; if (is_top_level_assertion(group)) { int assertion_index = get_assertion_index(group); assert(assertion_index >= 0); opensmt::setbit(p, static_cast(assertion_index)); } else { bool ok = group != PTRef_Undef && logic->isAnd(group); if (ok) { Pterm const & and_t = logic->getPterm(group); for (int j = 0; j < and_t.size(); j++) { PTRef tr = and_t[j]; ok = is_top_level_assertion(tr); if (!ok) { break; } int assertion_index = get_assertion_index(tr); assert(assertion_index >= 0); opensmt::setbit(p, static_cast(assertion_index)); } } if (!ok) { // error in interpolation command notify_formatted(true, "Invalid arguments of get-interpolants command"); return; } } partitionings.emplace_back(p); } if (main_solver->getStatus() != s_False) { notify_formatted(true, "Cannot interpolate, solver is not in UNSAT state!"); return; } auto interpolationContext = main_solver->getInterpolationContext(); // cerr << "Computing interpolant with mask " << p << endl; vec itps; if (partitionings.size() > 1) { interpolationContext->getPathInterpolants(itps, partitionings); } else { interpolationContext->getSingleInterpolant(itps, partitionings[0]); } for (int j = 0; j < itps.size(); j++) { auto itp = logic->pp(itps[j]); notify_formatted(false, "%s%s%s", (j == 0 ? "(" : " "), itp.c_str(), (j == itps.size() - 1 ? ")" : "")); } } bool Interpret::is_top_level_assertion(PTRef ref) { return get_assertion_index(ref) >= 0; } int Interpret::get_assertion_index(PTRef ref) { for (int i = 0; i < assertions.size(); ++i) { if (ref == assertions[i]) { return i;} } return -1; } void Interpret::initializeLogic(opensmt::Logic_t logicType) { logic.reset(opensmt::LogicFactory::getInstance(logicType)); } std::unique_ptr Interpret::createMainSolver(const char* logic_name) { return std::make_unique(*logic, config, std::string(logic_name) + " solver"); } opensmt-2.5.2/src/api/Interpret.h000066400000000000000000000177621445011647600167170ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ #ifndef API_INTERPRET_H #define API_INTERPRET_H #include "smt2newcontext.h" #include "SStore.h" #include "PtStructs.h" #include "SymRef.h" #include "Logic.h" #include "MainSolver.h" #include "ScopedVector.h" #include #include class DefinedFunctions { std::unordered_map defined_functions; opensmt::ScopedVector scopedNames; public: bool has(std::string const & name) const { return defined_functions.find(name) != defined_functions.end(); } void insert(std::string const & name, TemplateFunction && templ, bool scoped = false) { assert(not has(name)); defined_functions[name] = std::move(templ); if (scoped) { scopedNames.push(name); } } TemplateFunction & operator[](char const * name) { assert(has(name)); return defined_functions[name]; } void pushScope() { scopedNames.pushScope(); } void popScope() { scopedNames.popScope([&](std::string const & name) { defined_functions.erase(name); }); } }; class LetBinder { PTRef currentValue; vec shadowedValues; public: LetBinder(PTRef val) : currentValue(val) {} LetBinder(const LetBinder&) = delete; LetBinder& operator=(const LetBinder&) = delete; LetBinder(LetBinder&&) = default; LetBinder& operator=(LetBinder&&) = default; PTRef getValue() const { return currentValue; } bool hasShadowValue() const { return shadowedValues.size() != 0; } void restoreShadowedValue() { currentValue = shadowedValues.last(); shadowedValues.pop(); } void addValue(PTRef val) { shadowedValues.push(currentValue); currentValue = val; } }; class LetRecords { std::unordered_map letBinders; std::vector knownBinders; std::vector frameLimits; bool has(std::string const & name) const { return letBinders.find(name) != letBinders.end(); } public: PTRef getOrUndef(const char* letSymbol) const { auto it = letBinders.find(letSymbol); if (it != letBinders.end()) { return it->second.getValue(); } return PTRef_Undef; } void pushFrame() { frameLimits.push_back(knownBinders.size()); } void popFrame() { auto limit = frameLimits.back(); frameLimits.pop_back(); while (knownBinders.size() > limit) { std::string binder = std::move(knownBinders.back()); knownBinders.pop_back(); assert(this->has(binder)); auto& values = letBinders.at(binder); if (values.hasShadowValue()) { values.restoreShadowedValue(); } else { letBinders.erase(binder); } } } /** * Bind `name` to `arg` in this let scope. * @param name * @param arg */ void addBinding(std::string const & name, PTRef arg) { if (not this->has(name)) { letBinders.insert({name, LetBinder(arg)}); } else { letBinders.at(name).addValue(arg); } knownBinders.push_back(name); } }; class Interpret { protected: SMTConfig & config; std::unique_ptr logic; std::unique_ptr main_solver; bool f_exit; // Named terms for getting variable values MapWithKeys> nameToTerm; VecMap > termToNames; vec term_names; // For (! :named ) constructs. if Itp is enabled, this maps a // partition to it name. vec assertions; vec user_declarations; DefinedFunctions defined_functions; void initializeLogic(opensmt::Logic_t logicType); bool isInitialized() const { return logic != nullptr; } SRef sortFromASTNode(ASTNode const & n) const; static SortSymbol sortSymbolFromASTNode(ASTNode const & node); void setInfo(ASTNode& n); void getInfo(ASTNode& n); void setOption(ASTNode& n); void getOption(ASTNode& n); void writeState(const char* fname); bool declareFun(ASTNode const & n); //(const char* fname, const vec& args); bool declareConst(ASTNode& n); //(const char* fname, const SRef ret_sort); bool defineFun(const ASTNode& n); virtual sstat checkSat(); void getValue(std::vector const & terms); void getModel(); std::string printDefinitionSmtlib(PTRef tr, PTRef val); std::string printDefinitionSmtlib(const TemplateFunction &templateFun) const; void push(int); void pop(int); PTRef parseTerm(const ASTNode& term, LetRecords& letRecords); PTRef resolveTerm(const char* s, vec&& args, SRef sortRef = SRef_Undef, SymbolMatcher symbolMatcher = SymbolMatcher::Any); bool storeDefinedFun(std::string const & fname, const vec& args, SRef ret_sort, const PTRef tr); virtual void exit(); void getInterpolants(const ASTNode& n); void interp (ASTNode& n); void notify_formatted(bool error, const char* s, ...); void notify_success(); void comment_formatted(const char* s, ...) const; bool addLetFrame(ASTNode const & bindingsNode, LetRecords& letRecords); PTRef letNameResolve(const char* s, const LetRecords& letRecords) const; PTRef resolveQualifiedIdentifier(const char * name, ASTNode const & sort, bool isQuoted); virtual std::unique_ptr createMainSolver(const char* logic_name); public: Interpret(SMTConfig & c) : config (c) , f_exit (false) { } ~Interpret(); int interpFile(FILE* in); int interpFile(char *content); int interpPipe(); void execute(const ASTNode* n); bool gotExit() const { return f_exit; } bool getAssignment (); void reportError(char const * msg) { notify_formatted(true, msg); } PTRef getParsedFormula(); vec& getAssertions() { return assertions; } bool is_top_level_assertion(PTRef ref); int get_assertion_index(PTRef ref); MainSolver& getMainSolver() { return *main_solver; } }; #endif opensmt-2.5.2/src/api/MainSolver.cc000066400000000000000000000315541445011647600171530ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ #include "MainSolver.h" #include "BoolRewriting.h" #include "LookaheadSMTSolver.h" #include "GhostSMTSolver.h" #include "UFLATheory.h" #include "LATheory.h" #include "LATHandler.h" #include "ArrayTheory.h" #include "OsmtApiException.h" #include "ModelBuilder.h" #include "IteHandler.h" #include "RDLTHandler.h" #include "IDLTHandler.h" #include #include namespace opensmt { bool stop; } void MainSolver::push() { bool alreadyUnsat = isLastFrameUnsat(); frames.push(pfstore.alloc()); if (alreadyUnsat) { rememberLastFrameUnsat(); } } bool MainSolver::pop() { if (frames.size() > 1) { if (config.produce_inter() > 0) { auto toPop = frames.last(); auto& partitionsToInvalidate = pfstore[toPop].formulas; ipartitions_t mask = 0; for (int i = 0; i < partitionsToInvalidate.size(); ++i) { PTRef part = partitionsToInvalidate[i]; auto index = pmanager.getPartitionIndex(part); assert(index != -1); opensmt::setbit(mask, static_cast(index)); } pmanager.invalidatePartitions(mask); } frames.pop(); if (!isLastFrameUnsat()) { getSMTSolver().restoreOK(); } return true; } else return false; } sstat MainSolver::push(PTRef root) { push(); char* msg; sstat res = insertFormula(root, &msg); if (res == s_Error) printf("%s\n", msg); return res; } void MainSolver::insertFormula(PTRef fla) { char* msg; auto res = insertFormula(fla, &msg); if (res == s_Error) { OsmtApiException ex(msg); free(msg); throw ex; } } sstat MainSolver::insertFormula(PTRef root, char** msg) { if (logic.getSortRef(root) != logic.getSort_bool()) { int chars_written = asprintf(msg, "Top-level assertion sort must be %s, got %s", Logic::s_sort_bool, logic.printSort(logic.getSortRef(root)).c_str()); (void)chars_written; return s_Error; } root = logic.conjoinExtras(root); root = IteHandler(logic, getPartitionManager().getNofPartitions()).rewrite(root); if (getConfig().produce_inter()) { // MB: Important for HiFrog! partition index is the index of the formula in an virtual array of inserted formulas, // thus we need the old value of count. TODO: Find a good interface for this so it cannot be broken this easily unsigned int partition_index = inserted_formulas_count++; pmanager.assignTopLevelPartitionIndex(partition_index, root); assert(pmanager.getPartitionIndex(root) != -1); } else { ++inserted_formulas_count; } PushFrame& lastFrame = pfstore[frames.last()]; lastFrame.push(root); lastFrame.root = PTRef_Undef; // New formula has been added to the last frame. If the frame has been simplified before, we need to do it again frames.setSimplifiedUntil(std::min(frames.getSimplifiedUntil(), frames.size() - 1)); return s_Undef; } sstat MainSolver::simplifyFormulas() { status = s_Undef; vec coll_f; bool keepPartitionsSeparate = getConfig().produce_inter(); // Process (and simplify) not yet processed frames. Stop processing if solver is in UNSAT state already for (std::size_t i = frames.getSimplifiedUntil(); i < frames.size() && status != s_False; i++) { getTheory().simplify(frames.getFrameReferences(), pmanager, i); frames.setSimplifiedUntil(i + 1); const PushFrame & frame = pfstore[frames.getFrameReference(i)]; if (keepPartitionsSeparate) { vec const & flas = frame.formulas; if (flas.size() == 0 or std::all_of(flas.begin(), flas.end(), [&](PTRef fla) { return fla == logic.getTerm_true(); })) { pmanager.assignTopLevelPartitionIndex(0, logic.getTerm_true()); status = giveToSolver(logic.getTerm_true(), frame.getId()); continue; } for (int j = 0; j < flas.size() && status != s_False; ++j) { PTRef fla = flas[j]; if (fla == logic.getTerm_true()) { continue; } assert(pmanager.getPartitionIndex(fla) != -1); // Optimize the dag for cnfization if (logic.isBooleanOperator(fla)) { PTRef old = fla; fla = rewriteMaxArity(fla); pmanager.transferPartitionMembership(old, fla); } assert(pmanager.getPartitionIndex(fla) != -1); pmanager.propagatePartitionMask(fla); status = giveToSolver(fla, frame.getId()); } } else { PTRef root = frame.root; if (logic.isFalse(root)) { giveToSolver(getLogic().getTerm_false(), frame.getId()); status = s_False; break; } // Optimize the dag for cnfization if (logic.isBooleanOperator(root)) { root = rewriteMaxArity(root); } root_instance.setRoot(root); status = giveToSolver(root, frame.getId()); } } if (status == s_False) { rememberUnsatFrame(frames.getSimplifiedUntil() - 1); } return status; } // Replace subtrees consisting only of ands / ors with a single and / or term. // Search a maximal section of the tree consisting solely of ands / ors. The // root of this subtree is called and / or root. Collect the subtrees rooted at // the leaves of this section, and create a new and / or term with the leaves as // arguments and the parent of the and / or tree as the parent. // // However, we will do this in a clever way so that if a certain // term appears as a child in more than one term, we will not flatten // that structure. // PTRef MainSolver::rewriteMaxArity(PTRef root) { return ::rewriteMaxArityClassic(logic, root); } std::unique_ptr MainSolver::getModel() { ModelBuilder modelBuilder {logic}; ts.solver.fillBooleanVars(modelBuilder); thandler->fillTheoryFunctions(modelBuilder); return modelBuilder.build(); } std::unique_ptr MainSolver::getInterpolationContext() { if (status != s_False) { throw OsmtApiException("Interpolation context cannot be created if solver is not in UNSAT state"); } return std::make_unique( config, *theory, *term_mapper, getSMTSolver().getProof(), pmanager ); } bool MainSolver::writeSolverState_smtlib2(const char* file, char** msg) const { char* name; int written = asprintf(&name, "%s.smt2", file); assert(written >= 0); std::ofstream file_s; file_s.open(name); if (file_s.is_open()) { logic.dumpHeaderToFile(file_s); logic.dumpFormulaToFile(file_s, root_instance.getRoot()); logic.dumpChecksatToFile(file_s); file_s.close(); } else { written = asprintf(msg, "Failed to open file %s\n", name); assert(written >= 0); free(name); return false; } (void)written; free(name); return true; } void MainSolver::printFramesAsQuery() const { char* base_name = config.dump_query_name(); if (base_name == NULL) getTheory().printFramesAsQuery(frames.getFrameReferences(), std::cout); else { char* s_file_name; int chars_written = asprintf(&s_file_name, "%s-%d.smt2", base_name, check_called); (void)chars_written; std::ofstream stream; stream.open(s_file_name); getTheory().printFramesAsQuery(frames.getFrameReferences(), stream); stream.close(); free(s_file_name); } free(base_name); } sstat MainSolver::check() { check_called ++; if (config.timeQueries()) { printf("; %s query time so far: %f\n", solver_name.c_str(), query_timer.getTime()); opensmt::StopWatch sw(query_timer); } if (isLastFrameUnsat()) { return s_False; } initialize(); sstat rval = simplifyFormulas(); if (config.dump_query()) printFramesAsQuery(); if (rval == s_Undef) { try { rval = solve(); } catch (std::overflow_error const& error) { rval = s_Error; } if (rval == s_False) { assert(not smt_solver->isOK()); rememberUnsatFrame(smt_solver->getConflictFrame()); } } return rval; } sstat MainSolver::solve() { if (!smt_solver->isOK()){ return s_False; } vec en_frames; for (std::size_t i = 0; i < frames.size(); i++) { const PushFrame& frame = pfstore[frames.getFrameReference(i)]; en_frames.push(frame.getId()); } status = sstat(solve_(en_frames)); if (status == s_True && config.produce_models()) thandler->computeModel(); smt_solver->clearSearch(); return status; } std::unique_ptr MainSolver::createInnerSolver(SMTConfig & config, THandler & thandler) { if (config.sat_pure_lookahead()) { return std::make_unique(config, thandler); } else if (config.use_ghost_vars()) { return std::make_unique(config, thandler); } else if (config.sat_picky()) { return std::make_unique(config, thandler); } else { return std::make_unique(config, thandler); } } std::unique_ptr MainSolver::createTheory(Logic & logic, SMTConfig & config) { using Logic_t = opensmt::Logic_t; Logic_t logicType = logic.getLogic(); Theory* theory = nullptr; switch (logicType) { case Logic_t::QF_UF: case Logic_t::QF_BOOL: { theory = new UFTheory(config, logic); break; } case Logic_t::QF_AX: { theory = new ArrayTheory(config, logic); break; } case Logic_t::QF_CUF: case Logic_t::QF_BV: { BVLogic & bvLogic = dynamic_cast(logic); theory = new CUFTheory(config, bvLogic); break; } case Logic_t::QF_LRA: { ArithLogic & lraLogic = dynamic_cast(logic); theory = new LATheory(config, lraLogic); break; } case Logic_t::QF_LIA: { ArithLogic & liaLogic = dynamic_cast(logic); theory = new LATheory(config, liaLogic); break; } case Logic_t::QF_RDL: { ArithLogic& lraLogic = dynamic_cast(logic); theory = new LATheory(config, lraLogic); break; } case Logic_t::QF_IDL: { ArithLogic & liaLogic = dynamic_cast(logic); theory = new LATheory(config, liaLogic); break; } case Logic_t::QF_UFRDL: case Logic_t::QF_UFIDL: case Logic_t::QF_UFLRA: case Logic_t::QF_UFLIA: case Logic_t::QF_ALRA: case Logic_t::QF_ALIA: case Logic_t::QF_AUFLRA: case Logic_t::QF_AUFLIA: case Logic_t::QF_AUFLIRA: { ArithLogic & laLogic = dynamic_cast(logic); theory = new UFLATheory(config, laLogic); break; } case Logic_t::UNDEF: throw OsmtApiException{"Error in creating reasoning engine: Engige type not specified"}; break; default: assert(false); throw std::logic_error{"Unreachable code - error in logic selection"}; }; return std::unique_ptr(theory); } opensmt-2.5.2/src/api/MainSolver.h000066400000000000000000000207741445011647600170170ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ #ifndef MAINSOLVER_H #define MAINSOLVER_H #include "Tseitin.h" #include "SimpSMTSolver.h" #include "Model.h" #include "PartitionManager.h" #include "InterpolationContext.h" #include class Logic; class sstat { char value; public: explicit sstat(int v) : value(v) {} bool operator == (sstat s) const { return value == s.value; } bool operator != (sstat s) const { return value != s.value; } sstat() : value(0) {} sstat(lbool l) { if (l == l_True) value = 1; else if (l == l_False) value = -1; else if (l == l_Undef) value = 0; else assert(false); } char getValue() const { return value; } friend sstat toSstat(int v); }; inline sstat toSstat(int v) {return sstat(v); } const sstat s_True = toSstat( 1); const sstat s_False = toSstat(-1); const sstat s_Undef = toSstat( 0); const sstat s_Error = toSstat( 2); class MainSolver { protected: class PushFramesWrapper { private: vec frames; std::size_t simplified_until = 0; // The frame have been simplified up to (excluding) frames[simplified_until]. public: PFRef last() const { assert(frames.size() > 0); return frames.last(); } std::size_t size() const { return frames.size_(); } const vec& getFrameReferences() const { return frames; } PFRef getFrameReference(std::size_t i) const { return frames[i]; } std::size_t getSimplifiedUntil() const { return simplified_until; } void setSimplifiedUntil(std::size_t n) { simplified_until = n; } void push(PFRef frame_ref) { frames.push(frame_ref); } void pop() { frames.pop(); if (simplified_until > size()) { simplified_until = size(); } } }; std::unique_ptr theory; std::unique_ptr term_mapper; std::unique_ptr thandler; std::unique_ptr smt_solver; Logic& logic; PartitionManager pmanager; SMTConfig& config; PushFrameAllocator& pfstore; Tseitin ts; PushFramesWrapper frames; opensmt::OSMTTimeVal query_timer; // How much time we spend solving. std::string solver_name; // Name for the solver int check_called; // A counter on how many times check was called. sstat status; // The status of the last solver call (initially s_Undef) unsigned int inserted_formulas_count = 0; // Number of formulas that has been inserted to this solver class FContainer { PTRef root; public: FContainer(PTRef r) : root(r) {} void setRoot (PTRef r) { root = r; } PTRef getRoot () const { return root; } }; FContainer root_instance; // Contains the root of the instance once simplifications are done sstat solve (); virtual sstat solve_(vec & enabledFrames) { return ts.solve(enabledFrames); } sstat giveToSolver(PTRef root, FrameId push_id) { if (ts.cnfizeAndGiveToSolver(root, push_id) == l_False) return s_False; return s_Undef; } PTRef rewriteMaxArity(PTRef); // helper private methods PushFrame& getLastFrame() const { return pfstore[frames.last()]; } bool isLastFrameUnsat() const { return getLastFrame().unsat; } void rememberLastFrameUnsat() { getLastFrame().unsat = true; } void rememberUnsatFrame(std::size_t frameIndex) { assert(frameIndex < frames.size()); for (; frameIndex < frames.size(); ++frameIndex) { pfstore[frames.getFrameReference(frameIndex)].unsat = true; } } static std::unique_ptr createInnerSolver(SMTConfig& config, THandler& thandler); public: MainSolver(Logic& logic, SMTConfig& conf, std::string name) : theory(createTheory(logic, conf)), term_mapper(new TermMapper(logic)), thandler(new THandler(getTheory(), *term_mapper)), smt_solver(createInnerSolver(conf, *thandler)), logic(thandler->getLogic()), pmanager(logic), config(conf), pfstore(getTheory().pfstore), ts( config, logic, pmanager, *term_mapper, *smt_solver ), solver_name {std::move(name)}, check_called(0), status(s_Undef), root_instance(logic.getTerm_true()) { conf.setUsedForInitiliazation(); frames.push(pfstore.alloc()); PushFrame& last = pfstore[frames.last()]; last.push(logic.getTerm_true()); } MainSolver(std::unique_ptr th, std::unique_ptr tm, std::unique_ptr thd, std::unique_ptr ss, Logic & logic, SMTConfig & conf, std::string name) : theory(std::move(th)), term_mapper(std::move(tm)), thandler(std::move(thd)), smt_solver(std::move(ss)), logic(thandler->getLogic()), pmanager(logic), config(conf), pfstore(getTheory().pfstore), ts( config, logic, pmanager, *term_mapper, *smt_solver ), solver_name {std::move(name)}, check_called(0), status(s_Undef), root_instance(logic.getTerm_true()) { conf.setUsedForInitiliazation(); frames.push(pfstore.alloc()); PushFrame& last = pfstore[frames.last()]; last.push(logic.getTerm_true()); } virtual ~MainSolver() = default; SMTConfig& getConfig() { return config; } SimpSMTSolver& getSMTSolver() { return *smt_solver; } SimpSMTSolver const & getSMTSolver() const { return *smt_solver; } THandler &getTHandler() { return *thandler; } Logic &getLogic() { return logic; } Theory &getTheory() { return *theory; } const Theory &getTheory() const { return *theory; } PartitionManager &getPartitionManager() { return pmanager; } sstat push(PTRef root); void push(); bool pop(); sstat insertFormula(PTRef root, char** msg); void insertFormula(PTRef fla); void initialize() { ts.solver.initialize(); ts.initialize(); } virtual sstat check(); // A wrapper for solve which simplifies the loaded formulas and initializes the solvers // Simplify frames (not yet simplified) until all are simplified or the instance is detected unsatisfiable. sstat simplifyFormulas(); void printFramesAsQuery() const; sstat getStatus () const { return status; } bool solverEmpty () const { return ts.solverEmpty(); } bool writeSolverState_smtlib2 (const char* file, char** msg) const; // Values lbool getTermValue (PTRef tr) const { return ts.getTermValue(tr); } // Returns model of the last query (must be in satisfiable state) std::unique_ptr getModel(); void stop() { ts.solver.stop = true; } // Returns interpolation context for the last query (must be in UNSAT state) std::unique_ptr getInterpolationContext(); static std::unique_ptr createTheory(Logic & logic, SMTConfig & config); }; #endif // opensmt-2.5.2/src/api/OpenSMTConfig.cmake.in000066400000000000000000000004501445011647600205760ustar00rootroot00000000000000include(CMakeFindDependencyMacro) list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}) find_dependency(Threads REQUIRED) find_dependency(GMP REQUIRED) @PACKAGE_INIT@ include("${CMAKE_CURRENT_LIST_DIR}/OpenSMTTargets.cmake") check_required_components(opensmt) #message("Config file used") opensmt-2.5.2/src/api/Opensmt.cc000066400000000000000000000040251445011647600165120ustar00rootroot00000000000000#include "Opensmt.h" #include "LogicFactory.h" namespace{ opensmt::Logic_t convert(opensmt_logic logic) { switch (logic) { case qf_lra: return opensmt::Logic_t::QF_LRA; case qf_lia: return opensmt::Logic_t::QF_LIA; case qf_bool: return opensmt::Logic_t::QF_BOOL; case qf_bv: return opensmt::Logic_t::QF_BV; case qf_uf: return opensmt::Logic_t::QF_UF; case qf_cuf: return opensmt::Logic_t::QF_CUF; case qf_idl: return opensmt::Logic_t::QF_IDL; case qf_rdl: return opensmt::Logic_t::QF_RDL; case qf_ufidl: return opensmt::Logic_t::QF_UFIDL; case qf_uflra: return opensmt::Logic_t::QF_UFLRA; case qf_ufrdl: return opensmt::Logic_t::QF_UFRDL; case qf_uflia: return opensmt::Logic_t::QF_UFLIA; case qf_ax: return opensmt::Logic_t::QF_AX; case qf_alra: return opensmt::Logic_t::QF_ALRA; case qf_alia: return opensmt::Logic_t::QF_ALIA; case qf_auflra: return opensmt::Logic_t::QF_AUFLRA; case qf_auflia: return opensmt::Logic_t::QF_AUFLIA; case qf_auflira: return opensmt::Logic_t::QF_AUFLIRA; default: return opensmt::Logic_t::UNDEF; } } } Opensmt::Opensmt(opensmt_logic _logic, const char* name) { config = std::unique_ptr(new SMTConfig()); logic.reset(opensmt::LogicFactory::getInstance(convert(_logic))); mainSolver = std::unique_ptr(new MainSolver(*logic, *config, name)); mainSolver->initialize(); } Opensmt::Opensmt(opensmt_logic logic_, const char* name, std::unique_ptr config_) { this->config = std::move(config_); logic.reset(opensmt::LogicFactory::getInstance(convert(logic_))); mainSolver = std::unique_ptr(new MainSolver(*logic, *this->config, name)); mainSolver->initialize(); } Opensmt::~Opensmt() { } opensmt-2.5.2/src/api/Opensmt.h000066400000000000000000000041241445011647600163540ustar00rootroot00000000000000#ifndef OPENSMT_H #define OPENSMT_H #include "SMTConfig.h" #include "MainSolver.h" #include "Logic.h" #include "ArithLogic.h" #include typedef enum { qf_uf // Uninterpreted Functions , qf_cuf // Uninterpreted Functions for C , qf_bv // BitVectors , qf_rdl // Real difference logics , qf_idl // Integer difference logics , qf_lra // Real linear arithmetic , qf_lia // Integer linear arithmetic , qf_ufrdl // UF + RDL , qf_ufidl // UF + IDL , qf_uflra // UF + LRA , qf_uflia // UF + LIA , qf_ax // Arrays with extensionality , qf_alra // Arrays + LRA , qf_alia // Arrays + LIA , qf_auflra // Arrays + UF + LRA , qf_auflia // Arrays + UF + LIA , qf_bool // Only booleans , qf_auflira // Arrays + UF + (LIA or LRA) } opensmt_logic; class Opensmt { public: Opensmt(opensmt_logic _logic, const char* name); /** * Constructor for OpenSMT instance where user user can passed its open configuration. * Useful for example when interpolation needs to be enabled * Note that this object takes ownership of the passed pointer * * @param _logic SMT-LIB logic that OpenSMT instance will operate in * @param name Name for the solver instance * @param config Configuration for the OpenSMT instance */ Opensmt(opensmt_logic _logic, const char* name, std::unique_ptr config); ~Opensmt(); SMTConfig& getConfig() { return *config; } Logic& getLogic() { return *logic; } ArithLogic& getLRALogic() { return dynamic_cast(*logic); } ArithLogic& getLIALogic() { return dynamic_cast(*logic); } CUFLogic& getCUFLogic() { return dynamic_cast(*logic); } MainSolver& getMainSolver() { return *mainSolver; } SimpSMTSolver& getSolver() { return getMainSolver().getSMTSolver(); } private: std::unique_ptr config; std::unique_ptr logic; std::unique_ptr mainSolver; }; #endif //OPENSMT_H opensmt-2.5.2/src/api/PartitionManager.cc000066400000000000000000000063411445011647600203340ustar00rootroot00000000000000/* * Copyright (c) 2020 - 2022, Antti Hyvarinen * Copyright (c) 2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #include "PartitionManager.h" #include "TreeOps.h" #include "OsmtInternalException.h" void PartitionManager::propagatePartitionMask(PTRef root) { ipartitions_t& p = getIPartitions(root); std::vector seen; // MB: Relies on invariant: Every subterm was created before its parent, so it has lower id auto size = Idx(logic.getPterm(root).getId()) + 1; seen.resize(size, false); std::vector queue {root}; while (!queue.empty()) { PTRef current = queue.back(); queue.pop_back(); const Pterm& c_term = logic.getPterm(current); auto id = Idx(c_term.getId()); assert(id < size); if (!seen[id]) { addIPartitions(current, p); for (int j = 0; j < c_term.size(); ++j) { queue.push_back(c_term[j]); } if (logic.isUF(current) || logic.isUP(current)) { addIPartitions(c_term.symb(), p); } seen[id] = true; } } } ipartitions_t PartitionManager::computeAllowedPartitions(PTRef p) { vec vars = variables(logic, p); if (vars.size() == 0) { return 0; } ipartitions_t allowed = getIPartitions(vars[0]); for (int i = 1; i < vars.size(); ++i) { allowed &= getIPartitions(vars[i]); } return allowed; } using opensmt::isAlocal; using opensmt::isBlocal; PTRef PartitionManager::getPartition(const ipartitions_t& mask, PartitionManager::part p) { auto isLocalToP = [p](const ipartitions_t& p_mask, const ipartitions_t& mask){ return p == part::A ? isAlocal(p_mask, mask) : isBlocal(p_mask, mask); }; auto hasNoPartition = [](const ipartitions_t& p_mask, const ipartitions_t&mask) { return !isAlocal(p_mask, mask) and !isBlocal(p_mask, mask); }; auto parts = getPartitions(); vec args; for (auto part : parts) { int partitionIndex = getPartitionIndex(part); if (partitionIndex < 0) { throw OsmtInternalException("Internal error in partition bookkeeping"); } ipartitions_t p_mask = 0; opensmt::setbit(p_mask, static_cast(partitionIndex)); if (isLocalToP(p_mask, mask)) { args.push(part); } else if (hasNoPartition(p_mask, mask)) { throw OsmtInternalException("Assertion is neither A or B"); } } PTRef requestedPartition = logic.mkAnd(std::move(args)); return requestedPartition; } vec PartitionManager::getPartitions(ipartitions_t const & mask) const { vec res; for (PTRef topLevelPartition : getPartitions()) { int index = getPartitionIndex(topLevelPartition); assert(index >= 0); if (opensmt::tstbit(mask, static_cast(index))) { res.push(topLevelPartition); } } return res; } void PartitionManager::addClauseClassMask(CRef c, const ipartitions_t& toadd) { partitionInfo.addClausePartition(c, toadd); } void PartitionManager::invalidatePartitions(const ipartitions_t& toinvalidate) { partitionInfo.invalidatePartitions(toinvalidate); } opensmt-2.5.2/src/api/PartitionManager.h000066400000000000000000000042321445011647600201730ustar00rootroot00000000000000/* * Copyright (c) 2020 - 2022, Antti Hyvarinen * Copyright (c) 2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #ifndef OPENSMT_PARTITIONMANAGER_H #define OPENSMT_PARTITIONMANAGER_H #include "PartitionInfo.h" #include "Logic.h" class PartitionManager { PartitionInfo partitionInfo; Logic & logic; public: PartitionManager(Logic & l) : logic(l) { // MB: TODO: Is this necessary? ipartitions_t mask = 0; mask = ~mask; addIPartitions(logic.getTerm_true(), mask); addIPartitions(logic.getTerm_false(), mask); } enum class part { A, B }; PTRef getPartition(const ipartitions_t &, part); //partitions: ipartitions_t & getIPartitions(PTRef _t) { return partitionInfo.getIPartitions(_t); } void addIPartitions(PTRef _t, const ipartitions_t & _p) { partitionInfo.addIPartitions(_t, _p); } ipartitions_t & getIPartitions(SymRef _s) { return partitionInfo.getIPartitions(_s); } void addIPartitions(SymRef _s, const ipartitions_t & _p) { partitionInfo.addIPartitions(_s, _p); } void propagatePartitionMask(PTRef tr); void assignTopLevelPartitionIndex(unsigned int n, PTRef tr) { partitionInfo.assignTopLevelPartitionIndex(n, tr); } ipartitions_t computeAllowedPartitions(PTRef p); const ipartitions_t & getClauseClassMask(CRef c) const { return partitionInfo.getClausePartitions(c); } void addClauseClassMask(CRef c, const ipartitions_t & toadd); void invalidatePartitions(const ipartitions_t & toinvalidate); inline std::vector getPartitions() const { return partitionInfo.getTopLevelFormulas(); } vec getPartitions(ipartitions_t const &) const; unsigned getNofPartitions() const { return partitionInfo.getNoOfPartitions(); } void transferPartitionMembership(PTRef old, PTRef new_ptref) { this->addIPartitions(new_ptref, getIPartitions(old)); partitionInfo.transferPartitionMembership(old, new_ptref); } int getPartitionIndex(PTRef ref) const { return partitionInfo.getPartitionIndex(ref); } }; #endif //OPENSMT_PARTITIONMANAGER_H opensmt-2.5.2/src/api/smt2tokens.h000066400000000000000000000104211445011647600170350ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2016 Antti Hyvarinen 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. *********************************************************************/ #ifndef APITOKENS_H #define APITOKENS_H #include #include #include namespace osmttokens { // // The names for the tokens in the API for smtlib // enum token { t_none, t_as, t_DECIMAL, t_NUMERAL, t_par, t_STRING, t_exists, t_forall, t_assert, t_checksat, t_declaresort, t_definesort, t_declarefun, t_declareconst, t_definefun, t_exit, t_getassertions, t_getassignment, t_getinfo, t_setinfo, t_getoption, t_setoption, t_getproof, t_getunsatcore, t_getvalue, t_getmodel, t_pop, t_push, t_setlogic, t_getinterpolants, t_theory, t_writestate, t_readstate, t_simplify, t_let, t_echo }; inline const std::unordered_set tokenNames = { "none", "as", "decimal", "numeral", "par", "string", "exists", "forall", "assert", "check-sat", "declare-sort", "define-sort", "declare-fun", "declare-const", "define-fun", "exit", "get-assertions", "get-assignment", "get-info", "set-info", "get-option", "set-option", "get-proof", "get-unsat-core", "get-value", "get-model", "pop", "push", "set-logic", "get-interpolants", "theory", "write-state", "read-state", "simplify", "write-funs", "let", "echo" }; inline const std::unordered_map tokenToName = { {t_none, "none"}, {t_as, "as"}, {t_DECIMAL, "decimal"}, {t_NUMERAL, "numeral"}, {t_par, "par"}, {t_STRING, "string"}, {t_exists, "exists"}, {t_forall, "forall"}, {t_assert, "assert"}, {t_checksat, "check-sat"}, {t_declaresort, "declare-sort"}, {t_definesort, "define-sort"}, {t_declarefun, "declare-fun"}, {t_declareconst, "declare-const"}, {t_definefun, "define-fun"}, {t_exit, "exit"}, {t_getassertions, "get-assertions"}, {t_getassignment, "get-assignment"}, {t_getinfo, "get-info"}, {t_setinfo, "set-info"}, {t_getoption, "get-option"}, {t_setoption, "set-option"}, {t_getproof, "get-proof"}, {t_getunsatcore, "get-unsat-core"}, {t_getvalue, "get-value"}, {t_getmodel, "get-model"}, {t_pop, "pop"}, {t_push, "push"}, {t_setlogic, "set-logic"}, {t_getinterpolants, "get-interpolants"}, {t_theory, "theory"}, {t_writestate, "write-state"}, {t_readstate, "read-state"}, {t_simplify, "simplify"}, {t_let, "let"}, {t_echo, "echo"} }; struct smt2token { token x; }; } #endif opensmt-2.5.2/src/bin/000077500000000000000000000000001445011647600145545ustar00rootroot00000000000000opensmt-2.5.2/src/bin/CMakeLists.txt000066400000000000000000000014421445011647600173150ustar00rootroot00000000000000add_executable(OpenSMT-bin opensmt.cc) set_target_properties(OpenSMT-bin PROPERTIES NO_SYSTEM_FROM_IMPORTED true # For some reason on MAC OS build in travis, the .cc files from this target were compiled with -isystem /usr/include and that was messing up the search order of include paths; This seems to fix it OUTPUT_NAME opensmt RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}") if (ENABLE_LINE_EDITING) if (NOT USE_READLINE) find_package(LibEdit REQUIRED) target_link_libraries(OpenSMT-bin PUBLIC LibEdit::LibEdit) else() find_package(Readline REQUIRED) target_link_libraries(OpenSMT-bin PUBLIC Readline::Readline) endif() endif() target_link_libraries(OpenSMT-bin PUBLIC OpenSMT-static) install(TARGETS OpenSMT-bin RUNTIME DESTINATION bin) opensmt-2.5.2/src/bin/opensmt.cc000066400000000000000000000200311445011647600165440ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #include "Interpret.h" #include #include #include #include #include #define opensmt_error_() { std::cerr << "# Error (triggered at " << __FILE__ << ", " << __LINE__ << ")" << std::endl; assert(false); ::exit( 1 ); } #define opensmt_error( S ) { std::cerr << "; Error: " << S << " (triggered at " << __FILE__ << ", " << __LINE__ << ")" << std::endl; ::exit( 1 ); } #define opensmt_error2( S, T ) { std::cerr << "; Error: " << S << " " << T << " (triggered at " << __FILE__ << ", " << __LINE__ << ")" << std::endl; ::exit( 1 ); } #ifdef ENABLE_LINE_EDITING #if !defined(USE_READLINE) #include #else #include #include #endif #endif // ENABLE_LINE_EDITING #if defined(__GLIBC__) #include #endif namespace opensmt { void catcher ( int ); } /*****************************************************************************\ * * * MAIN * * * \*****************************************************************************/ void interpretInteractive(Interpret & interpret); int main( int argc, char * argv[] ) { signal( SIGTERM, opensmt::catcher ); signal( SIGINT , opensmt::catcher ); #ifdef PEDANTIC_DEBUG cerr << "; pedantic assertion checking enabled (very slow)" << endl; #endif #ifndef NDEBUG std::cerr << "; this binary is compiled in debug mode (slow)" << std::endl; #endif // Accepts file from stdin if nothing specified FILE * fin = NULL; int opt; SMTConfig c; bool pipe = false; while ((opt = getopt(argc, argv, "hdpir:v")) != -1) { switch (opt) { case 'h': // context.getConfig( ).printHelp( ); break; case 'd': const char* msg; c.setOption(SMTConfig::o_dryrun, SMTOption(true), msg); break; case 'r': if (!c.setOption(SMTConfig::o_random_seed, SMTOption(atoi(optarg)), msg)) fprintf(stderr, "Error setting random seed: %s\n", msg); else fprintf(stderr, "; Using random seed %d\n", atoi(optarg)); break; case 'i': c.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); break; case 'v': c.setOption(SMTConfig::o_verbosity, SMTOption(true), msg); break; case 'p': pipe = true; break; default: /* '?' */ fprintf(stderr, "Usage:\n\t%s [-d] [-h] [-r seed] filename [...]\n", argv[0]); return 0; } } Interpret interpreter(c); if (argc - optind == 0) { c.setInstanceName("stdin"); if (pipe) { interpreter.interpPipe(); } else { interpretInteractive(interpreter); } } else { for (int i = optind; i < argc; i++) { const char * filename = argv[i]; assert( filename ); c.setInstanceName(filename); if ( strncmp( filename, "--", 2 ) == 0 || strncmp( filename, "-", 1 ) == 0 ) { opensmt_error( "input file must be last argument" ); } else if ( (fin = fopen( filename, "rt" )) == NULL ) opensmt_error( "can't open file" ); const char * extension = strrchr( filename, '.' ); if ( extension != NULL && strcmp( extension, ".smt" ) == 0 ) { opensmt_error( "SMTLIB 1.2 format is not supported in this version, sorry" ); } else if ( extension != NULL && strcmp( extension, ".smt2" ) == 0 ) { interpreter.interpFile(fin); } else opensmt_error2( filename, " extension not recognized. Please use one in { smt2, cnf } or stdin (smtlib2 is assumed)" ); } fclose( fin ); } return 0; } #ifndef ENABLE_LINE_EDITING void interpretInteractive(Interpret & interpret) { interpret.interpPipe(); } #else void interpretInteractive(Interpret & interpret) { char* line_read = nullptr; bool done = false; int par = 0; int pb_cap = 1; int pb_sz = 0; char *parse_buf = (char *) malloc(pb_cap); while (!done) { if (line_read) { free(line_read); line_read = nullptr; } if (par == 0) line_read = readline("> "); else if (par > 0) line_read = readline("... "); else { interpret.reportError("interactive reader: unbalanced parentheses"); parse_buf[pb_sz-1] = 0; // replace newline with end of string add_history(parse_buf); pb_sz = 0; par = 0; } if (line_read && *line_read) { for (int i = 0; line_read[i] != '\0'; i++) { char c = line_read[i]; if (c == '(') par ++; if (c == ')') par --; while (pb_cap - 2 < pb_sz) { // the next char and terminating zero pb_cap *= 2; parse_buf = (char*) realloc(parse_buf, pb_cap); } parse_buf[pb_sz ++] = c; } if (par == 0) { parse_buf[pb_sz] = '\0'; // Parse starting from the command nonterminal // Parsing should be done from a string that I get from the readline // library. Smt2newContext context(parse_buf); int rval = smt2newparse(&context); if (rval != 0) interpret.reportError("scanner"); else { const ASTNode* r = context.getRoot(); interpret.execute(r); done = interpret.gotExit(); } add_history(parse_buf); pb_sz = 0; } else { // add the line break while (pb_cap - 2 < pb_sz) { // the next char and terminating zero pb_cap *= 2; parse_buf = (char*) realloc(parse_buf, pb_cap); } parse_buf[pb_sz ++] = '\n'; } } } if (parse_buf) free(parse_buf); if (line_read) free(line_read); } #endif namespace opensmt { void catcher( int sig ) { switch (sig) { case SIGINT: case SIGTERM: printf("Exit from signal\n"); exit(1); break; } } } // namespace opensmt opensmt-2.5.2/src/cnfizers/000077500000000000000000000000001445011647600156275ustar00rootroot00000000000000opensmt-2.5.2/src/cnfizers/CMakeLists.txt000066400000000000000000000002261445011647600203670ustar00rootroot00000000000000add_library(cnfizers OBJECT Cnfizer.cc TermMapper.cc Tseitin.cc) install(FILES TermMapper.h Tseitin.h Cnfizer.h DESTINATION ${INSTALL_HEADERS_DIR}) opensmt-2.5.2/src/cnfizers/Cnfizer.cc000066400000000000000000000325221445011647600175420ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #include "Cnfizer.h" #include "SimpSMTSolver.h" #include "TreeOps.h" #include "OsmtInternalException.h" #include #ifdef PEDANTIC_DEBUG #define TRACE(x) std::cerr << x << std::endl; #define TRACE_FLA_VEC(v) for (unsigned i = 0; i < v.size_(); ++i) \ std::cerr << i << ": " << logic.printTerm(v[i]) << '\n'; \ std::cerr << std::endl; #else #define TRACE(x) #define TRACE_FLA_VEC(v) #endif // PEDANTIC_DEBUG using namespace std; Cnfizer::Cnfizer ( SMTConfig &config_ , Logic &logic_ , PartitionManager &pmanager_ , TermMapper &tmap , SimpSMTSolver &solver_ ) : solver (solver_) , config (config_ ) , logic (logic_) , pmanager (pmanager_) , tmap (tmap) , s_empty (true) , alreadyAsserted(logic.getTerm_true()) , frame_terms({logic.getTerm_true()}) // Frame 0 does not have an enabling var , current_frame_term(frame_terms[0]) { } void Cnfizer::initialize() { // TODO: MB: why is all this initialization necessary? currentPartition = 0; vec c; Lit l = this->getOrCreateLiteralFor (logic.getTerm_true()); c.push (l); addClause(c); c.pop(); l = this->getOrCreateLiteralFor (logic.getTerm_false()); c.push (~l); addClause(c); currentPartition = -1; } lbool Cnfizer::solve(vec& en_frames) { vec assumps; // Initialize so that by default frames are disabled for (PTRef tr : frame_terms) { assumps.push(this->getOrCreateLiteralFor(tr)); } // Enable the terms which are listed in en_frames // At this point assumps has the same size as frame_terms and the // elements are in the same order. We simply invert the // corresponding literals uint32_t prevId = UINT32_MAX; for (FrameId fid : en_frames) { assumps[fid.id] = ~assumps[fid.id]; solver.mapEnabledFrameIdToVar(var(assumps[fid.id]), fid.id, prevId); } // Filter out the lit_Trues and lit_Falses used as empty values Lit lit_true = this->getOrCreateLiteralFor(logic.getTerm_true()); int i, j; for (i = j = 0; i < assumps.size(); i++) { if (assumps[i] != lit_true && assumps[i] != ~lit_true) assumps[j++] = assumps[i]; } assumps.shrink(i-j); return solver.solve(assumps, !config.isIncremental(), config.isIncremental()); } void Cnfizer::setFrameTerm(FrameId frame_id) { while (static_cast(frame_terms.size()) <= frame_id.id) { frame_terms.push(logic.getTerm_true()); } // frame_id == {0} is for the bottom frame and we don't want to add // literals to it since it is never retracted. if (frame_id != FrameId_bottom && frame_terms[frame_id.id] == logic.getTerm_true()) { std::string name {Logic::s_framev_prefix}; name += std::to_string(frame_id.id); PTRef frame_term = logic.mkBoolVar(name.c_str()); frame_terms[frame_id.id] = frame_term; } current_frame_term = frame_terms[frame_id.id]; } // // Main Routine. Examine formula and give it to the solver // lbool Cnfizer::cnfizeAndGiveToSolver(PTRef formula, FrameId frame_id) { // Get the variable for the incrementality. setFrameTerm(frame_id); if (!solver.isOK()) return l_False; assert ( formula != PTRef_Undef); TRACE("cnfizerAndGiveToSolver: " << logic.printTerm (formula)) if (keepPartitionInfo()) { assert(pmanager.getPartitionIndex(formula) != -1); currentPartition = pmanager.getPartitionIndex(formula); } // Retrieve top-level formulae - this is a list constructed from a conjunction vec top_level_formulae = topLevelConjuncts(logic, formula); assert (top_level_formulae.size() != 0); TRACE("Top level formulae:") TRACE_FLA_VEC(top_level_formulae) bool res = true; // For each top-level conjunct for (unsigned i = 0 ; i < top_level_formulae.size_() && (res == true) ; i ++) { PTRef f = top_level_formulae[i]; assert(not logic.isAnd(f)); // Conjunction should have been split when retrieving top-level formulae if (alreadyAsserted.contains(f, current_frame_term)) { continue; } TRACE("Adding clause " << logic.printTerm (f)) // Give it to the solver if already in CNF if (isClause(f)) { TRACE(" => Already a clause") res = assertClause(f); } else if (checkDeMorgan(f)) { // Check whether it can be rewritten using deMorgan laws TRACE(" => Will be de Morganized") res = deMorganize (f); } else { TRACE(" => proper cnfization") res = cnfizeAndAssert (f); // Perform actual cnfization (implemented in subclasses) } alreadyAsserted.insert(f, current_frame_term); } s_empty = false; // solver no longer empty if (res) { vec nestedBoolRoots = getNestedBoolRoots(formula); for (PTRef tr : nestedBoolRoots) { res &= cnfize(tr); // cnfize the formula without asserting the top level } assert(res); declareVars(logic.propFormulasAppearingInUF); } currentPartition = -1; return res == false ? l_False : l_Undef; } bool Cnfizer::cnfizeAndAssert(PTRef formula) { assert(formula != PTRef_Undef); // Top level formula must not be and anymore assert(!logic.isAnd(formula)); bool res = true; // Add the top level literal as a unit to solver. vec clause; clause.push(this->getOrCreateLiteralFor(formula)); res &= addClause(clause); res &= cnfize(formula); return res; } void Cnfizer::declareVars(vec& vars) { for (PTRef tr : vars) { Lit l = tmap.getOrCreateLit(tr); solver.addVar(var(l)); } } // // Apply simple de Morgan laws to the formula // bool Cnfizer::deMorganize ( PTRef formula ) { assert (!logic.isAnd (formula)); Pterm &pt = logic.getPterm (formula); bool rval = true; // // Case (not (and a b)) --> (or (not a) (not b)) // if (logic.isNot (formula) && logic.isAnd (pt[0])) { vec conjuncts; vec clause; retrieveConjuncts (pt[0], conjuncts); for (PTRef tr : conjuncts) { clause.push (~this->getOrCreateLiteralFor(tr)); TRACE("(not " << logic.printTerm (tr) << ")") } rval = addClause(clause); } return rval; } // // Check whether a formula is in cnf // bool Cnfizer::isCnf(PTRef e) { return isConjunctionOfClauses(e); } bool Cnfizer::isConjunctionOfClauses(PTRef e) { if (isClause(e)) { // Single clause counts as a conjunction of clauses return true; } if (not logic.isAnd(e)) { return false; } vec to_process; to_process.push (e); while (to_process.size() != 0) { e = to_process.last(); to_process.pop(); Pterm const & and_t = logic.getPterm(e); for (PTRef tr : and_t) { if (logic.isAnd(tr)) { to_process.push(tr); } else if (not isClause(tr)) { return false; } } } return true; } // // Check whether a formula is a clause // bool Cnfizer::isClause(PTRef e) { assert (e != PTRef_Undef); if (isLiteral(e)) { // Single literals count as clauses return true; } if (not logic.isOr(e)) { return false; } vec to_process; to_process.push (e); while (to_process.size() != 0) { e = to_process.last(); to_process.pop(); Pterm const & or_t = logic.getPterm (e); for (PTRef tr : or_t) { if (logic.isOr(tr)) { to_process.push(tr); } else { if (not isLiteral(tr)) { return false; } } } } return true; } // // Check whether it can be easily put in clausal form by means of DeMorgan's Rules // bool Cnfizer::checkDeMorgan (PTRef e) { Map > check_cache; const Pterm ¬_t = logic.getPterm (e); if (logic.isNot (e) && checkPureConj (not_t[0], check_cache) ) return true; else return false; } // // Check whether it is a pure conjunction of literals // bool Cnfizer::checkPureConj (PTRef e, Map > &check_cache) { if (check_cache.has (e)) return true; vec to_process; to_process.push (e); // Topmost needs to be and if (!logic.isAnd (e)) return false; while (to_process.size() != 0) { e = to_process.last(); to_process.pop(); Pterm &and_t = logic.getPterm (e); if (logic.isAnd(e)) { for (PTRef tr : and_t) { to_process.push(tr); } } else if (not isLiteral(e)) { return false; } check_cache.insert (e, true); } return true; } bool Cnfizer::addClause(const vec & c_in) { vec c; c_in.copyTo(c); if (current_frame_term != logic.getTerm_true()) { Lit l = this->getOrCreateLiteralFor(current_frame_term); Var v = var(l); tmap.setFrozen(v); solver.addAssumptionVar(v); c.push(l); } #ifdef PEDANTIC_DEBUG cerr << "== clause start" << endl; for (int i = 0; i < c.size(); i++) { cerr << "(" << c[i].x << "," << var (c[i]) << ") * " << (sign (c[i]) ? "not " : "") << logic.printTerm (tmap.varToPTRef (var (c[i]))) << " "; cerr << endl; } #endif opensmt::pair iorefs{CRef_Undef, CRef_Undef}; bool res = solver.addOriginalSMTClause(c, iorefs); if (keepPartitionInfo()) { CRef ref = iorefs.first; if (ref != CRef_Undef) { ipartitions_t parts = 0; assert(currentPartition != -1); opensmt::setbit(parts, static_cast(currentPartition)); pmanager.addClauseClassMask(ref, parts); } } return res; } // // Give the formula to the solver // bool Cnfizer::assertClause (PTRef f) { vec clause; // // A unit clause // if (isLiteral(f)) { clause.push(this->getOrCreateLiteralFor(f)); return addClause(clause); } // // A clause // if (logic.isOr(f)) { vec lits; retrieveClause (f, lits); for (PTRef tr : lits) clause.push(this->getOrCreateLiteralFor(tr)); return addClause(clause); } throw OsmtInternalException("UNREACHABLE: Unexpected situation in Cnfizer"); } // // Retrieve a clause // void Cnfizer::retrieveClause ( PTRef f, vec &clause ) { assert (isLiteral(f) || logic.isOr (f)); if (isLiteral(f)) { clause.push(f); } else if ( logic.isOr (f) ) { Pterm const &t = logic.getPterm (f); for (PTRef tr : t) { retrieveClause(tr, clause); } } } // // Retrieve conjuncts // void Cnfizer::retrieveConjuncts ( PTRef f, vec &conjuncts ) { assert (isLiteral(f) || logic.isAnd (f)); if (isLiteral(f)) { conjuncts.push(f); } else { Pterm &t = logic.getPterm (f); for (PTRef tr : t) { retrieveConjuncts(tr, conjuncts); } } } lbool Cnfizer::getTermValue (PTRef tr) const { assert (solver.isOK()); if (tmap.hasLit(tr)) { Lit l = tmap.getLit(tr); lbool val = solver.modelValue(l); assert (val != l_Undef); return val; } else return l_Undef; } bool Cnfizer::Cache::contains(PTRef term, PTRef frame_term) { return cache.find(std::make_pair<>(term, frame_term)) != cache.end() || ( frame_term != zeroLevelTerm && cache.find(std::make_pair<>(term, zeroLevelTerm)) != cache.end()); } void Cnfizer::Cache::insert(PTRef term, PTRef frame_term) { assert(!contains(term, frame_term)); cache.insert(std::make_pair<>(term, frame_term)); } bool Cnfizer::isLiteral(PTRef ptr) const { return (logic.isNot(ptr) and logic.isAtom(logic.getPterm(ptr)[0])) or logic.isAtom(ptr); } opensmt-2.5.2/src/cnfizers/Cnfizer.h000066400000000000000000000104521445011647600174020ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #ifndef CNFIZER_H #define CNFIZER_H #include "Theory.h" #include "Logic.h" #include "PartitionManager.h" #include "TermMapper.h" #include class SimpSMTSolver; class THandler; struct SMTConfig; // // Generic class for conversion into CNF // class Cnfizer { public: SimpSMTSolver& solver; protected: SMTConfig& config; Logic& logic; PartitionManager& pmanager; TermMapper& tmap; bool s_empty; class Cache { PTRef zeroLevelTerm; using CacheEntry = std::pair; std::unordered_set cache; public: Cache(PTRef zeroLevelTerm): zeroLevelTerm(zeroLevelTerm) {} bool contains(PTRef term, PTRef frame_term); void insert(PTRef term, PTRef frame_term); }; Cache alreadyAsserted; public: Cnfizer( SMTConfig & config_ , Logic& logic_ , PartitionManager& pmanager_ , TermMapper& tmap_ , SimpSMTSolver& solver_ ); virtual ~Cnfizer() = default; lbool cnfizeAndGiveToSolver (PTRef, FrameId frame_id); // Main routine lbool getTermValue(PTRef) const; void initialize (); lbool solve (vec& en_frames); bool solverEmpty () const { return s_empty; } protected: virtual bool cnfizeAndAssert ( PTRef ); // Cnfize and assert the top-level. virtual bool cnfize ( PTRef ) = 0; // Actual cnfization. To be implemented in derived classes bool deMorganize ( PTRef ); // Apply deMorgan rules whenever feasible void declareVars (vec&); // Declare a set of Boolean atoms to the solver (without asserting them) public: bool isClause (PTRef); bool isCnf (PTRef); bool checkDeMorgan ( PTRef ); // Check if formula can be deMorganized protected: bool assertClause (PTRef f); // Gives formula to the SAT solver bool addClause(const vec &); void retrieveClause ( PTRef, vec & ); // Retrieve a clause from a formula void retrieveConjuncts ( PTRef, vec & ); // Retrieve the list of conjuncts private: bool isConjunctionOfClauses (PTRef); bool checkPureConj (PTRef, Map& check_cache); // Check if a formula is purely a conjuntion protected: bool isLiteral(PTRef ptr) const; inline Lit getOrCreateLiteralFor(PTRef ptr) {return this->tmap.getOrCreateLit(ptr);} inline vec getNestedBoolRoots(PTRef ptr) { return logic.getNestedBoolRoots(ptr); } bool keepPartitionInfo() const { return config.produce_inter(); } int currentPartition = -1; vec frame_terms; PTRef current_frame_term; void setFrameTerm(FrameId frame_id); }; #endif opensmt-2.5.2/src/cnfizers/TermMapper.cc000066400000000000000000000065331445011647600202210ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ #include "TermMapper.h" // // Create the binding to a variable for the reference tr. tr can be // negated, in which case the binding is created to (not tr). Safe to // call several times for both tr and (not tr) // Var TermMapper::addBinding(PTRef tr) { assert(tr != PTRef_Undef); assert(varToTerm.size() == var_cnt); PTRef tr_p; // The purified term Var v; getVar(tr, tr_p, v); assert(v == var_Undef); v = Var(var_cnt++); assert(not hasLit(tr_p)); auto termIndex = Idx(toId(tr_p)); termToVar.growTo(termIndex + 1, var_Undef); termToVar[termIndex] = v; assert(varToTerm.size() == frozen.size()); while (varToTerm.size() <= v) { varToTerm.push(PTRef_Undef); frozen.push(false); } varToTerm[v] = tr_p; return v; } void TermMapper::getTerm(PTRef r, PTRef & p, bool & sgn) const { sgn = false; while (logic.getPterm(r).symb() == logic.getSym_not()) { r = logic.getPterm(r)[0]; sgn = !sgn; } p = r; } Lit TermMapper::getLit(PTRef r) const { bool sgn; PTRef p; getTerm(r, p, sgn); Var v = var_Undef; bool found = peekVar(p, v); assert(found); (void)found; return mkLit(v, sgn); } void TermMapper::getVar(PTRef r, PTRef & p, Var & v) const { bool sgn; getTerm(r, p, sgn); v = var_Undef; peekVar(p, v); } Var TermMapper::getVar(PTRef r) const { Var v = var_Undef; PTRef p; getVar(r, p, v); return v; } const Lit TermMapper::getOrCreateLit(PTRef ptr) { PTRef p_tr; bool sgn; Var v = var_Undef; getTerm(ptr, p_tr, sgn); peekVar(p_tr, v); if (v == var_Undef) { assert(logic.hasSortBool(p_tr)); v = this->addBinding(p_tr); } Lit l = mkLit(v, sgn); return l; } bool TermMapper::peekVar(PTRef positiveTerm, Var & v) const { assert(not logic.isNot(positiveTerm)); auto id = Idx(toId(positiveTerm)); v = id < termToVar.size_() ? termToVar[id] : var_Undef; return v != var_Undef; } PTRef TermMapper::toPositive(PTRef term) const { bool sign; PTRef pos; getTerm(term, pos, sign); return pos; } opensmt-2.5.2/src/cnfizers/TermMapper.h000066400000000000000000000074451445011647600200660ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ #ifndef TERMMAPPER_H #define TERMMAPPER_H #include "Logic.h" #include "Map.h" #include "PTRef.h" class TermMapper { private: int var_cnt; Logic & logic; vec frozen; vec varToTerm; // Mapping Var -> PTRef using var's index vec termToVar; // Mapping PTRef -> Var using term's index; NOTE: Only positive terms are stored! // Given a term computes the positive term and a sign. A -> A, false; (not A) -> A, true void getTerm(PTRef tr, PTRef & tr_pos, bool & sgn) const; // Given a term returns the positive version of the term. PTRef toPositive(PTRef term) const; PTId toId(PTRef term) const { return logic.getPterm(term).getId(); } // Giver a term computes the positive term and SAT variable correspoding to the positive term. void getVar(PTRef, PTRef &, Var &) const; // Check if there exists a SAT variable corresponding to the term. On success fill the output paramter v and returns // true. bool peekVar(PTRef positiveTerm, Var & v) const; // Creates a new bound between the given term and the returned SAT variable. Must not be called multiple times for // the same term. Var addBinding(PTRef tr); public: TermMapper(Logic & l) : var_cnt(0), logic(l) {} void setFrozen(Var v) { frozen[v] = true; } bool isFrozen(Var v) { return frozen[v]; } /* * Returns a SAT literal corresponding to the giver BOOLEAN term. * If no SAT variable has been assigned to (the positive version of) this term yet, a new one will be created. * Handles the sign of the term correctly, i.e., it returned negative literal for negative term and * positive literal for positive term. */ const Lit getOrCreateLit(PTRef ptr); // Returns the variable corresponding to the term. The connection must already exist. Var getVar(PTRef) const; // Returns the literal corresponding to the term. The connection must already exist. Lit getLit(PTRef) const; // Test if the given term already has an assigned SAT variable bool hasLit(PTRef tr) const { Var v = var_Undef; peekVar(toPositive(tr), v); return v != var_Undef; } // Returns the term to which the given variable has been assigned. The connection must already exist. PTRef varToPTRef(Var v) const { assert(v >= 0); return varToTerm[v]; } PTRef litToPTRef(Lit l) const { Var v = var(l); PTRef atom = varToPTRef(v); return sign(l) ? logic.mkNot(atom) : atom; } int nVars() const { return varToTerm.size(); } }; #endif opensmt-2.5.2/src/cnfizers/Tseitin.cc000066400000000000000000000216251445011647600175630ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #include "Cnfizer.h" #include "Tseitin.h" // // Performs the actual cnfization // bool Tseitin::cnfize(PTRef term) { bool res = true; vec unprocessed_terms {term}; // // Visit the DAG of the formula // while (unprocessed_terms.size() != 0) { PTRef ptr = unprocessed_terms.last(); unprocessed_terms.pop(); // // Skip if the node has already been processed before // if (alreadyCnfized.contains(ptr, current_frame_term)){ continue; } // Here (after the checks) not safe to use Pterm& since cnfize.* can alter the table of terms // by calling findLit int sz = logic.getPterm(ptr).size(); if (logic.isAnd(ptr)) res &= cnfizeAnd(ptr); else if (logic.isOr(ptr)) res &= cnfizeOr(ptr); else if (logic.isXor(ptr)) res &= cnfizeXor(ptr); else if (logic.isIff(ptr)) res &= cnfizeIff(ptr); else if (logic.isImplies(ptr)) res &= cnfizeImplies(ptr); // Ites are handled through the ite manager system and treated here as variables // else if (logic.isIte(ptr)) // res &= cnfizeIfthenelse(ptr); else if (!logic.isNot(ptr) && sz > 0) { goto tseitin_end; } { Pterm const& pt = logic.getPterm(ptr); for (int i = 0; i < pt.size(); i++) { unprocessed_terms.push(pt[i]); // Using the PTRef is safe if a reallocation happened } } tseitin_end: alreadyCnfized.insert(ptr, current_frame_term); } return res; } bool Tseitin::cnfizeAnd(PTRef and_term) { // assert( list ); // assert( list->isList( ) ); // // ( a_0 & ... & a_{n-1} ) // // <=> // // aux = ( -aux | a_0 ) & ... & ( -aux | a_{n-1} ) & ( aux & -a_0 & ... & -a_{n-1} ) // Lit v = this->getOrCreateLiteralFor(and_term); vec little_clause; vec big_clause; int size = logic.getPterm(and_term).size(); big_clause.capacity(size + 1); little_clause.push(~v); big_clause .push(v); bool res = true; for (int i = 0; i < size; i++) { PTRef arg = logic.getPterm(and_term)[i]; little_clause.push( this->getOrCreateLiteralFor(arg) ); big_clause .push(~this->getOrCreateLiteralFor(arg)); res &= addClause(little_clause); // Adds a little clause to the solver little_clause.pop(); } res &= addClause(big_clause); // Adds a big clause to the solver return res; } bool Tseitin::cnfizeOr(PTRef or_term) { // // ( a_0 | ... | a_{n-1} ) // // <=> // // aux = ( aux | -a_0 ) & ... & ( aux | -a_{n-1} ) & ( -aux | a_0 | ... | a_{n-1} ) // vec little_clause; vec big_clause; Lit v = this->getOrCreateLiteralFor(or_term); little_clause.push( v); big_clause .push(~v); bool res = true; for (int i = 0 ; i < logic.getPterm(or_term).size(); i++) { Lit arg = this->getOrCreateLiteralFor(logic.getPterm(or_term)[i]); little_clause.push(~arg); big_clause .push( arg); res &= addClause(little_clause); // Adds a little clause to the solver little_clause.pop(); } res &= addClause(big_clause); // Adds a big clause to the solver return res; } bool Tseitin::cnfizeXor(PTRef xor_term) { // // ( a_0 xor a_1 ) // // <=> // // aux = ( -aux | a_0 | a_1 ) & ( -aux | -a_0 | -a_1 ) & // ( aux | -a_0 | a_1 ) & ( aux | a_0 | -a_1 ) // Lit v = this->getOrCreateLiteralFor(xor_term); Lit arg0 = this->getOrCreateLiteralFor(logic.getPterm(xor_term)[0]); Lit arg1 = this->getOrCreateLiteralFor(logic.getPterm(xor_term)[1]); vec clause; bool res = true; clause.push(~v); // First clause clause.push(arg0); clause.push(arg1); res &= addClause(clause); clause.pop(); clause.pop(); // Second clause clause.push(~arg0); clause.push(~arg1); res &= addClause(clause); clause.pop(); clause.pop(); clause.pop(); clause.push(v); // Third clause clause.push(~arg0); clause.push( arg1); res &= addClause(clause); clause.pop(); clause.pop(); // Fourth clause clause.push( arg0); clause.push(~arg1); res &= addClause(clause); return res; } bool Tseitin::cnfizeIff(PTRef eq_term) { // // ( a_0 <-> a_1 ) // // <=> // // aux = ( -aux | a_0 | -a_1 ) & ( -aux | -a_0 | a_1 ) & // ( aux | a_0 | a_1 ) & ( aux | -a_0 | -a_1 ) // assert(logic.getPterm(eq_term).size() == 2); Lit v = this->getOrCreateLiteralFor(eq_term); Lit arg0 = this->getOrCreateLiteralFor(logic.getPterm(eq_term)[0]); Lit arg1 = this->getOrCreateLiteralFor(logic.getPterm(eq_term)[1]); vec clause; bool res = true; clause.push(~v); // First clause clause.push( arg0); clause.push(~arg1); res &= addClause(clause); clause.pop(); clause.pop(); // Second clause clause.push(~arg0); clause.push( arg1); res &= addClause(clause); clause.pop(); clause.pop(); clause.pop(); clause.push(v); // Third clause clause.push(arg0); clause.push(arg1); res &= addClause(clause); clause.pop(); clause.pop(); // Fourth clause clause.push(~arg0); clause.push(~arg1); res &= addClause(clause); return res; } bool Tseitin::cnfizeIfthenelse(PTRef ite_term) { // (!a | !i | t) & (!a | i | e) & (a | !i | !t) & (a | i | !e) // // ( if a_0 then a_1 else a_2 ) // // <=> // // aux = ( -aux | -a_0 | a_1 ) & // ( -aux | a_0 | a_2 ) & // ( aux | -a_0 | -a_1 ) & // ( aux | a_0 | -a_2 ) // Pterm& pt_ite = logic.getPterm(ite_term); assert(pt_ite.size() == 3); Lit v = this->getOrCreateLiteralFor(ite_term); Lit a0 = this->getOrCreateLiteralFor(pt_ite[0]); Lit a1 = this->getOrCreateLiteralFor(pt_ite[1]); Lit a2 = this->getOrCreateLiteralFor(pt_ite[2]); vec clause; bool res = true; clause.push(~v); clause.push(~a0); clause.push(a1); res &= addClause(clause); clause.clear(); clause.push(~v); clause.push(a0); clause.push(a2); res &= addClause(clause); clause.clear(); clause.push(v); clause.push(~a0); clause.push(~a1); res &= addClause(clause); clause.clear(); clause.push(v); clause.push(a0); clause.push(~a2); res &= addClause(clause); return res; } bool Tseitin::cnfizeImplies(PTRef impl_term) { // ( a_0 => a_1 ) // // <=> // // aux = ( -aux | -a_0 | a_1 ) & // ( aux | a_0 ) & // ( aux | -a_1 ) // Pterm& pt_impl = logic.getPterm(impl_term); assert(pt_impl.size() == 2); Lit v = this->getOrCreateLiteralFor(impl_term); Lit a0 = this->getOrCreateLiteralFor(pt_impl[0]); Lit a1 = this->getOrCreateLiteralFor(pt_impl[1]); vec clause; bool res = true; clause.push(v); clause.push(a0); res &= addClause(clause); clause.pop(); clause.push(~a1); res &= addClause(clause); clause.clear(); clause.push(~v); clause.push(~a0); clause.push(a1); res &= addClause(clause); return res; } //void Tseitin::copyArgsWithCache(PTRef tr, vec& args, Map& cache) //{ // Pterm& t = logic.getPterm(tr); // for (int i = 0; i < t.size(); i++) { // if (cache.has(t[i])) // args.push(cache[t[i]]); // else // args.push(t[i]); // } //} opensmt-2.5.2/src/cnfizers/Tseitin.h000066400000000000000000000052021445011647600174160ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #ifndef TSEITIN_H #define TSEITIN_H #include "PTRef.h" #include "Cnfizer.h" class Tseitin : public Cnfizer { public: Tseitin( SMTConfig& config_ , Logic& logic_ , PartitionManager &pmanager_ , TermMapper& tmap_ , SimpSMTSolver& solver_ ) : Cnfizer( config_ , logic_ , pmanager_ , tmap_ , solver_ ) , alreadyCnfized(logic_.getTerm_true()) {} ~Tseitin( ) { } private: // Cache of already cnfized terms. Note that this is different from Cnfizer cache of already processed top-level flas Cache alreadyCnfized; bool cnfize (PTRef); // Cnfize the given term bool cnfizeAnd (PTRef); // Cnfize conjunctions bool cnfizeOr (PTRef); // Cnfize disjunctions bool cnfizeIff (PTRef); // Cnfize iffs bool cnfizeXor (PTRef); // Cnfize xors bool cnfizeIfthenelse (PTRef); // Cnfize if then elses bool cnfizeImplies (PTRef); // Cnfize if then elses // void copyArgsWithCache(PTRef, vec&, Map&); }; #endif opensmt-2.5.2/src/common/000077500000000000000000000000001445011647600152745ustar00rootroot00000000000000opensmt-2.5.2/src/common/Alloc.h000066400000000000000000000110421445011647600164750ustar00rootroot00000000000000/*****************************************************************************************[Alloc.h] Copyright (c) 2008-2010, Niklas Sorensson 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. **************************************************************************************************/ #ifndef Minisat_Alloc_h #define Minisat_Alloc_h #include "osmtinttypes.h" #include "XAlloc.h" #include "Vec.h" //================================================================================================= // Simple Region-based memory allocator: template class RegionAllocator { T* memory; uint32_t sz; uint32_t cap; uint32_t wasted_; uint32_t start_cap; void capacity(uint32_t min_cap); public: // TODO: make this a class for better type-checking? typedef uint32_t Ref; enum { Ref_Undef = UINT32_MAX }; enum { Ref_Fake = UINT32_MAX-1 }; enum { Ref_True = UINT32_MAX-2 }; enum { Unit_Size = sizeof(uint32_t) }; explicit RegionAllocator(uint32_t start_cap = 1024*1024) : memory(NULL), sz(0), cap(0), wasted_(0), start_cap(start_cap) { capacity(start_cap); } ~RegionAllocator() { ::free(memory); } virtual void clear() { ::free(memory); memory = nullptr; sz = 0; cap = 0; wasted_ = 0; capacity(start_cap); } uint32_t size () const { return sz; } uint32_t wasted () const { return wasted_; } Ref alloc (int size); void free (int size) { wasted_ += size; } // Deref, Load Effective Address (LEA), Inverse of LEA (AEL): T& operator[](Ref r) { assert(r < sz); return memory[r]; } const T& operator[](Ref r) const { assert(r < sz); return memory[r]; } T* lea (Ref r) { assert(r < sz); return &memory[r]; } const T* lea (Ref r) const { assert(r < sz); return &memory[r]; } Ref ael (const T* t) { assert((void*)t >= (void*)&memory[0] && (void*)t < (void*)&memory[sz-1]); return (Ref)(t - &memory[0]); } void moveTo(RegionAllocator& to) { if (to.memory != NULL) ::free(to.memory); to.memory = memory; to.sz = sz; to.cap = cap; to.wasted_ = wasted_; memory = NULL; sz = cap = wasted_ = 0; } }; template void RegionAllocator::capacity(uint32_t min_cap) { if (cap >= min_cap) return; uint32_t prev_cap = cap; while (cap < min_cap){ // NOTE: Multiply by a factor (13/8) without causing overflow, then add 2 and make the // result even by clearing the least significant bit. The resulting sequence of capacities // is carefully chosen to hit a maximum capacity that is close to the '2^32-1' limit when // using 'uint32_t' as indices so that as much as possible of this space can be used. uint32_t delta = ((cap >> 1) + (cap >> 3) + 2) & ~1; cap += delta; if (cap <= prev_cap) throw OutOfMemoryException(); } // printf(" .. (%p) cap = %u\n", this, cap); assert(cap > 0); memory = (T*)xrealloc(memory, sizeof(T)*cap); } template typename RegionAllocator::Ref RegionAllocator::alloc(int size) { // printf("ALLOC called (this = %p, size = %d)\n", this, size); fflush(stdout); assert(size > 0); capacity(sz + size); uint32_t prev_sz = sz; sz += size; // Handle overflow: if (sz < prev_sz) throw OutOfMemoryException(); return prev_sz; } //================================================================================================= #endif opensmt-2.5.2/src/common/CMakeLists.txt000066400000000000000000000021561445011647600200400ustar00rootroot00000000000000add_library(common OBJECT "FastRational.cc" Real.h) target_sources(common PUBLIC "${CMAKE_CURRENT_LIST_DIR}/FastRational.h" PUBLIC "${CMAKE_CURRENT_LIST_DIR}/FlaPartitionMap.cc" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/Alloc.h" "${CMAKE_CURRENT_LIST_DIR}/XAlloc.h" "${CMAKE_CURRENT_LIST_DIR}/SystemQueries.h" "${CMAKE_CURRENT_LIST_DIR}/Integer.h" "${CMAKE_CURRENT_LIST_DIR}/Number.h" "${CMAKE_CURRENT_LIST_DIR}/NumberUtils.h" "${CMAKE_CURRENT_LIST_DIR}/osmtinttypes.h" "${CMAKE_CURRENT_LIST_DIR}/StringMap.h" "${CMAKE_CURRENT_LIST_DIR}/StringConv.h" "${CMAKE_CURRENT_LIST_DIR}/Timer.h" "${CMAKE_CURRENT_LIST_DIR}/TreeOps.h" "${CMAKE_CURRENT_LIST_DIR}/NatSet.h" "${CMAKE_CURRENT_LIST_DIR}/PartitionInfo.cc" "${CMAKE_CURRENT_LIST_DIR}/VerificationUtils.cc" "${CMAKE_CURRENT_LIST_DIR}/ReportUtils.h" ) install(FILES Integer.h Number.h FastRational.h XAlloc.h Alloc.h StringMap.h Timer.h osmtinttypes.h TreeOps.h Real.h FlaPartitionMap.h PartitionInfo.h OsmtApiException.h TypeUtils.h NumberUtils.h NatSet.h DESTINATION ${INSTALL_HEADERS_DIR}) opensmt-2.5.2/src/common/FastRational.cc000066400000000000000000000156701445011647600202030ustar00rootroot00000000000000/* Fast rationals David Monniaux, VERIMAG 2008-2009 Copyright (c) 2008, 2009 Centre national de la recherche scientifique (CNRS) */ #include "FastRational.h" #include #include mpq_ptr FastRational::mpqPool::alloc() { mpq_ptr r; if (!pool.empty()) { r = pool.top(); pool.pop(); } else { r = store.emplace().get_mpq_t(); } return r; } void FastRational::mpqPool::release(mpq_ptr ptr) { pool.push(ptr); } FastRational::FastRational( const char * s, const int base ) { mpq = pool.alloc(); mpq_set_str(mpq, s, base); mpq_canonicalize( mpq ); state = State::MPQ_ALLOCATED_AND_VALID; try_fit_word(); if ( wordPartValid() ) kill_mpq( ); assert( isWellFormed( ) ); } FastRational::FastRational(mpz_t z) { if (mpz_fits_sint_p(z)) { num = mpz_get_si(z); den = 1; state = State::WORD_VALID; } else { mpq = pool.alloc(); mpz_set(mpq_numref(mpq), z); mpz_set_ui(mpq_denref(mpq), 1); state = State::MPQ_ALLOCATED_AND_VALID; } } FastRational::FastRational(uint32_t x) { if (x > INT_MAX) { mpq = pool.alloc(); mpq_set_ui(mpq, x, 1); state = State::MPQ_ALLOCATED_AND_VALID; } else { num = x; den = 1; state = State::WORD_VALID; } } void FastRational::reset() { kill_mpq(); state = State::WORD_VALID; num = 0; den = 1; } void FastRational::print(std::ostream & out) const { const bool sign = this->sign() < 0; if (wordPartValid()) { uword abs_num = absVal(num); if (den == 1) { out << (sign?"(- ":"") << abs_num << (sign?")":""); } else { out << "(/ " << (sign?"(- ":"") << abs_num << (sign?") ":" ") << den << ")"; } } else { assert(mpqPartValid()); mpq_class mpq_c( mpq ); if ( sign ) mpq_c = -mpq_c; out << (sign?"(- ":"") << mpq_c << (sign?")":""); } } void FastRational::print_(std::ostream & out) const { if (wordPartValid()) { if (den == 1) { out << num; } else { out << num << "/" << den; } } else { assert(mpqPartValid()); out << mpq; } } std::string FastRational::get_str() const { std::ostringstream os; print_(os); return os.str(); } FastRational gcd(FastRational const & a, FastRational const & b) { assert(a.isInteger() and b.isInteger()); if (a.wordPartValid() && b.wordPartValid()) { return FastRational(gcd(a.num, b.num)); } else { a.force_ensure_mpq_valid(); b.force_ensure_mpq_valid(); mpz_gcd(FastRational::mpz(), mpq_numref(a.mpq), mpq_numref(b.mpq)); return FastRational(FastRational::mpz()); } } FastRational lcm(FastRational const & a, FastRational const & b) { assert(a.isInteger() and b.isInteger()); if (a.wordPartValid() && b.wordPartValid()) { return lcm(a.num, b.num); } else { a.force_ensure_mpq_valid(); b.force_ensure_mpq_valid(); mpz_lcm(FastRational::mpz(), mpq_numref(a.mpq), mpq_numref(b.mpq)); return FastRational(FastRational::mpz()); } } FastRational fastrat_round_to_int(const FastRational& n) { FastRational res = n + FastRational(1, 2); return fastrat_fdiv_q(res.get_num(), res.get_den()); } // The quotient of n and d using the fast rationals. // Divide n by d, forming a quotient q. // Rounds q down towards -infinity, and q will satisfy n = q*d + r for some 0 <= abs(r) <= abs(d) FastRational fastrat_fdiv_q(FastRational const & n, FastRational const & d) { assert(n.isInteger() && d.isInteger()); if (n.wordPartValid() && d.wordPartValid()) { word num = n.num; word den = d.num; word quo; if (num == INT_MIN) // The abs is guaranteed to overflow. Otherwise this is always fine goto overflow; // After this -INT_MIN+1 <= numerator <= INT_MAX, and therefore the result always fits into a word. quo = num / den; if (num % den != 0 && ((num < 0 && den >=0) || (den < 0 && num >= 0))) // The result should be negative quo--; // INT_MAX-1 >= quo >= -INT_MIN return quo; } overflow: n.force_ensure_mpq_valid(); d.force_ensure_mpq_valid(); mpz_fdiv_q(FastRational::mpz(), mpq_numref(n.mpq), mpq_numref(d.mpq)); return FastRational(FastRational::mpz()); } //void mpz_divexact (mpz_ptr, mpz_srcptr, mpz_srcptr); FastRational divexact(FastRational const & n, FastRational const & d) { assert(d != 0); assert(n.isInteger() && d.isInteger()); if (n.wordPartValid() && d.wordPartValid()) { word num = n.num; word den = d.num; word quo; if (den != 0){ quo = num / den; return quo; } else { // Division by zero assert(false); return FastRational(0); } } else { assert(n.mpqPartValid() || d.mpqPartValid()); n.force_ensure_mpq_valid(); d.force_ensure_mpq_valid(); mpz_divexact(FastRational::mpz(), mpq_numref(n.mpq), mpq_numref(d.mpq)); return FastRational(FastRational::mpz()); } } // Given as input the sequence Reals, return the smallest number m such that for each r in Reals, r*m is an integer FastRational get_multiplicand(const std::vector& reals) { std::vector dens; for (const auto & r : reals) { if (!r.isInteger()) { dens.push_back(r.get_den()); } } // Iterate until dens is not empty FastRational mult = 1; // Collect here the number I need to multiply the polynomial to get rid of all denominators while (dens.size() > 0) { // Unique denominators std::sort(dens.begin(), dens.end()); auto last = std::unique(dens.begin(), dens.end()); dens.erase(last, dens.end()); #ifdef PRINTALOT char *buf = (char*) malloc(1); buf[0] = '\0'; char *buf_new; for (int j = 0; j < dens.size(); j++) { asprintf(&buf_new, "%s%s%s", buf, dens[j].get_str().c_str(), j == dens.size() - 1 ? "" : ", "); free(buf); buf = buf_new; } printf("Dens size now %lu, and individual are denominators: %s\n", dens.size(), buf); free(buf); #endif if (dens.size() == 1) { mult *= dens[0]; dens.clear(); } else { // We filter in place the integers in dens. The last two are guaranteed to be ; int k = 0; FastRational m = lcm(dens[dens.size()-1], dens[dens.size()-2]); mult *= m; for (size_t j = 0; j < dens.size()-2; j++) { FastRational n = (m/dens[j]).get_den(); if (n != 1) dens[k++] = n; } dens.resize(k); } } #ifdef PRINTALOT printf("Multiplicand is %s\n", mult.get_str().c_str()); #endif return mult; } opensmt-2.5.2/src/common/FastRational.h000066400000000000000000001034701445011647600200410ustar00rootroot00000000000000/* Fast rationals David Monniaux, VERIMAG 2008-2009 Copyright (c) 2008, 2009 Centre national de la recherche scientifique (CNRS) */ #ifndef FAST_RATIONALS_H #define FAST_RATIONALS_H #include #include #include #include #include "Vec.h" #include #include typedef int32_t word; typedef uint32_t uword; typedef int64_t lword; typedef uint64_t ulword; #define WORD_MIN INT_MIN #define WORD_MAX INT_MAX #define UWORD_MAX UINT_MAX #define LWORD_MIN LONG_MIN #define LWORD_MAX LONG_MAX enum class State: unsigned char { /* * bit 0 - wheter word part is valid or not * bit 1 - whether memory for mpq has been allocated * bit 2 - whether mpq part is valid * * INVARIANT - if both parts are valid, they are the same */ WORD_VALID = 1, // ONLY the WORD part is valid and memory for MPQ is not initialized MPQ_MEMORY_ALLOCATED = 2, // SHOULD NEVER BE STANDALONE WORD_PLUS_MPQ_INITIALIZED = WORD_VALID | MPQ_MEMORY_ALLOCATED, // ONLY the WORD part is valid, but memory is already initialized MPQ_VALID = 4, // // SHOULD NEVER BE STANDALONE MPQ_ALLOCATED_AND_VALID = MPQ_MEMORY_ALLOCATED | MPQ_VALID, // ONLY MPQ part is valid WORD_AND_MPQ = WORD_VALID | MPQ_ALLOCATED_AND_VALID // BOTH WORD and MPQ parts are valid (and they are the same) }; using state_t = std::underlying_type::type; static_assert(std::is_same::value, "Underlying value for FastRational inner type is not as expected"); inline State operator | (State lhs, State rhs) { return static_cast(static_cast(lhs) | static_cast(rhs)); } inline State& operator |= (State& lhs, State rhs) { lhs = lhs | rhs; return lhs; } inline uword absVal(word x) { // Taking just (- WORD_MIN) is undefined behaviour, changed according to https://stackoverflow.com/questions/12231560/correct-way-to-take-absolute-value-of-int-min return x < 0 ? -((uword)(x)) : +((uword)(x)); } inline ulword absVal(lword x) { // Taking just (- LWORD_MIN) is undefined behaviour return x < 0 ? -((ulword)(x)) : +((ulword)(x)); } class FastRational { class mpqPool { std::stack store; // uses deque as storage to avoid realloc std::stack> pool; public: mpq_ptr alloc(); void release(mpq_ptr); }; State state; word num{0}; uword den{1}; mpq_ptr mpq{nullptr}; inline static mpqPool pool; inline static thread_local mpz_class temp; inline static mpz_ptr mpz() { return temp.get_mpz_t(); } // Bit masks for questioning state: static const unsigned char wordValidMask = 0x1; static const unsigned char mpqMemoryAllocatedMask = 0x2; static const unsigned char mpqValidMask = 0x4; // Methods for adjusting the inner state inline void setMpqPartValid() {this->state |= State::MPQ_VALID; } inline void setMpqMemoryAllocated() {this->state |= State::MPQ_MEMORY_ALLOCATED; } inline void setMpqAllocatedAndValid() {this->state |= State::MPQ_ALLOCATED_AND_VALID; } inline void setWordPartValid() {this->state |= State::WORD_VALID; } inline void setWordPartInvalid() { assert(mpqPartValid()); this->state = State::MPQ_ALLOCATED_AND_VALID; } inline void setOnlyWordPartValid() { setWordPartValid(); setMpqPartInvalid(); } inline void setMpqPartInvalid() { assert(wordPartValid()); // clear the bit representing MPQ_VALID this->state = static_cast(static_cast(this->state) & ~(mpqValidMask)); assert(not mpqPartValid() and wordPartValid()); } public: // Methods for questioning inner state inline bool wordPartValid() const { return static_cast(state) & wordValidMask; } inline bool wordAndMpqEqual() const; inline bool mpqMemoryAllocated() const { return static_cast(state) & mpqMemoryAllocatedMask; } inline bool mpqPartValid() const { return static_cast(state) & mpqValidMask; } // // Constructors // FastRational () : state{State::WORD_VALID}, num(0), den(1) {} FastRational (word x) : state{State::WORD_VALID}, num(x), den(1) {} FastRational (uint32_t); inline FastRational(word n, uword d); // The string must be in the format accepted by mpq_set_str, e.g., "1/2" explicit FastRational(const char* s, const int base = 10); inline FastRational (const FastRational &); inline FastRational (FastRational&& other) noexcept; FastRational(mpz_t x); // // Destroyer // ~FastRational( ) { kill_mpq(); } FastRational & operator=(FastRational && other) { std::swap(this->state, other.state); std::swap(this->num, other.num); std::swap(this->den, other.den); std::swap(this->mpq, other.mpq); return *this; } void reset(); inline FastRational & operator=( const FastRational & ); private: void kill_mpq() { if (mpqMemoryAllocated()) { pool.release(mpq); state = State::WORD_VALID; } } void ensure_mpq_valid() { if (!mpqPartValid()) { assert(wordPartValid()); if (!mpqMemoryAllocated()) { mpq = pool.alloc(); } mpz_set_si(mpq_numref(mpq), num); mpz_set_ui(mpq_denref(mpq), den); setMpqAllocatedAndValid(); } } void force_ensure_mpq_valid() const { const_cast(this)->ensure_mpq_valid(); } void ensure_mpq_memory_allocated() { if (!mpqMemoryAllocated()) { mpq = pool.alloc(); setMpqMemoryAllocated(); } } bool fitsWord() const { assert(not wordPartValid() and mpqPartValid()); // Do not call this method if word part is already valid return mpz_fits_sint_p(mpq_numref(mpq)) and mpz_fits_uint_p(mpq_denref(mpq)); } // // Tries to convert the current rational // stored in mpq into word/uword // void try_fit_word() { assert(not wordPartValid() and mpqPartValid()); // Do not call this method if word part is already valid if (fitsWord()) { num = mpz_get_si(mpq_numref(mpq)); den = mpz_get_ui(mpq_denref(mpq)); setWordPartValid(); } } friend inline void addition (FastRational &, const FastRational &, const FastRational &); friend inline void substraction (FastRational &, const FastRational &, const FastRational &); friend inline void multiplication (FastRational &, const FastRational &, const FastRational &); friend inline void division (FastRational &, const FastRational &, const FastRational &); friend inline void additionAssign (FastRational &, const FastRational &); friend inline void substractionAssign (FastRational &, const FastRational &); friend inline void multiplicationAssign(FastRational &, const FastRational &); friend inline void divisionAssign (FastRational &, const FastRational &); friend FastRational gcd (FastRational const &, FastRational const &); friend FastRational lcm (FastRational const &, FastRational const &); friend FastRational fastrat_fdiv_q (FastRational const & n, FastRational const & d); friend FastRational divexact (FastRational const & n, FastRational const & d); static inline int compare(lword a, lword b) { if (a < b) return -1; else if (a > b) return 1; else return 0; } void print_(std::ostream& out) const; public: void print (std::ostream &) const; std::string get_str() const; inline double get_d () const; inline bool operator==(const FastRational& b) const; inline FastRational operator-() const; inline void negate(); FastRational get_den() const { if (wordPartValid() && den <= INT32_MAX) { return FastRational((uword)den); } else { force_ensure_mpq_valid(); return FastRational(mpq_denref(mpq)); } } FastRational get_num() const { if (wordPartValid()) { return FastRational(num); } else { return FastRational(mpq_numref(mpq)); } } inline int compare(const FastRational& b) const; inline int sign() const; bool operator< ( const FastRational & b ) const { return compare(b) < 0; } bool operator> ( const FastRational & b ) const { return compare(b) > 0; } bool operator<=( const FastRational & b ) const { return compare(b) <= 0; } bool operator>=( const FastRational & b ) const { return compare(b) >= 0; } bool operator!=( const FastRational & b ) const { return !(*this == b); } inline unsigned size() const; uint32_t getHashValue() const { if (wordPartValid()) { return 37*(uint32_t)num + 13*(uint32_t)den; } else { uint32_t h_n = 2166136261U; for (int i = 0; i < mpq->_mp_num._mp_size; i++) { h_n *= 16777619U; h_n ^= mpq->_mp_num._mp_d[i]; } uint32_t h_d = 2166136261U; for (int i = 0; i < mpq->_mp_den._mp_size; i++) { h_d *= 16777619U; h_d ^= mpq->_mp_den._mp_d[i]; } return h_n + h_d; } } bool isInteger() const { if (wordPartValid()) return den == 1; else { assert(mpqPartValid()); return mpz_fits_uint_p(mpq_denref(mpq)) && (mpz_get_ui(mpq_denref(mpq)) == 1); } } inline FastRational ceil() const { if (isInteger()) return *this; if (wordPartValid()) { word ret = absVal(num) / den; // Use correct abs if ( num < 0 ) ret = -ret; // Guaranteed not to overflow since den >= 2 else ++ret; return ret; } else { mpz_cdiv_q(mpz(), mpq_numref(mpq), mpq_denref(mpq)); return FastRational(mpz()); } } inline FastRational floor() const { if (isInteger()) return *this; return ceil() - 1; } bool isWellFormed() const; FastRational operator+(const FastRational& b) const { FastRational dest; assert(isWellFormed()); assert(b.isWellFormed()); addition(dest, *this, b); assert(dest.isWellFormed()); return dest; } FastRational operator-(const FastRational& b) const { FastRational dest; assert(isWellFormed()); assert(b.isWellFormed()); substraction(dest, *this, b); assert(dest.isWellFormed()); return dest; } FastRational operator*(const FastRational& b) const { FastRational dest; assert(isWellFormed()); assert(b.isWellFormed()); multiplication(dest, *this, b); assert(dest.isWellFormed()); return dest; } FastRational operator/(const FastRational& b) const { FastRational dest; assert(isWellFormed()); assert(b.isWellFormed()); division(dest, *this, b); assert(dest.isWellFormed()); return dest; } FastRational& operator+=(const FastRational& b) { assert(isWellFormed()); assert(b.isWellFormed()); additionAssign(*this, b); assert(isWellFormed()); return *this; } FastRational& operator-=(const FastRational& b) { assert(isWellFormed()); assert(b.isWellFormed()); substractionAssign(*this, b); assert(isWellFormed()); return *this; } FastRational& operator*=(const FastRational& b) { assert(isWellFormed()); assert(b.isWellFormed()); multiplicationAssign(*this, b); assert(isWellFormed()); return *this; } FastRational& operator/=(const FastRational& b) { assert(isWellFormed()); assert(b.isWellFormed()); divisionAssign(*this, b); assert(isWellFormed()); return *this; } inline FastRational inverse() const; bool isZero() const { assert(wordPartValid() or not fitsWord()); return wordPartValid() and num == 0; } bool isOne() const { assert(wordPartValid() or not fitsWord()); return wordPartValid() && num == 1 && den == 1; } // Return *this % d. The return value will have the sign of d FastRational operator%(const FastRational& d) { assert(isInteger() && d.isInteger()); if (wordPartValid() && d.wordPartValid()) { uword w = absVal(num % d.num); // Largest value is absVal(INT_MAX % INT_MIN) = INT_MAX return (word)(d.num > 0 ? w : -w); // No overflow since 0 <= w <= INT_MAX } FastRational r = (*this) / d; r = r.floor(); r = (*this) - r*d; return r; } }; FastRational fastrat_fdiv_q(FastRational const & n, FastRational const & d); FastRational fastrat_round_to_int(const FastRational& n); struct FastRationalHash { uint32_t operator() (const FastRational& s) const { return (uint32_t)s.getHashValue(); } }; inline std::ostream & operator<<(std::ostream & out, const FastRational & r) { r.print(out); return out; } inline FastRational::FastRational(const FastRational& x) { if (x.wordPartValid()) { num = x.num; den = x.den; state = State::WORD_VALID; } else { assert(x.mpqPartValid()); mpq = pool.alloc(); mpq_set(mpq, x.mpq); state = State::MPQ_ALLOCATED_AND_VALID; } } inline FastRational::FastRational(FastRational &&other) noexcept : state{other.state}, num{other.num}, den{other.den} { if (other.mpqMemoryAllocated()) { std::swap(this->mpq, other.mpq); other.state = State::WORD_VALID; } } inline FastRational& FastRational::operator=(const FastRational& x) { if (x.wordPartValid()) { num = x.num; den = x.den; setOnlyWordPartValid(); // MB: keeps mpq memory allocated if it already is } else { assert(x.mpqPartValid()); if (!this->mpqMemoryAllocated()) { mpq = pool.alloc(); } mpq_set(mpq, x.mpq); this->state = State::MPQ_ALLOCATED_AND_VALID; } return *this; } inline bool FastRational::operator==(const FastRational& b) const { if (this->wordPartValid() && b.wordPartValid()) { return num == b.num && den == b.den; } force_ensure_mpq_valid(); b.force_ensure_mpq_valid(); return mpq_equal(mpq, b.mpq); } inline FastRational FastRational::operator-() const { if (this->wordPartValid() && num > WORD_MIN) { return FastRational(-num, den); } else { force_ensure_mpq_valid(); FastRational x; x.mpq = pool.alloc(); mpq_neg(x.mpq, mpq); x.state = State::MPQ_ALLOCATED_AND_VALID; x.try_fit_word(); // MB: If current value is 2^31, it does not fit word representation, but it's negation -2^31 does. return x; } } inline void FastRational::negate() { if (this->wordPartValid() && num > WORD_MIN) { num = -num; setMpqPartInvalid(); } else { force_ensure_mpq_valid(); mpq_neg(mpq, mpq); // MB: for the special case num == WORD_MIN && wordPartValid setWordPartInvalid(); try_fit_word(); } assert(isWellFormed()); } inline int FastRational::compare(const FastRational& b) const { if (this->wordPartValid() && b.wordPartValid()) { if (b.den == den) { return compare(num, b.num); } else { return compare(lword(num)*b.den, lword(b.num)*den); } } force_ensure_mpq_valid(); b.force_ensure_mpq_valid(); return mpq_cmp(mpq, b.mpq); } inline int FastRational::sign() const { if (wordPartValid()) { // Based on benchmarking, the tricks in // https://stackoverflow.com/questions/14579920/fast-sign-of-integer-in-c // either degrade performance or have no effect apart from making code less readable if (num < 0) return -1; else if (num > 0) return 1; else return 0; } else { assert(mpqPartValid()); return mpq_sgn(mpq); } } template integer gcd(integer a, integer b) { if (a==0) return b; if (b==0) return a; if (b > a) { integer c = a; a = b; b = c; } while(true) { integer r = a%b; if (r==0) return b; a = b; b = r; } } template FastRational lcm(integer a, integer b) { if (a == 0) return 0; if (b == 0) return 0; if (b > a) return FastRational(b / gcd(a, b)) * a; else return FastRational(a / gcd(a, b)) * b; } // Return 1 if |op1| > |op2|, -1 if |op1| < |op2|, and 0 if op1 = op2 inline int cmpabs(FastRational op1, FastRational op2) { if (op1.sign() == -1) op1 = -op1; if (op2.sign() == -1) op2 = -op2; return op1.compare(op2); }; template ulword gcd(ulword a, ulword b); template uword gcd(uword a, uword b); #define CHECK_WORD(var, value) \ do { \ lword tmp = value; \ if (tmp < WORD_MIN || tmp > WORD_MAX) { \ goto overflow; \ } \ var = tmp; \ } while(0) \ // Adapted from https://codereview.stackexchange.com/questions/37177/simple-method-to-detect-int-overflow #define CHECK_SUM_OVERFLOWS_LWORD(var, s1, s2) \ do { \ if (s1 > 0 and s2 > LWORD_MAX - s1) { \ goto overflow; \ } if (s1 < 0 and s2 < LWORD_MIN - s1) {\ goto overflow; \ } \ var = s1 + s2; \ } while (0) \ #define CHECK_SUB_OVERFLOWS_LWORD(var, s1, s2) \ do { \ if (s1 >= 0 and s2 < s1 - LWORD_MAX) { \ goto overflow; \ } if (s1 < 0 and s2 > (s1 + 1) + LWORD_MAX) { \ goto overflow; \ } \ var = s1 - s2; \ } while (0) \ #define CHECK_POSITIVE(value) \ if (value < 1) abort() #define CHECK_UWORD(var, value) \ do { \ CHECK_POSITIVE(value); \ ulword tmp = value; \ if (tmp > UWORD_MAX) { \ goto overflow; \ } \ var = tmp;\ } while(0) #define COMPUTE_WORD(var, value) \ word var; CHECK_WORD(var, value) inline bool FastRational::isWellFormed() const { assert(wordPartValid() or not fitsWord()); return ( wordPartValid() || mpqPartValid() ) && ( !wordPartValid() || (den != 0 && gcd(absVal(num), den)==1) ) && ( !mpqPartValid() || mpz_sgn(mpq_denref(mpq))!=0 ) && ( !(wordPartValid() && mpqPartValid()) || wordAndMpqEqual()); // Check that if both wordPartValid() and mpqPartValid(), the are the same number } inline bool FastRational::wordAndMpqEqual() const { assert(wordPartValid() && mpqPartValid()); uword int_den = mpz_get_ui(mpq_denref(mpq)); word int_num = mpz_get_si(mpq_numref(mpq)); return int_den == den and int_num == num; } inline FastRational::FastRational(word n, uword d) : state{State::WORD_VALID} { assert(d > 0); if (n == 0) { num = 0; den = 1; } else { uword common = gcd(absVal(n), d); if (common > 1) { num = n / common; den = d / common; } else { num = n; den = d; } } } inline void addition(FastRational& dst, const FastRational& a, const FastRational& b) { if (a.wordPartValid() && b.wordPartValid()) { if (b.num == 0) { dst.num = a.num; dst.den = a.den; } else if (a.num == 0) { dst.num = b.num; dst.den = b.den; } else if (a.den == b.den and b.num > WORD_MIN and a.num == -b.num) { dst.num = 0; dst.den = 1; } else if (b.den == 1) { // Maximum sum here is INT_MAX + INT_MAX*UINT_MAX, which does not overflow. // Minimum sum here is INT_MIN + UINT_MAX*INT_MIN = 2^63, which does not overflow. // (a.num + b.num*a.den)/a.den is already canonicalized as can be seen with simple number theory. lword num_tmp = lword(a.num) + lword(b.num)*a.den; CHECK_WORD(dst.num, num_tmp); dst.den = a.den; // No overflow } else if (a.den == 1) { // See comments above. lword num_tmp = lword(b.num) + lword(a.num)*b.den; CHECK_WORD(dst.num, num_tmp); dst.den = b.den; } else { uword common = gcd(a.den, b.den); lword n1, n2; if (common != 1) { n1 = lword(a.num) * (b.den / common); n2 = lword(b.num) * (a.den / common); } else { n1 = lword(a.num) * b.den; n2 = lword(b.num) * a.den; } lword n; CHECK_SUM_OVERFLOWS_LWORD(n, n1, n2); ulword d = ulword(a.den) * (b.den / common); common = gcd(absVal(n), d); word zn; uword zd; if (common != 1) { CHECK_WORD(zn, n / common); CHECK_UWORD(zd, d / common); } else { CHECK_WORD(zn, n); CHECK_UWORD(zd, d); } dst.num = zn; dst.den = zd; } dst.setOnlyWordPartValid(); assert(dst.isWellFormed()); return; } overflow: a.force_ensure_mpq_valid(); b.force_ensure_mpq_valid(); dst.ensure_mpq_memory_allocated(); mpq_add(dst.mpq, a.mpq, b.mpq); dst.state = State::MPQ_ALLOCATED_AND_VALID; dst.try_fit_word(); } inline void substraction(FastRational& dst, const FastRational& a, const FastRational& b) { if (a.wordPartValid() && b.wordPartValid()) { if (b.num == 0) { dst.num = a.num; dst.den = a.den; } else if (a.num == 0) { CHECK_WORD(dst.num, -lword(b.num)); dst.den = b.den; } else if (a.den == b.den and a.num == b.num) { dst.num = 0; dst.den = 1; } else if (b.den == 1) { // Maximum subtraction here is INT_MAX - (INT_MIN)*(UINT_MAX) = 2^63-1 which does not overflow lword // Minimum subtraction here is INT_MIN - (INT_MAX)*(UINT_MAX) = -9223372028264841217 which does not underflow lword // (a.num - b.num*a.den) / a.den is already canonicalized CHECK_WORD(dst.num, lword(a.num) - lword(b.num)*a.den); dst.den = a.den; } else if (a.den == 1) { // (a.num*b.den - b.den)/b.den is already canonicalized. CHECK_WORD(dst.num, lword(a.num)*b.den - lword(b.num)); dst.den = b.den; } else { uword common = gcd(a.den, b.den); lword n1, n2, n; ulword d; if (common != 1) { // Worst case for n1-n2 seems to be // - 2147483647/4294967292 - 2147483645/4294967294 // This does not overflow. The positive case is the same n1 = lword(a.num) * (b.den / common); n2 = lword(b.num) * (a.den / common); n = n1 - n2; // CHECK_SUB_OVERFLOWS_LWORD(n, n1, n2); d = ulword(a.den) * (b.den / common); } else { n1 = lword(a.num) * b.den; n2 = lword(b.num) * a.den; // Consider -2147483645/4294967294 - 2147483647/4294967295. The following underflows lword CHECK_SUB_OVERFLOWS_LWORD(n, n1, n2); d = ulword(a.den) * b.den; } common = gcd(absVal(n), d); word zn; uword zd; if (common != 1) { CHECK_WORD(zn, n / common); CHECK_UWORD(zd, d / common); } else { CHECK_WORD(zn, n); CHECK_UWORD(zd, d); } dst.num = zn; dst.den = zd; } dst.setOnlyWordPartValid(); assert(dst.isWellFormed()); return; } overflow: a.force_ensure_mpq_valid(); b.force_ensure_mpq_valid(); dst.ensure_mpq_memory_allocated(); mpq_sub(dst.mpq, a.mpq, b.mpq); dst.state = State::MPQ_ALLOCATED_AND_VALID; dst.try_fit_word(); } inline void multiplication(FastRational& dst, const FastRational& a, const FastRational& b) { if ((a.wordPartValid() && a.num==0) || (b.wordPartValid() && b.num==0)) { dst.num=0; dst.den=1; dst.setOnlyWordPartValid(); return; } if (a.wordPartValid() && a.num==1 && a.den==1) { dst = b; return; } if (b.wordPartValid() && b.num==1 && b.den==1) { dst = a; return; } if (a.wordPartValid() && b.wordPartValid()) { word zn; uword zd; uword common1 = gcd(absVal(a.num), b.den), common2 = gcd(a.den, absVal(b.num)); lword k1, k2; ulword k3, k4; // Changed lword => ulword if (common1 > 1) { k1 = lword(a.num)/common1; k4 = ulword(b.den)/common1; } else { k1 = lword(a.num); k4 = ulword(b.den); } if (common2 > 1) { k2 = lword(b.num)/common2; k3 = ulword(a.den)/common2; } else { k2 = lword(b.num); k3 = ulword(a.den); } CHECK_WORD(zn, k1 * k2); CHECK_UWORD(zd, k3 * k4); dst.num = zn; dst.den = zd; dst.setOnlyWordPartValid(); return; } overflow: a.force_ensure_mpq_valid(); b.force_ensure_mpq_valid(); dst.ensure_mpq_memory_allocated(); mpq_mul(dst.mpq, a.mpq, b.mpq); dst.state = State::MPQ_ALLOCATED_AND_VALID; dst.try_fit_word(); } inline void division(FastRational& dst, const FastRational& a, const FastRational& b) { if (b.wordPartValid() && b.num == 1 && b.den == 1) { dst = a; return; } if (a.wordPartValid() && a.num == 0) { dst = 0; return; } if (a.wordPartValid() && b.wordPartValid()) { if (a.num == b.num && a.den == b.den) { dst.num = 1; dst.den = 1; dst.setOnlyWordPartValid(); return; } uword common1 = gcd(absVal(a.num), absVal(b.num)); uword common2 = gcd(a.den, b.den); word zn; uword zd; CHECK_WORD(zn, ulword(absVal(a.num)/common1) * (b.den/common2)); CHECK_UWORD(zd, ulword(absVal(b.num)/common1) * (a.den/common2)); // Note: dst and a or b might be the same FastRational. bool b_num_lt_0 = b.num < 0; bool a_num_ge_0 = a.num >= 0; bool b_num_gt_0 = b.num > 0; bool a_num_le_0 = a.num <= 0; if ((b_num_lt_0 && a_num_ge_0) || (b_num_gt_0 && a_num_le_0)) { // Flip the sign if necessary zn = -zn; // Cannot overflow since zn is a positive word } dst.num = zn; dst.den = zd; dst.setOnlyWordPartValid(); assert(dst.isWellFormed()); return; } overflow: a.force_ensure_mpq_valid(); b.force_ensure_mpq_valid(); dst.ensure_mpq_memory_allocated(); mpq_div(dst.mpq, a.mpq, b.mpq); dst.state = State::MPQ_ALLOCATED_AND_VALID; dst.try_fit_word(); } inline double FastRational::get_d() const { if (wordPartValid()) { return double(num)/double(den); } else { assert(mpqPartValid()); return mpq_get_d(mpq); } } inline void additionAssign(FastRational& a, const FastRational& b) { if (b.wordPartValid()) { if (b.num == 0) return; if (a.wordPartValid()) { if (b.den == 1) { CHECK_WORD(a.num, lword(a.num) + lword(b.num)*a.den); } else if (a.num == 0) { a.num = b.num; a.den = b.den; } else { lword c1 = lword(a.num)*b.den; // No overflow lword c2 = lword(b.num)*a.den; // No overflow lword n; CHECK_SUM_OVERFLOWS_LWORD(n, c1, c2); // Overflow possible ulword d = ulword(a.den) * b.den; lword common = gcd(absVal(n), d); word zn; uword zd; if (common > 1) { CHECK_WORD(zn, n/common); CHECK_UWORD(zd, d/common); } else { CHECK_WORD(zn, n); CHECK_UWORD(zd, d); } a.num = zn; a.den = zd; } a.setOnlyWordPartValid(); assert(a.isWellFormed()); return; } } overflow: a.ensure_mpq_valid(); b.force_ensure_mpq_valid(); mpq_add(a.mpq, a.mpq, b.mpq); a.state = State::MPQ_ALLOCATED_AND_VALID; a.try_fit_word(); } inline void substractionAssign(FastRational& a, const FastRational& b) { if (a.wordPartValid() && b.wordPartValid()) { uword common = gcd(a.den, b.den); COMPUTE_WORD(n1, lword(a.num) * (b.den / common)); COMPUTE_WORD(n2, lword(b.num) * (a.den / common)); lword n = lword(n1) - lword(n2); // Cannot overflow ulword d = ulword(a.den) * (b.den / common); common = gcd(absVal(n), d); word zn; uword zd; if (common > 1) { CHECK_WORD(zn, n / common); CHECK_UWORD(zd, d / common); } else { CHECK_WORD(zn, n); CHECK_UWORD(zd, d); } a.num = zn; a.den = zd; a.setOnlyWordPartValid(); assert(a.isWellFormed()); return; } overflow: a.ensure_mpq_valid(); b.force_ensure_mpq_valid(); mpq_sub(a.mpq, a.mpq, b.mpq); a.state = State::MPQ_ALLOCATED_AND_VALID; a.try_fit_word(); } inline void multiplicationAssign(FastRational& a, const FastRational& b) { if (a.wordPartValid() && b.wordPartValid()) { uword common1 = gcd(absVal(a.num), b.den); uword common2 = gcd(a.den, absVal(b.num)); word zn; uword zd; // Without the absVal, this fails for a.num < 0 when common1 > 1 and b.num < 0 when common2 > 1 since the result of the division is unsigned. CHECK_WORD(zn, lword(common1 > 1 ? absVal(a.num)/common1 : absVal(a.num)) * (common2 > 1 ? absVal(b.num)/common2 : absVal(b.num))); CHECK_UWORD(zd, ulword(common2 > 1 ? a.den/common2 : a.den) * (common1 > 1 ? b.den/common1 : b.den)); bool b_num_lt_0 = b.num < 0; bool a_num_ge_0 = a.num >= 0; bool b_num_gt_0 = b.num > 0; bool a_num_le_0 = a.num <= 0; if ((b_num_lt_0 && a_num_ge_0) || (b_num_gt_0 && a_num_le_0)) { // Flip sign zn = -zn; // Cannot overflow since zn is a positive word } a.num = zn; a.den = zd; a.setOnlyWordPartValid(); assert(a.isWellFormed()); return; } overflow: a.ensure_mpq_valid(); b.force_ensure_mpq_valid(); mpq_mul(a.mpq, a.mpq, b.mpq); a.state = State::MPQ_ALLOCATED_AND_VALID; a.try_fit_word(); } inline void divisionAssign(FastRational& a, const FastRational& b) { if (a.wordPartValid() && b.wordPartValid()) { uword common1 = gcd(absVal(a.num), absVal(b.num)); uword common2 = gcd(a.den, b.den); word zn; uword zd; CHECK_WORD(zn, ulword(absVal(a.num) / common1) * (b.den / common2)); CHECK_UWORD(zd, ulword(absVal(b.num) / common1) * (a.den / common2)); bool b_num_lt_0 = b.num < 0; bool a_num_ge_0 = a.num >= 0; bool b_num_gt_0 = b.num > 0; bool a_num_le_0 = a.num <= 0; if ((b_num_lt_0 && a_num_ge_0) || (b_num_gt_0 && a_num_le_0)) { // Flip sign zn = -zn; // Cannot overflow since zn is a positive word } a.den = zd; a.num = zn; a.setOnlyWordPartValid(); assert(a.isWellFormed()); return; } overflow: a.ensure_mpq_valid(); b.force_ensure_mpq_valid(); mpq_div(a.mpq, a.mpq, b.mpq); a.state = State::MPQ_ALLOCATED_AND_VALID; a.try_fit_word(); } inline unsigned FastRational::size() const { if (wordPartValid()) return 64; return mpz_sizeinbase(mpq_numref(mpq), 2) + mpz_sizeinbase(mpq_denref(mpq), 2); } inline FastRational FastRational::inverse() const { FastRational dest; if (wordPartValid()) { assert(num != 0); word zn; uword zd; if (num > 0) { CHECK_WORD(zn, den); CHECK_UWORD(zd, num); } else { CHECK_WORD(zn, -lword(den)); CHECK_UWORD(zd, -lword(num)); } dest.num = zn; dest.den = zd; return dest; } overflow: force_ensure_mpq_valid(); dest.ensure_mpq_memory_allocated(); mpq_inv(dest.mpq, mpq); dest.state = State::MPQ_ALLOCATED_AND_VALID; dest.try_fit_word(); assert(dest.isWellFormed()); return dest; } inline FastRational abs(const FastRational& x) { if (x.sign() >= 0) { return x; } else { return -x; } } inline FastRational FastRational_inverse(const FastRational& x) { return x.inverse(); } inline bool isNegative(FastRational const& num) { return num.sign() < 0; } inline bool isPositive(FastRational const& num) { return num.sign() > 0; } inline bool isNonNegative(FastRational const& num) { return num.sign() >= 0; } inline bool isNonPositive(FastRational const& num) { return num.sign() <= 0; } FastRational get_multiplicand(const std::vector& reals); #endif opensmt-2.5.2/src/common/FlaPartitionMap.cc000066400000000000000000000020171445011647600206350ustar00rootroot00000000000000// // Created by Martin Blicha on 06.10.18. // #include "FlaPartitionMap.h" std::vector FlaPartitionMap::get_top_level_flas() const { std::vector res; res.reserve(top_level_flas.size()); for(auto entry : top_level_flas) { res.push_back(entry.first); } return res; } void FlaPartitionMap::transferPartitionMembership(PTRef old, PTRef new_ptref) { auto it = top_level_flas.find(old); if (it != top_level_flas.end()) { store_other_fla_index(new_ptref, it->second); return; } auto other_it = other_flas.find(old); if (other_it != other_flas.end()) { store_other_fla_index(new_ptref, other_it->second); } } int FlaPartitionMap::getPartitionIndex(PTRef ref) const { auto it = top_level_flas.find(ref); if (it != top_level_flas.end()) { return static_cast(it->second); } auto other_it = other_flas.find(ref); if (other_it != other_flas.end()) { return static_cast(other_it->second); } return -1; } opensmt-2.5.2/src/common/FlaPartitionMap.h000066400000000000000000000013711445011647600205010ustar00rootroot00000000000000// // Created by Martin Blicha on 06.10.18. // #ifndef OPENSMT_FLAPARTITIONMAP_H #define OPENSMT_FLAPARTITIONMAP_H #include "PTRef.h" #include #include class FlaPartitionMap { std::map top_level_flas; std::map other_flas; public: void store_top_level_fla_index(PTRef fla, unsigned int idx) { top_level_flas[fla] = idx; } void store_other_fla_index(PTRef fla, unsigned int idx) { other_flas[fla] = idx; } std::vector get_top_level_flas () const; unsigned getNoOfPartitions() const {return get_top_level_flas().size();} void transferPartitionMembership(PTRef old, PTRef new_ptref); int getPartitionIndex(PTRef ref) const; }; #endif //OPENSMT_FLAPARTITIONMAP_H opensmt-2.5.2/src/common/Integer.h000066400000000000000000000003111445011647600170350ustar00rootroot00000000000000// // Created by Martin Blicha on 18.02.18. // #ifndef OPENSMT_INTEGER_H #define OPENSMT_INTEGER_H #include "Number.h" namespace opensmt { typedef Number Integer2; } #endif //OPENSMT_INTEGER_H opensmt-2.5.2/src/common/NatSet.h000066400000000000000000000034571445011647600166540ustar00rootroot00000000000000/*++ Copyright (c) 2006 Microsoft Corporation Module Name: nat_set.h Abstract: Set of natural number with fast reset method. Author: Leonardo de Moura (leonardo) 2007-03-27. Revision History: --*/ #ifndef OPENSMT_NATSET_H #define OPENSMT_NATSET_H #include #include class nat_set { unsigned m_curr_timestamp; std::vector m_timestamps; public: nat_set(unsigned s = 0): m_curr_timestamp(0), m_timestamps() { if (s > 0) { m_timestamps.resize(s, 0); } } // A nat_set is a function from [0..s-1] -> boolean. // This method sets the domain of this function. void set_domain(unsigned s) { m_timestamps.resize(s, 0); } unsigned get_domain() const { return m_timestamps.size(); } // Assure that v is in the domain of the set. void assure_domain(unsigned v) { if (v >= get_domain()) { set_domain(v+1); } } bool contains(unsigned v) const { return m_timestamps[v] > m_curr_timestamp; } void insert(unsigned v) { m_timestamps[v] = m_curr_timestamp + 1; } void remove(unsigned v) { m_timestamps[v] = m_curr_timestamp; } void reset() { m_curr_timestamp++; if (m_curr_timestamp == UINT_MAX) { std::fill(m_timestamps.begin(), m_timestamps.end(), 0); m_curr_timestamp = 0; } } bool empty() const { std::vector::const_iterator it = m_timestamps.begin(); std::vector::const_iterator end = m_timestamps.end(); for (; it != end; ++it) { if (*it > m_curr_timestamp) { return false; } } return true; } }; #endif //OPENSMT_NATSET_H opensmt-2.5.2/src/common/Number.h000066400000000000000000000005421445011647600166760ustar00rootroot00000000000000// // Created by Martin Blicha on 18.02.18. // #ifndef OPENSMT_NUMBER_H #define OPENSMT_NUMBER_H #define FAST_RATIONALS 1 #ifdef FAST_RATIONALS #include "FastRational.h" #else #include #endif namespace opensmt { #ifdef FAST_RATIONALS typedef FastRational Number; #else typedef mpq_class Number; #endif } #endif //OPENSMT_NUMBER_H opensmt-2.5.2/src/common/NumberUtils.h000066400000000000000000000032401445011647600177150ustar00rootroot00000000000000/* * Copyright (c) 2021, Antti Hyvarinen * Copyright (c) 2021, Martin Blicha * * SPDX-License-Identifier: MIT */ #ifndef OPENSMT_NUMBERUTILS_H #define OPENSMT_NUMBERUTILS_H #include #include namespace opensmt { typedef mpz_class Integer; //PS. related to BV logic void static inline wordToBinary(const opensmt::Integer x, char *&bin, const int width) { bin = (char *) malloc(width + 1); int p = 0; opensmt::Integer one = 1; for (opensmt::Integer i = (one << (width - 1)); i > 0; i >>= 1) bin[p++] = ((x & i) == i) ? '1' : '0'; bin[p] = '\0'; } void static inline wordToBinary(const unsigned x, char *&bin, const int width) { bin = (char *) malloc(width + 1); int p = 0; opensmt::Integer one = 1; for (opensmt::Integer i = (one << (width - 1)); i > 0; i >>= 1) bin[p++] = ((x & i) == i) ? '1' : '0'; bin[p] = '\0'; } void static inline normalize(char *&rat, const char *flo, bool is_neg) { mpq_t num; mpq_init(num); int val = mpq_set_str(num, flo, 0); (void) val; assert(val != -1); mpq_canonicalize(num); if (is_neg) mpq_neg(num, num); gmp_asprintf(&rat, "%Qd", num); mpq_clear(num); } static inline bool isPowOfTwo(int b) { return b && !(b & (b - 1)); } static inline int getLogFromPowOfTwo(int l) { assert(isPowOfTwo(l)); if (l == 1) return 0; int n = 0; while ((2 << (n++)) != l); return n; } } #endif //OPENSMT_NUMBERUTILS_H opensmt-2.5.2/src/common/OsmtApiException.h000066400000000000000000000006031445011647600206770ustar00rootroot00000000000000// // Created by Martin Blicha on 30.07.20. // #ifndef OPENSMT_OSMTAPIEXCEPTION_H #define OPENSMT_OSMTAPIEXCEPTION_H #include class OsmtApiException : public std::runtime_error { public: OsmtApiException(const std::string & msg) : std::runtime_error(msg) {} OsmtApiException(const char * msg) : std::runtime_error(msg) {} }; #endif //OPENSMT_OSMTAPIEXCEPTION_H opensmt-2.5.2/src/common/OsmtInternalException.h000066400000000000000000000006761445011647600217540ustar00rootroot00000000000000// // Created by prova on 13.05.20. // #pragma once #include #include class OsmtInternalException : public std::exception { std::string msg; public: OsmtInternalException(const std::string & msg) : msg(msg) {} OsmtInternalException(const char * msg) : msg(msg) {} OsmtInternalException() : msg("Unknown internal error") {} virtual const char* what() const noexcept override { return msg.c_str(); } }; opensmt-2.5.2/src/common/PartitionInfo.cc000066400000000000000000000037231445011647600203750ustar00rootroot00000000000000// // Created by Martin Blicha on 2019-08-14. // #include "PartitionInfo.h" void PartitionInfo::assignTopLevelPartitionIndex(unsigned int n, PTRef tr) { flaPartitionMap.store_top_level_fla_index(tr, n); ipartitions_t p = 0; opensmt::setbit(p, n); addIPartitions(tr, p); } ipartitions_t& PartitionInfo::getIPartitions(PTRef _t) { // MB: // this default construct the value if the key was not present and it is default constructed to 0 return term_partitions[_t]; } void PartitionInfo::addIPartitions(PTRef _t, const ipartitions_t& _p) { // MB: // this default construct the value if the key was not present and it is default constructed to 0 term_partitions[_t] |= _p; } ipartitions_t& PartitionInfo::getIPartitions(SymRef _s) { // MB: // this default construct the value if the key was not present and it is default constructed to 0 return sym_partitions[_s]; } void PartitionInfo::addIPartitions(SymRef _s, const ipartitions_t& _p) { // MB: // this default construct the value if the key was not present and it is default constructed to 0 sym_partitions[_s] |= _p; } const ipartitions_t & PartitionInfo::getClausePartitions(CRef c) const { return clause_class.at(c); } void PartitionInfo::addClausePartition(CRef c, const ipartitions_t & p) { // opensmt::orbit(clause_class[c], clause_class[c], p); clause_class[c] |= p; } void PartitionInfo::invalidatePartitions(const ipartitions_t& toinvalidate) { auto negated = ~toinvalidate; for (auto it = term_partitions.begin(); it != term_partitions.end(); /* deliberately empty */) { auto& current_info = it->second; opensmt::andbit(current_info, current_info, negated); if (current_info == 0) { it = term_partitions.erase(it); } else { ++it; } } for (auto & sym_info : sym_partitions) { auto& current_info = sym_info.second; opensmt::andbit(current_info, current_info, negated); } }opensmt-2.5.2/src/common/PartitionInfo.h000066400000000000000000000027101445011647600202320ustar00rootroot00000000000000// // Created by Martin Blicha on 2019-08-14. // #ifndef OPENSMT_PARTITIONINFO_H #define OPENSMT_PARTITIONINFO_H #include #include "InterpolationUtils.h" #include "PTRef.h" #include "SymRef.h" #include "SolverTypes.h" #include "FlaPartitionMap.h" class PartitionInfo { std::unordered_map sym_partitions; std::unordered_map term_partitions; std::unordered_map clause_class; FlaPartitionMap flaPartitionMap; public: void assignTopLevelPartitionIndex(unsigned int n, PTRef tr); // The new partition system ipartitions_t& getIPartitions(PTRef t); void addIPartitions(PTRef t, const ipartitions_t& p); ipartitions_t& getIPartitions(SymRef _s); void addIPartitions(SymRef s, const ipartitions_t& p); const ipartitions_t& getClausePartitions(CRef) const; void addClausePartition(CRef c, const ipartitions_t& p); inline std::vector getTopLevelFormulas() const { return flaPartitionMap.get_top_level_flas(); } inline unsigned int getNoOfPartitions() const {return flaPartitionMap.getNoOfPartitions(); } inline void transferPartitionMembership(PTRef o, PTRef n) { return flaPartitionMap.transferPartitionMembership(o, n); } inline int getPartitionIndex(PTRef p) const { return flaPartitionMap.getPartitionIndex(p); } void invalidatePartitions(ipartitions_t const & p); }; #endif //OPENSMT_PARTITIONINFO_H opensmt-2.5.2/src/common/Random.h000066400000000000000000000013261445011647600166670ustar00rootroot00000000000000/* * Copyright (c) 2022, Antti Hyvarinen * Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson * * SPDX-License-Identifier: MIT */ #ifndef OPENSMT_RANDOM_H #define OPENSMT_RANDOM_H namespace opensmt { // Returns a random float 0 <= x < 1. Seed must never be 0. static inline double drand(double &seed) { assert(seed != 0); seed *= 1389796; int q = (int) (seed / 2147483647); seed -= (double) q * 2147483647; return seed / 2147483647; } // Returns a random integer 0 <= x < size. Seed must never be 0. static inline int irand(double &seed, int size) { return (int) (drand(seed) * size); } } #endif //OPENSMT_RANDOM_H opensmt-2.5.2/src/common/Real.h000066400000000000000000000007131445011647600163310ustar00rootroot00000000000000// // Created by Martin Blicha on 18.02.18. // #ifndef OPENSMT_REAL_H #define OPENSMT_REAL_H /*#define FAST_RATIONALS 1 #ifdef FAST_RATIONALS #include "FastRational.h" #else #include #endif namespace opensmt { #ifdef FAST_RATIONALS typedef FastRational Real; typedef FastRationalHash RealHash; #else typedef mpq_class Real; #endif } */ #include "Number.h" namespace opensmt { typedef Number Real; } #endif //OPENSMT_REAL_H opensmt-2.5.2/src/common/ReportUtils.h000066400000000000000000000011671445011647600177460ustar00rootroot00000000000000/* * Copyright (c) 2008-2012, Roberto Bruttomesso * Copyright (c) 2012-2022, Antti Hyvarinen * Copyright (c) 2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #ifndef OPENSMT_REPORTUTILS_H #define OPENSMT_REPORTUTILS_H #define opensmt_warning( S ) { std::cerr << "; Warning: " << S << std::endl; } #define opensmt_warning2( S, T ) { cerr << "; Warning: " << S << " " << T << endl; } #define reportf(format, args...) ( fflush(stdout), fprintf(stderr, format, ## args), fflush(stderr) ) #endif //OPENSMT_REPORTUTILS_H opensmt-2.5.2/src/common/ScopedVector.h000066400000000000000000000020051445011647600200420ustar00rootroot00000000000000/* * Copyright (c) 2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #ifndef OPENSMT_SCOPEDVECTOR_H #define OPENSMT_SCOPEDVECTOR_H #include namespace opensmt { template class ScopedVector { std::vector elements; std::vector limits; public: void push(T const & element) { return elements.push_back(element); } void pushScope() { limits.push_back(elements.size()); } void popScope(); template void popScope(TFun callback); }; template void ScopedVector::popScope() { popScope([](){}); } template template void ScopedVector::popScope(TFun callback) { assert(not limits.empty()); auto lastLimit = limits.back(); limits.pop_back(); assert(elements.size() >= lastLimit); while (elements.size() > lastLimit) { callback(elements.back()); elements.pop_back(); } } } // namespace opensmt #endif //OPENSMT_SCOPEDVECTOR_H opensmt-2.5.2/src/common/SplayTree.h000066400000000000000000000164511445011647600173640ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ /********************************************************************* The code here is adapted from simple top-down splay from the publicy available code of D. Sleator, avaialable via anonymous ftp from spade.pc.cs.cmu.edu in directory /usr/sleator/public. I've made it a template class parametrizable with the data T to be stored and the comparison function C *********************************************************************/ #ifndef SPLAY_TREE_H #define SPLAY_TREE_H template class SplayTree { public: SplayTree( ) : last_node ( NULL ) , initialized( false ) , size ( 0 ) { } ~SplayTree( ) { deleteTree( root ); delete bnil_node; if ( last_node ) delete last_node; } void setNil( T & e ) { assert( !initialized ); // // Initialize splay tree with just the // node containing an atom that we use // to express a failure in the search // bnil_node = new Bnode; bnil_node->left = bnil_node; bnil_node->right = bnil_node; bnil_node->element = e; root = bnil_node; initialized = true; } T & find ( T & x ); inline bool isEmpty ( ) const { assert( initialized ); return root == bnil_node; } T & insert ( T & ); void remove ( T & ); // // Copy is not supported // const SplayTree & operator=( const SplayTree & rhs ) { assert( false ); } void printStatistics( ostream & ); private: // // Nodes of the tree // struct Bnode { Bnode( ) : left( NULL ) , right( NULL ) { } Bnode( T & t, Bnode * lt, Bnode * rt ) : element( t ) , left ( lt ) , right ( rt ) { } T element; Bnode * left; Bnode * right; }; void deleteTree ( Bnode * t ); void rotateWithLeftChild ( Bnode * & k2 ); void rotateWithRightChild ( Bnode * & k1 ); void splay ( T & x, Bnode * & t ); Bnode * root; // rott of the tree Bnode * last_node; // rott of the tree Bnode * bnil_node; // nil node C cmp; // Comparison structure bool initialized; // Check if the nil node has been initialized unsigned size; // Keep track of the size of the tree (number of nodes) }; // // Inserts an element // template T & SplayTree< T, C >::insert( T & x ) { assert( initialized ); if( last_node == NULL ) { last_node = new Bnode; size ++; } last_node->element = x; if( root == bnil_node ) { last_node->left = last_node->right = bnil_node; root = last_node; } else { splay( x, root ); // // Element is less than // if( cmp( x, root->element ) ) { last_node->left = root->left; last_node->right = root; root->left = bnil_node; root = last_node; } // // Element is greater than // else if( cmp( root->element, x ) ) { last_node->right = root->right; last_node->left = root; root->right = bnil_node; root = last_node; } // // Element is equal; do not insert // else { return root->element; } } last_node = NULL; // Element inserted return x; // Insertion took place } // // Remove element // template void SplayTree< T, C >::remove( T & x ) { assert( initialized ); Bnode * new_tree; // If x is found, it will be at the root splay( x, root ); if( root->element != x ) return; // Item not found; do nothing if( root->left == bnil_node ) new_tree = root->right; else { // Find the maximum in the left subtree // Splay it to the root; and then attach right child new_tree = root->left; splay( x, new_tree ); new_tree->right = root->right; } delete root; root = new_tree; } // // Find an element // template T & SplayTree< T, C >::find( T & x ) { assert( initialized ); if( isEmpty( ) ) return bnil_node; splay( x, root ); if( root->element != x ) return bnil_node; return root->element; } // // Splay the tree with respect to t // template void SplayTree< T, C >::splay( T & t, Bnode * & n ) { assert( initialized ); Bnode *leftTreeMat, *rightTreeMin; static Bnode header; header.left = header.right = bnil_node; leftTreeMat = rightTreeMin = &header; bnil_node->element = t; for(;;) { if( cmp( t, n->element ) ) { if( cmp( t, n->left->element ) ) rotateWithLeftChild( n ); if( n->left == bnil_node ) break; // Link Right rightTreeMin->left = n; rightTreeMin = n; n = n->left; } else if( cmp( n->element, t ) ) { if( cmp( n->right->element, t ) ) rotateWithRightChild( n ); if( n->right == bnil_node ) break; // Link Left leftTreeMat->right = n; leftTreeMat = n; n = n->right; } else break; } leftTreeMat->right = n->left; rightTreeMin->left = n->right; n->left = header.right; n->right = header.left; } // // Rotate using left child of k2 // template void SplayTree< T, C >::rotateWithLeftChild( Bnode * & k2 ) { assert( initialized ); Bnode * k1 = k2->left; k2->left = k1->right; k1->right = k2; k2 = k1; } // // Rotate using right child of k1 // template void SplayTree< T, C >::rotateWithRightChild( Bnode * & k1 ) { assert( initialized ); Bnode * k2 = k1->right; k1->right = k2->left; k2->left = k1; k1 = k2; } // // Recursively delete the tree // template void SplayTree< T, C >::deleteTree( Bnode * t ) { assert( initialized ); if( t != t->left ) { deleteTree( t->left ); deleteTree( t->right ); delete t; } } template void SplayTree< T, C >::printStatistics( ostream & os ) { os << "#" << endl; os << "# Total bnodes..........: " << size << endl; os << "# Bnode size in memory..: " << size * sizeof( Bnode ) / ( 1024.0 * 1024.0 ) << " MB" << endl; os << "# Avg size per bnode....: " << sizeof( Bnode ) << " B" << endl; } #endif opensmt-2.5.2/src/common/StringConv.h000066400000000000000000000154341445011647600175500ustar00rootroot00000000000000/* * Copyright (c) 2021, Antti Hyvarinen * Copyright (c) 2021, Martin Blicha * * SPDX-License-Identifier: MIT */ #ifndef OPENSMT_STRINGCONV_H #define OPENSMT_STRINGCONV_H #include "NumberUtils.h" namespace opensmt { class strConvException : std::exception { char *reason; public: strConvException(const char *reason_) { int res = asprintf(&reason, "Error converting string to rational. %s is not a legal rational", reason_); assert(res >= 0); (void) res; } virtual const char *what() const noexcept { return reason; } ~strConvException() { free(reason); } }; bool static inline isDigit(char c) { return (c >= '0' && c <= '9'); } bool static inline isPosDig(char c) { return (c > '0' && c <= '9'); } bool static inline isIntString(char const *str) { if (str[0] == '\0') return false; for (int i = str[0] == '-' ? 1 : 0; str[i] != '\0'; i++) { if (not isDigit(str[i])) { return false; } } return true; } bool static inline isRealString(char const *str) { if (str[0] == '\0') return false; enum t_State { S0, S1, S2, S3, S4, S5, S6, S7 }; t_State state = S0; bool unexpectedSymbol = false; for (int i = str[0] == '-' ? 1 : 0; str[i] != '\0' and not unexpectedSymbol; i++) { switch (state) { case S0: if (str[i] == '.') state = S2; else if (isDigit(str[i])) state = S1; else unexpectedSymbol = true; break; case S1: if (str[i] == '.') state = S2; else if (isDigit(str[i])) state = S1; else if (str[i] == '/') state = S4; else unexpectedSymbol = true; break; case S2: if (isDigit(str[i])) state = S3; else unexpectedSymbol = true; break; case S3: if (isDigit(str[i])) state = S3; else if (str[i] == '/') state = S4; else unexpectedSymbol = true; break; case S4: case S5: if (isDigit(str[i])) state = S5; else if (str[i] == '.') state = S6; else unexpectedSymbol = true; break; case S6: case S7: if (isDigit(str[i])) state = S7; else unexpectedSymbol = true; break; } } if (unexpectedSymbol) return false; switch (state) { case S1: case S3: case S5: case S7: return true; case S0: case S2: case S4: case S6: return false; } assert(false); // Unreachable return false; } bool static inline stringToRational(char *&rat, const char *flo) { int nom_l = 0; int den_l = 1; int state = 0; int zeroes = 0; bool is_frac = false; bool is_neg = false; if (flo[0] == '-') { flo++; is_neg = true; } for (int i = 0; flo[i] != '\0'; i++) { if (state == 0 && flo[i] == '0') {} else if (state == 0 && isPosDig(flo[i])) { nom_l++; state = 1; } else if (state == 0 && flo[i] == '.') { state = 4; } else if (state == 0 && flo[i] == '/') { state = 5; is_frac = true; } else if (state == 1 && isDigit(flo[i])) { nom_l++; state = 1; } else if (state == 1 && flo[i] == '.') { state = 2; } else if (state == 1 && flo[i] == '/') { state = 5; is_frac = true; } else if (state == 2 && flo[i] == '0') { zeroes++; state = 3; } else if (state == 2 && isPosDig(flo[i])) { nom_l++; state = 2; } else if (state == 3 && flo[i] == '0') { zeroes++; state = 3; } else if (state == 3 && isPosDig(flo[i])) { nom_l += zeroes + 1; zeroes = 0; state = 2; } else if (state == 4 && flo[i] == '0') { state = 4; } else if (state == 4 && isPosDig(flo[i])) { nom_l++; state = 2; } // We come here if it is a fraction already else if (state == 5 && isDigit(flo[i])) { state = 5; } else { throw strConvException(flo); } } if (is_frac) { normalize(rat, flo, is_neg); return true; } if (nom_l == 0) { normalize(rat, "0", false); return true; } state = 0; zeroes = 0; for (int i = 0; flo[i] != '\0'; i++) { if (state == 0 && isDigit(flo[i])) { state = 0; } else if (state == 0 && flo[i] == '.') { state = 1; } else if (state == 1 && isPosDig(flo[i])) { state = 1; den_l++; } else if (state == 1 && flo[i] == '0') { state = 2; zeroes++; } else if (state == 2 && flo[i] == '0') { state = 2; zeroes++; } else if (state == 2 && isPosDig(flo[i])) { state = 1; den_l += zeroes + 1; zeroes = 0; } } // printf("The literal %s, once converted, will have denominator of length %d and nominator of length %d characters\n", flo, den_l, nom_l); char *rat_tmp = (char *) malloc(nom_l + den_l + 2); rat_tmp[0] = '\0'; int i, j; state = -1; for (i = j = 0; j < nom_l; i++) { assert(flo[i] != '\0'); if (state == -1 && flo[i] != '.' && flo[i] != '0') { rat_tmp[j++] = flo[i]; state = 0; } else if (state == -1 && flo[i] == '.') {} else if (state == -1 && flo[i] == '0') {} else if (state == 0 && flo[i] != '.') { rat_tmp[j++] = flo[i]; } else if (state == 0 && flo[i] == '.') {} } rat_tmp[j++] = '/'; rat_tmp[j++] = '1'; for (i = 0; i < den_l - 1; i++) rat_tmp[j++] = '0'; rat_tmp[j] = '\0'; normalize(rat, rat_tmp, is_neg); free(rat_tmp); return true; } } #endif //OPENSMT_STRINGCONV_H opensmt-2.5.2/src/common/StringMap.h000066400000000000000000000037361445011647600173620ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ #ifndef STRINGMAP_H #define STRINGMAP_H #include "Map.h" //=================================================================================================== // Specializations for string hashing (Map from mtl) // struct StringHash { uint32_t operator () (const char* s) const { // http://www.cse.yorku.ca/~oz/hash.html size_t h = 5381; int c; while ((c = *s++)) h = ((h << 5) + h) + c; return h; } }; template <> struct Equal { bool operator() (const char* s1, const char* s2) const { int i = 0; for (i = 0; s1[i] != '\0' && s2[i] != '\0'; i++) if (s1[i] != s2[i]) break; return (s1[i] == 0 && s2[i] == 0); } }; #endif opensmt-2.5.2/src/common/SystemQueries.h000066400000000000000000000036221445011647600202720ustar00rootroot00000000000000/* * Copyright (c) 2008-2012, Roberto Bruttomesso * Copyright (c) 2012-2022, Antti Hyvarinen * Copyright (c) 2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #ifndef SYSTEMQUERIES_H #define SYSTEMQUERIES_H #include #include #include #include namespace opensmt { static inline double cpuTime(void) { struct rusage ru; getrusage(RUSAGE_SELF, &ru); return (double)ru.ru_utime.tv_sec + (double)ru.ru_utime.tv_usec / 1000000; } #if defined(__linux__) static inline int memReadStat(int field) { constexpr std::size_t BUFF_SIZE = 256; char name[BUFF_SIZE]; pid_t pid = getpid(); snprintf(name, BUFF_SIZE, "/proc/%d/statm", pid); FILE* in = fopen(name, "rb"); if (in == NULL) return 0; int value; for (; field >= 0; field--) { int res = fscanf(in, "%d", &value); (void)res; } fclose(in); return value; } static inline uint64_t memUsed() { return (uint64_t)memReadStat(0) * (uint64_t)getpagesize(); } #elif defined(__FreeBSD__) || defined(__OSX__) || defined(__APPLE__) static inline uint64_t memUsed() { constexpr std::size_t BUFF_SIZE = 256; char name[BUFF_SIZE]; FILE *pipe; char buf[4*BUFF_SIZE]; uint64_t value=0; pid_t pid = getpid(); snprintf(name, BUFF_SIZE,"ps -o rss -p %d | grep -v RSS", pid); pipe = popen(name, "r"); if (pipe) { fgets(buf, 1024, pipe); value = 1024 * strtoul(buf, NULL, 10); pclose(pipe); } return value; } #else // stub to support every platform static inline uint64_t memUsed() {return 0; } #endif } // namespace opensmt using opensmt::cpuTime; using opensmt::memUsed; #endif // SYSTEMQUERIES_H opensmt-2.5.2/src/common/Timer.h000066400000000000000000000105031445011647600165240ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2016, Antti Hyvarinen 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #ifndef TIMER_H #define TIMER_H #include #include #include #include #include #include namespace opensmt { // A c++ wrapper for struct timeval class BTime { time_t tv_sec; suseconds_t tv_usec; public: BTime() : tv_sec(0), tv_usec(0) {} BTime(const struct timeval& tv) : tv_sec(tv.tv_sec), tv_usec(tv.tv_usec) {} BTime(const BTime& from) : tv_sec(from.tv_sec), tv_usec(from.tv_usec) {} void operator-= (const BTime& subst) { tv_sec -= subst.tv_sec; tv_usec -= subst.tv_usec; } BTime operator- (const BTime& subst) { BTime out; out.tv_sec = tv_sec - subst.tv_sec; out.tv_usec = tv_usec - subst.tv_usec; return out; } void operator= (const BTime& from) { tv_sec = from.tv_sec; tv_usec = from.tv_usec; } BTime& operator+= (const BTime& other) { tv_sec += other.tv_sec; tv_usec += other.tv_usec; return *this; } double getTime() { return tv_sec + tv_usec/(double)1000000; } }; class OSMTTimeVal { BTime usrtime; BTime systime; public: OSMTTimeVal() {} OSMTTimeVal(const BTime& usrtime, const BTime& systime) : usrtime(usrtime), systime(systime) {} OSMTTimeVal(const struct rusage& res_usage) : usrtime(res_usage.ru_utime), systime(res_usage.ru_stime) {} void operator-= (const OSMTTimeVal& subst) { usrtime -= subst.usrtime; systime -= subst.systime; } OSMTTimeVal operator- (const OSMTTimeVal& subst) { OSMTTimeVal out; out.usrtime = usrtime - subst.usrtime; out.systime = systime - subst.systime; return out; } OSMTTimeVal& operator+= (const OSMTTimeVal& from) { usrtime += from.usrtime; systime += from.systime; return *this; } double getTime() { return usrtime.getTime() + systime.getTime(); } }; class StopWatch { protected: struct rusage tmp_rusage; OSMTTimeVal time_start; OSMTTimeVal &timer; public: StopWatch(OSMTTimeVal& timer) : timer(timer) { if (getrusage(RUSAGE_SELF, &tmp_rusage) == 0) { time_start = OSMTTimeVal(tmp_rusage); } else assert(false); } ~StopWatch() { if (getrusage(RUSAGE_SELF, &tmp_rusage) == 0) { timer += OSMTTimeVal(tmp_rusage) - time_start; } else assert(false); } }; class PrintStopWatch { protected: char* name; OSMTTimeVal timer; std::ostream& os; StopWatch* watch; public: PrintStopWatch(const char* _name, std::ostream& os) : os(os), watch(new StopWatch(timer)) { int size = strlen(_name); name = (char*)malloc(size+1); strcpy(name, _name); } ~PrintStopWatch() { delete watch; os << "; " << name << " " << timer.getTime() << " s\n"; free(name); } }; } #endif opensmt-2.5.2/src/common/TreeOps.h000066400000000000000000000247641445011647600170430ustar00rootroot00000000000000/* * Copyright (c) 2012-2022, Antti Hyvarinen * Copyright (c) 2021-2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #ifndef Common_TreeOps_h #define Common_TreeOps_h #include "Logic.h" #include "NatSet.h" #include "Pterm.h" #include "Vec.h" #include template class TermVisitor { Logic const & logic; TConfig & cfg; public: TermVisitor(Logic const & logic, TConfig & cfg) : logic(logic), cfg(cfg) {} virtual void visit(PTRef root) { // Avoid initializations if no traversal will be done if (logic.isVar(root)) { if (cfg.previsit(root)) cfg.visit(root); return; } struct DFSEntry { DFSEntry(PTRef term) : term(term) {} PTRef term; unsigned int nextChild = 0; }; auto termMarks = logic.getTermMarks(logic.getPterm(root).getId()); std::vector toProcess; toProcess.emplace_back(root); while (not toProcess.empty()) { auto & currentEntry = toProcess.back(); PTRef currentRef = currentEntry.term; auto currentId = logic.getPterm(currentRef).getId(); if (not cfg.previsit(currentRef)) { toProcess.pop_back(); termMarks.mark(currentId); continue; } assert(not termMarks.isMarked(currentId)); Pterm const & term = logic.getPterm(currentRef); unsigned childrenCount = term.size(); if (currentEntry.nextChild < childrenCount) { PTRef nextChild = term[currentEntry.nextChild]; ++currentEntry.nextChild; auto childId = logic.getPterm(nextChild).getId(); if (not termMarks.isMarked(childId)) { toProcess.push_back(DFSEntry(nextChild)); } continue; } // If we are here, we have already processed all children assert(not termMarks.isMarked(currentId)); cfg.visit(currentRef); termMarks.mark(currentId); toProcess.pop_back(); } } }; class DefaultVisitorConfig { public: virtual bool previsit(PTRef) { return true; } // should continue visiting virtual void visit(PTRef) { } // don't do anything }; class AppearsInUFVisitorConfig : public DefaultVisitorConfig { Logic & logic; public: AppearsInUFVisitorConfig(Logic & logic): logic(logic) {} void visit(PTRef term) override { if (logic.isUF(term)) { for (PTRef child : logic.getPterm(term)) { if (logic.hasSortBool(child)) { logic.setAppearsInUF(logic.isNot(child) ? logic.getPterm(child)[0] : child); } } } } }; class AppearsInUfVisitor : public TermVisitor { AppearsInUFVisitorConfig cfg; public: AppearsInUfVisitor(Logic & logic): TermVisitor(logic, cfg), cfg(logic) {} }; class TopLevelConjunctsConfig : public DefaultVisitorConfig { Logic const & logic; vec & conjuncts; public: TopLevelConjunctsConfig(Logic const & logic, vec & res) : logic(logic), conjuncts(res) {} bool previsit(PTRef term) override { if (not logic.isAnd(term)) { conjuncts.push(term); return false; } return true; } }; inline void topLevelConjuncts(Logic const & logic, PTRef fla, vec & res) { TopLevelConjunctsConfig config(logic, res); TermVisitor(logic, config).visit(fla); } inline vec topLevelConjuncts(Logic const & logic, PTRef fla) { vec res; topLevelConjuncts(logic, fla, res); return res; } template class Qel { public: T x; int chk; Qel(T r) : x(r), chk(0) {}; }; // // Visit the term dag starting from vec trs. Return in list_out every term occurrence // in the tree in an order where the parent term is always listed before its // children. Also store the information who is the parent of the term. Since // the parent info is also returned, duplicate terms will be reported. // However, the list_out will not contain duplicates. // template [[deprecated]] void getTermsList(const vec& trs, vec& list_out, Logic& logic) { vec > queue; Map seen; Map chkd; #ifdef PEDANTIC_DEBUG // assert(logic.hasSym(logic.getPterm(tr).symb())); #endif for (int i = 0; i < trs.size(); i++) queue.push(Qel(PtChild(trs[i], PTRef_Undef, -1))); while (queue.size() > 0) { int q_idx = queue.size() - 1; #ifdef PEDANTIC_DEBUG // assert(logic.hasSym(logic.getPterm(queue[q_idx].x.tr).symb())); #endif Pterm& pt = logic.getPterm(queue[q_idx].x.tr); int i = queue[q_idx].chk; if (i < pt.size()) { PtChild ptc(pt[i], queue[q_idx].x.tr, i); if (!seen.has(ptc)) { queue.push(Qel(ptc)); #ifdef PEDANTIC_DEBUG // assert(logic.hasSym(logic.getPterm(ptc.tr).symb())); #endif } queue[q_idx].chk = i+1; } else { T ptc(queue[q_idx].x.tr, queue[q_idx].x.parent, queue[q_idx].x.pos); list_out.push(ptc); seen.insert(ptc, true); assert(queue.size() > 0); queue.pop(); } } } template [[deprecated]] void getTermList(PTRef tr, vec& list_out, Logic& logic) { getTermsList({tr}, list_out, logic); } // Get variables starting from the root // [[deprecated("Use variables(Logic &, PTRef) instead.")]] inline void getVars(PTRef tr, Logic& logic, MapWithKeys& vars) { Map seen; vec queue; queue.push(tr); while (queue.size() != 0) { tr = queue.last(); if (seen.has(tr)) { queue.pop(); continue; } bool unprocessed_children = false; for (int i = 0; i < logic.getPterm(tr).size(); i++) { PTRef c = logic.getPterm(tr)[i]; if (seen.has(c)) continue; else { queue.push(c); unprocessed_children = true; } } if (unprocessed_children == true) continue; queue.pop(); if (logic.isVar(tr)) vars.insert(tr, true); seen.insert(tr, true); } } [[deprecated]] inline std::vector getAtoms(PTRef tr, Logic & logic) { std::vector atoms; std::unordered_set seen; std::vector queue; queue.push_back(tr); while (queue.size() != 0) { tr = queue.back(); if (seen.find(tr) != seen.end()) { queue.pop_back(); continue; } if (logic.isBooleanOperator(tr)) { // I only need to consider children of connectives, no need for going further bool unprocessed_children = false; for (int i = 0; i < logic.getPterm(tr).size(); i++) { PTRef c = logic.getPterm(tr)[i]; if (seen.find(c) != seen.end()) continue; else { queue.push_back(c); unprocessed_children = true; } } if (unprocessed_children == true) continue; } // if not boolean operator => it is an atom! queue.pop_back(); assert(logic.isBooleanOperator(tr) || logic.hasSortBool(tr)); // MB: we should not go past atoms! if (!logic.isBooleanOperator(tr) && logic.hasSortBool(tr)) { atoms.push_back(tr); } seen.insert(tr); } return atoms; } template class TermCollectorConfig : public DefaultVisitorConfig { TPred predicate; vec gatheredTerms; public: TermCollectorConfig(TPred predicate) : predicate(std::move(predicate)) {} vec && extractCollectedTerms() { return std::move(gatheredTerms); } void visit(PTRef term) override { if (predicate(term)) gatheredTerms.push(term); } }; template static vec matchingSubTerms(Logic const & logic, PTRef term, TPred predicate) { TermCollectorConfig config(predicate); TermVisitor(logic, config).visit(term); return config.extractCollectedTerms(); } inline vec subTerms(Logic const & logic, PTRef term) { return matchingSubTerms(logic, term, [](PTRef) { return true; }); } /* Returns all variables present in the given term */ inline vec variables(Logic const & logic, PTRef term) { return matchingSubTerms(logic, term, [&](PTRef subTerm) { return logic.isVar(subTerm); }); } class PtermNodeCounterConfig : public DefaultVisitorConfig { friend class PtermNodeCounter; uint32_t nodeCounter = 0; uint32_t maxNodes; std::unordered_map & countLookup; using Cache = std::pair>; public: PtermNodeCounterConfig(Cache & cache) : maxNodes(cache.first), countLookup(cache.second) {} bool limitReached() const { return nodeCounter >= maxNodes; } void visit(PTRef tr) override { auto it = countLookup.find(tr); if (it != countLookup.end()) { if (it->second >= maxNodes) { nodeCounter = std::max(nodeCounter, maxNodes); } } else { ++ nodeCounter; } } bool previsit(PTRef tr) override { auto it = countLookup.find(tr); if (it != countLookup.end() and it->second >= maxNodes) { nodeCounter = std::max(nodeCounter, it->second); } return (nodeCounter < maxNodes); } uint32_t getCount() const { return nodeCounter; } }; class PtermNodeCounter : public TermVisitor { PtermNodeCounterConfig::Cache cache; PtermNodeCounterConfig cfg; public: PtermNodeCounter(Logic const & logic, int countUntil) : TermVisitor(logic, cfg), cache(countUntil, std::unordered_map()), cfg(cache) {} void visit(PTRef root) override { cfg.nodeCounter = 0; TermVisitor::visit(root); if (cache.second.find(root) == cache.second.end()) { cache.second.insert({root, getCount()}); } } bool limitReached() const { return cfg.limitReached(); } uint32_t getCount() const { return cfg.getCount(); } }; #endif opensmt-2.5.2/src/common/TypeUtils.h000066400000000000000000000017021445011647600174070ustar00rootroot00000000000000/* * Copyright (c) 2021, Antti Hyvarinen * Copyright (c) 2021, Martin Blicha * * SPDX-License-Identifier: MIT */ #ifndef OPENSMT_TYPEUTILS_H #define OPENSMT_TYPEUTILS_H namespace opensmt { // std::pair is not trivially copyable. This version seems to allow on current compilers faster implementations. template struct pair { T first; U second; }; template class span { T *_beg; uint32_t _size; public: span(T *beg, uint32_t size) : _beg{beg}, _size{size} {} uint32_t size() const { return _size; } T const & operator[](uint32_t index) const { return *(_beg + index); } T const *begin() const { return _beg; } T const *end() const { return _beg + _size; } T & operator[](uint32_t index) { return *(_beg + index); } T * begin() { return _beg; } T * end() { return _beg + _size; } }; } #endif //OPENSMT_TYPEUTILS_H opensmt-2.5.2/src/common/VerificationUtils.cc000066400000000000000000000034431445011647600212520ustar00rootroot00000000000000/* * Copyright (c) 2020-2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #include "VerificationUtils.h" #include "MainSolver.h" #include "TreeOps.h" bool VerificationUtils::verifyInterpolantInternal(PTRef Apartition, PTRef Bpartition, PTRef itp) { SMTConfig validationConfig; MainSolver validationSolver(logic, validationConfig, "validator"); // std::cout << "A part: " << logic.printTerm(Apartition) << '\n'; // std::cout << "B part: " << logic.printTerm(Bpartition) << '\n'; // std::cout << "Interpol: " << logic.printTerm(itp) << std::endl; validationSolver.push(); validationSolver.insertFormula(logic.mkNot(logic.mkImpl(Apartition, itp))); auto res = validationSolver.check(); bool ok = res == s_False; if (not ok) { return false; } validationSolver.pop(); validationSolver.insertFormula(logic.mkNot(logic.mkImpl(itp, logic.mkNot(Bpartition)))); res = validationSolver.check(); ok = res == s_False; if (not ok) { return false; } return checkSubsetCondition(itp, Apartition) and checkSubsetCondition(itp, Bpartition); } bool VerificationUtils::checkSubsetCondition(PTRef p1, PTRef p2) const { auto vars_p1 = variables(logic, p1); auto vars_p2 = variables(logic, p2); for (PTRef key : vars_p1) { if (std::find(vars_p2.begin(), vars_p2.end(), key) == vars_p2.end()) { return false; } } return true; } bool VerificationUtils::impliesInternal(PTRef antecedent, PTRef consequent) { SMTConfig validationConfig; MainSolver validationSolver(logic, validationConfig, "validator"); validationSolver.insertFormula(logic.mkNot(logic.mkImpl(antecedent, consequent))); auto res = validationSolver.check(); bool valid = res == s_False; return valid; } opensmt-2.5.2/src/common/VerificationUtils.h000066400000000000000000000013121445011647600211050ustar00rootroot00000000000000/* * Copyright (c) 2020-2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #ifndef OPENSMT_VERIFICATIONUTILS_H #define OPENSMT_VERIFICATIONUTILS_H #include "Logic.h" class VerificationUtils { Logic & logic; public: VerificationUtils(Logic & logic) : logic(logic) {} bool verifyInterpolantInternal(PTRef partA, PTRef partB, PTRef itp); // Verify interpolant internally, using OpenSMT's MainSolver bool impliesInternal(PTRef antecedent, PTRef consequent); // Verify validity of implication `antecedent -> consequent`, using OpenSMT's MainSolver private: bool checkSubsetCondition(PTRef p1, PTRef p2) const; }; #endif //OPENSMT_VERIFICATIONUTILS_H opensmt-2.5.2/src/common/XAlloc.h000066400000000000000000000035561445011647600166400ustar00rootroot00000000000000/****************************************************************************************[XAlloc.h] Copyright (c) 2009-2010, Niklas Sorensson 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. **************************************************************************************************/ #ifndef Minisat_XAlloc_h #define Minisat_XAlloc_h #include #include //================================================================================================= // Simple layer on top of malloc/realloc to catch out-of-memory situtaions and provide some typing: class OutOfMemoryException{}; static inline void* xrealloc(void *ptr, size_t size) { void* mem = realloc(ptr, size); if (mem == NULL && errno == ENOMEM){ throw OutOfMemoryException(); }else return mem; } //================================================================================================= #endif opensmt-2.5.2/src/common/osmtinttypes.h000066400000000000000000000035601445011647600202330ustar00rootroot00000000000000/**************************************************************************************[osmtinttypes.h] Copyright (c) 2009-2010, Niklas Sorensson 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. **************************************************************************************************/ #ifndef Minisat_IntTypes_h #define Minisat_IntTypes_h #ifdef __sun // Not sure if there are newer versions that support C99 headers. The // needed features are implemented in the headers below though: # include # include # include #else #define __STDC_LIMIT_MACROS # include //# include #ifndef UINT32_MAX # define UINT32_MAX (4294967295U) #endif //# define uint32_t unsigned int #endif #include //================================================================================================= #endif opensmt-2.5.2/src/interpolation/000077500000000000000000000000001445011647600166735ustar00rootroot00000000000000opensmt-2.5.2/src/interpolation/CMakeLists.txt000066400000000000000000000001101445011647600214230ustar00rootroot00000000000000install(FILES InterpolationUtils.h DESTINATION ${INSTALL_HEADERS_DIR}) opensmt-2.5.2/src/interpolation/InterpolationUtils.h000066400000000000000000000067621445011647600227270ustar00rootroot00000000000000/* * Copyright (c) 2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #ifndef OPENSMT_INTERPOLATIONUTILS_H #define OPENSMT_INTERPOLATIONUTILS_H #include #include #include namespace opensmt { enum class icolor_t : char { I_UNDEF = 0, I_A = 1, I_B = 2, I_AB = I_A | I_B, I_S = 4 }; inline constexpr icolor_t operator| (icolor_t f, icolor_t s) { return static_cast(static_cast>(f) | static_cast>(s)); } inline constexpr icolor_t operator& (icolor_t f, icolor_t s) { return static_cast(static_cast>(f) & static_cast>(s)); } inline std::string colorToString(icolor_t c) { switch (c) { case icolor_t::I_UNDEF: return "UNDEF"; case icolor_t::I_A: return "A"; case icolor_t::I_B: return "B"; case icolor_t::I_AB: return "AB"; case icolor_t::I_S: return "S"; default: assert(false); throw std::logic_error("Unreachable"); } } using ipartitions_t = mpz_class; inline void setbit(ipartitions_t & p, const unsigned b) { mpz_setbit(p.get_mpz_t(), b); } inline void clrbit(ipartitions_t & p, const unsigned b) { mpz_clrbit(p.get_mpz_t(), b); } inline int tstbit(const ipartitions_t & p, const unsigned b) { return mpz_tstbit(p.get_mpz_t(), b); } // Set rop to op1 bitwise-and op2. inline void andbit(ipartitions_t & ipres, const ipartitions_t & ip1, const ipartitions_t & ip2) { mpz_and(ipres.get_mpz_t(), ip1.get_mpz_t(), ip2.get_mpz_t()); } // Set rop to op1 bitwise inclusive-or op2. inline void orbit(ipartitions_t & ipres, const ipartitions_t & ip1, const ipartitions_t & ip2) { mpz_ior(ipres.get_mpz_t(), ip1.get_mpz_t(), ip2.get_mpz_t()); } inline bool isAlocal (const ipartitions_t & p, const ipartitions_t & mask) { return (p & mask) != 0; } inline bool isBlocal (const ipartitions_t & p, const ipartitions_t & mask) { return (p & ~mask) != 0; } inline bool isAstrict(const ipartitions_t & p, const ipartitions_t & mask) { return isAlocal(p, mask) and not isBlocal(p, mask); } inline bool isBstrict(const ipartitions_t & p, const ipartitions_t & mask) { return isBlocal( p, mask ) and not isAlocal(p, mask); } inline bool isAB (const ipartitions_t & p, const ipartitions_t & mask) { return isAlocal( p, mask ) and isBlocal(p, mask); } // To specify the tree structure of a collection of partitions // NOTE Partitions should be tagged with consecutive ids >=1 class InterpolationTree { public: InterpolationTree(int _partition_id): partition_id(_partition_id), parent(NULL) {} void addChild (InterpolationTree* _tree){ children.insert(_tree); (*_tree).setParent(this); } void setParent(InterpolationTree* _parent){ parent = _parent; } int getPartitionId() { return partition_id; } std::set& getChildren() { return children; } InterpolationTree* getParent() {return parent; } private: // NOTE if the tree has N nodes, the partition ids go from 1 to N int partition_id; // The integer corresponding to the partition id std::set children; // The children of the node in the tree InterpolationTree* parent; }; } // TODO: Remove these using from header file using opensmt::ipartitions_t; using opensmt::icolor_t; #endif //OPENSMT_INTERPOLATIONUTILS_H opensmt-2.5.2/src/itehandler/000077500000000000000000000000001445011647600161235ustar00rootroot00000000000000opensmt-2.5.2/src/itehandler/CMakeLists.txt000066400000000000000000000002351445011647600206630ustar00rootroot00000000000000add_library(itehandler OBJECT IteToSwitch.cc IteToSwitchMisc.cc IteHandler.cc) install(FILES IteToSwitch.h IteHandler.h DESTINATION ${INSTALL_HEADERS_DIR}) opensmt-2.5.2/src/itehandler/IteHandler.cc000066400000000000000000000067121445011647600204570ustar00rootroot00000000000000// // Created by Martin Blicha on 18.05.21. // #include "IteHandler.h" #include "IteToSwitch.h" #include "OsmtInternalException.h" PTRef IteHandler::rewrite(PTRef root) { IteToSwitch switches(logic, root); PTRef new_root = switches.conjoin(root); return new_root == root ? root : replaceItes(new_root); } PTRef IteHandler::getAuxVarFor(PTRef ite) { assert(logic.isIte(ite)); std::string name(itePrefix); name += std::to_string(ite.x); name += suffix; return logic.mkVar(logic.getSortRef(ite), name.c_str()); } PTRef IteHandler::getIteTermFor(Logic const & logic, PTRef auxVar) { std::string const & name = logic.getSymName(auxVar); assert(name.compare(0, itePrefix.size(), itePrefix) == 0); std::string numberStr; for (auto it = name.begin() + itePrefix.size(); it != name.end(); ++it) { if ('0' <= *it and *it <= '9') { numberStr += *it; } else { break; } } auto number = static_cast(std::stoul(numberStr)); PTRef ite = { number }; assert(logic.isIte(ite)); return ite; } PTRef IteHandler::replaceItes(PTRef root) { // Note: We cannot use the current rewriting infrastructure because here we want to rewrite ITE without analyzing first its children. // TODO: adjust rewriting infrastructure to fit this case as well. struct DFSEntry { DFSEntry(PTRef term) : term(term) {} PTRef term; unsigned int nextChild = 0; }; // MB: Relies on an invariant that id of a child is lower than id of a parent. auto size = Idx(logic.getPterm(root).getId()) + 1; std::vector done; done.resize(size, 0); std::unordered_map substitutions; std::vector toProcess; toProcess.emplace_back(root); while (not toProcess.empty()) { auto & currentEntry = toProcess.back(); PTRef currentRef = currentEntry.term; auto currentId = Idx(logic.getPterm(currentRef).getId()); if (logic.isIte(currentRef)) { substitutions.insert({currentRef, getAuxVarFor(currentRef)}); done[currentId] = 1; toProcess.pop_back(); continue; } assert(not done[currentId]); Pterm const & term = logic.getPterm(currentRef); unsigned childrenCount = term.size(); if (currentEntry.nextChild < childrenCount) { PTRef nextChild = term[currentEntry.nextChild]; ++currentEntry.nextChild; if (not done[Idx(logic.getPterm(nextChild).getId())]) { toProcess.push_back(DFSEntry(nextChild)); } continue; } // If we are here, we have already processed all children assert(done[currentId] == 0); vec newArgs(childrenCount); bool needsChange = false; for (unsigned i = 0; i < childrenCount; ++i) { auto it = substitutions.find(term[i]); bool childChanged = it != substitutions.end(); needsChange |= childChanged; newArgs[i] = childChanged ? it->second : term[i]; } PTRef newTerm = needsChange ? logic.insertTerm(term.symb(), std::move(newArgs)) : currentRef; if (needsChange) { substitutions.insert({currentRef, newTerm}); } done[currentId] = 1; toProcess.pop_back(); } auto it = substitutions.find(root); PTRef res = it == substitutions.end() ? root : it->second; return res; } opensmt-2.5.2/src/itehandler/IteHandler.h000066400000000000000000000013251445011647600203140ustar00rootroot00000000000000// // Created by Martin Blicha on 18.05.21. // #ifndef OPENSMT_ITEHANDLER_H #define OPENSMT_ITEHANDLER_H #include "PTRef.h" #include "Logic.h" #include class IteHandler { private: Logic & logic; std::string suffix; PTRef getAuxVarFor(PTRef ite); PTRef replaceItes(PTRef root); public: IteHandler(Logic & logic) : logic(logic) {} IteHandler(Logic & logic, unsigned long partitionNumber) : logic(logic), suffix('_' + std::to_string(partitionNumber)) {} PTRef rewrite(PTRef root); static PTRef getIteTermFor(Logic const & logic, PTRef auxVar); // The inverse of getAuxVarFor static std::string_view constexpr itePrefix = ".ite"; }; #endif //OPENSMT_ITEHANDLER_H opensmt-2.5.2/src/itehandler/IteToSwitch.cc000066400000000000000000000210221445011647600206350ustar00rootroot00000000000000// // Created by prova on 04.08.20. // #include "IteToSwitch.h" #include "Logic.h" ite::Node::Node(PTRef term, PTRef cond, NodeRef true_node, NodeRef false_node, uint32_t id) : id(id) , type(cond != PTRef_Undef ? static_cast(NodeType::inner) : static_cast(NodeType::leaf)) , term(term) { if (cond != PTRef_Undef) { // a leaf node. setCond(cond); setTrueChild(true_node); setFalseChild(false_node); } } ite::NodeRef ite::Dag::newNode(PTRef val) { return newNode(val, PTRef_Undef, NodeRef_Undef, NodeRef_Undef); } ite::NodeRef ite::Dag::newNode(PTRef tr, PTRef cond, ite::NodeRef true_node, ite::NodeRef false_node) { assert(not nodes.has(tr)); nodeRefs.push(na.alloc(tr, cond, true_node, false_node)); nodes.insert(tr, nodeRefs.last()); return nodeRefs.last(); } void ite::Dag::annotateWithParentInfo(PTRef root_tr) { NodeRef root = getNode(root_tr); vec queue; vec flag; flag.growTo(na.getNumNodes()); parents[root] = ParentSet(); queue.push(root); while (queue.size() != 0) { NodeRef el_r = queue.last(); const Node &el = na[el_r]; if (flag[el.getId()] == type::black) { queue.pop(); continue; } flag[el.getId()] = type::gray; bool unprocessed_children = false; for (lbool childPolarity : { l_False, l_True }) { NodeRef child = childPolarity == l_False ? el.getFalseChild() : el.getTrueChild(); if (child != NodeRef_Undef) { parents[child].insert({el_r, childPolarity}); if (flag[na[child].getId()] == type::white) { unprocessed_children = true; queue.push(child); } } else { leaves.insert(el_r); } } if (unprocessed_children) { continue; } flag[el.getId()] = type::black; queue.pop(); } } ite::Dag ite::Dag::getReachableSubGraph(const Logic &logic, PTRef root) { Dag dag; vec queue; vec flag; flag.growTo(na.getNumNodes()); NodeRef rootNode = nodes[root]; queue.push(rootNode); while (queue.size() > 0) { NodeRef el_r = queue.last(); const Node &el = na[el_r]; if (flag[el.getId()] == type::black) { queue.pop(); continue; } flag[el.getId()] = type::gray; bool unprocessed_children = false; for (NodeRef child : {el.getFalseChild(), el.getTrueChild()}) { if (child != NodeRef_Undef && flag[na[child].getId()] == type::white) { queue.push(child); unprocessed_children = true; } } if (unprocessed_children) { continue; } flag[el.getId()] = type::black; queue.pop(); PTRef term = el.getTerm(); if (logic.isIte(term)) { assert(na[el_r].getTrueChild() != NodeRef_Undef); assert(na[el_r].getFalseChild() != NodeRef_Undef); NodeRef true_node = dag.getNodeOrCreateLeafNode(na[na[el_r].getTrueChild()].getTerm()); NodeRef false_node = dag.getNodeOrCreateLeafNode(na[na[el_r].getFalseChild()].getTerm()); dag.createAndStoreNode(term, na[el_r].getCond(), true_node, false_node); } else { for (int i = 0; i < logic.getPterm(term).size(); i++) { PTRef c = logic.getPterm(term)[i]; if (logic.isIte(c) and isTopLevelIte(c)) { dag.addTopLevelIte(c); } } } } return dag; } vec ite::Dag::getCondValPairs(Logic& logic) const { // Reverse traversal starting from leaves std::map dagNodeToPTRef; vec queue; for (auto root : leaves) { queue.push(root); } vec flag; flag.growTo(na.getNumNodes()); vec switches; while (queue.size() != 0) { NodeRef el_r = queue.last(); const Node &el = na[el_r]; if (flag[el.getId()] == type::black) { queue.pop(); continue; } bool unprocessed_parents = false; for (const auto &parentAndPolarity : parents.at(el_r)) { auto parent = parentAndPolarity.nr; if (flag[na[parent].getId()] == type::white) { flag[na[parent].getId()] = type::gray; queue.push(parent); unprocessed_parents = true; } } if (unprocessed_parents) { continue; } flag[el.getId()] = type::black; queue.pop(); if (dagNodeToPTRef.find(el_r) == dagNodeToPTRef.end()) { auto &myParents = parents.at(el_r); vec parentConditions; if (myParents.empty()) { parentConditions.push(logic.getTerm_true()); } else { for (auto &nodeAndPolarity : myParents) { PTRef cond = na[nodeAndPolarity.nr].getCond(); lbool pol = nodeAndPolarity.sign; PTRef parentCondition = dagNodeToPTRef.at(nodeAndPolarity.nr); PTRef edgeCondition = pol == l_True ? cond : logic.mkNot(cond); parentConditions.push(logic.mkAnd(parentCondition, edgeCondition)); } } PTRef pathCondition = logic.mkOr(std::move(parentConditions)); dagNodeToPTRef[el_r] = pathCondition; if (el.isLeaf()) { // A value node switches.push_m(CondValPair(pathCondition, el.getVal())); } } } return switches; } ite::Dag IteToSwitch::constructIteDag(PTRef root, const Logic &logic) { ite::Dag dag; vec queue; vec flag; flag.growTo(logic.getNumberOfTerms()); if (logic.isIte(root)) { dag.addTopLevelIte(root); } queue.push(root); while (queue.size() != 0) { PTRef tr = queue.last(); const Pterm &t = logic.getPterm(tr); auto index = Idx(t.getId()); if (flag[index] == ite::type::black) { queue.pop(); continue; } flag[index] = type::gray; bool unprocessed_children = false; for (int i = 0; i < t.size(); i++) { auto childIndex = Idx(logic.getPterm(t[i]).getId()); if (flag[childIndex] == type::white) { queue.push(t[i]); unprocessed_children = true; } } if (unprocessed_children) { continue; } flag[index] = type::black; queue.pop(); if (logic.isIte(tr)) { dag.addItePTRef(tr); const Pterm &ite = logic.getPterm(tr); PTRef cond_tr = ite[0]; PTRef true_tr = ite[1]; PTRef false_tr = ite[2]; { ite::NodeRef true_node = dag.getNodeOrCreateLeafNode(true_tr); ite::NodeRef false_node = dag.getNodeOrCreateLeafNode(false_tr); assert(logic.hasSortBool(cond_tr)); dag.createAndStoreNode(tr, cond_tr, true_node, false_node); } if (logic.isIte(cond_tr) and !dag.isTopLevelIte(cond_tr)) { dag.addTopLevelIte(cond_tr); // The (boolean) ites at condition are always top-level } } else { // not Ite for (int i = 0; i < t.size(); i++) { if (logic.isIte(t[i]) and !dag.isTopLevelIte(t[i])) { // Term t[i] is an ite which appears as a child of a non-ite. // We store this term for an expansion into a switch. dag.addTopLevelIte(t[i]); } } } } return dag; } void IteToSwitch::constructSwitches() { const vec & ites = iteDag.getTopLevelItes(); for (auto tl_ite : ites) { PTRef switch_tr = makeSwitch(tl_ite); switches.push(switch_tr); } } PTRef IteToSwitch::makeSwitch(PTRef root) { ite::Dag dag = iteDag.getReachableSubGraph(logic, root); dag.annotateWithParentInfo(root); vec root_switches = dag.getCondValPairs(logic); vec cases; for (auto condVal : root_switches) { cases.push(logic.mkImpl(condVal.cond, logic.mkEq(root, condVal.val))); } return logic.mkAnd(std::move(cases)); } PTRef IteToSwitch::conjoin(PTRef root) { return switches.size() == 0 ? root : logic.mkAnd(root, logic.mkAnd(switches)); }; opensmt-2.5.2/src/itehandler/IteToSwitch.h000066400000000000000000000151601445011647600205050ustar00rootroot00000000000000// // Created by prova on 04.08.20. // #ifndef OPENSMT_ITETOSWITCH_H #define OPENSMT_ITETOSWITCH_H #include "Logic.h" #include #include #include namespace ite { class timer { time_t start; const std::string name; public: explicit timer(std::string&& name) : start(time(nullptr)), name(name) {} ~timer() { std::cout << name << ": " << time(nullptr) - start << std::endl; } }; struct NodeRef { uint32_t x; inline friend bool operator== (NodeRef a1, NodeRef a2) { return a1.x == a2.x; } inline friend bool operator!= (NodeRef a1, NodeRef a2) { return a1.x != a2.x; } inline friend bool operator< (NodeRef a1, NodeRef a2) { return a1.x < a2.x; } }; static struct NodeRef NodeRef_Undef = {UINT32_MAX}; class Node { friend class NodeAllocator; struct Tail { NodeRef true_child; NodeRef false_child; PTRef cond; }; enum class NodeType { leaf = 0, inner = 1 }; uint32_t id : 30; bool type : 1; PTRef term; Tail tail[0]; void setCond(PTRef cond) { assert(!isLeaf()); tail[0].cond = cond; } void setTrueChild(NodeRef n) { assert(!isLeaf()); tail[0].true_child = n; } void setFalseChild(NodeRef n) { assert(!isLeaf()); tail[0].false_child = n; } public: Node(PTRef term, PTRef cond, NodeRef true_node, NodeRef false_node, uint32_t id); Node() = delete; bool isLeaf() const { return NodeType(type) == NodeType::leaf; } PTRef getCond() const { assert(!isLeaf()); return tail[0].cond; } PTRef getVal() const { assert(isLeaf()); return term; } NodeRef getTrueChild() const { return isLeaf() ? NodeRef_Undef : tail[0].true_child; } NodeRef getFalseChild() const { return isLeaf() ? NodeRef_Undef : tail[0].false_child; } int getId() const { return id; } PTRef getTerm() const { return term; } }; class NodeAllocator : public RegionAllocator { unsigned n_nodes; static unsigned iteNodeWord32Size(bool internalNode) { return (sizeof(Node) + (internalNode ? sizeof(Node::Tail) : 0)) / sizeof(uint32_t); } public: void clear() override { n_nodes = 0; RegionAllocator::clear(); } NodeAllocator() : RegionAllocator(1024), n_nodes(0) {} unsigned getNumNodes() const { return n_nodes; } NodeRef alloc(PTRef term, PTRef cond, NodeRef trueChild, NodeRef falseChild) { assert((cond == PTRef_Undef) == (trueChild == NodeRef_Undef and falseChild == NodeRef_Undef)); assert((trueChild == NodeRef_Undef) == (falseChild == NodeRef_Undef)); uint32_t v = RegionAllocator::alloc(static_cast(iteNodeWord32Size(cond != PTRef_Undef))); NodeRef id = {v}; new (lea(id)) Node(term, cond, trueChild, falseChild, n_nodes); n_nodes++; return id; } Node &operator[](NodeRef r) { return (Node&)RegionAllocator::operator[](r.x); } const Node &operator[](NodeRef r) const { return (Node&)RegionAllocator::operator[](r.x); } Node* lea (NodeRef r) { return (Node*)RegionAllocator::lea(r.x); } const Node *lea (NodeRef r) const { return (Node*)RegionAllocator::lea(r.x); } NodeRef ael (const Node *t) { auto r = RegionAllocator::ael((uint32_t*)t); return {r}; } void free (NodeRef) {} }; enum class type : char { white, gray, black }; class CondValPair { public: PTRef cond; PTRef val; CondValPair(PTRef cond, PTRef val) : cond(cond), val(val) {} CondValPair() : cond(PTRef_Undef), val(PTRef_Undef) {} }; class Dag { struct NodeRefLBool { NodeRef nr; lbool sign; NodeRefLBool() : nr(NodeRef_Undef), sign(l_Undef) {} NodeRefLBool(NodeRef nr, lbool sign): nr(nr), sign(sign) {}; bool operator<(const NodeRefLBool& o) const { return (this->nr < o.nr) or (this->nr == o.nr and toInt(this->sign) < toInt(o.sign)); } }; NodeAllocator na; Map nodes; Map itePTRefs; vec nodeRefs; MapWithKeys top_level_ites; std::set leaves; NodeRef newNode(PTRef tr); NodeRef newNode(PTRef tr, PTRef cond, NodeRef true_node, NodeRef false_node); using ParentSet = std::set; NodeRef getNode(PTRef tr) { assert(nodes.has(tr)); return nodes[tr]; } const vec& getNodes() const { return nodeRefs; } std::map parents; void clear() { for (auto node : nodeRefs) { na.free(node); } nodes.clear(); nodeRefs.clear(); } public: Dag(Dag &&dag) = default; Dag() = default; ~Dag() { clear(); } NodeRef getNodeOrCreateLeafNode(PTRef tr) { return nodes.has(tr) ? nodes[tr] : newNode(tr); } void createAndStoreNode(PTRef tr, PTRef cond, NodeRef true_node, NodeRef false_node) { assert(not nodes.has(tr)); newNode(tr, cond, true_node, false_node); } void addItePTRef(PTRef tr) { itePTRefs.insert(tr, true); } bool isTopLevelIte(PTRef tr) const { return top_level_ites.has(tr) and top_level_ites[tr]; } void addTopLevelIte(PTRef tr) { top_level_ites.insert(tr, true); } const vec & getTopLevelItes() const { return top_level_ites.getKeys(); } Dag getReachableSubGraph(const Logic& logic, PTRef root); void annotateWithParentInfo(PTRef root); vec getCondValPairs(Logic& logic) const; // Debug void writeDagToStream(std::ostream&) const; }; } class IteToSwitch { protected: using type = ite::type; Logic &logic; ite::Dag iteDag; vec switches; PTRef makeSwitch(PTRef root); static ite::Dag constructIteDag(PTRef root, const Logic& l); // Construct the IteDag that define values for the Ite-terms void constructSwitches(); public: explicit IteToSwitch(Logic& l, PTRef root) : logic(l), iteDag(constructIteDag(root, l)) { constructSwitches(); } PTRef conjoin(PTRef root); static void printDagToFile(const std::string &fname, const ite::Dag&); void printDagToFile(const std::string &fname) const { printDagToFile(fname, iteDag); }; }; #endif //OPENSMT_ITETOSWITCH_H opensmt-2.5.2/src/itehandler/IteToSwitchMisc.cc000066400000000000000000000022351445011647600214560ustar00rootroot00000000000000// // Created by prova on 02.09.20. // #include "IteToSwitch.h" #include void IteToSwitch::printDagToFile(const std::string &fname, const ite::Dag &dag) { std::fstream fs; fs.open(fname, std::fstream::out); dag.writeDagToStream(fs); fs.close(); } void ite::Dag::writeDagToStream(std::ostream &out) const { std::string annotations_str; std::string edges_str; auto &nodes = getNodes(); std::cout << "Starting production of a graph" << std::endl; for (const ite::NodeRef node : nodes) { if (isTopLevelIte(na[node].getTerm())) { annotations_str += " " + std::to_string(na[node].getId()) + " [shape=box];\n"; } if (na[node].getTrueChild() != NodeRef_Undef) { edges_str += " " + std::to_string(na[node].getId()) + " -> " + std::to_string(na[na[node].getTrueChild()].getId()) + ";\n"; } if (na[node].getFalseChild() != NodeRef_Undef) { edges_str += " " + std::to_string(na[node].getId()) + " -> " + std::to_string(na[na[node].getFalseChild()].getId()) + ";\n"; } } out << "digraph G {" << annotations_str << "\n" << edges_str << "}" << std::endl; }opensmt-2.5.2/src/logics/000077500000000000000000000000001445011647600152645ustar00rootroot00000000000000opensmt-2.5.2/src/logics/ArithLogic.cc000066400000000000000000001516051445011647600176300ustar00rootroot00000000000000#include "ArithLogic.h" #include "DivModRewriter.h" #include "FastRational.h" #include "OsmtApiException.h" #include "OsmtInternalException.h" #include "Polynomial.h" #include "PtStore.h" #include "SStore.h" #include "StringConv.h" #include "TreeOps.h" #include #include #include #include const std::string ArithLogic::e_nonlinear_term = "Logic does not support nonlinear terms"; /*********************************************************** * Class defining simplifications ***********************************************************/ namespace{ class SimplifyConst { protected: ArithLogic& l; virtual void Op(opensmt::Number& s, const opensmt::Number& v) const = 0; virtual opensmt::Number getIdOp() const = 0; virtual void constSimplify(SymRef s, vec const & terms, SymRef & s_new, vec & terms_new) const = 0; public: SimplifyConst(ArithLogic& log) : l(log) {} void simplify(SymRef s, vec const & terms, SymRef & s_new, vec & terms_new); PTRef simplifyConstOp(const vec & const_terms); }; class SimplifyConstSum : public SimplifyConst { void Op(opensmt::Number& s, const opensmt::Number& v) const { s += v; } opensmt::Number getIdOp() const { return 0; } void constSimplify(SymRef s, vec const & terms, SymRef & s_new, vec & terms_new) const; public: SimplifyConstSum(ArithLogic& log) : SimplifyConst(log) {} }; class SimplifyConstTimes : public SimplifyConst { void Op(opensmt::Number& s, const opensmt::Number& v) const { s *= v; } opensmt::Number getIdOp() const { return 1; } void constSimplify(SymRef s, vec const & terms, SymRef & s_new, vec & terms_new) const; public: SimplifyConstTimes(ArithLogic& log) : SimplifyConst(log) {} }; class SimplifyConstDiv : public SimplifyConst { void Op(opensmt::Number& s, const opensmt::Number& v) const { if (v == 0) { printf("explicit div by zero\n"); } s /= v; } opensmt::Number getIdOp() const { return 1; } void constSimplify(SymRef s, vec const & terms, SymRef & s_new, vec & terms_new) const; public: SimplifyConstDiv(ArithLogic& log) : SimplifyConst(log) {} }; } const std::string ArithLogic::tk_int_zero = "0"; const std::string ArithLogic::tk_int_one = "1"; const std::string ArithLogic::tk_int_neg = "-"; const std::string ArithLogic::tk_int_minus = "-"; const std::string ArithLogic::tk_int_plus = "+"; const std::string ArithLogic::tk_int_times = "*"; const std::string ArithLogic::tk_int_div = "div"; const std::string ArithLogic::tk_int_mod = "mod"; const std::string ArithLogic::tk_int_lt = "<"; const std::string ArithLogic::tk_int_leq = "<="; const std::string ArithLogic::tk_int_gt = ">"; const std::string ArithLogic::tk_int_geq = ">="; const std::string ArithLogic::s_sort_int = "Int"; const std::string ArithLogic::tk_real_zero = "0.0"; const std::string ArithLogic::tk_real_one = "1.0"; const std::string ArithLogic::tk_real_neg = "-"; const std::string ArithLogic::tk_real_minus = "-"; const std::string ArithLogic::tk_real_plus = "+"; const std::string ArithLogic::tk_real_times = "*"; const std::string ArithLogic::tk_real_div = "/"; const std::string ArithLogic::tk_real_lt = "<"; const std::string ArithLogic::tk_real_leq = "<="; const std::string ArithLogic::tk_real_gt = ">"; const std::string ArithLogic::tk_real_geq = ">="; const std::string ArithLogic::s_sort_real = "Real"; const std::string ArithLogic::tk_val_int_default = "0"; const std::string ArithLogic::tk_val_real_default = "0.0"; ArithLogic::ArithLogic(opensmt::Logic_t type) : Logic(type) , sort_REAL(getSort(sort_store.newSortSymbol(SortSymbol(s_sort_real, 0, SortSymbol::INTERNAL)), {})) , term_Real_ZERO(mkConst(sort_REAL, tk_real_zero.c_str())) , term_Real_ONE(mkConst(sort_REAL, tk_real_one.c_str())) , term_Real_MINUSONE(mkConst(sort_REAL, tk_real_minus + tk_real_one)) , sym_Real_ZERO(getSymRef(term_Real_ZERO)) , sym_Real_ONE(getSymRef(term_Real_ONE)) , sym_Real_NEG(declareFun_NoScoping(tk_real_neg, sort_REAL, {sort_REAL})) , sym_Real_MINUS(declareFun_NoScoping_LeftAssoc(tk_real_minus, sort_REAL, {sort_REAL, sort_REAL})) , sym_Real_PLUS(declareFun_Commutative_NoScoping_LeftAssoc(tk_real_plus, sort_REAL, {sort_REAL, sort_REAL})) , sym_Real_TIMES(declareFun_Commutative_NoScoping_LeftAssoc(tk_real_times, sort_REAL, {sort_REAL, sort_REAL})) , sym_Real_DIV(declareFun_NoScoping_LeftAssoc(tk_real_div, sort_REAL, {sort_REAL, sort_REAL})) , sym_Real_EQ(sortToEquality[sort_REAL]) , sym_Real_LEQ(declareFun_NoScoping_Chainable(tk_real_leq, sort_BOOL, {sort_REAL, sort_REAL})) , sym_Real_LT(declareFun_NoScoping_Chainable(tk_real_lt, sort_BOOL, {sort_REAL, sort_REAL})) , sym_Real_GEQ(declareFun_NoScoping_Chainable(tk_real_geq, sort_BOOL, {sort_REAL, sort_REAL})) , sym_Real_GT(declareFun_NoScoping_Chainable(tk_real_gt, sort_BOOL, {sort_REAL, sort_REAL})) , sym_Real_ITE(sortToIte[sort_REAL]) , sym_Real_DISTINCT(sortToDisequality[sort_REAL]) , sort_INT(getSort(sort_store.newSortSymbol(SortSymbol(s_sort_int, 0, SortSymbol::INTERNAL)), {})) , term_Int_ZERO(mkConst(sort_INT, tk_int_zero)) , term_Int_ONE(mkConst(sort_INT, tk_int_one.c_str())) , term_Int_MINUSONE(mkConst(sort_INT, tk_int_minus + tk_int_one)) , sym_Int_ZERO(getSymRef(term_Int_ZERO)) , sym_Int_ONE(getSymRef(term_Int_ONE)) , sym_Int_NEG(declareFun_NoScoping(tk_int_neg, sort_INT, {sort_INT})) , sym_Int_MINUS(declareFun_NoScoping_LeftAssoc(tk_int_minus, sort_INT, {sort_INT, sort_INT})) , sym_Int_PLUS(declareFun_Commutative_NoScoping_LeftAssoc(tk_int_plus, sort_INT, {sort_INT, sort_INT})) , sym_Int_TIMES(declareFun_Commutative_NoScoping_LeftAssoc(tk_int_times, sort_INT, {sort_INT, sort_INT})) , sym_Int_DIV(declareFun_NoScoping_LeftAssoc(tk_int_div, sort_INT, {sort_INT, sort_INT})) , sym_Int_MOD(declareFun_NoScoping(tk_int_mod, sort_INT, {sort_INT, sort_INT})) , sym_Int_EQ(sortToEquality[sort_INT]) , sym_Int_LEQ(declareFun_NoScoping_Chainable(tk_int_leq, sort_BOOL, {sort_INT, sort_INT})) , sym_Int_LT(declareFun_NoScoping_Chainable(tk_int_lt, sort_BOOL, {sort_INT, sort_INT})) , sym_Int_GEQ(declareFun_NoScoping_Chainable(tk_int_geq, sort_BOOL, {sort_INT, sort_INT})) , sym_Int_GT(declareFun_NoScoping_Chainable(tk_int_gt, sort_BOOL, {sort_INT, sort_INT})) , sym_Int_ITE(sortToIte[sort_INT]) , sym_Int_DISTINCT(sortToDisequality[sort_INT]) { } SymRef ArithLogic::getPlusForSort(SRef sort) const { assert (sort == getSort_int() or sort == getSort_real()); return sort == getSort_int() ? get_sym_Int_PLUS() : get_sym_Real_PLUS(); } SymRef ArithLogic::getTimesForSort(SRef sort) const { assert (sort == getSort_int() or sort == getSort_real()); return sort == getSort_int() ? get_sym_Int_TIMES() : get_sym_Real_TIMES(); } SymRef ArithLogic::getMinusForSort(SRef sort) const { assert (sort == getSort_int() or sort == getSort_real()); return sort == getSort_int() ? get_sym_Int_MINUS() : get_sym_Real_MINUS(); }; PTRef ArithLogic::getZeroForSort(SRef sort) const { assert (sort == getSort_int() or sort == getSort_real()); return sort == getSort_int() ? getTerm_IntZero() : getTerm_RealZero(); } PTRef ArithLogic::getOneForSort(SRef sort) const { assert (sort == getSort_int() or sort == getSort_real()); return sort == getSort_int() ? getTerm_IntOne() : getTerm_RealOne(); } PTRef ArithLogic::getMinusOneForSort(SRef sort) const { assert (sort == getSort_int() or sort == getSort_real()); return sort == getSort_int() ? getTerm_IntMinusOne() : getTerm_RealMinusOne(); } bool ArithLogic::isLinearFactor(PTRef tr) const { if (isNumConst(tr) || isNumVarLike(tr)) { return true; } if (isTimes(tr)) { Pterm const& term = getPterm(tr); return term.size() == 2 && ((isNumConst(term[0]) && (isNumVarLike(term[1]))) || (isNumConst(term[1]) && (isNumVarLike(term[0])))); } return false; } bool ArithLogic::isLinearTerm(PTRef tr) const { if (isLinearFactor(tr)) { return true; } if (isPlus(tr)) { Pterm const& term = getPterm(tr); return std::all_of(term.begin(), term.end(), [this](PTRef tr) { return isLinearFactor(tr); }); } return false; } const FastRational& ArithLogic::getNumConst(PTRef tr) const { SymId id = sym_store[getPterm(tr).symb()].getId(); assert(id < static_cast(numbers.size()) && numbers[id] != nullptr); return *numbers[id]; } opensmt::pair> ArithLogic::getConstantAndFactors(PTRef sum) const { assert(isPlus(sum)); vec varFactors; PTRef constant = PTRef_Undef; Pterm const & s = getPterm(sum); for (PTRef arg : s) { if (isConstant(arg)) { assert(constant == PTRef_Undef); constant = arg; } else { assert(isLinearFactor(arg)); varFactors.push(arg); } } if (constant == PTRef_Undef) { constant = isIntPlus(sum) ? getTerm_IntZero() : getTerm_RealZero(); } auto constantValue = getNumConst(constant); assert(varFactors.size() > 0); termSort(varFactors); return {std::move(constantValue), std::move(varFactors)}; } opensmt::pair ArithLogic::splitTermToVarAndConst(PTRef term) const { assert(isTimes(term) || isNumVarLike(term) || isConstant(term)); if (isTimes(term)) { assert(getPterm(term).size() == 2); PTRef fac = getPterm(term)[0]; PTRef var = getPterm(term)[1]; if (not isConstant(fac)) { std::swap(fac, var); } assert(isConstant(fac)); assert(isNumVarLike(var)); return {var, fac}; } else if (isNumVarLike(term)) { assert(yieldsSortInt(term) or yieldsSortReal(term)); PTRef var = term; PTRef fac = yieldsSortInt(term) ? getTerm_IntOne() : getTerm_RealOne(); return {var, fac}; } else { assert(isConstant(term)); return {PTRef_Undef, term}; } } // Normalize a product of the form (* a v) to either v or (* -1 v) PTRef ArithLogic::normalizeMul(PTRef mul) { assert(isTimes(mul)); auto [v,c] = splitTermToVarAndConst(mul); if (getNumConst(c) < 0) { return mkNeg(v); } else { return v; } } namespace{ using poly_t = PolynomialT; void eraseIndices(std::vector & elements, std::vector const & indices) { assert(std::is_sorted(indices.begin(), indices.end())); for (auto rit = indices.rbegin(); rit != indices.rend(); ++rit) { elements[*rit] = std::move(elements.back()); elements.pop_back(); } } Logic::SubstMap collectConstantSubstitutions(ArithLogic & logic, std::vector & zeroPolynomials) { Logic::SubstMap substitutions; while (true) { vec new_keys; std::vector processedIndices; std::unordered_map, PTRefHash> varToPolyIndices; for (std::size_t i = 0; i < zeroPolynomials.size(); ++i) { auto const & poly = zeroPolynomials[i]; if (poly.size() == 0) { // Could happen after first iteration; can safely ignore processedIndices.push_back(i); continue; } for (auto const & term : poly) { varToPolyIndices[term.var].push_back(i); } if (poly.size() == 1) { auto const & term = *poly.begin(); if (term.var == PTRef_Undef) { // FALSE equality continue; } // poly is "x = 0" PTRef var = term.var; if (not substitutions.has(var)) { substitutions.insert(var, logic.getZeroForSort(logic.getSortRef(var))); new_keys.push(var); } processedIndices.push_back(i); varToPolyIndices.at(var).pop_back(); continue; } assert(poly.begin()->var != PTRef_Undef); if (poly.size() == 2 and (poly.begin() + 1)->var == PTRef_Undef) { // poly is "a*x + c = 0" for c != 0 auto const & [var, coeff] = *poly.begin(); if (not substitutions.has(var)) { auto val = -((poly.begin() + 1)->coeff) / coeff; substitutions.insert(var, logic.mkConst(logic.getSortRef(var), val)); new_keys.push(var); } processedIndices.push_back(i); varToPolyIndices.at(var).pop_back(); continue; // Unnecessary, but clearer this way } } // Apply found substitutions bool changed = false; for (PTRef var : new_keys) { for (std::size_t index : varToPolyIndices.at(var)) { auto & poly = zeroPolynomials[index]; auto coeff = poly.removeVar(var); auto val = substitutions[var]; if (not logic.isZero(val)) { poly_t constantPoly; constantPoly.addTerm(PTRef_Undef, coeff * logic.getNumConst(val)); poly.merge(constantPoly, 1); } changed = true; } } // remove used polynomials eraseIndices(zeroPolynomials, processedIndices); if (not changed) { break; } } return substitutions; } PTRef polyToPTRef(ArithLogic & logic, poly_t const & poly) { vec args; args.capacity(poly.size()); assert(poly.size() > 0); assert(poly.begin()->var != PTRef_Undef); SRef sortRef = logic.getSortRef(poly.begin()->var); for (auto const & term : poly) { assert(not term.coeff.isZero()); if (term.var == PTRef_Undef) { args.push(logic.mkConst(sortRef, term.coeff)); } else if (term.coeff.isOne()) { args.push(term.var); } else { args.push(logic.mkTimes(term.var, logic.mkConst(logic.getSortRef(term.var), term.coeff))); } } return logic.mkPlus(std::move(args)); // TODO: Can we use non-simplifying versions of mkPlus/mkTimes? } Logic::SubstMap collectSingleEqualitySubstitutions(ArithLogic & logic, std::vector & zeroPolynomials) { // MB: We enforce order to ensure that later-created terms are processed first. // This ensures that from an equality "f(x) = x" we get a substitution "f(x) -> x" and not the other way // around, which would cause infinite cycle in transitive closure std::map, std::greater> varToPolyIndices; Logic::SubstMap substitutions; for (std::size_t i = 0; i < zeroPolynomials.size(); ++i) { auto const & poly = zeroPolynomials[i]; for (auto const & term : poly) { varToPolyIndices[term.var].push_back(i); } } std::unordered_set processedIndices; for (auto const & [var, polyIndices] : varToPolyIndices) { if (polyIndices.size() != 1 or var == PTRef_Undef) { continue; } auto index = polyIndices[0]; if (processedIndices.find(index) != processedIndices.end()) { continue; } auto & poly = zeroPolynomials[index]; if ((logic.hasUFs() or logic.hasArrays()) and logic.isVar(var)) { if (std::any_of(poly.begin(), poly.end(), [&logic](auto const & term) { return term.var != PTRef_Undef and not logic.isVar(term.var); })) { continue; } } auto coeff = poly.removeVar(var); coeff.negate(); if (not coeff.isOne()) { poly.divideBy(coeff); } PTRef val = polyToPTRef(logic, poly); substitutions.insert(var, val); processedIndices.insert(index); } // Remove processed polynomials std::vector indicesToRemove(processedIndices.begin(), processedIndices.end()); std::sort(indicesToRemove.begin(), indicesToRemove.end()); eraseIndices(zeroPolynomials, indicesToRemove); return substitutions; } } lbool ArithLogic::arithmeticElimination(const vec & top_level_arith, SubstMap & out_substitutions) { ArithLogic & logic = *this; auto toPoly = [&logic](PTRef eq) { assert(logic.isEquality(eq)); poly_t poly; PTRef lhs = logic.getPterm(eq)[0]; PTRef rhs = logic.getPterm(eq)[1]; PTRef polyTerm = lhs == logic.getZeroForSort(logic.getSortRef(lhs)) ? rhs : logic.mkMinus(rhs, lhs); assert(logic.isLinearTerm(polyTerm)); if (logic.isLinearFactor(polyTerm)) { auto [var,c] = logic.splitTermToVarAndConst(polyTerm); auto coeff = logic.getNumConst(c); poly.addTerm(var, std::move(coeff)); } else { assert(logic.isPlus(polyTerm)); for (PTRef factor : logic.getPterm(polyTerm)) { auto [var,c] = logic.splitTermToVarAndConst(factor); auto coeff = logic.getNumConst(c); poly.addTerm(var, std::move(coeff)); } } return poly; }; std::vector polynomials; polynomials.reserve(top_level_arith.size_()); std::transform(top_level_arith.begin(), top_level_arith.end(), std::back_inserter(polynomials), toPoly); auto constSubstitutions = collectConstantSubstitutions(logic, polynomials); for (PTRef key : constSubstitutions.getKeys()) { assert(not out_substitutions.has(key)); out_substitutions.insert(key, constSubstitutions[key]); } auto singleEqSubstitutions = collectSingleEqualitySubstitutions(logic, polynomials); for (PTRef key : singleEqSubstitutions.getKeys()) { assert(not out_substitutions.has(key)); out_substitutions.insert(key, singleEqSubstitutions[key]); } for (auto & poly : polynomials) { // solve polynomial with respect to its first variable assert(poly.size() > 0); PTRef var = poly.begin()->var; if (var == PTRef_Undef) { // 'c = 0' for some constant c; let the main loop deal with this continue; } if (out_substitutions.has(var)) { // Already have a substitution for this variable; skip this equality, let the main loop deal with this continue; } if ((logic.hasUFs() or logic.hasArrays()) and logic.isVar(var)) { if (std::any_of(poly.begin(), poly.end(), [&logic](auto const & term) { return term.var != PTRef_Undef and not logic.isVar(term.var); })) { continue; } } auto coeff = poly.removeVar(var); coeff.negate(); if (not coeff.isOne()) { poly.divideBy(coeff); } PTRef val = polyToPTRef(logic, poly); assert(not out_substitutions.has(var)); out_substitutions.insert(var, val); } // To simplify this method, we do not try to detect a conflict here, so result is always l_Undef return l_Undef; } opensmt::pair ArithLogic::retrieveSubstitutions(const vec& facts) { auto resAndSubsts = Logic::retrieveSubstitutions(facts); if (resAndSubsts.first != l_Undef) return resAndSubsts; vec top_level_arith; for (PtAsgn fact : facts) { PTRef tr = fact.tr; lbool sgn = fact.sgn; if (isNumEq(tr) && sgn == l_True) top_level_arith.push(tr); } lbool res = arithmeticElimination(top_level_arith, resAndSubsts.second); return {res, std::move(resAndSubsts.second)}; } uint32_t LessThan_deepPTRef::getVarIdFromProduct(PTRef tr) const { assert(l.isTimes(tr)); auto [v,c] = l.splitTermToVarAndConst(tr); return v.x; } bool LessThan_deepPTRef::operator()(PTRef x_, PTRef y_) const { uint32_t id_x = l.isTimes(x_) ? getVarIdFromProduct(x_) : x_.x; uint32_t id_y = l.isTimes(y_) ? getVarIdFromProduct(y_) : y_.x; return id_x < id_y; } void ArithLogic::termSort(vec& v) const { sort(v, LessThan_deepPTRef(*this)); } bool ArithLogic::isBuiltinFunction(const SymRef sr) const { if (sym_store[sr].isInterpreted()) return true; else return Logic::isBuiltinFunction(sr); } bool ArithLogic::isNumTerm(PTRef tr) const { if (isNumVarLike(tr)) return true; const Pterm& t = getPterm(tr); if (t.size() == 2 && isTimes(tr)) return (isNumVarLike(t[0]) && isConstant(t[1])) || (isNumVarLike(t[1]) && isConstant(t[0])); else if (t.size() == 0) return isNumVar(tr) || isConstant(tr); else return false; } PTRef ArithLogic::mkNeg(PTRef tr) { assert(!isNeg(tr)); // MB: The invariant now is that there is no "Minus" node SymRef symref = getSymRef(tr); if (isConstant(symref)) { const opensmt::Number& v = getNumConst(tr); return mkConst(getSortRef(tr), -v); } if (isPlus(symref)) { vec args; args.capacity(getPterm(tr).size()); // Note: Do this in two phases to avoid calling mkNeg that invalidates the Pterm reference for (PTRef tr_arg : getPterm(tr)) { assert(tr_arg != PTRef_Undef); args.push(tr_arg); } for (PTRef & tr_arg: args) { tr_arg = mkNeg(tr_arg); } PTRef tr_n = mkFun(symref, std::move(args)); return tr_n; } if (isTimes(symref)) { // constant * var-like assert(getPterm(tr).size() == 2); auto [var, constant] = splitTermToVarAndConst(tr); return constant == getMinusOneForSort(getSortRef(symref)) ? var : mkFun(symref, {var, mkNeg(constant)}); } if (isNumVarLike(symref)) { auto sortRef = getSortRef(symref); return mkFun(getTimesForSort(sortRef), {tr, getMinusOneForSort(sortRef)}); } // MB: All cases should be covered throw OsmtInternalException("Failed attempt to negate a term"); } PTRef ArithLogic::mkConst(SRef sort, opensmt::Number const & c) { std::string str = c.get_str(); // MB: I cannot store c.get_str().c_str() directly, since that is a pointer inside temporary object -> crash. const char * val = str.c_str(); PTRef ptr = PTRef_Undef; ptr = mkVar(sort, val, true); // Store the value of the number as a real SymId id = sym_store[getPterm(ptr).symb()].getId(); for (auto i = numbers.size(); i <= id; i++) { numbers.emplace_back(); } if (numbers[id] == nullptr) { numbers[id] = new opensmt::Number(val); } assert(c == *numbers[id]); markConstant(id); return ptr; } PTRef ArithLogic::mkMinus(vec && args) { assert(args.size() > 0); if (args.size() == 1) { return mkNeg(args[0]); } assert(args.size() == 2); if (args.size() > 2) { throw OsmtApiException("Too many terms provided to LALogic::mkNumMinus"); } PTRef fact = mkNeg(args[1]); assert(fact != PTRef_Undef); args[1] = fact; return mkPlus(std::move(args)); } PTRef ArithLogic::mkPlus(vec && args) { SRef returnSort = checkArithSortCompatible(args); SymRef plusSym = getPlusForSort(returnSort); vec flattened_args; flattened_args.capacity(args.size()); // Flatten possible internal sums. This needs not be done properly, // with a post-order dfs, since we are guaranteed that the inner // sums are already flattened. for (auto tr : args) { if (isPlus(tr)) { Pterm const & t = getPterm(tr); for (auto j : t) { flattened_args.push(j); } } else { flattened_args.push(tr); } } SimplifyConstSum simp(*this); args.clear(); SymRef s_new; simp.simplify(plusSym, flattened_args, s_new, args); if (s_new != getPlusForSort(returnSort)) { return mkFun(s_new, std::move(args)); } if (args.size() == 1) { return args[0]; } assert(args.size() != 0); // This code takes polynomials (+ (* v c1) (* v c2)) and converts them to the form (* v c3) where c3 = c1+c2 Map varIndices; struct Entry { PTRef var; std::variant coeff; }; std::vector simplified; simplified.reserve(args.size()); for (PTRef arg : args) { auto [v,c] = splitTermToVarAndConst(arg); assert(c != PTRef_Undef); assert(isConstant(c)); if (not varIndices.has(v)) { varIndices.insert(v, simplified.size()); simplified.push_back({.var = v, .coeff = c}); } else { auto index = varIndices[v]; auto & entry = simplified[index]; if (std::holds_alternative(entry.coeff)) { entry.coeff = this->getNumConst(std::get(entry.coeff)); } assert(std::holds_alternative(entry.coeff)); std::get(entry.coeff) += this->getNumConst(c); } } flattened_args.clear(); for (auto const & [var,coeff] : simplified) { PTRef coeffTerm = std::holds_alternative(coeff) ? std::get(coeff) : this->mkConst(this->getSortRef(var), std::get(coeff)); if (isZero(coeffTerm)) { continue; } if (var == PTRef_Undef) { flattened_args.push(coeffTerm); continue; } if (isOne(coeffTerm)) { flattened_args.push(var); continue; } // default case, variable and constant (cannot be simplified) PTRef term = mkFun(getTimesForSort(returnSort), {coeffTerm, var}); flattened_args.push(term); } if (flattened_args.size() == 0) return getZeroForSort(returnSort); if (flattened_args.size() == 1) return flattened_args[0]; PTRef tr = mkFun(s_new, std::move(flattened_args)); return tr; } PTRef ArithLogic::mkTimes(vec && args) { SRef returnSort = checkArithSortCompatible(args); if (args.size() == 2) { // MB: Multiplication by -1 as negation is more efficient PTRef minusOne = getMinusOneForSort(returnSort); if (minusOne == args[0]) { return mkNeg(args[1]); } else if (minusOne == args[1]) { return mkNeg(args[0]); } // else continue the usual normalization } vec flatten_args; // Flatten possible internal multiplications for (PTRef arg : args) { if (isTimes(arg)) { Pterm const & t = getPterm(arg); for (PTRef child : t) flatten_args.push(child); } else { flatten_args.push(arg); } } SimplifyConstTimes simp(*this); args.clear(); SymRef s_new; simp.simplify(getTimesForSort(returnSort), flatten_args, s_new, args); PTRef tr = mkFun(s_new, std::move(args)); // Either a real term or, if we constructed a multiplication of a // constant and a sum, a real sum. if (isNumTerm(tr) || isPlus(tr) || isUF(tr) || isIte(tr)) return tr; else { auto termStr = pp(tr); throw LANonLinearException(termStr.c_str()); } } SymRef ArithLogic::getLeqForSort(SRef sr) const { assert(sr == getSort_int() or sr == getSort_real()); return sr == getSort_int() ? get_sym_Int_LEQ() : get_sym_Real_LEQ(); } // If the call results in a leq it is guaranteed that arg[0] is a // constant, and arg[1][0] has factor 1 or -1 PTRef ArithLogic::mkBinaryLeq(PTRef lhs, PTRef rhs) { SRef argSort = checkArithSortCompatible({lhs, rhs}); if (isConstant(lhs) && isConstant(rhs)) { opensmt::Number const & v1 = this->getNumConst(lhs); opensmt::Number const & v2 = this->getNumConst(rhs); return v1 <= v2 ? getTerm_true() : getTerm_false(); } // Should be in the form that on one side there is a constant // and on the other there is a sum PTRef sum_tmp = lhs == getZeroForSort(argSort) ? rhs : rhs == getZeroForSort(argSort) ? mkNeg(lhs) : mkPlus(rhs, mkNeg(lhs)); // "sum_tmp = rhs - lhs" so the inequality is "0 <= sum_tmp" if (isConstant(sum_tmp)) { opensmt::Number const & v = this->getNumConst(sum_tmp); return v.sign() < 0 ? getTerm_false() : getTerm_true(); } if (isNumVarLike(sum_tmp) || isTimes(sum_tmp)) { // "sum_tmp = c * v", just scale to "v" or "-v" without changing the sign sum_tmp = isTimes(sum_tmp) ? normalizeMul(sum_tmp) : sum_tmp; return mkFun(getLeqForSort(argSort), {getZeroForSort(argSort), sum_tmp}); } else if (isPlus(sum_tmp)) { // Normalize the sum return sumToNormalizedInequality(sum_tmp); } assert(false); throw OsmtInternalException{"Unexpected situation in LALogic::mkNumLeq"}; } PTRef ArithLogic::mkLeq(vec const & args) { if (args.size() < 2) { throw OsmtApiException("Too few arguments passed to LALogic::mkNumLeq"); } if (args.size() == 2) { return mkBinaryLeq(args[0], args[1]); } vec binaryInequalities; binaryInequalities.capacity(args.size() - 1); for (int i = 1; i < args.size(); ++i) { binaryInequalities.push(mkBinaryLeq(args[i - 1], args[i])); } return mkAnd(std::move(binaryInequalities)); } PTRef ArithLogic::mkGeq(vec const & args) { if (args.size() < 2) { throw OsmtApiException("Too few arguments passed to LALogic::mkNumGeq"); } if (args.size() == 2) { return mkBinaryGeq(args[0], args[1]); } vec binaryInequalities; binaryInequalities.capacity(args.size() - 1); for (int i = 1; i < args.size(); ++i) { binaryInequalities.push(mkBinaryGeq(args[i - 1], args[i])); } return mkAnd(std::move(binaryInequalities)); } PTRef ArithLogic::mkLt(vec const & args) { if (args.size() < 2) { throw OsmtApiException("Too few arguments passed to LALogic::mkNumLt"); } if (args.size() == 2) { return mkBinaryLt(args[0], args[1]); } vec binaryInequalities; binaryInequalities.capacity(args.size() - 1); for (int i = 1; i < args.size(); ++i) { binaryInequalities.push(mkBinaryLt(args[i - 1], args[i])); } return mkAnd(std::move(binaryInequalities)); } PTRef ArithLogic::mkGt(vec const & args) { if (args.size() < 2) { throw OsmtApiException("Too few arguments passed to LALogic::mkNumGt"); } if (args.size() == 2) { return mkBinaryGt(args[0], args[1]); } vec binaryInequalities; binaryInequalities.capacity(args.size() - 1); for (int i = 1; i < args.size(); ++i) { binaryInequalities.push(mkBinaryGt(args[i - 1], args[i])); } return mkAnd(std::move(binaryInequalities)); } PTRef ArithLogic::mkBinaryEq(PTRef lhs, PTRef rhs) { if (getSortRef(rhs) != getSortRef(lhs)) { throw OsmtApiException("Equality over non-equal sorts"); } if (hasUFs() or hasArrays()) { return Logic::mkBinaryEq(lhs, rhs); } SRef eqSort = getSortRef(lhs); if (!isSortNum(eqSort)) { return Logic::mkBinaryEq(lhs, rhs); } if (isConstant(lhs) && isConstant(rhs)) { opensmt::Number const & v1 = this->getNumConst(lhs); opensmt::Number const & v2 = this->getNumConst(rhs); return v1 == v2 ? getTerm_true() : getTerm_false(); } // diff = rhs - lhs PTRef diff = isZero(lhs) ? rhs : isZero(rhs) ? mkNeg(lhs) : mkPlus(rhs, mkNeg(lhs)); if (isConstant(diff)) { opensmt::Number const & v = this->getNumConst(diff); return v.isZero() ? getTerm_true() : getTerm_false(); } else if (isNumVarLike(diff) || isTimes(diff)) { auto [var, constant] = splitTermToVarAndConst(diff); return Logic::mkBinaryEq(getZeroForSort(eqSort), var); // Avoid anything that calls Logic::mkEq as this would create a loop } else if (isPlus(diff)) { return sumToNormalizedEquality(diff); } else { assert(false); throw OsmtInternalException{"Unexpected situation in LALogic::mkNumLeq"}; } } PTRef ArithLogic::mkMod(vec && args) { if (args.size() != 2) { throw OsmtApiException("Modulo needs exactly two arguments"); } checkSortInt(args); PTRef dividend = args[0]; PTRef divisor = args[1]; if (not isNumConst(divisor)) { throw OsmtApiException("Divisor must be constant in linear logic"); } if (isZero(divisor)) { throw ArithDivisionByZeroException(); } if (isOne(divisor) or isMinusOne(divisor)) { return getTerm_IntZero(); } if (isConstant(dividend)) { auto const& dividendValue = getNumConst(dividend); auto const& divisorValue = getNumConst(divisor); assert(dividendValue.isInteger() and divisorValue.isInteger()); // evaluate immediately the operation on two constants auto realDiv = dividendValue / divisorValue; auto intDiv = divisorValue.sign() > 0 ? realDiv.floor() : realDiv.ceil(); auto intMod = dividendValue - intDiv * divisorValue; assert(intMod.sign() >= 0 and intMod < abs(divisorValue)); return mkIntConst(intMod); } return mkFun(sym_Int_MOD, {dividend, divisor}); } PTRef ArithLogic::mkIntDiv(vec && args) { checkSortInt(args); assert(args.size() == 2); PTRef dividend = args[0]; PTRef divisor = args[1]; if (not isConstant(divisor) and not isConstant(dividend)) { throw LANonLinearException("Divisor or dividend must be constant in linear logic"); } if (isZero(divisor)) { throw ArithDivisionByZeroException(); } if (isOne(divisor)) { return dividend; } if (isMinusOne(divisor)) { return mkNeg(dividend); } if (isConstant(divisor) and isConstant(dividend)) { auto const& dividendValue = getNumConst(dividend); auto const& divisorValue = getNumConst(divisor); assert(dividendValue.isInteger() and divisorValue.isInteger()); // evaluate immediately the operation on two constants auto realDiv = dividendValue / divisorValue; auto intDiv = divisorValue.sign() > 0 ? realDiv.floor() : realDiv.ceil(); return mkIntConst(intDiv); } return mkFun(sym_Int_DIV, std::move(args)); } PTRef ArithLogic::mkRealDiv(vec && args) { checkSortReal(args); if (args.size() != 2) { throw OsmtApiException("Division operation requires exactly 2 arguments"); } if (isZero(args[1])) { throw ArithDivisionByZeroException(); } if (not isConstant(args[1])) { throw LANonLinearException("Only division by constant is permitted in linear arithmetic!"); } SimplifyConstDiv simp(*this); vec args_new; SymRef s_new; simp.simplify(get_sym_Real_DIV(), args, s_new, args_new); if (isRealDiv(s_new)) { assert((isNumTerm(args_new[0]) || isPlus(args_new[0])) && isConstant(args_new[1])); args_new[1] = mkRealConst(FastRational_inverse(getNumConst(args_new[1]))); //mkConst(1/getRealConst(args_new[1])); return mkTimes(args_new); } PTRef tr = mkFun(s_new, std::move(args_new)); return tr; } PTRef ArithLogic::insertTerm(SymRef sym, vec&& terms) { if (isNeg(sym)) return mkNeg(terms[0]); if (isMinus(sym)) return mkMinus(std::move(terms)); if (isPlus(sym)) return mkPlus(std::move(terms)); if (isTimes(sym)) return mkTimes(std::move(terms)); if (isRealDiv(sym)) return mkRealDiv(std::move(terms)); if (isLeq(sym)) return mkLeq(terms); if (isLt(sym)) return mkLt(terms); if (isGeq(sym)) return mkGeq(terms); if (isGt(sym)) return mkGt(terms); if (isMod(sym)) return mkMod(std::move(terms)); if (isIntDiv(sym)) return mkIntDiv(std::move(terms)); return Logic::insertTerm(sym, std::move(terms)); } PTRef ArithLogic::mkConst(SRef s, const char* name) { assert(strlen(name) != 0); PTRef ptr = PTRef_Undef; if (s == sort_REAL or s == sort_INT) { char* rat; if (s == sort_REAL) opensmt::stringToRational(rat, name); else { if (not opensmt::isIntString(name)) throw OsmtApiException("Not parseable as an integer"); rat = strdup(name); } ptr = mkVar(s, rat, true); // Store the value of the number as a real SymId id = sym_store[getPterm(ptr).symb()].getId(); for (auto i = numbers.size(); i <= id; i++) numbers.emplace_back(nullptr); if (numbers[id] != nullptr) { delete numbers[id]; } numbers[id] = new FastRational(rat); free(rat); markConstant(id); } else ptr = Logic::mkConst(s, name); return ptr; } /** * SMT-LIB style resolution of numeric constants. * @param name string representation of the constant * @return a PTRef of the correct sort representing the constant. */ PTRef ArithLogic::mkConst(char const * name) { bool isIntegralForm = opensmt::isIntString(name); bool isRealForm = opensmt::isRealString(name); if (hasIntegers() and not hasReals()) { if (not isIntegralForm and isRealForm) { throw OsmtApiException("Expected integral constant"); } else if (isIntegralForm) { return mkConst(sort_INT, name); } } else if (hasReals() and not hasIntegers()) { if (isRealForm) { return mkConst(sort_REAL, name); } else { assert(not isRealForm); throw OsmtApiException("Expected real constant"); } } else { assert(hasReals() and hasIntegers()); // Logic has mixed arithmetic if (isIntegralForm) { return mkConst(sort_INT, name); } else if (isRealForm) { return mkConst(sort_REAL, name); } } // Not a numeric constant, so let Logic decide. assert(not isRealForm and not isIntegralForm); return Logic::mkConst(name); } /*********************************************************** * Class defining simplifications ***********************************************************/ // // Identify all constants, and combine them into one using the operator // rules. If the constant is special for that operator, do the // corresponding simplifications. Examples include 0 with // multiplication and summation, e.g. // void SimplifyConst::simplify(SymRef s, vec const & args, SymRef & s_new, vec & args_new) { vec const_idx; for (int i = 0; i < args.size(); i++) { assert(!l.isNeg(args[i])); // MB: No minus nodes, the check can be simplified if (l.isConstant(args[i])) { assert(not l.isIte(args[i])); const_idx.push(i); } } if (const_idx.size() == 0) { s_new = s; args.copyTo(args_new); } else { if (const_idx.size() > 1) { vec const_terms; for (int i = 0; i < const_idx.size(); i++) const_terms.push(args[const_idx[i]]); PTRef tr = simplifyConstOp(const_terms); assert(tr != PTRef_Undef); vec args_new_2; args_new_2.capacity((args.size() - const_terms.size()) + 1); int i, k; for (i = k = 0; k < const_terms.size(); i++) { if (i != const_idx[k]) { args_new_2.push(args[i]); } else { k++; } } // Copy also the rest for (; i < args.size(); i++) { args_new_2.push(args[i]); } args_new_2.push(tr); constSimplify(s, args_new_2, s_new, args_new); } else { constSimplify(s, args, s_new, args_new); } } // // A single argument for the operator, and the operator is identity // // in that case if (args_new.size() == 1 && (l.isPlus(s_new) || l.isTimes(s_new) )) { PTRef ch_tr = args_new[0]; args_new.clear(); s_new = l.getPterm(ch_tr).symb(); for (int i = 0; i < l.getPterm(ch_tr).size(); i++) args_new.push(l.getPterm(ch_tr)[i]); } } void SimplifyConstSum::constSimplify(SymRef s, vec const & terms, SymRef & s_new, vec & terms_new) const { assert(terms_new.size() == 0); for (auto tr : terms) if (not l.isZero(tr)) terms_new.push(tr); if (terms_new.size() == 0) { // The term was sum of all zeroes terms_new.clear(); s_new = l.getPterm(l.getZeroForSort(l.getSortRef(s))).symb(); return; } s_new = s; } void SimplifyConstTimes::constSimplify(SymRef s, vec const & terms, SymRef & s_new, vec & terms_new) const { PTRef con, plus; con = plus = PTRef_Undef; for (auto tr : terms) { if (l.isZero(tr)) { terms_new.clear(); s_new = l.getPterm(l.getZeroForSort(l.getSortRef(s))).symb(); return; } if ( not l.isOne(tr)) { if (l.isPlus(tr)) { plus = tr; } else if (l.isConstant(tr)) { con = tr; } else { terms_new.push(tr); } } } if (con == PTRef_Undef and plus == PTRef_Undef); else if (con == PTRef_Undef and plus != PTRef_Undef) terms_new.push(plus); else if (con != PTRef_Undef and plus == PTRef_Undef) terms_new.push(con); else { assert(con != PTRef_Undef && plus != PTRef_Undef); //distribute the constant over the sum vec sum_args; int termSize = l.getPterm(plus).size(); for (int i = 0; i < termSize; ++i) { // MB: we cannot use Pterm& here, because in the line after next new term might be allocated, which might // trigger reallocation of the table of terms PTRef arg = l.getPterm(plus)[i]; sum_args.push(l.mkTimes(con, arg)); } terms_new.push(l.mkPlus(std::move(sum_args))); } if (terms_new.size() == 0) { // The term was multiplication of all ones terms_new.clear(); s_new = l.getPterm(l.getOneForSort(l.getSortRef(s))).symb(); return; } s_new = s; } void SimplifyConstDiv::constSimplify(SymRef s, vec const & terms, SymRef & s_new, vec & terms_new) const { assert(terms_new.size() == 0); assert(terms.size() <= 2); if (terms.size() == 2 && l.isZero(terms[1])) { printf("Explicit div by zero\n"); assert(false); } if (terms.size() == 1 or l.isOne(terms[terms.size()-1])) { terms_new.clear(); s_new = l.getPterm(terms[0]).symb(); for (int i = 0; i < l.getPterm(terms[0]).size(); i++) terms_new.push(l.getPterm(terms[0])[i]); return; } else if (l.isZero(terms[0])) { terms_new.clear(); s_new = l.getPterm(terms[0]).symb(); return; } for (int i = 0; i < terms.size(); i++) terms_new.push(terms[i]); s_new = s; } // Returns a term corresponding to the operation applied to the constant terms. PTRef SimplifyConst::simplifyConstOp(vec const & terms) { assert(terms.size() != 0); if (terms.size() == 1) { return terms[0]; } else { opensmt::Number s = l.getNumConst(terms[0]); for (int i = 1; i < terms.size(); ++i) { assert(l.isConstant((terms[i]))); opensmt::Number const & val = l.getNumConst(terms[i]); Op(s, val); } return l.mkConst(l.getSortRef(terms[0]), s); } } const char* ArithLogic::getDefaultValue(const PTRef tr) const { if (getSortRef(tr) == sort_INT) return tk_val_int_default.data(); else if (getSortRef(tr) == sort_REAL) return tk_val_real_default.data(); else return Logic::getDefaultValue(tr); } PTRef ArithLogic::getDefaultValuePTRef(const SRef sref) const { if (isSortNum(sref)) return getZeroForSort(sref); else return Logic::getDefaultValuePTRef(sref); } PTRef ArithLogic::removeAuxVars(PTRef tr) { // Note: Since ites are removed first and div/mod's then, it is important to first reintroduce div/mod's and then ites class AuxSymbolMatcherConfig : public DefaultRewriterConfig { ArithLogic & logic; public: AuxSymbolMatcherConfig(ArithLogic & logic) : logic(logic) {} PTRef rewrite(PTRef tr) override { if (not logic.isVar(tr)) return tr; // Only variables can match auto symName = std::string_view(logic.getSymName(tr)); if (symName.compare(0, DivModConfig::divPrefix.size(), DivModConfig::divPrefix) == 0) { return DivModConfig::getDivTermFor(logic, tr); } else if (symName.compare(0, DivModConfig::divPrefix.size(), DivModConfig::modPrefix) == 0){ return DivModConfig::getModTermFor(logic, tr); } return tr; } }; // Note: this has negligible impact on performance, no need to check if there are divs or mods AuxSymbolMatcherConfig config(*this); tr = Rewriter(*this, config).rewrite(tr); return Logic::removeAuxVars(tr); } // Handle the printing of real constants that are negative and the // rational constants std::string ArithLogic::printTerm_(PTRef tr, bool ext, bool safe) const { if (isNumConst(tr)) { bool is_neg = false; char* tmp_str; opensmt::stringToRational(tmp_str, sym_store.getName(getPterm(tr).symb())); opensmt::Number v(tmp_str); if (!isNonNegNumConst(tr)) { v.negate(); is_neg = true; } std::string rat_str = v.get_str(); free(tmp_str); bool is_div = false; unsigned i = 0; unsigned rat_size = rat_str.size(); for (; i != rat_size; i++) { if (rat_str[i] == '/') { is_div = true; break; } } if (is_div) { unsigned j = 0; char* nom = (char*) malloc(i+1); for (; j < i; j++) nom[j] = rat_str[j]; nom[i] = '\0'; char* den = (char*) malloc(rat_size-i); i++; j = 0; for (; i < rat_size; i++) den[j++] = rat_str[i]; den[j] = '\0'; char * tmp; std::stringstream str; int written = is_neg ? asprintf(&tmp, "(/ (- %s) %s)", nom, den) : asprintf(&tmp, "(/ %s %s)", nom, den); assert(written >= 0); (void)written; str << tmp; if (ext) { str << " <" << tr.x << ">"; } free(nom); free(den); free(tmp); return str.str(); } else if (is_neg) { std::stringstream str; str << "(- " << rat_str << ')'; if (ext) { str << " <" << tr.x << ">"; } return str.str(); } else { return rat_str; } } return Logic::printTerm_(tr, ext, safe); } /** * Normalizes a sum term a1x1 + a2xn + ... + anxn + c such that the coefficients of non-constant terms are coprime integers * Additionally, the normalized term is separated to constant and non-constant part, and the constant is modified as if * it was placed on the other side of an equality. * Note that the constant part can be a non-integer number after normalization. * * @param sum * @return Constant part of the normalized sum as LHS and non-constant part of the normalized sum as RHS */ opensmt::pair ArithLogic::sumToNormalizedIntPair(PTRef sum) { auto [constantValue, varFactors] = getConstantAndFactors(sum); vec vars; vars.capacity(varFactors.size()); std::vector coeffs; coeffs.reserve(varFactors.size()); for (PTRef factor : varFactors) { auto [var, coeff] = splitTermToVarAndConst(factor); assert(ArithLogic::isNumVarLike(var) and isNumConst(coeff)); vars.push(var); coeffs.push_back(getNumConst(coeff)); } bool changed = false; // Keep track if any change to varFactors occurs bool allIntegers = std::all_of(coeffs.begin(), coeffs.end(), [](opensmt::Number const & coeff) { return coeff.isInteger(); }); if (not allIntegers) { // first ensure that all coeffs are integers using Integer = FastRational; // TODO: change when we have FastInteger auto lcmOfDenominators = Integer(1); auto accumulateLCMofDenominators = [&lcmOfDenominators](FastRational const & next) { if (next.isInteger()) { // denominator is 1 => lcm of denominators stays the same return; } Integer den = next.get_den(); if (lcmOfDenominators == 1) { lcmOfDenominators = std::move(den); return; } lcmOfDenominators = lcm(lcmOfDenominators, den); }; std::for_each(coeffs.begin(), coeffs.end(), accumulateLCMofDenominators); for (auto & coeff : coeffs) { coeff *= lcmOfDenominators; assert(coeff.isInteger()); } // DONT forget to update also the constant factor constantValue *= lcmOfDenominators; changed = true; } assert(std::all_of(coeffs.begin(), coeffs.end(), [](opensmt::Number const & coeff) { return coeff.isInteger(); })); // Now make sure all coeffs are coprime auto coeffs_gcd = abs(coeffs[0]); for (std::size_t i = 1; i < coeffs.size() && coeffs_gcd != 1; ++i) { coeffs_gcd = gcd(coeffs_gcd, abs(coeffs[i])); assert(coeffs_gcd.isInteger()); } if (coeffs_gcd != 1) { for (auto & coeff : coeffs) { coeff /= coeffs_gcd; assert(coeff.isInteger()); } // DONT forget to update also the constant factor constantValue /= coeffs_gcd; changed = true; } // update the factors if (changed) { for (int i = 0; i < varFactors.size(); ++i) { varFactors[i] = mkTimes(vars[i], mkConst(getSort_int(), coeffs[i])); } } PTRef normalizedSum = varFactors.size() == 1 ? varFactors[0] : mkFun(get_sym_Int_PLUS(), std::move(varFactors)); // 0 <= normalizedSum + constantValue constantValue.negate(); return {std::move(constantValue), normalizedSum}; } /** * Normalizes a sum term a1x1 + a2xn + ... + anxn + c such that the leading coefficient is either 1 or -1. * Additionally, the normalized term is separated to constant and non-constant part, and the constant is modified as if * it was placed on the other side of an equality. * * @param sum * @return Constant part of the normalized sum as LHS and non-constant part of the normalized sum as RHS */ opensmt::pair ArithLogic::sumToNormalizedRealPair(PTRef sum) { auto [constantValue, varFactors] = getConstantAndFactors(sum); PTRef leadingFactor = varFactors[0]; // normalize the sum according to the leading factor auto [var, coeff] = splitTermToVarAndConst(leadingFactor); opensmt::Number normalizationCoeff = abs(getNumConst(coeff)); // varFactors come from a normalized sum, no need to call normalization code again PTRef normalizedSum = varFactors.size() == 1 ? varFactors[0] : mkFun(get_sym_Real_PLUS(), std::move(varFactors)); if (normalizationCoeff != 1) { // normalize the whole sum normalizedSum = mkTimes(normalizedSum, mkRealConst(normalizationCoeff.inverse())); // DON'T forget to update also the constant factor! constantValue /= normalizationCoeff; } constantValue.negate(); // moving the constant to the LHS of the inequality return {std::move(constantValue), normalizedSum}; } opensmt::pair ArithLogic::sumToNormalizedPair(PTRef sum) { SRef sr = getUniqueArgSort(sum); assert(isSortInt(sr) or isSortReal(sr)); return isSortInt(sr) ? sumToNormalizedIntPair(sum) : sumToNormalizedRealPair(sum); } PTRef ArithLogic::sumToNormalizedInequality(PTRef sum) { auto [lhsVal, rhs] = sumToNormalizedPair(sum); SRef sort = getSortRef(rhs); if (isSortInt(sort)) { lhsVal = lhsVal.ceil(); } return mkFun(getLeqForSort(sort), {mkConst(sort, lhsVal), rhs}); } PTRef ArithLogic::sumToNormalizedEquality(PTRef sum) { auto [lhsVal, rhs] = sumToNormalizedPair(sum); SRef sort = getSortRef(sum); if (isSortInt(sort) and not lhsVal.isInteger()) { return getTerm_false(); } // Ensure that in equality we always have positive leading variable if (hasNegativeLeadingVariable(rhs)) { rhs = mkNeg(rhs); lhsVal.negate(); } return Logic::mkBinaryEq(mkConst(getSortRef(sum), lhsVal), rhs); } PTRef ArithLogic::getConstantFromLeq(PTRef leq) { Pterm const & term = getPterm(leq); if (not isLeq(term.symb())) { throw OsmtApiException("LALogic::getConstantFromLeq called on a term that is not less-or-equal inequality"); } return term[0]; } PTRef ArithLogic::getTermFromLeq(PTRef leq) { Pterm const & term = getPterm(leq); if (not isLeq(term.symb())) { throw OsmtApiException("LALogic::getConstantFromLeq called on a term that is not less-or-equal inequality"); } return term[1]; } std::pair ArithLogic::leqToConstantAndTerm(PTRef leq) { Pterm const & term = getPterm(leq); assert(isLeq(term.symb())); return std::make_pair(term[0], term[1]); } bool ArithLogic::hasNegativeLeadingVariable(PTRef poly) const { if (isNumConst(poly) or isNumVarLike(poly)) { return false; } if (isTimes(poly)) { auto [var, constant] = splitTermToVarAndConst(poly); return isNegative(getNumConst(constant)); } assert(isPlus(poly)); PTRef leadingTerm = getPterm(poly)[0]; auto [var, constant] = splitTermToVarAndConst(leadingTerm); return isNegative(getNumConst(constant)); } opensmt-2.5.2/src/logics/ArithLogic.h000066400000000000000000000513551445011647600174730ustar00rootroot00000000000000#ifndef LALOGIC_H #define LALOGIC_H #include "Logic.h" #include "Number.h" #include class LANonLinearException : std::runtime_error { std::string msg; public: LANonLinearException(const char* reason_) : runtime_error(reason_) { msg = "Term " + std::string(reason_) + " is non-linear"; } virtual const char* what() const noexcept override { return msg.c_str(); } }; class ArithDivisionByZeroException : public std::runtime_error { public: ArithDivisionByZeroException() : runtime_error("Explicit division by zero encountered!") {} ~ArithDivisionByZeroException() = default; }; class ArithLogic: public Logic { friend class LessThan_deepPTRef; protected: std::vector numbers; static const std::string e_nonlinear_term; static const std::string tk_val_int_default; static const std::string tk_val_real_default; static const std::string tk_real_zero; static const std::string tk_int_zero; static const std::string tk_real_one; static const std::string tk_int_one; static const std::string tk_real_neg; static const std::string tk_int_neg; static const std::string tk_real_minus; static const std::string tk_int_minus; static const std::string tk_real_plus; static const std::string tk_int_plus; static const std::string tk_real_times; static const std::string tk_int_times; static const std::string tk_real_div; static const std::string tk_int_div; static const std::string tk_int_mod; static const std::string tk_real_leq; static const std::string tk_int_leq; static const std::string tk_real_lt; static const std::string tk_int_lt; static const std::string tk_real_geq; static const std::string tk_int_geq; static const std::string tk_real_gt; static const std::string tk_int_gt; static const std::string s_sort_real; static const std::string s_sort_int; // Reals SRef sort_REAL; PTRef term_Real_ZERO; PTRef term_Real_ONE; PTRef term_Real_MINUSONE; SymRef sym_Real_ZERO; SymRef sym_Real_ONE; SymRef sym_Real_NEG; SymRef sym_Real_MINUS; SymRef sym_Real_PLUS; SymRef sym_Real_TIMES; SymRef sym_Real_DIV; SymRef sym_Real_EQ; SymRef sym_Real_LEQ; SymRef sym_Real_LT; SymRef sym_Real_GEQ; SymRef sym_Real_GT; SymRef sym_Real_ITE; SymRef sym_Real_DISTINCT; // Integers SRef sort_INT; PTRef term_Int_ZERO; PTRef term_Int_ONE; PTRef term_Int_MINUSONE; SymRef sym_Int_ZERO; SymRef sym_Int_ONE; SymRef sym_Int_NEG; SymRef sym_Int_MINUS; SymRef sym_Int_PLUS; SymRef sym_Int_TIMES; SymRef sym_Int_DIV; SymRef sym_Int_MOD; SymRef sym_Int_EQ; SymRef sym_Int_LEQ; SymRef sym_Int_LT; SymRef sym_Int_GEQ; SymRef sym_Int_GT; SymRef sym_Int_ITE; SymRef sym_Int_DISTINCT; public: ArithLogic(opensmt::Logic_t type); ~ArithLogic() { for (auto number : numbers) { delete number; } } bool isBuiltinFunction(SymRef sr) const override; PTRef insertTerm (SymRef sym, vec && terms) override; SRef getSort_real () const { return sort_REAL; } SRef getSort_int () const { return sort_INT; } PTRef mkConst (const char* name) override; PTRef mkConst (SRef s, const char* name) override; PTRef mkConst (SRef s, const std::string& name) { return mkConst(s, name.c_str()); } PTRef mkConst (SRef s, opensmt::Number const & c); PTRef mkIntConst (opensmt::Number const & c) { if (not hasIntegers()) { throw OsmtApiException("Create Int constant in non-integral logic"); } return mkConst(getSort_int(), c); } PTRef mkRealConst (opensmt::Number const & c) { if (not hasReals()) { throw OsmtApiException("Create Real constant in non-real logic"); } return mkConst(getSort_real(), c); } PTRef mkIntVar (const char* name) { if (not hasIntegers()) { throw OsmtApiException("Create Int var in non-integral logic"); } return mkVar(sort_INT, name, false); } PTRef mkRealVar (const char* name) { if (not hasReals()) { throw OsmtApiException("Create Real var in non-real logic"); } return mkVar(sort_REAL, name, false); } bool isBuiltinSort (SRef sr) const override { return sr == getSort_int() || sr == getSort_real() || Logic::isBuiltinSort(sr); } bool isBuiltinSortSym (SSymRef ssr) const override { return ssr == sort_store.getSortSym(getSort_int()) || ssr == sort_store.getSortSym(getSort_real()) || Logic::isBuiltinSortSym(ssr); } bool isBuiltinConstant(SymRef sr) const override { return (isIntConst(sr) || isRealConst(sr) || Logic::isBuiltinConstant(sr)); } bool isNumConst (SymRef sr) const { return Logic::isConstant(sr) && yieldsSortNum(sr); } bool isNumConst (PTRef tr) const { return isNumConst(getPterm(tr).symb()); } bool isIntConst(SymRef sr) const { return isNumConst(sr) && yieldsSortInt(sr); } bool isIntConst (PTRef tr) const { return isIntConst(getPterm(tr).symb()); } bool isRealConst(SymRef sr) const { return isNumConst(sr) && yieldsSortReal(sr); } bool isRealConst (PTRef tr) const { return isRealConst(getPterm(tr).symb()); } bool isNonNegNumConst (PTRef tr) const { return isNumConst(tr) && isNonNegative(getNumConst(tr)); } bool isSortInt(SRef sr) const { return sr == getSort_int(); } bool isSortReal(SRef sr) const { return sr == getSort_real(); } bool isSortNum(SRef sr) const { return isSortInt(sr) or isSortReal(sr); } bool yieldsSortInt(SymRef sr) const { return isSortInt(sym_store[sr].rsort()); } bool yieldsSortInt(PTRef tr) const { return yieldsSortInt(getPterm(tr).symb()); } bool yieldsSortReal(SymRef sr) const { return isSortReal(sym_store[sr].rsort()); } bool yieldsSortReal(PTRef tr) const { return yieldsSortReal(getPterm(tr).symb()); } bool yieldsSortNum(SymRef sr) const { return yieldsSortInt(sr) or yieldsSortReal(sr); } bool yieldsSortNum(PTRef tr) const { return yieldsSortInt(tr) or yieldsSortReal(tr); } const FastRational & getNumConst(PTRef tr) const; bool isUFEquality(PTRef tr) const override { return !isNumEq(tr) && Logic::isUFEquality(tr); } bool isAtom(PTRef tr) const override { return isNumEq(tr) || isLt(tr) || isGt(tr) || isLeq(tr) || isGeq(tr) || Logic::isAtom(tr); } const char* getDefaultValue(PTRef tr) const override; PTRef getDefaultValuePTRef(SRef sref) const override; SymRef get_sym_Int_TIMES () const { return sym_Int_TIMES; } SymRef get_sym_Real_TIMES () const { return sym_Real_TIMES; } SymRef get_sym_Int_DIV () const { return sym_Int_DIV; } SymRef get_sym_Int_MOD () const { return sym_Int_MOD; } SymRef get_sym_Real_DIV () const { return sym_Real_DIV; } SymRef get_sym_Int_MINUS () const { return sym_Int_MINUS; } SymRef get_sym_Real_MINUS () const { return sym_Real_MINUS; } SymRef get_sym_Real_PLUS () const {return sym_Real_PLUS; } SymRef get_sym_Int_PLUS () const {return sym_Int_PLUS; } SymRef get_sym_Int_NEG () const { return sym_Int_NEG; } SymRef get_sym_Int_LEQ() const { return sym_Int_LEQ; } SymRef get_sym_Real_LEQ() const { return sym_Real_LEQ; } SymRef getLeqForSort(SRef sr) const; SymRef get_sym_Int_GEQ() const { return sym_Int_GEQ; } SymRef get_sym_Real_GEQ() const { return sym_Real_GEQ; } SymRef get_sym_Int_LT() const { return sym_Int_LT; } SymRef get_sym_Real_LT() const { return sym_Real_LT; } SymRef get_sym_Int_GT() const { return sym_Int_GT; } SymRef get_sym_Real_GT() const { return sym_Real_GT; } SymRef get_sym_Int_EQ() const { return sym_Int_EQ; } SymRef get_sym_Real_EQ() const { return sym_Real_EQ; } SymRef get_Sym_Int_ZERO () const { return sym_Int_ZERO; } SymRef get_Sym_Real_ZERO () const { return sym_Real_ZERO; } SymRef get_Sym_Int_ONE() const { return sym_Int_ONE; } SymRef get_Sym_Real_ONE() const { return sym_Real_ONE; } SymRef get_sym_Int_ITE() const { return sym_Int_ITE;} SymRef get_sym_Real_ITE() const { return sym_Real_ITE; } void checkArithSortCompatible(vec const & args, SRef numSort) const { for (auto tr : args) { if (getSortRef(tr) != numSort) throw OsmtApiException("Argument sorts disagree"); } } SRef checkArithSortCompatible(vec const & args) const { if (args.size() == 0) { return SRef_Undef; } SRef numSort = getSortRef(args[0]); checkArithSortCompatible(args, numSort); return numSort; } void checkHasReals() const { if (not hasReals()) throw OsmtApiException("Reals not defined for logic"); } void checkHasIntegers() const { if (not hasIntegers()) throw OsmtApiException("Integers not defined for logic"); } bool isPlus(SymRef sr) const { return isIntPlus(sr) or isRealPlus(sr); } bool isPlus(PTRef tr) const { return isPlus(getPterm(tr).symb()); } bool isIntPlus(PTRef tr) const { return isIntPlus(getPterm(tr).symb()); } bool isRealPlus(PTRef tr ) const { return isRealPlus(getPterm(tr).symb()); } bool isIntPlus(SymRef sr) const { return sr == sym_Int_PLUS; } bool isRealPlus(SymRef sr) const { return sr == sym_Real_PLUS; } bool isMinus(SymRef sr) const { return isIntMinus(sr) or isRealMinus(sr); } bool isIntMinus(PTRef tr) const { return isIntMinus(getPterm(tr).symb()); } bool isRealMinus(PTRef tr) const { return isRealMinus(getPterm(tr).symb()); } bool isIntMinus(SymRef sr) const { return sr == sym_Int_MINUS; } bool isRealMinus(SymRef sr) const { return sr == sym_Real_MINUS; } bool isNeg(SymRef sr) const { return isIntNeg(sr) or isRealNeg(sr); } bool isNeg(PTRef tr) const { return isNeg(getPterm(tr).symb()); } bool isIntNeg(PTRef tr) const { return isIntNeg(getPterm(tr).symb()); } bool isRealNeg(PTRef tr) const { return isRealNeg(getPterm(tr).symb()); } bool isIntNeg(SymRef sr) const { return sr == sym_Int_NEG; } bool isRealNeg(SymRef sr) const { return sr == sym_Real_NEG; } bool isTimes(SymRef sr) const { return isIntTimes(sr) or isRealTimes(sr); } bool isTimes(PTRef tr) const { return isTimes(getPterm(tr).symb()); } bool isIntTimes(PTRef tr) const { return isIntTimes(getPterm(tr).symb()); } bool isRealTimes(PTRef tr) const { return isRealTimes(getPterm(tr).symb()); } bool isIntTimes(SymRef sr) const { return sr == sym_Int_TIMES; } bool isRealTimes(SymRef sr) const { return sr == sym_Real_TIMES; } bool isRealDiv(PTRef tr) const { return isRealDiv(getPterm(tr).symb()); } bool isRealDiv(SymRef sr) const { return sr == sym_Real_DIV; } bool isIntDiv(PTRef tr) const { return isIntDiv(getPterm(tr).symb()); } bool isIntDiv(SymRef sr) const { return sr == sym_Int_DIV; } bool isMod(SymRef sr) const { return sr == sym_Int_MOD; } bool isNumEq(SymRef sr) const { return isEquality(sr) and isSortNum(sym_store[sr][0]); } bool isNumEq(PTRef tr) const { return isNumEq(getPterm(tr).symb()); } bool isIntEq(PTRef tr) const { return isIntEq(getPterm(tr).symb()); } bool isRealEq(PTRef tr) const { return isRealEq(getPterm(tr).symb()); } bool isIntEq(SymRef sr) const { return isEquality(sr) && sym_store[sr][0] == sort_INT; } bool isRealEq(SymRef sr) const { return isEquality(sr) && sym_store[sr][0] == sort_REAL; } bool isLeq(SymRef sr) const { return isRealLeq(sr) or isIntLeq(sr); } bool isLeq(PTRef tr) const { return isLeq(getPterm(tr).symb()); } bool isIntLeq(PTRef tr) const { return isIntLeq(getPterm(tr).symb()); } bool isRealLeq(PTRef tr) const { return isRealLeq(getPterm(tr).symb()); } bool isIntLeq(SymRef sr) const { return sr == sym_Int_LEQ; } bool isRealLeq(SymRef sr) const { return sr == sym_Real_LEQ; } bool isLt(SymRef sr) const { return isIntLt(sr) or isRealLt(sr); } bool isLt(PTRef tr) const { return isLt(getPterm(tr).symb()); } bool isIntLt(PTRef tr) const { return isIntLt(getPterm(tr).symb()); } bool isRealLt(PTRef tr) const { return isRealLt(getPterm(tr).symb()); } bool isIntLt(SymRef sr) const { return sr == sym_Int_LT; } bool isRealLt(SymRef sr) const { return sr == sym_Real_LT; } bool isGeq(SymRef sr) const { return isIntGeq(sr) or isRealGeq(sr); } bool isGeq(PTRef tr) const { return isGeq(getPterm(tr).symb()); } bool isIntGeq(PTRef tr) const { return isIntGeq(getPterm(tr).symb()); } bool isRealGeq(PTRef tr) const { return isRealGeq(getPterm(tr).symb()); } bool isIntGeq(SymRef sr) const { return sr == sym_Int_GEQ; } bool isRealGeq(SymRef sr) const { return sr == sym_Real_GEQ; } bool isGt(SymRef sr) const { return isIntGt(sr) or isRealGt(sr); } bool isGt(PTRef tr) const { return isGt(getPterm(tr).symb()); } bool isIntGt(PTRef tr) const { return isIntGt(getPterm(tr).symb()); } bool isRealGt(PTRef tr) const { return isRealGt(getPterm(tr).symb()); } bool isIntGt(SymRef sr) const { return sr == sym_Int_GT; } bool isRealGt(SymRef sr) const { return sr == sym_Real_GT; } bool isNumVar(SymRef sr) const { return isVar(sr) and (yieldsSortInt(sr) or yieldsSortReal(sr)); } bool isNumVar(PTRef tr) const { return isNumVar(getPterm(tr).symb()); } bool isNumVarLike(SymRef sr) const { return yieldsSortNum(sr) and not isPlus(sr) and not isTimes(sr) and not isNumConst(sr); } bool isNumVarLike(PTRef tr) const { return isNumVarLike(getPterm(tr).symb()); } bool isZero(SymRef sr) const { return isIntZero(sr) or isRealZero(sr); } bool isZero(PTRef tr) const { return isZero(getSymRef(tr)); } bool isIntZero(PTRef tr) const { return tr == getTerm_IntZero(); } bool isRealZero(PTRef tr) const { return tr == getTerm_RealZero(); } bool isIntZero(SymRef sr) const { return sr == sym_Int_ZERO; } bool isRealZero(SymRef sr) const { return sr == sym_Real_ZERO; } bool isOne(PTRef tr) const { return isIntOne(tr) or isRealOne(tr); } bool isIntOne(PTRef tr) const { return tr == getTerm_IntOne(); } bool isMinusOne(PTRef tr) const { return isIntMinusOne(tr) or isRealMinusOne(tr); } bool isIntMinusOne(PTRef tr) const { return tr == getTerm_IntMinusOne(); } bool isRealOne(PTRef tr) const { return tr == getTerm_RealOne(); } bool isRealMinusOne(PTRef tr) const { return tr == getTerm_RealMinusOne(); } bool isIntOne(SymRef sr) const { return sr == sym_Int_ONE; } bool isRealOne(SymRef sr) const { return sr == sym_Real_ONE; } // Real terms are of form c, a, or (* c a) where c is a constant and a is a variable or Ite. bool isNumTerm(PTRef tr) const; PTRef getTerm_IntZero() const { return term_Int_ZERO; } PTRef getTerm_RealZero() const { return term_Real_ZERO; } PTRef getTerm_IntOne() const { return term_Int_ONE; } PTRef getTerm_RealOne() const { return term_Real_ONE; } PTRef getTerm_IntMinusOne() const { return term_Int_MINUSONE; } PTRef getTerm_RealMinusOne()const { return term_Real_MINUSONE; } void checkSortInt(PTRef tr) { if (getSortRef(tr) != getSort_int()) throw OsmtApiException("Expected integral sort"); } void checkSortReal(PTRef tr) { if (getSortRef(tr) != getSort_real()) throw OsmtApiException("Expected real sort"); } void checkSortInt(vec const & args) { if (args.size() > 0) checkSortInt(args[0]); } void checkSortReal(vec const & args) { if (args.size() > 0) checkSortReal(args[0]); } SymRef getPlusForSort(SRef sort) const; SymRef getTimesForSort(SRef sort) const; SymRef getMinusForSort(SRef sort) const; PTRef getZeroForSort(SRef sort) const; PTRef getOneForSort(SRef sort) const; PTRef getMinusOneForSort(SRef sort) const; // Negation PTRef mkNeg(PTRef tr); // Minus PTRef mkMinus(vec &&); PTRef mkMinus(PTRef a1, PTRef a2) { return mkMinus(vec({a1, a2})); } PTRef mkMinus(vec const & args) { vec tmp; args.copyTo(tmp); return mkMinus(std::move(tmp)); } // Plus PTRef mkPlus(vec &&); PTRef mkPlus(PTRef p1, PTRef p2) { return mkPlus(vec({p1, p2})); } PTRef mkPlus(vec const & args) { vec tmp; args.copyTo(tmp); return mkPlus(std::move(tmp)); } PTRef mkPlus(std::vector const & args) { return mkPlus(vec(args)); } // Times PTRef mkTimes(vec && args); PTRef mkTimes(PTRef p1, PTRef p2) { return mkTimes(vec{p1, p2}); } PTRef mkTimes(vec const &args) { vec tmp; args.copyTo(tmp); return mkTimes(std::move(tmp)); } PTRef mkTimes(std::vector const &args) { return mkTimes(vec(args)); } // Div PTRef mkIntDiv(vec && args); PTRef mkIntDiv(PTRef nom, PTRef den) { return mkIntDiv(vec{nom, den}); } PTRef mkIntDiv(vec const & args) { vec tmp; args.copyTo(tmp); return mkIntDiv(std::move(tmp)); } PTRef mkRealDiv(vec && args); PTRef mkRealDiv(PTRef nom, PTRef den) { return mkRealDiv(vec{nom, den}); } PTRef mkRealDiv(vec const & args) { vec tmp; args.copyTo(tmp); return mkRealDiv(std::move(tmp)); } // Mod PTRef mkMod(vec && args); PTRef mkMod(PTRef first, PTRef second) { return mkMod(vec{first, second}); } // Leq PTRef mkLeq(vec const & args); PTRef mkLeq(PTRef arg1, PTRef arg2) { return mkBinaryLeq(arg1, arg2); } // Geq PTRef mkGeq(vec const & args); PTRef mkGeq(PTRef arg1, PTRef arg2) { return mkBinaryGeq(arg1, arg2); } // Lt PTRef mkLt(vec const & args); PTRef mkLt(PTRef arg1, PTRef arg2) { return mkBinaryLt(arg1, arg2); } // Gt PTRef mkGt(vec const & args); PTRef mkGt(PTRef arg1, PTRef arg2) { return mkBinaryGt(arg1, arg2); } bool isLinearTerm(PTRef tr) const; bool isLinearFactor(PTRef tr) const; opensmt::pair> getConstantAndFactors(PTRef sum) const; opensmt::pair splitTermToVarAndConst(PTRef term) const; PTRef normalizeMul(PTRef mul); // Given a sum term 't' returns a normalized inequality 'c <= s' equivalent to '0 <= t' PTRef sumToNormalizedInequality(PTRef sum); PTRef sumToNormalizedEquality(PTRef sum); lbool arithmeticElimination(vec const & top_level_arith, SubstMap & substitutions); opensmt::pair retrieveSubstitutions(vec const & facts) override; void termSort(vec &v) const override; PTRef removeAuxVars(PTRef) override; std::string printTerm_(PTRef tr, bool ext, bool s) const override; // Helper methods // Given an inequality 'c <= t', return the constant c; checked version PTRef getConstantFromLeq(PTRef); // Given an inequality 'c <= t', return the term t; checked version PTRef getTermFromLeq(PTRef); // Given an inequality 'c <= t', return the pair for a constant c and term t; unchecked version, for internal use std::pair leqToConstantAndTerm(PTRef); // MB: In pure LA, there are never nested boolean terms vec getNestedBoolRoots (PTRef) const override { return vec(); } protected: PTRef mkBinaryLeq(PTRef lhs, PTRef rhs); PTRef mkBinaryGeq(PTRef lhs, PTRef rhs) { return mkBinaryLeq(rhs, lhs); } PTRef mkBinaryLt(PTRef lhs, PTRef rhs) { return mkNot(mkBinaryGeq(lhs, rhs)); } PTRef mkBinaryGt(PTRef lhs, PTRef rhs) { return mkNot(mkBinaryLeq(lhs, rhs)); } PTRef mkBinaryEq(PTRef lhs, PTRef rhs) override; opensmt::pair sumToNormalizedPair(PTRef sum); opensmt::pair sumToNormalizedIntPair(PTRef sum); opensmt::pair sumToNormalizedRealPair(PTRef sum); bool hasNegativeLeadingVariable(PTRef poly) const; }; // Determine for two multiplicative terms (* k1 v1) and (* k2 v2), v1 != // v2 which one is smaller, based on the PTRef of v1 and v2. (i.e. // v1.ptref < v2.ptref iff (* k1 v1) < (* k2 v2)). // // This code is required for canonicalising the terms and correctly identifying their sign. // // If term contains a const-ite: // (* ite v) or (* ite c) or (* v ite) or (* c ite) => consider {v,c}.ptref // (* ite1 ite2) => consider min(ite1.ptref, ite2.ptref) class LessThan_deepPTRef { ArithLogic const & l; uint32_t getVarIdFromProduct(PTRef term) const; public: LessThan_deepPTRef(ArithLogic const& l) : l(l) {} bool operator () (PTRef x_, PTRef y_) const; }; #endifopensmt-2.5.2/src/logics/ArrayHelpers.cc000066400000000000000000000023221445011647600201730ustar00rootroot00000000000000/* * Copyright (c) 2023, Martin Blicha * * SPDX-License-Identifier: MIT * */ #include "ArrayHelpers.h" #include "TreeOps.h" vec collectStores(Logic const & logic, PTRef fla) { class CollectStoresConfig : public DefaultVisitorConfig { Logic const & logic; public: vec stores; CollectStoresConfig(Logic const & logic) : logic(logic) {} void visit(PTRef term) override { if (logic.isArrayStore(term)) { stores.push(term); } } }; CollectStoresConfig config(logic); TermVisitor visitor(logic, config); visitor.visit(fla); return std::move(config.stores); } PTRef instantiateReadOverStore(Logic & logic, PTRef fla) { vec stores = collectStores(logic, fla); vec instantiatedAxioms; for (PTRef store : stores) { PTRef index = logic.getPterm(store)[1]; PTRef value = logic.getPterm(store)[2]; assert(logic.isArrayStore(store)); instantiatedAxioms.push(logic.mkEq(logic.mkSelect({store, index}), value)); } instantiatedAxioms.push(fla); return logic.mkAnd(std::move(instantiatedAxioms)); } opensmt-2.5.2/src/logics/ArrayHelpers.h000066400000000000000000000005271445011647600200420ustar00rootroot00000000000000/* * Copyright (c) 2023, Martin Blicha * * SPDX-License-Identifier: MIT * */ #ifndef OPENSMT_ARRAYHELPERS_H #define OPENSMT_ARRAYHELPERS_H #include "Logic.h" PTRef instantiateReadOverStore(Logic & logic, PTRef fla); vec collectStores(Logic const & logic, PTRef fla); #endif //OPENSMT_ARRAYHELPERS_H opensmt-2.5.2/src/logics/ArrayTheory.cc000066400000000000000000000012771445011647600200530ustar00rootroot00000000000000/* * Copyright (c) 2021, Martin Blicha * * SPDX-License-Identifier: MIT */ #include "ArrayTheory.h" #include "ArrayHelpers.h" #include "DistinctRewriter.h" #include "TreeOps.h" bool ArrayTheory::simplify(vec const & formulas, PartitionManager &, int curr) { // TODO: simplify select over store on the same index auto & currentFrame = pfstore[formulas[curr]]; if (this->keepPartitions()) { std::logic_error("Not suppported yet"); } PTRef rewritten = rewriteDistincts(getLogic(), getCollateFunction(formulas, curr)); rewritten = instantiateReadOverStore(getLogic(), rewritten); currentFrame.root = rewritten; return true; } opensmt-2.5.2/src/logics/ArrayTheory.h000066400000000000000000000015621445011647600177120ustar00rootroot00000000000000/* * Copyright (c) 2021, Martin Blicha * * SPDX-License-Identifier: MIT */ #ifndef OPENSMT_ARRAYTHEORY_H #define OPENSMT_ARRAYTHEORY_H #include "Theory.h" #include "ArrayTHandler.h" class ArrayTheory : public Theory { private: Logic & logic; ArrayTHandler tshandler; public: ArrayTheory(SMTConfig & c, Logic & logic) : Theory(c) , logic(logic) , tshandler(c, logic) { } ~ArrayTheory() {} virtual Logic& getLogic() override { return logic; } virtual const Logic& getLogic() const override { return logic; } virtual ArrayTHandler& getTSolverHandler() override { return tshandler; } virtual const ArrayTHandler& getTSolverHandler() const { return tshandler; } virtual bool simplify(vec const &, PartitionManager &, int) override; }; #endif //OPENSMT_ARRAYTHEORY_H opensmt-2.5.2/src/logics/BVLogic.cc000066400000000000000000000277501445011647600170730ustar00rootroot00000000000000/*******************************************************************\ Module: New Logic for BitVector * Author: Antti Hyvarinen * Author: Sepideh Asadi * Created on: Jan 16, 2017 \*******************************************************************/ #include "SStore.h" #include "PtStore.h" #include "BVLogic.h" #include "CUFLogic.h" const char* BVLogic::tk_bv_neg = "-"; const char* BVLogic::tk_bv_eq = "=="; const char* BVLogic::tk_bv_minus = "-"; const char* BVLogic::tk_bv_plus = "+"; const char* BVLogic::tk_bv_times = "*"; const char* BVLogic::tk_bv_div = "/"; const char* BVLogic::tk_bv_slt = "s<"; const char* BVLogic::tk_bv_ult = "u<"; const char* BVLogic::tk_bv_sleq = "s<="; const char* BVLogic::tk_bv_uleq = "u<="; const char* BVLogic::tk_bv_sgt = "s>"; const char* BVLogic::tk_bv_ugt = "u>"; const char* BVLogic::tk_bv_sgeq = "s>="; const char* BVLogic::tk_bv_ugeq = "u>="; const char* BVLogic::tk_bv_lshift = "<<"; const char* BVLogic::tk_bv_arshift = "a>>"; const char* BVLogic::tk_bv_lrshift = "l>>"; const char* BVLogic::tk_bv_mod = "%"; const char* BVLogic::tk_bv_bwand = "&"; const char* BVLogic::tk_bv_bwor = "|"; const char* BVLogic::tk_bv_land = "&&"; const char* BVLogic::tk_bv_lor = "||"; const char* BVLogic::tk_bv_not = "!"; const char* BVLogic::tk_bv_bwxor = "^"; const char* BVLogic::tk_bv_compl = "~"; const char* BVLogic::s_sort_bvnum = "BVNum"; //const char* BVLogic::s_sort_bvstr = "BVStr"; const char* BVLogic::s_uf_extract_base = ".ex"; const char* BVLogic::tk_bv_coll32 = ".coll32"; const int BVLogic::i_default_bitwidth = 32; BVLogic::BVLogic(opensmt::Logic_t type, int width) : CUFLogic(type) , bitwidth(width) , sort_BVNUM(getSort(sort_store.newSortSymbol(SortSymbol(s_sort_bvnum, 0, SortSymbol::INTERNAL)), {})) , term_BV_ZERO(mkBVConst(0)) , term_BV_ONE(mkBVConst(1)) , sym_BV_ZERO(getSymRef(term_BV_ZERO)) , sym_BV_ONE(getSymRef(term_BV_ONE)) , sym_BV_NEG(declareFun_NoScoping(tk_bv_neg, sort_BVNUM, {sort_BVNUM})) , sym_BV_MINUS(declareFun_NoScoping_LeftAssoc(tk_bv_minus, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_PLUS(declareFun_NoScoping_LeftAssoc(tk_bv_plus, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_TIMES(declareFun_NoScoping_LeftAssoc(tk_bv_times, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_DIV(declareFun_NoScoping_LeftAssoc(tk_bv_div, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_EQ(declareFun_NoScoping_LeftAssoc(tk_equals, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_SLEQ(declareFun_NoScoping_RightAssoc(tk_bv_sleq, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_ULEQ(declareFun_NoScoping_RightAssoc(tk_bv_uleq, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_SGEQ(declareFun_NoScoping_RightAssoc(tk_bv_sgeq, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_UGEQ(declareFun_NoScoping_RightAssoc(tk_bv_ugeq, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_SLT(declareFun_NoScoping_RightAssoc(tk_bv_slt, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_ULT(declareFun_NoScoping_RightAssoc(tk_bv_ult, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_SGT(declareFun_NoScoping_RightAssoc(tk_bv_sgt, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_UGT(declareFun_NoScoping_RightAssoc(tk_bv_ugt, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_BWXOR(declareFun_NoScoping_LeftAssoc(tk_bv_bwxor, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_LSHIFT(declareFun_NoScoping_LeftAssoc(tk_bv_lshift, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_LRSHIFT(declareFun_NoScoping_LeftAssoc(tk_bv_lrshift, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_ARSHIFT(declareFun_NoScoping_LeftAssoc(tk_bv_lrshift, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_MOD(declareFun_NoScoping_LeftAssoc(tk_bv_mod, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_BWOR(declareFun_NoScoping_LeftAssoc(tk_bv_bwor, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_BWAND(declareFun_NoScoping_LeftAssoc(tk_bv_bwand, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_LAND(declareFun_NoScoping_LeftAssoc(tk_bv_land, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_LOR(declareFun_NoScoping_LeftAssoc(tk_bv_lor, sort_BVNUM, {sort_BVNUM, sort_BVNUM})) , sym_BV_NOT(declareFun_NoScoping(tk_bv_not, sort_BVNUM, {sort_BVNUM})) , sym_BV_COMPL(declareFun_NoScoping(tk_bv_compl, sort_BVNUM, {sort_BVNUM})) , sym_BV_COLLATE32(declareFun_NoScoping(tk_bv_coll32, sort_CUFNUM, {sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL, sort_BOOL})) { equalities.insert(sym_BV_EQ, true); for (int i = 0; i < 32; i++) { std::string sym_name {s_uf_extract_base}; sym_name += std::to_string(i); declareFun_NoScoping(sym_name.c_str(), sort_BOOL, {sort_CUFNUM}); } } BVLogic::~BVLogic() {} PTRef BVLogic::mkBVEq(PTRef a1, PTRef a2) { assert(hasSortBVNUM(a1)); assert(hasSortBVNUM(a2)); if (isConstant(a1) && isConstant(a2)) return (a1 == a2) ? getTerm_BVOne() : getTerm_BVZero(); if (a1 == a2) return getTerm_BVOne(); if (a1 == mkBVNot(a2)) return getTerm_BVZero(); return mkFun(sym_BV_EQ, {a1,a2}); } PTRef BVLogic::mkBVNeg(PTRef tr) { assert(hasSortBVNUM(tr)); if (isBVNeg(tr)) return getPterm(tr)[0]; if (isConstant(tr)) { int v = getBVNUMConst(tr); v = -v; PTRef nterm = mkBVConst(v); return nterm; } vec arg; arg.push(getTerm_BVZero()); arg.push(tr); return mkBVMinus(arg); } PTRef BVLogic::mkBVMinus(const vec& args_in) { for (int i = 0; i < args_in.size(); i++) assert(hasSortBVNUM(args_in[i])); vec args; args_in.copyTo(args); if (args.size() == 1) return mkBVNeg(args[0]); assert(args.size() == 2); PTRef mo = mkBVConst(-1); PTRef fact = mkBVTimes(mo, args[1]); args[1] = fact; return mkBVPlus(args[0], args[1]); } PTRef BVLogic::mkBVPlus(const PTRef arg1, const PTRef arg2) { assert(hasSortBVNUM(arg1)); assert(hasSortBVNUM(arg2)); PTRef tr = mkFun(sym_BV_PLUS, {arg1, arg2}); // sum_args[0] = arg2; // sum_args[1] = arg1; // PTRef tr_comm = mkFun(sym_BV_PLUS, sum_args, msg); // PTRef tr_comm_eq = mkEq(tr, tr_comm); // if (!comm_eqs.has(tr_comm_eq)) // comm_eqs.insert(tr_comm_eq, true); return tr; } PTRef BVLogic::mkBVTimes(const PTRef arg1, const PTRef arg2) { assert(hasSortBVNUM(arg1)); assert(hasSortBVNUM(arg2)); PTRef tr = mkFun(sym_BV_TIMES, {arg1, arg2}); // times_args[0] = arg2; // times_args[1] = arg1; // PTRef tr_comm = mkFun(sym_BV_TIMES, times_args, msg); // PTRef tr_comm_eq = mkEq(tr, tr_comm); // if (!comm_eqs.has(tr_comm_eq)) // comm_eqs.insert(tr_comm_eq, true); return tr; } PTRef BVLogic::mkBVDiv(const PTRef arg1, const PTRef arg2) { assert(hasSortBVNUM(arg1)); assert(hasSortBVNUM(arg2)); PTRef tr = mkFun(sym_BV_DIV, {arg1, arg2}); return tr; } PTRef BVLogic::mkBVUgeq(const PTRef arg1, const PTRef arg2) { assert(hasSortBVNUM(arg1)); assert(hasSortBVNUM(arg2)); return mkBVUleq(arg2, arg1); } PTRef BVLogic::mkBVSgeq(const PTRef arg1, const PTRef arg2) { assert(hasSortBVNUM(arg1)); assert(hasSortBVNUM(arg2)); return mkBVSleq(arg2, arg1); } PTRef BVLogic::mkBVUgt(const PTRef arg1, const PTRef arg2) { assert(hasSortBVNUM(arg1)); assert(hasSortBVNUM(arg2)); return mkBVUlt(arg2, arg1); } PTRef BVLogic::mkBVSgt(const PTRef arg1, const PTRef arg2) { assert(hasSortBVNUM(arg1)); assert(hasSortBVNUM(arg2)); return mkBVSlt(arg2, arg1); } PTRef BVLogic::mkBVSleq(const PTRef arg1, const PTRef arg2) { assert(hasSortBVNUM(arg1)); assert(hasSortBVNUM(arg2)); if (isBVNUMConst(arg1) && isBVNUMConst(arg2)) { int c1 = (int)getBVNUMConst(arg1); int c2 = (int)getBVNUMConst(arg2); if (c1 <= c2) return term_BV_ONE; else return term_BV_ZERO; } return mkBVNot(mkBVSgt(arg1, arg2)); } PTRef BVLogic::mkBVUleq(const PTRef arg1, const PTRef arg2) { assert(hasSortBVNUM(arg1)); assert(hasSortBVNUM(arg2)); if (isBVNUMConst(arg1) && isBVNUMConst(arg2)) { unsigned c1 = (unsigned)getBVNUMConst(arg1); unsigned c2 = (unsigned)getBVNUMConst(arg2); if (c1 <= c2) return term_BV_ONE; else return term_BV_ZERO; } PTRef tr = mkFun(sym_BV_ULEQ, {arg1, arg2}); return tr; } PTRef BVLogic::mkBVUlt(const PTRef arg1, const PTRef arg2) { assert(hasSortBVNUM(arg1)); assert(hasSortBVNUM(arg2)); return mkBVNeg(mkBVUgeq(arg1, arg2)); } PTRef BVLogic::mkBVSlt(const PTRef arg1, const PTRef arg2) { assert(hasSortBVNUM(arg1)); assert(hasSortBVNUM(arg2)); if (isBVNUMConst(arg1) && isBVNUMConst(arg2)) { int c1 = (int)getBVNUMConst(arg1); int c2 = (int)getBVNUMConst(arg2); if (c1 < c2) return term_BV_ONE; else return term_BV_ZERO; } PTRef tr = mkFun(sym_BV_SLT, {arg1, arg2}); return tr; } PTRef BVLogic::mkBVLshift(const PTRef arg1, const PTRef arg2) { assert(hasSortBVNUM(arg1)); assert(hasSortBVNUM(arg2)); if (isBVNUMConst(arg2) && getBVNUMConst(arg2) == 0) return arg1; return mkFun(sym_BV_LSHIFT, {arg1, arg2}); } PTRef BVLogic::mkBVLRshift(const PTRef arg1, const PTRef arg2) { if (isBVNUMConst(arg2) && getBVNUMConst(arg2) == 0) return arg1; return mkFun(sym_BV_LRSHIFT, {arg1, arg2}); } PTRef BVLogic::mkBVARshift(const PTRef arg1, const PTRef arg2) { if (isBVNUMConst(arg2) && getBVNUMConst(arg2) == 0) return arg1; return mkFun(sym_BV_ARSHIFT, {arg1, arg2}); } PTRef BVLogic::mkBVMod(const PTRef arg1, const PTRef arg2) { assert(hasSortBVNUM(arg1)); assert(hasSortBVNUM(arg2)); if (isBVNUMConst(arg2) && getBVNUMConst(arg2) == 1) return getTerm_BVZero(); // if b > 0, then 0 <= a % b < b // if b < 0, then b < a % b <= 0 return mkFun(sym_BV_MOD, {arg1, arg2}); } PTRef BVLogic::mkBVBwAnd(const PTRef arg1, const PTRef arg2) { assert(hasSortBVNUM(arg1)); assert(hasSortBVNUM(arg2)); return mkFun(sym_BV_BWAND, {arg1, arg2}); } PTRef BVLogic::mkBVBwOr(const PTRef arg1, const PTRef arg2) { assert(hasSortBVNUM(arg1)); assert(hasSortBVNUM(arg2)); return mkFun(sym_BV_BWOR, {arg1, arg2}); } PTRef BVLogic::mkBVLand(const PTRef arg1, const PTRef arg2) { assert(hasSortBVNUM(arg1)); assert(hasSortBVNUM(arg2)); PTRef tr = mkFun(sym_BV_LAND, {arg1, arg2}); return tr; } PTRef BVLogic::mkBVLor(const PTRef arg1, const PTRef arg2) { assert(hasSortBVNUM(arg1)); assert(hasSortBVNUM(arg2)); PTRef tr = mkFun(sym_BV_LOR, {arg1, arg2}); return tr; } PTRef BVLogic::mkBVNot(const PTRef arg) { assert(hasSortBVNUM(arg)); if (isBVNot(arg)) return getPterm(arg)[0]; else if (isConstant(arg) && (arg != term_BV_ZERO)) return term_BV_ZERO; else if (arg == term_BV_ZERO) return term_BV_ONE; PTRef tr = mkFun(sym_BV_NOT, {arg}); return tr; } PTRef BVLogic::mkBVBwXor(const PTRef arg1, const PTRef arg2) { assert(hasSortBVNUM(arg1)); assert(hasSortBVNUM(arg2)); return mkFun(sym_BV_BWXOR, {arg1, arg2}); } PTRef BVLogic::mkBVCompl(const PTRef arg1) { assert(hasSortBVNUM(arg1)); PTRef tr = mkFun(sym_BV_COMPL, {arg1}); // PTRef neq = mkBVNeq(tr, arg1); // if (!compl_diseqs.has(neq)) // compl_diseqs.insert(neq, true); return tr; } PTRef BVLogic::mkBVNeq(const PTRef a1, const PTRef a2) { assert(hasSortBVNUM(a1)); assert(hasSortBVNUM(a2)); vec args; args.push(a1); args.push(a2); return mkBVNot(mkBVEq(args)); } int BVLogic::getBVNUMConst(PTRef tr) const { return atoi(getSymName(tr)); } opensmt-2.5.2/src/logics/BVLogic.h000066400000000000000000000363751445011647600167400ustar00rootroot00000000000000/*******************************************************************\ Module: New Logic for BitVector * Author: Antti Hyvarinen * Author: Sepideh Asadi * Created on: Jan 16, 2017 \*******************************************************************/ #ifndef BVLOGIC_H #define BVLOGIC_H #include "Logic.h" #include "CUFLogic.h" #include "NumberUtils.h" class BVLogic: public CUFLogic { // protected: // Map comm_eqs; // a+b <-> b+a // Map diseq_eqs; // a>b -> a != b // Map diseq_split; // a != b -> (a>b) || (a mod_ineqs; // b > 0 -> 0 <= a % b < b, b < 0 -> b < a % b <= 0 // Map inc_diseqs; // a++ != a (< is not safe for overflows for some compiler semantics) // Map compl_diseqs; // ~a != a // public: // void getCommEqs(vec& out) const { comm_eqs.getKeys(out); } protected: static const char* tk_bv_neg; static const char* tk_bv_eq; static const char* tk_bv_minus; static const char* tk_bv_plus; static const char* tk_bv_times; static const char* tk_bv_div; static const char* tk_bv_sleq; static const char* tk_bv_uleq; static const char* tk_bv_slt; static const char* tk_bv_ult; static const char* tk_bv_sgeq; static const char* tk_bv_ugeq; static const char* tk_bv_sgt; static const char* tk_bv_ugt; static const char* tk_bv_lshift; static const char* tk_bv_arshift; static const char* tk_bv_lrshift; static const char* tk_bv_mod; static const char* tk_bv_bwand; static const char* tk_bv_bwor; static const char* tk_bv_land; static const char* tk_bv_lor; static const char* tk_bv_not; static const char* tk_bv_bwxor; static const char* tk_bv_compl; static const char* tk_bv_coll32; static const char* s_uf_extract_base; static const char* s_sort_bvnum; int bitwidth; SRef sort_BVNUM; PTRef term_BV_ZERO; PTRef term_BV_ONE; SymRef sym_BV_ZERO; // 0 SymRef sym_BV_ONE; // 1 SymRef sym_BV_NEG; // - SymRef sym_BV_MINUS; // - SymRef sym_BV_PLUS; // + SymRef sym_BV_TIMES; // * SymRef sym_BV_DIV; // / SymRef sym_BV_EQ; // == SymRef sym_BV_SLEQ; // s<= SymRef sym_BV_ULEQ; // u<= SymRef sym_BV_SGEQ; // s>= SymRef sym_BV_UGEQ; // u>= SymRef sym_BV_SLT; // s< SymRef sym_BV_ULT; // u< SymRef sym_BV_SGT; // s> SymRef sym_BV_UGT; // u> SymRef sym_BV_BWXOR; // ^ SymRef sym_BV_LSHIFT; // << SymRef sym_BV_LRSHIFT; // l>> SymRef sym_BV_ARSHIFT; // a>> SymRef sym_BV_MOD; // % SymRef sym_BV_BWOR; // | SymRef sym_BV_BWAND; // & SymRef sym_BV_LAND; // && SymRef sym_BV_LOR; // || SymRef sym_BV_NOT; // ! SymRef sym_BV_COMPL; // ~ SymRef sym_BV_COLLATE32; // .coll32 SymRef sym_BV_INC; // ++ SymRef sym_BV_DEC; // -- SymRef sym_BV_NEQ; // != static const int i_default_bitwidth; public: BVLogic(opensmt::Logic_t type, int width = i_default_bitwidth); ~BVLogic(); virtual int getBitWidth() const { return bitwidth; } virtual std::string const getName() const override { return "QF_BV"; } // virtual PTRef insertTerm(SymRef sym, vec& terms, char** msg); PTRef mkBVConst (const int c) { char* num; opensmt::wordToBinary(c, num, getBitWidth()); PTRef tr = Logic::mkConst(sort_BVNUM, num); free(num); return tr; } // Convert the int c to binary PTRef mkBVConst (const char* c) { char* num; opensmt::wordToBinary(opensmt::Integer(c), num, getBitWidth()); PTRef tr = Logic::mkConst(sort_BVNUM, num); free(num); return tr; } // Convert the string c to binary virtual PTRef mkBVNumVar (const char* name) { return mkVar(sort_BVNUM, name); } virtual bool isBuiltinSortSym(SSymRef ssr) const override { return (ssr == sort_store.getSortSym(sort_BVNUM)) || CUFLogic::isBuiltinSortSym(ssr); } virtual bool isBuiltinSort(SRef sr) const override { return (sr == sort_BVNUM) /*|| (sr == sort_BVSTR)*/ || CUFLogic::isBuiltinSort(sr); } virtual bool isBuiltinConstant(SymRef sr) const override { return isBVNUMConst(sr) || CUFLogic::isBuiltinConstant(sr); } // virtual void conjoinExtras(PTRef root, PTRef& root_out) { root_out = root; } bool isBVNUMConst(SymRef sr) const { return isConstant(sr) && hasSortBVNUM(sr); } bool isBVNUMConst(PTRef tr) const { return isBVNUMConst(getPterm(tr).symb()); } bool hasSortBVNUM(const SymRef sr) const { return getSortRef(sr) == sort_BVNUM; } bool hasSortBVNUM(const PTRef tr) const { return hasSortBVNUM(getPterm(tr).symb()); } SRef declareSort_BVNUM(char** msg); SRef getSort_BVNUM() const { return sort_BVNUM; } int getBVNUMConst(PTRef tr) const; bool isBVPlus(SymRef sr) const { return sr == sym_BV_PLUS; } bool isBVPlus(PTRef tr) const { return isBVPlus(getPterm(tr).symb()); } bool isBVMinus(SymRef sr) const { return sr == sym_BV_MINUS; } bool isBVMinus(PTRef tr) const { return isBVMinus(getPterm(tr).symb()); } bool isBVNeg(SymRef sr) const { return sr == sym_BV_NEG; } bool isBVNeg(PTRef tr) const { return isBVNeg(getPterm(tr).symb()); } bool isBVTimes(SymRef sr) const { return sr == sym_BV_TIMES; } bool isBVTimes(PTRef tr) const { return isBVTimes(getPterm(tr).symb()); } bool isBVDiv(SymRef sr) const { return sr == sym_BV_DIV; } bool isBVDiv(PTRef tr) const { return isBVDiv(getPterm(tr).symb()); } bool isBVEq(SymRef sr) const { return isEquality(sr) && (sym_store[sr][0] == sort_BVNUM); } bool isBVEq(PTRef tr) const { return isBVEq(getPterm(tr).symb()); } bool isBVSleq(SymRef sr) const { return sr == sym_BV_SLEQ; } bool isBVSleq(PTRef tr) const { return isBVSleq(getPterm(tr).symb()); } bool isBVUleq(SymRef sr) const { return sr == sym_BV_ULEQ; } bool isBVUleq(PTRef tr) const { return isBVUleq(getPterm(tr).symb()); } bool isBVSlt(SymRef sr) const { return sr == sym_BV_SLT; } bool isBVSlt(PTRef tr) const { return isBVSlt(getPterm(tr).symb()); } bool isBVUlt(SymRef sr) const { return sr == sym_BV_ULT; } bool isBVUlt(PTRef tr) const { return isBVUlt(getPterm(tr).symb()); } bool isBVSgeq(SymRef sr) const { return sr == sym_BV_SGEQ; } bool isBVSgeq(PTRef tr) const { return isBVSgeq(getPterm(tr).symb()); } bool isBVSgt(SymRef sr) const { return sr == sym_BV_SGT; } bool isBVSgt(PTRef tr) const { return isBVSgt(getPterm(tr).symb()); } bool isBVVar(SymRef sr) const { return isVar(sr) && sym_store[sr].rsort() == sort_BVNUM; } bool isBVVar(PTRef tr) const { return isBVVar(getPterm(tr).symb()); } bool isBVZero(SymRef sr) const { return sr == sym_BV_ZERO; } bool isBVZero(PTRef tr) const { return tr == term_BV_ZERO; } bool isBVOne(SymRef sr) const { return sr == sym_BV_ONE; } bool isBVOne(PTRef tr) const { return tr == term_BV_ONE; } bool isBVLshift(SymRef sr) const { return sr == sym_BV_LSHIFT; } bool isBVLshift(PTRef tr) const { return isBVLshift(getPterm(tr).symb()); } bool isBVLRshift(SymRef sr) const { return sr == sym_BV_LRSHIFT; } bool isBVARshift(SymRef sr) const { return sr == sym_BV_ARSHIFT; } bool isBVLRshift(PTRef tr) const { return isBVLRshift(getPterm(tr).symb()); } bool isBVARshift(PTRef tr) const { return isBVARshift(getPterm(tr).symb()); } bool isBVMod(SymRef sr) const { return sr == sym_BV_MOD; } bool isBVMod(PTRef tr) const { return isBVMod(getPterm(tr).symb()); } bool isBVBwAnd(SymRef sr) const { return sr == sym_BV_BWAND; } bool isBVBwAnd(PTRef tr) const { return isBVBwAnd(getPterm(tr).symb()); } bool isBVBwOr(SymRef sr) const { return sr == sym_BV_BWOR; } bool isBVBwOr(PTRef tr) const { return isBVBwOr(getPterm(tr).symb()); } bool isBVInc(SymRef sr) const { return sr == sym_BV_INC; } bool isBVInc(PTRef tr) const { return isBVInc(getPterm(tr).symb()); } bool isBVDec(SymRef sr) const { return sr == sym_BV_DEC; } bool isBVDec(PTRef tr) const { return isBVDec(getPterm(tr).symb()); } bool isBVNeq(SymRef sr) const { return sr == sym_BV_NEQ; } bool isBVNeq(PTRef tr) const { return isBVNeq(getPterm(tr).symb()); } bool isBVLand(SymRef sr) const { return sr == sym_BV_LAND; } bool isBVLand(PTRef tr) const { return isBVLand(getPterm(tr).symb()); } bool isBVLor(SymRef sr) const { return sr == sym_BV_LOR; } bool isBVLor(PTRef tr) const { return isBVLor(getPterm(tr).symb()); } bool isBVNot(SymRef sr) const { return sr == sym_BV_NOT; } bool isBVNot(PTRef tr) const { return isBVNot(getPterm(tr).symb()); } bool isBVBwXor(SymRef sr) const { return sr == sym_BV_BWXOR; } bool isBVBwXor(PTRef tr) const { return isBVBwXor(getPterm(tr).symb()); } bool isBVCompl(SymRef sr) const { return sr == sym_BV_COMPL; } bool isBVCompl(PTRef tr) const { return isBVCompl(getPterm(tr).symb()); } bool isUFEquality(PTRef tr) const override { return !isBVEq(tr) && Logic::isUFEquality(tr); } bool isTheoryEquality(PTRef tr) const override { return isBVEq(tr); } bool isUF(PTRef tr) const override { return !hasSortBVNUM(tr) && Logic::isUF(tr); } PTRef getTerm_BVZero() { return term_BV_ZERO; } PTRef getTerm_BVOne() { return term_BV_ONE; } PTRef mkBVNeg(const vec& args) { assert(args.size() == 1); return mkBVNeg(args[0]); } PTRef mkBVNeg(PTRef); PTRef mkBVMinus(const vec&); PTRef mkBVMinus(const PTRef a1, const PTRef a2) { vec tmp; tmp.push(a1); tmp.push(a2); return mkBVMinus(tmp); } PTRef mkBVPlus(const vec& args) { assert(args.size() == 2); return mkBVPlus(args[0], args[1]); } PTRef mkBVPlus(const PTRef arg1, const PTRef arg2); PTRef mkBVTimes(const vec& args) {assert(args.size() == 2); return mkBVTimes(args[0], args[1]);} PTRef mkBVTimes(const PTRef, const PTRef); PTRef mkBVDiv(const vec& args) {assert(args.size() == 2); return mkBVDiv(args[0], args[1]);} PTRef mkBVDiv(const PTRef nom, const PTRef den); PTRef mkBVSleq(const PTRef arg1, const PTRef arg2); PTRef mkBVSleq(const vec& args) {assert(args.size() == 2); return mkBVSleq(args[0], args[1]);} PTRef mkBVUleq(const PTRef arg1, const PTRef arg2); PTRef mkBVUleq(const vec& args) {assert(args.size() == 2); return mkBVUleq(args[0], args[1]);} PTRef mkBVSlt(const PTRef arg1, const PTRef arg2); PTRef mkBVSlt(const vec& args) {assert(args.size() == 2); return mkBVSlt(args[0], args[1]);} PTRef mkBVUlt(const PTRef arg1, const PTRef arg2); PTRef mkBVUlt(const vec& args) {assert(args.size() == 2); return mkBVUlt(args[0], args[1]);} PTRef mkBVSgeq(const PTRef arg1, const PTRef arg2); PTRef mkBVSgeq(const vec& args) { assert(args.size() == 2); return mkBVSgeq(args[0], args[1]); } PTRef mkBVUgeq(const PTRef arg1, const PTRef arg2); PTRef mkBVUgeq(const vec& args) { assert(args.size() == 2); return mkBVUgeq(args[0], args[1]); } PTRef mkBVSgt(const PTRef arg1, const PTRef arg2); PTRef mkBVSgt(const vec& args) { assert(args.size() == 2); return mkBVSgt(args[0], args[1]); } PTRef mkBVUgt(const PTRef arg1, const PTRef arg2); PTRef mkBVUgt(const vec& args) { assert(args.size() == 2); return mkBVUgt(args[0], args[1]); } PTRef mkBVLshift(const vec& args) {assert(args.size() == 2); return mkBVLshift(args[0], args[1]);} PTRef mkBVLshift (const PTRef, const PTRef); PTRef mkBVLRshift(const vec& args) {assert(args.size() == 2); return mkBVLRshift(args[0], args[1]);} PTRef mkBVLRshift (const PTRef, const PTRef); PTRef mkBVARshift(const vec& args) {assert(args.size() == 2); return mkBVARshift(args[0], args[1]);} PTRef mkBVARshift (const PTRef, const PTRef); PTRef mkBVMod(const vec& args) {assert(args.size() == 2); return mkBVMod(args[0], args[1]);} PTRef mkBVMod (const PTRef, const PTRef); PTRef mkBVBwAnd(const vec& args) {assert(args.size() == 2); return mkBVBwAnd(args[0], args[1]);} PTRef mkBVBwAnd (const PTRef, const PTRef); PTRef mkBVBwOr(const vec& args) {assert(args.size() == 2); return mkBVBwOr(args[0], args[1]);} PTRef mkBVBwOr (const PTRef, const PTRef); /*PTRef mkBVInc(const vec& args) {assert(args.size() == 1); return mkBVInc(args[0]);} PTRef mkBVInc (const PTRef); PTRef mkBVDec(const vec& args) {assert(args.size() == 1); return mkBVDec(args[0]);} PTRef mkBVDec (const PTRef);*/ PTRef mkBVEq (const vec& args) {assert(args.size() == 2); return mkBVEq(args[0], args[1]);} PTRef mkBVEq (const PTRef, const PTRef); virtual PTRef mkEq(const PTRef a1, const PTRef a2) { if (hasSortBVNUM(a1)) assert(false); return CUFLogic::mkEq(a1, a2); } virtual PTRef mkEq(vec&& args) { if (hasSortBVNUM(args[0])) assert(false); return CUFLogic::mkEq(std::move(args)); } PTRef mkBVNeq(const vec& args) {assert(args.size() == 2); return mkBVNeq(args[0], args[1]);} PTRef mkBVNeq (const PTRef, const PTRef); PTRef mkBVLand(const vec& args) {assert(args.size() == 2); return mkBVLand(args[0], args[1]);} PTRef mkBVLand (const PTRef, const PTRef); PTRef mkBVLor(const vec& args) {assert(args.size() == 2); return mkBVLor(args[0], args[1]);} PTRef mkBVLor (const PTRef, const PTRef); PTRef mkBVNot(const vec& args) {assert(args.size() == 1); return mkBVNot(args[0]);} PTRef mkBVNot (const PTRef); PTRef mkBVBwXor(const vec& args) {assert(args.size() == 2); return mkBVBwXor(args[0], args[1]);} PTRef mkBVBwXor (const PTRef, const PTRef); PTRef mkBVCompl(const vec& args) {assert(args.size() == 1); return mkBVCompl(args[0]);} PTRef mkBVCompl (const PTRef); // PTRef mkGlueBtoUF(const vec& bits, PTRef tr); // PTRef mkGlueUFtoB(PTRef tr, const vec& bits); // PTRef mkCollate32(const vec& bits); // PTRef mkExtract(PTRef tr, int i); /* PTRef mkBVSizeof(const vec& args) {assert(args.size() == 1); return mkBVSizeof(args[0]);} PTRef mkBVSizeof (const PTRef); PTRef mkBVAddrof(const vec& args) {assert(args.size() == 1); return mkBVAddrof(args[0]);} PTRef mkBVAddrof (const PTRef); PTRef mkBVPtr(const vec& args) {assert(args.size() == 1); return mkBVPtr(args[0]);} PTRef mkBVPtr (const PTRef); PTRef mkBVCond(const vec& args) {assert(args.size() == 3); return mkBVCond(args[0], args[1], args[2]);} PTRef mkBVCond (const PTRef, const PTRef, const PTRef);*/ }; #endif opensmt-2.5.2/src/logics/CMakeLists.txt000066400000000000000000000023131445011647600200230ustar00rootroot00000000000000add_library(logics OBJECT "") target_sources(logics PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/LogicFactory.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/BVLogic.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/BVLogic.h" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/CUFLogic.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/CUFLogic.h" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/CUFTheory.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/Logic.cc" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/Logic.h" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/LATheory.h" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/ArrayTheory.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/ArrayHelpers.cc" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/ArithLogic.h" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/ArithLogic.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/Theory.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/Theory.h" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/UFLATheory.h" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/UFLATheory.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/UFTheory.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/SubstLoopBreaker.h" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/SubstLoopBreaker.cc" ) install(FILES LogicFactory.h Theory.h Logic.h ArithLogic.h CUFLogic.h BVLogic.h FunctionTools.h DESTINATION ${INSTALL_HEADERS_DIR}) opensmt-2.5.2/src/logics/CUFLogic.cc000066400000000000000000000331751445011647600171770ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2017 Antti Hyvarinen 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. *********************************************************************/ #include "SStore.h" #include "PtStore.h" #include "CUFLogic.h" const char* CUFLogic::tk_cuf_zero = "0"; const char* CUFLogic::tk_cuf_one = "1"; const char* CUFLogic::tk_cuf_neg = "-"; const char* CUFLogic::tk_cuf_minus = "-"; const char* CUFLogic::tk_cuf_plus = "+"; const char* CUFLogic::tk_cuf_times = "*"; const char* CUFLogic::tk_cuf_div = "/"; const char* CUFLogic::tk_cuf_lt = "<"; const char* CUFLogic::tk_cuf_leq = "<="; const char* CUFLogic::tk_cuf_gt = ">"; const char* CUFLogic::tk_cuf_geq = ">="; const char* CUFLogic::tk_cuf_lshift = "<<"; const char* CUFLogic::tk_cuf_lrshift = "l>>"; const char* CUFLogic::tk_cuf_arshift = "a>>"; const char* CUFLogic::tk_cuf_mod = "%"; const char* CUFLogic::tk_cuf_bwand = "&"; const char* CUFLogic::tk_cuf_bwor = "|"; const char* CUFLogic::tk_cuf_inc = "++"; const char* CUFLogic::tk_cuf_dec = "--"; const char* CUFLogic::tk_cuf_neq = "!="; const char* CUFLogic::tk_cuf_land = "&&"; const char* CUFLogic::tk_cuf_lor = "||"; const char* CUFLogic::tk_cuf_not = "!"; const char* CUFLogic::tk_cuf_bwxor = "^"; const char* CUFLogic::tk_cuf_compl = "~"; const char* CUFLogic::tk_cuf_sizeof = "sizeof"; const char* CUFLogic::tk_cuf_addrof = "&"; const char* CUFLogic::tk_cuf_ptr = "*"; const char* CUFLogic::tk_cuf_cond = "?"; const char* CUFLogic::s_sort_cufnum = "CUFNum"; CUFLogic::CUFLogic(opensmt::Logic_t logicType) : Logic(logicType) , sort_CUFNUM(declareUninterpretedSort(s_sort_cufnum)) , term_CUF_ZERO(mkConst(sort_CUFNUM, tk_cuf_zero)) , term_CUF_ONE(mkConst(sort_CUFNUM, tk_cuf_one)) , sym_CUF_ZERO(getSymRef(term_CUF_ZERO)) , sym_CUF_ONE(getSymRef(term_CUF_ONE)) , sym_CUF_NEG(declareFun_NoScoping(tk_cuf_neg, sort_CUFNUM, {sort_CUFNUM})) , sym_CUF_MINUS(declareFun_NoScoping_LeftAssoc(tk_cuf_minus, sort_CUFNUM, {sort_CUFNUM, sort_CUFNUM})) , sym_CUF_PLUS(declareFun_NoScoping_LeftAssoc(tk_cuf_plus, sort_CUFNUM, {sort_CUFNUM, sort_CUFNUM})) , sym_CUF_TIMES(declareFun_NoScoping_LeftAssoc(tk_cuf_times, sort_CUFNUM, {sort_CUFNUM, sort_CUFNUM})) , sym_CUF_DIV(declareFun_NoScoping_LeftAssoc(tk_cuf_div, sort_CUFNUM, {sort_CUFNUM, sort_CUFNUM})) , sym_CUF_MOD(declareFun_NoScoping(tk_cuf_mod, sort_CUFNUM, {sort_CUFNUM, sort_CUFNUM})) , sym_CUF_EQ(sortToEquality[sort_CUFNUM]) , sym_CUF_LEQ(declareFun_NoScoping_Chainable(tk_cuf_leq, sort_BOOL, {sort_CUFNUM, sort_CUFNUM})) , sym_CUF_LT(declareFun_NoScoping_Chainable(tk_cuf_lt, sort_BOOL, {sort_CUFNUM, sort_CUFNUM})) , sym_CUF_GEQ(declareFun_NoScoping_Chainable(tk_cuf_geq, sort_BOOL, {sort_CUFNUM, sort_CUFNUM})) , sym_CUF_GT(declareFun_NoScoping_Chainable(tk_cuf_gt, sort_BOOL, {sort_CUFNUM, sort_CUFNUM})) , sym_CUF_LSHIFT(declareFun_NoScoping_LeftAssoc(tk_cuf_lshift, sort_CUFNUM, {sort_CUFNUM, sort_CUFNUM})) , sym_CUF_LRSHIFT(declareFun_NoScoping_LeftAssoc(tk_cuf_lrshift, sort_CUFNUM, {sort_CUFNUM, sort_CUFNUM})) , sym_CUF_ARSHIFT(declareFun_NoScoping_LeftAssoc(tk_cuf_arshift, sort_CUFNUM, {sort_CUFNUM, sort_CUFNUM})) , sym_CUF_BWAND(declareFun_NoScoping_LeftAssoc(tk_cuf_bwand, sort_CUFNUM, {sort_CUFNUM, sort_CUFNUM})) , sym_CUF_BWOR(declareFun_NoScoping_LeftAssoc(tk_cuf_bwor, sort_CUFNUM, {sort_CUFNUM, sort_CUFNUM})) , sym_CUF_INC(declareFun_NoScoping(tk_cuf_inc, sort_CUFNUM, {sort_CUFNUM, sort_CUFNUM})) , sym_CUF_DEC(declareFun_NoScoping(tk_cuf_dec, sort_CUFNUM, {sort_CUFNUM, sort_CUFNUM})) , sym_CUF_NEQ(declareFun_Commutative_NoScoping_Chainable(tk_equals, sort_BOOL, {sort_CUFNUM, sort_CUFNUM})) , sym_CUF_LAND(declareFun_NoScoping_LeftAssoc(tk_cuf_land, sort_CUFNUM, {sort_CUFNUM, sort_CUFNUM})) , sym_CUF_LOR(declareFun_NoScoping_LeftAssoc(tk_cuf_lor, sort_CUFNUM, {sort_CUFNUM, sort_CUFNUM})) , sym_CUF_BWXOR(declareFun_Commutative_NoScoping_LeftAssoc(tk_cuf_bwxor, sort_CUFNUM, {sort_CUFNUM, sort_CUFNUM})) , sym_CUF_COMPL(declareFun_Commutative_NoScoping_LeftAssoc(tk_cuf_bwxor, sort_CUFNUM, {sort_CUFNUM, sort_CUFNUM})) , sym_CUF_SIZEOF(declareFun_NoScoping(tk_cuf_sizeof, sort_CUFNUM, {sort_CUFNUM})) , sym_CUF_ADDROF(declareFun_NoScoping(tk_cuf_addrof, sort_CUFNUM, {sort_CUFNUM})) , sym_CUF_PTR(declareFun_NoScoping(tk_cuf_addrof, sort_CUFNUM, {sort_CUFNUM})) , sym_CUF_ITE(sortToIte[sort_CUFNUM]) , sym_CUF_DISTINCT(sortToDisequality[sort_CUFNUM]) { } CUFLogic::~CUFLogic() {} PTRef CUFLogic::insertTerm(SymRef sym, vec && terms) { if (isCUFNeg(sym)) return mkCUFNeg(terms[0]); if (isCUFMinus(sym)) return mkCUFMinus(terms); if (isCUFPlus(sym)) return mkCUFPlus(terms); if (isCUFTimes(sym)) return mkCUFTimes(terms); if (isCUFDiv(sym)) return mkCUFDiv(terms); if (isCUFLeq(sym)) return mkCUFLeq(terms); if (isCUFLt(sym)) return mkCUFLt(terms); if (isCUFGeq(sym)) return mkCUFGeq(terms); if (isCUFGt(sym)) return mkCUFGt(terms); if (isCUFMod(sym)) return mkCUFMod(terms); if (isCUFLshift(sym)) return mkCUFLshift(terms); if (isCUFLRshift(sym)) return mkCUFLRshift(terms); if (isCUFARshift(sym)) return mkCUFARshift(terms); if (isCUFBwAnd(sym)) return mkCUFBwAnd(terms); if (isCUFBwOr(sym)) return mkCUFBwOr(terms); if (isCUFNeq(sym)) return mkCUFNeq(terms); if (isCUFBwxor(sym)) return mkCUFBwXor(terms); if (isCUFAddrof(sym)) return mkCUFAddrof(terms); if (isCUFCompl(sym)) return mkCUFCompl(terms); if (isCUFInc(sym)) return mkCUFInc(terms); if (isCUFDec(sym)) return mkCUFDec(terms); if (isCUFLand(sym)) return mkCUFLand(terms); if (isCUFLor(sym)) return mkCUFLor(terms); if (isCUFPtr(sym)) return mkCUFPtr(terms); return Logic::insertTerm(sym, std::move(terms)); } PTRef CUFLogic::mkCUFNeg(PTRef tr) { if (isCUFNeg(tr)) return getPterm(tr)[0]; if (isCUFPlus(tr)) { vec args; assert(getPterm(tr).size() == 2); PTRef arg1 = mkCUFNeg(getPterm(tr)[0]); PTRef arg2 = mkCUFNeg(getPterm(tr)[1]); PTRef tr_n = mkCUFPlus(arg1, arg2); assert(tr_n != PTRef_Undef); return tr_n; } if (isConstant(tr)) { int v = getCUFNUMConst(tr); v = -v; PTRef nterm = mkCUFConst(v); SymRef s = getPterm(nterm).symb(); return mkFun(s, {}); } PTRef mo = mkCUFConst(-1); return mkCUFTimes(mo, tr); } PTRef CUFLogic::mkCUFMinus(const vec& args_in) { vec args; args_in.copyTo(args); if (args.size() == 1) { PTRef ret = mkCUFNeg(args[0]); return ret; } else { assert(args.size() == 2); PTRef mo = mkCUFConst(-1); PTRef fact = mkCUFTimes(mo, args[1]); args[1] = fact; return mkCUFPlus(args[0], args[1]); } } PTRef CUFLogic::mkCUFPlus(const PTRef arg1, const PTRef arg2) { PTRef tr = mkFun(sym_CUF_PLUS, {arg1, arg2}); PTRef tr_comm = mkFun(sym_CUF_PLUS, {arg2, arg1}); PTRef tr_comm_eq = mkEq(tr, tr_comm); if (!comm_eqs.has(tr_comm_eq)) comm_eqs.insert(tr_comm_eq, true); return tr; } PTRef CUFLogic::mkCUFTimes(const PTRef arg1, const PTRef arg2) { PTRef tr = mkFun(sym_CUF_TIMES, {arg1, arg2}); PTRef tr_comm = mkFun(sym_CUF_TIMES, {arg2, arg1}); PTRef tr_comm_eq = mkEq(tr, tr_comm); if (!comm_eqs.has(tr_comm_eq)) comm_eqs.insert(tr_comm_eq, true); return tr; } PTRef CUFLogic::mkCUFDiv(const PTRef arg1, const PTRef arg2) { PTRef tr = mkFun(sym_CUF_DIV, {arg1, arg2}); return tr; } PTRef CUFLogic::mkCUFGeq(const PTRef arg1, const PTRef arg2) { return mkCUFLeq(arg2, arg1); } PTRef CUFLogic::mkCUFLeq(const PTRef arg1, const PTRef arg2) { if (isCUFNUMConst(arg1) && isCUFNUMConst(arg2)) { int c1 = getCUFNUMConst(arg1); int c2 = getCUFNUMConst(arg2); if (c1 <= c2) return getTerm_true(); else return getTerm_false(); } PTRef leq_tr = mkFun(sym_CUF_LEQ, {arg1, arg2}); return mkOr(leq_tr, mkEq(arg1, arg2)); } PTRef CUFLogic::mkCUFGt(const PTRef arg1, const PTRef arg2) { if (isCUFNUMConst(arg1) && isCUFNUMConst(arg2)) { int c1 = getCUFNUMConst(arg1); int c2 = getCUFNUMConst(arg2); if (c1 > c2) return getTerm_true(); else return getTerm_false(); } PTRef tr = mkFun(sym_CUF_GT, {arg1, arg2}); // a>b -> a != b PTRef tr_eq = mkEq(arg1, arg2); PTRef n_tr_eq = mkCUFNot(tr_eq); PTRef tr_impl = mkImpl(n_tr_eq, n_tr_eq); if (!diseq_eqs.has(tr_impl)) diseq_eqs.insert(tr_impl, true); return tr; } PTRef CUFLogic::mkCUFLt(const PTRef arg1, const PTRef arg2) { return mkCUFGt(arg2, arg1); } PTRef CUFLogic::mkCUFLshift(const PTRef arg1, const PTRef arg2) { if (isCUFNUMConst(arg2) && getCUFNUMConst(arg2) == 0) return arg1; return mkFun(sym_CUF_LSHIFT, {arg1, arg2}); } PTRef CUFLogic::mkCUFLRshift(const PTRef arg1, const PTRef arg2) { if (isCUFNUMConst(arg2) && getCUFNUMConst(arg2) == 0) return arg1; return mkFun(sym_CUF_LRSHIFT, {arg1, arg2}); } PTRef CUFLogic::mkCUFARshift(const PTRef arg1, const PTRef arg2) { if (isCUFNUMConst(arg2) && getCUFNUMConst(arg2) == 0) return arg1; return mkFun(sym_CUF_ARSHIFT, {arg1, arg2}); } PTRef CUFLogic::mkCUFMod(const PTRef arg1, const PTRef arg2) { if (isCUFNUMConst(arg2) && getCUFNUMConst(arg2) == 1) return getTerm_CUFZero(); // if b > 0, then 0 <= a % b < b // if b < 0, then b < a % b <= 0 return mkFun(sym_CUF_MOD, {arg1, arg2}); } PTRef CUFLogic::mkCUFBwAnd(const PTRef arg1, const PTRef arg2) { PTRef tr = mkFun(sym_CUF_BWAND, {arg1, arg2}); PTRef tr_comm = mkFun(sym_CUF_BWAND, {arg2, arg1}); PTRef tr_comm_eq = mkEq(tr, tr_comm); if (!comm_eqs.has(tr_comm_eq)) comm_eqs.insert(tr_comm_eq, true); return tr; } PTRef CUFLogic::mkCUFBwOr(const PTRef arg1, const PTRef arg2) { PTRef tr = mkFun(sym_CUF_BWOR, {arg1, arg2}); PTRef tr_comm = mkFun(sym_CUF_BWOR, {arg2, arg1}); PTRef tr_comm_eq = mkEq(tr, tr_comm); if (!comm_eqs.has(tr_comm_eq)) comm_eqs.insert(tr_comm_eq, true); return tr; } PTRef CUFLogic::mkCUFInc(const PTRef arg1) { PTRef tr = mkFun(sym_CUF_INC, {arg1}); PTRef neq = mkCUFNeq(arg1, tr); if (!inc_diseqs.has(neq)) inc_diseqs.insert(neq, true); return tr; } PTRef CUFLogic::mkCUFDec(const PTRef arg1) { PTRef tr = mkFun(sym_CUF_DEC, {arg1}); PTRef neq = mkCUFNeq(arg1, tr); if (!inc_diseqs.has(neq)) inc_diseqs.insert(neq, true); return tr; } PTRef CUFLogic::mkCUFLand(const PTRef arg1, const PTRef arg2) { PTRef tr = mkFun(sym_CUF_LAND, {arg1, arg2}); return tr; } PTRef CUFLogic::mkCUFLor(const PTRef arg1, const PTRef arg2) { PTRef tr = mkFun(sym_CUF_LOR, {arg1, arg2}); return tr; } PTRef CUFLogic::mkCUFNot(const PTRef arg) { return Logic::mkNot(arg); } PTRef CUFLogic::mkCUFBwXor(const PTRef arg1, const PTRef arg2) { PTRef tr = mkFun(sym_CUF_BWXOR, {arg1, arg2}); PTRef tr_comm = mkFun(sym_CUF_BWXOR, {arg2, arg1}); PTRef tr_comm_eq = mkEq(tr, tr_comm); if (!comm_eqs.has(tr_comm_eq)) comm_eqs.insert(tr_comm_eq, true); return tr; } PTRef CUFLogic::mkCUFCompl(const PTRef arg1) { PTRef tr = mkFun(sym_CUF_COMPL, {arg1}); PTRef neq = mkCUFNeq(tr, arg1); if (!compl_diseqs.has(neq)) compl_diseqs.insert(neq, true); return tr; } PTRef CUFLogic::mkCUFSizeof(const PTRef arg) { return mkFun(sym_CUF_SIZEOF, {arg}); } PTRef CUFLogic::mkCUFAddrof(const PTRef arg) { return mkFun(sym_CUF_SIZEOF, {arg}); } PTRef CUFLogic::mkCUFPtr(const PTRef arg) { return mkFun(sym_CUF_PTR, {arg}); } PTRef CUFLogic::mkCUFCond(const PTRef cond, PTRef i_arg, PTRef e_arg) { return mkIte(cond, i_arg, e_arg); } PTRef CUFLogic::mkCUFNeq(const PTRef a1, const PTRef a2) { return Logic::mkNot(Logic::mkEq(a1, a2)); } int CUFLogic::getCUFNUMConst(PTRef tr) const { return atoi(getSymName(tr)); } PTRef CUFLogic::conjoinExtras(PTRef root) { PTRef root_out = root; root_out = mkAnd(root_out, mkAnd(comm_eqs.getKeys())); root_out = mkAnd(root_out, mkAnd(diseq_eqs.getKeys())); root_out = mkAnd(root_out, mkAnd(diseq_split.getKeys())); root_out = mkAnd(root_out, mkAnd(mod_ineqs.getKeys())); root_out = mkAnd(root_out, mkAnd(inc_diseqs.getKeys())); root_out = mkAnd(root_out, mkAnd(compl_diseqs.getKeys())); return root_out; } opensmt-2.5.2/src/logics/CUFLogic.h000066400000000000000000000356511445011647600170420ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2017 Antti Hyvarinen 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. *********************************************************************/ #ifndef CUFLOGIC_H #define CUFLOGIC_H #include "Logic.h" class CUFLogic: public Logic { protected: MapWithKeys comm_eqs; // a+b <-> b+a MapWithKeys diseq_eqs; // a>b -> a != b MapWithKeys diseq_split; // a != b -> (a>b) || (a mod_ineqs; // b > 0 -> 0 <= a % b < b, b < 0 -> b < a % b <= 0 MapWithKeys inc_diseqs; // a++ != a (< is not safe for overflows for some compiler semantics) MapWithKeys compl_diseqs; // ~a != a static const char* tk_cuf_zero; static const char* tk_cuf_one; static const char* tk_cuf_neg; static const char* tk_cuf_minus; static const char* tk_cuf_plus; static const char* tk_cuf_times; static const char* tk_cuf_div; static const char* tk_cuf_leq; static const char* tk_cuf_lt; static const char* tk_cuf_geq; static const char* tk_cuf_gt; static const char* tk_cuf_lshift; static const char* tk_cuf_lrshift; static const char* tk_cuf_arshift; static const char* tk_cuf_mod; static const char* tk_cuf_bwand; static const char* tk_cuf_bwor; static const char* tk_cuf_inc; static const char* tk_cuf_dec; static const char* tk_cuf_neq; static const char* tk_cuf_land; static const char* tk_cuf_lor; static const char* tk_cuf_not; static const char* tk_cuf_bwxor; static const char* tk_cuf_compl; static const char* tk_cuf_sizeof; static const char* tk_cuf_addrof; static const char* tk_cuf_ptr; static const char* tk_cuf_cond; static const char* s_sort_cufnum; SRef sort_CUFNUM; PTRef term_CUF_ZERO; PTRef term_CUF_ONE; SymRef sym_CUF_ZERO; // 0 SymRef sym_CUF_ONE; // 1 SymRef sym_CUF_NEG; // - SymRef sym_CUF_MINUS; // - SymRef sym_CUF_PLUS; // + SymRef sym_CUF_TIMES; // * SymRef sym_CUF_DIV; // / SymRef sym_CUF_MOD; // % SymRef sym_CUF_EQ; // == SymRef sym_CUF_LEQ; // <= SymRef sym_CUF_LT; // < SymRef sym_CUF_GEQ; // >= SymRef sym_CUF_GT; // > SymRef sym_CUF_LSHIFT; // << SymRef sym_CUF_LRSHIFT; // l>> SymRef sym_CUF_ARSHIFT; // a>> SymRef sym_CUF_BWAND; // & SymRef sym_CUF_BWOR; // | SymRef sym_CUF_INC; // ++ SymRef sym_CUF_DEC; // -- SymRef sym_CUF_NEQ; // != SymRef sym_CUF_LAND; // && SymRef sym_CUF_LOR; // || SymRef sym_CUF_BWXOR; // ^ SymRef sym_CUF_COMPL; // ~ SymRef sym_CUF_SIZEOF; // sizeof SymRef sym_CUF_ADDROF; // & SymRef sym_CUF_PTR; // * SymRef sym_CUF_ITE; SymRef sym_CUF_DISTINCT; public: CUFLogic(opensmt::Logic_t logicType); ~CUFLogic(); virtual std::string const getName() const override { return "QF_CUF"; } PTRef insertTerm(SymRef sym, vec && terms) override; using Logic::mkConst; virtual PTRef mkConst (const int c) { return mkCUFConst(c); } PTRef mkCUFConst (const int c) { std::string num = std::to_string(c); PTRef tr = Logic::mkConst(sort_CUFNUM, num.c_str()); return tr; } virtual PTRef mkCUFNumVar(const char* name) { return mkVar(sort_CUFNUM, name); } virtual bool isBuiltinSort(SRef sr) const override { return (sr == sort_CUFNUM) || Logic::isBuiltinSort(sr); } virtual bool isBuiltinSortSym(SSymRef ssr) const override { return (ssr == sort_store.getSortSym(sort_CUFNUM)) || Logic::isBuiltinSortSym(ssr); } virtual bool isBuiltinConstant(SymRef sr) const override { return isCUFNUMConst(sr) || Logic::isBuiltinConstant(sr); } PTRef conjoinExtras(PTRef root) override; bool isCUFNUMConst(SymRef sr) const { return isConstant(sr) && hasSortCUFNUM(sr); } bool isCUFNUMConst(PTRef tr) const { return isCUFNUMConst(getPterm(tr).symb()); } bool hasSortCUFNUM(const SymRef sr) const { return getSortRef(sr) == sort_CUFNUM; } bool hasSortCUFNUM(const PTRef tr) const { return hasSortCUFNUM(getPterm(tr).symb()); } SRef declareSort_CUFNUM(char** msg); SRef getSort_CUFNUM() const { return sort_CUFNUM; } int getCUFNUMConst(PTRef tr) const; bool isCUFPlus(SymRef sr) const { return sr == sym_CUF_PLUS; } bool isCUFPlus(PTRef tr) const { return isCUFPlus(getPterm(tr).symb()); } bool isCUFMinus(SymRef sr) const { return sr == sym_CUF_MINUS; } bool isCUFMinus(PTRef tr) const { return isCUFMinus(getPterm(tr).symb()); } bool isCUFNeg(SymRef sr) const { return sr == sym_CUF_NEG; } bool isCUFNeg(PTRef tr) const { return isCUFNeg(getPterm(tr).symb()); } bool isCUFTimes(SymRef sr) const { return sr == sym_CUF_TIMES; } bool isCUFTimes(PTRef tr) const { return isCUFTimes(getPterm(tr).symb()); } bool isCUFDiv(SymRef sr) const { return sr == sym_CUF_DIV; } bool isCUFDiv(PTRef tr) const { return isCUFDiv(getPterm(tr).symb()); } bool isCUFEq(SymRef sr) const { return isEquality(sr) && (sym_store[sr][0] == sort_CUFNUM); } bool isCUFEq(PTRef tr) const { return isCUFEq(getPterm(tr).symb()); } bool isCUFLeq(SymRef sr) const { return sr == sym_CUF_LEQ; } bool isCUFLeq(PTRef tr) const { return isCUFLeq(getPterm(tr).symb()); } bool isCUFLt(SymRef sr) const { return sr == sym_CUF_LT; } bool isCUFLt(PTRef tr) const { return isCUFLt(getPterm(tr).symb()); } bool isCUFGeq(SymRef sr) const { return sr == sym_CUF_GEQ; } bool isCUFGeq(PTRef tr) const { return isCUFGeq(getPterm(tr).symb()); } bool isCUFGt(SymRef sr) const { return sr == sym_CUF_GT; } bool isCUFGt(PTRef tr) const { return isCUFGt(getPterm(tr).symb()); } bool isCUFVar(SymRef sr) const { return isVar(sr) && sym_store[sr].rsort() == sort_CUFNUM; } bool isCUFVar(PTRef tr) const { return isCUFVar(getPterm(tr).symb()); } bool isCUFZero(SymRef sr) const { return sr == sym_CUF_ZERO; } bool isCUFZero(PTRef tr) const { return tr == term_CUF_ZERO; } bool isCUFOne(SymRef sr) const { return sr == sym_CUF_ONE; } bool isCUFOne(PTRef tr) const { return tr == term_CUF_ONE; } bool isCUFLshift(SymRef sr) const { return sr == sym_CUF_LSHIFT; } bool isCUFLshift(PTRef tr) const { return isCUFLshift(getPterm(tr).symb()); } bool isCUFLRshift(SymRef sr) const { return sr == sym_CUF_LRSHIFT; } bool isCUFLRshift(PTRef tr) const { return isCUFLRshift(getPterm(tr).symb()); } bool isCUFARshift(SymRef sr) const { return sr == sym_CUF_ARSHIFT; } bool isCUFARshift(PTRef tr) const { return isCUFARshift(getPterm(tr).symb()); } bool isCUFMod(SymRef sr) const { return sr == sym_CUF_MOD; } bool isCUFMod(PTRef tr) const { return isCUFMod(getPterm(tr).symb()); } bool isCUFBwAnd(SymRef sr) const { return sr == sym_CUF_BWAND; } bool isCUFBwAnd(PTRef tr) const { return isCUFBwAnd(getPterm(tr).symb()); } bool isCUFBwOr(SymRef sr) const { return sr == sym_CUF_BWOR; } bool isCUFBwOr(PTRef tr) const { return isCUFBwOr(getPterm(tr).symb()); } bool isCUFInc(SymRef sr) const { return sr == sym_CUF_INC; } bool isCUFInc(PTRef tr) const { return isCUFInc(getPterm(tr).symb()); } bool isCUFDec(SymRef sr) const { return sr == sym_CUF_DEC; } bool isCUFDec(PTRef tr) const { return isCUFDec(getPterm(tr).symb()); } bool isCUFNeq(SymRef sr) const { return sr == sym_CUF_NEQ; } bool isCUFNeq(PTRef tr) const { return isCUFNeq(getPterm(tr).symb()); } bool isCUFLand(SymRef sr) const { return sr == sym_CUF_LAND; } bool isCUFLand(PTRef tr) const { return isCUFLand(getPterm(tr).symb()); } bool isCUFLor(SymRef sr) const { return sr == sym_CUF_LOR; } bool isCUFLor(PTRef tr) const { return isCUFLor(getPterm(tr).symb()); } // bool isCUFNot(SymRef sr) const { return sr == sym_CUF_NOT; } // bool isCUFNot(PTRef tr) const { return isCUFNot(getPterm(tr).symb()); } bool isCUFBwxor(SymRef sr) const { return sr == sym_CUF_BWXOR; } bool isCUFBwxor(PTRef tr) const { return isCUFBwxor(getPterm(tr).symb()); } bool isCUFCompl(SymRef sr) const { return sr == sym_CUF_COMPL; } bool isCUFCompl(PTRef tr) const { return isCUFCompl(getPterm(tr).symb()); } bool isCUFSizeof(SymRef sr) const { return sr == sym_CUF_SIZEOF; } bool isCUFSizeof(PTRef tr) const { return isCUFSizeof(getPterm(tr).symb()); } bool isCUFAddrof(SymRef sr) const { return sr == sym_CUF_ADDROF; } bool isCUFAddrof(PTRef tr) const { return isCUFAddrof(getPterm(tr).symb()); } bool isCUFPtr(SymRef sr) const { return sr == sym_CUF_PTR; } bool isCUFPtr(PTRef tr) const { return isCUFPtr(getPterm(tr).symb()); } // bool isCUFCond(SymRef sr) const { return sr == sym_CUF_COND; } // bool isCUFCond(PTRef tr) const { return isCUFCond(getPterm(tr).symb()); } bool isUFEquality(PTRef tr) const override { return !isCUFEq(tr) && Logic::isUFEquality(tr); } bool isTheoryEquality(PTRef tr) const override { return isCUFEq(tr); } bool isUF(PTRef tr) const override { return !hasSortCUFNUM(tr) && Logic::isUF(tr); } PTRef getTerm_CUFZero() { return term_CUF_ZERO; } PTRef getTerm_CUFOne() { return term_CUF_ONE; } PTRef mkCUFNeg(const vec& args) { assert(args.size() == 1); return mkCUFNeg(args[0]); } PTRef mkCUFNeg(PTRef); PTRef mkCUFMinus(const vec&); PTRef mkCUFMinus(const PTRef a1, const PTRef a2) { return mkCUFMinus({a1, a2}); } PTRef mkCUFPlus(const vec& args) { assert(args.size() == 2); return mkCUFPlus(args[0], args[1]); } PTRef mkCUFPlus(const PTRef arg1, const PTRef arg2); PTRef mkCUFTimes(const vec& args) {assert(args.size() == 2); return mkCUFTimes(args[0], args[1]);} PTRef mkCUFTimes(const PTRef, const PTRef); PTRef mkCUFDiv(const vec& args) {assert(args.size() == 2); return mkCUFDiv(args[0], args[1]);} PTRef mkCUFDiv(const PTRef nom, const PTRef den); PTRef mkCUFLeq(const vec& args) {assert(args.size() == 2); return mkCUFLeq(args[0], args[1]);} PTRef mkCUFLeq(const PTRef arg1, const PTRef arg2); PTRef mkCUFGeq(const vec& args) {assert(args.size() == 2); return mkCUFGeq(args[0], args[1]);} PTRef mkCUFGeq(const PTRef arg1, const PTRef arg2); PTRef mkCUFLt(const vec& args) {assert(args.size() == 2); return mkCUFLt(args[0], args[1]);} PTRef mkCUFLt(const PTRef arg1, const PTRef arg2); PTRef mkCUFGt(const vec& args) {assert(args.size() == 2); return mkCUFGt(args[0], args[1]);} PTRef mkCUFGt(const PTRef arg1, const PTRef arg2); PTRef mkCUFLshift(const vec& args) {assert(args.size() == 2); return mkCUFLshift(args[0], args[1]);} PTRef mkCUFLshift (const PTRef, const PTRef); PTRef mkCUFLRshift(const vec& args) {assert(args.size() == 2); return mkCUFLRshift(args[0], args[1]);} PTRef mkCUFLRshift(const PTRef, const PTRef); PTRef mkCUFARshift(const vec& args) {assert(args.size() == 2); return mkCUFARshift(args[0], args[1]);} PTRef mkCUFARshift(const PTRef, const PTRef); PTRef mkCUFMod(const vec& args) {assert(args.size() == 2); return mkCUFMod(args[0], args[1]);} PTRef mkCUFMod (const PTRef, const PTRef); PTRef mkCUFBwAnd(const vec& args) {assert(args.size() == 2); return mkCUFBwAnd(args[0], args[1]);} PTRef mkCUFBwAnd (const PTRef, const PTRef); PTRef mkCUFBwOr(const vec& args) {assert(args.size() == 2); return mkCUFBwOr(args[0], args[1]);} PTRef mkCUFBwOr (const PTRef, const PTRef); PTRef mkCUFInc(const vec& args) {assert(args.size() == 1); return mkCUFInc(args[0]);} PTRef mkCUFInc (const PTRef); PTRef mkCUFDec(const vec& args) {assert(args.size() == 1); return mkCUFDec(args[0]);} PTRef mkCUFDec (const PTRef); PTRef mkCUFNeq(const vec& args) {assert(args.size() == 2); return mkCUFNeq(args[0], args[1]);} PTRef mkCUFNeq (const PTRef, const PTRef); PTRef mkCUFLand(const vec& args) {assert(args.size() == 2); return mkCUFLand(args[0], args[1]);} PTRef mkCUFLand (const PTRef, const PTRef); PTRef mkCUFLor(const vec& args) {assert(args.size() == 2); return mkCUFLor(args[0], args[1]);} PTRef mkCUFLor (const PTRef, const PTRef); PTRef mkCUFNot(const vec& args) {assert(args.size() == 1); return mkCUFNot(args[0]);} PTRef mkCUFNot (const PTRef); PTRef mkCUFBwXor(const vec& args) {assert(args.size() == 2); return mkCUFBwXor(args[0], args[1]);} PTRef mkCUFBwXor (const PTRef, const PTRef); PTRef mkCUFCompl(const vec& args) {assert(args.size() == 1); return mkCUFCompl(args[0]);} PTRef mkCUFCompl (const PTRef); PTRef mkCUFSizeof(const vec& args) {assert(args.size() == 1); return mkCUFSizeof(args[0]);} PTRef mkCUFSizeof (const PTRef); PTRef mkCUFAddrof(const vec& args) {assert(args.size() == 1); return mkCUFAddrof(args[0]);} PTRef mkCUFAddrof (const PTRef); PTRef mkCUFPtr(const vec& args) {assert(args.size() == 1); return mkCUFPtr(args[0]);} PTRef mkCUFPtr (const PTRef); PTRef mkCUFCond(const vec& args) {assert(args.size() == 3); return mkCUFCond(args[0], args[1], args[2]);} PTRef mkCUFCond (const PTRef, const PTRef, const PTRef); }; #endif opensmt-2.5.2/src/logics/CUFTheory.cc000066400000000000000000000014111445011647600174000ustar00rootroot00000000000000#include "Theory.h" const int CUFTheory::i_default_bitwidth = 32; // // Simplify with unit propagation, add the diamond equalities if // present. // // This function adds the newly introduced partial interpretations to // the top frame. // bool CUFTheory::simplify(const vec& formulas, PartitionManager&, int curr) { auto & currentFrame = pfstore[formulas[curr]]; if (this->keepPartitions()) { currentFrame.root = getLogic().mkAnd(currentFrame.formulas); } else { PTRef coll_f = getCollateFunction(formulas, curr); PTRef trans = getLogic().learnEqTransitivity(coll_f); coll_f = getLogic().mkAnd(coll_f, trans); currentFrame.root = applySubstitutionBasedSimplificationIfEnabled(coll_f); } return true; } opensmt-2.5.2/src/logics/FunctionTools.h000066400000000000000000000041741445011647600202510ustar00rootroot00000000000000/* * Copyright (c) 2021-2022, Antti Hyvarinen * * SPDX-License-Identifier: MIT * */ #ifndef FUNCTION_TOOLS_H #define FUNCTION_TOOLS_H #include "PTRef.h" #include "SSort.h" class FunctionSignature { friend class TemplateFunction; SRef ret_sort; std::string name; vec args; private: FunctionSignature() : ret_sort(SRef_Undef) {} public: FunctionSignature(std::string && name, vec && args, SRef ret_sort) : ret_sort(ret_sort) , name(std::move(name)) , args(std::move(args)) {} std::string getName() const { return name; } SRef getRetSort() const { return ret_sort; } const vec& getArgs() const { return args; } }; class TemplateFunction { FunctionSignature signature; PTRef tr_body; inline static std::string_view constexpr template_arg_prefix = ".arg"; inline static std::size_t template_arg_counter = 0; public: static std::string nextFreeArgumentName() { return std::string(template_arg_prefix) + std::to_string(template_arg_counter++); } TemplateFunction(const std::string & name, const vec& args_, SRef ret_sort, PTRef tr_body) : tr_body(tr_body) { args_.copyTo(signature.args); signature.name = name; signature.ret_sort = ret_sort; } TemplateFunction(FunctionSignature&& signature, PTRef body) : signature(std::move(signature)), tr_body(body) {} TemplateFunction() : tr_body(PTRef_Undef) {} TemplateFunction(const TemplateFunction& other) : tr_body(other.tr_body) { signature.ret_sort = other.getRetSort(); signature.name = other.getName(); other.getArgs().copyTo(signature.args); } TemplateFunction(TemplateFunction && other) = default; TemplateFunction& operator= (TemplateFunction &&) = default; std::string getName() const { return signature.getName(); } SRef getRetSort() const { return signature.getRetSort(); } PTRef getBody() const { return tr_body; } const vec& getArgs() const { return signature.getArgs(); } void updateBody(PTRef new_body) { tr_body = new_body; } }; #endif // FUNCTION_TOOLS_Hopensmt-2.5.2/src/logics/LATheory.h000066400000000000000000000052731445011647600171330ustar00rootroot00000000000000// // Created by Antti on 10.03.21. // #ifndef OPENSMT_LATHEORY_H #define OPENSMT_LATHEORY_H #include "Theory.h" #include "ArithmeticEqualityRewriter.h" #include "DistinctRewriter.h" #include "DivModRewriter.h" template class LATheory : public Theory { protected: LinAlgLogic& lalogic; LinAlgTHandler latshandler; std::unique_ptr> notOkToPartition; public: LATheory(SMTConfig & c, LinAlgLogic & logic) : Theory(c) , lalogic(logic) , latshandler(c, lalogic) { } ~LATheory() {}; virtual LinAlgLogic& getLogic() override { return lalogic; } virtual const LinAlgLogic& getLogic() const override { return lalogic; } virtual LinAlgTHandler& getTSolverHandler() override { return latshandler; } virtual bool simplify(const vec&, PartitionManager& pmanager, int) override; // Theory specific simplifications virtual bool okToPartition(PTRef tr) const override { return !notOkToPartition->has(tr); } }; namespace { template PTRef rewriteDivMod(TLogic &, PTRef fla) { return fla; } template<> PTRef rewriteDivMod(ArithLogic & logic, PTRef fla) { // Real logic cannot have div and mod return not logic.hasIntegers() ? fla : DivModRewriter(logic).rewrite(fla); } } // // Unit propagate with simplifications and split equalities into // inequalities. If partitions cannot mix, only do the splitting to // inequalities. // template bool LATheory::simplify(const vec& formulas, PartitionManager& pmanager, int curr) { auto & currentFrame = pfstore[formulas[curr]]; ArithmeticEqualityRewriter equalityRewriter(lalogic); if (this->keepPartitions()) { vec & flas = currentFrame.formulas; for (PTRef & fla : flas) { PTRef old = fla; fla = rewriteDistincts(getLogic(), fla); fla = rewriteDivMod(lalogic, fla); fla = equalityRewriter.rewrite(fla); pmanager.transferPartitionMembership(old, fla); } currentFrame.root = getLogic().mkAnd(flas); } else { PTRef coll_f = getCollateFunction(formulas, curr); PTRef finalFla = applySubstitutionBasedSimplificationIfEnabled(coll_f); finalFla = rewriteDistincts(getLogic(), finalFla); finalFla = rewriteDivMod(lalogic, finalFla); currentFrame.root = equalityRewriter.rewrite(finalFla); } notOkToPartition = equalityRewriter.getAndClearNotOkToPartition(); return true; } #endif //OPENSMT_LATHEORY_H opensmt-2.5.2/src/logics/Logic.cc000066400000000000000000001625261445011647600166440ustar00rootroot00000000000000/* * Copyright (c) 2012-2022, Antti Hyvarinen * Copyright (c) 2018-2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #include "Logic.h" #include "SStore.h" #include "PtStore.h" #include "SubstLoopBreaker.h" #include "OsmtApiException.h" #include "OsmtInternalException.h" #include "Substitutor.h" #include "smt2tokens.h" #include "IteHandler.h" #include #include #include #include #include using namespace std; /*********************************************************** * Class defining logic ***********************************************************/ const char* Logic::e_argnum_mismatch = "incorrect number of arguments"; const char* Logic::e_bad_constant = "incorrect constant for logic"; const char* Logic::tk_val_uf_default = "UFDefault"; const char* Logic::tk_val_bool_default = "true"; const char* Logic::tk_true = "true"; const char* Logic::tk_false = "false"; const char* Logic::tk_not = "not"; const char* Logic::tk_uf_not = ".uf-not"; const char* Logic::tk_equals = "="; const char* Logic::tk_implies = "=>"; const char* Logic::tk_and = "and"; const char* Logic::tk_or = "or"; const char* Logic::tk_xor = "xor"; const char* Logic::tk_distinct = "distinct"; const char* Logic::tk_ite = "ite"; const char* Logic::tk_indexed = "_"; const char* Logic::s_sort_bool = "Bool"; const char* Logic::s_framev_prefix = ".frame"; const char* Logic::s_abstract_value_prefix = "@"; // The constructor initiates the base logic (Boolean) Logic::Logic(opensmt::Logic_t _logicType) : logicType(_logicType) , distinctClassCount(0) , sort_store() , term_store(sym_store) , sym_IndexedSort(sort_store.newSortSymbol(SortSymbol(tk_indexed, 2, SortSymbol::INTERNAL))) , sort_BOOL(sort_store.getOrCreateSort(sort_store.newSortSymbol(SortSymbol(s_sort_bool, 0, SortSymbol::INTERNAL)), {}).first) , term_TRUE(mkConst(getSort_bool(), tk_true)) , term_FALSE(mkConst(getSort_bool(), tk_false)) , sym_TRUE(getSymRef(term_TRUE)) , sym_FALSE(getSymRef(term_FALSE)) , sym_AND(declareFun_Commutative_NoScoping_LeftAssoc(tk_and, sort_BOOL, {sort_BOOL, sort_BOOL})) , sym_OR(declareFun_Commutative_NoScoping_LeftAssoc(tk_or, sort_BOOL, {sort_BOOL, sort_BOOL})) , sym_XOR(declareFun_Commutative_NoScoping_LeftAssoc(tk_xor, sort_BOOL, {sort_BOOL, sort_BOOL})) , sym_NOT(declareFun_NoScoping(tk_not, sort_BOOL, {sort_BOOL})) , sym_UF_NOT(declareFun_NoScoping(tk_uf_not, sort_BOOL, {sort_BOOL})) , sym_EQ(declareFun_Commutative_NoScoping_Chainable(tk_equals, sort_BOOL, {sort_BOOL, sort_BOOL})) , sym_IMPLIES(declareFun_NoScoping(tk_implies, sort_BOOL, {sort_BOOL, sort_BOOL})) , sym_DISTINCT(declareFun_Commutative_NoScoping_Pairwise(tk_distinct, sort_BOOL, {sort_BOOL, sort_BOOL})) , sym_ITE(declareFun_NoScoping(tk_ite, sort_BOOL, {sort_BOOL, sort_BOOL, sort_BOOL})) { equalities.insert(sym_EQ, true); disequalities.insert(sym_DISTINCT, true); ites.insert(sym_ITE, true); sortToEquality.insert(sort_BOOL, sym_EQ); sortToDisequality.insert(sort_BOOL, sym_DISTINCT); sortToIte.insert(sort_BOOL, sym_ITE); sym_ArraySort = sort_store.newSortSymbol(SortSymbol("Array", 2, SortSymbol::INTERNAL)); } Logic::~Logic() = default; bool Logic::isBuiltinFunction(const SymRef sr) const { if (sr == sym_TRUE || sr == sym_FALSE || sr == sym_AND || sr == sym_OR || sr == sym_XOR || sr == sym_NOT || sr == sym_EQ || sr == sym_IMPLIES || sr == sym_DISTINCT || sr == sym_ITE) return true; if (isEquality(sr) || isDisequality(sr)) return true; return false; } bool Logic::isReservedWord(std::string const & name) const { return osmttokens::tokenNames.find(name) != osmttokens::tokenNames.end(); } // // Escape the symbol name if it contains a prohibited character from the // list defined by the quotable[] table below // bool Logic::hasQuotableChars(std::string const & name) const { // Entry is 1 if the corresponding ascii character requires quoting const bool quotable[256] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, // , ", #, $, ' 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, // (, ), <,> 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, // :, ; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, // [, \, ], ` 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, // {, } 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; if (name.front() == '|' and name.back() == '|') return false; // Already quoted for (auto c : name) { if (quotable[(int)c]) return true; } return false; } // If the symbol corresponding to the one specified in the arguments would be ambiguous, i.e., either not known by // the user or there is a homonymous symbol with the same return type that is not a constant fixed by the language syntax, // specify the return sort. std::string Logic::disambiguateName(std::string const & protectedName, SRef sortRef, bool isNullary, bool isInterpreted) const { assert(not protectedName.empty()); if (not isNullary or isInterpreted) { return protectedName; } auto isQuoted = [](std::string const &s) { return s.size() > 3 and *s.begin() == '|' and *(s.end()-1) == '|'; }; auto name = isQuoted(protectedName) ? std::string_view(protectedName.data()+1, protectedName.size()-2) : std::string_view(protectedName); if (not isKnownToUser(name) or isAmbiguousUninterpretedNullarySymbolName(name)) { return "(as " + std::string(protectedName) + " " + printSort(sortRef) + ')'; } else { return protectedName; } } // // Quote the name if it contains illegal characters // std::string Logic::protectName(std::string const & name, bool isInterpreted) const { assert(not name.empty()); if (not isInterpreted and (hasQuotableChars(name) or std::isdigit(name[0]) or isReservedWord(name))) { return '|' + name + '|'; } return name; } // Return a string corresponding to the SMT lib representation of the symbol, with disambiguation and name protection std::string Logic::printSym(SymRef sr) const { Symbol const & symbol = getSym(sr); bool isInterpreted = symbol.isInterpreted(); std::string protectedName = protectName(getSymName(sr), isInterpreted); return disambiguateName(std::move(protectedName), getSortRef(sr), symbol.nargs() == 0, isInterpreted); } std::string Logic::pp(PTRef tr) const { const Pterm &t = getPterm(tr); SymRef sr = t.symb(); std::string name_escaped = printSym(sr); if (t.size() == 0) { return name_escaped; } assert(t.size() > 0); std::stringstream ss; ss << '(' << name_escaped << ' '; for (int i = 0; i < t.size(); i++) { const std::string arg = pp(t[i]); ss << arg; if (i < t.size()-1) { ss << ' '; } } ss << ')'; #ifdef PARTITION_PRETTYPRINT ss << " [" << getIPartitions(tr) << ']'; #endif return ss.str(); } std::string Logic::printTerm_(PTRef tr, bool ext, bool safe) const { std::stringstream ss; const Pterm& t = getPterm(tr); SymRef sr = t.symb(); std::string name_escaped = printSym(sr); if (t.size() == 0) { std::string ext_string = ext ? " <" + std::to_string(tr.x) + ">" : ""; ss << name_escaped << (ext ? ext_string : ""); return ss.str(); } else { assert(t.size() > 0); ss << "(" << name_escaped; for (auto arg : t) { ss << " " << printTerm_(arg, ext, safe); } ss << ")" << (ext ? " <" + std::to_string(tr.x) + ">" : ""); } return ss.str(); } bool Logic::isTheoryTerm(PTRef ptr) const { const Pterm& p = term_store[ptr]; SymRef sr = p.symb(); if ((sr == sym_EQ) && not appearsInUF(ptr)) { assert(p.nargs() == 2); return false; } else if (hasSortBool(sr) && appearsInUF(ptr)) { return true; } else return isTheorySymbol(sr); } bool Logic::isTheorySymbol(SymRef tr) const { // True and False are special cases, we count them as theory symbols if (tr == sym_TRUE || tr == sym_FALSE) return true; const Symbol& t = sym_store[tr]; // Boolean var if (t.rsort() == sort_BOOL && t.nargs() == 0) return false; // Standard Boolean operators return !(isBooleanOperator(tr)); } void Logic::unsetAppearsInUF(PTRef tr) { tr = isNot(tr) ? getPterm(tr)[0]: tr; uint32_t id = Idx(getPterm(tr).getId()); appears_in_uf[id] = UFAppearanceStatus::removed; } void Logic::setAppearsInUF(PTRef tr) { assert(not isNot(tr)); int id = static_cast(Idx(getPterm(tr).getId())); if (appears_in_uf.size() <= id || appears_in_uf[id] == UFAppearanceStatus::unseen) { propFormulasAppearingInUF.push(tr); } while (id >= appears_in_uf.size()) { appears_in_uf.push(UFAppearanceStatus::unseen); } appears_in_uf[id] = UFAppearanceStatus::appears; } bool Logic::appearsInUF(PTRef tr) const { tr = isNot(tr) ? getPterm(tr)[0] : tr; uint32_t id = Idx(getPterm(tr).getId()); if (id < static_cast(appears_in_uf.size())) return appears_in_uf[id] == UFAppearanceStatus::appears; else return false; } /** * Return all nested Boolean roots. A PTRef tr is a nested Boolean root if it is an argument of a term f * where f is not a Boolean operator and tr has a Boolean return sort. * @param root * @return */ vec Logic::getNestedBoolRoots(PTRef root) const { vec nestedBoolRoots; vec queue; std::unordered_set processed; queue.push(root); while (queue.size() != 0) { PTRef tr = queue.last(); queue.pop(); if (processed.find(tr) != processed.end()) { continue; } // already processed const Pterm& t = getPterm(tr); for (int i = 0; i < t.size(); i++) { queue.push(t[i]); if (!isBooleanOperator(tr) && hasSortBool(t[i])) { nestedBoolRoots.push(t[i]); } } processed.insert(tr); } return nestedBoolRoots; } bool Logic::hasSortSymbol(const SortSymbol & symbol) { SSymRef unused; return sort_store.peek(symbol, unused); } bool Logic::peekSortSymbol(SortSymbol const & symbol, SSymRef & out) const { return sort_store.peek(symbol, out); } SSymRef Logic::declareSortSymbol(SortSymbol symbol) { SSymRef res; if (sort_store.peek(symbol, res)) { return res; } return sort_store.newSortSymbol(std::move(symbol)); } SRef Logic::getSort(SSymRef symbolRef, vec && args) { auto [sr,created] = sort_store.getOrCreateSort(symbolRef, std::move(args)); if (created) { instantiateFunctions(sr); if (not isInternalSort(sr)) { newUninterpretedSortHandler(sr); } else if (isArraySort(sr)) { instantiateArrayFunctions(sr); } } return sr; } void Logic::newUninterpretedSortHandler(SRef sref) { std::stringstream ss; ss << Logic::s_abstract_value_prefix << 'd' << sort_store.numSorts(); defaultValueForSort.insert(sref, mkConst(sref, ss.str().c_str())); ufsorts.insert(sref, true); } bool Logic::isInternalSort(SRef sref) const { Sort const & sort = sort_store[sref]; SSymRef sortSymbol = sort.getSymRef(); return sort_store[sortSymbol].isInternal(); } SRef Logic::declareUninterpretedSort(const std::string & name) { SSymRef sortSymbol = declareSortSymbol(SortSymbol(name, 0)); return getSort(sortSymbol, {}); } PTRef Logic::resolveTerm(const char* s, vec&& args, SRef sortRef, SymbolMatcher symbolMatcher) { SymRef sref = term_store.lookupSymbol(s, args, symbolMatcher, sortRef); if (sref == SymRef_Undef) { std::string argSortsString; for (int i = 0; i < args.size(); i++) { PTRef tr = args[i]; argSortsString += printSort(getSortRef(tr)) + (i == args.size() - 1 ? "" : " "); } throw OsmtApiException("Unknown symbol `" + std::string(s) + ' ' + argSortsString + (sortRef != SRef_Undef ? "/ " + printSort(sortRef) : "") + "'"); } assert(sref != SymRef_Undef); PTRef rval = insertTerm(sref, std::move(args)); if (rval == PTRef_Undef) throw OsmtApiException("Error in resolveTerm\n"); return rval; } const char* Logic::getDefaultValue(const PTRef tr) const { if (hasSortBool(tr)) return tk_val_bool_default; else return tk_val_uf_default; } PTRef Logic::getDefaultValuePTRef(const SRef sref) const { if (sref == sort_BOOL) { return term_TRUE; } else { return defaultValueForSort[sref]; } } PTRef Logic::mkIte(vec&& args) { if (!hasSortBool(args[0])) return PTRef_Undef; if (args.size() != 3) throw OsmtApiException("ITE needs to have 3 arguments"); assert(args.size() == 3); if (isTrue(args[0])) return args[1]; if (isFalse(args[0])) return args[2]; if (args[1] == args[2]) return args[1]; SRef sr = getSortRef(args[1]); if (sr != getSortRef(args[2])) { throw OsmtApiException("ITE arguments need to have same return sorts"); } assert(sortToIte.has(sr)); SymRef iteSym = sortToIte[sr]; return mkFun(iteSym, std::move(args)); } // Check if arguments contain trues or a false and return the simplified // term PTRef Logic::mkAnd(vec&& args) { if (args.size() == 0) { return getTerm_true(); } // Remove duplicates vec tmp_args; tmp_args.capacity(args.size()); for (int i = 0; i < args.size(); i++) { if (!hasSortBool(args[i])) { return PTRef_Undef; } if (isNot(args[i])) { tmp_args.push(PtAsgn(getPterm(args[i])[0], l_False)); } else { tmp_args.push(PtAsgn(args[i], l_True)); } } std::sort(tmp_args.begin(), tmp_args.end(), LessThan_PtAsgn()); int i, j; PtAsgn p = PtAsgn_Undef; for (i = 0, j = 0; i < tmp_args.size(); i++) { if (isFalse(tmp_args[i].tr)) { assert(tmp_args[i].sgn == l_True); return getTerm_false(); } else if (isTrue(tmp_args[i].tr)) { // skip assert(tmp_args[i].sgn == l_True); } else if (p == tmp_args[i]) { // skip } else if (p.tr == tmp_args[i].tr && p.sgn != tmp_args[i].sgn) { return getTerm_false(); } else { tmp_args[j++] = p = tmp_args[i]; } } tmp_args.shrink(i - j); if (tmp_args.size() == 0) { return getTerm_true(); } else if (tmp_args.size() == 1) { return tmp_args[0].sgn == l_True ? tmp_args[0].tr : mkNot(tmp_args[0].tr); } args.clear(); args.capacity(tmp_args.size()); for (PtAsgn tmp_arg : tmp_args) { args.push(tmp_arg.sgn == l_True ? tmp_arg.tr : mkNot(tmp_arg.tr)); } return mkFun(getSym_and(), std::move(args)); } PTRef Logic::mkOr(vec && args) { if (args.size() == 0) { return getTerm_false(); } // Remove duplicates vec tmp_args; tmp_args.capacity(args.size()); for (int i = 0; i < args.size(); i++) { if (!hasSortBool(args[i])) { return PTRef_Undef; } if (isNot(args[i])) { tmp_args.push(PtAsgn(getPterm(args[i])[0], l_False)); } else { tmp_args.push(PtAsgn(args[i], l_True)); } } std::sort(tmp_args.begin(), tmp_args.end(), LessThan_PtAsgn()); int i, j; PtAsgn p = PtAsgn_Undef; for (i = 0, j = 0; i < tmp_args.size(); i++) { if (isTrue(tmp_args[i].tr)) { assert(tmp_args[i].sgn == l_True); return getTerm_true(); } else if (isFalse(tmp_args[i].tr)) { // skip assert(tmp_args[i].sgn == l_True); } else if (p == tmp_args[i]) { // skip } else if (p.tr == tmp_args[i].tr && p.sgn != tmp_args[i].sgn) { return getTerm_true(); } else { tmp_args[j++] = p = tmp_args[i]; } } tmp_args.shrink(i - j); if (tmp_args.size() == 0) { return getTerm_false(); } else if (tmp_args.size() == 1) { return tmp_args[0].sgn == l_True ? tmp_args[0].tr : mkNot(tmp_args[0].tr); } args.clear(); args.capacity(tmp_args.size()); for (PtAsgn tmp_arg : tmp_args) { args.push(tmp_arg.sgn == l_True ? tmp_arg.tr : mkNot(tmp_arg.tr)); } return mkFun(getSym_or(), std::move(args)); } PTRef Logic::mkXor(vec&& args) { PTRef tr = PTRef_Undef; for (int i = 0; i < args.size(); i++) if (!hasSortBool(args[i])) return PTRef_Undef; if (args.size() != 2) return PTRef_Undef; else if (args[0] == args[1]) return getTerm_false(); else if (args[0] == mkNot(args[1])) return getTerm_true(); else if (args[0] == getTerm_true() || args[1] == getTerm_true()) return (args[0] == getTerm_true() ? mkNot(args[1]) : mkNot(args[0])); else if (args[0] == getTerm_false() || args[1] == getTerm_false()) return (args[0] == getTerm_false() ? args[1] : args[0]); sort(args, std::greater{}); tr = mkFun(getSym_xor(), std::move(args)); if(tr == PTRef_Undef) { printf("Error in mkXor"); assert(0); } return tr; } PTRef Logic::mkImpl(vec && args) { for (int i = 0; i < args.size(); i++) if (!hasSortBool(args[i])) return PTRef_Undef; assert(args.size() == 2); PTRef tr = PTRef_Undef; if (isFalse(args[0])) tr = getTerm_true(); else if (isTrue(args[1])) tr = getTerm_true(); else if (isTrue(args[0]) && isFalse(args[1])) tr = getTerm_false(); else { args[0] = mkNot(args[0]); tr = mkOr(std::move(args)); } if (tr == PTRef_Undef) { printf("Error in mkImpl"); assert(0); } return tr; } PTRef Logic::mkBinaryEq(PTRef lhs, PTRef rhs) { assert(getSortRef(lhs) == getSortRef(rhs)); if (lhs == rhs) return getTerm_true(); if (isConstant(lhs) && isConstant(rhs)) return getTerm_false(); SRef sref = getSortRef(lhs); // Simplify more here now that the equals type is known if (sref == getSort_bool()) { if (lhs == mkNot(rhs)) return getTerm_false(); if (lhs == getTerm_true() || rhs == getTerm_true()) return lhs == getTerm_true() ? rhs : lhs; if (lhs == getTerm_false() || rhs == getTerm_false()) return lhs == getTerm_false() ? mkNot(rhs) : mkNot(lhs); } vec args {lhs, rhs}; assert(sortToEquality.has(sref)); SymRef eq_sym = sortToEquality[sref]; return mkFun(eq_sym, std::move(args)); } PTRef Logic::mkEq(vec&& args) { if (args.size() < 2) { return PTRef_Undef; } if (args.size() > 2) { // split to chain of equalities with 2 arguments vec binaryEqualities; for (int i = 0; i < args.size() - 1; ++i) { binaryEqualities.push(mkBinaryEq(args[i], args[i + 1])); } return mkAnd(std::move(binaryEqualities)); } assert(args.size() == 2); return mkBinaryEq(args[0], args[1]); } // Given args = {a_1, ..., a_n}, distinct(args) holds iff // for all a_i, a_j \in args s.t. i != j: a_i != a_j // General distinctions are represented as separate terms until the distinction classes have been used up. // After this, they are written explicitly as the O(n^2) expansion. PTRef Logic::mkDistinct(vec&& args) { if (args.size() == 0) return getTerm_true(); if (args.size() == 1) return getTerm_true(); if (args.size() == 2) return mkNot(mkEq(std::move(args))); // The boolean distinctness over > 2 args is false if (hasSortBool(args[0])) { assert(args.size() > 2); return getTerm_false(); } termSort(args); for (int i = 1, j = 0; i < args.size(); i++, j++) { if (args[j] == args[i]) { return getTerm_false(); } } // Here we know that no two terms are the same if (std::all_of(args.begin(), args.end(), [this](PTRef arg) { return this->isConstant(arg); })) { return getTerm_true(); } SymRef diseq_sym = term_store.lookupSymbol(tk_distinct, args); assert(!isBooleanOperator(diseq_sym)); PTLKey key; key.sym = diseq_sym; args.moveTo(key.args); if (term_store.hasCplxKey(key)) { return term_store.getFromCplxMap(key); } else { if (distinctClassCount < maxDistinctClasses) { PTRef res = term_store.newTerm(diseq_sym, key.args); term_store.addToCplxMap(std::move(key), res); distinctClassCount++; return res; } else { vec distinct_terms; for (int i = 0; i < key.args.size(); i++) { for (int j = i + 1; j < key.args.size(); j++) { distinct_terms.push(mkDistinct({key.args[i], key.args[j]})); } } return mkAnd(std::move(distinct_terms)); } } } PTRef Logic::mkNot(vec&& args) { assert(args.size() == 1); return mkNot(args[0]); } PTRef Logic::mkNot(PTRef arg) { PTRef tr = PTRef_Undef; if (!hasSortBool(arg)) return PTRef_Undef; if (isNot(arg)) tr = getPterm(arg)[0]; else if (isTrue(arg)) return getTerm_false(); else if (isFalse(arg)) return getTerm_true(); else { tr = mkFun(getSym_not(), {arg}); } if(tr == PTRef_Undef) { printf("Error in mkNot"); assert(0); } return tr; } PTRef Logic::mkConst(const char* name) { //assert(0); //return PTRef_Undef; assert(strlen(name) > 0); return resolveTerm(name, {}); } PTRef Logic::mkVar(SRef s, const char* name, bool isInterpreted) { SymRef sr = sym_store.newSymb(name, s, {}, isInterpreted ? SymConf::Interpreted : SymConf::Default); assert(sr != SymRef_Undef); if (sr == SymRef_Undef) { std::cerr << "Unexpected situation in Logic::mkVar for " << name << std::endl; assert(symNameToRef(name).size() == 1); sr = symNameToRef(name)[0]; } PTRef ptr = mkFun(sr, {}); assert (ptr != PTRef_Undef); return ptr; } PTRef Logic::mkUniqueAbstractValue(SRef s) { std::string uniqueName = s_abstract_value_prefix + std::to_string(abstractValueCount++); return mkVar(s, uniqueName.c_str()); } PTRef Logic::mkConst(const SRef s, const char* name) { assert(strlen(name) != 0); PTRef ptr = PTRef_Undef; if (s == sort_BOOL) { if ((strcmp(name, tk_true) != 0) && (strcmp(name, tk_false) != 0)) { char *msg = (char*)malloc(strlen(e_bad_constant)+1); strcpy(msg, e_bad_constant); ptr = PTRef_Undef; } ptr = mkVar(s, name); } else { ptr = mkVar(s, name); } markConstant(ptr); return ptr; } void Logic::markConstant(PTRef ptr) { SymId id = sym_store[getPterm(ptr).symb()].getId(); markConstant(id); } void Logic::markConstant(SymId id) { // Code to allow efficient constant detection. while (id >= static_cast(constants.size())) constants.push(false); constants[id] = true; } PTRef Logic::mkUninterpFun(SymRef f, vec && args) { if (f == SymRef_Undef) { return PTRef_Undef; } if (isInterpreted(f)) { std::string msg = "Error in Logic: mkUninterpFun called with interpreted symbol " + printSym(f); throw OsmtApiException(msg); } PTRef tr = mkFun(f, std::move(args)); return tr; } PTRef Logic::mkBoolVar(const char* name) { SymRef sr = declareFun(name, sort_BOOL, {}); assert(sr != SymRef_Undef); return mkFun(sr, {}); } void Logic::instantiateFunctions(SRef sr) { // Equality SymRef tr = declareFun_Commutative_NoScoping_Chainable(tk_equals, sort_BOOL, {sr, sr}); assert(tr != SymRef_Undef); equalities.insert(tr, true); sortToEquality.insert(sr, tr); // distinct tr = declareFun_Commutative_NoScoping_Pairwise(tk_distinct, sort_BOOL, {sr, sr}); assert(tr != SymRef_Undef); disequalities.insert(tr, true); sortToDisequality.insert(sr, tr); // ite tr = declareFun_NoScoping(tk_ite, sr, {sort_BOOL, sr, sr}); assert(tr != SymRef_Undef); ites.insert(tr, true); sortToIte.insert(sr, tr); } void Logic::instantiateArrayFunctions(SRef arraySRef) { assert(arraySRef != SRef_Undef and isArraySort(arraySRef)); Sort const & sort = sort_store[arraySRef]; assert(sort.getSize() == 2); SRef indexSRef = sort[0]; SRef elementSRef = sort[1]; SymRef selectRef = declareFun_NoScoping("select", elementSRef, {arraySRef, indexSRef}); selects.insert(selectRef, true); sortToSelect.insert(arraySRef, selectRef); SymRef storeRef = declareFun_NoScoping("store", arraySRef, {arraySRef, indexSRef, elementSRef}); stores.insert(storeRef, true); sortToStore.insert(arraySRef, storeRef); } PTRef Logic::mkStore(vec && args) { assert(args.size() == 3); SRef arraySort = sym_store[getPterm(args[0]).symb()].rsort(); return mkFun(sortToStore[arraySort], std::move(args)); } PTRef Logic::mkSelect(vec && args) { assert(args.size() == 2); SRef arraySort = sym_store[getPterm(args[0]).symb()].rsort(); return mkFun(sortToSelect[arraySort], std::move(args)); } SymRef Logic::declareFun(std::string const & fname, SRef rsort, vec const & args, SymbolConfig const & symbolConfig) { assert(rsort != SRef_Undef); assert(std::find(args.begin(), args.end(), SRef_Undef) == args.end()); SymRef sr = sym_store.newSymb(fname.c_str(), rsort, args, symbolConfig); return sr; } PTRef Logic::insertTerm(SymRef sym, vec&& terms) { if (sym == getSym_and()) return mkAnd(std::move(terms)); if (sym == getSym_or()) return mkOr(std::move(terms)); if (sym == getSym_xor()) return mkXor(std::move(terms)); if (sym == getSym_not()) return mkNot(std::move(terms)); if (isEquality(sym)) return mkEq(std::move(terms)); if (isDisequality(sym)) return mkDistinct(std::move(terms)); if (isIte(sym)) return mkIte(std::move(terms)); if (sym == getSym_implies()) return mkImpl(std::move(terms)); if (sym == getSym_true()) return getTerm_true(); if (sym == getSym_false()) return getTerm_false(); if (isVar(sym)) { assert(terms.size() == 0); return mkFun(sym, std::move(terms)); } if (hasArrays()) { if (isArrayStore(sym)) return mkStore(std::move(terms)); if (isArraySelect(sym)) return mkSelect(std::move(terms)); } return mkUninterpFun(sym, std::move(terms)); } PTRef Logic::mkFun(SymRef sym, vec&& terms) { #ifndef NDEBUG std::string why; if (not typeCheck(sym, terms, why)) { throw OsmtInternalException(why); } #endif PTRef res = PTRef_Undef; if (terms.size() == 0) { if (term_store.hasCtermKey(sym)) //cterm_map.contains(sym)) res = term_store.getFromCtermMap(sym); //cterm_map[sym]; else { res = term_store.newTerm(sym, terms); term_store.addToCtermMap(sym, res); //cterm_map.insert(sym, res); } } else if (!isBooleanOperator(sym)) { if (!sym_store[sym].left_assoc() && !sym_store[sym].right_assoc() && !sym_store[sym].chainable() && !sym_store[sym].pairwise() && sym_store[sym].nargs() != terms.size_()) { throw OsmtApiException(e_argnum_mismatch); } PTLKey k; k.sym = sym; terms.moveTo(k.args); if (sym_store[sym].commutes()) { termSort(k.args); } if (term_store.hasCplxKey(k)) res = term_store.getFromCplxMap(k); else { res = term_store.newTerm(sym, k.args); term_store.addToCplxMap(std::move(k), res); } } else { // Boolean operator PTLKey k; k.sym = sym; terms.moveTo(k.args); if (term_store.hasBoolKey(k)) {//bool_map.contains(k)) { res = term_store.getFromBoolMap(k); //bool_map[k]; #ifdef SIMPLIFY_DEBUG char* ts = printTerm(res); cerr << "duplicate: " << ts << endl; ::free(ts); #endif } else { res = term_store.newTerm(sym, k.args); term_store.addToBoolMap(std::move(k), res); #ifdef SIMPLIFY_DEBUG char* ts = printTerm(res); cerr << "new: " << ts << endl; ::free(ts); #endif } } return res; } bool Logic::isUF(SymRef sref) const { return getSym(sref).nargs() > 0 and not isInterpreted(sref); } bool Logic::isUF(PTRef ptr) const { return isUF(getSymRef(ptr)); } bool Logic::isIF(SymRef sref) const { return getSym(sref).nargs() > 0 && isInterpreted(sref); } bool Logic::isIF(PTRef ptr) const { return isIF(getSymRef(ptr)); } // Uninterpreted predicate p : U U* -> Bool bool Logic::isUP(PTRef ptr) const { return isUF(ptr) and hasSortBool(ptr); } // Check if the term store contains an equality over the given arguments // Return the reference if yes, return PTRef_Undef if no // Changes the argument! PTRef Logic::hasEquality(vec& args) { SymRef sref = term_store.lookupSymbol(tk_equals, args); assert(sref != SymRef_Undef); termSort(args); PTLKey k; k.sym = sref; args.copyTo(k.args); if (term_store.hasCplxKey(k)) return term_store.getFromCplxMap(k); else return PTRef_Undef; } bool Logic::isBooleanOperator(SymRef tr) const { if (tr == getSym_and()) return true; if (tr == getSym_or()) return true; if (tr == getSym_not()) return true; if (tr == getSym_eq()) return true; if (tr == getSym_xor()) return true; if (tr == getSym_ite()) return true; if (tr == getSym_implies()) return true; if (tr == getSym_distinct()) return true; return false; } bool Logic::isConstant(SymRef sr) const { int id = sym_store[sr].getId(); if (constants.size() <= id) return false; return constants[id]; } // A term is atom if its sort is Bool and // (i) it is a variable or constant (number of arguments is 0) // (ii) it is a non-boolean equality or distinct // (iii) it is a theory atom (here we check only UF atoms, logics should override this method to add their specific checks) bool Logic::isAtom(PTRef r) const { const Pterm& t = term_store[r]; if (sym_store[t.symb()].rsort() == getSort_bool()) { if (t.size() == 0) return true; if (t.symb() == getSym_not() ) return false; // At this point all arguments of equivalence have the same sort. Check only the first if (isEquality(t.symb()) && (sym_store[term_store[t[0]].symb()].rsort() != getSort_bool())) return true; if (isDisequality(t.symb())) return true; if (isUP(r)) return true; } return false; } // // The substitutions for the term riddance from osmt1 // opensmt::pair Logic::retrieveSubstitutions(const vec& facts) { MapWithKeys substs; for (int i = 0; i < facts.size(); i++) { PTRef tr = facts[i].tr; lbool sgn = facts[i].sgn; // Join equalities if (isEquality(tr) && sgn == l_True) { #ifdef SIMPLIFY_DEBUG cerr << "Identified an equality: " << printTerm(tr) << endl; #endif const Pterm& t = getPterm(tr); // n will be the reference if (isUFEquality(tr) || isIff(tr)) { // This is the simple replacement to elimiate enode terms where possible assert(t.size() == 2); // One of them should be a var const Pterm& a1 = getPterm(t[0]); const Pterm& a2 = getPterm(t[1]); if (a1.size() == 0 || a2.size() == 0) { PTRef var = a1.size() == 0 ? t[0] : t[1]; PTRef trm = a1.size() == 0 ? t[1] : t[0]; if (contains(trm, var)) continue; if (isConstant(var)) { assert(!isConstant(trm)); PTRef tmp = var; var = trm; trm = tmp; } #ifdef SIMPLIFY_DEBUG if (substs.has(var)) { cerr << "Double substitution:" << endl; cerr << " " << printTerm(var) << "/" << printTerm(trm) << endl; cerr << " " << printTerm(var) << "/" << printTerm(substs[var].tr) << endl; if (substs[var].sgn == l_False) cerr << " disabled" << endl; } else { char* tmp1 = printTerm(var); char* tmp2 = printTerm(trm); cerr << "Substituting " << tmp1 << " with " << tmp2 << endl; ::free(tmp1); ::free(tmp2); } #endif if (!substs.has(var)) { substs.insert(var, PtAsgn(trm, l_True)); } } } } else if (isBoolAtom(tr)) { PTRef term = sgn == l_True ? getTerm_true() : getTerm_false(); if (substs.has(tr)) { if (substs[tr].tr==getTerm_true() || substs[tr].tr==getTerm_false()) { if (term != substs[tr].tr) { return {l_False, SubstMap()}; } } } else { substs.insert(tr, PtAsgn(term, l_True)); } } } SubstLoopBreaker slb(*this); return {l_Undef, slb(std::move(substs))}; } void Logic::substitutionsTransitiveClosure(SubstMap & substs) { bool changed = true; const auto & keys = substs.getKeys(); // We can use direct pointers, since no elements are inserted or deleted in the loop std::vector notChangedElems(substs.getSize(), 0); // True if not changed in last iteration, initially False while (changed) { changed = false; for (int i = 0; i < keys.size(); ++i) { if (notChangedElems[i]) { continue; } PTRef & val = substs[keys[i]]; PTRef oldVal = val; PTRef newVal = Substitutor(*this, substs).rewrite(oldVal); if (oldVal != newVal) { changed = true; val = newVal; } else { notChangedElems[i] = 1; } } } } // // TODO: Also this should most likely be dependent on the theory being // used. Depending on the theory a fact should either be added on the // top level or left out to reduce e.g. simplex matrix size. // bool Logic::getNewFacts(PTRef root, MapWithKeys & facts) { Map isdup; vec queue; PTRef p; lbool sign; purify(root, p, sign); queue.push(PtAsgn(p, sign)); while (queue.size() != 0) { PtAsgn pta = queue.last(); queue.pop(); if (isdup.has(pta)) continue; isdup.insert(pta, true); Pterm const & t = getPterm(pta.tr); if (isAnd(pta.tr) and pta.sgn == l_True) { for (PTRef l : t) { PTRef c; lbool c_sign; purify(l, c, c_sign); queue.push(PtAsgn(c, c_sign)); } } else if (isOr(pta.tr) and (pta.sgn == l_False)) { for (PTRef l : t) { PTRef c; lbool c_sign; purify(l, c, c_sign); queue.push(PtAsgn(c, c_sign ^ true)); } } else { lbool prev_val = facts.has(pta.tr) ? facts[pta.tr] : l_Undef; if (prev_val != l_Undef && prev_val != pta.sgn) return false; // conflict else if (prev_val == pta.sgn) continue; // Already seen assert(prev_val == l_Undef); if (isEquality(pta.tr) and pta.sgn == l_True) { facts.insert(pta.tr, pta.sgn); } else if (isUP(pta.tr) and pta.sgn == l_True) { facts.insert(pta.tr, pta.sgn); } else if (isXor(pta.tr) and pta.sgn == l_True) { Pterm const & xorTerm = getPterm(pta.tr); facts.insert(mkEq(xorTerm[0], mkNot(xorTerm[1])), l_True); } else { PTRef c; lbool c_sign; purify(pta.tr, c, c_sign); if (isBoolAtom(c)) { facts.insert(c, c_sign^(pta.sgn == l_False)); } } } } return true; #ifdef SIMPLIFY_DEBUG cerr << "True facts" << endl; vec::Pair> facts_dbg; facts.getKeysAndVals(facts_dbg); for (int i = 0; i < facts_dbg.size(); i++) cerr << (facts_dbg[i].data == l_True ? "" : "not ") << printTerm(facts_dbg[i].key) << " (" << facts_dbg[i].key.x << ")" << endl; #endif } // // Does term contain var? (works even if var is a term...) // bool Logic::contains(PTRef term, PTRef var) { Map proc; vec queue; queue.push(term); while (queue.size() != 0) { PTRef tr = queue.last(); if (tr == var) return true; if (proc.has(tr)) { queue.pop(); continue; } bool unprocessed_children = false; Pterm& t = getPterm(tr); for (int i = 0; i < t.size(); i++) if (!proc.has(t[i])) { queue.push(t[i]); unprocessed_children = true; } if (unprocessed_children) continue; queue.pop(); proc.insert(tr, true); } return false; } PTRef Logic::learnEqTransitivity(PTRef formula) { vec implications; vec queue; Map processed; queue.push(formula); while (queue.size() != 0) { PTRef tr = queue.last(); if (processed.has(tr)) { queue.pop(); continue; } Pterm& t = getPterm(tr); bool unp_ch = false; for (int i = 0; i < t.size(); i++) { if (!processed.has(t[i])) { queue.push(t[i]); unp_ch = true; } } if (unp_ch) continue; queue.pop(); // // Add (or (and (= x w) (= w z)) (and (= x y) (= y z))) -> (= x z) // const bool cond1 = isOr(tr) && t.size() == 2 && isAnd(t[0]) && isAnd(t[1]) && isEquality(getPterm(t[0])[0]) && isEquality(getPterm(t[0])[1]) && isEquality(getPterm(t[1])[0]) && isEquality(getPterm(t[1])[1]); if (cond1) { // (= v1 v2) (= v3 v4) PTRef v1 = getPterm(getPterm(t[0])[0])[0]; PTRef v2 = getPterm(getPterm(t[0])[0])[1]; PTRef v3 = getPterm(getPterm(t[0])[1])[0]; PTRef v4 = getPterm(getPterm(t[0])[1])[1]; // (= t1 t2) (= t3 t4) PTRef t1 = getPterm(getPterm(t[1])[0])[0]; PTRef t2 = getPterm(getPterm(t[1])[0])[1]; PTRef t3 = getPterm(getPterm(t[1])[1])[0]; PTRef t4 = getPterm(getPterm(t[1])[1])[1]; // Detecting bridging variables const bool cond2a = v1 == v3 || v1 == v4 || v2 == v3 || v2 == v4; const bool cond2b = t1 == t3 || t1 == t4 || t2 == t3 || t2 == t4; if (cond2a && cond2b) { PTRef w = (v1 == v3 || v1 == v4 ? v1 : v2); PTRef x1 = (v1 == w ? v2 : v1); PTRef z1 = (v3 == w ? v4 : v3); PTRef y = (t1 == t3 || t1 == t4 ? t1 : t2); PTRef x2 = (t1 == y ? t2 : t1); PTRef z2 = (t3 == y ? t4 : t3); const bool cond2 = (x1 == x2 && z1 == z2) || (x1 == z2 && x2 == z1); if (cond2) { PTRef eq = mkEq(x1,z1); PTRef impl = mkImpl(tr,eq); implications.push(impl); } } } processed.insert(tr, true); } if (implications.size() > 0) return mkAnd(std::move(implications)); else return getTerm_true(); } PTRef Logic::removeAuxVars(PTRef tr) { class AuxSymbolMatcherConfig : public DefaultRewriterConfig { Logic const & logic; bool match(PTRef tr) const { if (not logic.isVar(tr)) return false; // Only variables can match auto symName = std::string_view(logic.getSymName(tr)); return symName.compare(0, IteHandler::itePrefix.size(), IteHandler::itePrefix) == 0; } public: AuxSymbolMatcherConfig(Logic const & logic) : logic(logic) {} PTRef rewrite(PTRef tr) override { return (match(tr)) ? IteHandler::getIteTermFor(logic, tr) : tr; } }; AuxSymbolMatcherConfig config(*this); Rewriter rewriter(*this, config); return rewriter.rewrite(tr); } void Logic::dumpChecksatToFile(ostream& dump_out) const { dump_out << "(check-sat)" << endl; dump_out << "(exit)" << endl; } std::string Logic::dumpWithLets(PTRef formula) const { std::stringstream out; dumpWithLets(out, formula); return out.str(); } void Logic::dumpWithLets(std::ostream & dump_out, PTRef formula) const { uint32_t random_Idx = 0; vector unprocessed_enodes; std::map enode_to_def; unsigned num_lets = 0; unprocessed_enodes.push_back(formula); // Visit the DAG of the formula from the leaves to the root // while (not unprocessed_enodes.empty()) { PTRef e = unprocessed_enodes.back(); // // Skip if the node has already been processed before // if (enode_to_def.find(e) not_eq enode_to_def.end()) { unprocessed_enodes.pop_back(); continue; } bool unprocessed_children = false; auto const & term = getPterm(e); for (PTRef pref : term) { // Push only if it is unprocessed if (enode_to_def.find(pref) == enode_to_def.end() && (isBooleanOperator(pref) || isEquality(pref))) { unprocessed_enodes.push_back(pref); unprocessed_children = true; } } if (unprocessed_children) continue; unprocessed_enodes.pop_back(); std::string definition = "?def" + std::to_string(random_Idx++); // Open let dump_out << "(let "; // Open binding dump_out << "((" << definition << " "; if (term.size() > 0) dump_out << "("; dump_out << printSym(term.symb()); for (PTRef pref : term) { if (isBooleanOperator(pref) || isEquality(pref)) { dump_out << " " << enode_to_def[pref]; } else { dump_out << " " << printTerm(pref); if (isAnd(e)) dump_out << endl; } } if (term.size() > 0) dump_out << ")"; // Closes binding dump_out << "))\n"; // Keep track of number of lets to close num_lets++; assert(enode_to_def.find(e) == enode_to_def.end()); enode_to_def[e] = std::move(definition); } dump_out << '\n' << enode_to_def[formula] << '\n'; // Close all lets for (unsigned n = 1; n <= num_lets; n++) dump_out << ")"; } void Logic::dumpHeaderToFile(ostream& dump_out) const { dump_out << "(set-logic " << getName() << ")\n"; for (SSymRef ssr : sort_store.getSortSyms()) { if (isBuiltinSortSym(ssr)) continue; dump_out << "(declare-sort " << sort_store.getSortSymName(ssr) << " " << sort_store.getSortSymSize(ssr) << ")\n"; } const vec& symbols = sym_store.getSymbols(); for (SymRef s : symbols) { if (s == getSym_true() || s == getSym_false()) continue; if (isConstant(s)) { if (isBuiltinConstant(s)) continue; dump_out << "(declare-const "; } //else if (!isUF(s) && !isVar(s)) continue; else if (isBuiltinFunction(s)) continue; else { dump_out << "(declare-fun "; } auto sym = printSym(s); dump_out << sym << " "; Symbol const & symb = sym_store[s]; dump_out << "("; for (SRef sr : symb) { dump_out << printSort(sr) << " "; } dump_out << ") " << printSort(symb.rsort()) << ")\n"; } } void Logic::dumpFormulaToFile(ostream & dump_out, PTRef formula, bool negate, bool toassert) const { if (toassert) dump_out << "(assert\n"; if (negate) dump_out << "(not "; dumpWithLets(dump_out, formula); if (negate) dump_out << ")"; if (toassert) dump_out << ")\n"; } void Logic::dumpFunction(ostream& dump_out, const TemplateFunction& tpl_fun) { const std::string& name = tpl_fun.getName(); auto quoted_name = protectName(name, false); dump_out << "(define-fun " << quoted_name << " ( "; const vec& args = tpl_fun.getArgs(); for (PTRef arg : args) { dump_out << '(' << printTerm(arg) << ' ' << printSort(getSortRef(arg)) << ") "; } dump_out << ") " << printSort(tpl_fun.getRetSort()); dumpFormulaToFile(dump_out, tpl_fun.getBody(), false, false); dump_out << ")\n"; } PTRef Logic::instantiateFunctionTemplate(TemplateFunction const & tmplt, vec const & args) { auto const & targs = tmplt.getArgs(); if (args.size() != targs.size()) { throw OsmtApiException("Function instantiation argument count mismatch"); } if (args.size() == 0) { return tmplt.getBody(); } SubstMap substMap; for (int i = 0; i < args.size(); ++i) { if (getSortRef(targs[i]) != getSortRef(args[i])) { throw OsmtApiException("Function instantiation source and target sort mismatch"); } substMap.insert(targs[i], args[i]); } PTRef res = Substitutor(*this, substMap).rewrite(tmplt.getBody()); assert(getSortRef(res) == tmplt.getRetSort()); return res; } void Logic::collectStats(PTRef root, int& n_of_conn, int& n_of_eq, int& n_of_uf, int& n_of_if) { set seen_terms; queue to_visit; n_of_conn = n_of_eq = n_of_uf = n_of_if = 0; to_visit.push(root); while(!to_visit.empty()) { PTRef node = to_visit.front(); to_visit.pop(); if(seen_terms.find(node) != seen_terms.end()) continue; seen_terms.insert(node); if(isBooleanOperator(node)) { ++n_of_conn; Pterm& pnode = getPterm(node); for(int i = 0; i < pnode.size(); ++i) to_visit.push(pnode[i]); } else if(isUFEquality(node)) { ++n_of_eq; Pterm& pnode = getPterm(node); to_visit.push(pnode[0]); to_visit.push(pnode[1]); } else if(isUF(node)) { ++n_of_uf; Pterm& pnode = getPterm(node); for(int i = 0; i < pnode.size(); ++i) to_visit.push(pnode[i]); } else if(isIF(node)) { ++n_of_if; Pterm& pnode = getPterm(node); for(int i = 0; i < pnode.size(); ++i) to_visit.push(pnode[i]); } } } PTRef Logic::conjoinExtras(PTRef root) { return root; } // Fetching sorts SRef Logic::getSortRef (const PTRef tr) const { return getSortRef(getPterm(tr).symb()); } SRef Logic::getSortRef (const SymRef sr) const { return getSym(sr).rsort(); } std::string Logic::printSort(SRef s) const { return sort_store.printSort(s); } SRef Logic::getUniqueArgSort(SymRef sr) const { SRef res = SRef_Undef; for (SRef a : getSym(sr)) { if (res == SRef_Undef) { res = a; } else { if (res != a) { throw OsmtApiException("getUniqueArgSort called for a symbol with non-uniform arguments"); } } } return res; } // The Boolean connectives SymRef Logic::getSym_true () const { return sym_TRUE; } SymRef Logic::getSym_false () const { return sym_FALSE; } SymRef Logic::getSym_and () const { return sym_AND; } SymRef Logic::getSym_or () const { return sym_OR; } SymRef Logic::getSym_xor () const { return sym_XOR; } SymRef Logic::getSym_not () const { return sym_NOT; } SymRef Logic::getSym_eq () const { return sym_EQ; } SymRef Logic::getSym_ite () const { return sym_ITE; } SymRef Logic::getSym_implies () const { return sym_IMPLIES; } SymRef Logic::getSym_distinct () const { return sym_DISTINCT; } SRef Logic::getSort_bool () const { return sort_BOOL; } PTRef Logic::getTerm_true () const { return term_TRUE; } PTRef Logic::getTerm_false () const { return term_FALSE; } bool Logic::isEquality (SymRef tr) const { return equalities.has(tr); } bool Logic::isEquality (PTRef tr) const { return equalities.has(term_store[tr].symb());} bool Logic::isUFEquality (PTRef tr) const { return isEquality(tr) && !hasSortBool(getPterm(tr)[0]); } bool Logic::isTheoryEquality (PTRef tr) const { return isEquality(tr) && !hasSortBool(getPterm(tr)[0]); } bool Logic::isDisequality (SymRef tr) const { return disequalities.has(tr); } bool Logic::isDisequality (PTRef tr) const { return disequalities.has(term_store[tr].symb()); } bool Logic::isIte (SymRef tr) const { return ites.has(tr); } bool Logic::isIte (PTRef tr) const { return ites.has(term_store[tr].symb()); } bool Logic::isBooleanOperator (PTRef tr) const { return isBooleanOperator(term_store[tr].symb()); } bool Logic::isBuiltinSort (const SRef sr) const { return sr == sort_BOOL; } bool Logic::isBuiltinSortSym (const SSymRef ssr) const { return ssr == sort_store.getSortSym(sort_BOOL); } bool Logic::isBuiltinConstant (const SymRef sr) const { return isConstant(sr) && (sr == sym_TRUE || sr == sym_FALSE); } bool Logic::isBuiltinConstant (const PTRef tr) const { return isBuiltinConstant(getPterm(tr).symb()); } bool Logic::isConstant (PTRef tr) const { return isConstant(getPterm(tr).symb()); } bool Logic::yieldsSortUninterpreted (PTRef tr) const { return isUFSort(getSortRef(tr)); } bool Logic::isUFSort (const SRef sr) const { return ufsorts.has(sr); } bool Logic::isVar (SymRef sr) const { return sym_store[sr].nargs() == 0 && !isConstant(sr); } bool Logic::isVar (PTRef tr) const { return isVar(getPterm(tr).symb()); } bool Logic::isBoolAtom (PTRef tr) const { return hasSortBool(tr) && isVar(tr); } bool Logic::isAnd(PTRef tr) const { return getPterm(tr).symb() == getSym_and(); } bool Logic::isAnd(SymRef sr) const { return sr == getSym_and(); } bool Logic::isOr (PTRef tr) const { return getPterm(tr).symb() == getSym_or (); } bool Logic::isOr (SymRef sr) const { return sr == getSym_or(); } bool Logic::isNot(PTRef tr) const { return getPterm(tr).symb() == getSym_not(); } bool Logic::isNot(SymRef sr) const { return sr == getSym_not(); } bool Logic::isXor(SymRef sr) const { return sr == getSym_xor(); } bool Logic::isXor(PTRef tr) const { return isXor(getPterm(tr).symb()); } bool Logic::isImplies(SymRef sr) const { return sr == getSym_implies(); } bool Logic::isImplies(PTRef tr) const { return isImplies(getPterm(tr).symb()); } bool Logic::isTrue(SymRef sr) const { return sr == getSym_true(); } bool Logic::isTrue(PTRef tr) const { return isTrue(getPterm(tr).symb()); } bool Logic::isFalse(SymRef sr) const { return sr == getSym_false(); } bool Logic::isFalse(PTRef tr) const { return isFalse(getPterm(tr).symb()); } bool Logic::isIff(SymRef sr) const { return sr == getSym_eq(); } bool Logic::isIff(PTRef tr) const { return isIff(getPterm(tr).symb()); } bool Logic::hasSortBool(PTRef tr) const { return sym_store[getPterm(tr).symb()].rsort() == sort_BOOL; } bool Logic::hasSortBool(SymRef sr) const { return sym_store[sr].rsort() == sort_BOOL; } bool Logic::isArraySelect(SymRef sr) const { return selects.has(sr); } bool Logic::isArraySelect(PTRef tr) const { return isArraySelect(getPterm(tr).symb()); } bool Logic::isArrayStore(SymRef sr) const { return stores.has(sr); } bool Logic::isArrayStore(PTRef tr) const { return isArrayStore(getPterm(tr).symb()); } SRef Logic::getArraySort(SRef domain, SRef codomain) { return getSort(sym_ArraySort, {domain, codomain}); } void Logic::termSort(vec& v) const { sort(v, std::less{}); } void Logic::purify (PTRef r, PTRef& p, lbool& sgn) const {p = r; sgn = l_True; while (isNot(p)) { sgn = sgn^1; p = getPterm(p)[0]; }} bool Logic::typeCheck(SymRef sym, vec const & args, std::string & why) const { auto genSortMismatchString = [&](SymRef sym, vec const & args) { std::string symStr = getSymName(sym); Symbol const & symbol = sym_store[sym]; if (symbol.chainable() or symbol.pairwise()) { for (int i = 0; i < args.size(); i++) { symStr += " " + printSort(symbol[0]); } } else if (symbol.left_assoc()) { symStr += " " + printSort(symbol[0]); for (int i = 1; i < args.size(); i++) { symStr += " " + printSort(symbol[1]); } } else if (symbol.right_assoc()) { for (int i = 0; i < args.size() - 1; i++) { symStr += " " + printSort(symbol[0]); } symStr += " " + printSort(symbol[1]); } std::string argSorts; for (PTRef tr : args) { argSorts += printSort(getSortRef(tr)) + " "; } return "Symbol " + symStr + " instantiated with arguments of sort " + argSorts; }; auto genArgNumMismatchString = [&](SymRef sym, int expectedArgs, int actualArgs) { return "Symbol `" + std::string(getSymName(sym)) + "` expects " + std::to_string(expectedArgs) + " arguments but " + std::to_string(actualArgs) + " arguments were provided. "; }; Symbol const & symbol = sym_store[sym]; if (symbol.chainable() or symbol.pairwise()) { // Need to have at least two arguments and they all need to be of the same sort if (args.size() < 2) { why.assign(genArgNumMismatchString(sym, 2, args.size())); return false; } SRef argSort = getSortRef(args[0]); auto allArgSortsEqual = [&](vec const & args) { return std::all_of(args.begin(), args.end(), [&](PTRef tr) { return argSort == getSortRef(tr); });}; if (argSort != symbol[0] or not allArgSortsEqual(args)) { why.assign(genSortMismatchString(sym, args)); return false; } } else if (symbol.left_assoc()) { // Needs to have at least two arguments // first arg must match symbol's first sort, and // all other arguments must match symbol's second sort if (args.size() < 2) { why.assign(genArgNumMismatchString(sym, 2, args.size())); return false; } SRef firstSort = symbol[0]; SRef secondSort = symbol[1]; auto allButFirstSortEqualSecond = [&](vec const & args) { return std::all_of(args.begin()+1, args.end(), [&](PTRef tr) { return secondSort == getSortRef(tr); });}; if (firstSort != getSortRef(args[0]) or not allButFirstSortEqualSecond(args)) { why.assign (genSortMismatchString(sym, args)); return false; } } else if (symbol.right_assoc()) { // Needs to have at least two arguments // all but last argument must match symbol's first sort // last argument must match symbol's second sort if (args.size() < 2) { why.assign(genArgNumMismatchString(sym, 2, args.size())); return false; } SRef firstSort = symbol[0]; SRef secondSort = symbol[1]; auto allButLastSortEqualFirst = [&](vec const & args) { return std::all_of(args.begin(), args.end()-1, [&](PTRef tr) { return firstSort == getSortRef(tr); });}; if (secondSort != getSortRef(args.last()) or not allButLastSortEqualFirst(args)) { why.assign(genSortMismatchString(sym, args)); return false; } } else if (symbol.nargs() == args.size_()) { // Normal symbol: all argument sorts must match symbol sorts for (unsigned int i = 0; i < symbol.nargs(); i++) { if (symbol[i] != getSortRef(args[i])) { why.assign(genSortMismatchString(sym, args)); return false; } } } else if (symbol.nargs() != args.size_()) { why.assign(genArgNumMismatchString(sym, symbol.nargs(), args.size())); return false; } return true; } opensmt-2.5.2/src/logics/Logic.h000066400000000000000000000525031445011647600164770ustar00rootroot00000000000000/* * Copyright (c) 2012-2022, Antti Hyvarinen * Copyright (c) 2018-2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #ifndef LOGIC_H #define LOGIC_H #include "SymStore.h" #include "PtStore.h" #include "SStore.h" #include "CgTypes.h" #include "LogicFactory.h" #include "MapWithKeys.h" #include "OsmtApiException.h" #include "FunctionTools.h" #include "TypeUtils.h" #include "NatSet.h" #include #include #include class SStore; class Logic { public: using SubstMap = MapWithKeys; protected: static const char* e_argnum_mismatch; static const char* e_bad_constant; Map > equalities; Map > disequalities; Map > ites; Map > selects; Map > stores; Map sortToEquality; Map sortToDisequality; Map sortToIte; Map sortToSelect; Map sortToStore; Map > ufsorts; Map> defaultValueForSort; opensmt::Logic_t const logicType; bool isKnownToUser(std::string_view name) const { return name[0] != s_abstract_value_prefix[0]; } bool isKnownToUser(SymRef sr) const { return isKnownToUser(getSymName(sr)); } std::size_t abstractValueCount = 0; int distinctClassCount; vec constants; SStore sort_store; SymStore sym_store; PtStore term_store; class TermMarks { nat_set & innerSet; public: TermMarks(nat_set & innerSet, unsigned int domainSize) : innerSet(innerSet){ innerSet.assure_domain(domainSize); innerSet.reset(); } inline void mark(PTId id) { innerSet.insert(Idx(id)); } inline bool isMarked(PTId id) const { return innerSet.contains(Idx(id)); } }; mutable nat_set auxiliaryNatSet; SSymRef sym_IndexedSort; SRef sort_BOOL; PTRef term_TRUE; PTRef term_FALSE; SymRef sym_TRUE; SymRef sym_FALSE; SymRef sym_AND; SymRef sym_OR; SymRef sym_XOR; SymRef sym_NOT; SymRef sym_UF_NOT; SymRef sym_EQ; SymRef sym_IMPLIES; SymRef sym_DISTINCT; SymRef sym_ITE; SSymRef sym_ArraySort; void dumpFunction(std::ostream &, const TemplateFunction&); private: enum class UFAppearanceStatus { unseen, removed, appears }; vec appears_in_uf; void unsetAppearsInUF(PTRef tr); public: vec propFormulasAppearingInUF; std::size_t getNumberOfTerms() const { return term_store.getNumberOfTerms(); } static const char* tk_val_uf_default; static const char* tk_val_bool_default; static const char* tk_true; static const char* tk_false; static const char* tk_uf_not; // The symbol for propositional not in UF. static const char* tk_not; static const char* tk_equals; static const char* tk_implies; static const char* tk_and; static const char* tk_or; static const char* tk_xor; static const char* tk_distinct; static const char* tk_ite; static const char* tk_indexed; static const char* s_sort_bool; static const char* s_ite_prefix; static const char* s_framev_prefix; static const char* s_abstract_value_prefix; Logic(opensmt::Logic_t type); virtual ~Logic(); virtual PTRef conjoinExtras(PTRef root); virtual std::string const getName() const { return opensmt::QFLogicToProperties.at(logicType).name; } opensmt::Logic_t getLogic() const { return logicType; } bool hasUFs() const { return opensmt::QFLogicToProperties.at(logicType).ufProperty.hasUF; } bool hasIntegers() const { return opensmt::QFLogicToProperties.at(logicType).arithProperty.hasInts; } bool hasReals() const { return opensmt::QFLogicToProperties.at(logicType).arithProperty.hasReals; } protected: PTRef mkFun (SymRef f, vec&& args); void markConstant (PTRef ptr); void markConstant (SymId sid); public: SRef getSortRef (PTRef tr) const; SRef getSortRef (SymRef sr) const; std::string printSort (SRef s) const; std::size_t getSortSize(SRef s) const; SRef declareUninterpretedSort(std::string const &); bool isArraySort(SRef sref) const { return sort_store[sref].getSymRef() == sym_ArraySort; } SRef getArraySort(SRef domain, SRef codomain); bool hasArrays() const { return opensmt::QFLogicToProperties.at(logicType).ufProperty.hasArrays; } bool isArrayStore(SymRef) const; bool isArrayStore(PTRef) const; bool isArraySelect(SymRef) const; bool isArraySelect(PTRef) const; PTRef mkStore(vec &&); PTRef mkSelect(vec &&); SRef getUniqueArgSort(SymRef sr) const; SRef getUniqueArgSort(PTRef tr) const { return getUniqueArgSort(getSymRef(tr)); } // Symbols const Symbol& getSym (const SymRef s) const { return sym_store[s]; } const Symbol& getSym (const PTRef tr) const { return getSym(getPterm(tr).symb()); } SymRef getSymRef (const PTRef tr) const { return getPterm(tr).symb(); } const char* getSymName (const PTRef tr) const { return sym_store.getName(getPterm(tr).symb()); } const char* getSymName (const SymRef s) const { return sym_store.getName(s); } vec& symNameToRef (const char* s) { return sym_store.nameToRef(s); } bool hasSym (const char* s) const { return sym_store.contains(s); } bool commutes (const SymRef s) const { return getSym(s).commutes(); } // Terms Pterm& getPterm (const PTRef tr) { return term_store[tr]; } const Pterm& getPterm (const PTRef tr) const { return term_store[tr]; } PtermIter getPtermIter () { return term_store.getPtermIter(); } /* * Provides an efficient data structure for representing a set of terms through "marking". * * Relies on a term invariant that id of a child is lower than id of a parent. */ TermMarks getTermMarks(PTId maxTermId) const { return TermMarks(auxiliaryNatSet, Idx(maxTermId) + 1); } // Default values for the logic // Deprecated! Use getDefaultValuePTRef instead virtual const char* getDefaultValue(const PTRef tr) const; // Returns the default value of the sort of the argument term PTRef getDefaultValuePTRef(const PTRef tr) const { return getDefaultValuePTRef(getSortRef(tr)); } // Returns the default value of the given sort virtual PTRef getDefaultValuePTRef(const SRef sref) const; PTRef mkUninterpFun (SymRef f, vec&& args); PTRef mkUninterpFun (SymRef f, vec const & args) { vec tmp; args.copyTo(tmp); return mkUninterpFun(f, std::move(tmp)); } // Boolean term generation PTRef mkAnd (vec&&); PTRef mkAnd (vec const& args) { vec tmp; args.copyTo(tmp); return mkAnd(std::move(tmp)); } PTRef mkAnd (PTRef a1, PTRef a2) { return mkAnd({a1, a2}); } PTRef mkOr (vec&&); PTRef mkOr (vec const & args) { vec tmp; args.copyTo(tmp); return mkOr(std::move(tmp)); } PTRef mkOr (PTRef a1, PTRef a2) { return mkOr({a1, a2}); } PTRef mkXor (vec&&); PTRef mkXor (PTRef a1, PTRef a2) { return mkXor({a1, a2}); } PTRef mkImpl (vec&&); PTRef mkImpl (PTRef a1, PTRef a2) { return mkImpl({a1, a2}); } PTRef mkNot (PTRef); PTRef mkNot (vec&&); PTRef mkIte (vec&&); PTRef mkIte (PTRef c, PTRef t, PTRef e) { return mkIte({c, t, e}); } // Generic equalities PTRef mkEq (vec&& args); PTRef mkEq (vec const & args) { vec tmp; args.copyTo(tmp); return mkEq(std::move(tmp)); } PTRef mkEq (PTRef a1, PTRef a2) { return mkBinaryEq(a1, a2); } protected: virtual PTRef mkBinaryEq(PTRef lhs, PTRef rhs); bool isInternalSort(SRef) const; void newUninterpretedSortHandler(SRef); public: // General disequalities PTRef mkDistinct (vec&& args); // Generic variables PTRef mkVar (SRef, const char*, bool isInterpreted = false); PTRef mkUniqueAbstractValue(SRef); // Generic constants virtual PTRef mkConst (const char*); virtual PTRef mkConst (SRef, const char*); SymRef declareFun(std::string const & fname, SRef rsort, vec const & args, SymbolConfig const & symbolConfig); SymRef declareFun(std::string const & fname, SRef rsort, vec const & args) { return declareFun(fname, rsort, args, SymConf::Default); } SymRef declareFun_NoScoping(std::string const & s, SRef rsort, vec const & args) { return declareFun(s, rsort, args, SymConf::NoScoping); } SymRef declareFun_NoScoping_LeftAssoc(std::string const & s, SRef rsort, vec const & args) { return declareFun(s, rsort, args, SymConf::NoScopingLeftAssoc); } SymRef declareFun_NoScoping_RightAssoc(std::string const & s, SRef rsort, vec const & args) { return declareFun(s, rsort, args, SymConf::NoScopingRightAssoc); } SymRef declareFun_NoScoping_Chainable(std::string const & s, SRef rsort, vec const & args) { return declareFun(s, rsort, args, SymConf::NoScopingChainable); } SymRef declareFun_NoScoping_Pairwise(std::string const & s, SRef rsort, vec const & args) { return declareFun(s, rsort, args, SymConf::NoScopingPairwise); } SymRef declareFun_Commutative_NoScoping_LeftAssoc(std::string const & s, SRef rsort, vec const & args) { return declareFun(s, rsort, args, SymConf::CommutativeNoScopingLeftAssoc); } SymRef declareFun_Commutative_NoScoping_Chainable(std::string const & s, SRef rsort, vec const & args) { return declareFun(s, rsort, args, SymConf::CommutativeNoScopingChainable); } SymRef declareFun_Commutative_NoScoping_Pairwise(std::string const & s, SRef rsort, vec const & args) { return declareFun(s, rsort, args, SymConf::CommutativeNoScopingPairwise); } SymRef declareFun_LeftAssoc(std::string const & s, SRef rsort, vec const & args) { return declareFun(s, rsort, args, SymConf::LeftAssoc); } SymRef declareFun_RightAssoc(std::string const & s, SRef rsort, vec const & args) { return declareFun(s, rsort, args, SymConf::RightAssoc); } SymRef declareFun_Chainable(std::string const & s, SRef rsort, vec const & args) { return declareFun(s, rsort, args, SymConf::Chainable); } SymRef declareFun_Pairwise(std::string const & s, SRef rsort, vec const & args) { return declareFun(s, rsort, args, SymConf::Pairwise); } void instantiateFunctions(SRef); void instantiateArrayFunctions(SRef); bool hasSortSymbol(SortSymbol const &); bool peekSortSymbol(SortSymbol const &, SSymRef &) const; SSymRef declareSortSymbol(SortSymbol symbol); SRef getSort(SSymRef, vec && args); PTRef mkBoolVar (const char* name); void dumpHeaderToFile(std::ostream& dump_out) const; void dumpFormulaToFile(std::ostream& dump_out, PTRef formula, bool negate = false, bool toassert = true) const; void dumpChecksatToFile(std::ostream& dump_out) const; void dumpWithLets(std::ostream & out, PTRef formula) const; std::string dumpWithLets(PTRef formula) const; PTRef instantiateFunctionTemplate(TemplateFunction const & tmplt, vec const & args); SSymRef getSortSymIndexed() const { return sym_IndexedSort; } // The Boolean connectives SymRef getSym_true () const;// { return sym_TRUE; } SymRef getSym_false () const;// { return sym_FALSE; } SymRef getSym_and () const;// { return sym_AND; } SymRef getSym_or () const;// { return sym_OR; } SymRef getSym_xor () const;// { return sym_XOR; } SymRef getSym_not () const;// { return sym_NOT; } SymRef getSym_eq () const;// { return sym_EQ; } SymRef getSym_ite () const;// { return sym_ITE; } SymRef getSym_implies () const;// { return sym_IMPLIES; } SymRef getSym_distinct () const;// { return sym_DISTINCT; } SymRef getSym_uf_not () const { return sym_UF_NOT; } SRef getSort_bool () const;// { return sort_BOOL; } PTRef getTerm_true () const;// { return term_TRUE; } PTRef getTerm_false () const;// { return term_FALSE; } bool isEquality (SymRef tr) const;// { return equalities.has(tr); } bool isEquality (PTRef tr) const;// { return equalities.has(term_store[tr].symb());} virtual bool isUFEquality (PTRef tr) const;// { return isEquality(tr) && !hasSortBool(getPterm(tr)[0]); } virtual bool isTheoryEquality (PTRef tr) const;// { return isUFEquality(tr); } bool isDisequality (SymRef tr) const;// { return disequalities.has(tr); } bool isDisequality (PTRef tr) const;// { return disequalities.has(term_store[tr].symb()); } bool isIte (SymRef tr) const;// { return ites.has(tr); } bool isIte (PTRef tr) const;// { return ites.has(term_store[tr].symb()); } bool isNonBoolIte (SymRef sr) const { return isIte(sr) and getSortRef(sr) != sort_BOOL; } bool isNonBoolIte (PTRef tr) const { return isNonBoolIte(getPterm(tr).symb()); } // tr is a theory symbol if it is not a boolean variable, nor one of the standard // boolean operators (and, not, or, etc...) // Note that equivalence over non-boolean terms is not a Boolean operator. bool isTheorySymbol (SymRef tr) const; // True for terms (PTRef) that are of interest to theory solver and should be declared to the solver. Only such terms should be declared to the theory solver bool isTheoryTerm (PTRef tr) const; bool isBooleanOperator (SymRef tr) const; bool isBooleanOperator (PTRef tr) const;// { return isBooleanOperator(term_store[tr].symb()); } virtual bool isBuiltinSort (const SRef sr) const;// { return sr == sort_BOOL; } virtual bool isBuiltinSortSym (const SSymRef ssr) const; virtual bool isBuiltinConstant (const SymRef sr) const;// { return isConstant(sr) && (sr == sym_TRUE || sr == sym_FALSE); } bool isBuiltinConstant (const PTRef tr) const;// { return isBuiltinConstant(getPterm(tr).symb()); } virtual bool isBuiltinFunction (const SymRef sr) const; bool isConstant (const SymRef sr) const; bool isConstant (PTRef tr) const; bool yieldsSortUninterpreted (PTRef tr) const; bool isUFSort (const SRef sr) const; bool appearsInUF (PTRef tr) const; void setAppearsInUF (PTRef tr); virtual vec getNestedBoolRoots (PTRef tr) const; bool isVar (SymRef sr) const ;//{ return sym_store[sr].nargs() == 0 && !isConstant(sr); } bool isVar (PTRef tr) const;// { return isVar(getPterm(tr).symb()); } bool isVarOrIte (SymRef sr) const { return isVar(sr) or isIte(sr); } bool isVarOrIte (PTRef tr) const { return isVarOrIte(getPterm(tr).symb()); } virtual bool isAtom (PTRef tr) const; bool isBoolAtom (PTRef tr) const;// { return hasSortBool(tr) && isVar(tr); } // Check if term is an uninterpreted predicate. bool isInterpreted (SymRef sr) const { return sym_store.isInterpreted(sr); } virtual bool isUP (PTRef) const; virtual bool isUF (PTRef) const; virtual bool isUF (SymRef) const; virtual bool isIF (PTRef) const; virtual bool isIF (SymRef) const; bool isAnd(PTRef tr) const ;//{ return getPterm(tr).symb() == getSym_and(); } bool isAnd(SymRef sr) const;// { return sr == getSym_and(); } bool isOr (PTRef tr) const ;//{ return getPterm(tr).symb() == getSym_or (); } bool isOr (SymRef sr) const;// { return sr == getSym_or(); } bool isNot(PTRef tr) const;// { return getPterm(tr).symb() == getSym_not(); } bool isNot(SymRef sr) const ;//{ return sr == getSym_not(); } bool isXor(SymRef sr) const;// { return sr == getSym_xor(); } bool isXor(PTRef tr) const;// { return isXor(getPterm(tr).symb()); } bool isImplies(SymRef sr) const;// { return sr == getSym_implies(); } bool isImplies(PTRef tr) const;// { return isImplies(getPterm(tr).symb()); } bool isTrue(SymRef sr) const;// { return sr == getSym_true(); } bool isTrue(PTRef tr) const ;//{ return isTrue(getPterm(tr).symb()); } bool isFalse(SymRef sr) const;// { return sr == getSym_false(); } bool isFalse(PTRef tr) const;// { return isFalse(getPterm(tr).symb()); } bool isIff(SymRef sr) const;// { return sr == getSym_eq(); } bool isIff(PTRef tr) const;// { return isIff(getPterm(tr).symb()); } bool hasSortBool(PTRef tr) const;// { return sym_store[getPterm(tr).symb()].rsort() == sort_BOOL; } bool hasSortBool(SymRef sr) const;// { return sym_store[sr].rsort() == sort_BOOL; } // Returns an equality over args if term store contains one, otherwise returns PTRef_Undef. // args is sorted before lookup, but not simplified otherwise PTRef hasEquality (vec& args); PTRef resolveTerm(const char* s, vec&& args, SRef sortRef = SRef_Undef, SymbolMatcher symbolMatcher = SymbolMatcher::Any); virtual PTRef insertTerm (SymRef sym, vec && args); PTRef insertTerm(SymRef sym, vec const & args) { vec tmp; args.copyTo(tmp); return insertTerm(sym, std::move(tmp)); } // Top-level equalities based substitutions bool getNewFacts(PTRef root, MapWithKeys & facts); virtual opensmt::pair retrieveSubstitutions(const vec& units); void substitutionsTransitiveClosure(SubstMap & substs); bool contains(PTRef x, PTRef y); // term x contains an occurrence of y PTRef learnEqTransitivity(PTRef); // Learn limited transitivity information virtual PTRef removeAuxVars(PTRef tr); bool hasQuotableChars(std::string const & name) const; bool isReservedWord(std::string const & name) const; bool isAmbiguousUninterpretedNullarySymbolName(std::string_view name) const { return term_store.isAmbiguousNullarySymbolName(name); }; std::string protectName(std::string const & name, bool isInterpreted) const; std::string disambiguateName(std::string const & protectedName, SRef retSort, bool isNullary, bool isInterpreted) const; std::string protectName(SymRef sr) const { return protectName(getSymName(sr), getSym(sr).isInterpreted()); }; virtual std::string printTerm_ (PTRef tr, bool l, bool s) const; std::string printTerm (PTRef tr) const { return printTerm_(tr, false, false); } std::string printTerm (PTRef tr, bool l, bool s) const { return printTerm_(tr, l, s); } std::string pp(PTRef tr) const; // A pretty printer std::string printSym (SymRef sr) const; virtual void termSort(vec& v) const;// { sort(v, LessThan_PTRef()); } void purify (PTRef r, PTRef& p, lbool& sgn) const;//{p = r; sgn = l_True; while (isNot(p)) { sgn = sgn^1; p = getPterm(p)[0]; }} #ifdef PEDANTIC_DEBUG void compareSymStore(SymStore& other) { sym_store.compare(other); } void compareIdStore(IdentifierStore& other) {} void compareSortStore(SStore& other) { } void compareTermStore(PtStore& other) { }// term_store.compare(other); } #endif // Statistics void collectStats(PTRef, int& n_of_conn, int& n_of_eq, int& n_of_uf, int& n_of_if); bool typeCheck(SymRef sym, vec const & args, std::string & why) const; inline int verbose ( ) const;// { return config.verbosity(); } }; #endif // LOGIC_H opensmt-2.5.2/src/logics/LogicFactory.cc000066400000000000000000000057341445011647600201710ustar00rootroot00000000000000// // Created by Martin Blicha on 27.07.20. // #include "LogicFactory.h" #include "ArithLogic.h" #include "BVLogic.h" #include "OsmtApiException.h" #include std::array logicToName = {{"Undef", "Empty", "QF_UF", "QF_CUF", "QF_BV", "QF_RDL", "QF_IDL", "QF_LRA", "QF_LIA", "QF_UFRDL", "QF_UFIDL", "QF_UFLRA", "QF_UFLIA", "QF_UFBV", "QF_AX", "QF_AXDIFF", "QF_ALRA", "QF_ALIA", "QF_AUFLRA", "QF_AUFLIA", "QF_BOOL", "QF_AUFBV", "QF_AUFLIRA"}}; opensmt::Logic_t opensmt::getLogicFromString(const std::string& name) { if (name == "QF_UF") return opensmt::Logic_t::QF_UF; if (name == "QF_LRA") return opensmt::Logic_t::QF_LRA; if (name == "QF_RDL") return opensmt::Logic_t::QF_RDL; if (name == "QF_LIA") return opensmt::Logic_t::QF_LIA; if (name == "QF_IDL") return opensmt::Logic_t::QF_IDL; if (name == "QF_CUF") return opensmt::Logic_t::QF_CUF; if (name == "QF_UFLRA") return opensmt::Logic_t::QF_UFLRA; if (name == "QF_UFLIA") return opensmt::Logic_t::QF_UFLIA; if (name == "QF_UFRDL") return opensmt::Logic_t::QF_UFRDL; if (name == "QF_UFIDL") return opensmt::Logic_t::QF_UFIDL; if (name == "QF_AX") return opensmt::Logic_t::QF_AX; if (name == "QF_ALRA") return opensmt::Logic_t::QF_ALRA; if (name == "QF_ALIA") return opensmt::Logic_t::QF_ALIA; if (name == "QF_AUFLRA") return opensmt::Logic_t::QF_AUFLRA; if (name == "QF_AUFLIA") return opensmt::Logic_t::QF_AUFLIA; if (name == "QF_AUFLIRA") return opensmt::Logic_t::QF_AUFLIRA; return opensmt::Logic_t::UNDEF; } std::string opensmt::getStringFromLogic(const opensmt::Logic_t logic) { return logicToName[static_cast(logic)]; } Logic * opensmt::LogicFactory::getInstance(Logic_t logicType) { Logic * l = nullptr; switch (logicType) { case Logic_t::QF_RDL: case Logic_t::QF_UFRDL: case Logic_t::QF_LRA: case Logic_t::QF_UFLRA: case Logic_t::QF_ALRA: case Logic_t::QF_AUFLRA: case Logic_t::QF_IDL: case Logic_t::QF_UFIDL: case Logic_t::QF_LIA: case Logic_t::QF_UFLIA: case Logic_t::QF_ALIA: case Logic_t::QF_AUFLIA: case Logic_t::QF_AUFLIRA: { l = new ArithLogic(logicType); break; } case Logic_t::QF_UF: case Logic_t::QF_BOOL: case Logic_t::QF_AX: { l = new Logic(logicType); break; } case Logic_t::QF_CUF: { l = new BVLogic(logicType); break; } default: assert(false); throw OsmtApiException{"No logic or unsupported logic specified"}; } return l; } ArithLogic * opensmt::LogicFactory::getLRAInstance() { return new ArithLogic(Logic_t::QF_LRA); } ArithLogic * opensmt::LogicFactory::getLIAInstance() { return new ArithLogic(Logic_t::QF_LIA); } opensmt-2.5.2/src/logics/LogicFactory.h000066400000000000000000000141041445011647600200220ustar00rootroot00000000000000// // Created by Martin Blicha on 27.07.20. // #ifndef OPENSMT_LOGICFACTORY_H #define OPENSMT_LOGICFACTORY_H #include #include class Logic; class ArithLogic; namespace opensmt { enum class Arithmetic_t : int { None, Difference, Linear, Nonlinear }; struct ArithProperty { bool const hasInts; bool const hasReals; Arithmetic_t const arithType; }; constexpr ArithProperty no_arith = ArithProperty{false, false, Arithmetic_t::None}; struct UFProperty { bool const hasArrays; bool const hasUF; bool hasDiff; }; constexpr UFProperty no_uf = UFProperty{false, false, false}; struct BVProperty { bool const hasBV; }; constexpr BVProperty no_bv = BVProperty{false}; struct LogicProperty { std::string const name; ArithProperty const arithProperty; UFProperty const ufProperty; BVProperty const bvProperty; }; enum class Logic_t : int { UNDEF, EMPTY, QF_UF, QF_CUF, QF_BV, QF_RDL, QF_IDL, QF_LRA, QF_LIA, QF_NIA, QF_NRA, QF_LIRA, QF_NIRA, QF_UFRDL, QF_UFIDL, QF_UFLRA, QF_UFLIA, QF_UFBV, QF_AX, QF_AXDIFF, QF_ALRA, QF_ALIA, QF_AUFLRA, QF_AUFLIA, QF_BOOL, QF_AUFBV, QF_AUFLIRA }; inline const std::unordered_map QFLogicToProperties { {Logic_t::UNDEF, {"undef", no_arith, no_uf, no_bv}}, {Logic_t::EMPTY, {"empty", no_arith, no_uf, no_bv}}, {Logic_t::QF_UF, {"QF_UF", no_arith, UFProperty{false, true, false}, no_bv}}, {Logic_t::QF_CUF, {"QF_CUF", no_arith, UFProperty{false, true, false}, BVProperty{true}}}, {Logic_t::QF_BV, {"QF_BV", no_arith, no_uf, BVProperty{true}}}, {Logic_t::QF_RDL, {"QF_RDL", ArithProperty{false, true, Arithmetic_t::Difference}, no_uf, no_bv}}, {Logic_t::QF_IDL, {"QF_IDL", ArithProperty{true, false, Arithmetic_t::Difference}, no_uf, no_bv}}, {Logic_t::QF_LRA, {"QF_LRA", ArithProperty{false, true, Arithmetic_t::Linear}, no_uf, no_bv}}, {Logic_t::QF_LIA, {"QF_LIA", ArithProperty{true, false, Arithmetic_t::Linear}, no_uf, no_bv}}, {Logic_t::QF_NIA, {"QF_NIA", ArithProperty{true, false, Arithmetic_t::Nonlinear}, no_uf, no_bv}}, {Logic_t::QF_NRA, {"QF_NRA", ArithProperty{false, true, Arithmetic_t::Nonlinear}, no_uf, no_bv}}, {Logic_t::QF_LIRA, {"QF_LIRA", ArithProperty{true, true, Arithmetic_t::Linear}, no_uf, no_bv}}, {Logic_t::QF_NIRA, {"QF_NIRA", ArithProperty{true, true, Arithmetic_t::Nonlinear}, no_uf, no_bv}}, {Logic_t::QF_UFRDL, {"QF_UFRDL", ArithProperty{false, true, Arithmetic_t::Difference}, UFProperty{false, true, false}, no_bv}}, {Logic_t::QF_UFIDL, {"QF_UFIDL", ArithProperty{true, false, Arithmetic_t::Difference}, UFProperty{false, true, false}, no_bv}}, {Logic_t::QF_UFLRA, {"QF_UFLRA", ArithProperty{false, true, Arithmetic_t::Linear}, UFProperty{false, true, false}, no_bv}}, {Logic_t::QF_UFLIA, {"QF_UFLIA", ArithProperty{true, false, Arithmetic_t::Linear}, UFProperty{false, true, false}, no_bv}}, {Logic_t::QF_UFBV, {"QF_UFBV", no_arith, UFProperty{false, true, false}, no_bv}}, {Logic_t::QF_AX, {"QF_AX", no_arith, UFProperty{true, false, false}, no_bv}}, {Logic_t::QF_AXDIFF, {"QF_AXDIFF", no_arith, UFProperty{true, false, true}, no_bv}}, {Logic_t::QF_ALRA, {"QF_ALRA", ArithProperty{false, true, Arithmetic_t::Linear}, UFProperty{true, false, false}, no_bv}}, {Logic_t::QF_ALIA, {"QF_ALIA", ArithProperty{true, false, Arithmetic_t::Linear}, UFProperty{true, false, false}, no_bv}}, {Logic_t::QF_AUFLRA, {"QF_AUFLRA", ArithProperty{false, true, Arithmetic_t::Linear}, UFProperty{true, true, false}, no_bv}}, {Logic_t::QF_AUFLIA, {"QF_AUFLIA", ArithProperty{true, false, Arithmetic_t::Linear}, UFProperty{true, true, false}, no_bv}}, {Logic_t::QF_BOOL, {"QF_BOOL", no_arith, no_uf, no_bv}}, {Logic_t::QF_AUFBV, {"QF_AUFBV", no_arith, UFProperty{true, true, false}, BVProperty{true}}}, {Logic_t::QF_AUFLIRA, {"QF_AUFLIRA", ArithProperty{true, true, Arithmetic_t::Linear}, UFProperty{true, true, false}, no_bv}} }; Logic_t getLogicFromString(const std::string & name); std::string getStringFromLogic(const Logic_t logic); class LogicFactory { public: static Logic * getInstance(Logic_t); static ArithLogic * getLRAInstance(); static ArithLogic * getLIAInstance(); }; } #endif //OPENSMT_LOGICFACTORY_H opensmt-2.5.2/src/logics/SubstLoopBreaker.cc000066400000000000000000000236261445011647600210320ustar00rootroot00000000000000// // Created by prova on 21.11.19. // #include "SubstLoopBreaker.h" #include #include SNRef SubstNode::getNextChild() { if (procChild < nChildren()) return operator[](procChild++); return SNRef_Undef; } // // Get all vars from a term. Guarantees that no variable repeats in the list. // vec SubstNodeAllocator::getVars(PTRef term) const { vec vars; Map proc; vec queue; queue.push(term); while (queue.size() != 0) { PTRef tr = queue.last(); if (proc.has(tr)) { queue.pop(); continue; } bool unprocessed_children = false; const Pterm& t = logic.getPterm(tr); for (int i = 0; i < t.size(); i++) if (!proc.has(t[i])) { queue.push(t[i]); unprocessed_children = true; } if (unprocessed_children) continue; queue.pop(); proc.insert(tr, true); if (logic.isVar(tr)) vars.push(tr); } return vars; } SNRef SubstNodeAllocator::alloc(PTRef tr, PTRef target) { SNRef tmp; if (SourceToSNRef.peek(tr, tmp)) return tmp; uint32_t v = RegionAllocator::alloc(substNode32Size()); SNRef sid = {v}; TVLRef tvr; if (target == PTRef_Undef) { new (lea(sid)) SubstNode(tr, vec(), tla); } else if (TargetToTargetVarListRef.peek(target, tvr)) { new (lea(sid)) SubstNode(tr, tvr, tla); } else { new (lea(sid)) SubstNode(tr, getVars(target), tla); } SourceToSNRef.insert(tr, sid); SNRefs.push(sid); return sid; } void SubstNodeAllocator::clearTarjan() { for (int i = 0; i < SNRefs.size(); i++) operator[](SNRefs[i]).clearTarjan(); } TargetVarList::TargetVarList(vec&& _children) { header.sz = (unsigned)_children.size(); for (int i = 0; i < size(); i++) vars[i].t = _children[i]; } TVLRef TargetVarListAllocator::alloc(vec&& _children) { sort(_children, std::greater{}); uint32_t v = RegionAllocator::alloc(targetVarList32Size(_children.size())); TVLRef sid = {v}; auto size = (unsigned)_children.size(); new (lea(sid)) TargetVarList(std::move(_children)); operator[](sid).header.proc = 0; operator[](sid).header.sz = size; return sid; } void TarjanAlgorithm::addNode(SNRef n) { sna[n].setIndex(index); sna[n].setLowLink(index); index++; controlStack.push(n); tarjanStack.push(n); sna[n].setStatus(NStatus::inStack); } std::vector> TarjanAlgorithm::getLoops(SNRef startNode) { std::vector> loops; addNode(startNode); while (controlStack.size() > 0) { SNRef n = controlStack.last(); SNRef c = sna[n].getNextChild(); if (c != SNRef_Undef) { if (sna[c].getStatus() == NStatus::unseen) addNode(c); else if (sna[c].getStatus() == NStatus::inStack) sna[n].updateLowLink(sna[c].getIndex()); } else { controlStack.pop(); if (controlStack.size() > 0) sna[controlStack.last()].updateLowLink(sna[n].getLowLink()); if (sna[n].getLowLink() == sna[n].getIndex()) { // Start a new SCC vec scc; SNRef w = SNRef_Undef; do { w = tarjanStack.last(); tarjanStack.pop(); sna[w].setStatus(NStatus::complete); scc.push(w); } while (w != n); if (scc.size() > 1) { loops.emplace_back(); for (int i = scc.size()-1; i >= 0; i--) loops.back().push(scc[i]); } } } } return loops; } vec SubstLoopBreaker::constructSubstitutionGraph(const MapWithKeys& substs) { Map PTRefToSNRef; vec PTRefs; for (PTRef name : substs.getKeys()) { PtAsgn subst = substs[name]; // Allocate the nodes and create the mapping for each enabled substitution if (subst.sgn == l_True) { PTRefToSNRef.insert(name, sna.alloc(name, subst.tr)); PTRefs.push(name); } } vec roots; for (int i = 0; i < PTRefs.size(); i++) { PTRef var = PTRefs[i]; SNRef var_node = PTRefToSNRef[var]; vec queue; // The node has already been processed or the substitution is disabled if (seen.has(var)) continue; queue.push(var_node); roots.push(var_node); while (queue.size() > 0) { SNRef var_sr = queue.last(); queue.pop(); PTRef var_tr = sna[var_sr].getTr(); if (!seen.has(var_tr)) { seen.insert(var_tr, true); sna[var_sr].setProcessing(); for (int j = 0; j < sna[var_sr].nChildren(); j++) { PTRef child_tr = sna[var_sr].getChildTerm(j); SNRef cn = SNRef_Undef; if (PTRefToSNRef.peek(child_tr, cn)) { // The child is already created if (sna[cn].getParent() == SNRef_Undef && cn != var_sr) sna[cn].setParent(var_sr); } else { // The child is not yet created, so create it. // The child cannot have a substitution target since in that case it would have been created. // No need to push it to the queue therefore. cn = sna.alloc(child_tr, PTRef_Undef); } // Update the child to var sna[var_sr][j] = cn; queue.push(cn); } sna[var_sr].setProcessed(); } } } return minimizeRoots(std::move(roots)); } std::vector> SubstLoopBreaker::findLoops(vec& startNodes) { std::vector> loops; TarjanAlgorithm tarjan(sna); for (int i = 0; i < startNodes.size(); i++) { std::vector> loops_tmp = tarjan.getLoops(startNodes[i]); for (auto & loop : loops_tmp) { loops.emplace_back(std::move(loop)); } } return loops; } Logic::SubstMap SubstLoopBreaker::constructLooplessSubstitution(MapWithKeys&& substs) { Logic::SubstMap substPTRefs; for (PTRef key : substs.getKeys()) { PtAsgn & data = substs[key]; if (data.sgn != l_True) { continue; } SNRef subst_node = sna.getSNRefBySource(key); if (sna[subst_node].hasChildren()) { substPTRefs.insert(key, data.tr); } } return substPTRefs; } // // Identify and break any substitution loops // Logic::SubstMap SubstLoopBreaker::operator() (MapWithKeys&& substs) { assert(seen.elems() == 0); if (substs.getSize() == 0) return {}; vec startNodes = constructSubstitutionGraph(substs); while (true) { std::vector> loops = findLoops(startNodes); // Terminate if no loops found if (loops.empty()) break; // printGraphAndLoops(startNodes, loops); vec orphans = breakLoops(loops); for (SNRef orphan : orphans) startNodes.push(orphan); sort(startNodes); uniq(startNodes); // printGraphAndLoops(startNodes, loops); } return constructLooplessSubstitution(std::move(substs)); } vec SubstLoopBreaker::breakLoops(const std::vector>& loops) { // Break the found loops. Return the orphaned children as new start nodes vec orphans; for (const auto & loop : loops) { int last_idx = loop.size()-1; assert(last_idx >= 0); for (int j = 0; j < sna[loop[last_idx]].nChildren(); j++) { orphans.push(sna[loop[last_idx]][j]); } sna[loop[last_idx]].swipeChildren(); } return orphans; } std::string SubstLoopBreaker::printGraphAndLoops(const vec &startNodes, const std::vector>& loops) { if (loops.size() == 0) std::cerr << "No loops\n"; int count = 0; for (const vec & loop : loops) { std::cerr << "Loop " << count++ << std::endl; for (SNRef snr: loop) std::cerr << " " << logic.pp(sna[snr].getTr()) << std::endl; } std::stringstream ss; // Debug: visualize a bit. ss << "digraph foo {\n"; for (int i = 0; i < startNodes.size(); i++) { ss << " " << logic.pp(sna[startNodes[i]].getTr()) << " [shape=box]\n"; } Map seen; for (int i = 0; i < startNodes.size(); i++) { vec queue; queue.push(startNodes[i]); while (queue.size() > 0) { SNRef n = queue.last(); queue.pop(); PTRef n_tr = sna[n].getTr(); if (seen.has(n_tr)) continue; seen.insert(n_tr, true); for (int j = 0; j < sna[n].nChildren(); j++) { SNRef sn = sna[n][j]; if (sn != SNRef_Undef) { ss << " " << logic.pp(sna[n].getTr()) << " -> " << logic.pp(sna[sn].getTr()) << ";\n"; queue.push(sn); } } } } for (const auto & loop : loops) { for (int j = 0; j < loop.size()-1; j++) { ss << " " << logic.pp(sna[loop[j]].getTr()) << " -> " << logic.pp(sna[loop[(j + 1)]].getTr()) << " [style=dotted];\n"; } SNRef last = loop[loop.size()-1]; auto in = logic.pp(sna[last].getTr()); for (int j = 0; j < sna[last].nChildren(); j++) { auto out = logic.pp(sna[sna[last][j]].getTr()); ss << " " << in << " -> " << out << " [style=dashed];\n"; } } ss << "}"; return ss.str(); } opensmt-2.5.2/src/logics/SubstLoopBreaker.h000066400000000000000000000160341445011647600206670ustar00rootroot00000000000000// // Created by prova on 21.11.19. // #ifndef OPENSMT_SUBSTLOOPBREAKER_H #define OPENSMT_SUBSTLOOPBREAKER_H #include #include #include #include #include #include #include // For breaking substitution loops enum class NStatus { inStack, complete, unseen }; template struct Ref { uint32_t x; Ref() : x(INT32_MAX-1) {} Ref(uint32_t i) : x(i) {} inline friend bool operator== (const Ref& a1, const Ref& a2) { return a1.x == a2.x; } inline friend bool operator!= (const Ref& a1, const Ref& a2) { return a1.x != a2.x; } inline friend bool operator< (const Ref& a1, const Ref& a2) { return a1.x > a2.x; } }; class TVLr {}; typedef Ref TVLRef; static TVLRef TVLRef_Undef = {INT32_MAX}; class SNr {}; typedef Ref SNRef; static SNRef SNRef_Undef = {INT32_MAX}; class TargetVarList { friend class TargetVarListAllocator; private: struct { unsigned sz : 30; unsigned proc : 2; } header; union { SNRef s; PTRef t; } vars[0]; TargetVarList(vec&& _children); public: bool unprocessed() const { return header.proc == 0; } bool processing() const { return header.proc == 1; } bool processed() const { return header.proc == 2; } void setProcessed() { header.proc = 2; } void setProcessing() { header.proc = 1; } int size() const { return header.sz; } SNRef operator[] (int i) const { assert(i < size()); assert(processed() || processing() ); return vars[i].s; } SNRef& operator[] (int i) { assert(i < size()); assert(processed() || processing() ); return vars[i].s; } PTRef getChildTerm (int i) const { assert(i < size()); assert(unprocessed() || processing() ); return vars[i].t; } }; class TargetVarListAllocator: RegionAllocator { static int targetVarList32Size(int size) { return (sizeof(TargetVarList) + size*sizeof(SNRef))/sizeof(uint32_t); } public: TargetVarListAllocator(uint32_t start_cap) : RegionAllocator(start_cap) {} TargetVarListAllocator() {} TVLRef alloc(vec&& _children); TargetVarList & operator[](TVLRef r) { return (TargetVarList&)RegionAllocator::operator[](r.x); } const TargetVarList & operator[](TVLRef r) const { return (TargetVarList&)RegionAllocator::operator[](r.x); } private: TargetVarList* lea(TVLRef r) { return (TargetVarList*)RegionAllocator::lea(r.x); } }; class SubstNode { friend class SubstNodeAllocator; private: TargetVarListAllocator& tvla; int procChild; int index; int lowlink; NStatus status; PTRef tr; SNRef parent; TVLRef children; SubstNode(PTRef tr, TargetVarListAllocator& tvla) : tvla(tvla) , procChild(0) , index(-1) , lowlink(-1) , status(NStatus::unseen) , tr(tr) , parent(SNRef_Undef) {} SubstNode(PTRef tr, vec&& children, TargetVarListAllocator& tvla) : SubstNode(tr, tvla) { this->children = tvla.alloc(std::move(children)); } SubstNode(PTRef tr, TVLRef children, TargetVarListAllocator& tvla) : SubstNode(tr, tvla) { this->children = children; } public: PTRef getTr() const { return tr; } SNRef getParent() const { return parent; } void setParent(SNRef p) { parent = p; } void setIndex(int i) { index = i; } int getIndex() { return index; } void setLowLink(int i) { lowlink = i; } int getLowLink() const { return lowlink; } void setStatus(NStatus s) { status = s; } NStatus getStatus() const { return status; } int nChildren() const { if (children == TVLRef_Undef) return 0; return tvla[children].size(); } SNRef& operator[](int i) { return tvla[children][i]; } SNRef operator[](int i) const { return tvla[children][i]; } PTRef getChildTerm(int i) const { return tvla[children].getChildTerm(i); } SNRef getNextChild(); void updateLowLink(int i) { lowlink = lowlink < i ? lowlink : i; } bool processed() const { return tvla[children].processed(); } bool processing() const { return tvla[children].processing(); } void setProcessed() { tvla[children].setProcessed(); } void setProcessing() { tvla[children].setProcessing(); } bool hasChildren() const { return children != TVLRef_Undef; } void swipeChildren() { children = TVLRef_Undef; } void clearTarjan() { procChild = 0; index = -1; lowlink = -1; status = NStatus::unseen; } }; class SubstNodeAllocator : RegionAllocator { private: static int substNode32Size() { return sizeof(SubstNode) / sizeof(uint32_t); } TargetVarListAllocator& tla; const Logic& logic; Map TargetToTargetVarListRef; vec getVars(PTRef term) const; Map SourceToSNRef; vec SNRefs; public: SubstNodeAllocator(TargetVarListAllocator& tla, const Logic& l, uint32_t start_cap) : RegionAllocator(start_cap), tla(tla), logic(l) {} SNRef alloc(PTRef tr, PTRef target); SubstNode& operator[](SNRef r) { return (SubstNode&)RegionAllocator::operator[](r.x); } const SubstNode& operator[](SNRef r) const { return (SubstNode&)RegionAllocator::operator[](r.x); } SNRef getSNRefBySource(PTRef ptr) const { return SourceToSNRef[ptr]; } void clearTarjan(); private: SubstNode* lea(SNRef r) { return (SubstNode*)RegionAllocator::lea(r.x); } }; class TarjanAlgorithm { vec controlStack; vec tarjanStack; SubstNodeAllocator& sna; int index; void addNode(SNRef n); public: TarjanAlgorithm(SubstNodeAllocator &sna) : sna(sna), index(0) {} ~TarjanAlgorithm() { sna.clearTarjan(); } std::vector> getLoops(SNRef startNode); }; class SubstLoopBreaker { private: const Logic& logic; Map seen; TargetVarListAllocator tvla; SubstNodeAllocator sna; public: SubstLoopBreaker(const Logic& l) : logic(l), tvla(1024), sna(tvla, logic, 1024) {} Logic::SubstMap operator() (MapWithKeys&& substs); vec constructSubstitutionGraph(const MapWithKeys& substKeysAndVals); std::vector> findLoops(vec& startNodes); vec breakLoops(const std::vector>& loops); std::string printGraphAndLoops(const vec& startNodes, const std::vector>& loops); vec minimizeRoots(vec&& roots) { return std::move(roots); }// nothing here, maybe do some attempt? Logic::SubstMap constructLooplessSubstitution(MapWithKeys&& substs); }; #endif //OPENSMT_SUBSTLOOPBREAKER_H opensmt-2.5.2/src/logics/TestSimplify.cc000066400000000000000000000063541445011647600202370ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ #include "SSort.h" #include "SStore.h" #include "SymStore.h" #include "Symbol.h" #include "PtStore.h" #include "Pterm.h" #include "Logic.h" int main(int argc, char** argv) { SMTConfig cfg(argc, argv); Logic logic(cfg); assert(logic.setLogic("QF_UF")); SRef bsr = logic.getSort_bool(); PTRef t1 = logic.mkConst(bsr, "t1"); PTRef t2 = logic.mkConst(bsr, "t2"); vec args1; args1.push(t1); args1.push(logic.getTerm_true()); args1.push(t1); args1.push(t2); char* msg; // No simplification cerr << "Term " << logic.getSym_and().x << " (" << logic.getSymName(logic.getSym_and()) << ")" << (logic.commutes(logic.getSym_and()) ? " commutes." : " does not commute.") << endl; PTRef and1 = logic.insertTerm(logic.getSym_and(), args1, &msg); vec args2; args2.push(t1); args2.push(t2); PTRef and2 = logic.insertTerm(logic.getSym_and(), args2, &msg); vec args3; args3.push(and1); args3.push(and1); args3.push(and2); PTRef or1 = logic.insertTerm(logic.getSym_or(), args3, &msg); Pterm& or1_t_old = logic.getPterm(or1); cout << "before: " << logic.printTerm(or1, true) << endl; cout << " - old term num " << or1.x << endl; cout << " - old term size " << or1_t_old.size() << endl; cout << " - old term children " << endl; for (int i = 0; i < or1_t_old.size(); i++) cout << " " << or1_t_old[i].x << endl; lbool res = logic.simplifyTree(or1); if (res == l_True) cout << "simplified to true" << endl; else if (res == l_False) cout << "simplified to false" << endl; else { Pterm& or1_t = logic.getPterm(or1); cout << " - new term num " << or1.x << endl; cout << " - new term size " << or1_t.size() << endl; cout << " - new term children " << endl; for (int i = 0; i < or1_t.size(); i++) cout << " " << or1_t[i].x << endl; cerr << endl; cout << "after: " << logic.printTerm(or1) << endl; } return 0; } opensmt-2.5.2/src/logics/Theory.cc000066400000000000000000000106771445011647600170600ustar00rootroot00000000000000#include "Theory.h" #include "Substitutor.h" //#include "MainSolver.h" //#include "logics/Logic.h" // The Collate function is constructed from all frames up to the current // one and will be used to simplify the formulas in the current frame // formulas[curr]. // (1) Construct the collate function as a conjunction of formulas up to curr. // (2) From the coll function compute units_{curr} // (3) Use units_1 /\ ... /\ units_{curr} to simplify formulas[curr] // // In addition we add the transitivie equalities as a further // simplification (critical for the eq_diamond instances in QF_UF of // smtlib). // PTRef Theory::getCollateFunction(const vec & formulas, int curr) { assert(curr < formulas.size()); // XXX // getLogic().dumpHeaderToFile(std::cout); // getLogic().dumpFormulaToFile(std::cout, pfstore[formulas[1]].formulas[0]); vec coll_f_args; // compute coll_f as (a_1^0 /\ ... /\ a_{n_1}^0) /\ ... /\ (a_1^{curr} /\ ... /\ a_{n_k}^{curr}) for (int i = 0; i <= curr; i++) { for (int j = 0; j < pfstore[formulas[i]].size(); j++) coll_f_args.push(pfstore[formulas[i]][j]); } return getLogic().mkAnd(std::move(coll_f_args)); } Theory::SubstitutionResult Theory::computeSubstitutions(const PTRef fla) { SubstitutionResult result; assert(config.do_substitutions() && !config.produce_inter()); PTRef root = fla; // l_True : exists and is valid // l_False : exists but has been disabled to break symmetries Logic::SubstMap allsubsts; // This computes the new unit clauses to curr_frame.units until closure while (true) { // update the current simplification formula PTRef simp_formula = root; MapWithKeys new_units; vec current_units_vec; // Get U_i bool rval = getLogic().getNewFacts(simp_formula, new_units); if (not rval) { return SubstitutionResult{{}, getLogic().getTerm_false()}; } // Add the newly obtained units to the list of all substitutions // Clear the previous units const auto & new_units_vec = new_units.getKeys(); for (PTRef key : new_units_vec) { current_units_vec.push(PtAsgn{key, new_units[key]}); } auto [res, newsubsts] = getLogic().retrieveSubstitutions(current_units_vec); getLogic().substitutionsTransitiveClosure(newsubsts); // remember the substitutions for models for (PTRef key : newsubsts.getKeys()) { if (!allsubsts.has(key)) { const auto target = newsubsts[key]; allsubsts.insert(key, target); } } if (res != l_Undef) root = (res == l_True ? getLogic().getTerm_true() : getLogic().getTerm_false()); PTRef new_root = Substitutor(getLogic(), newsubsts).rewrite(root); bool cont = new_root != root; root = new_root; if (!cont) break; } #ifdef SIMPLIFY_DEBUG cerr << "Number of substitutions: " << allsubsts.elems() << endl; vec::Pair> subst_vec; allsubsts.getKeysAndVals(subst_vec); printf("Substitutions:\n"); for (int i = 0; i < subst_vec.size(); i++) { PTRef source = subst_vec[i].key; PTRef target = subst_vec[i].data.tr; lbool sgn = subst_vec[i].data.sgn; printf(" %s -> %s (%s)\n", getLogic().printTerm(source), getLogic().printTerm(target), sgn == l_True ? "enabled" : "disabled"); } #endif result.result = root; result.usedSubstitution = std::move(allsubsts); return result; } void Theory::printFramesAsQuery(const vec & frames, std::ostream & s) const { getLogic().dumpHeaderToFile(s); for (int i = 0; i < frames.size(); i++) { if (i > 0) s << "(push 1)\n"; getLogic().dumpFormulaToFile(s, pfstore[frames[i]].root); } getLogic().dumpChecksatToFile(s); } PTRef Theory::flaFromSubstitutionResult(const Theory::SubstitutionResult & sr) { Logic & logic = getLogic(); vec args; const auto & entries = sr.usedSubstitution.getKeys(); for (auto entry : entries) { auto target = sr.usedSubstitution[entry]; args.push(logic.mkEq(entry, target)); } args.push(sr.result); return logic.mkAnd(std::move(args)); } PTRef Theory::applySubstitutionBasedSimplificationIfEnabled(PTRef root) { return config.do_substitutions() ? flaFromSubstitutionResult(computeSubstitutions(root)) : root; } opensmt-2.5.2/src/logics/Theory.h000066400000000000000000000202241445011647600167070ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2016 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #ifndef THEORY_H #define THEORY_H #include #include "Logic.h" #include "CUFLogic.h" #include "BVLogic.h" #include "UFTHandler.h" #include "CUFTHandler.h" #include "Alloc.h" #include "PartitionManager.h" // Simplification in frames: // A frame F_i consists of: // P_i : a list of asserts given on this frame // U_i : the unit clauses, or facts, implied by P_1 /\ ... /\ P_i // R_i : P_i simplified with U_1, ..., U_i // // We require that U_i \cap U_j = \emptyset // if U_1 /\ ... /\ U_i is unsatisfiable, then R_i must be false // R_i must not be simplified with any U_j such that j > i. // // Some of the U_i might be theory equalities. These allow potentially // more simplifications. For instance in arithmetics if (= a b) \in U_j, // a may be substituted everywhere in U_k, j <= k <= i. These must be // simplified using a theory specific simplifier. This will be part of // the simplifications we do. // // The simplification has to use information from the theory solver and // propositional structure to accomplish this. The unit clauses need to // be derived in a closure. For the closure we need the problem P_i // separately as input to computeSubstitutions. Hence the interface // will be as follows: // - units U_1 ... U_{curr-1} // - conjunction of simplified problems R_i ... R_{curr-1} // - The problem to be simplified P_{curr} // - The last frame where the simplified problem R_{curr} and the new // unit clauses U_{curr} will be placed // class PushFrameAllocator; struct FrameId { uint32_t id; bool operator== (const FrameId other) const { return id == other.id; } bool operator!= (const FrameId other) const { return id != other.id; } }; static struct FrameId FrameId_Undef = { INT32_MAX }; static struct FrameId FrameId_bottom = { 0 }; struct PushFrame { friend PushFrameAllocator; private: FrameId id; public: FrameId getId() const { return id; } int size() const { return formulas.size(); } void push(PTRef tr) { formulas.push(tr); } PTRef operator[] (int i) const { return formulas[i]; } PTRef root; vec formulas; bool unsat; // If true than the stack of frames with this frame at top is UNSAT PushFrame(PushFrame& pf); PushFrame() : id(FrameId_Undef), root(PTRef_Undef) {} // For pushing into vecs we need a default. PushFrame operator= (PushFrame& other); private: PushFrame(uint32_t id) : id({id}), root(PTRef_Undef), unsat(false) {} }; struct PFRef { uint32_t x; inline friend bool operator== (const PFRef& a1, const PFRef& a2) { return a1.x == a2.x; }; }; const static struct PFRef PFRef_Undef = {INT32_MAX}; // No global variable for storing the push frame id. I decided to // implement this as my own memory allocation. There's no free though // at the moment, the implementation is very minimalistic. class PushFrameAllocator : public RegionAllocator { private: int id_counter; std::vector allocatedFrames; public: PushFrameAllocator() : id_counter(FrameId_bottom.id) {} PushFrameAllocator(uint32_t init_capacity) : RegionAllocator(init_capacity), id_counter(FrameId_bottom.id) {} ~PushFrameAllocator() { for (PFRef ref : allocatedFrames) { lea(ref)->PushFrame::~PushFrame(); } } void moveTo(PushFrameAllocator& to) { to.id_counter = id_counter; RegionAllocator::moveTo(to); to.allocatedFrames = std::move(allocatedFrames); } PFRef alloc() { uint32_t v = RegionAllocator::alloc(sizeof(PushFrame)/sizeof(uint32_t)); PFRef r = {v}; new (lea(r)) PushFrame(id_counter++); allocatedFrames.push_back(r); return r; } PushFrame& operator[](PFRef r) { return (PushFrame&)RegionAllocator::operator[](r.x); } const PushFrame& operator[](PFRef r) const { return (PushFrame&)RegionAllocator::operator[](r.x); } PushFrame* lea (PFRef r) { return (PushFrame*)RegionAllocator::lea(r.x); } PFRef ael (const PushFrame* t) { RegionAllocator::Ref r = RegionAllocator::ael((uint32_t*)t); return { r }; } }; class Theory { protected: struct SubstitutionResult { Logic::SubstMap usedSubstitution; PTRef result; }; SMTConfig & config; PTRef getCollateFunction(const vec & formulas, int curr); Theory(SMTConfig &c) : config(c) { } inline bool keepPartitions() const { return config.produce_inter(); } /* Computes the final formula from substitution result. * The formula is the computed formula with all substitutions conjoined in form of equalities */ PTRef flaFromSubstitutionResult(const SubstitutionResult & sr); PTRef applySubstitutionBasedSimplificationIfEnabled(PTRef); public: PushFrameAllocator pfstore {1024}; virtual Logic &getLogic() = 0; virtual const Logic &getLogic() const = 0; virtual TSolverHandler &getTSolverHandler() = 0; virtual bool simplify(const vec&, PartitionManager& pmanager, int) = 0; // Simplify a vector of PushFrames in an incrementality-aware manner SubstitutionResult computeSubstitutions(PTRef fla); void printFramesAsQuery(const vec & frames, std::ostream & s) const; virtual bool okToPartition(PTRef) const { return true; } virtual ~Theory() {}; }; class UFTheory : public Theory { private: Logic & uflogic; UFTHandler tshandler; public: UFTheory(SMTConfig & c, Logic & logic ) : Theory(c) , uflogic(logic) , tshandler(c, uflogic) { } ~UFTheory() {} virtual Logic& getLogic() override { return uflogic; } virtual const Logic& getLogic() const override { return uflogic; } virtual UFTHandler& getTSolverHandler() override { return tshandler; } virtual const UFTHandler& getTSolverHandler() const { return tshandler; } virtual bool simplify(const vec&, PartitionManager& pmanager, int) override; }; class CUFTheory : public Theory { private: BVLogic & cuflogic; CUFTHandler tshandler; static const int i_default_bitwidth; public: CUFTheory(SMTConfig & c, BVLogic & logic) : Theory(c) , cuflogic(logic) , tshandler(c, cuflogic) { } ~CUFTheory() {} virtual BVLogic& getLogic() override { return cuflogic; } virtual const BVLogic& getLogic() const override { return cuflogic; } virtual CUFTHandler& getTSolverHandler() override { return tshandler; } virtual const CUFTHandler& getTSolverHandler() const { return tshandler; } virtual bool simplify(const vec&, PartitionManager& pmanager, int) override; }; #endif opensmt-2.5.2/src/logics/UFLATheory.cc000066400000000000000000000200401445011647600175110ustar00rootroot00000000000000#include "UFLATheory.h" #include "ArithmeticEqualityRewriter.h" #include "ArrayHelpers.h" #include "DistinctRewriter.h" #include "LATheory.h" #include "OsmtInternalException.h" #include "Substitutor.h" #include "TreeOps.h" bool UFLATheory::simplify(const vec& formulas, PartitionManager &, int curr) { auto & currentFrame = pfstore[formulas[curr]]; if (this->keepPartitions()) { throw OsmtInternalException("Mode not supported for QF_UFLRA yet"); } else { PTRef coll_f = getCollateFunction(formulas, curr); PTRef fla = applySubstitutionBasedSimplificationIfEnabled(coll_f); fla = rewriteDistincts(getLogic(), fla); fla = rewriteDivMod(logic, fla); PTRef purified = purify(fla); if (logic.hasArrays()) { purified = instantiateReadOverStore(logic, purified); } PTRef noArithmeticEqualities = splitArithmeticEqualities(purified); this->getTSolverHandler().setInterfaceVars(getInterfaceVars(noArithmeticEqualities)); currentFrame.root = noArithmeticEqualities; } return true; } namespace { bool isArithmeticSymbol(ArithLogic const & logic, SymRef sym) { return logic.isPlus(sym) or logic.isTimes(sym) or logic.isLeq(sym); } bool isUninterpreted(ArithLogic const & logic, SymRef sym) { return logic.isUF(sym); } /* * Helper function to determine if an arithmetic equality is pure or not * // NOTE: This is correct only under the condition that children have been purified */ bool isPureArithmeticEquality(PTRef ptref, ArithLogic & logic) { assert(logic.isNumEq(ptref)); auto isUForArray = [&](SymRef sym) { return isUninterpreted(logic, sym) or logic.isArraySelect(sym); }; auto const & term = logic.getPterm(ptref); PTRef lhs = term[0]; PTRef rhs = term[1]; return not (isUForArray(logic.getSymRef(lhs)) or isUForArray(logic.getSymRef(rhs))); } class PurifyConfig : public DefaultRewriterConfig { static constexpr const char * prefix = ".purify_"; ArithLogic & logic; Logic::SubstMap freshVarMap; vec auxArgs; void createVarFor(PTRef ptref) { if (freshVarMap.has(ptref)) { return; } assert(logic.yieldsSortNum(ptref)); auto name = prefix + std::to_string(ptref.x); PTRef var = logic.mkVar(logic.getSortRef(ptref), name.c_str()); freshVarMap.insert(ptref, var); } template PTRef rewriteInternal(PTRef ptref, TIsInterestingChild && isInteresting) { auxArgs.clear(); bool needsRewriting = false; auto nargs = logic.getPterm(ptref).nargs(); for (unsigned i = 0; i < nargs; ++i) { PTRef child = logic.getPterm(ptref)[i]; if (isInteresting(child)) { createVarFor(child); auxArgs.push(freshVarMap[child]); needsRewriting = true; } else { auxArgs.push(child); } } return needsRewriting ? logic.insertTerm(logic.getPterm(ptref).symb(), std::move(auxArgs)) : ptref; } public: PurifyConfig(ArithLogic & logic) : DefaultRewriterConfig(), logic(logic) { } PTRef rewrite(PTRef ptref) override { auto const & term = logic.getPterm(ptref); if (isArithmeticSymbol(logic, term.symb())) { return rewriteInternal(ptref, [this](PTRef child) { return isUninterpreted(logic, logic.getSymRef(child)) or (logic.hasArrays() and logic.isArraySelect(child)); }); } else if (isUninterpreted(logic, term.symb()) or logic.isArraySelect(term.symb()) or logic.isArrayStore(term.symb())) { return rewriteInternal(ptref, [this](PTRef child) { return isArithmeticSymbol(logic, logic.getSymRef(child)) and not logic.isConstant(child); }); } else if (logic.isNumEq(term.symb())) { if (not isPureArithmeticEquality(ptref, logic)) { return rewriteInternal(ptref, [this](PTRef child) { return isArithmeticSymbol(logic, logic.getSymRef(child)) and not logic.isConstant(child); }); } } return ptref; } Logic::SubstMap const & getPurificationMap() const { return freshVarMap; } }; class Purifier : public Rewriter { PurifyConfig config; public: Purifier(ArithLogic & logic) : Rewriter(logic, config), config(logic) {} Logic::SubstMap const & getPurificationMap() const { return config.getPurificationMap(); } }; } PTRef UFLATheory::purify(PTRef fla) { Purifier purifier(logic); PTRef rewritten = purifier.rewrite(fla); auto const & renameMap = purifier.getPurificationMap(); vec equalities; equalities.capacity(renameMap.getSize() + 1); for (PTRef key : renameMap.getKeys()) { equalities.push(logic.mkEq(key, renameMap[key])); } equalities.push(rewritten); return logic.mkAnd(equalities); } template class RewriterConfig : public DefaultRewriterConfig { ArithLogic & logic; Pred pred; public: RewriterConfig(ArithLogic & logic, Pred && pred) : logic(logic), pred(std::move(pred)) {} bool previsit(PTRef term) override { return logic.hasSortBool(term) and not logic.isIte(term); } PTRef rewrite(PTRef term) override { if (logic.isNumEq(term) and pred(term)) { Pterm const & p = logic.getPterm(term); PTRef a1 = p[0]; PTRef a2 = p[1]; PTRef i1 = logic.mkLeq(a1, a2); PTRef i2 = logic.mkGeq(a1, a2); return logic.mkAnd(i1, i2); } return term; } }; PTRef UFLATheory::splitArithmeticEqualities(PTRef fla) { auto config = RewriterConfig(logic, [this](PTRef term) { return isPureArithmeticEquality(term, logic); } ); auto rewriter = Rewriter(logic, config); return rewriter.rewrite(fla); } class CollectInterfaceVariablesConfig : public DefaultVisitorConfig { vec interfaceVars; ArithLogic & logic; enum class Type : char { Arith, Unint, Both }; MapWithKeys occurrences; void updateOccurrenceUsingType(PTRef child, Type seenType) { Type t; if (not occurrences.peek(child, t)) { occurrences.insert(child, seenType); if (seenType == Type::Both) { interfaceVars.push(child); } } else { if (t != seenType and t != Type::Both) { occurrences[child] = Type::Both; interfaceVars.push(child); } } } public: CollectInterfaceVariablesConfig(ArithLogic & logic) : DefaultVisitorConfig(), logic(logic) {} void visit(PTRef ptref) override { SymRef symbolRef = logic.getSymRef(ptref); if (isArithmeticSymbol(logic, symbolRef)) { for (PTRef child : logic.getPterm(ptref)) { if (logic.isVar(child) or logic.isNumConst(child)) { updateOccurrenceUsingType(child, Type::Arith); } } } else if (isUninterpreted(logic, symbolRef) or logic.isEquality(symbolRef) or logic.isArraySelect(symbolRef) or logic.isArrayStore(symbolRef)) { for (PTRef child : logic.getPterm(ptref)) { if (logic.isNumVar(child) or logic.isNumConst(child)) { updateOccurrenceUsingType(child, logic.isNumConst(child) ? Type::Both : Type::Unint); } } } } vec const & getInterfaceVars() const { return interfaceVars; } }; vec UFLATheory::getInterfaceVars(PTRef fla) { CollectInterfaceVariablesConfig config(logic); TermVisitor(logic, config).visit(fla); vec const & interfaceVars = config.getInterfaceVars(); vec ret; interfaceVars.copyTo(ret); return ret; } opensmt-2.5.2/src/logics/UFLATheory.h000066400000000000000000000040571445011647600173650ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2016 Antti Hyvarinen 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. *********************************************************************/ #ifndef UFLRATheory_h #define UFLRATheory_h #include "Theory.h" #include "UFLATHandler.h" #include "ArithLogic.h" class UFLATheory : public Theory { private: ArithLogic & logic; UFLATHandler uflatshandler; public: UFLATheory(SMTConfig& c, ArithLogic & logic) : Theory(c) , logic(logic) , uflatshandler(c, logic) { } virtual ArithLogic& getLogic() override { return logic; } virtual const ArithLogic& getLogic() const override { return logic; } virtual UFLATHandler& getTSolverHandler() override { return uflatshandler; } virtual bool simplify(const vec&, PartitionManager&, int) override; protected: PTRef purify(PTRef fla); PTRef splitArithmeticEqualities(PTRef fla); vec getInterfaceVars(PTRef fla); }; #endif opensmt-2.5.2/src/logics/UFTheory.cc000066400000000000000000000017271445011647600173070ustar00rootroot00000000000000#include "Theory.h" #include "TreeOps.h" #include "DistinctRewriter.h" // // Simplify with unit propagation, add the diamond equalities if // present. If partitions cannot mix, do no simplifications but just // update the root. // bool UFTheory::simplify(const vec& formulas, PartitionManager &, int curr) { auto & currentFrame = pfstore[formulas[curr]]; if (this->keepPartitions()) { currentFrame.root = getLogic().mkAnd(currentFrame.formulas); } else { PTRef coll_f = getCollateFunction(formulas, curr); PTRef trans = getLogic().learnEqTransitivity(coll_f); coll_f = getLogic().mkAnd(coll_f, trans); currentFrame.root = applySubstitutionBasedSimplificationIfEnabled(coll_f); } currentFrame.root = curr == 0 ? rewriteDistinctsKeepTopLevel(getLogic(), currentFrame.root) : rewriteDistincts(getLogic(), currentFrame.root); AppearsInUfVisitor(getLogic()).visit(currentFrame.root); return true; } opensmt-2.5.2/src/minisat/000077500000000000000000000000001445011647600154505ustar00rootroot00000000000000opensmt-2.5.2/src/minisat/CMakeLists.txt000066400000000000000000000004761445011647600202170ustar00rootroot00000000000000add_library(minisat INTERFACE) target_include_directories(minisat INTERFACE ${CMAKE_CURRENT_LIST_DIR}/mtl INTERFACE ${CMAKE_CURRENT_LIST_DIR}/core ) install(FILES mtl/Heap.h mtl/Map.h mtl/Vec.h mtl/Alg.h mtl/Sort.h mtl/Queue.h core/SolverTypes.h mtl/MapWithKeys.h DESTINATION ${INSTALL_HEADERS_DIR}) opensmt-2.5.2/src/minisat/LICENSE000066400000000000000000000021011445011647600164470ustar00rootroot00000000000000MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson 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. opensmt-2.5.2/src/minisat/README000066400000000000000000000006201445011647600163260ustar00rootroot00000000000000Directory overview: ================== mtl/ Mini Template Library core/ A core version of the solver simp/ An extended solver with simplification capabilities README LICENSE To build (release version: without assertions, statically linked, etc): ====================================================================== cd { core | simp } gmake rs Usage: ====== TODO opensmt-2.5.2/src/minisat/core/000077500000000000000000000000001445011647600164005ustar00rootroot00000000000000opensmt-2.5.2/src/minisat/core/Main.C000066400000000000000000000260701445011647600173750ustar00rootroot00000000000000/******************************************************************************************[Main.C] MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson 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. **************************************************************************************************/ #include #include #include #include #include #include #include "Solver.h" /*************************************************************************************/ #ifdef _MSC_VER #include static inline double cpuTime(void) { return (double)clock() / CLOCKS_PER_SEC; } #else #include #include #include static inline double cpuTime(void) { struct rusage ru; getrusage(RUSAGE_SELF, &ru); return (double)ru.ru_utime.tv_sec + (double)ru.ru_utime.tv_usec / 1000000; } #endif #if defined(__linux__) static inline int memReadStat(int field) { char name[256]; pid_t pid = getpid(); sprintf(name, "/proc/%d/statm", pid); FILE* in = fopen(name, "rb"); if (in == NULL) return 0; int value; for (; field >= 0; field--) fscanf(in, "%d", &value); fclose(in); return value; } static inline uint64_t memUsed() { return (uint64_t)memReadStat(0) * (uint64_t)getpagesize(); } #elif defined(__FreeBSD__) static inline uint64_t memUsed(void) { struct rusage ru; getrusage(RUSAGE_SELF, &ru); return ru.ru_maxrss*1024; } #else static inline uint64_t memUsed() { return 0; } #endif #if defined(__GLIBC__) #include #endif //================================================================================================= // DIMACS Parser: #define CHUNK_LIMIT 1048576 class StreamBuffer { gzFile in; char buf[CHUNK_LIMIT]; int pos; int size; void assureLookahead() { if (pos >= size) { pos = 0; size = gzread(in, buf, sizeof(buf)); } } public: StreamBuffer(gzFile i) : in(i), pos(0), size(0) { assureLookahead(); } int operator * () { return (pos >= size) ? EOF : buf[pos]; } void operator ++ () { pos++; assureLookahead(); } }; //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - template static void skipWhitespace(B& in) { while ((*in >= 9 && *in <= 13) || *in == 32) ++in; } template static void skipLine(B& in) { for (;;){ if (*in == EOF || *in == '\0') return; if (*in == '\n') { ++in; return; } ++in; } } template static int parseInt(B& in) { int val = 0; bool neg = false; skipWhitespace(in); if (*in == '-') neg = true, ++in; else if (*in == '+') ++in; if (*in < '0' || *in > '9') reportf("PARSE ERROR! Unexpected char: %c\n", *in), exit(3); while (*in >= '0' && *in <= '9') val = val*10 + (*in - '0'), ++in; return neg ? -val : val; } template static void readClause(B& in, Solver& S, vec& lits) { int parsed_lit, var; lits.clear(); for (;;){ parsed_lit = parseInt(in); if (parsed_lit == 0) break; var = abs(parsed_lit)-1; while (var >= S.nVars()) S.newVar(); lits.push( (parsed_lit > 0) ? Lit(var) : ~Lit(var) ); } } template static bool match(B& in, char* str) { for (; *str != 0; ++str, ++in) if (*str != *in) return false; return true; } template static void parse_DIMACS_main(B& in, Solver& S) { vec lits; for (;;){ skipWhitespace(in); if (*in == EOF) break; else if (*in == 'p'){ if (match(in, "p cnf")){ int vars = parseInt(in); int clauses = parseInt(in); reportf("| Number of variables: %-12d |\n", vars); reportf("| Number of clauses: %-12d |\n", clauses); }else{ reportf("PARSE ERROR! Unexpected char: %c\n", *in), exit(3); } } else if (*in == 'c' || *in == 'p') skipLine(in); else readClause(in, S, lits), S.addClause(lits); } } // Inserts problem into solver. // static void parse_DIMACS(gzFile input_stream, Solver& S) { StreamBuffer in(input_stream); parse_DIMACS_main(in, S); } //================================================================================================= void printStats(Solver& solver) { double cpu_time = cpuTime(); uint64_t mem_used = memUsed(); reportf("restarts : %lld\n", solver.starts); reportf("conflicts : %-12lld (%.0f /sec)\n", solver.conflicts , solver.conflicts /cpu_time); reportf("decisions : %-12lld (%4.2f %% random) (%.0f /sec)\n", solver.decisions, (float)solver.rnd_decisions*100 / (float)solver.decisions, solver.decisions /cpu_time); reportf("propagations : %-12lld (%.0f /sec)\n", solver.propagations, solver.propagations/cpu_time); reportf("conflict literals : %-12lld (%4.2f %% deleted)\n", solver.tot_literals, (solver.max_literals - solver.tot_literals)*100 / (double)solver.max_literals); if (mem_used != 0) reportf("Memory used : %.2f MB\n", mem_used / 1048576.0); reportf("CPU time : %g s\n", cpu_time); } Solver* solver; static void SIGINT_handler(int signum) { reportf("\n"); reportf("*** INTERRUPTED ***\n"); printStats(*solver); reportf("\n"); reportf("*** INTERRUPTED ***\n"); exit(1); } //================================================================================================= // Main: void printUsage(char** argv) { reportf("USAGE: %s [options] \n\n where input may be either in plain or gzipped DIMACS.\n\n", argv[0]); reportf("OPTIONS:\n\n"); reportf(" -polarity-mode = {true,false,rnd}\n"); reportf(" -decay = [ 0 - 1 ]\n"); reportf(" -rnd-freq = [ 0 - 1 ]\n"); reportf(" -verbosity = {0,1,2}\n"); reportf("\n"); } const char* hasPrefix(const char* str, const char* prefix) { int len = strlen(prefix); if (strncmp(str, prefix, len) == 0) return str + len; else return NULL; } int main(int argc, char** argv) { Solver S; S.verbosity = 1; int i, j; const char* value; for (i = j = 0; i < argc; i++){ if ((value = hasPrefix(argv[i], "-polarity-mode="))){ if (strcmp(value, "true") == 0) S.polarity_mode = Solver::polarity_true; else if (strcmp(value, "false") == 0) S.polarity_mode = Solver::polarity_false; else if (strcmp(value, "rnd") == 0) S.polarity_mode = Solver::polarity_rnd; else{ reportf("ERROR! unknown polarity-mode %s\n", value); exit(0); } }else if ((value = hasPrefix(argv[i], "-rnd-freq="))){ double rnd; if (sscanf(value, "%lf", &rnd) <= 0 || rnd < 0 || rnd > 1){ reportf("ERROR! illegal rnd-freq constant %s\n", value); exit(0); } S.random_var_freq = rnd; }else if ((value = hasPrefix(argv[i], "-decay="))){ double decay; if (sscanf(value, "%lf", &decay) <= 0 || decay <= 0 || decay > 1){ reportf("ERROR! illegal decay constant %s\n", value); exit(0); } S.var_decay = 1 / decay; }else if ((value = hasPrefix(argv[i], "-verbosity="))){ int verbosity = (int)strtol(value, NULL, 10); if (verbosity == 0 && errno == EINVAL){ reportf("ERROR! illegal verbosity level %s\n", value); exit(0); } S.verbosity = verbosity; }else if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "-help") == 0 || strcmp(argv[i], "--help") == 0){ printUsage(argv); exit(0); }else if (strncmp(argv[i], "-", 1) == 0){ reportf("ERROR! unknown flag %s\n", argv[i]); exit(0); }else argv[j++] = argv[i]; } argc = j; reportf("This is MiniSat 2.0 beta\n"); #if defined(__GLIBC__) fpu_control_t oldcw, newcw; _FPU_GETCW(oldcw); newcw = (oldcw & ~_FPU_EXTENDED) | _FPU_DOUBLE; _FPU_SETCW(newcw); reportf("WARNING: for repeatability, setting FPU to use double precision\n"); #endif double cpu_time = cpuTime(); solver = &S; signal(SIGINT,SIGINT_handler); signal(SIGHUP,SIGINT_handler); if (argc == 1) reportf("Reading from standard input... Use '-h' or '--help' for help.\n"); gzFile in = (argc == 1) ? gzdopen(0, "rb") : gzopen(argv[1], "rb"); if (in == NULL) reportf("ERROR! Could not open file: %s\n", argc == 1 ? "" : argv[1]), exit(1); reportf("============================[ Problem Statistics ]=============================\n"); reportf("| |\n"); parse_DIMACS(in, S); gzclose(in); FILE* res = (argc >= 3) ? fopen(argv[2], "wb") : NULL; double parse_time = cpuTime() - cpu_time; reportf("| Parsing time: %-12.2f s |\n", parse_time); if (!S.simplify()){ reportf("Solved by unit propagation\n"); if (res != NULL) fprintf(res, "UNSAT\n"), fclose(res); printf("UNSATISFIABLE\n"); exit(20); } bool ret = S.solve(); printStats(S); reportf("\n"); printf(ret ? "SATISFIABLE\n" : "UNSATISFIABLE\n"); if (res != NULL){ if (ret){ fprintf(res, "SAT\n"); for (int i = 0; i < S.nVars(); i++) if (S.model[i] != l_Undef) fprintf(res, "%s%s%d", (i==0)?"":" ", (S.model[i]==l_True)?"":"-", i+1); fprintf(res, " 0\n"); }else fprintf(res, "UNSAT\n"); fclose(res); } #ifdef NDEBUG exit(ret ? 10 : 20); // (faster than "return", which will invoke the destructor for 'Solver') #endif } opensmt-2.5.2/src/minisat/core/Solver.C000066400000000000000000000567011445011647600177670ustar00rootroot00000000000000/****************************************************************************************[Solver.C] MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson 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. **************************************************************************************************/ #include "Solver.h" #include "Sort.h" #include //================================================================================================= // Constructor/Destructor: Solver::Solver() : // Parameters: (formerly in 'SearchParams') var_decay(1 / 0.95), clause_decay(1 / 0.999), random_var_freq(0.02) , restart_first(100), restart_inc(1.5), learntsize_factor((double)1/(double)3), learntsize_inc(1.1) // More parameters: // , expensive_ccmin (true) , polarity_mode (polarity_false) , verbosity (0) // Statistics: (formerly in 'SolverStats') // , starts(0), decisions(0), rnd_decisions(0), propagations(0), conflicts(0) , clauses_literals(0), learnts_literals(0), max_literals(0), tot_literals(0) , ok (true) , cla_inc (1) , var_inc (1) , qhead (0) , simpDB_assigns (-1) , simpDB_props (0) , order_heap (VarOrderLt(activity)) , random_seed (91648253) , progress_estimate(0) , remove_satisfied (true) {} Solver::~Solver() { for (int i = 0; i < learnts.size(); i++) free(learnts[i]); for (int i = 0; i < clauses.size(); i++) free(clauses[i]); } //================================================================================================= // Minor methods: // Creates a new SAT variable in the solver. If 'decision_var' is cleared, variable will not be // used as a decision variable (NOTE! This has effects on the meaning of a SATISFIABLE result). // Var Solver::newVar(bool sign, bool dvar) { int v = nVars(); watches .push(); // (list for positive literal) watches .push(); // (list for negative literal) reason .push(NULL); assigns .push(toInt(l_Undef)); level .push(-1); activity .push(0); seen .push(0); polarity .push((char)sign); decision_var.push((char)dvar); insertVarOrder(v); return v; } bool Solver::addClause(vec& ps) { assert(decisionLevel() == 0); if (!ok) return false; else{ // Check if clause is satisfied and remove false/duplicate literals: sort(ps); Lit p; int i, j; for (i = j = 0, p = lit_Undef; i < ps.size(); i++) if (value(ps[i]) == l_True || ps[i] == ~p) return true; else if (value(ps[i]) != l_False && ps[i] != p) ps[j++] = p = ps[i]; ps.shrink(i - j); } if (ps.size() == 0) return ok = false; else if (ps.size() == 1){ assert(value(ps[0]) == l_Undef); uncheckedEnqueue(ps[0]); return ok = (propagate() == NULL); }else{ Clause* c = Clause_new(ps, false); clauses.push(c); attachClause(*c); } return true; } void Solver::attachClause(Clause& c) { assert(c.size() > 1); watches[toInt(~c[0])].push(&c); watches[toInt(~c[1])].push(&c); if (c.learnt()) learnts_literals += c.size(); else clauses_literals += c.size(); } void Solver::detachClause(Clause& c) { assert(c.size() > 1); assert(find(watches[toInt(~c[0])], &c)); assert(find(watches[toInt(~c[1])], &c)); remove(watches[toInt(~c[0])], &c); remove(watches[toInt(~c[1])], &c); if (c.learnt()) learnts_literals -= c.size(); else clauses_literals -= c.size(); } void Solver::removeClause(Clause& c) { detachClause(c); free(&c); } bool Solver::satisfied(const Clause& c) const { for (int i = 0; i < c.size(); i++) if (value(c[i]) == l_True) return true; return false; } // Revert to the state at given level (keeping all assignment at 'level' but not beyond). // void Solver::cancelUntil(int level) { if (decisionLevel() > level){ for (int c = trail.size()-1; c >= trail_lim[level]; c--){ Var x = var(trail[c]); assigns[x] = toInt(l_Undef); insertVarOrder(x); } qhead = trail_lim[level]; trail.shrink(trail.size() - trail_lim[level]); trail_lim.shrink(trail_lim.size() - level); } } //================================================================================================= // Major methods: Lit Solver::pickBranchLit(int polarity_mode, double random_var_freq) { Var next = var_Undef; // Random decision: if (drand(random_seed) < random_var_freq && !order_heap.empty()){ next = order_heap[irand(random_seed,order_heap.size())]; if (toLbool(assigns[next]) == l_Undef && decision_var[next]) rnd_decisions++; } // Activity based decision: while (next == var_Undef || toLbool(assigns[next]) != l_Undef || !decision_var[next]) if (order_heap.empty()){ next = var_Undef; break; }else next = order_heap.removeMin(); bool sign = false; switch (polarity_mode){ case polarity_true: sign = false; break; case polarity_false: sign = true; break; case polarity_user: sign = polarity[next]; break; case polarity_rnd: sign = irand(random_seed, 2); break; default: assert(false); } return next == var_Undef ? lit_Undef : Lit(next, sign); } /*_________________________________________________________________________________________________ | | analyze : (confl : Clause*) (out_learnt : vec&) (out_btlevel : int&) -> [void] | | Description: | Analyze conflict and produce a reason clause. | | Pre-conditions: | * 'out_learnt' is assumed to be cleared. | * Current decision level must be greater than root level. | | Post-conditions: | * 'out_learnt[0]' is the asserting literal at level 'out_btlevel'. | | Effect: | Will undo part of the trail, upto but not beyond the assumption of the current decision level. |________________________________________________________________________________________________@*/ void Solver::analyze(Clause* confl, vec& out_learnt, int& out_btlevel) { int pathC = 0; Lit p = lit_Undef; // Generate conflict clause: // out_learnt.push(); // (leave room for the asserting literal) int index = trail.size() - 1; out_btlevel = 0; do{ assert(confl != NULL); // (otherwise should be UIP) Clause& c = *confl; if (c.learnt()) claBumpActivity(c); for (int j = (p == lit_Undef) ? 0 : 1; j < c.size(); j++){ Lit q = c[j]; if (!seen[var(q)] && level[var(q)] > 0){ varBumpActivity(var(q)); seen[var(q)] = 1; if (level[var(q)] >= decisionLevel()) pathC++; else{ out_learnt.push(q); if (level[var(q)] > out_btlevel) out_btlevel = level[var(q)]; } } } // Select next clause to look at: while (!seen[var(trail[index--])]); p = trail[index+1]; confl = reason[var(p)]; seen[var(p)] = 0; pathC--; }while (pathC > 0); out_learnt[0] = ~p; // Simplify conflict clause: // int i, j; if (expensive_ccmin){ uint32_t abstract_level = 0; for (i = 1; i < out_learnt.size(); i++) abstract_level |= abstractLevel(var(out_learnt[i])); // (maintain an abstraction of levels involved in conflict) out_learnt.copyTo(analyze_toclear); for (i = j = 1; i < out_learnt.size(); i++) if (reason[var(out_learnt[i])] == NULL || !litRedundant(out_learnt[i], abstract_level)) out_learnt[j++] = out_learnt[i]; }else{ out_learnt.copyTo(analyze_toclear); for (i = j = 1; i < out_learnt.size(); i++){ Clause& c = *reason[var(out_learnt[i])]; for (int k = 1; k < c.size(); k++) if (!seen[var(c[k])] && level[var(c[k])] > 0){ out_learnt[j++] = out_learnt[i]; break; } } } max_literals += out_learnt.size(); out_learnt.shrink(i - j); tot_literals += out_learnt.size(); // Find correct backtrack level: // if (out_learnt.size() == 1) out_btlevel = 0; else{ int max_i = 1; for (int i = 2; i < out_learnt.size(); i++) if (level[var(out_learnt[i])] > level[var(out_learnt[max_i])]) max_i = i; Lit p = out_learnt[max_i]; out_learnt[max_i] = out_learnt[1]; out_learnt[1] = p; out_btlevel = level[var(p)]; } for (int j = 0; j < analyze_toclear.size(); j++) seen[var(analyze_toclear[j])] = 0; // ('seen[]' is now cleared) } // Check if 'p' can be removed. 'abstract_levels' is used to abort early if the algorithm is // visiting literals at levels that cannot be removed later. bool Solver::litRedundant(Lit p, uint32_t abstract_levels) { analyze_stack.clear(); analyze_stack.push(p); int top = analyze_toclear.size(); while (analyze_stack.size() > 0){ assert(reason[var(analyze_stack.last())] != NULL); Clause& c = *reason[var(analyze_stack.last())]; analyze_stack.pop(); for (int i = 1; i < c.size(); i++){ Lit p = c[i]; if (!seen[var(p)] && level[var(p)] > 0){ if (reason[var(p)] != NULL && (abstractLevel(var(p)) & abstract_levels) != 0){ seen[var(p)] = 1; analyze_stack.push(p); analyze_toclear.push(p); }else{ for (int j = top; j < analyze_toclear.size(); j++) seen[var(analyze_toclear[j])] = 0; analyze_toclear.shrink(analyze_toclear.size() - top); return false; } } } } return true; } /*_________________________________________________________________________________________________ | | analyzeFinal : (p : Lit) -> [void] | | Description: | Specialized analysis procedure to express the final conflict in terms of assumptions. | Calculates the (possibly empty) set of assumptions that led to the assignment of 'p', and | stores the result in 'out_conflict'. |________________________________________________________________________________________________@*/ void Solver::analyzeFinal(Lit p, vec& out_conflict) { out_conflict.clear(); out_conflict.push(p); if (decisionLevel() == 0) return; seen[var(p)] = 1; for (int i = trail.size()-1; i >= trail_lim[0]; i--){ Var x = var(trail[i]); if (seen[x]){ if (reason[x] == NULL){ assert(level[x] > 0); out_conflict.push(~trail[i]); }else{ Clause& c = *reason[x]; for (int j = 1; j < c.size(); j++) if (level[var(c[j])] > 0) seen[var(c[j])] = 1; } seen[x] = 0; } } seen[var(p)] = 0; } void Solver::uncheckedEnqueue(Lit p, Clause* from) { assert(value(p) == l_Undef); assigns [var(p)] = toInt(lbool(!sign(p))); // <<== abstract but not uttermost effecient level [var(p)] = decisionLevel(); reason [var(p)] = from; trail.push(p); } /*_________________________________________________________________________________________________ | | propagate : [void] -> [Clause*] | | Description: | Propagates all enqueued facts. If a conflict arises, the conflicting clause is returned, | otherwise NULL. | | Post-conditions: | * the propagation queue is empty, even if there was a conflict. |________________________________________________________________________________________________@*/ Clause* Solver::propagate() { Clause* confl = NULL; int num_props = 0; while (qhead < trail.size()){ Lit p = trail[qhead++]; // 'p' is enqueued fact to propagate. vec& ws = watches[toInt(p)]; Clause **i, **j, **end; num_props++; for (i = j = (Clause**)ws, end = i + ws.size(); i != end;){ Clause& c = **i++; // Make sure the false literal is data[1]: Lit false_lit = ~p; if (c[0] == false_lit) c[0] = c[1], c[1] = false_lit; assert(c[1] == false_lit); // If 0th watch is true, then clause is already satisfied. Lit first = c[0]; if (value(first) == l_True){ *j++ = &c; }else{ // Look for new watch: for (int k = 2; k < c.size(); k++) if (value(c[k]) != l_False){ c[1] = c[k]; c[k] = false_lit; watches[toInt(~c[1])].push(&c); goto FoundWatch; } // Did not find watch -- clause is unit under assignment: *j++ = &c; if (value(first) == l_False){ confl = &c; qhead = trail.size(); // Copy the remaining watches: while (i < end) *j++ = *i++; }else uncheckedEnqueue(first, &c); } FoundWatch:; } ws.shrink(i - j); } propagations += num_props; simpDB_props -= num_props; return confl; } /*_________________________________________________________________________________________________ | | reduceDB : () -> [void] | | Description: | Remove half of the learnt clauses, minus the clauses locked by the current assignment. Locked | clauses are clauses that are reason to some assignment. Binary clauses are never removed. |________________________________________________________________________________________________@*/ struct reduceDB_lt { bool operator () (Clause* x, Clause* y) { return x->size() > 2 && (y->size() == 2 || x->activity() < y->activity()); } }; void Solver::reduceDB() { int i, j; double extra_lim = cla_inc / learnts.size(); // Remove any clause below this activity sort(learnts, reduceDB_lt()); for (i = j = 0; i < learnts.size() / 2; i++){ if (learnts[i]->size() > 2 && !locked(*learnts[i])) removeClause(*learnts[i]); else learnts[j++] = learnts[i]; } for (; i < learnts.size(); i++){ if (learnts[i]->size() > 2 && !locked(*learnts[i]) && learnts[i]->activity() < extra_lim) removeClause(*learnts[i]); else learnts[j++] = learnts[i]; } learnts.shrink(i - j); } void Solver::removeSatisfied(vec& cs) { int i,j; for (i = j = 0; i < cs.size(); i++){ if (satisfied(*cs[i])) removeClause(*cs[i]); else cs[j++] = cs[i]; } cs.shrink(i - j); } /*_________________________________________________________________________________________________ | | simplify : [void] -> [bool] | | Description: | Simplify the clause database according to the current top-level assigment. Currently, the only | thing done here is the removal of satisfied clauses, but more things can be put here. |________________________________________________________________________________________________@*/ bool Solver::simplify() { assert(decisionLevel() == 0); if (!ok || propagate() != NULL) return ok = false; if (nAssigns() == simpDB_assigns || (simpDB_props > 0)) return true; // Remove satisfied clauses: removeSatisfied(learnts); if (remove_satisfied) // Can be turned off. removeSatisfied(clauses); // Remove fixed variables from the variable heap: order_heap.filter(VarFilter(*this)); simpDB_assigns = nAssigns(); simpDB_props = clauses_literals + learnts_literals; // (shouldn't depend on stats really, but it will do for now) return true; } /*_________________________________________________________________________________________________ | | search : (nof_conflicts : int) (nof_learnts : int) (params : const SearchParams&) -> [lbool] | | Description: | Search for a model the specified number of conflicts, keeping the number of learnt clauses | below the provided limit. NOTE! Use negative value for 'nof_conflicts' or 'nof_learnts' to | indicate infinity. | | Output: | 'l_True' if a partial assigment that is consistent with respect to the clauseset is found. If | all variables are decision variables, this means that the clause set is satisfiable. 'l_False' | if the clause set is unsatisfiable. 'l_Undef' if the bound on number of conflicts is reached. |________________________________________________________________________________________________@*/ lbool Solver::search(int nof_conflicts, int nof_learnts) { assert(ok); int backtrack_level; int conflictC = 0; vec learnt_clause; starts++; bool first = true; for (;;){ Clause* confl = propagate(); if (confl != NULL){ // CONFLICT conflicts++; conflictC++; if (decisionLevel() == 0) return l_False; first = false; learnt_clause.clear(); analyze(confl, learnt_clause, backtrack_level); cancelUntil(backtrack_level); assert(value(learnt_clause[0]) == l_Undef); if (learnt_clause.size() == 1){ uncheckedEnqueue(learnt_clause[0]); }else{ Clause* c = Clause_new(learnt_clause, true); learnts.push(c); attachClause(*c); claBumpActivity(*c); uncheckedEnqueue(learnt_clause[0], c); } varDecayActivity(); claDecayActivity(); }else{ // NO CONFLICT if (nof_conflicts >= 0 && conflictC >= nof_conflicts){ // Reached bound on number of conflicts: progress_estimate = progressEstimate(); cancelUntil(0); return l_Undef; } // Simplify the set of problem clauses: if (decisionLevel() == 0 && !simplify()) return l_False; if (nof_learnts >= 0 && learnts.size()-nAssigns() >= nof_learnts) // Reduce the set of learnt clauses: reduceDB(); Lit next = lit_Undef; while (decisionLevel() < assumptions.size()){ // Perform user provided assumption: Lit p = assumptions[decisionLevel()]; if (value(p) == l_True){ // Dummy decision level: newDecisionLevel(); }else if (value(p) == l_False){ analyzeFinal(~p, conflict); return l_False; }else{ next = p; break; } } if (next == lit_Undef){ // New variable decision: decisions++; next = pickBranchLit(polarity_mode, random_var_freq); if (next == lit_Undef) // Model found: return l_True; } // Increase decision level and enqueue 'next' assert(value(next) == l_Undef); newDecisionLevel(); uncheckedEnqueue(next); } } } double Solver::progressEstimate() const { double progress = 0; double F = 1.0 / nVars(); for (int i = 0; i <= decisionLevel(); i++){ int beg = i == 0 ? 0 : trail_lim[i - 1]; int end = i == decisionLevel() ? trail.size() : trail_lim[i]; progress += pow(F, i) * (end - beg); } return progress / nVars(); } bool Solver::solve(const vec& assumps) { model.clear(); conflict.clear(); if (!ok) return false; assumps.copyTo(assumptions); double nof_conflicts = restart_first; double nof_learnts = nClauses() * learntsize_factor; lbool status = l_Undef; if (verbosity >= 1){ reportf("============================[ Search Statistics ]==============================\n"); reportf("| Conflicts | ORIGINAL | LEARNT | Progress |\n"); reportf("| | Vars Clauses Literals | Limit Clauses Lit/Cl | |\n"); reportf("===============================================================================\n"); } // Search: while (status == l_Undef){ if (verbosity >= 1) reportf("| %9d | %7d %8d %8d | %8d %8d %6.0f | %6.3f %% |\n", (int)conflicts, order_heap.size(), nClauses(), (int)clauses_literals, (int)nof_learnts, nLearnts(), (double)learnts_literals/nLearnts(), progress_estimate*100), fflush(stdout); status = search((int)nof_conflicts, (int)nof_learnts); nof_conflicts *= restart_inc; nof_learnts *= learntsize_inc; } if (verbosity >= 1) reportf("===============================================================================\n"); if (status == l_True){ // Extend & copy model: model.growTo(nVars()); for (int i = 0; i < nVars(); i++) model[i] = value(i); #ifndef NDEBUG verifyModel(); #endif }else{ assert(status == l_False); if (conflict.size() == 0) ok = false; } cancelUntil(0); return status == l_True; } //================================================================================================= // Debug methods: void Solver::verifyModel() { bool failed = false; for (int i = 0; i < clauses.size(); i++){ assert(clauses[i]->mark() == 0); Clause& c = *clauses[i]; for (int j = 0; j < c.size(); j++) if (modelValue(c[j]) == l_True) goto next; reportf("unsatisfied clause: "); printClause(*clauses[i]); reportf("\n"); failed = true; next:; } assert(!failed); reportf("Verified %d original clauses.\n", clauses.size()); } void Solver::checkLiteralCount() { // Check that sizes are calculated correctly: int cnt = 0; for (int i = 0; i < clauses.size(); i++) if (clauses[i]->mark() == 0) cnt += clauses[i]->size(); if ((int)clauses_literals != cnt){ fprintf(stderr, "literal count: %d, real value = %d\n", (int)clauses_literals, cnt); assert((int)clauses_literals == cnt); } } opensmt-2.5.2/src/minisat/core/Solver.h000066400000000000000000000527461445011647600200410ustar00rootroot00000000000000/****************************************************************************************[Solver.h] Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson Copyright (c) 2007-2010, Niklas Sorensson 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. **************************************************************************************************/ #ifndef Minisat_Solver_h #define Minisat_Solver_h #include "minisat/mtl/Vec.h" #include "minisat/mtl/Heap.h" #include "minisat/mtl/Alg.h" #include "minisat/utils/Options.h" #include "minisat/core/SolverTypes.h" namespace Minisat { //================================================================================================= // Solver -- the main class: class Solver { public: // Constructor/Destructor: // Solver(); virtual ~Solver(); // Problem specification: // Var newVar (bool polarity = true, bool dvar = true); // Add a new variable with parameters specifying variable mode. bool addClause (const vec& ps); // Add a clause to the solver. bool addEmptyClause(); // Add the empty clause, making the solver contradictory. bool addClause (Lit p); // Add a unit clause to the solver. bool addClause (Lit p, Lit q); // Add a binary clause to the solver. bool addClause (Lit p, Lit q, Lit r); // Add a ternary clause to the solver. bool addClause_( vec& ps); // Add a clause to the solver without making superflous internal copy. Will // change the passed vector 'ps'. // Solving: // bool simplify (); // Removes already satisfied clauses. bool solve (const vec& assumps); // Search for a model that respects a given set of assumptions. lbool solveLimited (const vec& assumps); // Search for a model that respects a given set of assumptions (With resource constraints). bool solve (); // Search without assumptions. bool solve (Lit p); // Search for a model that respects a single assumption. bool solve (Lit p, Lit q); // Search for a model that respects two assumptions. bool solve (Lit p, Lit q, Lit r); // Search for a model that respects three assumptions. bool okay () const; // FALSE means solver is in a conflicting state void toDimacs (FILE* f, const vec& assumps); // Write CNF to file in DIMACS-format. void toDimacs (const char *file, const vec& assumps); void toDimacs (FILE* f, Clause& c, vec& map, Var& max); // Convenience versions of 'toDimacs()': void toDimacs (const char* file); void toDimacs (const char* file, Lit p); void toDimacs (const char* file, Lit p, Lit q); void toDimacs (const char* file, Lit p, Lit q, Lit r); // Variable mode: // void setPolarity (Var v, bool b); // Declare which polarity the decision heuristic should use for a variable. Requires mode 'polarity_user'. void setDecisionVar (Var v, bool b); // Declare if a variable should be eligible for selection in the decision heuristic. // Read state: // lbool value (Var x) const; // The current value of a variable. lbool value (Lit p) const; // The current value of a literal. lbool modelValue (Var x) const; // The value of a variable in the last model. The last call to solve must have been satisfiable. lbool modelValue (Lit p) const; // The value of a literal in the last model. The last call to solve must have been satisfiable. int nAssigns () const; // The current number of assigned literals. int nClauses () const; // The current number of original clauses. int nLearnts () const; // The current number of learnt clauses. int nVars () const; // The current number of variables. int nFreeVars () const; // Resource contraints: // void setConfBudget(int64_t x); void setPropBudget(int64_t x); void budgetOff(); void interrupt(); // Trigger a (potentially asynchronous) interruption of the solver. void clearInterrupt(); // Clear interrupt indicator flag. // Memory managment: // virtual void garbageCollect(); void checkGarbage(double gf); void checkGarbage(); // Extra results: (read-only member variable) // vec model; // If problem is satisfiable, this vector contains the model (if any). vec conflict; // If problem is unsatisfiable (possibly under assumptions), // this vector represent the final conflict clause expressed in the assumptions. // Mode of operation: // int verbosity; double var_decay; double clause_decay; double random_var_freq; double random_seed; bool luby_restart; int ccmin_mode; // Controls conflict clause minimization (0=none, 1=basic, 2=deep). int phase_saving; // Controls the level of phase saving (0=none, 1=limited, 2=full). bool rnd_pol; // Use random polarities for branching heuristics. bool rnd_init_act; // Initialize variable activities with a small random value. double garbage_frac; // The fraction of wasted memory allowed before a garbage collection is triggered. int restart_first; // The initial restart limit. (default 100) double restart_inc; // The factor with which the restart limit is multiplied in each restart. (default 1.5) double learntsize_factor; // The intitial limit for learnt clauses is a factor of the original clauses. (default 1 / 3) double learntsize_inc; // The limit for learnt clauses is multiplied with this factor each restart. (default 1.1) int learntsize_adjust_start_confl; double learntsize_adjust_inc; // Statistics: (read-only member variable) // uint64_t solves, starts, decisions, rnd_decisions, propagations, conflicts; uint64_t dec_vars, clauses_literals, learnts_literals, max_literals, tot_literals; protected: // Helper structures: // struct VarData { CRef reason; int level; }; static inline VarData mkVarData(CRef cr, int l){ VarData d = {cr, l}; return d; } struct Watcher { CRef cref; Lit blocker; Watcher(CRef cr, Lit p) : cref(cr), blocker(p) {} bool operator==(const Watcher& w) const { return cref == w.cref; } bool operator!=(const Watcher& w) const { return cref != w.cref; } }; struct WatcherDeleted { const ClauseAllocator& ca; WatcherDeleted(const ClauseAllocator& _ca) : ca(_ca) {} bool operator()(const Watcher& w) const { return ca[w.cref].mark() == 1; } }; struct VarOrderLt { const vec& activity; bool operator () (Var x, Var y) const { return activity[x] > activity[y]; } VarOrderLt(const vec& act) : activity(act) { } }; // Solver state: // bool ok; // If FALSE, the constraints are already unsatisfiable. No part of the solver state may be used! vec clauses; // List of problem clauses. vec learnts; // List of learnt clauses. double cla_inc; // Amount to bump next clause with. vec activity; // A heuristic measurement of the activity of a variable. double var_inc; // Amount to bump next variable with. OccLists, WatcherDeleted> watches; // 'watches[lit]' is a list of constraints watching 'lit' (will go there if literal becomes true). vec assigns; // The current assignments. vec polarity; // The preferred polarity of each variable. vec decision; // Declares if a variable is eligible for selection in the decision heuristic. vec trail; // Assignment stack; stores all assigments made in the order they were made. vec trail_lim; // Separator indices for different decision levels in 'trail'. vec vardata; // Stores reason and level for each variable. int qhead; // Head of queue (as index into the trail -- no more explicit propagation queue in MiniSat). int simpDB_assigns; // Number of top-level assignments since last execution of 'simplify()'. int64_t simpDB_props; // Remaining number of propagations that must be made before next execution of 'simplify()'. vec assumptions; // Current set of assumptions provided to solve by the user. Heap order_heap; // A priority queue of variables ordered with respect to the variable activity. double progress_estimate;// Set by 'search()'. bool remove_satisfied; // Indicates whether possibly inefficient linear scan for satisfied clauses should be performed in 'simplify'. ClauseAllocator ca; // Temporaries (to reduce allocation overhead). Each variable is prefixed by the method in which it is // used, exept 'seen' wich is used in several places. // vec seen; vec analyze_stack; vec analyze_toclear; vec add_tmp; double max_learnts; double learntsize_adjust_confl; int learntsize_adjust_cnt; // Resource contraints: // int64_t conflict_budget; // -1 means no budget. int64_t propagation_budget; // -1 means no budget. bool asynch_interrupt; // Main internal methods: // void insertVarOrder (Var x); // Insert a variable in the decision order priority queue. Lit pickBranchLit (); // Return the next decision variable. void newDecisionLevel (); // Begins a new decision level. void uncheckedEnqueue (Lit p, CRef from = CRef_Undef); // Enqueue a literal. Assumes value of literal is undefined. bool enqueue (Lit p, CRef from = CRef_Undef); // Test if fact 'p' contradicts current state, enqueue otherwise. CRef propagate (); // Perform unit propagation. Returns possibly conflicting clause. void cancelUntil (int level); // Backtrack until a certain level. void analyze (CRef confl, vec& out_learnt, int& out_btlevel); // (bt = backtrack) void analyzeFinal (Lit p, vec& out_conflict); // COULD THIS BE IMPLEMENTED BY THE ORDINARIY "analyze" BY SOME REASONABLE GENERALIZATION? bool litRedundant (Lit p, uint32_t abstract_levels); // (helper method for 'analyze()') lbool search (int nof_conflicts); // Search for a given number of conflicts. lbool solve_ (); // Main solve method (assumptions given in 'assumptions'). void reduceDB (); // Reduce the set of learnt clauses. void removeSatisfied (vec& cs); // Shrink 'cs' to contain only non-satisfied clauses. void rebuildOrderHeap (); // Maintaining Variable/Clause activity: // void varDecayActivity (); // Decay all variables with the specified factor. Implemented by increasing the 'bump' value instead. void varBumpActivity (Var v, double inc); // Increase a variable with the current 'bump' value. void varBumpActivity (Var v); // Increase a variable with the current 'bump' value. void claDecayActivity (); // Decay all clauses with the specified factor. Implemented by increasing the 'bump' value instead. void claBumpActivity (Clause& c); // Increase a clause with the current 'bump' value. // Operations on clauses: // void attachClause (CRef cr); // Attach a clause to watcher lists. void detachClause (CRef cr, bool strict = false); // Detach a clause to watcher lists. void removeClause (CRef cr); // Detach and free a clause. bool locked (const Clause& c) const; // Returns TRUE if a clause is a reason for some implication in the current state. bool satisfied (const Clause& c) const; // Returns TRUE if a clause is satisfied in the current state. void relocAll (ClauseAllocator& to); // Misc: // int decisionLevel () const; // Gives the current decisionlevel. uint32_t abstractLevel (Var x) const; // Used to represent an abstraction of sets of decision levels. CRef reason (Var x) const; int level (Var x) const; double progressEstimate () const; // DELETE THIS ?? IT'S NOT VERY USEFUL ... bool withinBudget () const; // Static helpers: // // Returns a random float 0 <= x < 1. Seed must never be 0. static inline double drand(double& seed) { seed *= 1389796; int q = (int)(seed / 2147483647); seed -= (double)q * 2147483647; return seed / 2147483647; } // Returns a random integer 0 <= x < size. Seed must never be 0. static inline int irand(double& seed, int size) { return (int)(drand(seed) * size); } }; //================================================================================================= // Implementation of inline methods: inline CRef Solver::reason(Var x) const { return vardata[x].reason; } inline int Solver::level (Var x) const { return vardata[x].level; } inline void Solver::insertVarOrder(Var x) { if (!order_heap.inHeap(x) && decision[x]) order_heap.insert(x); } inline void Solver::varDecayActivity() { var_inc *= (1 / var_decay); } inline void Solver::varBumpActivity(Var v) { varBumpActivity(v, var_inc); } inline void Solver::varBumpActivity(Var v, double inc) { if ( (activity[v] += inc) > 1e100 ) { // Rescale: for (int i = 0; i < nVars(); i++) activity[i] *= 1e-100; var_inc *= 1e-100; } // Update order_heap with respect to new activity: if (order_heap.inHeap(v)) order_heap.decrease(v); } inline void Solver::claDecayActivity() { cla_inc *= (1 / clause_decay); } inline void Solver::claBumpActivity (Clause& c) { if ( (c.activity() += cla_inc) > 1e20 ) { // Rescale: for (int i = 0; i < learnts.size(); i++) ca[learnts[i]].activity() *= 1e-20; cla_inc *= 1e-20; } } inline void Solver::checkGarbage(void){ return checkGarbage(garbage_frac); } inline void Solver::checkGarbage(double gf){ if (ca.wasted() > ca.size() * gf) garbageCollect(); } // NOTE: enqueue does not set the ok flag! (only public methods do) inline bool Solver::enqueue (Lit p, CRef from) { return value(p) != l_Undef ? value(p) != l_False : (uncheckedEnqueue(p, from), true); } inline bool Solver::addClause (const vec& ps) { ps.copyTo(add_tmp); return addClause_(add_tmp); } inline bool Solver::addEmptyClause () { add_tmp.clear(); return addClause_(add_tmp); } inline bool Solver::addClause (Lit p) { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp); } inline bool Solver::addClause (Lit p, Lit q) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp); } inline bool Solver::addClause (Lit p, Lit q, Lit r) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp); } inline bool Solver::locked (const Clause& c) const { return value(c[0]) == l_True && reason(var(c[0])) != CRef_Undef && ca.lea(reason(var(c[0]))) == &c; } inline void Solver::newDecisionLevel() { trail_lim.push(trail.size()); } inline int Solver::decisionLevel () const { return trail_lim.size(); } inline uint32_t Solver::abstractLevel (Var x) const { return 1 << (level(x) & 31); } inline lbool Solver::value (Var x) const { return assigns[x]; } inline lbool Solver::value (Lit p) const { return assigns[var(p)] ^ sign(p); } inline lbool Solver::modelValue (Var x) const { return model[x]; } inline lbool Solver::modelValue (Lit p) const { return model[var(p)] ^ sign(p); } inline int Solver::nAssigns () const { return trail.size(); } inline int Solver::nClauses () const { return clauses.size(); } inline int Solver::nLearnts () const { return learnts.size(); } inline int Solver::nVars () const { return vardata.size(); } inline int Solver::nFreeVars () const { return (int)dec_vars - (trail_lim.size() == 0 ? trail.size() : trail_lim[0]); } inline void Solver::setPolarity (Var v, bool b) { polarity[v] = b; } inline void Solver::setDecisionVar(Var v, bool b) { if ( b && !decision[v]) dec_vars++; else if (!b && decision[v]) dec_vars--; decision[v] = b; insertVarOrder(v); } inline void Solver::setConfBudget(int64_t x){ conflict_budget = conflicts + x; } inline void Solver::setPropBudget(int64_t x){ propagation_budget = propagations + x; } inline void Solver::interrupt(){ asynch_interrupt = true; } inline void Solver::clearInterrupt(){ asynch_interrupt = false; } inline void Solver::budgetOff(){ conflict_budget = propagation_budget = -1; } inline bool Solver::withinBudget() const { return !asynch_interrupt && (conflict_budget < 0 || conflicts < (uint64_t)conflict_budget) && (propagation_budget < 0 || propagations < (uint64_t)propagation_budget); } // FIXME: after the introduction of asynchronous interrruptions the solve-versions that return a // pure bool do not give a safe interface. Either interrupts must be possible to turn off here, or // all calls to solve must return an 'lbool'. I'm not yet sure which I prefer. inline bool Solver::solve () { budgetOff(); assumptions.clear(); return solve_() == l_True; } inline bool Solver::solve (Lit p) { budgetOff(); assumptions.clear(); assumptions.push(p); return solve_() == l_True; } inline bool Solver::solve (Lit p, Lit q) { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); return solve_() == l_True; } inline bool Solver::solve (Lit p, Lit q, Lit r) { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); assumptions.push(r); return solve_() == l_True; } inline bool Solver::solve (const vec& assumps){ budgetOff(); assumps.copyTo(assumptions); return solve_() == l_True; } inline lbool Solver::solveLimited (const vec& assumps){ assumps.copyTo(assumptions); return solve_(); } inline bool Solver::okay () const { return ok; } inline void Solver::toDimacs (const char* file){ vec as; toDimacs(file, as); } inline void Solver::toDimacs (const char* file, Lit p){ vec as; as.push(p); toDimacs(file, as); } inline void Solver::toDimacs (const char* file, Lit p, Lit q){ vec as; as.push(p); as.push(q); toDimacs(file, as); } inline void Solver::toDimacs (const char* file, Lit p, Lit q, Lit r){ vec as; as.push(p); as.push(q); as.push(r); toDimacs(file, as); } //================================================================================================= // Debug etc: //================================================================================================= } #endif opensmt-2.5.2/src/minisat/core/SolverTypes.h000066400000000000000000000417101445011647600210530ustar00rootroot00000000000000/***********************************************************************************[SolverTypes.h] Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson Copyright (c) 2007-2010, Niklas Sorensson 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. **************************************************************************************************/ #ifndef Minisat_SolverTypes_h #define Minisat_SolverTypes_h #include #include "osmtinttypes.h" #include "Alg.h" #include "Vec.h" #include "Map.h" #include "Alloc.h" #include "TypeUtils.h" //================================================================================================= // Variables, literals, lifted booleans, clauses: // NOTE! Variables are just integers. No abstraction here. They should be chosen from 0..N, // so that they can be used as array indices. typedef int Var; #define var_Undef (-1) struct VarHash { uint32_t operator() (const Var& s) const { return s; } }; struct Lit { int x; // Use this as a constructor: friend Lit mkLit(Var var, bool sign); bool operator == (Lit p) const { return x == p.x; } bool operator != (Lit p) const { return x != p.x; } bool operator < (Lit p) const { return x < p.x; } // '<' makes p, ~p adjacent in the ordering. bool operator <= (Lit p) const { return x <= p.x; } // '<=' makes p, ~p adjacent in the ordering. }; inline Lit mkLit (Var var, bool sign = false) { Lit p; p.x = var + var + (int)sign; return p; } inline Lit operator ~(Lit p) { Lit q; q.x = p.x ^ 1; return q; } inline Lit operator ^(Lit p, bool b) { Lit q; q.x = p.x ^ (unsigned int)b; return q; } inline bool sign (Lit p) { return p.x & 1; } inline int var (Lit p) { return p.x >> 1; } // Mapping Literals to and from compact integers suitable for array indexing: inline int toInt (Var v) { return v; } inline int toInt (Lit p) { return p.x; } inline Lit toLit (int i) { Lit p; p.x = i; return p; } //const Lit lit_Undef = mkLit(var_Undef, false); // }- Useful special constants. //const Lit lit_Error = mkLit(var_Undef, true ); // } const Lit lit_Undef = { -2 }; // }- Useful special constants. const Lit lit_Error = { -1 }; // } class LitLev { public: Lit l; int lev; LitLev() : l(lit_Undef), lev(-1) {} LitLev(Lit l_, int lev_) : l(l_), lev(lev_) {} }; struct LitLev_lt { bool operator () (LitLev& x, LitLev& y) { return x.lev < y.lev; } }; //================================================================================================= // Lifted booleans: // // NOTE: this implementation is optimized for the case when comparisons between values are mostly // between one variable and one constant. Some care had to be taken to make sure that gcc // does enough constant propagation to produce sensible code, and this appears to be somewhat // fragile unfortunately. #define l_True (lbool((uint8_t)0)) // gcc does not do constant propagation if these are real constants. #define l_False (lbool((uint8_t)1)) #define l_Undef (lbool((uint8_t)2)) class lbool { uint8_t value; public: explicit lbool(uint8_t v) : value(v) { } lbool() : value(0) { } explicit lbool(bool x) : value(!x) { } bool operator == (lbool b) const { return ((b.value&2) & (value&2)) | (!(b.value&2)&(value == b.value)); } bool operator != (lbool b) const { return !(*this == b); } lbool operator ^ (bool b) const { return lbool((uint8_t)(value^(uint8_t)b)); } lbool operator && (lbool b) const { uint8_t sel = (this->value << 1) | (b.value << 3); uint8_t v = (0xF7F755F4 >> sel) & 3; return lbool(v); } lbool operator || (lbool b) const { uint8_t sel = (this->value << 1) | (b.value << 3); uint8_t v = (0xFCFCF400 >> sel) & 3; return lbool(v); } friend int toInt (lbool l); friend lbool toLbool(int v); }; inline int toInt (lbool l) { return l.value; } inline lbool toLbool(int v) { return lbool((uint8_t)v); } //================================================================================================= // Clause -- a simple class for representing a clause: typedef RegionAllocator::Ref CRef; struct VarData { CRef reason; int level; }; class Clause { struct { unsigned mark : 2; unsigned learnt : 1; unsigned has_extra : 1; unsigned reloced : 1; unsigned glue : 3; unsigned size : 24; } header; union { Lit lit; float act; uint32_t abs; CRef rel; } data[0]; friend class ClauseAllocator; // NOTE: This constructor cannot be used directly (doesn't allocate enough memory). template Clause(const V& ps, bool use_extra, bool learnt) { header.mark = 0; header.learnt = learnt; header.has_extra = use_extra; header.reloced = 0; header.size = ps.size(); header.glue = 7; for (unsigned i = 0; i < (unsigned)ps.size(); i++) data[i].lit = ps[i]; if (header.has_extra){ if (header.learnt) data[header.size].act = 0; else calcAbstraction(); } } public: void calcAbstraction() { assert(header.has_extra); uint32_t abstraction = 0; for (unsigned i = 0; i < size(); i++) abstraction |= 1 << (var(data[i].lit) & 31); data[header.size].abs = abstraction; } unsigned int size () const { return header.size; } void shrink (unsigned i) { assert(i <= size()); if (header.has_extra) data[header.size-i] = data[header.size]; header.size -= i; } void pop () { shrink(1); } bool learnt () const { return header.learnt; } bool has_extra () const { return header.has_extra; } uint32_t mark () const { return header.mark; } void mark (uint32_t m) { header.mark = m; } const Lit& last () const { return data[header.size-1].lit; } bool reloced () const { return header.reloced; } CRef relocation () const { return data[0].rel; } void relocate (CRef c) { header.reloced = 1; data[0].rel = c; } // NOTE: somewhat unsafe to change the clause in-place! Must manually call 'calcAbstraction' afterwards for // subsumption operations to behave correctly. Lit& operator [] (int i) { return data[i].lit; } Lit operator [] (int i) const { return data[i].lit; } operator const Lit* (void) const { return (Lit*)data; } Lit const * begin() const { return &data[0].lit; } Lit const * end() const { return &data[0].lit + static_cast(header.size); } float& activity () { assert(header.has_extra); return data[header.size].act; } uint32_t abstraction () const { assert(header.has_extra); return data[header.size].abs; } Lit subsumes (const Clause& other) const; void strengthen (Lit p); uint32_t getGlue() const { return header.glue; } void setGlue(const uint32_t glue) { assert(glue < 8); header.glue = glue; } }; //================================================================================================= // ClauseAllocator -- a simple class for allocating memory for clauses: const CRef CRef_Undef = RegionAllocator::Ref_Undef; const CRef CRef_True = RegionAllocator::Ref_True; const CRef CRef_Fake = RegionAllocator::Ref_Fake; // The artificial clause reference for theory implications class ClauseAllocator : public RegionAllocator { static int clauseWord32Size(int size, bool has_extra){ return (sizeof(Clause) + (sizeof(Lit) * (size + (int)has_extra))) / sizeof(uint32_t); } public: bool extra_clause_field; ClauseAllocator(uint32_t start_cap) : RegionAllocator(start_cap), extra_clause_field(false){} ClauseAllocator() : extra_clause_field(false){} void moveTo(ClauseAllocator& to){ to.extra_clause_field = extra_clause_field; RegionAllocator::moveTo(to); } template CRef alloc(const Lits& ps, opensmt::pair learntAndGlue = {false, 0}) { assert(sizeof(Lit) == sizeof(uint32_t)); assert(sizeof(float) == sizeof(uint32_t)); auto [learnt, glue] = learntAndGlue; bool use_extra = learnt | extra_clause_field; CRef cid = RegionAllocator::alloc(clauseWord32Size(ps.size(), use_extra)); new (lea(cid)) Clause(ps, use_extra, learnt); if (learnt) { operator[](cid).setGlue(glue); } return cid; } // Deref, Load Effective Address (LEA), Inverse of LEA (AEL): Clause& operator[](Ref r) { return (Clause&)RegionAllocator::operator[](r); } const Clause& operator[](Ref r) const { return (Clause&)RegionAllocator::operator[](r); } Clause* lea (Ref r) { return (Clause*)RegionAllocator::lea(r); } const Clause* lea (Ref r) const { return (Clause*)RegionAllocator::lea(r); } Ref ael (const Clause* t){ return RegionAllocator::ael((uint32_t*)t); } void free(CRef cid) { Clause& c = operator[](cid); RegionAllocator::free(clauseWord32Size(c.size(), c.has_extra())); } void reloc(CRef& cr, ClauseAllocator& to) { Clause& c = operator[](cr); if (c.reloced()) { cr = c.relocation(); return; } cr = to.alloc(c, {c.learnt(), c.getGlue()}); c.relocate(cr); // Copy extra data-fields: // (This could be cleaned-up. Generalize Clause-constructor to be applicable here instead?) to[cr].mark(c.mark()); if (to[cr].learnt()) to[cr].activity() = c.activity(); else if (to[cr].has_extra()) to[cr].calcAbstraction(); } }; //================================================================================================= // OccLists -- a class for maintaining occurence lists with lazy deletion: template class OccLists { std::vector occs; vec dirty; vec dirties; Deleted deleted; public: OccLists(const Deleted& d) : deleted(d) {} void init (const Idx& idx){ occs.resize(toInt(idx)+1); dirty.growTo(toInt(idx)+1, 0); } Vec& operator[](const Idx& idx){ return occs[toInt(idx)]; } Vec& lookup (const Idx& idx){ if (dirty[toInt(idx)]) clean(idx); return occs[toInt(idx)]; } void cleanAll (); void clean (const Idx& idx); void smudge (const Idx& idx){ if (dirty[toInt(idx)] == 0){ dirty[toInt(idx)] = 1; dirties.push(idx); } } void clear(bool free = true) { occs .clear(); dirty .clear(free); dirties.clear(free); } }; template void OccLists::cleanAll() { for (int i = 0; i < dirties.size(); i++) // Dirties may contain duplicates so check here if a variable is already cleaned: if (dirty[toInt(dirties[i])]) clean(dirties[i]); dirties.clear(); } template void OccLists::clean(const Idx& idx) { Vec& vec = occs[toInt(idx)]; int i, j; for (i = j = 0; i < vec.size(); i++) if (!deleted(vec[i])) vec[j++] = vec[i]; vec.shrink(i - j); dirty[toInt(idx)] = 0; } //================================================================================================= // CMap -- a class for mapping clauses to values: template class CMap { struct CRefHash { uint32_t operator()(CRef cr) const { return (uint32_t)cr; } }; typedef Map HashTable; HashTable map; public: // Size-operations: void clear () { map.clear(); } int size () const { return map.elems(); } // Insert/Remove/Test mapping: void insert (CRef cr, const T& t){ map.insert(cr, t); } void growTo (CRef cr, const T& t){ map.insert(cr, t); } // NOTE: for compatibility void remove (CRef cr) { map.remove(cr); } bool has (CRef cr, T& t) { return map.peek(cr, t); } // Vector interface (the clause 'c' must already exist): const T& operator [] (CRef cr) const { return map[cr]; } T& operator [] (CRef cr) { return map[cr]; } // Iteration (not transparent at all at the moment): int bucket_count() const { return map.bucket_count(); } const vec& bucket(int i) const { return map.bucket(i); } // Move contents to other map: void moveTo(CMap& other){ map.moveTo(other.map); } // TMP debug: void debug(){ printf(" --- size = %d, bucket_count = %d\n", size(), map.bucket_count()); } }; //================================================================================================= // TPropRes-- a class for containing the result of a theory propagation: enum class TPropRes : int { Undef = INT32_MAX, Unsat = -1, Propagate = 0, Decide = 1 }; /*_________________________________________________________________________________________________ | | subsumes : (other : const Clause&) -> Lit | | Description: | Checks if clause subsumes 'other', and at the same time, if it can be used to simplify 'other' | by subsumption resolution. | | Result: | lit_Error - No subsumption or simplification | lit_Undef - Clause subsumes 'other' | p - The literal p can be deleted from 'other' |________________________________________________________________________________________________@*/ inline Lit Clause::subsumes(const Clause& other) const { //if (other.size() < size() || (extra.abst & ~other.extra.abst) != 0) //if (other.size() < size() || (!learnt() && !other.learnt() && (extra.abst & ~other.extra.abst) != 0)) assert(!header.learnt); assert(!other.header.learnt); assert(header.has_extra); assert(other.header.has_extra); if (other.header.size < header.size || (data[header.size].abs & ~other.data[other.header.size].abs) != 0) return lit_Error; Lit ret = lit_Undef; const Lit* c = (const Lit*)(*this); const Lit* d = (const Lit*)other; for (unsigned i = 0; i < header.size; i++) { // search for c[i] or ~c[i] for (unsigned j = 0; j < other.header.size; j++) if (c[i] == d[j]) goto ok; else if (ret == lit_Undef && c[i] == ~d[j]){ ret = c[i]; goto ok; } // did not find it return lit_Error; ok:; } return ret; } inline void Clause::strengthen(Lit p) { remove(*this, p); calcAbstraction(); } class ConflQuota { bool disabled; int quota; public: ConflQuota(int quota) : disabled(false), quota(quota) {} ConflQuota() : disabled(true), quota(0) {} ConflQuota(ConflQuota &q) : disabled(q.disabled), quota(q.quota) {} ConflQuota& operator= (const ConflQuota& o) { disabled = o.disabled; quota = o.quota; return *this; } void operator= (ConflQuota&& o) { disabled = o.disabled; quota = o.quota; }; bool operator< (int i) { if (disabled) return false; else return quota < i; } bool operator<= (int i) { if (disabled) return false; else return quota < i; } bool operator> (int i) { if (disabled) return true; else return quota > i; } ConflQuota& operator-- () { if (!disabled) { quota --; } return *this; } int getQuota() const { return quota; } }; //================================================================================================= #endif opensmt-2.5.2/src/minisat/core/depend.mk000066400000000000000000000015061445011647600201720ustar00rootroot00000000000000Main.o: Main.C Solver.h ../mtl/Vec.h ../mtl/Heap.h ../mtl/Vec.h \ ../mtl/Alg.h SolverTypes.h Solver.o: Solver.C Solver.h ../mtl/Vec.h ../mtl/Heap.h ../mtl/Vec.h \ ../mtl/Alg.h SolverTypes.h ../mtl/Sort.h Main.op: Main.C Solver.h ../mtl/Vec.h ../mtl/Heap.h ../mtl/Vec.h \ ../mtl/Alg.h SolverTypes.h Solver.op: Solver.C Solver.h ../mtl/Vec.h ../mtl/Heap.h ../mtl/Vec.h \ ../mtl/Alg.h SolverTypes.h ../mtl/Sort.h Main.od: Main.C Solver.h ../mtl/Vec.h ../mtl/Heap.h ../mtl/Vec.h \ ../mtl/Alg.h SolverTypes.h Solver.od: Solver.C Solver.h ../mtl/Vec.h ../mtl/Heap.h ../mtl/Vec.h \ ../mtl/Alg.h SolverTypes.h ../mtl/Sort.h Main.or: Main.C Solver.h ../mtl/Vec.h ../mtl/Heap.h ../mtl/Vec.h \ ../mtl/Alg.h SolverTypes.h Solver.or: Solver.C Solver.h ../mtl/Vec.h ../mtl/Heap.h ../mtl/Vec.h \ ../mtl/Alg.h SolverTypes.h ../mtl/Sort.h opensmt-2.5.2/src/minisat/mtl/000077500000000000000000000000001445011647600162445ustar00rootroot00000000000000opensmt-2.5.2/src/minisat/mtl/Alg.h000066400000000000000000000055021445011647600171220ustar00rootroot00000000000000/*******************************************************************************************[Alg.h] Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson Copyright (c) 2007-2010, Niklas Sorensson 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. **************************************************************************************************/ #ifndef Minisat_Alg_h #define Minisat_Alg_h #include "Vec.h" //================================================================================================= // Useful functions on vector-like types: //================================================================================================= // Removing and searching for elements: // template static inline void remove(V& ts, const T& t) { int j = 0; for (; j < static_cast(ts.size()) && ts[j] != t; j++); assert(j < static_cast(ts.size())); for (; j < static_cast(ts.size())-1; j++) ts[j] = ts[j+1]; ts.pop(); } template static inline bool find(V& ts, const T& t) { int j = 0; for (; j < static_cast(ts.size()) && ts[j] != t; j++); return j < static_cast(ts.size()); } //================================================================================================= // Copying vectors with support for nested vector types: // // Base case: template static inline void copy(const T& from, T& to) { to = from; } // Recursive case: template static inline void copy(const vec& from, vec& to, bool append = false) { if (!append) to.clear(); for (int i = 0; i < from.size(); i++){ to.push(); copy(from[i], to.last()); } } template static inline void append(const vec& from, vec& to){ copy(from, to, true); } //================================================================================================= #endif opensmt-2.5.2/src/minisat/mtl/BasicHeap.h000066400000000000000000000067141445011647600202440ustar00rootroot00000000000000/******************************************************************************************[Heap.h] MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson 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. **************************************************************************************************/ #ifndef BasicHeap_h #define BasicHeap_h #include "Vec.h" //================================================================================================= // A heap implementation with support for decrease/increase key. template class BasicHeap { Comp lt; vec heap; // heap of ints // Index "traversal" functions static inline int left (int i) { return i*2+1; } static inline int right (int i) { return (i+1)*2; } static inline int parent(int i) { return (i-1) >> 1; } inline void percolateUp(int i) { int x = heap[i]; while (i != 0 && lt(x, heap[parent(i)])){ heap[i] = heap[parent(i)]; i = parent(i); } heap [i] = x; } inline void percolateDown(int i) { int x = heap[i]; while (left(i) < heap.size()){ int child = right(i) < heap.size() && lt(heap[right(i)], heap[left(i)]) ? right(i) : left(i); if (!lt(heap[child], x)) break; heap[i] = heap[child]; i = child; } heap[i] = x; } bool heapProperty(int i) { return i >= heap.size() || ((i == 0 || !lt(heap[i], heap[parent(i)])) && heapProperty(left(i)) && heapProperty(right(i))); } public: BasicHeap(const C& c) : comp(c) { } int size () const { return heap.size(); } bool empty () const { return heap.size() == 0; } int operator[](int index) const { return heap[index+1]; } void clear (bool dealloc = false) { heap.clear(dealloc); } void insert (int n) { heap.push(n); percolateUp(heap.size()-1); } int removeMin() { int r = heap[0]; heap[0] = heap.last(); heap.pop(); if (heap.size() > 1) percolateDown(0); return r; } // DEBUG: consistency checking bool heapProperty() { return heapProperty(1); } // COMPAT: should be removed int getmin () { return removeMin(); } }; //================================================================================================= #endif opensmt-2.5.2/src/minisat/mtl/BoxedVec.h000066400000000000000000000127521445011647600201230ustar00rootroot00000000000000/*******************************************************************************************[Vec.h] MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson 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. **************************************************************************************************/ #ifndef BoxedVec_h #define BoxedVec_h #include #include #include //================================================================================================= // Automatically resizable arrays // // NOTE! Don't use this vector on datatypes that cannot be re-located in memory (with realloc) template class bvec { static inline int imin(int x, int y) { int mask = (x-y) >> (sizeof(int)*8-1); return (x&mask) + (y&(~mask)); } static inline int imax(int x, int y) { int mask = (y-x) >> (sizeof(int)*8-1); return (x&mask) + (y&(~mask)); } struct Vec_t { int sz; int cap; T data[0]; static Vec_t* alloc(Vec_t* x, int size){ x = (Vec_t*)realloc((void*)x, sizeof(Vec_t) + sizeof(T)*size); x->cap = size; return x; } }; Vec_t* ref; static const int init_size = 2; static int nextSize (int current) { return (current * 3 + 1) >> 1; } static int fitSize (int needed) { int x; for (x = init_size; needed > x; x = nextSize(x)); return x; } void fill (int size) { assert(ref != NULL); for (T* i = ref->data; i < ref->data + size; i++) new (i) T(); } void fill (int size, const T& pad) { assert(ref != NULL); for (T* i = ref->data; i < ref->data + size; i++) new (i) T(pad); } // Don't allow copying (error prone): altvec& operator = (altvec& other) { assert(0); } altvec (altvec& other) { assert(0); } public: void clear (bool dealloc = false) { if (ref != NULL){ for (int i = 0; i < ref->sz; i++) (*ref).data[i].~T(); if (dealloc) { free(ref); ref = NULL; }else ref->sz = 0; } } // Constructors: altvec(void) : ref (NULL) { } altvec(int size) : ref (Vec_t::alloc(NULL, fitSize(size))) { fill(size); ref->sz = size; } altvec(int size, const T& pad) : ref (Vec_t::alloc(NULL, fitSize(size))) { fill(size, pad); ref->sz = size; } ~altvec(void) { clear(true); } // Ownership of underlying array: operator T* (void) { return ref->data; } // (unsafe but convenient) operator const T* (void) const { return ref->data; } // Size operations: int size (void) const { return ref != NULL ? ref->sz : 0; } void pop (void) { assert(ref != NULL && ref->sz > 0); int last = --ref->sz; ref->data[last].~T(); } void push (const T& elem) { int size = ref != NULL ? ref->sz : 0; int cap = ref != NULL ? ref->cap : 0; if (size == cap){ cap = cap != 0 ? nextSize(cap) : init_size; ref = Vec_t::alloc(ref, cap); } //new (&ref->data[size]) T(elem); ref->data[size] = elem; ref->sz = size+1; } void push () { int size = ref != NULL ? ref->sz : 0; int cap = ref != NULL ? ref->cap : 0; if (size == cap){ cap = cap != 0 ? nextSize(cap) : init_size; ref = Vec_t::alloc(ref, cap); } new (&ref->data[size]) T(); ref->sz = size+1; } void shrink (int nelems) { for (int i = 0; i < nelems; i++) pop(); } void shrink_(int nelems) { for (int i = 0; i < nelems; i++) pop(); } void growTo (int size) { while (this->size() < size) push(); } void growTo (int size, const T& pad) { while (this->size() < size) push(pad); } void capacity (int size) { growTo(size); } const T& last (void) const { return ref->data[ref->sz-1]; } T& last (void) { return ref->data[ref->sz-1]; } // Vector interface: const T& operator [] (int index) const { return ref->data[index]; } T& operator [] (int index) { return ref->data[index]; } void copyTo(altvec& copy) const { copy.clear(); for (int i = 0; i < size(); i++) copy.push(ref->data[i]); } void moveTo(altvec& dest) { dest.clear(true); dest.ref = ref; ref = NULL; } }; #endif opensmt-2.5.2/src/minisat/mtl/Heap.h000066400000000000000000000153341445011647600173000ustar00rootroot00000000000000/******************************************************************************************[Heap.h] MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson 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. **************************************************************************************************/ #ifndef Minisat_Heap_h #define Minisat_Heap_h #include "Vec.h" #include "stdio.h" //================================================================================================= // A heap implementation with support for decrease/increase key. template class Heap { Comp lt; vec heap; // heap of ints vec indices; // int -> index in heap // Index "traversal" functions static inline int left (int i) { return i*2+1; } static inline int right (int i) { return (i+1)*2; } static inline int parent(int i) { return (i-1) >> 1; } inline void percolateUp(int i) { int x = heap[i]; while (i != 0 && lt(x, heap[parent(i)])){ heap[i] = heap[parent(i)]; indices[heap[i]] = i; i = parent(i); } heap [i] = x; indices[x] = i; } // void percolateUp(int i) // { // int x = heap[i]; // int p = parent(i); // // while (i != 0 && lt(x, heap[p])){ // heap[i] = heap[p]; // indices[heap[p]] = i; // i = p; // p = parent(p); // } // heap [i] = x; // indices[x] = i; // } void percolateDown(int i) { int x = heap[i]; while (left(i) < heap.size()){ int child = right(i) < heap.size() && lt(heap[right(i)], heap[left(i)]) ? right(i) : left(i); if (!lt(heap[child], x)) break; heap[i] = heap[child]; indices[heap[i]] = i; i = child; } heap [i] = x; indices[x] = i; } bool heapProperty (int i) const { return i >= heap.size() || ((i == 0 || !lt(heap[i], heap[parent(i)])) && heapProperty(left(i)) && heapProperty(right(i))); } public: Heap(const Comp& c) : lt(c) { } int size () const { return heap.size(); } bool empty () const { return heap.size() == 0; } bool inHeap (int n) const { return n < indices.size() && indices[n] >= 0; } int operator[](int index) const { assert(index < heap.size()); return heap[index]; } void decrease (int n) { assert(inHeap(n)); percolateUp(indices[n]); } void increase (int n) { assert(inHeap(n)); percolateDown(indices[n]); } // RENAME WHEN THE DEPRECATED INCREASE IS REMOVED. void increase_ (int n) { assert(inHeap(n)); percolateDown(indices[n]); } // Fool proof variant of insert/decrease/increase void update(int n) { if (!inHeap(n)) insert(n); else { percolateUp(indices[n]); percolateDown(indices[n]); } } void insert(int n) { indices.growTo(n+1, -1); assert(!inHeap(n)); indices[n] = heap.size(); heap.push(n); percolateUp(indices[n]); } //================================================================================================= // Added Code // // I hope it makes sense // Removes a variable from a // position in the heap // void remove(int n) { assert(inHeap(n)); // Retrieve position of n in the heap int ind = indices[n]; // Replace n with what is bigger in the heap heap[ind] = heap.last( ); // Save new indices for that bigger variable indices[heap[ind]] = ind; // Percolate down bigger variable heap.pop( ); // Percolate down if ( heap.size( ) > 1 ) percolateDown(ind); // Detach n indices[n] = -1; assert(!inHeap(n)); } // Added Code //================================================================================================= int removeMin() { int x = heap[0]; heap[0] = heap.last(); indices[heap[0]] = 0; indices[x] = -1; heap.pop(); if (heap.size() > 1) percolateDown(0); return x; } // Rebuild the heap from scratch, using the elements in 'ns': void build(vec& ns) { for (int i = 0; i < heap.size(); i++) indices[heap[i]] = -1; heap.clear(); for (int i = 0; i < ns.size(); i++){ indices[ns[i]] = i; heap.push(ns[i]); } for (int i = heap.size() / 2 - 1; i >= 0; i--) percolateDown(i); } void clear(bool dealloc = false) { for (int i = 0; i < heap.size(); i++) indices[heap[i]] = -1; #ifdef NDEBUG for (int i = 0; i < indices.size(); i++) assert(indices[i] == -1); #endif heap.clear(dealloc); } // Delete elements from the heap using a given filter function (-object). // *** this could probaly be replaced with a more general "buildHeap(vec&)" method *** template void filter(const F& filt) { int i,j; for (i = j = 0; i < heap.size(); i++) if (filt(heap[i])){ heap[j] = heap[i]; indices[heap[i]] = j++; }else indices[heap[i]] = -1; heap.shrink(i - j); for (int i = heap.size() / 2 - 1; i >= 0; i--) percolateDown(i); // assert(heapProperty()); } // DEBUG: consistency checking bool heapProperty() const { return heapProperty(1); } }; //================================================================================================= #endif opensmt-2.5.2/src/minisat/mtl/Map.h000066400000000000000000000524371445011647600171450ustar00rootroot00000000000000/*******************************************************************************************[Map.h] Copyright (c) 2006-2010, Niklas Sorensson 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. **************************************************************************************************/ #ifndef Minisat_Map_h #define Minisat_Map_h #include "osmtinttypes.h" #include "Vec.h" #include //================================================================================================= // Default hash/equals functions // //template struct Hash { uint32_t operator()(const K& k) const { return hash(k); } }; template struct Equal { bool operator()(const K& k1, const K& k2) const { return k1 == k2; } }; //template struct DeepHash { uint32_t operator()(const K* k) const { return hash(*k); } }; template struct DeepEqual { bool operator()(const K* k1, const K* k2) const { return *k1 == *k2; } }; //static inline uint32_t hash(uint32_t x){ return x; } //static inline uint32_t hash(uint64_t x){ return (uint32_t)x; } //static inline uint32_t hash(int32_t x) { return (uint32_t)x; } //static inline uint32_t hash(int64_t x) { return (uint32_t)x; } //================================================================================================= // Some primes // static const int nprimes = 25; static const int primes [nprimes] = { 31, 73, 151, 313, 643, 1291, 2593, 5233, 10501, 21013, 42073, 84181, 168451, 337219, 674701, 1349473, 2699299, 5398891, 10798093, 21596719, 43193641, 86387383, 172775299, 345550609, 691101253 }; //================================================================================================= // Hash table implementation of Maps // //template, class E = Equal > template > class Map { public: struct Pair { K key; D data; }; private: H hash; E equals; vec* table; int cap; int size; // Don't allow copying (error prone): Map& operator = (Map& other) = delete; Map (Map& other) = delete; bool checkCap(int new_size) const { return new_size > cap; } int32_t index (const K& k) const { return hash(k) % cap; } void _insert (const K& k, const D& d) { vec& ps = table[index(k)]; ps.push(); ps.last().key = k; ps.last().data = d; } void rehash () { const vec* old = table; int old_cap = cap; int newsize = primes[0]; for (int i = 1; newsize <= cap && i < nprimes; i++) newsize = primes[i]; table = new vec[newsize]; cap = newsize; for (int i = 0; i < old_cap; i++){ for (int j = 0; j < old[i].size(); j++){ _insert(old[i][j].key, old[i][j].data); }} delete [] old; // printf(" --- rehashing, old-cap=%d, new-cap=%d\n", cap, newsize); } public: Map () : table(NULL), cap(0), size(0) {} Map (const H& h, const E& e) : hash(h), equals(e), table(NULL), cap(0), size(0) {} Map (Map&& o) noexcept : table(NULL), cap(0), size(0) { std::swap(hash, o.hash); std::swap(equals, o.equals); std::swap(table, o.table); std::swap(cap, o.cap); std::swap(size, o.size); } // Map (Map&& o) noexcept : cap(0), size(0) { std::swap(hash, o.hash); std::swap(equals, o.equals); std::swap(table, o.table); std::swap(cap, o.cap); std::swap(size, o.size); } ~Map () { delete [] table; } //Map& operator = (Map&& o) { std::swap(hash, o.hash); std::swap(equals, o.equals); std::swap(table, o.table); std::swap(cap, o.cap); std::swap(size, o.size); return *this; } Map& operator = (Map&& o) { std::swap(hash, o.hash); std::swap(equals, o.equals); std::swap(table, o.table); std::swap(cap, o.cap); std::swap(size, o.size); return *this; } // PRECONDITION: the key must already exist in the map. const D& operator [] (const K& k) const { assert(size != 0); const D* res = NULL; const vec& ps = table[index(k)]; for (int i = 0; i < ps.size(); i++) if (equals(ps[i].key, k)) res = &ps[i].data; assert(res != NULL); return *res; } // PRECONDITION: the key must already exist in the map. D& operator [] (const K& k) { assert(size != 0); D* res = NULL; vec& ps = table[index(k)]; for (int i = 0; i < ps.size(); i++) if (equals(ps[i].key, k)) res = &ps[i].data; assert(res != NULL); return *res; } // PRECONDITION: the key must *NOT* exist in the map. void insert (const K& k, const D& d) { if (checkCap(size+1)) rehash(); _insert(k, d); size++; } bool peek (const K& k, D& d) const { if (size == 0) return false; const vec& ps = table[index(k)]; for (int i = 0; i < ps.size(); i++) if (equals(ps[i].key, k)){ d = ps[i].data; return true; } return false; } bool has (const K& k) const { if (size == 0) return false; const vec& ps = table[index(k)]; for (int i = 0; i < ps.size(); i++) if (equals(ps[i].key, k)) return true; return false; } void getKeys(vec& out) const { if (size == 0) return; for (int i = 0; i < cap; i++) { if (table[i] == NULL) continue; for (int j = 0; j < table[i].size(); j++) out.push(table[i][j].key); } } void getKeysAndVals(vec& out) const { if (size == 0) return; for (int i = 0; i < cap; i++) { if (table[i] == NULL) continue; for (int j = 0; j < table[i].size(); j++) out.push(table[i][j]); } } vec getKeysAndVals() const { vec out; if (size == 0) return {}; for (int i = 0; i < cap; i++) { if (table[i] == NULL) continue; for (int j = 0; j < table[i].size(); j++) out.push(table[i][j]); } return out; } void getKeysAndValsPtrs(vec& out) { if (size == 0) return; for (int i = 0; i < cap; i++) { if (table[i] == NULL) continue; for (int j = 0; j < table[i].size(); j++) out.push(&table[i][j]); } } vec getKeysAndValsPtrs() { if (size == 0) return {}; vec out; for (int i = 0; i < cap; i++) { if (table[i] == NULL) continue; for (int j = 0; j < table[i].size(); j++) out.push(&table[i][j]); } return out; } vec getKeysAndValsPtrs() const { if (size == 0) return {}; vec out; for (int i = 0; i < cap; i++) { if (table[i] == NULL) continue; for (int j = 0; j < table[i].size(); j++) out.push(&table[i][j]); } return out; } // PRECONDITION: the key must exist in the map. void remove(const K& k) { assert(has(k)); assert(table != NULL); vec& ps = table[index(k)]; int j = 0; for (; j < ps.size() && !equals(ps[j].key, k); j++); assert(j < ps.size()); ps[j] = ps.last(); ps.pop(); size--; } void clear () { cap = size = 0; delete [] table; table = NULL; } int getSize() const { return size; } int elems() const { return size; } int bucket_count() const { return cap; } // NOTE: the hash and equality objects are not moved by this method: void moveTo(Map& other){ delete [] other.table; other.table = table; other.cap = cap; other.size = size; table = NULL; size = cap = 0; } void copyTo(Map& other) const { if (other.table != NULL) delete [] other.table; other.table = new vec[cap]; for (int i = 0; i < cap; i++) { table[i].copyTo(other.table[i]); } other.cap = cap; other.size = size; } // NOTE: given a bit more time, I could make a more C++-style iterator out of this: const vec& bucket(int i) const { return table[i]; } }; template > class VecMap { static_assert(std::is_trivially_copyable::value, "elements of mtl::VecMap vectors need to be trivially copyable"); public: struct Pair { K key; vec data; }; private: H hash; E equals; std::vector* table; int cap; int size; // Don't allow copying (error prone): VecMap& operator = (VecMap& ) = delete; VecMap (VecMap& ) = delete; bool checkCap(int new_size) const { return new_size > cap; } int32_t index (const K& k) const { return hash(k) % cap; } void _insert (const K& k, const vec& d) { std::vector& ps = table[index(k)]; ps.emplace_back(); ps.back().key = k; d.copyTo(ps.back().data); } void rehash () { const std::vector* old = table; int old_cap = cap; int newsize = primes[0]; for (int i = 1; newsize <= cap && i < nprimes; i++) newsize = primes[i]; table = new std::vector[newsize]; cap = newsize; for (int i = 0; i < old_cap; i++) { for (const auto & pair : old[i]) { _insert(pair.key, pair.data); } } delete [] old; // printf(" --- rehashing, old-cap=%d, new-cap=%d\n", cap, newsize); } public: VecMap () : table(NULL), cap(0), size(0) {} VecMap (const H& h, const E& e) : hash(h), equals(e), table(NULL), cap(0), size(0){} ~VecMap () { delete [] table; } // PRECONDITION: the key must already exist in the map. const vec& operator [] (const K& k) const { assert(size != 0); const vec* res = NULL; const std::vector& ps = table[index(k)]; for (const Pair& p : ps) if (equals(p.key, k)) res = &p.data; assert(res != NULL); return *res; } // PRECONDITION: the key must already exist in the map. vec& operator [] (const K& k) { assert(size != 0); vec* res = NULL; std::vector& ps = table[index(k)]; for (Pair & p : ps) if (equals(p.key, k)) res = &p.data; assert(res != NULL); return *res; } // PRECONDITION: the key must *NOT* exist in the map. void insert (const K& k, const vec& d) { assert(not has(k)); if (checkCap(size+1)) rehash(); _insert(k, d); size++; } bool peek (const K& k, vec& d) const { if (size == 0) return false; const std::vector& ps = table[index(k)]; for (int i = 0; i < ps.size(); i++) if (equals(ps[i].key, k)){ ps[i].data.copyTo(d); return true; } return false; } bool has(const K& k) const { if (size == 0) return false; const std::vector& ps = table[index(k)]; for (const Pair& p : ps) if (equals(p.key, k)) return true; return false; } const vec* getOrNull(const K& k) const { if (size == 0) return nullptr; const std::vector& ps = table[index(k)]; for (const Pair & p : ps) if (equals(p.key, k)) return &p.data; return nullptr; } void getKeys(vec& out) const { if (size == 0) return; for (auto i = 0; i < cap; i++) { for (const auto & pair : table[i]) { out.push(pair.key); } } } // PRECONDITION: the key must exist in the map. void remove(const K& k) { assert(table != NULL); std::vector& ps = table[index(k)]; int j = 0; for (; j < ps.size() && !equals(ps[j].key, k); j++); assert(j < ps.size()); ps[j].key = ps.last().key; ps.last().data.copyTo(ps[j].data); ps.pop(); size--; } void clear () { cap = size = 0; delete [] table; table = NULL; } int elems() const { return size; } int bucket_count() const { return cap; } // NOTE: the hash and equality objects are not moved by this method: void moveTo(VecMap& other){ delete [] other.table; other.table = table; other.cap = cap; other.size = size; table = NULL; size = cap = 0; } // NOTE: given a bit more time, I could make a more C++-style iterator out of this: const std::vector& bucket(int i) const { return table[i]; } }; template > class VecKeyMap { public: struct Pair { vec key; D data; }; private: H hash; E equals; vec* table; int cap; int size; // Don't allow copying (error prone): VecKeyMap& operator = (VecKeyMap& other) = delete; VecKeyMap (VecKeyMap& other) = delete; bool checkCap(int new_size) const { return new_size > cap; } int32_t index (const vec& k) const { return hash(k) % cap; } void _insert (const vec& k, const D& d) { vec& ps = table[index(k)]; ps.push(); k.copyTo(ps.last().key); ps.last().data = d; } void rehash () { const vec* old = table; int old_cap = cap; int newsize = primes[0]; for (int i = 1; newsize <= cap && i < nprimes; i++) newsize = primes[i]; table = new vec[newsize]; cap = newsize; for (int i = 0; i < old_cap; i++){ for (int j = 0; j < old[i].size(); j++){ _insert(old[i][j].key, old[i][j].data); }} delete [] old; // printf(" --- rehashing, old-cap=%d, new-cap=%d\n", cap, newsize); } public: VecKeyMap () : table(NULL), cap(0), size(0) {} VecKeyMap (const H& h, const E& e) : hash(h), equals(e), table(NULL), cap(0), size(0){} ~VecKeyMap () { delete [] table; } // PRECONDITION: the key must already exist in the map. const D& operator [] (const vec& k) const { assert(size != 0); const D* res = NULL; const vec& ps = table[index(k)]; for (int i = 0; i < ps.size(); i++) if (equals(ps[i].key, k)) res = &ps[i].data; assert(res != NULL); return *res; } // PRECONDITION: the key must already exist in the map. D& operator [] (const vec& k) { assert(size != 0); D* res = NULL; vec& ps = table[index(k)]; for (int i = 0; i < ps.size(); i++) if (equals(ps[i].key, k)) res = &ps[i].data; assert(res != NULL); return *res; } // PRECONDITION: the key must *NOT* exist in the map. void insert (const vec& k, const D& d) { if (checkCap(size+1)) rehash(); _insert(k, d); size++; } bool peek (const vec& k, D& d) const { if (size == 0) return false; const vec& ps = table[index(k)]; for (int i = 0; i < ps.size(); i++) if (equals(ps[i].key, k)){ d = ps[i].data; return true; } return false; } bool contains(const vec& k) const { if (size == 0) return false; const vec& ps = table[index(k)]; for (int i = 0; i < ps.size(); i++) if (equals(ps[i].key, k)) return true; return false; } // PRECONDITION: the key must exist in the map. void remove(const vec& k) { assert(table != NULL); vec& ps = table[index(k)]; int j = 0; for (; j < ps.size() && !equals(ps[j].key, k); j++); assert(j < ps.size()); ps[j] = ps.last(); ps.pop(); size--; } void clear () { cap = size = 0; delete [] table; table = NULL; } int elems() const { return size; } int bucket_count() const { return cap; } // NOTE: the hash and equality objects are not moved by this method: void moveTo(VecKeyMap& other){ delete [] other.table; other.table = table; other.cap = cap; other.size = size; table = NULL; size = cap = 0; } // NOTE: given a bit more time, I could make a more C++-style iterator out of this: const vec& bucket(int i) const { return table[i]; } }; // A vector of maps. template > class MapVec { Map* data; int sz; int cap; // Don't allow copying (error prone): MapVec& operator = (MapVec& other) = delete; MapVec (MapVec& other) = delete; // Helpers for calculating next capacity: static inline int imax (int x, int y) { int mask = (y-x) >> (sizeof(int)*8-1); return (x&mask) + (y&(~mask)); } //static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; } static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; } public: // Constructors: MapVec() : data(NULL) , sz(0) , cap(0) { } explicit MapVec(int size) : data(NULL) , sz(0) , cap(0) { growTo(size); } MapVec(int size, const Map& pad) : data(NULL) , sz(0) , cap(0) { growTo(size, pad); } ~MapVec() { clear(true); } // Pointer to first element: operator Map* (void) { return data; } // Size operations: int size (void) const { return sz; } uint32_t size_ (void) const { assert(sz >= 0); return (uint32_t) sz; } void shrink (int nelems) { assert(nelems <= sz); for (int i = 0; i < nelems; i++) sz--, data[sz].~Map(); } void shrink_ (int nelems) { assert(nelems <= sz); sz -= nelems; } int capacity (void) const { return cap; } void capacity (int min_cap) { if (cap >= min_cap) return; int add = imax((min_cap - cap + 1) & ~1, ((cap >> 1) + 2) & ~1); // NOTE: grow by approximately 3/2 if (add > INT_MAX - cap || (((data = (Map*)::realloc(data, (cap += add) * sizeof(Map))) == NULL) && errno == ENOMEM)) throw OutOfMemoryException(); } void growTo (int size); void growTo (int size, const Map& pad); void clear (bool dealloc = false) { if (data != NULL) { for (int i = 0; i < sz; i++) data[i].~Map(); sz = 0; if (dealloc) free(data), data = NULL, cap = 0; } } void reset (); // Stack interface: void push (void) { if (sz == cap) capacity(sz+1); new (&data[sz]) Map(); sz++; } void push (const MapVec& elem) { if (sz == cap) capacity(sz+1); elem.moveTo(data[sz++]); } void pop (void) { assert(sz > 0); sz--, data[sz].~Map(); } // NOTE: it seems possible that overflow can happen in the 'sz+1' expression of 'push()', but // in fact it can not since it requires that 'cap' is equal to INT_MAX. This in turn can not // happen given the way capacities are calculated (below). Essentially, all capacities are // even, but INT_MAX is odd. const Map& last (void) const { return data[sz-1]; } Map& last (void) { return data[sz-1]; } // Vector interface: const Map& operator [] (int index) const { return data[index]; } Map& operator [] (int index) { return data[index]; } // Duplicatation (preferred instead): void copyTo(MapVec& copy) const { copy.clear(); copy.growTo(sz); for (int i = 0; i < sz; i++) data[i].copyTo(copy[i]); } void moveTo(MapVec& dest) { dest.clear(true); dest.data = data; dest.sz = sz; dest.cap = cap; data = NULL; sz = 0; cap = 0; } }; //================================================================================================= #endif opensmt-2.5.2/src/minisat/mtl/Map.old.h000066400000000000000000000120071445011647600177070ustar00rootroot00000000000000/*******************************************************************************************[Map.h] MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson 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. **************************************************************************************************/ #ifndef Map_h #define Map_h #include #include "Vec.h" //================================================================================================= // Default hash/equals functions // //template struct Hash { uint32_t operator()(const K& k) const { return hash(k); } }; template struct Equal { bool operator()(const K& k1, const K& k2) const { return k1 == k2; } }; //template struct DeepHash { uint32_t operator()(const K* k) const { return hash(*k); } }; template struct DeepEqual { bool operator()(const K* k1, const K* k2) const { return *k1 == *k2; } }; //================================================================================================= // Some primes // static const int nprimes = 25; static const int primes [nprimes] = { 31, 73, 151, 313, 643, 1291, 2593, 5233, 10501, 21013, 42073, 84181, 168451, 337219, 674701, 1349473, 2699299, 5398891, 10798093, 21596719, 43193641, 86387383, 172775299, 345550609, 691101253 }; //================================================================================================= // Hash table implementation of Maps // //template, class E = Equal > template > class Map { struct Pair { K key; D data; }; H hash; E equals; vec* table; int cap; int size; // Don't allow copying (error prone): Map& operator = (Map& other) { assert(0); } Map (Map& other) { assert(0); } int32_t index (const K& k) const { return hash(k) % cap; } void _insert (const K& k, const D& d) { table[index(k)].push(); table[index(k)].last().key = k; table[index(k)].last().data = d; } void rehash () { const vec* old = table; int newsize = primes[0]; for (int i = 1; newsize <= cap && i < nprimes; i++) newsize = primes[i]; table = new vec[newsize]; for (int i = 0; i < cap; i++){ for (int j = 0; j < old[i].size(); j++){ _insert(old[i][j].key, old[i][j].data); }} if (old) delete [] old; cap = newsize; } public: Map () : table(NULL), cap(0), size(0) {} Map (const H& h, const E& e) : Map(), hash(h), equals(e) {} ~Map () { if (table) delete [] table; } const D& operator [] (const K& k) const { assert(size != 0); const D* res = NULL; const vec& ps = table[index(k)]; for (int i = 0; i < ps.size(); i++) if (equals(ps[i].key, k)) res = &ps[i].data; assert(res != NULL); return *res; } void insert (const K& k, const D& d) { if (size+1 > cap / 2) rehash(); _insert(k, d); size++; } bool peek (const K& k, D& d) { if (size == 0) return false; const vec& ps = table[index(k)]; for (int i = 0; i < ps.size(); i++) if (equals(ps[i].key, k)){ d = ps[i].data; return true; } return false; } bool contains(const K& k) const { if (size == 0) return false; const vec& ps = table[index(k)]; for (int i = 0; i < ps.size(); i++) if (equals(ps[i].key, k)) return true; return false; } void remove (const K& k) { assert(table != NULL); vec& ps = table[index(k)]; int j = 0; for (; j < ps.size() && !equals(ps[j].key, k); j++) ; assert(j < ps.size()); ps[j] = ps.last(); ps.pop(); } void clear () { cap = size = 0; delete [] table; table = NULL; } }; #endif opensmt-2.5.2/src/minisat/mtl/MapWithKeys.h000066400000000000000000000032321445011647600206220ustar00rootroot00000000000000// // Created by Antti on 18.05.21. // #ifndef OPENSMT_KEYVALMAP_H #define OPENSMT_KEYVALMAP_H #include "Map.h" template > class MapWithKeys { Map map; vec keys; public: int getSize() const { return map.getSize(); } MapWithKeys () {} MapWithKeys (const H& h, const E& e) : map(h, e) {} MapWithKeys (MapWithKeys&& o) noexcept : map(std::move(o.map)), keys(std::move(o.keys)) { } MapWithKeys& operator = (MapWithKeys&& o) { std::swap(map, o.map); std::swap(keys, o.keys); return *this; } // PRECONDITION: the key must already exist in the map. const D& operator [] (const K& k) const { return map.operator[](k); } // PRECONDITION: the key must already exist in the map. D& operator [] (const K& k) { return map.operator[](k); } // PRECONDITION: the key must *NOT* exist in the map. void insert (const K& k, const D& d) { map.insert(k, d); keys.push(k); } /** * Check if k exists in the map. If it exists, return h[k] i d. If it does not, d remains unchanged * @param k key * @param d where to place data * @return true if k is in the map and false if k is not in the map. */ bool peek (const K& k, D& d) const { return map.peek(k, d); } bool has (const K& k) const { return map.has(k); } const vec & getKeys() const { return keys; } const Map & getMap() const { return map; } void copyTo(MapWithKeys & o) const { map.copyTo(o.map); keys.copyTo(o.keys); } void clear() { map.clear(); keys.clear(); } }; #endif //OPENSMT_KEYVALMAP_H opensmt-2.5.2/src/minisat/mtl/Queue.h000066400000000000000000000056431445011647600175110ustar00rootroot00000000000000/*****************************************************************************************[Queue.h] Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson Copyright (c) 2007-2010, Niklas Sorensson 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. **************************************************************************************************/ #ifndef Minisat_Queue_h #define Minisat_Queue_h #include "Vec.h" //================================================================================================= template class Queue { vec buf; int first; int end; public: typedef T Key; Queue() : buf(1), first(0), end(0) {} void clear (bool dealloc = false) { buf.clear(dealloc); buf.growTo(1); first = end = 0; } int size () const { return (end >= first) ? end - first : end - first + buf.size(); } const T& operator [] (int index) const { assert(index >= 0); assert(index < size()); return buf[(first + index) % buf.size()]; } T& operator [] (int index) { assert(index >= 0); assert(index < size()); return buf[(first + index) % buf.size()]; } T peek () const { assert(first != end); return buf[first]; } void pop () { assert(first != end); first++; if (first == buf.size()) first = 0; } void insert(T elem) { // INVARIANT: buf[end] is always unused buf[end++] = elem; if (end == buf.size()) end = 0; if (first == end){ // Resize: vec tmp((buf.size()*3 + 1) >> 1); //**/printf("queue alloc: %d elems (%.1f MB)\n", tmp.size(), tmp.size() * sizeof(T) / 1000000.0); int i = 0; for (int j = first; j < buf.size(); j++) tmp[i++] = buf[j]; for (int j = 0 ; j < end ; j++) tmp[i++] = buf[j]; first = 0; end = buf.size(); tmp.moveTo(buf); } } }; //================================================================================================= #endif opensmt-2.5.2/src/minisat/mtl/Sort.h000066400000000000000000000106721445011647600173520ustar00rootroot00000000000000/******************************************************************************************[Sort.h] MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson 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. **************************************************************************************************/ #ifndef Sort_h #define Sort_h #include "Vec.h" //================================================================================================= // Some sorting algorithms for vec's template struct LessThan_default { bool operator () (T x, T y) { return x < y; } }; template void selectionSort(T* array, int size, LessThan lt) { int i, j, best_i; T tmp; for (i = 0; i < size-1; i++){ best_i = i; for (j = i+1; j < size; j++){ if (lt(array[j], array[best_i])) best_i = j; } tmp = array[i]; array[i] = array[best_i]; array[best_i] = tmp; } } template static inline void selectionSort(T* array, int size) { selectionSort(array, size, LessThan_default()); } template void sort(T* array, int size, LessThan lt) { if (size <= 15) selectionSort(array, size, lt); else{ T pivot = array[size / 2]; T tmp; int i = -1; int j = size; for(;;){ do i++; while(lt(array[i], pivot)); do j--; while(lt(pivot, array[j])); if (i >= j) break; tmp = array[i]; array[i] = array[j]; array[j] = tmp; } sort(array , i , lt); sort(&array[i], size-i, lt); } } template static inline void sort(T* array, int size) { sort(array, size, LessThan_default()); } template void copyArray(T* src, int begin, int end, T* dst) { for (int i = begin; i < end; i++) dst[i] = src[i]; } template void merge(T* src, int begin, int middle, int end, T* work, LessThan lt) { int i0 = begin; int i1 = middle; for (int j = begin; j < end; j++) { if (i0 < middle && (i1 >= end || lt(src[i0], src[i1]))) work[j] = src[i0++]; else work[j] = src[i1++]; } } template void splitMerge(T* src, int begin, int end, T* work, LessThan lt) { if (end-begin <= 1) return; int middle = (end+begin)/2; splitMerge(src, begin, middle, work, lt); splitMerge(src, middle, end, work, lt); merge(src, begin, middle, end, work, lt); copyArray(work, begin, end, src); } template static inline void mergeSort(T* src, int size, LessThan lt) { T* work = (T*)malloc(sizeof(T)*size); splitMerge(src, 0, size, work, lt); free(work); } //================================================================================================= // For 'vec's: template void sort(vec& v, LessThan lt) { sort((T*)v, v.size(), lt); } template void sort(vec& v) { sort(v, LessThan_default()); } template void uniq(vec& v) { int j, i; if (v.size() == 0) return; T* prev = &v[0]; for (i = 1, j = 1; i < v.size(); i++) { if (v[i] != *prev) { v[j++] = v[i]; prev = &v[i]; } } v.shrink(i-j); } //================================================================================================= #endif opensmt-2.5.2/src/minisat/mtl/Vec.h000066400000000000000000000156671445011647600171510ustar00rootroot00000000000000/*******************************************************************************************[Vec.h] Copyright (c) 2003-2007, Niklas Een, Niklas Sorensson Copyright (c) 2007-2010, Niklas Sorensson Copyright (c) 2012-2014, Antti Hyvarinen 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. **************************************************************************************************/ #ifndef Minisat_Vec_h #define Minisat_Vec_h #include #include #include #include #include #include "osmtinttypes.h" #include "XAlloc.h" //================================================================================================= // Automatically resizable arrays // // NOTE! Don't use this vector on datatypes that cannot be re-located in memory (with realloc) template class vec { T* data; int sz; int cap; static_assert(std::is_trivially_copyable::value, "mtl::vec elements need to be trivially copyable"); // Helpers for calculating next capacity: static inline int imax (int x, int y) { int mask = (y-x) >> (sizeof(int)*8-1); return (x&mask) + (y&(~mask)); } //static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; } static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; } public: // Constructors: vec() : data(NULL) , sz(0) , cap(0) { } explicit vec(int size) : data(NULL) , sz(0) , cap(0) { growTo(size); } vec(int size, const T& pad) : data(NULL) , sz(0) , cap(0) { growTo(size, pad); } vec(const std::initializer_list &iList); vec(const std::vector& v) : vec(v.size()) { for (unsigned i = 0; i < v.size(); i++) { operator[](i) = v[i]; } }; vec(vec&& o) : data(NULL) , sz(0) , cap(0) { std::swap(data, o.data); std::swap(sz, o.sz); std::swap(cap, o.cap); } // copy constructor if ever needed //vec(const vec& other) : sz(other.sz), cap(other.cap) { data = (T*)malloc(cap*sizeof(T)); memcpy(data, other.data, sz*sizeof(T)); } ~vec() { clear(true); } vec& operator = (vec&& o) { std::swap(data, o.data); std::swap(sz, o.sz); std::swap(cap, o.cap); return *this; } // Pointer to first element: operator T* (void) { return data; } // Size operations: int size (void) const { return sz; } uint32_t size_ (void) const { assert(sz >= 0); return (uint32_t) sz; } void shrink (int nelems) { assert(nelems <= sz); for (int i = 0; i < nelems; i++) sz--, data[sz].~T(); } void shrink_ (int nelems) { assert(nelems <= sz); sz -= nelems; } int capacity (void) const { return cap; } void capacity (int min_cap); void growTo (int size); void growTo (int size, const T& pad); void clear (bool dealloc = false); void reset (); // Stack interface: void push (void) { if (sz == cap) capacity(sz+1); new (&data[sz]) T(); sz++; } void push (const T& elem) { if (sz == cap) capacity(sz+1); data[sz++] = elem; } void push_m(T&& elem) { int sz_old = sz; if (sz_old == cap) capacity(sz_old+1); growTo(sz_old+1); data[sz_old] = std::move(elem); } void push_c(const T& elem) { if (sz == cap) { cap = imax(2, (cap*3+1)>>1); data = (T*)realloc(data, cap * sizeof(T)); } new (&data[sz]) T(elem); sz++; } void push_ (const T& elem) { assert(sz < cap); data[sz++] = elem; } void pop (void) { assert(sz > 0); sz--, data[sz].~T(); } // NOTE: it seems possible that overflow can happen in the 'sz+1' expression of 'push()', but // in fact it can not since it requires that 'cap' is equal to INT_MAX. This in turn can not // happen given the way capacities are calculated (below). Essentially, all capacities are // even, but INT_MAX is odd. const T& last (void) const { return data[sz-1]; } T& last (void) { return data[sz-1]; } // Vector interface: const T& operator [] (int index) const { return data[index]; } T& operator [] (int index) { return data[index]; } // methods for STL compatibility T* begin() { return data; } const T* begin() const { return data; } T* end() { return data + sz; } const T* end() const { return data + sz; } // Duplicatation (preferred instead): void copyTo(vec& copy) const { copy.clear(); copy.growTo(sz); for (int i = 0; i < sz; i++) copy[i] = data[i]; } void moveTo(vec& dest) { dest.clear(true); dest.data = data; dest.sz = sz; dest.cap = cap; data = NULL; sz = 0; cap = 0; } }; template vec::vec(const std::initializer_list &iList) : data(NULL), sz(0), cap(0) { this->growTo(iList.size()); int i = 0; for (const T &elem : iList) { data[i++] = elem; } } template void vec::capacity(int min_cap) { if (cap >= min_cap) return; int add = imax((min_cap - cap + 1) & ~1, ((cap >> 1) + 2) & ~1); // NOTE: grow by approximately 3/2 if (add > INT_MAX - cap || (((data = (T*)::realloc(data, (cap += add) * sizeof(T))) == NULL) && errno == ENOMEM)) throw OutOfMemoryException(); } template void vec::growTo(int size, const T& pad) { if (sz >= size) return; capacity(size); for (int i = sz; i < size; i++) data[i] = pad; sz = size; } template void vec::growTo(int size) { if (sz >= size) return; capacity(size); for (int i = sz; i < size; i++) new (&data[i]) T(); sz = size; } template void vec::clear(bool dealloc) { if (data != NULL){ for (int i = 0; i < sz; i++) data[i].~T(); sz = 0; if (dealloc) free(data), data = NULL, cap = 0; } } template void vec::reset() { data = 0; sz = 0; cap = 0; } //================================================================================================= #endif opensmt-2.5.2/src/minisat/mtl/template.mk000066400000000000000000000045701445011647600204160ustar00rootroot00000000000000## ## Template makefile for Standard, Profile, Debug, Release, and Release-static versions ## ## eg: "make rs" for a statically linked release version. ## "make d" for a debug version (no optimizations). ## "make" for the standard version (optimized, but with debug information and assertions active) CSRCS ?= $(wildcard *.C) CHDRS ?= $(wildcard *.h) COBJS ?= $(addsuffix .o, $(basename $(CSRCS))) PCOBJS = $(addsuffix p, $(COBJS)) DCOBJS = $(addsuffix d, $(COBJS)) RCOBJS = $(addsuffix r, $(COBJS)) EXEC ?= $(notdir $(shell pwd)) LIB ?= $(EXEC) CXX ?= g++ CFLAGS ?= -Wall LFLAGS ?= -Wall COPTIMIZE ?= -O3 .PHONY : s p d r rs lib libd clean s: $(EXEC) p: $(EXEC)_profile d: $(EXEC)_debug r: $(EXEC)_release rs: $(EXEC)_static lib: lib$(LIB).a libd: lib$(LIB)d.a ## Compile options %.o: CFLAGS +=$(COPTIMIZE) -ggdb -D DEBUG %.op: CFLAGS +=$(COPTIMIZE) -pg -ggdb -D NDEBUG %.od: CFLAGS +=-O0 -ggdb -D DEBUG # -D INVARIANTS %.or: CFLAGS +=$(COPTIMIZE) -D NDEBUG ## Link options $(EXEC): LFLAGS := -ggdb $(LFLAGS) $(EXEC)_profile: LFLAGS := -ggdb -pg $(LFLAGS) $(EXEC)_debug: LFLAGS := -ggdb $(LFLAGS) $(EXEC)_release: LFLAGS := $(LFLAGS) $(EXEC)_static: LFLAGS := --static $(LFLAGS) ## Dependencies $(EXEC): $(COBJS) $(EXEC)_profile: $(PCOBJS) $(EXEC)_debug: $(DCOBJS) $(EXEC)_release: $(RCOBJS) $(EXEC)_static: $(RCOBJS) lib$(LIB).a: $(filter-out Main.or, $(RCOBJS)) lib$(LIB)d.a: $(filter-out Main.od, $(DCOBJS)) ## Build rule %.o %.op %.od %.or: %.C @echo Compiling: "$@ ( $< )" @$(CXX) $(CFLAGS) -c -o $@ $< ## Linking rules (standard/profile/debug/release) $(EXEC) $(EXEC)_profile $(EXEC)_debug $(EXEC)_release $(EXEC)_static: @echo Linking: "$@ ( $^ )" @$(CXX) $^ $(LFLAGS) -o $@ ## Library rule lib$(LIB).a lib$(LIB)d.a: @echo Library: "$@ ( $^ )" @rm -f $@ @ar cq $@ $^ ## Clean rule clean: @rm -f $(EXEC) $(EXEC)_profile $(EXEC)_debug $(EXEC)_release $(EXEC)_static \ $(COBJS) $(PCOBJS) $(DCOBJS) $(RCOBJS) *.core depend.mak lib$(LIB).a lib$(LIB)d.a ## Make dependencies depend.mk: $(CSRCS) $(CHDRS) @echo Making dependencies ... @$(CXX) $(CFLAGS) -MM $(CSRCS) > depend.mk @cp depend.mk /tmp/depend.mk.tmp @sed "s/o:/op:/" /tmp/depend.mk.tmp >> depend.mk @sed "s/o:/od:/" /tmp/depend.mk.tmp >> depend.mk @sed "s/o:/or:/" /tmp/depend.mk.tmp >> depend.mk @rm /tmp/depend.mk.tmp -include depend.mk opensmt-2.5.2/src/minisat/simp/000077500000000000000000000000001445011647600164205ustar00rootroot00000000000000opensmt-2.5.2/src/minisat/simp/Main.C000066400000000000000000000332551445011647600174200ustar00rootroot00000000000000/******************************************************************************************[Main.C] MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson 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. **************************************************************************************************/ #include #include #include #include #include #include #include "SimpSolver.h" /*************************************************************************************/ #ifdef _MSC_VER #include static inline double cpuTime(void) { return (double)clock() / CLOCKS_PER_SEC; } #else #include #include #include static inline double cpuTime(void) { struct rusage ru; getrusage(RUSAGE_SELF, &ru); return (double)ru.ru_utime.tv_sec + (double)ru.ru_utime.tv_usec / 1000000; } #endif #if defined(__linux__) static inline int memReadStat(int field) { char name[256]; pid_t pid = getpid(); sprintf(name, "/proc/%d/statm", pid); FILE* in = fopen(name, "rb"); if (in == NULL) return 0; int value; for (; field >= 0; field--) fscanf(in, "%d", &value); fclose(in); return value; } static inline uint64_t memUsed() { return (uint64_t)memReadStat(0) * (uint64_t)getpagesize(); } #elif defined(__FreeBSD__) static inline uint64_t memUsed(void) { struct rusage ru; getrusage(RUSAGE_SELF, &ru); return ru.ru_maxrss*1024; } #else static inline uint64_t memUsed() { return 0; } #endif #if defined(__GLIBC__) #include #endif //================================================================================================= // DIMACS Parser: #define CHUNK_LIMIT 1048576 class StreamBuffer { gzFile in; char buf[CHUNK_LIMIT]; int pos; int size; void assureLookahead() { if (pos >= size) { pos = 0; size = gzread(in, buf, sizeof(buf)); } } public: StreamBuffer(gzFile i) : in(i), pos(0), size(0) { assureLookahead(); } int operator * () { return (pos >= size) ? EOF : buf[pos]; } void operator ++ () { pos++; assureLookahead(); } }; //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - template static void skipWhitespace(B& in) { while ((*in >= 9 && *in <= 13) || *in == 32) ++in; } template static void skipLine(B& in) { for (;;){ if (*in == EOF || *in == '\0') return; if (*in == '\n') { ++in; return; } ++in; } } template static int parseInt(B& in) { int val = 0; bool neg = false; skipWhitespace(in); if (*in == '-') neg = true, ++in; else if (*in == '+') ++in; if (*in < '0' || *in > '9') reportf("PARSE ERROR! Unexpected char: %c\n", *in), exit(3); while (*in >= '0' && *in <= '9') val = val*10 + (*in - '0'), ++in; return neg ? -val : val; } template static void readClause(B& in, SimpSolver& S, vec& lits) { int parsed_lit, var; lits.clear(); for (;;){ parsed_lit = parseInt(in); if (parsed_lit == 0) break; var = abs(parsed_lit)-1; while (var >= S.nVars()) S.newVar(); lits.push( (parsed_lit > 0) ? Lit(var) : ~Lit(var) ); } } template static bool match(B& in, char* str) { for (; *str != 0; ++str, ++in) if (*str != *in) return false; return true; } template static void parse_DIMACS_main(B& in, SimpSolver& S) { vec lits; for (;;){ skipWhitespace(in); if (*in == EOF) break; else if (*in == 'p'){ if (match(in, "p cnf")){ int vars = parseInt(in); int clauses = parseInt(in); reportf("| Number of variables: %-12d |\n", vars); reportf("| Number of clauses: %-12d |\n", clauses); // SATRACE'06 hack if (clauses > 4000000) S.eliminate(true); }else{ reportf("PARSE ERROR! Unexpected char: %c\n", *in), exit(3); } } else if (*in == 'c' || *in == 'p') skipLine(in); else{ readClause(in, S, lits); S.addClause(lits); } } } // Inserts problem into solver. // static void parse_DIMACS(gzFile input_stream, SimpSolver& S) { StreamBuffer in(input_stream); parse_DIMACS_main(in, S); } //================================================================================================= void printStats(Solver& S) { double cpu_time = cpuTime(); uint64_t mem_used = memUsed(); reportf("restarts : %lld\n", S.starts); reportf("conflicts : %-12lld (%.0f /sec)\n", S.conflicts , S.conflicts /cpu_time); reportf("decisions : %-12lld (%4.2f %% random) (%.0f /sec)\n", S.decisions, (float)S.rnd_decisions*100 / (float)S.decisions, S.decisions /cpu_time); reportf("propagations : %-12lld (%.0f /sec)\n", S.propagations, S.propagations/cpu_time); reportf("conflict literals : %-12lld (%4.2f %% deleted)\n", S.tot_literals, (S.max_literals - S.tot_literals)*100 / (double)S.max_literals); if (mem_used != 0) reportf("Memory used : %.2f MB\n", mem_used / 1048576.0); reportf("CPU time : %g s\n", cpu_time); } SimpSolver* solver; static void SIGINT_handler(int signum) { reportf("\n"); reportf("*** INTERRUPTED ***\n"); printStats(*solver); reportf("\n"); reportf("*** INTERRUPTED ***\n"); exit(1); } //================================================================================================= // Main: void printUsage(char** argv) { reportf("USAGE: %s [options] \n\n where input may be either in plain or gzipped DIMACS.\n\n", argv[0]); reportf("OPTIONS:\n\n"); reportf(" -pre = {none,once}\n"); reportf(" -asymm\n"); reportf(" -rcheck\n"); reportf(" -grow = [ >0 ]\n"); reportf(" -polarity-mode = {true,false,rnd}\n"); reportf(" -decay = [ 0 - 1 ]\n"); reportf(" -rnd-freq = [ 0 - 1 ]\n"); reportf(" -dimacs = \n"); reportf(" -verbosity = {0,1,2}\n"); reportf("\n"); } typedef enum { pre_none, pre_once, pre_repeat } preprocessMode; const char* hasPrefix(const char* str, const char* prefix) { int len = strlen(prefix); if (strncmp(str, prefix, len) == 0) return str + len; else return NULL; } int main(int argc, char** argv) { reportf("This is MiniSat 2.0 beta\n"); #if defined(__GLIBC__) fpu_control_t oldcw, newcw; _FPU_GETCW(oldcw); newcw = (oldcw & ~_FPU_EXTENDED) | _FPU_DOUBLE; _FPU_SETCW(newcw); reportf("WARNING: for repeatability, setting FPU to use double precision\n"); #endif preprocessMode pre = pre_once; const char* dimacs = NULL; const char* freeze = NULL; SimpSolver S; S.verbosity = 1; // This just grew and grew, and I didn't have time to do sensible argument parsing yet :) // int i, j; const char* value; for (i = j = 0; i < argc; i++){ if ((value = hasPrefix(argv[i], "-polarity-mode="))){ if (strcmp(value, "true") == 0) S.polarity_mode = Solver::polarity_true; else if (strcmp(value, "false") == 0) S.polarity_mode = Solver::polarity_false; else if (strcmp(value, "rnd") == 0) S.polarity_mode = Solver::polarity_rnd; else{ reportf("ERROR! unknown polarity-mode %s\n", value); exit(0); } }else if ((value = hasPrefix(argv[i], "-rnd-freq="))){ double rnd; if (sscanf(value, "%lf", &rnd) <= 0 || rnd < 0 || rnd > 1){ reportf("ERROR! illegal rnd-freq constant %s\n", value); exit(0); } S.random_var_freq = rnd; }else if ((value = hasPrefix(argv[i], "-decay="))){ double decay; if (sscanf(value, "%lf", &decay) <= 0 || decay <= 0 || decay > 1){ reportf("ERROR! illegal decay constant %s\n", value); exit(0); } S.var_decay = 1 / decay; }else if ((value = hasPrefix(argv[i], "-verbosity="))){ int verbosity = (int)strtol(value, NULL, 10); if (verbosity == 0 && errno == EINVAL){ reportf("ERROR! illegal verbosity level %s\n", value); exit(0); } S.verbosity = verbosity; }else if ((value = hasPrefix(argv[i], "-pre="))){ if (strcmp(value, "none") == 0) pre = pre_none; else if (strcmp(value, "once") == 0) pre = pre_once; else if (strcmp(value, "repeat") == 0){ pre = pre_repeat; reportf("ERROR! preprocessing mode \"repeat\" is not supported at the moment.\n"); exit(0); }else{ reportf("ERROR! unknown preprocessing mode %s\n", value); exit(0); } }else if (strcmp(argv[i], "-asymm") == 0){ S.asymm_mode = true; }else if (strcmp(argv[i], "-rcheck") == 0){ S.redundancy_check = true; }else if ((value = hasPrefix(argv[i], "-grow="))){ int grow = (int)strtol(value, NULL, 10); if (grow == 0 && errno == EINVAL){ reportf("ERROR! illegal grow constant %s\n", &argv[i][6]); exit(0); } S.grow = grow; }else if ((value = hasPrefix(argv[i], "-dimacs="))){ dimacs = value; }else if ((value = hasPrefix(argv[i], "-freeze="))){ freeze = value; }else if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "-help") == 0){ printUsage(argv); exit(0); }else if (strncmp(argv[i], "-", 1) == 0){ reportf("ERROR! unknown flag %s\n", argv[i]); exit(0); }else argv[j++] = argv[i]; } argc = j; double cpu_time = cpuTime(); if (pre == pre_none) S.eliminate(true); solver = &S; signal(SIGINT,SIGINT_handler); signal(SIGHUP,SIGINT_handler); if (argc == 1) reportf("Reading from standard input... Use '-h' or '--help' for help.\n"); gzFile in = (argc == 1) ? gzdopen(0, "rb") : gzopen(argv[1], "rb"); if (in == NULL) reportf("ERROR! Could not open file: %s\n", argc == 1 ? "" : argv[1]), exit(1); reportf("============================[ Problem Statistics ]=============================\n"); reportf("| |\n"); parse_DIMACS(in, S); gzclose(in); FILE* res = (argc >= 3) ? fopen(argv[2], "wb") : NULL; double parse_time = cpuTime() - cpu_time; reportf("| Parsing time: %-12.2f s |\n", parse_time); /*HACK: Freeze variables*/ if (freeze != NULL && pre != pre_none){ int count = 0; FILE* in = fopen(freeze, "rb"); for(;;){ Var x; fscanf(in, "%d", &x); if (x == 0) break; x--; /**/assert(S.n_occ[toInt(Lit(x))] + S.n_occ[toInt(~Lit(x))] != 0); /**/assert(S.value(x) == l_Undef); S.setFrozen(x, true); count++; } fclose(in); reportf("| Frozen vars : %-12.0f |\n", (double)count); } /*END*/ if (!S.simplify()){ reportf("Solved by unit propagation\n"); if (res != NULL) fprintf(res, "UNSAT\n"), fclose(res); printf("UNSATISFIABLE\n"); exit(20); } if (dimacs){ if (pre != pre_none) S.eliminate(true); reportf("==============================[ Writing DIMACS ]===============================\n"); S.toDimacs(dimacs); printStats(S); exit(0); }else{ bool ret = S.solve(true, true); printStats(S); reportf("\n"); printf(ret ? "SATISFIABLE\n" : "UNSATISFIABLE\n"); if (res != NULL){ if (ret){ fprintf(res, "SAT\n"); for (int i = 0; i < S.nVars(); i++) if (S.model[i] != l_Undef) fprintf(res, "%s%s%d", (i==0)?"":" ", (S.model[i]==l_True)?"":"-", i+1); fprintf(res, " 0\n"); }else fprintf(res, "UNSAT\n"); fclose(res); } #ifdef NDEBUG exit(ret ? 10 : 20); // (faster than "return", which will invoke the destructor for 'Solver') #endif } } opensmt-2.5.2/src/minisat/simp/SimpSolver.C000066400000000000000000000472441445011647600206420ustar00rootroot00000000000000/************************************************************************************[SimpSolver.C] MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson 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. **************************************************************************************************/ #include "Sort.h" #include "SimpSolver.h" //================================================================================================= // Constructor/Destructor: SimpSolver::SimpSolver() : grow (0) , asymm_mode (false) , redundancy_check (false) , merges (0) , asymm_lits (0) , remembered_clauses (0) , elimorder (1) , use_simplification (true) , elim_heap (ElimLt(n_occ)) , bwdsub_assigns (0) { vec dummy(1,lit_Undef); bwdsub_tmpunit = Clause_new(dummy); remove_satisfied = false; } SimpSolver::~SimpSolver() { free(bwdsub_tmpunit); // NOTE: elimtable.size() might be lower than nVars() at the moment for (int i = 0; i < elimtable.size(); i++) for (int j = 0; j < elimtable[i].eliminated.size(); j++) free(elimtable[i].eliminated[j]); } Var SimpSolver::newVar(bool sign, bool dvar) { Var v = Solver::newVar(sign, dvar); if (use_simplification){ n_occ .push(0); n_occ .push(0); occurs .push(); frozen .push((char)false); touched .push(0); elim_heap.insert(v); elimtable.push(); } return v; } bool SimpSolver::solve(const vec& assumps, bool do_simp, bool turn_off_simp) { vec extra_frozen; bool result = true; do_simp &= use_simplification; if (do_simp){ // Assumptions must be temporarily frozen to run variable elimination: for (int i = 0; i < assumps.size(); i++){ Var v = var(assumps[i]); // If an assumption has been eliminated, remember it. if (isEliminated(v)) remember(v); if (!frozen[v]){ // Freeze and store. setFrozen(v, true); extra_frozen.push(v); } } result = eliminate(turn_off_simp); } if (result) result = Solver::solve(assumps); if (result) { extendModel(); #ifndef NDEBUG verifyModel(); #endif } if (do_simp) // Unfreeze the assumptions that were frozen: for (int i = 0; i < extra_frozen.size(); i++) setFrozen(extra_frozen[i], false); return result; } bool SimpSolver::addClause(vec& ps) { for (int i = 0; i < ps.size(); i++) if (isEliminated(var(ps[i]))) remember(var(ps[i])); int nclauses = clauses.size(); if (redundancy_check && implied(ps)) return true; if (!Solver::addClause(ps)) return false; if (use_simplification && clauses.size() == nclauses + 1){ Clause& c = *clauses.last(); subsumption_queue.insert(&c); for (int i = 0; i < c.size(); i++){ assert(occurs.size() > var(c[i])); assert(!find(occurs[var(c[i])], &c)); occurs[var(c[i])].push(&c); n_occ[toInt(c[i])]++; touched[var(c[i])] = 1; assert(elimtable[var(c[i])].order == 0); if (elim_heap.inHeap(var(c[i]))) elim_heap.increase_(var(c[i])); } } return true; } void SimpSolver::removeClause(Clause& c) { assert(!c.learnt()); if (use_simplification) for (int i = 0; i < c.size(); i++){ n_occ[toInt(c[i])]--; updateElimHeap(var(c[i])); } detachClause(c); c.mark(1); } bool SimpSolver::strengthenClause(Clause& c, Lit l) { assert(decisionLevel() == 0); assert(c.mark() == 0); assert(!c.learnt()); assert(find(watches[toInt(~c[0])], &c)); assert(find(watches[toInt(~c[1])], &c)); // FIX: this is too inefficient but would be nice to have (properly implemented) // if (!find(subsumption_queue, &c)) subsumption_queue.insert(&c); // If l is watched, delete it from watcher list and watch a new literal if (c[0] == l || c[1] == l){ Lit other = c[0] == l ? c[1] : c[0]; if (c.size() == 2){ removeClause(c); c.strengthen(l); }else{ c.strengthen(l); remove(watches[toInt(~l)], &c); // Add a watch for the correct literal watches[toInt(~(c[1] == other ? c[0] : c[1]))].push(&c); // !! this version assumes that remove does not change the order !! //watches[toInt(~c[1])].push(&c); clauses_literals -= 1; } } else{ c.strengthen(l); clauses_literals -= 1; } // if subsumption-indexing is active perform the necessary updates if (use_simplification){ remove(occurs[var(l)], &c); n_occ[toInt(l)]--; updateElimHeap(var(l)); } return c.size() == 1 ? enqueue(c[0]) && propagate() == NULL : true; } // Returns FALSE if clause is always satisfied ('out_clause' should not be used). bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, vec& out_clause) { merges++; out_clause.clear(); bool ps_smallest = _ps.size() < _qs.size(); const Clause& ps = ps_smallest ? _qs : _ps; const Clause& qs = ps_smallest ? _ps : _qs; for (int i = 0; i < qs.size(); i++){ if (var(qs[i]) != v){ for (int j = 0; j < ps.size(); j++) if (var(ps[j]) == var(qs[i])) if (ps[j] == ~qs[i]) return false; else goto next; out_clause.push(qs[i]); } next:; } for (int i = 0; i < ps.size(); i++) if (var(ps[i]) != v) out_clause.push(ps[i]); return true; } // Returns FALSE if clause is always satisfied. bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v) { merges++; bool ps_smallest = _ps.size() < _qs.size(); const Clause& ps = ps_smallest ? _qs : _ps; const Clause& qs = ps_smallest ? _ps : _qs; const Lit* __ps = (const Lit*)ps; const Lit* __qs = (const Lit*)qs; for (int i = 0; i < qs.size(); i++){ if (var(__qs[i]) != v){ for (int j = 0; j < ps.size(); j++) if (var(__ps[j]) == var(__qs[i])) if (__ps[j] == ~__qs[i]) return false; else goto next; } next:; } return true; } void SimpSolver::gatherTouchedClauses() { //fprintf(stderr, "Gathering clauses for backwards subsumption\n"); int ntouched = 0; for (int i = 0; i < touched.size(); i++) if (touched[i]){ const vec& cs = getOccurs(i); ntouched++; for (int j = 0; j < cs.size(); j++) if (cs[j]->mark() == 0){ subsumption_queue.insert(cs[j]); cs[j]->mark(2); } touched[i] = 0; } //fprintf(stderr, "Touched variables %d of %d yields %d clauses to check\n", ntouched, touched.size(), clauses.size()); for (int i = 0; i < subsumption_queue.size(); i++) subsumption_queue[i]->mark(0); } bool SimpSolver::implied(const vec& c) { assert(decisionLevel() == 0); trail_lim.push(trail.size()); for (int i = 0; i < c.size(); i++) if (value(c[i]) == l_True){ cancelUntil(0); return false; }else if (value(c[i]) != l_False){ assert(value(c[i]) == l_Undef); uncheckedEnqueue(~c[i]); } bool result = propagate() != NULL; cancelUntil(0); return result; } // Backward subsumption + backward subsumption resolution bool SimpSolver::backwardSubsumptionCheck(bool verbose) { int cnt = 0; int subsumed = 0; int deleted_literals = 0; assert(decisionLevel() == 0); while (subsumption_queue.size() > 0 || bwdsub_assigns < trail.size()){ // Check top-level assignments by creating a dummy clause and placing it in the queue: if (subsumption_queue.size() == 0 && bwdsub_assigns < trail.size()){ Lit l = trail[bwdsub_assigns++]; (*bwdsub_tmpunit)[0] = l; bwdsub_tmpunit->calcAbstraction(); assert(bwdsub_tmpunit->mark() == 0); subsumption_queue.insert(bwdsub_tmpunit); } Clause& c = *subsumption_queue.peek(); subsumption_queue.pop(); if (c.mark()) continue; if (verbose && verbosity >= 2 && cnt++ % 1000 == 0) reportf("subsumption left: %10d (%10d subsumed, %10d deleted literals)\r", subsumption_queue.size(), subsumed, deleted_literals); assert(c.size() > 1 || value(c[0]) == l_True); // Unit-clauses should have been propagated before this point. // Find best variable to scan: Var best = var(c[0]); for (int i = 1; i < c.size(); i++) if (occurs[var(c[i])].size() < occurs[best].size()) best = var(c[i]); // Search all candidates: vec& _cs = getOccurs(best); Clause** cs = (Clause**)_cs; for (int j = 0; j < _cs.size(); j++) if (c.mark()) break; else if (!cs[j]->mark() && cs[j] != &c){ Lit l = c.subsumes(*cs[j]); if (l == lit_Undef) subsumed++, removeClause(*cs[j]); else if (l != lit_Error){ deleted_literals++; if (!strengthenClause(*cs[j], ~l)) return false; // Did current candidate get deleted from cs? Then check candidate at index j again: if (var(l) == best) j--; } } } return true; } bool SimpSolver::asymm(Var v, Clause& c) { assert(decisionLevel() == 0); if (c.mark() || satisfied(c)) return true; trail_lim.push(trail.size()); Lit l = lit_Undef; for (int i = 0; i < c.size(); i++) if (var(c[i]) != v && value(c[i]) != l_False) uncheckedEnqueue(~c[i]); else l = c[i]; if (propagate() != NULL){ cancelUntil(0); asymm_lits++; if (!strengthenClause(c, l)) return false; }else cancelUntil(0); return true; } bool SimpSolver::asymmVar(Var v) { assert(!frozen[v]); assert(use_simplification); vec pos, neg; const vec& cls = getOccurs(v); if (value(v) != l_Undef || cls.size() == 0) return true; for (int i = 0; i < cls.size(); i++) if (!asymm(v, *cls[i])) return false; return backwardSubsumptionCheck(); } void SimpSolver::verifyModel() { bool failed = false; int cnt = 0; // NOTE: elimtable.size() might be lower than nVars() at the moment for (int i = 0; i < elimtable.size(); i++) if (elimtable[i].order > 0) for (int j = 0; j < elimtable[i].eliminated.size(); j++){ cnt++; Clause& c = *elimtable[i].eliminated[j]; for (int k = 0; k < c.size(); k++) if (modelValue(c[k]) == l_True) goto next; reportf("unsatisfied clause: "); printClause(*elimtable[i].eliminated[j]); reportf("\n"); failed = true; next:; } assert(!failed); reportf("Verified %d eliminated clauses.\n", cnt); } bool SimpSolver::eliminateVar(Var v, bool fail) { if (!fail && asymm_mode && !asymmVar(v)) return false; const vec& cls = getOccurs(v); // if (value(v) != l_Undef || cls.size() == 0) return true; if (value(v) != l_Undef) return true; // Split the occurrences into positive and negative: vec pos, neg; for (int i = 0; i < cls.size(); i++) (find(*cls[i], Lit(v)) ? pos : neg).push(cls[i]); // Check if number of clauses decreases: int cnt = 0; for (int i = 0; i < pos.size(); i++) for (int j = 0; j < neg.size(); j++) if (merge(*pos[i], *neg[j], v) && ++cnt > cls.size() + grow) return true; // Delete and store old clauses: setDecisionVar(v, false); elimtable[v].order = elimorder++; assert(elimtable[v].eliminated.size() == 0); for (int i = 0; i < cls.size(); i++){ elimtable[v].eliminated.push(Clause_new(*cls[i])); removeClause(*cls[i]); } // Produce clauses in cross product: int top = clauses.size(); vec resolvent; for (int i = 0; i < pos.size(); i++) for (int j = 0; j < neg.size(); j++) if (merge(*pos[i], *neg[j], v, resolvent) && !addClause(resolvent)) return false; // DEBUG: For checking that a clause set is saturated with respect to variable elimination. // If the clause set is expected to be saturated at this point, this constitutes an // error. if (fail){ reportf("eliminated var %d, %d <= %d\n", v+1, cnt, cls.size()); reportf("previous clauses:\n"); for (int i = 0; i < cls.size(); i++){ printClause(*cls[i]); reportf("\n"); } reportf("new clauses:\n"); for (int i = top; i < clauses.size(); i++){ printClause(*clauses[i]); reportf("\n"); } assert(0); } return backwardSubsumptionCheck(); } void SimpSolver::remember(Var v) { assert(decisionLevel() == 0); assert(isEliminated(v)); vec clause; // Re-activate variable: elimtable[v].order = 0; setDecisionVar(v, true); // Not good if the variable wasn't a decision variable before. Not sure how to fix this right now. if (use_simplification) updateElimHeap(v); // Reintroduce all old clauses which may implicitly remember other clauses: for (int i = 0; i < elimtable[v].eliminated.size(); i++){ Clause& c = *elimtable[v].eliminated[i]; clause.clear(); for (int j = 0; j < c.size(); j++) clause.push(c[j]); remembered_clauses++; check(addClause(clause)); free(&c); } elimtable[v].eliminated.clear(); } void SimpSolver::extendModel() { vec vs; // NOTE: elimtable.size() might be lower than nVars() at the moment for (int v = 0; v < elimtable.size(); v++) if (elimtable[v].order > 0) vs.push(v); sort(vs, ElimOrderLt(elimtable)); for (int i = 0; i < vs.size(); i++){ Var v = vs[i]; Lit l = lit_Undef; for (int j = 0; j < elimtable[v].eliminated.size(); j++){ Clause& c = *elimtable[v].eliminated[j]; for (int k = 0; k < c.size(); k++) if (var(c[k]) == v) l = c[k]; else if (modelValue(c[k]) != l_False) goto next; assert(l != lit_Undef); model[v] = lbool(!sign(l)); break; next:; } if (model[v] == l_Undef) model[v] = l_True; } } bool SimpSolver::eliminate(bool turn_off_elim) { if (!ok || !use_simplification) return ok; // Main simplification loop: //assert(subsumption_queue.size() == 0); //gatherTouchedClauses(); while (subsumption_queue.size() > 0 || elim_heap.size() > 0){ //fprintf(stderr, "subsumption phase: (%d)\n", subsumption_queue.size()); if (!backwardSubsumptionCheck(true)) return false; //fprintf(stderr, "elimination phase:\n (%d)", elim_heap.size()); for (int cnt = 0; !elim_heap.empty(); cnt++){ Var elim = elim_heap.removeMin(); // if (verbosity >= 2 && cnt % 100 == 0) // reportf("elimination left: %10d\r", elim_heap.size()); if (!frozen[elim] && !eliminateVar(elim)) return false; } assert(subsumption_queue.size() == 0); gatherTouchedClauses(); } // Cleanup: cleanUpClauses(); order_heap.filter(VarFilter(*this)); #ifdef INVARIANTS // Check that no more subsumption is possible: reportf("Checking that no more subsumption is possible\n"); for (int i = 0; i < clauses.size(); i++){ if (i % 1000 == 0) reportf("left %10d\r", clauses.size() - i); assert(clauses[i]->mark() == 0); for (int j = 0; j < i; j++) assert(clauses[i]->subsumes(*clauses[j]) == lit_Error); } reportf("done.\n"); // Check that no more elimination is possible: reportf("Checking that no more elimination is possible\n"); for (int i = 0; i < nVars(); i++) if (!frozen[i]) eliminateVar(i, true); reportf("done.\n"); checkLiteralCount(); #endif // If no more simplification is needed, free all simplification-related data structures: if (turn_off_elim){ use_simplification = false; touched.clear(true); occurs.clear(true); n_occ.clear(true); subsumption_queue.clear(true); elim_heap.clear(true); remove_satisfied = true; } return true; } void SimpSolver::cleanUpClauses() { int i , j; vec dirty; for (i = 0; i < clauses.size(); i++) if (clauses[i]->mark() == 1){ Clause& c = *clauses[i]; for (int k = 0; k < c.size(); k++) if (!seen[var(c[k])]){ seen[var(c[k])] = 1; dirty.push(var(c[k])); } } for (i = 0; i < dirty.size(); i++){ cleanOcc(dirty[i]); seen[dirty[i]] = 0; } for (i = j = 0; i < clauses.size(); i++) if (clauses[i]->mark() == 1) free(clauses[i]); else clauses[j++] = clauses[i]; clauses.shrink(i - j); } //================================================================================================= // Convert to DIMACS: void SimpSolver::toDimacs(FILE* f, Clause& c) { if (satisfied(c)) return; for (int i = 0; i < c.size(); i++) if (value(c[i]) != l_False) fprintf(f, "%s%d ", sign(c[i]) ? "-" : "", var(c[i])+1); fprintf(f, "0\n"); } void SimpSolver::toDimacs(const char* file) { assert(decisionLevel() == 0); FILE* f = fopen(file, "wr"); if (f != NULL){ // Cannot use removeClauses here because it is not safe // to deallocate them at this point. Could be improved. int cnt = 0; for (int i = 0; i < clauses.size(); i++) if (!satisfied(*clauses[i])) cnt++; fprintf(f, "p cnf %d %d\n", nVars(), cnt); for (int i = 0; i < clauses.size(); i++) toDimacs(f, *clauses[i]); fprintf(stderr, "Wrote %d clauses...\n", clauses.size()); }else fprintf(stderr, "could not open file %s\n", file); } opensmt-2.5.2/src/minisat/simp/SimpSolver.h000066400000000000000000000230231445011647600206740ustar00rootroot00000000000000/************************************************************************************[SimpSolver.h] Copyright (c) 2006, Niklas Een, Niklas Sorensson Copyright (c) 2007-2010, Niklas Sorensson 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. **************************************************************************************************/ #ifndef Minisat_SimpSolver_h #define Minisat_SimpSolver_h #include "minisat/mtl/Queue.h" #include "minisat/core/Solver.h" namespace Minisat { //================================================================================================= class SimpSolver : public Solver { public: // Constructor/Destructor: // SimpSolver(); ~SimpSolver(); // Problem specification: // Var newVar (bool polarity = true, bool dvar = true); bool addClause (const vec& ps); bool addEmptyClause(); // Add the empty clause to the solver. bool addClause (Lit p); // Add a unit clause to the solver. bool addClause (Lit p, Lit q); // Add a binary clause to the solver. bool addClause (Lit p, Lit q, Lit r); // Add a ternary clause to the solver. bool addClause_( vec& ps); bool substitute(Var v, Lit x); // Replace all occurences of v with x (may cause a contradiction). // Variable mode: // void setFrozen (Var v, bool b); // If a variable is frozen it will not be eliminated. bool isEliminated(Var v) const; // Solving: // bool solve (const vec& assumps, bool do_simp = true, bool turn_off_simp = false); lbool solveLimited(const vec& assumps, bool do_simp = true, bool turn_off_simp = false); bool solve ( bool do_simp = true, bool turn_off_simp = false); bool solve (Lit p , bool do_simp = true, bool turn_off_simp = false); bool solve (Lit p, Lit q, bool do_simp = true, bool turn_off_simp = false); bool solve (Lit p, Lit q, Lit r, bool do_simp = true, bool turn_off_simp = false); bool eliminate (bool turn_off_elim = false); // Perform variable elimination based simplification. // Memory managment: // virtual void garbageCollect(); // Generate a (possibly simplified) DIMACS file: // #if 0 void toDimacs (const char* file, const vec& assumps); void toDimacs (const char* file); void toDimacs (const char* file, Lit p); void toDimacs (const char* file, Lit p, Lit q); void toDimacs (const char* file, Lit p, Lit q, Lit r); #endif // Mode of operation: // int grow; // Allow a variable elimination step to grow by a number of clauses (default to zero). int clause_lim; // Variables are not eliminated if it produces a resolvent with a length above this limit. // -1 means no limit. int subsumption_lim; // Do not check if subsumption against a clause larger than this. -1 means no limit. double simp_garbage_frac; // A different limit for when to issue a GC during simplification (Also see 'garbage_frac'). bool use_asymm; // Shrink clauses by asymmetric branching. bool use_rcheck; // Check if a clause is already implied. Prett costly, and subsumes subsumptions :) bool use_elim; // Perform variable elimination. // Statistics: // int merges; int asymm_lits; int eliminated_vars; protected: // Helper structures: // struct ElimLt { const vec& n_occ; explicit ElimLt(const vec& no) : n_occ(no) {} // TODO: are 64-bit operations here noticably bad on 32-bit platforms? Could use a saturating // 32-bit implementation instead then, but this will have to do for now. uint64_t cost (Var x) const { return (uint64_t)n_occ[toInt(mkLit(x))] * (uint64_t)n_occ[toInt(~mkLit(x))]; } bool operator()(Var x, Var y) const { return cost(x) < cost(y); } // TODO: investigate this order alternative more. // bool operator()(Var x, Var y) const { // int c_x = cost(x); // int c_y = cost(y); // return c_x < c_y || c_x == c_y && x < y; } }; struct ClauseDeleted { const ClauseAllocator& ca; explicit ClauseDeleted(const ClauseAllocator& _ca) : ca(_ca) {} bool operator()(const CRef& cr) const { return ca[cr].mark() == 1; } }; // Solver state: // int elimorder; bool use_simplification; vec elimclauses; vec touched; OccLists, ClauseDeleted> occurs; vec n_occ; Heap elim_heap; Queue subsumption_queue; vec frozen; vec eliminated; int bwdsub_assigns; int n_touched; // Temporaries: // CRef bwdsub_tmpunit; // Main internal methods: // lbool solve_ (bool do_simp = true, bool turn_off_simp = false); bool asymm (Var v, CRef cr); bool asymmVar (Var v); void updateElimHeap (Var v); void gatherTouchedClauses (); bool merge (const Clause& _ps, const Clause& _qs, Var v, vec& out_clause); bool merge (const Clause& _ps, const Clause& _qs, Var v, int& size); bool backwardSubsumptionCheck (bool verbose = false); bool eliminateVar (Var v); void extendModel (); void removeClause (CRef cr); bool strengthenClause (CRef cr, Lit l); void cleanUpClauses (); bool implied (const vec& c); void relocAll (ClauseAllocator& to); }; //================================================================================================= // Implementation of inline methods: inline bool SimpSolver::isEliminated (Var v) const { return eliminated[v]; } inline void SimpSolver::updateElimHeap(Var v) { assert(use_simplification); // if (!frozen[v] && !isEliminated(v) && value(v) == l_Undef) if (elim_heap.inHeap(v) || (!frozen[v] && !isEliminated(v) && value(v) == l_Undef)) elim_heap.update(v); } inline bool SimpSolver::addClause (const vec& ps) { ps.copyTo(add_tmp); return addClause_(add_tmp); } inline bool SimpSolver::addEmptyClause() { add_tmp.clear(); return addClause_(add_tmp); } inline bool SimpSolver::addClause (Lit p) { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp); } inline bool SimpSolver::addClause (Lit p, Lit q) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp); } inline bool SimpSolver::addClause (Lit p, Lit q, Lit r) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp); } inline void SimpSolver::setFrozen (Var v, bool b) { frozen[v] = (char)b; if (use_simplification && !b) { updateElimHeap(v); } } inline bool SimpSolver::solve ( bool do_simp, bool turn_off_simp) { budgetOff(); assumptions.clear(); return solve_(do_simp, turn_off_simp) == l_True; } inline bool SimpSolver::solve (Lit p , bool do_simp, bool turn_off_simp) { budgetOff(); assumptions.clear(); assumptions.push(p); return solve_(do_simp, turn_off_simp) == l_True; } inline bool SimpSolver::solve (Lit p, Lit q, bool do_simp, bool turn_off_simp) { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); return solve_(do_simp, turn_off_simp) == l_True; } inline bool SimpSolver::solve (Lit p, Lit q, Lit r, bool do_simp, bool turn_off_simp) { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); assumptions.push(r); return solve_(do_simp, turn_off_simp) == l_True; } inline bool SimpSolver::solve (const vec& assumps, bool do_simp, bool turn_off_simp){ budgetOff(); assumps.copyTo(assumptions); return solve_(do_simp, turn_off_simp) == l_True; } inline lbool SimpSolver::solveLimited (const vec& assumps, bool do_simp, bool turn_off_simp){ assumps.copyTo(assumptions); return solve_(do_simp, turn_off_simp); } //================================================================================================= } #endif opensmt-2.5.2/src/minisat/utils/000077500000000000000000000000001445011647600166105ustar00rootroot00000000000000opensmt-2.5.2/src/minisat/utils/Options.cc000066400000000000000000000072641445011647600205630ustar00rootroot00000000000000/**************************************************************************************[Options.cc] Copyright (c) 2008-2010, Niklas Sorensson 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. **************************************************************************************************/ #include "Sort.h" #include "Options.h" #include "ParseUtils.h" void Minisat::parseOptions(int& argc, char** argv, bool strict) { int i, j; for (i = j = 1; i < argc; i++){ const char* str = argv[i]; if (match(str, "--") && match(str, Option::getHelpPrefixString()) && match(str, "help")){ if (*str == '\0') printUsageAndExit(argc, argv); else if (match(str, "-verb")) printUsageAndExit(argc, argv, true); } else { bool parsed_ok = false; for (int k = 0; !parsed_ok && k < Option::getOptionList().size(); k++){ parsed_ok = Option::getOptionList()[k]->parse(argv[i]); // fprintf(stderr, "checking %d: %s against flag <%s> (%s)\n", i, argv[i], Option::getOptionList()[k]->name, parsed_ok ? "ok" : "skip"); } if (!parsed_ok) if (strict && match(argv[i], "-")) fprintf(stderr, "ERROR! Unknown flag \"%s\". Use '--%shelp' for help.\n", argv[i], Option::getHelpPrefixString()), exit(1); else argv[j++] = argv[i]; } } argc -= (i - j); } void Minisat::setUsageHelp (const char* str){ Option::getUsageString() = str; } void Minisat::setHelpPrefixStr (const char* str){ Option::getHelpPrefixString() = str; } void Minisat::printUsageAndExit (int argc, char** argv, bool verbose) { const char* usage = Option::getUsageString(); if (usage != NULL) fprintf(stderr, usage, argv[0]); sort(Option::getOptionList(), Option::OptionLt()); const char* prev_cat = NULL; const char* prev_type = NULL; for (int i = 0; i < Option::getOptionList().size(); i++){ const char* cat = Option::getOptionList()[i]->category; const char* type = Option::getOptionList()[i]->type_name; if (cat != prev_cat) fprintf(stderr, "\n%s OPTIONS:\n\n", cat); else if (type != prev_type) fprintf(stderr, "\n"); Option::getOptionList()[i]->help(verbose); prev_cat = Option::getOptionList()[i]->category; prev_type = Option::getOptionList()[i]->type_name; } fprintf(stderr, "\nHELP OPTIONS:\n\n"); fprintf(stderr, " --%shelp Print help message.\n", Option::getHelpPrefixString()); fprintf(stderr, " --%shelp-verb Print verbose help message.\n", Option::getHelpPrefixString()); fprintf(stderr, "\n"); exit(0); } opensmt-2.5.2/src/minisat/utils/Options.h000066400000000000000000000275321445011647600204250ustar00rootroot00000000000000/***************************************************************************************[Options.h] Copyright (c) 2008-2010, Niklas Sorensson 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. **************************************************************************************************/ #ifndef Minisat_Options_h #define Minisat_Options_h #include #include #include #include #include #include "osmtinttypes.h" #include "Vec.h" #include "ParseUtils.h" //================================================================================================== // Top-level option parse/help functions: extern void parseOptions (int& argc, char** argv, bool strict = false); extern void printUsageAndExit(int argc, char** argv, bool verbose = false); extern void setUsageHelp (const char* str); extern void setHelpPrefixStr (const char* str); //================================================================================================== // Options is an abstract class that gives the interface for all types options: class Option { protected: const char* name; const char* description; const char* category; const char* type_name; static vec& getOptionList () { static vec options; return options; } static const char*& getUsageString() { static const char* usage_str; return usage_str; } static const char*& getHelpPrefixString() { static const char* help_prefix_str = ""; return help_prefix_str; } struct OptionLt { bool operator()(const Option* x, const Option* y) { int test1 = strcmp(x->category, y->category); return test1 < 0 || test1 == 0 && strcmp(x->type_name, y->type_name) < 0; } }; Option(const char* name_, const char* desc_, const char* cate_, const char* type_) : name (name_) , description(desc_) , category (cate_) , type_name (type_) { getOptionList().push(this); } public: virtual ~Option() {} virtual bool parse (const char* str) = 0; virtual void help (bool verbose = false) = 0; friend void parseOptions (int& argc, char** argv, bool strict); friend void printUsageAndExit (int argc, char** argv, bool verbose); friend void setUsageHelp (const char* str); friend void setHelpPrefixStr (const char* str); }; //================================================================================================== // Range classes with specialization for floating types: struct IntRange { int begin; int end; IntRange(int b, int e) : begin(b), end(e) {} }; struct Int64Range { int64_t begin; int64_t end; Int64Range(int64_t b, int64_t e) : begin(b), end(e) {} }; struct DoubleRange { double begin; double end; bool begin_inclusive; bool end_inclusive; DoubleRange(double b, bool binc, double e, bool einc) : begin(b), end(e), begin_inclusive(binc), end_inclusive(einc) {} }; //================================================================================================== // Double options: class DoubleOption : public Option { protected: DoubleRange range; double value; public: DoubleOption(const char* c, const char* n, const char* d, double def = double(), DoubleRange r = DoubleRange(-HUGE_VAL, false, HUGE_VAL, false)) : Option(n, d, c, ""), range(r), value(def) { // FIXME: set LC_NUMERIC to "C" to make sure that strtof/strtod parses decimal point correctly. } operator double (void) const { return value; } operator double& (void) { return value; } DoubleOption& operator=(double x) { value = x; return *this; } virtual bool parse(const char* str){ const char* span = str; if (!match(span, "-") || !match(span, name) || !match(span, "=")) return false; char* end; double tmp = strtod(span, &end); if (end == NULL) return false; else if (tmp >= range.end && (!range.end_inclusive || tmp != range.end)){ fprintf(stderr, "ERROR! value <%s> is too large for option \"%s\".\n", span, name); exit(1); }else if (tmp <= range.begin && (!range.begin_inclusive || tmp != range.begin)){ fprintf(stderr, "ERROR! value <%s> is too small for option \"%s\".\n", span, name); exit(1); } value = tmp; // fprintf(stderr, "READ VALUE: %g\n", value); return true; } virtual void help (bool verbose = false){ fprintf(stderr, " -%-12s = %-8s %c%4.2g .. %4.2g%c (default: %g)\n", name, type_name, range.begin_inclusive ? '[' : '(', range.begin, range.end, range.end_inclusive ? ']' : ')', value); if (verbose){ fprintf(stderr, "\n %s\n", description); fprintf(stderr, "\n"); } } }; //================================================================================================== // Int options: class IntOption : public Option { protected: IntRange range; int32_t value; public: IntOption(const char* c, const char* n, const char* d, int32_t def = int32_t(), IntRange r = IntRange(INT32_MIN, INT32_MAX)) : Option(n, d, c, ""), range(r), value(def) {} operator int32_t (void) const { return value; } operator int32_t& (void) { return value; } IntOption& operator= (int32_t x) { value = x; return *this; } virtual bool parse(const char* str){ const char* span = str; if (!match(span, "-") || !match(span, name) || !match(span, "=")) return false; char* end; int32_t tmp = strtol(span, &end, 10); if (end == NULL) return false; else if (tmp > range.end){ fprintf(stderr, "ERROR! value <%s> is too large for option \"%s\".\n", span, name); exit(1); }else if (tmp < range.begin){ fprintf(stderr, "ERROR! value <%s> is too small for option \"%s\".\n", span, name); exit(1); } value = tmp; return true; } virtual void help (bool verbose = false){ fprintf(stderr, " -%-12s = %-8s [", name, type_name); if (range.begin == INT32_MIN) fprintf(stderr, "imin"); else fprintf(stderr, "%4d", range.begin); fprintf(stderr, " .. "); if (range.end == INT32_MAX) fprintf(stderr, "imax"); else fprintf(stderr, "%4d", range.end); fprintf(stderr, "] (default: %d)\n", value); if (verbose){ fprintf(stderr, "\n %s\n", description); fprintf(stderr, "\n"); } } }; // Leave this out for visual C++ until Microsoft implements C99 and gets support for strtoll. #ifndef _MSC_VER class Int64Option : public Option { protected: Int64Range range; int64_t value; public: Int64Option(const char* c, const char* n, const char* d, int64_t def = int64_t(), Int64Range r = Int64Range(INT64_MIN, INT64_MAX)) : Option(n, d, c, ""), range(r), value(def) {} operator int64_t (void) const { return value; } operator int64_t& (void) { return value; } Int64Option& operator= (int64_t x) { value = x; return *this; } virtual bool parse(const char* str){ const char* span = str; if (!match(span, "-") || !match(span, name) || !match(span, "=")) return false; char* end; int64_t tmp = strtoll(span, &end, 10); if (end == NULL) return false; else if (tmp > range.end){ fprintf(stderr, "ERROR! value <%s> is too large for option \"%s\".\n", span, name); exit(1); }else if (tmp < range.begin){ fprintf(stderr, "ERROR! value <%s> is too small for option \"%s\".\n", span, name); exit(1); } value = tmp; return true; } virtual void help (bool verbose = false){ fprintf(stderr, " -%-12s = %-8s [", name, type_name); if (range.begin == INT64_MIN) fprintf(stderr, "imin"); else fprintf(stderr, "%4li", range.begin); fprintf(stderr, " .. "); if (range.end == INT64_MAX) fprintf(stderr, "imax"); else fprintf(stderr, "%4li", range.end); fprintf(stderr, "] (default: %li)\n", value); if (verbose){ fprintf(stderr, "\n %s\n", description); fprintf(stderr, "\n"); } } }; #endif //================================================================================================== // String option: class StringOption : public Option { const char* value; public: StringOption(const char* c, const char* n, const char* d, const char* def = NULL) : Option(n, d, c, ""), value(def) {} operator const char* (void) const { return value; } operator const char*& (void) { return value; } StringOption& operator= (const char* x) { value = x; return *this; } virtual bool parse(const char* str){ const char* span = str; if (!match(span, "-") || !match(span, name) || !match(span, "=")) return false; value = span; return true; } virtual void help (bool verbose = false){ fprintf(stderr, " -%-10s = %8s\n", name, type_name); if (verbose){ fprintf(stderr, "\n %s\n", description); fprintf(stderr, "\n"); } } }; //================================================================================================== // Bool option: class BoolOption : public Option { bool value; public: BoolOption(const char* c, const char* n, const char* d, bool v) : Option(n, d, c, ""), value(v) {} operator bool (void) const { return value; } operator bool& (void) { return value; } BoolOption& operator=(bool b) { value = b; return *this; } virtual bool parse(const char* str){ const char* span = str; if (match(span, "-")){ bool b = !match(span, "no-"); if (strcmp(span, name) == 0){ value = b; return true; } } return false; } virtual void help (bool verbose = false){ fprintf(stderr, " -%s, -no-%s", name, name); for (uint32_t i = 0; i < 32 - strlen(name)*2; i++) fprintf(stderr, " "); fprintf(stderr, " "); fprintf(stderr, "(default: %s)\n", value ? "on" : "off"); if (verbose){ fprintf(stderr, "\n %s\n", description); fprintf(stderr, "\n"); } } }; //================================================================================================= #endif opensmt-2.5.2/src/minisat/utils/ParseUtils.h000066400000000000000000000076651445011647600210720ustar00rootroot00000000000000/************************************************************************************[ParseUtils.h] Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson Copyright (c) 2007-2010, Niklas Sorensson 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. **************************************************************************************************/ #ifndef Minisat_ParseUtils_h #define Minisat_ParseUtils_h #include #include #include //------------------------------------------------------------------------------------------------- // A simple buffered character stream class: static const int buffer_size = 1048576; class StreamBuffer { gzFile in; unsigned char buf[buffer_size]; int pos; int size; void assureLookahead() { if (pos >= size) { pos = 0; size = gzread(in, buf, sizeof(buf)); } } public: explicit StreamBuffer(gzFile i) : in(i), pos(0), size(0) { assureLookahead(); } int operator * () const { return (pos >= size) ? EOF : buf[pos]; } void operator ++ () { pos++; assureLookahead(); } int position () const { return pos; } }; //------------------------------------------------------------------------------------------------- // End-of-file detection functions for StreamBuffer and char*: static inline bool isEof(StreamBuffer& in) { return *in == EOF; } static inline bool isEof(const char* in) { return *in == '\0'; } //------------------------------------------------------------------------------------------------- // Generic parse functions parametrized over the input-stream type. template static void skipWhitespace(B& in) { while ((*in >= 9 && *in <= 13) || *in == 32) ++in; } template static void skipLine(B& in) { for (;;){ if (isEof(in)) return; if (*in == '\n') { ++in; return; } ++in; } } template static int parseInt(B& in) { int val = 0; bool neg = false; skipWhitespace(in); if (*in == '-') neg = true, ++in; else if (*in == '+') ++in; if (*in < '0' || *in > '9') fprintf(stderr, "PARSE ERROR! Unexpected char: %c\n", *in), exit(3); while (*in >= '0' && *in <= '9') val = val*10 + (*in - '0'), ++in; return neg ? -val : val; } // String matching: in case of a match the input iterator will be advanced the corresponding // number of characters. template static bool match(B& in, const char* str) { int i; for (i = 0; str[i] != '\0'; i++) if (in[i] != str[i]) return false; in += i; return true; } // String matching: consumes characters eagerly, but does not require random access iterator. template static bool eagerMatch(B& in, const char* str) { for (; *str != '\0'; ++str, ++in) if (*str != *in) return false; return true; } //================================================================================================= #endif opensmt-2.5.2/src/minisat/utils/System.cc000066400000000000000000000061051445011647600204050ustar00rootroot00000000000000/***************************************************************************************[System.cc] Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson Copyright (c) 2007-2010, Niklas Sorensson 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. **************************************************************************************************/ #include "utils/System.h" #if defined(__linux__) #include #include using namespace Minisat; // TODO: split the memory reading functions into two: one for reading high-watermark of RSS, and // one for reading the current virtual memory size. static inline int memReadStat(int field) { char name[256]; pid_t pid = getpid(); int value; sprintf(name, "/proc/%d/statm", pid); FILE* in = fopen(name, "rb"); if (in == NULL) return 0; for (; field >= 0; field--) if (fscanf(in, "%d", &value) != 1) printf("ERROR! Failed to parse memory statistics from \"/proc\".\n"), exit(1); fclose(in); return value; } static inline int memReadPeak(void) { char name[256]; pid_t pid = getpid(); sprintf(name, "/proc/%d/status", pid); FILE* in = fopen(name, "rb"); if (in == NULL) return 0; // Find the correct line, beginning with "VmPeak:": int peak_kb = 0; while (!feof(in) && fscanf(in, "VmPeak: %d kB", &peak_kb) != 1) while (!feof(in) && fgetc(in) != '\n') ; fclose(in); return peak_kb; } double Minisat::memUsed() { return (double)memReadStat(0) * (double)getpagesize() / (1024*1024); } double Minisat::memUsedPeak() { double peak = memReadPeak() / 1024; return peak == 0 ? memUsed() : peak; } #elif defined(__FreeBSD__) double Minisat::memUsed(void) { struct rusage ru; getrusage(RUSAGE_SELF, &ru); return (double)ru.ru_maxrss / 1024; } double MiniSat::memUsedPeak(void) { return memUsed(); } #elif defined(__APPLE__) #include double Minisat::memUsed(void) { malloc_statistics_t t; malloc_zone_statistics(NULL, &t); return (double)t.max_size_in_use / (1024*1024); } #else double Minisat::memUsed() { return 0; } #endif opensmt-2.5.2/src/minisat/utils/System.h000066400000000000000000000045521445011647600202530ustar00rootroot00000000000000/****************************************************************************************[System.h] Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson Copyright (c) 2007-2010, Niklas Sorensson 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. **************************************************************************************************/ #ifndef Minisat_System_h #define Minisat_System_h #if defined(__GLIBC__) #include #endif #include "osmtinttypes.h" //------------------------------------------------------------------------------------------------- //static inline double cpuTime(void); // CPU-time in seconds. //extern double memUsed(); // Memory in mega bytes (returns 0 for unsupported architectures). extern double memUsedPeak(); // Peak-memory in mega bytes (returns 0 for unsupported architectures). //------------------------------------------------------------------------------------------------- // Implementation of inline functions: #if defined(_MSC_VER) || defined(__MINGW32__) #include //static inline double Minisat::cpuTime(void) { return (double)clock() / CLOCKS_PER_SEC; } #else #include #include #include //static inline double Minisat::cpuTime(void) { // struct rusage ru; // getrusage(RUSAGE_SELF, &ru); // return (double)ru.ru_utime.tv_sec + (double)ru.ru_utime.tv_usec / 1000000; } #endif #endif opensmt-2.5.2/src/models/000077500000000000000000000000001445011647600152675ustar00rootroot00000000000000opensmt-2.5.2/src/models/CMakeLists.txt000066400000000000000000000002021445011647600200210ustar00rootroot00000000000000add_library(models OBJECT Model.cc ModelBuilder.cc) install(FILES Model.h ModelBuilder.h DESTINATION ${INSTALL_HEADERS_DIR}) opensmt-2.5.2/src/models/Model.cc000066400000000000000000000103351445011647600166400ustar00rootroot00000000000000// // Created by Martin Blicha on 12.06.20. // #include "Model.h" #include "Substitutor.h" #include bool Model::isCorrect(const SymbolDefinition & defs) const { for (const auto & entry : defs) { SymRef sr = entry.first; const TemplateFunction &templFun = entry.second; if (not logic.isUF(sr)) { return false; } const Symbol &s = logic.getSym(sr); if (templFun.getName() != logic.getSymName(sr)) { return false; } if (s.nargs() != templFun.getArgs().size_()) { return false; } if (logic.getSortRef(sr) != templFun.getRetSort()) { return false; } for (auto i = 0; i < (int) s.nargs(); i++) if (s[i] != logic.getSortRef(templFun.getArgs()[i])) { return false; } } return true; } Model::Model(Logic& logic, Evaluation basicEval, SymbolDefinition symbolDef) : varEval(std::move(basicEval)) , symDef(std::move(symbolDef)) , logic(logic) , formalArgDefaultPrefix("x") { assert(isCorrect(symbolDef)); } PTRef Model::evaluate(PTRef term) { if (logic.isConstant(term)) { return term; } if (hasDerivedVal(term)) { return getDerivedVal(term); } if (logic.isVar(term)) { if (hasVarVal(term)) { return getVarVal(term); } // else - new variable use and remember default value PTRef defaultVal = logic.getDefaultValuePTRef(term); // cache value and return addDerivedVal(term, defaultVal); return defaultVal; } else { // complex term not seen before, compute and store the value int size = logic.getPterm(term).size(); vec nargs; for (int i = 0; i < size; ++i) { PTRef narg = evaluate(logic.getPterm(term)[i]); nargs.push(narg); } SymRef symbol = logic.getPterm(term).symb(); PTRef val; if (symDef.find(symbol) != symDef.end()) { const TemplateFunction & tfun = symDef.at(symbol); val = logic.instantiateFunctionTemplate(tfun, nargs); } else { val = logic.insertTerm(symbol, std::move(nargs)); } assert(val != PTRef_Undef); addDerivedVal(term, val); return val; } } /** * Return a name that can be extended to a formal argument name by appending, e.g., a number. * The returned string is guaranteed not to collide with the name of the symbol sr after * appending a non-empty string * * Name collisions with sorts is possible, but should not be an issue. * * @param logic * @param sr * @param formalArgDefaultPrefix * @return a string that is guaranteed to be different from sr */ std::string Model::getFormalArgBaseNameForSymbol(const Logic & logic, SymRef sr, const std::string & formalArgDefaultPrefix) { const std::string & symName(logic.getSymName(sr)); // Collision is possible if formalArgDefaultPrefix can be extended to symName by adding at least one character. bool collisionPossible = formalArgDefaultPrefix == symName.substr(0, formalArgDefaultPrefix.size()); if (collisionPossible) { // Modify the base by changing the first character to a different character. Collision is then not possible std::string newPrefix(formalArgDefaultPrefix); newPrefix[0] = (symName[0] + 1) % 26 + 'a'; assert(newPrefix[0] != symName[0]); return newPrefix; } return formalArgDefaultPrefix; } TemplateFunction Model::getDefinition(SymRef sr) const { if (symDef.find(sr) != symDef.end()) { return symDef.at(sr); } else { // A query for a function not known to egraph. We create a default function. std::string symName = logic.getSymName(sr); vec formalArgs; formalArgs.growTo(logic.getSym(sr).nargs()); std::string varNameBase = getFormalArgBaseNameForSymbol(logic, sr, formalArgDefaultPrefix); for (int i = 0; i < (int)logic.getSym(sr).nargs(); i++) { SRef argSort = logic.getSym(sr)[i]; std::stringstream ss; ss << varNameBase << i; formalArgs[i] = logic.mkVar(argSort, ss.str().c_str()); } return TemplateFunction(symName, formalArgs, logic.getSym(sr).rsort(), logic.getDefaultValuePTRef(logic.getSym(sr).rsort())); } }opensmt-2.5.2/src/models/Model.h000066400000000000000000000033131445011647600165000ustar00rootroot00000000000000// // Created by Martin Blicha on 12.06.20. // #include "PTRef.h" #include "Logic.h" #include #include #include #ifndef OPENSMT_MODEL_H #define OPENSMT_MODEL_H class Model { public: using Evaluation = std::unordered_map; using SymbolDefinition = std::unordered_map; Model(Logic& logic, Evaluation basicEval, SymbolDefinition symbolDef); Model(Logic& logic, Evaluation basicEval) : Model(logic, std::move(basicEval), {}) { } PTRef evaluate(PTRef term); TemplateFunction getDefinition(SymRef) const; static std::string getFormalArgBaseNameForSymbol(const Logic & logic, SymRef sr, const std::string & formalArgDefaultPrefix); // Return a string that is not equal to the argument private: bool isCorrect(const SymbolDefinition & defs) const; const Evaluation varEval; const SymbolDefinition symDef; Evaluation extendedEval; Logic & logic; const std::string formalArgDefaultPrefix; inline bool hasVarVal(PTRef term) const { assert(logic.isVar(term)); return varEval.find(term) != varEval.end(); } inline PTRef getVarVal(PTRef term) const { assert(hasVarVal(term)); return varEval.at(term); } inline bool hasDerivedVal(PTRef term) { return extendedEval.find(term) != extendedEval.end(); } inline PTRef getDerivedVal(PTRef term) { assert(hasDerivedVal(term)); return extendedEval.at(term); } inline void addDerivedVal(PTRef term, PTRef val) { auto res = extendedEval.insert(std::make_pair(term, val)); assert(res.second); (void)res; } }; #endif //OPENSMT_MODEL_H opensmt-2.5.2/src/models/ModelBuilder.cc000066400000000000000000000124771445011647600201600ustar00rootroot00000000000000// // Created by Martin Blicha on 14.06.20. // #include "ModelBuilder.h" #include #include std::unique_ptr ModelBuilder::build() { std::unordered_map builtDefinitions; for (auto & symbolSigVal : definitions) { const ValuationNode * valuationNode = symbolSigVal.second.second; SRef sr = logic.getSortRef(symbolSigVal.first); PTRef body = valuationTreeToFunctionBody(valuationNode, sr); TemplateFunction templateFun(std::move(symbolSigVal.second.first), body); builtDefinitions[symbolSigVal.first] = std::move(templateFun); } return std::make_unique(logic, assignment, builtDefinitions); } void ModelBuilder::addToTheoryFunction(SymRef sr, const vec & vals, PTRef val) { if (logic.getSortRef(sr) != logic.getSortRef(val)) { throw OsmtApiException("Incompatible sort for symbol valuation"); } const Symbol & sym = logic.getSym(sr); if (sym.nargs() != vals.size_()) { throw OsmtApiException("Incorrect valuation for symbol: argument and valuation size do not match"); } for (int i = 0; i < vals.size(); i++) { if (sym[i] != logic.getSortRef(vals[i])) { throw OsmtApiException("Incorrect valuation for symbol: sort mismatch"); } } if (not hasTheoryFunction(sr)) { vec formalArgs; formalArgs.capacity(vals.size()); // Ensure that no formal arg name collides with the function name std::string formalArgPrefix(Model::getFormalArgBaseNameForSymbol(logic, sr, formalArgDefaultPrefix)); for (PTRef v : vals) { std::stringstream ss; ss << formalArgPrefix << uniqueNum++; formalArgs.push(logic.mkVar(logic.getSortRef(v), ss.str().c_str())); } FunctionSignature templateSig(logic.protectName(sr), std::move(formalArgs), logic.getSortRef(sr)); definitions.insert({sr,opensmt::pair{std::move(templateSig), nullptr}}); } auto & signatureAndValuation = definitions.at(sr); const vec & formalArgs = signatureAndValuation.first.getArgs(); vec> valuation; valuation.capacity(vals.size()); for (int i = 0; i < vals.size(); i++) { valuation.push({formalArgs[i], vals[i]}); } assert(logic.getSortRef(val) == logic.getSortRef(sr)); signatureAndValuation.second = addToValuationTree(valuation, val, signatureAndValuation.second); } ModelBuilder::ValuationNode * ModelBuilder::addToValuationTree(const vec> & valuation, PTRef value, ValuationNode * root) { assert(valuation.size() >= 1); if (root == nullptr) { root = valuationNodeFactory.getValuationNode(valuation[0].first, PTRef_Undef); } ValuationNode * current = root; for (int i = 0; i < valuation.size(); i++) { PTRef val = valuation[i].second; // The value of my parent's var assert(current != nullptr); bool foundChild = false; for (auto child: *current) { if (child->getValue() == val) { current = child; foundChild = true; break; } } if (not foundChild) { // No child found with this value. Need to create a new child. If this will be a leaf // (i.e., it is the last value in a valuation) the var will by convention be set to the // value of this valuation current = current->addChild(valuationNodeFactory.getValuationNode(i == valuation.size()-1 ? value : valuation[i+1].first, val)); } } return root; } // Copied from TermVisitor. Maybe it'd be possible to template TermVisitor to handle also ValuationNodes PTRef ModelBuilder::valuationTreeToFunctionBody(const ValuationNode *root, SRef returnSort) { struct QPair { const ValuationNode * node; std::size_t nextChild; QPair(const ValuationNode* n) : node(n), nextChild(0) {} }; std::unordered_map nodeToFormula; vec done(valuationNodeFactory.numNodes(), 0); vec queue; queue.push(QPair{root}); while (queue.size() != 0) { auto & el = queue.last(); auto * node = el.node; assert(not done[node->getId()]); if (el.nextChild < node->nChildren()) { const ValuationNode *child = (*node)[el.nextChild]; el.nextChild ++; if (not done[child->getId()]) { queue.push({QPair{child}}); } continue; } // All children of the node are processed assert(done[node->getId()] == 0); if (not node->hasChildren()) { // Base case: the node is a leaf value node. nodeToFormula[node] = node->getVar(); assert(logic.getSortRef(node->getVar()) == returnSort); } else { PTRef nodeFormula = logic.getDefaultValuePTRef(returnSort); for (int i = node->nChildren()-1; i >= 0; i--) { nodeFormula = logic.mkIte(logic.mkEq(node->getVar(), (*node)[i]->getValue()), nodeToFormula.at((*node)[i]), nodeFormula); } nodeToFormula[node] = nodeFormula; } done[node->getId()] = 1; queue.pop(); } return nodeToFormula[root]; }opensmt-2.5.2/src/models/ModelBuilder.h000066400000000000000000000074361445011647600200210ustar00rootroot00000000000000// // Created by Martin Blicha on 14.06.20. // #ifndef OPENSMT_MODELBUILDER_H #define OPENSMT_MODELBUILDER_H #include "PTRef.h" #include "Model.h" #include #include class Logic; class ModelBuilder { protected: class ValuationNodeFactory; class ValuationNode { friend class ModelBuilder::ValuationNodeFactory; int id; std::vector children; PTRef value; PTRef var; ValuationNode(int id) : id(id), value{PTRef_Undef}, var{PTRef_Undef} {} ValuationNode(int id, PTRef var, PTRef val) : id(id), value{val}, var{var} { assert(var != PTRef_Undef); } public: bool operator== (const ValuationNode* o) const { return this->id == o->id; } ValuationNode* operator[] (int i) { return children[i]; } const ValuationNode* operator[] (int i) const { return children[i]; } std::size_t nChildren() const { return children.size(); } bool hasChildren() const { return not children.empty(); } int getId() const { return id; } PTRef getValue() const { return value; } PTRef getVar() const { return var; } std::vector::iterator begin() { return children.begin(); } std::vector::iterator end() { return children.end(); } ValuationNode* addChild(ValuationNode* n) { children.emplace_back(n); return n; } }; struct ValuationNodeHash { std::size_t operator() (const ValuationNode* n) const { return std::hash()(n->getId()); } }; class ValuationNodeFactory { int numValuationNodes; vec nodes; public: ValuationNodeFactory() : numValuationNodes(0) {} ValuationNode * getValuationNode() { auto vn = new ValuationNode(numValuationNodes++); nodes.push(vn); return vn; } ValuationNode * getValuationNode(PTRef var, PTRef val) { auto vn = new ValuationNode(numValuationNodes++, var, val); nodes.push(vn); return vn; } int numNodes() const { return nodes.size(); } ~ValuationNodeFactory() { for (auto n : nodes) { delete n; } } }; ValuationNodeFactory valuationNodeFactory; ValuationNode * addToValuationTree(const vec> & valuation, PTRef value, ValuationNode * root); PTRef valuationTreeToFunctionBody(const ValuationNode *, SRef sr); std::unordered_map assignment; std::unordered_map, SymRefHash> definitions; Logic& logic; int uniqueNum; const std::string formalArgDefaultPrefix; public: ModelBuilder(Logic & logic) : logic(logic), uniqueNum(0), formalArgDefaultPrefix("x") {} void addVarValue(PTRef var, PTRef value) { auto res = assignment.insert(std::make_pair(var, value)); assert(res.second); (void)res; } inline bool hasVarVal(PTRef term) const { assert(logic.isVar(term)); return assignment.find(term) != assignment.end(); } inline PTRef getVarVal(PTRef term) const { assert(hasVarVal(term)); return assignment.at(term); } template void addVarValues(TIt begin, TIt end) { assignment.insert(begin, end); } bool hasTheoryFunction(SymRef sr) const { return definitions.find(sr) != definitions.end();} bool hasTheoryFunction(PTRef tr) const { return hasTheoryFunction(logic.getSymRef(tr)); } void addToTheoryFunction(SymRef sr, const vec & vals, PTRef val); template void addFunctionDefinitions(TIt begin, TIt end) { definitions.insert(begin, end); } std::unique_ptr build(); }; #endif //OPENSMT_MODELBUILDER_H opensmt-2.5.2/src/opensmt2.h000066400000000000000000000003321445011647600157220ustar00rootroot00000000000000#include /* #include #include #include #include #include #include */ opensmt-2.5.2/src/options/000077500000000000000000000000001445011647600154775ustar00rootroot00000000000000opensmt-2.5.2/src/options/CMakeLists.txt000066400000000000000000000001501445011647600202330ustar00rootroot00000000000000add_library(options OBJECT SMTConfig.cc) install(FILES SMTConfig.h DESTINATION ${INSTALL_HEADERS_DIR}) opensmt-2.5.2/src/options/SMTConfig.cc000066400000000000000000000572471445011647600176160ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #include "SMTConfig.h" #include "OsmtInternalException.h" #include void ASTNode::print(std::ostream& o, int indent) { for (int i = 0; i < indent; i++) printf(" "); o << "" << std::endl; if (children == NULL) return; for (auto i = children->begin(); i != children->end(); i++) (*i)->print(o, indent+1); } const char* ASTNode::typestr[] = { "command" , "command-list" // CMD , "symbol" , "symbol-list" // SYM , "number" , "number_list" // NUM , "sort" , "sort-list" // SORT , "sorted-var" , "sorted-var-list" // SV , "user-attr" , "user-attr-list" // UATTR , "predef-attr" , "predef-attr-list" // PATTR , "gen-attr" , "gen-attr-list" // GATTR , "spec-const" , "spec-const-list" // SPECC , "s-expr" , "s-expr-list" // SEXPR , "identifier" , "identifier-list" // ID , "long-identifier" , "long-identifier-list" // LID , "decimal" , "decimal-list" // DEC , "hex" , "hex-list" // HEX , "binary" , "binary-list" // BIN , "string" , "string-list" // STR , "as" , "as-list" // AS , "var-binding" , "var-binding-list" // VARB , "term" , "term-list" // TERM , "qualified-id" , "qualified-id-list" // QID , "long-qual-id" , "long-qual-id-list" // LQID , "let" , "let-list" // LET , "forall" , "forall-list" // FORALL , "exists" , "exists-list" // EXISTS , "!" , "!-list" // BANG , "sort-sym-decl" , "sort-sym-decl-list" // SSYMD , "fun-sym-decl" , "fun-sym-decl-list" // FSYMD , "par-fun-sym-decl", "par-fun-sym-decl-list" // PFSYMD , "pf-2nd" , "pf-2nd-list" // PFID , "theory-attr" , "theory-attr-list" // TATTR , "theory-decl" , "theory-decl-list" // TDECL , "logic-attr" , "logic-attr-list" // LATTR , "logic" , "logic-list" // LOGIC , "bool" , "bool-list" // BOOL , "option" , "option-list" // OPTION , "info-flag" , "info-flag-list" // INFO }; /********************************************************************* * Generic configuration class, used for both set-info and set-option *********************************************************************/ ConfValue::ConfValue(const char* s) { type = O_STR; strval = strdup(s); // TODO memory leak } ConfValue::ConfValue(const ASTNode& s_expr_n) { if (s_expr_n.getType() == SEXPRL_T) { type = O_LIST; configs = new std::list; for (auto i = s_expr_n.children->begin(); i != s_expr_n.children->end(); i++) configs->push_back(new ConfValue(**i)); } else if (s_expr_n.getType() == SYM_T) { type = O_SYM; strval = strdup(s_expr_n.getValue()); } else if (s_expr_n.getType() == SPECC_T) { ASTNode& spn = **(s_expr_n.children->begin()); if (spn.getType() == NUM_T) { type = O_NUM; numval = atoi(spn.getValue()); } else if (spn.getType() == DEC_T) { type = O_DEC; char* end; decval = strtod(spn.getValue(), &end); assert(end != NULL); } else if (spn.getType() == HEX_T) { type = O_HEX; std::string tmp(spn.getValue()); tmp.erase(0,2); char* end; unumval = strtoul(tmp.c_str(), &end, 16); assert(end != NULL); } else if (spn.getType() == BIN_T) { type = O_BIN; std::string tmp(spn.getValue()); tmp.erase(0,2); char* end; unumval = strtoul(tmp.c_str(), &end, 2); assert(end != NULL); } else if (spn.getType() == STR_T) { type = O_STR; strval = strdup(spn.getValue()); } else assert(false); } else if (s_expr_n.getType() == UATTR_T) { type = O_ATTR; strval = strdup(s_expr_n.getValue()); } else assert(false); //Not implemented } ConfValue::ConfValue(const ConfValue& other) { type = other.type; if (type == O_NUM) numval = other.numval; else if (type == O_STR) strval = strdup(other.strval); else if (type == O_DEC) decval = other.decval; else if (type == O_LIST) { configs = new std::list; for (ConfValue * value : *other.configs) configs->push_back(new ConfValue(*value)); } else if (type == O_SYM) strval = strdup(other.strval); else if (type == O_HEX) unumval = other.unumval; else if (type == O_BIN) unumval = other.unumval; else if (type == O_ATTR) strval = strdup(other.strval); else if (type == O_BOOL) numval = other.numval; else if (type == O_EMPTY) strval = strdup(""); else assert(false); } ConfValue& ConfValue::operator=(const ConfValue& other) { type = other.type; if (type == O_NUM) numval = other.numval; else if (type == O_STR) strval = strdup(other.strval); else if (type == O_DEC) decval = other.decval; else if (type == O_LIST) { configs = new std::list; for (ConfValue * value : *other.configs) configs->push_back(new ConfValue(*value)); } else if (type == O_SYM) strval = strdup(other.strval); else if (type == O_HEX) unumval = other.unumval; else if (type == O_BIN) unumval = other.unumval; else if (type == O_ATTR) strval = strdup(other.strval); else if (type == O_BOOL) numval = other.numval; else if (type == O_EMPTY) strval = strdup(""); else assert(false); return *this; } ConfValue::~ConfValue() { if (type == O_STR && strval != NULL) { free(strval); strval = NULL; } else if (type == O_EMPTY) free(strval); else if (type == O_LIST) { for (auto * value : *configs) delete value; delete configs; } else if (type == O_SYM) free(strval); else if (type == O_ATTR) free(strval); } std::string ConfValue::toString() const { if (type == O_BOOL) return numval == 1 ? "true" : "false"; if (type == O_STR) return strval; if (type == O_NUM) { return std::to_string(numval); } if (type == O_EMPTY) { return ""; } if (type == O_ATTR) { return strval; } if (type == O_DEC) { std::stringstream ss; ss << decval; return ss.str(); } if (type == O_HEX or type == O_BIN) { return std::to_string(unumval); } if (type == O_SYM) { return strval; } if (type == O_LIST) { assert(configs); std::stringstream ss; ss << "( "; for (ConfValue * val : *configs) { ss << val->toString() << " "; } ss << ")"; return ss.str(); } throw OsmtInternalException("Not implemented"); } /*********************************************************** * Class defining the information, configured with set-info ***********************************************************/ Info::Info(ASTNode const & n) { assert(n.getType() == UATTR_T or n.getType() == PATTR_T); if (n.children == NULL) { value.type = O_EMPTY; return; } else { // child is attribute_value ASTNode const & child = **(n.children->begin()); if (child.getType() == SPECC_T or child.getType() == SEXPRL_T) { value = ConfValue(child); } else if (child.getType() == SYM_T or child.getType() == QSYM_T) { value.strval = strdup(child.getValue()); value.type = O_STR; } else assert(false); } } Info::Info(const Info& other) { value = other.value; } /*********************************************************** * Class defining the options, configured with set-config ***********************************************************/ SMTOption::SMTOption(ASTNode const & n) { assert(n.children); ASTNode const & child = **(n.children->begin()); if (child.getType() == BOOL_T) { value.type = O_BOOL; value.numval = strcmp(child.getValue(), "true") == 0 ? 1 : 0; return; } if (child.getType() == STR_T) { value.type = O_STR; value.strval = strdup(child.getValue()); return; } if (child.getType() == NUM_T) { value.type = O_NUM; value.numval = atoi(child.getValue()); return; } if (child.getType() == DEC_T) { value.type = O_DEC; sscanf(child.getValue(), "%lf", &value.decval); } assert(child.getType() == UATTR_T or child.getType() == PATTR_T); // The option is an attribute if (not child.children) { value.type = O_EMPTY; return; } else { // n is now attribute_value ASTNode const & attributeValue = **(child.children->begin()); if (attributeValue.getType() == SPECC_T or attributeValue.getType() == SEXPRL_T) { value = ConfValue(attributeValue); } else if (attributeValue.getType() == SYM_T) { if (strcmp(attributeValue.getValue(), "true") == 0) { value.type = O_BOOL; value.numval = 1; } else if (strcmp(attributeValue.getValue(), "false") == 0) { value.type = O_BOOL; value.numval = 0; } else { value.strval = strdup(attributeValue.getValue()); value.type = O_STR; } return; } else assert(false); } } //--------------------------------------------------------------------------------- // SMTConfig bool SMTConfig::setOption(const char* name, const SMTOption& value, const char*& msg) { msg = "ok"; if (usedForInitialization && isPreInitializationOption(name)) { msg = "Option cannot be changed at this point"; return false; } // Special options: // stats_out if (strcmp(name, o_stats_out) == 0) { if (value.getValue().type != O_STR) { msg = s_err_not_str; return false; } if (!optionTable.has(name)) stats_out.open(value.getValue().strval, std::ios_base::out); else if (strcmp(optionTable[name]->getValue().strval, value.getValue().strval) != 0) { if (stats_out.is_open()) { stats_out.close(); stats_out.open(value.getValue().strval, std::ios_base::out); } } else {} } // produce stats if (strcmp(name, o_produce_stats) == 0) { if (value.getValue().type != O_BOOL) { msg = s_err_not_bool; return false; } if (value.getValue().numval == 1) { // Gets set to true if (!optionTable.has(o_stats_out)) { if (!optionTable.has(o_produce_stats) || optionTable[o_produce_stats]->getValue().numval == 0) { // Insert the default value insertOption(o_stats_out, new SMTOption("/dev/stdout")); } else if (optionTable.has(o_produce_stats) && optionTable[o_produce_stats]->getValue().numval == 1) assert(false); } else { } // No action required if (!stats_out.is_open()) stats_out.open(optionTable[o_stats_out]->getValue().strval, std::ios_base::out); } else if (optionTable.has(o_produce_stats) && optionTable[o_produce_stats]->getValue().numval == 1) { // gets set to false and was previously true if (optionTable.has(o_stats_out)) { if (optionTable[o_stats_out]->getValue().numval == 0) assert(false); else if (stats_out.is_open()) stats_out.close(); } } } if (strcmp(name, o_random_seed) == 0) { if (value.getValue().type != O_NUM) { msg = s_err_not_num; return false; } int seed = value.getValue().numval; if (seed == 0) { msg = s_err_seed_zero; return false; } } if (strcmp(name, o_sat_split_type) == 0) { if (value.getValue().type != O_STR) { msg = s_err_not_str; return false; } const char* val = value.getValue().strval; if (strcmp(val, spts_lookahead) != 0 && strcmp(val, spts_scatter) != 0 && strcmp(val, spts_none) != 0) { msg = s_err_unknown_split; return false; } } if (strcmp(name, o_sat_split_units) == 0) { if (value.getValue().type != O_STR) { msg = s_err_not_str; return false; } const char* val = value.getValue().strval; if (strcmp(val, spts_time) != 0 && strcmp(val, spts_search_counter) != 0) { msg = s_err_unknown_units; return false; } } if (optionTable.has(name)) optionTable.remove(name); insertOption(name, new SMTOption(value)); return true; } const SMTOption& SMTConfig::getOption(const char* name) const { if (optionTable.has(name)) return *optionTable[name]; else return option_Empty; } bool SMTConfig::setInfo(const char* name_, const Info& value) { if (infoTable.has(name_)) infoTable.remove(name_); Info* value_new = new Info(value); char* name = strdup(name_); infos.push(value_new); info_names.push(name); infoTable.insert(name, value_new); return true; } const Info& SMTConfig::getInfo(const char* name) const { if (infoTable.has(name)) return *infoTable[name]; else return info_Empty; } const char* SMTConfig::o_produce_models = ":produce-models"; const char* SMTConfig::o_verbosity = ":verbosity"; const char* SMTConfig::o_incremental = ":incremental"; const char* SMTConfig::o_produce_stats = ":produce-stats"; const char* SMTConfig::o_stats_out = ":stats-out"; const char* SMTConfig::o_random_seed = ":random-seed"; const char* SMTConfig::o_grow = ":grow"; const char* SMTConfig::o_clause_lim = ":cl-lim"; const char* SMTConfig::o_subsumption_lim = ":sub-lim"; const char* SMTConfig::o_simp_garbage_frac = ":simp-gc-frac"; const char* SMTConfig::o_use_asymm = ":asymm"; const char* SMTConfig::o_use_rcheck = ":rcheck"; const char* SMTConfig::o_use_elim = ":elim"; const char* SMTConfig::o_var_decay = ":var-decay"; const char* SMTConfig::o_clause_decay = ":clause-decay"; const char* SMTConfig::o_random_var_freq= ":random-var-freq"; const char* SMTConfig::o_luby_restart = ":luby-restart"; const char* SMTConfig::o_ccmin_mode = ":ccmin-mode"; const char* SMTConfig::o_rnd_pol = ":rnd-pol"; const char* SMTConfig::o_rnd_init_act = ":rnd-init-act"; const char* SMTConfig::o_sat_dump_rnd_inter = ":sat-num-rnd-itps"; const char* SMTConfig::o_garbage_frac = ":garbage-frac"; const char* SMTConfig::o_restart_first = ":restart-first"; const char* SMTConfig::o_restart_inc = ":restart-inc"; const char* SMTConfig::o_produce_proofs = ":produce-proofs"; const char* SMTConfig::o_produce_inter = ":produce-interpolants"; const char* SMTConfig::o_certify_inter = ":certify-interpolants"; const char* SMTConfig::o_simplify_inter = ":simplify-interpolants"; const char* SMTConfig::o_interpolant_cnf = ":cnf-interpolants"; const char* SMTConfig::o_proof_struct_hash = ":proof-struct-hash"; const char* SMTConfig::o_proof_check = ":proof-check"; const char* SMTConfig::o_proof_multiple_inter = ":proof-interpolation-property"; const char* SMTConfig::o_proof_alternative_inter = ":proof-alternative-inter"; const char* SMTConfig::o_proof_reduce = ":proof-reduce"; const char* SMTConfig::o_proof_rec_piv = ":proof-rpi"; const char* SMTConfig::o_proof_push_units = ":proof-lower-units"; const char* SMTConfig::o_proof_transf_trav = ":proof-reduce-expose"; const char* SMTConfig::o_proof_num_graph_traversals = ":proof-num-graph-traversals"; const char* SMTConfig::o_proof_red_trans = ":proof-num-global-iterations"; const char* SMTConfig::o_itp_bool_alg = ":interpolation-bool-algorithm"; const char* SMTConfig::o_itp_euf_alg = ":interpolation-euf-algorithm"; const char* SMTConfig::o_itp_lra_alg = ":interpolation-lra-algorithm"; const char* SMTConfig::o_itp_lra_factor = ":interpolation-lra-factor"; const char* SMTConfig::o_sat_resource_units = ":resource-units"; const char* SMTConfig::o_sat_resource_limit = ":resource-limit"; const char* SMTConfig::o_dump_state = ":dump-state"; const char* SMTConfig::o_time_queries = ":time-queries"; const char* SMTConfig::o_output_dir = ":output-dir"; const char* SMTConfig::o_ghost_vars = ":ghost-vars"; const char* SMTConfig::o_dump_query = ":dump-query"; const char* SMTConfig::o_dump_query_name = ":dump-query-name"; const char* SMTConfig::o_inst_name = ":instance-name"; const char* SMTConfig::o_dump_only = ":dump-only"; const char* SMTConfig::o_sat_dump_learnts = ":dump-learnts"; const char* SMTConfig::o_sat_split_type = ":split-type"; const char* SMTConfig::o_sat_split_inittune = ":split-init-tune"; const char* SMTConfig::o_sat_split_midtune = ":split-mid-tune"; const char* SMTConfig::o_sat_split_num = ":split-num"; const char* SMTConfig::o_sat_split_fix_vars = ":split-fix-vars"; const char* SMTConfig::o_sat_split_asap = ":split-asap"; const char* SMTConfig::o_sat_split_units = ":split-units"; const char* SMTConfig::o_sat_split_preference = ":split-preference"; const char* SMTConfig::o_sat_split_test_cube_and_conquer = ":test-cube-and-conquer"; const char* SMTConfig::o_sat_split_randomize_lookahead = ":randomize-lookahead"; const char* SMTConfig::o_sat_split_randomize_lookahead_buf = ":randomize-lookahead-buf"; // The n best found literals const char* SMTConfig::o_sat_remove_symmetries = ":remove-symmetries"; const char* SMTConfig::o_dryrun = ":dryrun"; const char* SMTConfig::o_do_substitutions = ":do-substitutions"; const char* SMTConfig::o_respect_logic_partitioning_hints = ":respect-logic-partitioning-hints"; // Logic can have a say whether a var is good for partitioning const char* SMTConfig::o_sat_scatter_split = ":scatter-split"; const char* SMTConfig::o_sat_lookahead_split = ":lookahead-split"; const char* SMTConfig::o_sat_pure_lookahead = ":pure-lookahead"; const char* SMTConfig::o_lookahead_score_deep = ":lookahead-score-deep"; const char* SMTConfig::o_sat_solver_limit = ":solver-limit"; const char* SMTConfig::o_sat_picky = ":picky"; const char* SMTConfig::o_sat_picky_w = ":picky_w"; const char* SMTConfig::o_global_declarations = ":global-declarations"; const char* SMTConfig::o_sat_split_mode = ":split-mode"; char* SMTConfig::server_host=NULL; uint16_t SMTConfig::server_port = 0; char* SMTConfig::database_host=NULL; uint16_t SMTConfig::database_port = 0; // Error strings const char* SMTConfig::s_err_not_str = "expected string"; const char* SMTConfig::s_err_not_bool = "expected Boolean"; const char* SMTConfig::s_err_not_num = "expected number"; const char* SMTConfig::s_err_seed_zero = "seed cannot be 0"; const char* SMTConfig::s_err_unknown_split = "unknown split type"; const char* SMTConfig::s_err_unknown_units = "unknown split units"; void SMTConfig::initializeConfig( ) { // Set Global Default configuration status = l_Undef; insertOption(o_produce_stats, new SMTOption(0)); // produce_stats = 0; // produce_models = 0; print_stats = 1; print_proofs_smtlib2 = 0; print_proofs_dotty = 0; // produce_inter = 0; dump_formula = 0; // verbosity = 2; // print_success = false; certification_level = 0; strcpy( certifying_solver, "tool_wrapper.sh" ); // Set SAT-Solver Default configuration sat_initial_skip_step = 1; sat_skip_step_factor = 1; sat_use_luby_restart = 1; sat_learn_up_to_size = 0; sat_temporary_learn = 1; sat_preprocess_booleans = 1; sat_preprocess_theory = 0; sat_centrality = 18; sat_trade_off = 8192; sat_minimize_conflicts = 1; sat_dump_cnf = 0; // sat_dump_rnd_inter = 0; sat_lazy_dtc = 0; sat_lazy_dtc_burst = 1; // UF-Solver Default configuration uf_disable = 0; // BV-Solver Default configuration bv_disable = 0; // DL-Solver Default configuration dl_disable = 0; // LRA-Solver Default configuration lra_disable = 0; lra_poly_deduct_size = 0; lra_integer_solver = 0; lra_check_on_assert = 0; // Proof parameters // proof_reduce = 0; proof_ratio_red_solv = 0; proof_red_time = 0; // proof_num_graph_traversals = 0; // proof_red_trans = 0; proof_reorder_pivots = 0; proof_reduce_while_reordering = 0; proof_random_context_analysis = 0; proof_random_swap_application = 0; proof_remove_mixed = 0; // proof_certify_inter = 0; proof_random_seed = 0; sat_theory_polarity_suggestion = 1; cuf_bitwidth = 32; } void SMTConfig::parseCMDLine( int argc , char * argv[ ] ) { for ( int i = 1 ; i < argc - 1 ; i ++ ) { const char * buf = argv[ i ]; // Parsing of configuration options // if ( sscanf( buf, "--config=%s", config_name ) == 1 ) // { // parseConfig( config_name ); // break; // } if ( strcmp( buf, "--help" ) == 0 || strcmp( buf, "-h" ) == 0 ) { printHelp( ); exit( 1 ); } else { printHelp( ); std::cerr << "unrecognized option" << buf << std::endl; exit(1); } } } void SMTConfig::printHelp( ) { const char help_string[] = "Usage: ./opensmt [OPTION] filename\n" "where OPTION can be\n" " --help [-h] print this help\n" " --config= use configuration file \n"; std::cerr << help_string; } opensmt-2.5.2/src/options/SMTConfig.h000066400000000000000000001152641445011647600174520ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2016 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #ifndef SMTCONFIG_H #define SMTCONFIG_H #include "SolverTypes.h" #include "StringMap.h" #include "smt2tokens.h" #include #include #include #include #include #include enum ASTType { CMD_T , CMDL_T , SYM_T , SYML_T , QSYM_T , QSYML_T , NUM_T , NUML_T , SORT_T , SORTL_T , SV_T , SVL_T , UATTR_T , UATTRL_T , PATTR_T , PATTRL_T , GATTR_T , GATTRL_T , SPECC_T , SPECCL_T , SEXPR_T , SEXPRL_T , ID_T , IDL_T , LID_T , LIDL_T , DEC_T , DECL_T , HEX_T , HEXL_T , BIN_T , BINL_T , STR_T , STRL_T , AS_T , ASL_T , VARB_T , VARBL_T , TERM_T , TERML_T , QID_T , QITL_T , LQID_T , LQIDL_T , LET_T , LETL_T , FORALL_T , FORALLL_T , EXISTS_T , EXISTSL_T , BANG_T , BANGL_T , SSYMD_T , SSYMDL_T , FSYMD_T , FSYMDL_T , PFSYMD_T , PFSYMDL_T , PFID_T , PFIDL_T , TATTR_T , TATTRL_T , TDECL_T , TDECLL_T , LATTR_T , LATTRL_T , LOGIC_T , LOGICL_T , BOOL_T , BOOLL_T , OPTION_T , OPTIONL_T , INFO_T , INFOL_T , CONST_T , CONSTL_T }; class ASTNode { private: ASTType type; osmttokens::smt2token tok; char* val; static const char* typestr[]; public: std::vector< ASTNode* >*children; ASTNode(ASTType t, osmttokens::smt2token tok) : type(t), tok(tok), val(NULL), children(NULL) {} ASTNode(ASTType t, char* v) : type(t), tok({osmttokens::t_none}), val(v), children(NULL) {} ASTNode(ASTNode const &) = delete; ASTNode & operator=(ASTNode const &) = delete; ~ASTNode() { if (children) { for (auto ci = children->begin(); ci != children->end(); ci++) { delete *ci; }; delete children; } free(val); } void print(std::ostream& o, int indent); inline const char *typeToStr() const { return typestr[type]; } inline ASTType getType() const { return type; } inline const char *getValue() const { return val; } inline const osmttokens::smt2token getToken() const { return tok; } }; enum ConfType { O_EMPTY, O_STR, O_SYM, O_NUM, O_DEC, O_HEX, O_BIN, O_LIST, O_ATTR, O_BOOL }; class ConfValue { public: ConfType type; union { char* strval; int numval; double decval; uint32_t unumval; std::list* configs; }; ConfValue() : type(O_EMPTY), strval(NULL) {}; ConfValue(const ASTNode& s_expr_n); ConfValue(int i) : type(O_NUM), numval(i) {}; ConfValue(double i) : type(O_DEC), decval(i) {}; ConfValue(const char* s); ConfValue(const ConfValue& other); ConfValue& operator=(const ConfValue& other); std::string toString() const; double getDoubleVal() const {if (type == O_NUM) return (double)numval; else if (type == O_DEC) return decval; else assert(false); return -1;} ~ConfValue(); }; class Info { private: ConfValue value; public: Info(ASTNode const & n); Info(Info const & other); Info() {}; bool isEmpty() const { return value.type == O_EMPTY; } inline std::string toString() const { return value.toString(); } }; class SMTOption { private: ConfValue value; public: SMTOption(ASTNode const & n); SMTOption() {} SMTOption(int i) : value(i) {} SMTOption(double i): value(i) {} SMTOption(const char* s) : value(s) {} inline bool isEmpty() const { return value.type == O_EMPTY; } inline std::string toString() const { return value.toString(); } inline const ConfValue& getValue() const { return value; } }; // Type safe wrapper for split types typedef struct SpType { int t; } SpType; typedef struct SpPref { int t; } SpPref; typedef struct SpFormat { int t; } SpFormat; struct ItpAlgorithm { int x; bool operator==(const ItpAlgorithm& o) const { return x == o.x; }}; static const struct ItpAlgorithm itp_alg_mcmillan = { 0 }; static const struct ItpAlgorithm itp_alg_pudlak = { 1 }; static const struct ItpAlgorithm itp_alg_mcmillanp = { 2 }; static const struct ItpAlgorithm itp_alg_ps = { 3 }; static const struct ItpAlgorithm itp_alg_psw = { 4 }; static const struct ItpAlgorithm itp_alg_pss = { 5 }; static const struct ItpAlgorithm itp_euf_alg_strong = { 0 }; static const struct ItpAlgorithm itp_euf_alg_weak = { 2 }; static const struct ItpAlgorithm itp_euf_alg_random = { 3 }; static const struct ItpAlgorithm itp_lra_alg_strong = { 0 }; static const struct ItpAlgorithm itp_lra_alg_weak = { 2 }; static const struct ItpAlgorithm itp_lra_alg_factor = { 3 }; static const struct ItpAlgorithm itp_lra_alg_decomposing_strong = {4 }; static const struct ItpAlgorithm itp_lra_alg_decomposing_weak = {5 }; static const char *itp_lra_factor_0 = "1/2"; inline bool operator==(const SpType& s1, const SpType& s2) { return s1.t == s2.t; } inline bool operator!=(const SpType& s1, const SpType& s2) { return s1.t != s2.t; } inline bool operator==(const SpPref& s1, const SpPref& s2) { return s1.t == s2.t; } inline bool operator!=(const SpPref& s1, const SpPref& s2) { return s1.t != s2.t; } inline bool operator==(const SpFormat& s1, const SpFormat& s2) { return s1.t == s2.t; } inline bool operator!=(const SpFormat& s1, const SpFormat& s2) { return s1.t != s2.t; } static const char* const spts_lookahead = "lookahead"; static const char* const spts_scatter = "scattering"; static const char* const spts_none = "none"; static const char* const spts_search_counter = "search_counter"; static const char* const spts_time = "time"; static const char* const spprefs_tterm = "tterm"; static const char* const spprefs_blind = "blind"; static const char* const spprefs_bterm = "bterm"; static const char* const spprefs_rand = "random"; static const char* const spprefs_noteq = "noteq"; static const char* const spprefs_eq = "eq"; static const char* const spprefs_tterm_neq = "tterm_neq"; static const char* const spformats_brief = "brief"; static const char* const spformats_full = "full"; static const struct SpType spt_none = { 0 }; static const struct SpType spt_lookahead = { 1 }; static const struct SpType spt_scatter = { 2 }; enum class SpUnit : char { search_counter, time }; static const struct SpPref sppref_tterm = { 0 }; static const struct SpPref sppref_blind = { 1 }; static const struct SpPref sppref_bterm = { 2 }; static const struct SpPref sppref_rand = { 3 }; static const struct SpPref sppref_undef = { 4 }; static const struct SpPref sppref_noteq = { 5 }; static const struct SpPref sppref_eq = { 6 }; static const struct SpPref sppref_tterm_neq = { 7 }; static const struct SpFormat spformat_smt2 = { 0 }; static const struct SpFormat spformat_osmt2 = { 1 }; static const struct SpFormat spformat_brief = { 2 }; static const struct SpFormat spformat_full = { 3 }; // // Holds informations about the configuration of the solver // struct SMTConfig { // The options here should be private public: static const char* o_incremental; static const char* o_verbosity; static const char* o_produce_stats; static const char* o_stats_out; static const char* o_random_seed; // Allow a variable elimination step to grow by a number of clauses. static const char* o_grow; //Variables are not eliminated if it produces a resolvent with a length above this limit. -1 means no limit static const char* o_clause_lim; // Do not check if subsumption against a clause larger than this. -1 means no limit. static const char* o_subsumption_lim; // The fraction of wasted memory allowed before a garbage collection is triggered during simplification. static const char* o_simp_garbage_frac; // Shrink clauses by asymmetric branching. static const char* o_use_asymm; // Check if a clause is already implied. (costly) static const char* o_use_rcheck; // Perform variable elimination. static const char* o_use_elim; static const char* o_var_decay; static const char* o_clause_decay; static const char* o_random_var_freq; static const char* o_luby_restart; static const char* o_ccmin_mode; static const char* o_rnd_pol; static const char* o_rnd_init_act; static const char* o_garbage_frac; static const char* o_restart_first; static const char* o_restart_inc; static const char* o_produce_proofs; static const char* o_produce_inter; static const char* o_certify_inter; static const char* o_simplify_inter; static const char* o_interpolant_cnf; static const char* o_proof_struct_hash; static const char* o_proof_num_graph_traversals; static const char* o_proof_red_trans; static const char* o_proof_rec_piv; static const char* o_proof_push_units; static const char* o_proof_transf_trav; static const char* o_proof_check; static const char* o_proof_multiple_inter; static const char* o_proof_alternative_inter; static const char* o_proof_reduce; static const char* o_itp_bool_alg; static const char* o_itp_euf_alg; static const char* o_itp_lra_alg; static const char* o_itp_lra_factor; static const char* o_sat_dump_rnd_inter; static const char* o_sat_resource_units; static const char* o_sat_resource_limit; static const char* o_dump_state; static const char* o_time_queries; static const char* o_inst_name; static const char* o_dump_only; static const char* o_dump_mode; static const char* o_dump_query; static const char* o_dump_query_name; static const char* o_sat_dump_learnts; static const char* o_sat_split_type; static const char* o_sat_split_inittune; static const char* o_sat_split_midtune; static const char* o_sat_split_num; static const char* o_sat_split_fix_vars; // Like split_num, but give the number of vars to fix instead static const char* o_sat_split_asap; static const char* o_sat_scatter_split; static const char* o_sat_lookahead_split; static const char* o_sat_pure_lookahead; static const char* o_lookahead_score_deep; static const char* o_sat_picky; static const char* o_sat_picky_w; static const char* o_sat_split_units; static const char* o_sat_split_preference; static const char* o_sat_split_test_cube_and_conquer; static const char* o_sat_split_randomize_lookahead; static const char* o_sat_split_randomize_lookahead_buf; static const char* o_produce_models; static const char* o_sat_remove_symmetries; static const char* o_dryrun; static const char* o_do_substitutions; static const char* o_respect_logic_partitioning_hints; static const char* o_output_dir; static const char* o_ghost_vars; static const char* o_sat_solver_limit; static const char* o_global_declarations; static const char* o_sat_split_mode; private: static const char* s_err_not_str; static const char* s_err_not_bool; static const char* s_err_not_num; static const char* s_err_seed_zero; static const char* s_err_unknown_split; static const char* s_err_unknown_units; Info info_Empty; SMTOption option_Empty; vec options; vec option_names; vec infos; vec info_names; Map > infoTable; Map > optionTable; bool usedForInitialization = false; // Some options can be changed only before this config is used for initialization of MainSolver bool isPreInitializationOption(const char* o_name) { return strcmp(o_name, o_produce_inter) == 0 || strcmp(o_name, o_produce_proofs) == 0 || strcmp(o_name, o_sat_pure_lookahead) == 0 || strcmp(o_name, o_sat_lookahead_split) == 0 || strcmp(o_name, o_sat_picky) == 0 || strcmp(o_name, o_sat_scatter_split) == 0 || strcmp(o_name, o_ghost_vars) == 0; } void insertOption(const char* o_name, SMTOption* o) { options.push(o); if (optionTable.has(o_name)) optionTable[o_name] = o; else { char* my_name = strdup(o_name); option_names.push(my_name); optionTable.insert(my_name, o); } } char* append_output_dir(const char* name) const { const char* path = output_dir(); // If output_dir() is not defined (or is empty), just return (copy of) name if (strlen(path) == 0) return strdup(name); // Otherwise, use name but prepend output_dir. char* tmp_name = strdup(name); char* base = basename(tmp_name); int full_length = strlen(base)+1+strlen(output_dir()); char *full_str = (char*)malloc(full_length+1); char* ptr = full_str; for (unsigned int i = 0; i < strlen(path); i++) { *ptr = path[i]; ptr++; } (*ptr) = '/'; ptr++; for (unsigned int i = 0; i < strlen(base); i++) { *ptr = base[i]; ptr++; } *ptr = '\0'; free(tmp_name); return full_str; } // // For standard executable // public: SMTConfig(int argc, char* argv[]) : rocset(false), docset(false) { initializeConfig( ); // Parse command-line options parseCMDLine( argc, argv ); } // // For API // SMTConfig () : rocset(false), docset(false) { initializeConfig( ); } ~SMTConfig ( ) { if ( produceStats() ) stats_out.close( ); if ( rocset ) out.close( ); if ( docset ) err.close( ); for (int i = 0; i < options.size(); i++) delete options[i]; for (int i = 0; i < option_names.size(); i++) free(option_names[i]); for (int i = 0; i < infos.size(); i++) delete infos[i]; for (int i = 0; i < info_names.size(); i++) free(info_names[i]); } bool setOption(const char* name, const SMTOption& value, const char*& msg); const SMTOption& getOption(const char* name) const; bool setInfo (const char* name, const Info& value); const Info& getInfo (const char* name) const; void initializeConfig ( ); void parseConfig ( char * ); void parseCMDLine ( int argc, char * argv[ ] ); void printHelp ( ); void printConfig ( std::ostream & out ); inline std::ostream & getStatsOut ( ) { assert( optionTable.has(o_produce_stats) ); return stats_out; } inline std::ostream & getRegularOut ( ) { return rocset ? out : std::cout; } inline std::ostream & getDiagnosticOut( ) { return docset ? err : std::cerr; } inline int getRandomSeed ( ) const { return optionTable.has(o_random_seed) ? optionTable[o_random_seed]->getValue().numval : 91648253; } inline void setProduceModels( ) { insertOption(o_produce_models, new SMTOption(1)); } inline bool setRandomSeed(int seed) { insertOption(o_random_seed, new SMTOption(seed)); return true; } void setUsedForInitiliazation() { usedForInitialization = true; } inline bool produceProof( ) { return optionTable.has(o_produce_proofs) ? optionTable[o_produce_proofs]->getValue().numval > 0 : false; } void setTimeQueries() { insertOption(o_time_queries, new SMTOption(1)); } bool timeQueries() { return optionTable.has(o_time_queries) ? optionTable[o_time_queries]->getValue().numval : false; } // Set reduction params inline void setReduction(int r) { insertOption(o_proof_reduce, new SMTOption(r)); } inline void setReductionGraph(int r) { insertOption(o_proof_num_graph_traversals, new SMTOption(r)); } inline void setReductionLoops(int r) { insertOption(o_proof_red_trans, new SMTOption(r)); } // Set interpolation algorithms inline void setBooleanInterpolationAlgorithm( ItpAlgorithm i ) { insertOption(o_itp_bool_alg, new SMTOption(i.x)); } inline void setEUFInterpolationAlgorithm( ItpAlgorithm i ) { insertOption(o_itp_euf_alg, new SMTOption(i.x)); } inline void setLRAInterpolationAlgorithm( ItpAlgorithm i ) { insertOption(o_itp_lra_alg, new SMTOption(i.x)); } inline void setLRAStrengthFactor(const char *factor) { insertOption(o_itp_lra_factor, new SMTOption(factor)); } inline void setInstanceName(const char* name) { insertOption(o_inst_name, new SMTOption(name)); } // Get interpolation algorithms inline ItpAlgorithm getBooleanInterpolationAlgorithm() const { if (optionTable.has(o_itp_bool_alg)) { return { optionTable[o_itp_bool_alg]->getValue().numval }; } else { return itp_alg_mcmillan; }} inline ItpAlgorithm getEUFInterpolationAlgorithm() const { if (optionTable.has(o_itp_euf_alg)) { return { optionTable[o_itp_euf_alg]->getValue().numval }; } else { return itp_euf_alg_strong; }} inline ItpAlgorithm getLRAInterpolationAlgorithm() const { if (optionTable.has(o_itp_lra_alg)) { return { optionTable[o_itp_lra_alg]->getValue().numval }; } else { return itp_lra_alg_strong; }} inline const char* getLRAStrengthFactor() const { if (optionTable.has(o_itp_lra_factor)) { return optionTable[o_itp_lra_factor]->getValue().strval; } else { return itp_lra_factor_0; } } inline const char* getInstanceName() const { if (optionTable.has(o_inst_name)) { return optionTable[o_inst_name]->getValue().strval; } else { return "unknown"; } } inline void setRegularOutputChannel( const char * attr ) { if ( strcmp( attr, "stdout" ) != 0 && !rocset ) { out.open( attr ); if( !out ) throw std::ifstream::failure("can't open " + std::string(attr)); rocset = true; } } inline void setDiagnosticOutputChannel( const char * attr ) { if ( strcmp( attr, "stderr" ) != 0 && !rocset ) { err.open( attr ); if( !err ) throw std::ifstream::failure("can't open " + std::string(attr)); rocset = true; } } lbool status; // Status of the benchmark // int incremental; // Incremental solving int isIncremental() const { return optionTable.has(o_incremental) ? optionTable[o_incremental]->getValue().numval == 1: true; } int produce_models() const { return optionTable.has(o_produce_models) ? optionTable[o_produce_models]->getValue().numval : 1; } int produceStats() const { return optionTable.has(o_produce_stats) ? optionTable[o_produce_stats]->getValue().numval == 1: false; } std::string getStatsOut() const { return optionTable.has(o_stats_out) ? optionTable[o_stats_out]->getValue().strval: "/dev/stdout"; } int sat_grow() const { return optionTable.has(o_grow) ? optionTable[o_grow]->getValue().numval : 0; } int sat_clause_lim() const { return optionTable.has(o_clause_lim) ? optionTable[o_clause_lim]->getValue().numval : 20; } int sat_subsumption_lim() const { return optionTable.has(o_subsumption_lim) ? optionTable[o_subsumption_lim]->getValue().numval : 1000; } double sat_simp_garbage_frac() const { return optionTable.has(o_simp_garbage_frac) ? optionTable[o_simp_garbage_frac]->getValue().decval : 0.5; } int sat_use_asymm() const { return optionTable.has(o_use_asymm) ? optionTable[o_use_asymm]->getValue().numval == 1: false; } int sat_use_rcheck() const { return optionTable.has(o_use_rcheck) ? optionTable[o_use_rcheck]->getValue().numval == 1: false; } int sat_use_elim() const { return optionTable.has(o_use_elim) ? optionTable[o_use_elim]->getValue().numval == 1: true; } double sat_var_decay() const { return optionTable.has(o_var_decay) ? optionTable[o_var_decay]->getValue().decval : 1 / 0.95; } double sat_clause_decay() const { return optionTable.has(o_clause_decay) ? optionTable[o_clause_decay]->getValue().decval : 1 / 0.999; } double sat_random_var_freq() const { return optionTable.has(o_random_var_freq) ? optionTable[o_random_var_freq]->getValue().decval : 0.02; } int sat_random_seed() const { return optionTable.has(o_random_seed) ? optionTable[o_random_seed]->getValue().decval : 91648253; } int sat_luby_restart() const { return optionTable.has(o_luby_restart) ? optionTable[o_luby_restart]->getValue().numval > 0 : 1; } int sat_ccmin_mode() const { return optionTable.has(o_ccmin_mode) ? optionTable[o_ccmin_mode]->getValue().numval : 2; } int sat_rnd_pol() const { return optionTable.has(o_rnd_pol) ? optionTable[o_rnd_pol]->getValue().numval > 0 : 0; } int sat_rnd_init_act() const { return optionTable.has(o_rnd_init_act) ? optionTable[o_rnd_init_act]->getValue().numval > 0 : 0; } double sat_garbage_frac() const { return optionTable.has(o_garbage_frac) ? optionTable[o_garbage_frac]->getValue().decval : 0.20; } int sat_restart_first() const { return optionTable.has(o_restart_first) ? optionTable[o_restart_first]->getValue().numval : 100; } double sat_restart_inc() const { return optionTable.has(o_restart_inc) ? optionTable[o_restart_inc]->getValue().numval : 1.1; } int proof_interpolant_cnf() const { return optionTable.has(o_interpolant_cnf) ? optionTable[o_interpolant_cnf]->getValue().numval : 0; } int certify_inter() const { return optionTable.has(o_certify_inter) ? optionTable[o_certify_inter]->getValue().numval : 0; } bool produce_inter() const { return optionTable.has(o_produce_inter) ? optionTable[o_produce_inter]->getValue().numval > 0 : false; } int simplify_inter() const { return optionTable.has(o_simplify_inter) ? optionTable[o_simplify_inter]->getValue().numval : 0; } int proof_struct_hash() const { return optionTable.has(o_proof_struct_hash) ? optionTable[o_proof_struct_hash]->getValue().numval : 1; } int proof_num_graph_traversals() const { return optionTable.has(o_proof_num_graph_traversals) ? optionTable[o_proof_num_graph_traversals]->getValue().numval : 3; } int proof_red_trans() const { return optionTable.has(o_proof_red_trans) ? optionTable[o_proof_red_trans]->getValue().numval : 2; } int proof_rec_piv() const { return optionTable.has(o_proof_rec_piv) ? optionTable[o_proof_rec_piv]->getValue().numval : 1; } int proof_push_units() const { return optionTable.has(o_proof_push_units) ? optionTable[o_proof_push_units]->getValue().numval : 1; } int proof_transf_trav() const { return optionTable.has(o_proof_transf_trav) ? optionTable[o_proof_transf_trav]->getValue().numval : 1; } int proof_check() const { return optionTable.has(o_proof_check) ? optionTable[o_proof_check]->getValue().numval : 0; } int proof_multiple_inter() const { return optionTable.has(o_proof_multiple_inter) ? optionTable[o_proof_multiple_inter]->getValue().numval : 0; } int proof_alternative_inter() const { return optionTable.has(o_proof_alternative_inter) ? optionTable[o_proof_alternative_inter]->getValue().numval : 0; } int proof_reduce() const { return optionTable.has(o_proof_reduce) ? optionTable[o_proof_reduce]->getValue().numval : 0; } int itp_bool_alg() const { return optionTable.has(o_itp_bool_alg) ? optionTable[o_itp_bool_alg]->getValue().numval : 0; } int itp_euf_alg() const { return optionTable.has(o_itp_euf_alg) ? optionTable[o_itp_euf_alg]->getValue().numval : 0; } int itp_lra_alg() const { return optionTable.has(o_itp_lra_alg) ? optionTable[o_itp_lra_alg]->getValue().numval : 0; } int sat_dump_rnd_inter() const { return optionTable.has(o_sat_dump_rnd_inter) ? optionTable[o_sat_dump_rnd_inter]->getValue().numval : 2; } bool declarations_are_global() const { return optionTable.has(o_global_declarations) ? optionTable[o_global_declarations]->getValue().numval > 0 : false; } SpUnit sat_resource_units() const { if (optionTable.has(o_sat_resource_units)) { const char* type = optionTable[o_sat_resource_units]->getValue().strval; if (strcmp(type, spts_search_counter) == 0) return SpUnit::search_counter; else if (strcmp(type, spts_time) == 0) return SpUnit::time; } return SpUnit::search_counter; } bool respect_logic_partitioning_hints() const { return optionTable.has(o_respect_logic_partitioning_hints) ? optionTable[o_respect_logic_partitioning_hints]->getValue().numval : 0; } double sat_resource_limit() const { return optionTable.has(o_sat_resource_limit) ? optionTable[o_sat_resource_limit]->getValue().getDoubleVal() : -1; } char* dump_state() const { char* n; if (optionTable.has(o_dump_state)) n = strdup(optionTable[o_dump_state]->getValue().strval); else { const char* name = getInstanceName(); int name_length = strlen(name)-strlen(".smt2"); n = (char*)malloc(name_length+1); for (int i = 0; i < name_length; i++) n[i] = name[i]; n[name_length] = '\0'; } char* name = append_output_dir(n); free(n); return name; } const char* output_dir() const { if (optionTable.has(o_output_dir)) return optionTable[o_output_dir]->getValue().strval; else return ""; } int dump_only() const { return optionTable.has(o_dump_only) ? optionTable[o_dump_only]->getValue().numval : 0; } bool dump_query() const { return optionTable.has(o_dump_query) ? optionTable[o_dump_query]->getValue().numval : 0; } void set_dump_query_name(const char* dump_query_name) { if (optionTable.has(o_dump_query_name)) { delete optionTable[o_dump_query_name]; optionTable[o_dump_query_name] = new SMTOption(strdup(dump_query_name)); } else insertOption(o_dump_query_name, new SMTOption(strdup(dump_query_name))); } char* dump_query_name() const { char* n; if (optionTable.has(o_dump_query_name)) n = strdup(optionTable[o_dump_query_name]->getValue().strval); else { return NULL; } char* name = append_output_dir(n); free(n); return name; } int sat_dump_learnts() const { return optionTable.has(o_sat_dump_learnts) ? optionTable[o_sat_dump_learnts]->getValue().numval : 0; } bool sat_split_test_cube_and_conquer() const { return optionTable.has(o_sat_split_test_cube_and_conquer) ? optionTable[o_sat_split_test_cube_and_conquer]->getValue().numval : 0; } SpType sat_split_type() const { if (sat_lookahead_split()) { return spt_lookahead; } else if (sat_scatter_split()) { return spt_scatter; } else { return spt_none; } } SpUnit sat_split_units() const { if (optionTable.has(o_sat_split_units)) { const char* type = optionTable[o_sat_split_units]->getValue().strval; if (strcmp(type, spts_search_counter) == 0) return SpUnit::search_counter; else if (strcmp(type, spts_time) == 0) return SpUnit::time; } return SpUnit::search_counter; } double sat_split_inittune() const { return optionTable.has(o_sat_split_inittune) ? optionTable[o_sat_split_inittune]->getValue().getDoubleVal() : -1; } double sat_split_midtune() const { return optionTable.has(o_sat_split_midtune) ? optionTable[o_sat_split_midtune]->getValue().getDoubleVal() : -1; } int sat_split_num() const { return optionTable.has(o_sat_split_num) ? optionTable[o_sat_split_num]->getValue().numval : 2; } int sat_split_fixvars() const { return optionTable.has(o_sat_split_fix_vars) ? optionTable[o_sat_split_fix_vars]->getValue().numval : -1; } int sat_split_asap() const { return optionTable.has(o_sat_split_asap) ? optionTable[o_sat_split_asap]->getValue().numval : 0; } int sat_lookahead_split() const { return optionTable.has(o_sat_lookahead_split) ? optionTable[o_sat_lookahead_split]->getValue().numval : 0; } int sat_scatter_split() const { return optionTable.has(o_sat_scatter_split) ? optionTable[o_sat_scatter_split]->getValue().numval : 0; } int sat_pure_lookahead() const { return optionTable.has(o_sat_pure_lookahead) ? optionTable[o_sat_pure_lookahead]->getValue().numval : 0; } int lookahead_score_deep() const { return optionTable.has(o_lookahead_score_deep) ? optionTable[o_lookahead_score_deep]->getValue().numval : 0; } int sat_picky() const { return optionTable.has(o_sat_picky) ? optionTable[o_sat_picky]->getValue().numval : 0; } int randomize_lookahead() const { return optionTable.has(o_sat_split_randomize_lookahead) ? optionTable[o_sat_split_randomize_lookahead]->getValue().numval : 0; } int randomize_lookahead_bufsz() const { return optionTable.has(o_sat_split_randomize_lookahead_buf) ? optionTable[o_sat_split_randomize_lookahead_buf]->getValue().numval : 1; } int remove_symmetries() const { return optionTable.has(o_sat_remove_symmetries) ? optionTable[o_sat_remove_symmetries]->getValue().numval : 0; } int dryrun() const { return optionTable.has(o_dryrun) ? optionTable[o_dryrun]->getValue().numval : 0; } void set_dryrun(bool b) { insertOption(o_dryrun, new SMTOption(b)); } SpPref sat_split_preference() const { if (optionTable.has(o_sat_split_preference)) { const char* type = optionTable[o_sat_split_preference]->getValue().strval; if (strcmp(type, spprefs_tterm) == 0) return sppref_tterm; if (strcmp(type, spprefs_blind) == 0) return sppref_blind; if (strcmp(type, spprefs_bterm) == 0) return sppref_bterm; if (strcmp(type, spprefs_rand) == 0) return sppref_rand; if (strcmp(type, spprefs_noteq) == 0) return sppref_noteq; if (strcmp(type, spprefs_eq) == 0) return sppref_eq; if (strcmp(type, spprefs_tterm_neq) == 0) return sppref_tterm_neq; } return sppref_blind; } bool use_ghost_vars() const { if (optionTable.has(o_ghost_vars)) { return optionTable[o_ghost_vars]->getValue().numval != 0; } return false; } int do_substitutions() const { return optionTable.has(o_do_substitutions) ? optionTable[o_do_substitutions]->getValue().numval : 1; } bool use_theory_polarity_suggestion() const { return sat_theory_polarity_suggestion != 0; } int sat_picky_w() const { return optionTable.has(o_sat_picky_w) ? optionTable[o_sat_picky_w]->getValue().numval : 1; } int sat_solver_limit() const { return optionTable.has(o_sat_solver_limit) ? optionTable[o_sat_solver_limit]->getValue().numval : 0; } bool sat_split_mode() const { if (optionTable.has(o_sat_split_mode)) { return optionTable[o_sat_split_mode]->getValue().numval != 0; } return false; } // int produce_stats; // Should print statistics ? int print_stats; // Should print statistics ? int print_proofs_smtlib2; // Should print proofs ? int print_proofs_dotty; // Should print proofs ? bool rocset; // Regular Output Channel set ? bool docset; // Diagnostic Output Channel set ? int dump_formula; // Dump input formula int verbosity() const // Verbosity level // TODO: remove MACROS from header file #ifdef PEDANTIC_DEBUG { return optionTable.has(o_verbosity) ? optionTable[o_verbosity]->getValue().numval : 2; } #elif GC_DEBUG { return optionTable.has(o_verbosity) ? optionTable[o_verbosity]->getValue().numval : 2; } #else { return optionTable.has(o_verbosity) ? optionTable[o_verbosity]->getValue().numval : 0; } #endif int printSuccess() const { return optionTable.has(":print-success") ? optionTable[":print-success"]->getValue().numval == 1: false; } int certification_level; // Level of certification char certifying_solver[256]; // Executable used for certification // SAT-Solver related parameters int sat_theory_polarity_suggestion; // Should the SAT solver ask the theory solver for var polarity when making a decision double sat_initial_skip_step; // Initial skip step for tsolver calls double sat_skip_step_factor; // Increment for skip step int sat_use_luby_restart; // Use luby restart mechanism int sat_learn_up_to_size; // Learn theory clause up to size int sat_temporary_learn; // Is learning temporary int sat_preprocess_booleans; // Activate satelite (on booleans) int sat_preprocess_theory; // Activate theory version of satelite int sat_centrality; // Specify centrality parameter int sat_trade_off; // Specify trade off int sat_minimize_conflicts; // Conflict minimization: 0 none, 1 bool only, 2 full int sat_dump_cnf; // Dump cnf formula int sat_lazy_dtc; // Activate dtc int sat_lazy_dtc_burst; // % of eij to generate int sat_reduce_proof; // Enable proof reduction int sat_reorder_pivots; // Enable pivots reordering for interpolation double sat_ratio_red_time_solv_time; // Reduction time / solving time for each global loop double sat_red_time; // Reduction time for each global loop int sat_num_glob_trans_loops; // Number of loops recycle pivots + reduction int sat_remove_mixed; // Compression of AB-mixed subtrees int sat_propagate_small; // Try to propagate first smaller clauses int sat_restart_learnt_thresh; // Restart solver if the current learnt has width > thresh int sat_orig_thresh; // Allows original clauses of width up to thresh // Proof manipulation parameters double proof_ratio_red_solv; // Ratio reduction time solving time for each global loop double proof_red_time; // Reduction time for each global loop int proof_reorder_pivots; // Enable pivot reordering int proof_reduce_while_reordering;// Enable reduction during reordering int proof_random_context_analysis;// Examine a context with 50% probability int proof_random_swap_application;// Apply a chosen A1,A2,B2k rule with 50% probability int proof_remove_mixed; // Enable removal of mixed predicates int proof_certify_inter; // Check interpolants int proof_random_seed; // Randomly initialize seed for transformation // int proof_rec_piv; // Enable the use of RecyclePivots for reduction // int proof_push_units; // Enable pushing down units heuristics // int proof_struct_hash_build; // Enable structural hashing while building the proof // int proof_struct_hash; // Enable structural hashing for compression int proof_switch_to_rp_hash; // Instead of hashing + rp does the opposite // int proof_transf_trav; // Enable transformation traversals // int proof_check; // Enable proof checking // int proof_alternative_inter; // Dual formula for AB pivots // int proof_multiple_inter; // Multiple interpolants // int proof_interpolant_cnf; // Enable proof restructuring for interpolant in CNF int proof_trans_strength; // Light proof restructuring for stronger/weaker interpolants, for Pudlak/McMillan/McMillan' algorithms // UF-Solver related parameters int uf_disable; // Disable the solver // CUF-Solver related parameter int cuf_bitwidth; // Bit-width to use by the CUF solver // BV-Solver related parameters int bv_disable; // Disable the solver // DL-Solver related parameters int dl_disable; // Disable the solver // LRA-Solver related parameters int lra_disable; // Disable the solver int lra_poly_deduct_size; // Used to define the size of polynomial to be used for deduction; 0 - no deduction for polynomials int lra_trade_off; // Trade-off value for DL preprocessing int lra_integer_solver; // Flag to require integer solution for LA problem int lra_check_on_assert; // Probability (0 to 100) to run check when assert is called static char* server_host; static uint16_t server_port; static char* database_host; static uint16_t database_port; void setSimplifyInterpolant(int val) { const char* msg; setOption(o_simplify_inter, SMTOption(val), msg); } int getSimplifyInterpolant() const { return simplify_inter(); } private: std::ofstream stats_out; // File for statistics std::ofstream out; // Regular output channel std::ofstream err; // Diagnostic output channel }; #endif opensmt-2.5.2/src/parallel/000077500000000000000000000000001445011647600156005ustar00rootroot00000000000000opensmt-2.5.2/src/parallel/CMakeLists.txt000066400000000000000000000067741445011647600203560ustar00rootroot00000000000000#Fetch and add PTPLib********************************************************************************************************** set(PTPLib_repository "https://github.com/usi-verification-and-security/ptplib.git") set(PTPLib_branch ${branch}) string(ASCII 27 ESCAPE) set(TM [0m) if(NOT PTPLib_branch) set(PINK [35m) message(STATUS "${ESCAPE}${PINK} You can choose which branch of PTPLib to fetch by: ${ESCAPE}${TM} ${ESCAPE}${PINK}-Dbranch=${ESCAPE}${TM}") set(PTPLib_branch master) endif() set(GREEN [32m) set(BLUE [34m) message(STATUS "${ESCAPE}${GREEN} PTPLib Repository: ${ESCAPE}${TM} ${ESCAPE}${BLUE}${PTPLib_repository}${ESCAPE}${TM}") message(STATUS "${ESCAPE}${GREEN} PTPLib BRANCH: ${ESCAPE}${TM}${ESCAPE}${BLUE}${PTPLib_branch}${ESCAPE}${TM}") include(FetchContent) Set(FETCHCONTENT_QUIET FALSE) FetchContent_Declare( PTPLib GIT_REPOSITORY ${PTPLib_repository} GIT_TAG ${PTPLib_branch} GIT_SHALLOW true GIT_PROGRESS true ) FetchContent_MakeAvailable(PTPLib) add_library(PTPLib::PTPLib ALIAS PTPLib) message(STATUS "PTPLib include: ${PTPLib_SOURCE_DIR}/include") #add parallel lib and link against PTPLib******************************************************************************* add_library(parallel OBJECT "") target_link_libraries(parallel PUBLIC PTPLib::PTPLib) list(APPEND PRIVATE_SOURCES_TO_ADD "${CMAKE_CURRENT_SOURCE_DIR}/ScatterSplitter.cc" "${CMAKE_CURRENT_SOURCE_DIR}/SplitterInterpret.cc" "${CMAKE_CURRENT_SOURCE_DIR}/LookaheadSplitter.cc" "${CMAKE_CURRENT_SOURCE_DIR}/LookaheadSplitter.h" "${CMAKE_CURRENT_SOURCE_DIR}/SplitContext.h" "${CMAKE_CURRENT_SOURCE_DIR}/SplitData.h" "${CMAKE_CURRENT_SOURCE_DIR}/Splitter.h" "${CMAKE_CURRENT_SOURCE_DIR}/MainSplitter.cc" "${CMAKE_CURRENT_SOURCE_DIR}/Splitter.cc" ) list(APPEND PUBLIC_SOURCES_TO_ADD "${CMAKE_CURRENT_SOURCE_DIR}/MainSplitter.h" "${CMAKE_CURRENT_SOURCE_DIR}/ScatterSplitter.h" "${CMAKE_CURRENT_SOURCE_DIR}/SplitterInterpret.h" ) target_sources(parallel PRIVATE ${PRIVATE_SOURCES_TO_ADD} PUBLIC ${PUBLIC_SOURCES_TO_ADD} ) #Define OpenSMT-splitter-static library which contains OpenSMT-static, parallel and PTPLib****************************** #Usage: SMTS if (BUILD_STATIC_LIBS) add_library(OpenSMT-splitter-static STATIC "") set_target_properties(OpenSMT-splitter-static PROPERTIES OUTPUT_NAME opensmt-split NO_SYSTEM_FROM_IMPORTED true VERSION ${OPENSMT_VERSION} ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib" ) target_link_libraries(OpenSMT-splitter-static PUBLIC OpenSMT-static parallel) install(TARGETS OpenSMT-splitter-static ARCHIVE DESTINATION lib) endif() install(FILES SplitterInterpret.h DESTINATION ${INSTALL_HEADERS_DIR}) #build splitter executable********************************************************************************************** if (BUILD_EXECUTABLES) add_executable(OpenSMT-bin-splitter opensmtSplitter.cc) set_target_properties(OpenSMT-bin-splitter PROPERTIES NO_SYSTEM_FROM_IMPORTED true OUTPUT_NAME opensmt-splitter RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}") if (ENABLE_LINE_EDITING) if (NOT USE_READLINE) find_package(LibEdit REQUIRED) target_link_libraries(OpenSMT-bin-splitter PUBLIC LibEdit::LibEdit) else() find_package(Readline REQUIRED) target_link_libraries(OpenSMT-bin-splitter PUBLIC Readline::Readline) endif() endif() #link splitter executable against OpenSMT-splitter-static, PTPLib and parallel library********************************** target_link_libraries(OpenSMT-bin-splitter PUBLIC OpenSMT-splitter-static) endif(BUILD_EXECUTABLES)opensmt-2.5.2/src/parallel/LookaheadSplitter.cc000066400000000000000000000040631445011647600215300ustar00rootroot00000000000000/* * Copyright (c) 2022, Antti Hyvarinen * Copyright (c) 2022, Seyedmasoud Asadzadeh * * SPDX-License-Identifier: MIT */ #include "LookaheadSplitter.h" LookaheadSMTSolver::LALoopRes LookaheadSplitter::solveLookahead() { auto [result, node] = buildAndTraverse(SplitBuildConfig(*this)); if (result == LALoopRes::unknown_final) { copySplits(*node); assert(static_cast(splitContext.getCurrentSplitCount()) == splitContext.splitTargetNumber()); } return result; } bool LookaheadSplitter::createSplitLookahead(LASplitNode & n) { // Create a split instance and add it to node n. assert(n.sd == nullptr); n.sd = std::make_unique(); SplitData& sd = *n.sd; printf("; Outputing an instance:\n; "); Lit p = lit_Undef; for (int i = 0; i < decisionLevel(); i++) { Lit l = trail[trail_lim[i]]; if (p != l) { // In cases where the LA solver couldn't propagate due to // literal being already assigned, the literal may be // duplicated. Do not report duplicates. printf("%s%d ", sign(l) ? "-" : "", var(l)); sd.addConstraint({l}); } p = l; } printf("\n"); assert(ok); return true; } void LookaheadSplitter::copySplits(LASplitNode const & root) { vec queue; queue.push(&root); Map seen; // This is buggy: We need to pop the instances once all their children have been processed. while (queue.size() != 0) { LASplitNode const * n = queue.last(); if (!seen.has(n)) { seen.insert(n, true); if (n->c1 != nullptr) { assert(n->c2 != nullptr); queue.push(n->getC1()); queue.push(n->getC2()); } continue; } queue.pop(); if (n->sd != nullptr) splitContext.insertSplitData(std::move(*n->sd)); } } opensmt-2.5.2/src/parallel/LookaheadSplitter.h000066400000000000000000000047061445011647600213760ustar00rootroot00000000000000/* * Copyright (c) 2022, Antti Hyvarinen * Copyright (c) 2022, Seyedmasoud Asadzadeh * * SPDX-License-Identifier: MIT */ #ifndef PARALLEL_LOOKAHEADSPLITTER_H #define PARALLEL_LOOKAHEADSPLITTER_H #include "LookaheadSMTSolver.h" #include "SplitData.h" #include "Splitter.h" static inline int getLog2Ceil(int i) { if (i == 0 || i == 1) return 0; int r = 0; int j = i; while (i >>= 1) r++; if ((1 << r) ^ j) r++; return r; } class LookaheadSplitter : public LookaheadSMTSolver, public Splitter { public: LookaheadSplitter(SMTConfig& c, THandler& thandler, PTPLib::net::Channel & ch) : LookaheadSMTSolver(c, thandler) , Splitter(c, ch) {} protected: LALoopRes solveLookahead() override; class LASplitNode : public LookaheadSMTSolver::LANode { static inline unsigned numNodes = 0; unsigned id; public: LASplitNode() : id(numNodes++) {} std::unique_ptr sd; LASplitNode * getParent() override { return (LASplitNode*)p; } unsigned getId() const { return id; } void print_local() const override { LANode::print_local(); for (int i = 0; i < d; i++) dprintf(STDERR_FILENO, " "); dprintf(STDERR_FILENO, "%s\n", sd == nullptr ? "no instance" : "has instance" ); } LASplitNode const * getC1() const { return (LASplitNode*) c1.get(); } LASplitNode const * getC2() const { return (LASplitNode*) c2.get(); } struct Hash { uint32_t operator ()(LASplitNode const * p) const { return (uint32_t)p->getId(); } }; }; void copySplits(LASplitNode const & root); bool createSplitLookahead(LASplitNode &); struct SplitBuildConfig { private: LookaheadSplitter & splitter; public: bool stopCondition(LASplitNode & n, int num_split) { int maxDepth = getLog2Ceil(num_split); if (n.d == maxDepth) { #ifdef LADEBUG printf("Producing a split:\n");; printTrace(); #endif splitter.createSplitLookahead(n); return true; } return false; } LALoopRes exitState() const { return LALoopRes::unknown_final; } SplitBuildConfig(LookaheadSplitter & splitter_) : splitter(splitter_) {} }; }; #endif //PARALLEL_LOOKAHEADSPLITTER_H opensmt-2.5.2/src/parallel/MainSplitter.cc000066400000000000000000000155601445011647600205310ustar00rootroot00000000000000/* * Copyright (c) 2022, Antti Hyvarinen * Copyright (c) 2022, Seyedmasoud Asadzadeh * * SPDX-License-Identifier: MIT */ #include "MainSplitter.h" #include "VerificationUtils.h" void MainSplitter::notifyResult(sstat const & result) { if (result != s_Undef) { getChannel().setShallStop(); getChannel().notify_all(); } } sstat MainSplitter::check() { if (getChannel().isSolverInParallelMode() and not config.sat_solver_limit()) { //push frames size should match with length of the solver branch if (frames.size() != static_cast(getSplitter().getSolverBranch().size() + 1)) throw PTPLib::common::Exception(__FILE__, __LINE__, ";assert: Inconsistency in push frames size and length of the solver address"); } sstat res = MainSolver::check(); notifyResult(res); status = res; return res; } sstat MainSplitter::solve_(vec & enabledFrames) { if (getChannel().isSolverInParallelMode() and not config.sat_solver_limit()) { vec> const & solverBranch = getSplitter().getSolverBranch(); if (enabledFrames.size() > solverBranch.size() + 1) { throw PTPLib::common::Exception(__FILE__, __LINE__, ";assert: inconsistency in solverBranch length and enabled_frame size: " + std::to_string(enabledFrames.size()) + " solverBranch size: " + std::to_string(solverBranch.size())); } for (int i = 0; i < enabledFrames.size(); i++) { if (i > 0) getSplitter().addBranchToFrameId(opensmt::span const>(solverBranch.begin(), i), enabledFrames[i].id); } } sstat res = MainSolver::solve_(enabledFrames); if (getSplitter().getSplits().size() >= 1 and res == s_False) throw PTPLib::common::Exception(__FILE__, __LINE__, ";assert: At least one split is created but splitter returned unsatisfiable."); return res; } sstat MainSplitter::solve() { sstat res = MainSolver::solve(); if (getSplitter().getSplits().size() >= 1 and res == s_False) throw PTPLib::common::Exception(__FILE__, __LINE__, ";assert: At least one split is created but splitter returned unsatisfiable"); return res; }; void MainSplitter::writeSplits(std::string const & baseName) const { assert(config.sat_split_type() != spt_none); auto const & splits = getSplitter().getSplits(); auto splitStrings = getPartitionClauses(); int i = 0; for (auto const &splitString : splitStrings) { auto zeroPadNumber = [](int number, unsigned long targetLength) { std::string s = std::to_string(number); return std::string(targetLength - std::min(targetLength, s.length()), '0') + s; }; std::string name = baseName + '-' + zeroPadNumber(i++, static_cast(std::log10(splits.size()))+1) + ".smt2"; std::ofstream outFile; outFile.open(name); if (outFile.is_open()) { outFile << "(assert " << splitString << ")\n"; outFile.close(); } else { throw OsmtApiException("Failed to open file " + name); } } } std::unique_ptr MainSplitter::createInnerSolver(SMTConfig & config, THandler & thandler, PTPLib::net::Channel & ch) { if (config.sat_split_type() == spt_scatter) { return std::make_unique(config, thandler, ch); } else if (config.sat_split_type() == spt_lookahead) { return std::make_unique(config, thandler, ch); } else { return MainSolver::createInnerSolver(config, thandler); } } bool MainSplitter::verifyPartitions(vec const & partitions) const { bool ok = true; std::string error; VerificationUtils verifier(logic); for (int i = 0; i < partitions.size(); i++) { for (int j = i + 1; j < partitions.size(); j++) { if (not verifier.impliesInternal(logic.mkAnd(partitions[i], partitions[j]), logic.getTerm_false())) { error += "[Partitions share models: (and " + logic.pp(partitions[i]) + " " + logic.pp(partitions[j]) + ") is satisfiable] "; ok = false; } } } vec partitionCoverageQuery; partitionCoverageQuery.capacity(partitions.size()); for (PTRef tr : partitions) { partitionCoverageQuery.push(logic.mkNot(tr)); } if (partitions.size() == config.sat_split_num()) { // The partitions need to cover the full search space, i.e., the conjunction of the negated partitions must be unsatisfiable if (not verifier.impliesInternal(logic.mkAnd(partitionCoverageQuery), logic.getTerm_false())) { error += "[Non-covering partitioning: " + logic.pp(logic.mkAnd(partitionCoverageQuery)) + " is satisfiable] "; ok = false; } } else { // The partial partitioning must be satisfiable if (verifier.impliesInternal(logic.mkOr(partitions), logic.getTerm_false())) { error += "[Unsatisfiable partial partitioning: " + logic.pp(logic.mkOr(partitions)) + "] "; ok = false; } else { // Removing the models of the partial partitions from the root instance must yield unsat if (not verifier.impliesInternal(logic.mkAnd(partitionCoverageQuery), logic.mkNot(root_instance.getRoot()))) { error += "[Non-covering partial partitioning: partial partitions do not contain all models of original instance] "; ok = false; } } } if (not ok) { std::cout << error << std::endl; throwWithLocationInfo(error); } return ok; } std::vector MainSplitter::getPartitionClauses() const { assert(not isSplitTypeNone()); auto const & splits = getSplitter().getSplits(); vec partitionsTr; partitionsTr.capacity(splits.size()); for (auto const &split : splits) { auto conj_vec = addToConjunction(split.splitToPtAsgns(*thandler)); partitionsTr.push(logic.mkAnd(conj_vec)); } std::vector partitions; for (PTRef trWithAuxVars : partitionsTr) { PTRef tr = logic.removeAuxVars(trWithAuxVars); partitions.push_back(logic.dumpWithLets(tr)); } assert(verifyPartitions(partitionsTr)); return partitions; } vec MainSplitter::addToConjunction(std::vector> const & in) const { vec out; for (const auto & constr : in) { vec disj_vec; for (const auto & pta : constr) { disj_vec.push(pta.sgn == l_True ? pta.tr : logic.mkNot(pta.tr)); } out.push(logic.mkOr(std::move(disj_vec))); } return out; }opensmt-2.5.2/src/parallel/MainSplitter.h000066400000000000000000000044311445011647600203660ustar00rootroot00000000000000/* * Copyright (c) 2022, Antti Hyvarinen * Copyright (c) 2022, Seyedmasoud Asadzadeh * * SPDX-License-Identifier: MIT */ #ifndef PARALLEL_MAINSPLITTER_H #define PARALLEL_MAINSPLITTER_H #include "MainSolver.h" #include "SplitData.h" #include "ScatterSplitter.h" #include "OsmtInternalException.h" #include "LookaheadSplitter.h" #include "Splitter.h" #include class MainSplitter : public MainSolver { private: inline bool isSplitTypeScatter() const & { return dynamic_cast(ts.solver).isSplitTypeScatter(); } inline bool isSplitTypeNone() const & { return dynamic_cast(ts.solver).isSplitTypeNone(); } inline PTPLib::net::Channel & getChannel() const { return getSplitter().getChannel(); } inline ScatterSplitter & getScatterSplitter() { return dynamic_cast(getSMTSolver()); } inline Splitter & getSplitter() const { return dynamic_cast(ts.solver); } void notifyResult(sstat const & result); vec addToConjunction(std::vector> const &) const; sstat solve_(vec & enabledFrames) override; sstat check() override; void throwWithLocationInfo(std::string const & str) const { std::scoped_lock s_lk(getChannel().getMutex()); throw OsmtInternalException(getChannel().get_current_header().at(PTPLib::common::Param.NODE + " " + str)); } bool verifyPartitions(vec const & partitions) const; public: MainSplitter(std::unique_ptr t,std::unique_ptr tm, std::unique_ptr th, std::unique_ptr ss, Logic & logic, SMTConfig & config, std::string name) : MainSolver(std::move(t), std::move(tm), std::move(th), std::move(ss),logic,config, std::move(name)) {} sstat solve(); std::vector getPartitionClauses() const; void writeSplits(std::string const &) const; static std::unique_ptr createInnerSolver(SMTConfig &, THandler &, PTPLib::net::Channel &); inline TermMapper& getTermMapper() const { return *term_mapper;} }; #endif //PARALLEL_MAINSPLITTER_H opensmt-2.5.2/src/parallel/ScatterSplitter.cc000066400000000000000000000350121445011647600212440ustar00rootroot00000000000000/* * Copyright (c) 2022, Antti Hyvarinen * Copyright (c) 2022, Seyedmasoud Asadzadeh * * SPDX-License-Identifier: MIT */ #include "ScatterSplitter.h" #include "Random.h" #include "TreeOps.h" ScatterSplitter::ScatterSplitter(SMTConfig & c, THandler & t, PTPLib::net::Channel & ch) : SimpSMTSolver (c, t) , Splitter (c, ch) , nodeCounter (t.getLogic(), PTPLib::common::STATS.MAX_SIZE) {} bool ScatterSplitter::branchLitRandom() { return ((not splitContext.isInSplittingCycle() and opensmt::drand(random_seed) < random_var_freq) or (splitContext.isInSplittingCycle() and splitContext.preferRandom())) and not order_heap.empty(); } Var ScatterSplitter::doActivityDecision() { vec discarded; Var next = var_Undef; while (next == var_Undef || value(next) != l_Undef || !decision[next]) { if (order_heap.empty()) { if (discarded.size() > 0) { assert(splitContext.isInSplittingCycle()); assert([&]() { for (Var v : discarded) { if (not isAssumptionVar(v)) { throw PTPLib::common::Exception(__FILE__,__LINE__,";unable to split: all available variables have too long representations"); } } return true; }()); // All available literals are assumption literals. Instance is satisfiable } else { next = var_Undef; } break; } else { next = order_heap.removeMin(); if (splitContext.isInSplittingCycle() && next != var_Undef) { if (isAssumptionVar(next)) { discarded.push(next); next = var_Undef; } else { // Do not branch on lengthy variables to avoid oversized terms. // Note: for better performance, term is filter in two phases, without and with auxes PTRef auxTerm = theory_handler.varToTerm(next); nodeCounter.visit(auxTerm); if (nodeCounter.limitReached()) { discarded.push(next); next = var_Undef; } else { PTRef auxExpandedTerm = theory_handler.getLogic().removeAuxVars(auxTerm); nodeCounter.visit(auxExpandedTerm); if (nodeCounter.limitReached()) { discarded.push(next); next = var_Undef; } } } } } } for (Var v : discarded) order_heap.insert(v); return next; } bool ScatterSplitter::scatterLevel() { int d; int currentSplitNum = static_cast(splitContext.getCurrentSplitCount()); int targetSplitNum = splitContext.splitTargetNumber(); int splitsToDo = targetSplitNum - currentSplitNum; assert(splitsToDo > 0); // Current scattered instance number i = splits.size() + 1 float r = 1/(float)(splitsToDo); for (int i = 1; ; i++) { // 2 << i == 2^(i+1) if ((2 << (i-1) <= splitsToDo) && (2 << i >= splitsToDo)) { // r-1(2^i) < 0 and we want absolute d = -(r-1/(float)(2<<(i-1))) > r-1/(float)(2< ScatterSplitter::createSplitAndBlockAssumptions() { SplitData splitData; vec constraints_negated; // Add the literals on the decision levels. for (int i = assumptions.size(); i < decisionLevel(); i++) { Lit l = trail[trail_lim[i]]; // Remember this literal in the split assumptions vector of the // SAT solver splitData.addSplitAssumptions(vec{l}); // This will be added to the SAT formula to exclude the search // space constraints_negated.push(~l); } for (SplitData const & previousSplit : splitContext.getSplits()) { auto const & previousAssumptions = previousSplit.peekSplitAssumptions(); vec tmp; for (auto const & clause : previousAssumptions) { assert(clause.size() == 1); tmp.push(~clause[0]); } splitData.addConstraint(std::move(tmp)); } cancelUntil(0); lbool res = excludeAssumptions(constraints_negated) ? l_Undef : l_False; return {std::move(splitData), res}; } bool ScatterSplitter::excludeAssumptions(vec const & neg_constrs) { addOriginalClause(neg_constrs); simplify(); return ok; } bool ScatterSplitter::okContinue() const { if (splitContext.solverLimit() and splitContext.solverLimit() == search_counter and not config.sat_split_mode()) { return false; } else if (getChannel().shouldStop()) { return false; } else if (conflicts % 1000 == 0 and splitContext.resourceLimitReached(search_counter)) { getChannel().setShouldStop(); return false; } else if (static_cast(splitContext.getCurrentSplitCount()) == splitContext.splitTargetNumber() - 1) { return false; } return true; } void ScatterSplitter::notifyEnd() { if (splitContext.solverLimit() and not config.sat_split_mode()) return; if (isSplitTypeScatter()) { auto[data, result] = createSplitAndBlockAssumptions(); splitContext.insertSplitData(std::move(data)); if (result != l_False) throw PTPLib::common::Exception(__FILE__, __LINE__, ";assert: Instance not unsatisfiable after creating last partition."); } getChannel().setShouldStop(); } lbool ScatterSplitter::solve_() { if (decisionLevel() != 0) throw PTPLib::common::Exception(__FILE__, __LINE__, ";assert: decision level is not zero at the start of the search!"); if (isSplitTypeScatter()) { splitContext.reset(search_counter); splitContext.enterInitCycle(search_counter); } return CoreSMTSolver::solve_(); } lbool ScatterSplitter::zeroLevelConflictHandler() { if (splitContext.hasSplits()) { getChannel().setShouldStop(); return l_Undef; } else { return CoreSMTSolver::zeroLevelConflictHandler(); } } CoreSMTSolver::ConsistencyAction ScatterSplitter::notifyConsistency() { if (splitContext.solverLimit() and not config.sat_split_mode()) return ConsistencyAction::NoOp; if (not splitContext.isInSplittingCycle() and splitContext.shouldEnterSplittingCycle(search_counter)) { splitContext.enterSplittingCycle(); return ConsistencyAction::BacktrackToZero; } if (splitContext.isInSplittingCycle() and scatterLevel()) { auto[data, result] = createSplitAndBlockAssumptions(); splitContext.insertSplitData(std::move(data)); if (result == l_False) { // Rest is unsat getChannel().setShouldStop(); return ConsistencyAction::ReturnUndef; } else { splitContext.enterTuningCycle(search_counter); return ConsistencyAction::SkipToSearchBegin; } } return ConsistencyAction::NoOp; } void ScatterSplitter::exposeUnitClauses(std::vector & learnedLemmas) { int trail_max = trail_lim.size() == 0 ? trail.size() : trail_lim[0]; trail_sent = std::max(trail_sent, numTriviallyPropagatedOnDl0-1); assert(trail_sent >= 0); auto & logic = theory_handler.getLogic(); int numUnitClauses = trail_max - trail_sent; int unitClauseIncrement = std::max(1, (numUnitClauses)/100); for (int i = this->trail_sent; i < trail_max; i+=unitClauseIncrement) { Lit l = trail[i]; Var v = var(l); if (isAssumptionVar(v)) { continue; } auto ptWithAuxVars = sign(l) ? logic.mkNot(theory_handler.varToTerm(v)) : theory_handler.varToTerm(v); // Note: for better performance, term is filter in two phases, without and with auxes nodeCounter.visit(ptWithAuxVars); if (nodeCounter.limitReached()) { continue; } PTRef pt = theory_handler.getLogic().removeAuxVars(ptWithAuxVars); nodeCounter.visit(pt); if (nodeCounter.limitReached()) continue; std::string str = logic.dumpWithLets(pt); assert([&](std::string_view clause_str) { if (clause_str.find(".frame") != std::string::npos) { throw PTPLib::common::Exception(__FILE__, __LINE__,"assert: frame caught in trail"); } return true; }(str)); learnedLemmas.emplace_back(PTPLib::net::Lemma(str, 0)); } trail_sent = trail_max; } void ScatterSplitter::exposeLongerClauses(std::vector & learnedLemmas) { auto & logic = theory_handler.getLogic(); for (CRef cr : learnts) { Clause &c = this->ca[cr]; if (c.size() > static_cast(3 + assumptions.size()) || c.mark() == 3) continue; int level = 0; vec clause; bool hasForeignAssumption = false; bool hasBulkyLit = false; for (Lit l : c) { Var v = var(l); PTRef ptWithAuxVars = theory_handler.varToTerm(v); // Note: for better performance, term is filter in two phases, without and with auxes nodeCounter.visit(ptWithAuxVars); if (nodeCounter.limitReached()) { hasBulkyLit = true; break; } PTRef pt = theory_handler.getLogic().removeAuxVars(ptWithAuxVars); nodeCounter.visit(pt); if (nodeCounter.limitReached()) { hasBulkyLit = true; break; } if (isAssumptionVar(v)) { vec> const & solverBranch_perVar = getBranchOfVar(v); if (isPrefix(solverBranch_perVar, getSolverBranch())) { int result = solverBranch_perVar.size(); assert([&]() { if (result <= 0) { std::scoped_lock s_lk(getChannel().getMutex()); throw PTPLib::common::Exception(__FILE__, __LINE__, ";assert: level is less than zero " + getChannel().get_current_header().at(PTPLib::common::Param.NODE)+ std::to_string(result)); } if (result > getSolverBranch().size()) { std::scoped_lock s_lk(getChannel().getMutex()); throw PTPLib::common::Exception(__FILE__, __LINE__, ";assert: level is greater than solver address length " + getChannel().get_current_header().at(PTPLib::common::Param.NODE)+ std::to_string(result)); } return true; }()); level = std::max(level, result); continue; } else { hasForeignAssumption = true; break; } // Second algorithm of how to correctly publish clauses so that they do not include assumption literals. // https://github.com/usi-verification-and-security/opensmt/issues/499 // auto getAssumptionLevel = [this](Var const & v) { // assert(isAssumptionVar(v)); // int level = 0; // for (Lit p : assumptions) { // if (sign(p)) { // ++level; // if (var(p) == v) // return level; // } // } // return -1; // }; // int result = getAssumptionLevel(v); // if (result >= 1) { // level = std::max(level, result); // continue; // } else { // hasForeignAssumption = true; // break; // } } pt = sign(l) ? theory_handler.getLogic().mkNot(pt) : pt; clause.push(pt); } if (hasBulkyLit or hasForeignAssumption or clause.size() > 3) continue; std::string str = logic.dumpWithLets(theory_handler.getLogic().mkOr(clause)); learnedLemmas.emplace_back(PTPLib::net::Lemma(str, level)); assert([&](std::string_view clause_str) { if (clause_str.find(".frame") != std::string::npos) { throw PTPLib::common::Exception(__FILE__, __LINE__,";assert: frame caught in actual clauses"); } return true; }(str)); c.mark(3); } } bool ScatterSplitter::exposeClauses(std::vector & learnedLemmas) { exposeUnitClauses(learnedLemmas); exposeLongerClauses(learnedLemmas); return not learnedLemmas.empty(); } void ScatterSplitter::runPeriodic() { if (firstPropagation) { assert(decisionLevel() == 0); firstPropagation = false; numTriviallyPropagatedOnDl0 = trail.size(); } if (not getChannel().isClauseShareMode()) return; std::vector toPublishLemmas; if (getChannel().shouldLearnClauses()) { getChannel().clearShouldLearnClauses(); if (exposeClauses(toPublishLemmas)) { { std::unique_lock lk(getChannel().getMutex()); if (not lk.owns_lock()) { throw PTPLib::common::Exception(__FILE__, __LINE__, ";assert: clause Learning couldn't take the lock"); } getChannel().insert_learned_clause(std::move(toPublishLemmas)); } if (syncedStream) syncedStream->println(getChannel().isColorMode() ? PTPLib::common::Color::FG_Green : PTPLib::common::Color::FG_DEFAULT, "[t SEARCH ] -------------- add learned clauses to channel buffer, Size : ", toPublishLemmas.size()); } } } void ScatterSplitter::mapEnabledFrameIdToVar(Var v, uint32_t fid, uint32_t & prevId) { if (prevId != UINT32_MAX and fid <= prevId) { throw PTPLib::common::Exception(__FILE__, __LINE__,";assert: en_frame order is not increasing"); } prevId = fid; var_frameId[v] = fid ; } vec> const & ScatterSplitter::getBranchOfVar(Var v) { return frameIdToSolverBranch[get_FrameId(v)]; }opensmt-2.5.2/src/parallel/ScatterSplitter.h000066400000000000000000000071371445011647600211150ustar00rootroot00000000000000/* * Copyright (c) 2022, Antti Hyvarinen * Copyright (c) 2022, Seyedmasoud Asadzadeh * * SPDX-License-Identifier: MIT */ #ifndef PARALLEL_SCATTERSPLITTER_H #define PARALLEL_SCATTERSPLITTER_H #include "SimpSMTSolver.h" #include "SplitData.h" #include "SplitContext.h" #include "Splitter.h" #include "TreeOps.h" #include #include #include class ScatterSplitter : public SimpSMTSolver, public Splitter { public: ScatterSplitter(SMTConfig & c, THandler & t, PTPLib::net::Channel & ch); void set_syncedStream(PTPLib::common::synced_stream & ss) { syncedStream = &ss; } //SMTS Client owns the SyncedStream and should directly set the SyncedStream void enterSplittingCycle() { splitContext.enterSplittingCycle(); } bool isSplitTypeNone() const { return splitContext.isSplitTypeNone(); } void resetSplitType() { splitContext.resetSplitType(); } void setSplitTypeScatter() { splitContext.setSplitTypeScatter(); } int getSplitTypeValue() const { return splitContext.getSplitTypeValue(); } int getSearchCounter() const { return search_counter; } void mapEnabledFrameIdToVar(Var v, uint32_t fid, uint32_t & prevId) override; private: int trail_sent = 0; bool firstPropagation = true; int numTriviallyPropagatedOnDl0 = 0; using map_var_frameId = std::map; map_var_frameId var_frameId; std::unordered_set assumptionVars; PTPLib::common::synced_stream * syncedStream = nullptr; PtermNodeCounter nodeCounter; void runPeriodic() override; // Check if solver is in clause share mode to starts clause exposing operation protected: bool scatterLevel(); // Are we currently on a scatter level. opensmt::pair createSplitAndBlockAssumptions(); // Create a split formula and place it to the splits vector. bool excludeAssumptions(vec const & neg_constrs); // Add a clause to the database and propagate bool isAssumptionVar(Var v) const { return assumptionVars.find(v) != assumptionVars.end(); } lbool solve_() override; bool branchLitRandom() override; Var doActivityDecision() override; bool okContinue() const override; ConsistencyAction notifyConsistency() override; void notifyEnd() override; lbool zeroLevelConflictHandler() override; // Common handling of zero-level conflict as it can happen at multiple places void exposeUnitClauses(std::vector & learnedLemmas); void exposeLongerClauses(std::vector & learnedLemmas); bool exposeClauses(std::vector & learnedLemmas); bool isPrefix(const vec> & prefix, const vec> & full) { if (prefix.size() > full.size()) return false; for (int i = 0; i < prefix.size(); ++i) { if (prefix[i].first != full[i].first or prefix[i].second != full[i].second) return false; } return true; } uint32_t get_FrameId(Var v) { return var_frameId[v]; } void addAssumptionVar(Var v) override { assumptionVars.insert(v); } vec> const & getBranchOfVar(Var v); }; #endif //PARALLEL_SCATTERSPLITTER_Hopensmt-2.5.2/src/parallel/SplitContext.h000066400000000000000000000112511445011647600204110ustar00rootroot00000000000000/* * Copyright (c) 2022, Antti Hyvarinen * Copyright (c) 2022, Seyedmasoud Asadzadeh * * SPDX-License-Identifier: MIT */ #ifndef PARALLEL_SPLITCONTEXT_H #define PARALLEL_SPLITCONTEXT_H #include "SMTConfig.h" #include "SystemQueries.h" class SplitContext { SMTConfig const & config; SpUnit resource_units; double resource_limit; // Time limit for the search in resource_units double next_resource_limit; // The limit at which the solver needs to stop // splitting state vars SpType split_type; int solver_limit; bool split_on; int split_num; SpUnit split_units; double initTune; // Initial tuning in units. double midTune; // mid-tuning in units. double split_next; // When the next split will happen? SpPref split_preference; bool resourceLimitEnabled() const { return resource_limit >= 0; } bool useTimeAsResourceLimit() const { return resource_units == SpUnit::time; } bool useTimeAsSplitLimit() const { return split_units == SpUnit::time; } bool splitLimitReached(uint64_t search_counter) const { return useTimeAsSplitLimit() ? (cpuTime() >= split_next) : (search_counter >= split_next); } void setNextSplitLimit(uint64_t search_counter, double tuneLimit) { auto split_baseline = (useTimeAsSplitLimit()) ? cpuTime() : static_cast(search_counter); split_next = split_baseline + std::max(0.0, tuneLimit); } std::vector splits; public: std::size_t getCurrentSplitCount() const { return splits.size(); } std::size_t getCurrentSplitAssumptionsCount(std::size_t i) { return splits[i].getSplitAssumptions().size(); } bool hasSplits() const { return not splits.empty(); } void enterInitCycle(uint64_t search_counter) { split_on = false; setNextSplitLimit(search_counter, initTune); } void enterTuningCycle(uint64_t search_counter) { split_on = false; setNextSplitLimit(search_counter, midTune); } void enterSplittingCycle() { split_on = true; } bool shouldEnterSplittingCycle(uint64_t search_counter) const { return splitLimitReached(search_counter); } bool isInSplittingCycle() const { return split_on; } int solverLimit() const { return solver_limit; } int splitTargetNumber() const { return split_num; } void insertSplitData(SplitData && data) { splits.emplace_back(std::move(data)); } std::vector const & getSplits() const { return splits; } bool preferRandom() const { return split_preference == sppref_rand; } bool isSplitTypeScatter() const { return split_type == spt_scatter; } bool isSplitTypeLookahead() const { return split_type == spt_lookahead; } bool isSplitTypeNone() const { return split_type == spt_none; } void resetSplitType() { split_type = spt_none; } void setSplitTypeScatter() { split_type = spt_scatter; } int getSplitTypeValue() const & { return split_type.t; } bool resourceLimitReached(uint64_t search_counter) const { if (resourceLimitEnabled()) { if (useTimeAsResourceLimit()) { return time(nullptr) >= next_resource_limit; } else { return search_counter >= next_resource_limit; } } return false; } void setNextResourceLimit(uint64_t search_counter) { if (resource_limit == -1) { return; } next_resource_limit = useTimeAsResourceLimit() ? cpuTime() + resource_limit : search_counter + resource_limit; } void reset(uint64_t search_counter) { assert(config.sat_split_units() == SpUnit::time or config.sat_split_units() == SpUnit::search_counter); assert(config.sat_resource_units() == SpUnit::time or config.sat_resource_units() == SpUnit::search_counter); resource_units = config.sat_resource_units(); resource_limit = config.sat_resource_limit(); setNextResourceLimit(search_counter); split_type = config.sat_split_type(); split_on = false; split_num = config.sat_split_num(); split_units = config.sat_split_units(); initTune = config.sat_split_inittune(); midTune = config.sat_split_midtune(); split_next = split_units == SpUnit::time ? initTune + cpuTime() : initTune + search_counter; split_preference = config.sat_split_preference(); solver_limit = config.sat_solver_limit(); } SplitContext(const SMTConfig & config) : config(config) { reset(0); } }; #endif //PARALLEL_SPLITCONTEXT_H opensmt-2.5.2/src/parallel/SplitData.h000066400000000000000000000034611445011647600176420ustar00rootroot00000000000000/* * Copyright (c) 2022, Antti Hyvarinen * Copyright (c) 2022, Seyedmasoud Asadzadeh * * SPDX-License-Identifier: MIT */ #ifndef PARALLEL_SPLITDATA_H #define PARALLEL_SPLITDATA_H #include "SolverTypes.h" #include "THandler.h" // ----------------------------------------------------------------------------------------- // The splits // class SplitData { std::vector> constraints; // The constraints are the assumptions from previous splits std::vector> split_assumptions; // The assumptions in this split static void addClausesToPtAsgns(std::vector> & out, std::vector> const & in, THandler const & thandler) { for (vec const & c : in) { vec outClause; outClause.capacity(c.size()); for (Lit l : c) { PTRef tr = thandler.varToTerm(var(l)); PtAsgn pta(tr, sign(l) ? l_False : l_True); outClause.push(pta); } out.push_back(std::move(outClause)); } } public: void addConstraint(vec && c) { constraints.emplace_back(std::move(c)); } void addSplitAssumptions(vec && sa) { split_assumptions.emplace_back(std::move(sa)); } [[nodiscard]] std::vector> splitToPtAsgns(THandler const & thandler) const { std::vector> out; addClausesToPtAsgns(out, constraints, thandler); addClausesToPtAsgns(out, split_assumptions, thandler); return out; } std::vector> & getSplitAssumptions() { return split_assumptions; } [[nodiscard]] std::vector> const & peekSplitAssumptions() const { return split_assumptions; } }; #endif //PARALLEL_SPLITDATA_H opensmt-2.5.2/src/parallel/Splitter.cc000066400000000000000000000013041445011647600177130ustar00rootroot00000000000000/* * Copyright (c) 2022, Antti Hyvarinen * Copyright (c) 2022, Seyedmasoud Asadzadeh * * SPDX-License-Identifier: MIT */ #include "Splitter.h" void Splitter::addBranchToFrameId(opensmt::span const> && solver_branch, uint32_t fid) { vec> addrVector; addrVector.capacity(solver_branch.size()); for (auto el : solver_branch) { addrVector.push(el); } mapSolverBranchToFrameId(fid, std::move(addrVector)); } void Splitter::mapSolverBranchToFrameId(uint32_t fid, vec> && solverAddress) { frameIdToSolverBranch[fid] = std::move(solverAddress); }opensmt-2.5.2/src/parallel/Splitter.h000066400000000000000000000035251445011647600175640ustar00rootroot00000000000000/* * Copyright (c) 2022, Antti Hyvarinen * Copyright (c) 2022, Seyedmasoud Asadzadeh * * SPDX-License-Identifier: MIT */ #ifndef PARALLEL_SPLITTER_H #define PARALLEL_SPLITTER_H #include "SplitData.h" #include "SplitContext.h" #include class Splitter { private: vec> solverBranch; protected: SplitContext splitContext; PTPLib::net::Channel & channel; using map_frameId_solverBranch = std::map>>; map_frameId_solverBranch frameIdToSolverBranch; using map_var_frameId = std::map; map_var_frameId varToFrameId; public: Splitter(SMTConfig & c, PTPLib::net::Channel & ch) : splitContext(c) , channel(ch) {} std::vector const & getSplits() { return splitContext.getSplits(); } bool isSplitTypeScatter() const { return splitContext.isSplitTypeScatter(); } bool isSplitTypeLookahead() const { return splitContext.isSplitTypeLookahead(); } bool isSplitTypeNone() const { return splitContext.isSplitTypeNone(); } void resetSplitType() { splitContext.resetSplitType(); } PTPLib::net::Channel & getChannel() const { return channel; } inline void setSolverBranch(vec> && vec) { solverBranch = std::move(vec); } void addBranchToFrameId(opensmt::span const> && solver_branch, uint32_t fid); void mapSolverBranchToFrameId(uint32_t fid, vec> && solverAddress); vec> const & getSolverBranch() const { return solverBranch; } }; #endif //PARALLEL_SPLITTER_H opensmt-2.5.2/src/parallel/SplitterInterpret.cc000066400000000000000000000044551445011647600216220ustar00rootroot00000000000000/* * Copyright (c) 2022, Antti Hyvarinen * Copyright (c) 2022, Seyedmasoud Asadzadeh * * SPDX-License-Identifier: MIT */ #include "SplitterInterpret.h" /*********************************************************** * Class defining Splitter-Interpreter * Usage: Parallel solver ***********************************************************/ void SplitterInterpret::writeSplits(const char* filename) { try { dynamic_cast(getMainSolver()).writeSplits(filename); } catch (OsmtApiException const & e) { std::cout << "While writing splits: " << e.what() << std::endl; } } sstat SplitterInterpret::checkSat() { if (not search) return s_Undef; char* name = config.dump_state(); sstat res = Interpret::checkSat(); if (res == s_Undef and strcmp(config.output_dir(),"") != 0) { writeSplits(name); } return res; } sstat SplitterInterpret::interpSMTContent(char *content, vec> && vec, bool shouldUpdateSolverBranch, bool s) { search = s; if (shouldUpdateSolverBranch) getSplitter().setSolverBranch(std::forward<::vec>>(vec)); int rval = Interpret::interpFile(content); if (rval != 0) return s_Error; else return getMainSplitter().getStatus(); } std::unique_ptr SplitterInterpret::createMainSolver(const char* logic_name) { if (config.sat_split_type() != spt_none) { auto th = MainSolver::createTheory(*logic, config); auto tm = std::make_unique(*logic); auto thandler = new THandler(*th, *tm); return std::make_unique(std::move(th), std::move(tm), std::unique_ptr(thandler), MainSplitter::createInnerSolver(config, *thandler, channel), *logic, config, std::string(logic_name) + " splitter"); } else return std::make_unique(*logic, config, std::string(logic_name) + " solver"); } opensmt-2.5.2/src/parallel/SplitterInterpret.h000066400000000000000000000025471445011647600214640ustar00rootroot00000000000000/* * Copyright (c) 2022, Antti Hyvarinen * Copyright (c) 2022, Seyedmasoud Asadzadeh * * SPDX-License-Identifier: MIT */ #ifndef PARALLEL_SPLITTERINTERPRET_H #define PARALLEL_SPLITTERINTERPRET_H #include "MainSplitter.h" #include "Interpret.h" class SplitterInterpret : public Interpret { private: PTPLib::net::Channel & channel; bool search = true; protected: void writeSplits(const char* filename); std::unique_ptr createMainSolver(const char* logic_name) override; sstat checkSat() override; void exit() override { return; } public: SplitterInterpret(SMTConfig & c, PTPLib::net::Channel & ch) : Interpret(c) , channel(ch) { } virtual ~SplitterInterpret() = default; sstat interpSMTContent(char *content, vec> &&, bool, bool); inline MainSplitter & getMainSplitter() { return dynamic_cast(getMainSolver()); }; inline Splitter & getSplitter() { return dynamic_cast(getMainSplitter().getSMTSolver()); } }; #endif //PARALLEL_SPLITTERINTERPRET_H opensmt-2.5.2/src/parallel/opensmtSplitter.cc000066400000000000000000000164371445011647600213360ustar00rootroot00000000000000/* * Copyright (c) 2022, Antti Hyvarinen * Copyright (c) 2022, Seyedmasoud Asadzadeh * * SPDX-License-Identifier: MIT */ #include "SplitterInterpret.h" #include #include #include #include #include #define opensmt_error_() { std::cerr << "# Error (triggered at " << __FILE__ << ", " << __LINE__ << ")" << std::endl; assert(false); ::exit( 1 ); } #define opensmt_error( S ) { std::cerr << "; Error: " << S << " (triggered at " << __FILE__ << ", " << __LINE__ << ")" << std::endl; ::exit( 1 ); } #define opensmt_error2( S, T ) { std::cerr << "; Error: " << S << " " << T << " (triggered at " << __FILE__ << ", " << __LINE__ << ")" << std::endl; ::exit( 1 ); } #ifdef ENABLE_LINE_EDITING #if !defined(USE_READLINE) #include #else #include #include #endif #endif // ENABLE_LINE_EDITING #if defined(__GLIBC__) #include #endif namespace opensmt { void catcher ( int ); } /*****************************************************************************\ * * * MAIN * * * \*****************************************************************************/ void interpretInteractive(SplitterInterpret & interpret); int main( int argc, char * argv[] ) { signal( SIGTERM, opensmt::catcher ); signal( SIGINT , opensmt::catcher ); // // This trick (copied from Main.C of MiniSAT) is to allow // the repeatability of experiments that might be compromised // by the floating point unit approximations on doubles // #if defined(__GLIBC__) fpu_control_t oldcw, newcw; _FPU_GETCW(oldcw); newcw = (oldcw & ~_FPU_EXTENDED) | _FPU_DOUBLE; _FPU_SETCW(newcw); #endif #ifdef PEDANTIC_DEBUG cerr << "; pedantic assertion checking enabled (very slow)" << endl; #endif #ifndef NDEBUG std::cerr << "; this binary is compiled in debug mode (slow)" << std::endl; #endif // Accepts file from stdin if nothing specified FILE * fin = NULL; int opt; SMTConfig c; bool pipe = false; while ((opt = getopt(argc, argv, "hdpir:")) != -1) { switch (opt) { case 'h': // context.getConfig( ).printHelp( ); break; case 'd': const char* msg; c.setOption(SMTConfig::o_dryrun, SMTOption(true), msg); break; case 'r': if (!c.setOption(SMTConfig::o_random_seed, SMTOption(atoi(optarg)), msg)) fprintf(stderr, "Error setting random seed: %s\n", msg); else fprintf(stderr, "; Using random seed %d\n", atoi(optarg)); break; case 'i': c.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); break; case 'p': pipe = true; break; default: /* '?' */ fprintf(stderr, "Usage:\n\t%s [-d] [-h] [-r seed] filename [...]\n", argv[0]); return 0; } } auto channel = std::make_unique>(); SplitterInterpret interpreter(c, *channel); if (argc - optind == 0) { c.setInstanceName("stdin"); if (pipe) { interpreter.interpPipe(); } else { interpretInteractive(interpreter); } } else { for (int i = optind; i < argc; i++) { const char * filename = argv[i]; assert( filename ); c.setInstanceName(filename); if ( strncmp( filename, "--", 2 ) == 0 || strncmp( filename, "-", 1 ) == 0 ) { opensmt_error( "input file must be last argument" ); } else if ( (fin = fopen( filename, "rt" )) == NULL ) opensmt_error( "can't open file" ); const char * extension = strrchr( filename, '.' ); if ( extension != NULL && strcmp( extension, ".smt" ) == 0 ) { opensmt_error( "SMTLIB 1.2 format is not supported in this version, sorry" ); } else if ( extension != NULL && strcmp( extension, ".smt2" ) == 0 ) { interpreter.interpFile(fin); } else opensmt_error2( filename, " extension not recognized. Please use one in { smt2, cnf } or stdin (smtlib2 is assumed)" ); } fclose( fin ); } return 0; } #ifndef ENABLE_LINE_EDITING void interpretInteractive(SplitterInterpret & interpret) { interpret.interpPipe(); } #else void interpretInteractive(SplitterInterpret & interpret) { char* line_read = nullptr; bool done = false; int par = 0; int pb_cap = 1; int pb_sz = 0; char *parse_buf = (char *) malloc(pb_cap); while (!done) { if (line_read) { free(line_read); line_read = nullptr; } if (par == 0) line_read = readline("> "); else if (par > 0) line_read = readline("... "); else { interpret.reportError("interactive reader: unbalanced parentheses"); parse_buf[pb_sz-1] = 0; // replace newline with end of string add_history(parse_buf); pb_sz = 0; par = 0; } if (line_read && *line_read) { for (int i = 0; line_read[i] != '\0'; i++) { char c = line_read[i]; if (c == '(') par ++; if (c == ')') par --; while (pb_cap - 2 < pb_sz) { // the next char and terminating zero pb_cap *= 2; parse_buf = (char*) realloc(parse_buf, pb_cap); } parse_buf[pb_sz ++] = c; } if (par == 0) { parse_buf[pb_sz] = '\0'; // Parse starting from the command nonterminal // Parsing should be done from a string that I get from the readline // library. Smt2newContext context(parse_buf); int rval = smt2newparse(&context); if (rval != 0) interpret.reportError("scanner"); else { const ASTNode* r = context.getRoot(); interpret.execute(r); done = interpret.gotExit(); } add_history(parse_buf); pb_sz = 0; } else { // add the line break while (pb_cap - 2 < pb_sz) { // the next char and terminating zero pb_cap *= 2; parse_buf = (char*) realloc(parse_buf, pb_cap); } parse_buf[pb_sz ++] = '\n'; } } } if (parse_buf) free(parse_buf); if (line_read) free(line_read); } #endif namespace opensmt { void catcher( int sig ) { switch (sig) { case SIGINT: case SIGTERM: printf("Exit from signal\n"); exit(1); break; } } } // namespace opensmt opensmt-2.5.2/src/parsers/000077500000000000000000000000001445011647600154635ustar00rootroot00000000000000opensmt-2.5.2/src/parsers/CMakeLists.txt000066400000000000000000000010701445011647600202210ustar00rootroot00000000000000#add_library(parsers OBJECT "") # #find_package(BISON) #find_package(FLEX) # #BISON_TARGET(smt2newParser smt2new/smt2newparser.yy ${CMAKE_CURRENT_BINARY_DIR}/smt2new/smt2newparser.cc) #FLEX_TARGET(smt2newScanner smt2new/smt2newlexer.ll ${CMAKE_CURRENT_BINARY_DIR}/smt2new/smt2newlexer.cc) #ADD_FLEX_BISON_DEPENDENCY(smt2newScanner smt2newParser) # #target_sources(parsers # PUBLIC "smt2new/smt2newcontext.cc" # PUBLIC "smt2new/smt2newcontext.h" # PRIVATE ${BISON_smt2newParser_OUTPUTS} # PRIVATE ${FLEX_smt2newScanner_OUTPUTS} #) add_subdirectory(smt2new) opensmt-2.5.2/src/parsers/smt2new/000077500000000000000000000000001445011647600170625ustar00rootroot00000000000000opensmt-2.5.2/src/parsers/smt2new/CMakeLists.txt000066400000000000000000000017211445011647600216230ustar00rootroot00000000000000#target_sources(parsers #PUBLIC "${CMAKE_CURRENT_LIST_DIR}/smt2newcontext.h" #PUBLIC "${CMAKE_CURRENT_LIST_DIR}/smt2newparser.hh" #PRIVATE "${CMAKE_CURRENT_LIST_DIR}/smt2newcontext.cc" #PRIVATE "${CMAKE_CURRENT_LIST_DIR}/smt2newlexer.cc" #PRIVATE "${CMAKE_CURRENT_LIST_DIR}/smt2newparser.cc" #) add_library(parsers OBJECT "") find_package(BISON 3.0 REQUIRED) find_package(FLEX 2.6 REQUIRED) BISON_TARGET(smt2newParser smt2newparser.yy ${CMAKE_CURRENT_BINARY_DIR}/smt2newparser.cc) FLEX_TARGET(smt2newScanner smt2newlexer.ll ${CMAKE_CURRENT_BINARY_DIR}/smt2newlexer.cc) ADD_FLEX_BISON_DEPENDENCY(smt2newScanner smt2newParser) target_sources(parsers PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/smt2newcontext.cc" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/smt2newcontext.h" PRIVATE ${BISON_smt2newParser_OUTPUTS} PRIVATE ${FLEX_smt2newScanner_OUTPUTS} ) target_compile_options(parsers PRIVATE -Wno-error) install(FILES smt2newcontext.h DESTINATION ${INSTALL_HEADERS_DIR}) opensmt-2.5.2/src/parsers/smt2new/parsetest000077500000000000000000010462541445011647600210360ustar00rootroot00000000000000ELF>p@@(#@8 @(%@@@@@øø88@8@@@ô¸ô¸ ˜º˜º`˜º` 8 è½è½`è½`ÐÐTT@T@DDPåtdt¯t¯@t¯@´´QåtdRåtd˜º˜º`˜º`hh/lib64/ld-linux-x86-64.so.2GNUGNUFãC—|£g4{Ïù­ÿ P+!+(EÕL˜ CyIk¶ßb ®y  31\íÑ>ó‡n€lÈzí”rTK ÊØ¥¦ædDháü,õ @^ Ã`IP@__gmon_start___Jv_RegisterClasseslibstdc++.so.6_ZNKSt5ctypeIcE13_M_widen_initEv_ZNSo5flushEv_ZSt16__throw_bad_castv_ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l_ZNSt8__detail15_List_node_base7_M_hookEPS0__ZNSt8ios_base4InitD1Ev_ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate__gxx_personality_v0_ZSt4cout_Znwm_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6__ZNSo3putEc_ZNSt8ios_base4InitC1Evlibgcc_s.so.1_Unwind_Resumelibc.so.6getc__printf_chkfopenperror__stack_chk_failputcharreallocstdinstrdupisattystrlen__cxa_atexit__errno_locationclearerr__fprintf_chkstdoutmemcpyfclosemallocstderrfilenofwritefread__libc_start_mainferrorstpcpyfreeGCC_3.0CXXABI_1.3GLIBCXX_3.4.9GLIBCXX_3.4.15GLIBCXX_3.4.11GLIBCXX_3.4GLIBC_2.14GLIBC_2.4GLIBC_2.3.4GLIBC_2.2.5    P&y $`Ó¯k ‰)+eø—9aø—Ht)’W"”‘– cii nti xui „¸¿`À¿`+È¿`Ø¿`à¿`) Ã`,À`À`À`À` À`(À`0À` 8À` @À` HÀ` PÀ` XÀ``À`hÀ`pÀ`+xÀ`€À`ˆÀ`À`˜À` À`¨À`°À`¸À`ÀÀ`ÈÀ`ÐÀ`ØÀ`àÀ` èÀ`!ðÀ`"øÀ`#Á`$Á`-Á`%Á`& Á`'(Á`(0Á`*HƒìèƒèèiHƒÄÃÿ5º¯ ÿ%¼¯ @ÿ%º¯ héàÿÿÿÿ%²¯ héÐÿÿÿÿ%ª¯ héÀÿÿÿÿ%¢¯ hé°ÿÿÿÿ%š¯ hé ÿÿÿÿ%’¯ héÿÿÿÿ%Š¯ hé€ÿÿÿÿ%‚¯ hépÿÿÿÿ%z¯ hé`ÿÿÿÿ%r¯ h éPÿÿÿÿ%j¯ h é@ÿÿÿÿ%b¯ h é0ÿÿÿÿ%Z¯ h é ÿÿÿÿ%R¯ h éÿÿÿÿ%J¯ héÿÿÿÿ%B¯ héðþÿÿÿ%:¯ héàþÿÿÿ%2¯ héÐþÿÿÿ%*¯ héÀþÿÿÿ%"¯ hé°þÿÿÿ%¯ hé þÿÿÿ%¯ héþÿÿÿ% ¯ hé€þÿÿÿ%¯ hépþÿÿÿ%ú® hé`þÿÿÿ%ò® héPþÿÿÿ%ê® hé@þÿÿÿ%â® hé0þÿÿÿ%Ú® hé þÿÿÿ%Ò® héþÿÿÿ%Ê® héþÿÿÿ%® héðýÿÿÿ%º® h éàýÿÿÿ%²® h!éÐýÿÿÿ%ª® h"éÀýÿÿÿ%¢® h#é°ýÿÿÿ%š® h$é ýÿÿÿ%’® h%éýÿÿÿ%Š® h&é€ýÿÿS‹GLL‹Ÿ€H‹_@é…AŠA²„ÒtH K€¶ÒDŠ‘H=„HcÈfƒ"SH‰ûtH…Û„ŽH‰ßèvøÿÿH)Ø[Ã1ÀH…ÿH‰ñtS¶Q€ú'tÖ€ú"tvHƒÁˆHƒÀëãf„€ú,t´€ú\uà€y\u²HƒÁëØf.„€ú"t¨HƒÁHƒÀ¶Q€ú't~è€ú,t€ú\uã€y\uHƒÁëÛf[H‰÷é×øÿÿ€H…Û„dÿÿÿÆ[ÃAWHcÁAVAUATA‰ÌUH‰ÕH7¢ SH‰û1ÿHƒìXL‹,ÂH‰t$L‰îè ÿÿÿAƒüþH‰D$„¥H¿UHlL‰l$ D¿HƒÄX[]A\A]A^A_ÀL‹l$ºA¾H-¸cIÕ¸rÉ€L;+‡H‹D$E1äH‹¶EëfDHƒÃHƒÅ„Àˆt:<%¶Euêõÿÿ¿èÔçÿÿH‰ÂI‹Eø¿ÇDHÇBH‰BH‰T$è¬çÿÿH‹T$I‰Ç¿I‰I‰GH‰BèçÿÿHƒøðH‹T$tI‹MH‰HL‰þH‰ÇH‰T$è|æÿÿH‹T$éÂôÿÿI‹UL èR¹L‰ÏH‰Öó¦„kL ÓR¹H‰ÖL‰Ïó¦…þ¿L‰L$èçÿÿL‹L$H‰ÂÇBHÇ@L‰Hé\ôÿÿ¿èòæÿÿI‰ÇI‹E¿AÇIÇGI‰GI‹uøH‰t$èÅæÿÿHƒøðH‹t$tL‰xH‰Çè¾åÿÿI‹Uøéôÿÿ¿è›æÿÿH‰ÂH‰H‰Béìóÿÿ¿è‚æÿÿ¿Ç0HÇ@HÇ@H‰D$è]æÿÿH‹T$I‰Ç¿I‰I‰GH‰Bè@æÿÿHƒøðH‹T$tI‹MðH‰HL‰þH‰ÇH‰T$è-åÿÿI‹E¿L‹8è æÿÿHƒøðH‹T$tI‹MøH‰HH‰ÇL‰þH‰T$èùäÿÿI‹EH‹T$H‰Bé7óÿÿ¿èÍåÿÿ¿Ç.HÇ@HÇ@H‰D$è¨åÿÿH‹T$H‰¿H‰@H‰BI‹EèL‹8è‡åÿÿHƒøðH‹T$tI‹MàH‰HL‰þH‰ÇH‰T$ètäÿÿ¿èZåÿÿH‹T$Ç I‰ÇHÇ@I‹Eè¿I‰GH‹rH‰t$è)åÿÿHƒøðH‹T$H‹t$tL‰xH‰ÇH‰T$èäÿÿH‹T$¿L‹zèõäÿÿHƒøðH‹T$tI‹MøH‰HL‰þH‰ÇH‰T$èâãÿÿH‹T$é(òÿÿ¿è¾äÿÿ¿Ç,HÇ@HÇ@H‰D$è™äÿÿH‹T$H‰¿H‰@H‰BI‹EèL‹8èxäÿÿHƒøðH‹T$tI‹MàH‰HL‰þH‰ÇH‰T$èeãÿÿ¿èKäÿÿH‹T$Ç I‰ÇHÇ@I‹Eè¿I‰GH‹rH‰t$èäÿÿHƒøðH‹T$H‹t$tL‰xH‰ÇH‰T$è ãÿÿH‹T$¿L‹zèæãÿÿHƒøðH‹T$tI‹MøH‰HL‰þH‰ÇH‰T$èÓâÿÿH‹T$éñÿÿ¿è¯ãÿÿ¿Ç*HÇ@HÇ@H‰D$èŠãÿÿH‹T$H‰¿H‰@H‰BI‹EèL‹8èiãÿÿHƒøðH‹T$tI‹MàH‰HL‰þH‰ÇH‰T$èVâÿÿ¿è<ãÿÿH‹T$Ç#I‰ÇHÇ@I‹Eè¿I‰GH‹rH‰t$è ãÿÿHƒøðH‹T$H‹t$tL‰xH‰ÇH‰T$èúáÿÿH‹T$¿L‹zè×âÿÿHƒøðH‹T$tI‹MøH‰HL‰þH‰ÇH‰T$èÄáÿÿH‹T$é ðÿÿ¿è âÿÿH‰ÂÇ(HÇ@I‹Eø¿H‰BL‹8H‰T$èuâÿÿHƒøðH‹T$tI‹MðH‰HL‰þH‰ÇH‰T$èbáÿÿH‹T$é¨ïÿÿ¿è>âÿÿ¿Ç&HÇ@HÇ@H‰D$èâÿÿH‹T$I‰Ç¿I‰I‰GH‰BèüáÿÿHƒøðH‹T$tI‹MH‰HL‰þH‰ÇH‰T$èéàÿÿH‹T$é/ïÿÿ¿èÅáÿÿ¿Ç$HÇ@HÇ@H‰D$è áÿÿH‹T$I‰Ç¿I‰I‰GH‰BèƒáÿÿHƒøðH‹T$tI‹MH‰HL‰þH‰ÇH‰T$èpàÿÿH‹T$é¶îÿÿ¿M‹}øèHáÿÿHƒøðtI‹UH‰PL‰þH‰Çè?àÿÿI‹Uøé†îÿÿ¿èáÿÿH‰ÂH‰H‰Bémîÿÿ¿èáÿÿH‰ÂI‹Eð¿ÇHÇBH‰BH‰T$èÛàÿÿH‹T$I‰Ç¿I‰I‰GH‰Bè¾àÿÿHƒøðH‹T$tI‹MøH‰HL‰þH‰ÇH‰T$è«ßÿÿH‹T$éñíÿÿ¿M‹}øèƒàÿÿHƒøðtI‹UH‰PL‰þH‰ÇèzßÿÿI‹UøéÁíÿÿ¿èWàÿÿH‰ÂH‰H‰Bé¨íÿÿ¿è>àÿÿH‰ÂI‹Eð¿Ç"HÇBH‰BH‰T$èàÿÿH‹T$I‰Ç¿I‰I‰GH‰BèùßÿÿHƒøðH‹T$tI‹MøH‰HL‰þH‰ÇH‰T$èæÞÿÿH‹T$é,íÿÿ¿èÂßÿÿH‰ÂI‹Eð¿ÇHÇBH‰BH‰T$èšßÿÿH‹T$I‰Ç¿I‰I‰GH‰Bè}ßÿÿHƒøðH‹T$tI‹MøH‰HL‰þH‰ÇH‰T$èjÞÿÿH‹T$é°ìÿÿ¿èFßÿÿH‰ÂI‹Eð¿ÇHÇBH‰BH‰T$èßÿÿH‹T$H‰¿H‰@H‰BèßÿÿH‹T$I‰ÇI‹EøIÇGAÇ¿H‹rI‰GH‰t$èÒÞÿÿHƒøðH‹T$H‹t$tL‰xH‰ÇH‰T$èÁÝÿÿH‹T$éìÿÿ¿M‹}øè™ÞÿÿHƒøðtI‹UH‰PL‰þH‰ÇèÝÿÿI‹Uøé×ëÿÿ¿èmÞÿÿH‰ÂH‰H‰Bé¾ëÿÿ¿èTÞÿÿH‰ÂI‹EÇHÇBH‰Bé–ëÿÿ¿è,ÞÿÿH‰ÂI‹EÇHÇBH‰Bénëÿÿ¿èÞÿÿH‰ÂI‹EÇHÇBH‰BéFëÿÿ¿M‹}øèØÝÿÿHƒøðtI‹UH‰PL‰þH‰ÇèÏÜÿÿI‹Uøéëÿÿ¿è¬ÝÿÿH‰ÂH‰H‰Béýêÿÿ¿è“ÝÿÿH‰ÂÇHÇ@I‹EøH‰BéÕêÿÿ¿èkÝÿÿH‰ÂI‹EÇ HÇBH‰Bé­êÿÿ¿èCÝÿÿH‰ÂI‹EÇHÇBH‰Bé…êÿÿ¿èÝÿÿ¿ÇHÇ@HÇ@H‰D$èöÜÿÿH‹T$I‰Ç¿I‰I‰GH‰BèÙÜÿÿHƒøðH‹T$tI‹MH‰HL‰þH‰ÇH‰T$èÆÛÿÿH‹T$é êÿÿ¿è¢ÜÿÿH‰ÂH‰H‰Béóéÿÿ¿M‹}øè…ÜÿÿHƒøðtI‹UH‰PL‰þH‰Çè|ÛÿÿI‹UøéÃéÿÿ¿èYÜÿÿH‰ÂÇHÇ@I‹Eø¿H‰BL‹8H‰T$è.ÜÿÿHƒøðH‹T$tI‹MðH‰HL‰þH‰ÇH‰T$èÛÿÿH‹T$éaéÿÿ¿è÷Ûÿÿ¿ÇHÇ@HÇ@H‰D$èÒÛÿÿH‹T$I‰Ç¿I‰I‰GH‰BèµÛÿÿHƒøðH‹T$tI‹MH‰HL‰þH‰ÇH‰T$è¢ÚÿÿH‹T$éèèÿÿ¿è~ÛÿÿH‰ÂI‹EðÇH‰BI‹EøH‰BéÀèÿÿ¿èVÛÿÿH‰ÂI‹EÇHÇBH‰Bé˜èÿÿ¿è.ÛÿÿH‰ÂÇHÇ@I‹EøH‰Bépèÿÿ¿èÛÿÿH‰ÂI‹EÇHÇBH‰BéHèÿÿ¿èÞÚÿÿ¿ÇHÇ@HÇ@H‰D$è¹ÚÿÿH‹T$I‰Ç¿I‰I‰GH‰BèœÚÿÿHƒøðH‹T$tI‹MH‰HL‰þH‰ÇH‰T$è‰ÙÿÿH‹T$éÏçÿÿ¿èeÚÿÿH‰ÂI‹Eø¿Ç HÇBH‰BH‰T$è=ÚÿÿH‹T$I‰Ç¿I‰I‰GH‰Bè ÚÿÿHƒøðH‹T$tI‹MH‰HL‰þH‰ÇH‰T$è ÙÿÿH‹T$éSçÿÿ¿èéÙÿÿH‰ÂI‹EÇ HÇBH‰Bé+çÿÿ¿èÁÙÿÿH‰ÂI‹Eø¿Ç HÇBH‰BH‰T$è™ÙÿÿH‹T$I‰Ç¿I‰I‰GH‰Bè|ÙÿÿHƒøðH‹T$tI‹MH‰HL‰þH‰ÇH‰T$èiØÿÿH‹T$é¯æÿÿ¿èEÙÿÿH‰ÂI‹EÇ HÇBH‰Bé‡æÿÿ¿M‹}øèÙÿÿHƒøðtI‹UH‰PL‰þH‰ÇèØÿÿI‹UøéWæÿÿ¿èíØÿÿH‰ÂH‰H‰Bé>æÿÿ¿èÔØÿÿH‰ÂI‹EøÇHÇBH‰Béæÿÿ¿è¬ØÿÿH‰ÂI‹EÇFHÇBH‰Béîåÿÿ¿è„ØÿÿH‰ÂI‹EÇFHÇBH‰BéÆåÿÿ¿è\ØÿÿH‰ÂI‹EÇFHÇBH‰Béžåÿÿ¿è4ØÿÿH‰ÂI‹EÇFHÇBH‰Bévåÿÿ¿è ØÿÿH‰ÂI‹EÇFHÇBH‰BéNåÿÿ¿èä×ÿÿH‰ÂI‹EÇFHÇBH‰Bé&åÿÿ¿è¼×ÿÿH‰ÂI‹EÇFHÇBH‰Béþäÿÿ¿è”×ÿÿH‰ÂI‹EøÇHÇBH‰BéÖäÿÿ¿èl×ÿÿH‰ÂI‹EøÇHÇBH‰Bé®äÿÿ¿èD×ÿÿH‰ÂI‹Eð¿ÇHÇBH‰BH‰T$è×ÿÿH‹T$I‰Ç¿I‰I‰GH‰BèÿÖÿÿHƒøðH‹T$tI‹MøH‰HL‰þH‰ÇH‰T$èìÕÿÿH‹T$é2äÿÿ¿èÈÖÿÿH‰ÂI‹Eð¿ÇHÇBH‰BH‰T$è ÖÿÿH‹T$H‰¿H‰@H‰Bè†ÖÿÿH‹T$I‰ÇI‹EøIÇGAÇ¿H‹rI‰GH‰t$èTÖÿÿHƒøðH‹T$H‹t$tL‰xH‰ÇH‰T$èCÕÿÿH‹T$é‰ãÿÿ¿èÖÿÿH‰ÂI‹Eð¿ÇHÇBH‰BH‰T$è÷ÕÿÿH‹T$H‰¿H‰@H‰BèÝÕÿÿH‹T$I‰ÇI‹EøIÇGAÇ¿H‹rI‰GH‰t$è«ÕÿÿHƒøðH‹T$H‹t$tL‰xH‰ÇH‰T$èšÔÿÿH‹T$éàâÿÿ¿èvÕÿÿH‰ÂI‹EпÇHÇBH‰BH‰T$èNÕÿÿH‹T$H‰¿H‰@H‰Bè4ÕÿÿH‹T$I‰ÇI‹EØIÇGAÇ¿H‹rI‰GH‰t$èÕÿÿHƒøðH‹T$H‹t$tL‰xH‰ÇH‰T$èñÓÿÿ¿è×ÔÿÿH‹T$ÇI‰ÇHÇ@I‹Eè¿I‰GH‹rH‰t$è¦ÔÿÿHƒøðH‹T$H‹t$tL‰xH‰ÇH‰T$è•ÓÿÿH‹T$¿L‹zèrÔÿÿHƒøðH‹T$tI‹MøH‰HL‰þH‰ÇH‰T$è_ÓÿÿH‹T$é¥áÿÿ¿è;ÔÿÿH‰ÂI‹EпÇHÇBH‰BH‰T$èÔÿÿH‹T$H‰¿H‰@H‰BèùÓÿÿH‹T$I‰ÇI‹EØIÇGAÇ¿H‹rI‰GH‰t$èÇÓÿÿHƒøðH‹T$H‹t$tL‰xH‰ÇH‰T$è¶Òÿÿ¿èœÓÿÿH‹T$ÇI‰ÇHÇ@I‹Eè¿I‰GH‹rH‰t$èkÓÿÿHƒøðH‹T$H‹t$tL‰xH‰ÇH‰T$èZÒÿÿH‹T$¿L‹zè7ÓÿÿHƒøðH‹T$tI‹MøH‰HL‰þH‰ÇH‰T$è$ÒÿÿH‹T$éjàÿÿ¿èÓÿÿH‰ÂI‹Eè¿ÇHÇBH‰BH‰T$èØÒÿÿH‹T$H‰¿H‰@H‰Bè¾ÒÿÿH‹T$I‰ÇI‹EðIÇGAÇ¿H‹rI‰GH‰t$èŒÒÿÿHƒøðH‹T$H‹t$tL‰xH‰ÇH‰T$è{Ñÿÿ¿èaÒÿÿH‹T$I‰ÇI‹EøIÇGAÇ¿H‹rI‰GH‰t$è/ÒÿÿHƒøðH‹T$H‹t$tL‰xH‰ÇH‰T$èÑÿÿH‹T$édßÿÿ¿èúÑÿÿH‰ÂH‰H‰BéKßÿÿ¿èáÑÿÿ¿Ç HÇ@HÇ@H‰D$è¼ÑÿÿH‹T$I‰Ç¿I‰I‰GH‰BèŸÑÿÿHƒøðH‹T$tI‹MðH‰HL‰þH‰ÇH‰T$èŒÐÿÿH‹T$¿L‹zèiÑÿÿHƒøðH‹T$tI‹MøH‰HL‰þH‰ÇH‰T$èVÐÿÿH‹T$éœÞÿÿI‹Ué“Þÿÿ¿è)ÑÿÿH‰Â¿H‰H‰BH‰D$èÑÿÿI‰ÇI‹E¿AÇIÇGI‰GèìÐÿÿHƒøðH‹T$tL‰xH‰ÖH‰ÇH‰T$èÝÏÿÿH‹T$é#Þÿÿ¿è¹ÐÿÿI‰ÇI‹E¿AÇIÇGI‰GI‹uøH‰t$èŒÐÿÿHƒøðH‹t$tL‰xH‰Çè…ÏÿÿI‹UøéÌÝÿÿ¿èbÐÿÿH‰ÂI‹EÇHÇBH‰Bé¤Ýÿÿ¿è:ÐÿÿH‰ÂI‹EÇHÇBH‰Bé|Ýÿÿ¿H‰T$è ÐÿÿH ‹;ÇH‹t$hH‹T$H‰HI‹MH‰HH‰FéAÝÿÿ¿è×ÏÿÿH‰ÂI‹Eð¿ÇHÇBH‰BH‰T$è¯ÏÿÿH‹T$I‰Ç¿I‰I‰GH‰Bè’ÏÿÿHƒøðH‹T$tI‹MøH‰HL‰þH‰ÇH‰T$èÎÿÿH‹T$éÅÜÿÿ¿è[ÏÿÿH‰ÂI‹Eð¿ÇHÇBH‰BH‰T$è3ÏÿÿH‹T$H‰¿H‰@H‰BèÏÿÿH‹T$I‰ÇI‹EøIÇGAÇ ¿H‹rI‰GH‰t$èçÎÿÿHƒøðH‹T$H‹t$tL‰xH‰ÇH‰T$èÖÍÿÿH‹T$éÜÿÿ¿è²ÎÿÿH‰ÂI‹Eð¿ÇHÇBH‰BH‰T$èŠÎÿÿH‹T$H‰¿H‰@H‰BèpÎÿÿH‹T$I‰ÇI‹EøIÇGAÇ ¿H‹rI‰GH‰t$è>ÎÿÿHƒøðH‹T$H‹t$tL‰xH‰ÇH‰T$è-ÍÿÿH‹T$ésÛÿÿ¿è ÎÿÿH‰ÂI‹EøÇHÇBH‰BéKÛÿÿ¿èáÍÿÿH‰ÂI‹EØ¿ÇH‰BI‹EðH‰BL‹8H‰T$è¶ÍÿÿHƒøðH‹T$tI‹MèH‰HL‰þH‰ÇH‰T$è£ÌÿÿH‹T$ééÚÿÿ¿èÍÿÿH‰ÂI‹EøÇHÇBH‰BéÁÚÿÿ¿èWÍÿÿH‰ÂI‹EøÇHÇBH‰Bé™Úÿÿ¿è/Íÿÿ¿ÇFHÇ@HÇ@H‰D$è ÍÿÿH‹T$H‰¿H‰@H‰BèðÌÿÿH‹T$I‰ÇI‹EIÇGAÇ¿H‹rI‰GH‰t$è¾ÌÿÿHƒøðH‹T$H‹t$tL‰xH‰ÇH‰T$è­ËÿÿH‹T$éóÙÿÿ¿è‰ÌÿÿH‰ÂI‹Eð¿ÇHÇBH‰BH‰T$èaÌÿÿH‹T$I‰Ç¿I‰I‰GH‰BèDÌÿÿHƒøðH‹T$tI‹MøH‰HL‰þH‰ÇH‰T$è1ËÿÿH‹T$éwÙÿÿHŒ$ÀH‹t$hHŸ7H‰Ï»èÆÔÿÿéöÚÿÿ1ÛéïÚÿÿH‹¼$àH;|$tD‰D$è±ÊÿÿD‹D$H‹¼$ðD‰D$è:ÊÿÿH…ÀH‰„$àD‹D$t5H´$àH¼$ðH‰ÚD‰Áè½ÑÿÿH‹”$àéZÛÿÿM‰þ»éxÚÿÿHŒ$H‹t$hH‘6HÇ„$ð€H‰Œ$àHŒ$ÀH‰ÏH‰L$èÔÿÿH‹L$éÿÿÿH5Õ;¿1ÀL‰D$èdÉÿÿJ åL‹D$I)ÍK $IÁäL‰ÀH)ËHÁàH¿ HèL)å‹‹@E¿$Oé]Ùÿÿ¿L‰L$èÊÊÿÿL‹L$H‰ÂÇBHÇ@L‰Hé ØÿÿH‹L$0é’þÿÿè ÊÿÿHƒìH‹ýw H‰ùHü5¾H‹81Àè|Èÿÿ¿è’ÈÿÿfH…ÿtBH‹GÇG ÆH‹GÆ@H‹F(H‹WÇG,ÇG<H…ÀH‰Wt H‹NHÈH;8t óÀ‹O H‰V@H‰–€H‹‰N4H‹H‰F¶ˆF0Ãfffff.„H‹Ãfff.„H‹W(1ÀH…ÒtH‹OH‹ÊH…Òt‹B0óÃH‹W(1ÀH…ÒtH‹OH‹ÊH…Òt‹B4óÃH‹GÃff.„H‹GÃff.„‹G8Ãfff.„H‹‡€Ã„H‰>Ãfff.„HƒìH‹F(H…ÀtH‹VH‹ÐH…Àt‰x0HƒÄÃH=‡Eè‚þÿÿfHƒìH‹F(H…ÀtH‹VH‹ÐH…Àt‰x4HƒÄÃH=EèRþÿÿfH‰~Ãff.„H‰~Ãff.„‹G|Ãfff.„‰~|Ãfff.„H‹‡Ã„H‰¾Ã„H‹‡˜Ã„H‰¾˜Ã„éÛÆÿÿff.„UH‰ýSH‰óHì¨H‰æèéþÿÿH…Û„H‰æ¿ èÃÿÿÿH…ÀH‰„¨H‰Çº …@öÇ…-@öÇ…;‰Ñ1ÀÁéöÂóH«… öÂ…ƒâurH‹3H‰ïèwþÿÿH‹HÇ@(HÇ@HÇ@ HÇ@@Ç@HÇ@LÇ@TÇ@XHÇ@`HÇ@HÇ@HĨ1À[]Ã@Æë‰fÇHƒÇƒâ„tÿÿÿëä@ÇHƒÇö„VÿÿÿëÓècÆÿÿÇHĨ¸[]ÃfDèCÆÿÿÇ HĨ¸[]ÃfDÆHƒÇ²ŸéÓþÿÿf.„fǃêHƒÇéÂþÿÿ€ÇƒêHƒÇé³þÿÿfDH…ÿSH‰û„ë1ö¿ è'þÿÿH…ÀH‰„ë¨H‰Çº …ó@öÇ…@öÇ…‰Ñ1ÀÁéöÂóH«…„öÂuoƒâubH‹HÇ@(HÇ@HÇ@ HÇ@@Ç@HÇ@LÇ@TÇ@XHÇ@`HÇ@HÇ@1À[ÀÆë™fÇHƒÇƒâtˆëèÇHƒÇö„nÿÿÿëÛèãÄÿÿǸ[ÃfDèËÄÿÿÇ ¸[ÃfDÆHƒÇ²Ÿéÿþÿÿf.„fǃêHƒÇéîþÿÿ€ÇƒêHƒÇéßþÿÿfDH‰\$ØH‰l$àH‰ûL‰d$èL‰l$ð‰õL‰t$øH‰ÖHƒì(¿@I‰ÕèžüÿÿH…ÀI‰Ä„¹HcíL‰îH}H‰hèüÿÿH…ÀI‰D$„˜AÇD$$èÄÿÿL‰îL‰çH‰ÅD‹0èRúÿÿI‹E(I‰$AÇD$8H…Àt I‹UL;$ÐtAÇD$0AÇD$41ÀH…ÛtH‰ßèQÂÿÿ‰ÇèŠÂÿÿ…ÀŸÀ¶ÀA‰D$(H‹$L‰àD‰uL‹d$H‹l$L‹l$L‹t$ HƒÄ(ÃH=ò@èùÿÿffff.„éëÃÿÿff.„U‰ýSH‰óHƒì‹VT‹FX9Â|[H‹~`ƒÀ‰FXH˜HÁàH…ÿtVH‰òH‰Æè»ÿÿÿH‰C`H…ÀtP‹ST‹KLl-HcòƒÂƒé‰ÏÁïùÑù‰ °‰kL‰STHƒÄ[]ÃfDH‹F`ëËf.„H‰Çè(ûÿÿH‰C`ë«H=s@èæøÿÿfDATUH‰ýSH‹~(H‰óH…ÿ„‘L‹f H‹FH‰úIL$ÿH9ȃ H‹ÇH9è„„H…Ò„RH‹KHƒ<ÊHÍt1¶S0H‹C@ˆH‹CH‹s@H‹{(HÁàH‰ÂHS(H‹ H‰q‹K4H‹‰J H‰,HC(H‹‹J H‹RH‰S@H‰“€H‹‰K4H‹H‰C¶ÇCPˆC0[]A\Ãf.„AƒÄH‰ÚMcäJ4åèiþÿÿH…ÀH‰C(„H‹S H<к@@öÇ…å@öÇ…ë@öÇ…¹‰Ñ1ÀÁéöÂóH«uRöÂu5ƒâu(L‰c H‹{(1Ò1ÀH…ÿ„çþÿÿH‹CH‰úé×þÿÿ€ÆëÓfÇHƒÇƒâtÂëè„ÇHƒÇöÂt¤ë×€H‹CHÁàéåþÿÿ@·è`ùÿÿH…ÀH‰C(tXHÇHÇC HÇCégÿÿÿǃêHƒÇé5ÿÿÿfDƲ?HƒÇé ÿÿÿffǃêHƒÇéÿÿÿH=€>èÃöÿÿH‰\$àH‰l$èH‰óL‰d$ðL‰l$øHƒì(HƒþH‰ýI‰Ô†•€|7þ…Š€|7ÿ…H‰Ö¿@è¢øÿÿH…ÀI‰ÅtoHƒëH‰hH‰hH‰XÇ@$L‰æHljX H‰ÇÇ@(Ç@,Ç@8Ç@<èBýÿÿL‰èH‹\$H‹l$L‹d$L‹l$ HƒÄ(ÃfDE1íëÙH=ä=èïõÿÿffffff.„AUI‰ÕATUH‰ýS‰óH‰ÖDcHƒìMcäL‰çèì÷ÿÿH…À„¯…Û~z‰ßÁï‰þÁæ…ö„±HUƒûL@—ÁH9ЗÂL9ÅA—ÀD „Ñ„‹1Ò1ÉóoDƒÁóHƒÂ9Ïwê9ót!Hcþ1ÒHýHǶLˆ HƒÂ 9ËíHcÛL‰êL‰æÆDÆH‰Çè[þÿÿH…ÀtÇ@$HƒÄ[]A\A]ÃH==èøôÿÿH=A=èìôÿÿ1öë’„H‰\$ðH‰l$øH‰ûHƒìH‰õèG¾ÿÿH‰êH‰ßH‹l$H‹\$‰ÆHƒÄéÌþÿÿfff.„ATH…ÿUH‰ýSH‰ó„ÀH‹~(H…ÿ„ L‹f H‹VIL$ÿHÕH9ʃ¢Hƒ<„_¶S0H‹C@ˆH‹SH‹{(L‹C@HÕH…ÿH H‹1L‰F‹s4H‹ ‰q „¹H…É„#HBH‰ùH‰CHÁàH‰,HC(H‹‹J H‹RH‰S@H‰“€H‹‰K4H‹H‰C¶ÇCPˆC0[]A\ÄAƒÄH‰ÚMcäJ4åèúÿÿH…ÀH‰C(„-H‹S H<к@@öÇ…õ@öÇ…û@öÇ…ɉÑ1ÀÁéöÂóH«uRöÂu5ƒâu(H‹SL‰c HÕH‹{(1ÉH…ÿ…×þÿÿé0ÿÿÿ@ÆëÓfÇHƒÇƒâtÂëè„ÇHƒÇöÂt¤ë×€1ÉéÕþÿÿH‰ùéäþÿÿ„@·èõÿÿH…ÀH‰C(t`HÇ1ÒHÇC HÇC1Àégÿÿÿ€ÇƒêHƒÇé%ÿÿÿfDƲ?HƒÇéýþÿÿffǃêHƒÇéôþÿÿH= :ècòÿÿ1ÉéXþÿÿfff.„H‰\$ØH‰l$àH‰ýL‰d$èL‰l$ðH‰óL‰t$øHƒì(H‹~(H…ÿ„ÈH‹FL$ÇM‹,$M…í„ËèÖ»ÿÿH‰ÞL‰ïI‰ÄD‹0è%òÿÿH‹S(1ÀI‰mAÇE8H…ÒtH‹CH‹ÂI9ÅtAÇE0AÇE41ÀH…ítH‰ïè"ºÿÿ‰Çè[ºÿÿ…ÀŸÀ¶ÀA‰E(H‹S(H‹CE‰4$H‹l$L‹d$L‹l$L‹t$ HÂH‹‹J H‹RH‰S@H‰“€H‹‰K4H‹H‰C¶ˆC0H‹$HƒÄ(Ãf.„H‹V HJÿH9Ès3H‹{H‰Ú¾@E1íèöÿÿI‰$H‹C(H…À„ÿÿÿH‹SL‹,ÐéöþÿÿDbH‰ÚMcäJ4åèY÷ÿÿH…ÀH‰C(„èH‹S H<к@@öÇ…Ã@öÇ…¨@öÇ…Œ‰Ñ1ÀÁéöÂóH«u:öÂu%ƒâuL‰c H‹K(L‹cN$áéPÿÿÿÆëãfÇHƒÇëÐDÇHƒÇëº@¿è~òÿÿH…ÀH‰C(tQHÇHÇC HÇCL‹c(éòþÿÿǃêHƒÇébÿÿÿfǃêHƒÇéGÿÿÿƲ?HƒÇé/ÿÿÿH=¥7èèïÿÿ„AWAVAUATI‰ÔUSHƒìX‹ZHH‰ºH‰²˜…Û„ž¶B0L‹j@L÷:HðGL5é>H-âKL=ÛPL‰D$(AˆEA‹D$LM‰éHcÐL‹D$(· SfDA¶ufAƒ´ÿÿH‰¸élýÿÿL‰çèYìÿÿL‰çH‰ÃèþêÿÿL‰ç‰è$ìÿÿL‰çH‰ÃèYëÿÿH‰Çè´ÿÿH‰¸é/ýÿÿL‰çèìÿÿL‰çH‰ÃèÁêÿÿL‰ç‰èçëÿÿL‰çH‰ÃèëÿÿH‰ÇèijÿÿH‰¸éòüÿÿL‰çèßëÿÿL‰çH‰Ãè„êÿÿL‰ç‰èªëÿÿL‰çH‰ÃèßêÿÿH‰Ç至ÿÿH‰¸éµüÿÿL‰çè¢ëÿÿL‰çH‰ÃèGêÿÿL‰ç‰èmëÿÿL‰çH‰Ãè¢êÿÿH‰ÇèJ³ÿÿH‰¸éxüÿÿL‰çèeëÿÿL‰çH‰Ãè êÿÿL‰ç‰è0ëÿÿL‰çH‰ÃèeêÿÿH‰Çè ³ÿÿH‰¸é;üÿÿL‰çè(ëÿÿL‰çH‰ÃèÍéÿÿL‰ç‰èóêÿÿL‰çH‰Ãè(êÿÿH‰ÇèвÿÿH‰¸éþûÿÿL‰çèëêÿÿL‰çH‰ÃèéÿÿL‰ç‰è¶êÿÿL‰çH‰ÃèëéÿÿH‰Ç蓲ÿÿH‰¸éÁûÿÿL‰çè®êÿÿL‰çH‰ÃèSéÿÿL‰ç‰èyêÿÿL‰çH‰Ãè®éÿÿH‰ÇèV²ÿÿH‰¸é„ûÿÿL‰çèqêÿÿL‰çH‰ÃèéÿÿL‰ç‰è<êÿÿL‰çH‰ÃèqéÿÿH‰Çè²ÿÿH‰¸éGûÿÿL‰çè4êÿÿL‰çH‰ÃèÙèÿÿL‰ç‰èÿéÿÿL‰çH‰Ãè4éÿÿH‰ÇèܱÿÿH‰¸é ûÿÿL‰çè÷éÿÿL‰çH‰ÃèœèÿÿL‰ç‰èÂéÿÿL‰çH‰Ãè÷èÿÿH‰Ç蟱ÿÿH‰¸ éÍúÿÿL‰çèºéÿÿL‰çH‰Ãè_èÿÿL‰ç‰è…éÿÿL‰çH‰ÃèºèÿÿH‰Çèb±ÿÿH‰¸ éúÿÿL‰çè}éÿÿL‰çH‰Ãè"èÿÿL‰ç‰èHéÿÿL‰çH‰Ãè}èÿÿH‰Çè%±ÿÿH‰¸ éSúÿÿL‰çè@éÿÿL‰çH‰ÃèåçÿÿL‰ç‰è éÿÿL‰çH‰Ãè@èÿÿH‰Çèè°ÿÿH‰¸éúÿÿL‰çèéÿÿL‰çH‰Ãè¨çÿÿL‰ç‰èÎèÿÿL‰çH‰ÃèèÿÿH‰Çè«°ÿÿH‰¸@éÙùÿÿL‰çèÆèÿÿL‰çH‰ÃèkçÿÿL‰ç‰è‘èÿÿL‰çH‰ÃèÆçÿÿH‰Çèn°ÿÿH‰¸?éœùÿÿL‰çè‰èÿÿL‰çH‰Ãè.çÿÿL‰ç‰èTèÿÿL‰çH‰Ãè‰çÿÿH‰Çè1°ÿÿH‰¸>é_ùÿÿL‰çèLèÿÿL‰çH‰ÃèñæÿÿL‰ç‰èèÿÿL‰çH‰ÃèLçÿÿH‰Çèô¯ÿÿH‰¸=é"ùÿÿL‰çèèÿÿL‰çH‰Ãè´æÿÿL‰ç‰èÚçÿÿL‰çH‰ÃèçÿÿH‰Çè·¯ÿÿH‰¸<éåøÿÿL‰çèÒçÿÿL‰çH‰ÃèwæÿÿL‰ç‰èçÿÿL‰çH‰ÃèÒæÿÿH‰Çèz¯ÿÿH‰¸;é¨øÿÿL‰çè•çÿÿL‰çH‰Ãè:æÿÿL‰ç‰è`çÿÿL‰çH‰Ãè•æÿÿH‰Çè=¯ÿÿH‰¸:ékøÿÿL‰çèXçÿÿL‰çH‰ÃèýåÿÿL‰ç‰è#çÿÿL‰çH‰ÃèXæÿÿH‰Çè¯ÿÿH‰¸9é.øÿÿL‰çèçÿÿL‰çH‰ÃèÀåÿÿL‰ç‰èææÿÿL‰çH‰ÃèæÿÿH‰ÇèîÿÿH‰¸8éñ÷ÿÿL‰çèÞæÿÿL‰çH‰ÃèƒåÿÿL‰ç‰è©æÿÿL‰çH‰ÃèÞåÿÿH‰Ç膮ÿÿH‰¸7é´÷ÿÿL‰çè¡æÿÿL‰çH‰ÃèFåÿÿL‰ç‰èlæÿÿL‰çH‰Ãè¡åÿÿH‰ÇèI®ÿÿH‰¸6éw÷ÿÿL‰çèdæÿÿL‰çH‰Ãè åÿÿL‰ç‰è/æÿÿL‰çH‰ÃèdåÿÿH‰Çè ®ÿÿH‰¸5é:÷ÿÿL‰çè'æÿÿL‰çH‰ÃèÌäÿÿL‰ç‰èòåÿÿL‰çH‰Ãè'åÿÿH‰ÇèÏ­ÿÿH‰¸4éýöÿÿL‰çèêåÿÿL‰çH‰ÃèäÿÿL‰ç‰èµåÿÿL‰çH‰ÃèêäÿÿH‰Çè’­ÿÿH‰¸ éÀöÿÿL‰çL‰ûM‰ßè§åÿÿL‰çI‰ÅèLäÿÿL‰æA‰E¿èûéÿÿéãöÿÿ1ÀéŠöÿÿL‰çL‰ûM‰ßèqåÿÿL‰çI‰ÅèäÿÿIct$8I‹L$ºI‹¼$€A‰E膭ÿÿéžöÿÿL‰çè9åÿÿL‰çH‰ÃèÞãÿÿL‰ç‰èåÿÿL‰çH‰Ãè9äÿÿH‰Çèá¬ÿÿH‰¸éöÿÿL‰çèüäÿÿL‰çH‰Ãè¡ãÿÿL‰ç‰èäÿÿL‰çH‰ÃèŒãÿÿH5+H‰Ù‰Â¿1À蔫ÿÿ¿èj«ÿÿL‰çè²äÿÿL‰çH‰ÃèWãÿÿL‰ç‰è}äÿÿL‰çH‰Ãè²ãÿÿH‰ÇèZ¬ÿÿH‰¸éˆõÿÿL‰çèuäÿÿL‰çH‰ÃèãÿÿL‰ç‰è@äÿÿL‰çH‰ÃèuãÿÿH‰Çè¬ÿÿH‰¸$éKõÿÿL‰çè8äÿÿL‰çH‰ÃèÝâÿÿL‰ç‰èäÿÿL‰çH‰Ãè8ãÿÿH‰Çèà«ÿÿH‰¸#éõÿÿL‰çèûãÿÿL‰çH‰Ãè âÿÿL‰ç‰èÆãÿÿL‰çH‰ÃèûâÿÿH‰Ç裫ÿÿH‰¸"éÑôÿÿL‰çè¾ãÿÿL‰çH‰ÃècâÿÿL‰ç‰è‰ãÿÿL‰çH‰Ãè¾âÿÿH‰Çèf«ÿÿH‰¸ é”ôÿÿL‰çèãÿÿL‰çH‰Ãè&âÿÿL‰ç‰èLãÿÿL‰çH‰ÃèâÿÿH‰Çè)«ÿÿH‰¸ éWôÿÿL‰çèDãÿÿL‰çH‰ÃèéáÿÿL‰ç‰èãÿÿL‰çH‰ÃèDâÿÿH‰ÇèìªÿÿH‰¸éôÿÿL‰çèãÿÿL‰çH‰Ãè¬áÿÿL‰ç‰èÒâÿÿL‰çH‰ÃèâÿÿH‰Ç诪ÿÿH‰¸éÝóÿÿL‰çèÊâÿÿL‰çH‰ÃèoáÿÿL‰ç‰è•âÿÿL‰çH‰ÃèÊáÿÿH‰ÇèrªÿÿH‰¸é óÿÿL‰çèâÿÿL‰çH‰Ãè2áÿÿL‰ç‰èXâÿÿL‰çH‰ÃèáÿÿH‰Çè5ªÿÿH‰¸écóÿÿL‰çèPâÿÿL‰çH‰ÃèõàÿÿL‰ç‰èâÿÿL‰çH‰ÃèPáÿÿH‰Çèø©ÿÿH‰¸3é&óÿÿL‰çèâÿÿL‰çH‰Ãè¸àÿÿL‰ç‰èÞáÿÿL‰çH‰ÃèáÿÿH‰Ç軩ÿÿH‰¸2ééòÿÿL‰çèÖáÿÿL‰çH‰Ãè{àÿÿL‰ç‰è¡áÿÿL‰çH‰ÃèÖàÿÿH‰Çè~©ÿÿH‰¸1é¬òÿÿL‰çè™áÿÿL‰çH‰Ãè>àÿÿL‰ç‰èdáÿÿL‰çH‰Ãè™àÿÿH‰ÇèA©ÿÿH‰¸0éoòÿÿL‰çè\áÿÿL‰çH‰ÃèàÿÿL‰ç‰è'áÿÿL‰çH‰Ãè\àÿÿH‰Çè©ÿÿH‰¸/é2òÿÿL‰çèáÿÿL‰çH‰ÃèÄßÿÿL‰ç‰èêàÿÿL‰çH‰ÃèàÿÿH‰ÇèǨÿÿH‰¸-éõñÿÿL‰çèâàÿÿL‰çH‰Ãè‡ßÿÿL‰ç‰è­àÿÿL‰çH‰ÃèâßÿÿH‰Ç芨ÿÿH‰¸,é¸ñÿÿL‰çè¥àÿÿL‰çH‰ÃèJßÿÿL‰ç‰èpàÿÿL‰çH‰Ãè¥ßÿÿH‰ÇèM¨ÿÿH‰¸+é{ñÿÿL‰çèhàÿÿL‰çH‰Ãè ßÿÿL‰ç‰è3àÿÿL‰çH‰ÃèhßÿÿH‰Çè¨ÿÿH‰¸*é>ñÿÿL‰çè+àÿÿL‰çH‰ÃèÐÞÿÿL‰ç‰èößÿÿL‰çH‰Ãè+ßÿÿH‰ÇèÓ§ÿÿH‰¸.éñÿÿL‰çèîßÿÿL‰çH‰Ãè“ÞÿÿL‰ç‰è¹ßÿÿL‰çH‰ÃèîÞÿÿH‰Çè–§ÿÿH‰¸)éÄðÿÿL‰çè±ßÿÿL‰çH‰ÃèVÞÿÿL‰ç‰è|ßÿÿL‰çH‰Ãè±ÞÿÿH‰ÇèY§ÿÿH‰¸(é‡ðÿÿL‰çètßÿÿL‰çH‰ÃèÞÿÿL‰ç‰è?ßÿÿL‰çH‰ÃètÞÿÿH‰Çè§ÿÿH‰¸'éJðÿÿL‰çè7ßÿÿL‰çH‰ÃèÜÝÿÿL‰ç‰èßÿÿL‰çH‰Ãè7ÞÿÿH‰ÇèߦÿÿH‰¸&é ðÿÿL‰çèúÞÿÿL‰çH‰ÃèŸÝÿÿL‰ç‰èÅÞÿÿL‰çH‰ÃèúÝÿÿH‰Ç袦ÿÿH‰¸%éÐïÿÿL‰çè½ÞÿÿL‰çH‰ÃèbÝÿÿL‰ç‰èˆÞÿÿL‰çH‰Ãè½ÝÿÿH‰Çèe¦ÿÿH‰¸é“ïÿÿL‰èI+„$€ƒè‰D$commandcommand-listsymbolsymbol-listnumbernumber_listsortsort-listsorted-varsorted-var-listuser-attruser-attr-listpredef-attrpredef-attr-listgen-attrgen-attr-listspec-constspec-const-lists-exprs-expr-listlong-identifierlong-identifier-listdecimaldecimal-listhexhex-listbinarybinary-liststringstring-listasas-listvar-bindingvar-binding-listtermterm-listqualified-idqualified-id-listlong-qual-idlong-qual-id-listletlet-listforallforall-listexistsexists-list!!-listsort-sym-declsort-sym-decl-listpar-fun-sym-declpar-fun-sym-decl-listpf-2ndpf-2nd-listtheory-attrtheory-attr-listtheory-decltheory-decl-listlogic-attrlogic-attr-listlogiclogic-listboolbool-listoptionoption-listinfo-flaginfo-flag-listsyntax errorsyntax error, unexpected %sAt interactive input: %s At line %d: %s main-scripttruefalsememory exhausted$end$undefinedTK_ASTK_DECIMALTK_EXISTSTK_FORALLTK_LETTK_NUMERALTK_PARTK_STRINGTK_ASSERTTK_CHECKSATTK_DECLARESORTTK_DECLAREFUNTK_DEFINESORTTK_DEFINEFUNTK_EXITTK_GETASSERTIONSTK_GETASSIGNMENTTK_GETINFOTK_GETOPTIONTK_GETPROOFTK_GETUNSATCORETK_GETVALUETK_POPTK_PUSHTK_SETLOGICTK_SETINFOTK_SETOPTIONTK_THEORYTK_NUMTK_SYMTK_KEYTK_STRTK_DECTK_HEXTK_BINKW_SORTSKW_FUNSKW_SORTSDESCRIPTIONKW_FUNSDESCRIPTIONKW_DEFINITIONKW_NOTESKW_THEORIESKW_LANGUAGEKW_EXTENSIONSKW_VALUESKW_PRINTSUCCESSKW_EXPANDDEFINITIONSKW_INTERACTIVEMODEKW_PRODUCEPROOFSKW_PRODUCEUNSATCORESKW_PRODUCEMODELSKW_PRODUCEASSIGNMENTSKW_REGULAROUTPUTCHANNELKW_DIAGNOSTICOUTPUTCHANNELKW_RANDOMSEEDKW_VERBOSITYKW_ERRORBEHAVIORKW_NAMEKW_AUTHORSKW_VERSIONKW_STATUSKW_REASONUNKNOWNKW_ALLSTATISTICS'('')''_''!'$acceptcommand_listattribute_listattributeattribute_valuesort_lists_exprs_expr_listspec_constnumeral_listqual_identifiervar_binding_listvar_bindingsorted_var_listsorted_varterm_listsymbol_listb_valuepredef_keyinfo_flagsyntax error, unexpected %s, expecting %ssyntax error, unexpected %s, expecting %s or %ssyntax error, unexpected %s, expecting %s or %s or %ssyntax error, unexpected %s, expecting %s or %s or %s or %sSyntax error: expecting either 'true' or 'false', got '%s' ;–ÿÿu–ÿÿ–—ÿÿ…—ÿÿc—ÿÿt—ÿÿHœÿÿHœÿÿ̾ÿÿq°ÿÿA°ÿÿ˜¯ÿÿ¯ÿÿUÂÿÿÞ»ÿÿ£ºÿÿh¹ÿÿÒšÿÿ¿¸ÿÿ¸ÿÿš·ÿÿr·ÿÿJ·ÿÿ‡Áÿÿ_ÁÿÿýÀÿÿÕÀÿÿ,Àÿÿƒ¿ÿÿ¿ÿÿ ¶ÿÿñµÿÿÁµÿÿ™µÿÿµÿÿõ´ÿÿy´ÿÿ´ÿÿسÿÿ°³ÿÿˆ³ÿÿ`³ÿÿç²ÿÿ…²ÿÿU²ÿÿ<²ÿÿñÿÿ›±ÿÿs±ÿÿK±ÿÿ2±ÿÿ±ÿÿÚ°ÿÿ²°ÿÿŠ°ÿÿ¤¾ÿÿ|¾ÿÿ%¾ÿÿµ½ÿÿ¬½ÿÿý¼ÿÿä¼ÿÿÙŸÿÿ ®ÿÿ‡®ÿÿW®ÿÿÛ­ÿÿ­ÿÿ’­ÿÿ­ÿÿ ¬ÿÿ>¬ÿÿ/«ÿÿ ªÿÿ©ÿÿ\¨ÿÿC¨ÿÿì§ÿÿ†§ÿÿ §ÿÿŽ¦ÿÿ¦ÿÿ–¥ÿÿ¥ÿÿž¤ÿÿ"¤ÿÿy£ÿÿТÿÿ'¢ÿÿ~¡ÿÿ¡ÿÿü ÿÿó ÿÿê ÿÿá ÿÿØ ÿÿÏ ÿÿÆ ÿÿ½ ÿÿ´ ÿÿ« ÿÿ¢ ÿÿ™ ÿÿ ÿÿ‡ ÿÿ~ ÿÿu ÿÿl ÿÿc ÿÿZ ÿÿQ ÿÿH ÿÿ? ÿÿ6 ÿÿ- ÿÿ$ ÿÿ ÿÿ ÿÿ  ÿÿ"·ÿÿú¶ÿÿÒ¶ÿÿª¶ÿÿ‚¶ÿÿZ¶ÿÿ2¶ÿÿ¯ÁÿÿrÿÎÿrÿrÿAÕÿýÿ m£þÿ$4;ÄårÿrÿrÿrÿrÿrÿArÿrÿrÿrÿC%&'rÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿ()rÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿ+rÿrÿA,<=e>ebbbbbbbijnprÿMçÿOPTwAÄrÿUrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿrÿVùÿWWa…rÿrÿrÿïÿóÿÙÿòÿRæÿrÿcrÿrÿrÿrÿìÿÄùÿrÿrÿùÿùÿrÿorÿrÿrÿrÿrÿrÿrÿùÿrÿùÿáÿãÿA rÿrÿrÿrÿqrArÿYrÿsAAtArÿrÿrÿvrÿÿÿrÿxyrÿzrÿrÿrÿrÿrÿEBCD  !"#$%&'()*+,-./0123456789:;<=>?@AZj\’  B "#$%C BC « ®¯BCBC BBD’¹ »C BCšBCCEŸ B"#$%BBC«Cž®¯BDDBC£¤VC¹»“”CCCq BCCE "#$%BBBpCCÔCCÈ !"#$% !"#$%CCC B E"#$%""!CBBªBCB CBDBC^_`abcB\CB;<=>?@A ÉCCCCC¾CµCCCÿÿÆ—¿ÿÿ!ËÌÿÿÎ&'()*+,-./0123456789:;<=>?@A!ÿÿÿÿÿÿÿÿ&'()*+,-./0123456789:;<=>?@A!ÿÿÿÿÿÿÿÿ&'()*+,-./0123456789:;<=>?@A $h’¡jjÀklm­%q¢¯&Ä'ÅƢˢÌ‘‘o É(ÊÁ)Ÿ« ±® ¹ŸVŸÛW *¸  noo¥Î¼½z+ X £¤,TU˜YÂr stuv—wx y{¸³´³´|}‚„~ ŒŽ-“”õ¶•–™¢oµÓ†‡ˆ‰Š‹¥§ƒº./01234»¾ÔÇpÐÑÕØÍÚÈÜÝÞSÒ©Ï6Ö×Ù789:;<=>?@ABCDEFGHIJKLMNOPQRZ789:;<=>?@ABCDEFGHIJKLMNOPQRZ789:;<=>?@]^_`abcdefgLMNOPQR ."2/015?@xqrstuvwUVWXY[\]^Z_`abcdefghijklmnop_`abcdefghiT'F:=  ,HIJKLMNOPQRS=$::74E&G;>)*,!-(63#A'8 +<9 %DCB FGHHIIIIIIIIIIIIIIIIIIIIJJKKKKLLLMMNNOOPPPPQQRRRRRSSTTUUVWWXYYZZZZZZZ[[\]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^________rÿrÿrÿrÿrÿéÿI™ÿsÿèÿrÿ¨ÿrÿ”rÿ«ÿÂÿ*úÿrÿ?rÿ®rÿÿÿª[€!¬š·ž"¨#¿¦œ°²›…i\5input in flex scanner failedsmt2newset_lineno called with no buffersmt2newset_column called with no bufferout of dynamic memory in smt2new_create_buffer()out of memory expanding start-condition stackout of dynamic memory in smt2newensure_buffer_stack()out of dynamic memory in smt2new_scan_buffer()out of dynamic memory in smt2new_scan_bytes()bad buffer in smt2new_scan_bytes()start-condition stack underflowSyntax error at line %d near %s, \ not allowed inside | ... | Syntax error at line %d near %s fatal flex scanner internal error--end of buffer missedfatal error - scanner input buffer overflowout of dynamic memory in yy_get_next_buffer()fatal flex scanner internal error--no action found˜ÚÿÿŒÊÿÿŒÊÿÿ+Éÿÿ+ÉÿÿÿÒÿÿëÊÿÿ®Êÿÿ«ÕÿÿnÕÿÿ1ÕÿÿôÔÿÿ·ÔÿÿzÔÿÿ»Îÿÿ~ÎÿÿAÎÿÿÎÿÿÇÍÿÿŠÍÿÿMÍÿÿÍÿÿÓÌÿÿ–ÌÿÿYÌÿÿÌÿÿßËÿÿ¢ËÿÿeËÿÿ(ËÿÿûÜÿÿÜÿÿ{Ùÿÿ>ÙÿÿÙÿÿÄØÿÿ‡ØÿÿJØÿÿ ØÿÿÐ×ÿÿ“×ÿÿV×ÿÿ×ÿÿÜÖÿÿŸÖÿÿbÖÿÿ%ÖÿÿèÕÿÿÒÿÿÔÑÿÿ—ÑÿÿZÑÿÿÑÿÿàÐÿÿ£ÐÿÿfÐÿÿ)ÐÿÿìÏÿÿ¯ÏÿÿrÏÿÿ5ÏÿÿøÎÿÿ=ÔÿÿÔÿÿÃÓÿÿ†ÓÿÿNÒÿÿ+Éÿÿ„ÜÿÿDÊÿÿüÉÿÿZÉÿÿ³ÜÿÿÆÛÿÿ­Éÿÿ¶Úÿÿ‹ÒÿÿDÊÿÿüÉÿÿZÉÿÿ­Éÿÿ>ÛÿÿKÜÿÿ<ÓÿÿÁÒÿÿ¸ÙÿÿºÒÿÿºÒÿÿºÒÿÿ    !"#$%&'()*+,-./0123456789USDSAC==SSAAAAAAAAAAAAALJFGEKTPNOMRQA=BBBBBBBBBBBBBAAAAAAAAAAAAAAHI@?>>BBBBBBBBBBBBBBBBBBBAAAAAAAAAA AAABBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAABBBBBBB"BB7BBBBBBBBBBBBAAAAAAAAAAAAAAAAAAABBBBBBBBBB'BBBBB!BBBBBAA AAAAAAAAAAAA BBBBBBBBBBBBBBBB:B&BB AAAAAAAAAAAAB8BBBBBBBBBBBBBBBB9AAAAAAAAAAAABBBBBBBB)BBBBBB(BAAAAAAAAABBBBBBBBBBBBBBBBB5AAAAAAB%BBB*BBBBBBBBBBBAAAABBBBBBBBBBB4BBBAAABBBBBBBBBBBBBBAAABBBBBB+BBBBBBB<B6BBBB0.B;BBBBBBBBBBBB$-BBBBBBBBB#B,BBBB1/BBBBBB2BB3òóóôôòòòòõòòõòòòö÷õõõõõõõõõõõõõõòòòòòòòòòòòòòòõòøòòòööööööööööööö÷òõõõõõõõõõõõõõõõòòòøòòöööööööööööööööööööõõõõõõõõõõõõõõõõööööööööööööööööööööööõõõõõõõõõõõõõõöööööööööööööööööööööööõõõõõõõõõõõõõõõõõõõööööööööööööööööööööööõõõõõõõõõõõõõõõõõõõöööööööööööööööööööööõõõõõõõõõõõõõõöööööööööööööööööööõõõõõõõõõõõõõõöööööööööööööööööõõõõõõõõõõõõõööööööööööööööööööõõõõõõõõõöööööööööööööööööõõõõõõöööööööööööööööõõõõööööööööööööööõõõööööööööööööööõõõöööööööööööööööööööööööööööööööööööööööööööööööööööööòòòòòò8=BE?@HK@@FM];'4  @@@@@@J@@@@@@\Y^bf5PFý 5ýVRd)@ ömüôñðññîìø@@ˆŠñéôøèmêäèèátå}áïêãÝõöóäåÜÝoäúÛøÓö×ÕÖÎÚÕÈÓÐÑÐÇÏÎÀ½½¼¿¹VÒÏϸ½Å¸²¸‚|²°²²±­¯®Ð©¥¦¤¢¦¥§ Ÿ©Ÿ£º¹³–½– “˜‘”‘‘œ‹‚†‡‡ªŽ¤Š€~‰Ÿw~utv‹Šp{•mwjminrpdtcaao†fijeZe~Wb`[Vaw‚„RVP\IMQPFNDPPEA?K<d<9aE865†374<4;.:;/3-113*3,1.%#= !       ü#øö÷óÿõïðíðøîòìðëè äëîäðâàåàßÛçÖÚÞÔÙÓÜ×ÛÎÊËÎËÉÕÈÆÇÄÌÆÆÁÀæ¼»½Â¼Å¼Äܼ±µµ¼»±»¯ª®­©°ªÌ¤¢®¬œŒŽ’‹“‚{efT@ÁÅÈËÏ> ø ( =///7=117(3334444555589?’8?9ð@@B’BïJíJVVXXXYYY_eg_ttegŸìŸ Ÿ+Bëê é+èBåäBãâàBóóóóôôôôõõõöÞö÷÷÷÷ÝÜÛÚÙØ×ÖÓÒÑÐÏÎÍÌËÊÉÈÆÃÂÁÀ¾¹¸·¶µ´³±°¯®­¬«ª©¨§¦¥¤£¢¡ Ÿžœ›š™˜–•”’‘ŽŒ‹Š‰ˆ‡†…ƒ€~}|{zyxwutsqomlkihfedcba`_^]\[ZYXWVURPONMLKJHFEDCA?>=<;:98764321/.-,*('&%$#"!   ÿþýüûúùø÷öõôòñðïîíìëêçæåâáàßÞÝÜÛÚÙØ×ÖÔÓÒÑÐÏÎÍÌËÊÉÈÇÆÅÄÃÂÁÀ¿¾½¼»º¹¸·¶µ´³²±°¯®­¬ª©¨§¦¥¤£¢¡ œš™˜—–•”“‘ŽŒ‹Š‰ˆ‡†…„ƒ‚€~}|{zvusrqponmlkjihfdcba`^]\[ZSRQPONMLKIHGFECA><;:! òòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòò  !"$%&1'$%&W'*+,*+,//////T23444Oc(3555(///Z-Pd-VVQ[UXYY34443555\^f¶].g_.7ñh89:ik;·<l=ð>?@ArBïsVVXYYYYY‚‰Œƒš›ŠÁÇîÈ,.ÉÂJ/_íÃÄì-ëÅÆKê`éèaçæåb####))))0006ä6CCCCãâáàßÞÝÜÛÚÙØ×ÖÕÔÓÒÑÐÏÎÍÌËÊÉÈÇÆÅÄÃÂÁÀ¿¾½¼»º¹¸·¶µ´³²±°¯®­¬«ª©¨§¦¥¤£¢¡ Ÿžœ›š™˜—–•”“’‘ŽŒ‹Š‰ˆ‡†…„ƒ‚€~}|{zyxwvutsrqponmlkjihgfedc^]\[ZYXWVUTSRQPONMLIHGFEDCBA@?>=<;:9876543210+*)('&%$#"!      ÿþýüûúùø÷öõôóòñðïîíìëêéèçæåäãâáàßÞÝÜÛÚÙØ×ÖÕÔÓÒÑÐÏÎÍÌËÊÀ¿¾½¼»º¹¸µ´³²±°¯®­¬«ª©¨§¦¥¤£¢¡ Ÿžœ™˜—–•”“’‘Ž‹ˆ‡†…„€~}|{zyxwvutqponmDjeba`SRNMLKJIHGFEDòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòòò;°5¼`ÿÿÌ »` ¼ ½¢ ¾Ï ¿ë Á Ã9 Ä[ Å} ÆŸ ÇÀ ÈØ Éú Ê Ë< Ì] Ív Î ϯ ÐÐ Ñð Ò ” ¸ Ú1™ c4›F78u9‘6 œm®‘=w +Õ Åþ€€‹ ¤Ò í ¤›  úÒ €‡eÑ •efTvUkV^Œg¨jÄkÛ "! nˆ ã øé "ï å FÕ#Ê ’#ù _${b²RFRª!"’Ú ¨’^Â_øaûbc,dDe\fsg‹h®iÏjìm n0pRqtrœt´uÌvÙwðxz$|;}R~n€‚›‚„߅솇 ˆA‰]°~³ Á B%ïXŠÕ ô!ì÷¤¤‚ ÍL${¹gÖÊÖ‚ "’Ú I’#Ê ’#&` Ÿ ""&¹0Ÿ!0 #p ""ª!'4EZ #Ê ’#"E(½>¸o)0KG'“+  "f' æ¨ "¨ š'†Ð Ð "Ð "f"¨ Ö ”'‡ ôú "Ö "¨ 'µ f " "¨  Ö 'Á Hf? "¨ "f'ÞZf] "¨ " *' xf{ "¨ " *'  ç“ "¨ +ä í'ù Œ™à "í"™"à '9 j™ð "Ð "í"™"à '§ ff "  '4Û™: "Ð ": "™"à í'ˆ õ] "Ö "¨ '~ ûu "Ö 'uf˜ "Ð "™" *'Ä ‚f¶ " " *'Æ Ó ""¨ 'Ýmfõ "¨ " "õ ,' ®f "¨ " "õ 't<fD "Ð "™" "õ 'à ºff " " "õ 'ògfƒ " "õ '¢ ¶f  " "õ '°¹™ "Œ"Ö "à &˜÷Ð Þ "Ð " &B  fú " " &“ ½f " " &™Ð 2 "Ð " &º ù™N " " '¼ T™u "Ð "™" "u { € ,tm8…&³‡f#ýˆf#„‰f# Šf# H‹f#åŒf#Âf#gŽf#Ñf# C’m#(“í#0' ™>" 'IÐ `"Ð " "™&ƒ £f" " "™&ÀÐ ¢"Ð " "™'Õý™É"Œ"É"™"à  &œ ý™ë" " 'î ¿" "Y Ð '• Æ22" "v' Ð ["Ð " "'  Ñm}" ""f'ð ÖFŸ" ""f&* Á™À"Ð " "™'æ ‡fØ"'‹ Bfú" " "™&û(Ð "Ð " "™&{EÐ <"Ð " "™&‚Ð ]"Ð "Ö "™'ßTfv" *' f" *-g Ýg ¯" "Ö .õ õ Ð" " -« ç«  ð" "Ö .º º " " .¯ 9¯  7" "Ö "™/A ô” ú” ¸ Ú*å+  W¨¦~© 'Þ È±±" "T ' à»Ú" ""f'J ç´ü" ""f/809Ø1ßëéÚ í’‡îf2jôqM"é"ï3eqøÿúl"ï"ï3ltüÌú‹"ï"ï. ªf±"""å. Å åÍ".,ó""å"ï.ë. ¼ """å.í?"""å.jÚe""å".× S" .„ž&"ï.•"ú¾" " 4eof&¢&5æ*o&" 66õ”õ6&£`6uð:Œ#‹;Œ#9AŒ#× GŒ#ªHŒ# ìIŒ#(‡JŒ#05KŒ#8žLŒ#@AMŒ#H¡N’#P¥O’#Q Q’#Rê S’#SËU’#T W’#UÔ^’#V)_’#Wb’#Xæ d’#YÇf’#Z h’#[Ðo’#\%p’#]&"}Œ‘"f"í7\€žÄ f1g78 :8Ù;8º ?8ð @#Î f#Î fúŒ1m7`8 :`8Ù;`8º ?8ð @#Î F#Î FFGô 5FK»‡[&U°f¨""k&)ÞÄ""v&+ÛvÛ"í&W¬kò"í1s7E8 :ó8Ù;ó8º ?8ð @#Î ’#Î ’6Õ1y7ž8 :ž8Ù;ž8º ?8ð @#Î T#Î TT17ö8 :ö8Ù;ö8º ?8ð @#Î m#Î mm9±7"Â&T îf,"'¶9fD"'Ò;f\"&áófs"'ß f‹"'|f¨""¨ø& õŒÏ"Œ"f"',ì"í"í&Õ`f ""í*'1 ™0"Š"™"™"'OR"í"í"'Æêft""m"f' f‘""‘—ø' ïm´"'à fÌ"7‡ -f& âŒð"Œ9÷K"í:Ögf$*; gí*&M Pf;"f&‚³fR"í&>µfn"í"í9 ô‚"9ðM›""Œ'pQfÂ""Œ"f"™&V fß"Œ"í*7cÄ&ßÒŒ"Œ'^»f "f"&Ô}fA""í"õ &¾sf]"í"õ &U,f~"Œ"í"õ &P>f "Œ"™"í*&OKfÆ"Œ"™"í"õ & ‹A¬˜ } i‘âüœ  ê  Ÿ ö;s Bk¡Sû Ø” n{ ª4 V\Ê' ; !‡"9 #$_%n &è'm (Ì)¬*"+î,8-± .Œ/Ž0Ú1{ 2ç 3ý4ÿ5ü6þ7Q8ù 9K:u;z <t =è>[ ?"À/ÁÊÂôÉIJ ÅœÆÐÇ<) 0v=Ã2Æ#>val3í#?4v96#@) 7âó‡"Æ"íA8ë‡""f!}92í29“! :òÆRY“BØ;Kín“íCi‹6o™‹<ä)@>| =Ó4BŒ#=eCf#=»Df# =O E‡#  GŠ#y+Hf# DisI#(DibJŒ#0 5Kú#8E› @ƒ fDK| Fj A5ah| !êLS“ˆ| @ä)N™¥| "@ä)[¶Â| "Œ@hÓà| fA*l™õ | "’!@ tí ! | Ad yà6 = | Ac} R ^ | "‡G•øo | "žˆ zH„› ¦ I° ¦ ‚ JôÌ K__aŸK__bŸJ±ã L__s6Õõ Mã !"ã Hß!(!I° (!; nï é H^ ;!O!I° O!KoT!| Hˆg!|!I° O!KinNHŠ!Ÿ!I° O!Iæ6¥!"¥!J Ï!#p "K__f0ª!H,Ý!ô!I° ô!L__cb’ª!H°""I° ¦ L__c¹’J0 G"#Ê ’#N4G"EOÞ n";2f;pfP f`@¬@Ú#Qý  f²Q‚  RSinjTBž‘ UŽ fÙVY!¤@0 #Wq!"Wg!kVö@`,#W¡X-!@;@s#YE!Z!"@*@‚Y!W!ÍX|!C@K@˜#WŠ!ðV~@¹#WZ|!œ@¬@[Š!W\Ž°@Ö@?$]L"´@À^b"ÿÿ_W"`µ©µ`Aªµa‚ Šbk ÀÄ`c»€€€€xdÈ. ÿÿÿe@@e DcWA €€~fd£ÿc¯Y€€€€€€€€€g¼Uÿÿÿÿÿÿÿ\3ÄÙ7 ac4 Ô<ÖA ™ÛC · ~ )qinttv x& ŽxJ »Ø qn q#ó —#G —#b —#ç —# s —#(3 —#0B —#8’ —#@þ —#H` !—#P "—#Xº $n#`` &t#hÕ (q#p~ ,q#t© .#xˆ 2J#€G 3X#‚K 4z#ƒ– 8Š#ˆ­ AŠ# J•#˜– K•# ç L•#¨£ M•#°ª N1#¸Ì Pq#À9 R#ÄA¤ Tz Ä W§ YQ  ]Ä OUq# W^ˆ# Ô<| _|³ $ xQ# ¨ Q# Æ•# Ø•#^ ¶ß ¼b Ó$ ½b# P ¾h# F Âq#+¤+¤ Š<$  <¦Ñ aQ~ jÔqstd B·« 8 ‘V ’… “¢ ”Ê •ç – —# ˜; ™I šq ›˜ œ» è ž   ¢@ £^ ¤{ ¦£ ©Å ¬ì ® °+ ²H ³j ´† µ¢ ¶¾ ·Ú ¸ö ¹Î ºæ »¼)½J¾w¿“Á½ÃáÄÅ%ÆGÇhȀɢÊÃËäÌÍÎ7ÏWÐxјÒ¹ : ^ ‡1™ c4›<7Ì8)9E6 œx® ‘åw +Õ Åþ€€‹ LÒ  í X› ®Ò (/Ñ =qT+U V«^Ag]jyk Ê! nˆ 3- ¬9-"?-å F}#Ê #Ãù ${b²úîúè-"Ú ¨%Á Bq&ïXŠ}&Å&Ÿ  B#ª'Ê+5(Ø#Ô8°#Ê+:zd Ê+>d "j )·1±æ|"&È!& ]!ì÷ìåìò+Í L¸${¹gò+"Ú I*J'•|>J¬."¸#Ê #Ã+` Ÿ¸y"¸"¸,»þúŸ#Ã"ú" +¹0Ý-¿#p Ê"è-,4úé#Ê #Ã"ú,!ú #Ê #Ã"ú-0 Kï,“+«8 "q,æ«P "P q,†x x "x "q"P ~ ”,‡ ô«¢ "~ "P ,µ  q¿ "¿ "P Å ~ ,ÁHqç "P "q,ÞZq "P "¿ .,xq# "P "¿ ., ç«; "P /ä í«,ù Œ1k " "1"k ·,9j1˜ "x " "1"k ,§ fq° "° ¶ ·,4Û1â "x "â "1"k  ,ˆ õ« "~ "P ,~û« "~ ,uq@ "x "1"¿ .,Ä‚q^ "¿ "¿ .,Æ «{ "«"P ,Ýmq "P "¿ " ß,®qÅ "P "¿ " ,t<qì "x "1"¿ " ,úq "¿ "¿ " ,ògq+ "¿ " ,¢¶qH "¿ " ,°¹1j "—"~ "k +˜÷x † "x "¿ +B q¢ "¿ "¿ +“ ½q¾ "¿ "¿ +™x Ú "x "¿ +ºù1ö "¿ "¿ ,¼ T1 "x "1"¿ " # ( 0tm8…Î ³‡q# ýˆq# „‰q# Šq# H‹q# åŒq# Âq# gŽq# Ñq# C’x#( “ #0,1æ "¿ ,Ix "x "¿ "1+ƒ £q)"¿ "¿ "1+Àx J"x "¿ "1,Õý1q"—"q"1"k ¿ +œý1“"¿ "¿ ,î¿°°"¿ "·Y x ,•ÆÚÚ"¿ "·v,x "x "¿ "·, Ñx%"¿ "·"q,ðÖ<G"¿ "·"q+*Á1h"x "¿ "1,æ‡q€"«,‹Bq¢"¿ "¿ "1+û(x Ã"x "¿ "1+{Ex ä"x "¿ "1+‚x "x "~ "1,ßTq"¿ .,q7"¿ .1gÝg¿ W"¿ "~ 2õõ¿ x"¿ "¿ 1« ç« ¿ ˜"¿ "~ 2ºº¿ ¹"¿ "¿ 2¯ 9¯ ¿ ß"¿ "~ "1%Aô:ú:^‡*+­  W¨&Á&› ,ÞÈWW"¿ "·T ,à€€"¿ "·"qo,Jç©©"¿ "·"qÑ%8Ã39€4‡ëÚ í‡îq5jôq""£6eqøÿ® "£"£6ltüÌ®?"£"£2 ªqe"µ"µ"2 Å "µ2,µ§"µ""£2ë. ¼ »Í"»"µ"2í»ó"»"µ"2jÚ»"»""Ï2× SÏ5"Á2„žÚQ"£2•"®r"Á"Á7eof&¢Ú8æ*oÚ"Á9Ï9©Ï”©Ï9ÇÚ£`6) ð:—# ‹;—# 9A—# × G—# ªH—# ìI—#( ‡J—#0 5K—#8 žL—#@ AM—#H ¡N#P ¥O#Q Q#R ê S#S ËU#T W#U Ô^#V )_#W b#X æ d#Y Çf#Z  h#[ Ðo#\ %p#]+"}—E"q" :\€RÌÄ qi;47½< :Â<Ù;Â<º ?½<ð @Â#Î q#Î q®47< :<Ù;<º ?½<ð @Â#Î <#Î <<ïô 5<K»6<f+U°q]"«" +)Þ«y"«"+++Û+" +W¬ §" 47ú< :¦<Ù;¦<º ?½<ð @Â#Î #Î 9}4!7S< :S<Ù;S<º ?½<ð @Â#Î _#Î __4'7«< :«<Ù;«<º ?½<ð @Â#Î x#Î xx4Lp Ñ$Np# À"Op#5Rô"v"v*QU |"p"p*ÉY]/6|*È"\i%KW|"p=i_=h|°9°°& GA¬˜ } i‘âüœ  ê  Ÿ ö;s Bk¡Sû Ø” n{ ª4 V\Ê' ; !‡"9 #$_%n &è'm (Ì)¬*"+î,8-± .Œ/Ž0Ú1{ 2ç 3ý4ÿ5ü6þ7Q8ù 9K:u;z <t =è>[ ?"À/ÁÊÂôÉIJ ÅœÆÐÇ>) 02?Ã2‚#@val3 #A42 96=#B) 7ž¯C"‚" *8ëÄÕC"I"q!}92 îõO! :ò‚OCØ;K *O  =DG9UGE-6î"9®;î¨<ôBüE˜Ÿ BüG°¼ "BûLÍÚ q!ùOqóÿ"ÿ!ùRD|$"!¸W q=N "<"c*¶as$ct "î"<!eif”*ö#kº#©º "î"*"/vÏÛ "îF_TpCF_TpCCúC9C9úZ9Z"ZE*\ú(Z#¾!cÿ¸!dBÚkcjúBÚm{‡ú"Bä&s˜¥úq—#hÆËi0#¼+X%hçËi'#C#oC#oC'9'E36Ÿ"9®;Ÿ¨<¥BüEIP¼BüGam¼"ÂBûL~‹¼q!ùO³"¤°Í"°!ùRw-ÉÕÍ"¶!¸W)"îÿ¼"<"c*¶a&%¼"Ÿ"<!e= >EÍ*ö#k %Zk¼"Ÿ"¶*"/va&€Œ¼"ŸF_Tp¼+F_Tp¼+6«6969« 9È Ó E0\S ( #BÚkþ S BÚm " S "Y Bä&s3 @ S q#o¼+#o¼+Ø9_ ØF9p šG< P"HCF#)à3ÒéN'I0F±&ŸÆ Í P"J &JBä ð P""Ÿ$ÎQ,V" !!P"$ÎUÿ!j +!2!\"$÷%Y“’ L!S!\"$¥]gŸ m!t!\"ø`†!!P"ødŸ!«!P""g"÷s½!Ê!P"q*#Bß!æ!P"KïzCü!"P"­‚ ­Í ­« ­2!­!F_TpC#o'F_TpC#o'u 9šb"u 9m"Ÿ G­¹)(u #¸C¾!»<¸!¼Gk!½ª–%¾°]!¿¶c!À¼"ÁéÃ')äÈ6I ×Ù$¹)#(#="¿)’(:#A#=L’(T#`#="Ê)L’(.s#‰#="<"¿)"Ê)’(;›#§#="Õ)!Ö¹¯à)À#Ì#="Õ)Kjª¥%â#ó#="<"¿)$¥Ñnè" $$æ)$Úr#¬".$5$=$ã¸"O$V$æ)Mendìõ¬"p$w$=MendõV¸"‘$˜$æ)$þM$Ð"²$¹$=$Ð%Ä"Ó$Ú$æ)$)$Ð"ô$û$=$€Ä"%%æ)$ÈHÏ®6%=%æ)$ã0MÊÜ"W%^%æ)$R$Ü"x%%æ)*§©ï”%¥%="<"C$vƒt!”"¿%Æ%=$v‹½ "à%ç%æ)$»“7”"&&=$»Ÿ, ""&)&æ)Kq²?&K&="¿)K™!Ía&h&=K¶Û{~&Š&="¿)Køõê  &§&=!;#cÐ"¬"À&Ñ&="ª"¿)K;#Gÿç&ý&="ª"<"¿)!õmü¬"'"'="ª$õˆÙ¬"<'M'="ª"ªK™6!c'o'="ñ)K&«Å …'Œ'=KTÁ‹¢'³'="ª"ñ)KTßÑÉ'ß'="ª"ñ)"ªKTõ'(="ª"ñ)"ª"ª*‚ï %(1(="¿)Kê QG(N(=K<Ôd(p(="ñ)K̇#†((=KU+b­$£(ª(=J[¶ñÁ(Ò(="<"¿)NbÏsè(ù(="<"¿)JQãÀ)&)="ª"ª"ªJ8#é®=)N)="ª"¿)Jòúqe)q)="ªJ="ˆ)”)="ñ)F_TpC#o'F_TpC#o'ô"9Å)ˆ"9Ð)è"9Û)r"9r"ì)r"9r"4ª|š+ Ô¾|#à~÷)ä6®„î¾!…ÿBˆ‡N*U*š+Oˆ‹g*s*š+"|!ÌA2*Œ*“* +! ”—'*¬*³* +!v˜›"«+Ì*Ó*š+!vŸW"*ì*ø*š+"q!2 §ô«+++š+!2 ®Ï*1+=+š+"q!¦&¶G®V+b+ +"±+!¾º¥®{+‡+ +"±+F_TpCF_TpC÷)¦+÷)9*9·+*46iò+(°# lC#F_TpCF_TpCø+ÂPÌ ,,Q° ,ò+R]<,S__a Ÿ¸S__b Ÿ¸ReS,T__sµRy,#ÃUzþ,T__sþ úPÕ’,,Q° ,OPÓ*°,Í,Q° Í,"qVWã¡*š+PU*à,ö,Q° Í,S__x‹|P$--Q° -=XÖgq3-Y g .9¬}E-Z3-T-"3-P‡b-x-Q° x-Y n?-9-Ps*‹-–-Q° –- +PV$©-´-Q° -Pb+Â-Ø-Q° –-S__xºØ-±+9ã-Êã-RŸ .#p ÊS__f0è-PÔ.2.Q° 2.T__cbè-PøE.\.Q° ,T__c¹R¿….#Ê #ÃU4….ú[Þ ¬.Y22qYp2qÂP)À.Ö.Q° Ö.YÝ•ì¬.Ré/#Ê #ÃU/ú\¯`@Ð@‹,/f2]° ú‹^of2Ô_[q` m/aiq{bS,œ@Pž/cr, „z@Ÿdf,²e„,°@¼@bS,Á@€’0dr,èdf,f<,Ê@Ò@0dF,TgS,±@Ë@df,wh±@Ë@ir,j².»@Ë@dÊ.šdÀ.¾g,»@Á@–d0,šd%,ákS,à@ò@À0dr,df,MkS,ò@@1dr,–df,¹j<,ò@ú@dF,–kS,@@>1dr,df,JbT-@° 2il-ib-lÛ.@ðsd÷.“m7.)@0 æ1dO.Ümî-)@pº¾1d. n .2@ ºd.{ d%.Ï j\.I@Q@ dx.ó h]@‰@ai ¬" g¢,@ƒ@ d°,g h@ƒ@oÀ,“ IpÜà@@¸ «2lŠ.ä@Ð2q .ÿÿr•.sµ©hsAªht‚ •u ÄÄ`vv€€€€xwƒ. ÿÿÿxõ@xÀDv A €€~y£ÿvdY€€€€€€€€€zqUÿÿÿÿÿÿÿ{q £! `Á`Pµ« Ù9,7 àsc4 Ô<ÖA ™ÛC · ~ )qinttv x& ŽxJ ¿ 1¯»Ø |n q#ó —#G —#b —#ç —# s —#(3 —#0B —#8’ —#@þ —#H` !—#P "—#Xº $­#`` &³#hÕ (q#p~ ,q#t© .#xˆ 2J#€G 3X#‚K 4¹#ƒ– 8É#ˆ­ AŠ# J•#˜– K•# ç L•#¨£ M•#°ª N1#¸Ì Pq#À9 RÏ#Ä A¯  Tz Ï  W²  YQ  ]Ï O Uq# W ^“# ß<| _‡  E# Ýß#Ãê³ c xQ# ¨ Q# Æ•# Ø•#^ ¶ß ¼¡ Ó$ ½¡# P ¾§# F Âq#j¯j¯ É<c ß<åÆ ostd‚ ^¤_êa‚ bœ c³ dË eã fú g h5 iV js m n· pÙ qû r# t; uS v` ww x‹ z« | }Ù ~õ € " ‚I „f …s †Š ‡§ ˆÎ ‰ê °à ³fQg…kl#mBnZorqžt»vÓyðz {;}]~€€Ž¢‚ă儆‡JÎÀÑU Ôp Õf׃ØÝÙ›Ú¼Û1c4›<6 œxÁ B qBxlƒ›‘¹’Û“ø”•2–P—n˜†™”š¼›ãœ3žP h¢‹£©¤Æ¦è© ¬1®S°p²³¯´Ëµç¶·¸;¹º+»M¼n½¾¼¿ØÁûÃÄ:Å\Æ~ÇŸÈ·ÉÙÊúËÌ<ÍUÎnÏŽЯÑÏÒð  3 U™ 7y8Ö9ò‹ ;Ò í ›  6Ò »Ñ ,»qTÌUÁVl^âgþj k1 ‰Ê w ïXŠl ã' Å Ÿ  B#= !Ê+5"++#Ô8š#Ê+:ð÷·+Ê+> " ·+#½+$·1Þ(%É+. ·+qæ|" È! &ú)+(u '_Tp´##,((0KÞ)± 7– #– ¤&T îq³ #– *¶ 9qË #– *Ò ;qã #– &á óqú #– *ß q #– *| q/ #– #/ ê& õ—V #—#q#– *, – s #ß#ß&Õ`q #– #ß+*1 1· #•#1#1#– *O – Ù #ß#ß#– *Æ êqû #– #x#q* q #– #  ê* ïx; #– *à qS #– ,‡-q& â—w #—)÷ K‹ #ß-Ögq« +. gß+&MPq #q&‚ ³qÙ #ß&> µqõ #ß#ß) ô #– )ð M" #– #—*p QqI #– #—#q#1&V qf #—#ß+,c Ä– &ß Ò—Š #—*^ »q§ #q#– &Ô}qÈ #– #ß#È &¾sqê #ß#È &U,q #—#ß#È A•à ¦à ©£À¶fÁƒ›üÅÝÆ/abs­N*¹p #¹/div³ö+À #¹#¹*ã+îú3U  W¨ Á › &P>q#—#1#ß+&OKq(#—#1#ß#È c€+Q ö(dq#0remeq#+f( k'… ö(lx#0remmx#‘'n\ w4'¹ ö(x¹#0remy¹#o5'zqÑ1™+æãé2qý#ý#ý3*§(q#"4*v';;#ßY *{'qZ#ß*€'!xr#ß*3+ó•ž#ý#ý#1#1#×5divQ»#q#q*­+7—Ó#ß*Æ'…ð#x#x*)\q #ß#1&h*r1.#.#ß#14”*’+_q]#.#ß#1)T+ù€#•#1#1#×6*|q)*~¢#Q&g'¥;¾#ß#¾—&Ø*¸xå#ß#¾#q&p)¼<#ß#¾#q*1*Íq#ß&)‘1?#—#?#1E4&˜'Tqf#—#4*Å'Àƒ#¹#¹*#+*¹›#ß&Ÿ(Ò¹¼#ß#¾#q&!,×ÐÝ#ß#¾#q&Ñ*­ùù#ß#¾v&—(°#ß#¾T 8679Ü”68ž 7•9 :•9Ù;•9º ?=9ð @ËÎ xÎ xx8LZ Ñ$NZ# À"OZ#:RÞ#`#`;QUóf#Z#Z;ÉY] f;È"\i%5Af#Z<i_=Rfš=šš1Ñ aQ~ jß*“+ l›#q* æl³#³|*†.Û#.#q#³*‡ ôlø#4#³*µ q#?#³*Á Hq2#³#q*ÞZqP#³#?+* xqn#³#?+*  çl†#³6ä íl*ù Œ1¶#ß#1#¶x*9 j1ã#.#ß#1#¶*§ fqû#ûx*4Û1-#.#-#1#¶ß*ˆ õlP#4#³*~ ûlh#4*uq‹#.#1#?+*Ä ‚q©#?#?+*Æ lÆ#l#³*Ýmqè#³#?#È * ®q #³#?#È *t<q1#.#1#?#È *à ºqS#?#?#È *ògqp#?#È *¢ ¶q#?#È *°¹1¯#—#4#¶&˜÷.Ë#.#?&B  qç#?#?&“ ½q#?#?&™.#.#?&º ù1;#?#?*¼ T1b#.#1#?#bhm>tm8… ³‡q# ýˆq# „‰q# Šq# H‹q# åŒq# Âq# gŽq# Ñq# C’x#( “ß#0* 1+#?*I.M#.#?#1&ƒ £qn#?#?#1&À.#.#?#1*Õý1¶#—#¶#1#¶?&œ ý1Ø#?#?*î ¿;õ#?#õ.*• Æù#?#õ* .:#.#?#õ*  Ñx\#?#õ#q*ð Ö<~#?#õ#q&* Á1Ÿ#.#?#1*æ ‡q·#l*‹ BqÙ#?#?#1&û(.ú#.#?#1&{E.#.#?#1&‚.<#.#4#1*ßTqU#?+* qn#?+?g Ýg?Ž#?#4@õ õ?¯#?#??« ç« ?Ï#?#4@º º?ð#?#?@¯ 9¯ ?#?#4#1*Þ È3#?#õ* à¹U#?#õ#q*J çÐw#?#õ#q8¹ ëQÚ í‡ îq:j ôqµ#Q#W/eq øÿ6Ô#W#W/lt üÌ6ó#W#W@ ªq#b#b#ã@ Å ã5#b@ ,b[#b#ã#W@ë. ¼ h#h#b#ã@í h§#h#b#ã@j ÚhÍ#h#ã#ƒ@× Sƒé#n@„ žŽ#W@• "6&#n#nAeof &¢ŽBæ *oŽ#n=ƒ=]ƒ]ƒ=tŽ£`!6Ö ð!:—# ‹!;—# 9!A—# × !G—# ª!H—# ì!I—#( ‡!J—#0 5!K—#8 ž!L—#@ A!M—#H ¡!N#P ¥!O#Q !Q#R ê !S#S Ë!U#T !W#U Ô!^#V )!_#W !b#X æ !d#Y Ç!f#Z  !h#[ Ð!o#\ %!p#]&"!}—ò#q#ß,\!€ÿyÄ" q8» 7c9 :Ë9Ù;Ë9º ?=9ð @ËÎ qÎ q8Á 7¶9 :¶9Ù;¶9º ?=9ð @ËÎ <Î <<Þô #5<K#»×Ýf&U#°qþ#l#Á&)#Þl #l#Ì&+#ÛÌ1 #ß&W#¬ÁH #ß8Ç 7› 9 :å9Ù;å9º ?=9ð @ËÎ Î 8Í 7î 9 :î 9Ù;î 9º ?=9ð @ËÎ _Î __C& ¸"DAD¬D˜D D} DiD‘DâDüDœ D Dê D DŸ DöD;Ds DBDkD¡DSDû DØD” DnD{ DªD4 DVDD\DÊD' D; !D‡"D9 #D$D_%Dn &Dè'Dm (DÌ)D¬*D"+Dî,D8-D± .DŒ/DŽ0DÚ1D{ 2Dç 3Dý4Dÿ5Dü6Dþ7DQ8Dù 9DK:Du;Dz D[ ?D"ÀD/ÁDÊÂDôÃD‰ÄD² ÅDœÆDÐÇE) 0£#FÃ2ó #Gval3ß#H4£# 96®##I) 7# #´##ó #ß;8ë5#F#´##º##qJ}92ß_#f#À#J :òó #†#À#KØ;Kß›#À# ß®#L‰¸"=Æ#¸"Eä)@>©%FÓ4B—#FeCq#F»Dq# FO E´##   G•# y+Hq# 0isI– #(0ibJ—#0  5K6#8M› @ƒ qq$x$©%Nj A5Ž$•$©%JêLSÀ#®$µ$©%Iä)NÆ$Ò$©%#– Iä)[ã$ï$©%#—Ih% %©%q;*l™"%.%©%#J@ tßG%N%©%;d yàc%j%©%;c} %‹%©%#´#<•øœ%©%#º#Ë#O’*$®è%Pstr)— º+*è% F++´# Œ(,®#š’*$½¯%8)$Æ>& -)$Èq# Ë'$Éq# +$Êq# ê+$Ëq# 8)$Ìù%1¸*S_Q*ׇ&R´'ÙI&R +Úî%R='Û>&SÓ 6("9ã®;(¨(IûLú&'8(qJùOž& ','I(#,(JùRD©&E'Q'I(#2(J¸W ž&j'{'8(#<#ý;¶as$'¡'8(#(#<Jei“&º'Á'I(;ö#kº#Ö'ç'8(#(#2(;"/vü'(8(#('_Tp´#'_Tp´#´#'(´#=´#='(‡&=D(‡&O(‡&S %\M)"‡&#¾!%c,(¸!%d2(IÚ%k(—(M)IÚ%m¨(´(M)#S)Iä&%sÅ(Ò(M)q—#%hó(Ë%i¦ 7X%%h)Ë%iT(´#IŸ %q.):) 7M)#°:'_Tp´#'_Tp´#T(=Y)T(SÙ 6ò*"9ã®;ò*¨<ø*IüEœ)£)+IüG´)À)+#+IûLÑ)Þ)+qJùO³u)÷)* +#+JùRw€)*(* +# +J¸W)u)A*R*+#<#ý;¶a&g*x*+#ò*#<Je= j)‘*˜* +;ö#k %­*¾*+#ò*# +;"/va&Ó*ß*+#ò*'_Tp 7'_Tp 7¬þ*¬=¬=þ*^)=+^)&+^)S¦%\¦+"^)#IÚ%kQ+X+¦+IÚ%mi+u+¦+#¬+Iä&%s†+“+¦+q'_Tp 7'_Tp 7++=²+++¼=Ã+ T² £-UC¼#$à3ÿ(1éNT(V0F±&ò*, ,£-W &JB7,C,£-#ò*XÎQ,©-],d,£-XÎUÿ!½+~,…,¯-X÷%Y“å+Ÿ,¦,¯-X¥]gò+À,Ç,¯-ø`Ù,à,£-ødò,þ,£-#º-÷s--£-q;#&B2-9-£-YïzCO-V-£-­Õ+­ ,­þ+­…,­d,'_Tp´#oT('_Tp´#oT(È+= µ-È+=À-ò+T‰­ 5"È+#1¸´#1¾!»i(1¸!¼t(1k!½= 1–%¾C 1]!¿I 1c!ÀO 1"Áã1éÃT($äȬV ×Ù$ 5o.{.®##5’(.”.®#Z’(§.³.®##5Z’(.Æ.Ü.®##<#5#5’(;î.ú.®##(5JÖ&¹¯35//®##(5Yjª¥%5/F/®##<#5X¥Ñn;.`/g/95XÚr#ÿ-/ˆ/®#Xã .¢/©/95[endìõÿ-Ã/Ê/®#[endõV .ä/ë/95XþM$#.0 0®#XÐ%.&0-095X)$#.G0N0®#X€.h0o095XÈHÏ6‰0095Xã0MÊ/.ª0±095XR$/.Ë0Ò095;§&©ïç0ø0®##<#´#Xvƒt!ç-11®#Xv‹½ó-31:195X»“7ç-T1[1®#X»Ÿ,ó-u1|195Yq²’1ž1®##5Y™!Í´1»1®#Y¶Û{Ñ1Ý1®##5Yøõê ó1ú1®#J;#&cÐ"ÿ-2$2®##= #5Y;#Gÿ:2P2®##= #<#5Jõ&müÿ-i2u2®##= XõˆÙÿ-2 2®##= #= Y™6!¶2Â2®##D5Y&«Å Ø2ß2®#YTÁ‹õ23®##= #D5YTßÑ323®##= #D5#= YTH3c3®##= #D5#= #= ;‚&ï x3„3®##5Yê& Qš3¡3®#Y<&Ô·3Ã3®##D5Ẏ#Ù3à3®#YU+&b­$ö3ý3®#W[¶ñ4%4®##<#5Nb&Ïs;4L4®##<#5WQãÀc4y4®##= #= #= W8#é®4¡4®##= #5Wòúq¸4Ä4®##= W="Û4ç4®##D5'_Tp´#oT('_Tp´#oT(G.=5Û-=#5;.=.5Å-=Å-?5Å-=Å-<8= |è6 Ô¾f#à~P5®„(¾!…,(Iˆ‡œ5£5è6\ˆ‹µ5Á5è6#fJÌA€5Ú5á5î6J ”—u5ú56î6Jv˜›"ù66!6è6JvŸW"j5:6F6è6#qJ2 §ôù6_6f6è6J2 ®Ïj56‹6è6#qJ¦&¶G6¤6°6î6#ÿ6J¾º¥6É6Õ6î6#ÿ6'_Tp´#'_Tp´#P5ô6P5=j5=7j58¬i@7"š# l´##'_Tp´#'_Tp´#]…'¿Š7^'¿ß^‰)¿q^€)¿Š7^k+¿7^B¿©%î%>&-`'n—¿7.‹*n—.j)nß_'*< 8^Ø'—^š*ß`™)$abyyn <byyp ßcS''g•-8#ãd__p'g•ej%;8O8f° O8dn}´#©%gû(8.Þ'7.B©%dsße£58¥8f° ¥8d__x‹fè6eg/¸8Ã8f° Ã8®#eÀ)Ö8ë8f° ë8fæË+eu+þ89f° 9fæ˦+h" 5)9>9f° >9fæË·+eÁ'Q9r9f° r9d__pkž&.W,kw98(2(e‹)Š9•9f° ë8e@+£9®9f° 9eÞ¼9Ç9f° >9e9-Õ9à9f° à9£-eÇ,ó9þ9f° à9eé& :!:f° r9fæËe´(/:D:f° D:fæËM)eR*W:r:f° ë8d__pau)#j)e ,€:—:f° à9i__pJò*e´&¥:°:f° r9=¶:++e)Ò:â: 7f° D:#â:°:ed,õ:;f° ;¯-e…,;;f° ;ex*,;7;f° 7; +e(*J;e;f° ë8d__nWj)#ýeþ+s;~;f° à9jU ;'_Tp´#d__r+;,(eT.°;Õ;f° Ã8i__x×Õ;ab__pÙ 55ey4è;<f° Ã8^Z+éÿ-i__xé<akãë 55e©/,<7<f° Ã8eþ"E<b<f° '(dt7ó dv7ße{.p<{<f° Ã8lÞ Ÿ<^2 q^p qm¿7Ð@@ :=nÐ7  nÜ7" oè7Ù@p0÷<qñ7k qý7¡ r¿7ê@í@nÜ7 nÐ7³ sê@í@tè7uì*7q@$@Ö ‹>v '7J5Uv'7¾±v…*8‹>évn'8q2w`xÒ(:<{xÊ*;<³xÚ(<<‰x*?ßSy¿'A‘>‘xx)Dq|pc>zyyncq,w`x+jqux_)lq˜xµ)mqÚzyyxnq£wÀzyyp¥—%zyyi¦q^I& ß¡><{T80@c@wc?na8•nl8Ënw8|‹ 6@P@ý>nž J}T8P@c@nw8vsP@c@~l8~a8}‹ P@c@ž »}@Ÿe»1q?ˆ?f° Ã8i__xÛˆ?5e|1›?²?f° Ã8i__x²²?5€ß*ýÑ)qp@ÄG@™h²vBý©%ëù&æ e!@`;+í 'õ QF@Ç(gW @H'l@­*¢ 4G@$)û e!@)+· j"@L)Ö@Ÿ'X ` @ï&ûÃ@È)»S@wðx¼)q#y¨' î%‘€~y@) >&‘ð}xJ,qx­)q%x®(qTyw*h²‘àzx¨*‹>àx…* ‹>uy´+#x²‘ nx+$Š7XxÃ+%Š7ùy)(ˆ²‘ UxD*)7îxÛ+*7 x&'-˜²½!x8*/<•"zyyn1q#xw+2q¸$xn'4q(%xq*7î%«%x§+8>&ß8y)<¨²‘°~y'=—‘~y '><‘ ~xÕ+Eqw:pPãBxÊ*r<%;w€xb*—‹>m;xº(˜¸²£;pбBx‡+œ<ì;p ËBx‡+<2<wpx‡+ž<x<‚J@À@KHƒsvl†´#¾<|7<`@r@‚@CnX<ô<nO<=nE<<=„b<@°ƒ Cnp<_=…å9@ànó9_=…Ç9@bnÕ9‚=„c?–@@„§D~{?nq?2C†<–@€ÜéCn,<ZC…Ú;±@°Ü~þ;~ò;wàq <rK…¢;±@ënº;•Kw@qÇ;ÒO†e;±@pÙ{D…<;±@ GnT;UrC9È@Ü@Ü~f9n[9%U„7<¢@ЄÛDnX<JUnO<nUnE<’U„c?ó@ ˆîEn{?µUnq?áU†<ó@@ Ü(En,<ZC…Ú; @p Ünþ; V~ò;w  q <5V…¢; @Ð ënº;•Kw qÇ;ÒO†e; @0 Ù¾E…<; @` GnT;XVrC9$@8@Ünf9|Vn[9¨V„7<ø@ †"FnX<ÍVnO<ñVnE<W|c?E@{@Š8Gn{?KWnq?pW†<E@À ÜrFn,<ZC…Ú;J@ð Ünþ;«W~ò;w q <ÐW…¢;J@P ënº;•Kw€ qÇ;ÒO†e;J@° ÙG…<;J@à GnT;óWrC9X@k@Ünf9Xn[9(@–%TnX<ÏcnO<ócnE<d†c?P(@`˜Un{?;dnq?^d…Ú;P(@Ünþ;;d~ò;wÀq <”d…¢;P(@ðënº;•Kw qÇ;ÒO†e;P(@PÙæT…<;P(@€GnT;·drC9e(@x(@Ünf9Ûdn[9þd‡b<U(@\(@—Unp<#erå9U(@\(@nó9#erÇ9U(@\(@bnÕ9‚=‡7<¨(@º(@ºUnX<YenO<}enE<¢e†c?Ì(@°’«Vn{?Åenq?èe…Ú;Ì(@àÜnþ;Åe~ò;wq <f…¢;Ì(@@ënº;•KwpqÇ;ÒO†e;Ì(@ Ù{V…<;Ì(@ÐGnT;AfrC9á(@ô(@Ünf9efn[9ˆf‡b<Ñ(@Ø(@‘Wnp<­frå9Ñ(@Ø(@nó9­frÇ9Ñ(@Ø(@bnÕ9‚=‡7<$)@6)@ŠOWnX<ãfnO<gnE<,g†c?H)@Œ@Xn{?Ognq?rg…Ú;H)@0Ünþ;Og~ò;w`q <¨g…¢;H)@ënº;•KwÀqÇ;ÒO†e;H)@ðÙX…<;H)@ GnT;ËgrC9])@p)@Ünf9ïgn[9h‡b<M)@T)@‹«Xnp<7hrå9M)@T)@nó97hrÇ9M)@T)@bnÕ9‚=‡7< )@²)@„äXnX<mhnO<‘hnE<¶h†c?Ä)@P†ÕYn{?Ùhnq?üh…Ú;Ä)@€Ünþ;Ùh~ò;w°q <2i…¢;Ä)@àënº;•KwqÇ;ÒO†e;Ä)@@Ù¥Y…<;Ä)@pGnT;UirC9Ù)@ì)@Ünf9yin[9œi‡b<É)@Ð)@…@Znp<Áirå9É)@Ð)@nó9ÁirÇ9É)@Ð)@bnÕ9‚=‡7<*@.*@~yZnX<÷inO<jnE<@j†c?@*@ €j[n{?cjnq?†j…Ú;@*@ÐÜnþ;cj~ò;w q <¼j…¢;@*@0 ënº;•Kw` qÇ;ÒO†e;@*@ Ù:[…<;@*@À GnT;ßjrC9U*@h*@Ünf9kn[9&k‡b<E*@L*@Õ[np<Kkrå9E*@L*@nó9KkrÇ9E*@L*@bnÕ9‚=‡7<˜*@ª*@x\nX<knO<¥knE<Êk†c?¼*@ð zÿ\n{?íknq?l…Ú;¼*@ !Ünþ;ík~ò;wP!q <Fl…¢;¼*@€!ënº;•Kw°!qÇ;ÒO†e;¼*@à!ÙÏ\…<;¼*@"GnT;ilrC9Ñ*@ä*@Ünf9ln[9°l‡b<Á*@È*@yj]np<Õlrå9Á*@È*@nó9ÕlrÇ9Á*@È*@bnÕ9‚=†7<E+@@"nŸ]nX< mnO<7mnE<\m†c?u+@p"ͪ^~{?nq?m†Ú;u+@ "܇^~þ;~ò;wÐ"q <£m…¢;u+@#ënº;•Kw0#qÇ;ÒO†e;u+@`#Ù\^…<;u+@#GnT;ÆmrC9›+@ª+@Ü~f9n[9êmr<+@‘+@Ün,<ZC‡7<z+@+@Íã^nX<nnO<3nnE<Wn‡b<È+@Ï+@ËN_np<znrå9È+@Ï+@nó9znrÇ9È+@Ï+@bnÕ9‚=‡7<ã+@ù+@‚‡_nX<nnO<ÁnnE<æn†c? ,@À#„x`n{? onq?.o…Ú; ,@ð#Ünþ; o~ò;w $q <do…¢; ,@P$ënº;•Kw€$qÇ;ÒO†e; ,@°$ÙH`…<; ,@à$GnT;‡orC9 ,@3,@Ünf9«on[9Ðo‡b<,@,@ƒã`np<õorå9,@,@nó9õorÇ9,@,@bnÕ9‚=‡?C,@w,@…Øan¥?+pn›?Pp…Ú;G,@%³nþ;tp~ò;w@%q <™p…¢;G,@p%ënº;•Kw %qÇ;ÒO†e;G,@Ð%Ù¨a…<;G,@&GnT;¼prC9T,@g,@Ünf9àpn[9q‚‰,@˜-@æezsvl{´#*q‡7<˜,@®,@x7bnX<`qnO<„qnE<©q†b<½,@0&y˜bnp<Ìq…å9½,@`&nó9Ìq…Ç9½,@&bnÕ9‚=†?À,@À&z‰cn¥?rn›?,r…Ú;À,@ð&³nþ;Pr~ò;w 'q <ur…¢;À,@P'ënº;•Kw€'qÇ;ÒO†e;À,@°'ÙYc…<;À,@à'GnT;˜rrC9Ù,@ì,@Ünf9¼rn[9ár†c?-@(}dn{?snq?2s†<-@P(Ü×cn,<ZC…Ú; -@€(Ünþ;Zs~ò;w°(q <†s…¢; -@à(ënº;•Kw)qÇ;ÒO†e; -@@)Ùmd…<; -@p)GnT;©srC97-@K-@Ünf9Ísn[9ùs†7< -@ ){ÒdnX<tnO<BtnE<ftrc?X-@˜-@~n{?œtnq?Át†<X-@Ð)Üen,<ZC…Ú;]-@*Ünþ;üt~ò;w0*q <!u…¢;]-@`*ënº;•Kw*qÇ;ÒO†e;]-@À*Ùµe…<;]-@ð*GnT;DurC9k-@~-@Ünf9hun[9u‚˜-@§.@ôizsvlq´#²u‡7<§-@½-@nEfnX<èunO< vnE<1v†b<Ì-@ +o¦fnp<Tv…å9Ì-@P+nó9Tv…Ç9Ì-@€+bnÕ9‚=†?Ï-@°+p—gn¥?vn›?´v…Ú;Ï-@à+³nþ;Øv~ò;w,q <ýv…¢;Ï-@@,ënº;•Kwp,qÇ;ÒO†e;Ï-@ ,Ùgg…<;Ï-@Ð,GnT; wrC9è-@û-@Ünf9Dwn[9iw†c?.@-s«hn{?Žwnq?ºw†<.@@-Üågn,<ZC…Ú;/.@p-Ünþ;âw~ò;w -q <x…¢;/.@Ð-ënº;•Kw.qÇ;ÒO†e;/.@0.Ù{h…<;/.@`.GnT;1xrC9F.@Z.@Ünf9Uxn[9x†7<.@.qàhnX<¦xnO<ÊxnE<îxrc?g.@§.@tn{?$ynq?Iy†<g.@À.Ü-in,<ZC…Ú;l.@ð.Ünþ;„y~ò;w /q <©y…¢;l.@P/ënº;•Kw€/qÇ;ÒO†e;l.@°/ÙÃi…<;l.@à/GnT;ÌyrC9z.@.@Ünf9ðyn[9z‚§.@¶/@nzvblg´#:z‡7<¶.@Ì.@dSjnX<pznO<”znE<¹z†b<Û.@0e´jnp<Üz…å9Û.@@0nó9Üz…Ç9Û.@p0bnÕ9‚=†?Þ.@ 0f¥kn¥?{n›?<{…Ú;Þ.@Ð0³nþ;`{~ò;w1q <…{…¢;Þ.@01ënº;•Kw`1qÇ;ÒO†e;Þ.@1Ùuk…<;Þ.@À1GnT;¨{rC9÷.@ /@Ünf9Ì{n[9ñ{†c?$/@ð1i¹ln{?|nq?B|†<$/@02Üókn,<ZC…Ú;>/@`2Ünþ;j|~ò;w2q <–|…¢;>/@À2ënº;•Kwð2qÇ;ÒO†e;>/@ 3Ù‰l…<;>/@P3GnT;¹|rC9U/@i/@Ünf9Ý|n[9 }†7<)/@€3gîlnX<.}nO<R}nE<w}rc?v/@¶/@jn{?­}nq?Ò}†<v/@°3Ü;mn,<ZC…Ú;{/@à3Ünþ; ~~ò;w4q <2~…¢;{/@@4ënº;•Kwp4qÇ;ÒO†e;{/@ 4ÙÑm…<;{/@Ð4GnT;U~rC9‰/@œ/@Ünf9y~n[9ž~‡7<Ã/@Ñ/@^;nnX<Ã~nO<ç~nE< †?Õ/@5`,on¥?Bn›?g…Ú;Õ/@05³nþ;‹~ò;w`5q <°…¢;Õ/@5ënº;•KwÀ5qÇ;ÒO†e;Õ/@ð5Ùün…<;Õ/@ 6GnT;ÓrC9ë/@þ/@Ünf9÷n[9€‡7<'0@=0@[eonX<A€nO<e€nE<Š€†c?O0@P6[Vpn{?­€nq?Ѐ…Ú;O0@€6Ünþ;­€~ò;w°6q <…¢;O0@à6ënº;•Kw7qÇ;ÒO†e;O0@@7Ù&p…<;O0@p7GnT;)rC9d0@w0@Ünf9Mn[9p‡b<T0@[0@[Ápnp<•rå9T0@[0@nó9•rÇ9T0@[0@bnÕ9‚=‡7< 0@¶0@YúpnX<ËnO<ïnE<‚†c?È0@ 7Yëqn{?7‚nq?Z‚…Ú;È0@Ð7Ünþ;7‚~ò;w8q <‚…¢;È0@08ënº;•Kw`8qÇ;ÒO†e;È0@8Ù»q…<;È0@À8GnT;³‚rC9Ý0@ð0@Ünf9ׂn[9ú‚‡b<Í0@Ô0@YVrnp<ƒrå9Í0@Ô0@nó9ƒrÇ9Í0@Ô0@bnÕ9‚=‡c? 1@11@Uqsn{?Uƒnq?xƒ†Ú; 1@ð8ÜNsnþ;¯ƒ~ò;w 9q <Òƒ…¢; 1@P9ënº;•Kw€9qÇ;ÒO†e; 1@°9Ùs…<; 1@à9GnT;õƒrC91@&1@Ünf9„n[9<„r<1@1@Ün,<ZC‡b<G1@N1@SÜsnp<a„rå9G1@N1@nó9a„rÇ9G1@N1@bnÕ9‚=‡7<i1@{1@PtnX<„„nO<¨„nE<Ì„†c?1@:Pun{?ï„nq?……Ú;1@@:Ünþ;ï„~ò;wp:q <J……¢;1@ :ënº;•KwÐ:qÇ;ÒO†e;1@;ÙÖt…<;1@0;GnT;m…rC9¢1@µ1@Ünf9‘…n[9¶…‡b<’1@™1@Pqunp<Û…rå9’1@™1@nó9Û…rÇ9’1@™1@bnÕ9‚=‡c?Ï1@ö1@LŒvn{?†nq?4††Ú;Ï1@`;Üivnþ;k†~ò;w;q <Ž†…¢;Ï1@À;ënº;•Kwð;qÇ;ÒO†e;Ï1@ <Ù:v…<;Ï1@P<GnT;±†rC9Ý1@ë1@Ünf9Õ†n[9ø†r<Ô1@Ø1@Ün,<ZC‡b< 2@2@J÷vnp<‡rå9 2@2@nó9‡rÇ9 2@2@bnÕ9‚=‡7<.2@@2@F0wnX<@‡nO<d‡nE<‰‡†c?R2@€<F!xn{?¬‡nq?ч…Ú;R2@°<Ünþ;¬‡~ò;wà<q <ˆ…¢;R2@=ënº;•Kw@=qÇ;ÒO†e;R2@p=Ùñw…<;R2@ =GnT;*ˆrC9g2@z2@Ünf9Nˆn[9sˆ‡b<W2@^2@FŒxnp<˜ˆrå9W2@^2@nó9˜ˆrÇ9W2@^2@bnÕ9‚=|7<ª2@¼2@VÃxnX<ΈnO<òˆnE<‰„c?Î2@Ð=X³yn{?9‰nq?^‰…Ú;Î2@>Ünþ;9‰~ò;w0>q <”‰…¢;Î2@`>ënº;•Kw>qÇ;ÒO†e;Î2@À>Ùƒy…<;Î2@ð>GnT;·‰rC9ã2@ö2@Ünf9Û‰n[9Š|b<Ó2@Ú2@Wznp<%Šrå9Ó2@Ú2@nó9%ŠrÇ9Ó2@Ú2@bnÕ9‚=|7<&3@83@PSznX<[ŠnO<ŠnE<£Š„b<G3@ ?Q³znp<ÆŠ…å9G3@P?nó9ÆŠ…Ç9G3@€?bnÕ9‚=„c?\3@°?Rº{~{?nq?銆<\3@ð?Üüzn,<ZC…Ú;w3@ @Ü~þ;~ò;wP@q <‹…¢;w3@€@ënº;•Kw°@qÇ;ÒO†e;w3@à@ÙŽ{…<;w3@AGnT;4‹rC9Ž3@¢3@Ü~f9n[9X‹„7<h3@@ARî{nX<}‹nO<¡‹nE<Å‹|c?¹3@à3@K}n{?è‹nq? Œ†Ú;¹3@pAÜä|nþ;BŒ~ò;w Aq <eŒ…¢;¹3@ÐAënº;•KwBqÇ;ÒO†e;¹3@0BÙµ|…<;¹3@`BGnT;ˆŒrC9Ç3@Õ3@Ünf9¬Œn[9ÏŒr<¾3@Â3@Ün,<ZC|b<ö3@ý3@Ip}np<ôŒrå9ö3@ý3@nó9ôŒrÇ9ö3@ý3@bnÕ9‚=‡7<4@%4@'©}nX<nO<;nE<_‡7<;4@M4@%â}nX<‚nO<¦nE<ʇ7<c4@u4@#~nX<ínO<ŽnE<5Ž‡c?z4@¡4@6n{?XŽnq?{Ž†Ú;z4@BÜnþ;²Ž~ò;wÀBq <ÕŽ…¢;z4@ðBënº;•Kw CqÇ;ÒO†e;z4@PCÙä~…<;z4@€CGnT;øŽrC9ˆ4@–4@Ünf9n[9?r<4@ƒ4@Ün,<ZC‡b<·4@¾4@¡np<drå9·4@¾4@nó9drÇ9·4@¾4@bnÕ9‚=‡7<Ð4@Þ4@ÚnX<‡nO<«nE<χ7<ü4@5@€nX<nO<)nE<M‡7<$5@65@ L€nX<pnO<”nE<¸‡7<J5@`5@…€nX<ÛnO<ÿnE<#‘†c?r5@°Cvn{?F‘nq?i‘…Ú;r5@àCÜnþ;F‘~ò;wDq <Ÿ‘…¢;r5@@Dënº;•KwpDqÇ;ÒO†e;r5@ DÙF…<;r5@ÐDGnT;‘rC9‡5@š5@Ünf9æ‘n[9 ’‡b<w5@~5@ánp<.’rå9w5@~5@nó9.’rÇ9w5@~5@bnÕ9‚=|b<Á5@È5@ÿJ‚np<d’rå9Á5@È5@nó9d’rÇ9Á5@È5@bnÕ9‚=|c?Í5@ô5@ýcƒn{?‡’nq?ª’†Ú;Í5@EÜ@ƒnþ;á’~ò;w0Eq <“…¢;Í5@`Eënº;•KwEqÇ;ÒO†e;Í5@ÀEÙƒ…<;Í5@ðEGnT;'“rC9Û5@é5@Ünf9K“n[9n“r<Ò5@Ö5@Ün,<ZC|7< 6@6@öšƒnX<““nO<·“nE<Û“„?6@ FøŠ„n¥?”n›?6”…Ú;6@PF³nþ;Z”~ò;w€Fq <”…¢;6@°Fënº;•KwàFqÇ;ÒO†e;6@GÙZ„…<;6@@GGnT;¢”rC926@E6@Ünf9Æ”n[9ë”|7<n6@„6@óÁ„nX<•nO<4•nE<X•„c?–6@pGó±…n{?{•nq?ž•…Ú;–6@ GÜnþ;{•~ò;wÐGq <Ô•…¢;–6@Hënº;•Kw0HqÇ;ÒO†e;–6@`HÙ……<;–6@HGnT;÷•rC9«6@¾6@Ünf9–n[9>–|b<›6@¢6@ó†np<c–rå9›6@¢6@nó9c–rÇ9›6@¢6@bnÕ9‚=|7<é6@ó6@ïQ†nX<™–nO<½–nE<á–|7<7@#7@툆nX<—nO<(—nE<L—|7<57@C7@翆nX<o—nO<“—nE<·—|7<a7@s7@ãö†nX<í—nO<˜nE<5˜|7<‡7@7@à-‡nX<X˜nO<|˜nE< ˜„c?¯7@ÀHàˆn{?Ønq?昅Ú;¯7@ðHÜnþ;Ø~ò;w Iq <™…¢;¯7@PIënº;•Kw€IqÇ;ÒO†e;¯7@°IÙ퇅<;¯7@àIGnT;?™rC9Ä7@×7@Ünf9c™n[9†™|b<´7@»7@à†ˆnp<«™rå9´7@»7@nó9«™rÇ9´7@»7@bnÕ9‚=|7<8@8@ܽˆnX<á™nO<šnE<)š„c?+8@JÜ­‰n{?Lšnq?oš…Ú;+8@@JÜnþ;Lš~ò;wpJq <¥š…¢;+8@ Jënº;•KwÐJqÇ;ÒO†e;+8@KÙ}‰…<;+8@0KGnT;ÈšrC9@8@S8@Ünf9ìšn[9›|b<08@78@ÜŠnp<4›rå908@78@nó94›rÇ908@78@bnÕ9‚=|7<~8@8@ÚMŠnX<j›nO<Ž›nE<²›|7<«8@½8@Ø„ŠnX<Õ›nO<ù›nE<œ„c?Ï8@`KØt‹n{?@œnq?cœ…Ú;Ï8@KÜnþ;@œ~ò;wÀKq <™œ…¢;Ï8@ðKënº;•Kw LqÇ;ÒO†e;Ï8@PLÙD‹…<;Ï8@€LGnT;¼œrC9ä8@÷8@Ünf9àœn[9|b<Ô8@Û8@ØÝ‹np<(rå9Ô8@Û8@nó9(rÇ9Ô8@Û8@bnÕ9‚=|7<"9@49@ÖŒnX<^nO<‚nE<¦|c?99@`9@Ò-n{?Énq?ì†Ú;99@°LÜ nþ;#ž~ò;wàLq <Fž…¢;99@Mënº;•Kw@MqÇ;ÒO†e;99@pMÙÛŒ…<;99@ MGnT;ižrC9G9@U9@Ünf9žn[9°žr<>9@B9@Ün,<ZC|b<v9@}9@Жnp<Õžrå9v9@}9@nó9ÕžrÇ9v9@}9@bnÕ9‚=|7<“9@¥9@ÌÍnX<øžnO<ŸnE<@Ÿ‡7<»9@Í9@ŽnX<cŸnO<‡ŸnE<¬Ÿ‡7<ã9@õ9@?ŽnX<ÏŸnO<óŸnE< ‡7< :@:@xŽnX<; nO<_ nE<„ ‡7<3:@E:@±ŽnX<§ nO<Ë nE<ð ‡7<[:@m:@ÿêŽnX<¡nO<7¡nE<\¡‡7<ƒ:@•:@ý#nX<¡nO<£¡nE<È¡‡7<«:@½:@û\nX<ë¡nO<¢nE<4¢|7<Ó:@å:@¥“nX<W¢nO<{¢nE<Ÿ¢|7<û:@ ;@¡ÊnX<¢nO<æ¢nE< £|7<(;@:;@›nX<-£nO<Q£nE<u£„c?L;@ÐMñn{?˜£nq?½£…Ú;L;@NÜnþ;˜£~ò;w0Nq <ó£…¢;L;@`Nënº;•KwNqÇ;ÒO†e;L;@ÀNÙÁ…<;L;@ðNGnT;¤rC9a;@t;@Ünf9:¤n[9_¤|b<Q;@X;@œZ‘np<„¤rå9Q;@X;@nó9„¤rÇ9Q;@X;@bnÕ9‚=|7<¤;@¶;@•‘‘nX<º¤nO<Þ¤nE<¥„b<Å;@ O–ñ‘np<%¥…å9Å;@POnó9%¥…Ç9Å;@€ObnÕ9‚=„c?Ú;@°O—ø’~{?nq?H¥†<Ú;@ðOÜ:’n,<ZC…Ú;õ;@ PÜ~þ;~ò;wPPq <p¥…¢;õ;@€Pënº;•Kw°PqÇ;ÒO†e;õ;@àPÙÌ’…<;õ;@QGnT;“¥rC9 <@ <@Ü~f9n[9·¥„7<æ;@@Q—,“nX<Ü¥nO<¦nE<$¦|7<M<@_<@c“nX<G¦nO<k¦nE<¦„b<n<@pQÓnp<²¦…å9n<@ Qnó9²¦…Ç9n<@ÐQbnÕ9‚=„c?ƒ<@R‘Ê”~{?nq?Õ¦†<ƒ<@@RÜ ”n,<ZC…Ú;ž<@pRÜ~þ;~ò;w Rq <ý¦…¢;ž<@ÐRënº;•KwSqÇ;ÒO†e;ž<@0SÙž”…<;ž<@`SGnT; §rC9µ<@É<@Ü~f9n[9D§„7<<@S‘þ”nX<i§nO<§nE<±§‚à<@>@P™ˆe+z´#Ô§|7<ö<@=@v[•nX< ¨nO<.¨nE<R¨„b<=@ÀSw»•np<u¨…å9=@ðSnó9u¨…Ç9=@ TbnÕ9‚=„c?,=@PTx–~{?nq?˜¨†<,=@TÜ–n,<ZC…Ú;G=@ÀTÜ~þ;~ò;wðTq <À¨…¢;G=@ Uënº;•KwPUqÇ;ÒO†e;G=@€UÙ––…<;G=@°UGnT;ã¨rC9^=@r=@Ü~f9n[9©„7<8=@àUxö–nX<,©nO<P©nE<t©„c?‰=@V| ˜n{?—©nq?é†<‰=@PVÜC—n,<ZC…Ú;£=@€VÜnþ;ë©~ò;w°Vq <ª…¢;£=@àVënº;•KwWqÇ;ÒO†e;£=@@WÙÙ—…<;£=@pWGnT;:ªrC9º=@Î=@Ünf9^ªn[9Šª„7<Ž=@ Wz=˜nX<¯ªnO<ÓªnE<÷ª}c?Û=@>@~n{?-«nq?R«†<Û=@ÐW܉˜n,<ZC…Ú;à=@XÜnþ;«~ò;w0Xq <²«…¢;à=@`Xënº;•KwXqÇ;ÒO†e;à=@ÀXÙ™…<;à=@ðXGnT;Õ«rC9î=@>@Ünf9ù«n[9¬‚>@V?@¢ˆû*m´#C¬|7<1>@C>@i­™nX<y¬nO<¬nE<Á¬„b<R>@ Yj šnp<䬅å9R>@PYnó9䬅Ç9R>@€YbnÕ9‚=„c?g>@°Yk›~{?nq?­†<g>@ðYÜVšn,<ZC…Ú;‚>@ ZÜ~þ;~ò;wPZq </­…¢;‚>@€Zënº;•Kw°ZqÇ;ÒO†e;‚>@àZÙèš…<;‚>@[GnT;R­rC9™>@­>@Ü~f9n[9v­„7<s>@@[kH›nX<›­nO<¿­nE<ã­„c?Ä>@p[o[œn{?®nq?2®†<Ä>@°[Ü•›n,<ZC…Ú;Þ>@à[Ünþ;Z®~ò;w\q <†®…¢;Þ>@@\ënº;•Kwp\qÇ;ÒO†e;Þ>@ \Ù+œ…<;Þ>@Ð\GnT;©®rC9õ>@ ?@Ünf9Í®n[9ù®„7<É>@]mœnX<¯nO<B¯nE<f¯}c??@V?@qn{?œ¯nq?Á¯†<?@0]ÜÛœn,<ZC…Ú;?@`]Ünþ;ü¯~ò;w]q <!°…¢;?@À]ënº;•Kwð]qÇ;ÒO†e;?@ ^Ùq…<;?@P^GnT;D°rC9)?@³rå9i@@p@@nó9>³rÇ9i@@p@@bnÕ9‚=‡7<„@@š@@8S¡nX<a³nO<…³nE<ª³†c?¬@@b:D¢n{?ͳnq?ò³…Ú;¬@@ÀbÜnþ;ͳ~ò;wðbq <(´…¢;¬@@ cënº;•KwPcqÇ;ÒO†e;¬@@€cÙ¢…<;¬@@°cGnT;K´rC9Á@@Ô@@Ünf9o´n[9”´‡b<±@@¸@@9¯¢np<¹´rå9±@@¸@@nó9¹´rÇ9±@@¸@@bnÕ9‚=‡c?ä@@$A@;Ç£n{?ï´nq?µ†<ä@@àcÜ£n,<ZC…Ú;é@@dÜnþ;Oµ~ò;w@dq <tµ…¢;é@@pdënº;•Kw dqÇ;ÒO†e;é@@ÐdÙ—£…<;é@@eGnT;—µrC9÷@@ A@Ünf9»µn[9േb<?A@FA@12¤np<¶rå9?A@FA@nó9¶rÇ9?A@FA@bnÕ9‚=†c?WA@0e1¥~{?nq?(¶…Ú;WA@`eÜ~þ;~ò;weq <M¶…¢;WA@Àeënº;•KwðeqÇ;ÒO†e;WA@ fÙ뤅<;WA@PfGnT;p¶rC9tA@ƒA@Ü~f9n[9”¶‡7<\A@oA@1P¥nX<¹¶nO<ݶnE<·†c?®A@€f/[¦~{?nq?$·†Ú;®A@°fÜ8¦~þ;~ò;wàfq <H·…¢;®A@gënº;•Kw@gqÇ;ÒO†e;®A@pgÙ ¦…<;®A@ gGnT;k·rC9ÔA@ãA@Ü~f9n[9·r<ÆA@ÊA@Ün,<ZC‡7<³A@ÆA@/”¦nX<´·nO<Ø·nE<ü·‡7<B@B@+ͦnX<¸nO<C¸nE<g¸‡7<-B@?B@)§nX<Š¸nO<®¸nE<Ò¸‚DB@B@}§ƒnE´#õ¸„7<SB@ÐgE^§nX<¹nO<D¹nE<h¹‰-8`B@hEnE8‹¹|7<•B@§B@Ç´§nX<®¹nO<Ò¹nE<ö¹„c?¹B@0hɤ¨n{?ºnq?>º…Ú;¹B@`hÜnþ;º~ò;whq <tº…¢;¹B@Àhënº;•KwðhqÇ;ÒO†e;¹B@ iÙt¨…<;¹B@PiGnT;—ºrC9ÎB@áB@Ünf9»ºn[9àº|b<¾B@ÅB@È ©np<»rå9¾B@ÅB@nó9»rÇ9¾B@ÅB@bnÕ9‚=|7<C@#C@ÁD©nX<;»nO<_»nE<ƒ»„b<2C@€i¤©np<¦»…å92C@°inó9¦»…Ç92C@àibnÕ9‚=„c?GC@jëª~{?nq?É»†<GC@PjÜí©n,<ZC…Ú;bC@€jÜ~þ;~ò;w°jq <ñ»…¢;bC@àjënº;•KwkqÇ;ÒO†e;bC@@kÙª…<;bC@pkGnT;¼rC9yC@C@Ü~f9n[98¼„7<SC@ kÃߪnX<]¼nO<¼nE<¥¼|7<ºC@ÌC@»«nX<ȼnO<ì¼nE<½„b<ÛC@Ðk¼v«np<3½…å9ÛC@lnó93½…Ç9ÛC@0lbnÕ9‚=„c?ðC@`l½}¬~{?nq?V½†<ðC@ lÜ¿«n,<ZC…Ú; D@ÐlÜ~þ;~ò;wmq <~½…¢; D@0mënº;•Kw`mqÇ;ÒO†e; D@mÙQ¬…<; D@ÀmGnT;¡½rC9"D@6D@Ü~f9n[9Ž„7<üC@ðm½±¬nX<ê½nO<¾nE<2¾|7<^D@pD@·è¬nX<U¾nO<y¾nE<¾„?†D@ n³Ø­n¥?À¾n›?å¾…Ú;†D@Pn³nþ; ¿~ò;w€nq <.¿…¢;†D@°nënº;•KwànqÇ;ÒO†e;†D@oÙ¨­…<;†D@@oGnT;Q¿rC9ªD@½D@Ünf9u¿n[9š¿|7<‹D@•D@±®nX<¿¿nO<ã¿nE<À|7<èD@úD@­F®nX<*ÀnO<NÀnE<rÀ|7<E@"E@©}®nX<•ÀnO<¹ÀnE<ÝÀ‡7<6E@LE@ ¶®nX<ÁnO<$ÁnE<IÁ†b<[E@po ¯np<lÁ…å9[E@ onó9lÁ…Ç9[E@ÐobnÕ9‚=†c?pE@p °~{?nq?Á†<pE@@pÜa¯n,<ZC…Ú;‹E@ppÜ~þ;~ò;w pq <·Á…¢;‹E@Ðpënº;•KwqqÇ;ÒO†e;‹E@0qÙó¯…<;‹E@`qGnT;ÚÁrC9¢E@¶E@Ü~f9n[9þÁ†7<|E@q T°nX<#ÂnO<GÂnE<kÂ|7<ãE@õE@\‹°nX<ŽÂnO<²ÂnE<Ö„c?F@Àq^{±n{?ùÂnq?Ã…Ú;F@ðqÜnþ;ùÂ~ò;w rq <TÃ…¢;F@Prënº;•Kw€rqÇ;ÒO†e;F@°rÙK±…<;F@àrGnT;wÃrC9F@/F@Ünf9›Ãn[9ÀÃ|b< F@F@]ä±np<åÃrå9 F@F@nó9åÃrÇ9 F@F@bnÕ9‚=‡‹ 4G@LG@p ²nž Ć7<–G@sl@²nX<GÄnO<sÄnE<˜Äw@sx)g ß»Äx ,h q\Å _x²<Ç ¯%ˆ²<Ç ù%˜²<Ç ù%¨²< ¸²<U&Š*,@>@Íų…{<@ s ‹’<ÿÿŒ†<µ ©§A ª§ C1³Ž<@yê(%G³  ‡@³ ß\³<`yL+Ÿr³ àº`L³ C‡³<xyÅ*ʳ  @w³yI*ܸ³  @w³ Cͳ<Þyá+ðã³ @Œ@½³ _ø³<yU) ´ `Ž@è³ _#´<ÞyÀ(9´ `…@´y *2T´  Ž@è³ Ck´Ž<9y}*=´ ‹@Y´ _˜´Ž<9yâ(g®´ €ˆ@†´kó)¿´½³‚ •u ÈÄ`‘NY€€€€€€€€€’[Uÿÿÿÿÿÿÿ‘€€€€x“). ÿÿÿ”–@”a D‘§ A €€~•´ £ÿ.DÙT-7 À…Ñc4Ô<ÖA ™ÛC · ~)qinttvx&ŽxJ ¿ 1¯»Ø |n q#ó —#G —#b —#ç —# s —#(3 —#0B —#8’ —#@þ —#H` !—#P "—#Xº $­#`` &³#hÕ (q#p~ ,q#t© .#xˆ 2J#€G 3X#‚K 4¹#ƒ– 8É#ˆ­ AŠ# J•#˜– K•# ç L•#¨£ M•#°ª N1#¸Ì Pq#À9 RÏ#Ä A¯  Tz Ï  W²  YQ  ]Ï O Uq# W ^“# ß<| _‡   E # Ý ß#Ã ê³  c x Q# ¨ Q# Æ •# Ø •#^ ¶ß ¼¡ Ó$ ½¡# P ¾§# F Âq#j¯j¯ É<c ß<åÆ oq c€+# ö(dq#remeq#+fú k'W ö(lx#remmx#‘'n. w4'‹ ö(x‹#remy‹#o5'zbÑ™+æ°¶qÊÊÊи,}•81³çíj4@ৠ5â²# 2ä—# T/å—# ¹2ê§# 2ïq# ž3õq#$ š5üq#(º4q#,.q#0ä5q#4. q#87 q#<`4Û1¤Ù/aCã-cqstd } ^¤_êa} b‘ c¨ dÀ eØ fï g h* iK jh m“ n× pù q rC t[ us v€ w— x« zË |â }ù ~ €) B ‚i „† …“ †ª ‡Ç ˆî ‰ °ô³f#gWk<l[mzn’oªqÖtóv y(zE{s}•~¸€ÆÚ‚üƒ„>†V‡‚Î’ÑuÔÕž×»ØÙÓÚôÛ81c4›<6 œxÁ BBÞÒé‘’A“^”{•˜–¶—Ô˜ì™úš"›Iœl™ž¶ Î¢ñ£¤,¦N©p¬—®¹°Ö²ó³´1µM¶i·…¸¡¹yº‘»³¼Ô½õ¾"¿>ÁaÃ~Ä ÅÂÆäÇÈÉ?Ê`Ë̢ͻÎÔÏôÐÑ5ÒV | ™ »™ 7ß8<9X‹  Ò í k›  nÒ ç î !!Ñ ü ! qT2U'VÒ^Hgdj€k—"Y #Ê #Ý$ïXŠ< $ã'%0K® &± 7‘ ²'T îq¨ ²(¶ 9qÀ ²(Ò ;qØ ²'á óqï ²(ß q ²(| q$ ²$ ê' õ—K —q²(, ²h ßß)Õ`q“ *+}1`²+ `ß*,1 1× -—.•-á01.__n1-}1²(O ²ù ßß²(Æ êq ²xq( q8 ²8 > ê( ïx[ ²(à qs ²/‡-q' â—— —&÷ K« ß)ÖgqË *+ gß*'MPqâ q'‚ ³qù ß'> µq ßß& ô) ²&ð MB ²—(p Qqi ²—q1'V q† —ß*/c IJ'ß Ò—ª —(^ »qÇ q²'Ô}qè ²ßè '¾sq ßè 'U,q+—ßè 0A•ô¦ô©£’¶žÁ»ÂÓÃôÅÆ81abs­N*‹‹1div³ö+’°‹‹*¾+Éú|™»  W¨'P>q—1ß*'OKq<—1ßè (§(qTTZ2(v'ssßY ({'q’ß(€'!xªß(3+ó•ÖÊÊ11¤3div#óqq(­+7— ß(Æ'W(xx()\qEß1'h*r1ffß1l”(’+_q•fß1&T+ù¸•11¤4*|q&*~ÚQ'g'¥sößö—'Ø*¸xßöq'p)¼<>ßöq(1*ÍqVß')‘1w—w1}l'˜'Tqž—l(Å'’»‹‹(#+*‹Óß'Ÿ(Ò‹ôßöq'!,×ßöq'Ñ*­11ßöv'—(°TTßöT 08n59·”n6¾7Í7 :Í7Ù;Í7º ?u7ð @õ#Î x#Î xxÑaQ~ jß(“+ Òq( æÒ|(†fAfq(‡ ôÒ^l(µ q{w(Á Hq˜q(ÞZq¶w*( xqÔw*(  çÒì4ä íÒ(ù Œ1ß1Þ(9 j1Ifß1(§ fqaagÞ(4Û1“f“1ß(ˆ õÒ¶l(~ ûÒÎl(uqñf1w*(Ä ‚qww*(Æ Ò,Ò(ÝmqNwè ( ®qpwè (t<q—f1wè (à ºq¹wwè (ògqÖwè (¢ ¶qówè (°¹1—l'˜÷f1fw'B  qMww'“ ½qiww'™f…fw'º ù1¡ww(¼ T1Èf1wÈÎÓ8tm8…y ³‡q# ýˆq# „‰q# Šq# H‹q# åŒq# Âq# gŽq# Ñq# C’x#( “ß#0( 1‘w(If³fw1'ƒ £qÔww1'Àfõfw1(Õý1—1w'œ ý1>ww(î ¿s[w[f(• Æ1~w[( f fw[(  ÑxÂw[q(ð Ö<äw[q'* Á1fw1(æ ‡qÒ(‹ Bq?ww1'û(f`fw1'{Effw1'‚f¢fl1(ßTq»w*( qÔw*9g Ýgwôwl:õ õwww9« ç« w5wl:º ºwVww:¯ 9¯ w|wl1(Þ ÈT™w[( à‹»w[q(J çÝw[q6‰ ë·Ú í‡îq;jôq·½1eqøÿn:½½1ltüÌnY½½: ªqÈȾ: Å ¾›È:,ÈÁȾ½:ë. ¼ ÎçÎȾ:íÎ ÎȾ:jÚÎ3ξé:× SéOÔ:„žôk½:•"nŒÔÔ<eof&¢ô=æ*oôÔ>é>ÃéÃé>Úô£` 6< ð :—# ‹ ;—# 9 A—# × G—# ª H—# ì I—#( ‡ J—#0 5 K—#8 ž L—#@ A M—#H ¡ N#P ¥ O#Q Q#R ê S#S Ë U#T W#U Ô ^#V ) _#W  b#X æ d#Y Ç f#Z  h#[ Ð o#\ % p#]'" }—Xqß/\ €eßÄ! q6Û7É7 :õ7Ù;õ7º ?u7ð @õ#Î q#Î q6á77 :7Ù;7º ?u7ð @õ#Î <#Î <<® ô "5<K"»=Cf'U"°qdÒ'')"ÞÒ€Ò2'+"Û2—ß'W"¬'®ß6ç7 7 :å7Ù;å7º ?u7ð @õ#Î #Î 6í7T 7 :T 7Ù;T 7º ?u7ð @õ#Î _#Î __?& "@A@¬@˜@ @} @i@‘@â@ü@œ @ @ê @ @Ÿ @ö@;@s @B@k@¡@S@û @Ø@” @n@{ @ª@4 @V@@\@Ê@' @; !@‡"@9 #@$@_%@n &@è'@m (@Ì)@¬*@"+@î,@8-@± .@Œ/@Ž0@Ú1@{ 2@ç 3@ý4@ÿ5@ü6@þ7@Q8@ù 9@K:@u;@z <@t =@è>@[ ?@"À@/Á@ÊÂ@ôÃ@‰Ä@² Å@œÆ@ÐÇA) 0 #BÃ2Y #Cval3ß#D4 # 96##E) 7u"†" #Y ßF8ë›"¬" # #qG}92ßÅ"Ì" &#G :òY å"ì" &#HØ;Kß# &# ß#IY ">_ ,#"Aä)@>%BÓ4B—#BeCq#B»Dq# BO E##   G•# y+Hq# isI²#(ibJ—#0  5Kn#8J› @ƒ q×#Þ# %Kj A5ô#û# %GêLS&#$$ %Eä)N,$8$ %²Eä)[I$U$ %—Ehf$s$ % qF*l™ˆ$”$ %G@ tß­$´$ %Fd yàÉ$Ð$ %Fc} å$ñ$ %#L•ø% % #1#M’*$®N%Nstr#)— º+#*N% F+#+# Œ(#,#j ’*$½%8)$Ƥ% -)$Èq# Ë'$Éq# +$Êq# ê+$Ëq# 8)$Ì_%Ú4 "9'­7&%#¬5)²#ã4)²##0*1#ž0+1# ¼1,9'#(14-#02.q#4$-/q#8ñ50—#@±21q#H022q#L 13q#P5.4q#Td-5q#X¼66?'#`á/7Ä#h{,8—#pû3:q#xl3;q#|Ø0=—#€ />q#ˆ>4?q#Œ%3AE'#1CK'#˜ÜqT%¤%O], w'.msg ß-$. ÑP´$…''Q° '%)M•É'+‹*M•+Ú6Mq+Ú2M1R2‚ qõ'-$.‚ ÑSTyyg„ õ'¯%Uí0f q4(-y-f %-Ë6f 4(SVH7i ¯%ÑOà2Ó|(-$.ÓÑSV6ÕqTyygÖõ'SV”3ïqP”$Š(•(Q° 'RŒ7WÄñ(-r7WÄ-$.WÑSV.YqTyygZõ'V21[—Vè0]¸WÞ )+2˜q+p˜qXJ46Ä°@T@Æœ)Y$.6ÑUZ±@R@[r78ÄeÆ[219—éÆ\yyg:õ'U]t[è0@¸IÇ^Q'ÐG@þG@lÇí)_^'¤Ç`h ÔG@@tƒ a† á}@Ÿb{ O²0"*-$."ÑSTyyg$õ'cÅ2‚_/H@rH@w­*db‚ÜUY$.‚ÑTZH@rH@\yyg„õ'Teí)PH@rH@—aú)TZPH@rH@f*Tg4- ä3%€H@„H@w+Y$. ÑUZ€H@ƒH@\yygŸ õ'Ug3¦ |3qH@­H@w]+h$.¦ ÑÚÇZH@«H@\yyg¨ õ'Ug6³ 4q°H@ÍH@w¶+h$.³ ÑÈZ°H@ËH@\yygµ õ'Ugz4À 1²ÐH@ÕH@w ,Y$.À ÑUZÐH@ÔH@\yyg õ'Ug‚0É ­/²àH@åH@wd,Y$.É ÑUZàH@äH@\yygË õ'Ug\3Ò 70qðH@ôH@w»,Y$.Ò ÑUZðH@óH@\yygÔ õ'Ug¯3Ü .—I@I@w-Y$.Ü ÑUZI@I@\yygÞ õ'Uc˜-æ H2I@I@ws-Y|-æ %UY$.æ ÑTZI@I@\yygè õ'Tie0ð V6 I@NI@FÈÏ-h 5ð q¦Èh$.ð ÑÉÈ]ptjyygò õ'ìÈiŒ6ÿ H.PI@~I@É+.hM0ÿ qoÉh$.ÿ Ñ’É] tjyyg õ'µÉcW0 ž6€I@…I@wŒ.Y™1 ²UY$. ÑTZ€I@„I@\yyg õ'Tc‰- A5I@•I@wí.Yä1 ²UY$. ÑTZI@”I@\yyg õ'Tg7 p2q I@¤I@wD/Y$. ÑUZ I@£I@\yyg õ'UcU7" û2°I@´I@w¥/Yü6" qUY$." ÑTZ°I@³I@\yyg$ õ'Tg’,* ü5E'ÀI@ÈI@wü/Y$.* ÑUZÀI@ÇI@\yyg, õ'Ucñ-0 {5ÐI@ØI@w]0YŒ10 E'UY$.0 ÑTZÐI@×I@\yyg2 õ'Tg06 ë4K'àI@èI@w´0Y$.6 ÑUZàI@çI@\yyg8 õ'Uc7< 76ðI@øI@w1YG/< K'UY$.< ÑTZðI@÷I@\yyg> õ'Tg¿3Ù -5•J@J@w^1hã0Ù §ØÉh$.Ù ÑûÉ^û'J@ºK@Ê2_ (rË_(áËkÐt 1f&(‘À~`û'ŽJ@@uf _(PÌ_ (™Ì]pul&(`É'œJ@ u _Ú'âÌ]Ðumç'âÌno6I Â/qÀK@*M@Íw2hË6I 4(¶ÍeÉ')L@}L@[ _Ú'%ÎZ)L@}L@mç'%ÎO`5eÁ2.beÜ- 5e²-$.eÑSV 1hqTyygiõ'nÄ41ð.Ü0M@3N@IÎw3h 51²©Îhã01qòÎh$.1Ñ(Ï]vjb3ÜqÏ`w2˜M@`vD_š2ÍÏ_Ž2ðÏ_„2Ð]vm§2IÐm³2€Ðgl,Þ Ì1•@N@EN@wÐ3optrÞ •£Ðhã0Þ §ÆÐh$.Þ ÑéÐp‘2U PN@êN@ Ñ=4h5U q¼Ñh$.U ÑÒ]ÀvjyygW õ'aÒ]ðv[ƒ7Z §ªÒiˆ4³5ðN@ Q@àÒU5h'1ÜÓh$.ÑÙÓ] wjyygõ'ÙÓq:(÷N@`w &5_G(ÙÓkÀwã4mT("Ôm`(ÙÓ] xmm(`Ôe:(˜P@ÈP@_G(¬ÔZ˜P@ÈP@mT(ÏÔl`(`í)~O@`x_ú)óÔ]xm*óÔnH1 */ÜQ@áQ@ÕÃ5hk —vÕhã0 §ÒÕh$. Ñ0Ö]Àxjb ÜŒÖn47 ß6ÜðQ@èR@èÖ]6hÁ,7 ßè×h±-7 qDØh$.7 Ñ¢Ø]yjb9 ÜëØjbuf: —!Ùjn; §jÙji< q ÙnŒ/* a.ÜðR@$S@ØÙ§6hš** ß$Úh$.* ÑmÚi- Ò,0S@tU@¶Ú¿7h'1 ÜfÛh$. Ñ¯Û]`yjyyg¢õ'øÛq:(CS@ y¦7_G(AÜkzM7mT(wÜm`(AÜ]`zmm(µÜe:(ðT@(U@ _G(ÝZðT@(U@mT($Ýl`(`í)ÐS@ z·_ú)HÝ]Ðzm*HÝi92ð¬.€U@èW@kÝ9h5ð²ËÝh$.ðÑÞ]{jyygòõ']Þqw2ÅU@@{úe8_š2¦Þ_Ž2ÉÞ_„2ìÞ]p{m§2ßm³2Fßqí)1V@ {û–8_ú)iß]Ð{m*iß`:(V@|õaG(Sk0|Ú8mT(Œßf`(S]p|mm(Êße:(xW@«W@ð_G(àZxW@«W@mT(%àl`(Ps$-9A9Q° 'rclO‘0n i9-$.n ÑSTyygp õ'R$6¯q/:-$.¯ÑSTyyg±õ'V*²—V..³—Vá.´qTi´qV©-µqs:VÌ0Þqs:TbåÜVŸ2çqSVƒ7ìqSTc qTn 1SVƒ7%§nw0%7qðW@tv@Ià@hŒ1E'›áhG/K'8âh$.ÑÑât‡2ht~.QtÉ,=] |[r7Äã[21 —Ûã[ 0 —xä[t5 qëjyyg õ'<ñu9[@Ð|y;_79…ñ_-9½ñu9y[@}zI;_79ò_-9Qòu9½[@0}xs;_79›ò_-9Óòu9\@`}w;_79ó_-9Wóv« e@e@€Â;_¾ ¡ók}]=[\1*qÍóqi9Èk@~kë<_z9Dô]À~m‡9Dôm“9 ômŸ9õm«9põm·9ÐõmÁ9ökpÎ<mÒ9fök°t<mã9Q÷mí9š÷]ðmú9ó÷w“ Jr@^r@ µ<_Ê 3ø_¾ Wø_¦ ¦ø_² Ñø]0€m :ùm:~ùZv@tv@m :ÈùZst@&u@xÖ3IÄP`•(’t@`€X_²( ú_¦(.ú]€m¿(QúmË( úm×(úmã(¦úu|(wl@À€p¤=_Š(Êúy9wl@u_79û_-9Êúzw'¡l@¬l@pvA9¬l@Þl@qû=_N9LûZ¬l@Þl@m[9Lûu|(ÿl@@{B>_Š(oûy9ÿl@€u_79¹û_-9oûzw')m@4m@{uA94m@À|‰>_N9ñû]ðm[9ñûu9‡m@ ‚n³>_79ü_-9Nüv« n@$n@}Ø>_¾ ˜üu9tn@P‚m?_79Äü_-9þü{hX@ÓX@(?[è0@¸Hýk€‚B?jyyl^q†ýqí)þY@Ђ-s?_ú)ªý]ƒm*ªý`:(SZ@0ƒ(_G(Íýk€ƒ»?mT(þm`(Íý]Àƒmm(Tþe:(Z@ËZ@_G(ŒþZZ@ËZ@mT(¯þl`(cf7ê ù/€v@…v@wE@optrê •Óþh$.ê ÑöþiË.M.3v@w@ÿŸ@obMÜÿh$.MÑüÿ]ðƒjyygOõ'üÿiì1¿¾-w@šw@~Ah$.¿ÑÞ]0„jyygÁõ'Þ`í)^w@p„Ë_ú)'] „m*'n/¤ ¡4q w@hx@J•Ah$.¤ Ñ–]Єjyyg¦ õ'à`É' x@…¹ _Ú']@…mç'|½#…px@óx@9¸AÇA}° 'Á~Þ#•y@ y@wéAøA}° '2E-@@n@U:Byñ(@@€…˜€)ÿÿü(‚µ ©§‚A ª§‚)2 «§ _vBƒ<òxÌ3ŒB  —@dB q¡B<ÿx†1º·B  “@‘B qÌB<9x%5ÚâB  Ÿ@¼B _ùBƒ<øx-äC   @çBxÜ- *C  ›@çB _ACƒ<yxv1\WC  ©@/Cx--¦rC  ¤@/C q‡C<Tx¢,ñC  ®@wC„‚ •…p ÌÄ`††Y€€€€€€€€€‡“Uÿÿÿÿÿÿÿ†‚€€€€xˆ. ÿÿÿ‰ü@‰ÇD† A €€~Š £ÿ% RU$ > : ; I$ >   II!I/  : ; : ;I8  : ; ‡@  : ;  : ; I : ; I8  : ; : ; &I: ;I9: ; : ; : ;9: ; <  : ; ( <  : ; : ;I? 2 < .? : ;< dI4 .? : ;< d < !.? : ; ‡@I< d"I#/I$.? : ;‡@I< d%< &.? : ; I< '.? : ;I< (4: ; ‡@I? < )4: ; I< *+.? : ;I< , : ; -.? : ; ‡@I< ..? : ;‡@I< /9: ; 0:: ; 1G : ; 2.? : ; ‡@< 3.? : ; ‡@I< 4.? : ;‡@I< 5.? : ;‡@I< 6 I7.? : ; I< 8 : ; I? < 9.? : ;< :.? : ; I 4 ;: ; I< : ; = : ; I8 2 > : ; I8 2 ? : ; I? 2 < @.? : ; < dA.? : ; ‡@< dB.? : ; ‡@I< dC!D : ; I8 E.? : ; ‡@I2 < dF.? : ; ‡@2 < dG.? : ; ‡@< dH.G dII4 J.G K: ; IL: ;IMIN: ;IO.4 P.? : ; I@Q: ; IR US4: ; IT4: ; I U4: ; IV1RUX Y W1X1X Y Y1Z1X Y [1 \.4 @]1RUX Y ^1_1 `4: ; I? < a4I? 4 < b4G c4G‡@ d4G‡@e4G‡@ f4G‡@g4G‡@% RU: ; I$ > $ >   I : ; : ;I8  : ; ‡@  : ;  : ; I : ; I8 I!I/  : ; : ; &I: ;I9: ; : ; : ;9: ; <  : ; ( <  : ; : ;I? 2 < .? : ;< dI4 .? : ;< d < !.? : ; ‡@I< d"I#/I$.? : ;‡@I< d%9: ; &< ' : ;2 (I8 2 ): ;I2 *.? : ; ‡@< d+.? : ; I< ,.? : ;I< -4: ; I< ./.? : ;I< 0 : ; 1.? : ; ‡@I< 2.? : ;‡@I< 3:: ; 4G : ; 5.? : ; ‡@< 6.? : ; ‡@I< 7.? : ;‡@I< 8.? : ;‡@I< 9 I:.? : ; I< ;&< : ; I? < =.? : ; ‡@< d> : ; ? : ; I8 2 @ : ; I8 2 A : ; I? 2 < B.? : ; < dC.? : ; ‡@I< dD!EG : ; F/IGG : ;H : ;I8 2 I.? : ;‡@I2 < dJ.? : ;‡@2 < dK.? : ;‡@< dL.? : ;< c dM.? : ;‡@I< dN.? : ; ‡@2 < dO.? : ; < c dP.G dQI4 R.G S: ; IT: ;IU: ;IV W4: ; IX.? : ; I 4 Y: ; IZI[.4 \.G: ; @d]I4 ^: ; I_: ; I` Ua4: ; Ib1RUX Y c1 d1e1X Y f1X Yg1X Y h i1j1X Yk1X Y l1RUX Y m1RUX Yn1RUX Yo41p.4 @q1r1 s4: ; I? < t4I? 4 < u4G v4G‡@ w4G‡@x4G‡@ y4G‡@z4G‡@{4G: ; ‡@ % RU: ; I$ > $ >   I : ; : ;I8  : ; ‡@  : ;  : ; I : ; I8 I!I/  : ; : ; &I9: ; : ; 9: ; 9: ; < : ;<  : ; : ;I? 2 < .? : ;< dI4 .? : ;< d< /I < ! : ;2 "I8 2 #I$: ;I2 %.? 4 < d&.? : ; I< '/I(4: ; I< ).? : ;< *.? : ;I< +,.? : ; I< -.? : ; I 4 .: ; I/.? : ; ‡@I< 0 : ; I8 1: ;I2I3&45.? : ;I< 6.? : ;I< 7:: ; 8G : ; 9 : ; I? < :.? : ; ‡@< ;.? : ; ‡@< d<.? : ; ‡@< d= I> : ; ?.? : ; ‡@I< @.? : ;‡@I< A.? : ;‡@I< B.? : ;‡@I< C : ; D( E : ; F : ; I8 2 G : ; I8 2 H : ; I? 2 < I.? : ; < dJ.? : ; ‡@I< dK.? : ; ‡@I< dL!M.? : ; ‡@I2 < dN.? : ; ‡@2 < dO : ; P : ; IQ : ;R : ;ISG : ; TG : ;U : ;I8 2 V.? : ;‡@I2 < dW.? : ;‡@2 < dX.? : ;‡@I< dY.? : ;‡@< dZ.? : ;< c d[.? : ;‡@I< d\.? : ; < c d].: ; ^: ;I_.: ;I ` : ;a b4: ;Ic.? : ; I d: ; Ie.G dfI4 g.? : ; h.G: ; di: ;Ij.G k4: ;Il.4 m.1@n1o 1p Uq41r1X Ys t 1u.: ;I@v: ;Iw Ux4: ;Iy4: ;I z4: ;I{.1@ |1X Y }1X Y ~11 €.? : ;‡@I@ : ;‚ ƒ4: ; I„1RUX Y …1RUX Y†1RUX Y‡1X Yˆ4: ; I‰1RUX Y Š.4 @‹1Œ1 4: ; I? < Ž!I/4I? 4 < 4G ‘4G‡@ ’4G‡@“4G‡@”4G‡@ •4G‡@% RU: ; I$ > $ >   I : ; : ;I8  : ; ‡@  : ;  : ; I : ; I8 I!I/  : ; : ; &I : ; I8 : ;III&9: ; : ; 9: ; : ;< <  : ; : ;I? 2 < .? : ;< d I4 !.? : ;< d"< #/I$< %4: ; I< &.? : ;< '.? : ; I< (.? : ;I< ).? : ; I 4 *+: ; I,.? : ;I 4 -: ;I.: ;I/.? : ; I< 09: ; 1.? : ; ‡@I< 23.? : ;I< 4.? : ;I< 5:: ; 6G : ; 7 : ; I? < 8 : ; 9.? : ; ‡@I< :.? : ;‡@I< ;.? : ; ‡@< <.? : ;‡@I< =.? : ;‡@I< > I? : ; @( A : ; B : ; I8 2 C : ; I8 2 D : ; I? 2 < E.? : ; < dF.? : ; ‡@< dG.? : ; ‡@I< dH.? : ; ‡@I< dI!J.? : ; ‡@I2 < dK.? : ; ‡@2 < dL.? : ; ‡@< dM : ; N : ; IO.: ; P.G dQI4 R.: ;I S T4: ;IU.? : ;I V4: ;IW.4 X.: ;I@Y: ;I Z [4: ;I\4: ;I ] U^.1@_1`1RUX Ya1 b1c.? : ;‡@@ d: ;I e1X Yf41 g.? : ;‡@I@ h: ;Ii.? : ;‡@@j4: ;Ik Ul41m41n.? : ;‡@I@o: ;Ip.: ;@q1RUX Yr: ; Is t : ;u1RUX Y v1X Y w1X Yx4: ;I y1RUX Y z1X Y { |.G: ; @d}I4 ~.G: ; @ d.4 @€11 ‚4: ; I? < ƒ!I/„4I? 4 < …4G †4G‡@ ‡4G‡@ˆ4G‡@‰4G‡@ Š4G‡@]§û /usr/include/x86_64-linux-gnu/bits/usr/include/c++/4.6/usr/lib/gcc/x86_64-linux-gnu/4.6/include/usr/include/usr/include/c++/4.6/x86_64-linux-gnu/./bits/usr/include/c++/4.6/bits/usr/include/c++/4.6/debug/usr/include/c++/4.6/extparsetest.ccsmt2newcontext.hstdio2.hostreamiostreamtypes.hstddef.hstdio.hlibio.hwchar.h_G_config.hcwcharc++config.hclocaleios_base.hcwctypelocale_facets.hcstdiodebug.hstl_list.hiosfwdbasic_ios.hwchar2.htime.hnew_allocator.hchar_traits.hlocale.hatomic_word.hnumeric_traits.hwctype.hstdio.h `@ ­X†•Á :4YAž?<AJÐX°JÐ.².çJq䂚̂¶‚sƒÖ¥äÛX¥XÛX¶<,JT‚,Jœ£û /usr/include/x86_64-linux-gnu/bits/usr/include/c++/4.6/usr/include/c++/4.6/bits/usr/lib/gcc/x86_64-linux-gnu/4.6/include/usr/include/usr/include/c++/4.6/x86_64-linux-gnu/./bits/usr/include/c++/4.6/ext/usr/include/c++/4.6/debugsmt2newcontext.ccstdio2.hostreamsmt2newcontext.hchar_traits.hbasic_ios.hlocale_facets.hstl_list.hios_base.hiostreamstddef.htypes.hlibio.hstdio.hwchar.hcwcharc++config.hclocalecwctypeiosfwdwchar2.htime.hnew_allocator.hdebug.hlocale.hatomic_word.hnumeric_traits.hwctype.hallocator.hlist.tcc `@/-º=äÈœXäJœXZü„|È2tʺU…~þ‚‚~äþ‚ä’|<º²u»}X¬Ó{‚*W</˜äç~JhÛ䃚} Ÿ}žvfž à@1 Jg‚ JÌû /usr/include/x86_64-linux-gnu/bits/usr/include/c++/4.6/bits/usr/include/c++/4.6/ext/usr/include/c++/4.6/usr/lib/gcc/x86_64-linux-gnu/4.6/include/usr/include/usr/include/c++/4.6/x86_64-linux-gnu/./bits/usr/include/c++/4.6/debugsmt2newparser.ccstring3.hsmt2newparser.yystdio2.hsmt2newcontext.hstl_list.hnew_allocator.hiostreamstddef.htypes.hstdio.hlibio.hwchar.h_G_config.hcstdiocstdlibc++config.hcwcharclocaleios_base.hcwctypeiosfwdmove.hstdio.hstdlib.hstdlib.hdebug.hnumeric_traits.hwchar2.htime.hchar_traits.hlocale.hatomic_word.hwctype.hsmt2newparser.hallocator.hlist.tccnew Ð@‡ ; =.Évº ‚=^<¤ <=rJ­¥yX sJQÖxä‘ Jstdlib.hcstdiocstdlibc++config.hdebug.hstl_list.hcwcharclocaleios_base.hcwctypeiosfwdstdio.hnew_allocator.hstdlib.hnumeric_traits.hwchar2.htime.hchar_traits.hlocale.hatomic_word.hwctype.hsmt2newparser.yysmt2newparser.h °@¶%>ôž×=j­u¨(rt<rJ ÐG@€âmJžtâm<¡Xÿ}º XzJz=‰ELuv7O.X=­:>uöJ=ÎK-XË=^K-XË=^KÀKÀ=Ïu—=ÏNË=U ÖNË=U ÖK½K½=Ë=Íu“u“u“ušòç„•Ê:>ákf¨E® <ƒƒƒƒuvuu‰ƒf‚tf.Õkt™8¬otXu ¬vt XÕköH; =k¼:>‚lf†A.<ƒƒƒƒuvuu‰ƒA‚/ùkø0­Xx‚­_ùk‚ÝHË9MU?Y;=iAoOY;Yi&[ci XyJK–å‘“N#4tLJy‚Ÿ‚ï|ò®¥Ggh\æ†>HL:?zÈzòÜ} Õt«~JÕ< ~‚J“1ŸƒI!“JŸå:>uw< tx<ÑäN/;KjÛnJ¦@‘~JÉp$º8Òòƒ;Kón.’tƒínò¢9ä¡Gif¬²É;=1KL|yd’ƒ^wo¬ ºlºtº>­/Iô~0:X>5fȸÈÈ‚½¯ŸA7­”f‘åñ~JŸå:>u<ð~t‘<8ÈN/;KjÛnJ¦@®ò¬otÏ8‚/òƒ;Kón.“t-ƒínX¢9»º¿~.#ÈôJ[ci XyfKˆXɃ…¬"Ö‚J)<Ÿå:>uTfð.‹~Ƚ9“÷žN/;KjÛnJ¦@ÚntŒ(Ÿ;Kón.’tƒín¢1v<8vvÔ3KXQ”YeY0Y­uºpPYLotJ=NVZ[Ø:„.12FKhŸI2p <¹XÇ{.´òzJzYv……ÖÿI=É:ZƒýwäýÊ ¾v · +É;Yónf’t‘þnò-=-Á ‚Ösä·tJ@·ÖÔpò€>Hsº@ ä¸uJ@5¹vJ@¯.¸_,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,2%.<.%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%=IŸ° XÞttgI¡ž,>,à%-=-iòtcž-=-%,>,%,>,%,>,M%-=-%,>,%,>,%,>,%,>,%,>,+%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%,>,%-=-%,>,í %#¡ Öƒƒ žðžT†”>:„Už\vVZ…-YÉÒ{òŸæxXH·=; ÷¬Mým. žHrº žv< <÷¬Mˆn.tž¸I@M.,>,Ã%,>,lòÿ=IŸ_¸J@L.,>,¶%@/;YjÛnX¦VôntIgggÿgsYeggsYâ .L:Z³zfÎA²zXÍÖ/²zºÍ<1 <  JyG…N#zX˃ówÛ~º=å:>u¤<Ü~t¦<zfÝò$F@‚Ƀƒ;ƒU—°q…YT‚3‚N<ƒ1‚P<ƒuvu|ƒ"‚[Çkº×W=/‘ È/xòu»­Ì/âA  @@—³Ít³JͳJ__debugint_p_cs_precedestypestrLOGIC_Twcsxfrm_ZNK7ASTNode9typeToStrEv_shortbufiswctype_IO_lock_tNUML_Tsetvbufgp_offsetremoveOPTION_T_IO_buf_end_ZNSt11char_traitsIcE11to_int_typeERKc_S_failbitINFOL_TgetValuefflushQITL_Tlist >vfwscanfLETL_Ttowctrans_IO_write_end__gnu_cxx_ZNK7ASTNode8getValueEvinsertRoot_flagsTATTRL_T__int32_t_cur_columnwchar_tSVL_Tvwscanfcurrency_symbol_markersvswscanf_ZNSt11char_traitsIcE2ltERKcS2_mon_decimal_point_S_ios_iostate_end_ZN9__gnu_cxx24__numeric_traits_integerIiE5__minEtm_gmtoffputcharvsprintfungetcbuffer_sz_ZNSt11char_traitsIcE7not_eofERKiSORT_TwcscatPATTRL_T__numeric_traits_integerLQIDL_Tvfprintf__statetm_yearcopyvwprintfwmemcpy__gnu_debug__FILE__numeric_traits_integermbrtowcstdouttm_mon__count__numeric_traits_integerfloatfgetposto_int_typeUATTR_TSYM_Tpositive_signLET_T_ZNKSt5ctypeIcE5widenEcSTRL_Tlong long unsigned intLATTR_Twcstoul_ZN14Smt2newContext11prettyPrintERSofsetposint_n_sign_posn_ZN14Smt2newContext15destroy_scannerEvlocaleconv_ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEceq_int_typeSEXPRL_THEX_Twcrtomb_ZSt4cout9_G_fpos_tiostate_filenovfwprintf__pad3FORALL_T_ZNKSt9basic_iosIcSt11char_traitsIcEE7rdstateEvAS_Tfopen__initialize_pCMD_T_vtable_offsetBIN_TSTR_T_IO_read_base__prioritywiden_IO_save_endBANG_TprettyPrintint_frac_digitsclearerrwcsstrfwideint_n_cs_precedes__max_IO_markergetRoot_ZNK7ASTNode7getTypeEv__fmtfindbasic_ostream >negative_signfreopen__valueTERML_Ttm_ydaylong long inttypeToStrVARB_T_GLOBAL__sub_I_main_ZNSt11char_traitsIcE3eofEvvprintffseek_modeferrorGNU C++ 4.6.3_IO_write_baseGATTR_TPFSYMDL_TBINL_T__wch__os~Smt2newContextinsertBufmbsrtowcsrename__poswctrans_t_ZN9__gnu_cxx24__numeric_traits_integerIlE5__maxEgetcharprintwcstofwcsspn_ZN9__gnu_cxx24__numeric_traits_integerIsE5__maxEwcsrtombstmpnam__in_chrgsetbufperror_IO_save_base__pfTERM_TPATTR_Toperator<<_S_badbitmon_groupingcontextwcstoull_ZN14Smt2newContext7getRootEv_ZNSt11char_traitsIcE6assignERcRKcbool_ZN14Smt2newContext9insertBufEc__check_facet >_ZNSt11char_traitsIcE6assignEPcmcPFSYMD_TgetTypebasic_ios >ptrdiff_tgetBuf_IO_read_endlong double_IO_backup_base_Facet_S_goodbit__dso_handle__pad1__pad2ftell__pad4__pad5EXISTS_T__is_signedungetwc_Value_S_eofbitfgetc__ostream_typewctype_targcrewindtm_mdaycomparefgetsSYML_TASTType_ZN9__gnu_cxx24__numeric_traits_integerIiE5__maxEoperator|destroy_scannerTDECL_Targvfputwcrvalwcscoll_S_synced_with_stdiothisfputws_ZNSt11char_traitsIcE4moveEPcPKcm__static_initialization_and_destruction_0__numeric_traits_integerHEXL_TASL_Tunsigned charrootfcloseLATTRL_TclearBufLQID_TTDECLL_TNUM_T_ZN14Smt2newContext12init_scannerEvmbsinitwmemchrshort int__detail_CharT~Initint_curr_symbolSSYMDL_T__digitsmbrlenlength_ZN14Smt2newContext10insertRootEP7ASTNodefread/home/aehyvari/src/OpenSMT/opensmt-dev/opensmt/src/parsers/smt2new11__mbstate_t_ZNSolsEPFRSoS_Echar_traitswcsrchrtypedef __va_list_tag __va_list_tagto_char_typegetwchar_S_refcountPFIDL_T__wchbint_n_sep_by_space__numeric_traits_integerVARBL_T_ZN9__gnu_cxx24__numeric_traits_integerIsE5__minESPECC_TSSYMD_Twcsncmpios_baseLIDL_Tinit_scannerfp_offsetOPTIONL_Twcsftime_ZNSt11char_traitsIcE6lengthEPKcint_p_sep_by_spacectype_ZNSt11char_traitsIcE11eq_int_typeERKiS2_LOGICL_TFORALLL_TSPECCL_TTATTR_T_ZNSt11char_traitsIcE12to_char_typeERKiwmemmovetm_hourEXISTSL_T_lockINFO_Tlconv_old_offsetstdin_IO_FILE_Atomic_wordwint_treg_save_areanot_eofwcstodwcspbrktm_minwcstokwcstoltm_zonewmemsetsetlocale_ZNSt11char_traitsIcE4findEPKcmRS1__sbufparsetest.cctmpfileSEXPR_T_IO_write_ptr_ZN9__gnu_cxx24__numeric_traits_integerImE8__digitsEfeofbuffer_capoverflow_arg_areaLID_TwcstoldwctobrdstateBOOLL_TSV_Twcstoll__minwcscpyflush >GATTRL_T_ZN9__gnu_cxx24__numeric_traits_integerIcE5__maxE__off_tputwcharmon_thousands_sepshort unsigned intCMDL_Ttm_secwcscspntm_wdayBOOL_Ttm_isdstBANGL_TSORTL_TUATTRL_T_IO_read_ptrwcsncpyfgetwc_Traits_ZNSt11char_traitsIcE4copyEPcPKcmchildrenwcscmpwcsncatPFID_Tostream_chainwcschrDEC_Tvswprintf_flags2fgetws_ZN14Smt2newContext6getBufEv_ZNSt11char_traitsIcE7compareEPKcS2_mint_p_sign_posn_ZN14Smt2newContext8clearBufEv_ZNSt11char_traitsIcE2eqERKcS2_wcslen__off64_t__ioinit_unused2_IO_buf_basevsnprintf_ZN9__gnu_cxx24__numeric_traits_integerIlE5__minEwmemcmp_ZNKSt10_List_baseIP7ASTNodeSaIS1_EE19_M_get_Tp_allocatorEv_ZNSt14_List_iteratorIP7ASTNodeEmmEi_ZNSt14_List_iteratorIP7ASTNodeEmmEv_Tp1_ZNKSt4listIP7ASTNodeSaIS1_EE5beginEv_ZNK9__gnu_cxx13new_allocatorIP7ASTNodeE7addressERKS2__ZNSt4listIP7ASTNodeSaIS1_EE9push_backERKS1_const_pointerdeallocatenew_allocator_ZNSt4listIP7ASTNodeSaIS1_EE5eraseESt14_List_iteratorIS1_ES5_max_size_ZN9__gnu_cxx13new_allocatorIP7ASTNodeE8allocateEmPKv_ZNKSt4listIP7ASTNodeSaIS1_EE3endEv__out_ZNKSt4listIP7ASTNodeSaIS1_EE4rendEv_ZNKSt14_List_iteratorIP7ASTNodeEneERKS2__ZNKSt4listIP7ASTNodeSaIS1_EE5emptyEv_ZNSt4listIP7ASTNodeSaIS1_EE3endEvvalue_type_M_clear_ZNSt10_List_baseIP7ASTNodeSaIS1_EE21_M_get_Node_allocatorEv_ZNK9__gnu_cxx13new_allocatorIP7ASTNodeE8max_sizeEv_ZNSt10_List_baseIP7ASTNodeSaIS1_EE8_M_clearEvoperator*operator=_Self_List_iterator_ZNSt4listIP7ASTNodeSaIS1_EE6insertESt14_List_iteratorIS1_EmRKS1__ZNKSt14_List_iteratorIP7ASTNodeEdeEv_ZNKSt10_List_baseIP7ASTNodeSaIS1_EE13get_allocatorEv_ZNSt8__detail15_List_node_base4swapERS0_S1__ZNKSt4listIP7ASTNodeSaIS1_EE4sizeEv_ZNSt4listIP7ASTNodeSaIS1_EE6resizeEmS1_rendswapsize_type_ZNKSt4listIP7ASTNodeSaIS1_EE4backEv_M_transfer_ZNSt8__detail15_List_node_base10_M_reverseEv_ZNSt4listIP7ASTNodeSaIS1_EE6spliceESt14_List_iteratorIS1_ERS3_other_ZNSt4listIP7ASTNodeSaIS1_EE6spliceESt14_List_iteratorIS1_ERS3_S5__ZNSt4listIP7ASTNodeSaIS1_EE25_M_check_equal_allocatorsERS3__ZNSt4listIP7ASTNodeSaIS1_EE6uniqueEv_ZNK9__gnu_cxx13new_allocatorISt10_List_nodeIP7ASTNodeEE7addressERKS4_operator!=_M_reverse_ZNSt4listIP7ASTNodeSaIS1_EE5mergeERS3__ZNSt4listIP7ASTNodeSaIS1_EE5eraseESt14_List_iteratorIS1_E_ZNSt4listIP7ASTNodeSaIS1_EE4backEvindent_M_fill_assignpush_front_ZNSt9basic_iosIcSt11char_traitsIcEE8setstateESt12_Ios_Iostateoperator<< >_Tp_alloc_type_M_init~_List_baserbegin_List_node_ZN9__gnu_cxx13new_allocatorIP7ASTNodeE7destroyEPS2_splice_M_fill_initialize_ZNKSt4listIP7ASTNodeSaIS1_EE13get_allocatorEv_M_implget_allocator_ZNK9__gnu_cxx13new_allocatorISt10_List_nodeIP7ASTNodeEE7addressERS4_address_ZNSt4listIP7ASTNodeSaIS1_EE10push_frontERKS1__M_get_nodemerge_ZNSt10_List_baseIP7ASTNodeSaIS1_EE11_M_put_nodeEPSt10_List_nodeIS1_E_List_iterator_ZNKSt14_List_iteratorIP7ASTNodeEptEv_ZNKSt4listIP7ASTNodeSaIS1_EE5frontEv__tmpallocator_typepop_back_ZNSt4listIP7ASTNodeSaIS1_EE6spliceESt14_List_iteratorIS1_ERS3_S5_S5__ZNKSt14_List_iteratorIP7ASTNodeEeqERKS2__ZNSt4listIP7ASTNodeSaIS1_EE8_M_eraseESt14_List_iteratorIS1_E_ZNSt4listIP7ASTNodeSaIS1_EEaSERKS3__M_node_GLOBAL__sub_I__ZN7ASTNode5printERSoismt2newcontext.cc_ZNSt4listIP7ASTNodeSaIS1_EE9pop_frontEv_ZNSt8__detail15_List_node_base9_M_unhookEv_M_unhook_ZNSt4listIP7ASTNodeSaIS1_EE14_M_fill_assignEmRKS1_resize_ZNSt4listIP7ASTNodeSaIS1_EE9_M_insertESt14_List_iteratorIS1_ERKS1__M_erase~new_allocator_M_datareverse_iterator >_ZNSt10_List_baseIP7ASTNodeSaIS1_EE7_M_initEv_List_node_base_ZNK9__gnu_cxx13new_allocatorIP7ASTNodeE7addressERS2__Node_alloc_typeempty_M_get_Node_allocator_Nodeunique_ZNSt4listIP7ASTNodeSaIS1_EE18_M_fill_initializeEmRKS1__ZN9__gnu_cxx13new_allocatorISt10_List_nodeIP7ASTNodeEE8allocateEmPKv_Allocoperator++_ZNSt8__detail15_List_node_base11_M_transferEPS0_S1_push_back_ZNSt4listIP7ASTNodeSaIS1_EE11_M_transferESt14_List_iteratorIS1_ES5_S5__ZNSt4listIP7ASTNodeSaIS1_EE6removeERKS1_operator--_ZNK9__gnu_cxx13new_allocatorISt10_List_nodeIP7ASTNodeEE8max_sizeEv_M_create_nodeoperator->new_allocator >_ZNSt4listIP7ASTNodeSaIS1_EE5clearEv_ZNSt4listIP7ASTNodeSaIS1_EE8pop_backEvendl >_ZNSt4listIP7ASTNodeSaIS1_EE4swapERS3_const_reverse_iterator_ZNSt4listIP7ASTNodeSaIS1_EE5frontEvpop_front_ZN7ASTNode7typestrEconst_referencereverse_iterator >_ZNKSt10_List_baseIP7ASTNodeSaIS1_EE21_M_get_Node_allocatorEv_M_check_equal_allocators_ZNSt14_List_iteratorIP7ASTNodeEppEi_List_const_iterator_ZNSt14_List_iteratorIP7ASTNodeEppEv_M_prev_M_hook_ZNSt4listIP7ASTNodeSaIS1_EE6insertESt14_List_iteratorIS1_ERKS1__ZNSt4listIP7ASTNodeSaIS1_EE7reverseEv_M_insert_List_base >_ZNSt4listIP7ASTNodeSaIS1_EE5beginEvrebind >_ZN9__gnu_cxx13new_allocatorIP7ASTNodeE9constructEPS2_RKS2_construct_ZNKSt4listIP7ASTNodeSaIS1_EE8max_sizeEv_ZNSt4listIP7ASTNodeSaIS1_EE4rendEv_ZNSt4listIP7ASTNodeSaIS1_EE6rbeginEv_ZN9__gnu_cxx13new_allocatorIP7ASTNodeE10deallocateEPS2_m_ZNSt4listIP7ASTNodeSaIS1_EE4sortEv_M_next_ZNSt4listIP7ASTNodeSaIS1_EE14_M_create_nodeERKS1__ZN9__gnu_cxx13new_allocatorISt10_List_nodeIP7ASTNodeEE9constructEPS4_RKS4_rebind_ZNSt8__detail15_List_node_base7_M_hookEPS0_const_iterator_ZNSt4listIP7ASTNodeSaIS1_EE6assignEmRKS1__ZNKSt4listIP7ASTNodeSaIS1_EE6rbeginEv_M_get_Tp_allocator_M_put_node_ZN9__gnu_cxx13new_allocatorISt10_List_nodeIP7ASTNodeEE10deallocateEPS4_m_ZN9__gnu_cxx13new_allocatorISt10_List_nodeIP7ASTNodeEE7destroyEPS4_operator==_ZNSt10_List_baseIP7ASTNodeSaIS1_EE11_M_get_nodeEv~allocatoryydefaultyyacceptlabyymsgyymsg_allocyyexhaustedlabyyerror_range7lldiv_tyyls_allocyysetstateoperator newstpcpystrtodyytokenatofatoiatolyydestruct6ldiv_twctombyyerrlabsmt2newlvalyyss_allocyyarglldivfirst_columnyyreslocpvector, std::allocator >, std::allocator, std::allocator > > >snode_liststrtoldstrtollatexityyerrstatusyyptryypactyynewstateyysize0yysize1yycheckyytranslatequotsmt2newerroryymsgbufyylsayymsgpmblenyyreturnfirst_lineYYLTYPEsmt2newllocyyreduceyydefgotoyychecklim__srcstrtoulyycountyyvaluepyytypewcstombsdo_not_strip_quotesyystateyyxendsmt2newcharyybackup_Z12smt2newparseP14Smt2newContextyystos__addressofyyformatsrandyyallocyytnamerrsystemyystacksizeyylsyyr2_ZN9__gnu_cxx3absExyyss1mbstowcsyyvalyyssayytableyyssp__destYYSTYPEyystryypgotoyyssyyerrorlabyytype_int16yyr1yysizestrtofstrtolsmt2newparseyysyntax_errorsymlyyxbeginyyvs_alloclast_lineyyvsatollyyerrlab1bsearchyyabortlabsnodeyytnameqsort__positionsortlyylocationpyyresult5div_tyynewbytesmbtowc__compar_fn_tyylocgetenvyyvsastr_listyyvsp~_List_implyylenyylspyydefactlast_column_ZN9__gnu_cxx3divExxyysyntax_error_statusstrtoull_GLOBAL__sub_I_smt2newparser.ccsmt2newnerrs__valyy_fatal_errorsmt2newreallocyy_last_accepting_cpossmt2newget_lvalyy_rule_can_match_eolyyscan_tyybytesyy_match_Z24smt2newpush_buffer_stateP15yy_buffer_statePvsmt2newpush_buffer_stateyy_baseyyleng_ryy_chksmt2newget_extra_GLOBAL__sub_I_smt2newlexer.ccyy_start_stack_depthyy_user_definedsmt2newset_outsmt2newset_extraret_val_yybytes_len_Z23smt2newpop_buffer_statePvyy_defyy_state_typesmt2newset_lvalyy_bs_lineno_Z15smt2newget_textPvyyscannersourceyy_start_stack_ptr_Z17smt2newset_columniPv_Z19smt2new_scan_stringPKcPvyy_find_actionyy_is_jam__ptryy_fill_buffer_Z14smt2newrestartP8_IO_FILEPvsmt2new_delete_buffernumber_to_move_Z21smt2new_create_bufferP8_IO_FILEiPvsmt2newlex_destroy_Z19smt2new_scan_bufferPcmPvyylloc_paramyy_buf_pos_Z20smt2new_flush_bufferP15yy_buffer_statePvsmt2new_scan_stringyy_more_flag_Z14smt2newget_outPv_Z15smt2newlex_initPPvYY_CHARyy_last_accepting_state_Z11smt2newfreePvS_yy_bpsmt2newget_llocyy_buffer_stack_top_Z15smt2newget_lengPvcolumn_nosmt2newset_insmt2newset_linenosmt2newlexsmt2newget_outyy_pop_stateyy_buffer_stack_maxsmt2new_load_buffer_statenum_to_readyytext_r__sizeyy_csmt2newlex_init_extrayylloc_roerrno_Z13smt2newget_inPvnew_bufferyy_cpYY_BUFFER_STATEsmt2new_scan_bufferyy_amount_of_matched_textyy_nxt__streamyy_ecyylval_paramin_stryy_did_buffer_switch_on_eofyy_buffer_stack_Z14smt2newreallocPvmS_out_strsmt2newpop_buffer_stateyy_init_globalsyy_n_charsyy_ch_bufstderryy_startsmt2newrestart_Z16smt2newset_extraP14Smt2newContextPv_Z16smt2newget_debugPvdo_actionyy_push_stateyy_c_buf_p_offsetyy_inityy_buf_sizesmt2new_flush_buffer__lensmt2newensure_buffer_stack_Z16smt2newset_debugiPvsmt2newget_linenoyylval_r_Z21smt2new_delete_bufferP15yy_buffer_statePvsmt2newget_lengyy_flex_debug_r_Z17smt2newget_linenoPvgrow_sizeyy_is_our_buffersmt2newget_textsmt2newallocyy_acceptyy_next_state_Z16smt2newget_extraPvyylineno_rsmt2new_scan_bytes_Z17smt2newget_columnPvyy_hold_charyy_more_lenyy_get_previous_stateyy_size_tyy_buffer_statesmt2newget_insmt2new_switch_to_buffer_Z18smt2newlex_destroyPvyy_at_bolsmt2new_create_bufferyyguts_tyyout_r_Z15smt2newget_llocPvnew_stateline_numberyy_input_fileyy_meta_Z12smt2newallocmPv_Z14smt2newset_outP8_IO_FILEPvsmt2new_init_bufferyy_act_Z15smt2newset_lvalP7YYSTYPEPvyy_is_interactiveyyin_r_Z24smt2new_switch_to_bufferP15yy_buffer_statePvyy_bs_columnyy_c_buf_p_Z15smt2newget_lvalPvsmt2newget_columnyy_get_next_buffer_Z15smt2newset_llocP7YYLTYPEPv_Z17smt2newset_linenoiPvsmt2newlex_initnum_to_allocsmt2newset_column_Z13smt2newset_inP8_IO_FILEPvyy_start_stackptr_yy_globals__ch_Z18smt2new_scan_bytesPKciPvbdebugsmt2newget_debugyy_buffer_status_Z10smt2newlexP7YYSTYPEP7YYLTYPEPvdummy_yygutssmt2newset_debugsmt2newfreeyy_current_statenew_sizeyy_try_NUL_transsmt2newset_llocyyextra_r`@a@wa@g@wg@k@wk@O@wàO@R@wR@S@wS@T@wT@¬@wà`@p@Up@ @PT@`@P~@@P`@p@Tp@ @QT@`@Q~@@Q¤@ß@Pß@K@Vg@{@P{@~@V™@¬@Vü@ @P @@R@K@S¤@ß@Pß@K@V™@¬@V¤@K@W™@¬@Wü@K@ Pz@Ÿ"@)@PC@K@W~@™@  z@Ÿ°@´@w´@Ñ@wÑ@Ö@w`@b@wb@f@wf@h@wh@l@w l@p@w(p@Š@w0Š@‹@w(‹@@w @@w@‘@w‘@˜@w˜@Ð@w0`@x@Ux@‹@V’@Ð@V`@u@Tu@Š@S’@Ð@S`@x@Qx@f@\f@‰@|Ÿ’@Ð@\`@x@0ŸŽ@“@]¼@Š@S’@Ð@SÁ@‘@^’@Ð@^Á@Š@S’@Ð@SÊ@à@^±@Ë@S»@Ë@1Ÿ»@Å@U»@Å@u à@±@ Œz@ŸË@Ð@ Œz@Ÿà@Š@S’@±@SË@Ð@Sò@)@]ò@Š@S’@±@SË@Ð@S@±@ –z@ŸË@Ð@ –z@Ÿ@Š@S’@±@SË@Ð@S@Š@S’@±@SË@Ð@S)@±@:ŸË@Ð@:Ÿ)@>@ ssH"#ð>@]@]’@±@]Ë@Ð@]2@>@ ssH"#ð>@]@]’@±@]2@±@:ŸI@P@P]@f@v“f@ƒ@]“ƒ@‰@]“@‰@ òÕV@ƒ@]“à@ä@wä@@w@@wÐ@Ô@wÔ@î@wî@ð@wð@q@wq@€@w€@Ž@wŽ@@wÐ@Ù@UÙ@î@Sï@q@Sq@t@Uy@Ž@SŽ@@UÐ@é@Tï@x@Ty@@Tú@n@Py@@Pú@@rŸ@@R@*@rŸ*@4@rŸ4@6@R6@I@rŸI@M@RM@b@rŸb@l@rŸl@n@Ry@@rŸâ@é@Tâ@í@S@’@w’@—@w—@™@w™@›@w ›@Ÿ@w(Ÿ@ª@w0ª@³@w8³@¾@w¾@¿@w8¿@À@w0À@Â@w(Â@Ä@w Ä@Æ@wÆ@È@wÈ@Ð@wÐ@d@wd@g@w8g@h@w0h@j@w(j@l@w l@n@wn@p@wp@x@wx@@w@@w8@@w0@@w(@@w @!@w!@#@w#@$@w@¯@U¯@¿@SÉ@ @Sq@@S@¿@T¿@$@‘ˆ@©@Q©@û@Vq@Š@V@Ã@RÃ@4@\q@@\Í@ß@Pß@$@‘€Í@ß@Pß@4@‘€4@w@]†@³@]É@Õ@‘€Õ@ê@]ê@ñ@}eŸñ@l@]q@@‘€@@]t@w@p}"Ÿw@†@]ª@³@q}"Ÿ³@Ä@]ç@ê@q}"Ÿê@@]@l@]@¯@]@@]Í@ª@0Ÿª@À@VÉ@Õ@0ŸÕ@ç@ Ÿ}@Ÿç@N@VN@V@vŸV@h@Vq@@0Ÿ@¯@V¯@Ã@0ŸÃ@Ô@ ˜‚@ŸÔ@å@ Ђ@Ÿå@$@0ŸÍ@é@0Ÿé@4@1Ÿj@†@|Ÿ†@ª@\É@Õ@1Ÿq@@0Ÿ¯@@\@@|Ÿé@ª@_É@ñ@_¯@#@_ @4@V @ª@ :Ÿ¯@#@ :Ÿ@•@^•@ª@ :F : $€€€€à,(Ÿ¯@@ :F : $€€€€à,(Ÿ@!@^!@#@ :F : $€€€€à,(Ÿ@¢@V¯@Ï@VÔ@à@Vå@ñ@Vö@@V@@V @@‘ˆ@g@S @@0Ÿ@j@\0@G@UN@\@U0@B@TN@W@T0@;@Q;@M@RN@b@Q6@N@ Õ}@ŸN@b@Qp@r@wr@t@wt@v@wv@x@w x@|@w(|@}@w0}@„@w8„@¨!@wÐ+¨!@©!@w8©!@ª!@w0ª!@¬!@w(¬!@®!@w ®!@°!@w°!@²!@w²!@¸!@w¸!@ÄG@wÐ+p@@U@ÄG@‘˜Ué@@ þŸ@e!@‘øT³!@}"@‘øT}"@"@Q"@¸"@‘øT¸"@é"@ þŸé"@#@‘øT#@!#@P!#@QF@‘øToF@¿G@‘øTé@@0Ÿé@@0Ÿ@b@\b@v@R/ @K @RW @` @\ß @ä @ s”0$0&ŸY!@^!@\¸"@#@R!#@-#@R-#@2#@\IF@QF@\oF@vF@\àF@íF@\}G@‡G@ s”0$0&Ÿé@@0Ÿ@¼ @‘üT^!@`!@‘üT³!@x"@‘üTx"@}"@3Ÿ}"@¿G@‘üTé@@R@­@^­@I@_I@°!@^³!@àF@^àF@íF@_íF@ÄG@^é@@R@Œ@S @Ö@SÜ@Í @SÍ @Û @sŸÛ @e!@S³!@QF@SoF@qF@SvF@èF@SíF@jG@S}G@¿G@Sé@@]@Ç@‘èTÇ@I@‘àTI@e!@‘èT³!@àF@‘èTàF@íF@‘àTíF@¿G@‘èTé@ @] @5@ v3$‘àT"ŸI@Ó@]Ü@e!@]³!@¸"@]¸"@Ð"@}ŸÐ"@QF@]oF@àF@]àF@íF@ v3$‘àT"ŸíF@\G@]}G@¿G@]é@@V@î@‘€Uî@I@‘èTI@e!@‘€U³!@àF@‘€UàF@íF@‘èTíF@¿G@‘€Ué@d@V @5@ v4$‘èT"ŸI@ß@Vß@ö@Rö@/!@V/!@?!@R?!@e!@V³!@¸"@V¸"@ä"@vŸä"@IF@VoF@àF@VàF@íF@ v4$‘èT"ŸíF@xG@V}G@¿G@V— @ž @ “‘ð}““ž @º @“‘ð}“‘ô}““^!@`!@ “Q“P““q"@x"@ “‘ð}““x"@}"@“‘ð}“‘ô}““zG@}G@“p““}G@‡G@ “Q“P““é@@ÈŸ@P@‘ØTP@\@Pa@o@Po@|@Q|@ÄG@‘ØTb@¥@\¥@Ã@QÎ@E@RE@ö@‘àTö@W @‘àT @"”8$8%Ÿ` @º @Rº @¼ @\ä @^!@\^!@`!@R³!@"@R}"@"@\"@›"@Q›"@é"@Ré"@!#@\!#@(#@pÆŸ(#@2#@‘àT @"”8$8%ŸQ#@IF@‘àT4G@µG@‘àTe!@©!@S©!@³!@PjF@oF@2Ÿ¿G@ÃG@PÃG@ÄG@Sé@@0Ÿ¡@Ã@P @¼ @X^!@`!@Xñ!@"@X"@—"@Pþ@S@ x3$}"“n@{@Q“¶@ë@Q“ë@W @}“³!@Ö!@Q“!#@2#@}“Q#@^#@Q“|#@#@}x“#@…#@Q“…#@Š#@}“Š#@Ž#@ x3$}"“Ž#@“#@}““#@—#@ x3$}"“—#@œ#@}“œ#@ #@ x3$}"“ #@¥#@}“¥#@©#@ x3$}"“©#@®#@}“®#@²#@ x3$}"“²#@·#@}“·#@»#@ x3$}"“»#@À#@}“À#@Ä#@ x3$}"“Ä#@É#@}“É#@Í#@ x3$}"“Í#@Ò#@}“Ò#@Ö#@ x3$}"“Ö#@Û#@}“Û#@ß#@ x3$}"“ß#@ä#@}“ä#@è#@ x3$}"“è#@í#@}“í#@ñ#@ x3$}"“ñ#@ö#@}“ö#@ú#@ x3$}"“ú#@ÿ#@}“ÿ#@$@ x3$}"“$@$@}“$@ $@ x3$}"“ $@$@}“$@$@ x3$}"“$@$@}“$@$@ x3$}"“$@#$@}“#$@'$@ x3$}"“'$@,$@}“,$@0$@ x3$}"“0$@5$@}“5$@9$@ x3$}"“9$@>$@}“>$@B$@ x3$}"“B$@G$@}“G$@K$@ x3$}"“K$@P$@}“P$@T$@ x3$}"“T$@Y$@}“Y$@]$@ x3$}"“]$@b$@}“b$@f$@ x3$}"“f$@k$@}“k$@o$@ x3$}"“o$@t$@}“t$@x$@ x3$}"“x$@}$@}“}$@†$@ x3$}"“¢$@«$@P“ö$@ÿ$@Q“%@'%@Q“Ÿ%@¨%@Q“Ã%@Ð%@Q“H&@Q&@Q“l&@y&@Q“ñ&@ú&@Q“'@"'@Q“š'@£'@Q“¾'@Ë'@Q“(@(@Q“:(@G(@Q“’(@›(@Q“¶(@Ã(@Q“)@)@Q“2)@?)@Q“Š)@“)@Q“®)@»)@Q“*@*@Q“**@7*@Q“‚*@‹*@Q“¦*@³*@Q“þ*@+@Q“+@D+@ x3$}"“[+@d+@P“d+@m+@Q“¶+@»+@}x“»+@Ä+@Q“Ï+@Ô+@P“Ô+@Ý+@Q“ù+@,@P“‰,@’,@Q“®,@·,@P“˜-@¡-@Q“½-@Æ-@P“§.@°.@Q“Ì.@Õ.@P“¶/@¿/@Q“Ñ/@Õ/@P“Õ/@ê/@Q“0@!0@Q“=0@F0@P“‘0@š0@Q“¶0@¿0@P“ 1@1@Q“51@:1@}x“:1@C1@Q“N1@S1@P“S1@\1@Q“w1@„1@Q“Ï1@Ü1@Q“ú1@ÿ1@}x“ÿ1@2@Q“2@2@P“2@!2@Q“<2@I2@Q“”2@2@Q“¸2@Å2@Q“3@3@Q“43@A3@Q“¹3@Æ3@Q“ä3@é3@}x“é3@ò3@Q“ý3@4@P“4@ 4@Q“!4@34@Q“I4@[4@Q“q4@‡4@Q“¥4@ª4@}x“ª4@³4@Q“¾4@Ã4@P“Ã4@Ì4@Q“Þ4@â4@P“â4@ô4@Q“ 5@5@Q“25@D5@Q“`5@i5@P“´5@½5@Q“È5@Í5@P“Í5@Ú5@Q“ø5@ý5@}x“ý5@6@Q“6@6@P“6@16@Q“_6@h6@Q“„6@6@P“Ø6@á6@Q“ó6@ 7@Q“7@17@Q“C7@G7@P“G7@Y7@Q“o7@7@Q“7@¦7@P“ñ7@ú7@Q“8@"8@Q“m8@v8@Q“Œ8@ž8@Q“¹8@Æ8@Q“9@9@Q“09@F9@Q“d9@i9@}x“i9@r9@Q“}9@‚9@P“‚9@‹9@Q“¡9@³9@Q“É9@Û9@Q“ñ9@:@Q“:@+:@Q“A:@S:@Q“i:@{:@Q“‘:@£:@Q“¹:@Ë:@Q“á:@ó:@Q“ ;@;@Q“6;@C;@Q“Ž;@—;@Q“²;@¿;@Q“7<@@<@Q“[<@h<@Q“à<@é<@Q“=@=@Q“>@$>@Q“?>@L>@Q“V?@_?@Q“z?@‡?@Q“\@@e@@Q“p@@u@@P“u@@~@@Q“š@@£@@P“$A@(A@Q“(A@-A@}“-A@6A@ x3$}"“FA@OA@P“A@¦A@Q“ïA@ôA@}x“ôA@ýA@Q“B@%B@Q“;B@RB@Q“B@ˆB@Q“£B@°B@Q“ûB@C@Q“C@,C@Q“¤C@­C@Q“ÈC@ÕC@Q“MD@VD@Q“lD@~D@Q“•D@©D@Q“×D@àD@Q“öD@E@Q“E@0E@Q“LE@UE@P“ÍE@ÖE@Q“ñE@þE@Q“4G@KG@ x3$}"“‡G@•G@ x3$}"“¬G@µG@P“@#@T““ #@&@T“P““&@)@ ‘ˆU“P““)@1@ ‘ˆU“‘ŒU““1@W @‘ˆU“‘ŒU“‘U“‘”U“?!@I!@Q“P“‘ø}“‘ü}“I!@^!@Q“r“‘ø}“‘ü}“Å!@É!@ v““v““É!@Ö!@v“v “v“v “!#@2#@‘ˆU“‘ŒU“‘U“‘”U“Q#@IF@‘ˆU“‘ŒU“‘U“‘”U“4G@µG@‘ˆU“‘ŒU“‘U“‘”U“é@ð@0Ÿð@1@\ß@³!@0Ÿ³!@Á!@\Ö!@Q#@0ŸIF@4G@0Ÿ}G@‡G@0ŸµG@ÄG@0Ÿ0@Œ@ s~2#ŸIF@QF@ s~2#Ÿa@(@^àF@ãF@^ƒ@¬@P¬@Â@_Â@Ç@V­@I@ ‘ØT1$#ŸàF@íF@ ‘ØT1$#ŸÇ@I@ ‘ØT3$#ŸàF@íF@ ‘ØT3$#Ÿî@I@ ‘ØT4$#ŸàF@íF@ ‘ØT4$#Ÿ @ @P @S@_[@{@}H[@¶@0Ÿ[@{@Q|@•@P|@•@P´$@È$@PÈ$@ö$@_(%@A%@PÑ%@ê%@Pz&@“&@P#'@<'@PÔ'@è'@Pè'@(@_P(@d(@Pd(@’(@_Ì(@à(@Pà(@)@_H)@\)@P\)@Š)@_Ä)@Ø)@PØ)@*@_@*@T*@PT*@‚*@_¼*@Ð*@PÐ*@þ*@_È+@Ô+@P ,@,@P,@O,@_¸,@Ñ,@PÑ,@Ø,@‘¸T#Ç-@à-@Pà-@ç-@‘¸T#Ö.@ï.@Pï.@ö.@‘¸T#O0@c0@Pc0@‘0@_È0@Ü0@PÜ0@ 1@_G1@S1@P1@¡1@P¡1@Ï1@_ 2@2@PR2@f2@Pf2@”2@_Î2@â2@Pâ2@3@_B3@[3@Pö3@4@P·4@Ã4@Pr5@†5@P†5@´5@_Á5@Í5@P–6@ª6@Pª6@Ø6@_¯7@Ã7@PÃ7@ñ7@_+8@?8@P?8@m8@_Ï8@ã8@Pã8@9@_v9@‚9@PL;@`;@P`;@Ž;@_À;@Ù;@Pi<@‚<@P=@+=@PM>@f>@Pˆ?@¡?@Pi@@u@@P¬@@À@@PÀ@@ò@@_:A@OA@P¹B@ÍB@PÍB@ûB@_-C@FC@PÖC@ïC@PVE@oE@PF@F@PF@IF@_ª@Ç@‘¸T#ª@Ç@‘¸T#@#@‘¸T#E@W@‘¸T#W@{@_{@@‘¸T#@¶@_Q#@^#@}x^#@#@_Ä$@È$@PÈ$@ö$@_V%@s%@‘¸T#ÿ%@&@‘¸T#¨&@Å&@‘¸T#Q'@n'@‘¸T#ä'@è'@Pè'@(@_`(@d(@Pd(@’(@_Ü(@à(@Pà(@)@_X)@\)@P\)@Š)@_Ô)@Ø)@PØ)@*@_P*@T*@PT*@‚*@_Ì*@Ð*@PÐ*@þ*@_‰+@š+@}x,@,@P,@O,@_)-@6-@‘¸T#X-@j-@‘¸T#j-@˜-@_8.@E.@‘¸T#g.@y.@‘¸T#y.@§.@_G/@T/@‘¸T#v/@ˆ/@‘¸T#ˆ/@¶/@__0@c0@Pc0@‘0@_Ø0@Ü0@PÜ0@ 1@_ 1@1@}x1@:1@_1@¡1@P¡1@Ï1@_Ï1@Ü1@}xÜ1@ÿ1@_b2@f2@Pf2@”2@_Þ2@â2@Pâ2@3@_p3@3@‘¸T#¹3@Æ3@}xÆ3@é3@_z4@‡4@}x‡4@ª4@_‚5@†5@P†5@´5@_Í5@Ú5@}xÚ5@ý5@_¦6@ª6@Pª6@Ø6@_¿7@Ã7@PÃ7@ñ7@_;8@?8@P?8@m8@_ß8@ã8@Pã8@9@_99@F9@}xF9@i9@_\;@`;@P`;@Ž;@_î;@ <@‘¸T#—<@´<@‘¸T#@=@]=@‘¸T#¬=@¹=@‘¸T#Û=@í=@‘¸T#í=@>@_{>@˜>@‘¸T#ç>@ô>@‘¸T#?@(?@‘¸T#(?@V?@_¶?@Ó?@‘¸T#@@0@@‘¸T#¼@@À@@PÀ@@ä@@_ä@@ö@@‘¸T#ö@@$A@_kA@sA@‘¸TÂA@ÓA@}xÉB@ÍB@PÍB@ûB@_[C@xC@‘¸T#D@!D@‘¸T#„E@¡E@‘¸T#F@F@PF@IF@_Ü@è@P@S@ ò›S@‰@}pŸ‰@¶@}xŸZ#@#@]Ä$@ö$@]ä'@(@]`(@’(@]Ü(@)@]X)@Š)@]Ô)@*@]P*@‚*@]Ì*@þ*@],@O,@}pŸO,@‰,@}xŸÔ,@--@}`Ÿ--@f-@ òºf-@˜-@}xŸã-@<.@}`Ÿ<.@u.@ ò¾u.@§.@}xŸò.@K/@}`ŸK/@„/@ ò$„/@¶/@}xŸá/@0@}pŸ_0@‘0@]Ø0@ 1@]1@:1@]1@Ï1@}xŸØ1@ÿ1@]b2@”2@}xŸÞ2@3@}xŸÂ3@é3@]ƒ4@ª4@]‚5@´5@]Ö5@ý5@](6@_6@}pŸ¦6@Ø6@]¿7@ñ7@];8@m8@]ß8@9@]B9@i9@]\;@Ž;@}xŸ°=@é=@ ò.íé=@>@}xŸë>@$?@ ò€ñ$?@V?@}xŸ¼@@ò@@}pŸò@@$A@}xŸÉB@ûB@}xŸ D@×D@}hŸF@IF@}xŸÈ@è@P$@D@PX@z@PŽ@°@P_#@w#@PÉ$@ë$@Pt%@”%@P&@=&@PÆ&@æ&@Po'@'@Pé'@ (@Pe(@‡(@Pá(@)@P])@)@PÙ)@û)@PU*@w*@PÑ*@ó*@P›+@±+@P ,@B,@PT,@v,@PÙ,@û,@P7-@W-@Pk-@-@Pè-@ .@PF.@f.@Pz.@œ.@P÷.@/@PU/@u/@P‰/@«/@Pë/@ 0@Pd0@†0@PÝ0@ÿ0@P1@01@P¢1@Ä1@PÝ1@õ1@Pg2@‰2@Pã2@3@PŽ3@®3@PÇ3@ß3@Pˆ4@ 4@P‡5@©5@PÛ5@ó5@P26@T6@P«6@Í6@PÄ7@æ7@P@8@b8@Pä8@9@PG9@_9@Pa;@ƒ;@P <@,<@Pµ<@Õ<@P^=@~=@Pº=@Ú=@Pî=@>@P™>@¹>@Põ>@?@P)?@K?@PÔ?@ô?@P1@@Q@@PÁ@@ã@@P÷@@A@PtA@’A@PÔA@êA@PÎB@ðB@PyC@™C@P"D@BD@PªD@ÌD@P¢E@ÂE@PF@>F@Pº@¶@1ŸÈ@è@pŸ¢@Ç@}P¢@¶@2Ÿ¢@@_@¶@ ò›@#@‘¸T#@¶@ ò›8@D@P@¶@1Ÿ$@¶@ ò›$@D@pŸ@¶@0Ÿ@¶@9Ÿ@ @P @S@_E@¶@}pŸE@W@‘¸T#W@‰@_S@¶@}pŸk@z@PS@¶@1ŸX@¶@}pŸX@z@pŸ{@¶@}xŸ{@@‘¸T#@¶@_‰@¶@}xŸ¡@°@P‰@¶@1ŸŽ@¶@}xŸŽ@°@pŸQ#@#@]Q#@^#@}x^#@#@_Z#@#@]m#@w#@PZ#@#@1Ÿ_#@#@]_#@w#@pŸ‡$@ö$@0Ÿ‡$@ö$@DŸ‡$@«$@PÄ$@ö$@]Ä$@È$@PÈ$@ö$@_Ü$@ë$@PÄ$@ö$@1ŸÉ$@ö$@]É$@ë$@pŸ´$@È$@PÈ$@ö$@_%@'%@}x%@Ÿ%@DŸ%@'%@Q(%@A%@PV%@s%@‘¸T#ˆ%@”%@Pf%@Ÿ%@1Ÿt%@”%@pŸN%@s%@}N%@Ÿ%@4ŸN%@Ÿ%@_°%@Ð%@}x°%@H&@DŸ°%@Ð%@QÑ%@ê%@Pÿ%@&@‘¸T#1&@=&@P&@H&@1Ÿ&@=&@pŸ÷%@&@}÷%@H&@4Ÿ÷%@H&@_Y&@y&@}xY&@ñ&@DŸY&@y&@Qz&@“&@P¨&@Å&@‘¸T#Ú&@æ&@P¸&@ñ&@1ŸÆ&@æ&@pŸ &@Å&@} &@ñ&@NŸ &@ñ&@_'@"'@}x'@š'@DŸ'@"'@Q#'@<'@PQ'@n'@‘¸T#ƒ'@'@Pa'@š'@1Ÿo'@'@pŸI'@n'@}I'@š'@NŸI'@š'@_«'@Ë'@}x«'@(@DŸ«'@Ë'@Qä'@(@]ä'@è'@Pè'@(@_ü'@ (@Pä'@(@1Ÿé'@(@]é'@ (@pŸÔ'@è'@Pè'@(@_'(@G(@}x'(@’(@DŸ'(@G(@Q`(@’(@]`(@d(@Pd(@’(@_x(@‡(@P`(@’(@1Ÿe(@’(@]e(@‡(@pŸP(@d(@Pd(@’(@_£(@Ã(@}x£(@)@DŸ£(@Ã(@QÜ(@)@]Ü(@à(@Pà(@)@_ô(@)@PÜ(@)@1Ÿá(@)@]á(@)@pŸÌ(@à(@Pà(@)@_)@?)@}x)@Š)@DŸ)@?)@QX)@Š)@]X)@\)@P\)@Š)@_p)@)@PX)@Š)@1Ÿ])@Š)@]])@)@pŸH)@\)@P\)@Š)@_›)@»)@}x›)@*@DŸ›)@»)@QÔ)@*@]Ô)@Ø)@PØ)@*@_ì)@û)@PÔ)@*@1ŸÙ)@*@]Ù)@û)@pŸÄ)@Ø)@PØ)@*@_*@7*@}x*@‚*@DŸ*@7*@QP*@‚*@]P*@T*@PT*@‚*@_h*@w*@PP*@‚*@1ŸU*@‚*@]U*@w*@pŸ@*@T*@PT*@‚*@_“*@³*@}x“*@þ*@DŸ“*@³*@QÌ*@þ*@]Ì*@Ð*@PÐ*@þ*@_ä*@ó*@PÌ*@þ*@1ŸÑ*@þ*@]Ñ*@ó*@pŸ¼*@Ð*@PÐ*@þ*@_M+@d+@ ö}@ŸM+@d+@BŸM+@d+@P‰+@š+@}xª+@±+@P‘+@»+@1Ÿ›+@±+@pŸu+@š+@}u+@»+@2Ÿu+@»+@_È+@Ô+@PÞ+@‰,@0ŸÞ+@‰,@0ŸÞ+@,@P,@‰,@}pŸ,@,@P,@O,@_3,@B,@P,@‰,@1Ÿ ,@‰,@}pŸ ,@B,@pŸ ,@,@P,@O,@_C,@‰,@}xŸC,@S,@}O,@‰,@}xŸg,@v,@PO,@‰,@1ŸT,@‰,@}xŸT,@v,@pŸ-@ -@P -@f-@_“,@˜-@0Ÿ“,@˜-@.Ÿ“,@·,@P¸,@Ñ,@PÑ,@Ø,@‘¸T#Í,@˜-@}`ŸÍ,@Ø,@}hÔ,@˜-@}`Ÿì,@û,@PÔ,@˜-@1ŸÙ,@˜-@}`ŸÙ,@û,@pŸ)-@˜-@ òº)-@6-@‘¸T#--@˜-@ òºK-@W-@P--@˜-@1Ÿ7-@˜-@ òº7-@W-@pŸ-@˜-@0Ÿ-@˜-@9Ÿ-@ -@P -@f-@_X-@˜-@}xŸX-@j-@‘¸T#j-@˜-@_f-@˜-@}xŸ~-@-@Pf-@˜-@1Ÿk-@˜-@}xŸk-@-@pŸ+.@/.@P/.@u.@_¢-@§.@0Ÿ¢-@§.@,Ÿ¢-@Æ-@PÇ-@à-@Pà-@ç-@‘¸T#Ü-@§.@}`ŸÜ-@ç-@}hã-@§.@}`Ÿû-@ .@Pã-@§.@1Ÿè-@§.@}`Ÿè-@ .@pŸ8.@§.@ ò¾8.@E.@‘¸T#<.@§.@ ò¾Z.@f.@P<.@§.@1ŸF.@§.@ ò¾F.@f.@pŸ#.@§.@0Ÿ#.@§.@9Ÿ#.@/.@P/.@u.@_g.@§.@}xŸg.@y.@‘¸T#y.@§.@_u.@§.@}xŸ.@œ.@Pu.@§.@1Ÿz.@§.@}xŸz.@œ.@pŸ:/@>/@P>/@„/@_±.@¶/@0Ÿ±.@¶/@*Ÿ±.@Õ.@PÖ.@ï.@Pï.@ö.@‘¸T#ë.@¶/@}`Ÿë.@ö.@}hò.@¶/@}`Ÿ /@/@Pò.@¶/@1Ÿ÷.@¶/@}`Ÿ÷.@/@pŸG/@¶/@ ò$ÂG/@T/@‘¸T#K/@¶/@ ò$Âi/@u/@PK/@¶/@1ŸU/@¶/@ ò$ÂU/@u/@pŸ2/@¶/@0Ÿ2/@¶/@#Ÿ2/@>/@P>/@„/@_v/@¶/@}xŸv/@ˆ/@‘¸T#ˆ/@¶/@_„/@¶/@}xŸœ/@«/@P„/@¶/@1Ÿ‰/@¶/@}xŸ‰/@«/@pŸÃ/@0@0ŸÃ/@0@(ŸÃ/@Õ/@PÕ/@ê/@QÞ/@0@}pŸÞ/@ê/@}xá/@0@}pŸþ/@ 0@Pá/@0@1Ÿë/@0@}pŸë/@ 0@pŸ"0@‘0@0Ÿ"0@‘0@&Ÿ"0@F0@P_0@‘0@]_0@c0@Pc0@‘0@_w0@†0@P_0@‘0@1Ÿd0@‘0@]d0@†0@pŸO0@c0@Pc0@‘0@_›0@ 1@0Ÿ›0@ 1@$Ÿ›0@¿0@PØ0@ 1@]Ø0@Ü0@PÜ0@ 1@_ð0@ÿ0@PØ0@ 1@1ŸÝ0@ 1@]Ý0@ÿ0@pŸÈ0@Ü0@PÜ0@ 1@_ 1@:1@] 1@1@}x1@:1@_1@:1@]&1@01@P1@:1@1Ÿ1@:1@]1@01@pŸG1@S1@Pd1@„1@}pd1@Ï1@8Ÿd1@„1@Q1@Ï1@}xŸ1@¡1@P¡1@Ï1@_µ1@Ä1@P1@Ï1@1Ÿ¢1@Ï1@}xŸ¢1@Ä1@pŸ1@¡1@P¡1@Ï1@_Ï1@ÿ1@]Ï1@Ü1@}xÜ1@ÿ1@_Ø1@ÿ1@]ë1@õ1@PØ1@ÿ1@1ŸÝ1@ÿ1@]Ý1@õ1@pŸ 2@2@P)2@I2@}p)2@”2@"Ÿ)2@I2@Qb2@”2@}xŸb2@f2@Pf2@”2@_z2@‰2@Pb2@”2@1Ÿg2@”2@}xŸg2@‰2@pŸR2@f2@Pf2@”2@_¥2@Å2@}p¥2@3@0Ÿ¥2@Å2@QÞ2@3@}xŸÞ2@â2@Pâ2@3@_ö2@3@PÞ2@3@1Ÿã2@3@}xŸã2@3@pŸÎ2@â2@Pâ2@3@_!3@A3@}p!3@¹3@0Ÿ!3@A3@QB3@[3@Pp3@3@‘¸T#¢3@®3@P€3@¹3@1ŸŽ3@®3@pŸh3@3@}xh3@¹3@2Ÿh3@¹3@_¹3@é3@]¹3@Æ3@}xÆ3@é3@_Â3@é3@]Õ3@ß3@PÂ3@é3@1ŸÇ3@é3@]Ç3@ß3@pŸö3@4@P4@*4@}4@*4@JŸ4@*4@Q;4@R4@};4@R4@HŸ;4@R4@Qc4@z4@}c4@z4@4Ÿc4@z4@Qz4@ª4@]z4@‡4@}x‡4@ª4@_ƒ4@ª4@]–4@ 4@Pƒ4@ª4@1Ÿˆ4@ª4@]ˆ4@ 4@pŸ·4@Ã4@PÐ4@ë4@0ŸÐ4@ë4@CŸÐ4@â4@Pâ4@ë4@Qü4@5@}ü4@5@:Ÿü4@5@Q$5@;5@}$5@;5@2Ÿ$5@;5@QE5@´5@0ŸE5@´5@@ŸE5@i5@P‚5@´5@]‚5@†5@P†5@´5@_š5@©5@P‚5@´5@1Ÿ‡5@´5@]‡5@©5@pŸr5@†5@P†5@´5@_Á5@Í5@PÍ5@ý5@]Í5@Ú5@}xÚ5@ý5@_Ö5@ý5@]é5@ó5@PÖ5@ý5@1ŸÛ5@ý5@]Û5@ó5@pŸ 6@_6@0Ÿ 6@_6@FŸ 6@6@P6@16@Q%6@_6@}pŸ%6@16@}x(6@_6@}pŸE6@T6@P(6@_6@1Ÿ26@_6@}pŸ26@T6@pŸi6@Ø6@0Ÿi6@Ø6@DŸi6@6@P¦6@Ø6@]¦6@ª6@Pª6@Ø6@_¾6@Í6@P¦6@Ø6@1Ÿ«6@Ø6@]«6@Í6@pŸ–6@ª6@Pª6@Ø6@_é6@7@}pé6@7@2Ÿé6@7@Q7@(7@}7@(7@2Ÿ7@(7@Q57@P7@0Ÿ57@P7@CŸ57@G7@PG7@P7@Qa7@x7@}a7@x7@2Ÿa7@x7@Q‚7@ñ7@0Ÿ‚7@ñ7@@Ÿ‚7@¦7@P¿7@ñ7@]¿7@Ã7@PÃ7@ñ7@_×7@æ7@P¿7@ñ7@1ŸÄ7@ñ7@]Ä7@æ7@pŸ¯7@Ã7@PÃ7@ñ7@_8@"8@}x8@m8@<Ÿ8@"8@Q;8@m8@];8@?8@P?8@m8@_S8@b8@P;8@m8@1Ÿ@8@m8@]@8@b8@pŸ+8@?8@P?8@m8@_~8@•8@}~8@•8@<Ÿ~8@•8@Q¦8@Æ8@}x¦8@9@:Ÿ¦8@Æ8@Qß8@9@]ß8@ã8@Pã8@9@_÷8@9@Pß8@9@1Ÿä8@9@]ä8@9@pŸÏ8@ã8@Pã8@9@_"9@99@}"9@99@:Ÿ"9@99@Q99@i9@]99@F9@}xF9@i9@_B9@i9@]U9@_9@PB9@i9@1ŸG9@i9@]G9@_9@pŸv9@‚9@P“9@ª9@}x“9@ª9@0Ÿ“9@ª9@Q»9@Ò9@}»9@Ò9@FŸ»9@Ò9@Qã9@ú9@}ã9@ú9@FŸã9@ú9@Q :@":@} :@":@FŸ :@":@Q3:@J:@}3:@J:@FŸ3:@J:@Q[:@r:@}[:@r:@FŸ[:@r:@Qƒ:@š:@}ƒ:@š:@FŸƒ:@š:@Q«:@Â:@}«:@Â:@FŸ«:@Â:@QÓ:@ê:@}xÓ:@ê:@0ŸÓ:@ê:@Qû:@;@}xû:@;@0Ÿû:@;@Q#;@C;@}p#;@Ž;@0Ÿ#;@C;@Q\;@Ž;@}xŸ\;@`;@P`;@Ž;@_t;@ƒ;@P\;@Ž;@1Ÿa;@Ž;@}xŸa;@ƒ;@pŸL;@`;@P`;@Ž;@_Ÿ;@¿;@}pŸ;@7<@0ŸŸ;@¿;@QÀ;@Ù;@Pî;@ <@‘¸T# <@,<@Pþ;@7<@1Ÿ <@,<@pŸæ;@ <@}xæ;@7<@4Ÿæ;@7<@_H<@h<@}pH<@à<@0ŸH<@h<@Qi<@‚<@P—<@´<@‘¸T#É<@Õ<@P§<@à<@1Ÿµ<@Õ<@pŸ<@´<@}x<@à<@4Ÿ<@à<@_Ÿ=@£=@P£=@é=@_ñ<@=@}Pñ<@>@0Ÿñ<@=@Q=@+=@P@=@]=@‘¸T#r=@~=@PP=@>@1Ÿ^=@~=@pŸ8=@]=@}X8=@>@2Ÿ8=@—=@_¬=@>@ ò.í¬=@¹=@‘¸T#°=@>@ ò.íÎ=@Ú=@P°=@>@1Ÿº=@>@ ò.íº=@Ú=@pŸ—=@>@0Ÿ—=@>@7Ÿ—=@£=@P£=@é=@_Û=@>@}xŸÛ=@í=@‘¸T#í=@>@_é=@>@}xŸ>@>@Pé=@>@1Ÿî=@>@}xŸî=@>@pŸÚ>@Þ>@PÞ>@$?@_,>@L>@}P,>@V?@0Ÿ,>@L>@QM>@f>@P{>@˜>@‘¸T#­>@¹>@P‹>@V?@1Ÿ™>@¹>@pŸs>@˜>@}Xs>@V?@2Ÿs>@Ò>@_ç>@V?@ ò€ñç>@ô>@‘¸T#ë>@V?@ ò€ñ ?@?@Pë>@V?@1Ÿõ>@V?@ ò€ñõ>@?@pŸÒ>@V?@0ŸÒ>@V?@3ŸÒ>@Þ>@PÞ>@$?@_?@V?@}xŸ?@(?@‘¸T#(?@V?@_$?@V?@}xŸŸ|E@ÍE@_ÞE@þE@}pÞE@IF@0ŸÞE@þE@QF@IF@}xŸF@F@PF@IF@_/F@>F@PF@IF@1ŸF@IF@}xŸF@>F@pŸF@F@PF@IF@_4G@‡G@ ƒ@ŸžG@µG@ ñ}@ŸžG@µG@BŸžG@µG@Pý!@:"@ ’}@Ÿ:"@\"@Q2#@K#@‘~vF@ÛF@ ’}@ŸÛF@àF@‘~íF@4G@ ’}@Ÿ"@\"@P2#@Q#@0ŸvF@ŽF@PÓF@àF@P G@4G@2Ÿ@@w@9@w9@>@w°@±@w±@S@wS@T@w´@Ä@uÌÄ@ý@Pý@@Q@B@PB@I@QI@T@P»@Ä@u€Ä@E@[E@I@{ŸI@T@[Ü@I@ZÐG@ÔG@wÔG@þG@wÐG@íG@UíG@óG@RH@›H@U«H@­H@U°H@»H@UËH@ÍH@U I@$I@w$I@AI@wAI@BI@wBI@NI@w I@II@U I@MI@T I@MI@TPI@TI@wTI@qI@wqI@rI@wrI@~I@wPI@yI@UPI@}I@TPI@}I@TJ@J@UJ@J@TJ@J@wJ@J@wJ@J@wJ@÷J@wÀ÷J@úJ@wúJ@ûJ@wûJ@K@wK@JK@wÀJK@PK@wPK@QK@wQK@XK@wXK@jK@wÀjK@pK@wpK@qK@wqK@xK@wxK@ºK@wÀJ@&J@U&J@ûJ@VüJ@QK@VRK@qK@VrK@ºK@VJ@"J@T"J@úJ@SüJ@PK@SRK@pK@SrK@ºK@SIJ@úJ@SüJ@5K@SrK@ºK@SIJ@ûJ@VüJ@5K@VrK@ºK@VœJ@úJ@sÀK@ÄK@wÄK@€L@w€L@ˆL@wˆL@ÉL@wÉL@ÐL@wÐL@áL@wáL@èL@wèL@*M@wÀK@ÍK@UÍK@€L@SL@ÉL@SÊL@áL@SâL@*M@S)L@€L@s0M@UM@wUM@&N@w0&N@'N@w'N@3N@w00M@ZM@UZM@N@S'N@3N@S0M@QM@TQM@¦M@V0M@aM@QaM@N@]'N@3N@]hM@€M@P€M@N@\N@'N@P'N@3N@\˜M@N@]˜M@N@S˜M@N@\N@'N@P©M@­M@p­M@"N@^©M@N@]@N@DN@U@N@DN@T@N@DN@QPN@QN@wQN@TN@wTN@[N@w[N@·N@w ·N@¸N@w¸N@¹N@w¹N@ÀN@wÀN@êN@w PN@iN@UiN@˜N@VºN@ÆN@UÆN@êN@VPN@eN@T‰N@¸N@SºN@êN@SPN@eN@TeN@¸N@SºN@êN@SuN@„N@PÆN@×N@PðN@òN@wòN@óN@wóN@÷N@w÷N@²O@w ²O@³O@w³O@µO@wµO@ÀO@wÀO@ Q@w ðN@ûN@UûN@³O@V¶O@ Q@VðN@O@TO@²O@S¶O@ Q@S¶O@ÄO@|ŸÄO@ÖO@s ”#Ÿ¶O@,P@8ŸIP@P@8ŸÅP@Q@8Ÿ˜P@ÅP@S˜P@ÅP@1Ÿ~O@±O@SQ@+Q@w+Q@ÉQ@w0ÉQ@ÐQ@wÐQ@áQ@w0Q@YQ@UYQ@»Q@VÊQ@ÕQ@UÕQ@áQ@VQ@;Q@T;Q@jQ@SjQ@®Q@sŸÊQ@áQ@SQ@]Q@Q]Q@ÀQ@\ÊQ@ÕQ@QÕQ@áQ@\dQ@­Q@P­Q@®Q@]ÕQ@àQ@PàQ@áQ@]ðQ@òQ@wòQ@÷Q@w÷Q@øQ@wøQ@üQ@w üQ@ R@w( R@ÅR@w0ÅR@ÆR@w(ÆR@ÇR@w ÇR@ÉR@wÉR@ËR@wËR@ÌR@wÌR@èR@w0ðQ@R@UR@‚R@VÌR@ØR@VäR@èR@VðQ@R@TR@ÆR@SÆR@ÉR@|~ŸÌR@èR@SðQ@R@QR@ËR@]ÌR@èR@]µR@ÌR@PØR@ãR@PR@´R@PÌR@×R@PäR@èR@P R@ÉR@\ÌR@èR@\R@]R@0ŸäR@èR@0ŸðR@S@wS@S@w S@$S@wðR@S@US@S@SS@#S@UðR@S@TS@S@VS@#S@Q0S@2S@w2S@6S@w6S@:S@w:S@T@w T@T@wT@T@wT@T@wT@tU@w 0S@GS@UGS@T@VT@tU@V0S@CS@TnS@T@ST@tU@S0S@CS@TCS@T@ST@tU@SCS@T@ST@tU@ST@T@|ŸT@&T@s ”#ŸT@ˆT@8ŸœT@ÑT@8Ÿ!U@aU@8ŸðT@!U@SðT@!U@1ŸÐS@T@S€U@£U@w£U@…V@w0…V@V@wV@èW@w0€U@§U@U§U@BV@V†V@èW@V€U@°U@TÅU@V@S†V@èW@S€U@°U@T°U@V@S†V@èW@SÅU@V@SÅU@BV@VÅU@LV@]ÖU@ÚU@pÚU@QV@^ÖU@V@S=V@V@SÐV@×V@qŸ×V@æV@s ”#ŸÐV@tW@8Ÿ«W@ÜW@8ŸtW@«W@StW@«W@1ŸðW@òW@wòW@ôW@wôW@öW@wöW@øW@w øW@üW@w(üW@ýW@w0ýW@X@w8X@ïZ@wïZ@ðZ@w8ðZ@ñZ@w0ñZ@óZ@w(óZ@õZ@w õZ@÷Z@w÷Z@ùZ@wùZ@úZ@wúZ@tv@wðW@"X@U¸Y@äY@UäY@þY@|1Z@SZ@USZ@eZ@|Z@œZ@|Øn@ín@|ðW@"X@T¸Y@þY@T1Z@eZ@TZ@“Z@T“Z@œZ@|˜Øn@én@Tén@ín@|˜ðW@X@Q"X@óZ@\úZ@tv@\SX@VX@|ÌVX@—X@P›X@ïX@PY@Y@|èl@2l@PLl@Vl@|è+s@=s@P’t@Ît@Pu@&u@PJX@Y@]Y@Y@|ðY@Y@]l@2l@|ÀLl@Vl@|ð0s@=s@|Àu@&u@]NX@VX@]VX@ïX@YïX@¸Y@SËZ@ÙZ@SúZ@[@SM[@S[@Sœ[@¢[@Sä[@ê[@S,\@2\@SN\@\\@S‹\@™\@SÈ\@Ö\@S]@]@SB]@P]@S]@]@S¼]@Ê]@Sù]@^@S6^@D^@Ss^@^@S°^@¾^@Sí^@û^@S*_@8_@Sg_@u_@S¤_@²_@Sá_@ï_@S`@,`@S[`@i`@S˜`@¦`@SÕ`@ã`@Sa@ a@SOa@]a@SŒa@ša@SÉa@×a@Sb@b@SCb@Qb@S€b@Žb@S½b@Ëb@Súb@c@S7c@Ec@Stc@‚c@S±c@¿c@Sîc@üc@S+d@1d@SZd@gd@SŸd@­d@SÜd@êd@S&e@4e@Sce@qe@S e@®e@SÝe@ëe@Sf@(f@SWf@ef@S”f@¢f@SÑf@ßf@Sg@g@SKg@Yg@Sˆg@–g@SÅg@Óg@Sh@h@S?h@Mh@S|h@Šh@S¹h@Çh@Söh@i@S3i@Ai@Spi@~i@S­i@»i@Sêi@øi@S'j@5j@Sdj@rj@S¡j@¯j@SÞj@ìj@Sk@)k@SXk@#l@S#l@2l@|€2l@dl@SÞl@ìl@Sfm@lm@S®m@¼m@Sëm@ùm@S$n@*n@SSn@Yn@S›n@©n@Shp@s@S8s@=s@|€=s@4t@S@t@÷t@Su@&u@|€cu@tv@SòX@ Y@Q¡Y@¸Y@QËZ@ÒZ@QúZ@[@QM[@Z[@Qœ[@©[@Qä[@ñ[@Q,\@9\@QN\@U\@Q‹\@’\@QÈ\@Ï\@Q]@ ]@QB]@I]@Q]@†]@Q¼]@Ã]@Qù]@^@Q6^@=^@Qs^@z^@Q°^@·^@Qí^@ô^@Q*_@1_@Qg_@n_@Q¤_@«_@Qá_@è_@Q`@%`@Q[`@b`@Q˜`@Ÿ`@QÕ`@Ü`@Qa@a@QOa@Va@QŒa@“a@QÉa@Ða@Qb@ b@QCb@Jb@Q€b@‡b@Q½b@Äb@Qúb@c@Q7c@>c@Qtc@{c@Q±c@¸c@Qîc@õc@Q+d@8d@QZd@nd@QŸd@¦d@QÜd@ãd@Q&e@-e@Qce@je@Q e@§e@QÝe@äe@Qf@!f@QWf@^f@Q”f@›f@QÑf@Øf@Qg@g@QKg@Rg@Qˆg@g@QÅg@Ìg@Qh@ h@Q?h@Fh@Q|h@ƒh@Q¹h@Àh@Qöh@ýh@Q3i@:i@Qpi@wi@Q­i@´i@Qêi@ñi@Q'j@.j@Qdj@kj@Q¡j@¨j@QÞj@åj@Qk@"k@QXk@–k@Q2l@Ql@QVl@]l@QÞl@ål@Qfm@sm@Q®m@µm@Qëm@òm@Q$n@1n@QSn@`n@Q›n@¢n@Qbt@gt@QðW@"X@Q"X@óZ@\úZ@tv@\[@=[@:Ÿoo@Žo@:Ÿ[@/[@|/[@=[@]oo@Žo@]y[@[@p[@[@Q­o@Âo@Qv[@[@|[@œ[@]­o@Õo@]½[@ä[@9ŸŽo@­o@9Ÿ½[@Ñ[@|Ñ[@ä[@]Žo@­o@]\@,\@ ŸÕo@ôo@ Ÿ\@\@|\@,\@]Õo@ôo@]e@e@ ¨@Ÿjk@pk@Ppk@2l@‘¬hp@4t@‘¬@t@&u@‘¬cu@tv@‘¬Èk@2l@\hp@4t@\@t@st@\cu@tv@\Èk@ák@rák@ûk@Qhp@»p@Qgt@rt@Q{u@‚u@QÕk@ûk@|€hp@»p@Pgt@rt@P{u@‚u@|€tp@.q@Y.q@4t@‘¨cu@‚u@Y‚u@tv@‘¨tp@»p@0Ÿ{u@‚u@0Ÿ˜r@¥r@2Ÿ¥r@¸r@RÛu@v@1Ÿv@/v@R!q@6q@R³q@Ëq@Rçq@üq@Rüq@r@Qr@Fr@QFr@tr@‘°=s@hs@‘°hs@ws@Qws@às@‘ ïs@4t@‘°‚u@Åu@‘ 6q@·q@]Ãq@êq@]às@ïs@]6q@oq@yrŸËq@Ûq@y}Ÿàs@ïs@yrŸ:q@oq@}”1$Ÿàs@ïs@p1$ŸFr@]r@|Fr@tr@‘°=s@hs@‘°ïs@4t@‘°Fr@]r@ x‘¸"ŸFr@tr@1Ÿ=s@hs@1Ÿïs@4t@1Ÿhs@ws@*Ÿs@Ôs@P‚u@©u@:Ÿ©u@Åu@ ÿŸhs@ws@0ŸÊs@Ôs@Q u@©u@Qv@v@q1&p" $ &Ÿ&v@/v@T’t@&u@\’t@&u@Püt@&u@p $€€€€ >)Ÿšt@&u@|Àšt@&u@1Ÿol@ˆl@|ˆl@Þl@SMp@hp@Sol@Þl@0ŸMp@hp@0Ÿ¬l@Þl@\÷l@m@|m@fm@Sôo@p@S÷l@fm@0Ÿôo@p@0Ÿ4m@fm@\‡m@®m@\Ÿp@.p@\Ÿ‡m@›m@|›m@®m@]p@.p@]n@$n@ h@Ÿtn@›n@"Ÿ.p@Mp@"Ÿtn@ˆn@|ˆn@›n@].p@Mp@]xX@†X@ t2$‘˜"†X@ïX@ZDY@YY@0ŸþY@1Z@\SZ@ËZ@\Øn@oo@\&u@cu@\Øn@Ûn@pŸÛn@ín@| ”#ŸØn@oo@8Ÿ2u@cu@8ŸZ@ËZ@\Z@ËZ@1Ÿ€v@„v@U€v@„v@Tv@žv@wžv@Úv@w Úv@àv@wàv@w@w w@w@wv@©v@U©v@Öv@SÖv@Þv@Ußv@w@Sw@w@Uv@Æv@TÆv@Ñv@VÑv@Þv@Tßv@çv@Tçv@ w@V w@w@Tw@w@ww@‹w@w‹w@w@ww@šw@ww@w@Uw@‹w@SŒw@šw@S^w@Šw@S w@¡w@w¡w@gx@wgx@hx@w w@­w@U­w@dx@Sdx@hx@0Ÿ w@­w@U­w@gx@S x@gx@Spx@~x@w~x@®x@w ®x@°x@w°x@ëx@w ëx@ìx@wìx@óx@w px@ˆx@Uˆx@¥x@S¯x@âx@Sâx@çx@vhŸìx@óx@Sy@y@U@@K@wK@i@wi@n@wk@K@T@¬@¤@ê@í@ñ@ö@ú@ü@@~@@’@—@´@Í@Ñ@Ö@`@¬@°@Ö@b@d@s@“@œ@©@¼@Á@Á@à@±@Ë@@Q@˜@±@Ë@Ð@@Q@˜@±@Ë@Ð@)@>@˜@±@Ë@Ð@)@2@Ë@Ð@2@>@˜@±@ä@ý@@@`@Ð@à@@ú@p@€@@’@•@¢@©@­@¯@³@·@¼@º@Ð@`@d@f@{@@@@Ó@Ž@’@•@@¢@Ð@Õ@@@ö@Ž@’@•@@¢@Ð@Õ@@@@`@d@f@x@{@„@©@®@·@Ê@ˆ!@¸!@¿G@0@I@àF@íF@a@‰@Œ@’@•@™@@ý@Œ@’@•@™@@­@½@Â@­@½@Â@Ñ@Ø@Ü@ä@é@Ñ@Ø@Ü@ä@é@î@@„@‰@@@„@‰@@@„@‰@@–@›@±@º@¾@é@–@›@¶@º@±@¶@¾@é@±@¶@¾@é@±@¶@¾@Ü@±@¶@¾@Ü@±@¶@¾@È@±@¶@¾@È@¢@±@º@¾@ó@ø@ @@@E@ó@ø@@@ @@@E@ @@@E@ @@@8@ @@@8@ @@@$@ @@@$@ø@þ@@ @E@J@O@S@J@O@S@{@J@O@S@{@J@O@S@k@J@O@S@k@J@O@S@X@J@O@S@X@{@€@…@‰@€@…@‰@À@€@…@‰@À@€@…@‰@¡@€@…@‰@¡@€@…@‰@Ž@€@…@‰@Ž@Q#@V#@Z#@x#@Q#@V#@Z#@x#@Q#@V#@Z#@m#@Q#@V#@Z#@m#@Q#@V#@Z#@_#@Q#@V#@Z#@_#@´$@¹$@Ä$@ö$@´$@¹$@Ä$@ö$@´$@¹$@Ä$@ö$@´$@¹$@Ä$@Ü$@´$@¹$@Ä$@Ü$@´$@¹$@Ä$@É$@´$@¹$@Ä$@É$@-%@0%@5%@9%@-%@0%@5%@9%@-%@0%@5%@9%@B%@G%@]%@f%@j%@Ÿ%@B%@G%@b%@f%@]%@b%@j%@Ÿ%@]%@b%@j%@Ÿ%@]%@b%@j%@ˆ%@]%@b%@j%@ˆ%@]%@b%@j%@t%@]%@b%@j%@t%@N%@]%@f%@j%@Ö%@Ù%@Þ%@â%@Ö%@Ù%@Þ%@â%@Ö%@Ù%@Þ%@â%@ë%@ð%@&@&@&@H&@ë%@ð%@ &@&@&@ &@&@H&@&@ &@&@H&@&@ &@&@1&@&@ &@&@1&@&@ &@&@&@&@ &@&@&@÷%@&@&@&@&@‚&@‡&@‹&@&@‚&@‡&@‹&@&@‚&@‡&@‹&@”&@™&@¯&@¸&@¼&@ñ&@”&@™&@´&@¸&@¯&@´&@¼&@ñ&@¯&@´&@¼&@ñ&@¯&@´&@¼&@Ú&@¯&@´&@¼&@Ú&@¯&@´&@¼&@Æ&@¯&@´&@¼&@Æ&@ &@¯&@¸&@¼&@('@+'@0'@4'@('@+'@0'@4'@('@+'@0'@4'@='@B'@X'@a'@e'@š'@='@B'@]'@a'@X'@]'@e'@š'@X'@]'@e'@š'@X'@]'@e'@ƒ'@X'@]'@e'@ƒ'@X'@]'@e'@o'@X'@]'@e'@o'@I'@X'@a'@e'@Ô'@Ù'@ä'@(@Ô'@Ù'@ä'@(@Ô'@Ù'@ä'@(@Ô'@Ù'@ä'@ü'@Ô'@Ù'@ä'@ü'@Ô'@Ù'@ä'@é'@Ô'@Ù'@ä'@é'@P(@U(@`(@’(@P(@U(@`(@’(@P(@U(@`(@’(@P(@U(@`(@x(@P(@U(@`(@x(@P(@U(@`(@e(@P(@U(@`(@e(@Ì(@Ñ(@Ü(@)@Ì(@Ñ(@Ü(@)@Ì(@Ñ(@Ü(@)@Ì(@Ñ(@Ü(@ô(@Ì(@Ñ(@Ü(@ô(@Ì(@Ñ(@Ü(@á(@Ì(@Ñ(@Ü(@á(@H)@M)@X)@Š)@H)@M)@X)@Š)@H)@M)@X)@Š)@H)@M)@X)@p)@H)@M)@X)@p)@H)@M)@X)@])@H)@M)@X)@])@Ä)@É)@Ô)@*@Ä)@É)@Ô)@*@Ä)@É)@Ô)@*@Ä)@É)@Ô)@ì)@Ä)@É)@Ô)@ì)@Ä)@É)@Ô)@Ù)@Ä)@É)@Ô)@Ù)@@*@E*@P*@‚*@@*@E*@P*@‚*@@*@E*@P*@‚*@@*@E*@P*@h*@@*@E*@P*@h*@@*@E*@P*@U*@@*@E*@P*@U*@¼*@Á*@Ì*@þ*@¼*@Á*@Ì*@þ*@¼*@Á*@Ì*@þ*@¼*@Á*@Ì*@ä*@¼*@Á*@Ì*@ä*@¼*@Á*@Ì*@Ñ*@¼*@Á*@Ì*@Ñ*@E+@J+@M+@d+@u+@z+@+@²+@u+@z+@‘+@²+@u+@z+@‘+@²+@u+@z+@‘+@ª+@u+@z+@‘+@ª+@u+@z+@‘+@›+@u+@z+@‘+@›+@ ,@,@,@C,@ ,@,@,@C,@ ,@,@,@C,@ ,@,@,@3,@ ,@,@,@3,@ ,@,@,@ ,@ ,@,@,@ ,@G,@L,@O,@w,@G,@L,@O,@w,@G,@L,@O,@g,@G,@L,@O,@g,@G,@L,@O,@T,@G,@L,@O,@T,@½,@À,@Å,@É,@½,@À,@Å,@É,@½,@À,@Å,@É,@À,@Å,@Í,@ü,@À,@Å,@Ô,@ü,@À,@Å,@Ô,@ü,@À,@Å,@Ô,@ì,@À,@Å,@Ô,@ì,@À,@Å,@Ô,@Ù,@À,@Å,@Ô,@Ù,@-@ -@ -@%-@)-@X-@-@ -@)-@--@ -@%-@--@X-@ -@%-@--@X-@ -@%-@--@K-@ -@%-@--@K-@ -@%-@--@7-@ -@%-@--@7-@ -@-@-@-@X-@]-@b-@f-@]-@b-@f-@˜-@]-@b-@f-@˜-@]-@b-@f-@~-@]-@b-@f-@~-@]-@b-@f-@k-@]-@b-@f-@k-@Ì-@Ï-@Ô-@Ø-@Ì-@Ï-@Ô-@Ø-@Ì-@Ï-@Ô-@Ø-@Ï-@Ô-@Ü-@ .@Ï-@Ô-@ã-@ .@Ï-@Ô-@ã-@ .@Ï-@Ô-@ã-@û-@Ï-@Ô-@ã-@û-@Ï-@Ô-@ã-@è-@Ï-@Ô-@ã-@è-@.@.@/.@4.@8.@g.@.@.@8.@<.@/.@4.@<.@g.@/.@4.@<.@g.@/.@4.@<.@Z.@/.@4.@<.@Z.@/.@4.@<.@F.@/.@4.@<.@F.@.@ .@#.@+.@g.@l.@q.@u.@l.@q.@u.@§.@l.@q.@u.@§.@l.@q.@u.@.@l.@q.@u.@.@l.@q.@u.@z.@l.@q.@u.@z.@Û.@Þ.@ã.@ç.@Û.@Þ.@ã.@ç.@Û.@Þ.@ã.@ç.@Þ.@ã.@ë.@/@Þ.@ã.@ò.@/@Þ.@ã.@ò.@/@Þ.@ã.@ò.@ /@Þ.@ã.@ò.@ /@Þ.@ã.@ò.@÷.@Þ.@ã.@ò.@÷.@$/@)/@>/@C/@G/@v/@$/@)/@G/@K/@>/@C/@K/@v/@>/@C/@K/@v/@>/@C/@K/@i/@>/@C/@K/@i/@>/@C/@K/@U/@>/@C/@K/@U/@)/@//@2/@:/@v/@{/@€/@„/@{/@€/@„/@¶/@{/@€/@„/@¶/@{/@€/@„/@œ/@{/@€/@„/@œ/@{/@€/@„/@‰/@{/@€/@„/@‰/@Õ/@Ú/@Þ/@0@Õ/@Ú/@á/@0@Õ/@Ú/@á/@0@Õ/@Ú/@á/@þ/@Õ/@Ú/@á/@þ/@Õ/@Ú/@á/@ë/@Õ/@Ú/@á/@ë/@O0@T0@_0@‘0@O0@T0@_0@‘0@O0@T0@_0@‘0@O0@T0@_0@w0@O0@T0@_0@w0@O0@T0@_0@d0@O0@T0@_0@d0@È0@Í0@Ø0@ 1@È0@Í0@Ø0@ 1@È0@Í0@Ø0@ 1@È0@Í0@Ø0@ð0@È0@Í0@Ø0@ð0@È0@Í0@Ø0@Ý0@È0@Í0@Ø0@Ý0@ 1@1@1@11@ 1@1@1@11@ 1@1@1@&1@ 1@1@1@&1@ 1@1@1@1@ 1@1@1@1@1@’1@1@Ï1@1@’1@1@Ï1@1@’1@1@Ï1@1@’1@1@µ1@1@’1@1@µ1@1@’1@1@¢1@1@’1@1@¢1@Ï1@Ô1@Ø1@ö1@Ï1@Ô1@Ø1@ö1@Ï1@Ô1@Ø1@ë1@Ï1@Ô1@Ø1@ë1@Ï1@Ô1@Ø1@Ý1@Ï1@Ô1@Ø1@Ý1@R2@W2@b2@”2@R2@W2@b2@”2@R2@W2@b2@”2@R2@W2@b2@z2@R2@W2@b2@z2@R2@W2@b2@g2@R2@W2@b2@g2@Î2@Ó2@Þ2@3@Î2@Ó2@Þ2@3@Î2@Ó2@Þ2@3@Î2@Ó2@Þ2@ö2@Î2@Ó2@Þ2@ö2@Î2@Ó2@Þ2@ã2@Î2@Ó2@Þ2@ã2@G3@J3@O3@S3@G3@J3@O3@S3@G3@J3@O3@S3@\3@a3@w3@€3@„3@¹3@\3@a3@|3@€3@w3@|3@„3@¹3@w3@|3@„3@¹3@w3@|3@„3@¢3@w3@|3@„3@¢3@w3@|3@„3@Ž3@w3@|3@„3@Ž3@h3@w3@€3@„3@¹3@¾3@Â3@à3@¹3@¾3@Â3@à3@¹3@¾3@Â3@Õ3@¹3@¾3@Â3@Õ3@¹3@¾3@Â3@Ç3@¹3@¾3@Â3@Ç3@z4@4@ƒ4@¡4@z4@4@ƒ4@¡4@z4@4@ƒ4@–4@z4@4@ƒ4@–4@z4@4@ƒ4@ˆ4@z4@4@ƒ4@ˆ4@r5@w5@‚5@´5@r5@w5@‚5@´5@r5@w5@‚5@´5@r5@w5@‚5@š5@r5@w5@‚5@š5@r5@w5@‚5@‡5@r5@w5@‚5@‡5@Í5@Ò5@Ö5@ô5@Í5@Ò5@Ö5@ô5@Í5@Ò5@Ö5@é5@Í5@Ò5@Ö5@é5@Í5@Ò5@Ö5@Û5@Í5@Ò5@Ö5@Û5@6@!6@%6@_6@6@!6@(6@_6@6@!6@(6@_6@6@!6@(6@E6@6@!6@(6@E6@6@!6@(6@26@6@!6@(6@26@–6@›6@¦6@Ø6@–6@›6@¦6@Ø6@–6@›6@¦6@Ø6@–6@›6@¦6@¾6@–6@›6@¦6@¾6@–6@›6@¦6@«6@–6@›6@¦6@«6@¯7@´7@¿7@ñ7@¯7@´7@¿7@ñ7@¯7@´7@¿7@ñ7@¯7@´7@¿7@×7@¯7@´7@¿7@×7@¯7@´7@¿7@Ä7@¯7@´7@¿7@Ä7@+8@08@;8@m8@+8@08@;8@m8@+8@08@;8@m8@+8@08@;8@S8@+8@08@;8@S8@+8@08@;8@@8@+8@08@;8@@8@Ï8@Ô8@ß8@9@Ï8@Ô8@ß8@9@Ï8@Ô8@ß8@9@Ï8@Ô8@ß8@÷8@Ï8@Ô8@ß8@÷8@Ï8@Ô8@ß8@ä8@Ï8@Ô8@ß8@ä8@99@>9@B9@`9@99@>9@B9@`9@99@>9@B9@U9@99@>9@B9@U9@99@>9@B9@G9@99@>9@B9@G9@L;@Q;@\;@Ž;@L;@Q;@\;@Ž;@L;@Q;@\;@Ž;@L;@Q;@\;@t;@L;@Q;@\;@t;@L;@Q;@\;@a;@L;@Q;@\;@a;@Å;@È;@Í;@Ñ;@Å;@È;@Í;@Ñ;@Å;@È;@Í;@Ñ;@Ú;@ß;@õ;@þ;@<@7<@Ú;@ß;@ú;@þ;@õ;@ú;@<@7<@õ;@ú;@<@7<@õ;@ú;@<@ <@õ;@ú;@<@ <@õ;@ú;@<@ <@õ;@ú;@<@ <@æ;@õ;@þ;@<@n<@q<@v<@z<@n<@q<@v<@z<@n<@q<@v<@z<@ƒ<@ˆ<@ž<@§<@«<@à<@ƒ<@ˆ<@£<@§<@ž<@£<@«<@à<@ž<@£<@«<@à<@ž<@£<@«<@É<@ž<@£<@«<@É<@ž<@£<@«<@µ<@ž<@£<@«<@µ<@<@ž<@§<@«<@=@=@=@#=@=@=@=@#=@=@=@=@#=@,=@1=@G=@P=@T=@=@,=@1=@L=@P=@G=@L=@T=@=@G=@L=@T=@=@G=@L=@T=@r=@G=@L=@T=@r=@G=@L=@T=@^=@G=@L=@T=@^=@8=@G=@P=@T=@‰=@Ž=@£=@¨=@¬=@Û=@‰=@Ž=@¬=@°=@£=@¨=@°=@Û=@£=@¨=@°=@Û=@£=@¨=@°=@Î=@£=@¨=@°=@Î=@£=@¨=@°=@º=@£=@¨=@°=@º=@Ž=@”=@—=@Ÿ=@Û=@à=@å=@é=@à=@å=@é=@>@à=@å=@é=@>@à=@å=@é=@>@à=@å=@é=@>@à=@å=@é=@î=@à=@å=@é=@î=@R>@U>@Z>@^>@R>@U>@Z>@^>@R>@U>@Z>@^>@g>@l>@‚>@‹>@>@º>@g>@l>@‡>@‹>@‚>@‡>@>@º>@‚>@‡>@>@º>@‚>@‡>@>@­>@‚>@‡>@>@­>@‚>@‡>@>@™>@‚>@‡>@>@™>@s>@‚>@‹>@>@Ä>@É>@Þ>@ã>@ç>@?@Ä>@É>@ç>@ë>@Þ>@ã>@ë>@?@Þ>@ã>@ë>@?@Þ>@ã>@ë>@ ?@Þ>@ã>@ë>@ ?@Þ>@ã>@ë>@õ>@Þ>@ã>@ë>@õ>@É>@Ï>@Ò>@Ú>@?@?@ ?@$?@?@ ?@$?@V?@?@ ?@$?@V?@?@ ?@$?@C@2C@5C@:C@>C@2C@5C@:C@>C@GC@LC@bC@kC@oC@¤C@GC@LC@gC@kC@bC@gC@oC@¤C@bC@gC@oC@¤C@bC@gC@oC@C@bC@gC@oC@C@bC@gC@oC@yC@bC@gC@oC@yC@SC@bC@kC@oC@ÛC@ÞC@ãC@çC@ÛC@ÞC@ãC@çC@ÛC@ÞC@ãC@çC@ðC@õC@ D@D@D@MD@ðC@õC@D@D@ D@D@D@MD@ D@D@D@MD@ D@D@D@6D@ D@D@D@6D@ D@D@D@"D@ D@D@D@"D@üC@ D@D@D@†D@‹D@D@×D@†D@‹D@ D@×D@†D@‹D@ D@×D@†D@‹D@ D@½D@†D@‹D@ D@½D@†D@‹D@ D@ªD@†D@‹D@ D@ªD@[E@^E@cE@gE@[E@^E@cE@gE@[E@^E@cE@gE@pE@uE@‹E@”E@˜E@ÍE@pE@uE@E@”E@‹E@E@˜E@ÍE@‹E@E@˜E@ÍE@‹E@E@˜E@¶E@‹E@E@˜E@¶E@‹E@E@˜E@¢E@‹E@E@˜E@¢E@|E@‹E@”E@˜E@F@ F@F@QF@F@ F@F@QF@F@ F@F@QF@F@ F@F@/F@F@ F@F@/F@F@ F@F@F@F@ F@F@F@–G@›G@žG@¿G@ @ž @ý!@j"@2#@Q#@vF@àF@íF@4G@@@@5@9@>@Ð@ÄG@@>@Ä@B@E@I@ÔG@ÛG@ÞG@ôG@$I@=I@BI@NI@TI@mI@rI@~I@J@ŽJ@K@CK@JK@OK@XK@cK@jK@oK@xK@ºK@ŽJ@ðJ@÷J@ùJ@ŽJ@ðJ@÷J@ùJ@œJ@ðJ@÷J@ùJ@œJ@ðJ@÷J@ùJ@NM@QM@UM@ZM@]M@N@ N@N@'N@3N@˜M@N@ N@N@˜M@N@ N@N@[N@³N@ÀN@êN@eN@‘N@ÀN@êN@÷N@ûN@þN@±O@ÀO@ Q@÷N@ûN@þN@ O@ÀO@,P@PP@ˆP@˜P@ Q@÷N@ûN@þN@ O@ÀO@,P@PP@ˆP@ÈP@ Q@ÀO@,P@PP@ˆP@ÈP@ Q@~O@§O@®O@±O@~O@§O@®O@±O@+Q@/Q@5Q@®Q@ÐQ@áQ@þQ@R@ R@YR@`R@}R@R@ÁR@ÌR@äR@2S@5S@=S@T@T@tU@CS@]S@eS@nS@T@ˆT@ T@ØT@ðT@mU@CS@]S@eS@nS@T@ˆT@ T@ØT@(U@mU@T@ˆT@ T@ØT@(U@mU@ÐS@ùS@T@T@ÐS@ùS@T@T@£U@=V@QV@}V@V@èW@ÅU@1V@9V@=V@ÅU@1V@9V@=V@1V@9V@QV@}V@1V@9V@QV@}V@V@V@ÐV@èW@V@V@ÐV@xW@«W@èW@ÐV@xW@«W@èW@X@ëZ@úZ@tv@[@=[@oo@Žo@y[@œ[@­o@Õo@½[@ä[@Žo@­o@\@,\@Õo@ôo@Xk@8l@hp@·p@»p@ßp@áp@4t@@t@&u@cu@{u@‚u@tv@Èk@ök@hp@·p@»p@ßp@áp@Ár@Är@s@@s@4t@gt@st@cu@{u@‚u@Ñu@Ûu@tv@Èk@ök@hp@·p@»p@ßp@áp@Ár@Är@s@@s@4t@gt@st@cu@{u@‚u@Ñu@Ûu@tv@q@†r@@s@4t@‚u@Ñu@6q@³q@·q@êq@às@ïs@6q@pq@sq@wq@às@ïs@hs@às@‚u@Ñu@’t@ït@÷t@u@’t@ït@÷t@u@wl@’l@•l@˜l@Mp@hp@wl@’l@•l@˜l@Mp@hp@ÿl@m@m@ m@ôo@p@ÿl@m@m@ m@ôo@p@4m@fm@4t@@t@4m@fm@4t@@t@‡m@®m@p@.p@tn@›n@.p@Mp@DY@Y@·p@»p@ßp@áp@{u@‚u@þY@1Z@=[@M[@þY@1Z@=[@M[@SZ@eZ@Z@ËZ@Øn@oo@&u@cu@SZ@eZ@Øn@oo@&u@cu@Øn@oo@&u@cu@žv@¡v@§v@Ìv@Úv@w@w@w@w@Šw@w@šw@^w@€w@‡w@Šw@^w@€w@‡w@Šw@¡w@¥w@¨w@dx@ x@x@x@(x@+x@_x@ x@x@x@(x@+x@_x@@@G@K@e@i@n@ÐG@ y@°@T@@@n@.symtab.strtab.shstrtab.interp.note.ABI-tag.note.gnu.build-id.gnu.hash.dynsym.dynstr.gnu.version.gnu.version_r.rela.dyn.rela.plt.init.text.fini.rodata.eh_frame_hdr.eh_frame.gcc_except_table.init_array.ctors.dtors.jcr.data.rel.ro.dynamic.got.got.plt.data.bss.comment.debug_aranges.debug_info.debug_abbrev.debug_line.debug_str.debug_loc.debug_ranges8@8#T@T 1t@t$Döÿÿo˜@˜0N È@ÈPV@^ÿÿÿo¨ @¨ \kþÿÿo @ ÐzØ @Ø „h @h ¨ Ž@‰0@0€”°@°8gšèy@èy z@zt5 ¨t¯@t¯´¶(±@(±´Àܸ@ܸÒ˜º`˜º Þ¸º`¸ºåȺ`Ⱥìغ`غñàº`ຠþè½`è½Ð¸¿`¸¿0 è¿`è¿P@Á`@Á`  Ã` Ã0 0 Ã*)ÊÃ8ÚÄ QDzßRY3ñ,^0J`·7i˜¡t¢›†¢!‚(-Ð'[ ø>´ 8@T@t@˜@È@@¨ @ @ Ø @ h @ @ 0@ °@èy@z@t¯@(±@ܸ@˜º`¸º`Ⱥ`غ`àº`è½`¸¿`è¿`@Á` Ã` !"#$ œ@ñÿ¸º`*Ⱥ`8غ`E À@[°Ä`j¸Ä`x 0@ñÿ„Àº`‘ظ@Ÿغ`« °y@ÁñÿÑ °@¤î “@ø —@æ ›@ò Ÿ@è  @ò) ¤@ô4 ©@ô? ÐG@._ PN@šu ®@T @@.¯ÌÄ`¾ñÿË °@&¯ÀÄ`ßñÿñ à@&¯ÄÄ`ñÿ( Ð@¿; @”Wàº`c`…@¾n€ˆ@tz ‡@A‹@Œ@ߘ @y¡ @yª Ž@4¶`Ž@4Ä‹@:Ð @.¯ÈÄ`ðè¿`HÁ`¸º`$˜º`7è½`@ @Á`K @N@c H@{ àI@‘¥  y@µ p@T,× p@Þ ÀK@j J@ªH Q@Ñey J@¨¼ Ë ßñ"< I@dèy@j¤ ðQ@øÁ €U@hàô& °I@> ÀI@T 0S@D…Ÿ ðW@„ €I@à @ ÐH@^ y@ …z@”¦ w@ŠÄØ ðH@î@Á`û ðI@. €v@BU °H@m  w@Ȇ Ã`к`ª y@‰º  I@Ñ PI@.ê'  0@3U  px@ƒy Ö é   ñÿ Ã`' B  I@X t  I@“  I@.¬  v@Ú # ñÿÐÄ`( <  €H@S g } Å  `@pÜ  0M@  ,  H@rY m ñÿ Ã`t  ÐI@“ P@´  ðR@4Ñ `Á`@æ ù  ðN@* B [  àH@p ƒ —  `@Lœ  @¢ call_gmon_startcrtstuff.c__CTOR_LIST____DTOR_LIST____JCR_LIST____do_global_dtors_auxcompleted.6531dtor_idx.6533frame_dummy__CTOR_END____FRAME_END____JCR_END____do_global_ctors_auxsmt2newlexer.cc_ZL21yy_get_previous_statePv_ZL5yy_ec_ZL9yy_accept_ZL6yy_def_ZL7yy_meta_ZL7yy_base_ZL6yy_chk_ZL6yy_nxt_ZL14yy_fatal_errorPKcPv.isra.0_ZL13yy_push_stateiPv_ZL21yy_rule_can_match_eol_GLOBAL__sub_I_smt2newlexer.cc_ZStL8__ioinitparsetest.cc_GLOBAL__sub_I_mainsmt2newcontext.cc_GLOBAL__sub_I__ZN7ASTNode5printERSoismt2newparser.cc_ZL9yytnamerrPcPKc_ZL14yysyntax_errorPmPPcPsi_ZL7yytname_ZL6yypact_ZL7yycheck_ZL11yytranslate_ZL8yydefact_ZL4yyr2_ZL4yyr1_ZL7yypgoto_ZL9yydefgoto_ZL7yytable_GLOBAL__sub_I_smt2newparser.cc_GLOBAL_OFFSET_TABLE___dso_handle__init_array_end__init_array_start_DYNAMICdata_start_Z14smt2newreallocPvmS__Z17smt2newget_linenoPv_Z15smt2newget_llocPvfileno@@GLIBC_2.2.5__libc_csu_fini_Z12smt2newparseP14Smt2newContext_start_ZSt16__throw_bad_castv@@GLIBCXX_3.4_Z15smt2newlex_initPPv_Z21smt2newlex_init_extraP14Smt2newContextPPv_Z19smt2new_scan_bufferPcmPvstpcpy@@GLIBC_2.2.5_Z12smt2newallocmPv__fprintf_chk@@GLIBC_2.3.4isatty@@GLIBC_2.2.5__gmon_start___Jv_RegisterClassesexit@@GLIBC_2.2.5_ZNKSt5ctypeIcE13_M_widen_initEv@@GLIBCXX_3.4.11__printf_chk@@GLIBC_2.3.4_Z16smt2newset_extraP14Smt2newContextPv_finiputchar@@GLIBC_2.2.5_ZNSt8ios_base4InitC1Ev@@GLIBCXX_3.4_Z18smt2new_scan_bytesPKciPv_Z14smt2newrestartP8_IO_FILEPvmalloc@@GLIBC_2.2.5fopen@@GLIBC_2.2.5__libc_start_main@@GLIBC_2.2.5_Z16smt2newset_debugiPv_Z15smt2newget_lvalPv_Z24smt2newpush_buffer_stateP15yy_buffer_statePv__cxa_atexit@@GLIBC_2.2.5_Z10smt2newlexP7YYSTYPEP7YYLTYPEPv_Z13smt2newset_inP8_IO_FILEPv_ZNSt8ios_base4InitD1Ev@@GLIBCXX_3.4_Z13smt2newget_inPv_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@@GLIBCXX_3.4_ZN14Smt2newContext15destroy_scannerEv_IO_stdin_usedfree@@GLIBC_2.2.5_Z23smt2newpop_buffer_statePvstrlen@@GLIBC_2.2.5_Z15smt2newget_lengPv__data_start_Z15smt2newset_llocP7YYLTYPEPvferror@@GLIBC_2.2.5_Z11smt2newfreePvS_stdin@@GLIBC_2.2.5_Z17smt2newget_columnPv_Z18smt2newlex_destroyPv_ZSt4cout@@GLIBCXX_3.4__DTOR_END____libc_csu_init_Z16smt2newget_debugPv_Z17smt2newset_columniPv_ZNSt8__detail15_List_node_base7_M_hookEPS0_@@GLIBCXX_3.4.15_Z12smt2newerrorP7YYLTYPEP14Smt2newContextPKc_ZN14Smt2newContext12init_scannerEv_ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l@@GLIBCXX_3.4.9fread@@GLIBC_2.2.5__errno_location@@GLIBC_2.2.5strdup@@GLIBC_2.2.5__bss_start_ZNSo5flushEv@@GLIBCXX_3.4_Z15smt2newget_textPv__stack_chk_fail@@GLIBC_2.4_Z14smt2newset_outP8_IO_FILEPv_Z17smt2newset_linenoiPv_Z21smt2new_delete_bufferP15yy_buffer_statePv_ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate@@GLIBCXX_3.4_endfclose@@GLIBC_2.2.5_Z16smt2newget_extraPvstderr@@GLIBC_2.2.5clearerr@@GLIBC_2.2.5_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_@@GLIBCXX_3.4_ZN7ASTNode5printERSoi_Z21smt2new_create_bufferP8_IO_FILEiPvfwrite@@GLIBC_2.2.5realloc@@GLIBC_2.2.5_Z20smt2new_flush_bufferP15yy_buffer_statePvperror@@GLIBC_2.2.5_edata_Z15smt2newset_lvalP7YYSTYPEPv__gxx_personality_v0@@CXXABI_1.3_Z19smt2new_scan_stringPKcPv_ZN7ASTNode7typestrE_Znwm@@GLIBCXX_3.4_Z24smt2new_switch_to_bufferP15yy_buffer_statePv_Unwind_Resume@@GCC_3.0_ZNSo3putEc@@GLIBCXX_3.4_Z14smt2newget_outPvmemcpy@@GLIBC_2.14stdout@@GLIBC_2.2.5main_initgetc@@GLIBC_2.2.5opensmt-2.5.2/src/parsers/smt2new/parsetest.cc000066400000000000000000000040061445011647600214030ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ #include #include #include #include #include "smt2newcontext.h" extern void smt2newset_in ( FILE * ); extern void smt2newparse ( ); int main(int argc, char ** argv) { if (argc > 1 && strcmp(argv[1], "--help") == 0) { printf("Usage: %s [file]\n", argv[0]); return 1; } FILE* in; if (argc == 2) { if ((in = fopen(argv[1], "r")) == 0) { perror("Error opening file"); return 1; } } else in = fopen("/dev/stdin", "r"); Smt2newContext context(in); int rval = smt2newparse(&context); printf("Parser returned with result %d and ret val %d\n", context.result, rval); if (rval == 0) context.prettyPrint(std::cout); fclose(in); return rval; } opensmt-2.5.2/src/parsers/smt2new/smt2newcontext.cc000066400000000000000000000024541445011647600224020ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ #include #include "smt2newcontext.h" opensmt-2.5.2/src/parsers/smt2new/smt2newcontext.h000066400000000000000000000060301445011647600222360ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ #ifndef SMT2NEWCONTEXT_H #define SMT2NEWCONTEXT_H #include #include "SMTConfig.h" class Smt2newContext { private: int init_scanner(); void destroy_scanner(); char* buffer; int buffer_sz; int buffer_cap; ASTNode* root; public: void* scanner; int result; FILE* is; char* ib; bool interactive; inline const ASTNode* getRoot() { return root; }; Smt2newContext(FILE* in) : buffer_sz(0) , buffer_cap(1) , root(NULL) , result(0) , is(in) , ib(NULL) , interactive(false) { init_scanner(); buffer = (char *)malloc(buffer_cap); } Smt2newContext(char* in_s) : buffer_sz(0) , buffer_cap(1) , root(NULL) , result(0) , is(NULL) , ib(in_s) , interactive(true) { init_scanner(); buffer = (char*) malloc(buffer_cap); } ~Smt2newContext() { destroy_scanner(); delete root; free(buffer); } void insertBuf(char c) { if (buffer_cap < buffer_sz + 1) { buffer_cap *= 2; buffer = (char*) realloc(buffer, buffer_cap); } buffer[buffer_sz++] = c; } const char* getBuf() { insertBuf('\0'); return buffer; } void clearBuf() { buffer_sz = 0; } void insertRoot(ASTNode* n) { root = n; } void prettyPrint(std::ostream& o) { o << "Starting print" << std::endl; root->print(o, 0); } }; int smt2newparse(Smt2newContext*); #endif opensmt-2.5.2/src/parsers/smt2new/smt2newlexer.cc000066400000000000000000002777121445011647600220500ustar00rootroot00000000000000#line 1 "smt2new/smt2newlexer.cc" #line 3 "smt2new/smt2newlexer.cc" #define YY_INT_ALIGNED short int /* A lexical scanner generated by flex */ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MINOR_VERSION 6 #define YY_FLEX_SUBMINOR_VERSION 4 #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif #ifdef yy_create_buffer #define smt2new_create_buffer_ALREADY_DEFINED #else #define yy_create_buffer smt2new_create_buffer #endif #ifdef yy_delete_buffer #define smt2new_delete_buffer_ALREADY_DEFINED #else #define yy_delete_buffer smt2new_delete_buffer #endif #ifdef yy_scan_buffer #define smt2new_scan_buffer_ALREADY_DEFINED #else #define yy_scan_buffer smt2new_scan_buffer #endif #ifdef yy_scan_string #define smt2new_scan_string_ALREADY_DEFINED #else #define yy_scan_string smt2new_scan_string #endif #ifdef yy_scan_bytes #define smt2new_scan_bytes_ALREADY_DEFINED #else #define yy_scan_bytes smt2new_scan_bytes #endif #ifdef yy_init_buffer #define smt2new_init_buffer_ALREADY_DEFINED #else #define yy_init_buffer smt2new_init_buffer #endif #ifdef yy_flush_buffer #define smt2new_flush_buffer_ALREADY_DEFINED #else #define yy_flush_buffer smt2new_flush_buffer #endif #ifdef yy_load_buffer_state #define smt2new_load_buffer_state_ALREADY_DEFINED #else #define yy_load_buffer_state smt2new_load_buffer_state #endif #ifdef yy_switch_to_buffer #define smt2new_switch_to_buffer_ALREADY_DEFINED #else #define yy_switch_to_buffer smt2new_switch_to_buffer #endif #ifdef yypush_buffer_state #define smt2newpush_buffer_state_ALREADY_DEFINED #else #define yypush_buffer_state smt2newpush_buffer_state #endif #ifdef yypop_buffer_state #define smt2newpop_buffer_state_ALREADY_DEFINED #else #define yypop_buffer_state smt2newpop_buffer_state #endif #ifdef yyensure_buffer_stack #define smt2newensure_buffer_stack_ALREADY_DEFINED #else #define yyensure_buffer_stack smt2newensure_buffer_stack #endif #ifdef yylex #define smt2newlex_ALREADY_DEFINED #else #define yylex smt2newlex #endif #ifdef yyrestart #define smt2newrestart_ALREADY_DEFINED #else #define yyrestart smt2newrestart #endif #ifdef yylex_init #define smt2newlex_init_ALREADY_DEFINED #else #define yylex_init smt2newlex_init #endif #ifdef yylex_init_extra #define smt2newlex_init_extra_ALREADY_DEFINED #else #define yylex_init_extra smt2newlex_init_extra #endif #ifdef yylex_destroy #define smt2newlex_destroy_ALREADY_DEFINED #else #define yylex_destroy smt2newlex_destroy #endif #ifdef yyget_debug #define smt2newget_debug_ALREADY_DEFINED #else #define yyget_debug smt2newget_debug #endif #ifdef yyset_debug #define smt2newset_debug_ALREADY_DEFINED #else #define yyset_debug smt2newset_debug #endif #ifdef yyget_extra #define smt2newget_extra_ALREADY_DEFINED #else #define yyget_extra smt2newget_extra #endif #ifdef yyset_extra #define smt2newset_extra_ALREADY_DEFINED #else #define yyset_extra smt2newset_extra #endif #ifdef yyget_in #define smt2newget_in_ALREADY_DEFINED #else #define yyget_in smt2newget_in #endif #ifdef yyset_in #define smt2newset_in_ALREADY_DEFINED #else #define yyset_in smt2newset_in #endif #ifdef yyget_out #define smt2newget_out_ALREADY_DEFINED #else #define yyget_out smt2newget_out #endif #ifdef yyset_out #define smt2newset_out_ALREADY_DEFINED #else #define yyset_out smt2newset_out #endif #ifdef yyget_leng #define smt2newget_leng_ALREADY_DEFINED #else #define yyget_leng smt2newget_leng #endif #ifdef yyget_text #define smt2newget_text_ALREADY_DEFINED #else #define yyget_text smt2newget_text #endif #ifdef yyget_lineno #define smt2newget_lineno_ALREADY_DEFINED #else #define yyget_lineno smt2newget_lineno #endif #ifdef yyset_lineno #define smt2newset_lineno_ALREADY_DEFINED #else #define yyset_lineno smt2newset_lineno #endif #ifdef yyget_column #define smt2newget_column_ALREADY_DEFINED #else #define yyget_column smt2newget_column #endif #ifdef yyset_column #define smt2newset_column_ALREADY_DEFINED #else #define yyset_column smt2newset_column #endif #ifdef yywrap #define smt2newwrap_ALREADY_DEFINED #else #define yywrap smt2newwrap #endif #ifdef yyget_lval #define smt2newget_lval_ALREADY_DEFINED #else #define yyget_lval smt2newget_lval #endif #ifdef yyset_lval #define smt2newset_lval_ALREADY_DEFINED #else #define yyset_lval smt2newset_lval #endif #ifdef yyget_lloc #define smt2newget_lloc_ALREADY_DEFINED #else #define yyget_lloc smt2newget_lloc #endif #ifdef yyset_lloc #define smt2newset_lloc_ALREADY_DEFINED #else #define yyset_lloc smt2newset_lloc #endif #ifdef yyalloc #define smt2newalloc_ALREADY_DEFINED #else #define yyalloc smt2newalloc #endif #ifdef yyrealloc #define smt2newrealloc_ALREADY_DEFINED #else #define yyrealloc smt2newrealloc #endif #ifdef yyfree #define smt2newfree_ALREADY_DEFINED #else #define yyfree smt2newfree #endif /* First, we deal with platform-specific or compiler-specific issues. */ /* begin standard C headers. */ #include #include #include #include /* end standard C headers. */ /* flex integer type definitions */ #ifndef FLEXINT_H #define FLEXINT_H /* C99 systems have . Non-C99 systems may or may not. */ #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, * if you want the limit (max/min) macros for int types. */ #ifndef __STDC_LIMIT_MACROS #define __STDC_LIMIT_MACROS 1 #endif #include typedef int8_t flex_int8_t; typedef uint8_t flex_uint8_t; typedef int16_t flex_int16_t; typedef uint16_t flex_uint16_t; typedef int32_t flex_int32_t; typedef uint32_t flex_uint32_t; #else typedef signed char flex_int8_t; typedef short int flex_int16_t; typedef int flex_int32_t; typedef unsigned char flex_uint8_t; typedef unsigned short int flex_uint16_t; typedef unsigned int flex_uint32_t; /* Limits of integral types. */ #ifndef INT8_MIN #define INT8_MIN (-128) #endif #ifndef INT16_MIN #define INT16_MIN (-32767-1) #endif #ifndef INT32_MIN #define INT32_MIN (-2147483647-1) #endif #ifndef INT8_MAX #define INT8_MAX (127) #endif #ifndef INT16_MAX #define INT16_MAX (32767) #endif #ifndef INT32_MAX #define INT32_MAX (2147483647) #endif #ifndef UINT8_MAX #define UINT8_MAX (255U) #endif #ifndef UINT16_MAX #define UINT16_MAX (65535U) #endif #ifndef UINT32_MAX #define UINT32_MAX (4294967295U) #endif #ifndef SIZE_MAX #define SIZE_MAX (~(size_t)0) #endif #endif /* ! C99 */ #endif /* ! FLEXINT_H */ /* begin standard C++ headers. */ /* TODO: this is always defined, so inline it */ #define yyconst const #if defined(__GNUC__) && __GNUC__ >= 3 #define yynoreturn __attribute__((__noreturn__)) #else #define yynoreturn #endif /* Returned upon end-of-file. */ #define YY_NULL 0 /* Promotes a possibly negative, possibly signed char to an * integer in range [0..255] for use as an array index. */ #define YY_SC_TO_UI(c) ((YY_CHAR) (c)) /* An opaque pointer. */ #ifndef YY_TYPEDEF_YY_SCANNER_T #define YY_TYPEDEF_YY_SCANNER_T typedef void* yyscan_t; #endif /* For convenience, these vars (plus the bison vars far below) are macros in the reentrant scanner. */ #define yyin yyg->yyin_r #define yyout yyg->yyout_r #define yyextra yyg->yyextra_r #define yyleng yyg->yyleng_r #define yytext yyg->yytext_r #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) #define yy_flex_debug yyg->yy_flex_debug_r /* Enter a start condition. This macro really ought to take a parameter, * but we do it the disgusting crufty way forced on us by the ()-less * definition of BEGIN. */ #define BEGIN yyg->yy_start = 1 + 2 * /* Translate the current start state into a value that can be later handed * to BEGIN to return to the state. The YYSTATE alias is for lex * compatibility. */ #define YY_START ((yyg->yy_start - 1) / 2) #define YYSTATE YY_START /* Action number for EOF rule of a given start state. */ #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) /* Special action meaning "start processing a new file". */ #define YY_NEW_FILE yyrestart( yyin , yyscanner ) #define YY_END_OF_BUFFER_CHAR 0 /* Size of default input buffer. */ #ifndef YY_BUF_SIZE #ifdef __ia64__ /* On IA-64, the buffer size is 16k, not 8k. * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. * Ditto for the __ia64__ case accordingly. */ #define YY_BUF_SIZE 32768 #else #define YY_BUF_SIZE 16384 #endif /* __ia64__ */ #endif /* The state buf must be large enough to hold one state per character in the main buffer. */ #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) #ifndef YY_TYPEDEF_YY_BUFFER_STATE #define YY_TYPEDEF_YY_BUFFER_STATE typedef struct yy_buffer_state *YY_BUFFER_STATE; #endif #ifndef YY_TYPEDEF_YY_SIZE_T #define YY_TYPEDEF_YY_SIZE_T typedef size_t yy_size_t; #endif #define EOB_ACT_CONTINUE_SCAN 0 #define EOB_ACT_END_OF_FILE 1 #define EOB_ACT_LAST_MATCH 2 /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires * access to the local variable yy_act. Since yyless() is a macro, it would break * existing scanners that call yyless() from OUTSIDE yylex. * One obvious solution it to make yy_act a global. I tried that, and saw * a 5% performance hit in a non-yylineno scanner, because yy_act is * normally declared as a register variable-- so it is not worth it. */ #define YY_LESS_LINENO(n) \ do { \ int yyl;\ for ( yyl = n; yyl < yyleng; ++yyl )\ if ( yytext[yyl] == '\n' )\ --yylineno;\ }while(0) #define YY_LINENO_REWIND_TO(dst) \ do {\ const char *p;\ for ( p = yy_cp-1; p >= (dst); --p)\ if ( *p == '\n' )\ --yylineno;\ }while(0) /* Return all but the first "n" matched characters back to the input stream. */ #define yyless(n) \ do \ { \ /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ *yy_cp = yyg->yy_hold_char; \ YY_RESTORE_YY_MORE_OFFSET \ yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ YY_DO_BEFORE_ACTION; /* set up yytext again */ \ } \ while ( 0 ) #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner ) #ifndef YY_STRUCT_YY_BUFFER_STATE #define YY_STRUCT_YY_BUFFER_STATE struct yy_buffer_state { FILE *yy_input_file; char *yy_ch_buf; /* input buffer */ char *yy_buf_pos; /* current position in input buffer */ /* Size of input buffer in bytes, not including room for EOB * characters. */ int yy_buf_size; /* Number of characters read into yy_ch_buf, not including EOB * characters. */ int yy_n_chars; /* Whether we "own" the buffer - i.e., we know we created it, * and can realloc() it to grow it, and should free() it to * delete it. */ int yy_is_our_buffer; /* Whether this is an "interactive" input source; if so, and * if we're using stdio for input, then we want to use getc() * instead of fread(), to make sure we stop fetching input after * each newline. */ int yy_is_interactive; /* Whether we're considered to be at the beginning of a line. * If so, '^' rules will be active on the next match, otherwise * not. */ int yy_at_bol; int yy_bs_lineno; /**< The line count. */ int yy_bs_column; /**< The column count. */ /* Whether to try to fill the input buffer when we reach the * end of it. */ int yy_fill_buffer; int yy_buffer_status; #define YY_BUFFER_NEW 0 #define YY_BUFFER_NORMAL 1 /* When an EOF's been seen but there's still some text to process * then we mark the buffer as YY_EOF_PENDING, to indicate that we * shouldn't try reading from the input source any more. We might * still have a bunch of tokens to match, though, because of * possible backing-up. * * When we actually see the EOF, we change the status to "new" * (via yyrestart()), so that the user can continue scanning by * just pointing yyin at a new input file. */ #define YY_BUFFER_EOF_PENDING 2 }; #endif /* !YY_STRUCT_YY_BUFFER_STATE */ /* We provide macros for accessing buffer states in case in the * future we want to put the buffer states in a more general * "scanner state". * * Returns the top of the stack, or NULL. */ #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ : NULL) /* Same as previous macro, but useful when we know that the buffer stack is not * NULL or when we need an lvalue. For internal use only. */ #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] void yyrestart ( FILE *input_file , yyscan_t yyscanner ); void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner ); YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner ); void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner ); void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner ); void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner ); void yypop_buffer_state ( yyscan_t yyscanner ); static void yyensure_buffer_stack ( yyscan_t yyscanner ); static void yy_load_buffer_state ( yyscan_t yyscanner ); static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner ); #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner) YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner ); YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner ); YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner ); void *yyalloc ( yy_size_t , yyscan_t yyscanner ); void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner ); void yyfree ( void * , yyscan_t yyscanner ); #define yy_new_buffer yy_create_buffer #define yy_set_interactive(is_interactive) \ { \ if ( ! YY_CURRENT_BUFFER ){ \ yyensure_buffer_stack (yyscanner); \ YY_CURRENT_BUFFER_LVALUE = \ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ } #define yy_set_bol(at_bol) \ { \ if ( ! YY_CURRENT_BUFFER ){\ yyensure_buffer_stack (yyscanner); \ YY_CURRENT_BUFFER_LVALUE = \ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ } #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) /* Begin user sect3 */ #define smt2newwrap(yyscanner) (/*CONSTCOND*/1) #define YY_SKIP_YYWRAP typedef flex_uint8_t YY_CHAR; typedef int yy_state_type; #define yytext_ptr yytext_r static yy_state_type yy_get_previous_state ( yyscan_t yyscanner ); static yy_state_type yy_try_NUL_trans ( yy_state_type current_state , yyscan_t yyscanner); static int yy_get_next_buffer ( yyscan_t yyscanner ); static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner ); /* Done after the current pattern has been matched and before the * corresponding action - sets up yytext. */ #define YY_DO_BEFORE_ACTION \ yyg->yytext_ptr = yy_bp; \ yyleng = (int) (yy_cp - yy_bp); \ yyg->yy_hold_char = *yy_cp; \ *yy_cp = '\0'; \ yyg->yy_c_buf_p = yy_cp; #define YY_NUM_RULES 91 #define YY_END_OF_BUFFER 92 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info { flex_int32_t yy_verify; flex_int32_t yy_nxt; }; static const flex_int16_t yy_accept[559] = { 0, 0, 0, 0, 0, 0, 0, 92, 90, 2, 2, 3, 75, 90, 72, 74, 72, 68, 68, 90, 1, 72, 72, 72, 4, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 83, 81, 77, 78, 76, 82, 91, 87, 85, 86, 84, 89, 88, 2, 72, 0, 0, 72, 68, 0, 0, 0, 68, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 1, 72, 72, 72, 5, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 79, 80, 71, 70, 72, 72, 68, 69, 69, 68, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 9, 11, 28, 72, 72, 72, 72, 72, 72, 69, 69, 68, 68, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 72, 72, 72, 72, 72, 72, 72, 72, 20, 72, 72, 29, 72, 72, 72, 72, 72, 68, 73, 73, 73, 73, 73, 73, 73, 40, 73, 73, 61, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 62, 45, 73, 73, 73, 73, 73, 39, 73, 73, 73, 73, 73, 72, 72, 12, 13, 72, 72, 72, 7, 8, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 34, 72, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 65, 73, 44, 73, 73, 6, 10, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 73, 63, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 64, 72, 72, 72, 72, 72, 72, 23, 72, 72, 72, 72, 72, 72, 31, 72, 72, 37, 72, 72, 73, 73, 73, 73, 73, 73, 73, 73, 47, 73, 73, 73, 73, 73, 73, 46, 73, 14, 72, 72, 72, 72, 72, 72, 72, 72, 72, 25, 72, 27, 72, 30, 72, 72, 72, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 59, 72, 72, 72, 19, 72, 72, 72, 72, 24, 72, 36, 32, 38, 72, 73, 43, 73, 73, 73, 48, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 72, 16, 72, 18, 72, 72, 72, 72, 35, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 58, 73, 73, 73, 72, 15, 72, 72, 72, 72, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 17, 72, 72, 72, 72, 73, 73, 73, 73, 73, 73, 49, 73, 73, 73, 73, 73, 73, 73, 21, 22, 72, 26, 67, 73, 60, 73, 73, 73, 73, 54, 52, 73, 66, 73, 73, 72, 73, 73, 73, 73, 73, 73, 73, 73, 33, 73, 73, 42, 51, 73, 73, 73, 73, 73, 73, 73, 73, 73, 41, 73, 50, 73, 73, 73, 73, 55, 53, 73, 73, 73, 73, 73, 73, 56, 73, 73, 57, 0 } ; static const YY_CHAR yy_ec[256] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 5, 6, 7, 8, 8, 8, 9, 10, 10, 8, 8, 1, 11, 12, 13, 14, 15, 16, 16, 16, 16, 16, 16, 16, 16, 17, 18, 8, 8, 8, 8, 8, 19, 20, 21, 22, 23, 20, 24, 8, 25, 8, 8, 26, 27, 28, 8, 8, 8, 29, 30, 31, 32, 8, 8, 8, 8, 8, 1, 33, 1, 8, 34, 1, 35, 36, 37, 38, 39, 40, 41, 42, 43, 8, 44, 45, 46, 47, 48, 49, 8, 50, 51, 52, 53, 54, 55, 56, 57, 8, 1, 58, 1, 8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 } ; static const YY_CHAR yy_meta[59] = { 0, 1, 1, 2, 1, 3, 1, 1, 3, 4, 1, 3, 3, 3, 5, 5, 5, 1, 1, 5, 5, 5, 5, 5, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1, 3, 5, 5, 5, 5, 5, 5, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1 } ; static const flex_int16_t yy_base[565] = { 0, 0, 0, 57, 62, 67, 70, 666, 667, 73, 76, 0, 667, 26, 0, 667, 69, 77, 92, 94, 0, 642, 632, 632, 0, 611, 619, 621, 603, 610, 618, 617, 46, 616, 58, 612, 603, 667, 667, 667, 667, 667, 667, 80, 667, 667, 667, 667, 667, 667, 107, 0, 73, 0, 100, 105, 108, 135, 111, 140, 0, 85, 59, 86, 599, 604, 615, 122, 599, 96, 110, 606, 124, 0, 626, 619, 616, 593, 604, 124, 599, 591, 588, 587, 588, 588, 585, 600, 582, 587, 593, 588, 667, 667, 151, 0, 153, 156, 161, 164, 167, 170, 585, 577, 588, 592, 576, 138, 578, 572, 576, 576, 569, 145, 573, 154, 569, 583, 578, 571, 565, 589, 590, 587, 572, 573, 564, 565, 140, 572, 595, 0, 0, 0, 563, 566, 592, 553, 553, 548, 182, 185, 188, 191, 588, 556, 554, 555, 547, 559, 554, 541, 552, 549, 550, 549, 540, 548, 547, 533, 530, 530, 529, 532, 526, 158, 551, 548, 548, 525, 530, 538, 525, 519, 0, 525, 173, 0, 558, 167, 523, 517, 527, 203, 514, 516, 516, 515, 511, 513, 512, 547, 507, 503, 517, 503, 501, 499, 503, 502, 504, 497, 494, 496, 506, 496, 500, 523, 522, 516, 487, 527, 487, 497, 484, 489, 482, 485, 482, 480, 482, 493, 476, 479, 477, 475, 480, 465, 510, 468, 469, 475, 469, 505, 477, 463, 475, 477, 476, 0, 0, 499, 472, 462, 460, 471, 494, 453, 460, 451, 450, 452, 473, 472, 0, 0, 446, 457, 484, 0, 0, 443, 171, 441, 444, 440, 445, 437, 448, 446, 434, 445, 0, 173, 449, 432, 430, 430, 444, 468, 435, 438, 439, 434, 423, 434, 461, 460, 420, 431, 0, 429, 0, 424, 419, 0, 0, 430, 453, 174, 189, 415, 423, 418, 412, 424, 405, 422, 408, 412, 411, 396, 399, 399, 398, 0, 406, 396, 408, 408, 397, 393, 391, 403, 388, 429, 388, 385, 426, 397, 384, 382, 0, 381, 193, 379, 383, 380, 388, 0, 378, 379, 386, 373, 385, 371, 0, 385, 373, 0, 373, 384, 375, 369, 373, 373, 375, 366, 375, 368, 0, 373, 185, 370, 361, 359, 355, 0, 348, 0, 356, 350, 354, 354, 350, 347, 351, 348, 349, 0, 384, 0, 355, 0, 346, 341, 339, 339, 342, 351, 352, 346, 334, 334, 329, 345, 330, 332, 329, 331, 338, 332, 322, 337, 0, 326, 325, 321, 0, 318, 326, 322, 319, 0, 329, 0, 0, 0, 326, 312, 0, 352, 308, 318, 0, 317, 320, 319, 306, 318, 307, 303, 315, 305, 299, 300, 298, 0, 296, 0, 299, 307, 300, 296, 0, 300, 294, 298, 293, 290, 327, 286, 293, 296, 286, 298, 0, 284, 282, 287, 277, 0, 281, 280, 291, 275, 287, 270, 274, 278, 268, 273, 267, 276, 271, 275, 262, 258, 259, 262, 0, 259, 257, 261, 268, 255, 253, 254, 251, 259, 253, 0, 253, 248, 247, 286, 249, 243, 242, 0, 0, 241, 0, 0, 243, 0, 248, 242, 251, 242, 0, 0, 250, 0, 275, 242, 233, 230, 234, 234, 241, 240, 230, 240, 228, 0, 223, 227, 0, 0, 226, 222, 229, 223, 258, 217, 215, 227, 227, 0, 222, 0, 192, 191, 194, 198, 0, 0, 192, 202, 197, 188, 184, 113, 0, 101, 51, 0, 667, 244, 249, 252, 255, 260, 62 } ; static const flex_int16_t yy_def[565] = { 0, 558, 1, 559, 559, 560, 560, 558, 558, 558, 558, 561, 558, 558, 561, 558, 561, 558, 558, 562, 563, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 561, 558, 564, 561, 561, 558, 558, 558, 558, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 563, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 558, 558, 558, 564, 561, 561, 561, 558, 558, 558, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 558, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 561, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 561, 561, 561, 561, 561, 561, 561, 561, 561, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 561, 561, 561, 561, 561, 561, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 561, 561, 561, 561, 561, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 561, 561, 561, 561, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 561, 562, 562, 562, 562, 562, 562, 562, 562, 561, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 562, 0, 558, 558, 558, 558, 558, 558 } ; static const flex_int16_t yy_nxt[726] = { 0, 8, 9, 10, 9, 11, 12, 13, 14, 14, 15, 16, 14, 14, 17, 18, 18, 19, 20, 14, 14, 14, 21, 14, 14, 14, 14, 14, 22, 14, 23, 14, 14, 8, 24, 25, 14, 26, 27, 28, 29, 30, 14, 14, 14, 31, 14, 14, 14, 32, 33, 34, 35, 14, 14, 36, 14, 14, 37, 39, 40, 41, 52, 42, 39, 40, 41, 95, 42, 45, 46, 47, 45, 46, 47, 50, 50, 50, 50, 50, 50, 84, 53, 54, 55, 55, 92, 94, 94, 56, 43, 57, 57, 57, 85, 43, 557, 88, 104, 86, 48, 89, 105, 48, 56, 58, 59, 59, 59, 50, 50, 50, 96, 93, 54, 54, 54, 96, 97, 98, 98, 98, 99, 100, 100, 49, 101, 101, 49, 61, 102, 114, 62, 63, 64, 115, 106, 65, 103, 66, 556, 67, 107, 68, 69, 70, 71, 56, 72, 57, 57, 57, 56, 58, 59, 59, 59, 111, 116, 119, 555, 126, 117, 120, 127, 94, 94, 140, 141, 141, 112, 142, 142, 96, 97, 98, 98, 98, 99, 100, 100, 100, 100, 100, 143, 143, 143, 149, 156, 159, 150, 173, 174, 157, 205, 160, 140, 141, 141, 141, 141, 141, 183, 183, 183, 143, 143, 143, 216, 206, 223, 301, 224, 312, 335, 225, 217, 183, 183, 183, 396, 218, 219, 302, 313, 336, 220, 221, 337, 554, 370, 397, 338, 371, 398, 553, 552, 551, 399, 550, 549, 548, 547, 546, 372, 38, 38, 38, 38, 38, 44, 44, 44, 44, 44, 51, 51, 51, 60, 545, 60, 73, 544, 73, 73, 73, 543, 542, 541, 540, 539, 538, 537, 536, 535, 534, 533, 532, 531, 530, 529, 528, 527, 526, 525, 524, 523, 522, 521, 520, 519, 518, 517, 516, 515, 514, 513, 512, 511, 510, 509, 508, 507, 506, 505, 504, 503, 502, 501, 500, 499, 498, 497, 496, 495, 494, 493, 492, 491, 490, 489, 488, 487, 486, 485, 484, 483, 482, 481, 480, 479, 478, 477, 476, 475, 474, 473, 472, 471, 470, 469, 468, 467, 466, 465, 464, 463, 462, 461, 460, 459, 458, 457, 456, 455, 454, 453, 452, 451, 450, 449, 448, 447, 446, 445, 444, 443, 442, 441, 440, 439, 438, 437, 436, 435, 434, 433, 432, 431, 430, 429, 428, 427, 426, 425, 424, 423, 422, 421, 420, 419, 418, 417, 416, 415, 414, 413, 412, 411, 410, 409, 408, 407, 406, 405, 404, 403, 402, 401, 400, 395, 394, 393, 392, 391, 390, 389, 388, 387, 386, 385, 384, 383, 382, 381, 380, 379, 378, 377, 376, 375, 374, 373, 369, 368, 367, 366, 365, 364, 363, 362, 361, 360, 359, 358, 357, 356, 355, 354, 353, 352, 351, 350, 349, 348, 347, 346, 345, 344, 343, 342, 341, 340, 339, 334, 333, 332, 331, 330, 329, 328, 327, 326, 325, 324, 323, 322, 321, 320, 319, 318, 317, 316, 315, 314, 311, 310, 309, 308, 307, 306, 305, 304, 303, 300, 299, 298, 297, 296, 295, 294, 293, 292, 291, 290, 289, 288, 287, 286, 285, 284, 283, 282, 281, 280, 279, 278, 277, 276, 275, 274, 273, 272, 271, 270, 269, 268, 267, 266, 265, 264, 263, 262, 261, 260, 259, 258, 257, 256, 255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240, 239, 238, 237, 236, 235, 234, 233, 232, 231, 230, 229, 228, 227, 226, 222, 215, 214, 213, 212, 211, 210, 209, 208, 207, 204, 203, 202, 201, 200, 199, 198, 197, 196, 195, 194, 193, 192, 191, 190, 189, 188, 187, 186, 185, 184, 182, 181, 180, 179, 178, 177, 176, 175, 172, 171, 170, 169, 168, 167, 166, 165, 164, 163, 162, 161, 158, 155, 154, 153, 152, 151, 148, 147, 146, 145, 144, 139, 138, 137, 136, 135, 134, 133, 132, 131, 130, 129, 128, 125, 124, 123, 122, 121, 118, 113, 110, 109, 108, 91, 90, 87, 83, 82, 81, 80, 79, 78, 77, 76, 75, 74, 558, 7, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558 } ; static const flex_int16_t yy_chk[726] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 3, 13, 3, 4, 4, 4, 564, 4, 5, 5, 5, 6, 6, 6, 9, 9, 9, 10, 10, 10, 32, 13, 16, 16, 16, 43, 52, 52, 17, 3, 17, 17, 17, 32, 4, 556, 34, 62, 32, 5, 34, 62, 6, 18, 18, 18, 18, 18, 50, 50, 50, 54, 43, 54, 54, 54, 55, 55, 55, 55, 55, 56, 56, 56, 5, 58, 58, 6, 19, 61, 69, 19, 19, 19, 69, 63, 19, 61, 19, 555, 19, 63, 19, 19, 19, 19, 57, 19, 57, 57, 57, 59, 59, 59, 59, 59, 67, 70, 72, 553, 79, 70, 72, 79, 94, 94, 96, 96, 96, 67, 97, 97, 98, 98, 98, 98, 98, 99, 99, 99, 100, 100, 100, 101, 101, 101, 107, 113, 115, 107, 128, 128, 113, 165, 115, 140, 140, 140, 141, 141, 141, 142, 142, 142, 143, 143, 143, 176, 165, 179, 262, 179, 273, 299, 179, 176, 183, 183, 183, 362, 176, 176, 262, 273, 299, 176, 176, 300, 552, 334, 362, 300, 334, 362, 551, 550, 549, 362, 548, 545, 544, 543, 542, 334, 559, 559, 559, 559, 559, 560, 560, 560, 560, 560, 561, 561, 561, 562, 540, 562, 563, 538, 563, 563, 563, 537, 536, 535, 534, 533, 532, 531, 530, 527, 526, 524, 523, 522, 521, 520, 519, 518, 517, 516, 515, 514, 512, 509, 508, 507, 506, 504, 501, 498, 497, 496, 495, 494, 493, 492, 490, 489, 488, 487, 486, 485, 484, 483, 482, 481, 479, 478, 477, 476, 475, 474, 473, 472, 471, 470, 469, 468, 467, 466, 465, 464, 463, 462, 460, 459, 458, 457, 455, 454, 453, 452, 451, 450, 449, 448, 447, 446, 445, 443, 442, 441, 440, 438, 436, 435, 434, 433, 432, 431, 430, 429, 428, 427, 426, 425, 423, 422, 421, 419, 418, 414, 412, 411, 410, 409, 407, 406, 405, 403, 402, 401, 400, 399, 398, 397, 396, 395, 394, 393, 392, 391, 390, 389, 388, 387, 386, 385, 384, 382, 380, 378, 377, 376, 375, 374, 373, 372, 371, 370, 368, 366, 365, 364, 363, 361, 359, 358, 357, 356, 355, 354, 353, 352, 351, 350, 348, 347, 345, 344, 343, 342, 341, 340, 338, 337, 336, 335, 333, 331, 330, 329, 328, 327, 326, 325, 324, 323, 322, 321, 320, 319, 318, 317, 316, 314, 313, 312, 311, 310, 309, 308, 307, 306, 305, 304, 303, 302, 301, 298, 297, 294, 293, 291, 289, 288, 287, 286, 285, 284, 283, 282, 281, 280, 279, 278, 277, 276, 275, 274, 271, 270, 269, 268, 267, 266, 265, 264, 263, 261, 258, 257, 256, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 238, 237, 236, 235, 234, 233, 232, 231, 230, 229, 228, 227, 226, 225, 224, 223, 222, 221, 220, 219, 218, 217, 216, 215, 214, 213, 212, 211, 210, 209, 208, 207, 206, 205, 204, 203, 202, 201, 200, 199, 198, 197, 196, 195, 194, 193, 192, 191, 190, 189, 188, 187, 186, 185, 184, 182, 181, 180, 178, 175, 173, 172, 171, 170, 169, 168, 167, 166, 164, 163, 162, 161, 160, 159, 158, 157, 156, 155, 154, 153, 152, 151, 150, 149, 148, 147, 146, 145, 144, 139, 138, 137, 136, 135, 134, 130, 129, 127, 126, 125, 124, 123, 122, 121, 120, 119, 118, 117, 116, 114, 112, 111, 110, 109, 108, 106, 105, 104, 103, 102, 91, 90, 89, 88, 87, 86, 85, 84, 83, 82, 81, 80, 78, 77, 76, 75, 74, 71, 68, 66, 65, 64, 36, 35, 33, 31, 30, 29, 28, 27, 26, 25, 23, 22, 21, 7, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558 } ; /* Table of booleans, true if rule could match eol. */ static const flex_int32_t yy_rule_can_match_eol[92] = { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, }; /* The intent behind this definition is that it'll catch * any uses of REJECT which flex missed. */ #define REJECT reject_used_but_not_detected #define yymore() yymore_used_but_not_detected #define YY_MORE_ADJ 0 #define YY_RESTORE_YY_MORE_OFFSET #line 1 "smt2new/smt2newlexer.ll" /********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ #line 36 "smt2new/smt2newlexer.ll" #include #include #include #include #include "smt2tokens.h" #include "smt2newcontext.h" #include "smt2newparser.hh" #define YY_EXTRA_TYPE Smt2newContext* #define YY_USER_ACTION yyget_lloc(yyscanner)->first_line = yyget_lineno(yyscanner); #line 1065 "smt2new/smt2newlexer.cc" #line 1067 "smt2new/smt2newlexer.cc" #define INITIAL 0 #define STR 1 #define PSYM 2 #ifndef YY_NO_UNISTD_H /* Special case for "unistd.h", since it is non-ANSI. We include it way * down here because we want the user's section 1 to have been scanned first. * The user has a chance to override it with an option. */ #include #endif #ifndef YY_EXTRA_TYPE #define YY_EXTRA_TYPE void * #endif /* Holds the entire state of the reentrant scanner. */ struct yyguts_t { /* User-defined. Not touched by flex. */ YY_EXTRA_TYPE yyextra_r; /* The rest are the same as the globals declared in the non-reentrant scanner. */ FILE *yyin_r, *yyout_r; size_t yy_buffer_stack_top; /**< index of top of stack. */ size_t yy_buffer_stack_max; /**< capacity of stack. */ YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */ char yy_hold_char; int yy_n_chars; int yyleng_r; char *yy_c_buf_p; int yy_init; int yy_start; int yy_did_buffer_switch_on_eof; int yy_start_stack_ptr; int yy_start_stack_depth; int *yy_start_stack; yy_state_type yy_last_accepting_state; char* yy_last_accepting_cpos; int yylineno_r; int yy_flex_debug_r; char *yytext_r; int yy_more_flag; int yy_more_len; YYSTYPE * yylval_r; YYLTYPE * yylloc_r; }; /* end struct yyguts_t */ static int yy_init_globals ( yyscan_t yyscanner ); /* This must go here because YYSTYPE and YYLTYPE are included * from bison output in section 1.*/ # define yylval yyg->yylval_r # define yylloc yyg->yylloc_r int yylex_init (yyscan_t* scanner); int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner); /* Accessor methods to globals. These are made visible to non-reentrant scanners for convenience. */ int yylex_destroy ( yyscan_t yyscanner ); int yyget_debug ( yyscan_t yyscanner ); void yyset_debug ( int debug_flag , yyscan_t yyscanner ); YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner ); void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner ); FILE *yyget_in ( yyscan_t yyscanner ); void yyset_in ( FILE * _in_str , yyscan_t yyscanner ); FILE *yyget_out ( yyscan_t yyscanner ); void yyset_out ( FILE * _out_str , yyscan_t yyscanner ); int yyget_leng ( yyscan_t yyscanner ); char *yyget_text ( yyscan_t yyscanner ); int yyget_lineno ( yyscan_t yyscanner ); void yyset_lineno ( int _line_number , yyscan_t yyscanner ); int yyget_column ( yyscan_t yyscanner ); void yyset_column ( int _column_no , yyscan_t yyscanner ); YYSTYPE * yyget_lval ( yyscan_t yyscanner ); void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner ); YYLTYPE *yyget_lloc ( yyscan_t yyscanner ); void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner ); /* Macros after this point can all be overridden by user definitions in * section 1. */ #ifndef YY_SKIP_YYWRAP #ifdef __cplusplus extern "C" int yywrap ( yyscan_t yyscanner ); #else extern int yywrap ( yyscan_t yyscanner ); #endif #endif #ifndef YY_NO_UNPUT static void yyunput ( int c, char *buf_ptr , yyscan_t yyscanner); #endif #ifndef yytext_ptr static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner); #endif #ifdef YY_NEED_STRLEN static int yy_flex_strlen ( const char * , yyscan_t yyscanner); #endif #ifndef YY_NO_INPUT #ifdef __cplusplus static int yyinput ( yyscan_t yyscanner ); #else static int input ( yyscan_t yyscanner ); #endif #endif static void yy_push_state ( int _new_state , yyscan_t yyscanner); static void yy_pop_state ( yyscan_t yyscanner ); static int yy_top_state ( yyscan_t yyscanner ); /* Amount of stuff to slurp up with each read. */ #ifndef YY_READ_BUF_SIZE #ifdef __ia64__ /* On IA-64, the buffer size is 16k, not 8k */ #define YY_READ_BUF_SIZE 16384 #else #define YY_READ_BUF_SIZE 8192 #endif /* __ia64__ */ #endif /* Copy whatever the last rule matched to the standard output. */ #ifndef ECHO /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */ #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) #endif /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, * is returned in "result". */ #ifndef YY_INPUT #define YY_INPUT(buf,result,max_size) \ if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ int c = '*'; \ int n; \ for ( n = 0; n < max_size && \ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ if ( c == '\n' ) \ buf[n++] = (char) c; \ if ( c == EOF && ferror( yyin ) ) \ YY_FATAL_ERROR( "input in flex scanner failed" ); \ result = n; \ } \ else \ { \ errno=0; \ while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ { \ if( errno != EINTR) \ { \ YY_FATAL_ERROR( "input in flex scanner failed" ); \ break; \ } \ errno=0; \ clearerr(yyin); \ } \ }\ \ #endif /* No semi-colon after return; correct usage is to write "yyterminate();" - * we don't want an extra ';' after the "return" because that will cause * some compilers to complain about unreachable statements. */ #ifndef yyterminate #define yyterminate() return YY_NULL #endif /* Number of entries by which start-condition stack grows. */ #ifndef YY_START_STACK_INCR #define YY_START_STACK_INCR 25 #endif /* Report a fatal error. */ #ifndef YY_FATAL_ERROR #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) #endif /* end tables serialization structures and prototypes */ /* Default declaration of generated scanner - a define so the user can * easily add parameters. */ #ifndef YY_DECL #define YY_DECL_IS_OURS 1 extern int yylex \ (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner); #define YY_DECL int yylex \ (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner) #endif /* !YY_DECL */ /* Code executed at the beginning of each rule, after yytext and yyleng * have been set up. */ #ifndef YY_USER_ACTION #define YY_USER_ACTION #endif /* Code executed at the end of each rule. */ #ifndef YY_BREAK #define YY_BREAK /*LINTED*/break; #endif #define YY_RULE_SETUP \ YY_USER_ACTION /** The main scanner function which does all the work. */ YY_DECL { yy_state_type yy_current_state; char *yy_cp, *yy_bp; int yy_act; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yylval = yylval_param; yylloc = yylloc_param; if ( !yyg->yy_init ) { yyg->yy_init = 1; #ifdef YY_USER_INIT YY_USER_INIT; #endif if ( ! yyg->yy_start ) yyg->yy_start = 1; /* first start state */ if ( ! yyin ) yyin = stdin; if ( ! yyout ) yyout = stdout; if ( ! YY_CURRENT_BUFFER ) { yyensure_buffer_stack (yyscanner); YY_CURRENT_BUFFER_LVALUE = yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); } yy_load_buffer_state( yyscanner ); } { #line 53 "smt2new/smt2newlexer.ll" #line 1362 "smt2new/smt2newlexer.cc" while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { yy_cp = yyg->yy_c_buf_p; /* Support of yytext. */ *yy_cp = yyg->yy_hold_char; /* yy_bp points to the position in yy_ch_buf of the start of * the current run. */ yy_bp = yy_cp; yy_current_state = yyg->yy_start; yy_match: do { YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; if ( yy_accept[yy_current_state] ) { yyg->yy_last_accepting_state = yy_current_state; yyg->yy_last_accepting_cpos = yy_cp; } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 559 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; ++yy_cp; } while ( yy_base[yy_current_state] != 667 ); yy_find_action: yy_act = yy_accept[yy_current_state]; if ( yy_act == 0 ) { /* have to back up */ yy_cp = yyg->yy_last_accepting_cpos; yy_current_state = yyg->yy_last_accepting_state; yy_act = yy_accept[yy_current_state]; } YY_DO_BEFORE_ACTION; if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) { int yyl; for ( yyl = 0; yyl < yyleng; ++yyl ) if ( yytext[yyl] == '\n' ) do{ yylineno++; yycolumn=0; }while(0) ; } do_action: /* This label is used only to access EOF actions. */ switch ( yy_act ) { /* beginning of action switch */ case 0: /* must back up */ /* undo the effects of YY_DO_BEFORE_ACTION */ *yy_cp = yyg->yy_hold_char; yy_cp = yyg->yy_last_accepting_cpos; yy_current_state = yyg->yy_last_accepting_state; goto yy_find_action; case 1: YY_RULE_SETUP #line 55 "smt2new/smt2newlexer.ll" // Eat comments YY_BREAK case 2: /* rule 2 can match eol */ YY_RULE_SETUP #line 56 "smt2new/smt2newlexer.ll" // Eat spaces YY_BREAK case 3: YY_RULE_SETUP #line 58 "smt2new/smt2newlexer.ll" { return *yyget_text(yyscanner); } YY_BREAK case 4: YY_RULE_SETUP #line 59 "smt2new/smt2newlexer.ll" { return *yyget_text(yyscanner); } YY_BREAK case 5: YY_RULE_SETUP #line 60 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_as }; return TK_AS; } YY_BREAK case 6: YY_RULE_SETUP #line 62 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_DECIMAL }; return TK_DECIMAL; } YY_BREAK case 7: YY_RULE_SETUP #line 63 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_exists }; return TK_EXISTS; } YY_BREAK case 8: YY_RULE_SETUP #line 64 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_forall }; return TK_FORALL; } YY_BREAK case 9: YY_RULE_SETUP #line 65 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_let }; return TK_LET; } YY_BREAK case 10: YY_RULE_SETUP #line 66 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_NUMERAL }; return TK_NUMERAL; } YY_BREAK case 11: YY_RULE_SETUP #line 67 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_par }; return TK_PAR; } YY_BREAK case 12: YY_RULE_SETUP #line 68 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_STRING}; return TK_STRING; } YY_BREAK case 13: YY_RULE_SETUP #line 70 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_assert }; return TK_ASSERT; } YY_BREAK case 14: YY_RULE_SETUP #line 71 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_checksat }; return TK_CHECKSAT; } YY_BREAK case 15: YY_RULE_SETUP #line 72 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_declaresort }; return TK_DECLARESORT; } YY_BREAK case 16: YY_RULE_SETUP #line 73 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_declarefun }; return TK_DECLAREFUN; } YY_BREAK case 17: YY_RULE_SETUP #line 74 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_declareconst} ; return TK_DECLARECONST; } YY_BREAK case 18: YY_RULE_SETUP #line 75 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_definesort }; return TK_DEFINESORT; } YY_BREAK case 19: YY_RULE_SETUP #line 76 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_definefun }; return TK_DEFINEFUN; } YY_BREAK case 20: YY_RULE_SETUP #line 77 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_exit }; return TK_EXIT; } YY_BREAK case 21: YY_RULE_SETUP #line 78 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_getassertions }; return TK_GETASSERTIONS; } YY_BREAK case 22: YY_RULE_SETUP #line 79 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_getassignment }; return TK_GETASSIGNMENT; } YY_BREAK case 23: YY_RULE_SETUP #line 80 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_getinfo }; return TK_GETINFO; } YY_BREAK case 24: YY_RULE_SETUP #line 81 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_getoption }; return TK_GETOPTION; } YY_BREAK case 25: YY_RULE_SETUP #line 82 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_getproof }; return TK_GETPROOF; } YY_BREAK case 26: YY_RULE_SETUP #line 83 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_getunsatcore }; return TK_GETUNSATCORE; } YY_BREAK case 27: YY_RULE_SETUP #line 84 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_getvalue }; return TK_GETVALUE; } YY_BREAK case 28: YY_RULE_SETUP #line 85 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_pop }; return TK_POP; } YY_BREAK case 29: YY_RULE_SETUP #line 86 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_push }; return TK_PUSH; } YY_BREAK case 30: YY_RULE_SETUP #line 87 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_setlogic }; return TK_SETLOGIC; } YY_BREAK case 31: YY_RULE_SETUP #line 88 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_setinfo }; return TK_SETINFO; } YY_BREAK case 32: YY_RULE_SETUP #line 89 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_setoption }; return TK_SETOPTION; } YY_BREAK case 33: YY_RULE_SETUP #line 90 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_getinterpolants }; return TK_GETITPS; } YY_BREAK case 34: YY_RULE_SETUP #line 91 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_theory }; return TK_THEORY; } YY_BREAK case 35: YY_RULE_SETUP #line 92 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_writestate }; return TK_WRSTATE; } YY_BREAK case 36: YY_RULE_SETUP #line 93 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_readstate }; return TK_RDSTATE; } YY_BREAK case 37: YY_RULE_SETUP #line 94 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_simplify }; return TK_SIMPLIFY; } YY_BREAK case 38: YY_RULE_SETUP #line 95 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->tok = { t_writefuns }; return TK_WRFUNS; } YY_BREAK case 39: YY_RULE_SETUP #line 97 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_SORTS; } YY_BREAK case 40: YY_RULE_SETUP #line 98 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_FUNS; } YY_BREAK case 41: YY_RULE_SETUP #line 99 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_SORTSDESCRIPTION; } YY_BREAK case 42: YY_RULE_SETUP #line 100 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_FUNSDESCRIPTION; } YY_BREAK case 43: YY_RULE_SETUP #line 101 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_DEFINITION; } YY_BREAK case 44: YY_RULE_SETUP #line 102 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_VALUES; } YY_BREAK case 45: YY_RULE_SETUP #line 103 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_NOTES; } YY_BREAK case 46: YY_RULE_SETUP #line 104 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_THEORIES; } YY_BREAK case 47: YY_RULE_SETUP #line 105 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_LANGUAGE; } YY_BREAK case 48: YY_RULE_SETUP #line 106 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_EXTENSIONS; } YY_BREAK case 49: YY_RULE_SETUP #line 107 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_PRINTSUCCESS; } YY_BREAK case 50: YY_RULE_SETUP #line 108 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_EXPANDDEFINITIONS; } YY_BREAK case 51: YY_RULE_SETUP #line 109 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_INTERACTIVEMODE; } YY_BREAK case 52: YY_RULE_SETUP #line 110 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_PRODUCEPROOFS; } YY_BREAK case 53: YY_RULE_SETUP #line 111 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_PRODUCEUNSATCORES; } YY_BREAK case 54: YY_RULE_SETUP #line 112 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_PRODUCEMODELS; } YY_BREAK case 55: YY_RULE_SETUP #line 113 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_PRODUCEASSIGNMENTS; } YY_BREAK case 56: YY_RULE_SETUP #line 114 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_REGULAROUTPUTCHANNEL; } YY_BREAK case 57: YY_RULE_SETUP #line 115 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_DIAGNOSTICOUTPUTCHANNEL; } YY_BREAK case 58: YY_RULE_SETUP #line 116 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_RANDOMSEED; } YY_BREAK case 59: YY_RULE_SETUP #line 117 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_VERBOSITY; } YY_BREAK case 60: YY_RULE_SETUP #line 118 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_ERRORBEHAVIOR; } YY_BREAK case 61: YY_RULE_SETUP #line 119 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_NAME; } YY_BREAK case 62: YY_RULE_SETUP #line 120 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_NAMED; } YY_BREAK case 63: YY_RULE_SETUP #line 121 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_AUTHORS; } YY_BREAK case 64: YY_RULE_SETUP #line 122 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_VERSION; } YY_BREAK case 65: YY_RULE_SETUP #line 123 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_STATUS; } YY_BREAK case 66: YY_RULE_SETUP #line 124 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_REASONUNKNOWN; } YY_BREAK case 67: YY_RULE_SETUP #line 125 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_ALLSTATISTICS; } YY_BREAK case 68: YY_RULE_SETUP #line 128 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_NUM; } YY_BREAK case 69: YY_RULE_SETUP #line 129 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_DEC; } YY_BREAK case 70: YY_RULE_SETUP #line 130 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_HEX; } YY_BREAK case 71: YY_RULE_SETUP #line 131 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_BIN; } YY_BREAK case 72: YY_RULE_SETUP #line 133 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_SYM; } YY_BREAK case 73: YY_RULE_SETUP #line 134 "smt2new/smt2newlexer.ll" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_KEY; } YY_BREAK case 74: YY_RULE_SETUP #line 136 "smt2new/smt2newlexer.ll" { return *yyget_text(yyscanner); } YY_BREAK case 75: YY_RULE_SETUP #line 138 "smt2new/smt2newlexer.ll" { yy_push_state(STR, yyscanner); } YY_BREAK case 76: YY_RULE_SETUP #line 141 "smt2new/smt2newlexer.ll" { yyextra->insertBuf(' '); } YY_BREAK case 77: YY_RULE_SETUP #line 142 "smt2new/smt2newlexer.ll" { yyextra->insertBuf('\t'); } YY_BREAK case 78: /* rule 78 can match eol */ YY_RULE_SETUP #line 143 "smt2new/smt2newlexer.ll" { yyextra->insertBuf('\n'); } YY_BREAK case 79: YY_RULE_SETUP #line 144 "smt2new/smt2newlexer.ll" { yyextra->insertBuf('"'); } YY_BREAK case 80: YY_RULE_SETUP #line 145 "smt2new/smt2newlexer.ll" { yyextra->insertBuf('\\'); } YY_BREAK case 81: YY_RULE_SETUP #line 146 "smt2new/smt2newlexer.ll" { yyextra->insertBuf(yyget_text(yyscanner)[0]); } YY_BREAK case 82: YY_RULE_SETUP #line 147 "smt2new/smt2newlexer.ll" { yylval->str = strdup(yyextra->getBuf()); yyextra->clearBuf(); yy_pop_state(yyscanner); return TK_STR; } YY_BREAK case 83: YY_RULE_SETUP #line 151 "smt2new/smt2newlexer.ll" { yy_push_state(PSYM, yyscanner); } YY_BREAK case 84: YY_RULE_SETUP #line 154 "smt2new/smt2newlexer.ll" { yyextra->insertBuf(' '); } YY_BREAK case 85: YY_RULE_SETUP #line 155 "smt2new/smt2newlexer.ll" { yyextra->insertBuf('\t'); } YY_BREAK case 86: /* rule 86 can match eol */ YY_RULE_SETUP #line 156 "smt2new/smt2newlexer.ll" { yyextra->insertBuf('\n'); } YY_BREAK case 87: YY_RULE_SETUP #line 157 "smt2new/smt2newlexer.ll" { yyextra->insertBuf(yyget_text(yyscanner)[0]); } YY_BREAK case 88: YY_RULE_SETUP #line 158 "smt2new/smt2newlexer.ll" { yylval->str = strdup(yyextra->getBuf()); yyextra->clearBuf(); yy_pop_state(yyscanner); return TK_SYM; } YY_BREAK case 89: YY_RULE_SETUP #line 160 "smt2new/smt2newlexer.ll" { printf("Syntax error at line %d near %s, \\ not allowed inside | ... |\n", yyget_lineno(yyscanner), yyget_text(yyscanner)); exit(1); } YY_BREAK case 90: YY_RULE_SETUP #line 163 "smt2new/smt2newlexer.ll" { printf( "Syntax error at line %d near %s\n", yyget_lineno(yyscanner), yyget_text(yyscanner) ); exit( 1 ); } YY_BREAK case 91: YY_RULE_SETUP #line 165 "smt2new/smt2newlexer.ll" ECHO; YY_BREAK #line 1895 "smt2new/smt2newlexer.cc" case YY_STATE_EOF(INITIAL): case YY_STATE_EOF(STR): case YY_STATE_EOF(PSYM): yyterminate(); case YY_END_OF_BUFFER: { /* Amount of text matched not including the EOB char. */ int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; /* Undo the effects of YY_DO_BEFORE_ACTION. */ *yy_cp = yyg->yy_hold_char; YY_RESTORE_YY_MORE_OFFSET if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) { /* We're scanning a new file or input source. It's * possible that this happened because the user * just pointed yyin at a new source and called * yylex(). If so, then we have to assure * consistency between YY_CURRENT_BUFFER and our * globals. Here is the right place to do so, because * this is the first action (other than possibly a * back-up) that will match for the new input source. */ yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; } /* Note that here we test for yy_c_buf_p "<=" to the position * of the first EOB in the buffer, since yy_c_buf_p will * already have been incremented past the NUL character * (since all states make transitions on EOB to the * end-of-buffer state). Contrast this with the test * in input(). */ if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) { /* This was really a NUL. */ yy_state_type yy_next_state; yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; yy_current_state = yy_get_previous_state( yyscanner ); /* Okay, we're now positioned to make the NUL * transition. We couldn't have * yy_get_previous_state() go ahead and do it * for us because it doesn't know how to deal * with the possibility of jamming (and we don't * want to build jamming into it because then it * will run more slowly). */ yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; if ( yy_next_state ) { /* Consume the NUL. */ yy_cp = ++yyg->yy_c_buf_p; yy_current_state = yy_next_state; goto yy_match; } else { yy_cp = yyg->yy_c_buf_p; goto yy_find_action; } } else switch ( yy_get_next_buffer( yyscanner ) ) { case EOB_ACT_END_OF_FILE: { yyg->yy_did_buffer_switch_on_eof = 0; if ( yywrap( yyscanner ) ) { /* Note: because we've taken care in * yy_get_next_buffer() to have set up * yytext, we can now set up * yy_c_buf_p so that if some total * hoser (like flex itself) wants to * call the scanner after we return the * YY_NULL, it'll still work - another * YY_NULL will get returned. */ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; yy_act = YY_STATE_EOF(YY_START); goto do_action; } else { if ( ! yyg->yy_did_buffer_switch_on_eof ) YY_NEW_FILE; } break; } case EOB_ACT_CONTINUE_SCAN: yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; yy_current_state = yy_get_previous_state( yyscanner ); yy_cp = yyg->yy_c_buf_p; yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; goto yy_match; case EOB_ACT_LAST_MATCH: yyg->yy_c_buf_p = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; yy_current_state = yy_get_previous_state( yyscanner ); yy_cp = yyg->yy_c_buf_p; yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; goto yy_find_action; } break; } default: YY_FATAL_ERROR( "fatal flex scanner internal error--no action found" ); } /* end of action switch */ } /* end of scanning one token */ } /* end of user's declarations */ } /* end of yylex */ /* yy_get_next_buffer - try to read in a new buffer * * Returns a code representing an action: * EOB_ACT_LAST_MATCH - * EOB_ACT_CONTINUE_SCAN - continue scanning from current position * EOB_ACT_END_OF_FILE - end of file */ static int yy_get_next_buffer (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; char *source = yyg->yytext_ptr; int number_to_move, i; int ret_val; if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) YY_FATAL_ERROR( "fatal flex scanner internal error--end of buffer missed" ); if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) { /* Don't try to fill the buffer, so this is an EOF. */ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) { /* We matched a single character, the EOB, so * treat this as a final EOF. */ return EOB_ACT_END_OF_FILE; } else { /* We matched some text prior to the EOB, first * process it. */ return EOB_ACT_LAST_MATCH; } } /* Try to read more data. */ /* First move last chars to start of buffer. */ number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1); for ( i = 0; i < number_to_move; ++i ) *(dest++) = *(source++); if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) /* don't do the read, it's not guaranteed to return an EOF, * just force an EOF */ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; else { int num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; while ( num_to_read <= 0 ) { /* Not enough room in the buffer - grow it. */ /* just a shorter name for the current buffer */ YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; int yy_c_buf_p_offset = (int) (yyg->yy_c_buf_p - b->yy_ch_buf); if ( b->yy_is_our_buffer ) { int new_size = b->yy_buf_size * 2; if ( new_size <= 0 ) b->yy_buf_size += b->yy_buf_size / 8; else b->yy_buf_size *= 2; b->yy_ch_buf = (char *) /* Include room in for 2 EOB chars. */ yyrealloc( (void *) b->yy_ch_buf, (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); } else /* Can't grow it, we don't own it. */ b->yy_ch_buf = NULL; if ( ! b->yy_ch_buf ) YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" ); yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; } if ( num_to_read > YY_READ_BUF_SIZE ) num_to_read = YY_READ_BUF_SIZE; /* Read in more data. */ YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), yyg->yy_n_chars, num_to_read ); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; } if ( yyg->yy_n_chars == 0 ) { if ( number_to_move == YY_MORE_ADJ ) { ret_val = EOB_ACT_END_OF_FILE; yyrestart( yyin , yyscanner); } else { ret_val = EOB_ACT_LAST_MATCH; YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_EOF_PENDING; } } else ret_val = EOB_ACT_CONTINUE_SCAN; if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { /* Extend the array by 50%, plus the number we really need. */ int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner ); if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); /* "- 2" to take care of EOB's */ YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); } yyg->yy_n_chars += number_to_move; YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; return ret_val; } /* yy_get_previous_state - get the state just before the EOB char was reached */ static yy_state_type yy_get_previous_state (yyscan_t yyscanner) { yy_state_type yy_current_state; char *yy_cp; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yy_current_state = yyg->yy_start; for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) { YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); if ( yy_accept[yy_current_state] ) { yyg->yy_last_accepting_state = yy_current_state; yyg->yy_last_accepting_cpos = yy_cp; } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 559 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; } return yy_current_state; } /* yy_try_NUL_trans - try to make a transition on the NUL character * * synopsis * next_state = yy_try_NUL_trans( current_state ); */ static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner) { int yy_is_jam; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ char *yy_cp = yyg->yy_c_buf_p; YY_CHAR yy_c = 1; if ( yy_accept[yy_current_state] ) { yyg->yy_last_accepting_state = yy_current_state; yyg->yy_last_accepting_cpos = yy_cp; } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 559 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; yy_is_jam = (yy_current_state == 558); (void)yyg; return yy_is_jam ? 0 : yy_current_state; } #ifndef YY_NO_UNPUT static void yyunput (int c, char * yy_bp , yyscan_t yyscanner) { char *yy_cp; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yy_cp = yyg->yy_c_buf_p; /* undo effects of setting up yytext */ *yy_cp = yyg->yy_hold_char; if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) { /* need to shift things up to make room */ /* +2 for EOB chars. */ int number_to_move = yyg->yy_n_chars + 2; char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; char *source = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) *--dest = *--source; yy_cp += (int) (dest - source); yy_bp += (int) (dest - source); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size; if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) YY_FATAL_ERROR( "flex scanner push-back overflow" ); } *--yy_cp = (char) c; if ( c == '\n' ){ --yylineno; } yyg->yytext_ptr = yy_bp; yyg->yy_hold_char = *yy_cp; yyg->yy_c_buf_p = yy_cp; } #endif #ifndef YY_NO_INPUT #ifdef __cplusplus static int yyinput (yyscan_t yyscanner) #else static int input (yyscan_t yyscanner) #endif { int c; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; *yyg->yy_c_buf_p = yyg->yy_hold_char; if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) { /* yy_c_buf_p now points to the character we want to return. * If this occurs *before* the EOB characters, then it's a * valid NUL; if not, then we've hit the end of the buffer. */ if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) /* This was really a NUL. */ *yyg->yy_c_buf_p = '\0'; else { /* need more input */ int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr); ++yyg->yy_c_buf_p; switch ( yy_get_next_buffer( yyscanner ) ) { case EOB_ACT_LAST_MATCH: /* This happens because yy_g_n_b() * sees that we've accumulated a * token and flags that we need to * try matching the token before * proceeding. But for input(), * there's no matching to consider. * So convert the EOB_ACT_LAST_MATCH * to EOB_ACT_END_OF_FILE. */ /* Reset buffer status. */ yyrestart( yyin , yyscanner); /*FALLTHROUGH*/ case EOB_ACT_END_OF_FILE: { if ( yywrap( yyscanner ) ) return 0; if ( ! yyg->yy_did_buffer_switch_on_eof ) YY_NEW_FILE; #ifdef __cplusplus return yyinput(yyscanner); #else return input(yyscanner); #endif } case EOB_ACT_CONTINUE_SCAN: yyg->yy_c_buf_p = yyg->yytext_ptr + offset; break; } } } c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */ *yyg->yy_c_buf_p = '\0'; /* preserve yytext */ yyg->yy_hold_char = *++yyg->yy_c_buf_p; if ( c == '\n' ) do{ yylineno++; yycolumn=0; }while(0) ; return c; } #endif /* ifndef YY_NO_INPUT */ /** Immediately switch to a different input stream. * @param input_file A readable stream. * @param yyscanner The scanner object. * @note This function does not reset the start condition to @c INITIAL . */ void yyrestart (FILE * input_file , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if ( ! YY_CURRENT_BUFFER ){ yyensure_buffer_stack (yyscanner); YY_CURRENT_BUFFER_LVALUE = yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); } yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner); yy_load_buffer_state( yyscanner ); } /** Switch to a different input buffer. * @param new_buffer The new input buffer. * @param yyscanner The scanner object. */ void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* TODO. We should be able to replace this entire function body * with * yypop_buffer_state(); * yypush_buffer_state(new_buffer); */ yyensure_buffer_stack (yyscanner); if ( YY_CURRENT_BUFFER == new_buffer ) return; if ( YY_CURRENT_BUFFER ) { /* Flush out information for old buffer. */ *yyg->yy_c_buf_p = yyg->yy_hold_char; YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; } YY_CURRENT_BUFFER_LVALUE = new_buffer; yy_load_buffer_state( yyscanner ); /* We don't actually know whether we did this switch during * EOF (yywrap()) processing, but the only time this flag * is looked at is after yywrap() is called, so it's safe * to go ahead and always set it. */ yyg->yy_did_buffer_switch_on_eof = 1; } static void yy_load_buffer_state (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; yyg->yy_hold_char = *yyg->yy_c_buf_p; } /** Allocate and initialize an input buffer state. * @param file A readable stream. * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. * @param yyscanner The scanner object. * @return the allocated buffer state. */ YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner) { YY_BUFFER_STATE b; b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); b->yy_buf_size = size; /* yy_ch_buf has to be 2 characters longer than the size given because * we need to put in 2 end-of-buffer characters. */ b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); if ( ! b->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); b->yy_is_our_buffer = 1; yy_init_buffer( b, file , yyscanner); return b; } /** Destroy the buffer. * @param b a buffer created with yy_create_buffer() * @param yyscanner The scanner object. */ void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if ( ! b ) return; if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; if ( b->yy_is_our_buffer ) yyfree( (void *) b->yy_ch_buf , yyscanner ); yyfree( (void *) b , yyscanner ); } /* Initializes or reinitializes a buffer. * This function is sometimes called more than once on the same buffer, * such as during a yyrestart() or at EOF. */ static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner) { int oerrno = errno; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yy_flush_buffer( b , yyscanner); b->yy_input_file = file; b->yy_fill_buffer = 1; /* If b is the current buffer, then yy_init_buffer was _probably_ * called from yyrestart() or through yy_get_next_buffer. * In that case, we don't want to reset the lineno or column. */ if (b != YY_CURRENT_BUFFER){ b->yy_bs_lineno = 1; b->yy_bs_column = 0; } b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; errno = oerrno; } /** Discard all buffered characters. On the next scan, YY_INPUT will be called. * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. * @param yyscanner The scanner object. */ void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if ( ! b ) return; b->yy_n_chars = 0; /* We always need two end-of-buffer characters. The first causes * a transition to the end-of-buffer state. The second causes * a jam in that state. */ b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; b->yy_buf_pos = &b->yy_ch_buf[0]; b->yy_at_bol = 1; b->yy_buffer_status = YY_BUFFER_NEW; if ( b == YY_CURRENT_BUFFER ) yy_load_buffer_state( yyscanner ); } /** Pushes the new state onto the stack. The new state becomes * the current state. This function will allocate the stack * if necessary. * @param new_buffer The new state. * @param yyscanner The scanner object. */ void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if (new_buffer == NULL) return; yyensure_buffer_stack(yyscanner); /* This block is copied from yy_switch_to_buffer. */ if ( YY_CURRENT_BUFFER ) { /* Flush out information for old buffer. */ *yyg->yy_c_buf_p = yyg->yy_hold_char; YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; } /* Only push if top exists. Otherwise, replace top. */ if (YY_CURRENT_BUFFER) yyg->yy_buffer_stack_top++; YY_CURRENT_BUFFER_LVALUE = new_buffer; /* copied from yy_switch_to_buffer. */ yy_load_buffer_state( yyscanner ); yyg->yy_did_buffer_switch_on_eof = 1; } /** Removes and deletes the top of the stack, if present. * The next element becomes the new top. * @param yyscanner The scanner object. */ void yypop_buffer_state (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if (!YY_CURRENT_BUFFER) return; yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner); YY_CURRENT_BUFFER_LVALUE = NULL; if (yyg->yy_buffer_stack_top > 0) --yyg->yy_buffer_stack_top; if (YY_CURRENT_BUFFER) { yy_load_buffer_state( yyscanner ); yyg->yy_did_buffer_switch_on_eof = 1; } } /* Allocates the stack if it does not exist. * Guarantees space for at least one push. */ static void yyensure_buffer_stack (yyscan_t yyscanner) { yy_size_t num_to_alloc; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if (!yyg->yy_buffer_stack) { /* First allocation is just for 2 elements, since we don't know if this * scanner will even need a stack. We use 2 instead of 1 to avoid an * immediate realloc on the next call. */ num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc (num_to_alloc * sizeof(struct yy_buffer_state*) , yyscanner); if ( ! yyg->yy_buffer_stack ) YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); yyg->yy_buffer_stack_max = num_to_alloc; yyg->yy_buffer_stack_top = 0; return; } if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ /* Increase the buffer to prepare for a possible push. */ yy_size_t grow_size = 8 /* arbitrary grow size */; num_to_alloc = yyg->yy_buffer_stack_max + grow_size; yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc (yyg->yy_buffer_stack, num_to_alloc * sizeof(struct yy_buffer_state*) , yyscanner); if ( ! yyg->yy_buffer_stack ) YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); /* zero only the new slots.*/ memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); yyg->yy_buffer_stack_max = num_to_alloc; } } /** Setup the input buffer state to scan directly from a user-specified character buffer. * @param base the character buffer * @param size the size in bytes of the character buffer * @param yyscanner The scanner object. * @return the newly allocated buffer state object. */ YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner) { YY_BUFFER_STATE b; if ( size < 2 || base[size-2] != YY_END_OF_BUFFER_CHAR || base[size-1] != YY_END_OF_BUFFER_CHAR ) /* They forgot to leave room for the EOB's. */ return NULL; b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ b->yy_buf_pos = b->yy_ch_buf = base; b->yy_is_our_buffer = 0; b->yy_input_file = NULL; b->yy_n_chars = b->yy_buf_size; b->yy_is_interactive = 0; b->yy_at_bol = 1; b->yy_fill_buffer = 0; b->yy_buffer_status = YY_BUFFER_NEW; yy_switch_to_buffer( b , yyscanner ); return b; } /** Setup the input buffer state to scan a string. The next call to yylex() will * scan from a @e copy of @a str. * @param yystr a NUL-terminated string to scan * @param yyscanner The scanner object. * @return the newly allocated buffer state object. * @note If you want to scan bytes that may contain NUL values, then use * yy_scan_bytes() instead. */ YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner) { return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner); } /** Setup the input buffer state to scan the given bytes. The next call to yylex() will * scan from a @e copy of @a bytes. * @param yybytes the byte buffer to scan * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. * @param yyscanner The scanner object. * @return the newly allocated buffer state object. */ YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len , yyscan_t yyscanner) { YY_BUFFER_STATE b; char *buf; yy_size_t n; int i; /* Get memory for full buffer, including space for trailing EOB's. */ n = (yy_size_t) (_yybytes_len + 2); buf = (char *) yyalloc( n , yyscanner ); if ( ! buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); for ( i = 0; i < _yybytes_len; ++i ) buf[i] = yybytes[i]; buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; b = yy_scan_buffer( buf, n , yyscanner); if ( ! b ) YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); /* It's okay to grow etc. this buffer, and we should throw it * away when we're done. */ b->yy_is_our_buffer = 1; return b; } static void yy_push_state (int _new_state , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if ( yyg->yy_start_stack_ptr >= yyg->yy_start_stack_depth ) { yy_size_t new_size; yyg->yy_start_stack_depth += YY_START_STACK_INCR; new_size = (yy_size_t) yyg->yy_start_stack_depth * sizeof( int ); if ( ! yyg->yy_start_stack ) yyg->yy_start_stack = (int *) yyalloc( new_size , yyscanner ); else yyg->yy_start_stack = (int *) yyrealloc( (void *) yyg->yy_start_stack, new_size , yyscanner ); if ( ! yyg->yy_start_stack ) YY_FATAL_ERROR( "out of memory expanding start-condition stack" ); } yyg->yy_start_stack[yyg->yy_start_stack_ptr++] = YY_START; BEGIN(_new_state); } static void yy_pop_state (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if ( --yyg->yy_start_stack_ptr < 0 ) YY_FATAL_ERROR( "start-condition stack underflow" ); BEGIN(yyg->yy_start_stack[yyg->yy_start_stack_ptr]); } static int yy_top_state (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yyg->yy_start_stack[yyg->yy_start_stack_ptr - 1]; } #ifndef YY_EXIT_FAILURE #define YY_EXIT_FAILURE 2 #endif static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; (void)yyg; fprintf( stderr, "%s\n", msg ); exit( YY_EXIT_FAILURE ); } /* Redefine yyless() so it works in section 3 code. */ #undef yyless #define yyless(n) \ do \ { \ /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ yytext[yyleng] = yyg->yy_hold_char; \ yyg->yy_c_buf_p = yytext + yyless_macro_arg; \ yyg->yy_hold_char = *yyg->yy_c_buf_p; \ *yyg->yy_c_buf_p = '\0'; \ yyleng = yyless_macro_arg; \ } \ while ( 0 ) /* Accessor methods (get/set functions) to struct members. */ /** Get the user-defined data for this scanner. * @param yyscanner The scanner object. */ YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yyextra; } /** Get the current line number. * @param yyscanner The scanner object. */ int yyget_lineno (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if (! YY_CURRENT_BUFFER) return 0; return yylineno; } /** Get the current column number. * @param yyscanner The scanner object. */ int yyget_column (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if (! YY_CURRENT_BUFFER) return 0; return yycolumn; } /** Get the input stream. * @param yyscanner The scanner object. */ FILE *yyget_in (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yyin; } /** Get the output stream. * @param yyscanner The scanner object. */ FILE *yyget_out (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yyout; } /** Get the length of the current token. * @param yyscanner The scanner object. */ int yyget_leng (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yyleng; } /** Get the current token. * @param yyscanner The scanner object. */ char *yyget_text (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yytext; } /** Set the user-defined data. This data is never touched by the scanner. * @param user_defined The data to be associated with this scanner. * @param yyscanner The scanner object. */ void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yyextra = user_defined ; } /** Set the current line number. * @param _line_number line number * @param yyscanner The scanner object. */ void yyset_lineno (int _line_number , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* lineno is only valid if an input buffer exists. */ if (! YY_CURRENT_BUFFER ) YY_FATAL_ERROR( "yyset_lineno called with no buffer" ); yylineno = _line_number; } /** Set the current column. * @param _column_no column number * @param yyscanner The scanner object. */ void yyset_column (int _column_no , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* column is only valid if an input buffer exists. */ if (! YY_CURRENT_BUFFER ) YY_FATAL_ERROR( "yyset_column called with no buffer" ); yycolumn = _column_no; } /** Set the input stream. This does not discard the current * input buffer. * @param _in_str A readable stream. * @param yyscanner The scanner object. * @see yy_switch_to_buffer */ void yyset_in (FILE * _in_str , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yyin = _in_str ; } void yyset_out (FILE * _out_str , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yyout = _out_str ; } int yyget_debug (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yy_flex_debug; } void yyset_debug (int _bdebug , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yy_flex_debug = _bdebug ; } /* Accessor methods for yylval and yylloc */ YYSTYPE * yyget_lval (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yylval; } void yyset_lval (YYSTYPE * yylval_param , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yylval = yylval_param; } YYLTYPE *yyget_lloc (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yylloc; } void yyset_lloc (YYLTYPE * yylloc_param , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yylloc = yylloc_param; } /* User-visible API */ /* yylex_init is special because it creates the scanner itself, so it is * the ONLY reentrant function that doesn't take the scanner as the last argument. * That's why we explicitly handle the declaration, instead of using our macros. */ int yylex_init(yyscan_t* ptr_yy_globals) { if (ptr_yy_globals == NULL){ errno = EINVAL; return 1; } *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL ); if (*ptr_yy_globals == NULL){ errno = ENOMEM; return 1; } /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); return yy_init_globals ( *ptr_yy_globals ); } /* yylex_init_extra has the same functionality as yylex_init, but follows the * convention of taking the scanner as the last argument. Note however, that * this is a *pointer* to a scanner, as it will be allocated by this call (and * is the reason, too, why this function also must handle its own declaration). * The user defined value in the first argument will be available to yyalloc in * the yyextra field. */ int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals ) { struct yyguts_t dummy_yyguts; yyset_extra (yy_user_defined, &dummy_yyguts); if (ptr_yy_globals == NULL){ errno = EINVAL; return 1; } *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts ); if (*ptr_yy_globals == NULL){ errno = ENOMEM; return 1; } /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); yyset_extra (yy_user_defined, *ptr_yy_globals); return yy_init_globals ( *ptr_yy_globals ); } static int yy_init_globals (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* Initialization is the same as for the non-reentrant scanner. * This function is called from yylex_destroy(), so don't allocate here. */ yyg->yy_buffer_stack = NULL; yyg->yy_buffer_stack_top = 0; yyg->yy_buffer_stack_max = 0; yyg->yy_c_buf_p = NULL; yyg->yy_init = 0; yyg->yy_start = 0; yyg->yy_start_stack_ptr = 0; yyg->yy_start_stack_depth = 0; yyg->yy_start_stack = NULL; /* Defined in main.c */ #ifdef YY_STDINIT yyin = stdin; yyout = stdout; #else yyin = NULL; yyout = NULL; #endif /* For future reference: Set errno on error, since we are called by * yylex_init() */ return 0; } /* yylex_destroy is for both reentrant and non-reentrant scanners. */ int yylex_destroy (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* Pop the buffer stack, destroying each element. */ while(YY_CURRENT_BUFFER){ yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); YY_CURRENT_BUFFER_LVALUE = NULL; yypop_buffer_state(yyscanner); } /* Destroy the stack itself. */ yyfree(yyg->yy_buffer_stack , yyscanner); yyg->yy_buffer_stack = NULL; /* Destroy the start condition stack. */ yyfree( yyg->yy_start_stack , yyscanner ); yyg->yy_start_stack = NULL; /* Reset the globals. This is important in a non-reentrant scanner so the next time * yylex() is called, initialization will occur. */ yy_init_globals( yyscanner); /* Destroy the main struct (reentrant only). */ yyfree ( yyscanner , yyscanner ); yyscanner = NULL; return 0; } /* * Internal utility routines. */ #ifndef yytext_ptr static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; (void)yyg; int i; for ( i = 0; i < n; ++i ) s1[i] = s2[i]; } #endif #ifdef YY_NEED_STRLEN static int yy_flex_strlen (const char * s , yyscan_t yyscanner) { int n; for ( n = 0; s[n]; ++n ) ; return n; } #endif void *yyalloc (yy_size_t size , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; (void)yyg; return malloc(size); } void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; (void)yyg; /* The cast to (char *) in the following accommodates both * implementations that use char* generic pointers, and those * that use void* generic pointers. It works with the latter * because both ANSI C and C++ allow castless assignment from * any pointer type to void*, and deal with argument conversions * as though doing an assignment. */ return realloc(ptr, size); } void yyfree (void * ptr , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; (void)yyg; free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ } #define YYTABLES_NAME "yytables" #line 165 "smt2new/smt2newlexer.ll" int Smt2newContext::init_scanner() { if (is != NULL) { yylex_init_extra(this, &scanner); yyset_in(is, scanner); } else if (ib != NULL) { yylex_init(&scanner); yylex_init_extra(this, &scanner); yy_scan_string(ib, scanner); } else return -1; return 0; } void Smt2newContext::destroy_scanner() { yylex_destroy(scanner); } opensmt-2.5.2/src/parsers/smt2new/smt2newlexer.ll000066400000000000000000000265031445011647600220600ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ %option prefix="smt2new" %option reentrant %option bison-bridge %option bison-locations %option noyywrap %option yylineno %option stack %option nounput %option noinput %option noyy_top_state %{ #include #include #include #include #include "smt2tokens.h" #include "smt2newcontext.h" #include "smt2newparser.hh" using namespace osmttokens; #define YY_EXTRA_TYPE Smt2newContext* #define YY_USER_ACTION yyget_lloc(yyscanner)->first_line = yyget_lineno(yyscanner); %} %x STR %x PSYM %% \;.* // Eat comments [ \t\n]+ // Eat spaces "!" { return *yyget_text(yyscanner); } "_" { return *yyget_text(yyscanner); } "as" { yyget_lval(yyscanner)->tok = { t_as }; return TK_AS; } "DECIMAL" { yyget_lval(yyscanner)->tok = { t_DECIMAL }; return TK_DECIMAL; } "exists" { yyget_lval(yyscanner)->tok = { t_exists }; return TK_EXISTS; } "forall" { yyget_lval(yyscanner)->tok = { t_forall }; return TK_FORALL; } "let" { yyget_lval(yyscanner)->tok = { t_let }; return TK_LET; } "NUMERAL" { yyget_lval(yyscanner)->tok = { t_NUMERAL }; return TK_NUMERAL; } "par" { yyget_lval(yyscanner)->tok = { t_par }; return TK_PAR; } "STRING" { yyget_lval(yyscanner)->tok = { t_STRING}; return TK_STRING; } "assert" { yyget_lval(yyscanner)->tok = { t_assert }; return TK_ASSERT; } "check-sat" { yyget_lval(yyscanner)->tok = { t_checksat }; return TK_CHECKSAT; } "declare-sort" { yyget_lval(yyscanner)->tok = { t_declaresort }; return TK_DECLARESORT; } "declare-fun" { yyget_lval(yyscanner)->tok = { t_declarefun }; return TK_DECLAREFUN; } "declare-const" { yyget_lval(yyscanner)->tok = { t_declareconst} ; return TK_DECLARECONST; } "define-sort" { yyget_lval(yyscanner)->tok = { t_definesort }; return TK_DEFINESORT; } "define-fun" { yyget_lval(yyscanner)->tok = { t_definefun }; return TK_DEFINEFUN; } "exit" { yyget_lval(yyscanner)->tok = { t_exit }; return TK_EXIT; } "get-assertions" { yyget_lval(yyscanner)->tok = { t_getassertions }; return TK_GETASSERTIONS; } "get-assignment" { yyget_lval(yyscanner)->tok = { t_getassignment }; return TK_GETASSIGNMENT; } "get-info" { yyget_lval(yyscanner)->tok = { t_getinfo }; return TK_GETINFO; } "get-option" { yyget_lval(yyscanner)->tok = { t_getoption }; return TK_GETOPTION; } "get-proof" { yyget_lval(yyscanner)->tok = { t_getproof }; return TK_GETPROOF; } "get-unsat-core" { yyget_lval(yyscanner)->tok = { t_getunsatcore }; return TK_GETUNSATCORE; } "get-value" { yyget_lval(yyscanner)->tok = { t_getvalue }; return TK_GETVALUE; } "get-model" { yyget_lval(yyscanner)->tok = { t_getmodel }; return TK_GETMODEL; } "pop" { yyget_lval(yyscanner)->tok = { t_pop }; return TK_POP; } "push" { yyget_lval(yyscanner)->tok = { t_push }; return TK_PUSH; } "set-logic" { yyget_lval(yyscanner)->tok = { t_setlogic }; return TK_SETLOGIC; } "set-info" { yyget_lval(yyscanner)->tok = { t_setinfo }; return TK_SETINFO; } "set-option" { yyget_lval(yyscanner)->tok = { t_setoption }; return TK_SETOPTION; } "get-interpolants" { yyget_lval(yyscanner)->tok = { t_getinterpolants }; return TK_GETITPS; } "theory" { yyget_lval(yyscanner)->tok = { t_theory }; return TK_THEORY; } "write-state" { yyget_lval(yyscanner)->tok = { t_writestate }; return TK_WRSTATE; } "read-state" { yyget_lval(yyscanner)->tok = { t_readstate }; return TK_RDSTATE; } "simplify" { yyget_lval(yyscanner)->tok = { t_simplify }; return TK_SIMPLIFY; } "echo" { yyget_lval(yyscanner)->tok = { t_echo }; return TK_ECHO; } ":sorts" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_SORTS; } ":funs" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_FUNS; } ":sorts-description" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_SORTSDESCRIPTION; } ":funs-description" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_FUNSDESCRIPTION; } ":definition" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_DEFINITION; } ":values" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_VALUES; } ":notes" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_NOTES; } ":theories" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_THEORIES; } ":extensions" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_EXTENSIONS; } ":print-success" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_PRINTSUCCESS; } ":expand-definitions" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_EXPANDDEFINITIONS; } ":interactive-mode" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_INTERACTIVEMODE; } ":produce-proofs" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_PRODUCEPROOFS; } ":produce-unsat-cores" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_PRODUCEUNSATCORES; } ":produce-models" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_PRODUCEMODELS; } ":produce-assignments" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_PRODUCEASSIGNMENTS; } ":regular-output-channel" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_REGULAROUTPUTCHANNEL; } ":diagnostic-output-channel" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_DIAGNOSTICOUTPUTCHANNEL; } ":random-seed" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_RANDOMSEED; } ":verbosity" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_VERBOSITY; } ":error-behavior" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_ERRORBEHAVIOR; } ":name" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_NAME; } ":named" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_NAMED; } ":authors" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_AUTHORS; } ":version" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_VERSION; } ":status" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_STATUS; } ":reason-unknown" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_REASONUNKNOWN; } ":all-statistics" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_ALLSTATISTICS; } 0|-?[1-9][0-9]*(\/[1-9][0-9]*)? { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_NUM; } -?[0-9]+\.0*[0-9]+ { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_DEC; } #x[0-9a-fA-F]+ { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_HEX; } #b[01]+ { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_BIN; } [a-zA-Z~!@\$\%\^&\*\-\+=\<\>\.\?\/'_][a-zA-Z0-9~!@\$\%\^&\*_\-\+=\<\>\.\?\/']* { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_SYM; } \:[a-zA-Z0-9~!@\$\%\^&\*_\-\+=\<\>\.\?\/]+ { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_KEY; } [()] { return *yyget_text(yyscanner); } \" { yy_push_state(STR, yyscanner); } { [ ] { yyextra->insertBuf(' '); } [\t] { yyextra->insertBuf('\t'); } \n { yyextra->insertBuf('\n'); } \\\" { yyextra->insertBuf('"'); } \\\\ { yyextra->insertBuf('\\'); } [^\\\n\"] { yyextra->insertBuf(yyget_text(yyscanner)[0]); } \" { yylval->str = strdup(yyextra->getBuf()); yyextra->clearBuf(); yy_pop_state(yyscanner); return TK_STR; } } \| { yy_push_state(PSYM, yyscanner); } { [ ] { yyextra->insertBuf(' '); } [\t] { yyextra->insertBuf('\t'); } \n { yyextra->insertBuf('\n'); } [^ \t\n\\\|] { yyextra->insertBuf(yyget_text(yyscanner)[0]); } \| { yylval->str = strdup(yyextra->getBuf()); yyextra->clearBuf(); yy_pop_state(yyscanner); return TK_QSYM; } \\ { printf("Syntax error at line %d near %s, \\ not allowed inside | ... |\n", yyget_lineno(yyscanner), yyget_text(yyscanner)); exit(1); } } . { printf( "Syntax error at line %d near %s\n", yyget_lineno(yyscanner), yyget_text(yyscanner) ); exit( 1 ); } %% int Smt2newContext::init_scanner() { if (is != NULL) { yylex_init_extra(this, &scanner); yyset_in(is, scanner); } else if (ib != NULL) { yylex_init_extra(this, &scanner); yy_scan_string(ib, scanner); } else return -1; return 0; } void Smt2newContext::destroy_scanner() { yylex_destroy(scanner); } opensmt-2.5.2/src/parsers/smt2new/smt2newparser.cc000066400000000000000000003065761445011647600222260ustar00rootroot00000000000000/* A Bison parser, made by GNU Bison 3.0.4. */ /* Bison implementation for Yacc-like parsers in C Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ /* As a special exception, you may create a larger work that contains part or all of the Bison parser skeleton and distribute that work under terms of your choice, so long as that work isn't itself a parser generator using the skeleton or a modified version thereof as a parser skeleton. Alternatively, if you modify or redistribute the parser skeleton itself, you may (at your option) remove this special exception, which will cause the skeleton and the resulting Bison output files to be licensed under the GNU General Public License without this special exception. This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ /* C LALR(1) parser skeleton written by Richard Stallman, by simplifying the original so-called "semantic" parser. */ /* All symbols defined below should begin with yy or YY, to avoid infringing on user name space. This should be done even for local variables, as they might otherwise be expanded by user macros. There are some unavoidable exceptions within include files to define necessary library symbols; they are noted "INFRINGES ON USER NAME SPACE" below. */ /* Identify Bison output. */ #define YYBISON 1 /* Bison version. */ #define YYBISON_VERSION "3.0.4" /* Skeleton name. */ #define YYSKELETON_NAME "yacc.c" /* Pure parsers. */ #define YYPURE 1 /* Push parsers. */ #define YYPUSH 0 /* Pull parsers. */ #define YYPULL 1 /* Substitute the variable and function names. */ #define yyparse smt2newparse #define yylex smt2newlex #define yyerror smt2newerror #define yydebug smt2newdebug #define yynerrs smt2newnerrs /* Copy the first part of user declarations. */ #line 35 "smt2new/smt2newparser.yy" /* yacc.c:339 */ #include #include #include #include #include #include #include #include "smt2newcontext.h" #include "smt2newparser.hh" #include "smt2tokens.h" int smt2newlex(YYSTYPE* lvalp, YYLTYPE* llocp, void* scanner); void smt2newerror( YYLTYPE* locp, Smt2newContext* context, const char * s ) { if (context->interactive) printf("At interactive input: %s\n", s); else printf( "At line %d: %s\n", locp->first_line, s ); // exit( 1 ); } #define scanner context->scanner /* Overallocation to prevent stack overflow */ #define YYMAXDEPTH 1024 * 1024 #line 102 "smt2new/smt2newparser.cc" /* yacc.c:339 */ # ifndef YY_NULLPTR # if defined __cplusplus && 201103L <= __cplusplus # define YY_NULLPTR nullptr # else # define YY_NULLPTR 0 # endif # endif /* Enabling verbose error messages. */ #ifdef YYERROR_VERBOSE # undef YYERROR_VERBOSE # define YYERROR_VERBOSE 1 #else # define YYERROR_VERBOSE 1 #endif /* In a future release of Bison, this section will be replaced by #include "smt2newparser.hh". */ #ifndef YY_SMT2NEW_SMT2NEW_SMT2NEWPARSER_HH_INCLUDED # define YY_SMT2NEW_SMT2NEW_SMT2NEWPARSER_HH_INCLUDED /* Debug traces. */ #ifndef YYDEBUG # define YYDEBUG 0 #endif #if YYDEBUG extern int smt2newdebug; #endif /* Token type. */ #ifndef YYTOKENTYPE # define YYTOKENTYPE enum yytokentype { TK_AS = 258, TK_DECIMAL = 259, TK_EXISTS = 260, TK_FORALL = 261, TK_LET = 262, TK_NUMERAL = 263, TK_PAR = 264, TK_STRING = 265, TK_ASSERT = 266, TK_CHECKSAT = 267, TK_DECLARESORT = 268, TK_DECLAREFUN = 269, TK_DECLARECONST = 270, TK_DEFINESORT = 271, TK_DEFINEFUN = 272, TK_EXIT = 273, TK_GETASSERTIONS = 274, TK_GETASSIGNMENT = 275, TK_GETINFO = 276, TK_GETOPTION = 277, TK_GETPROOF = 278, TK_GETUNSATCORE = 279, TK_GETVALUE = 280, TK_POP = 281, TK_PUSH = 282, TK_SETLOGIC = 283, TK_SETINFO = 284, TK_SETOPTION = 285, TK_THEORY = 286, TK_GETITPS = 287, TK_WRSTATE = 288, TK_RDSTATE = 289, TK_SIMPLIFY = 290, TK_WRFUNS = 291, TK_NUM = 292, TK_SYM = 293, TK_KEY = 294, TK_STR = 295, TK_DEC = 296, TK_HEX = 297, TK_BIN = 298, KW_SORTS = 299, KW_FUNS = 300, KW_SORTSDESCRIPTION = 301, KW_FUNSDESCRIPTION = 302, KW_DEFINITION = 303, KW_NOTES = 304, KW_THEORIES = 305, KW_LANGUAGE = 306, KW_EXTENSIONS = 307, KW_VALUES = 308, KW_PRINTSUCCESS = 309, KW_EXPANDDEFINITIONS = 310, KW_INTERACTIVEMODE = 311, KW_PRODUCEPROOFS = 312, KW_PRODUCEUNSATCORES = 313, KW_PRODUCEMODELS = 314, KW_PRODUCEASSIGNMENTS = 315, KW_REGULAROUTPUTCHANNEL = 316, KW_DIAGNOSTICOUTPUTCHANNEL = 317, KW_RANDOMSEED = 318, KW_VERBOSITY = 319, KW_ERRORBEHAVIOR = 320, KW_NAME = 321, KW_NAMED = 322, KW_AUTHORS = 323, KW_VERSION = 324, KW_STATUS = 325, KW_REASONUNKNOWN = 326, KW_ALLSTATISTICS = 327 }; #endif /* Value type. */ #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED union YYSTYPE { #line 66 "smt2new/smt2newparser.yy" /* yacc.c:355 */ char * str; std::vector< std::string > * str_list; ASTNode * snode; std::list< ASTNode * > * snode_list; smt2token tok; #line 223 "smt2new/smt2newparser.cc" /* yacc.c:355 */ }; typedef union YYSTYPE YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 # define YYSTYPE_IS_DECLARED 1 #endif /* Location type. */ #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED typedef struct YYLTYPE YYLTYPE; struct YYLTYPE { int first_line; int first_column; int last_line; int last_column; }; # define YYLTYPE_IS_DECLARED 1 # define YYLTYPE_IS_TRIVIAL 1 #endif int smt2newparse (Smt2newContext* context); #endif /* !YY_SMT2NEW_SMT2NEW_SMT2NEWPARSER_HH_INCLUDED */ /* Copy the second part of user declarations. */ #line 253 "smt2new/smt2newparser.cc" /* yacc.c:358 */ #ifdef short # undef short #endif #ifdef YYTYPE_UINT8 typedef YYTYPE_UINT8 yytype_uint8; #else typedef unsigned char yytype_uint8; #endif #ifdef YYTYPE_INT8 typedef YYTYPE_INT8 yytype_int8; #else typedef signed char yytype_int8; #endif #ifdef YYTYPE_UINT16 typedef YYTYPE_UINT16 yytype_uint16; #else typedef unsigned short int yytype_uint16; #endif #ifdef YYTYPE_INT16 typedef YYTYPE_INT16 yytype_int16; #else typedef short int yytype_int16; #endif #ifndef YYSIZE_T # ifdef __SIZE_TYPE__ # define YYSIZE_T __SIZE_TYPE__ # elif defined size_t # define YYSIZE_T size_t # elif ! defined YYSIZE_T # include /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T size_t # else # define YYSIZE_T unsigned int # endif #endif #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) #ifndef YY_ # if defined YYENABLE_NLS && YYENABLE_NLS # if ENABLE_NLS # include /* INFRINGES ON USER NAME SPACE */ # define YY_(Msgid) dgettext ("bison-runtime", Msgid) # endif # endif # ifndef YY_ # define YY_(Msgid) Msgid # endif #endif #ifndef YY_ATTRIBUTE # if (defined __GNUC__ \ && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \ || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C # define YY_ATTRIBUTE(Spec) __attribute__(Spec) # else # define YY_ATTRIBUTE(Spec) /* empty */ # endif #endif #ifndef YY_ATTRIBUTE_PURE # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__)) #endif #ifndef YY_ATTRIBUTE_UNUSED # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) #endif #if !defined _Noreturn \ && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112) # if defined _MSC_VER && 1200 <= _MSC_VER # define _Noreturn __declspec (noreturn) # else # define _Noreturn YY_ATTRIBUTE ((__noreturn__)) # endif #endif /* Suppress unused-variable warnings by "using" E. */ #if ! defined lint || defined __GNUC__ # define YYUSE(E) ((void) (E)) #else # define YYUSE(E) /* empty */ #endif #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ /* Suppress an incorrect diagnostic about yylval being uninitialized. */ # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ _Pragma ("GCC diagnostic push") \ _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") # define YY_IGNORE_MAYBE_UNINITIALIZED_END \ _Pragma ("GCC diagnostic pop") #else # define YY_INITIAL_VALUE(Value) Value #endif #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN # define YY_IGNORE_MAYBE_UNINITIALIZED_END #endif #ifndef YY_INITIAL_VALUE # define YY_INITIAL_VALUE(Value) /* Nothing. */ #endif #if ! defined yyoverflow || YYERROR_VERBOSE /* The parser invokes alloca or malloc; define the necessary symbols. */ # ifdef YYSTACK_USE_ALLOCA # if YYSTACK_USE_ALLOCA # ifdef __GNUC__ # define YYSTACK_ALLOC __builtin_alloca # elif defined __BUILTIN_VA_ARG_INCR # include /* INFRINGES ON USER NAME SPACE */ # elif defined _AIX # define YYSTACK_ALLOC __alloca # elif defined _MSC_VER # include /* INFRINGES ON USER NAME SPACE */ # define alloca _alloca # else # define YYSTACK_ALLOC alloca # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS # include /* INFRINGES ON USER NAME SPACE */ /* Use EXIT_SUCCESS as a witness for stdlib.h. */ # ifndef EXIT_SUCCESS # define EXIT_SUCCESS 0 # endif # endif # endif # endif # endif # ifdef YYSTACK_ALLOC /* Pacify GCC's 'empty if-body' warning. */ # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) # ifndef YYSTACK_ALLOC_MAXIMUM /* The OS might guarantee only one guard page at the bottom of the stack, and a page size can be as small as 4096 bytes. So we cannot safely invoke alloca (N) if N exceeds 4096. Use a slightly smaller number to allow for a few compiler-allocated temporary stack slots. */ # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ # endif # else # define YYSTACK_ALLOC YYMALLOC # define YYSTACK_FREE YYFREE # ifndef YYSTACK_ALLOC_MAXIMUM # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM # endif # if (defined __cplusplus && ! defined EXIT_SUCCESS \ && ! ((defined YYMALLOC || defined malloc) \ && (defined YYFREE || defined free))) # include /* INFRINGES ON USER NAME SPACE */ # ifndef EXIT_SUCCESS # define EXIT_SUCCESS 0 # endif # endif # ifndef YYMALLOC # define YYMALLOC malloc # if ! defined malloc && ! defined EXIT_SUCCESS void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ # endif # endif # ifndef YYFREE # define YYFREE free # if ! defined free && ! defined EXIT_SUCCESS void free (void *); /* INFRINGES ON USER NAME SPACE */ # endif # endif # endif #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ #if (! defined yyoverflow \ && (! defined __cplusplus \ || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \ && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) /* A type that is properly aligned for any stack member. */ union yyalloc { yytype_int16 yyss_alloc; YYSTYPE yyvs_alloc; YYLTYPE yyls_alloc; }; /* The size of the maximum gap between one aligned stack and the next. */ # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) /* The size of an array large to enough to hold all stacks, each with N elements. */ # define YYSTACK_BYTES(N) \ ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ + 2 * YYSTACK_GAP_MAXIMUM) # define YYCOPY_NEEDED 1 /* Relocate STACK from its old location to the new one. The local variables YYSIZE and YYSTACKSIZE give the old and new number of elements in the stack, and YYPTR gives the new location of the stack. Advance YYPTR to a properly aligned location for the next stack. */ # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ do \ { \ YYSIZE_T yynewbytes; \ YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ Stack = &yyptr->Stack_alloc; \ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ yyptr += yynewbytes / sizeof (*yyptr); \ } \ while (0) #endif #if defined YYCOPY_NEEDED && YYCOPY_NEEDED /* Copy COUNT objects from SRC to DST. The source and destination do not overlap. */ # ifndef YYCOPY # if defined __GNUC__ && 1 < __GNUC__ # define YYCOPY(Dst, Src, Count) \ __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) # else # define YYCOPY(Dst, Src, Count) \ do \ { \ YYSIZE_T yyi; \ for (yyi = 0; yyi < (Count); yyi++) \ (Dst)[yyi] = (Src)[yyi]; \ } \ while (0) # endif # endif #endif /* !YYCOPY_NEEDED */ /* YYFINAL -- State number of the termination state. */ #define YYFINAL 3 /* YYLAST -- Last index in YYTABLE. */ #define YYLAST 378 /* YYNTOKENS -- Number of terminals. */ #define YYNTOKENS 77 /* YYNNTS -- Number of nonterminals. */ #define YYNNTS 27 /* YYNRULES -- Number of rules. */ #define YYNRULES 129 /* YYNSTATES -- Number of states. */ #define YYNSTATES 246 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned by yylex, with out-of-bounds checking. */ #define YYUNDEFTOK 2 #define YYMAXUTOK 327 #define YYTRANSLATE(YYX) \ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM as returned by yylex, without out-of-bounds checking. */ static const yytype_uint8 yytranslate[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 76, 2, 2, 2, 2, 2, 2, 73, 74, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 75, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72 }; #if YYDEBUG /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ static const yytype_uint16 yyrline[] = { 0, 97, 97, 101, 102, 106, 112, 118, 124, 131, 144, 156, 168, 181, 187, 193, 199, 203, 207, 211, 215, 221, 227, 233, 237, 243, 247, 253, 259, 265, 269, 274, 275, 279, 281, 283, 285, 289, 291, 295, 302, 304, 308, 310, 318, 321, 324, 330, 334, 338, 346, 349, 357, 359, 361, 363, 365, 369, 371, 375, 377, 381, 383, 393, 394, 398, 403, 404, 408, 412, 413, 417, 419, 421, 428, 438, 448, 458, 535, 536, 693, 706, 712, 718, 724, 730, 736, 742, 748, 754, 760, 766, 772, 780, 782, 784, 786, 788, 790, 792, 794, 796, 798, 800, 802, 804, 806, 808, 810, 812, 814, 816, 818, 820, 822, 824, 826, 828, 830, 832, 834, 836, 840, 842, 844, 846, 848, 850, 852, 854 }; #endif #if YYDEBUG || YYERROR_VERBOSE || 1 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. First, the terminals, then, starting at YYNTOKENS, nonterminals. */ static const char *const yytname[] = { "$end", "error", "$undefined", "TK_AS", "TK_DECIMAL", "TK_EXISTS", "TK_FORALL", "TK_LET", "TK_NUMERAL", "TK_PAR", "TK_STRING", "TK_ASSERT", "TK_CHECKSAT", "TK_DECLARESORT", "TK_DECLAREFUN", "TK_DECLARECONST", "TK_DEFINESORT", "TK_DEFINEFUN", "TK_EXIT", "TK_GETASSERTIONS", "TK_GETASSIGNMENT", "TK_GETINFO", "TK_GETOPTION", "TK_GETPROOF", "TK_GETUNSATCORE", "TK_GETVALUE", "TK_POP", "TK_PUSH", "TK_SETLOGIC", "TK_SETINFO", "TK_SETOPTION", "TK_THEORY", "TK_GETITPS", "TK_WRSTATE", "TK_RDSTATE", "TK_SIMPLIFY", "TK_WRFUNS", "TK_NUM", "TK_SYM", "TK_KEY", "TK_STR", "TK_DEC", "TK_HEX", "TK_BIN", "KW_SORTS", "KW_FUNS", "KW_SORTSDESCRIPTION", "KW_FUNSDESCRIPTION", "KW_DEFINITION", "KW_NOTES", "KW_THEORIES", "KW_LANGUAGE", "KW_EXTENSIONS", "KW_VALUES", "KW_PRINTSUCCESS", "KW_EXPANDDEFINITIONS", "KW_INTERACTIVEMODE", "KW_PRODUCEPROOFS", "KW_PRODUCEUNSATCORES", "KW_PRODUCEMODELS", "KW_PRODUCEASSIGNMENTS", "KW_REGULAROUTPUTCHANNEL", "KW_DIAGNOSTICOUTPUTCHANNEL", "KW_RANDOMSEED", "KW_VERBOSITY", "KW_ERRORBEHAVIOR", "KW_NAME", "KW_NAMED", "KW_AUTHORS", "KW_VERSION", "KW_STATUS", "KW_REASONUNKNOWN", "KW_ALLSTATISTICS", "'('", "')'", "'_'", "'!'", "$accept", "script", "command_list", "command", "attribute_list", "attribute", "attribute_value", "identifier", "sort", "sort_list", "s_expr", "s_expr_list", "spec_const", "const_val", "numeral_list", "qual_identifier", "var_binding_list", "var_binding", "sorted_var_list", "sorted_var", "term_list", "term", "symbol_list", "b_value", "option", "predef_key", "info_flag", YY_NULLPTR }; #endif # ifdef YYPRINT /* YYTOKNUM[NUM] -- (External) token number corresponding to the (internal) symbol number NUM (which must be that of a token). */ static const yytype_uint16 yytoknum[] = { 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 40, 41, 95, 33 }; # endif #define YYPACT_NINF -161 #define yypact_value_is_default(Yystate) \ (!!((Yystate) == (-161))) #define YYTABLE_NINF -1 #define yytable_value_is_error(Yytable_value) \ 0 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ static const yytype_int16 yypact[] = { -161, 10, -58, -161, 342, -161, -1, -10, 27, 29, 112, 32, 33, 3, 5, 11, 104, 212, 12, 13, 1, 43, 47, 50, 246, 280, 17, 54, 65, 36, 73, -161, -161, -161, -161, -161, -161, 0, -161, -161, -161, 44, -161, 82, 49, -161, -161, 53, 61, 62, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, 57, 63, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, 64, -161, -161, -1, 67, 68, 70, 87, 71, 87, 98, 98, 98, 98, 98, 98, 98, 111, 116, 120, 121, -161, 85, -161, 93, 97, -161, 103, -22, 105, 106, 107, 6, 143, -1, -1, -161, 108, -161, 109, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, 110, -14, 113, 113, 114, 147, 246, -161, -161, -11, -14, -24, -48, 66, -20, -27, -161, 115, 150, -161, -161, 152, -161, -161, -25, -161, 74, -14, -161, 118, -161, -14, -14, -161, 119, -161, -161, -161, -161, -161, -161, -161, -14, -161, -14, -45, -42, -1, -30, -161, -161, 178, -161, 122, -161, 123, -1, -161, 59, -161, 124, -1, -1, 125, -1, -161, -161, -161, -161, -161, 126, -161, -5, -161, 127, 128, -161, 129, -161, -161, -161, -161, -161 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. Performed when YYTABLE does not specify something else to do. Zero means the default is an error. */ static const yytype_uint8 yydefact[] = { 3, 0, 2, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 52, 40, 56, 53, 54, 55, 0, 61, 71, 72, 0, 16, 0, 0, 57, 58, 0, 0, 0, 30, 17, 25, 129, 122, 123, 124, 125, 126, 127, 128, 0, 0, 93, 94, 95, 96, 97, 99, 100, 101, 102, 98, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 0, 18, 23, 0, 0, 0, 0, 33, 0, 35, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 92, 0, 19, 0, 0, 29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 45, 0, 78, 66, 28, 26, 27, 69, 14, 13, 5, 38, 50, 34, 37, 7, 36, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 6, 20, 21, 22, 0, 0, 0, 0, 0, 0, 0, 69, 8, 0, 0, 0, 0, 0, 0, 0, 42, 0, 0, 66, 66, 0, 63, 60, 0, 31, 0, 0, 44, 0, 79, 0, 0, 67, 0, 70, 47, 48, 50, 39, 51, 46, 0, 62, 0, 0, 0, 0, 0, 59, 41, 0, 73, 0, 11, 0, 0, 24, 0, 45, 0, 0, 0, 0, 0, 64, 77, 32, 10, 9, 0, 49, 0, 68, 0, 0, 65, 0, 12, 43, 76, 75, 74 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { -161, -161, -161, -161, -161, -23, 94, -112, -160, -28, -161, 4, -9, -161, -161, 169, -161, -4, -127, -108, 38, -6, -161, 58, -161, 192, -161 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { -1, 1, 2, 5, 214, 100, 143, 38, 191, 172, 203, 177, 39, 47, 187, 40, 211, 185, 175, 196, 176, 198, 174, 148, 114, 101, 61 }; /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If positive, shift that token. If negative, reduce the rule whose number is the opposite. If YYTABLE_NINF, syntax error. */ static const yytype_uint8 yytable[] = { 41, 46, 113, 120, 180, 121, 122, 123, 164, 120, 3, 32, 212, 192, 193, 4, 32, 31, 199, 200, 33, 34, 35, 36, 32, 181, 195, 32, 181, 224, 216, 181, 225, 32, 218, 219, 31, 32, 32, 33, 34, 35, 36, 184, 227, 222, 163, 223, 125, 213, 194, 163, 179, 201, 202, 208, 209, 182, 183, 178, 179, 179, 178, 190, 42, 43, 205, 44, 178, 242, 48, 49, 37, 124, 95, 125, 126, 50, 179, 51, 96, 125, 179, 179, 97, 52, 93, 94, 98, 137, 144, 115, 144, 179, 116, 179, 31, 199, 200, 33, 34, 35, 36, 31, 32, 117, 33, 34, 35, 36, 118, 31, 32, 119, 33, 34, 35, 36, 128, 129, 169, 170, 130, 179, 31, 141, 131, 33, 34, 35, 36, 134, 201, 234, 132, 133, 147, 135, 136, 37, 197, 138, 139, 53, 140, 145, 188, 37, 215, 31, 45, 155, 33, 34, 35, 36, 156, 157, 158, 159, 142, 149, 150, 151, 152, 153, 154, 160, 204, 54, 55, 161, 56, 57, 58, 59, 60, 162, 165, 166, 167, 168, 171, 173, 186, 125, 181, 184, 207, 206, 210, 230, 217, 220, 235, 146, 231, 232, 236, 239, 241, 243, 244, 245, 226, 221, 127, 228, 189, 92, 0, 0, 204, 233, 0, 0, 0, 99, 237, 238, 0, 240, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 62, 229, 0, 0, 0, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 99, 0, 0, 0, 0, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 99, 0, 0, 0, 0, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 84, 85, 86, 87, 88, 89, 90, 91, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 26, 27, 28, 29, 30 }; static const yytype_int16 yycheck[] = { 6, 10, 25, 3, 164, 5, 6, 7, 120, 3, 0, 38, 37, 173, 38, 73, 38, 37, 38, 39, 40, 41, 42, 43, 38, 73, 74, 38, 73, 74, 190, 73, 74, 38, 194, 195, 37, 38, 38, 40, 41, 42, 43, 73, 74, 205, 73, 207, 75, 74, 74, 73, 164, 73, 74, 182, 183, 165, 166, 73, 172, 173, 73, 74, 74, 38, 178, 38, 73, 74, 38, 38, 73, 73, 73, 75, 76, 74, 190, 74, 37, 75, 194, 195, 37, 74, 74, 74, 38, 95, 99, 74, 101, 205, 40, 207, 37, 38, 39, 40, 41, 42, 43, 37, 38, 40, 40, 41, 42, 43, 74, 37, 38, 40, 40, 41, 42, 43, 74, 37, 126, 127, 73, 235, 37, 38, 73, 40, 41, 42, 43, 74, 73, 74, 73, 73, 38, 74, 74, 73, 74, 74, 74, 39, 74, 74, 169, 73, 74, 37, 38, 40, 40, 41, 42, 43, 40, 37, 37, 74, 73, 103, 104, 105, 106, 107, 108, 74, 177, 65, 66, 74, 68, 69, 70, 71, 72, 74, 73, 73, 73, 38, 74, 74, 37, 75, 73, 73, 38, 74, 38, 214, 74, 74, 222, 101, 74, 74, 74, 74, 74, 74, 74, 74, 210, 201, 37, 211, 170, 17, -1, -1, 221, 219, -1, -1, -1, 39, 224, 225, -1, 227, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 39, 74, -1, -1, -1, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 39, -1, -1, -1, -1, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 39, -1, -1, -1, -1, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, 35, 36 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing symbol of state STATE-NUM. */ static const yytype_uint8 yystos[] = { 0, 78, 79, 0, 73, 80, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 32, 33, 34, 35, 36, 37, 38, 40, 41, 42, 43, 73, 84, 89, 92, 98, 74, 38, 38, 38, 89, 90, 38, 38, 74, 74, 74, 39, 65, 66, 68, 69, 70, 71, 72, 103, 39, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 102, 74, 74, 73, 37, 37, 38, 39, 82, 102, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 82, 101, 74, 40, 40, 74, 40, 3, 5, 6, 7, 73, 75, 76, 92, 74, 37, 73, 73, 73, 73, 74, 74, 74, 98, 74, 74, 74, 38, 73, 83, 89, 74, 83, 38, 100, 100, 100, 100, 100, 100, 100, 40, 40, 37, 37, 74, 74, 74, 74, 73, 84, 73, 73, 73, 38, 98, 98, 74, 86, 74, 99, 95, 97, 88, 73, 84, 85, 73, 96, 96, 73, 94, 37, 91, 82, 97, 74, 85, 85, 38, 74, 74, 96, 74, 98, 38, 39, 73, 74, 87, 89, 84, 74, 38, 95, 95, 38, 93, 37, 74, 81, 74, 85, 74, 85, 85, 74, 88, 85, 85, 74, 74, 98, 74, 94, 74, 82, 74, 74, 98, 74, 86, 74, 98, 98, 74, 98, 74, 74, 74, 74, 74 }; /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ static const yytype_uint8 yyr1[] = { 0, 77, 78, 79, 79, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 81, 81, 82, 82, 82, 82, 83, 83, 83, 84, 84, 85, 85, 86, 86, 87, 87, 87, 87, 88, 88, 89, 89, 89, 89, 89, 90, 90, 91, 91, 92, 92, 93, 93, 94, 95, 95, 96, 97, 97, 98, 98, 98, 98, 98, 98, 98, 99, 99, 100, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 103, 103, 103, 103, 103, 103, 103, 103 }; /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ static const yytype_uint8 yyr2[] = { 0, 2, 1, 0, 2, 4, 4, 4, 5, 8, 8, 7, 9, 4, 4, 4, 3, 3, 3, 3, 4, 4, 4, 3, 7, 3, 4, 4, 4, 3, 3, 0, 2, 1, 2, 1, 2, 1, 1, 3, 1, 5, 1, 5, 2, 0, 1, 1, 1, 3, 0, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 5, 0, 2, 4, 0, 2, 4, 0, 2, 1, 1, 5, 8, 8, 8, 6, 0, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; #define yyerrok (yyerrstatus = 0) #define yyclearin (yychar = YYEMPTY) #define YYEMPTY (-2) #define YYEOF 0 #define YYACCEPT goto yyacceptlab #define YYABORT goto yyabortlab #define YYERROR goto yyerrorlab #define YYRECOVERING() (!!yyerrstatus) #define YYBACKUP(Token, Value) \ do \ if (yychar == YYEMPTY) \ { \ yychar = (Token); \ yylval = (Value); \ YYPOPSTACK (yylen); \ yystate = *yyssp; \ goto yybackup; \ } \ else \ { \ yyerror (&yylloc, context, YY_("syntax error: cannot back up")); \ YYERROR; \ } \ while (0) /* Error token number */ #define YYTERROR 1 #define YYERRCODE 256 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. If N is 0, then set CURRENT to the empty location which ends the previous symbol: RHS[0] (always defined). */ #ifndef YYLLOC_DEFAULT # define YYLLOC_DEFAULT(Current, Rhs, N) \ do \ if (N) \ { \ (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ } \ else \ { \ (Current).first_line = (Current).last_line = \ YYRHSLOC (Rhs, 0).last_line; \ (Current).first_column = (Current).last_column = \ YYRHSLOC (Rhs, 0).last_column; \ } \ while (0) #endif #define YYRHSLOC(Rhs, K) ((Rhs)[K]) /* Enable debugging if requested. */ #if YYDEBUG # ifndef YYFPRINTF # include /* INFRINGES ON USER NAME SPACE */ # define YYFPRINTF fprintf # endif # define YYDPRINTF(Args) \ do { \ if (yydebug) \ YYFPRINTF Args; \ } while (0) /* YY_LOCATION_PRINT -- Print the location on the stream. This macro was not mandated originally: define only if we know we won't break user code: when these are the locations we know. */ #ifndef YY_LOCATION_PRINT # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL /* Print *YYLOCP on YYO. Private, do not rely on its existence. */ YY_ATTRIBUTE_UNUSED static unsigned yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp) { unsigned res = 0; int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0; if (0 <= yylocp->first_line) { res += YYFPRINTF (yyo, "%d", yylocp->first_line); if (0 <= yylocp->first_column) res += YYFPRINTF (yyo, ".%d", yylocp->first_column); } if (0 <= yylocp->last_line) { if (yylocp->first_line < yylocp->last_line) { res += YYFPRINTF (yyo, "-%d", yylocp->last_line); if (0 <= end_col) res += YYFPRINTF (yyo, ".%d", end_col); } else if (0 <= end_col && yylocp->first_column < end_col) res += YYFPRINTF (yyo, "-%d", end_col); } return res; } # define YY_LOCATION_PRINT(File, Loc) \ yy_location_print_ (File, &(Loc)) # else # define YY_LOCATION_PRINT(File, Loc) ((void) 0) # endif #endif # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ do { \ if (yydebug) \ { \ YYFPRINTF (stderr, "%s ", Title); \ yy_symbol_print (stderr, \ Type, Value, Location, context); \ YYFPRINTF (stderr, "\n"); \ } \ } while (0) /*----------------------------------------. | Print this symbol's value on YYOUTPUT. | `----------------------------------------*/ static void yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, Smt2newContext* context) { FILE *yyo = yyoutput; YYUSE (yyo); YYUSE (yylocationp); YYUSE (context); if (!yyvaluep) return; # ifdef YYPRINT if (yytype < YYNTOKENS) YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); # endif YYUSE (yytype); } /*--------------------------------. | Print this symbol on YYOUTPUT. | `--------------------------------*/ static void yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, Smt2newContext* context) { YYFPRINTF (yyoutput, "%s %s (", yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]); YY_LOCATION_PRINT (yyoutput, *yylocationp); YYFPRINTF (yyoutput, ": "); yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, context); YYFPRINTF (yyoutput, ")"); } /*------------------------------------------------------------------. | yy_stack_print -- Print the state stack from its BOTTOM up to its | | TOP (included). | `------------------------------------------------------------------*/ static void yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) { YYFPRINTF (stderr, "Stack now"); for (; yybottom <= yytop; yybottom++) { int yybot = *yybottom; YYFPRINTF (stderr, " %d", yybot); } YYFPRINTF (stderr, "\n"); } # define YY_STACK_PRINT(Bottom, Top) \ do { \ if (yydebug) \ yy_stack_print ((Bottom), (Top)); \ } while (0) /*------------------------------------------------. | Report that the YYRULE is going to be reduced. | `------------------------------------------------*/ static void yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, Smt2newContext* context) { unsigned long int yylno = yyrline[yyrule]; int yynrhs = yyr2[yyrule]; int yyi; YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", yyrule - 1, yylno); /* The symbols being reduced. */ for (yyi = 0; yyi < yynrhs; yyi++) { YYFPRINTF (stderr, " $%d = ", yyi + 1); yy_symbol_print (stderr, yystos[yyssp[yyi + 1 - yynrhs]], &(yyvsp[(yyi + 1) - (yynrhs)]) , &(yylsp[(yyi + 1) - (yynrhs)]) , context); YYFPRINTF (stderr, "\n"); } } # define YY_REDUCE_PRINT(Rule) \ do { \ if (yydebug) \ yy_reduce_print (yyssp, yyvsp, yylsp, Rule, context); \ } while (0) /* Nonzero means print parse trace. It is left uninitialized so that multiple parsers can coexist. */ int yydebug; #else /* !YYDEBUG */ # define YYDPRINTF(Args) # define YY_SYMBOL_PRINT(Title, Type, Value, Location) # define YY_STACK_PRINT(Bottom, Top) # define YY_REDUCE_PRINT(Rule) #endif /* !YYDEBUG */ /* YYINITDEPTH -- initial size of the parser's stacks. */ #ifndef YYINITDEPTH # define YYINITDEPTH 200 #endif /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only if the built-in stack extension method is used). Do not make this value too large; the results are undefined if YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) evaluated with infinite-precision integer arithmetic. */ #ifndef YYMAXDEPTH # define YYMAXDEPTH 10000 #endif #if YYERROR_VERBOSE # ifndef yystrlen # if defined __GLIBC__ && defined _STRING_H # define yystrlen strlen # else /* Return the length of YYSTR. */ static YYSIZE_T yystrlen (const char *yystr) { YYSIZE_T yylen; for (yylen = 0; yystr[yylen]; yylen++) continue; return yylen; } # endif # endif # ifndef yystpcpy # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE # define yystpcpy stpcpy # else /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in YYDEST. */ static char * yystpcpy (char *yydest, const char *yysrc) { char *yyd = yydest; const char *yys = yysrc; while ((*yyd++ = *yys++) != '\0') continue; return yyd - 1; } # endif # endif # ifndef yytnamerr /* Copy to YYRES the contents of YYSTR after stripping away unnecessary quotes and backslashes, so that it's suitable for yyerror. The heuristic is that double-quoting is unnecessary unless the string contains an apostrophe, a comma, or backslash (other than backslash-backslash). YYSTR is taken from yytname. If YYRES is null, do not copy; instead, return the length of what the result would have been. */ static YYSIZE_T yytnamerr (char *yyres, const char *yystr) { if (*yystr == '"') { YYSIZE_T yyn = 0; char const *yyp = yystr; for (;;) switch (*++yyp) { case '\'': case ',': goto do_not_strip_quotes; case '\\': if (*++yyp != '\\') goto do_not_strip_quotes; /* Fall through. */ default: if (yyres) yyres[yyn] = *yyp; yyn++; break; case '"': if (yyres) yyres[yyn] = '\0'; return yyn; } do_not_strip_quotes: ; } if (! yyres) return yystrlen (yystr); return yystpcpy (yyres, yystr) - yyres; } # endif /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message about the unexpected token YYTOKEN for the state stack whose top is YYSSP. Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is not large enough to hold the message. In that case, also set *YYMSG_ALLOC to the required number of bytes. Return 2 if the required number of bytes is too large to store. */ static int yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, yytype_int16 *yyssp, int yytoken) { YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); YYSIZE_T yysize = yysize0; enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; /* Internationalized format string. */ const char *yyformat = YY_NULLPTR; /* Arguments of yyformat. */ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; /* Number of reported tokens (one for the "unexpected", one per "expected"). */ int yycount = 0; /* There are many possibilities here to consider: - If this state is a consistent state with a default action, then the only way this function was invoked is if the default action is an error action. In that case, don't check for expected tokens because there are none. - The only way there can be no lookahead present (in yychar) is if this state is a consistent state with a default action. Thus, detecting the absence of a lookahead is sufficient to determine that there is no unexpected or expected token to report. In that case, just report a simple "syntax error". - Don't assume there isn't a lookahead just because this state is a consistent state with a default action. There might have been a previous inconsistent state, consistent state with a non-default action, or user semantic action that manipulated yychar. - Of course, the expected token list depends on states to have correct lookahead information, and it depends on the parser not to perform extra reductions after fetching a lookahead from the scanner and before detecting a syntax error. Thus, state merging (from LALR or IELR) and default reductions corrupt the expected token list. However, the list is correct for canonical LR with one exception: it will still contain any token that will not be accepted due to an error action in a later state. */ if (yytoken != YYEMPTY) { int yyn = yypact[*yyssp]; yyarg[yycount++] = yytname[yytoken]; if (!yypact_value_is_default (yyn)) { /* Start YYX at -YYN if negative to avoid negative indexes in YYCHECK. In other words, skip the first -YYN actions for this state because they are default actions. */ int yyxbegin = yyn < 0 ? -yyn : 0; /* Stay within bounds of both yycheck and yytname. */ int yychecklim = YYLAST - yyn + 1; int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; int yyx; for (yyx = yyxbegin; yyx < yyxend; ++yyx) if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR && !yytable_value_is_error (yytable[yyx + yyn])) { if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) { yycount = 1; yysize = yysize0; break; } yyarg[yycount++] = yytname[yyx]; { YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) return 2; yysize = yysize1; } } } } switch (yycount) { # define YYCASE_(N, S) \ case N: \ yyformat = S; \ break YYCASE_(0, YY_("syntax error")); YYCASE_(1, YY_("syntax error, unexpected %s")); YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); # undef YYCASE_ } { YYSIZE_T yysize1 = yysize + yystrlen (yyformat); if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) return 2; yysize = yysize1; } if (*yymsg_alloc < yysize) { *yymsg_alloc = 2 * yysize; if (! (yysize <= *yymsg_alloc && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; return 1; } /* Avoid sprintf, as that infringes on the user's name space. Don't have undefined behavior even if the translation produced a string with the wrong number of "%s"s. */ { char *yyp = *yymsg; int yyi = 0; while ((*yyp = *yyformat) != '\0') if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) { yyp += yytnamerr (yyp, yyarg[yyi++]); yyformat += 2; } else { yyp++; yyformat++; } } return 0; } #endif /* YYERROR_VERBOSE */ /*-----------------------------------------------. | Release the memory associated to this symbol. | `-----------------------------------------------*/ static void yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, Smt2newContext* context) { YYUSE (yyvaluep); YYUSE (yylocationp); YYUSE (context); if (!yymsg) yymsg = "Deleting"; YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN YYUSE (yytype); YY_IGNORE_MAYBE_UNINITIALIZED_END } /*----------. | yyparse. | `----------*/ int yyparse (Smt2newContext* context) { /* The lookahead symbol. */ int yychar; /* The semantic value of the lookahead symbol. */ /* Default value used for initialization, for pacifying older GCCs or non-GCC compilers. */ YY_INITIAL_VALUE (static YYSTYPE yyval_default;) YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); /* Location data for the lookahead symbol. */ static YYLTYPE yyloc_default # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL = { 1, 1, 1, 1 } # endif ; YYLTYPE yylloc = yyloc_default; /* Number of syntax errors so far. */ int yynerrs; int yystate; /* Number of tokens to shift before error messages enabled. */ int yyerrstatus; /* The stacks and their tools: 'yyss': related to states. 'yyvs': related to semantic values. 'yyls': related to locations. Refer to the stacks through separate pointers, to allow yyoverflow to reallocate them elsewhere. */ /* The state stack. */ yytype_int16 yyssa[YYINITDEPTH]; yytype_int16 *yyss; yytype_int16 *yyssp; /* The semantic value stack. */ YYSTYPE yyvsa[YYINITDEPTH]; YYSTYPE *yyvs; YYSTYPE *yyvsp; /* The location stack. */ YYLTYPE yylsa[YYINITDEPTH]; YYLTYPE *yyls; YYLTYPE *yylsp; /* The locations where the error started and ended. */ YYLTYPE yyerror_range[3]; YYSIZE_T yystacksize; int yyn; int yyresult; /* Lookahead token as an internal (translated) token number. */ int yytoken = 0; /* The variables used to return semantic value and location from the action routines. */ YYSTYPE yyval; YYLTYPE yyloc; #if YYERROR_VERBOSE /* Buffer for error messages, and its allocated size. */ char yymsgbuf[128]; char *yymsg = yymsgbuf; YYSIZE_T yymsg_alloc = sizeof yymsgbuf; #endif #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) /* The number of symbols on the RHS of the reduced rule. Keep to zero when no symbol should be popped. */ int yylen = 0; yyssp = yyss = yyssa; yyvsp = yyvs = yyvsa; yylsp = yyls = yylsa; yystacksize = YYINITDEPTH; YYDPRINTF ((stderr, "Starting parse\n")); yystate = 0; yyerrstatus = 0; yynerrs = 0; yychar = YYEMPTY; /* Cause a token to be read. */ yylsp[0] = yylloc; goto yysetstate; /*------------------------------------------------------------. | yynewstate -- Push a new state, which is found in yystate. | `------------------------------------------------------------*/ yynewstate: /* In all cases, when you get here, the value and location stacks have just been pushed. So pushing a state here evens the stacks. */ yyssp++; yysetstate: *yyssp = yystate; if (yyss + yystacksize - 1 <= yyssp) { /* Get the current used size of the three stacks, in elements. */ YYSIZE_T yysize = yyssp - yyss + 1; #ifdef yyoverflow { /* Give user a chance to reallocate the stack. Use copies of these so that the &'s don't force the real ones into memory. */ YYSTYPE *yyvs1 = yyvs; yytype_int16 *yyss1 = yyss; YYLTYPE *yyls1 = yyls; /* Each stack pointer address is followed by the size of the data in use in that stack, in bytes. This used to be a conditional around just the two extra args, but that might be undefined if yyoverflow is a macro. */ yyoverflow (YY_("memory exhausted"), &yyss1, yysize * sizeof (*yyssp), &yyvs1, yysize * sizeof (*yyvsp), &yyls1, yysize * sizeof (*yylsp), &yystacksize); yyls = yyls1; yyss = yyss1; yyvs = yyvs1; } #else /* no yyoverflow */ # ifndef YYSTACK_RELOCATE goto yyexhaustedlab; # else /* Extend the stack our own way. */ if (YYMAXDEPTH <= yystacksize) goto yyexhaustedlab; yystacksize *= 2; if (YYMAXDEPTH < yystacksize) yystacksize = YYMAXDEPTH; { yytype_int16 *yyss1 = yyss; union yyalloc *yyptr = (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); if (! yyptr) goto yyexhaustedlab; YYSTACK_RELOCATE (yyss_alloc, yyss); YYSTACK_RELOCATE (yyvs_alloc, yyvs); YYSTACK_RELOCATE (yyls_alloc, yyls); # undef YYSTACK_RELOCATE if (yyss1 != yyssa) YYSTACK_FREE (yyss1); } # endif #endif /* no yyoverflow */ yyssp = yyss + yysize - 1; yyvsp = yyvs + yysize - 1; yylsp = yyls + yysize - 1; YYDPRINTF ((stderr, "Stack size increased to %lu\n", (unsigned long int) yystacksize)); if (yyss + yystacksize - 1 <= yyssp) YYABORT; } YYDPRINTF ((stderr, "Entering state %d\n", yystate)); if (yystate == YYFINAL) YYACCEPT; goto yybackup; /*-----------. | yybackup. | `-----------*/ yybackup: /* Do appropriate processing given the current state. Read a lookahead token if we need one and don't already have one. */ /* First try to decide what to do without reference to lookahead token. */ yyn = yypact[yystate]; if (yypact_value_is_default (yyn)) goto yydefault; /* Not known => get a lookahead token if don't already have one. */ /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ if (yychar == YYEMPTY) { YYDPRINTF ((stderr, "Reading a token: ")); yychar = yylex (&yylval, &yylloc, scanner); } if (yychar <= YYEOF) { yychar = yytoken = YYEOF; YYDPRINTF ((stderr, "Now at end of input.\n")); } else { yytoken = YYTRANSLATE (yychar); YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); } /* If the proper action on seeing token YYTOKEN is to reduce or to detect an error, take that action. */ yyn += yytoken; if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) goto yydefault; yyn = yytable[yyn]; if (yyn <= 0) { if (yytable_value_is_error (yyn)) goto yyerrlab; yyn = -yyn; goto yyreduce; } /* Count tokens shifted since error; after three, turn off error status. */ if (yyerrstatus) yyerrstatus--; /* Shift the lookahead token. */ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); /* Discard the shifted token. */ yychar = YYEMPTY; yystate = yyn; YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN *++yyvsp = yylval; YY_IGNORE_MAYBE_UNINITIALIZED_END *++yylsp = yylloc; goto yynewstate; /*-----------------------------------------------------------. | yydefault -- do the default action for the current state. | `-----------------------------------------------------------*/ yydefault: yyn = yydefact[yystate]; if (yyn == 0) goto yyerrlab; goto yyreduce; /*-----------------------------. | yyreduce -- Do a reduction. | `-----------------------------*/ yyreduce: /* yyn is the number of a rule to reduce with. */ yylen = yyr2[yyn]; /* If YYLEN is nonzero, implement the default value of the action: '$$ = $1'. Otherwise, the following line sets YYVAL to garbage. This behavior is undocumented and Bison users should not rely upon it. Assigning to YYVAL unconditionally makes the parser a bit smaller, and it avoids a GCC warning that YYVAL may be used uninitialized. */ yyval = yyvsp[1-yylen]; /* Default location. */ YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); YY_REDUCE_PRINT (yyn); switch (yyn) { case 2: #line 97 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { ASTNode *n = new ASTNode(CMDL_T, strdup("main-script")); n->children = (yyvsp[0].snode_list); context->insertRoot(n); } #line 1642 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 3: #line 101 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode_list) = new std::list(); } #line 1648 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 4: #line 103 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (*(yyvsp[-1].snode_list)).push_back((yyvsp[0].snode)); (yyval.snode_list) = (yyvsp[-1].snode_list); } #line 1654 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 5: #line 107 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-2].tok)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back(new ASTNode(SYM_T, (yyvsp[-1].str))); } #line 1664 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 6: #line 113 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-2].tok)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[-1].snode)); } #line 1674 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 7: #line 119 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-2].tok)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[-1].snode)); } #line 1684 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 8: #line 125 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-3].tok)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back(new ASTNode(SYM_T, (yyvsp[-2].str))); (yyval.snode)->children->push_back(new ASTNode(NUM_T, (yyvsp[-1].str))); } #line 1695 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 9: #line 132 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-6].tok)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back(new ASTNode(SYM_T, (yyvsp[-5].str))); ASTNode* syml = new ASTNode(SYML_T, NULL); syml->children = (yyvsp[-3].snode_list); (yyval.snode)->children->push_back(syml); (yyval.snode)->children->push_back((yyvsp[-1].snode)); } #line 1711 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 10: #line 145 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-6].tok)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back(new ASTNode(SYM_T, (yyvsp[-5].str))); ASTNode* sortl = new ASTNode(SORTL_T, NULL); sortl->children = (yyvsp[-3].snode_list); (yyval.snode)->children->push_back(sortl); (yyval.snode)->children->push_back((yyvsp[-1].snode)); } #line 1727 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 11: #line 157 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-5].tok)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[-4].snode)); ASTNode* sortl = new ASTNode(SORTL_T, NULL); sortl->children = new std::list(); (yyval.snode)->children->push_back(sortl); (yyval.snode)->children->push_back((yyvsp[-1].snode)); } #line 1743 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 12: #line 169 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-7].tok)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back(new ASTNode(SYM_T, (yyvsp[-6].str))); ASTNode* svl = new ASTNode(SVL_T, NULL); svl->children = (yyvsp[-4].snode_list); (yyval.snode)->children->push_back(svl); (yyval.snode)->children->push_back((yyvsp[-2].snode)); (yyval.snode)->children->push_back((yyvsp[-1].snode)); } #line 1760 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 13: #line 182 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-2].tok)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back(new ASTNode(NUM_T, (yyvsp[-1].str))); } #line 1770 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 14: #line 188 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-2].tok)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back(new ASTNode(NUM_T, (yyvsp[-1].str))); } #line 1780 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 15: #line 194 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-2].tok)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[-1].snode)); } #line 1790 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 16: #line 200 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-1].tok)); } #line 1798 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 17: #line 204 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-1].tok)); } #line 1806 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 18: #line 208 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-1].tok)); } #line 1814 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 19: #line 212 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-1].tok)); } #line 1822 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 20: #line 216 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-2].tok)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back(new ASTNode(UATTR_T, (yyvsp[-1].str))); } #line 1832 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 21: #line 222 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-2].tok)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back(new ASTNode(UATTR_T, (yyvsp[-1].str))); } #line 1842 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 22: #line 228 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-2].tok)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back(new ASTNode(UATTR_T, (yyvsp[-1].str))); } #line 1852 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 23: #line 234 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-1].tok)); } #line 1860 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 24: #line 238 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-5].tok)); (yyval.snode)->children = (yyvsp[-2].snode_list); (yyval.snode)->children->push_front((yyvsp[-3].snode)); } #line 1870 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 25: #line 244 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-1].tok)); } #line 1878 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 26: #line 248 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-2].tok)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back(new ASTNode(UATTR_T, (yyvsp[-1].str))); } #line 1888 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 27: #line 254 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-2].tok)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back(new ASTNode(PATTR_T, (yyvsp[-1].str))); } #line 1898 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 28: #line 260 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-2].tok)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[-1].snode)); } #line 1908 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 29: #line 266 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-1].tok)); } #line 1916 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 30: #line 270 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[-1].tok)); } #line 1922 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 31: #line 274 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode_list) = new std::list(); } #line 1928 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 32: #line 276 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyvsp[-1].snode_list)->push_back((yyvsp[0].snode)); (yyval.snode_list) = (yyvsp[-1].snode_list); } #line 1934 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 33: #line 280 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(UATTR_T, (yyvsp[0].str)); } #line 1940 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 34: #line 282 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(UATTR_T, (yyvsp[-1].str)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[0].snode)); } #line 1946 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 35: #line 284 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(PATTR_T, (yyvsp[0].str)); } #line 1952 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 36: #line 286 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(PATTR_T, (yyvsp[-1].str)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[0].snode)); } #line 1958 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 37: #line 290 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(SPECC_T, NULL); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[0].snode)); } #line 1964 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 38: #line 292 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(SYM_T, (yyvsp[0].str)); } #line 1972 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 39: #line 296 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(SEXPRL_T, NULL); (yyval.snode)->children = (yyvsp[-1].snode_list); } #line 1981 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 40: #line 303 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(SYM_T, (yyvsp[0].str)); } #line 1987 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 41: #line 305 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(SYM_T, (yyvsp[-2].str)); (yyval.snode)->children = (yyvsp[-1].snode_list); } #line 1993 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 42: #line 309 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(ID_T, NULL); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[0].snode)); } #line 1999 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 43: #line 311 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(LID_T, NULL); (yyval.snode)->children = (yyvsp[-1].snode_list); (yyval.snode)->children->push_front((yyvsp[-2].snode)); } #line 2009 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 44: #line 319 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyvsp[-1].snode_list)->push_back((yyvsp[0].snode)); (yyval.snode_list) = (yyvsp[-1].snode_list); } #line 2015 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 45: #line 321 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode_list) = new std::list(); } #line 2021 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 46: #line 325 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(SPECC_T, NULL); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[0].snode)); } #line 2031 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 47: #line 331 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(SYM_T, (yyvsp[0].str)); } #line 2039 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 48: #line 335 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(UATTR_T, (yyvsp[0].str)); } #line 2047 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 49: #line 339 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(SEXPRL_T, NULL); (yyval.snode)->children = (yyvsp[-1].snode_list); } #line 2056 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 50: #line 346 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode_list) = new std::list(); } #line 2064 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 51: #line 350 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyvsp[-1].snode_list)->push_back((yyvsp[0].snode)); (yyval.snode_list) = (yyvsp[-1].snode_list); } #line 2073 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 52: #line 358 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(NUM_T, (yyvsp[0].str)); } #line 2079 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 53: #line 360 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(DEC_T, (yyvsp[0].str)); } #line 2085 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 54: #line 362 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(HEX_T, (yyvsp[0].str)); } #line 2091 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 55: #line 364 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(BIN_T, (yyvsp[0].str)); } #line 2097 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 56: #line 366 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(STR_T, (yyvsp[0].str)); } #line 2103 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 57: #line 370 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(SYM_T, (yyvsp[0].str)); } #line 2109 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 58: #line 372 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = (yyvsp[0].snode); } #line 2115 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 59: #line 376 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyvsp[-1].snode_list)->push_back(new ASTNode(NUM_T, (yyvsp[0].str))); (yyval.snode_list) = (yyvsp[-1].snode_list); } #line 2121 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 60: #line 378 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode_list) = new std::list(); (yyval.snode_list)->push_back(new ASTNode(NUM_T, (yyvsp[0].str))); } #line 2127 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 61: #line 382 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = (yyvsp[0].snode); } #line 2133 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 62: #line 384 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(AS_T, NULL); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[-2].snode)); (yyval.snode)->children->push_back((yyvsp[-1].snode)); } #line 2144 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 63: #line 393 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode_list) = new std::list(); } #line 2150 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 64: #line 395 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyvsp[-1].snode_list)->push_back((yyvsp[0].snode)); (yyval.snode_list) = (yyvsp[-1].snode_list); } #line 2156 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 65: #line 399 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(VARB_T, (yyvsp[-2].str)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[-1].snode)); } #line 2162 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 66: #line 403 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode_list) = new std::list(); } #line 2168 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 67: #line 405 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyvsp[-1].snode_list)->push_back((yyvsp[0].snode)); (yyval.snode_list) = (yyvsp[-1].snode_list); } #line 2174 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 68: #line 409 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(SV_T, (yyvsp[-2].str)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[-1].snode)); } #line 2180 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 69: #line 412 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode_list) = new std::list(); } #line 2186 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 70: #line 414 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyvsp[-1].snode_list)->push_back((yyvsp[0].snode)); (yyval.snode_list) = (yyvsp[-1].snode_list); } #line 2192 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 71: #line 418 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(TERM_T, NULL); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[0].snode)); } #line 2198 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 72: #line 420 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(QID_T, NULL); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[0].snode)); } #line 2204 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 73: #line 422 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(LQID_T, NULL); (yyval.snode)->children = (yyvsp[-1].snode_list); (yyval.snode)->children->push_front((yyvsp[-2].snode)); (yyval.snode)->children->push_front((yyvsp[-3].snode)); } #line 2215 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 74: #line 429 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(LET_T, NULL); (yyval.snode)->children = new std::list(); (yyvsp[-3].snode_list)->push_front((yyvsp[-4].snode)); ASTNode* vbl = new ASTNode(VARBL_T, NULL); vbl->children = (yyvsp[-3].snode_list); (yyval.snode)->children->push_back(vbl); (yyval.snode)->children->push_back((yyvsp[-1].snode)); } #line 2229 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 75: #line 439 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(FORALL_T, NULL); (yyval.snode)->children = new std::list(); (yyvsp[-3].snode_list)->push_front((yyvsp[-4].snode)); ASTNode* svl = new ASTNode(SVL_T, NULL); svl->children = (yyvsp[-3].snode_list); (yyval.snode)->children->push_back(svl); (yyval.snode)->children->push_back((yyvsp[-1].snode)); } #line 2243 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 76: #line 449 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(EXISTS_T, NULL); (yyval.snode)->children = new std::list(); (yyvsp[-3].snode_list)->push_front((yyvsp[-4].snode)); ASTNode* svl = new ASTNode(SVL_T, NULL); svl->children = (yyvsp[-3].snode_list); (yyval.snode)->children->push_back(svl); (yyval.snode)->children->push_back((yyvsp[-1].snode)); } #line 2257 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 77: #line 459 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(BANG_T, NULL); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_front((yyvsp[-3].snode)); ASTNode *atrs = new ASTNode(GATTRL_T, NULL); (yyvsp[-1].snode_list)->push_front((yyvsp[-2].snode)); atrs->children = (yyvsp[-1].snode_list); (yyval.snode)->children->push_back(atrs); } #line 2271 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 78: #line 535 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode_list) = new std::list(); } #line 2277 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 79: #line 537 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyvsp[-1].snode_list)->push_back(new ASTNode(SYM_T, (yyvsp[0].str))); (yyval.snode_list) = (yyvsp[-1].snode_list); } #line 2283 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 80: #line 694 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { if (strcmp((yyvsp[0].str), "true") == 0) (yyval.snode) = new ASTNode(BOOL_T, strdup("true")); else if (strcmp((yyvsp[0].str), "false") == 0) (yyval.snode) = new ASTNode(BOOL_T, strdup("false")); else { printf("Syntax error: expecting either 'true' or 'false', got '%s'\n", (yyvsp[0].str)); YYERROR; } } #line 2298 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 81: #line 707 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[-1].str)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[0].snode)); } #line 2308 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 82: #line 713 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[-1].str)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[0].snode)); } #line 2318 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 83: #line 719 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[-1].str)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[0].snode)); } #line 2328 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 84: #line 725 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[-1].str)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[0].snode)); } #line 2338 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 85: #line 731 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[-1].str)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[0].snode)); } #line 2348 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 86: #line 737 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[-1].str)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[0].snode)); } #line 2358 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 87: #line 743 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[-1].str)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[0].snode)); } #line 2368 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 88: #line 749 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[-1].str)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back(new ASTNode(STR_T, (yyvsp[0].str))); } #line 2378 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 89: #line 755 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[-1].str)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back(new ASTNode(STR_T, (yyvsp[0].str))); } #line 2388 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 90: #line 761 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[-1].str)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back(new ASTNode(NUM_T, (yyvsp[0].str))); } #line 2398 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 91: #line 767 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[-1].str)); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back(new ASTNode(NUM_T, (yyvsp[0].str))); } #line 2408 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 92: #line 773 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(OPTION_T, NULL); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back((yyvsp[0].snode)); } #line 2418 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 93: #line 781 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2424 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 94: #line 783 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2430 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 95: #line 785 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2436 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 96: #line 787 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2442 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 97: #line 789 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2448 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 98: #line 791 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2454 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 99: #line 793 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2460 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 100: #line 795 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2466 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 101: #line 797 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2472 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 102: #line 799 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2478 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 103: #line 801 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2484 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 104: #line 803 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2490 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 105: #line 805 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2496 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 106: #line 807 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2502 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 107: #line 809 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2508 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 108: #line 811 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2514 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 109: #line 813 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2520 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 110: #line 815 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2526 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 111: #line 817 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2532 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 112: #line 819 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2538 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 113: #line 821 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2544 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 114: #line 823 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2550 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 115: #line 825 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2556 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 116: #line 827 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2562 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 117: #line 829 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2568 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 118: #line 831 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2574 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 119: #line 833 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2580 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 120: #line 835 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2586 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 121: #line 837 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.str) = (yyvsp[0].str); } #line 2592 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 122: #line 841 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(INFO_T, (yyvsp[0].str)); } #line 2598 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 123: #line 843 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(INFO_T, (yyvsp[0].str)); } #line 2604 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 124: #line 845 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(INFO_T, (yyvsp[0].str)); } #line 2610 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 125: #line 847 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(INFO_T, (yyvsp[0].str)); } #line 2616 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 126: #line 849 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(INFO_T, (yyvsp[0].str)); } #line 2622 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 127: #line 851 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(INFO_T, (yyvsp[0].str)); } #line 2628 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 128: #line 853 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(INFO_T, (yyvsp[0].str)); } #line 2634 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; case 129: #line 855 "smt2new/smt2newparser.yy" /* yacc.c:1646 */ { (yyval.snode) = new ASTNode(INFO_T, NULL); (yyval.snode)->children = new std::list(); (yyval.snode)->children->push_back(new ASTNode(GATTR_T, (yyvsp[0].str))); } #line 2644 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ break; #line 2648 "smt2new/smt2newparser.cc" /* yacc.c:1646 */ default: break; } /* User semantic actions sometimes alter yychar, and that requires that yytoken be updated with the new translation. We take the approach of translating immediately before every use of yytoken. One alternative is translating here after every semantic action, but that translation would be missed if the semantic action invokes YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an incorrect destructor might then be invoked immediately. In the case of YYERROR or YYBACKUP, subsequent parser actions might lead to an incorrect destructor call or verbose syntax error message before the lookahead is translated. */ YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); YYPOPSTACK (yylen); yylen = 0; YY_STACK_PRINT (yyss, yyssp); *++yyvsp = yyval; *++yylsp = yyloc; /* Now 'shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by. */ yyn = yyr1[yyn]; yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) yystate = yytable[yystate]; else yystate = yydefgoto[yyn - YYNTOKENS]; goto yynewstate; /*--------------------------------------. | yyerrlab -- here on detecting error. | `--------------------------------------*/ yyerrlab: /* Make sure we have latest lookahead translation. See comments at user semantic actions for why this is necessary. */ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); /* If not already recovering from an error, report this error. */ if (!yyerrstatus) { ++yynerrs; #if ! YYERROR_VERBOSE yyerror (&yylloc, context, YY_("syntax error")); #else # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ yyssp, yytoken) { char const *yymsgp = YY_("syntax error"); int yysyntax_error_status; yysyntax_error_status = YYSYNTAX_ERROR; if (yysyntax_error_status == 0) yymsgp = yymsg; else if (yysyntax_error_status == 1) { if (yymsg != yymsgbuf) YYSTACK_FREE (yymsg); yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); if (!yymsg) { yymsg = yymsgbuf; yymsg_alloc = sizeof yymsgbuf; yysyntax_error_status = 2; } else { yysyntax_error_status = YYSYNTAX_ERROR; yymsgp = yymsg; } } yyerror (&yylloc, context, yymsgp); if (yysyntax_error_status == 2) goto yyexhaustedlab; } # undef YYSYNTAX_ERROR #endif } yyerror_range[1] = yylloc; if (yyerrstatus == 3) { /* If just tried and failed to reuse lookahead token after an error, discard it. */ if (yychar <= YYEOF) { /* Return failure if at end of input. */ if (yychar == YYEOF) YYABORT; } else { yydestruct ("Error: discarding", yytoken, &yylval, &yylloc, context); yychar = YYEMPTY; } } /* Else will try to reuse lookahead token after shifting the error token. */ goto yyerrlab1; /*---------------------------------------------------. | yyerrorlab -- error raised explicitly by YYERROR. | `---------------------------------------------------*/ yyerrorlab: /* Pacify compilers like GCC when the user code never invokes YYERROR and the label yyerrorlab therefore never appears in user code. */ if (/*CONSTCOND*/ 0) goto yyerrorlab; yyerror_range[1] = yylsp[1-yylen]; /* Do not reclaim the symbols of the rule whose action triggered this YYERROR. */ YYPOPSTACK (yylen); yylen = 0; YY_STACK_PRINT (yyss, yyssp); yystate = *yyssp; goto yyerrlab1; /*-------------------------------------------------------------. | yyerrlab1 -- common code for both syntax error and YYERROR. | `-------------------------------------------------------------*/ yyerrlab1: yyerrstatus = 3; /* Each real token shifted decrements this. */ for (;;) { yyn = yypact[yystate]; if (!yypact_value_is_default (yyn)) { yyn += YYTERROR; if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) { yyn = yytable[yyn]; if (0 < yyn) break; } } /* Pop the current state because it cannot handle the error token. */ if (yyssp == yyss) YYABORT; yyerror_range[1] = *yylsp; yydestruct ("Error: popping", yystos[yystate], yyvsp, yylsp, context); YYPOPSTACK (1); yystate = *yyssp; YY_STACK_PRINT (yyss, yyssp); } YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN *++yyvsp = yylval; YY_IGNORE_MAYBE_UNINITIALIZED_END yyerror_range[2] = yylloc; /* Using YYLLOC is tempting, but would change the location of the lookahead. YYLOC is available though. */ YYLLOC_DEFAULT (yyloc, yyerror_range, 2); *++yylsp = yyloc; /* Shift the error token. */ YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); yystate = yyn; goto yynewstate; /*-------------------------------------. | yyacceptlab -- YYACCEPT comes here. | `-------------------------------------*/ yyacceptlab: yyresult = 0; goto yyreturn; /*-----------------------------------. | yyabortlab -- YYABORT comes here. | `-----------------------------------*/ yyabortlab: yyresult = 1; goto yyreturn; #if !defined yyoverflow || YYERROR_VERBOSE /*-------------------------------------------------. | yyexhaustedlab -- memory exhaustion comes here. | `-------------------------------------------------*/ yyexhaustedlab: yyerror (&yylloc, context, YY_("memory exhausted")); yyresult = 2; /* Fall through. */ #endif yyreturn: if (yychar != YYEMPTY) { /* Make sure we have latest lookahead translation. See comments at user semantic actions for why this is necessary. */ yytoken = YYTRANSLATE (yychar); yydestruct ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc, context); } /* Do not reclaim the symbols of the rule whose action triggered this YYABORT or YYACCEPT. */ YYPOPSTACK (yylen); YY_STACK_PRINT (yyss, yyssp); while (yyssp != yyss) { yydestruct ("Cleanup: popping", yystos[*yyssp], yyvsp, yylsp, context); YYPOPSTACK (1); } #ifndef yyoverflow if (yyss != yyssa) YYSTACK_FREE (yyss); #endif #if YYERROR_VERBOSE if (yymsg != yymsgbuf) YYSTACK_FREE (yymsg); #endif return yyresult; } #line 862 "smt2new/smt2newparser.yy" /* yacc.c:1906 */ //======================================================================================= // Auxiliary Routines opensmt-2.5.2/src/parsers/smt2new/smt2newparser.hh000066400000000000000000000103761445011647600222260ustar00rootroot00000000000000/* A Bison parser, made by GNU Bison 3.0.4. */ /* Bison interface for Yacc-like parsers in C Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ /* As a special exception, you may create a larger work that contains part or all of the Bison parser skeleton and distribute that work under terms of your choice, so long as that work isn't itself a parser generator using the skeleton or a modified version thereof as a parser skeleton. Alternatively, if you modify or redistribute the parser skeleton itself, you may (at your option) remove this special exception, which will cause the skeleton and the resulting Bison output files to be licensed under the GNU General Public License without this special exception. This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ #ifndef YY_SMT2NEW_SMT2NEW_SMT2NEWPARSER_HH_INCLUDED # define YY_SMT2NEW_SMT2NEW_SMT2NEWPARSER_HH_INCLUDED /* Debug traces. */ #ifndef YYDEBUG # define YYDEBUG 0 #endif #if YYDEBUG extern int smt2newdebug; #endif /* Token type. */ #ifndef YYTOKENTYPE # define YYTOKENTYPE enum yytokentype { TK_AS = 258, TK_DECIMAL = 259, TK_EXISTS = 260, TK_FORALL = 261, TK_LET = 262, TK_NUMERAL = 263, TK_PAR = 264, TK_STRING = 265, TK_ASSERT = 266, TK_CHECKSAT = 267, TK_DECLARESORT = 268, TK_DECLAREFUN = 269, TK_DECLARECONST = 270, TK_DEFINESORT = 271, TK_DEFINEFUN = 272, TK_EXIT = 273, TK_GETASSERTIONS = 274, TK_GETASSIGNMENT = 275, TK_GETINFO = 276, TK_GETOPTION = 277, TK_GETPROOF = 278, TK_GETUNSATCORE = 279, TK_GETVALUE = 280, TK_POP = 281, TK_PUSH = 282, TK_SETLOGIC = 283, TK_SETINFO = 284, TK_SETOPTION = 285, TK_THEORY = 286, TK_GETITPS = 287, TK_WRSTATE = 288, TK_RDSTATE = 289, TK_SIMPLIFY = 290, TK_WRFUNS = 291, TK_NUM = 292, TK_SYM = 293, TK_KEY = 294, TK_STR = 295, TK_DEC = 296, TK_HEX = 297, TK_BIN = 298, KW_SORTS = 299, KW_FUNS = 300, KW_SORTSDESCRIPTION = 301, KW_FUNSDESCRIPTION = 302, KW_DEFINITION = 303, KW_NOTES = 304, KW_THEORIES = 305, KW_LANGUAGE = 306, KW_EXTENSIONS = 307, KW_VALUES = 308, KW_PRINTSUCCESS = 309, KW_EXPANDDEFINITIONS = 310, KW_INTERACTIVEMODE = 311, KW_PRODUCEPROOFS = 312, KW_PRODUCEUNSATCORES = 313, KW_PRODUCEMODELS = 314, KW_PRODUCEASSIGNMENTS = 315, KW_REGULAROUTPUTCHANNEL = 316, KW_DIAGNOSTICOUTPUTCHANNEL = 317, KW_RANDOMSEED = 318, KW_VERBOSITY = 319, KW_ERRORBEHAVIOR = 320, KW_NAME = 321, KW_NAMED = 322, KW_AUTHORS = 323, KW_VERSION = 324, KW_STATUS = 325, KW_REASONUNKNOWN = 326, KW_ALLSTATISTICS = 327 }; #endif /* Value type. */ #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED union YYSTYPE { #line 66 "smt2new/smt2newparser.yy" /* yacc.c:1909 */ char * str; std::vector< std::string > * str_list; ASTNode * snode; std::list< ASTNode * > * snode_list; smt2token tok; #line 135 "smt2new/smt2newparser.hh" /* yacc.c:1909 */ }; typedef union YYSTYPE YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 # define YYSTYPE_IS_DECLARED 1 #endif /* Location type. */ #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED typedef struct YYLTYPE YYLTYPE; struct YYLTYPE { int first_line; int first_column; int last_line; int last_column; }; # define YYLTYPE_IS_DECLARED 1 # define YYLTYPE_IS_TRIVIAL 1 #endif int smt2newparse (Smt2newContext* context); #endif /* !YY_SMT2NEW_SMT2NEW_SMT2NEWPARSER_HH_INCLUDED */ opensmt-2.5.2/src/parsers/smt2new/smt2newparser.yy000066400000000000000000000513751445011647600222740ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ %define api.pure %define parse.error verbose %name-prefix "smt2new" %locations %defines %parse-param { Smt2newContext* context } %lex-param { void* scanner } %{ #include #include #include #include #include #include #include #include "smt2newcontext.h" #include "smt2newparser.hh" #include "smt2tokens.h" int smt2newlex(YYSTYPE* lvalp, YYLTYPE* llocp, void* scanner); void smt2newerror( YYLTYPE* locp, Smt2newContext* context, const char * s ) { if (context->interactive) printf("At interactive input: %s\n", s); else printf( "At line %d: %s\n", locp->first_line, s ); // exit( 1 ); } #define scanner context->scanner /* Overallocation to prevent stack overflow */ #define YYMAXDEPTH 1024 * 1024 %} %union { char * str; ASTNode * snode; std::vector< ASTNode * > * snode_list; osmttokens::smt2token tok; } %destructor { free($$); } %destructor { delete $$; } %destructor { if ($$) { for (auto node : *$$) { delete node; } delete $$; }} %token TK_AS TK_DECIMAL TK_EXISTS TK_FORALL TK_LET TK_NUMERAL TK_PAR TK_STRING %token TK_ASSERT TK_CHECKSAT TK_DECLARESORT TK_DECLAREFUN TK_DECLARECONST TK_DEFINESORT TK_DEFINEFUN TK_EXIT TK_GETASSERTIONS TK_GETASSIGNMENT TK_GETINFO TK_GETOPTION TK_GETPROOF TK_GETUNSATCORE TK_GETVALUE TK_GETMODEL TK_POP TK_PUSH TK_SETLOGIC TK_SETINFO TK_SETOPTION TK_THEORY TK_GETITPS TK_WRSTATE TK_RDSTATE TK_SIMPLIFY TK_WRFUNS TK_ECHO %token TK_NUM TK_SYM TK_QSYM TK_KEY TK_STR TK_DEC TK_HEX TK_BIN %token KW_SORTS KW_FUNS KW_SORTSDESCRIPTION KW_FUNSDESCRIPTION KW_DEFINITION KW_NOTES KW_THEORIES KW_EXTENSIONS KW_VALUES KW_PRINTSUCCESS KW_EXPANDDEFINITIONS KW_INTERACTIVEMODE KW_PRODUCEPROOFS KW_PRODUCEUNSATCORES KW_PRODUCEMODELS KW_PRODUCEASSIGNMENTS KW_REGULAROUTPUTCHANNEL KW_DIAGNOSTICOUTPUTCHANNEL KW_RANDOMSEED KW_VERBOSITY KW_ERRORBEHAVIOR KW_NAME KW_NAMED KW_AUTHORS KW_VERSION KW_STATUS KW_REASONUNKNOWN KW_ALLSTATISTICS %type TK_AS TK_DECIMAL TK_EXISTS TK_FORALL TK_LET TK_NUMERAL TK_PAR TK_STRING %type TK_ASSERT TK_CHECKSAT TK_DECLARESORT TK_DECLAREFUN TK_DECLARECONST TK_DEFINESORT TK_DEFINEFUN TK_EXIT TK_GETASSERTIONS TK_GETASSIGNMENT TK_GETINFO TK_GETOPTION TK_GETPROOF TK_GETUNSATCORE TK_GETVALUE TK_GETMODEL TK_POP TK_PUSH TK_SETLOGIC TK_SETINFO TK_SETOPTION TK_THEORY TK_GETITPS TK_WRSTATE TK_RDSTATE TK_SIMPLIFY TK_WRFUNS TK_ECHO %type TK_NUM TK_SYM TK_QSYM TK_KEY TK_STR TK_DEC TK_HEX TK_BIN %type KW_SORTS KW_FUNS KW_SORTSDESCRIPTION KW_FUNSDESCRIPTION KW_DEFINITION KW_NOTES KW_THEORIES KW_EXTENSIONS KW_VALUES KW_PRINTSUCCESS KW_EXPANDDEFINITIONS KW_INTERACTIVEMODE KW_PRODUCEPROOFS KW_PRODUCEUNSATCORES KW_PRODUCEMODELS KW_PRODUCEASSIGNMENTS KW_REGULAROUTPUTCHANNEL KW_DIAGNOSTICOUTPUTCHANNEL KW_RANDOMSEED KW_VERBOSITY KW_ERRORBEHAVIOR KW_NAME KW_NAMED KW_AUTHORS KW_VERSION KW_STATUS KW_REASONUNKNOWN KW_ALLSTATISTICS predef_key %type symbol identifier sort command attribute attribute_value s_expr spec_const qual_identifier var_binding sorted_var term const_val %type sort_list command_list s_expr_list numeral_list term_list var_binding_list attribute_list sorted_var_list symbol_list %type b_value option info_flag %start script %% script: command_list { ASTNode *n = new ASTNode(CMDL_T, strdup("main-script")); n->children = $1; context->insertRoot(n); }; symbol: TK_SYM { $$ = new ASTNode(SYM_T, $1); } | TK_QSYM { $$ = new ASTNode(QSYM_T, $1); } ; command_list: { $$ = new std::vector(); } | command_list command { (*$1).push_back($2); $$ = $1; } ; command: '(' TK_SETLOGIC symbol ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new std::vector(); $$->children->push_back($3); } | '(' TK_SETOPTION option ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new std::vector(); $$->children->push_back($3); } | '(' TK_SETINFO attribute ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new std::vector(); $$->children->push_back($3); } | '(' TK_DECLARESORT symbol TK_NUM ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new std::vector(); $$->children->push_back($3); $$->children->push_back(new ASTNode(NUM_T, $4)); } | '(' TK_DEFINESORT symbol '(' symbol_list ')' sort ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new std::vector(); $$->children->push_back($3); ASTNode* syml = new ASTNode(SYML_T, NULL); syml->children = $5; $$->children->push_back(syml); $$->children->push_back($7); } | '(' TK_DECLAREFUN symbol '(' sort_list ')' sort ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new std::vector(); $$->children->push_back($3); ASTNode* sortl = new ASTNode(SORTL_T, NULL); sortl->children = $5; $$->children->push_back(sortl); $$->children->push_back($7); } | '(' TK_DECLARECONST const_val sort ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new std::vector(); $$->children->push_back($3); ASTNode* sortl = new ASTNode(SORTL_T, NULL); sortl->children = new std::vector(); $$->children->push_back(sortl); $$->children->push_back($4); } | '(' TK_DEFINEFUN symbol '(' sorted_var_list ')' sort term ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new std::vector(); $$->children->push_back($3); ASTNode* svl = new ASTNode(SVL_T, NULL); svl->children = $5; $$->children->push_back(svl); $$->children->push_back($7); $$->children->push_back($8); } | '(' TK_PUSH TK_NUM ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new std::vector(); $$->children->push_back(new ASTNode(NUM_T, $3)); } | '(' TK_POP TK_NUM ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new std::vector(); $$->children->push_back(new ASTNode(NUM_T, $3)); } | '(' TK_ASSERT term ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new std::vector(); $$->children->push_back($3); } | '(' TK_CHECKSAT ')' { $$ = new ASTNode(CMD_T, $2); } | '(' TK_GETASSERTIONS ')' { $$ = new ASTNode(CMD_T, $2); } | '(' TK_GETPROOF ')' { $$ = new ASTNode(CMD_T, $2); } | '(' TK_GETITPS term_list ')' { $$ = new ASTNode(CMD_T, $2); $$->children = $3; } | '(' TK_WRSTATE TK_STR ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new std::vector(); $$->children->push_back(new ASTNode(UATTR_T, $3)); } | '(' TK_RDSTATE TK_STR ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new std::vector(); $$->children->push_back(new ASTNode(UATTR_T, $3)); } | '(' TK_WRFUNS TK_STR ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new std::vector(); $$->children->push_back(new ASTNode(UATTR_T, $3)); } | '(' TK_GETUNSATCORE ')' { $$ = new ASTNode(CMD_T, $2); } | '(' TK_GETVALUE '(' term term_list ')' ')' { $$ = new ASTNode(CMD_T, $2); $$->children = $5; $$->children->insert($$->children->begin(), $4); } | '(' TK_GETMODEL ')' { $$ = new ASTNode(CMD_T, $2); } | '(' TK_GETASSIGNMENT ')' { $$ = new ASTNode(CMD_T, $2); } | '(' TK_GETOPTION TK_KEY ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new std::vector(); $$->children->push_back(new ASTNode(UATTR_T, $3)); } | '(' TK_GETOPTION predef_key ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new std::vector(); $$->children->push_back(new ASTNode(PATTR_T, $3)); } | '(' TK_GETINFO info_flag ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new std::vector(); $$->children->push_back($3); } | '(' TK_SIMPLIFY ')' { $$ = new ASTNode(CMD_T, $2); } | '(' TK_EXIT ')' { $$ = new ASTNode(CMD_T, $2); } | '(' TK_ECHO TK_STR ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new std::vector(); $$->children->push_back(new ASTNode(UATTR_T, $3)); } ; attribute_list: { $$ = new std::vector(); } | attribute_list attribute { $1->push_back($2); $$ = $1; } ; attribute: TK_KEY { $$ = new ASTNode(UATTR_T, $1); } | TK_KEY attribute_value { $$ = new ASTNode(UATTR_T, $1); $$->children = new std::vector(); $$->children->push_back($2); } | predef_key { $$ = new ASTNode(PATTR_T, $1); } | predef_key attribute_value { $$ = new ASTNode(PATTR_T, $1); $$->children = new std::vector(); $$->children->push_back($2); } ; attribute_value: spec_const { $$ = new ASTNode(SPECC_T, NULL); $$->children = new std::vector(); $$->children->push_back($1); } | symbol { $$ = $1; } | '(' s_expr_list ')' { $$ = new ASTNode(SEXPRL_T, NULL); $$->children = $2; } ; identifier: symbol { $$ = $1; } | '(' '_' symbol numeral_list ')' { $$ = $3; $$->children = $4; } ; sort: identifier { $$ = $1; } | '(' identifier sort sort_list ')' { $$ = new ASTNode(LID_T, NULL); $$->children = $4; $$->children->insert($$->children->begin(), $3); $$->children->insert($$->children->begin(), $2); } ; sort_list: sort_list sort { $1->push_back($2); $$ = $1; } | { $$ = new std::vector(); } ; s_expr: spec_const { $$ = new ASTNode(SPECC_T, NULL); $$->children = new std::vector(); $$->children->push_back($1); } | symbol { $$ = $1; } | TK_KEY { $$ = new ASTNode(UATTR_T, $1); } | '(' s_expr_list ')' { $$ = new ASTNode(SEXPRL_T, NULL); $$->children = $2; } ; s_expr_list: { $$ = new std::vector(); } | s_expr_list s_expr { $1->push_back($2); $$ = $1; } ; spec_const: TK_NUM { $$ = new ASTNode(NUM_T, $1); } | TK_DEC { $$ = new ASTNode(DEC_T, $1); } | TK_HEX { $$ = new ASTNode(HEX_T, $1); } | TK_BIN { $$ = new ASTNode(BIN_T, $1); } | TK_STR { $$ = new ASTNode(STR_T, $1); } ; const_val: symbol { $$ = $1; } | spec_const { $$ = $1; } ; numeral_list: numeral_list TK_NUM { $1->push_back(new ASTNode(NUM_T, $2)); $$ = $1; } | TK_NUM { $$ = new std::vector(); $$->push_back(new ASTNode(NUM_T, $1)); } ; qual_identifier: identifier { $$ = $1; } | '(' TK_AS identifier sort ')' { $$ = new ASTNode(AS_T, NULL); $$->children = new std::vector(); $$->children->push_back($3); $$->children->push_back($4); } ; var_binding_list: { $$ = new std::vector(); } | var_binding_list var_binding { $1->push_back($2); $$ = $1; } ; var_binding: '(' symbol term ')' { $$ = new ASTNode(VARB_T, strdup($2->getValue())); delete $2; $$->children = new std::vector(); $$->children->push_back($3); } ; sorted_var_list: { $$ = new std::vector(); } | sorted_var_list sorted_var { $1->push_back($2); $$ = $1; } ; sorted_var: '(' symbol sort ')' { $$ = new ASTNode(SV_T, strdup($2->getValue())); delete $2; $$->children = new std::vector(); $$->children->push_back($3); } term_list: { $$ = new std::vector(); } | term_list term { $1->push_back($2); $$ = $1; } ; term: spec_const { $$ = new ASTNode(TERM_T, NULL); $$->children = new std::vector(); $$->children->push_back($1); } | qual_identifier { $$ = new ASTNode(QID_T, NULL); $$->children = new std::vector(); $$->children->push_back($1); } | '(' qual_identifier term term_list ')' { $$ = new ASTNode(LQID_T, NULL); $$->children = $4; $$->children->insert($$->children->begin(), $3); $$->children->insert($$->children->begin(), $2); } | '(' TK_LET '(' var_binding var_binding_list ')' term ')' { $$ = new ASTNode(LET_T, NULL); $$->children = new std::vector(); $5->insert($5->begin(), $4); ASTNode* vbl = new ASTNode(VARBL_T, NULL); vbl->children = $5; $$->children->push_back(vbl); $$->children->push_back($7); } | '(' TK_FORALL '(' sorted_var sorted_var_list ')' term ')' { $$ = new ASTNode(FORALL_T, NULL); $$->children = new std::vector(); $5->insert($5->begin(), $4); ASTNode* svl = new ASTNode(SVL_T, NULL); svl->children = $5; $$->children->push_back(svl); $$->children->push_back($7); } | '(' TK_EXISTS '(' sorted_var sorted_var_list ')' term ')' { $$ = new ASTNode(EXISTS_T, NULL); $$->children = new std::vector(); $5->insert($5->begin(), $4); ASTNode* svl = new ASTNode(SVL_T, NULL); svl->children = $5; $$->children->push_back(svl); $$->children->push_back($7); } | '(' '!' term attribute attribute_list ')' { $$ = new ASTNode(BANG_T, NULL); $$->children = new std::vector(); $$->children->push_back($3); ASTNode *atrs = new ASTNode(GATTRL_T, NULL); $5->insert($5->begin(), $4); atrs->children = $5; $$->children->push_back(atrs); } ; symbol_list: { $$ = new std::vector(); } | symbol_list symbol { $1->push_back($2); $$ = $1; } ; b_value: symbol { const char * str = $1->getValue(); if (strcmp(str, "true") == 0 or strcmp(str, "false") == 0) { $$ = new ASTNode(BOOL_T, strdup($1->getValue())); delete $1; } else { printf("Syntax error: expecting either 'true' or 'false', got '%s'\n", str); delete $1; YYERROR; } } ; option: KW_PRINTSUCCESS b_value { $$ = new ASTNode(OPTION_T, $1); $$->children = new std::vector(); $$->children->push_back($2); } | KW_EXPANDDEFINITIONS b_value { $$ = new ASTNode(OPTION_T, $1); $$->children = new std::vector(); $$->children->push_back($2); } | KW_INTERACTIVEMODE b_value { $$ = new ASTNode(OPTION_T, $1); $$->children = new std::vector(); $$->children->push_back($2); } | KW_PRODUCEPROOFS b_value { $$ = new ASTNode(OPTION_T, $1); $$->children = new std::vector(); $$->children->push_back($2); } | KW_PRODUCEUNSATCORES b_value { $$ = new ASTNode(OPTION_T, $1); $$->children = new std::vector(); $$->children->push_back($2); } | KW_PRODUCEMODELS b_value { $$ = new ASTNode(OPTION_T, $1); $$->children = new std::vector(); $$->children->push_back($2); } | KW_PRODUCEASSIGNMENTS b_value { $$ = new ASTNode(OPTION_T, $1); $$->children = new std::vector(); $$->children->push_back($2); } | KW_REGULAROUTPUTCHANNEL TK_STR { $$ = new ASTNode(OPTION_T, $1); $$->children = new std::vector(); $$->children->push_back(new ASTNode(STR_T, $2)); } | KW_DIAGNOSTICOUTPUTCHANNEL TK_STR { $$ = new ASTNode(OPTION_T, $1); $$->children = new std::vector(); $$->children->push_back(new ASTNode(STR_T, $2)); } | KW_RANDOMSEED TK_NUM { $$ = new ASTNode(OPTION_T, $1); $$->children = new std::vector(); $$->children->push_back(new ASTNode(NUM_T, $2)); } | KW_VERBOSITY TK_NUM { $$ = new ASTNode(OPTION_T, $1); $$->children = new std::vector(); $$->children->push_back(new ASTNode(NUM_T, $2)); } | attribute { $$ = new ASTNode(OPTION_T, NULL); $$->children = new std::vector(); $$->children->push_back($1); } ; predef_key: KW_SORTS { $$ = $1; } | KW_FUNS { $$ = $1; } | KW_SORTSDESCRIPTION { $$ = $1; } | KW_FUNSDESCRIPTION { $$ = $1; } | KW_DEFINITION { $$ = $1; } | KW_VALUES { $$ = $1; } | KW_NOTES { $$ = $1; } | KW_THEORIES { $$ = $1; } | KW_EXTENSIONS { $$ = $1; } | KW_PRINTSUCCESS { $$ = $1; } | KW_EXPANDDEFINITIONS { $$ = $1; } | KW_INTERACTIVEMODE { $$ = $1; } | KW_PRODUCEPROOFS { $$ = $1; } | KW_PRODUCEUNSATCORES { $$ = $1; } | KW_PRODUCEMODELS { $$ = $1; } | KW_PRODUCEASSIGNMENTS { $$ = $1; } | KW_REGULAROUTPUTCHANNEL { $$ = $1; } | KW_DIAGNOSTICOUTPUTCHANNEL { $$ = $1; } | KW_RANDOMSEED { $$ = $1; } | KW_VERBOSITY { $$ = $1; } | KW_ERRORBEHAVIOR { $$ = $1; } | KW_NAME { $$ = $1; } | KW_NAMED { $$ = $1; } | KW_AUTHORS { $$ = $1; } | KW_VERSION { $$ = $1; } | KW_STATUS { $$ = $1; } | KW_REASONUNKNOWN { $$ = $1; } | KW_ALLSTATISTICS { $$ = $1; } ; info_flag: KW_ERRORBEHAVIOR { $$ = new ASTNode(INFO_T, $1); } | KW_NAME { $$ = new ASTNode(INFO_T, $1); } | KW_AUTHORS { $$ = new ASTNode(INFO_T, $1); } | KW_VERSION { $$ = new ASTNode(INFO_T, $1); } | KW_STATUS { $$ = new ASTNode(INFO_T, $1); } | KW_REASONUNKNOWN { $$ = new ASTNode(INFO_T, $1); } | KW_ALLSTATISTICS { $$ = new ASTNode(INFO_T, $1); } | TK_KEY { $$ = new ASTNode(INFO_T, NULL); $$->children = new std::vector(); $$->children->push_back(new ASTNode(GATTR_T, $1)); } ; %% //======================================================================================= // Auxiliary Routines opensmt-2.5.2/src/proof/000077500000000000000000000000001445011647600151315ustar00rootroot00000000000000opensmt-2.5.2/src/proof/CMakeLists.txt000066400000000000000000000012061445011647600176700ustar00rootroot00000000000000add_library(proof OBJECT "") target_sources(proof PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/PG.h" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/PGBuild.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/PGCheck.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/PGHelp.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/PGHeuristics.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/PGMain.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/PGPrint.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/PGRules.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/PGTransformationAlgorithms.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/InterpolationContext.cc" ) install(FILES InterpolationContext.h DESTINATION ${INSTALL_HEADERS_DIR}) opensmt-2.5.2/src/proof/InterpolationContext.cc000066400000000000000000001162061445011647600216420ustar00rootroot00000000000000/* * Copyright (c) 2020-2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #include "InterpolationContext.h" #include "PG.h" #include "VerificationUtils.h" #include "BoolRewriting.h" class SingleInterpolationComputationContext { // Interpolation data for resolution proof element struct InterpolationNodeData { // NOTE labeling rules for AB variables // color a: bit 1, bit 0 // color b: bit 0, bit 1 // color ab: bit 1, bit 1 // missing: bit 0, bit 0 // This notation is consistent with coloring of inner nodes given by | of antecedents colorings ipartitions_t AB_vars_a_colored; ipartitions_t AB_vars_b_colored; PTRef partialInterpolant; InterpolationNodeData() : AB_vars_a_colored(0), AB_vars_b_colored(0), partialInterpolant(PTRef_Undef) {} inline void clearSharedVar(int varIndex) { clrbit(AB_vars_a_colored, varIndex); clrbit(AB_vars_b_colored, varIndex); } inline void resetLabeling() { AB_vars_a_colored = 0; AB_vars_b_colored = 0; } inline bool isColoredA(int i) const { return ((tstbit(AB_vars_a_colored, i) == 1) && (tstbit(AB_vars_b_colored, i) == 0)); } inline bool isColoredB(int i) const { return ((tstbit(AB_vars_a_colored, i) == 0) && (tstbit(AB_vars_b_colored, i) == 1)); } inline bool isColoredAB(int i) const { return ((tstbit(AB_vars_a_colored, i) == 1) && (tstbit(AB_vars_b_colored, i) == 1)); } inline void colorA(int i) { setbit(AB_vars_a_colored, i); clrbit(AB_vars_b_colored, i); } inline void colorB(int i) { setbit(AB_vars_b_colored, i); clrbit(AB_vars_a_colored, i); } inline void colorAB(int i) { setbit(AB_vars_a_colored, i); setbit(AB_vars_b_colored, i); } }; // NOTE class A has value -1, class B value -2, undetermined value -3, class AB has index bit from 0 onwards std::vector AB_vars_mapping; // Variables of class AB mapping to mpz integer bit index std::vector nodeData; Logic & logic; SMTConfig const & config; PartitionManager & pmanager; ProofGraph const & proofGraph; std::unique_ptr thandler; ipartitions_t const & A_mask; public: int getSharedVarIndex(Var v) const { assert(AB_vars_mapping[v] >= 0); return AB_vars_mapping[v]; } icolor_t getVarClassFromCache(Var v) const { assert((unsigned) v < AB_vars_mapping.size()); assert(AB_vars_mapping[v] >= -2); int c = AB_vars_mapping[v]; return c == -1 ? icolor_t::I_A : (c == -2 ? icolor_t::I_B : icolor_t::I_AB); } SingleInterpolationComputationContext( SMTConfig const & config, Theory & theory, TermMapper & termMapper, PartitionManager & pmanager, ProofGraph const & proof, ipartitions_t const & A_mask ); inline bool isColoredA(ProofNode const & n, Var v) const { return nodeData[n.getId()].isColoredA(getSharedVarIndex(v)); } inline bool isColoredB(ProofNode const & n, Var v) const { return nodeData[n.getId()].isColoredB(getSharedVarIndex(v)); } inline bool isColoredAB(ProofNode const & n, Var v) const { return nodeData[n.getId()].isColoredAB(getSharedVarIndex(v)); } inline void colorA(ProofNode & n, Var v) { nodeData[n.getId()].colorA(getSharedVarIndex(v)); } inline void colorB(ProofNode & n, Var v) { nodeData[n.getId()].colorB(getSharedVarIndex(v)); } inline void colorAB(ProofNode & n, Var v) { nodeData[n.getId()].colorAB(getSharedVarIndex(v)); } inline void resetLabeling(ProofNode const & n) { nodeData[n.getId()].resetLabeling(); } inline PTRef getPartialInterpolant(ProofNode const & n) { return nodeData[n.getId()].partialInterpolant; } inline void setPartialInterpolant(ProofNode const & n, PTRef itp) { nodeData[n.getId()].partialInterpolant = itp; } inline void updateColoringfromAnts(ProofNode const & n) { assert(not n.isLeaf()); auto & data = nodeData[n.getId()]; auto const & ant1Data = nodeData[n.getAnt1()->getId()]; auto const & ant2Data = nodeData[n.getAnt2()->getId()]; orbit(data.AB_vars_a_colored, ant1Data.AB_vars_a_colored, ant2Data.AB_vars_a_colored); orbit(data.AB_vars_b_colored, ant1Data.AB_vars_b_colored, ant2Data.AB_vars_b_colored); } inline void clearPivotColoring(ProofNode const & n) { assert(not n.isLeaf()); auto & data = nodeData[n.getId()]; data.clearSharedVar(getSharedVarIndex(n.getPivot())); } void initTSolver(); void backtrackTSolver(); bool assertLiteralsToTSolver(vec const &); ipartitions_t const & getVarPartition(Var v) const { return pmanager.getIPartitions(varToPTRef(v)); } inline Lit PTRefToLit(PTRef ref) const {return thandler->getTMap().getLit(ref);} inline Var PTRefToVar(PTRef ref) const { return thandler->getTMap().getVar(ref); } inline PTRef varToPTRef(Var v) const { return thandler->getTMap().varToPTRef(v); } icolor_t getSharedVarColorInNode(Var v, ProofNode const & node) const { if (isColoredA(node, v)) return icolor_t::I_A; else if (isColoredB(node, v)) return icolor_t::I_B; else if (isColoredAB(node, v)) return icolor_t::I_AB; throw OsmtInternalException("Variable " + std::to_string(v) + " has no color in clause " + std::to_string(node.getId())); } void labelLeaf(ProofNode & n, std::map const * PSFunction = nullptr); template void setLeafLabeling(ProofNode & node, TFun colorABVar); void setLeafMcMillanLabeling(ProofNode &); void setLeafPudlakLabeling(ProofNode &); void setLeafMcMillanPrimeLabeling(ProofNode &); void setLeafPSLabeling(ProofNode &, std::map const & PSFunction); void setLeafPSWLabeling(ProofNode &, std::map const & PSFunction); void setLeafPSSLabeling(ProofNode &, std::map const & PSFunction); PTRef getInterpolantForOriginalClause(ProofNode const & node, icolor_t clauseClass) const; std::vector getRestrictedNodeClause(ProofNode const & node, icolor_t wantedVarClass) const; icolor_t getVarClass(Var) const; icolor_t getClauseColor(CRef clause) const; std::unique_ptr> computePSFunction() const; PTRef computePartialInterpolantForOriginalClause(ProofNode const & n) const; PTRef computePartialInterpolantForTheoryClause(ProofNode const & n); PTRef computePartialInterpolantForSplitClause(ProofNode const & n) const; PTRef compInterpLabelingInner(ProofNode &); icolor_t getPivotColor(ProofNode const &); icolor_t getVarColor(ProofNode const & n, Var v) const; PTRef produceSingleInterpolant(); void checkInterAlgo() const; bool usingMcMillanInterpolation() const { return config.getBooleanInterpolationAlgorithm() == itp_alg_mcmillan; } bool usingPudlakInterpolation() const { return config.getBooleanInterpolationAlgorithm() == itp_alg_pudlak; } bool usingMcMillanPrimeInterpolation() const { return config.getBooleanInterpolationAlgorithm() == itp_alg_mcmillanp; } bool usingPSInterpolation() const { return config.getBooleanInterpolationAlgorithm() == itp_alg_ps; } bool usingPSWInterpolation() const { return config.getBooleanInterpolationAlgorithm() == itp_alg_psw; } bool usingPSSInterpolation() const { return config.getBooleanInterpolationAlgorithm() == itp_alg_pss; } int verbose() const { return config.verbosity(); } bool usingAlternativeInterpolant() const { return (config.proof_alternative_inter() == 1); } bool enabledInterpVerif() const { return (config.certify_inter() >= 1); } bool enabledPedInterpVerif() const { return (config.certify_inter() >= 2); } bool needProofStatistics() const { ItpAlgorithm ia = config.getBooleanInterpolationAlgorithm(); return ((ia == itp_alg_ps) or (ia == itp_alg_psw) or (ia == itp_alg_pss)); } bool verifyPartialInterpolant(ProofNode const &); bool verifyPartialInterpolantA(ProofNode const &); bool verifyPartialInterpolantB(ProofNode const &); }; /**************** HELPER METHODS ************************/ namespace { bool decideOnAlternativeInterpolation(PTRef I1, PTRef I2, Logic const & logic) { assert(I1 != PTRef_Undef); assert(I2 != PTRef_Undef); bool I1_is_true = (I1 == logic.getTerm_true()); bool I2_is_true = (I2 == logic.getTerm_true()); bool I1_is_false = (I1 == logic.getTerm_false()); bool I2_is_false = (I2 == logic.getTerm_false()); bool I1_is_none = (not I1_is_true and not I1_is_false); bool I2_is_none = (not I2_is_true and not I2_is_false); // For some combinations of I1, I2, the alternative interpolant // has a smaller size! // Standard (I1 \/ p ) /\ (I2 \/ ~p) // Alternative (I1 /\ ~p) \/ (I2 /\ p) if (I1_is_false and I2_is_none) return true; if (I1_is_none and I2_is_false) return true; if (I1_is_false and I2_is_false) return true; return false; } icolor_t getClass(ipartitions_t const & mask, ipartitions_t const & A_mask) { ipartitions_t B_mask = ~A_mask; // Check if belongs to A or B const bool in_A = ((mask & A_mask) != 0); const bool in_B = ((mask & B_mask) != 0); assert(in_A or in_B); icolor_t clause_color = icolor_t::I_UNDEF; if (in_A and not in_B) clause_color = icolor_t::I_A; else if (not in_A and in_B) clause_color = icolor_t::I_B; else if (in_A and in_B) clause_color = icolor_t::I_AB; else throw OsmtInternalException("No class could have been determined"); return clause_color; } } icolor_t SingleInterpolationComputationContext::getVarColor(ProofNode const & n, Var v) const { assert(n.isLeaf()); // In labeling, classes and colors are distinct icolor_t var_class = getVarClass(v); assert(var_class == icolor_t::I_A or var_class == icolor_t::I_B or var_class == icolor_t::I_AB); icolor_t var_color = var_class == icolor_t::I_B || var_class == icolor_t::I_A ? var_class : getSharedVarColorInNode(v, n); return var_color; } // Input: node, current interpolant partition masks for A and B // Output: returns node pivot color as a, b or ab // depending on the colors in the node antecedents icolor_t SingleInterpolationComputationContext::getPivotColor(ProofNode const & n) { assert(not n.isLeaf()); Var v = n.getPivot(); // In labeling, classes and colors are distinct icolor_t var_class = getVarClassFromCache(v); if (var_class != icolor_t::I_A and var_class != icolor_t::I_B and var_class != icolor_t::I_AB) { throw OsmtInternalException("Pivot " + std::to_string(v) + " has no class"); } // Update AB vars color vectors from antecedents updateColoringfromAnts(n); // Determine if variable A-local, B-local or AB-common icolor_t var_color = var_class; if (var_color != icolor_t::I_A and var_color != icolor_t::I_B) { assert(var_class == icolor_t::I_AB); var_color = getSharedVarColorInNode(v, n); // Remove pivot from resolvent if class AB clearPivotColoring(n); } if (proofGraph.isAssumedVar(v)) { // Small hack to deal with assumption literals in proof return icolor_t::I_S; } return var_color; } // Input: variable, current interpolant partition masks for A // Output: returns A-local , B-local or AB-common icolor_t SingleInterpolationComputationContext::getVarClass(Var v) const { if (proofGraph.isAssumedVar(v)) { return icolor_t::I_AB; } // MB: Does not matter for assumed literals const ipartitions_t & var_mask = getVarPartition(v); return getClass(var_mask, A_mask); } // Input: proof node, current interpolant partition masks for A // Output: returns A, B or AB icolor_t SingleInterpolationComputationContext::getClauseColor(CRef clause) const { auto const & clause_mask = pmanager.getClauseClassMask(clause); return getClass(clause_mask, A_mask); } std::unique_ptr> SingleInterpolationComputationContext::computePSFunction() const { auto labels = std::make_unique>(); std::map occ_a, occ_b; for (auto leafId : proofGraph.getLeaves()) { ProofNode * n = proofGraph.getNode(leafId); assert(n and n->isLeaf()); if (n->getType() != clause_type::CLA_ORIG) { continue; } icolor_t col = getClauseColor(n->getClauseRef()); for (Lit l : n->getClause()) { Var v = var(l); icolor_t vclass = getVarClassFromCache(v); if (vclass != icolor_t::I_AB) continue; if (col == icolor_t::I_A) { ++occ_a[v]; if (occ_b.find(v) == occ_b.end()) { occ_b[v] = 0; } } else if (col == icolor_t::I_B) { ++occ_b[v]; if (occ_a.find(v) == occ_a.end()) occ_a[v] = 0; } } } assert(occ_a.size() == occ_b.size()); for (auto const & entry : occ_a) { Var v = entry.first; int qtta = entry.second; int qttb = occ_b.find(v)->second; labels->insert({v, qtta > qttb ? icolor_t::I_A : icolor_t::I_B}); } return labels; } void SingleInterpolationComputationContext::checkInterAlgo() const { if ( ! ( usingMcMillanInterpolation() || usingPudlakInterpolation() || usingMcMillanPrimeInterpolation() || usingPSInterpolation() || usingPSWInterpolation() || usingPSSInterpolation())) throw OsmtApiException("Please choose 0/1/2/3/4/5 as values for itp_bool_algo"); if ( verbose() > 0 ) { std::cerr << "# Using "; if ( usingPudlakInterpolation() ) std::cerr << "Pudlak"; else if ( usingMcMillanInterpolation() ) std::cerr << "McMillan"; else if ( usingMcMillanPrimeInterpolation() ) std::cerr << "McMillan'"; else if ( usingPSInterpolation() ) std::cerr << "Proof-Sensitive"; else if ( usingPSWInterpolation() ) std::cerr << "Weak Proof-Sensitive"; else if ( usingPSSInterpolation() ) std::cerr << "Strong Proof-Sensitive"; std::cerr << " for propositional interpolation" << '\n'; } } void SingleInterpolationComputationContext::backtrackTSolver() { thandler->backtrack(-1); } bool SingleInterpolationComputationContext::assertLiteralsToTSolver(vec const & vec) { return thandler->assertLits(vec); } void SingleInterpolationComputationContext::initTSolver() { auto const & leaves_ids = proofGraph.getLeaves(); assert(not leaves_ids.empty()); for (auto id : leaves_ids) { ProofNode * node = proofGraph.getNode(id); assert(node); assert(isLeafClauseType(node->getType())); if (node->getType() != clause_type::CLA_THEORY) { continue; } const auto & clause = proofGraph.getNode(id)->getClause(); for (auto const & lit : clause) { Var v = var(lit); PTRef atom = this->varToPTRef(v); assert(logic.isTheoryTerm(atom)); thandler->declareAtom(atom); } } } bool SingleInterpolationComputationContext::verifyPartialInterpolant(ProofNode const & n) { if(verbose()) std::cout << "; Verifying partial interpolant" << '\n'; bool res = verifyPartialInterpolantA(n); if(!res) { assert(false); throw OsmtInternalException("Partial interpolant soundness does not hold for A"); } res = verifyPartialInterpolantB(n); if(!res) { assert(false); throw OsmtInternalException("Partial interpolant soundness does not hold for B"); } if(verbose()) std::cout << "; Partial interpolant is sound" << '\n'; return res; } bool SingleInterpolationComputationContext::verifyPartialInterpolantA(ProofNode const & n) { // Check A /\ ~(C|a,ab) -> I, i.e., A /\ ~(C|a,ab) /\ ~I unsat std::vector const & cl = n.getClause(); vec restricted_clause; for (Lit l : cl) { Var v = var(l); icolor_t var_class = getVarClass(v); assert(var_class == icolor_t::I_B || var_class == icolor_t::I_A || var_class == icolor_t::I_AB); icolor_t var_color = var_class == icolor_t::I_B || var_class == icolor_t::I_A ? var_class : getSharedVarColorInNode(v, n); if (var_color == icolor_t::I_A || var_color == icolor_t::I_AB) { PTRef ptaux = varToPTRef(v); if (sign(l)) { ptaux = logic.mkNot(ptaux); } restricted_clause.push(ptaux); } } PTRef cl_ptref = logic.mkNot(logic.mkOr(std::move(restricted_clause))); PTRef implicant = logic.mkAnd({pmanager.getPartition(A_mask, PartitionManager::part::A), cl_ptref}); bool res = VerificationUtils(logic).impliesInternal(implicant, getPartialInterpolant(n)); assert(res); return res; } bool SingleInterpolationComputationContext::verifyPartialInterpolantB(ProofNode const & n) { // Check B /\ ~(C|b,ab) -> ~I, i.e., B /\ ~(C|b,ab) /\ I unsat std::vector const & cl = n.getClause(); vec restricted_clause; for (Lit l : cl) { Var v = var(l); icolor_t var_class = getVarClass(v); assert(var_class == icolor_t::I_B || var_class == icolor_t::I_A || var_class == icolor_t::I_AB); icolor_t var_color = var_class == icolor_t::I_B || var_class == icolor_t::I_A ? var_class : getSharedVarColorInNode(v, n); if (var_color == icolor_t::I_B || var_color == icolor_t::I_AB) { PTRef ptaux = varToPTRef(v); if (sign(l)) { ptaux = logic.mkNot(ptaux); } restricted_clause.push(ptaux); } } PTRef cl_ptref = logic.mkNot(logic.mkOr(std::move(restricted_clause))); PTRef implicant = logic.mkAnd(pmanager.getPartition(A_mask, PartitionManager::part::B), cl_ptref); bool res = VerificationUtils(logic).impliesInternal(implicant, logic.mkNot(getPartialInterpolant(n))); assert(res); return res; } SingleInterpolationComputationContext::SingleInterpolationComputationContext( const SMTConfig & config, Theory & theory, TermMapper & termMapper, PartitionManager & pmanager, const ProofGraph & proof, const ipartitions_t & A_mask ) : logic(theory.getLogic()), config(config), pmanager(pmanager), proofGraph(proof), thandler(new THandler(theory, termMapper)), A_mask(A_mask) { auto const & vars = proof.getVariables(); std::size_t varCounts = (*std::max_element(vars.begin(), vars.end())) + 1; nodeData.resize(proof.getGraphSize()); AB_vars_mapping.resize(varCounts, -3); // NOTE class A has value -1, class B value -2, undetermined value -3, class AB has index bit from 0 onwards int AB_bit_index = 0; for (Var v: vars) { icolor_t v_class = this->getVarClass(v); if (v_class == icolor_t::I_A) { AB_vars_mapping[v] = -1; } else if (v_class == icolor_t::I_B) { AB_vars_mapping[v] = -2; } else if (v_class == icolor_t::I_AB) { AB_vars_mapping[v] = AB_bit_index; AB_bit_index++; } else throw OsmtInternalException("Error in computing variable colors"); } initTSolver(); } /**************** MAIN INTERPOLANTS GENERATION METHODS ************************/ PTRef SingleInterpolationComputationContext::produceSingleInterpolant() { // Check checkInterAlgo(); // Clause and partial interpolant ProofNode *n = nullptr; PTRef partial_interp = PTRef_Undef; // Vector for topological ordering std::vector DFSv = proofGraph.topolSortingTopDown(); size_t proof_size = DFSv.size(); if (verbose() > 0) std::cerr << "; Generating interpolant " << std::endl; auto PSFunction = needProofStatistics() ? computePSFunction() : nullptr; // Traverse proof and compute current interpolant for ( size_t i = 0 ; i < proof_size ; i++ ) { n = proofGraph.getNode(DFSv[i]); assert(n); // Generate partial interpolant for clause i if (n->isLeaf()) { if (!isLeafClauseType(n->getType())) throw OsmtInternalException("; Leaf node with non-leaf clause type"); labelLeaf(*n, PSFunction.get()); if (n->getType() == clause_type::CLA_ORIG) { partial_interp = computePartialInterpolantForOriginalClause(*n); } else if (n->getType() == clause_type::CLA_THEORY) { partial_interp = computePartialInterpolantForTheoryClause(*n); } else if (n->getType() == clause_type::CLA_SPLIT) { partial_interp = computePartialInterpolantForSplitClause(*n); } else { assert(n->getType() == clause_type::CLA_ASSUMPTION); // MB: Frame literals must be ignored when interpolating // This interpolant will be ignored eventually, any value would do setPartialInterpolant(*n, logic.getTerm_true()); continue; } assert ( partial_interp != PTRef_Undef ); setPartialInterpolant(*n, partial_interp); if (enabledPedInterpVerif()) { verifyPartialInterpolant(*n); } } else { // Inner node partial_interp = compInterpLabelingInner(*n); assert (partial_interp != PTRef_Undef); setPartialInterpolant(*n, partial_interp); } } PSFunction.release(); PTRef rootInterpolant = getPartialInterpolant(*proofGraph.getRoot()); assert(rootInterpolant != PTRef_Undef); // Last clause visited is the empty clause with total interpolant assert(partial_interp == rootInterpolant); if (verbose()) { //getComplexityInterpolant(partial_interp); int nbool, neq, nuf, nif; logic.collectStats(partial_interp, nbool, neq, nuf, nif); std::cerr << "; Number of boolean connectives: " << nbool << '\n'; std::cerr << "; Number of equalities: " << neq << '\n'; std::cerr << "; Number of uninterpreted functions: " << nuf << '\n'; std::cerr << "; Number of interpreted functions: " << nif << '\n'; } if (verbose() > 1) { std::cout << "; Interpolant:\n" << logic.printTerm(rootInterpolant) << '\n'; } return rootInterpolant; } /********** FULL LABELING BASED INTERPOLATION **********/ void SingleInterpolationComputationContext::labelLeaf(ProofNode & n, std::map const * PSFunction) { // Proof Sensitive if (usingPSInterpolation()) setLeafPSLabeling (n, *PSFunction); else if (usingPSWInterpolation()) setLeafPSWLabeling (n, *PSFunction); else if (usingPSSInterpolation()) setLeafPSSLabeling (n, *PSFunction); // McMillan's system else if ( usingMcMillanInterpolation( ) ) setLeafMcMillanLabeling ( n ); // Symmetric system else if ( usingPudlakInterpolation( ) ) setLeafPudlakLabeling ( n ); // McMillan's prime system else if ( usingMcMillanPrimeInterpolation( ) ) setLeafMcMillanPrimeLabeling ( n ); // Error else throw OsmtApiException("No interpolation algorithm chosen"); } std::vector SingleInterpolationComputationContext::getRestrictedNodeClause(ProofNode const & node, icolor_t wantedVarClass) const { std::vector restrictedClause; for (Lit l : node.getClause()) { if (proofGraph.isAssumedLiteral(~l)) { // ignore if the negation is assumed, it's as if this literal did not exist continue; } Var v = var(l); icolor_t var_class = getVarClassFromCache(v); assert(var_class == icolor_t::I_B or var_class == icolor_t::I_A or var_class == icolor_t::I_AB); icolor_t var_color = var_class == icolor_t::I_B or var_class == icolor_t::I_A ? var_class : getSharedVarColorInNode(v, node); if (var_color == wantedVarClass) restrictedClause.push_back(l); } return restrictedClause; } PTRef SingleInterpolationComputationContext::getInterpolantForOriginalClause(const ProofNode & node, icolor_t clauseClass) const { if (clauseClass != icolor_t::I_A and clauseClass != icolor_t::I_B) { throw OsmtInternalException("Unexpected class"); } auto otherClass = clauseClass == icolor_t::I_A ? icolor_t::I_B : icolor_t::I_A; bool clauseIsA = clauseClass == icolor_t::I_A; std::vector restricted_clause = getRestrictedNodeClause(node, otherClass); if (restricted_clause.empty()) { return clauseIsA ? logic.getTerm_false() : logic.getTerm_true(); } vec args; args.capacity(restricted_clause.size()); for (Lit l : restricted_clause) { PTRef litTerm = varToPTRef(var(l)); if (sign(l) == clauseIsA) litTerm = logic.mkNot(litTerm); args.push(litTerm); } return clauseClass == icolor_t::I_A ? logic.mkOr(std::move(args)) : logic.mkAnd(std::move(args)); } // Input: leaf clause, current interpolant partition masks for A and B // Output: Labeling-based partial interpolant for the clause PTRef SingleInterpolationComputationContext::computePartialInterpolantForOriginalClause(ProofNode const & n) const { assert(n.getType() == clause_type::CLA_ORIG); icolor_t clause_color = getClauseColor(n.getClauseRef()); if (clause_color == icolor_t::I_AB) { // Think of a heuristic for choosing the partition? clause_color = icolor_t::I_A; } // Original leaves can be only of class A or B assert(clause_color == icolor_t::I_A || clause_color == icolor_t::I_B); PTRef partial_interp = getInterpolantForOriginalClause(n, clause_color); assert (partial_interp != PTRef_Undef); return partial_interp; } PTRef SingleInterpolationComputationContext::computePartialInterpolantForTheoryClause(ProofNode const & n) { backtrackTSolver(); vec newvec; std::vector const & oldvec = n.getClause(); for (Lit l : oldvec) { newvec.push(~l); } bool satisfiable = this->assertLiteralsToTSolver(newvec); if (satisfiable) { TRes tres = thandler->check(true); satisfiable = (tres != TRes::UNSAT); } if (satisfiable) { assert(false); throw OsmtInternalException("Asserting negation of theory clause did not result in conflict in theory solver!"); } THandler::ItpColorMap ptref2label; for (Lit l : oldvec) { ptref2label.insert({varToPTRef(var(l)), getVarColor(n, var(l))}); } PTRef interpolant = thandler->getInterpolant(A_mask, &ptref2label, pmanager); backtrackTSolver(); return interpolant; } /* * We treat split clauses as original clauses, but we need to determine the color of the clause. * Currently we only support binary split clauses from LIA, in this case we know the split is on an expression * already present in the original formula (=> no mixed literals). Thus, we take the color of the clause as the common * color of both literals. If one literal is colored A and the other one B, then the split expression is actually common * to both A and B. Thus we can consider the clause as A or as B and the interpolant condition on common variables * will be preserved. */ PTRef SingleInterpolationComputationContext::computePartialInterpolantForSplitClause(const ProofNode & n) const { auto const & clause = n.getClause(); assert(clause.size() == 2); // only binary splits at the moment auto clauseColor = getVarClass(var(clause[0])) & getVarClass(var(clause[1])); if (clauseColor == icolor_t::I_AB) { clauseColor = icolor_t::I_A; // MB: Arbitrary choice, same as with original AB-clauses } else if (clauseColor == icolor_t::I_UNDEF) { clauseColor = icolor_t::I_A; // MB: Split expression is common, we treat the clause as AB-clause } if (clauseColor != icolor_t::I_A and clauseColor != icolor_t::I_B) { assert(false); throw OsmtInternalException("Error in coloring split clause!"); } // Compute interpolant the same way as for original clause return getInterpolantForOriginalClause(n, clauseColor); } // Input: inner clause, current interpolant partition masks for A and B // Output: Labeling-based partial interpolant for the clause PTRef SingleInterpolationComputationContext::compInterpLabelingInner(ProofNode & n) { PTRef partial_interp_ant1 = getPartialInterpolant(*n.getAnt1()); PTRef partial_interp_ant2 = getPartialInterpolant(*n.getAnt2()); assert (partial_interp_ant1 != PTRef_Undef); assert (partial_interp_ant2 != PTRef_Undef); // Determine color pivot, depending on its color in the two antecedents icolor_t pivot_color = getPivotColor(n); if (pivot_color == icolor_t::I_S) { Var v = n.getPivot(); Lit pos = mkLit(v); if (proofGraph.isAssumedLiteral(pos)) { // Positive occurence of assumed literal is in first parent => return interpolant from second return partial_interp_ant2; } else { assert(proofGraph.isAssumedLiteral(~pos)); return partial_interp_ant1; } } // Pivot colored a -> interpolant = interpolant of ant1 OR interpolant of ant2 if (pivot_color == icolor_t::I_A) { return logic.mkOr(partial_interp_ant1, partial_interp_ant2); } // Pivot colored b -> interpolant = interpolant of ant1 AND interpolant of ant2 else if (pivot_color == icolor_t::I_B) { return logic.mkAnd(partial_interp_ant1, partial_interp_ant2); } // Pivot colored ab -> interpolant = (pivot OR interpolant of ant1) AND ((NOT pivot) OR interpolant of ant2) // Alternative interpolant = ((NOT pivot) AND interpolant of ant1) OR (pivot AND interpolant of ant2) else if (pivot_color == icolor_t::I_AB) { // Find pivot occurrences in ant1 and ant2 and create enodes Var piv_ = n.getPivot(); PTRef piv = varToPTRef(piv_); bool choose_alternative = usingAlternativeInterpolant() ? decideOnAlternativeInterpolation(partial_interp_ant1, partial_interp_ant2, logic) : false; if (choose_alternative) { // Equivalent formula (I_1 /\ ~p) \/ (I_2 /\ p) PTRef and_1 = logic.mkAnd(partial_interp_ant1, logic.mkNot(piv)); PTRef and_2 = logic.mkAnd(partial_interp_ant2, piv); return logic.mkOr(and_1, and_2); } else { // Standard interpolation (I_1 \/ p) /\ (I_2 \/ ~p) PTRef or_1 = logic.mkOr(partial_interp_ant1, piv); PTRef or_2 = logic.mkOr(partial_interp_ant2, logic.mkNot(piv)); return logic.mkAnd(or_1, or_2); } } else throw OsmtInternalException("Pivot has no color"); } template void SingleInterpolationComputationContext::setLeafLabeling(ProofNode & node, TFun colorABVar) { resetLabeling(node); std::vector const & cl = node.getClause(); for (Lit l : cl) { Var v = var (l); icolor_t var_class = getVarClassFromCache(v); if (var_class == icolor_t::I_AB) { colorABVar(node, v); } else if ( var_class != icolor_t::I_A and var_class != icolor_t::I_B ) { OsmtInternalException("Variable has no class"); } } } void SingleInterpolationComputationContext::setLeafPSLabeling (ProofNode & n, std::map const & labels) { setLeafLabeling(n, [&](ProofNode & node, Var v) { auto it = labels.find(v); if (it->second == icolor_t::I_A) colorA(node, v); else colorB(node, v); }); } void SingleInterpolationComputationContext::setLeafPSWLabeling(ProofNode & n, std::map const & labels) { setLeafLabeling(n, [&](ProofNode & node, Var v) { auto it = labels.find(v); if (it->second == icolor_t::I_A) colorA(node, v); else colorAB(node, v); }); } void SingleInterpolationComputationContext::setLeafPSSLabeling(ProofNode & n, std::map const & labels) { setLeafLabeling(n, [&](ProofNode & node, Var v) { auto it = labels.find(v); if (it->second == icolor_t::I_A) colorAB(node, v); else colorB(node, v); }); } void SingleInterpolationComputationContext::setLeafPudlakLabeling(ProofNode & n) { setLeafLabeling(n, [&](ProofNode & node, Var v) { colorAB(node, v); }); } void SingleInterpolationComputationContext::setLeafMcMillanLabeling(ProofNode & n) { setLeafLabeling(n, [&](ProofNode & node, Var v) { colorB(node, v); }); } void SingleInterpolationComputationContext::setLeafMcMillanPrimeLabeling(ProofNode & n) { setLeafLabeling(n, [&](ProofNode & node, Var v) { colorA(node, v); }); } /************************ INTERPOLATION CONTEXT ************************************************************/ InterpolationContext::InterpolationContext(SMTConfig & c, Theory & th, TermMapper & termMapper, Proof const & proof, PartitionManager & pmanager) : config(c), theory(th), termMapper(termMapper), logic(th.getLogic()), pmanager(pmanager), proof_graph{new ProofGraph(c, th.getLogic(), termMapper, proof)} { ensureNoLiteralsWithoutPartition(); if (c.proof_reduce()) { reduceProofGraph(); } if (c.proof_interpolant_cnf() > 0) { // Proof restructuring for generation of interpolants in CNF transformProofForCNFInterpolants(); } } InterpolationContext::~InterpolationContext() = default; void InterpolationContext::printProofDotty() { assert(proof_graph); proof_graph->printProofGraph(); } void InterpolationContext::getSingleInterpolant(vec & interpolants, const ipartitions_t & A_mask) { assert(proof_graph); PTRef itp = SingleInterpolationComputationContext(config, theory, termMapper, pmanager, *proof_graph, A_mask).produceSingleInterpolant(); if (enabledInterpVerif()) { bool sound = verifyInterpolant(itp, A_mask); assert(sound); if (verbose()) { if (sound) std::cout << "; Final interpolant is sound" << '\n'; else std::cout << "; Final interpolant is NOT sound" << '\n'; } } if (config.simplify_inter() > 0) { itp = simplifyInterpolant(itp); } interpolants.push(itp); } void InterpolationContext::getSingleInterpolant(std::vector & interpolants, const ipartitions_t & A_mask) { vec itps; getSingleInterpolant(itps, A_mask); for (int i = 0; i < itps.size(); i++) interpolants.push_back(itps[i]); } bool InterpolationContext::getPathInterpolants(vec & interpolants, const std::vector & A_masks) { assert(proof_graph); bool propertySatisfied = true; // check that masks are subset of each other assert(std::mismatch(A_masks.begin() + 1, A_masks.end(), A_masks.begin(), [](auto const & next, auto const & previous){ return (previous & next) == previous; }).first == A_masks.end()); for (unsigned i = 0; i < A_masks.size(); ++i) { getSingleInterpolant(interpolants, A_masks[i]); if (i > 0 and enabledInterpVerif()) { PTRef previous_itp = interpolants[interpolants.size() - 2]; PTRef next_itp = interpolants[interpolants.size() - 1]; PTRef movedPartitions = logic.mkAnd(pmanager.getPartitions(A_masks[i] ^ A_masks[i - 1])); propertySatisfied &= VerificationUtils(logic).impliesInternal(logic.mkAnd(previous_itp, movedPartitions), next_itp); if (not propertySatisfied) { std::cerr << "; Path interpolation does not hold for:\n" << "First interpolant: " << logic.printTerm(previous_itp) << '\n' << "Moved partitions: " << logic.printTerm(movedPartitions) << '\n' << "Second interpolant: " << logic.printTerm(next_itp) << '\n'; } } } assert(propertySatisfied); return propertySatisfied; } void InterpolationContext::reduceProofGraph() { assert(proof_graph); proof_graph->transfProofForReduction(); } void InterpolationContext::transformProofForCNFInterpolants() { throw std::logic_error("Not supported at the moment"); assert(proof_graph); if (usingMcMillanInterpolation()) { proof_graph->transfProofForCNFInterpolants([](Var) { return icolor_t::I_UNDEF; }); // FIXME: this requires partition mask and can be done only for single interpolant computation } else { std::cerr << "; Warning!\n" << "; Please set McMillan interpolation algorithm to generate interpolants in CNF"; } } bool InterpolationContext::verifyInterpolant(PTRef itp, const ipartitions_t & A_mask) const { PTRef partA = pmanager.getPartition(A_mask, PartitionManager::part::A); PTRef partB = pmanager.getPartition(A_mask, PartitionManager::part::B); bool sound = VerificationUtils(logic).verifyInterpolantInternal(partA, partB, itp); return sound; } PTRef InterpolationContext::simplifyInterpolant(PTRef itp) const { const bool cannotSimplify = not logic.isBooleanOperator(itp) or logic.isNot(itp); if (cannotSimplify) { return itp; } auto simplificationLevel = config.simplify_inter(); if(simplificationLevel == 4) { itp = ::rewriteMaxArityAggresive(logic, itp); itp = ::simplifyUnderAssignment_Aggressive(itp, logic); } else { if (simplificationLevel > 0) { if (verbose() > 1) { std::cout << "Itp before rewriting max arity: \n" << logic.printTerm(itp) << "\n\n"; } itp = ::rewriteMaxArityClassic(logic, itp); } if (simplificationLevel == 2) { if (verbose() > 1) { std::cout << "Itp before aggressive simplifying: \n" << logic.printTerm(itp) << "\n\n"; } itp = ::simplifyUnderAssignment(logic, itp); } if (simplificationLevel == 3) { if (verbose() > 1) { std::cout << "Itp before aggressive simplifying: \n" << logic.printTerm(itp) << "\n\n"; } itp = ::simplifyUnderAssignment_Aggressive(itp, logic); } } return itp; } void InterpolationContext::ensureNoLiteralsWithoutPartition() { std::vector noPartitionVars; for (Var v : proof_graph->getVariables()) { auto const& part = pmanager.getIPartitions(termMapper.varToPTRef(v)); if(part == 0 && not proof_graph->isAssumedVar(v)) { PTRef term = termMapper.varToPTRef(v); assert(this->logic.isTheoryTerm(term)); auto allowedPartitions = pmanager.computeAllowedPartitions(term); if (allowedPartitions != 0) { // MB: Update the partition information pmanager.addIPartitions(term, allowedPartitions); } else { noPartitionVars.push_back(v); } } } if (!noPartitionVars.empty()) { proof_graph->eliminateNoPartitionTheoryVars(noPartitionVars); } } opensmt-2.5.2/src/proof/InterpolationContext.h000066400000000000000000000044341445011647600215030ustar00rootroot00000000000000/* * Copyright (c) 2020-2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #ifndef OPENSMT_INTERPOLATIONCONTEXT_H #define OPENSMT_INTERPOLATIONCONTEXT_H #include #include "Theory.h" // forward declaration class Proof; class ProofGraph; class InterpolationContext { SMTConfig & config; Theory & theory; TermMapper & termMapper; Logic & logic; PartitionManager & pmanager; std::unique_ptr proof_graph; public: InterpolationContext(SMTConfig & c, Theory & th, TermMapper & termMapper, Proof const & t, PartitionManager & pmanager); ~InterpolationContext(); void printProofDotty(); // Create interpolants with each A consisting of the specified partitions void getInterpolants(const std::vector > & partitions, vec & interpolants); void getSingleInterpolant(vec & interpolants, const ipartitions_t & A_mask); void getSingleInterpolant(std::vector& interpolants, const ipartitions_t& A_mask); bool getPathInterpolants(vec & interpolants, const std::vector & A_masks); private: void reduceProofGraph(); void transformProofForCNFInterpolants(); bool verifyInterpolant(PTRef itp, ipartitions_t const & A_mask) const; PTRef simplifyInterpolant(PTRef itp) const; void ensureNoLiteralsWithoutPartition(); /***** CONFIGURATION ****/ int verbose() const { return config.verbosity(); } bool usingMcMillanInterpolation() const { return config.getBooleanInterpolationAlgorithm() == itp_alg_mcmillan; } bool usingPudlakInterpolation() const { return config.getBooleanInterpolationAlgorithm() == itp_alg_pudlak; } bool usingMcMillanPrimeInterpolation() const { return config.getBooleanInterpolationAlgorithm() == itp_alg_mcmillanp; } bool usingPSInterpolation() const { return config.getBooleanInterpolationAlgorithm() == itp_alg_ps; } bool usingPSWInterpolation() const { return config.getBooleanInterpolationAlgorithm() == itp_alg_psw; } bool usingPSSInterpolation() const { return config.getBooleanInterpolationAlgorithm() == itp_alg_pss; } bool enabledInterpVerif() const { return (config.certify_inter() >= 1); } }; #endif //OPENSMT_INTERPOLATIONCONTEXT_H opensmt-2.5.2/src/proof/PG.h000077500000000000000000000413641445011647600156230ustar00rootroot00000000000000/********************************************************************* Author: Simone Fulvio Rollini Periplo -- Copyright (C) 2013, Simone Fulvio Rollini Periplo is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. Periplo 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Periplo. If not, see . *********************************************************************/ #ifndef PROOFGRAPH_H #define PROOFGRAPH_H #include "Proof.h" #include "PTRef.h" #include "Theory.h" #include "THandler.h" #include "OsmtInternalException.h" #include #include #include #include using namespace opensmt; class Proof; class Logic; struct SMTConfig; typedef unsigned clauseid_t; // Types of rules enum rul_type { rA1 , rA2 , rA2u , rB2 , rB3 , rB1 , rB2prime , rA1B , rA2B , rA1prime , rNO }; inline bool isSwapRule (rul_type rt) { return rt==rA1 || rt==rA1B || rt==rA1prime || rt==rA2 || rt==rA2B || rt==rA2u || rt==rB2; } inline bool isCutRule (rul_type rt) { return rt==rB1 || rt==rB2prime || rt==rB3; } // Rules applicability info // Five nodes context plus type of applicable rule class RuleContext { public: RuleContext ( ) : type( rNO ) , cv1 ( -1 ) , cv2 ( -1 ) , cw ( -1 ) , cv3 ( -1 ) , cv ( -1 ) { } ~RuleContext ( ) { } inline void reset( ) { type = rNO; cv1 = -1; cv2 = -1; cw = -1; cv3 = -1; cv = -1; } inline bool enabled() const { return (type!=rNO); } inline bool disabled() const { return (type==rNO); } inline rul_type getType() const { return type; } inline clauseid_t getW() const { return cw; } inline clauseid_t getV1() const { return cv1; } inline clauseid_t getV2() const { return cv2; } inline clauseid_t getV3() const { return cv3; } inline clauseid_t getV() const { return cv; } rul_type type; clauseid_t cv1; clauseid_t cv2; clauseid_t cw; clauseid_t cv3; clauseid_t cv; friend std::ostream& operator<< (std::ostream &out, RuleContext &ra); }; // Resolution proof graph element struct ProofNode { ProofNode () : clause (nullptr) , clause_ref (CRef_Undef) , pivot (-1) , ant1 (nullptr) , ant2 (nullptr) , resolvents () { } ~ProofNode ( ) { delete clause; } // // Auxiliary // inline void resetClause() { delete clause; clause = NULL; } void setClauseRef(CRef cref) { clause_ref = cref; } CRef getClauseRef() const { return clause_ref; } void initClause(Clause& cla) { assert(clause == NULL); clause = new std::vector(cla.size()); for(size_t k = 0; k < cla.size(); ++k) (*clause)[k] = cla[k]; } void initClause(std::vector& cla) { assert(clause == NULL); clause = new std::vector(cla.size()); for(size_t k = 0; k < cla.size(); ++k) (*clause)[k] = cla[k]; } void setClause(std::vector& cla) { assert(clause); clause->resize(cla.size()); for(size_t k = 0; k < cla.size(); ++k) (*clause)[k] = cla[k]; } void initClause() { assert(clause == NULL); clause = new std::vector; } // // Getty methods // inline clauseid_t getId ( ) const { return id; } inline std::vector & getClause ( ) { assert(clause); return *clause; } inline std::vector const & getClause ( ) const { assert(clause); return *clause; } inline std::vector const * getPClause ( ) const { return clause; } inline size_t getClauseSize ( ) const { return clause->size( ); } inline Var getPivot ( ) const { return pivot; } inline ProofNode * getAnt1 ( ) const { return ant1; } inline ProofNode * getAnt2 ( ) const { return ant2; } inline clause_type getType ( ) const { return type; } unsigned getNumResolvents ( ) const { return resolvents.size(); } std::set& getResolvents ( ) { return resolvents; } // // Setty methods // inline void setId ( clauseid_t new_id ) { id = new_id; } inline void setPivot ( Var new_pivot ) { pivot = new_pivot; } inline void setAnt1 ( ProofNode * a1 ) { ant1 = a1; } inline void setAnt2 ( ProofNode * a2 ) { ant2 = a2; } inline void setType ( clause_type new_type ) { type = new_type; } void addRes ( clauseid_t id ) { resolvents.insert( id ); } void remRes ( clauseid_t id ) { resolvents.erase( id ); } // // Test methods // inline bool isLeaf() const { assert((ant1 and ant2 ) or (not ant1 and not ant2)); return not ant1; } // 0 if positive, 1 if negative, -1 if not found short hasOccurrenceBin(Var) const; // true if positive occurrence pivot is in first antecedent bool checkPolarityAnt(); private: clauseid_t id; // id std::vector* clause; // Clause CRef clause_ref; Var pivot; // Non-leaf node pivot ProofNode * ant1; // Edges to antecedents ProofNode * ant2; // Edges to antecedents std::set resolvents; // Resolvents clause_type type; // Node type }; class ProofGraph { public: ProofGraph ( SMTConfig & c , Logic & logic , TermMapper const & termMapper , Proof const & proof ) : config ( c ) , logic_ ( logic ) , termMapper(termMapper) { mpz_init(visited_1); mpz_init(visited_2); buildProofGraph(proof); } ~ProofGraph() { mpz_clear(visited_1); mpz_clear(visited_2); for(size_t i=0;i= 1); } bool enabledPushDownUnits() { return (config.proof_push_units() >=1); } bool enabledTransfTraversals() { return (config.proof_transf_trav() >= 1); } bool enabledStructuralHashing() { return (config.proof_struct_hash() >= 1); } // Inverts the normal order Hashing + RecyclePivots bool switchToRPHashing() { return (config.proof_switch_to_rp_hash >= 1);} inline bool additionalRandomization ( ) { return ( config.proof_random_context_analysis == 1 ); } // // Build et al. // void emptyProofGraph (); // Empties all clauses besides leaves void fillProofGraph (); // Explicitly compute all clauses int cleanProofGraph ( ); // Removes proof leftovers void removeNode ( clauseid_t ); // Remove node unsigned removeTree ( clauseid_t ); // Remove useless subproof void normalizeAntecedentOrder (); // Make sure ant1 has positive occ pivot void printProofGraph (); // Returns id of new node clauseid_t dupliNode ( RuleContext& ); // Duplicates w in a context, assign to w only v as child // // Check et al. // void checkClause ( clauseid_t ); // Checks the proof structure; if flag is true, also checks correctness of clause derivations void checkProof ( bool check_clauses ); void checkClauseSorting ( clauseid_t ); // // Auxiliary // inline size_t getGraphSize ( ) const { return graph.size( ); } bool isSetVisited1 ( clauseid_t id ) const { return mpz_tstbit(visited_1, id); } bool isSetVisited2 ( clauseid_t id ) const { return mpz_tstbit(visited_2, id); } void setVisited1 ( clauseid_t id ) const { mpz_setbit(visited_1, id); } void setVisited2 ( clauseid_t id ) const { mpz_setbit(visited_2, id); } void resetVisited1 ( ) const { mpz_set_ui(visited_1,0); } void resetVisited2 ( ) const { mpz_set_ui(visited_2,0); } bool isResetVisited1 ( ) const { return mpz_cmp_ui(visited_1, 0) == 0; } bool isResetVisited2 ( ) const { return mpz_cmp_ui(visited_2, 0) == 0; } unsigned getMaxIdVar ( ) { return max_id_variable; } void getGraphInfo ( ); std::vector topolSortingTopDown() const; std::vector topolSortingBotUp() const; std::set const & getLeaves() const { return leaves_ids; }; std::set const & getVariables() const { return proof_variables; } void printClause ( ProofNode * ); void printClause ( ProofNode *, std::ostream & ); inline ProofNode* getNode ( clauseid_t id ) const { assert(id < graph.size()); return graph[id]; } static bool mergeClauses (std::vector const &, std::vector const &, std::vector&, Var); inline bool isRoot ( ProofNode* n ) const { assert(n); return( n->getId() == root ); } inline ProofNode* getRoot ( ) const { assert( root handleRules); void proofPostStructuralHashing(); double recyclePivotsIter(); void recycleUnits(); RuleContext getRuleContext (clauseid_t, clauseid_t); // In case of A1 rule, return id of node added clauseid_t ruleApply (RuleContext&); clauseid_t applyRuleA1 (RuleContext&); void applyRuleA1Prime (RuleContext&); void applyRuleA2 (RuleContext&); void applyRuleB1 (RuleContext&); void applyRuleB2 (RuleContext&); void applyRuleB2Prime (RuleContext&); void applyRuleB3 (RuleContext&); void printRuleApplicationStatus (); void transfProofForReduction (); void transfProofForCNFInterpolants(std::function getVarClass); double doReduction (double); // Reduce the proof ApplicationResult handleRuleApplicationForReduction(RuleContext & ra1, RuleContext & ra2); bool allowSwapRuleForReduction(RuleContext& ); bool allowCutRuleForReduction( RuleContext& ); // Push unit clauses down in the proof ApplicationResult handleRuleApplicationForUnitsPushingDown(RuleContext & ra1, RuleContext & ra2); bool allowSwapRuleForUnitsPushingDown(RuleContext&); // Push predicates in the proof ApplicationResult handleRuleApplicationForPredicatePushing(RuleContext & ra1, RuleContext & ra2); bool allowSwapRuleForPredicatePushingUp( RuleContext&,Var ); bool allowSwapRuleForPredicatePushingDown( RuleContext&,Var ); bool allowCutRuleForPredicatePushing( RuleContext&,Var ); inline void setPredicateToPush(Var p){ pred_to_push = p; } // Strengthen/weaken interpolants by applying A2 rule locally ApplicationResult handleRuleApplicationForStrongerWeakerInterpolant(RuleContext & ra1, RuleContext & ra2, std::function allowSwap); bool allowSwapRuleForStrongerWeakerInterpolant(RuleContext & ra, std::function getVarClass, bool restructureForStronger); // Produce interpolants in CNF using McMillan algorithm - partial CNFization since no duplications allowed! // See allowSwapRuleForCNFinterpolant ApplicationResult handleRuleApplicationForCNFinterpolant(RuleContext & ra1, RuleContext & ra2, std::function allowSwap); bool allowSwapRuleForCNFinterpolant(RuleContext& ra, std::function); inline bool isAssumedLiteral(Lit l) const { return std::find(assumedLiterals.begin(), assumedLiterals.end(), l) != assumedLiterals.end(); } inline bool isAssumedVar(Var v) const { return isAssumedLiteral(mkLit(v, true)) or isAssumedLiteral(mkLit(v, false)); } void eliminateNoPartitionTheoryVars(std::vector const & noParititionTheoryVars); private: void buildProofGraph(Proof const & proof); ProofNode * createProofNodeFor(CRef cref, clause_type _ctype, Proof const & proof); // Helper method for building the proof graph inline void addLeaf(clauseid_t id) { leaves_ids.insert(id); } inline void removeLeaf(clauseid_t id) { leaves_ids.erase(id); } void addDefaultAssumedLiterals(std::vector && assumedLiteralsFromDerivations); void liftVarsToLeaves(std::vector const & vars); void replaceSubproofsWithNoPartitionTheoryVars(std::vector const & vars); void recyclePivotsIter_RecyclePhase(); //NOTE added for experimentation Var pred_to_push; SMTConfig & config; Logic & logic_; TermMapper const & termMapper; std::vector graph {}; double building_time; // Time spent building graph clauseid_t root; // Proof root std::set leaves_ids; // Proof leaves, for top-down visits std::set< Var > proof_variables; // Variables actually present in the proof unsigned max_id_variable; // Highest value for a variable std::vector assumedLiterals; // Info on graph dimension int num_nodes; int num_edges; int num_unary; int num_leaves; // Info on clauses double av_cla_size; double var_cla_size; int max_cla_size; // Info on rules application unsigned A1; unsigned A1prime; unsigned A1B; unsigned A2; unsigned A2B; unsigned A2U; unsigned B1; unsigned B2prime; unsigned B2; unsigned B3; unsigned duplications; unsigned swap_ties; // Global visit vectors mutable mpz_t visited_1; mutable mpz_t visited_2; }; #endif opensmt-2.5.2/src/proof/PGBuild.cc000066400000000000000000000473601445011647600167400ustar00rootroot00000000000000/********************************************************************* Author: Simone Fulvio Rollini Periplo -- Copyright (C) 2013, Simone Fulvio Rollini Periplo is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. Periplo 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Periplo. If not, see . *********************************************************************/ #include "PG.h" #include "SystemQueries.h" #include "OsmtInternalException.h" #include "ReportUtils.h" #include std::ostream& operator<< (std::ostream &out, RuleContext &ra) { out << "Context: v1(" << ra.getV1() << ") v2(" << ra.getV2() << ") w(" << ra.getW() << ") v3(" << ra.getV3() << ") v(" << ra.getV() << ")"; return out; } namespace{ struct ProofBuildingStatistics { unsigned num_leaf = 0; unsigned num_theory = 0; unsigned num_derived = 0; unsigned num_learnt = 0; unsigned num_assump = 0; unsigned num_split = 0; void recordNewClause(clause_type typ) { switch(typ) { case clause_type::CLA_ORIG: ++num_leaf; break; case clause_type::CLA_THEORY: ++num_theory; break; case clause_type::CLA_LEARNT: ++num_learnt; break; case clause_type::CLA_DERIVED: ++num_derived; break; case clause_type::CLA_ASSUMPTION: ++num_assump; break; case clause_type::CLA_SPLIT: ++num_split; break; default: assert(false); ; } } }; } ProofNode * ProofGraph::createProofNodeFor(CRef clause, clause_type _ctype, Proof const & proof) { ProofNode * n = new ProofNode(); if (isLeafClauseType(_ctype)) { n->initClause(proof.getClause(clause)); n->setClauseRef(clause); //Sort clause literals std::sort(n->getClause().begin(),n->getClause().end()); } //Add node to graph vector auto currId = static_cast(graph.size()); graph.push_back(n); n->setId(currId); assert(getNode(currId) == n); return n; } void ProofGraph::buildProofGraph(const Proof & proof) { if (verbose()) { std::cerr << "# " << "Proof graph building begin" << '\n'; } if (verbose() > 0) { uint64_t mem_used = memUsed(); reportf("# Memory used before building the proof: %.3f MB\n", mem_used == 0 ? 0 : mem_used / 1048576.0); } const double initTime=cpuTime(); max_id_variable=0; av_cla_size=0; max_cla_size=0; num_edges=0; num_nodes=0; num_leaves=0; building_time=0; A1=0; A1prime=0; A1B=0; A2=0; A2B=0; A2U=0; B1=0; B2prime=0; B2=0; B3=0; duplications=0; swap_ties=0; auto const & clause_to_proof_der = proof.getProof(); //To map clauses to graph id //An id is associated when the node is created std::map clauseToIDMap; //To keep track of visited nodes std::set visitedSet; //Queue to build proof graph from sink std::deque q; ProofBuildingStatistics counters; unsigned max_leaf_size = 0; double avg_leaf_size = 0; unsigned max_learnt_size = 0; double avg_learnt_size = 0; // NOTE: Must guarantee first antecedent -> positive occurrence pivot // second antecedent -> negative occurrence pivot // Map to associate node to its antecedents std::map< std::pair, int > ants_map; //Start from empty clause { auto it = clause_to_proof_der.find(CRef_Undef); if (it == clause_to_proof_der.end()) { throw OsmtInternalException("Proof building: Empty clause was not derived!"); } if (it->second.isEmpty()) { throw OsmtInternalException("Proof building: Empty clause has no chain!"); } } // Helper method to process clause seen for the first time auto processNewClause = [&](CRef clause) { clause_type _ctype = clause_to_proof_der.at(clause).type; counters.recordNewClause(_ctype); ProofNode *n = createProofNodeFor(clause, _ctype, proof); if (isLeafClauseType(_ctype)) { if (n->getClauseSize() >= max_leaf_size) { max_leaf_size = n->getClauseSize(); } avg_leaf_size += n->getClauseSize(); } else if (_ctype == clause_type::CLA_LEARNT) { unsigned ssize = clause != CRef_Undef ? proof.getClause(clause).size() : 0; if (ssize >= max_learnt_size) { max_learnt_size = ssize; } avg_learnt_size += ssize; } else { assert(false); } clauseToIDMap[clause] = n->getId(); q.push_back(clause); }; processNewClause(CRef_Undef); do { CRef currClause = q.back(); q.pop_back(); if (visitedSet.find(currClause) != visitedSet.end()) { continue; } assert(clause_to_proof_der.find(currClause) != clause_to_proof_der.end()); auto const & proofder = clause_to_proof_der.at(currClause); // Derivation auto const & chaincla = proofder.chain_cla; // Clauses chain auto const & chainvar = proofder.chain_var; // Pivot chain clause_type ctype = proofder.type; if (isLeafClauseType(ctype)) { assert(chaincla.empty()); // MB: Proof built from the root towards the leaves. // A leaf node is constructed when its first children is constructred. Here it must already exist. auto it = clauseToIDMap.find(currClause); assert(it != clauseToIDMap.end()); getNode(it->second)->setType(ctype); addLeaf(it->second); } else if (ctype == clause_type::CLA_LEARNT) { assert(chaincla.size() >= 2); assert(chainvar.size() == chaincla.size() - 1); // TODO: Check if this is not redundant in current implementation auto skipChainsOfLengthOne = [&clause_to_proof_der](CRef cref) -> CRef { while (clause_to_proof_der.at(cref).chain_cla.size() == 1) { cref = clause_to_proof_der.at(cref).chain_cla[0]; } return cref; }; CRef clause_0 = skipChainsOfLengthOne(chaincla[0]); if (clauseToIDMap.find(clause_0) == clauseToIDMap.end()) { processNewClause(clause_0); } auto last_seen_id = clauseToIDMap.at(clause_0); // Check for internally deduced clauses for (std::size_t i = 1; i < chaincla.size(); ++i) { // ith clause not yet processed CRef clause_i = skipChainsOfLengthOne(chaincla[i]); if (clauseToIDMap.find(clause_i) == clauseToIDMap.end()) { processNewClause(clause_i); } ProofNode *n = nullptr; clauseid_t currId = static_cast(-1); // End tree not reached: deduced node if (i < chaincla.size() - 1) { currId = graph.size(); n = new ProofNode(); //Add node to graph vector n->setId(currId); graph.push_back(n); assert(getNode(currId) == n); n->setType(clause_type::CLA_DERIVED); counters.recordNewClause(clause_type::CLA_DERIVED); } else { // End tree reached: currClause if (clauseToIDMap.find(currClause) == clauseToIDMap.end()) { assert(false); throw OsmtInternalException("Error in proof building: Learnt clause not processed yet!"); } currId = clauseToIDMap.at(currClause); n = getNode(currId); n->setType(clause_type::CLA_LEARNT); } assert(n); // Edges creation // First internal node deduced from first clauses 0 and 1 // Other internal nodes deduced from last internal node and clause i Var pivot = chainvar[i - 1]; n->setPivot(pivot); proof_variables.insert(pivot); if (static_cast(pivot) > max_id_variable) { max_id_variable = static_cast(pivot); } assert(currId != static_cast(-1)); assert(last_seen_id != currId); bool pos_piv = true; bool found_piv = false; // Make sure ant1 has the pivot positive (and ant2 negated) Clause & clausei = proof.getClause(clause_i); for (unsigned k = 0; k < clausei.size(); ++k) { if (var(clausei[k]) == n->getPivot()) { if (sign(clausei[k]) != 0) { pos_piv = false; } found_piv = true; break; } } assert(found_piv); (void) found_piv; auto id_i = clauseToIDMap.at(clause_i); n->setAnt1(pos_piv ? getNode(id_i) : getNode(last_seen_id)); n->setAnt2(pos_piv ? getNode(last_seen_id) : getNode(id_i)); last_seen_id = currId; n->getAnt1()->addRes(n->getId()); n->getAnt2()->addRes(n->getId()); } } else { assert(false); } visitedSet.insert(currClause); } while(!q.empty()); setRoot(clauseToIDMap.at(CRef_Undef)); if (proofCheck()) { // Check whether there are any remaining pieces checkProof(false); unsigned rem = cleanProofGraph(); assert(rem == 0); (void) rem; } if (verbose() > 0) { unsigned num_non_null = 0; #ifdef PEDANTIC_DEBUG unsigned cl_non_null = 0; #endif for (size_t i = 0; i < getGraphSize(); i++) { if (getNode(i)) { num_non_null++; #ifdef PEDANTIC_DEBUG if (getNode(i)->getPClause()) { cl_non_null++; } #endif } } #ifdef PEDANTIC_DEBUG cout << "Graph size: " << getGraphSize() << '\n'; cout << "Non null nodes: " << num_non_null << '\n'; cout << "Non null clauses: " << cl_non_null << '\n'; #endif if (graph.size() > 1) { assert(num_non_null == (counters.num_leaf + counters.num_learnt + counters.num_derived + counters.num_theory + counters.num_assump)); } reportf("; Number of nodes: %d (leaves: %d - learnt: %d - derived: %d - theory: %d - assumptions: %d)\n", num_non_null, counters.num_leaf, counters.num_learnt, counters.num_derived, counters.num_theory, counters.num_assump); reportf("; Maximum, average size of leaves: %d %.2f\n", max_leaf_size, avg_leaf_size / (double) counters.num_leaf); reportf("; Maximum, average size of learnt: %d %.2f\n", max_learnt_size, avg_learnt_size / (double) counters.num_learnt); num_edges = (counters.num_learnt + counters.num_derived) * 2; reportf("; Number of edges: %d\n", num_edges); num_nodes = num_non_null; //reportf( "# Number of variables - nominal: %d - actual: %d\n", num_vars_limit, proof_variables.size() ); reportf("; Number of distinct variables in the proof: %d\n", (int) proof_variables.size()); } if (verbose() > 0) { uint64_t mem_used = memUsed(); reportf("; Memory used after building the proof: %.3f MB\n", mem_used == 0 ? 0 : mem_used / 1048576.0); } if (verbose()) { std::cerr << "; Proof graph building end" << std::endl; } building_time = cpuTime() - initTime; // Postprocessing of the proof this->addDefaultAssumedLiterals(proof.getAssumedLiterals()); if (proofCheck()) { verifyLeavesInconsistency(); } } void ProofGraph::fillProofGraph() { if (verbose() > 1) { uint64_t mem_used = memUsed(); reportf("; Memory used before filling the proof: %.3f MB\n", mem_used == 0 ? 0 : mem_used / 1048576.0); } std::vector q; q.push_back(getRoot()->getId()); do { clauseid_t id = q.back(); ProofNode * n = getNode(id); //Node not visited yet if (not isSetVisited1(id)) { // Enqueue antecedents if not visited if (n->getAnt1() and not isSetVisited1(n->getAnt1()->getId())) { q.push_back(n->getAnt1()->getId()); } else if (n->getAnt2() and not isSetVisited1(n->getAnt2()->getId())) { q.push_back(n->getAnt2()->getId()); } else { // Mark node as visited if both antecedents visited setVisited1(id); q.pop_back(); assert(n); //Non leaf node if (not n->isLeaf()) { n->initClause(); mergeClauses(n->getAnt1()->getClause(), n->getAnt2()->getClause(), n->getClause(), n->getPivot()); } } } else q.pop_back(); } while (not q.empty()); resetVisited1(); if (verbose() > 0) { uint64_t mem_used = memUsed(); reportf("; Memory used after filling the proof: %.3f MB\n", mem_used == 0 ? 0 : mem_used / 1048576.0); } } void ProofGraph::emptyProofGraph() { if (verbose() > 1) { uint64_t mem_used = memUsed(); reportf("; Memory used before emptying the proof: %.3f MB\n", mem_used == 0 ? 0 : mem_used / 1048576.0); } for (size_t i = 0; i < getGraphSize(); ++i) { ProofNode * n = getNode(i); if (n and not n->isLeaf()) { n->resetClause(); } } if (verbose() > 0) { uint64_t mem_used = memUsed(); reportf("; Memory used after emptying the proof: %.3f MB\n", mem_used == 0 ? 0 : mem_used / 1048576.0); } } void ProofGraph::normalizeAntecedentOrder() { // Normalize proof for interpolation std::deque q; q.push_back(getRoot()); do { ProofNode * n = q.front(); q.pop_front(); if (not isSetVisited1(n->getId())) { if (not n->isLeaf()) { q.push_back(n->getAnt1()); q.push_back(n->getAnt2()); // Check pivot in antecedents short f1 = n->getAnt1()->hasOccurrenceBin(n->getPivot()); short f2 = n->getAnt2()->hasOccurrenceBin(n->getPivot()); assert(f1 != -1 && f2 != -1); assert(not (f1 == 1 and f2 == 1) and not(f1 == 0 and f2 == 0)); // Exchange antecedents if necessary if (f1 == 1 and f2 == 0) { ProofNode * aux = n->getAnt1(); n->setAnt1(n->getAnt2()); n->setAnt2(aux); } } setVisited1(n->getId()); } } while (not q.empty()); resetVisited1(); } int ProofGraph::cleanProofGraph() { // Remove the unreachable part of the graph // Ideally it will be made of subgraphs not connected to the main graph unsigned removed = 0; bool done = false; while (not done) { done = true; for (size_t i = 0; i < getGraphSize(); i++) { if (getNode(i) and getNode(i)->getNumResolvents() == 0 and getNode(i) != getRoot()) { done = false; removed += removeTree(i); } } } return removed; } //Remove a node from the graph void ProofGraph::removeNode(clauseid_t vid) { ProofNode * n = getNode(vid); assert(n); if (n->getAnt1() == nullptr and n->getAnt2() == nullptr) { removeLeaf(vid); } n->setAnt1(nullptr); n->setAnt2(nullptr); delete n; // Remove n from proof graph[vid] = nullptr; } unsigned ProofGraph::removeTree(clauseid_t vid) { assert(getNode(vid)); assert(getNode(vid)->getNumResolvents() == 0); unsigned removed = 0; //Go on removing nodes with 0 resolvents //Visit graph from root keeping track of edges and nodes std::deque q; // Better a set than a boolean vector to avoid wasting memory std::set visit; q.push_back(vid); do { clauseid_t c = q.front(); q.pop_front(); assert(c < getGraphSize()); ProofNode * n = getNode(c); //Remove node if no more resolvents present if (n and n->getNumResolvents() == 0) { if (n->getAnt1()) { assert(getNode(n->getAnt1()->getId()) == n->getAnt1()); q.push_back(n->getAnt1()->getId()); n->getAnt1()->remRes(c); } if (n->getAnt2()) { assert(getNode(n->getAnt2()->getId()) == n->getAnt2()); q.push_back(n->getAnt2()->getId()); n->getAnt2()->remRes(c); } removeNode(c); removed++; } } while (not q.empty()); return removed; } clauseid_t ProofGraph::dupliNode(RuleContext & ra) { clauseid_t v_id = ra.getV(); ProofNode * w = getNode(ra.getW()); assert(w); unsigned num_old_res = w->getNumResolvents(); assert(num_old_res > 1); (void) num_old_res; for (clauseid_t resolvent_id : w->getResolvents()) { ProofNode * res = getNode(resolvent_id); assert(res); (void) res; assert(res->getAnt1() == w or res->getAnt2() == w); } // Create node and add to graph vector ProofNode * n = new ProofNode(); clauseid_t currId = getGraphSize(); n->setId(currId); graph.push_back(n); assert(getNode(currId) == n); n->setType(w->getType()); n->initClause(w->getClause()); n->setClauseRef(w->getClauseRef()); // Set antecedents, pivot n->setAnt1(w->getAnt1()); n->setAnt2(w->getAnt2()); n->getAnt1()->addRes(currId); n->getAnt2()->addRes(currId); n->setPivot(w->getPivot()); // The new node replaces w in the context // w loses v but keeps everything else ProofNode * v = getNode(v_id); w->remRes(v_id); n->addRes(v_id); if (v->getAnt1() == w) v->setAnt1(n); else if (v->getAnt2() == w) v->setAnt2(n); else throw OsmtInternalException("Error in node duplication"); assert(w->getResolvents().find(v_id) == w->getResolvents().end()); assert(w->getNumResolvents() == num_old_res - 1); // Remember to modify context ra.cw = currId; duplications++; return currId; } void ProofGraph::addDefaultAssumedLiterals(std::vector && assumedLiteralsFromDerivations) { this->assumedLiterals = std::move(assumedLiteralsFromDerivations); } void ProofGraph::eliminateNoPartitionTheoryVars(std::vector const & noPartitionTheoryVars) { // Prepare the graph for transformations this->fillProofGraph(); // First step: lift all resolution steps on these vars as close to leaves as possible to create subproofs // where resolution happens only on marked vars this->liftVarsToLeaves(noPartitionTheoryVars); // Second step: Replace the subproofs created in the first step with their root. // The leaves of each subproof must be theory clauses, so its root must also be a valid theory clause this->replaceSubproofsWithNoPartitionTheoryVars(noPartitionTheoryVars); // Cleanup this->emptyProofGraph(); for (Var v : noPartitionTheoryVars) { this->proof_variables.erase(v); } } opensmt-2.5.2/src/proof/PGCheck.cc000066400000000000000000000240431445011647600167070ustar00rootroot00000000000000/********************************************************************* Author: Simone Fulvio Rollini Periplo -- Copyright (C) 2013, Simone Fulvio Rollini Periplo is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. Periplo 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Periplo. If not, see . *********************************************************************/ #include "PG.h" #include "OsmtInternalException.h" #include "VerificationUtils.h" #include void ProofGraph::verifyLeavesInconsistency() { if (verbose() > 0) { std::cerr << "# Verifying unsatisfiability of the set of proof leaves" << std::endl; } std::vector proofleaves; std::vector q; std::vector visited_count(getGraphSize(), 0u); q.push_back(getRoot()->getId()); do { clauseid_t id = q.back(); ProofNode * node = getNode(id); assert(node); visited_count[id]++; q.pop_back(); // All resolvents have been visited if (id == getRoot()->getId() or visited_count[id] == node->getNumResolvents()) { if (not node->isLeaf()) { clauseid_t id1 = node->getAnt1()->getId(); clauseid_t id2 = node->getAnt2()->getId(); // Enqueue antecedents assert(visited_count[id1] < node->getAnt1()->getNumResolvents()); assert(visited_count[id2] < node->getAnt2()->getNumResolvents()); q.push_back(id1); q.push_back(id2); } else { proofleaves.push_back(id); } } } while (!q.empty()); vec clauses; for (clauseid_t leaf_id : leaves_ids) { auto const & clause = getNode(leaf_id)->getClause(); vec lits; lits.capacity(clause.size()); for (Lit l : clause) { lits.push(termMapper.litToPTRef(l)); } clauses.push(logic_.mkOr(std::move(lits))); } bool unsat = VerificationUtils(logic_).impliesInternal(logic_.mkAnd(std::move(clauses)), logic_.getTerm_false()); if (not unsat) { throw std::logic_error("The set of proof leaves is satisfiable!"); } } bool ProofNode::checkPolarityAnt() { assert(getAnt1()); assert(getAnt2()); std::vector & cla = getAnt1()->getClause(); for (size_t i = 0; i < cla.size(); i++) if (var(cla[i]) == getPivot()) { return not sign(cla[i]); } throw OsmtInternalException("Pivot not found in node's clause"); } void ProofGraph::checkClauseSorting(clauseid_t nid) { ProofNode * n = getNode(nid); assert(n); assert(n->getId() == nid); if (n->getClauseSize() == 0) return; for (size_t i = 0; i < n->getClauseSize() - 1; i++) { if (var(n->getClause()[i]) > var(n->getClause()[i + 1])) { std::cerr << "Bad clause sorting for clause " << n->getId() << " of type " << n->getType() << '\n'; printClause(n); throw OsmtInternalException(); } if (var(n->getClause()[i]) == var(n->getClause()[i + 1]) && sign(n->getClause()[i]) == sign(n->getClause()[i + 1])) { std::cerr << "Repetition of var " << var(n->getClause()[i]) << " in clause " << n->getId() << " of type " << n->getType() << '\n'; printClause(n); throw OsmtInternalException(); } if (var(n->getClause()[i]) == var(n->getClause()[i + 1]) && sign(n->getClause()[i]) != sign(n->getClause()[i + 1])) { std::cerr << "Inconsistency on var " << var(n->getClause()[i]) << " in clause " << n->getId() << " of type " << n->getType() << '\n'; printClause(n); throw OsmtInternalException(); } } } void ProofGraph::checkClause(clauseid_t nid) { ProofNode * n = getNode(nid); assert(n); assert(n->getId() == nid); // Check if empty clause if (isRoot(n)) { if (n->getClauseSize() != 0) { std::cerr << n->getId() << " is the sink but not an empty clause" << '\n'; printClause(n); throw OsmtInternalException(); } } if (n->getClauseSize() == 0) { if (n->getType() == clause_type::CLA_ORIG) { std::cerr << n->getId() << " is an empty original clause" << '\n'; throw OsmtInternalException(); } } else checkClauseSorting(n->getId()); if (!n->isLeaf()) { assert(n->getId() != n->getAnt1()->getId() && n->getId() != n->getAnt2()->getId()); assert(getNode(n->getAnt1()->getId())); assert(getNode(n->getAnt2()->getId())); if (n->getClauseSize() != 0) { std::vector v; mergeClauses(n->getAnt1()->getClause(), n->getAnt2()->getClause(), v, n->getPivot()); if (v.size() != n->getClauseSize()) { std::cerr << "Clause : "; printClause(n); std::cerr << " does not correctly derive from antecedents " << '\n'; printClause(getNode(n->getAnt1()->getId())); printClause(getNode(n->getAnt2()->getId())); throw OsmtInternalException(); } for (size_t i = 0; i < n->getClauseSize(); i++) if (n->getClause()[i] != v[i]) { std::cerr << "Clause : "; printClause(n); std::cerr << " does not correctly derive from antecedents " << '\n'; printClause(getNode(n->getAnt1()->getId())); printClause(getNode(n->getAnt2()->getId())); throw OsmtInternalException(); } // Checks whether clause is tautological std::vector & cl = n->getClause(); for (unsigned u = 0; u < cl.size() - 1; u++) if (var(cl[u]) == var(cl[u + 1])) { std::cerr << "Clause : "; printClause(n); std::cerr << " is tautological " << '\n'; } // Checks whether both antecedents have the pivot short f1 = n->getAnt1()->hasOccurrenceBin(n->getPivot()); short f2 = n->getAnt2()->hasOccurrenceBin(n->getPivot()); assert(f1 != -1); assert(f2 != -1); assert(f1 != f2); (void)f1; (void)f2; } } // Check that every resolvent has this node as its antecedent std::set & resolvents = n->getResolvents(); for (clauseid_t id : resolvents) { assert(id < getGraphSize()); ProofNode * res = getNode(id); if (res == NULL) { std::cerr << "Node " << n->getId() << " has resolvent " << id << " null" << '\n'; throw OsmtInternalException(); } else assert(res->getAnt1() == n || res->getAnt2() == n); } } void ProofGraph::checkProof(bool check_clauses) { if (verbose()) { std::cerr << "# Checking proof" << '\n'; } // Visit top down std::deque q; std::vector visit_level(getGraphSize()); q.assign(leaves_ids.begin(), leaves_ids.end()); do { clauseid_t id = q.front(); ProofNode * n = getNode(id); assert(n); q.pop_front(); if (!isSetVisited2(id)) { setVisited2(id); // Leaves are seen only once if (n->isLeaf()) { visit_level[id] = 1; for (clauseid_t resolvent_id : n->getResolvents()) { q.push_back(resolvent_id); } } } else { assert(!n->isLeaf()); assert(visit_level[id] == 0); // Inner should be seen twice for (clauseid_t resolvent_id : n->getResolvents()) { assert(visit_level[resolvent_id] == 0); q.push_back(resolvent_id); } clauseid_t id1 = n->getAnt1()->getId(); clauseid_t id2 = n->getAnt2()->getId(); assert(visit_level[id1] > 0); assert(visit_level[id2] > 0); visit_level[id] = visit_level[id1] > visit_level[id2] ? visit_level[id1] + 1 : visit_level[id2] + 1; } } while (!q.empty()); // Visit bottom up q.push_back(getRoot()->getId()); do { clauseid_t id = q.back(); ProofNode * node = getNode(id); assert(node); q.pop_back(); if (!node->isLeaf()) { clauseid_t id1 = node->getAnt1()->getId(); clauseid_t id2 = node->getAnt2()->getId(); assert(node->getAnt1() != node->getAnt2()); // Enqueue antecedents the first time the node is seen if (!isSetVisited1(id)) { q.push_back(id1); q.push_back(id2); } if (check_clauses) checkClause(id); } setVisited1(node->getId()); } while (!q.empty()); // Ensure that the same nodes have been visited top-down and bottom-up for (unsigned u = 0; u < getGraphSize(); u++) { if (isSetVisited1(u) && !isSetVisited2(u)) { std::cerr << "Node " << u << " is unreachable going top-down" << '\n'; throw OsmtInternalException(); } if (!isSetVisited1(u) && isSetVisited2(u)) { std::cerr << "Node " << u << " is unreachable going bottom-up" << '\n'; throw OsmtInternalException(); } } // Ensure that there are no useless leaves for (clauseid_t leave_id : leaves_ids) { if (not isSetVisited1(leave_id)) { std::cerr << "Detached leaf" << leave_id << '\n'; throw OsmtInternalException(); } } resetVisited1(); resetVisited2(); } opensmt-2.5.2/src/proof/PGHelp.cc000066400000000000000000000152161445011647600165640ustar00rootroot00000000000000/********************************************************************* Author: Simone Fulvio Rollini Periplo -- Copyright (C) 2013, Simone Fulvio Rollini Periplo is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. Periplo 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Periplo. If not, see . *********************************************************************/ #include "PG.h" #include "OsmtInternalException.h" #include #include short ProofNode::hasOccurrenceBin(Var v) const { std::vector const & cla = getClause(); int first = 0; int last = cla.size() - 1; while (first <= last) { int mid = (first + last) / 2; Lit l = cla[mid]; Var w = var(l); if (v > w) first = mid + 1; else if (v < w) last = mid - 1; else if (v == w) return (sign(l) == false) ? 0 : 1; } return -1; } // Calculate graph info // Assume proof filled void ProofGraph::getGraphInfo() { //Visit graph from sink keeping track of edges and nodes std::deque q; ProofNode* n; av_cla_size=0; max_cla_size=0; var_cla_size=0; num_nodes=0; num_edges=0; num_unary=0; num_leaves=0; proof_variables.clear(); q.push_back(getRoot()); do { n=q.front(); q.pop_front(); // Node not visited yet if (!isSetVisited1(n->getId())) { if (!n->isLeaf()) { q.push_back(n->getAnt1()); num_edges++; q.push_back(n->getAnt2()); num_edges++; proof_variables.insert(n->getPivot()); } else { assert(isLeafClauseType(n->getType())); num_leaves++; } //Mark node as visited setVisited1(n->getId()); num_nodes++; av_cla_size+=n->getClauseSize(); if (n->getClauseSize() > (size_t)max_cla_size) max_cla_size=n->getClauseSize(); if (n->getClauseSize()==1) num_unary++; } } while(!q.empty()); av_cla_size /= num_nodes; // Calculate sample variance for num resolvents and clause size for (size_t i=0;igetClauseSize()-av_cla_size,2); } var_cla_size/=(num_nodes-1); resetVisited1(); } std::vector ProofGraph::topolSortingTopDown() const { std::vector DFS; std::deque q; DFS.reserve(getGraphSize()); // Enqueue leaves first q.assign(leaves_ids.begin(),leaves_ids.end()); do { clauseid_t id = q.front(); q.pop_front(); ProofNode * n = getNode(id); assert(n); if (not isSetVisited1(id)) { // Process node if both antecedents visited if ((not n->getAnt1() or isSetVisited1(n->getAnt1()->getId())) and (not n->getAnt2() or isSetVisited1(n->getAnt2()->getId()))) { for (clauseid_t resolvent_id: n->getResolvents()) { if (getNode(resolvent_id)) q.push_back(resolvent_id); } setVisited1(id); DFS.push_back(id); } } } while(not q.empty()); resetVisited1(); return DFS; } std::vector ProofGraph::topolSortingBotUp() const { std::vector DFS; DFS.reserve(getGraphSize()); std::vector q; std::vector visited_count(getGraphSize(),0); q.push_back(getRoot()->getId()); do { clauseid_t id = q.back(); ProofNode * node = getNode(id); assert(node); visited_count[id]++; q.pop_back(); // All resolvents have been visited if (visited_count[id] == node->getNumResolvents() or id == getRoot()->getId()) { if (not node->isLeaf()) { clauseid_t id1 = node->getAnt1()->getId(); clauseid_t id2 = node->getAnt2()->getId(); assert(visited_count[id1] < node->getAnt1()->getNumResolvents()); assert(visited_count[id2] < node->getAnt2()->getNumResolvents()); q.push_back(id1); q.push_back(id2); } DFS.push_back(id); } } while (not q.empty()); return DFS; } /* * Given two clauses A and B, and a pivot variable, computes the resolvent clause after resolution. * * PRECONDITION: Literals in the input clauses must be sorted and the clauses must contain the pivot variable. * POSTCONDITION: Literals in the resolvent clause are sorted and the clause does not contain the pivot. */ bool ProofGraph::mergeClauses(std::vector const & A, std::vector const & B, std::vector& resolv, Var pivot) { assert(std::is_sorted(A.begin(), A.end())); assert(std::is_sorted(B.begin(), B.end())); assert(std::find_if(A.begin(), A.end(), [pivot](Lit l) { return var(l) == pivot; }) != A.end()); assert(std::find_if(B.begin(), B.end(), [pivot](Lit l) { return var(l) == pivot; }) != B.end()); const std::size_t Asize = A.size(); const std::size_t Bsize = B.size(); if (resolv.size() < Asize + Bsize - 2) { resolv.resize(Asize + Bsize - 2); } assert(resolv.size() >= Asize + Bsize - 2); std::size_t i = 0; std::size_t j = 0; std::size_t res = 0; auto addIfNotPivot = [&resolv, &res, pivot](Lit l) { if (var(l) != pivot) { assert(res == 0 or resolv[res - 1] != l); resolv[res++] = l; } }; while (i < Asize and j < Bsize) { if (A[i] <= B[j]) { if (A[i] == B[j]) { ++j; } addIfNotPivot(A[i]); ++i; } else { assert(B[j] < A[i]); addIfNotPivot(B[j]); ++j; } } while (i < Asize) { addIfNotPivot(A[i]); ++i; } while (j < Bsize) { addIfNotPivot(B[j]); ++j; } assert(resolv.size() >= res); resolv.resize(res); assert(std::is_sorted(resolv.begin(), resolv.end())); assert(std::find_if(resolv.begin(), resolv.end(), [pivot](Lit l) { return var(l) == pivot; }) == resolv.end()); return true; } opensmt-2.5.2/src/proof/PGHeuristics.cc000066400000000000000000001055661445011647600200260ustar00rootroot00000000000000/********************************************************************* Author: Simone Fulvio Rollini Periplo -- Copyright (C) 2013, Simone Fulvio Rollini Periplo is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. Periplo 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Periplo. If not, see . *********************************************************************/ #include "PG.h" #include "OsmtInternalException.h" //Input: a context for a swap rule, a predicate to be pushed up //Output: true if rule application is allowed bool ProofGraph::allowSwapRuleForPredicatePushingUp(RuleContext& ra, Var pred) { rul_type t=ra.getType(); bool dupl=(getNode(ra.getW())->getNumResolvents()>1); Var pred1 = ( getNode(ra.getW())->getPivot() ); Var pred2 = ( getNode(ra.getV())->getPivot() ); bool is1 = ( pred1==pred ); bool is2 = ( pred2==pred ); if(is1 && is2) { if(!dupl) { // Both pred, swap only if a reduction is possible // and no duplication is needed if(t==rB2) return true; if(t==rA2B) return true; if(t==rA1prime) return true; } } else if(is1) { // Upper pred, do not allow } else if(is2) { // Lower pred, allow return true; } else { // Other predicates, do nothing } return false; } //Input: a context for a swap rule, a predicate to be pushed up //Output: true if rule application is allowed bool ProofGraph::allowSwapRuleForPredicatePushingDown(RuleContext& ra, Var pred) { //cerr << "SWAP-Trying to push down " << thandler->varToEnode(pred) << // " where w=" << ra.getW() << " and v=" << ra.getV() << endl; Var pred1 = ( getNode(ra.getW())->getPivot() ); Var pred2 = ( getNode(ra.getV())->getPivot() ); bool is1 = (pred1==pred); bool is2 = (pred2==pred); if(is1 && is2) { throw OsmtInternalException("Incorrect pivot in resolution step"); } else if(is1) { // Upper pred, allow //if( dupl ) return false; //if( t==rA1 || t==rA1B ) return false; return true; } else if(is2) { // Lower pred, do not allow } else { // Other predicates, do nothing } return false; } //Input: a context for a swap rule, a predicate to be pushed up //Output: true if rule application is allowed bool ProofGraph::allowCutRuleForPredicatePushing(RuleContext& ra, Var pred) { bool dupl=(getNode(ra.getW())->getNumResolvents()>1); Var pred1 = ( getNode(ra.getW())->getPivot() ); Var pred2 = ( getNode(ra.getV())->getPivot() ); bool is1 = (pred1==pred); bool is2 = (pred2==pred); if(is1 && is2) { throw OsmtInternalException("Incorrect pivot in resolution step"); } else if(is1) return true; else if(is2) return true; else { if(!dupl) return true; } return false; } using ApplicationResult = ProofGraph::ApplicationResult; //Input: a pair of left/right contexts ApplicationResult ProofGraph::handleRuleApplicationForPredicatePushing(RuleContext & ra1, RuleContext & ra2) { /* cerr << "Examining (w=" << ra1.getW() << ",v=" << ra1.getV() << "," << ra1.getType() <<") and (w=" << ra2.getW() << ",v=" << ra2.getV() << "," << ra2.getType() << ")" << endl;*/ //TODO generalize Var pred = pred_to_push; bool push_up = false; // Swap application rule bool(ProofGraph::*allowSwap)(RuleContext& ra,Var v) = &ProofGraph::allowSwapRuleForPredicatePushingDown; // Cut application rule bool(ProofGraph::*allowCut)(RuleContext& ra,Var v) = &ProofGraph::allowCutRuleForPredicatePushing; // Check need for duplication bool dupl1, dupl2; rul_type t1 = ra1.getType(); rul_type t2 = ra2.getType(); bool is1cut = isCutRule(t1); bool is2cut = isCutRule(t2); bool is1swap = isSwapRule(t1); bool is2swap = isSwapRule(t2); //rA1,rA2,rA2u,rA1B,rA2B,rA1undo,rB2k,rB3,rB1,rB2 //Neither applicable if (ra1.disabled() && ra2.disabled()) { return ApplicationResult::NO_APPLICATION; } //First not applicable else if (ra1.disabled() && ra2.enabled()) { bool allowed2; if (is2cut) allowed2 = (*this.*allowCut)(ra2,pred); else if (is2swap) allowed2 = (*this.*allowSwap)(ra2,pred); else throw OsmtInternalException("Unexpected situation in rule application"); return allowed2 ? ApplicationResult::APPLY_SECOND : ApplicationResult::NO_APPLICATION; } //Second not applicable else if (ra1.enabled() && ra2.disabled()) { bool allowed1; if (is1cut) allowed1 = (*this.*allowCut)(ra1,pred); else if (is1swap) allowed1 = (*this.*allowSwap)(ra1,pred); else throw OsmtInternalException("Unexpected situation in rule application"); return allowed1 ? ApplicationResult::APPLY_FIRST : ApplicationResult::NO_APPLICATION; } //Both applicable else if (ra1.enabled() && ra2.enabled()) { bool allowed1, allowed2; if (is1cut) allowed1 = (*this.*allowCut)(ra1,pred); else if (is1swap) allowed1 = (*this.*allowSwap)(ra1,pred); else throw OsmtInternalException("Unexpected situation in rule application"); if (is2cut) allowed2 = (*this.*allowCut)(ra2,pred); else if (is2swap) allowed2 = (*this.*allowSwap)(ra2,pred); else throw OsmtInternalException("Unexpected situation in rule application"); //Neither allowed if (!allowed1 && !allowed2) return ApplicationResult::NO_APPLICATION; //First allowed else if (allowed1 && !allowed2) return ApplicationResult::APPLY_FIRST; //Second allowed else if (!allowed1 && allowed2) return ApplicationResult::APPLY_SECOND; //Both allowed else if (allowed1 && allowed2) { ApplicationResult res = ApplicationResult::NO_APPLICATION; //Case one cuts, the other swaps: privilege cut if (is1cut && is2swap) res = ApplicationResult::APPLY_FIRST; else if (is2cut && is1swap) res = ApplicationResult::APPLY_SECOND; //Case both cut else if(is1cut && is2cut) { //NOTE Privilege the one with the relevant predicate? //NOTE probably not necessary //Privilege B3 over B1 and B2 if (t1 == rB3 && t2 != rB3) res = ApplicationResult::APPLY_FIRST; else if (t1 != rB3 && t2 == rB3) res = ApplicationResult::APPLY_SECOND; //Break ties randomly else { res = rand() % 2 == 0 ? ApplicationResult::APPLY_FIRST : ApplicationResult::APPLY_SECOND; } } //Case both swap else if (is2swap && is1swap) { //NOTE Privilege the one with the relevant predicate! // v pivot is to be pushed up Var x1, x2; if (push_up) { x1 = getNode(ra1.getV())->getPivot(); x2 = getNode(ra2.getV())->getPivot(); } // w pivot is to be pushed down else { x1 = getNode(ra1.getW())->getPivot(); x2 = getNode(ra2.getW())->getPivot(); } if (x1 == pred && x2 != pred) res = ApplicationResult::APPLY_FIRST; else if (x1 != pred && x2 == pred) res = ApplicationResult::APPLY_SECOND; else { dupl1 = (getNode(ra1.getW())->getNumResolvents() > 1); dupl2 = (getNode(ra2.getW())->getNumResolvents() > 1); //Privilege the one not duplicating if (dupl1 && !dupl2) res = ApplicationResult::APPLY_SECOND; else if (!dupl1 && dupl2) res = ApplicationResult::APPLY_FIRST; //Privilege A1undo, then B2k, then A2 over A1 else if (t1 == rA1prime && t2 != rA1prime) res = ApplicationResult::APPLY_FIRST; else if (t1 != rA1prime && t2 == rA1prime) res = ApplicationResult::APPLY_SECOND; else if (t1 == rB2 && t2 != rB2) res = ApplicationResult::APPLY_FIRST; else if (t1 != rB2 && t2 == rB2) res = ApplicationResult::APPLY_SECOND; else if ((t1 == rA2 || t1 == rA2u || t1 == rA2B) && (t2 == rA1 || t2 == rA1B)) res = ApplicationResult::APPLY_FIRST; else if ((t2 == rA2 || t2 == rA2u || t2 == rA2B) && (t1 == rA1 || t1 == rA1B)) res = ApplicationResult::APPLY_SECOND; //Privilege A2B over A2 and A1B over A1 else if ((t1 == rA2B && (t2 == rA2 || t2 == rA2u)) || (t1 == rA1B && t2 == rA1)) res = ApplicationResult::APPLY_FIRST; else if ((t2 == rA2B && (t1 == rA2 || t1 == rA2u)) || (t2 == rA1B && t1 == rA1)) res = ApplicationResult::APPLY_SECOND; //Break ties randomly else { res = rand() % 2 == 0 ? ApplicationResult::APPLY_FIRST : ApplicationResult::APPLY_SECOND; } } } return res; } } assert(false); return ApplicationResult::NO_APPLICATION; } //Input: a context for a swap rule //Output: true if rule application is allowed bool ProofGraph::allowSwapRuleForUnitsPushingDown(RuleContext& ra) { rul_type t=ra.getType(); bool dupl=(getNode(ra.getW())->getNumResolvents()>1); if(dupl) return false; bool unit1 = ( getNode(ra.getV2())->getClauseSize() == 1 ); bool unit2 = ( getNode(ra.getV3())->getClauseSize() == 1 ); if(unit1 && unit2) { assert(t!=rA1 && t!=rA1B); // Both units, swap only if a reduction is possible if(t==rB2) return true; if(t==rA2B) return true; if(t==rA1prime) return true; } else if(unit1) { assert(t!=rA1 && t!=rA1B); // Upper unit, allow return true; } else if(unit2) { // Lower unit, do not allow } else { // No units, do not allow } return false; } //Input: a pair of left/right contexts //Output: 0,1,2 to apply no rule, rule1, rule2 ApplicationResult ProofGraph::handleRuleApplicationForUnitsPushingDown(RuleContext & ra1, RuleContext & ra2) { // Swap application rule bool(ProofGraph::*allowSwap)(RuleContext& ra) = &ProofGraph::allowSwapRuleForUnitsPushingDown; // Check need for duplication bool dupl1, dupl2; rul_type t1 = ra1.getType(); rul_type t2 = ra2.getType(); bool is1cut = isCutRule(t1); bool is2cut = isCutRule(t2); bool is1swap = isSwapRule(t1); bool is2swap = isSwapRule(t2); //rA1,rA2,rA2u,rA1B,rA2B,rA1undo,rB2k,rB3,rB1,rB2 //Neither applicable if (ra1.disabled() && ra2.disabled()) { return ApplicationResult::NO_APPLICATION; } //First not applicable else if (ra1.disabled() && ra2.enabled()) { bool allowed2; if (is2cut) allowed2 = true; else if (is2swap) allowed2 = (*this.*allowSwap)(ra2); else throw OsmtInternalException("Unexpected situation in rule application"); return allowed2 ? ApplicationResult::APPLY_SECOND : ApplicationResult::NO_APPLICATION; } //Second not applicable else if (ra1.enabled() && ra2.disabled()) { bool allowed1; if (is1cut) allowed1 = true; else if (is1swap) allowed1 = (*this.*allowSwap)(ra1); else throw OsmtInternalException("Unexpected situation in rule application"); return allowed1 ? ApplicationResult::APPLY_FIRST : ApplicationResult::NO_APPLICATION; } //Both applicable else if (ra1.enabled() && ra2.enabled()) { bool allowed1, allowed2; if (is1cut) allowed1 = true; else if (is1swap) allowed1 = (*this.*allowSwap)(ra1); else throw OsmtInternalException("Unexpected situation in rule application"); if (is2cut) allowed2 = true; else if (is2swap) allowed2 = (*this.*allowSwap)(ra2); else throw OsmtInternalException("Unexpected situation in rule application"); //Neither allowed if (!allowed1 && !allowed2) return ApplicationResult::NO_APPLICATION; //First allowed else if (allowed1 && !allowed2) return ApplicationResult::APPLY_FIRST; //Second allowed else if (!allowed1 && allowed2) return ApplicationResult::APPLY_SECOND; //Both allowed else if (allowed1 && allowed2) { ApplicationResult res = ApplicationResult::NO_APPLICATION; //Case one cuts, the other swaps: privilege cut if (is1cut && is2swap) res = ApplicationResult::APPLY_FIRST; else if (is2cut && is1swap) res = ApplicationResult::APPLY_SECOND; //Case both cut else if (is1cut && is2cut) { //Privilege B3 over B1 and B2 if (t1==rB3 && t2!=rB3) res = ApplicationResult::APPLY_FIRST; else if (t1!=rB3 && t2==rB3) res = ApplicationResult::APPLY_SECOND; //Break ties randomly else { res = rand() % 2 == 0 ? ApplicationResult::APPLY_FIRST : ApplicationResult::APPLY_SECOND; } } //Case both swap else if(is2swap && is1swap) { dupl1=(getNode(ra1.getW())->getNumResolvents() > 1); dupl2=(getNode(ra2.getW())->getNumResolvents() > 1); //Privilege the one not duplicating if(dupl1 && !dupl2) res = ApplicationResult::APPLY_SECOND; else if(!dupl1 && dupl2) res = ApplicationResult::APPLY_FIRST; //Privilege A1undo, then B2k, then A2 over A1 else if(t1==rA1prime && t2!=rA1prime) res = ApplicationResult::APPLY_FIRST; else if(t1!=rA1prime && t2==rA1prime) res = ApplicationResult::APPLY_SECOND; else if(t1==rB2 && t2!=rB2) res = ApplicationResult::APPLY_FIRST; else if(t1!=rB2 && t2==rB2) res = ApplicationResult::APPLY_SECOND; else if((t1==rA2 || t1==rA2u || t1==rA2B) && (t2==rA1 || t2==rA1B)) res = ApplicationResult::APPLY_FIRST; else if((t2==rA2 || t2==rA2u || t2==rA2B) && (t1==rA1 || t1==rA1B)) res = ApplicationResult::APPLY_SECOND; //Privilege A2B over A2 and A1B over A1 else if((t1==rA2B && (t2==rA2 || t2==rA2u)) || (t1==rA1B && t2==rA1)) res = ApplicationResult::APPLY_FIRST; else if((t2==rA2B && (t1==rA2 || t1==rA2u)) || (t2==rA1B && t1==rA1)) res = ApplicationResult::APPLY_SECOND; //Break ties randomly else { res = rand() % 2 == 0 ? ApplicationResult::APPLY_FIRST : ApplicationResult::APPLY_SECOND; } } return res; } } assert(false); return ApplicationResult::NO_APPLICATION; } //Input: a context for a swap rule //Output: true if rule application is allowed bool ProofGraph::allowSwapRuleForReduction(RuleContext& ra) { rul_type t=ra.getType(); bool dupl=(getNode(ra.getW())->getNumResolvents()>1); if(!dupl) { // Push up if it has more resolvents unsigned long sp2 = getNode(ra.getV2())->getNumResolvents(); unsigned long sp3 = getNode(ra.getV3())->getNumResolvents(); if(sp2 <= sp3) { //Always allow rB2k if(t==rB2) return true; //Allow A1 undo if no duplications if(t==rA1prime) return true; //Allow A2 if no duplications if(t==rA2B) return true; if(t==rA2 || t==rA2u) return true; //if(t==rA1B && !dupl) return true; } } //Don't allow the rest return false; } //Input: a context for a cut rule //Output: true if rule application is allowed bool ProofGraph::allowCutRuleForReduction(RuleContext& ra) { rul_type t=ra.getType(); if( t==rB1 ) return true; else if( t==rB2prime ) return true; else if( t==rB3 ) return true; else throw OsmtInternalException("Unexpected situation in rule application"); } //Input: a pair of left/right contexts ApplicationResult ProofGraph::handleRuleApplicationForReduction(RuleContext & ra1, RuleContext & ra2) { // Randomize application of rules if ( additionalRandomization() && rand()%2==0 ) return ApplicationResult::NO_APPLICATION; // Swap application rule bool(ProofGraph::*allowSwap)(RuleContext& ra) = &ProofGraph::allowSwapRuleForReduction; // Swap application rule bool(ProofGraph::*allowCut)(RuleContext& ra) = &ProofGraph::allowCutRuleForReduction; // Check need for duplication bool dupl1, dupl2; rul_type t1 = ra1.getType(); rul_type t2 = ra2.getType(); bool is1cut = isCutRule(t1); bool is2cut = isCutRule(t2); bool is1swap = isSwapRule(t1); bool is2swap = isSwapRule(t2); //rA1,rA2,rA2u,rA1B,rA2B,rA1undo,rB2k,rB3,rB1,rB2 //Neither applicable if (ra1.disabled() && ra2.disabled()) { return ApplicationResult::NO_APPLICATION; } //First not applicable else if (ra1.disabled() && ra2.enabled()) { bool allowed2; if (is2cut) allowed2 = (*this.*allowCut)(ra2); else if (is2swap) allowed2 = (*this.*allowSwap)(ra2); else throw OsmtInternalException("Unexpected situation in rule application"); return allowed2 ? ApplicationResult::APPLY_SECOND : ApplicationResult::NO_APPLICATION; } //Second not applicable else if(ra1.enabled() && ra2.disabled()) { bool allowed1; if (is1cut) allowed1 = (*this.*allowCut)(ra1); else if (is1swap) allowed1 = (*this.*allowSwap)(ra1); else throw OsmtInternalException("Unexpected situation in rule application"); return allowed1 ? ApplicationResult::APPLY_FIRST : ApplicationResult::NO_APPLICATION; } //Both applicable else if (ra1.enabled() && ra2.enabled()) { bool allowed1, allowed2; if (is1cut) allowed1 = (*this.*allowCut)(ra1); else if (is1swap) allowed1 = (*this.*allowSwap)(ra1); else throw OsmtInternalException("Unexpected situation in rule application"); if (is2cut) allowed2 = (*this.*allowCut)(ra2); else if (is2swap) allowed2 = (*this.*allowSwap)(ra2); else throw OsmtInternalException("Unexpected situation in rule application"); //Neither allowed if (!allowed1 && !allowed2) return ApplicationResult::NO_APPLICATION; //First allowed if (allowed1 && !allowed2) return ApplicationResult::APPLY_FIRST; //Second allowed else if (!allowed1 && allowed2) return ApplicationResult::APPLY_SECOND; //Both allowed else if (allowed1 && allowed2) { ApplicationResult res = ApplicationResult::NO_APPLICATION; //Case one cuts, the other swaps: privilege cut if (is1cut && is2swap) res = ApplicationResult::APPLY_FIRST; else if (is2cut && is1swap) res = ApplicationResult::APPLY_SECOND; //Case both cut else if(is1cut && is2cut) { //Privilege B3 over B1 and B2 if (t1 == rB3 && t2 != rB3) res = ApplicationResult::APPLY_FIRST; else if(t1 != rB3 && t2 == rB3) res = ApplicationResult::APPLY_SECOND; //Break ties randomly else { res = rand() % 2 == 0 ? ApplicationResult::APPLY_FIRST : ApplicationResult::APPLY_SECOND; } } //Case both swap else if (is2swap && is1swap) { dupl1 = (getNode(ra1.getW())->getNumResolvents() > 1); dupl2 = (getNode(ra2.getW())->getNumResolvents() > 1); //Privilege the one not duplicating if(dupl1 && !dupl2) res = ApplicationResult::APPLY_SECOND; else if (!dupl1 && dupl2) res = ApplicationResult::APPLY_FIRST; //Privilege A1undo, then B2k, then A2 over A1 else if (t1 == rA1prime && t2 != rA1prime) res = ApplicationResult::APPLY_FIRST; else if (t1 != rA1prime && t2 == rA1prime) res = ApplicationResult::APPLY_SECOND; else if (t1 == rB2 && t2 != rB2) res = ApplicationResult::APPLY_FIRST; else if (t1 != rB2 && t2 == rB2) res = ApplicationResult::APPLY_SECOND; else if ((t1 == rA2 || t1 == rA2u || t1 == rA2B) && (t2 == rA1 || t2 == rA1B)) res = ApplicationResult::APPLY_FIRST; else if ((t2 == rA2 || t2 == rA2u || t2 == rA2B) && (t1 == rA1 || t1 == rA1B)) res = ApplicationResult::APPLY_SECOND; //Privilege A2B over A2 and A1B over A1 else if ((t1==rA2B && (t2==rA2 || t2==rA2u)) || (t1==rA1B && t2==rA1)) res = ApplicationResult::APPLY_FIRST; else if ((t2==rA2B && (t1==rA2 || t1==rA2u)) || (t2==rA1B && t1==rA1)) res = ApplicationResult::APPLY_SECOND; //Break ties randomly else { swap_ties++; res = rand() % 2 == 0 ? ApplicationResult::APPLY_FIRST : ApplicationResult::APPLY_SECOND; } } return res; } } assert(false); return ApplicationResult::NO_APPLICATION; } //Input: a context for a swap rule //Output: true if rule application is allowed bool ProofGraph::allowSwapRuleForStrongerWeakerInterpolant(RuleContext & ra, std::function getVarClass, bool restructureForStronger) { rul_type t = ra.getType(); // Light technique: no duplications allowed if (getNode(ra.getW())->getNumResolvents() > 1) return false; // No creation of new nodes or simplifications allowed if (t == rA1 || t == rA1B || t == rB2 || t == rA1prime) return false; assert(t == rA2 || t == rA2B || t == rA2u); // Check colors of the two pivots icolor_t piv_w_color = getVarClass(getNode(ra.getW())->getPivot()); icolor_t piv_v_color = getVarClass(getNode(ra.getV())->getPivot()); if (restructureForStronger) { // The new interpolant is stronger than the original one for the following // pairs of pivot colors: (b,a) (ab,a) (b,ab) return (piv_w_color == icolor_t::I_B && piv_v_color == icolor_t::I_A) || (piv_w_color == icolor_t::I_AB && piv_v_color == icolor_t::I_A ) || (piv_w_color == icolor_t::I_B && piv_v_color == icolor_t::I_AB); } else { // restructure for weaker interpolant // The new interpolant is stronger than the original one for the following // pairs of pivot colors: (a,b) (a,ab) (ab,b) return (piv_w_color == icolor_t::I_A && piv_v_color == icolor_t::I_B) || (piv_w_color == icolor_t::I_A && piv_v_color == icolor_t::I_AB ) || (piv_w_color == icolor_t::I_AB && piv_v_color == icolor_t::I_B); } assert(false); // UNREACHABLE return false; } //Input: a pair of left/right contexts ApplicationResult ProofGraph::handleRuleApplicationForStrongerWeakerInterpolant(RuleContext & ra1, RuleContext & ra2, std::function allowSwap) { // Check need for duplication bool dupl1, dupl2; rul_type t1 = ra1.getType(); rul_type t2 = ra2.getType(); bool is1cut = isCutRule(t1); bool is2cut = isCutRule(t2); bool is1swap = isSwapRule(t1); bool is2swap = isSwapRule(t2); //rA1,rA2,rA2u,rA1B,rA2B,rA1undo,rB2k,rB3,rB1,rB2 //Neither applicable if (ra1.disabled() && ra2.disabled()) return ApplicationResult::NO_APPLICATION; //First not applicable else if (ra1.disabled() && ra2.enabled()) { bool allowed2; if (is2cut) allowed2 = false; else if (is2swap) allowed2 = allowSwap(ra2); else throw OsmtInternalException("Unexpected situation in rule application"); return allowed2 ? ApplicationResult::APPLY_SECOND : ApplicationResult::NO_APPLICATION; } //Second not applicable else if(ra1.enabled() && ra2.disabled()) { bool allowed1; if( is1cut ) allowed1 = false; else if( is1swap ) allowed1 = allowSwap(ra1); else throw OsmtInternalException("Unexpected situation in rule application"); return allowed1 ? ApplicationResult::APPLY_FIRST : ApplicationResult::NO_APPLICATION; } //Both applicable else if (ra1.enabled() && ra2.enabled()) { bool allowed1, allowed2; if (is1cut) allowed1 = false; else if (is1swap) allowed1 = allowSwap(ra1); else throw OsmtInternalException("Unexpected situation in rule application"); if (is2cut) allowed2 = false; else if (is2swap) allowed2 = allowSwap(ra2); else throw OsmtInternalException("Unexpected situation in rule application"); //Neither allowed if (!allowed1 && !allowed2) return ApplicationResult::NO_APPLICATION; //First allowed else if (allowed1 && !allowed2) return ApplicationResult::APPLY_FIRST; //Second allowed else if (!allowed1 && allowed2) return ApplicationResult::APPLY_SECOND; //Both allowed else if (allowed1 && allowed2) { ApplicationResult res = ApplicationResult::NO_APPLICATION; //Case one cuts, the other swaps: privilege cut if (is1cut && is2swap) res = ApplicationResult::APPLY_FIRST; else if (is2cut && is1swap) res = ApplicationResult::APPLY_SECOND; //Case both cut else if (is1cut && is2cut) { //Privilege B3 over B1 and B2 if (t1 == rB3 && t2 != rB3) res = ApplicationResult::APPLY_FIRST; else if (t1 != rB3 && t2 == rB3) res = ApplicationResult::APPLY_SECOND; //Break ties randomly else { res = rand() % 2 == 0 ? ApplicationResult::APPLY_FIRST : ApplicationResult::APPLY_SECOND; } } //Case both swap else if (is2swap && is1swap) { dupl1 = (getNode(ra1.getW())->getNumResolvents() > 1); dupl2 = (getNode(ra2.getW())->getNumResolvents() > 1); //Privilege the one not duplicating if (dupl1 && !dupl2) res = ApplicationResult::APPLY_SECOND; else if (!dupl1 && dupl2) res = ApplicationResult::APPLY_FIRST; //Privilege A1undo, then B2k, then A2 over A1 else if (t1 == rA1prime && t2 != rA1prime) res = ApplicationResult::APPLY_FIRST; else if (t1 != rA1prime && t2 == rA1prime) res = ApplicationResult::APPLY_SECOND; else if (t1 == rB2 && t2 != rB2) res = ApplicationResult::APPLY_FIRST; else if (t1 != rB2 && t2 == rB2) res = ApplicationResult::APPLY_SECOND; else if ((t1 == rA2 || t1 == rA2u || t1 == rA2B) && (t2 == rA1 || t2 == rA1B)) res = ApplicationResult::APPLY_FIRST; else if ((t2 == rA2 || t2 == rA2u || t2 == rA2B) && (t1 == rA1 || t1 == rA1B)) res = ApplicationResult::APPLY_SECOND; //Privilege A2B over A2 and A1B over A1 else if ((t1 == rA2B && (t2 == rA2 || t2 == rA2u)) || (t1 == rA1B && t2 == rA1)) res = ApplicationResult::APPLY_FIRST; else if ((t2 == rA2B && (t1 == rA2 || t1 == rA2u)) || (t2 == rA1B && t1 == rA1)) res = ApplicationResult::APPLY_SECOND; //Break ties randomly else { swap_ties++; res = rand() % 2 == 0 ? ApplicationResult::APPLY_FIRST : ApplicationResult::APPLY_SECOND; } } return res; } } assert(false); return ApplicationResult::NO_APPLICATION; } //Input: a context for a swap rule //Output: true if rule application is allowed bool ProofGraph::allowSwapRuleForCNFinterpolant(RuleContext& ra, std::function getVarClass) { bool dupl = (getNode(ra.getW())->getNumResolvents() > 1); // McMillan should be used for generating an interpolant in CNF // Check colors of the two pivots // NOTE with McMillan algorithm the color of a pivot is always A or B icolor_t piv_w_color = getVarClass(getNode(ra.getW())->getPivot()); if (piv_w_color == icolor_t::I_AB) piv_w_color = icolor_t::I_B; icolor_t piv_v_color = getVarClass(getNode(ra.getV())->getPivot()); if (piv_v_color == icolor_t::I_AB) piv_v_color = icolor_t::I_B; assert(piv_w_color != icolor_t::I_AB and piv_v_color != icolor_t::I_AB); // NOTE A-colored pivots must stay above B-colored pivots if(piv_w_color == piv_v_color) { return false; } else if (piv_w_color == icolor_t::I_B and piv_v_color == icolor_t::I_A) { return not dupl; } else if (piv_w_color == icolor_t::I_A and piv_v_color == icolor_t::I_B) { return false; } else throw OsmtInternalException("Unexpected situation in rule application"); } using ApplicationResult = ProofGraph::ApplicationResult; //Input: a pair of left/right contexts //Output: 0,1,2 to apply no rule, rule1, rule2 ApplicationResult ProofGraph::handleRuleApplicationForCNFinterpolant(RuleContext & ra1, RuleContext & ra2, std::function allowSwap) { // Cut application rule bool(ProofGraph::*allowCut)(RuleContext& ra) = &ProofGraph::allowCutRuleForReduction; // Check need for duplication bool dupl1, dupl2; bool allowed1, allowed2; rul_type t1=ra1.getType(); rul_type t2=ra2.getType(); bool is1cut=isCutRule(t1); bool is2cut=isCutRule(t2); bool is1swap=isSwapRule(t1); bool is2swap=isSwapRule(t2); //rA1,rA2,rA2u,rA1B,rA2B,rA1undo,rB2k,rB3,rB1,rB2 //Neither applicable if (ra1.disabled() && ra2.disabled()) { return ApplicationResult::NO_APPLICATION; } //First not applicable else if (ra1.disabled() && ra2.enabled()) { if (is2cut) allowed2 = (*this.*allowCut)(ra2); else if(is2swap) allowed2 = allowSwap(ra2); else throw OsmtInternalException("Unexpected situation in rule application"); return allowed2 ? ApplicationResult::APPLY_SECOND : ApplicationResult::NO_APPLICATION; } //Second not applicable else if (ra1.enabled() && ra2.disabled()) { if (is1cut) allowed1 = (*this.*allowCut)(ra1); else if (is1swap) allowed1 = allowSwap(ra1); else throw OsmtInternalException("Unexpected situation in rule application"); return allowed1 ? ApplicationResult::APPLY_FIRST : ApplicationResult::NO_APPLICATION; } //Both applicable else if (ra1.enabled() && ra2.enabled()) { if (is1cut) allowed1 = (*this.*allowCut)(ra1); else if (is1swap) allowed1 = allowSwap(ra1); else throw OsmtInternalException("Unexpected situation in rule application"); if (is2cut) allowed2 = (*this.*allowCut)(ra2); else if (is2swap) allowed2 = allowSwap(ra2); else throw OsmtInternalException("Unexpected situation in rule application"); //Neither allowed if(!allowed1 && !allowed2) return ApplicationResult::NO_APPLICATION; //First allowed else if (allowed1 && !allowed2) return ApplicationResult::APPLY_FIRST; //Second allowed else if (!allowed1 && allowed2) return ApplicationResult::APPLY_SECOND; //Both allowed else if (allowed1 && allowed2) { ApplicationResult res = ApplicationResult::NO_APPLICATION; //Case one cuts, the other swaps: privilege cut if (is1cut && is2swap) res = ApplicationResult::APPLY_FIRST; else if (is2cut && is1swap) res = ApplicationResult::APPLY_SECOND; //Case both cut else if (is1cut && is2cut) { //Privilege B3 over B1 and B2 if (t1==rB3 && t2 != rB3) res = ApplicationResult::APPLY_FIRST; else if (t1 != rB3 && t2 == rB3) res = ApplicationResult::APPLY_SECOND; //Break ties randomly else { res = rand() % 2 == 0 ? ApplicationResult::APPLY_FIRST : ApplicationResult::APPLY_SECOND; } } //Case both swap else if (is2swap && is1swap) { dupl1 = (getNode(ra1.getW())->getNumResolvents() > 1); dupl2 = (getNode(ra2.getW())->getNumResolvents() > 1); //Privilege the one not duplicating if (dupl1 && !dupl2) res = ApplicationResult::APPLY_SECOND; else if (!dupl1 && dupl2) res = ApplicationResult::APPLY_FIRST; //Privilege A1undo, then B2k, then A2 over A1 else if (t1 == rA1prime && t2 != rA1prime) res = ApplicationResult::APPLY_FIRST; else if (t1 != rA1prime && t2 == rA1prime) res = ApplicationResult::APPLY_SECOND; else if (t1 == rB2 && t2!=rB2) res = ApplicationResult::APPLY_FIRST; else if (t1 != rB2 && t2==rB2) res = ApplicationResult::APPLY_SECOND; else if ((t1 == rA2 || t1==rA2u || t1==rA2B) && (t2==rA1 || t2==rA1B)) res = ApplicationResult::APPLY_FIRST; else if ((t2 == rA2 || t2==rA2u || t2==rA2B) && (t1==rA1 || t1==rA1B)) res = ApplicationResult::APPLY_SECOND; //Privilege A2B over A2 and A1B over A1 else if ((t1 == rA2B && (t2 == rA2 || t2 == rA2u)) || (t1 == rA1B && t2 == rA1)) res = ApplicationResult::APPLY_FIRST; else if ((t2 == rA2B && (t1 == rA2 || t1 == rA2u)) || (t2 == rA1B && t1 == rA1)) res = ApplicationResult::APPLY_SECOND; //Break ties randomly else { swap_ties++; res = rand() % 2 == 0 ? ApplicationResult::APPLY_FIRST : ApplicationResult::APPLY_SECOND; } } return res; } } assert(false); return ApplicationResult::NO_APPLICATION; } //Input: node to be replaced by either antecedent during restructuring //Output: true if ant1 is chosen, false if ant2 is chosen bool ProofGraph::chooseReplacingAntecedent( ProofNode* n ) { //1) If an antecedent has only one resolvent, choose the other //2) If both (or none) have only one resolvent, choose the smaller clause //3) Break ties randomly bool choose_ant1; assert(n->getAnt1()!=NULL && n->getAnt2()!=NULL); if(n->getAnt1()->getNumResolvents()==1 && n->getAnt2()->getNumResolvents()>1) choose_ant1=false; else if(n->getAnt1()->getNumResolvents()>1 && n->getAnt2()->getNumResolvents()==1) choose_ant1=true; else { if(n->getAnt1()->getClauseSize()> n->getAnt2()->getClauseSize()) choose_ant1=false; else if(n->getAnt2()->getClauseSize()> n->getAnt1()->getClauseSize()) choose_ant1=true; else { if(rand()%2==0)choose_ant1=true; else choose_ant1=false; } } return choose_ant1; } // HEURISTICS TO GUIDE SIMPLIFICATION OF INTERPOLANTS // // TABLE OF TRANSFORMATIONS //(notice that A1 always produces an interpolant more complex but equivalent to the original one) // // I1 I2 // s I3 // t // // |----------------------------------------------------------------------------------------------------------------------------------------------------------| // | piv col | Original | | After A2,B2k | After B1,B2 | After B3 | // |----------------------------------------------------------------------------------------------------------------------------------------------------------| // | A A | I1 or I2 or I3 | = | I1 or I3 or I2 | I1 or I3 | I2 | // | A B | (I1 or I2) and I3 | => | (I1 and I3) or I2 | I1 and I3 | | // | B B | I1 and I2 and I3 | = | I1 and I3 and I2 | I1 and I3 | | // | B A | (I1 and I2) or I3 | <= | (I1 or I3) and I2 | I1 or I3 | | // | A AB | (t or I1 or I2) and (~t or I3) | => | ((I1 or t) and (I3 or ~t)) or I2 | (I1 or t) and (I3 or ~t) | | // | B AB | (t or (I1 and I2)) and (~t or I3) | <= | (I1 or t) and (I3 or ~t) and I2 | (I1 or t) and (I3 or ~t) | | // | AB A | ((s or I1) and (~s or I2)) or I3 | <= | (I1 or I3 or s) and (I2 or ~s) | I1 or I3 | | // | AB B | (s or I1) and (~s or I2) and I3 | => | (s or (I1 and I3)) and (~s or I2) | I1 and I3 | | // | AB AB | (((s or I1) and (~s or I2)) or t) and (I3 or ~t) | ? | (((I1 or t) and (I3 or ~t)) or s) and (I2 or ~s) | (I1 or t) and (I3 or ~t) | | // |----------------------------------------------------------------------------------------------------------------------------------------------------------| // SIMPLIFICATIONS TABLE WHEN HAVING true and false // |--------------------------------------------------------------------------------------------------------------------- // | piv col | Original | | After A2,B2k | // |--------------------------------------------------------------------------------------------------------------------- // | A B | (I1 or I2) and I3 | => | (I1 and I3) or I2 | // | B A | (I1 and I2) or I3 | <= | (I1 or I3) and I2 | // | A AB | (t or I1 or I2) and (~t or I3) | => | ((I1 or t) and (I3 or ~t)) or I2 | // | B AB | (t or (I1 and I2)) and (~t or I3) | <= | (I1 or t) and (I3 or ~t) and I2 | // | AB A | ((s or I1) and (~s or I2)) or I3 | <= | (I1 or I3 or s) and (I2 or ~s) | // | AB B | (s or I1) and (~s or I2) and I3 | => | (s or (I1 and I3)) and (~s or I2) | // | AB AB | (((s or I1) and (~s or I2)) or t) and (I3 or ~t) | ? | (((I1 or t) and (I3 or ~t)) or s) and (I2 or ~s) | // |--------------------------------------------------------------------------------------------------------------------- // // A B if I2=true I3 -> true // B A if I2=false I3 -> false // A AB if I2=true (~t or I3) -> true // B AB if I2=false t and (~t or I3) -> false // AB A if I1=true (~s or I2) or I3 -> (I2 or ~s) // AB B ? // AB AB ? opensmt-2.5.2/src/proof/PGMain.cc000066400000000000000000000260551445011647600165630ustar00rootroot00000000000000/********************************************************************* Author: Simone Fulvio Rollini Periplo -- Copyright (C) 2013, Simone Fulvio Rollini Periplo is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. Periplo 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Periplo. If not, see . *********************************************************************/ #include "PG.h" #include "SystemQueries.h" // Manipulates proofs void ProofGraph::printProofGraph( ) { assert( printProofDotty() > 0); // Fill proof fillProofGraph(); //Print original proof if( verbose() > 0 ) std::cerr << "# Outputting dotty proof" << '\n'; std::ofstream dotty( "proof.dot", std::ofstream::out | std::ofstream::trunc); printProofAsDotty( dotty ); emptyProofGraph(); } void ProofGraph::transfProofForReduction( ) { // Initialize C-random number generator with fixed seed to ensure reproducibility srand(config.getRandomSeed()); // Fill proof fillProofGraph(); // Time left for transformation double solvingTime = cpuTime( ); // size_t size=0; int numnodes=0; int numedges=0; int numleaves=0; int numvars=0; double avgdeg=0; int maxclasize=0; double avgclasize=0; int numunary=0; // double varclasize=0; if ( verbose() ) { getGraphInfo( ); // size = graph.size( ); numnodes = num_nodes; numedges = num_edges; numleaves = num_leaves; numvars = proof_variables.size(); avgdeg = (double)numedges / (double)numnodes; maxclasize = max_cla_size; avgclasize = av_cla_size; numunary = num_unary; // varclasize = var_cla_size; } double time=0; time = doReduction( solvingTime ); if( proofCheck() ) { checkProof( true ); unsigned rem = cleanProofGraph( ); if(verbose() > 0) std::cerr << "# Cleaned " << rem << " residual nodes" << '\n'; if(rem > 0) checkProof( true ); } if ( verbose() > 0 ) { getGraphInfo( ); double perc_nodes=(((double)num_nodes-(double)numnodes)/(double)numnodes)*100; double perc_edges=(((double)num_edges-(double)numedges)/(double)numedges)*100; double perc_leaves=(((double)num_leaves-(double)numleaves)/(double)numleaves)*100; std::cerr << "#" << '\n'; std::cerr << "# ------------------------------------" << '\n'; std::cerr << "# PROOF GRAPH REDUCTION STATISTICS " << '\n'; std::cerr << "# ------------------------------------" << '\n'; std::cerr << "# Structural properties" << '\n'; std::cerr << "# ---------------------" << '\n'; std::cerr << "# Actual num proof variables.: "; fprintf( stderr, "%-10d %-10d\n", numvars, (int)proof_variables.size() ); std::cerr << "# Nodes......................: "; fprintf( stderr, "%-10d %-10d\n", numnodes, num_nodes ); std::cerr << "# Nodes variation............: "; fprintf( stderr, "%-9.2f %%\n", perc_nodes ); std::cerr << "# Leaves.....................: "; fprintf( stderr, "%-10d %-10d\n", numleaves, num_leaves ); std::cerr << "# Leaves variation...........: "; fprintf( stderr, "%-9.2f %%\n", perc_leaves ); std::cerr << "# Edges......................: "; fprintf( stderr, "%-10d %-10d\n", numedges, num_edges ); std::cerr << "# Edges variation............: "; fprintf( stderr, "%-9.2f %%\n", perc_edges ); //std::cerr << "# Graph vector size..........: "; //fprintf( stderr, "%-10ld %-10ld\n", size, graph.size( ) ); std::cerr << "# Average degree.............: "; fprintf( stderr, "%-10.2f %-10.2f\n", avgdeg, (double)num_edges / (double)num_nodes ); std::cerr << "# Unary clauses..............: "; fprintf( stderr, "%-10d %-10d\n", numunary, num_unary ); std::cerr << "# Max clause size............: "; fprintf( stderr, "%-10d %-10d\n", maxclasize, max_cla_size ); std::cerr << "# Average clause size........: "; fprintf( stderr, "%-10.2f %-10.2f\n", avgclasize, av_cla_size ); //std::cerr << "# Variance clause size.......: "; //fprintf( stderr, "%-10.2f %-10.2f\n", varclasize, var_cla_size ); std::cerr << "# -------------------------" << '\n'; std::cerr << "# Transformation statistics" << '\n'; std::cerr << "# -------------------------" << '\n'; std::cerr << "# Graph building time........: " << building_time << " s" << '\n'; std::cerr << "# Transformation time........: " << time << " s" << '\n'; //std::cerr << "# Duplications...............: " << num_dup << '\n'; //std::cerr << "# Node additions due to A1...: " << num_node_add_A1 << '\n'; std::cerr << "# ---------------------------" << '\n'; std::cerr << "# Rules application statistics" << '\n'; std::cerr << "# ---------------------------" << '\n'; std::cerr << "# A1.........................: " << A1 << '\n'; std::cerr << "# A1'........................: " << A1prime << '\n'; std::cerr << "# A1 to B....................: " << A1B << '\n'; std::cerr << "# A2.........................: " << A2 << '\n'; std::cerr << "# A2 to B....................: " << A2B << '\n'; std::cerr << "# A2 unary...................: " << A2U << '\n'; std::cerr << "# B1.........................: " << B1 << '\n'; std::cerr << "# B2'........................: " << B2prime << '\n'; std::cerr << "# B2.........................: " << B2 << '\n'; std::cerr << "# B3.........................: " << B3 << '\n'; std::cerr << "# Duplications...............: " << duplications << '\n'; std::cerr << "# Swap ties..................: " << swap_ties << '\n'; std::cerr << "# ---------------------------" << '\n'; } /* if ( verbose() > 0 ) { uint64_t mem_used = memUsed(); reportff( "# Memory used after reducing the proof: %.3f MB\n", mem_used == 0 ? 0 : mem_used / 1048576.0 ); }*/ if( printProofDotty() == 1 ) { //Print reduced proof if( verbose() > 0 ) std::cerr << "# Outputting dotty proof reduced" << '\n'; std::ofstream dottyred( "proof_reduced.dot" ); printProofAsDotty( dottyred ); } // TODO return reduced proof in SMTLIB2 format // Normalize antecedents order ( for interpolation ) normalizeAntecedentOrder(); // Empty proof emptyProofGraph(); } void ProofGraph::transfProofForCNFInterpolants(std::function getVarClass) { if (verbose() > 0) std::cerr << "; Proof transformation for interpolants (partially) in CNF" << '\n'; fillProofGraph(); proofTransformAndRestructure(-1, -1, true, [this, &getVarClass](RuleContext & ra1, RuleContext & ra2) { return this->handleRuleApplicationForCNFinterpolant(ra1, ra2, [this, &getVarClass](RuleContext & ra) { return this->allowSwapRuleForCNFinterpolant(ra, getVarClass); }); }); checkProof(true); normalizeAntecedentOrder(); emptyProofGraph(); printRuleApplicationStatus(); } // Performs reduction double ProofGraph::doReduction(double solving_time) { if (enabledTransfTraversals()) { if ((ratioReductionSolvingTime() > 0 && reductionTime() > 0) || (ratioReductionSolvingTime() > 0 && numGraphTraversals() > 0) || (reductionTime() > 0 && numGraphTraversals() > 0) || (ratioReductionSolvingTime() == 0 && reductionTime() == 0 && numGraphTraversals() == 0)) { throw OsmtApiException("Please set either ratio or time for reduction or number of proof traversals"); } } if (reductionLoops() == 0) throw OsmtApiException("Please set number of global reduction loops to at least 1"); //Transformation time calculation double time_init = 0; double time_end = 0; double red_time = 0; //Number of inner transformation loops //-1 for exhaustiveness //int num_transf_loops=0; // MB: not used? //Number of outer transformation loops //useful for alternation with recycle pivots int num_global_reduction_loops = 0; // Time available for transformations // -1 for exhaustiveness double ratio; if (ratioReductionSolvingTime() > 0) { // Ratio transformation time/solving time ratio = ratioReductionSolvingTime(); red_time = ratio * solving_time; } else if (reductionTime() > 0) { red_time = reductionTime(); } //For each outer loop, recycle pivots algorithm is executed, followed by a certain //number of transformation loops, or by a single restructuring loop //Each global loop is given an equal fraction of available time num_global_reduction_loops = reductionLoops(); if (verbose() > 0) { std::cerr << "# Compressing proof, " << num_global_reduction_loops << " global iteration(s) " << '\n'; if (enabledPushDownUnits()) std::cerr << "# preceded by LowerUnits" << '\n'; std::cerr << "# Each global iteration consists of: " << '\n'; if (enabledStructuralHashing()) std::cerr << "# StructuralHashing" << '\n'; if (enabledRecyclePivots()) std::cerr << "# RecyclePivotsWithIntersection" << '\n'; if (enabledTransfTraversals()) { std::cerr << "# ReduceAndExpose "; if (ratioReductionSolvingTime() > 0 || reductionTime() > 0) std::cerr << "with overall timeout " << red_time << " sec(s) " << '\n'; else if (numGraphTraversals() > 0) std::cerr << "with " << numGraphTraversals() << " graph traversal(s) " << '\n'; } std::cerr << "#" << '\n'; } double spent_time = 0, i_time = 0; time_init = cpuTime(); if (enabledPushDownUnits()) recycleUnits(); for (int k = 1; k <= num_global_reduction_loops; k++) { if (verbose() > 0) std::cerr << "# Global iteration " << k << '\n'; i_time = cpuTime(); if (switchToRPHashing()) { if (enabledRecyclePivots()) recyclePivotsIter(); if (enabledStructuralHashing()) proofPostStructuralHashing(); } else { if (enabledStructuralHashing()) proofPostStructuralHashing(); if (enabledRecyclePivots()) recyclePivotsIter(); } spent_time = cpuTime() - i_time; // Not really meaningful to do graph traversals in the last global loop if (enabledTransfTraversals() && k <= num_global_reduction_loops - 1) { auto handleRuleApplication = [this](RuleContext & ra1, RuleContext & ra2) { return this->handleRuleApplicationForReduction(ra1, ra2); }; if (ratioReductionSolvingTime() > 0 || reductionTime() > 0) { // Available time = global loop timeout - time used for recycle pivots // Already out of time for transformation rules if (red_time - spent_time <= 0) { continue; } proofTransformAndRestructure(red_time - spent_time, -1, true, handleRuleApplication); } if (numGraphTraversals() > 0) { proofTransformAndRestructure(-1, numGraphTraversals(), true, handleRuleApplication); } } } time_end = cpuTime(); return time_end - time_init; } opensmt-2.5.2/src/proof/PGPrint.cc000066400000000000000000000150431445011647600167660ustar00rootroot00000000000000/* * Copyright (c) 2013, Simone Fulvio Rollini * * SPDX-License-Identifier: MIT * */ #include "PG.h" // Prints resolution proof graph to a dot file, // with proper colors void ProofGraph::printProofAsDotty(std::ostream & out) { // Visited nodes vector std::vector visited_dotty(getGraphSize(), false); // Visit proof graph from sink via DFS std::vector q; q.push_back(getRoot()); out << "digraph proof {" << '\n'; while (!q.empty()) { ProofNode * node = q.back(); // Remove node q.pop_back(); // Node not yet visited if (!visited_dotty.at(node->getId())) { //Clean //clauseSort(node->clause); // Print node std::string typ; std::string color = ""; switch (node->getType()) { case clause_type::CLA_ORIG: typ = "cls_"; out << typ << node->getId() << "[shape=plaintext, label=\"c" << node->getId() << " : "; printClause(node, out); out << "\", color=\"lightblue\","; out << " fontcolor=\"black\", style=\"filled\"]" << '\n'; break; case clause_type::CLA_THEORY: typ = "the_"; out << typ << node->getId() << "[shape=plaintext, label=\"c" << node->getId() << " : "; if (!node->getClause().empty()) { printClause(node, out); } else out << "+"; // learnt clause out << "\", color=\"grey\""; out << ", style=\"filled\"]" << '\n'; break; case clause_type::CLA_LEARNT: typ = "lea_"; out << typ << node->getId() << "[shape=plaintext, label=\"c" << node->getId() << " : "; if (!node->getClause().empty()) { printClause(node, out); } else out << "+"; // learnt clause out << "\", color=\"orange\""; out << ", style=\"filled\"]" << '\n'; break; case clause_type::CLA_DERIVED: typ = "der_"; out << typ << node->getId() << "[shape=plaintext, label=\"c" << node->getId() << " : "; if (!node->getClause().empty()) { printClause(node, out); } else out << "+"; // internal derived clause out << "\", color=\"green\""; out << ", style=\"filled\"]" << '\n'; break; case clause_type::CLA_ASSUMPTION: typ = "ass_"; out << typ << node->getId() << "[shape=plaintext, label=\"c" << node->getId() << " : "; assert(!node->getClause().empty()); printClause(node, out); out << "\", color=\"yellow\""; out << ", style=\"filled\"]" << '\n'; break; case clause_type::CLA_SPLIT: typ = "spl_"; out << typ << node->getId() << "[shape=plaintext, label=\"c" << node->getId() << " : "; assert(not node->getClause().empty()); printClause(node, out); out << "\", color=\"purple\""; out << ", style=\"filled\"]" << '\n'; break; default: assert(false); typ = ""; break; } // Print edges from parents (if existing) auto addEdgeToParent = [&out, &typ](const ProofNode & parent, const ProofNode & child) { std::string t1; switch (parent.getType()) { case clause_type::CLA_ORIG: t1 = "cls_"; break; case clause_type::CLA_THEORY: t1 = "the_"; break; case clause_type::CLA_LEARNT: t1 = "lea_"; break; case clause_type::CLA_DERIVED: t1 = "der_"; break; case clause_type::CLA_ASSUMPTION: t1 = "ass_"; break; case clause_type::CLA_SPLIT: t1 = "spl_"; break; default: assert(false); t1 = ""; break; } out << t1 << parent.getId() << " -> " << typ << child.getId() << '\n'; }; ProofNode * r1 = node->getAnt1(); ProofNode * r2 = node->getAnt2(); if (r1 != nullptr) { addEdgeToParent(*r1, *node); // Enqueue the parent q.push_back(r1); } if (r2 != nullptr) { addEdgeToParent(*r2, *node); // Enqueue the parent q.push_back(r2); } //Mark node as visited visited_dotty[node->getId()] = true; } } out << "}" << '\n'; } void ProofGraph::printClause(ProofNode* n) { assert(n); std::vector& cl=n->getClause(); std::cerr << n->getId(); if(!n->isLeaf()) std::cerr << "(" << n->getAnt1()->getId() << "," << n->getAnt2()->getId() << ")"; std::cerr << ": "; for(size_t k=0;k & cl = n->getClause(); for (size_t k = 0 ; k < cl.size(); k++) { if(sign(cl[k])) { os << "-"; } os << var(cl[k]) << " "; } } void ProofGraph::printRuleApplicationStatus() { std::cerr << "# Rules application status " << '\n'; std::cerr << "# A1: " << A1 << '\n'; std::cerr << "# A1prime: " << A1prime << '\n'; std::cerr << "# A1B: " << A1B << '\n'; std::cerr << "# A2: " << A2 << '\n'; std::cerr << "# A2B: " << A2B << '\n'; std::cerr << "# A2U: " << A2U << '\n'; std::cerr << "# B1: " << B1 << '\n'; std::cerr << "# B2prime: " << B2prime << '\n'; std::cerr << "# B2: " << B2 << '\n'; std::cerr << "# B3: " << B3 << '\n'; std::cerr << "# duplications: " << duplications << '\n'; std::cerr << "# swap_ties: " << swap_ties << '\n'; } opensmt-2.5.2/src/proof/PGRules.cc000066400000000000000000000411771445011647600167730ustar00rootroot00000000000000/********************************************************************* Author: Simone Fulvio Rollini Periplo -- Copyright (C) 2013, Simone Fulvio Rollini Periplo is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. Periplo 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Periplo. If not, see . *********************************************************************/ #include "PG.h" #include "OsmtInternalException.h" // Check if a rule can be applied and if so, determine its context // v3 and v are given in input // ra is modified to contain the 5 nodes context // Return false if w has not antecedents (that is, v1 and v2 don't exist) RuleContext ProofGraph::getRuleContext(clauseid_t idv3, clauseid_t idv) { RuleContext ra; ProofNode* v3=getNode(idv3); ProofNode* v=getNode(idv); assert((size_t)idv3getAnt1()==v3 || v->getAnt2()==v3); // assert(v->getAnt1()->getId()==idv3 || v->getAnt2()->getId()==idv3); // Determine w, i.e. second antecedent v ProofNode* w=(v3==v->getAnt1()) ? v->getAnt2() : v->getAnt1(); // If w has no antecedents, no rule can be applied if(w->isLeaf()) return ra; // Resolution pivots Var t0=w->getPivot(); Var t1=v->getPivot(); // w antecedents are v1,v2; clauses are (t0 t1 C1) and (~t0 C2) // w clause is (t1 C1 C2) // v antecedents are w and v3; clauses are w clause and (~t1, C3) // v clause is (C1 C2 C3) // Determine sign of t1 and t0 (if present) in v3 bool t0_in_C3 = false; bool sign_t0_C3 = false; short r0 = v3->hasOccurrenceBin(t0); if(r0 != -1) { t0_in_C3 = true; sign_t0_C3 = (r0 == 0)? false : true; } // Check condition: t1 not in C2 bool t1_in_ant1=false, t1_in_ant2 =false; bool sign_t0_ant1=false, sign_t0_ant2=false; bool sign_t1_ant1=false, sign_t1_ant2=false; (void)sign_t1_ant1;(void)sign_t1_ant2; // MB: For some reason this are not read ever. // Sign of t0 short r1 = w->getAnt1()->hasOccurrenceBin(t0); assert(r1 != -1); if(r1 != -1) { sign_t0_ant1 = (r1 == 0)? false : true; } // Look for t1 r1 = w->getAnt1()->hasOccurrenceBin(t1); if(r1 != -1) { t1_in_ant1 = true; sign_t1_ant1 = (r1 == 0)? false : true; } // Sign of t0 short r2; if( proofCheck() ) { r2 = w->getAnt2()->hasOccurrenceBin(t0); assert(r2 != -1); sign_t0_ant2 = (r2 == 0)? false : true; assert(sign_t0_ant2 == (!sign_t0_ant1)); } else sign_t0_ant2 = (!sign_t0_ant1); // Look for t1 r2 = w->getAnt2()->hasOccurrenceBin(t1); if(r2 != -1) { t1_in_ant2 = true; sign_t1_ant2 = (r2 == 0)? false : true; } // t1 found in both antecedents clauses? bool t1_in_C2=t1_in_ant1 && t1_in_ant2; bool sign_t0_v1 = false; // MB: Warning! this variable was previously unintialized and there is a path to usage without setting its value! // Determine v1 and v2 ProofNode * v1 = nullptr; ProofNode * v2 = nullptr; // Case t1 not in C2 if(!t1_in_C2) { if(t1_in_ant1) { v1=w->getAnt1(); sign_t0_v1=sign_t0_ant1; } else { v1=w->getAnt2(); sign_t0_v1=sign_t0_ant2; } v2=(v1==w->getAnt1()) ? w->getAnt2() : w->getAnt1(); assert(v1!=v2); } // Case t1 in C2 else { // If t0 in C3 we can determine who is v1 and // who is v2 looking at the sign of t0 // otherwise they are interchangeable if(t0_in_C3) { v1=(sign_t0_ant1==sign_t0_C3) ? w->getAnt1() : w->getAnt2(); v2=(v1==w->getAnt1()) ? w->getAnt2() : w->getAnt1(); } // As we like else { v1=w->getAnt1(); v2=w->getAnt2(); } } assert(v2); //Update applicability info ra.cv1=v1->getId(); ra.cv2=v2->getId(); ra.cw=w->getId(); ra.cv3=v3->getId(); ra.cv=v->getId(); assert(ra.cv == idv); assert(idv == v->getId()); assert(v == graph[idv]); assert(v == graph[ra.cv]); //Rules application if(!t1_in_C2 && !t0_in_C3) { //A1 undo case if((v3->getAnt1()==v2 || v3->getAnt2()==v2) && (v3->getPivot()==w->getPivot()) && (/*v3->getNumResolvents()==1 && */w->getNumResolvents()==1)) ra.type=rA1prime; //A2 leading to B case else if(v3->getAnt1()!=NULL && v3->getAnt2()!=NULL && w->getPivot()==v3->getPivot()) ra.type=rA2B; //A2 unary case else if(graph[ra.cv2]->getClauseSize()==1) ra.type=rA2u; else ra.type=rA2; return ra; } else if(t1_in_C2 && !t0_in_C3) { if(graph[ra.cv3]->getAnt1()!=NULL && graph[ra.cw]->getPivot()==graph[ra.cv3]->getPivot()) ra.type=rA1B; else ra.type=rA1; return ra; } else if(t1_in_C2 && t0_in_C3) { ra.type=rB1; return ra; } else if(!t1_in_C2 && t0_in_C3 && sign_t0_C3==sign_t0_v1) { if(graph[ra.cv]->getClauseSize()==1) ra.type=rB2; else ra.type=rB2prime; return ra; } else if(!t1_in_C2 && t0_in_C3 && sign_t0_C3!=sign_t0_v1) { ra.type=rB3; return ra; } throw OsmtInternalException("Unknown reduction rule context"); } //Given a 5 nodes context, applies the corresponding rule clauseid_t ProofGraph::ruleApply(RuleContext& ra) { rul_type toApply=ra.getType(); assert(toApply!=rNO); assert(ra.getV1()!=static_cast(-1)); clauseid_t claid = 0; if(toApply==rA1 || toApply==rA1B) claid = applyRuleA1(ra); else if (toApply==rA1prime) applyRuleA1Prime(ra); else if(toApply==rA2 || toApply==rA2u || toApply==rA2B) applyRuleA2(ra); else if(toApply==rB1) applyRuleB1(ra); else if(toApply==rB2prime) applyRuleB2Prime(ra); else if(toApply==rB2) applyRuleB2(ra); else if(toApply==rB3) applyRuleB3(ra); return claid; } clauseid_t ProofGraph::applyRuleA1( RuleContext& ra ) { assert(getNode(ra.getW())->getNumResolvents()==1); //Transformation A1 //v1 is combined with v3 //v2 is combined with v3 //the results are combined together to give v ProofNode *v1=getNode(ra.getV1()),*v2=getNode(ra.getV2()), *w=getNode(ra.getW()),*v3=getNode(ra.getV3()),*v=getNode(ra.getV()); assert((v->getAnt1()==w && v->getAnt2()== v3) || (v->getAnt1()==v3 && v->getAnt2()== w)); assert((w->getAnt1()==v1 && w->getAnt2()== v2) || (w->getAnt1()==v2 && w->getAnt2()==v1)); //w' given by resolution v1,v3 over v pivot mergeClauses(v1->getClause(),v3->getClause(),w->getClause(),v->getPivot()); assert(w->getAnt1()==v2 || w->getAnt2()==v2); if(w->getAnt1()==v2) w->setAnt1(v3); else w->setAnt2(v3); v3->remRes(ra.getV()); v3->addRes(ra.getW()); //Creation new node y ProofNode* y=new ProofNode(); y->initClause(); //y given by resolution v2,v3 over v pivot mergeClauses(v2->getClause(),v3->getClause(),y->getClause(),v->getPivot()); v2->remRes(ra.getW()); y->setAnt1(v2); y->setAnt2(v3); y->setType(clause_type::CLA_DERIVED); y->setPivot(v->getPivot()); y->setId(graph.size()); y->addRes(ra.getV()); graph.push_back(y); v2->addRes(y->getId()); v3->addRes(y->getId()); // Return id new node clauseid_t claid = y->getId(); //v pivot becomes w pivot and viceversa Var aux; aux=w->getPivot(); w->setPivot(v->getPivot()); v->setPivot(aux); //v new antecedents are w and y if(v->getAnt1()==v3) v->setAnt1(y); else v->setAnt2(y); assert( (w->getAnt1()==v1 && w->getAnt2()==v3) || (w->getAnt2()==v1 && w->getAnt1()==v3)); assert( (v->getAnt1()==y && v->getAnt2()==w) || (v->getAnt2()==y && v->getAnt1()==w)); A1++; return claid; } void ProofGraph::applyRuleA1Prime( RuleContext& ra ) { assert(getNode(ra.getW())->getNumResolvents()==1); //Transformation to undo A1 effect -> factorization ProofNode *v1=getNode(ra.getV1()),*v2=getNode(ra.getV2()), *w=getNode(ra.getW()),*v3=getNode(ra.getV3()),*v=getNode(ra.getV()); assert((v->getAnt1()==w && v->getAnt2()== v3) || (v->getAnt1()==v3 && v->getAnt2()== w)); assert((w->getAnt1()==v1 && w->getAnt2()== v2) || (w->getAnt1()==v2 && w->getAnt2()==v1)); Var aux; ProofNode * newv2 = NULL; if(v3->getAnt1()==v2) newv2=v3->getAnt2(); else if(v3->getAnt2()==v2) newv2=v3->getAnt1(); assert(v3->getAnt1()==v2 || v3->getAnt2()==v2); //Go back to A1 initial configuration mergeClauses(v1->getClause(),newv2->getClause(),w->getClause(),v->getPivot()); //Update antecedents w->setAnt1(v1); w->setAnt2(newv2); v->setAnt1(w); v->setAnt2(v2); //Swap pivots aux=v->getPivot(); v->setPivot(w->getPivot()); w->setPivot(aux); //remove v3 if useless v2->remRes(ra.getW()); v2->addRes(ra.getV()); v3->remRes(ra.getV()); newv2->addRes(ra.getW()); // Gains w assert(v3->getAnt1()->getNumResolvents()>=2 && v3->getAnt2()->getNumResolvents()>=2); if(v3->getNumResolvents()==0) { newv2->remRes(v3->getId()); v2->remRes(v3->getId()); removeNode(v3->getId()); } A1prime++; } void ProofGraph::applyRuleA2( RuleContext& ra ) { assert(getNode(ra.getW())->getNumResolvents()==1); //Transformation A2(plain swap) //v2 and v3 change place //w changes but v doesn't ProofNode *v1=getNode(ra.getV1()),*v2=getNode(ra.getV2()), *w=getNode(ra.getW()),*v3=getNode(ra.getV3()),*v=getNode(ra.getV()); assert((v->getAnt1()==w && v->getAnt2()== v3) || (v->getAnt1()==v3 && v->getAnt2()== w)); assert((w->getAnt1()==v1 && w->getAnt2()== v2) || (w->getAnt1()==v2 && w->getAnt2()==v1)); //Remove v2 from w antecedents, add v3 to w antecedents if(w->getAnt1()==v2) w->setAnt1(v3); else w->setAnt2(v3); //Remove v3 from v antecedents, add v2 to v antecedents if(v->getAnt1()==v3) v->setAnt1(v2); else v->setAnt2(v2); v2->remRes(ra.getW()); v2->addRes(ra.getV()); v3->remRes(ra.getV()); v3->addRes(ra.getW()); //Change w clause to resolvent of v1 and v3 over t1 : t0 C1 C3 mergeClauses(v1->getClause(),v3->getClause(),w->getClause(),v->getPivot()); //Change pivots w:t0->t1,v:t1->t0; Var aux; aux=w->getPivot(); w->setPivot(v->getPivot()); v->setPivot(aux); A2++; } void ProofGraph::applyRuleB1( RuleContext& ra ) { //Transformation B1 //v1 is combined with v3 //v2 does not contribute anymore //w might be removed //the new result v' (t0 C1 C3) subsumes v (t0 C1 C2 C3) //Must propagate changes ProofNode *v1=getNode(ra.getV1()),*v2=getNode(ra.getV2()), *w=getNode(ra.getW()),*v3=getNode(ra.getV3()),*v=getNode(ra.getV()); (void)v2; assert((v->getAnt1()==w && v->getAnt2()== v3) || (v->getAnt1()==v3 && v->getAnt2()== w)); assert((w->getAnt1()==v1 && w->getAnt2()== v2) || (w->getAnt1()==v2 && w->getAnt2()==v1)); //v new antecedents are v1 and v3 if(v->getAnt1()==w) v->setAnt1(v1); else v->setAnt2(v1); // w loses v as resolvent, v1 gains v as resolvent v1->addRes(ra.getV()); w->remRes(ra.getV()); //Change v clause to resolvent of v1 and v3 over t1 : t0 C1 C3 mergeClauses(v1->getClause(),v3->getClause(),v->getClause(),v->getPivot()); //Remove w, if no more resolvents (and in case also v2, w was its only resolvent) if(w->getNumResolvents()==0) removeTree(w->getId()); B1++; } void ProofGraph::applyRuleB2( RuleContext& ra ) { assert(getNode(ra.getW())->getNumResolvents()==1); //Transformation B2(swap with loss of literal) NB: useful only for B2k! //v2 and v3 change place //w changes and v loses t0: the new v' (C1 C2 C3) subsumes v (t0 C1 C2 C3) //Must propagate changes ProofNode *v1=getNode(ra.getV1()),*v2=getNode(ra.getV2()), *w=getNode(ra.getW()),*v3=getNode(ra.getV3()),*v=getNode(ra.getV()); assert((v->getAnt1()==w && v->getAnt2()== v3) || (v->getAnt1()==v3 && v->getAnt2()== w)); assert((w->getAnt1()==v1 && w->getAnt2()== v2) || (w->getAnt1()==v2 && w->getAnt2()==v1)); //Remove v2 from w antecedents, add v3 to w antecedents if(w->getAnt1()==v2) w->setAnt1(v3); else w->setAnt2(v3); //Remove v3 from v antecedents, add v2 to v antecedents if(v->getAnt1()==v3) v->setAnt1(v2); else v->setAnt2(v2); v2->remRes(ra.getW()); v2->addRes(ra.getV()); v3->remRes(ra.getV()); v3->addRes(ra.getW()); //Change w clause to resolvent of v1 and v3 over t1 : t0 C1 C3 mergeClauses(v1->getClause(),v3->getClause(),w->getClause(),v->getPivot()); //Change v clause to resolvent of w and v2 over t0 : C1 C2 C3 mergeClauses(w->getClause(),v2->getClause(),v->getClause(),w->getPivot()); //Change pivots w:t0->t1,v:t1->t0; Var aux; aux=w->getPivot();w->setPivot(v->getPivot());v->setPivot(aux); B2++; } void ProofGraph::applyRuleB2Prime( RuleContext& ra ) { //Transformation B2' //v1 is combined with v3 //v2 does not contribute anymore //w might be removed //the new result v' (t0 C1 C3) subsumes v (t0 C1 C2 C3) //Must propagate changes ProofNode *v1=getNode(ra.getV1()),*v2=getNode(ra.getV2()), *w=getNode(ra.getW()),*v3=getNode(ra.getV3()),*v=getNode(ra.getV()); (void)v2; assert((v->getAnt1()==w && v->getAnt2()== v3) || (v->getAnt1()==v3 && v->getAnt2()== w)); assert((w->getAnt1()==v1 && w->getAnt2()== v2) || (w->getAnt1()==v2 && w->getAnt2()==v1)); //v new antecedents are v1 and v3 if(v->getAnt1()==w) v->setAnt1(v1); else v->setAnt2(v1); // w loses v as resolvent, v1 gains v as resolvent v1->addRes(ra.getV()); w->remRes(ra.getV()); //Change v clause to resolvent of v1 and v3 over t1 : t0 C1 C3 mergeClauses(v1->getClause(),v3->getClause(),v->getClause(),v->getPivot()); //Remove w, if no more resolvents (and in case also v2, w was its only resolvent) if(w->getNumResolvents()==0) removeTree(w->getId()); B2prime++; } void ProofGraph::applyRuleB3( RuleContext& ra ) { //Transformation B3 //Supercut!!! //v1, v3 don't contribute anymore //w might be removed //v is replaced by v2 and removed //the new result v2 (~t0 C2) subsumes v (~t0 C1 C2 C3) //Must propagate changes ProofNode *v1=getNode(ra.getV1()),*v2=getNode(ra.getV2()), *w=getNode(ra.getW()),*v3=getNode(ra.getV3()),*v=getNode(ra.getV()); assert((v->getAnt1()==w && v->getAnt2()== v3) || (v->getAnt1()==v3 && v->getAnt2()== w)); assert((w->getAnt1()==v1 && w->getAnt2()== v2) || (w->getAnt1()==v2 && w->getAnt2()==v1)); if( proofCheck() > 1 ) { for(unsigned u = 0; u < getGraphSize(); u++) if(getNode(u) != NULL && !isRoot(getNode(u)) && getNode(u)->getNumResolvents() == 0) { std::cerr << u << " detached" << '\n'; throw OsmtInternalException("Unexpected situation in rule application"); } } w->remRes( ra.getV() ); v3->remRes( ra.getV() ); // v2 inherits v children std::set& resolvents = v->getResolvents(); for (clauseid_t resolvent_id : resolvents) { assert(resolvent_id < getGraphSize()); ProofNode* res = getNode(resolvent_id); assert(res); if(res->getAnt1() == v) res->setAnt1( v2 ); else if (res->getAnt2() == v) res->setAnt2( v2 ); else throw OsmtInternalException("Unexpected situation in rule application"); v2->addRes(resolvent_id); } assert(v->getNumResolvents()>0); // w might become useless if(w->getNumResolvents()==0) { v1->remRes( ra.getW() ); v2->remRes( ra.getW() ); removeNode( ra.getW() ); // v1 can become useless assert(v2->getNumResolvents()>0); if(v1->getNumResolvents()==0) removeTree(v1->getId()); } // v3 can become useless if(v3->getNumResolvents()==0) removeTree(v3->getId()); //Remove v removeNode(v->getId()); if( proofCheck() > 1 ) { for(unsigned u = 0; u < getGraphSize(); u++) if(getNode(u) != NULL && !isRoot(getNode(u)) && getNode(u)->getNumResolvents() == 0) { std::cerr << u << " detached" << '\n'; throw OsmtInternalException("Unexpected situation in rule application"); } } B3++; } opensmt-2.5.2/src/proof/PGTransformationAlgorithms.cc000066400000000000000000001311021445011647600227250ustar00rootroot00000000000000/********************************************************************* Author: Simone Fulvio Rollini Periplo -- Copyright (C) 2013, Simone Fulvio Rollini Periplo is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. Periplo 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Periplo. If not, see . *********************************************************************/ #include "PG.h" #include "SystemQueries.h" #include "OsmtInternalException.h" #include "ReportUtils.h" #include #include //************************* RECYCLE PIVOTS AND RECYCLE UNITS *************************** /* * Recycle phase of recycle pivots with intersection expects the proof is in a legal form. * After this phase the proof may not be in a legal form and must be reconstructed. */ void ProofGraph::recyclePivotsIter_RecyclePhase() { // Each node has associated bitvector containing the set of positive/negative pivots // present in all paths in its subgraph down to the root // Increased sets for taking into account pivots mpz_t incr_safe_lit_set_1; mpz_init(incr_safe_lit_set_1); mpz_t incr_safe_lit_set_2; mpz_init(incr_safe_lit_set_2); const size_t size = getGraphSize(); auto * safe_lit_set = new mpz_t[size]; // Allocate root bitset mpz_init(safe_lit_set[getRoot()->getId()]); std::vector DFSvec = topolSortingBotUp(); assert(isResetVisited1()); // To initialize pivots set to the set of the first resolvent for (clauseid_t id : DFSvec) { ProofNode * n = getNode(id); assert(n); // Remove nodes left without resolvents if (not isRoot(n) and n->getNumResolvents() == 0) { if (n->getAnt1()) { n->getAnt1()->remRes(id); } if (n->getAnt2()) { n->getAnt2()->remRes(id); } if (isSetVisited1(id)) { mpz_clear(safe_lit_set[id]); } removeNode(id); } else if (not n->isLeaf()) { clauseid_t id1 = n->getAnt1()->getId(); clauseid_t id2 = n->getAnt2()->getId(); Var piv = n->getPivot(); int pos_piv = toInt(mkLit(piv, false)); int neg_piv = toInt(mkLit(piv, true)); short out = n->getAnt1()->hasOccurrenceBin(piv); assert(out != -1); // TODO guarantee positive occurrence pivot in ant1 bool ant1_has_pos_occ_piv = (out == 0); assert(n->getAnt1()); assert(n->getAnt2()); enum class Replace : char {NO, ANT1, ANT2}; Replace replace = Replace::NO; // Check whether pivot present in all subgraph paths if (mpz_tstbit(safe_lit_set[id], pos_piv)) { replace = ant1_has_pos_occ_piv ? Replace::ANT1 : Replace::ANT2; } else if (mpz_tstbit(safe_lit_set[id], neg_piv)) { replace = ant1_has_pos_occ_piv ? Replace::ANT2 : Replace::ANT1; } // A node marked to be replaced is left with the replacing // antecedent at ant1 and with ant2 set to NULL if (replace == Replace::ANT1) { n->getAnt2()->remRes(id); n->setAnt2(nullptr); } else if (replace == Replace::ANT2) { n->getAnt1()->remRes(id); n->setAnt1(n->getAnt2()); n->setAnt2(nullptr); } // Update antecedents pivots sets // If we are replacing, just copy the pivot set // Otherwise, intersect the antecedent's set with current one enriched with pivot (or just initialize if not visited yet) auto updateSet = [this, &safe_lit_set](clauseid_t id, mpz_t const &other) { if (not isSetVisited1(id)) { mpz_init(safe_lit_set[id]); setVisited1(id); mpz_set(safe_lit_set[id], other); } else mpz_and(safe_lit_set[id], safe_lit_set[id], other); }; switch (replace) { case Replace::NO: { // Set pivot bit for propagation mpz_set(incr_safe_lit_set_1, safe_lit_set[id]); mpz_set(incr_safe_lit_set_2, safe_lit_set[id]); mpz_setbit(incr_safe_lit_set_1, ant1_has_pos_occ_piv ? pos_piv : neg_piv); mpz_setbit(incr_safe_lit_set_2, ant1_has_pos_occ_piv ? neg_piv : pos_piv); updateSet(id1, incr_safe_lit_set_1); updateSet(id2, incr_safe_lit_set_2); break; } case Replace::ANT1: updateSet(id1, safe_lit_set[id]); break; case Replace::ANT2: updateSet(id2, safe_lit_set[id]); break; default: assert(false); } // NOTE important, free memory for node id mpz_clear(safe_lit_set[id]); } else { assert(n->isLeaf()); // NOTE important, free memory for node id mpz_clear(safe_lit_set[id]); } } delete[] safe_lit_set; mpz_clear(incr_safe_lit_set_1); mpz_clear(incr_safe_lit_set_2); resetVisited1(); } double ProofGraph::recyclePivotsIter() { if (verbose() > 1) { std::cerr << "; Recycle pivots plus restructuring begin" << std::endl; } if (verbose() > 1) { uint64_t mem_used = memUsed(); reportf("; Memory used before recycling: %.3f MB\n", mem_used == 0 ? 0 : mem_used / 1048576.0); } double initTime = cpuTime(); recyclePivotsIter_RecyclePhase(); if (verbose() > 1) { std::cerr << "; Recycling end, restructuring begin" << std::endl; } if (verbose() > 1) { uint64_t mem_used = memUsed(); reportf("; Memory used after recycling, before restructuring: %.3f MB\n", mem_used == 0 ? 0 : mem_used / 1048576.0); } auto hasBeenReplaced = [](ProofNode * node) { return node->getAnt1() and not node->getAnt2(); }; // Restructuring, from leaves to root assert(isResetVisited2()); std::deque q; q.assign(leaves_ids.begin(), leaves_ids.end()); do { clauseid_t id = q.front(); assert(id < getGraphSize()); ProofNode * n = getNode(id); q.pop_front(); if (not n or isSetVisited2(id)) { continue; } if (n->getAnt1() and not isSetVisited2(n->getAnt1()->getId())) { continue; } if (n->getAnt2() and not isSetVisited2(n->getAnt2()->getId())) { continue; } // Mark node as visited if both antecedents visited setVisited2(id); //Non leaf node if (n->getAnt1() or n->getAnt2()) { assert(n->getAnt1() or not n->getAnt2()); // If replaced assign children to replacing node and remove if (hasBeenReplaced(n)) { ProofNode * replacing = n->getAnt1(); auto const & resolvents = n->getResolvents(); for (clauseid_t resId : resolvents) { assert(resId < getGraphSize()); ProofNode * res = getNode(resId); assert(res); assert(n == res->getAnt1() or n == res->getAnt2()); if (res->getAnt1() == n) { res->setAnt1(replacing); } else if (res->getAnt2() == n) { res->setAnt2(replacing); } else { throw OsmtInternalException("Invalid proof structure " + std::string(__FILE__) + ", " + std::to_string(__LINE__)); } replacing->addRes(resId); assert(not isSetVisited2(resId)); q.push_back(resId); } replacing->remRes(id); assert(n == getNode(id)); removeNode(id); assert(replacing->getNumResolvents() > 0); // NOTE extra check if (proofCheck() > 1) { checkClause(replacing->getId()); } } else { // node stays assert(n->getAnt1() and n->getAnt2()); assert((n->getAnt1()->getAnt1() and n->getAnt1()->getAnt2()) or (not n->getAnt1()->getAnt1() and not n->getAnt1()->getAnt2())); assert((n->getAnt2()->getAnt1() and n->getAnt2()->getAnt2()) or (not n->getAnt2()->getAnt1() and not n->getAnt2()->getAnt2())); //Look for pivot in antecedents bool piv_in_ant1 = false, piv_in_ant2 = false; short f1 = n->getAnt1()->hasOccurrenceBin(n->getPivot()); if (f1 != -1) { piv_in_ant1 = true; } short f2 = n->getAnt2()->hasOccurrenceBin(n->getPivot()); if (f2 != -1) { piv_in_ant2 = true; } assert(not(f1 == 1 and f2 == 1) and not(f1 == 0 and f2 == 0)); if (piv_in_ant1 and piv_in_ant2) { //Easy case: pivot still in both antecedents //Sufficient to propagate modifications via merge mergeClauses(n->getAnt1()->getClause(), n->getAnt2()->getClause(), n->getClause(), n->getPivot()); for (clauseid_t clauseid : n->getResolvents()) { if (getNode(clauseid)) { q.push_back(clauseid); } } // NOTE extra check if (proofCheck() > 1) checkClause(n->getId()); } else { assert(not piv_in_ant1 or not piv_in_ant2); //Second case: pivot not in ant1 or not in ant2 //Remove resolution step, remove n, ant without pivots gains n resolvents bool choose_ant1 = false; //Pivot not in ant1 and not in ant2 if (not piv_in_ant1 and not piv_in_ant2) { // Choose one of the two antecedents heuristically choose_ant1 = chooseReplacingAntecedent(n); } else { choose_ant1 = not piv_in_ant1; } ProofNode * replacing = choose_ant1 ? n->getAnt1() : n->getAnt2(); ProofNode * other = choose_ant1 ? n->getAnt2() : n->getAnt1(); bool identicalParents = replacing == other; // MB: This is possible, test_recyclePivots_IdenticalAntecedents is an example. replacing->remRes(id); if (not identicalParents) { other->remRes(id); } auto const & resolvents = n->getResolvents(); for (clauseid_t resId : resolvents) { assert(resId < getGraphSize()); ProofNode * res = getNode(resId); assert(res); if (res->getAnt1() == n) { res->setAnt1(replacing); } else if (res->getAnt2() == n) { res->setAnt2(replacing); } else { throw OsmtInternalException("Invalid proof structure " + std::string(__FILE__) + ", " + std::to_string(__LINE__)); } replacing->addRes(resId); assert(not isSetVisited2(resId)); // Enqueue resolvent q.push_back(resId); } //We might have reached old sink //Case legal only if we have produced another empty clause //Substitute old sink with new if (isRoot(n)) { assert(not identicalParents); assert(replacing->getClauseSize() == 0); setRoot(replacing->getId()); assert(n->getNumResolvents() == 0); assert(replacing->getNumResolvents() == 0); } removeNode(n->getId()); if (not identicalParents and other->getNumResolvents() == 0) { removeTree(other->getId()); } // NOTE extra check if (proofCheck() > 1) checkClause(replacing->getId()); } } } else { // Leaf node assert(isLeafClauseType(n->getType())); assert(n->getNumResolvents() > 0); for (clauseid_t clauseid : n->getResolvents()) { if (getNode(clauseid)) { q.push_back(clauseid); } } } } while (not q.empty()); resetVisited2(); if (proofCheck()) { unsigned rem = cleanProofGraph(); if (rem > 0) std::cerr << "; Cleaned " << rem << " residual nodes" << std::endl; checkProof(true); } double endTime = cpuTime(); if (verbose() > 1) { uint64_t mem_used = memUsed(); reportf("; Memory used after restructuring: %.3f MB\n", mem_used == 0 ? 0 : mem_used / 1048576.0); } //////////////////////////////////////////////////////////////////// if (verbose() > 0) { unsigned new_n_nodes = 0; unsigned new_n_edges = 0; for (unsigned i = 0; i < getGraphSize(); i++) { ProofNode * pn = getNode(i); if (pn) { new_n_nodes++; new_n_edges += pn->getNumResolvents(); } } std::cerr << "# RPI\t"; std::cerr << "Nodes: " << new_n_nodes << "(-" << 100 * ((double) (num_nodes - new_n_nodes) / num_nodes) << "%)\t"; std::cerr << "Edges: " << new_n_edges << "(-" << 100 * ((double) (num_edges - new_n_edges) / num_edges) << "%)\t"; std::cerr << "Time: " << (endTime - initTime) << " s" << std::endl; } ////////////////////////////////////////////////////////////////// return (endTime - initTime); } void ProofGraph::recycleUnits() { assert(mpz_cmp_ui(visited_1, 0) == 0 and mpz_cmp_ui(visited_2, 0) == 0); if (verbose() > 1) { std::cerr << "# " << "Recycle units begin" << '\n'; } if (verbose() > 1) { uint64_t mem_used = memUsed(); reportf("# Memory used before recycling: %.3f MB\n", mem_used == 0 ? 0 : mem_used / 1048576.0); } double initTime = cpuTime(); bool some_transf_done = true; long curr_num_loops = 0; std::set units_collected; std::deque q; // Main external loop while (some_transf_done) { // Enqueue leaves first q.assign(leaves_ids.begin(), leaves_ids.end()); some_transf_done = false; do { clauseid_t id = q.front(); assert(id < getGraphSize()); q.pop_front(); ProofNode *n = getNode(id); //Node not visited yet if (n and not isSetVisited1(id)) { // Wait if one antecedent is not visited yet; // the node will be enqueued anyway by that antecedent if (n->getAnt1() != nullptr and not isSetVisited1(n->getAnt1()->getId())) {/* skip */} else if (n->getAnt2() != nullptr and not isSetVisited1(n->getAnt2()->getId())) {/* skip */} else { // both antecedents visited, mark node as visited setVisited1(id); // Enqueue resolvents for (clauseid_t rid : n->getResolvents()) { if (getNode(rid)) { q.push_back(rid); } } // Non leaf node if (n->getAnt1() or n->getAnt2()) { assert(n->getAnt1()); assert(n->getAnt2()); assert((n->getAnt1()->getAnt1() and n->getAnt1()->getAnt2()) or (n->getAnt1()->getAnt1() == nullptr and n->getAnt1()->getAnt2() == nullptr)); assert((n->getAnt2()->getAnt1() and n->getAnt2()->getAnt2()) or (n->getAnt2()->getAnt1() == nullptr and n->getAnt2()->getAnt2() == nullptr)); //Look for pivot in antecedents bool piv_in_ant1 = false; bool piv_in_ant2 = false; short f1 = n->getAnt1()->hasOccurrenceBin(n->getPivot()); if (f1 != -1) { piv_in_ant1 = true; } short f2 = n->getAnt2()->hasOccurrenceBin(n->getPivot()); if (f2 != -1) { piv_in_ant2 = true; } assert(not(f1 == 1 and f2 == 1) and not(f1 == 0 and f2 == 0)); //Easy case: pivot still in both antecedents //Sufficient to propagate modifications via merge if (piv_in_ant1 and piv_in_ant2) { if (isSetVisited2(n->getAnt1()->getId()) or isSetVisited2(n->getAnt2()->getId())) { mergeClauses(n->getAnt1()->getClause(), n->getAnt2()->getClause(), n->getClause(), n->getPivot()); setVisited2(id); } // Check whether an antecedent is a unit clause // If so, v is replaced by the other antecedent // and the literal gets propagated down if (n->getAnt1()->getClauseSize() == 1 or n->getAnt2()->getClauseSize() == 1) { some_transf_done = true; bool choose_ant1 = n->getAnt2()->getClauseSize() == 1; ProofNode *replacing = choose_ant1 ? n->getAnt1() : n->getAnt2(); ProofNode *other = choose_ant1 ? n->getAnt2() : n->getAnt1(); // Keep track of the unit clause detached units_collected.insert(other->getId()); replacing->remRes(id); other->remRes(id); auto const &resolvents = n->getResolvents(); setVisited2(replacing->getId()); for (clauseid_t clauseid : resolvents) { assert(clauseid < getGraphSize()); ProofNode *res = getNode(clauseid); assert(res); if (res->getAnt1() == n) { res->setAnt1(replacing); } else if (res->getAnt2() == n) { res->setAnt2(replacing); } else throw OsmtInternalException("Unexpected situation in recycleUnits"); assert(res->getAnt1() != res->getAnt2()); replacing->addRes(clauseid); } //We might have reached old sink //Substitute old sink with new if (isRoot(n)) { setRoot(replacing->getId()); assert(n->getNumResolvents() == 0); assert(replacing->getNumResolvents() == 0); } removeNode(id); } } //Second case: pivot not in ant1 or not in ant2 //Remove resolution step, remove n, ant without pivots gains n resolvents else { assert(not piv_in_ant1 or not piv_in_ant2); //Pivot not in ant1 and not in ant2 bool choose_ant1 = false; if (not piv_in_ant1 and not piv_in_ant2) { // Choose one of the two antecedents heuristically choose_ant1 = chooseReplacingAntecedent(n); } else { // Choose the one not containing the pivot choose_ant1 = not piv_in_ant1 and piv_in_ant2; } ProofNode *replacing = choose_ant1 ? n->getAnt1() : n->getAnt2(); ProofNode *other = choose_ant1 ? n->getAnt2() : n->getAnt1(); replacing->remRes(id); other->remRes(id); auto const &resolvents = n->getResolvents(); setVisited2(replacing->getId()); for (clauseid_t clauseid : resolvents) { assert(clauseid < getGraphSize()); ProofNode *res = getNode(clauseid); assert(res); if (res->getAnt1() == n) { res->setAnt1(replacing); } else if (res->getAnt2() == n) { res->setAnt2(replacing); } else throw OsmtInternalException("Unexpected situation in recycleUnits"); assert(res->getAnt1() != res->getAnt2()); replacing->addRes(clauseid); } //We might have reached old sink //Substitute old sink with new if (isRoot(n)) { setRoot(replacing->getId()); assert(n->getNumResolvents() == 0); assert(replacing->getNumResolvents() == 0); } removeNode(n->getId()); if (other->getNumResolvents() == 0) { removeTree(other->getId()); } } } } } } while (not q.empty()); // Visit vector resetVisited1(); // To do only necessary merges, track modified nodes resetVisited2(); // End loop curr_num_loops++; } //printClause(getRoot()); // Readd each unit clause to restore the proof for (clauseid_t clauseid : units_collected) { ProofNode *unit = getNode(clauseid); ProofNode *oldroot = getRoot(); // NOTE is it possible to have multiple unit clauses containing the same literal? // If so, which one should be readded? if (oldroot->getClauseSize() == 0) { } else { assert(oldroot->hasOccurrenceBin(var(unit->getClause()[0])) != -1); //printClause(unit); ProofNode *newroot = new ProofNode(); newroot->initClause(); newroot->setAnt1(oldroot); newroot->setAnt2(unit); newroot->setType(clause_type::CLA_DERIVED); newroot->setPivot(var((unit->getClause())[0])); newroot->setId(graph.size()); graph.push_back(newroot); unit->addRes(newroot->getId()); oldroot->addRes(newroot->getId()); //newroot given by resolution of root and unit over v pivot mergeClauses(oldroot->getClause(), unit->getClause(), newroot->getClause(), newroot->getPivot()); setRoot(newroot->getId()); } } assert(getRoot()->getClauseSize() == 0); if (proofCheck()) { unsigned rem = cleanProofGraph(); if (rem > 0) std::cerr << "# Cleaned " << rem << " residual nodes" << '\n'; assert(rem == 0); checkProof(true); } double endTime = cpuTime(); if (verbose() > 1) { uint64_t mem_used = memUsed(); reportf("# Memory used after recycling: %.3f MB\n", mem_used == 0 ? 0 : mem_used / 1048576.0); } //////////////////////////////////////////////////////////////////// if (verbose() > 0) { unsigned new_n_nodes = 0; unsigned new_n_edges = 0; for (unsigned i = 0; i < getGraphSize(); i++) { ProofNode *pn = getNode(i); if (pn) { new_n_nodes++; new_n_edges += pn->getNumResolvents(); } } std::cerr << "# LU\t"; std::cerr << "Nodes: " << new_n_nodes << "(-" << 100 * ((double) (num_nodes - new_n_nodes) / num_nodes) << "%)\t"; std::cerr << "Edges: " << new_n_edges << "(-" << 100 * ((double) (num_edges - new_n_edges) / num_edges) << "%)\t"; std::cerr << "Traversals: " << curr_num_loops << "\t"; std::cerr << "Time: " << (endTime - initTime) << " s" << '\n'; } ////////////////////////////////////////////////////////////////// } void ProofGraph::proofTransformAndRestructure(const double left_time, const int max_num_loops, bool do_transf, std::function handleRules) { if (verbose() > 1) { std::cerr << "; " << "Proof transformation traversals begin" << std::endl; } if (verbose() > 1) { uint64_t mem_used = memUsed(); reportf("; Memory used before proof transformation traversals: %.3f MB\n", mem_used == 0 ? 0 : mem_used / 1048576.0); } double init_time = cpuTime(); assert(not (max_num_loops > 0 and left_time > 0)); //Flag to check if in a loop at least a transformation has been applied bool some_transf_done = true; long curr_num_loops = 0; std::deque q; // Main external loop // Continue until // - max number of loops reached or timeout (in case of reduction) // - some transformation is done (in case of pivot reordering) while ((max_num_loops == -1 ? true : curr_num_loops < max_num_loops) and (left_time == -1 ? true : (cpuTime() - init_time) <= left_time) and (left_time != -1 or max_num_loops != -1 or some_transf_done)) { assert(isResetVisited1() and isResetVisited2()); // Enqueue leaves first q.assign(leaves_ids.begin(), leaves_ids.end()); some_transf_done = false; while (not q.empty()) { clauseid_t id = q.front(); assert(id < getGraphSize()); q.pop_front(); ProofNode * n = getNode(id); //Node not visited yet if (n and not isSetVisited1(id)) { // Wait if one antecedent is not visited yet; // the node will be enqueued anyway by that antecedent if ((n->getAnt1() and not isSetVisited1(n->getAnt1()->getId())) or (n->getAnt2() and not isSetVisited1(n->getAnt2()->getId()))) { continue; } // ELSE, both antecedents ready, process the node // Mark node as visited setVisited1(id); // Non leaf node if ((n->getAnt1() or n->getAnt2())) { assert(n->getAnt1()); assert(n->getAnt2()); assert((n->getAnt1()->getAnt1() and n->getAnt1()->getAnt2()) or (not n->getAnt1()->getAnt1() and not n->getAnt1()->getAnt2())); assert((n->getAnt2()->getAnt1() and n->getAnt2()->getAnt2()) or (not n->getAnt2()->getAnt1() and not n->getAnt2()->getAnt2())); //Look for pivot in antecedents short f1 = n->getAnt1()->hasOccurrenceBin(n->getPivot()); bool piv_in_ant1 = (f1 != -1); short f2 = n->getAnt2()->hasOccurrenceBin(n->getPivot()); bool piv_in_ant2 = (f2 != -1); assert(not(f1 == 1 and f2 == 1) and not(f1 == 0 and f2 == 0)); if (piv_in_ant1 and piv_in_ant2) { //Easy case: pivot still in both antecedents //Sufficient to propagate modifications via merge for (clauseid_t resolvent : n->getResolvents()) { if (getNode(resolvent)) { q.push_back(resolvent); } } if (isSetVisited2(n->getAnt1()->getId()) or isSetVisited2(n->getAnt2()->getId())) { mergeClauses(n->getAnt1()->getClause(), n->getAnt2()->getClause(), n->getClause(), n->getPivot()); setVisited2(id); } // NOTE extra check if (proofCheck() > 1) { checkClause(n->getId()); } if (do_transf) { RuleContext ra1 = getRuleContext(n->getAnt1()->getId(), n->getId()); RuleContext ra2 = getRuleContext(n->getAnt2()->getId(), n->getId()); auto chosen = handleRules(ra1, ra2); rul_type app_rule = rNO; if (chosen != ApplicationResult::NO_APPLICATION) { assert(chosen == ApplicationResult::APPLY_FIRST || chosen == ApplicationResult::APPLY_SECOND); RuleContext & chosen_ra = chosen == ApplicationResult::APPLY_FIRST ? ra1 : ra2; app_rule = chosen_ra.getType(); clauseid_t dupl_id = 0; if (getNode(chosen_ra.getW())->getNumResolvents() > 1 && isSwapRule(app_rule)) { dupl_id = dupliNode(chosen_ra); } clauseid_t A1_new_id = ruleApply(chosen_ra); some_transf_done = true; // NOTE see ProofGraphRules B3 // Mark v as modified if (app_rule == rB1 or app_rule == rB2 or app_rule == rB2prime) { setVisited2(id); } // Remember that in B3 v2 replaces v if (app_rule == rB3) { setVisited2(chosen_ra.getV2()); } // NOTE nodes might have been added on the fly by A1 and/or duplication if (dupl_id != 0) { // The new node created by duplicating w has replaced w and will not be used elsewhere //visited_1.set(dupl_id); visited_2.reset(dupl_id); } if (A1_new_id != 0) { // The new node created by A1 is already updated and will not be used elsewhere //visited_1.set(A1_new_id); visited_2.reset(A1_new_id); } } // NOTE extra check if (proofCheck() > 1 && app_rule != rB3) { checkClause(n->getId()); } } } else { //Second case: pivot not in ant1 or not in ant2 assert(not piv_in_ant1 or not piv_in_ant2); //Remove resolution step, remove n, ant without pivots gains n resolvents bool choose_ant1 = false; if (not piv_in_ant1 and not piv_in_ant2) { // Choose one of the two antecedents heuristically choose_ant1 = chooseReplacingAntecedent(n); } else { choose_ant1 = not piv_in_ant1; } ProofNode * replacing = choose_ant1 ? n->getAnt1() : n->getAnt2(); ProofNode * other = choose_ant1 ? n->getAnt2() : n->getAnt1(); bool identicalParents = replacing == other; // MB: This is possible, test_proofTransformAndRestructure_IdenticalAntecedents is an example. replacing->remRes(id); if (not identicalParents) { other->remRes(id); } auto const & resolvents = n->getResolvents(); setVisited2(replacing->getId()); for (clauseid_t resolvent : resolvents) { assert(resolvent < getGraphSize()); ProofNode * res = getNode(resolvent); assert(res); assert(res->getAnt1() == n or res->getAnt2() == n); if (res->getAnt1() == n) { res->setAnt1(replacing); } else if (res->getAnt2() == n) { res->setAnt2(replacing); } else { throw OsmtInternalException("Invalid proof structure " + std::string(__FILE__) + ", " + std::to_string(__LINE__)); } replacing->addRes(resolvent); q.push_back(resolvent); } //We might have reached old sink //Case legal only if we have produced another empty clause //Substitute old sink with new if (isRoot(n)) { assert(not identicalParents); assert(replacing->getClauseSize() == 0); setRoot(replacing->getId()); assert(n->getNumResolvents() == 0); assert(replacing->getNumResolvents() == 0); } removeNode(n->getId()); if (not identicalParents and other->getNumResolvents() == 0) { removeTree(other->getId()); } // NOTE extra check if (proofCheck() > 1) { checkClause(replacing->getId()); } } } else { for (clauseid_t resolvent : n->getResolvents()) if (getNode(resolvent) != nullptr) { q.push_back(resolvent); } } } } // Visit vector resetVisited1(); // To do only necessary merges, track modified nodes resetVisited2(); // End loop curr_num_loops++; if (proofCheck() > 1) { std::cerr << "; Checking proof after loop " << curr_num_loops << std::endl; unsigned rem = cleanProofGraph(); if (rem > 0) std::cerr << "; Cleaned " << rem << " residual nodes" << std::endl; checkProof(true); } } if (proofCheck()) { unsigned rem = cleanProofGraph(); if (rem > 0) std::cerr << "; Cleaned " << rem << " residual nodes" << std::endl; //assert( rem == 0 ); checkProof(true); } double endTime = cpuTime(); if (verbose() > 1) { uint64_t mem_used = memUsed(); reportf("; Memory used after proof transformation traversals: %.3f MB\n", mem_used == 0 ? 0 : mem_used / 1048576.0); } ///////////////////////////////////////////////////////////////////////////// if (verbose() > 0) { unsigned new_n_nodes = 0; unsigned new_n_edges = 0; for (unsigned i = 0; i < getGraphSize(); i++) { ProofNode * pn = getNode(i); if (pn) { new_n_nodes++; new_n_edges += pn->getNumResolvents(); } } std::cerr << "; RE\t"; if (num_nodes >= static_cast(new_n_nodes)) { std::cerr << "Nodes: " << new_n_nodes << "(-" << 100 * ((double) (num_nodes - new_n_nodes) / num_nodes) << "%)\t"; } else { std::cerr << "Nodes: " << new_n_nodes << "(+" << 100 * ((double) (new_n_nodes - num_nodes) / num_nodes) << "%)\t"; } if (num_edges >= static_cast(new_n_edges)) { std::cerr << "Edges: " << new_n_edges << "(-" << 100 * ((double) (num_edges - new_n_edges) / num_edges) << "%)\t"; } else { std::cerr << "Edges: " << new_n_edges << "(+" << 100 * ((double) (new_n_edges - num_edges) / num_edges) << "%)\t"; } std::cerr << "Traversals: " << curr_num_loops << "\t"; std::cerr << "Time: " << (endTime - init_time) << " s" << std::endl; } /////////////////////////////////////////////////////////////////////////////// } void ProofGraph::proofPostStructuralHashing() { if ( verbose() > 1 ) std::cerr << "; Post-processing structural hashing begin" << std::endl; if ( verbose() > 1 ) { uint64_t mem_used = memUsed(); reportf( "; Memory used before structural hashing: %.3f MB\n", mem_used == 0 ? 0 : mem_used / 1048576.0 ); } double initTime = cpuTime(); std::vector q; clauseid_t id; ProofNode* n = nullptr; // Map to associate node to its antecedents std::map< std::pair, clauseid_t> ants_map; // NOTE Topological visit and node replacement on the fly // Guarantees that both replacing and replaced node subproofs have been visited q.push_back(getRoot()->getId()); do { id=q.back(); n=getNode(id); //Node not visited yet if(!isSetVisited1(id)) { // Enqueue antecedents if not visited if(n->getAnt1()!=NULL && !isSetVisited1(n->getAnt1()->getId())) q.push_back(n->getAnt1()->getId()); else if(n->getAnt2()!=NULL && !isSetVisited1(n->getAnt2()->getId())) q.push_back(n->getAnt2()->getId()); // Mark node as visited if both antecedents visited else { setVisited1(id); q.pop_back(); assert(n); // Non leaf node if(!n->isLeaf()) { bool found = false; clauseid_t c1, c2; if(n->getAnt1()->getId() <= n->getAnt2()->getId()) { c1 = n->getAnt1()->getId(); c2 = n->getAnt2()->getId(); } else { c2 = n->getAnt1()->getId(); c1 = n->getAnt2()->getId(); } // Look for pair std::pair ant_pair (c1,c2); auto it = ants_map.find(ant_pair); found = ( it != ants_map.end() ); // If pairs not found, add node to the map if( !found ) ants_map[ ant_pair ] = id ; // else replace node with existing one else { ProofNode* replacing = getNode( it->second ); assert( replacing ); // Move n children to replacing node for(clauseid_t resolvent_id : n->getResolvents()) { assert(resolvent_id < getGraphSize()); ProofNode* res = getNode(resolvent_id); assert( res ); if(res->getAnt1() == n) res->setAnt1( replacing ); else if (res->getAnt2() == n) res->setAnt2( replacing ); else throw OsmtInternalException("Unexpected situation in proofPostStructuralHashing"); replacing->addRes(resolvent_id); } n->getAnt1()->remRes(id); n->getAnt2()->remRes(id); removeNode(id); } } } } else q.pop_back(); } while(!q.empty()); resetVisited1(); if( proofCheck() ) { unsigned rem = cleanProofGraph( ); if(rem > 0 ) std::cerr << "; Cleaned " << rem << " residual nodes" << std::endl; //assert( rem == 0 ); checkProof( true ); } double endTime = cpuTime(); if ( verbose() > 1 ) { uint64_t mem_used = memUsed(); reportf( "; Memory used after structural hashing: %.3f MB\n", mem_used == 0 ? 0 : mem_used / 1048576.0 ); } ///////////////////////////////////////////////////////////////////////////// if( verbose() > 0 ) { unsigned new_n_nodes=0; unsigned new_n_edges=0; for(unsigned i = 0; i < getGraphSize(); i++) { ProofNode* pn = getNode(i); if(pn != NULL){ new_n_nodes++; new_n_edges += pn->getNumResolvents(); } } std::cerr << "; SH\t"; std::cerr << "Nodes: " << new_n_nodes << "(-" << 100*((double)(num_nodes - new_n_nodes)/num_nodes) << "%)\t"; std::cerr << "Edges: " << new_n_edges << "(-" << 100*((double)(num_edges - new_n_edges)/num_edges) << "%)\t"; std::cerr << "Time: " << (endTime-initTime) << " s" << std::endl; } /////////////////////////////////////////////////////////////////////////////// } namespace{ class LightVars { public: template LightVars(TIt begin, TIt end) { lights.insert(begin, end); } bool isLight(Var v) const { return lights.find(v) != lights.end(); } private: std::unordered_set lights; }; class LiftingVarsRuleHandler { public: LiftingVarsRuleHandler(ProofGraph & pg, LightVars const & lv) : proofGraph(pg), lightVars(lv) {} ProofGraph::ApplicationResult operator()(RuleContext & ra1, RuleContext & ra2); private: ProofGraph & proofGraph; LightVars const & lightVars; }; using ApplicationResult = ProofGraph::ApplicationResult; ApplicationResult LiftingVarsRuleHandler::operator()(RuleContext &ra1, RuleContext &ra2) { auto isUnordered = [this] (RuleContext const& ra) { Var lowerPivot = this->proofGraph.getNode(ra.getV())->getPivot(); Var upperPivot = this->proofGraph.getNode(ra.getW())->getPivot(); return this->lightVars.isLight(lowerPivot) && !this->lightVars.isLight(upperPivot); }; bool enabled1 = ra1.enabled() && isUnordered(ra1); bool enabled2 = ra2.enabled() && isUnordered(ra2); if (!enabled1) { return enabled2 ? ApplicationResult::APPLY_SECOND : ApplicationResult::NO_APPLICATION; } // ra1 is enabled if (!enabled2) { return ApplicationResult::APPLY_FIRST; } // BOTH are enabled, pick better rul_type t1 = ra1.getType(); rul_type t2 = ra2.getType(); if (isCutRule(t1)) { return ApplicationResult::APPLY_FIRST; } if (isCutRule(t2)) { return ApplicationResult::APPLY_SECOND; } assert(isSwapRule(t1) && isSwapRule(t2)); // Prefer simple swaps if (t1 == rA2) { return ApplicationResult::APPLY_FIRST; } if (t2 == rA2) { return ApplicationResult::APPLY_SECOND; } // No further rules, just pick first one return ApplicationResult::APPLY_FIRST; } } void ProofGraph::liftVarsToLeaves(std::vector const & vars) { LightVars lightVars (vars.begin(), vars.end()); LiftingVarsRuleHandler handler(*this, lightVars); proofTransformAndRestructure(-1, -1, true, handler); } void ProofGraph::replaceSubproofsWithNoPartitionTheoryVars(std::vector const & vars) { auto mustBeEliminated = [&vars](Var v) { return std::find(std::begin(vars), std::end(vars), v) != std::end(vars); }; std::deque toProcess; toProcess.assign(this->leaves_ids.begin(), this->leaves_ids.end()); resetVisited1(); while (!toProcess.empty()) { clauseid_t current_id = toProcess.front(); toProcess.pop_front(); setVisited1(current_id); ProofNode * leaf = this->getNode(current_id); assert(leaf); assert(leaf->isLeaf()); bool hasMixed = false; for (Var v : vars) { short present = leaf->hasOccurrenceBin(v); hasMixed |= (present != -1); } if (!hasMixed) { continue; } auto resolvents_ids = leaf->getResolvents(); for (auto resolvent_id : resolvents_ids) { ProofNode * resolvent = this->getNode(resolvent_id); assert(resolvent); assert(mustBeEliminated(resolvent->getPivot())); // MB: While there is a problematic variable in the clause, all resolution steps must be on a problematic var if (!mustBeEliminated(resolvent->getPivot())) { throw OsmtInternalException("Error in post-processing in the proof: Lifting orphaned theory variables did not work properly"); } // resolvent must be theory valid lemma, make it new leaf ProofNode * ant1 = resolvent->getAnt1(); ProofNode * ant2 = resolvent->getAnt2(); assert(ant1 && ant2); // only continue if both antecedents has been processed already! if (!isSetVisited1(ant1->getId()) || !isSetVisited1(ant2->getId())) { // This resolvent will be processed when the second antecedent is taken from the queue continue; } assert(ant1->getType() == clause_type::CLA_THEORY); assert(ant2->getType() == clause_type::CLA_THEORY); assert(ant1->isLeaf() && ant2->isLeaf()); ant1->remRes(resolvent_id); ant2->remRes(resolvent_id); if (ant1->getNumResolvents() == 0) { this->removeNode(ant1->getId()); } if (ant2->getNumResolvents() == 0) { this->removeNode(ant2->getId()); } resolvent->setType(clause_type::CLA_THEORY); resolvent->setAnt1(nullptr); resolvent->setAnt2(nullptr); this->addLeaf(resolvent_id); toProcess.push_back(resolvent_id); } } resetVisited1(); } opensmt-2.5.2/src/pterms/000077500000000000000000000000001445011647600153165ustar00rootroot00000000000000opensmt-2.5.2/src/pterms/CMakeLists.txt000066400000000000000000000007361445011647600200640ustar00rootroot00000000000000add_library(pterms OBJECT "") target_sources(pterms PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/PtStructs.h" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/PtStore.h" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/Pterm.h" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/PTRef.h" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/PtStore.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/Pterm.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/PtStructs.cc" ) install(FILES Pterm.h PtStore.h PTRef.h PtStructs.h DESTINATION ${INSTALL_HEADERS_DIR}) opensmt-2.5.2/src/pterms/PTRef.h000066400000000000000000000020551445011647600164510ustar00rootroot00000000000000/* * Copyright (c) 2012-2022, Antti Hyvarinen * Copyright (c) 2022, Martin Blicha * * SPDX-License-Identifier: MIT */ #ifndef OPENSMT_PTREF_H #define OPENSMT_PTREF_H #include #include struct PTRef { uint32_t x; inline friend bool operator== (PTRef a1, PTRef a2) { return a1.x == a2.x; } inline friend bool operator!= (PTRef a1, PTRef a2) { return a1.x != a2.x; } inline friend bool operator> (PTRef a1, PTRef a2) { return a1.x > a2.x; } inline friend bool operator< (PTRef a1, PTRef a2) { return a1.x < a2.x; } static const PTRef Undef; }; const struct PTRef PTRef_Undef = {INT32_MAX}; inline constexpr PTRef PTRef::Undef = PTRef { INT32_MAX }; struct PTRefHash { uint32_t operator () (PTRef s) const { return (uint32_t)s.x; } }; struct PTRefPairHash { std::size_t operator () (std::pair p) const { std::hash hasher; return (hasher(p.first.x) ^ hasher(p.second.x)); } }; #endif //OPENSMT_PTREF_H opensmt-2.5.2/src/pterms/PtStore.cc000066400000000000000000000216221445011647600172300ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ #include "PtStore.h" #include "OsmtInternalException.h" #include "OsmtApiException.h" #include const int PtStore::ptstore_vec_idx = 1; const int PtStore::ptstore_buf_idx = 2; bool PtStore::isAmbiguousNullarySymbolName(std::string_view name) const { auto * values = symstore.getRefOrNull(name.data()); if (not values) { return false; } assert(values); int matches = 0; for (SymRef sr : *values) { if (symstore[sr].nargs() == 0) { matches ++; } if (matches > 1) return true; } return false; } vec PtStore::getHomonymousNullarySymbols(std::string_view name) const { auto * values = symstore.getRefOrNull(name.data()); if (not values) { return {}; } vec ambiguousNullarySymbols; for (SymRef sr : *values) { if (symstore[sr].nargs() == 0) { ambiguousNullarySymbols.push(sr); } } return ambiguousNullarySymbols; } // // Resolves the SymRef for name s taking into account polymorphism // Returns SymRef_Undef if the name is not defined anywhere // SymRef PtStore::lookupSymbol(const char* s, const vec& args, SymbolMatcher symbolMatcher, SRef sort) { auto* values = symstore.getRefOrNull(s); std::vector candidates; if (values) { vec const & trefs = *values; if (symstore[trefs[0]].noScoping()) { // No need to look forward, this is the only possible term // list for (int i = 0; i < trefs.size(); i++) { SymRef ctr = trefs[i]; Symbol const & t = symstore[ctr]; if (t.nargs() == args.size_()) { // t is a potential match. Check that arguments match uint32_t j = 0; for (; j < t.nargs(); j++) { SymRef argt = pta[args[j]].symb(); if (t[j] != symstore[argt].rsort()) break; } if (j == t.nargs()) { // Add to list of candidates candidates.push_back(ctr); } } // The term might still be one of the special cases: // left associative // - requires that the left argument and the return value have the same sort else if (t.left_assoc() && symstore[pta[args[0]].symb()].rsort() == t.rsort()) { int j = 1; for (; j < args.size(); j++) { SymRef argt = pta[args[j]].symb(); if (symstore[argt].rsort() != t[1]) break; } if (j == args.size()) { // We add this candidate only if the return type of the candidate is new. SRef ctrReturnSort = symstore[ctr].rsort(); if (not std::any_of(candidates.begin(), candidates.end(), [this, ctrReturnSort](SymRef sr) { return symstore[sr].rsort() == ctrReturnSort; })) { candidates.push_back(ctr); } } } else if (t.right_assoc()) { throw OsmtInternalException( std::string("right assoc term not implemented yet:") + symstore.getName(ctr)); } else if (t.nargs() < args.size_() && t.chainable()) { int j = 0; for (; j < args.size(); j++) { SymRef argt = pta[args[j]].symb(); if (symstore[argt].rsort() != t[0]) break; } if (j == args.size()) { candidates.push_back(ctr); } } else if (t.nargs() < args.size_() && t.pairwise()) { int j = 0; for (; j < args.size(); j++) { SymRef argt = pta[args[j]].symb(); if (symstore[argt].rsort() != t[0]) break; } if (j == args.size()) { candidates.push_back(ctr); } } } } else { for (int i = 0; i < trefs.size(); i++) { SymRef ctr = trefs[i]; const Symbol &t = symstore[ctr]; if (t.nargs() == args.size_()) { // t is a potential match. Check that arguments match uint32_t j = 0; for (; j < t.nargs(); j++) { SymRef argt = pta[args[j]].symb(); if (t[j] != symstore[argt].rsort()) break; } if (j == t.nargs()) { candidates.push_back(ctr); } } } } } auto endOfMatches = std::remove_if(candidates.begin(), candidates.end(), [this, &symbolMatcher](SymRef sr) { return not symstore[sr].matches(symbolMatcher); }); candidates.erase(endOfMatches, candidates.end()); if (candidates.empty()) { return SymRef_Undef; // Not found } else if (candidates.size() == 1 and sort == SRef_Undef) { return candidates[0]; } else if (candidates.size() == 1 and sort != SRef_Undef) { if (symstore[candidates[0]].rsort() != sort) { return SymRef_Undef; } else { return candidates[0]; } } assert(candidates.size() > 1); if (sort == SRef_Undef) { throw OsmtApiException("Ambiguous symbol: `" + std::string(s) + "'"); } assert(sort != SRef_Undef); auto equalSortEnd = std::remove_if(candidates.begin(), candidates.end(), [this, sort](SymRef sr) { return symstore[sr].rsort() != sort; }); candidates.erase(equalSortEnd, candidates.end()); if (candidates.empty()) { return SymRef_Undef; } if (candidates.size() > 1) { throw OsmtInternalException("System has " + std::to_string(candidates.size()) + " symbols with same argument and return sorts"); } assert(candidates.size() == 1); assert(symstore[candidates[0]].rsort() == sort); return candidates[0]; } PTRef PtermIter::operator* () { if (i < idToPTRef.size()) return idToPTRef[i]; else return PTRef_Undef; } const PtermIter& PtermIter::operator++ () { i++; return *this; } PTRef PtStore::newTerm(const SymRef sym, const vec& ps) { PTRef tr = pta.alloc(sym, ps); idToPTRef.push(tr); assert(idToPTRef.size_() == pta.getNumTerms()); return tr; } void PtStore::free(PTRef r) { pta.free(r); } // this is guaranteed to be lazy Pterm& PtStore::operator[] (PTRef tr) { return pta[tr]; } const Pterm& PtStore::operator[] (PTRef tr) const { return pta[tr]; } bool PtStore::hasCtermKey (SymRef& k) { return cterm_map.has(k); } void PtStore::addToCtermMap (SymRef& k, PTRef tr) { cterm_map.insert(k, tr); } PTRef PtStore::getFromCtermMap(SymRef& k) { return cterm_map[k]; } bool PtStore::hasBoolKey (const PTLKey& k) { return bool_map.find(k) != bool_map.end(); } void PtStore::addToBoolMap (PTLKey &&k, PTRef tr) { bool_map[std::move(k)] = tr; } PTRef PtStore::getFromBoolMap (const PTLKey& k) { return bool_map.at(k); } bool PtStore::hasCplxKey (const PTLKey& k) { return cplx_map.find(k) != cplx_map.end(); } void PtStore::addToCplxMap (PTLKey && k, PTRef tr) { cplx_map[std::move(k)] = tr; } PTRef PtStore::getFromCplxMap (const PTLKey& k) { return cplx_map.at(k); } PtermIter PtStore::getPtermIter() { return PtermIter(idToPTRef); } opensmt-2.5.2/src/pterms/PtStore.h000066400000000000000000000073411445011647600170740ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ #ifndef PTSTORE_H #define PTSTORE_H #include "Pterm.h" #include "SymStore.h" #include class SStore; // forward declaration class PtermIter { private: int i; vec& idToPTRef; public: PtermIter(vec& in) : i(0), idToPTRef(in) {} PTRef operator* ();/* { if (i < idToPTRef.size()) return idToPTRef[i]; else return PTRef_Undef; }*/ const PtermIter& operator++ ();// { i++; return *this; } }; class PtStore { PtermAllocator pta{1024*1024}; SymStore& symstore; vec idToPTRef; Map > cterm_map; // Mapping constant symbols to terms // vec cterm_keys; std::unordered_map > cplx_map; // Mapping complex terms to canonical terms // vec cplx_keys; std::unordered_map > bool_map; // Mapping boolean terms to canonical terms // vec bool_keys; // friend class Logic; static const int ptstore_buf_idx; static const int ptstore_vec_idx; public: PtStore(SymStore& symstore) : symstore(symstore) {} PTRef newTerm(const SymRef sym, const vec& ps);/* { PTRef tr = pta.alloc(sym, ps); idToPTRef.push(tr); assert(idToPTRef.size() == pta.getNumTerms()); return tr; }*/ void free(PTRef r);// { pta.free(r); } // this is guaranteed to be lazy bool isAmbiguousNullarySymbolName(std::string_view name) const; vec getHomonymousNullarySymbols(std::string_view name) const; SymRef lookupSymbol(const char* s, const vec& args, SymbolMatcher symbolMatcher = SymbolMatcher::Any, SRef sort = SRef_Undef); Pterm& operator[] (PTRef tr);// { return pta[tr]; } const Pterm& operator[] (PTRef tr) const;// { return pta[tr]; } bool hasCtermKey(SymRef& k);// { return cterm_map.has(k); } void addToCtermMap(SymRef& k, PTRef tr);/* { cterm_map.insert(k, tr); // cterm_keys.push(k); }*/ PTRef getFromCtermMap(SymRef& k);// { return cterm_map[k]; } bool hasBoolKey(const PTLKey& k); void addToBoolMap(PTLKey && k, PTRef tr); PTRef getFromBoolMap(const PTLKey& k); bool hasCplxKey(const PTLKey& k); void addToCplxMap(PTLKey && k, PTRef tr); PTRef getFromCplxMap(const PTLKey& k); PtermIter getPtermIter();// { return PtermIter(idToPTRef); } std::size_t getNumberOfTerms() const { return pta.getNumTerms(); } }; #endif opensmt-2.5.2/src/pterms/PtStructs.cc000066400000000000000000000002071445011647600175770ustar00rootroot00000000000000#include uint32_t PtAsgnHash::operator () (const PtAsgn& s) const { return ((uint32_t)s.tr.x << 2) + toInt(s.sgn); }opensmt-2.5.2/src/pterms/PtStructs.h000066400000000000000000000034111445011647600174410ustar00rootroot00000000000000/* * Copyright (c) 2012-2022, Antti Hyvarinen * Copyright (c) 2022, Martin Blicha * * SPDX-License-Identifier: MIT */ #ifndef OPENSMT_PTHELPERSTRUCTS_H #define OPENSMT_PTHELPERSTRUCTS_H #include "SolverTypes.h" #include "PTRef.h" class PtAsgn { public: PTRef tr; lbool sgn; PtAsgn(PTRef tr_, lbool sgn_) : tr(tr_), sgn(sgn_) {} PtAsgn() : tr(PTRef_Undef), sgn(l_Undef) {} bool operator== (PtAsgn const & other) const { return tr == other.tr and sgn == other.sgn; } bool operator!= (PtAsgn const & other) const { return not (*this == other); } bool operator> (PtAsgn const & other) const { return tr > other.tr or (tr == other.tr and toInt(sgn) > toInt(other.sgn)); } bool operator< (PtAsgn const & other) const { return tr < other.tr or (tr == other.tr and toInt(sgn) < toInt(other.sgn)); } }; // Strict weak ordering of PtAsgn: Instances with same tr, but different sgn are treated as equivalent. // OK to be used in sorting, see https://en.cppreference.com/w/cpp/named_req/Compare struct LessThan_PtAsgn { bool operator() (PtAsgn x, PtAsgn y) { return x.tr.x < y.tr.x; } }; static class PtAsgn PtAsgn_Undef(PTRef_Undef, l_Undef); struct PtAsgnHash { uint32_t operator () (const PtAsgn& s) const;/* { return ((uint32_t)s.tr.x << 2) + toInt(s.sgn); }*/ }; class PtAsgn_reason { public: PTRef tr; PTRef reason; lbool sgn; PtAsgn_reason(PTRef tr_, lbool sgn_, PTRef reason_) : tr(tr_) , reason(reason_) , sgn(sgn_) {} PtAsgn_reason() : tr(PTRef_Undef), reason(PTRef_Undef), sgn(l_Undef) {} }; static class PtAsgn_reason PtAsgn_reason_Undef(PTRef_Undef, l_Undef, PTRef_Undef); #endif //OPENSMT_PTHELPERSTRUCTS_H opensmt-2.5.2/src/pterms/Pterm.cc000066400000000000000000000010471445011647600167160ustar00rootroot00000000000000#include "Pterm.h" // MB: TODO this calls method that is not implemented void PtermAllocator::reloc(PTRef& tr, PtermAllocator& to) { Pterm& t = operator[](tr); if (t.reloced()) { tr = t.relocation(); return; } // TODO: this is not implemented! tr = to.alloc(t, false); t.relocate(tr); // Copy extra data-fields: to[tr].type(t.type()); // if (to[tr].learnt()) to[tr].activity() = t.activity(); // else if (to[tr].has_extra()) to[tr].calcAbstraction(); } opensmt-2.5.2/src/pterms/Pterm.h000066400000000000000000000223101445011647600165540ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ // Strongly MiniSat inspired implementation for proper terms #ifndef PTERM_H #define PTERM_H #include "Vec.h" #include "Sort.h" #include "SolverTypes.h" #include "SymRef.h" #include "PtStructs.h" // A key used for pterm resolve lookups struct PTLKey { SymRef sym; vec args; friend bool operator== (const PTLKey& k1, const PTLKey& k2) { if (k1.sym != k2.sym) return false; if (k1.args.size() != k2.args.size()) return false; int i; for (i = 0; i < k1.args.size(); i++) if (k1.args[i] != k2.args[i]) break; return i == k1.args.size(); } }; struct PTLHash { uint32_t operator () (const PTLKey& s) const { uint32_t v = (uint32_t)s.sym.x; for (int i = 0; i < s.args.size(); i++) { v += (uint32_t)s.args[i].x; } return v; } }; //typedef uint32_t TRef; struct PTId { uint32_t x; inline friend bool operator== (const PTId& a1, const PTId& a2) { return a1.x == a2.x; } inline friend bool operator!= (const PTId& a1, const PTId& a2) { return a1.x != a2.x; } inline friend bool operator< (const PTId& a1, const PTId& a2) { return a1.x > a2.x; } inline friend uint32_t Idx(PTId p) { return p.x; } }; class Pterm { struct { unsigned type : 3; unsigned has_extra : 1; unsigned reloced : 1; unsigned noscoping : 1; unsigned size : 26; } header; PTId id; SymRef sym; PTRef args[0]; // Either the terms or the relocation reference friend class PtermAllocator; friend void ptermSort(Pterm&); public: // forbid any copies or moves Pterm() = delete; Pterm(const Pterm&) = delete; Pterm(Pterm&&) = delete; Pterm operator= (Pterm) = delete; Pterm operator= (const Pterm&) = delete; Pterm operator= (Pterm&) = delete; Pterm operator= (Pterm&&) = delete; int size () const { return static_cast(header.size); } PTRef operator [] (int i) const { assert(i < size()); return args[i]; } SymRef symb () const { return sym; } bool has_extra () const { return false; } bool reloced () const { return header.reloced; } PTRef relocation () const { return args[0]; } void relocate (PTRef t) { header.reloced = 1; args[0] = t; } uint32_t type () const { return header.type; } void type (uint32_t m) { header.type = m; } bool left_assoc () const { return header.type == 1; } bool right_assoc () const { return header.type == 2; } bool chainable () const { return header.type == 3; } bool pairwise () const { return header.type == 4; } bool noScoping () const { return header.noscoping; } uint32_t nargs () const { return size(); } bool setLeftAssoc () { if (header.type != 0) return false; return (header.type = 1); } bool setRightAssoc() { if (header.type != 0) return false; return (header.type = 2); } bool setChainable () { if (header.type != 0) return false; return (header.type = 3); } bool setPairwise () { if (header.type != 0) return false; return (header.type = 4); } void setNoScoping () { header.noscoping = 1; } PTId getId() const { return id; } void setId(int i) { id.x = i; } void shrink(int s) { header.size -= s; } /** * @note The function is unsafe: if used in a loop, the loop should in *absolutely no case* build new terms in the same Pterm allocator * @return A pointer to the first child of the term */ const PTRef* begin() const { return args; } /** * @note The function is unsafe: if used in a loop, the loop should in *absolutely no case* build new terms in the same Pterm allocator * @return A pointer to right past the last child of the term */ const PTRef* end() const { return args + size(); } #ifdef PEDANTIC_DEBUG void compare(Pterm& other) { assert(header.type == other.header.type); assert(header.has_extra == other.header.has_extra); assert(header.reloced == other.header.reloced); assert(header.noscoping == other.header.noscoping); assert(header.size == other.header.size); assert(id == other.id); assert(sym == other.sym); for (int i = 0; i < header.size; i++) assert(args[i] == other.args[i]); } #endif private: // MB: Constructor is private to forbid any use outside PtermAllocator, which is a friend Pterm(const SymRef sym_, const vec & ps) : sym(sym_) { header.type = 0; header.has_extra = 0; header.reloced = 0; header.noscoping = 0; // This is an optimization to avoid expensive name lookup on logic operations header.size = ps.size(); for (int i = 0; i < ps.size(); i++) { args[i] = ps[i]; } } }; class PtPair { public: PTRef x; PTRef y; PtPair(PTRef x_, PTRef y_) : x(x_), y(y_) {} }; class PtChild { public: PTRef tr; PTRef parent; int pos; PtChild(PTRef tr_, PTRef parent_, int pos_) : tr(tr_), parent(parent_), pos(pos_) {} PtChild() : tr(PTRef_Undef), parent(PTRef_Undef), pos(-1) {} inline friend bool operator== (const PtChild& a1, const PtChild& a2) { return (a1.tr == a2.tr) && (a1.parent == a2.parent) && (a1.pos == a2.pos); } inline friend bool operator!= (const PtChild& a1, const PtChild& a2) { return (a1.tr != a2.tr) || (a1.parent != a2.parent) || (a1.pos != a2.pos); } }; struct PtChildHash { uint32_t operator () (const PtChild& s) const { return (uint32_t)s.tr.x+(uint32_t)s.parent.x+(uint32_t)s.pos; } }; class PtermAllocator : public RegionAllocator { uint32_t n_terms; static int ptermWord32Size(int size) { return (sizeof(Pterm) + (sizeof(PTRef) * size )) / sizeof(uint32_t); } public: PtermAllocator(uint32_t start_cap) : RegionAllocator(start_cap), n_terms(0) {} PtermAllocator() : n_terms(0) {} uint32_t getNumTerms() const { return n_terms; } void moveTo(PtermAllocator& to) { to.n_terms = n_terms; RegionAllocator::moveTo(to); } PTRef alloc(const SymRef sym, const vec & ps) { assert(sizeof(PTRef) == sizeof(uint32_t)); uint32_t v = RegionAllocator::alloc(ptermWord32Size(ps.size())); PTRef tid = {v}; new(lea(tid)) Pterm(sym, ps); operator[](tid).setId(n_terms++); return tid; } PTRef alloc(Pterm&, bool) { assert(false); return PTRef_Undef; } // Deref, Load Effective Address (LEA), Inverse of LEA (AEL): Pterm& operator[](PTRef r) { return (Pterm&)RegionAllocator::operator[](r.x); } const Pterm& operator[](PTRef r) const { return (Pterm&)RegionAllocator::operator[](r.x); } Pterm* lea (PTRef r) { return (Pterm*)RegionAllocator::lea(r.x); } const Pterm* lea (PTRef r) const { return (Pterm*)RegionAllocator::lea(r.x); } PTRef ael (const Pterm* t) { RegionAllocator::Ref r = RegionAllocator::ael((uint32_t*)t); PTRef rf; rf.x = r; return rf; } void free(PTRef tid) { Pterm const & t = operator[](tid); RegionAllocator::free(ptermWord32Size(t.size())); } void reloc(PTRef& tr, PtermAllocator& to); /*{ Pterm& t = operator[](tr); if (t.reloced()) { tr = t.relocation(); return; } tr = to.alloc(t, false); t.relocate(tr); // Copy extra data-fields: to[tr].type(t.type()); // if (to[tr].learnt()) to[tr].activity() = t.activity(); // else if (to[tr].has_extra()) to[tr].calcAbstraction(); }*/ friend class PtStore; }; #endif opensmt-2.5.2/src/rewriters/000077500000000000000000000000001445011647600160325ustar00rootroot00000000000000opensmt-2.5.2/src/rewriters/ArithmeticEqualityRewriter.h000066400000000000000000000033201445011647600235340ustar00rootroot00000000000000/* * Copyright (c) 2021-2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #ifndef OPENSMT_ARITHMETICEQUALITYREWRITER_H #define OPENSMT_ARITHMETICEQUALITYREWRITER_H #include "Rewriter.h" class EqualityRewriterConfig : public DefaultRewriterConfig { ArithLogic & logic; std::unique_ptr> notOkToPartition; public: EqualityRewriterConfig(ArithLogic & logic) : logic(logic), notOkToPartition(new Map()) {} std::unique_ptr> getAndClearNotOkToPartition() { auto tmp = std::unique_ptr>(new Map()); std::swap(tmp, notOkToPartition); return tmp; } bool previsit(PTRef term) override { return logic.hasSortBool(term) and not logic.isIte(term); } PTRef rewrite(PTRef term) override { if (logic.isNumEq(term)) { Pterm const & p = logic.getPterm(term); PTRef a1 = p[0]; PTRef a2 = p[1]; PTRef i1 = logic.mkLeq(a1, a2); PTRef i2 = logic.mkGeq(a1, a2); notOkToPartition->insert(i1, true); notOkToPartition->insert(i2, true); term = logic.mkAnd(i1, i2); } return term; } }; class ArithmeticEqualityRewriter : public Rewriter { EqualityRewriterConfig config; public: ArithmeticEqualityRewriter(ArithLogic & logic) : Rewriter(logic, config), config(logic) {} std::unique_ptr> getAndClearNotOkToPartition() { return config.getAndClearNotOkToPartition(); } }; #endif // OPENSMT_ARITHMETICEQUALITYREWRITER_H opensmt-2.5.2/src/rewriters/CMakeLists.txt000066400000000000000000000003541445011647600205740ustar00rootroot00000000000000add_library(rewriters OBJECT "") target_sources(rewriters PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/DistinctRewriter.cc" ) install(FILES Substitutor.h Rewriter.h DivModRewriter.h DESTINATION ${INSTALL_HEADERS_DIR} ) opensmt-2.5.2/src/rewriters/DistinctRewriter.cc000066400000000000000000000011121445011647600216410ustar00rootroot00000000000000/* * Copyright (c) 2021-2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #include "DistinctRewriter.h" #include "TreeOps.h" PTRef rewriteDistinctsKeepTopLevel(Logic & logic, PTRef fla) { vec topLevelConjuncts = ::topLevelConjuncts(logic, fla); KeepTopLevelDistinctRewriter::TopLevelDistincts topLevelDistincts; for (PTRef conj : topLevelConjuncts) { if (logic.isDisequality(conj)) { topLevelDistincts.insert(conj); } } return KeepTopLevelDistinctRewriter(logic, std::move(topLevelDistincts)).rewrite(fla); } opensmt-2.5.2/src/rewriters/DistinctRewriter.h000066400000000000000000000050631445011647600215140ustar00rootroot00000000000000/* * Copyright (c) 2021-2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #ifndef OPENSMT_DISTINCTREWRITER_H #define OPENSMT_DISTINCTREWRITER_H #include "Rewriter.h" #include class DistinctRewriteConfig : public DefaultRewriterConfig { protected: Logic & logic; public: DistinctRewriteConfig(Logic & logic) : logic(logic) {} bool previsit(PTRef term) override { return logic.hasSortBool(term); } PTRef rewrite(PTRef ptr) override { if (logic.isDisequality(ptr) and doRewriteDistinct(ptr)) { Pterm const & term = logic.getPterm(ptr); vec args; args.capacity(term.nargs()); for (PTRef arg : term) { args.push(arg); } vec inequalities; for (int i = 0; i < args.size(); ++i) { for (int j = i + 1; j < args.size(); ++j) { inequalities.push(logic.mkNot(logic.mkEq(args[i], args[j]))); } } return logic.mkAnd(std::move(inequalities)); } return ptr; } virtual bool doRewriteDistinct(PTRef) const { return true; } }; class KeepTopLevelDistinctRewriteConfig : public DistinctRewriteConfig { public: using TopLevelDistincts = std::unordered_set; KeepTopLevelDistinctRewriteConfig(Logic & logic, std::unordered_set topLevelDistincts) : DistinctRewriteConfig(logic), topLevelDistincts(std::move(topLevelDistincts)) {} bool doRewriteDistinct(PTRef dist) const override { return topLevelDistincts.find(dist) == topLevelDistincts.end(); } private: TopLevelDistincts topLevelDistincts; }; class DistinctRewriter : public Rewriter { DistinctRewriteConfig config; public: DistinctRewriter(Logic & logic) : Rewriter(logic, config), config(logic) {} }; class KeepTopLevelDistinctRewriter : public Rewriter { KeepTopLevelDistinctRewriteConfig config; public: using TopLevelDistincts = KeepTopLevelDistinctRewriteConfig::TopLevelDistincts; KeepTopLevelDistinctRewriter(Logic & logic, TopLevelDistincts topLevelDistincts) : Rewriter(logic, config), config(logic, std::move(topLevelDistincts)) {} }; inline PTRef rewriteDistincts(Logic & logic, PTRef fla) { return DistinctRewriter(logic).rewrite(fla); } PTRef rewriteDistinctsKeepTopLevel(Logic & logic, PTRef fla); #endif // OPENSMT_DISTINCTREWRITER_H opensmt-2.5.2/src/rewriters/DivModRewriter.h000066400000000000000000000126061445011647600211160ustar00rootroot00000000000000/* * Copyright (c) 2021-2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #ifndef OPENSMT_DIVMODREWRITER_H #define OPENSMT_DIVMODREWRITER_H #include "Rewriter.h" #include "ArithLogic.h" #include "PTRef.h" #include "OsmtApiException.h" #include "OsmtInternalException.h" #include "TypeUtils.h" #include #include class DivModConfig : public DefaultRewriterConfig { ArithLogic & logic; struct DivModPair { PTRef div; PTRef mod; }; std::unordered_map, DivModPair, PTRefPairHash> divModCache; vec definitions; DivModPair freshDivModPair(PTRef dividend, PTRef divisor) { std::string id = "_" + std::to_string(dividend.x) + "_" + std::to_string(divisor.x); std::string divName(divPrefix); divName += id; std::string modName(modPrefix); modName += id; return {logic.mkIntVar(divName.c_str()), logic.mkIntVar(modName.c_str())}; } static opensmt::pair getDividendAndDivisor(std::string_view const name, std::string_view const prefix) { std::string dividendNumberStr; std::string divisorNumberStr; bool parsingDividend = true; for (auto it = name.begin() + prefix.size() + 1; it != name.end(); ++it) { if (parsingDividend and '0' <= *it and *it <= '9') { dividendNumberStr += *it; } else if (not parsingDividend and '0' <= *it and *it <= '9') { divisorNumberStr += *it; } else if (*it == '_') { if (not parsingDividend) throw OsmtInternalException("Parse error in auxiliary variable symbol: " + std::string(name)); parsingDividend = false; } } return {{static_cast(std::stoul(dividendNumberStr))}, {static_cast(std::stoul(divisorNumberStr))}}; } public: static std::string_view constexpr divPrefix = ".div"; static std::string_view constexpr modPrefix = ".mod"; DivModConfig(ArithLogic & logic) : logic(logic) {} PTRef rewrite(PTRef term) override { SymRef symRef = logic.getSymRef(term); if (logic.isIntDiv(symRef) || logic.isMod(symRef)) { assert(logic.getPterm(term).size() == 2); PTRef dividend = logic.getPterm(term)[0]; PTRef divisor = logic.getPterm(term)[1]; // check cache first auto it = divModCache.find({dividend, divisor}); bool inCache = (it != divModCache.end()); DivModPair divMod = inCache ? it->second : freshDivModPair(dividend, divisor); if (not inCache) { divModCache.insert({{dividend, divisor}, divMod}); } PTRef divVar = divMod.div; PTRef modVar = divMod.mod; PTRef rewritten = logic.isIntDiv(symRef) ? divVar : modVar; if (not inCache) { // collect the definitions to add assert(logic.isConstant(divisor)); auto divisorVal = logic.getNumConst(divisor); // general case auto upperBound = abs(divisorVal) - 1; // dividend = divVar * divisor + modVar // 0 <= modVar <= |dividend| - 1 definitions.push(logic.mkAnd(logic.mkEq(dividend, logic.mkPlus(logic.mkTimes(divisor, divVar), modVar)), logic.mkAnd(logic.mkLeq(logic.getTerm_IntZero(), modVar), logic.mkLeq(modVar, logic.mkIntConst(upperBound))))); } return rewritten; } return term; } void getDefinitions(vec & out) { for (PTRef def : definitions) { out.push(def); } } // Inverse operator from auxVar to Div Term static PTRef getDivTermFor(ArithLogic & logic, PTRef auxVar) { std::string const & name = logic.getSymName(auxVar); assert(name.compare(0, divPrefix.size(), divPrefix) == 0); auto [dividendTr, divisorTr] = getDividendAndDivisor(name, divPrefix); return logic.mkIntDiv(dividendTr, divisorTr); } // Inverse operator from auxVar to Mod Term static PTRef getModTermFor(ArithLogic & logic, PTRef auxVar) { std::string const & name = logic.getSymName(auxVar); assert(name.compare(0, modPrefix.size(), modPrefix) == 0); auto [dividendTr, divisorTr] = getDividendAndDivisor(name, modPrefix); return logic.mkMod(dividendTr, divisorTr); } }; class DivModRewriter : Rewriter { ArithLogic & logic; DivModConfig config; public: DivModRewriter(ArithLogic & logic) : Rewriter(logic, config), logic(logic), config(logic) {} PTRef rewrite(PTRef term) override { if (term == PTRef_Undef or not logic.hasSortBool(term)) { throw OsmtApiException("Div/Mod rewriting should only be called on formulas, not terms!"); } PTRef rewritten = Rewriter::rewrite(term); vec args; args.push(rewritten); config.getDefinitions(args); return logic.mkAnd(args); } }; // Simple single-use version inline PTRef rewriteDivMod(ArithLogic & logic, PTRef root) { return DivModRewriter(logic).rewrite(root); } #endif // OPENSMT_DIVMODEREWRITER_H opensmt-2.5.2/src/rewriters/Rewriter.h000066400000000000000000000073071445011647600200150ustar00rootroot00000000000000/* * Copyright (c) 2021-2022, Antti Hyvarinen * Copyright (c) 2021-2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #ifndef OPENSMT_REWRITER_H #define OPENSMT_REWRITER_H #include "Logic.h" template class Rewriter { protected: Logic & logic; TConfig & cfg; public: Rewriter(Logic & logic, TConfig & cfg) : logic(logic), cfg(cfg) {} virtual PTRef rewrite(PTRef root) { // MB: If term has no children then single call to config is enough; // this can save memory allocations if successful if (logic.isVar(root)) { return cfg.previsit(root) ? cfg.rewrite(root) : root; } struct DFSEntry { DFSEntry(PTRef term) : term(term) {} PTRef term; unsigned int nextChild = 0; }; auto termMarks = logic.getTermMarks(logic.getPterm(root).getId()); Map substitutions; vec auxiliaryArgs; std::vector toProcess; toProcess.emplace_back(root); while (not toProcess.empty()) { auto & currentEntry = toProcess.back(); PTRef currentRef = currentEntry.term; auto currentId = logic.getPterm(currentRef).getId(); if (not cfg.previsit(currentRef)) { toProcess.pop_back(); termMarks.mark(currentId); continue; } assert(not termMarks.isMarked(currentId)); Pterm const & term = logic.getPterm(currentRef); unsigned childrenCount = term.size(); if (currentEntry.nextChild < childrenCount) { PTRef nextChild = term[currentEntry.nextChild]; ++currentEntry.nextChild; auto childId = logic.getPterm(nextChild).getId(); if (not termMarks.isMarked(childId)) { toProcess.push_back(DFSEntry(nextChild)); } continue; } // If we are here, we have already processed all children assert(not substitutions.has(currentRef)); auxiliaryArgs.capacity(childrenCount); bool needsChange = false; for (unsigned i = 0; i < childrenCount; ++i) { PTRef target; bool childChanged = substitutions.peek(term[i], target); needsChange |= childChanged; assert(not childChanged or (logic.getSortRef(target) == logic.getSortRef(term[i]))); PTRef newChild = childChanged ? target : term[i]; auxiliaryArgs.push(newChild); } PTRef newTerm = needsChange ? logic.insertTerm(term.symb(), std::move(auxiliaryArgs)) : currentRef; auxiliaryArgs.clear(); // The reference "term" has now been possibly invalidated! Do not access it anymore! PTRef rewritten = cfg.rewrite(newTerm); if (rewritten != newTerm or needsChange) { assert(logic.getSortRef(currentRef) == logic.getSortRef(rewritten)); substitutions.insert(currentRef, rewritten); } termMarks.mark(currentId); toProcess.pop_back(); } PTRef target; PTRef res = substitutions.peek(root, target) ? target : root; return res; } }; class DefaultRewriterConfig { public: virtual bool previsit(PTRef) { return true; } // should continue visiting virtual PTRef rewrite(PTRef term) { return term; } // don't do anything }; class NoOpRewriter : Rewriter { DefaultRewriterConfig config; public: NoOpRewriter(Logic & logic) : Rewriter(logic, config) {} }; #endif // OPENSMT_REWRITER_Hopensmt-2.5.2/src/rewriters/Substitutor.h000066400000000000000000000014701445011647600205540ustar00rootroot00000000000000/* * Copyright (c) 2021-2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #ifndef OPENSMT_SUBSTITUTOR_H #define OPENSMT_SUBSTITUTOR_H #include "Rewriter.h" class SubstitutionConfig : public DefaultRewriterConfig { public: using SubMap = Logic::SubstMap; private: SubMap const & subMap; public: SubstitutionConfig(SubMap const & subMap) : subMap(subMap) {} PTRef rewrite(PTRef term) override { PTRef result; return subMap.peek(term, result) ? result : term; } }; class Substitutor : public Rewriter { SubstitutionConfig config; public: Substitutor(Logic & logic, SubstitutionConfig::SubMap const & substs) : Rewriter(logic, config), config(substs) {} }; #endif // OPENSMT_SUBSTITUTOR_Hopensmt-2.5.2/src/simplifiers/000077500000000000000000000000001445011647600163325ustar00rootroot00000000000000opensmt-2.5.2/src/simplifiers/AXDiffPreproc.cc000066400000000000000000001611231445011647600213010ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #include "AXDiffPreproc.h" #define NEW_MOD 1 #define NEW_MOD_2 1 #define NEW_MOD_3 0 Enode * AXDiffPreproc::doit( Enode * formula #ifdef PRODUCE_PROOF , const ipartitions_t p #endif ) { #ifdef PRODUCE_PROOF assert( config.produce_inter == 0 || p != 0 ); partition = p; #endif assert( formula ); assert( config.logic == QF_AXDIFF || config.logic == QF_AX ); // Gaussian elimination only if proof is not required #ifndef PRODUCE_PROOF formula = gauss( formula ); // egraph.dumpToFile( "aftergauss.smt2", formula ); #endif formula = flatten( formula ); #ifdef PRODUCE_PROOF // assert( config.produce_inter == 0 // || checkPartitions( formula ) ); #endif formula = addNeqAxioms( formula ); #ifdef PRODUCE_PROOF // assert( config.produce_inter == 0 // || checkPartitions( formula ) ); if ( config.produce_inter != 0 ) formula = normalizeDiffs( formula ); #endif formula = addEqualities ( formula ); #ifdef PRODUCE_PROOF // assert( config.produce_inter == 0 // || checkPartitions( formula ) ); #endif array_eqs_processed = array_eqs.size( ); // array_vars.clear( ); #ifndef PRODUCE_PROOF formula = canonize( formula ); #endif return formula; } #ifndef PRODUCE_PROOF Enode * AXDiffPreproc::gauss( Enode * formula ) { // Retrieve i != j at top-level (useful for applying axioms) retrieveTopLevelIndexNeqs( formula ); // A good canonization does not hurt ... formula = canonize( formula ); vector< Enode * > eq_list; do { eq_list.clear( ); Enode * rest = retrieveTopLevelArrayEqs( formula, eq_list ); if ( !eq_list.empty( ) ) formula = elimination( rest, eq_list ); } while( !eq_list.empty( ) ); // formula = solveReflexArrayEquations( formula ); return formula; } Enode * AXDiffPreproc::instantiateNeq( Enode * l , Enode * r , list< Enode * > & equalities ) { list< Enode * > conj_list; for ( set< Enode * >::iterator it = index_variables.begin( ) ; it != index_variables.end( ) ; it ++ ) { Enode * ll = canonizeTerm( egraph.mkSelect( l, *it ) ); Enode * rr = canonizeTerm( egraph.mkSelect( r, *it ) ); ll = getFlat( ll, equalities ); rr = getFlat( rr, equalities ); Enode * eq = egraph.mkEq( egraph.cons( ll , egraph.cons( rr ) ) ); conj_list.push_back( eq ); } return egraph.mkAnd( egraph.cons( conj_list ) ); } Enode * AXDiffPreproc::solveReflexArrayEquations( Enode * formula ) { egraph.initDupMap1( ); vector< Enode * > unprocessed_enodes; unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.valDupMap1( enode ) != NULL ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( egraph.valDupMap1( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); Enode * result = NULL; if ( enode->isEq( ) && enode->get1st( )->getRetSort( ) == egraph.getSortArray( ) ) { Enode * l = enode->get1st( ); Enode * r = enode->get2nd( ); vector< Enode * > l_indexes; vector< Enode * > r_indexes; vector< Enode * > l_elements; vector< Enode * > r_elements; while ( l->isStore( ) ) { l_indexes.push_back( l->get2nd( ) ); l_elements.push_back( l->get3rd( ) ); l = l->get1st( ); } while ( r->isStore( ) ) { r_indexes.push_back( r->get2nd( ) ); r_elements.push_back( r->get3rd( ) ); r = r->get1st( ); } if ( l == r ) { Enode * simp = simplifyStoreEq( enode ); // cerr << "Processing: " << simp << endl; list< Enode * > read_eqs; Enode * res = solve( simp, read_eqs ); (void)res; assert( res == NULL ); result = egraph.mkAnd( egraph.cons( read_eqs ) ); // cerr << "Result : " << result << endl; } } if ( result == NULL ) result = egraph.copyEnodeEtypeTermWithCache( enode ); assert( egraph.valDupMap1( enode ) == NULL ); egraph.storeDupMap1( enode, result ); } Enode * result = egraph.valDupMap1( formula ); assert( result ); egraph.doneDupMap1( ); result = canonize( result ); return result; } Enode * AXDiffPreproc::retrieveTopLevelArrayEqs( Enode * formula , vector< Enode * > & eq_list ) { list< Enode * > others; vector< Enode * > unprocessed_enodes; egraph.initDup1( ); unprocessed_enodes .push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); unprocessed_enodes.pop_back( ); // // Skip if the node has already been processed before // if ( egraph.isDup1( enode ) ) continue; if ( enode->isAnd( ) ) { Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); unprocessed_enodes.push_back( arg ); } continue; } // // Add a new substitution for iff if possible // if ( enode->isEq( ) // Equality && enode->get1st( )->getRetSort( ) == egraph.getSortArray( ) ) // of sort array { /* Enode * a = enode->get1st( ); Enode * b = enode->get2nd( ); while( a->isStore( ) ) a = a->get1st( ); while( b->isStore( ) ) b = b->get1st( ); if ( a != b ) eq_list.push_back( enode ); else others.push_back( solveReflexArrayEquations( enode ) ); */ eq_list.push_back( enode ); } else { others.push_back( enode ); } } egraph.doneDup1( ); return egraph.mkAnd( egraph.cons( others ) ); } void AXDiffPreproc::retrieveTopLevelIndexNeqs( Enode * formula ) { vector< Enode * > unprocessed_enodes; egraph.initDup1( ); unprocessed_enodes .push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); unprocessed_enodes.pop_back( ); // // Skip if the node has already been processed before // if ( egraph.isDup1( enode ) ) continue; if ( enode->isAnd( ) ) { Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); unprocessed_enodes.push_back( arg ); } continue; } // // Add a new substitution for iff if possible // if ( enode->isNot( ) && enode->get1st( )->isEq( ) && enode->get1st( )->get1st( )->getRetSort( ) == egraph.getSortIndex( ) ) { top_neg_indexes.insert( enode->get1st( ) ); } egraph.storeDup1( enode ); } egraph.doneDup1( ); } Enode * AXDiffPreproc::simplifyStoreEq( Enode * e ) { assert( e->isEq( ) ); Enode * lhs = e->get1st( ); Enode * rhs = e->get2nd( ); lhs = simplifyStore( lhs ); rhs = simplifyStore( rhs ); Enode * simp = egraph.mkEq( egraph.cons( lhs, egraph.cons( rhs ) ) ); #ifdef PRODUCE_PROOF assignPartitionsFrom( simp, lhs, rhs ); #endif return simp; } Enode * AXDiffPreproc::simplifyStore( Enode * e ) { assert( e->isStore( ) || e->isVar( ) ); egraph.initDup1( ); vector< Enode * > useful_stores; Enode * a = e; while ( a->isStore( ) ) { Enode * i = a->get2nd( ); if ( !egraph.isDup1( i ) ) { useful_stores.push_back( a ); egraph.storeDup1( i ); } a = a->get1st( ); } Enode * result = a; while ( !useful_stores.empty( ) ) { Enode * useful_store = useful_stores.back( ); useful_stores.pop_back( ); result = egraph.mkStore( result , useful_store->get2nd( ) , useful_store->get3rd( ) ); } egraph.doneDup1( ); return result; } Enode * AXDiffPreproc::canonize( Enode * formula ) { assert( formula ); vector< Enode * > unprocessed_enodes; egraph.initDupMap2( ); unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.valDupMap2( enode ) != NULL ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( egraph.valDupMap2( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; Enode * result = NULL; #if NEW_MOD_2 if ( enode->isSelect( ) ) { // Assume arguments are already canonical Enode * a = egraph.valDupMap2( enode->get1st( ) ); Enode * i = egraph.valDupMap2( enode->get2nd( ) ); result = egraph.mkSelect( a, i ); result = canonizeTerm( result ); } else if ( enode->isStore( ) ) { Enode * a = egraph.valDupMap2( enode->get1st( ) ); Enode * i = egraph.valDupMap2( enode->get2nd( ) ); Enode * e = egraph.valDupMap2( enode->get3rd( ) ); result = egraph.mkStore( a, i, e ); result = canonizeTerm( result ); } // TODO: probably useless else if ( enode->isEq( ) ) { Enode * l = egraph.valDupMap2( enode->get1st( ) ); Enode * r = egraph.valDupMap2( enode->get2nd( ) ); l = canonizeTerm( l ); r = canonizeTerm( r ); result = egraph.mkEq( egraph.cons( l, egraph.cons( r ) ) ); } #else if ( enode->isEq( ) ) { Enode * l = enode->get1st( ); Enode * r = enode->get2nd( ); l = canonizeTerm( l ); r = canonizeTerm( r ); result = egraph.mkEq( egraph.cons( l, egraph.cons( r ) ) ); } #endif if ( result == NULL ) result = egraph.copyEnodeEtypeTermWithCache( enode, true ); egraph.storeDupMap2( enode, result ); } Enode * new_formula = egraph.valDupMap2( formula ); egraph.doneDupMap2( ); assert( new_formula ); return new_formula; } Enode * AXDiffPreproc::canonizeTerm( Enode * assump, set< Enode * > & neg_assump, Enode * t ) { Enode * result = NULL; // If element equation if ( t->isSelect( ) ) { Enode * a = t->get1st( ); Enode * i = t->get2nd( ); // Canonize store first Enode * innermost_a = simplifyStore( a ); Enode * element = NULL; bool stop = false; while( element == NULL && innermost_a->isStore( ) && !stop ) { Enode * j = innermost_a->get2nd( ); Enode * e_ij = egraph.mkEq( egraph.cons( i, egraph.cons( j ) ) ); // If they are the same, or the same modulo assumption if ( j == i || e_ij == assump ) element = innermost_a->get3rd( ); // If they are explicitly different else if ( neg_assump.find( e_ij ) != neg_assump.end( ) ) { innermost_a = innermost_a->get1st( ); } // Otherwise innermost_a is the term to use else stop = true; } // Element found ! if ( element ) { #if NEW_MOD_2 result = element; #else result = canonizeTerm( element ); #endif } else result = egraph.mkSelect( innermost_a, i ); } else if ( t->isStore( ) ) { assert( false ); } else result = t; assert( result ); return result; } Enode * AXDiffPreproc::canonizeTerm( Enode * t ) { Enode * result = NULL; // If element equation if ( t->isSelect( ) ) { Enode * a = t->get1st( ); Enode * i = t->get2nd( ); // Canonize store first Enode * innermost_a = simplifyStore( a ); Enode * element = NULL; bool stop = false; while( element == NULL && innermost_a->isStore( ) && !stop ) { Enode * j = innermost_a->get2nd( ); // If they are the same if ( j == i ) element = innermost_a->get3rd( ); // If they are explicitly different else if ( top_neg_indexes.find( egraph.mkEq( egraph.cons( i, egraph.cons( j ) ) ) ) != top_neg_indexes.end( ) ) { innermost_a = innermost_a->get1st( ); } // Otherwise innermost_a is the term to use else stop = true; } // Element found ! if ( element ) { #if NEW_MOD_2 result = element; #else result = canonizeTerm( element ); #endif } else result = egraph.mkSelect( innermost_a, i ); } else if ( t->isStore( ) ) { result = simplifyStore( t ); } else result = t; assert( result ); return result; } Enode * AXDiffPreproc::solve( Enode * formula, list< Enode * > & read_eqs ) { // cerr << "Solving: " << formula << endl; #if 0 assert( config.produce_inter == 0 ); assert( formula ); vector< Enode * > unprocessed_enodes; egraph.initDupMap1( ); unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.valDupMap1( enode ) != NULL ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( egraph.valDupMap1( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; Enode * result = NULL; // Solve only array eqs if ( enode->isEq( ) && enode->get1st( )->getRetSort( ) == egraph.getSortArray( ) ) { Enode * lhs = egraph.valDupMap1( enode->get1st( ) ); Enode * rhs = egraph.valDupMap1( enode->get2nd( ) ); // Solve only this case if ( lhs->isStore( ) && rhs->isStore( ) ) { Enode * saved_lhs = lhs; Enode * saved_rhs = rhs; Enode * a = lhs; vector< Enode * > a_indexes; vector< Enode * > a_elements; int count_a = 0; while( a->isStore( ) ) { a_indexes.push_back( a->get2nd( ) ); a_elements.push_back( a->get3rd( ) ); a = a->get1st( ); count_a ++; } assert( a->isVar( ) ); Enode * b = rhs; vector< Enode * > b_indexes; vector< Enode * > b_elements; int count_b = 0; while( b->isStore( ) ) { b_indexes.push_back( b->get2nd( ) ); b_elements.push_back( b->get3rd( ) ); b = b->get1st( ); count_b ++; } assert( b->isVar( ) ); if ( a == b ) { opensmt_error( "Case not handled (yet)" ); } else if ( count_a < count_b ) { // Constructs a = store( b, ... ) for ( size_t j = 0 ; j < a_indexes.size( ) ; j ++ ) { Enode * sel = egraph.mkSelect( a, a_indexes[ j ] ); Enode * fresh = freshVarFrom( sel ); rhs = egraph.mkStore( rhs , a_indexes[ j ] , fresh ); read_eqs.push_back( egraph.mkEq( egraph.cons( egraph.mkSelect( saved_rhs, a_indexes[ j ] ) , egraph.cons( a_elements[ j ] ) ) ) ); read_eqs.push_back( egraph.mkEq( egraph.cons( sel , egraph.cons( fresh ) ) ) ); } lhs = a; result = egraph.mkEq( egraph.cons( lhs, egraph.cons( rhs ) ) ); } else { // Constructs b = store( a, ... ) for ( size_t j = 0 ; j < b_indexes.size( ) ; j ++ ) { Enode * sel = egraph.mkSelect( b, b_indexes[ j ] ); Enode * fresh = freshVarFrom( sel ); lhs = egraph.mkStore( lhs , b_indexes[ j ] , fresh ); read_eqs.push_back( egraph.mkEq( egraph.cons( egraph.mkSelect( saved_lhs, b_indexes[ j ] ) , egraph.cons( b_elements[ j ] ) ) ) ); read_eqs.push_back( egraph.mkEq( egraph.cons( sel , egraph.cons( fresh ) ) ) ); } rhs = b; result = egraph.mkEq( egraph.cons( lhs, egraph.cons( rhs ) ) ); } } } if ( result == NULL ) result = egraph.copyEnodeEtypeTermWithCache( enode ); egraph.storeDupMap1( enode, result ); } Enode * new_formula = egraph.valDupMap1( formula ); egraph.doneDupMap1( ); assert( new_formula ); return new_formula; #else assert( config.produce_inter == 0 ); Enode * eq = formula; assert( eq->isEq( ) ); assert( eq->get1st( )->getRetSort( ) == egraph.getSortArray( ) ); Enode * lhs = eq->get1st( ); Enode * rhs = eq->get2nd( ); Enode * result = NULL; bool is_reflex = false; // Solve only this case /* if ( lhs->isStore( ) && rhs->isStore( ) ) { */ Enode * a = lhs; vector< Enode * > a_indexes; vector< Enode * > a_elements; int count_a = 0; while( a->isStore( ) ) { a_indexes.push_back( a->get2nd( ) ); a_elements.push_back( a->get3rd( ) ); a = a->get1st( ); count_a ++; } assert( a->isVar( ) ); Enode * b = rhs; vector< Enode * > b_indexes; vector< Enode * > b_elements; int count_b = 0; while( b->isStore( ) ) { b_indexes.push_back( b->get2nd( ) ); b_elements.push_back( b->get3rd( ) ); b = b->get1st( ); count_b ++; } assert( b->isVar( ) ); is_reflex = a == b; if ( !is_reflex ) { if ( count_a < count_b ) { // Constructs a = store( b, ... ) for ( size_t j = 0 ; j < a_indexes.size( ) ; j ++ ) { // From wr( a, i, e ) to a lhs = lhs->get1st( ); Enode * sel = egraph.mkSelect( lhs, a_indexes[ j ] ); // Enode * fresh = freshVarFrom( sel ); read_eqs.push_back( egraph.mkEq( egraph.cons( egraph.mkSelect( rhs, a_indexes[ j ] ) , egraph.cons( a_elements[ j ] ) ) ) ); // From b to wr( b, i, rd( wr( a, j, e ), i ) rhs = egraph.mkStore( rhs , a_indexes[ j ] , sel ); } assert( lhs == a ); result = egraph.mkEq( egraph.cons( lhs, egraph.cons( rhs ) ) ); } else { // Constructs b = store( a, ... ) for ( size_t j = 0 ; j < b_indexes.size( ) ; j ++ ) { // From wr( b, i, e ) to b rhs = rhs->get1st( ); Enode * sel = egraph.mkSelect( b, b_indexes[ j ] ); // Enode * fresh = freshVarFrom( sel ); read_eqs.push_back( egraph.mkEq( egraph.cons( egraph.mkSelect( lhs, b_indexes[ j ] ) , egraph.cons( b_elements[ j ] ) ) ) ); // From a to wr( a, i, rd( wr( b, j, e ), i ) lhs = egraph.mkStore( lhs , b_indexes[ j ] , sel ); } assert( rhs == b ); result = egraph.mkEq( egraph.cons( lhs, egraph.cons( rhs ) ) ); } } // Solving Reflexive equations else { Enode * saved_lhs = lhs; Enode * saved_rhs = rhs; // Constructs a = store( b, ... ) for ( size_t j = 0 ; j < a_indexes.size( ) ; j ++ ) { // From wr( a, i, e ) to a lhs = lhs->get1st( ); Enode * sel = egraph.mkSelect( lhs, a_indexes[ j ] ); // Enode * fresh = freshVarFrom( sel ); Enode * eq = egraph.mkEq( egraph.cons( egraph.mkSelect( rhs, a_indexes[ j ] ) , egraph.cons( a_elements[ j ] ) ) ); read_eqs.push_back( canonize( eq ) ); // From b to wr( b, i, rd( wr( a, j, e ), i ) rhs = simplifyStore( egraph.mkStore( rhs, a_indexes[ j ], sel ) ); } assert( lhs == a ); lhs = saved_lhs; rhs = saved_rhs; // Constructs b = store( a, ... ) for ( size_t j = 0 ; j < b_indexes.size( ) ; j ++ ) { // From wr( b, i, e ) to b rhs = rhs->get1st( ); Enode * sel = egraph.mkSelect( rhs, b_indexes[ j ] ); // Enode * fresh = freshVarFrom( sel ); Enode * eq = egraph.mkEq( egraph.cons( egraph.mkSelect( lhs, b_indexes[ j ] ) , egraph.cons( b_elements[ j ] ) ) ); read_eqs.push_back( canonize( eq ) ); // cerr << "Adding: " << read_eqs.back( ) << endl; // From a to wr( a, i, rd( wr( b, j, e ), i ) lhs = simplifyStore( egraph.mkStore( lhs, b_indexes[ j ], sel ) ); } assert( rhs == b ); } /* } if ( result ) { cerr << "result: " << result << endl; } else { cerr << "REFLEX" << endl; } */ return result; #endif } Enode * AXDiffPreproc::elimination( Enode * formula , vector< Enode * > & eq_list ) { assert( config.produce_inter == 0 ); list< Enode * > read_eqs; map< Enode *, Enode * > substs; // // Forward elimination. From the first equality // solve and substitute in all others // for ( size_t i = 0 ; i < eq_list.size( ) ; i ++ ) { assert( eq_list[ i ] ); assert( eq_list[ i ]->isEq( ) ); // Canonize eq eq_list[ i ] = simplifyStoreEq( eq_list[ i ] ); // Solve w.r.t. some variable // May produce some equality // of type Elem Enode * a = eq_list[ i ]->get1st( ); Enode * b = eq_list[ i ]->get2nd( ); while( a->isStore( ) ) a = a->get1st( ); while( b->isStore( ) ) b = b->get1st( ); if ( a == b ) { // Moving in reflex // reflex.push_back( eq_list[ i ] ); Enode * res = solve( eq_list[ i ], read_eqs ); (void)res; assert( res == NULL ); // Removing from the list eq_list[ i ] = NULL; continue; } Enode * res = solve( eq_list[ i ], read_eqs ); assert( res ); eq_list[ i ] = simplifyStoreEq( res ); Enode * lhs = eq_list[ i ]->get1st( ); Enode * rhs = eq_list[ i ]->get2nd( ); assert( !lhs->isStore( ) || !rhs->isStore( ) ); assert( lhs->isVar( ) || rhs->isVar( ) ); if ( lhs->isVar( ) ) substs[ lhs ] = rhs; else substs[ rhs ] = lhs; // Substitute in all equalities down for ( size_t j = i + 1 ; j < eq_list.size( ) ; j ++ ) eq_list[ j ] = substitute( eq_list[ j ], substs ); } // // Backward elimination. From the last equality // solve substitute in the preceding // substs.clear( ); for ( int i = eq_list.size( ) - 1 ; i >= 0 ; i -- ) { // Skip reflex if ( eq_list[ i ] == NULL ) continue; // Canonize eq eq_list[ i ] = simplifyStoreEq( eq_list[ i ] ); assert( eq_list[ i ] ); assert( eq_list[ i ]->isEq( ) ); Enode * lhs = eq_list[ i ]->get1st( ); Enode * rhs = eq_list[ i ]->get2nd( ); assert( !lhs->isStore( ) || !rhs->isStore( ) ); assert( lhs->isVar( ) || rhs->isVar( ) ); if ( lhs->isVar( ) ) substs[ lhs ] = rhs; else substs[ rhs ] = lhs; // Substitute in all equalities up // but skip removed ones for ( int j = i - 1 ; j >= 0 ; j -- ) if ( eq_list[ j ] ) eq_list[ j ] = substitute( eq_list[ j ], substs ); } /* // Add formula reflex.push_back( formula ); formula = egraph.mkAnd( egraph.cons( reflex ) ); */ // Substitute using all substitutions obtained so far Enode * new_formula = substitute( formula, substs ); for ( list< Enode * >::iterator it = read_eqs.begin( ) ; it != read_eqs.end( ) ; ++ it ) { *it = substitute( *it, substs ); } // And rest with reads read_eqs.push_back( new_formula ); new_formula = egraph.mkAnd( egraph.cons( read_eqs ) ); // Canonize and return return canonize( new_formula ); } Enode * AXDiffPreproc::substitute( Enode * formula, map< Enode *, Enode * > & substs ) { assert( formula ); vector< Enode * > unprocessed_enodes; egraph.initDupMap1( ); unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.valDupMap1( enode ) != NULL ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( egraph.valDupMap1( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; map< Enode *, Enode * >::iterator it = substs.find( enode ); Enode * result = NULL; if ( it != substs.end( ) ) { assert( enode->isVar( ) ); result = it->second; } else result = egraph.copyEnodeEtypeTermWithCache( enode ); assert( result ); egraph.storeDupMap1( enode, result ); } Enode * new_formula = egraph.valDupMap1( formula ); egraph.doneDupMap1( ); assert( new_formula ); return new_formula; } Enode * AXDiffPreproc::substitute2( Enode * formula, map< Enode *, Enode * > & substs ) { assert( formula ); vector< Enode * > unprocessed_enodes; egraph.initDupMap2( ); unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.valDupMap2( enode ) != NULL ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( egraph.valDupMap2( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; map< Enode *, Enode * >::iterator it = substs.find( enode ); Enode * result = NULL; if ( it != substs.end( ) ) { assert( enode->isVar( ) ); result = it->second; } else result = egraph.copyEnodeEtypeTermWithCache( enode, true ); assert( result ); egraph.storeDupMap2( enode, result ); } Enode * new_formula = egraph.valDupMap2( formula ); egraph.doneDupMap2( ); assert( new_formula ); return new_formula; } #endif Enode * AXDiffPreproc::flatten( Enode * formula ) { // Step 1: figure out already flat constraints, // which are those equalities at top-level of // the kind c = t, with c constant and t term // of depth 1 assert( formula ); #if NEW_MOD gatherIndexes( formula ); #endif list< Enode * > equalities; list< Enode * > yet_not_flat; egraph.initDup1( ); vector< Enode * > unprocessed_enodes; unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.isDup1( enode ) ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; if ( enode->isAnd( ) ) { Enode * arg_list; for ( arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( !egraph.isDup1( arg ) ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); if ( enode->isEq( ) || ( enode->isNot( ) && enode->get1st( )->isEq( ) ) ) { Enode * eq = enode->isNot( ) ? enode->get1st( ) : enode; const bool is_neq = enode->isNot( ); Enode * l = eq->get1st( ); Enode * r = eq->get2nd( ); bool is_flat = false; if ( is_neq && ( !l->isVar( ) || !r->isVar( ) ) ) { yet_not_flat.push_back( enode ); assert( !egraph.isDup1( enode ) ); egraph.storeDup1( enode ); continue; } // At least one is variable if ( l->isVar( ) || r->isVar( ) ) { #if NEW_MOD is_flat = true; #else if ( l->getRetSort( ) == egraph.getSortArray( ) ) { is_flat = true; while( l->isStore( ) && is_flat ) { is_flat = l->get2nd( )->isVar( ) && l->get3rd( )->isVar( ); l = l->get1st( ); } while( r->isStore( ) && is_flat ) { is_flat = r->get2nd( )->isVar( ) && r->get3rd( )->isVar( ); r = r->get1st( ); } if ( is_neq ) { is_flat = l->isVar( ) && r->isVar( ); array_eqs.push_back( enode->get1st( ) ); } } else { is_flat = true; vector< Enode * > unprocessed_args; unprocessed_args.push_back( l ); unprocessed_args.push_back( r ); while ( !unprocessed_args.empty( ) && is_flat ) { Enode * arg = unprocessed_args.back( ); unprocessed_args.pop_back( ); if ( arg->isStore( ) ) { unprocessed_args.push_back( arg->get1st( ) ); unprocessed_args.push_back( arg->get2nd( ) ); unprocessed_args.push_back( arg->get3rd( ) ); } else if ( arg->isSelect( ) ) { if ( arg != l && arg != r ) is_flat = false; else { unprocessed_args.push_back( arg->get1st( ) ); unprocessed_args.push_back( arg->get2nd( ) ); } } } } #endif } if ( is_flat ) { equalities.push_back( enode ); // We do not do this optimization // when interpolation is enabled if ( enode->isEq( ) && enode->get1st( )->getRetSort( ) == egraph.getSortElem( ) && config.produce_inter == 0 ) { Enode * l = enode->get1st( ); Enode * r = enode->get2nd( ); if ( l->isSelect( ) || r->isSelect( ) ) { assert( !l->isSelect( ) || !r->isSelect( ) ); if ( l->isSelect( ) ) flat_select.insert( l ); if ( r->isSelect( ) ) flat_select.insert( r ); } } #if NEW_MOD #else gatherIndexes( enode ); #endif } else yet_not_flat.push_back( enode ); } else if ( !enode->isAnd( ) ) yet_not_flat.push_back( enode ); assert( !egraph.isDup1( enode ) ); egraph.storeDup1( enode ); } egraph.doneDup1( ); #ifdef PRODUCE_PROOF if ( config.produce_inter != 0 && !yet_not_flat.empty( ) ) opensmt_error( "Currently, we accept only flat constraints for interpolation" ); #endif // // Flatten what has to be flattened // formula = egraph.mkAnd( egraph.cons( yet_not_flat ) ); egraph.initDupMap1( ); unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.valDupMap1( enode ) != NULL ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( egraph.valDupMap1( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); Enode * result = NULL; #if NEW_MOD if ( enode->isEq( ) ) { Enode * l = egraph.valDupMap1( enode->get1st( ) ); Enode * r = egraph.valDupMap1( enode->get2nd( ) ); // // Equality is of the kind // select = select, or // store = store, or // var = store for negated eqs. Create a variable to separate // #if 0 && NEW_MOD_2 if ( l->isStore( ) && r->isStore( ) ) { set< Enode * > neg_assumptions; Enode * eq = egraph.mkEq( egraph.cons( l, egraph.cons( r ) ) ); result = simplifyEq( neg_assumptions, eq, equalities ); cerr << "Rewriting: " << eq << endl; cerr << " Into: " << result << endl; } else { Enode * sep = getFlat( l, equalities ); // // Produce second equality // result = egraph.mkEq( egraph.cons( sep , egraph.cons( r ) ) ); if ( l->isStore( ) || r->isStore( ) ) array_eqs.push_back( result ); } #else if( l->isSelect( ) ) { Enode * sep = getFlat( l, equalities ); // // Produce second equality // result = egraph.mkEq( egraph.cons( sep , egraph.cons( r ) ) ); } else { #if NEW_MOD_3 Enode * a = l; Enode * b = r; while ( a->isStore( ) ) a = a->get1st( ); while ( b->isStore( ) ) b = b->get1st( ); if ( a == b ) { result = instantiateNeq( l, r, equalities ); } else { assert( l->isStore( ) || r->isStore( ) ); Enode * flat_l = getFlat( l, equalities ); Enode * flat_r = getFlat( r, equalities ); result = egraph.mkEq( egraph.cons( flat_l , egraph.cons( flat_r ) ) ); array_eqs.push_back( result ); } #else assert( l->isStore( ) || r->isStore( ) ); Enode * flat_l = getFlat( l, equalities ); Enode * flat_r = getFlat( r, equalities ); result = egraph.mkEq( egraph.cons( flat_l , egraph.cons( flat_r ) ) ); array_eqs.push_back( result ); #endif } #endif } else { result = egraph.copyEnodeEtypeTermWithCache( enode ); } #else if ( enode->isStore( ) ) { Enode * a = egraph.valDupMap1( enode->get1st( ) ); Enode * i = egraph.valDupMap1( enode->get2nd( ) ); Enode * e = egraph.valDupMap1( enode->get3rd( ) ); // Store indexes in writes // write_indexes.insert( i ); // Assume i already flat assert( i->getArity( ) == 0 ); // Do not flatten a Enode * flat_a = a; Enode * flat_e = getFlat( e, equalities ); assert( flat_e ); result = egraph.mkStore( flat_a, i, flat_e ); } else if ( enode->isSelect( ) ) { Enode * a = egraph.valDupMap1( enode->get1st( ) ); Enode * i = egraph.valDupMap1( enode->get2nd( ) ); // Assume i already flat assert( i->getArity( ) == 0 ); Enode * flat_a = a; result = egraph.mkSelect( flat_a, i ); } else if ( enode->isDiff( ) ) { assert( config.logic == QF_AXDIFF ); Enode * a = egraph.valDupMap1( enode->get1st( ) ); Enode * b = egraph.valDupMap1( enode->get2nd( ) ); Enode * flat_a = getFlat( a, equalities ); Enode * flat_b = getFlat( b, equalities ); // Store array_vars assert( flat_b ); assert( flat_a ); result = egraph.mkDiff( flat_a, flat_b ); index_variables.insert( getFlat( result, equalities ) ); } // Flatten all but those array equalities which are at top-level else if ( enode->isEq( ) ) { Enode * l = egraph.valDupMap1( enode->get1st( ) ); Enode * r = egraph.valDupMap1( enode->get2nd( ) ); assert( !l->isStore( ) || r->isStore( ) ); Enode * flat_l = l; Enode * flat_r = r; if ( l->getRetSort( ) != egraph.getSortArray( ) ) { if ( !l->isVar( ) && !r->isVar( ) ) { flat_l = getFlat( l, equalities ); flat_r = getFlat( r, equalities ); } } // Equality of sort array else { flat_l = getFlat( l, equalities ); flat_r = getFlat( r, equalities ); } assert( result == NULL ); result = egraph.mkEq( egraph.cons( flat_l , egraph.cons( flat_r ) ) ); if ( l->getRetSort( ) == egraph.getSortArray( ) ) { array_eqs.push_back( result ); } gatherIndexes( enode ); } else { result = egraph.copyEnodeEtypeTermWithCache( enode ); } #endif assert( egraph.valDupMap1( enode ) == NULL ); egraph.storeDupMap1( enode, result ); } Enode * new_formula = egraph.valDupMap1( formula ); assert( new_formula ); egraph.doneDupMap1( ); equalities.push_back( new_formula ); Enode * res = egraph.mkAnd( egraph.cons( equalities ) ); return res; } Enode * AXDiffPreproc::addNeqAxioms( Enode * formula ) { list< Enode * > axioms; for ( size_t i = array_eqs_processed ; i < array_eqs.size( ) ; i ++ ) { Enode * l = array_eqs[ i ]->get1st( ); Enode * r = array_eqs[ i ]->get2nd( ); Enode * eq = array_eqs[ i ]; #if NEW_MOD_2 #else while( l->isStore( ) ) l = l->get1st( ); while( r->isStore( ) ) r = r->get1st( ); assert( l->isVar( ) ); assert( r->isVar( ) ); assert( l != r ); #endif // Add axioms // (not (= l r)) -> (= (diff l r) i) // (not (= l r)) -> (= (select l i) e) // (not (= l r)) -> (= (select r i) d) // (not (= l r)) -> (not (= d e)) Enode * diff = egraph.mkDiff( l, r ); map< Enode *, Enode * >::iterator it = diff_to_ind.find( diff ); // Diff already seen if ( it != diff_to_ind.end( ) ) continue; Enode * ind = freshVarFrom( diff ); // Store new diff(a,b) = i diff_to_ind[ diff ] = ind; // Adds to index variables to guess index_variables.insert( ind ); Enode * sel_l = egraph.mkSelect( l, ind ); Enode * sel_r = egraph.mkSelect( r, ind ); Enode * e = freshVarFrom( sel_l ); Enode * d = freshVarFrom( sel_r ); Enode * eq_diff = egraph.mkEq( egraph.cons( diff , egraph.cons( ind ) ) ); Enode * eq_sel_l = egraph.mkEq( egraph.cons( sel_l , egraph.cons( e ) ) ); Enode * eq_sel_r = egraph.mkEq( egraph.cons( sel_r , egraph.cons( d ) ) ); Enode * d_neq_e = egraph.mkNot( egraph.cons( egraph.mkEq( egraph.cons( e , egraph.cons( d ) ) ) ) ); // Conditional axiom a!=b -> diff(a,b) = i axioms.push_back( egraph.mkOr( egraph.cons( eq , egraph.cons( eq_diff ) ) ) ); // Conditional axiom a!=b -> rd axioms.push_back( egraph.mkOr( egraph.cons( eq , egraph.cons( eq_sel_l ) ) ) ); // Conditional axiom a!=b -> rd axioms.push_back( egraph.mkOr( egraph.cons( eq , egraph.cons( eq_sel_r ) ) ) ); // Pushed at top-level !! // axioms.push_back( eq_diff ); // axioms.push_back( eq_sel_l ); // axioms.push_back( eq_sel_r ); // Conditional axiom a!=b -> d!=e axioms.push_back( egraph.mkOr( egraph.cons( eq , egraph.cons( d_neq_e ) ) ) ); } axioms.push_back( formula ); Enode * res = egraph.mkAnd( egraph.cons( axioms ) ); return res; } Enode * AXDiffPreproc::addEqualities( Enode * formula ) { list< Enode * > equalities; equalities.push_back( formula ); // Adds equalities between indexes for ( set< Enode * >::iterator it = index_variables.begin( ) ; it != index_variables.end( ) ; it ++ ) { set< Enode * >::iterator jt = it; jt ++; for ( ; jt != index_variables.end( ) ; jt ++ ) { Enode * eq = egraph.mkEq( egraph.cons( (*it) , egraph.cons( (*jt) ) ) ); // Make sure we do not create mixed equalities #ifdef PRODUCE_PROOF if ( config.produce_inter != 0 && eq->getIPartitions( ) == 1 ) continue; #endif // Different indexes, useless to guess ... if ( top_neg_indexes.find( eq ) != top_neg_indexes.end( ) ) continue; // Skip already seen eq if ( !eqs_seen.insert( eq ).second ) continue; char buf[ 32 ]; sprintf( buf, "ACT_VAR_%d_%d", fresh_count ++, rand( ) % 100 ); egraph.newSymbol( buf, NULL, sstore.mkBool( ) ); Enode * av = egraph.mkVar( buf ); #ifdef PRODUCE_PROOF av->setIPartitions( partition ); #endif // // These two are equivalent to // equalities.push_back( egraph.mkIff( egraph.cons( av, egraph.cons( eq ) ) ) ); // equalities.push_back( egraph.mkOr( egraph.cons( egraph.mkNot( egraph.cons( av ) ) , egraph.cons( eq ) ) ) ); equalities.push_back( egraph.mkOr( egraph.cons( egraph.mkNot( egraph.cons( eq ) ) , egraph.cons( av ) ) ) ); } } // assert( array_vars.empty( ) ); gatherArrayVars( formula ); // Adds equalities of the kind rd(a,i)=e for ( set< Enode * >::iterator it = array_vars.begin( ) ; it != array_vars.end( ) ; it ++ ) { #ifdef PRODUCE_PROOF // Skip arrays that are local to one partition // ABcommon should be processed instead if ( ( (*it)->getIPartitions( ) & partition ) == 0 ) continue; #endif for ( set< Enode * >::iterator jt = index_variables.begin( ) ; jt != index_variables.end( ) ; jt ++ ) { Enode * sel = egraph.mkSelect( *it, *jt ); #ifdef PRODUCE_PROOF if ( config.produce_inter != 0 && sel->getIPartitions( ) == 1 ) continue; #endif if ( flat_select.find( sel ) != flat_select.end( ) ) continue; Enode * sel_var = freshVarFrom( sel ); Enode * eq = egraph.mkEq( egraph.cons( sel , egraph.cons( sel_var ) ) ); equalities.push_back( eq ); } } Enode * res = egraph.mkAnd( egraph.cons( equalities ) ); return res; } Enode * AXDiffPreproc::getFlat( Enode * e , list< Enode * > & eq ) { if ( e->getArity( ) == 0 ) return e; char def_name[ 32 ]; map< Enode *, Enode * >::iterator it = definitions.find( e ); Enode * flat_e = NULL; // If l was flattened if ( it != definitions.end( ) ) flat_e = it->second; else { stringstream ss; if ( e->getRetSort( ) == egraph.getSortArray( ) ) ss << "Array"; else ss << e->getRetSort( ); sprintf( def_name, "%s_%d_%d", ss.str( ).c_str( ), fresh_count ++, rand( ) % 100/*e->getId( )*/ ); egraph.newSymbol( def_name, NULL, e->getRetSort( ) ); flat_e = egraph.mkVar( def_name ); definitions[ e ] = flat_e; eq.push_back( egraph.mkEq( egraph.cons( flat_e, egraph.cons( e ) ) ) ); } return flat_e; } Enode * AXDiffPreproc::freshVarFrom( Enode * e ) { char buf[ 32 ]; stringstream ss; ss << e->getRetSort( ); sprintf( buf, "%s_%d_%d", ss.str( ).c_str( ), fresh_count ++, rand( ) % 100 ); egraph.newSymbol( buf, NULL, e->getRetSort( ) ); Enode * var = egraph.mkVar( buf ); return var; } void AXDiffPreproc::gatherIndexes( Enode * f ) { egraph.initDup2( ); vector< Enode * > unprocessed_enodes; unprocessed_enodes.push_back( f ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.isDup2( enode ) ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( !egraph.isDup2( arg ) ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); if ( enode->getRetSort( ) == egraph.getSortIndex( ) && enode->isVar( ) ) { index_variables.insert( enode ); } egraph.storeDup2( enode ); } egraph.doneDup2( ); } void AXDiffPreproc::gatherArrayVars( Enode * f ) { egraph.initDup2( ); vector< Enode * > unprocessed_enodes; unprocessed_enodes.push_back( f ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.isDup2( enode ) ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( !egraph.isDup2( arg ) ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); if ( enode->isEq( ) && enode->get1st( )->getRetSort( ) == egraph.getSortArray( ) ) { Enode * a = enode->get1st( ); Enode * b = enode->get2nd( ); while ( a->isStore( ) ) a = a->get1st( ); while ( b->isStore( ) ) b = b->get1st( ); array_vars.insert( a ); array_vars.insert( b ); } egraph.storeDup2( enode ); } egraph.doneDup2( ); } #if 0 // SimplifyStoreEq( a, b ) // // if ( a = b ) return true; // // if ( a->isStore( ) && b->isStore( ) ) // a = wr( a', i, e ) // b = wr( b', j, d ) // return (i = j -> e = d) and // (i != j -> (rd( a', j ) = d and rd( b', i ) and SimplifyStoreEq( a', b' )) #if 1 Enode * AXDiffPreproc::simplifyEq( set< Enode * > & neg_assumptions , Enode * eq , list< Enode * > & equalities ) { assert( eq ); if ( eq->isTrue( ) ) return eq; Enode * a = eq->get1st( ); Enode * b = eq->get2nd( ); if ( a == b ) return egraph.mkTrue( ); cerr << "CALLING ON : " << a << " = " << b << endl; cerr << " with ass : " << endl; for ( set< Enode * >::iterator it = neg_assumptions.begin( ) ; it != neg_assumptions.end( ) ; it ++ ) { cerr << " not " << *it << endl; } if ( a->isStore( ) && b->isStore( ) ) { Enode * ap = a->get1st( ); Enode * i = a->get2nd( ); Enode * e = a->get3rd( ); Enode * bp = b->get1st( ); Enode * j = b->get2nd( ); Enode * d = b->get3rd( ); Enode * assump = egraph.mkEq( egraph.cons( i, egraph.cons( j ) ) ); map< Enode *, Enode * > substs; substs[ i ] = j; e = canonizeTerm( substitute2( e, substs ) ); d = canonizeTerm( substitute2( e, substs ) ); if ( e != d ) { e = getFlat( e, equalities ); d = getFlat( d, equalities ); } Enode * elm_eq = egraph.mkEq( egraph.cons( e , egraph.cons( d ) ) ); list< Enode * > conj1_impl_list; conj1_impl_list.push_back( assump ); conj1_impl_list.push_back( elm_eq ); Enode * conj1 = NULL; bool split = false; if ( neg_assumptions.insert( assump ).second ) { split = true; Enode * simp_eq = canonize( substitute2( eq, substs ) ); cerr << "ass : " << assump << endl; cerr << "elm_eq : " << elm_eq << endl; cerr << "can eq : " << simp_eq << endl; if ( simp_eq->isEq( ) ) { Enode * ll = simp_eq->get1st( ); Enode * rr = simp_eq->get2nd( ); if ( ll->isStore( ) && rr->isStore( ) ) { simp_eq = egraph.mkEq( egraph.cons( ll->get1st( ), egraph.cons( rr->get1st( ) ) ) ); simp_eq = simplifyEq( neg_assumptions , simp_eq , equalities ); } } conj1_impl_list.push_back( simp_eq ); conj1 = egraph.mkImplies( egraph.cons( conj1_impl_list ) ); cerr << "Conj1 is : " << conj1 << endl; } // Assumption does not hold, so implication is true else { cerr << "Skipping conj1, assumption can't hold" << endl; conj1 = egraph.mkTrue( ); } list< Enode * > conj2_impl_list; Enode * rd1 = canonizeTerm( assump, neg_assumptions, egraph.mkSelect( ap, j ) ); Enode * rd2 = canonizeTerm( assump, neg_assumptions, egraph.mkSelect( bp, i ) ); // cerr << "elm_eq : " << elm_eq << endl; // cerr << "rd1 : " << rd1 << endl; // cerr << "rd2 : " << rd2 << endl; Enode * ss = simplifyEq( neg_assumptions , egraph.mkEq( egraph.cons( ap, egraph.cons( bp ) ) ) , equalities ); if ( rd1 != rd2 ) { rd1 = getFlat( rd1, equalities ); rd2 = getFlat( rd2, equalities ); } conj2_impl_list.push_back( egraph.mkEq( egraph.cons( rd1, egraph.cons( rd2 ) ) ) ); // cerr << "eq: " << conj2_impl_list.back( ) << endl; conj2_impl_list.push_back( ss ); Enode * conj2_impl = egraph.mkAnd( egraph.cons( conj2_impl_list ) ); if ( !split ) { // cerr << "Assumption " << assump << " cannot be taken" << endl; Enode * result = conj2_impl; cerr << "Conj2 alone is : " << result << endl; return result; } Enode * conj2 = egraph.mkImplies( egraph.cons( egraph.mkNot( egraph.cons( assump ) ) , egraph.cons( conj2_impl ) ) ); cerr << "Conj2 is : " << conj2 << endl; Enode * result = egraph.mkAnd( egraph.cons( conj1, egraph.cons( conj2 ) ) ); // cerr << "RESULT: " << result << endl; return result; } return eq; } #else Enode * AXDiffPreproc::simplifyEq( Enode * eq ) { assert( eq ); Enode * l = eq->get1st( ); Enode * r = eq->get2nd( ); assert( l ); assert( r ); vector< Enode * > indexes_l, indexes_r; vector< Enode * > elem_l, elem_r; while( l->isStore( ) ) { indexes_l.push_back( l->get2nd( ) ); elem_l.push_back( l->get3rd( ) ); l = l->get1st( ); } while( r->isStore( ) ) { indexes_r.push_back( r->get2nd( ) ); elem_r.push_back( r->get3rd( ) ); r = r->get1st( ); } // TODO: can be actually generalized ... if ( l != r ) return eq; // TODO: can be actually generalized ... if ( indexes_l.size( ) != indexes_r.size( ) ) return eq; list< Enode * > axioms; list< Enode * > idx_hyp; cerr << "Considering eq: " << eq << endl; // wr( wr( a, i1, d1 ), i2, d2 ) = wr( wr( a, j1, e1 ), j2, e2 ) // // <-> // // (i2 = j2) -> d2 = e2 // /\ (i2 != j2) -> rd( wr( wr( a, i1, d1 ), i2, d2 ), j2 ) = rd( wr( wr( a, j1, e1 ), j2, e2 ), i2 ) // [rd( wr( a, i1, d1 ), j2 ) ) = rd( wr( a, j1, e1 ), i2 )] // Let's see what happens by making hypothesis for ( size_t i = 0 ; i < indexes_l.size( ) ; i ++ ) { // produce ik = jk Enode * idx_eq = egraph.mkEq( egraph.cons( indexes_l[ i ] , egraph.cons( indexes_r[ i ] ) ) ); // Conjoin with prev hyps idx_hyp.push_back( idx_eq ); Enode * hyp = egraph.mkAnd( egraph.cons( idx_hyp ) ); map< Enode *, Enode * > substs; substs[ indexes_l[ i ] ] = indexes_r[ i ]; Enode * elm_eq = egraph.mkEq( egraph.cons( elem_l[ i ] , egraph.cons( elem_r[ i ] ) ) ); elm_eq = canonize( substitute2( elm_eq, substs ) ); axioms.push_back( egraph.mkImplies( egraph.cons( hyp , egraph.cons( elm_eq ) ) ) ); cerr << "ADDING AXIOM: " << axioms.back( ) << endl; // Store new hyp ik != jk idx_hyp.pop_back( ); idx_hyp.push_back( egraph.mkNot( egraph.cons( idx_eq ) ) ); } return egraph.mkAnd( egraph.cons( axioms ) ); } #endif #endif #ifdef PRODUCE_PROOF Enode * AXDiffPreproc::normalizeDiffs( Enode * formula ) { assert( formula ); vector< Enode * > unprocessed_enodes; // // Detect diffs // egraph.initDupMap2( ); egraph.initDup1( ); unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.isDup1( enode ) ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( !egraph.isDup1( arg ) ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; if ( enode->isEq( ) && enode->get1st( )->getRetSort( ) == egraph.getSortIndex( ) ) { Enode * l = enode->get1st( ); Enode * r = enode->get2nd( ); if ( l->isDiff( ) || r->isDiff( ) ) { if ( l->isDiff( ) ) { if ( l->get1st( )->getIPartitions( ) == 6 && l->get2nd( )->getIPartitions( ) == 6 && r->getIPartitions( ) != 6 ) { // Create a new ABcommon r Enode * r_prime = freshVarFrom( l ); def_to_orig[ r_prime ] = l; egraph.storeDupMap2( r, r_prime ); index_variables.insert( r_prime ); } } if ( r->isDiff( ) ) { if ( r->get1st( )->getIPartitions( ) == 6 && r->get2nd( )->getIPartitions( ) == 6 && l->getIPartitions( ) != 6 ) { // Create a new ABcommon l Enode * l_prime = freshVarFrom( r ); def_to_orig[ l_prime ] = r; egraph.storeDupMap2( l, l_prime ); index_variables.insert( l_prime ); } } } } egraph.storeDup1( enode ); } egraph.doneDup1( ); assert( formula ); // // Replace diffs // unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.valDupMap2( enode ) != NULL ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( egraph.valDupMap2( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; Enode * result = egraph.copyEnodeEtypeTermWithCache( enode, true ); egraph.storeDupMap2( enode, result ); } Enode * new_formula = egraph.valDupMap2( formula ); egraph.doneDupMap2( ); assert( new_formula ); return new_formula; } // Checks that all nodes are assigned to a partition bool AXDiffPreproc::checkPartitions( Enode * formula ) { list< Enode * > others; vector< Enode * > unprocessed_enodes; egraph.initDup1( ); unprocessed_enodes .push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); unprocessed_enodes.pop_back( ); // // Skip if the node has already been processed before // if ( egraph.isDup1( enode ) ) continue; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); if ( !egraph.isDup1( arg ) ) unprocessed_enodes.push_back( arg ); } if ( enode->getIPartitions( ) == 0 ) { egraph.doneDup1( ); return false; } egraph.storeDup1( enode ); } egraph.doneDup1( ); return true; } #endif opensmt-2.5.2/src/simplifiers/AXDiffPreproc.h000066400000000000000000000117711445011647600211460ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #ifndef AXDIFFPREPROC_H #define AXDIFFPREPROC_H #include "Global.h" #include "Otl.h" #include "Egraph.h" #include "SStore.h" class AXDiffPreproc { public: AXDiffPreproc( Egraph & egraph_ , SStore & sstore_ , SMTConfig & config_ ) : array_eqs_processed ( 0 ) , fresh_count ( egraph_.nofEnodes( ) + 1 ) , egraph ( egraph_ ) , sstore ( sstore_ ) , config ( config_ ) { } virtual ~AXDiffPreproc( ) { } Enode * doit ( Enode * #ifdef PRODUCE_PROOF , const ipartitions_t = 0 #endif ); // Main routine private: #ifndef PRODUCE_PROOF Enode * gauss ( Enode * ); Enode * simplifyEq ( set< Enode * > & , Enode * , list< Enode * > & ); Enode * retrieveTopLevelArrayEqs( Enode * , vector< Enode * > & ); void retrieveTopLevelIndexNeqs( Enode * ); Enode * solveReflexArrayEquations( Enode * ); Enode * instantiateNeq ( Enode *, Enode *, list< Enode * > & ); Enode * elimination ( Enode *, vector< Enode * > & ); Enode * substitute ( Enode *, map< Enode *, Enode * > & ); Enode * substitute2 ( Enode *, map< Enode *, Enode * > & ); Enode * canonize ( Enode * ); Enode * canonizeTerm ( Enode * ); Enode * canonizeTerm ( Enode *, set< Enode * > &, Enode * ); Enode * solve ( Enode *, list< Enode * > & ); Enode * simplifyStore ( Enode * ); Enode * simplifyStoreEq ( Enode * ); #else Enode * normalizeDiffs ( Enode * ); #endif Enode * flatten ( Enode * ); // Flatten Enode * deflatten ( Enode * ); // Inverse of flattening Enode * getFlat ( Enode * , list< Enode * > & ); Enode * freshVarFrom ( Enode * ); Enode * addNeqAxioms ( Enode * ); // Simulates preprocessing // of negated array eqs Enode * addEqualities ( Enode * ); // Adds index equalities void gatherIndexes ( Enode * ); // Gather index variables void gatherArrayVars ( Enode * ); // Gather meaningful ax vars #ifdef PRODUCE_PROOF void assignPartitionsFrom( Enode *, Enode * ); void assignPartitionsFrom( Enode *, Enode *, Enode * ); void assignPartitionsFrom( Enode *, Enode *, Enode *, Enode * ); bool checkPartitions ( Enode * ); void adjustColors ( Enode * ); #endif map< Enode *, Enode * > definitions; // From term to flat constant map< Enode *, Enode * > diff_to_ind; // Stores already identified diffs set< Enode * > index_variables; // Set of index variables vector< Enode * > array_eqs; // Set of array equalities set< Enode * > flat_select; // Selects for which no eq should be created set< Enode * > eqs_seen; // To avoid repetition set< Enode * > write_indexes; // Set of index variables occ. in writes set< Enode * > array_vars; // Set of index variables occ. in array eqs set< Enode * > top_neg_indexes; // Set of top-level differences of indexes #ifdef PRODUCE_PROOF map< Enode *, Enode * > def_to_orig; ipartitions_t partition; #endif size_t array_eqs_processed; unsigned fresh_count; // Counter to ensure fresh vars Egraph & egraph; // Reference to Egraph SStore & sstore; // Reference to SStore SMTConfig & config; // Reference to Config }; #endif opensmt-2.5.2/src/simplifiers/AXDiffPreproc2.cc000066400000000000000000001250171445011647600213650ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #include "AXDiffPreproc2.h" #define SPLIT_ON_DEMAND_P 0 #define ADD_LIMITED_EQS 0 #define ADD_BIG_AXIOMS 1 #define DONT_ADD_IDX_EQUALITIES 1 // // TO FIX: // - array equalities nel theory solver // - negated array equalities qua // Enode * AXDiffPreproc2::doit( Enode * formula, const uint64_t ) { assert( formula ); assert( config.logic == QF_AX ); // Retrive useful facts indeed retrieveTopLevelIndexNeqs( formula ); // Retrive indexes gatherIndexes ( formula ); // Canonize to begin with formula = canonize ( formula ); // Partial flattening formula = flatten ( formula ); assert( checkFlattened( formula ) ); #if 1 #else // Add neq axioms formula = addNeqAxioms ( formula ); #endif // Gaussian elimination formula = gauss ( formula ); assert( checkFlattened( formula ) ); // Add equalities for rotations formula = addEqualities ( formula ); // Performs some sort of static learning // Seems that it worse performance ... formula = addAxioms ( formula ); return formula; } Enode * AXDiffPreproc2::addAxioms( Enode * formula ) { assert( formula ); // Gather all top-level read equalities egraph.initDup1( ); vector< Enode * > unprocessed_enodes; vector< Enode * > equalities; unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.isDup1( enode ) ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; const bool arg_is_topl = enode->isAnd( ); Enode * arg_list; for ( arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( !egraph.isDup1( arg ) && arg_is_topl ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); if ( enode->isEq( ) ) { Enode * l = enode->get1st( ); Enode * r = enode->get2nd( ); if ( l->getRetSort( ) == egraph.getSortElem( ) && ( l->isSelect( ) || r->isSelect( ) ) ) equalities.push_back( enode ); } assert( !egraph.isDup1( enode ) ); egraph.storeDup1( enode ); } egraph.doneDup1( ); list< Enode * > axioms; // // Now that we have all equalities within equalities // we do the following. We take reads of the form // rd( a, i ) = d // rd( a, j ) = e // and we say // i = j -> d = e // for ( size_t i = 0 ; i < equalities.size( ) ; i ++ ) { Enode * eq1 = equalities[ i ]; Enode * sel1 = eq1->get1st( )->isSelect( ) ? eq1->get1st( ) : eq1->get2nd( ) ; Enode * var1 = eq1->get1st( )->isVar( ) ? eq1->get1st( ) : eq1->get2nd( ) ; Enode * idx1 = sel1->get2nd( ); for ( size_t j = i + 1 ; j < equalities.size( ) ; j ++ ) { Enode * eq2 = equalities[ j ]; Enode * sel2 = eq2->get1st( )->isSelect( ) ? eq2->get1st( ) : eq2->get2nd( ) ; if ( sel1->get1st( ) != sel2->get1st( ) ) continue; Enode * var2 = eq2->get1st( )->isVar( ) ? eq2->get1st( ) : eq2->get2nd( ) ; Enode * idx2 = sel2->get2nd( ); Enode * idx_eq = egraph.mkEq( egraph.cons( idx1 , egraph.cons( idx2 ) ) ); Enode * elm_eq = egraph.mkEq( egraph.cons( var1 , egraph.cons( var2 ) ) ); axioms.push_back( egraph.mkImplies( egraph.cons( idx_eq , egraph.cons( elm_eq ) ) ) ); } // // Also for rd( wr( X, i, e ), j ) = d // adds i = j -> d = e // if ( sel1->get1st( )->isStore( ) ) { Enode * var2 = sel1->get1st( )->get3rd( ); Enode * idx2 = sel1->get1st( )->get2nd( ); Enode * idx_eq = egraph.mkEq( egraph.cons( idx1 , egraph.cons( idx2 ) ) ); Enode * elm_eq = egraph.mkEq( egraph.cons( var1 , egraph.cons( var2 ) ) ); axioms.push_back( egraph.mkImplies( egraph.cons( idx_eq , egraph.cons( elm_eq ) ) ) ); } #if ADD_BIG_AXIOMS // if ( new_indexes.find( idx1 ) == new_indexes.end( ) ) // continue; // cerr << "FROM: " << equalities[ i ] << endl; list< Enode * > prev_eqs; Enode * a = sel1->get1st( ); Enode * e = var1; while ( a->isStore( ) ) { Enode * ik = a->get2nd( ); Enode * eiik = egraph.mkEq( egraph.cons( idx1 , egraph.cons( ik ) ) ); Enode * negeiik = egraph.mkNot( egraph.cons( eiik ) ); Enode * ek = a->get3rd( ); Enode * eeek = egraph.mkEq( egraph.cons( e , egraph.cons( ek ) ) ); prev_eqs.push_back( negeiik ); prev_eqs.push_back( eeek ); axioms.push_back( egraph.mkOr( egraph.cons( prev_eqs ) ) ); // cerr << "ADDING: " << axioms.back( ) << endl; // Remove last two prev_eqs.pop_back( ); prev_eqs.pop_back( ); // Add positive eiik prev_eqs.push_back( eiik ); a = a->get1st( ); } Enode * eeek = egraph.mkEq( egraph.cons( e , egraph.cons( egraph.mkSelect( a, idx1 ) ) ) ); prev_eqs.push_back( eeek ); axioms.push_back( egraph.mkOr( egraph.cons( prev_eqs ) ) ); #endif } axioms.push_back( formula ); return egraph.mkAnd( egraph.cons( axioms ) ); } Enode * AXDiffPreproc2::flatten( Enode * formula ) { assert( formula ); // // Flatten what has to be flattened // egraph.initDupMap1( ); vector< Enode * > unprocessed_enodes; vector< bool > unprocessed_istopl; list< Enode * > equalities; unprocessed_enodes.push_back( formula ); unprocessed_istopl.push_back( true ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { assert( unprocessed_enodes.size( ) == unprocessed_istopl.size( ) ); Enode * enode = unprocessed_enodes.back( ); const bool istopl = unprocessed_istopl.back( ); // // Skip if the node has already been processed before // if ( egraph.valDupMap1( enode ) != NULL ) { unprocessed_enodes.pop_back( ); unprocessed_istopl.pop_back( ); continue; } bool unprocessed_children = false; const bool arg_is_topl = istopl && enode->isAnd( ); Enode * arg_list; for ( arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( egraph.valDupMap1( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_istopl.push_back( arg_is_topl ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); unprocessed_istopl.pop_back( ); Enode * result = NULL; if ( enode->isEq( ) ) { Enode * l = egraph.valDupMap1( enode->get1st( ) ); Enode * r = egraph.valDupMap1( enode->get2nd( ) ); // If both variables it's already OK ! if ( !l->isVar( ) || !r->isVar( ) ) { // Top-level equality, just flatten one side if ( istopl ) { // But only if they are both non-constants if ( !l->isVar( ) && !r->isVar( ) ) { Enode * flat_l = getFlat( l, equalities ); result = egraph.mkEq( egraph.cons( flat_l , egraph.cons( r ) ) ); } } else { Enode * flat_l = getFlat( l, equalities ); Enode * flat_r = getFlat( r, equalities ); result = egraph.mkEq( egraph.cons( flat_l , egraph.cons( flat_r ) ) ); if ( l->getRetSort( ) == egraph.getSortArray( ) ) #if 1 result = addNeqAxiom( flat_l, flat_r, equalities ); #else non_top_array_eqs.insert( result ); #endif } } // Store as non-top-level else if ( !istopl && l->getRetSort( ) == egraph.getSortArray( ) ) { #if 1 result = addNeqAxiom( l, r, equalities ); #else result = egraph.mkEq( egraph.cons( l , egraph.cons( r ) ) ); non_top_array_eqs.insert( result ); #endif } } // For store flatten only element else if ( enode->isStore( ) ) { Enode * a = egraph.valDupMap1( enode->get1st( ) ); Enode * i = egraph.valDupMap1( enode->get2nd( ) ); Enode * e = egraph.valDupMap1( enode->get3rd( ) ); Enode * flat_e = getFlat( e, equalities ); result = egraph.mkStore( a, i, flat_e ); } if ( result == NULL ) result = egraph.copyEnodeEtypeTermWithCache( enode ); assert( egraph.valDupMap1( enode ) == NULL ); egraph.storeDupMap1( enode, result ); } Enode * new_formula = egraph.valDupMap1( formula ); assert( new_formula ); egraph.doneDupMap1( ); // Canonize introduced reads Enode * eqs = canonize( egraph.mkAnd( egraph.cons( equalities ) ) ); // Conjoin with formula Enode * res = egraph.mkAnd( egraph.cons( eqs , egraph.cons( new_formula ) ) ); return res; } bool AXDiffPreproc2::checkFlattened( Enode * formula ) { assert( formula ); // // Flatten what has to be flattened // egraph.initDup1( ); vector< Enode * > unprocessed_enodes; vector< bool > unprocessed_istopl; list< Enode * > equalities; unprocessed_enodes.push_back( formula ); unprocessed_istopl.push_back( true ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { assert( unprocessed_enodes.size( ) == unprocessed_istopl.size( ) ); Enode * enode = unprocessed_enodes.back( ); const bool istopl = unprocessed_istopl.back( ); // // Skip if the node has already been processed before // if ( egraph.isDup1( enode ) ) { unprocessed_enodes.pop_back( ); unprocessed_istopl.pop_back( ); continue; } bool unprocessed_children = false; const bool arg_is_topl = istopl && enode->isAnd( ); Enode * arg_list; for ( arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( !egraph.isDup1( arg ) ) { unprocessed_enodes.push_back( arg ); unprocessed_istopl.push_back( arg_is_topl ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); unprocessed_istopl.pop_back( ); if ( enode->isEq( ) ) { Enode * l = enode->get1st( ); Enode * r = enode->get2nd( ); // Top-level equality, just flatten one side if ( istopl ) { if ( !l->isVar( ) && !r->isVar( ) ) { egraph.doneDup1( ); return false; } } else { if ( !l->isVar( ) || !r->isVar( ) ) { egraph.doneDup1( ); return false; } } } // For store flatten only element else if ( enode->isStore( ) ) { if ( !enode->get3rd( )->isVar( ) ) return false; } assert( !egraph.isDup1( enode ) ); egraph.storeDup1( enode ); } egraph.doneDup1( ); return true; } Enode * AXDiffPreproc2::gauss( Enode * formula ) { vector< Enode * > arr_eq_list; vector< Enode * > elm_eq_list; Enode * rest = retrieveTopLevelEqs( formula, arr_eq_list, elm_eq_list ); if ( !arr_eq_list.empty( ) ) formula = elimination( rest, arr_eq_list, elm_eq_list ); return formula; } Enode * AXDiffPreproc2::retrieveTopLevelEqs( Enode * formula , vector< Enode * > & arr_eq_list , vector< Enode * > & elm_eq_list ) { list< Enode * > others; vector< Enode * > unprocessed_enodes; egraph.initDup1( ); unprocessed_enodes .push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); unprocessed_enodes.pop_back( ); // // Skip if the node has already been processed before // if ( egraph.isDup1( enode ) ) continue; if ( enode->isAnd( ) ) { Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); unprocessed_enodes.push_back( arg ); } continue; } // // Add a new substitution for iff if possible // if ( enode->isEq( ) // Equality && enode->get1st( )->getRetSort( ) == egraph.getSortArray( ) ) // of sort array { arr_eq_list.push_back( enode ); } else if ( enode->isEq( ) // Equality && enode->get1st( )->getRetSort( ) == egraph.getSortElem( ) ) // of sort array { elm_eq_list.push_back( enode ); } else { others.push_back( enode ); } } egraph.doneDup1( ); return egraph.mkAnd( egraph.cons( others ) ); } Enode * AXDiffPreproc2::solveReflexArrayEquations( Enode * formula ) { egraph.initDupMap1( ); vector< Enode * > unprocessed_enodes; unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.valDupMap1( enode ) != NULL ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( egraph.valDupMap1( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); Enode * result = NULL; if ( enode->isEq( ) && enode->get1st( )->getRetSort( ) == egraph.getSortArray( ) ) { Enode * l = enode->get1st( ); Enode * r = enode->get2nd( ); vector< Enode * > l_indexes; vector< Enode * > r_indexes; vector< Enode * > l_elements; vector< Enode * > r_elements; while ( l->isStore( ) ) { l_indexes.push_back( l->get2nd( ) ); l_elements.push_back( l->get3rd( ) ); l = l->get1st( ); } while ( r->isStore( ) ) { r_indexes.push_back( r->get2nd( ) ); r_elements.push_back( r->get3rd( ) ); r = r->get1st( ); } if ( l == r ) { Enode * simp = simplifyStoreEq( enode ); // cerr << "Processing: " << simp << endl; list< Enode * > read_eqs; Enode * res = solve( simp, read_eqs ); (void)res; assert( res == NULL ); result = egraph.mkAnd( egraph.cons( read_eqs ) ); // cerr << "Result : " << result << endl; } } if ( result == NULL ) result = egraph.copyEnodeEtypeTermWithCache( enode ); assert( egraph.valDupMap1( enode ) == NULL ); egraph.storeDupMap1( enode, result ); } Enode * result = egraph.valDupMap1( formula ); assert( result ); egraph.doneDupMap1( ); result = canonize( result ); return result; } void AXDiffPreproc2::retrieveTopLevelIndexNeqs( Enode * formula ) { vector< Enode * > unprocessed_enodes; egraph.initDup1( ); unprocessed_enodes .push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); unprocessed_enodes.pop_back( ); // // Skip if the node has already been processed before // if ( egraph.isDup1( enode ) ) continue; if ( enode->isAnd( ) ) { Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); unprocessed_enodes.push_back( arg ); } continue; } // // Add a new substitution for iff if possible // if ( enode->isNot( ) && enode->get1st( )->isEq( ) && enode->get1st( )->get1st( )->getRetSort( ) == egraph.getSortIndex( ) ) { top_neg_indexes.insert( enode->get1st( ) ); } egraph.storeDup1( enode ); } egraph.doneDup1( ); } Enode * AXDiffPreproc2::simplifyStoreEq( Enode * e ) { assert( e->isEq( ) ); Enode * lhs = e->get1st( ); Enode * rhs = e->get2nd( ); lhs = simplifyStore( lhs ); rhs = simplifyStore( rhs ); Enode * simp = egraph.mkEq( egraph.cons( lhs, egraph.cons( rhs ) ) ); return simp; } Enode * AXDiffPreproc2::simplifyStore( Enode * e ) { assert( e->isStore( ) || e->isVar( ) ); egraph.initDup1( ); vector< Enode * > useful_stores; Enode * a = e; while ( a->isStore( ) ) { Enode * i = a->get2nd( ); if ( !egraph.isDup1( i ) ) { useful_stores.push_back( a ); egraph.storeDup1( i ); } a = a->get1st( ); } Enode * result = a; while ( !useful_stores.empty( ) ) { Enode * useful_store = useful_stores.back( ); useful_stores.pop_back( ); result = egraph.mkStore( result , useful_store->get2nd( ) , useful_store->get3rd( ) ); } egraph.doneDup1( ); return result; } Enode * AXDiffPreproc2::canonize( Enode * formula ) { assert( formula ); vector< Enode * > unprocessed_enodes; egraph.initDupMap2( ); unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.valDupMap2( enode ) != NULL ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( egraph.valDupMap2( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; Enode * result = NULL; #if NEW_MOD_2 if ( enode->isSelect( ) ) { // Assume arguments are already canonical Enode * a = egraph.valDupMap2( enode->get1st( ) ); Enode * i = egraph.valDupMap2( enode->get2nd( ) ); result = egraph.mkSelect( a, i ); result = canonizeTerm( result ); } else if ( enode->isStore( ) ) { Enode * a = egraph.valDupMap2( enode->get1st( ) ); Enode * i = egraph.valDupMap2( enode->get2nd( ) ); Enode * e = egraph.valDupMap2( enode->get3rd( ) ); result = egraph.mkStore( a, i, e ); result = canonizeTerm( result ); } // TODO: probably useless else if ( enode->isEq( ) ) { Enode * l = egraph.valDupMap2( enode->get1st( ) ); Enode * r = egraph.valDupMap2( enode->get2nd( ) ); l = canonizeTerm( l ); r = canonizeTerm( r ); result = egraph.mkEq( egraph.cons( l, egraph.cons( r ) ) ); } #else if ( enode->isEq( ) ) { Enode * l = enode->get1st( ); Enode * r = enode->get2nd( ); l = canonizeTerm( l ); r = canonizeTerm( r ); result = egraph.mkEq( egraph.cons( l, egraph.cons( r ) ) ); } #endif if ( result == NULL ) result = egraph.copyEnodeEtypeTermWithCache( enode, true ); egraph.storeDupMap2( enode, result ); } Enode * new_formula = egraph.valDupMap2( formula ); egraph.doneDupMap2( ); assert( new_formula ); return new_formula; } Enode * AXDiffPreproc2::canonizeTerm( Enode * assump, set< Enode * > & neg_assump, Enode * t ) { Enode * result = NULL; // If element equation if ( t->isSelect( ) ) { Enode * a = t->get1st( ); Enode * i = t->get2nd( ); // Canonize store first Enode * innermost_a = simplifyStore( a ); Enode * element = NULL; bool stop = false; while( element == NULL && innermost_a->isStore( ) && !stop ) { Enode * j = innermost_a->get2nd( ); Enode * e_ij = egraph.mkEq( egraph.cons( i, egraph.cons( j ) ) ); // If they are the same, or the same modulo assumption if ( j == i || e_ij == assump ) element = innermost_a->get3rd( ); // If they are explicitly different else if ( neg_assump.find( e_ij ) != neg_assump.end( ) ) { innermost_a = innermost_a->get1st( ); } // Otherwise innermost_a is the term to use else stop = true; } // Element found ! if ( element ) { #if NEW_MOD_2 result = element; #else result = canonizeTerm( element ); #endif } else result = egraph.mkSelect( innermost_a, i ); } else if ( t->isStore( ) ) { assert( false ); } else result = t; assert( result ); return result; } Enode * AXDiffPreproc2::canonizeTerm( Enode * t ) { Enode * result = NULL; // If element equation if ( t->isSelect( ) ) { Enode * a = t->get1st( ); Enode * i = t->get2nd( ); // Canonize store first Enode * innermost_a = simplifyStore( a ); Enode * element = NULL; bool stop = false; while( element == NULL && innermost_a->isStore( ) && !stop ) { Enode * j = innermost_a->get2nd( ); // If they are the same if ( j == i ) element = innermost_a->get3rd( ); // If they are explicitly different else if ( top_neg_indexes.find( egraph.mkEq( egraph.cons( i, egraph.cons( j ) ) ) ) != top_neg_indexes.end( ) ) { innermost_a = innermost_a->get1st( ); } // Otherwise innermost_a is the term to use else stop = true; } // Element found ! if ( element ) { result = canonizeTerm( element ); } else result = egraph.mkSelect( innermost_a, i ); } else if ( t->isStore( ) ) { result = simplifyStore( t ); } else result = t; assert( result ); return result; } Enode * AXDiffPreproc2::solve( Enode * formula , list< Enode * > & read_eqs ) { #ifdef PRODUCE_PROOF assert( config.produce_inter == 0 ); #endif Enode * eq = formula; assert( eq->isEq( ) ); assert( eq->get1st( )->getRetSort( ) == egraph.getSortArray( ) ); Enode * lhs = eq->get1st( ); Enode * rhs = eq->get2nd( ); Enode * result = NULL; bool is_reflex = false; // Solve only this case Enode * a = lhs; vector< Enode * > a_indexes; vector< Enode * > a_elements; int count_a = 0; while( a->isStore( ) ) { a_indexes.push_back( a->get2nd( ) ); a_elements.push_back( a->get3rd( ) ); a = a->get1st( ); count_a ++; } assert( a->isVar( ) ); Enode * b = rhs; vector< Enode * > b_indexes; vector< Enode * > b_elements; int count_b = 0; while( b->isStore( ) ) { b_indexes.push_back( b->get2nd( ) ); b_elements.push_back( b->get3rd( ) ); b = b->get1st( ); count_b ++; } assert( b->isVar( ) ); is_reflex = a == b; if ( !is_reflex ) { if ( count_a < count_b ) { // Constructs a = store( b, ... ) for ( size_t j = 0 ; j < a_indexes.size( ) ; j ++ ) { // From wr( a, i, e ) to a lhs = lhs->get1st( ); Enode * sel = egraph.mkSelect( lhs, a_indexes[ j ] ); Enode * fresh = getFlat( sel, read_eqs ); read_eqs.push_back( egraph.mkEq( egraph.cons( egraph.mkSelect( rhs, a_indexes[ j ] ) , egraph.cons( a_elements[ j ] ) ) ) ); // From b to wr( b, i, rd( wr( a, j, e ), i ) rhs = egraph.mkStore( rhs , a_indexes[ j ] , fresh ); } assert( lhs == a ); result = egraph.mkEq( egraph.cons( lhs, egraph.cons( rhs ) ) ); } else { // Constructs b = store( a, ... ) for ( size_t j = 0 ; j < b_indexes.size( ) ; j ++ ) { // From wr( b, i, e ) to b rhs = rhs->get1st( ); Enode * sel = egraph.mkSelect( b, b_indexes[ j ] ); Enode * fresh = getFlat( sel, read_eqs ); read_eqs.push_back( egraph.mkEq( egraph.cons( egraph.mkSelect( lhs, b_indexes[ j ] ) , egraph.cons( b_elements[ j ] ) ) ) ); // From a to wr( a, i, rd( wr( b, j, e ), i ) lhs = egraph.mkStore( lhs , b_indexes[ j ] , fresh ); } assert( rhs == b ); result = egraph.mkEq( egraph.cons( lhs, egraph.cons( rhs ) ) ); } } // Solving Reflexive equations else { Enode * saved_lhs = lhs; Enode * saved_rhs = rhs; // Constructs a = store( b, ... ) for ( size_t j = 0 ; j < a_indexes.size( ) ; j ++ ) { // From wr( a, i, e ) to a lhs = lhs->get1st( ); Enode * sel = egraph.mkSelect( lhs, a_indexes[ j ] ); Enode * fresh = getFlat( sel, read_eqs ); Enode * eq = egraph.mkEq( egraph.cons( egraph.mkSelect( rhs, a_indexes[ j ] ) , egraph.cons( a_elements[ j ] ) ) ); read_eqs.push_back( canonize( eq ) ); // From b to wr( b, i, rd( wr( a, j, e ), i ) rhs = simplifyStore( egraph.mkStore( rhs , a_indexes[ j ] , fresh ) ); } assert( lhs == a ); lhs = saved_lhs; rhs = saved_rhs; // Constructs b = store( a, ... ) for ( size_t j = 0 ; j < b_indexes.size( ) ; j ++ ) { // From wr( b, i, e ) to b rhs = rhs->get1st( ); Enode * sel = egraph.mkSelect( rhs, b_indexes[ j ] ); Enode * fresh = getFlat( sel, read_eqs ); Enode * eq = egraph.mkEq( egraph.cons( egraph.mkSelect( lhs, b_indexes[ j ] ) , egraph.cons( b_elements[ j ] ) ) ); read_eqs.push_back( canonize( eq ) ); // cerr << "Adding: " << read_eqs.back( ) << endl; // From a to wr( a, i, rd( wr( b, j, e ), i ) lhs = simplifyStore( egraph.mkStore( lhs , b_indexes[ j ] , fresh ) ); } assert( rhs == b ); } return result; } Enode * AXDiffPreproc2::elimination( Enode * formula , vector< Enode * > & eq_list , vector< Enode * > & elm_eq_list ) { #ifdef PRODUCE_PROOF assert( config.produce_inter == 0 ); #endif list< Enode * > read_eqs; for ( size_t i = 0 ; i < elm_eq_list.size( ) ; i ++ ) read_eqs.push_back( elm_eq_list[ i ] ); map< Enode *, Enode * > substs; // // Forward elimination. From the first equality // solve and substitute in all others // for ( size_t i = 0 ; i < eq_list.size( ) ; i ++ ) { assert( eq_list[ i ] ); assert( eq_list[ i ]->isEq( ) ); // Canonize eq eq_list[ i ] = simplifyStoreEq( eq_list[ i ] ); // Solve w.r.t. some variable // May produce some equality // of type Elem Enode * a = eq_list[ i ]->get1st( ); Enode * b = eq_list[ i ]->get2nd( ); while( a->isStore( ) ) a = a->get1st( ); while( b->isStore( ) ) b = b->get1st( ); if ( a == b ) { // Moving in reflex // reflex.push_back( eq_list[ i ] ); Enode * res = solve( eq_list[ i ], read_eqs ); (void)res; assert( res == NULL ); // Removing from the list eq_list[ i ] = NULL; continue; } Enode * res = solve( eq_list[ i ], read_eqs ); assert( res ); eq_list[ i ] = simplifyStoreEq( res ); Enode * lhs = eq_list[ i ]->get1st( ); Enode * rhs = eq_list[ i ]->get2nd( ); assert( !lhs->isStore( ) || !rhs->isStore( ) ); assert( lhs->isVar( ) || rhs->isVar( ) ); if ( lhs->isVar( ) ) substs[ lhs ] = rhs; else substs[ rhs ] = lhs; // Substitute in all equalities down for ( size_t j = i + 1 ; j < eq_list.size( ) ; j ++ ) eq_list[ j ] = substitute( eq_list[ j ], substs ); } // // Backward elimination. From the last equality // solve substitute in the preceding // substs.clear( ); for ( int i = eq_list.size( ) - 1 ; i >= 0 ; i -- ) { // Skip reflex if ( eq_list[ i ] == NULL ) continue; // Canonize eq eq_list[ i ] = simplifyStoreEq( eq_list[ i ] ); assert( eq_list[ i ] ); assert( eq_list[ i ]->isEq( ) ); Enode * lhs = eq_list[ i ]->get1st( ); Enode * rhs = eq_list[ i ]->get2nd( ); assert( !lhs->isStore( ) || !rhs->isStore( ) ); assert( lhs->isVar( ) || rhs->isVar( ) ); if ( lhs->isVar( ) ) substs[ lhs ] = rhs; else substs[ rhs ] = lhs; // Substitute in all equalities up // but skip removed ones for ( int j = i - 1 ; j >= 0 ; j -- ) if ( eq_list[ j ] ) eq_list[ j ] = substitute( eq_list[ j ], substs ); } // // Substitute in reads using all the subts obtained so far // for ( list< Enode * >::iterator it = read_eqs.begin( ) ; it != read_eqs.end( ) ; ++ it ) { *it = canonize( substitute( *it, substs ) ); } // // Remove all the substitutions that involve array variables // not at the top-level // for ( set< Enode * >::iterator it = non_top_array_eqs.begin( ) ; it != non_top_array_eqs.end( ) ; it ++ ) { Enode * a = (*it)->get1st( ); Enode * b = (*it)->get2nd( ); map< Enode *, Enode * >::iterator jt = substs.find( a ); if ( jt != substs.end( ) ) { Enode * rhs = jt->second; read_eqs.push_back( egraph.mkEq( egraph.cons( a, egraph.cons( rhs ) ) ) ); substs.erase( jt ); } jt = substs.find( b ); if ( jt != substs.end( ) ) { Enode * rhs = jt->second; read_eqs.push_back( egraph.mkEq( egraph.cons( b, egraph.cons( rhs ) ) ) ); substs.erase( jt ); } } Enode * new_formula = substitute( formula, substs ); // And rest with reads read_eqs.push_back( new_formula ); new_formula = egraph.mkAnd( egraph.cons( read_eqs ) ); // Canonize and return return new_formula; } Enode * AXDiffPreproc2::substitute( Enode * formula, map< Enode *, Enode * > & substs ) { assert( formula ); vector< Enode * > unprocessed_enodes; egraph.initDupMap1( ); unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.valDupMap1( enode ) != NULL ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( egraph.valDupMap1( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; map< Enode *, Enode * >::iterator it = substs.find( enode ); Enode * result = NULL; if ( it != substs.end( ) ) { assert( enode->isVar( ) ); result = it->second; } else result = egraph.copyEnodeEtypeTermWithCache( enode ); assert( result ); egraph.storeDupMap1( enode, result ); } Enode * new_formula = egraph.valDupMap1( formula ); egraph.doneDupMap1( ); assert( new_formula ); return new_formula; } Enode * AXDiffPreproc2::addNeqAxioms( Enode * formula ) { list< Enode * > axioms; for ( set< Enode * >::iterator it = non_top_array_eqs.begin( ) ; it != non_top_array_eqs.end( ) ; it ++ ) { Enode * l = (*it)->get1st( ); Enode * r = (*it)->get2nd( ); Enode * eq = (*it); // Add axioms // (not (= l r)) -> (= (diff l r) i) // (not (= l r)) -> (= (select l i) e) // (not (= l r)) -> (= (select r i) d) // (not (= l r)) -> (not (= d e)) Enode * diff = egraph.mkDiff( l, r ); map< Enode *, Enode * >::iterator it = diff_to_ind.find( diff ); // Diff already seen if ( it != diff_to_ind.end( ) ) continue; Enode * ind = freshVarFrom( diff ); // Store new diff(a,b) = i diff_to_ind[ diff ] = ind; // Adds to index variables to guess #if SPLIT_ON_DEMAND_P new_indexes.insert( ind ); #else index_variables.insert( ind ); #endif Enode * sel_l = egraph.mkSelect( l, ind ); Enode * sel_r = egraph.mkSelect( r, ind ); Enode * e = freshVarFrom( sel_l ); Enode * d = freshVarFrom( sel_r ); /* Enode * eq_diff = egraph.mkEq( egraph.cons( diff , egraph.cons( ind ) ) ); */ Enode * eq_sel_l = egraph.mkEq( egraph.cons( sel_l , egraph.cons( e ) ) ); Enode * eq_sel_r = egraph.mkEq( egraph.cons( sel_r , egraph.cons( d ) ) ); Enode * d_neq_e = egraph.mkNot( egraph.cons( egraph.mkEq( egraph.cons( e , egraph.cons( d ) ) ) ) ); axioms.push_back( eq_sel_l ); axioms.push_back( eq_sel_r ); // a != b -> d != e axioms.push_back( egraph.mkOr( egraph.cons( eq , egraph.cons( d_neq_e ) ) ) ); } axioms.push_back( formula ); Enode * res = egraph.mkAnd( egraph.cons( axioms ) ); return res; } Enode * AXDiffPreproc2::addNeqAxiom( Enode * l , Enode * r , list< Enode * > & equalities ) { Enode * diff = egraph.mkDiff( l, r ); map< Enode *, Enode * >::iterator it = diff_to_ind.find( diff ); Enode * ind = NULL; // Diff already seen if ( it == diff_to_ind.end( ) ) ind = freshVarFrom( diff ); else ind = it->second; // Store new diff(a,b) = i diff_to_ind[ diff ] = ind; // Adds to index variables to guess #if SPLIT_ON_DEMAND_P #if ADD_LIMITED_EQS for ( set< Enode * >::iterator it = index_variables.begin( ) ; it != index_variables.end( ) ; it ++ ) { Enode * eq = egraph.mkEq( egraph.cons( (*it) , egraph.cons( ind ) ) ); cerr << "Adding eq: " << eq << endl; char buf[ 32 ]; sprintf( buf, "ACT_VAR_%d_%d", fresh_count ++, rand( ) % 100 ); egraph.newSymbol( buf, NULL, sstore.mkBool( ) ); Enode * av = egraph.mkVar( buf ); // // These two are equivalent to // equalities.push_back( egraph.mkIff( egraph.cons( av, egraph.cons( eq ) ) ) ); // equalities.push_back( egraph.mkOr( egraph.cons( egraph.mkNot( egraph.cons( av ) ) , egraph.cons( eq ) ) ) ); equalities.push_back( egraph.mkOr( egraph.cons( egraph.mkNot( egraph.cons( eq ) ) , egraph.cons( av ) ) ) ); } #else new_indexes.insert( ind ); #endif #else index_variables.insert( ind ); #endif Enode * sel_l = egraph.mkSelect( l, ind ); Enode * sel_r = egraph.mkSelect( r, ind ); Enode * e = freshVarFrom( sel_l ); Enode * d = freshVarFrom( sel_r ); Enode * eq_sel_l = egraph.mkEq( egraph.cons( sel_l , egraph.cons( e ) ) ); Enode * eq_sel_r = egraph.mkEq( egraph.cons( sel_r , egraph.cons( d ) ) ); Enode * d_eq_e = egraph.mkEq( egraph.cons( e , egraph.cons( d ) ) ); equalities.push_back( eq_sel_l ); equalities.push_back( eq_sel_r ); return d_eq_e; } Enode * AXDiffPreproc2::addEqualities( Enode * formula ) { list< Enode * > equalities; equalities.push_back( formula ); #if SPLIT_ON_DEMAND_P #else #if DONT_ADD_IDX_EQUALITIES #else // Adds equalities between indexes for ( set< Enode * >::iterator it = index_variables.begin( ) ; it != index_variables.end( ) ; it ++ ) { set< Enode * >::iterator jt = it; jt ++; for ( ; jt != index_variables.end( ) ; jt ++ ) { Enode * eq = egraph.mkEq( egraph.cons( (*it) , egraph.cons( (*jt) ) ) ); // Different indexes, useless to guess ... if ( top_neg_indexes.find( eq ) != top_neg_indexes.end( ) ) continue; // Skip already seen eq if ( !eqs_seen.insert( eq ).second ) continue; char buf[ 32 ]; sprintf( buf, "ACT_VAR_%d_%d", fresh_count ++, rand( ) % 100 ); egraph.newSymbol( buf, NULL, sstore.mkBool( ) ); Enode * av = egraph.mkVar( buf ); // // These two are equivalent to // equalities.push_back( egraph.mkIff( egraph.cons( av, egraph.cons( eq ) ) ) ); // equalities.push_back( egraph.mkOr( egraph.cons( egraph.mkNot( egraph.cons( av ) ) , egraph.cons( eq ) ) ) ); equalities.push_back( egraph.mkOr( egraph.cons( egraph.mkNot( egraph.cons( eq ) ) , egraph.cons( av ) ) ) ); } } #endif #endif /* // assert( array_vars.empty( ) ); gatherArrayVars( formula ); // Adds equalities of the kind rd(a,i)=e for ( set< Enode * >::iterator it = array_vars.begin( ) ; it != array_vars.end( ) ; it ++ ) { for ( set< Enode * >::iterator jt = index_variables.begin( ) ; jt != index_variables.end( ) ; jt ++ ) { Enode * sel = egraph.mkSelect( *it, *jt ); if ( flat_select.find( sel ) != flat_select.end( ) ) continue; Enode * sel_var = freshVarFrom( sel ); Enode * eq = egraph.mkEq( egraph.cons( sel , egraph.cons( sel_var ) ) ); equalities.push_back( eq ); } } */ Enode * res = egraph.mkAnd( egraph.cons( equalities ) ); return res; } Enode * AXDiffPreproc2::getFlat( Enode * e , list< Enode * > & eq ) { if ( e->getArity( ) == 0 ) return e; char def_name[ 32 ]; map< Enode *, Enode * >::iterator it = definitions.find( e ); Enode * flat_e = NULL; // If l was flattened if ( it != definitions.end( ) ) flat_e = it->second; else { stringstream ss; if ( e->getRetSort( ) == egraph.getSortArray( ) ) ss << "Array"; else ss << e->getRetSort( ); sprintf( def_name, "%s_%d_%d", ss.str( ).c_str( ), fresh_count ++, rand( ) % 100/*e->getId( )*/ ); egraph.newSymbol( def_name, NULL, e->getRetSort( ) ); flat_e = egraph.mkVar( def_name ); definitions[ e ] = flat_e; eq.push_back( egraph.mkEq( egraph.cons( flat_e, egraph.cons( e ) ) ) ); } return flat_e; } Enode * AXDiffPreproc2::freshVarFrom( Enode * e ) { char buf[ 32 ]; stringstream ss; ss << e->getRetSort( ); sprintf( buf, "%s_%d_%d", ss.str( ).c_str( ), fresh_count ++, rand( ) % 100 ); egraph.newSymbol( buf, NULL, e->getRetSort( ) ); Enode * var = egraph.mkVar( buf ); return var; } void AXDiffPreproc2::gatherIndexes( Enode * f ) { egraph.initDup2( ); vector< Enode * > unprocessed_enodes; unprocessed_enodes.push_back( f ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.isDup2( enode ) ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( !egraph.isDup2( arg ) ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); if ( enode->getRetSort( ) == egraph.getSortIndex( ) && enode->isVar( ) ) { index_variables.insert( enode ); } egraph.storeDup2( enode ); } egraph.doneDup2( ); } void AXDiffPreproc2::gatherArrayVars( Enode * f ) { egraph.initDup2( ); vector< Enode * > unprocessed_enodes; unprocessed_enodes.push_back( f ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.isDup2( enode ) ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( !egraph.isDup2( arg ) ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); if ( enode->isEq( ) && enode->get1st( )->getRetSort( ) == egraph.getSortArray( ) ) { Enode * a = enode->get1st( ); Enode * b = enode->get2nd( ); while ( a->isStore( ) ) a = a->get1st( ); while ( b->isStore( ) ) b = b->get1st( ); array_vars.insert( a ); array_vars.insert( b ); } egraph.storeDup2( enode ); } egraph.doneDup2( ); } opensmt-2.5.2/src/simplifiers/AXDiffPreproc2.h000066400000000000000000000112131445011647600212170ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #ifndef AXDIFFPREPROC2_H #define AXDIFFPREPROC2_H #include "Global.h" #include "Otl.h" #include "Egraph.h" #include "SStore.h" class AXDiffPreproc2 { public: AXDiffPreproc2( Egraph & egraph_ , SStore & sstore_ , SMTConfig & config_ ) : array_eqs_processed ( 0 ) , fresh_count ( egraph_.nofEnodes( ) + 1 ) , egraph ( egraph_ ) , sstore ( sstore_ ) , config ( config_ ) { } virtual ~AXDiffPreproc2( ) { } Enode * doit ( Enode *, const uint64_t = 0 ); // Main routine private: Enode * gauss ( Enode * ); Enode * simplifyEq ( set< Enode * > & , Enode * , list< Enode * > & ); Enode * retrieveTopLevelEqs( Enode * , vector< Enode * > & , vector< Enode * > & ); void retrieveTopLevelIndexNeqs( Enode * ); Enode * solveReflexArrayEquations( Enode * ); Enode * elimination ( Enode *, vector< Enode * > &, vector< Enode * > & ); Enode * substitute ( Enode *, map< Enode *, Enode * > & ); Enode * canonize ( Enode * ); Enode * canonizeTerm ( Enode * ); Enode * canonizeTerm ( Enode *, set< Enode * > &, Enode * ); Enode * solve ( Enode *, list< Enode * > & ); Enode * simplifyStore ( Enode * ); Enode * simplifyStoreEq ( Enode * ); Enode * flatten ( Enode * ); // Flatten bool checkFlattened ( Enode * ); Enode * addAxioms ( Enode * ); Enode * deflatten ( Enode * ); // Inverse of flattening Enode * getFlat ( Enode * , list< Enode * > & ); Enode * freshVarFrom ( Enode * ); Enode * addNeqAxioms ( Enode * ); // Simulates preprocessing Enode * addNeqAxiom ( Enode *, Enode *, list< Enode * > & ); Enode * addEqualities ( Enode * ); // Adds index equalities void gatherIndexes ( Enode * ); // Gather index variables void gatherArrayVars ( Enode * ); // Gather meaningful ax vars map< Enode *, Enode * > definitions; // From term to flat constant map< Enode *, Enode * > diff_to_ind; // Stores already identified diffs set< Enode * > index_variables; // Set of index variables set< Enode * > new_indexes; // Indexes added later on vector< Enode * > array_eqs; // Set of array equalities set< Enode * > flat_select; // Selects for which no eq should be created set< Enode * > non_top_array_eqs; set< Enode * > eqs_seen; // To avoid repetition set< Enode * > write_indexes; // Set of index variables occ. in writes set< Enode * > array_vars; // Set of index variables occ. in array eqs set< Enode * > top_neg_indexes; // Set of top-level differences of indexes size_t array_eqs_processed; unsigned fresh_count; // Counter to ensure fresh vars uint64_t partition; Egraph & egraph; // Reference to Egraph SStore & sstore; // Reference to SStore SMTConfig & config; // Reference to Config }; #endif opensmt-2.5.2/src/simplifiers/Ackermanize.cc000066400000000000000000000157261445011647600211050ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #include "Ackermanize.h" Enode * Ackermanize::doit( Enode * formula ) { assert( config.logic == QF_UFIDL || config.logic == QF_UFLRA ); map< Enode *, vector< Enode * > > uf_to_ack_vars; map< Enode *, vector< Enode * > > uf_to_ack_args; Enode * purified = retrieveAckVarsAndArguments( formula, uf_to_ack_vars, uf_to_ack_args ); Enode * result = generateAckermannExpansion ( purified, uf_to_ack_vars, uf_to_ack_args ); return result; } Enode * Ackermanize::retrieveAckVarsAndArguments( Enode * formula , map< Enode *, vector< Enode * > > & uf_to_ack_vars , map< Enode *, vector< Enode * > > & uf_to_ack_args ) { assert( formula ); vector< Enode * > unprocessed_enodes; egraph.initDupMap1( ); unprocessed_enodes.push_back( formula ); char def_name[ 256 ]; // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.valDupMap1( enode ) != NULL ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( egraph.valDupMap1( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); Enode * result = NULL; // // At this point, every child has been processed // if ( enode->isUf( ) || enode->isUp( ) ) { sprintf( def_name, "%s_app_%d", (enode->getCar( )->getName( )).c_str( ) , enode->getId( ) ); // Check buffer overflow in name assert( (enode->getCar( )->getName( )).length( ) <= 240 ); Snode * s = enode->getRetSort( ); egraph.newSymbol( def_name, NULL, s ); result = egraph.mkVar( def_name ); // Store variable in map for f uf_to_ack_vars[ enode->getCar( ) ].push_back( result ); // Retrieve arguments for ( Enode * arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * new_arg = egraph.valDupMap1( arg_list->getCar( ) ); uf_to_ack_args[ enode->getCar( ) ].push_back( new_arg ); } assert( uf_to_ack_args.find( enode->getCar( ) ) != uf_to_ack_args.end( ) ); } else { result = egraph.copyEnodeEtypeTermWithCache( enode ); } assert( result ); assert( egraph.valDupMap1( enode ) == NULL ); egraph.storeDupMap1( enode, result ); } Enode * new_formula = egraph.valDupMap1( formula ); assert( new_formula ); egraph.doneDupMap1( ); return new_formula; } Enode * Ackermanize::generateAckermannExpansion( Enode * formula , map< Enode *, vector< Enode * > > & uf_to_ack_vars , map< Enode *, vector< Enode * > > & uf_to_ack_args ) { list< Enode * > new_axioms_list; // // For each functional symbol // for ( map< Enode *, vector< Enode * > >::iterator it = uf_to_ack_vars.begin( ) ; it != uf_to_ack_vars.end( ) ; it ++ ) { assert( uf_to_ack_args.find( it->first ) != uf_to_ack_args.end( ) ); vector< Enode * > & args = uf_to_ack_args[ it->first ]; Enode * s = it->first; const int arity = s->getArity( ); vector< Enode * > & vars = it->second; // // For each ack variable // for ( unsigned i = 0 ; i < vars.size( ) - 1 ; i ++ ) { const int index_i = arity * i; for ( unsigned j = i + 1 ; j < vars.size( ) ; j ++ ) { const int index_j = arity * j; // // Construct (ai_1 = aj_1 /\ ai_2 = aj_2 /\ ... /\ ai_n = aj_n) --> var_i = var_j // equiv to (ai_1 != aj_1 \/ ai_2 != aj_2 \/ ... \/ ai_n != aj_n \/ var_i = var_j) // // equiv to (ai_1 < aj_1 \/ ai_1 > aj_1 \/ ... \/ var_i <= var_j) // equiv to (ai_1 < aj_1 \/ ai_1 > aj_1 \/ ... \/ var_i => var_j) // list< Enode * > axiom; for ( int k = 0 ; k < arity ; k ++ ) { Enode * ai_k = args[ index_i + k ]; Enode * aj_k = args[ index_j + k ]; // Generate ai_1 < aj_1 Enode * lt = egraph.mkLt( egraph.cons( ai_k, egraph.cons( aj_k ) ) ); Enode * gt = egraph.mkGt( egraph.cons( ai_k, egraph.cons( aj_k ) ) ); axiom.push_back( lt ); axiom.push_back( gt ); } // // Construct // var_i <= var_j and var_i >= var_j // or for the boolean case // var_i -> var_j and var_i <- var_j // Enode * le = NULL; Enode * ge = NULL; const bool is_bool = vars[ i ]->hasSortBool( ); if ( is_bool ) { le = egraph.mkOr( egraph.cons( egraph.mkNot( egraph.cons( vars[ i ] ) ) , egraph.cons( vars[ j ] ) ) ); ge = egraph.mkOr( egraph.cons( egraph.mkNot( egraph.cons( vars[ j ] ) ) , egraph.cons( vars[ i ] ) ) ); } else { le = egraph.mkLeq( egraph.cons( vars[ i ] , egraph.cons( vars[ j ] ) ) ); ge = egraph.mkGeq( egraph.cons( vars[ i ] , egraph.cons( vars[ j ] ) ) ); } axiom.push_back( le ); Enode * axiom_1 = egraph.mkOr( egraph.cons( axiom ) ); axiom.pop_back( ); axiom.push_back( ge ); Enode * axiom_2 = egraph.mkOr( egraph.cons( axiom ) ); new_axioms_list.push_back( axiom_1 ); new_axioms_list.push_back( axiom_2 ); } } } new_axioms_list.push_back( formula ); Enode * result = egraph.mkAnd( egraph.cons( new_axioms_list ) ); return result; } opensmt-2.5.2/src/simplifiers/Ackermanize.h000066400000000000000000000036741445011647600207460ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #ifndef ACKERMANIZE_H #define ACKERMANIZE_H #include "Global.h" #include "Otl.h" #include "Egraph.h" class Ackermanize { public: Ackermanize( Egraph & egraph_, SMTConfig & config_ ) : egraph ( egraph_ ) , config ( config_ ) { } virtual ~Ackermanize( ) { } Enode * doit ( Enode * ); // Main routine private: Enode * retrieveAckVarsAndArguments( Enode *, map< Enode *, vector< Enode * > > &, map< Enode *, vector< Enode * > > & ); Enode * generateAckermannExpansion ( Enode *, map< Enode *, vector< Enode * > > &, map< Enode *, vector< Enode * > > & ); Egraph & egraph; // Reference to Egraph SMTConfig & config; // Reference to Config }; #endif opensmt-2.5.2/src/simplifiers/ArraySimplify.cc000066400000000000000000000200371445011647600214360ustar00rootroot00000000000000/********************************************************************* Author: Simone Fulvio Rollini , Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #include "ArraySimplify.h" #include "Egraph.h" #include "Global.h" //#define ASVERB //#define ARR_VERB Enode * ArraySimplify::doit( Enode * formula ) { assert( formula ); vector< Enode * > unprocessed_enodes; egraph.initDup1( ); //setindexWorld; unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.isDup1( enode ) ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( !egraph.isDup1( arg ) ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; // If the term is a select or store, update its array argument info adding a new array user if ( enode->isTerm( ) && enode->isStore( ) ) { // Generate additional R(W(a,i,e),i)=e clause applying idx preprocIdx( enode ); // Enode * a = enode->get1st( ); // egraph.addStoreSuperterm(a,enode); //NB Not now but runtime! //egraph.addArrayRelevantIndex(enode,i); } if( enode->isTerm( ) && enode->isSelect( ) ) { // Enode * a = enode->get1st(); // Enode * i = enode->get2nd(); } // if(enode->isTerm() && enode->isDTypeArrayIndex()) // indexWorld.insert(enode); unprocessed_enodes.pop_back( ); assert( !egraph.isDup1( enode ) ); egraph.storeDup1( enode ); } egraph.doneDup1( ); // Generate additional clauses applying arrow up // preprocArrowUp( ); #ifdef ASVERB list::iterator it; for(it=new_clauses.begin();it!=new_clauses.end();it++) egraph.printStoreSupertermsList((*it)->get2nd()->get1st()); #endif new_clauses.push_back( formula ); Enode * total = egraph.mkAnd( egraph.cons( new_clauses ) ); //cout << "Index world size: " << indexWorld.size() << endl; return total; } // // Don't like to have to treat these cases without // using the already existent axiom procedures... // void ArraySimplify::preprocIdx( Enode * store ) { // create term R(W(a,i,e),i)=e Enode * i = store->get2nd( ); Enode * e = store->get3rd( ); // add clause R(W(a,i,e),i)=e Enode * newSelect = egraph.mkSelect( store, i ); Enode * cl = egraph.mkEq( egraph.cons( newSelect, egraph.cons( e ) ) ); new_clauses.push_back( cl ); #ifdef ARR_VERB cout << endl << "WAxiom:" << endl << store << endl << "->" << endl << cl << endl; #endif } /*void ArraySimplify::preprocArrowUp( ) { // scan all select and store users of each array term a: R(a,j) and W(a,i,e) // for each pair st i!=j create a new R(W(a,i,e),j) (i=j already dealt in Idx) list< Enode * > aSelUsers, aStoUsers; list< Enode * >::iterator aSelUsersIt, aStoUsersIt; Enode *select, *store, *i ,*j, *e, *newSelect; Enode *lit1, *lit2, *lit3, *lit4, *cl1, *cl2; for( map< enodeid_t, usersData >::iterator arrayUsersIt = arrayUsers.begin( ) ; arrayUsersIt != arrayUsers.end( ) ; arrayUsersIt++ ) { aSelUsers = arrayUsersIt->second.selectUsers; aStoUsers = arrayUsersIt->second.storeUsers; for ( aSelUsersIt = aSelUsers.begin( ) ; aSelUsersIt != aSelUsers.end( ) ; aSelUsersIt++) { for ( aStoUsersIt = aStoUsers.begin( ) ; aStoUsersIt != aStoUsers.end( ) ; aStoUsersIt++ ) { select =* aSelUsersIt; store =* aStoUsersIt; // create new term R(W(a,i,e),j) i = store->get2nd( ); e = store->get3rd( ); j = select->get2nd( ); // case i==j indirectly treated in idx if( i != j ) { newSelect = egraph.mkSelect( store, j ); // add clause IF i!=j THEN R(W(a,i,e),j)=R(a,j) // that is (i=j OR R(W(a,i,e),j)=R(a,j)) lit1 = egraph.mkEq( egraph.cons( i, egraph.cons( j ) ) ); lit2 = egraph.mkEq( egraph.cons( newSelect, egraph.cons( select ) ) ); cl1 = egraph.mkOr( egraph.cons( lit1, egraph.cons( lit2 ) ) ); // add clause IF i=j THEN R(W(a,i,e),j)=e // that is (NOT(i=j) OR R(W(a,i,e),j)=e) lit3 = egraph.mkNot( egraph.cons( egraph.mkEq( egraph.cons( i, egraph.cons( j ) ) ) ) ); lit4 = egraph.mkEq( egraph.cons( newSelect, egraph.cons( e ) ) ); cl2 = egraph.mkOr( egraph.cons( lit3, egraph.cons( lit4 ) ) ); new_clauses.push_back( cl1 ); new_clauses.push_back( cl2 ); #if VERBOSE cerr << "Adding: " << cl1 << endl; cerr << "Adding: " << cl2 << endl; #endif } } } } } // R(W(b,i,e),i)=e // RB: REMOVE ? Enode * ArraySimplify::simp1( Enode * enode, bool & appl ) { assert( false ); Enode * a = egraph.valDupMap1( enode->get1st( ) ); assert( a ); Enode * i = egraph.valDupMap1( enode->get2nd( ) ); assert( i ); if ( a->isTerm( ) && a->isStore( ) ) { Enode * indexStore = egraph.valDupMap1( a->get2nd() ); assert( indexStore ); Enode * elementStore = egraph.valDupMap1( a->get3rd() ); assert( elementStore ); // Substitution by application axiom R(W(b,i,e),i)=e if ( i == indexStore ) { Enode * result = elementStore; appl = true; return result; } } return enode; } // W(W(b,i,f),i,e)=W(b,i,e) // RB: REMOVE ? Enode * ArraySimplify::simp2( Enode * enode, bool & appl ) { assert( false ); Enode * a = egraph.valDupMap1( enode->get1st( ) ); assert( a ); Enode * i = egraph.valDupMap1( enode->get2nd( ) ); assert( i ); Enode * e = egraph.valDupMap1( enode->get3rd( ) ); assert( e ); if ( a->isTerm( ) && a->isStore( ) ) { Enode * b = egraph.valDupMap1( a->get1st() ); assert( b ); Enode * indexStore = egraph.valDupMap1( a->get2nd() ); assert( indexStore ); // Substitution by application axiom W(W(b,i,f),i,e)=W(b,i,e) if ( i == indexStore ) { Enode * result = egraph.mkStore(b,i,e); appl = true; return result; } } return enode; } // W(a,i,R(a,i))=a // RB: REMOVE ? Enode * ArraySimplify::simp3( Enode * enode, bool & appl ) { assert( false ); Enode * a = egraph.valDupMap1( enode->get1st( ) ); assert( a ); Enode * i = egraph.valDupMap1( enode->get2nd( ) ); assert( i ); Enode * e = egraph.valDupMap1( enode->get3rd( ) ); assert( e ); if ( e->isTerm( ) && e->isSelect( ) ) { Enode * indexSelect = egraph.valDupMap1( e->get2nd( ) ); assert( indexSelect ); Enode * arraySelect = egraph.valDupMap1( e->get1st() ); assert( arraySelect ); // Substitution by application axiom W(a,i,R(a,i))=a if ( i == indexSelect && a == arraySelect ) { Enode * result = a; appl = true; return result; } } return enode; }*/ opensmt-2.5.2/src/simplifiers/ArraySimplify.h000066400000000000000000000037541445011647600213070ustar00rootroot00000000000000/********************************************************************* Author: Simone Fulvio Rollini OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #ifndef ARRAYSIMPLIFY_H #define ARRAYSIMPLIFY_H #include "Global.h" #include "Otl.h" #include "Egraph.h" class ArraySimplify { public: ArraySimplify( Egraph & egraph_, SMTConfig & config_ ) : egraph ( egraph_ ) , config ( config_ ) { } virtual ~ArraySimplify( ) { } Enode * doit ( Enode * ); // Main routine private: list< Enode * > new_clauses; Egraph & egraph; // Reference to Egraph SMTConfig & config; // Reference to Config void preprocArrowUp ( ); void preprocIdx ( Enode * ); Enode * flattening ( Enode * ); Enode * simp1 ( Enode *, bool & ); Enode * simp2 ( Enode *, bool & ); Enode * simp3 ( Enode *, bool & ); }; #endif opensmt-2.5.2/src/simplifiers/BVBooleanize.cc000066400000000000000000000414111445011647600211610ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #include "BVBooleanize.h" Enode * BVBooleanize::doit( Enode * formula ) { /* assert( formula ); // // Step 0: propagate extractions // formula = propagateExtract( formula ); // // Step 1: replace (= x 0), (= x 1) with type-casts // formula = replaceWithTypeCasts( formula ); // // Step 2: apply the following rewrite rules: // // (ite s 1 0) --> s // (ite s 0 1) --> (not s) // (x + y) = y --> x = 0 // formula = rewriteRules( formula ); // // Step 3: propagate boolcasts // formula = propagateBoolcast( formula ); // // Step 4: remove type-casts // formula = removeCasts( formula ); */ return formula; } Enode * BVBooleanize::propagateExtract( Enode * formula ) { /* vector< Enode * > unprocessed_enodes; egraph.initDupMap1( ); unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.valDupMap1( enode ) != NULL ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( egraph.valDupMap1( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); Enode * result = NULL; int lsb, msb; if ( enode->isExtract( &msb, &lsb ) && msb == lsb ) { result = propagateExtractRec( egraph.mkExtract( msb, lsb, egraph.valDupMap1( enode->get1st( ) ) ) ); } else { result = egraph.copyEnodeEtypeTermWithCache( enode ); } assert( result ); assert( egraph.valDupMap1( enode ) == NULL ); egraph.storeDupMap1( enode, result ); } Enode * new_formula = egraph.valDupMap1( formula ); assert( new_formula ); egraph.doneDupMap1( ); return new_formula; */ return formula; } Enode * BVBooleanize::propagateExtractRec( Enode * e ) { /* if ( extraction_cache.find( e->getId( ) ) != extraction_cache.end( ) ) return extraction_cache[ e->getId( ) ]; int i, j; if ( !e->isExtract( &i, &j ) ) return e; const int init_width = e->getWidth( ); // To fool compiler (void)init_width; Enode * arg = e->get1st( ); Enode * res = e; int arg_msb, arg_lsb; // // Apply rewrite rules. We assume x to have width n, y to have width m // // Rule 1: // x[n-1:0] --> x // if ( arg->getWidth( ) == i - j + 1 ) res = arg; // // Rewrite rule for extraction // // x[msb:lsb][i:j] --> x[i+lsb:j+lsb] // else if ( arg->isExtract( &arg_msb, &arg_lsb ) ) { Enode * arg_arg = arg->getCdr( )->getCar( ); assert( !arg_arg->isExtract( ) ); res = egraph.mkExtract( i + arg_lsb, j + arg_lsb, arg_arg ); res = propagateExtractRec( res ); } // // Rewrite rules for concatenation // else if ( arg->isConcat( ) ) { list< Enode * > new_args; int width_left = arg->getWidth( ); for ( Enode * list = arg->getCdr( ) ; !list->isEnil( ) ; list = list->getCdr( ) ) { Enode * conc = list->getCar( ); const int conc_width = conc->getWidth( ); const int rem_width = width_left - conc_width; width_left = rem_width; // Compute current extraction indexes int real_msb = i - rem_width; int real_lsb = j - rem_width; // Continue if this slice is out of msb:lsb if ( real_msb < 0 || real_lsb >= conc_width ) continue; // Fix indexes if out of bounds if ( real_msb >= conc_width ) real_msb = conc_width - 1; if ( real_lsb < 0 ) real_lsb = 0; // Add slice to list new_args.push_front( propagateExtractRec( egraph.mkExtract( real_msb, real_lsb, conc ) ) ); } res = egraph.mkConcat( egraph.cons( new_args ) ); } // // Propagate thorugh bitwise operators // else if ( arg->isBvand( ) || arg->isBvor ( ) || arg->isBvnot( ) ) { list< Enode * > new_args; for ( Enode * list = arg->getCdr( ) ; !list->isEnil( ) ; list = list->getCdr( ) ) { Enode * argarg = list->getCar( ); new_args.push_front( propagateExtractRec( egraph.mkExtract( i, j, argarg ) ) ); } if ( arg->isBvand( ) ) res = egraph.mkBvand( egraph.cons( new_args ) ); else if ( arg->isBvor( ) ) res = egraph.mkBvor( egraph.cons( new_args ) ); else if ( arg->isBvnot( ) ) res = egraph.mkBvnot( egraph.cons( new_args ) ); } // // Propagate through ite branches // else if ( arg->isIte( ) ) { Enode * th = arg->get2nd( ); Enode * el = arg->get3rd( ); res = egraph.mkIte( arg->get1st( ) , propagateExtractRec( egraph.mkExtract( i, j, th ) ) , propagateExtractRec( egraph.mkExtract( i, j, el ) ) ); } // // Otherwise normal extraction // else { res = egraph.mkExtract( i, j, arg ); } // Initial and final width should match assert( res->getWidth( ) == init_width ); // Check has not been stored already assert( extraction_cache.find( e->getId( ) ) == extraction_cache.end( ) ); // Store extraction_cache[ e->getId( ) ] = res; return res; */ return e; } Enode * BVBooleanize::propagateBoolcast( Enode * formula ) { /* vector< Enode * > unprocessed_enodes; egraph.initDupMap1( ); unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.valDupMap1( enode ) != NULL ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( egraph.valDupMap1( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); Enode * result = NULL; Enode * arg = enode->getArity( ) > 0 ? egraph.valDupMap1( enode->get1st( ) ) : NULL; if ( enode->isBoolcast( ) ) { result = propagateBoolcastRec( egraph.mkBoolcast( arg ) ); } else { result = egraph.copyEnodeEtypeTermWithCache( enode ); } assert( result ); assert( egraph.valDupMap1( enode ) == NULL ); egraph.storeDupMap1( enode, result ); } Enode * new_formula = egraph.valDupMap1( formula ); assert( new_formula ); egraph.doneDupMap1( ); return new_formula; */ return formula; } Enode * BVBooleanize::propagateBoolcastRec( Enode * e ) { /* if ( boolcast_cache.find( e->getId( ) ) != boolcast_cache.end( ) ) return boolcast_cache[ e->getId( ) ]; if ( !e->isBoolcast( ) ) { assert( e->isSortBool( ) ); return e; } Enode * arg = e->get1st( ); Enode * res = e; // // (bool (bvnot x)) --> (not (bool x)) // if ( arg->isBvnot( ) ) res = egraph.mkNot( egraph.cons( propagateBoolcastRec( egraph.mkBoolcast( arg->get1st( ) ) ) ) ); // // (bool (bvand x y)) --> (and (bool x) (bool y)) // else if ( arg->isBvand( ) || arg->isBvor( ) ) { list< Enode * > new_args; for ( Enode * list = arg->getCdr( ) ; !list->isEnil( ) ; list = list->getCdr( ) ) { Enode * argarg = list->getCar( ); new_args.push_front( propagateBoolcastRec( egraph.mkBoolcast( argarg ) ) ); } if ( arg->isBvand( ) ) res = egraph.mkAnd( egraph.cons( new_args ) ); else res = egraph.mkOr ( egraph.cons( new_args ) ); } // // (bool (word1 x)) --> x // else if ( arg->isWord1cast( ) ) { res = arg->get1st( ); } // // (bool (ite i t e)) --> (if_then_else i (bool t) (bool e)) // else if ( arg->isIte( ) ) { Enode * th = arg->get2nd( ); Enode * el = arg->get3rd( ); res = egraph.mkIfthenelse( arg->get1st( ) , propagateBoolcastRec( egraph.mkBoolcast( th ) ) , propagateBoolcastRec( egraph.mkBoolcast( el ) ) ); } // // (bool (= x y)) --> (= x y) // else if ( arg->hasSortBool( ) ) { res = arg; } // // Otherwise normal boolcast // else { res = egraph.mkBoolcast( arg ); } assert( res->hasSortBool( ) ); assert( boolcast_cache.find( e->getId( ) ) == boolcast_cache.end( ) ); boolcast_cache[ e->getId( ) ] = res; return res; */ return e; } Enode * BVBooleanize::replaceWithTypeCasts( Enode * formula ) { /* // // One, zero shortcuts // Enode * bv0 = egraph.mkBvnum( const_cast< char * >( "0" ) ); Enode * bv1 = egraph.mkBvnum( const_cast< char * >( "1" ) ); vector< Enode * > unprocessed_enodes; egraph.initDupMap1( ); unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.valDupMap1( enode ) != NULL ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( egraph.valDupMap1( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); Enode * result = NULL; Enode * arg1 = enode->getArity( ) > 0 ? egraph.valDupMap1( enode->get1st( ) ) : NULL; Enode * arg2 = enode->getArity( ) > 1 ? egraph.valDupMap1( enode->get2nd( ) ) : NULL; // (= x 1) --> boolcast( x ) if ( enode->isEq( ) && ( arg1 == bv1 || arg2 == bv1 ) ) { result = egraph.mkBoolcast( arg1 == bv1 ? arg2 : arg1 ); } else if ( enode->isEq( ) && ( arg1 == bv0 || arg2 == bv0 ) ) { Enode * cast = egraph.mkBoolcast( arg1 == bv0 ? arg2 : arg1 ); result = egraph.mkNot( egraph.cons( cast ) ); } else if ( enode->isEq( ) && arg1->getWidth( ) == 1 ) { result = egraph.mkIff( egraph.cons( egraph.mkBoolcast( arg1 ) , egraph.cons( egraph.mkBoolcast( arg2 ) ) ) ); } else { result = egraph.copyEnodeEtypeTermWithCache( enode ); } assert( result ); assert( egraph.valDupMap1( enode ) == NULL ); egraph.storeDupMap1( enode, result ); } Enode * new_formula = egraph.valDupMap1( formula ); assert( new_formula ); egraph.doneDupMap1( ); return new_formula; */ return formula; } Enode * BVBooleanize::rewriteRules( Enode * formula ) { /* // // One, zero shortcuts // Enode * bv0 = egraph.mkBvnum( const_cast< char * >( "0" ) ); Enode * bv1 = egraph.mkBvnum( const_cast< char * >( "1" ) ); vector< Enode * > unprocessed_enodes; egraph.initDupMap1( ); unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.valDupMap1( enode ) != NULL ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( egraph.valDupMap1( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); Enode * result = NULL; Enode * arg1 = enode->getArity( ) > 0 ? egraph.valDupMap1( enode->get1st( ) ) : NULL; Enode * arg2 = enode->getArity( ) > 1 ? egraph.valDupMap1( enode->get2nd( ) ) : NULL; Enode * arg3 = enode->getArity( ) > 2 ? egraph.valDupMap1( enode->get3rd( ) ) : NULL; // ite( s, 0, 1 ) --> s if ( enode->isIte( ) && arg2 == bv1 && arg3 == bv0 ) { result = egraph.mkWord1cast( arg1 ); } // ite( s, 1, 0 ) --> (not s) else if ( enode->isIte( ) && arg2 == bv0 && arg3 == bv1 ) { result = egraph.mkBvnot( egraph.cons( egraph.mkWord1cast( arg1 ) ) ); } if ( result == NULL ) result = egraph.copyEnodeEtypeTermWithCache( enode ); assert( result ); assert( egraph.valDupMap1( enode ) == NULL ); egraph.storeDupMap1( enode, result ); } Enode * new_formula = egraph.valDupMap1( formula ); assert( new_formula ); egraph.doneDupMap1( ); return new_formula; */ return formula; } Enode * BVBooleanize::removeCasts( Enode * formula ) { /* // // One, zero shortcuts // Enode * bv0 = egraph.mkBvnum( const_cast< char * >( "0" ) ); Enode * bv1 = egraph.mkBvnum( const_cast< char * >( "1" ) ); vector< Enode * > unprocessed_enodes; egraph.initDupMap1( ); unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.valDupMap1( enode ) != NULL ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( egraph.valDupMap1( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); Enode * result = NULL; Enode * arg1 = enode->getArity( ) > 0 ? egraph.valDupMap1( enode->get1st( ) ) : NULL; // boolCast( x ) --> (= x 1) if ( enode->isBoolcast( ) ) { result = egraph.mkEq( egraph.cons( arg1, egraph.cons( bv1 ) ) ); } // wordCast( s ) --> (ite s 1 0) else if ( enode->isWord1cast( ) ) { result = egraph.mkIte( arg1, bv1, bv0 ); } else { result = egraph.copyEnodeEtypeTermWithCache( enode ); } assert( result ); assert( egraph.valDupMap1( enode ) == NULL ); egraph.storeDupMap1( enode, result ); } Enode * new_formula = egraph.valDupMap1( formula ); assert( new_formula ); egraph.doneDupMap1( ); return new_formula; */ return formula; } opensmt-2.5.2/src/simplifiers/BVBooleanize.h000066400000000000000000000050001445011647600210150ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #ifndef BV_BOOLEANIZE_HH #define BV_BOOLEANIZE_HH #include "Global.h" #include "Otl.h" #include "Egraph.h" class BVBooleanize { public: BVBooleanize ( Egraph & egraph_, SMTConfig & config_ ) : egraph ( egraph_ ) , config ( config_ ) { } virtual ~BVBooleanize( ) { } Enode * doit ( Enode * ); // Main routine private: Enode * propagateExtract ( Enode * ); // Propagate extractions Enode * propagateExtractRec ( Enode * ); // Propagate extractions recursively Enode * propagateBoolcast ( Enode * ); // Propagate Boolcasts Enode * propagateBoolcastRec ( Enode * ); // Propagate Boolcasts recursively Enode * replaceWithTypeCasts ( Enode * ); // Add boolcasts Enode * rewriteRules ( Enode * ); // Apply some rewrite rules Enode * removeCasts ( Enode * ); // Remove remaining casts Egraph & egraph; // Reference to Egraph SMTConfig & config; // Reference to Config map< enodeid_t, Enode * > extraction_cache; // Cache for extraction propagation map< enodeid_t, Enode * > boolcast_cache; // Cache for boolcast propagation }; #endif opensmt-2.5.2/src/simplifiers/BVNormalize.cc000066400000000000000000000263441445011647600210420ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #include "BVNormalize.h" Enode * BVNormalize::doit( Enode * formula ) { /* assert( formula ); vector< Enode * > unprocessed_enodes; egraph.initDupMap1( ); unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.valDupMap1( enode ) != NULL ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; if ( enode->isBooleanOperator( ) ) { Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // boolean operator // if ( egraph.valDupMap1( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); Enode * result = NULL; if ( enode->isTAtom( ) ) result = normalize( enode ); // // If nothing has been done copy and simplify // if ( result == NULL ) { result = egraph.copyEnodeEtypeTermWithCache( enode ); } assert( egraph.valDupMap1( enode ) == NULL ); egraph.storeDupMap1( enode, result ); } Enode * new_formula = egraph.valDupMap1( formula ); assert( new_formula ); egraph.doneDupMap1( ); return new_formula; */ return formula; } Enode * BVNormalize::normalize( Enode * term ) { /* assert( term ); // // Simplification for predicates // assert( term->isDistinct( ) || term->isEq ( ) || term->isBvule ( ) || term->isBvsle ( ) ); assert( term->getArity( ) == 2 ); if ( term->isBvule ( ) || term->isBvsle ( ) || term->isDistinct( ) ) return term; Enode * lhs = term->get1st( ); Enode * rhs = term->get2nd( ); // // Handle some particular case // if ( term->isEq( ) ) { int lhs_se, rhs_se; if ( lhs->isBvmul( ) && rhs->isBvmul( ) && lhs->get1st( ) == rhs->get1st( ) ) { lhs = lhs->get2nd( ); rhs = rhs->get2nd( ); } else if ( lhs->isSignExtend( &lhs_se ) && rhs->isSignExtend( &rhs_se ) && lhs_se == rhs_se ) { lhs = lhs->get1st( ); rhs = rhs->get1st( ); } } // // Map between node and coefficient // map< enodeid_t, mpz_class * > term_to_coeff; map< enodeid_t, Enode * > id_to_enode; vector< mpz_class * > garbage; // // For now process just equalities and signed le, which // can be safely rewritten as usual (I think ...) // mpz_class const_value( 0 ); scanPolynome( lhs, term_to_coeff, const_value, id_to_enode, garbage, false ); scanPolynome( rhs, term_to_coeff, const_value, id_to_enode, garbage, true ); mpz_class one ( 1 ); mpz_class minus( -1 ); mpz_class zero ( 0 ); // // Build new lhs and rhs // Enode * new_lhs = const_cast< Enode * >( egraph.enil ); Enode * new_rhs = const_cast< Enode * >( egraph.enil ); for ( map< enodeid_t, mpz_class * >::iterator it = term_to_coeff.begin( ) ; it != term_to_coeff.end( ) ; it ++ ) { Enode * e = id_to_enode[ it->first ]; if ( *(it->second) == one ) { new_lhs = new_lhs->isEnil( ) ? e : egraph.mkBvadd( egraph.cons( e, egraph.cons( new_lhs ) ) ); } else if ( *(it->second) == minus ) { new_rhs = new_rhs->isEnil( ) ? e : egraph.mkBvadd( egraph.cons( e, egraph.cons( new_rhs ) ) ); } else if ( *(it->second) > zero ) { Enode * num = makeNumberFromGmp( *(it->second ), e->getWidth( ) ); Enode * mon = egraph.mkBvmul( egraph.cons( num, egraph.cons( e ) ) ); new_lhs = new_lhs->isEnil( ) ? mon : egraph.mkBvadd( egraph.cons( mon, egraph.cons( new_lhs ) ) ); } else if ( *(it->second) < zero ) { mpz_class abs = *(it->second) * -1; Enode * num = makeNumberFromGmp( abs, e->getWidth( ) ); Enode * mon = egraph.mkBvmul( egraph.cons( num, egraph.cons( e ) ) ); new_rhs = new_rhs->isEnil( ) ? mon : egraph.mkBvadd( egraph.cons( mon, egraph.cons( new_rhs ) ) ); } } if ( new_lhs->isEnil( ) && new_rhs->isEnil( ) ) { if ( term->isEq( ) ) { if ( const_value == 0 ) return egraph.mkTrue ( ); else return egraph.mkFalse( ); } else { error( "Unsupported operator: ", term->getCar( ) ); } } assert( !new_lhs->isEnil( ) || !new_rhs->isEnil( ) ); const int width = new_lhs->isEnil ( ) ? new_rhs->getWidth ( ) : new_lhs->getWidth ( ); // // Add constant // if ( const_value > zero ) { Enode * mon = makeNumberFromGmp( const_value, width ); new_lhs = new_lhs->isEnil( ) ? mon : egraph.mkBvadd( egraph.cons( mon, egraph.cons( new_lhs ) ) ); } if ( const_value < zero ) { mpz_class abs = const_value * -1; Enode * mon = makeNumberFromGmp( abs, width ); new_rhs = new_rhs->isEnil( ) ? mon : egraph.mkBvadd( egraph.cons( mon, egraph.cons( new_rhs ) ) ); } // // Put zero if a side is empty // if ( new_lhs->isEnil( ) ) new_lhs = makeNumberFromGmp( zero, lhs->getWidth( ) ); if ( new_rhs->isEnil( ) ) new_rhs = makeNumberFromGmp( zero, rhs->getWidth( ) ); Enode * res = NULL; // // Return the right predicate // if ( term->isEq ( ) ) res = egraph.mkEq ( egraph.cons( new_lhs, egraph.cons( new_rhs ) ) ); // else if ( term->isBvsle( ) ) res = egraph.mkBvsle( egraph.cons( new_lhs, egraph.cons( new_rhs ) ) ); assert( res ); // // Clean created numbers // while( !garbage.empty( ) ) { mpz_class * e = garbage.back( ); garbage.pop_back( ); delete e; } return res; */ return term; } Enode * BVNormalize::makeNumberFromGmp( mpz_class & //n , const int //width ) { /* assert( n >= 0 ); string s = n.get_str( 2 ); string new_bin_value; // // Handle overflow // if ( (int)s.size( ) > width ) { s = s.substr( s.size( ) - width, width ); assert( (int)s.size( ) == width ); } assert( width >= (int)s.size( ) ); if( width - (int)s.size( ) > 0 ) new_bin_value.insert( 0, width - s.size( ), '0' ); new_bin_value += s; return egraph.mkBvnum( const_cast< char * >(new_bin_value.c_str( )) ); */ return NULL; } void BVNormalize::scanPolynome( Enode * //p , map< enodeid_t, mpz_class * > & //term_to_coeff , mpz_class & //const_value , map< enodeid_t, Enode * > & //id_to_enode , vector< mpz_class * > & //garbage , bool //negate ) { /* vector< Enode * > unprocessed_enodes; vector< mpz_class * > unprocessed_coeffs; unprocessed_enodes.push_back( p ); unprocessed_coeffs.push_back( negate ? new mpz_class( -1 ) : new mpz_class( 1 ) ); garbage.push_back( unprocessed_coeffs.back( ) ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { assert( unprocessed_enodes.size( ) == unprocessed_coeffs.size( ) ); Enode * enode = unprocessed_enodes.back( ); mpz_class * coeff = unprocessed_coeffs.back( ); unprocessed_enodes.pop_back( ); unprocessed_coeffs.pop_back( ); // // Process children // if ( enode->isBvadd( ) ) { assert( enode->getArity( ) == 2 ); Enode * a = enode->get1st( ); Enode * b = enode->get2nd( ); unprocessed_enodes.push_back( a ); unprocessed_coeffs.push_back( coeff ); unprocessed_enodes.push_back( b ); unprocessed_coeffs.push_back( coeff ); } else if ( enode->isBvsub( ) ) { assert( enode->getArity( ) == 2 ); Enode * a = enode->get1st( ); Enode * b = enode->get2nd( ); unprocessed_enodes.push_back( a ); unprocessed_coeffs.push_back( coeff ); unprocessed_enodes.push_back( b ); mpz_class * neg_coeff = new mpz_class; garbage.push_back( neg_coeff ); (*neg_coeff) = (*coeff) * -1; unprocessed_coeffs.push_back( neg_coeff ); } else if ( enode->isBvneg( ) ) { assert( enode->getArity( ) == 1 ); Enode * a = enode->get1st( ); unprocessed_enodes.push_back( a ); mpz_class * neg_coeff = new mpz_class; garbage.push_back( neg_coeff ); (*neg_coeff) = (*coeff) * -1; unprocessed_coeffs.push_back( neg_coeff ); } else if ( enode->isBvmul( ) && ( enode->get1st( )->isConstant( ) || enode->get2nd( )->isConstant( ) ) ) { Enode * c = enode->get1st( )->isConstant( ) ? enode->get1st( ) : enode->get2nd( ); Enode * t = enode->get1st( )->isConstant( ) ? enode->get2nd( ) : enode->get1st( ); mpz_class cval( c->getCar( )->getName( ), 2 ); unprocessed_enodes.push_back( t ); mpz_class * new_coeff = new mpz_class; garbage.push_back( new_coeff ); (*new_coeff) = (*coeff) * cval; unprocessed_coeffs.push_back( new_coeff ); } // // If constant, add to the value for constant // else if ( enode->isConstant( ) ) { mpz_class cval( enode->getCar( )->getName( ), 2 ); const_value += (*coeff) * cval; } // // Otherwise add an entry for this term // else { id_to_enode[ enode->getId( ) ] = enode; map< enodeid_t, mpz_class * >::iterator it = term_to_coeff.find( enode->getId( ) ); // // Create new entry // if ( it == term_to_coeff.end( ) ) { term_to_coeff[ enode->getId( ) ] = coeff; } // // Otherwise sum to the existing one // else { mpz_class * new_coeff = new mpz_class; garbage.push_back( new_coeff ); (*new_coeff) = (*(it->second)) + (*coeff); term_to_coeff[ enode->getId( ) ] = new_coeff; } } } */ } opensmt-2.5.2/src/simplifiers/BVNormalize.h000066400000000000000000000044671445011647600207060ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #ifndef BV_NORMALIZE_HH #define BV_NORMALIZE_HH #include "Global.h" #include "Otl.h" #include "Egraph.h" class BVNormalize { public: BVNormalize ( Egraph & egraph_, SMTConfig & config_ ) : egraph ( egraph_ ) , config ( config_ ) { } virtual ~BVNormalize( ) { } Enode * doit ( Enode * ); // Main routine private: Enode * normalize ( Enode * ); Enode * makeNumberFromGmp ( mpz_class &, const int ); void scanPolynome ( Enode * , map< enodeid_t, mpz_class * > & , mpz_class & , map< enodeid_t, Enode * > & , vector< mpz_class * > & , bool ); Enode * propagateUnconstrainedVariables ( Enode * ); Enode * replaceUnconstrainedTerms ( Enode *, vector< int > & , bool & ); void computeIncomingEdges ( Enode *, vector< int > & ); Egraph & egraph; // Reference to Egraph SMTConfig & config; // Reference to Config }; #endif opensmt-2.5.2/src/simplifiers/BoolRewriting.cc000066400000000000000000000273371445011647600214430ustar00rootroot00000000000000// // Created by Martin Blicha on 20.10.18. // #include "BoolRewriting.h" #include "Logic.h" #include // Replace subtrees consisting only of ands / ors with a single and / or term. // Search a maximal section of the tree consisting solely of ands / ors. The // root of this subtree is called and / or root. Collect the subtrees rooted at // the leaves of this section, and create a new and / or term with the leaves as // arguments and the parent of the and / or tree as the parent. // // However, we will do this in a clever way so that if a certain // term appears as a child in more than one term, we will not flatten // that structure. // void computeIncomingEdges(const Logic& logic, PTRef root, std::unordered_map& PTRefToIncoming) { assert(root != PTRef_Undef); // MB: Relies on an invariant that id of a child is lower than id of a parent. auto size = Idx(logic.getPterm(root).getId()) + 1; std::vector done; done.resize(size, 0); vec unprocessed_ptrefs; unprocessed_ptrefs.push(root); while (unprocessed_ptrefs.size() > 0) { PTRef current = unprocessed_ptrefs.last(); if (auto it = PTRefToIncoming.find(current); it != PTRefToIncoming.end()) { it->second++; unprocessed_ptrefs.pop(); continue; } bool unprocessed_children = false; if (logic.isBooleanOperator(current) && done[Idx(logic.getPterm(current).getId())] == 0) { const Pterm& t = logic.getPterm(current); for (int i = 0; i < t.size(); i++) { // push only unprocessed Boolean operators auto itChild = PTRefToIncoming.find(t[i]); if (itChild == PTRefToIncoming.end()) { unprocessed_ptrefs.push(t[i]); unprocessed_children = true; } else { itChild->second++; } } done[Idx(logic.getPterm(current).getId())] = 1; } if (unprocessed_children) continue; unprocessed_ptrefs.pop(); assert(logic.isBooleanOperator(current) || logic.isAtom(current)); PTRefToIncoming.insert(std::make_pair(current, 1)); } } PTRef rewriteMaxArityClassic(Logic & logic, PTRef root) { std::unordered_map PTRefToIncoming; computeIncomingEdges(logic, root, PTRefToIncoming); return rewriteMaxArity(logic, root, [&PTRefToIncoming](PTRef candidate) { auto it = PTRefToIncoming.find(candidate); assert(it != PTRefToIncoming.end() && it->second >= 1); return it->second > 1; }); } PTRef rewriteMaxArityAggresive(Logic & logic, PTRef root) { return rewriteMaxArity(logic, root, [](PTRef) { return false;}); } namespace { struct PtLit { PTRef var; bool sign; }; PtLit operator ~(PtLit lit) { return PtLit{lit.var, !lit.sign};} bool isTerminal(const Logic & logic, PTRef fla) { // return logic.isLit(fla); /* MB: The above does NOT work, because of Tseitin literals, * which are literals from proof point of view, but not not literals as PTRefs * So we stop at everything which is not AND or OR. * */ return !(logic.isAnd(fla) || logic.isOr(fla)); } PtLit decomposeLiteral(const Logic & logic, PTRef lit) { assert(isTerminal(logic, lit)); bool sgn = false; while (logic.getSymRef(lit) == logic.getSym_not()) { lit = logic.getPterm(lit)[0]; sgn = !sgn; } return PtLit{lit, sgn}; } PTRef _simplifyUnderAssignment(Logic & logic, PTRef root, const std::unordered_map & PTRefToIncoming, std::vector assignment, Map & cache ) { if (!logic.isAnd(root) && !logic.isOr(root)) { assert(false); // MB: should not be called for anything else return root; } assert(!cache.has(root)); bool isAnd = logic.isAnd(root); vec newargs; const Pterm & term = logic.getPterm(root); std::vector literals; std::vector owning_children; std::vector non_owning_children; for (int i = 0; i < term.size(); ++i) { if (isTerminal(logic, term[i])) { literals.push_back(term[i]); continue; } auto it = PTRefToIncoming.find(term[i]); assert(it != PTRefToIncoming.end()); assert(it->second >= 1); if (it->second > 1) { non_owning_children.push_back(term[i]); } else{ owning_children.push_back(term[i]); } } // process the literals for (PTRef lit : literals) { assert(!cache.has(lit)); PtLit decLit = decomposeLiteral(logic, lit); auto it = std::find_if(assignment.begin(), assignment.end(), [decLit](PtLit assign) { return assign.var == decLit.var; }); if (it == assignment.end()) { assignment.push_back(isAnd ? decLit : ~decLit); newargs.push(lit); } else { assert(decLit.var == it->var); if (decLit.sign == it->sign) { // this literal is evaluated to true if (!isAnd) { return logic.getTerm_true(); } } else { // this literal is evaluated to false if (isAnd) { return logic.getTerm_false(); } } } } for (PTRef owning_child : owning_children) { assert(!cache.has(owning_child)); newargs.push(_simplifyUnderAssignment(logic, owning_child, PTRefToIncoming, assignment, cache)); } for (PTRef non_owning_child : non_owning_children) { // cannot simplify under assignment if somebody else is also pointing to this if (cache.has(non_owning_child)) { newargs.push(cache[non_owning_child]); } else { PTRef new_child = _simplifyUnderAssignment(logic, non_owning_child, PTRefToIncoming, {}, cache); newargs.push(new_child); cache.insert(non_owning_child, new_child); } } return isAnd ? logic.mkAnd(std::move(newargs)) : logic.mkOr(std::move(newargs)); } } PTRef simplifyUnderAssignment(Logic & logic, PTRef root) { std::unordered_map incomingEdges; ::computeIncomingEdges(logic, root, incomingEdges); Map cache; return _simplifyUnderAssignment(logic, root, incomingEdges, {}, cache); } namespace{ template bool contains(C const & container, T el) { return container.find(el) != container.end(); } void walkDFS(PTRef node, std::unordered_set & visited, std::vector& order, Logic & logic) { visited.insert(node); Pterm const & term = logic.getPterm(node); for (int i = 0; i < term.size(); ++i) { assert(node.x > term[i].x); if (!contains(visited, term[i])) { walkDFS(term[i], visited, order, logic); } } order.push_back(node); } void update_idom(PTRef node, PTRef parent, std::unordered_map& idom) { // relies on the fact that child has to be always allocated before parent, so child's PTRef is smaller assert(contains(idom, node)); assert(node.x < parent.x); PTRef old_idom = idom.at(node); // walk up the DAG until you find common ancestor PTRef f1 = old_idom; PTRef f2 = parent; while (f1 != f2) { while (f1.x < f2.x) { assert(contains(idom, f1)); f1 = idom.at(f1); } while (f2.x < f1.x) { assert(contains(idom, f2)); f2 = idom.at(f2); } } idom[node] = f1; } } std::vector getPostOrder(PTRef root, Logic& logic) { std::vector res; std::unordered_set seen; walkDFS(root, seen, res, logic); return res; } std::unordered_map getImmediateDominators(PTRef root, Logic & logic) { std::unordered_map idom; idom[root] = root; auto postOrder = getPostOrder(root, logic); for(auto it = postOrder.rbegin(); it != postOrder.rend(); ++it) { // iterating in REVERSE post order PTRef current = *it; assert(contains(idom, current)); // update idoms of all children Pterm const & term = logic.getPterm(current); for(int i = 0; i < term.size(); ++i) { if (contains(idom, term[i])) { update_idom(term[i], current, idom); } else { idom[term[i]] = current; } } } return idom; } namespace{ PTRef simplifyUnderAssignment_Aggressive(PTRef node, Logic & logic, std::unordered_map const & dominators, std::unordered_map, PTRefHash>& assignments, std::unordered_map & cache ) { if (!logic.isAnd(node) && !logic.isOr(node)) { assert(false); // MB: should not be called for anything else return node; } assert(contains(dominators, node)); assert(contains(assignments, dominators.at(node))); assert(!contains(cache, node)); const Pterm & term = logic.getPterm(node); std::vector literals; std::vector connective_children; for (int i = 0; i < term.size(); ++i) { if (isTerminal(logic, term[i])) { literals.push_back(term[i]); } else{ connective_children.push_back(term[i]); } } bool isAnd = logic.isAnd(node); vec newargs; // this is the assignment that is propagated to me and I can use it to simplify myself and my children assert(assignments.find(dominators.at(node)) != assignments.end()); std::vector assignment = assignments.at(dominators.at(node)); // process the literals for (PTRef lit : literals) { assert(!contains(cache, lit)); PtLit decLit = decomposeLiteral(logic, lit); auto it = std::find_if(assignment.begin(), assignment.end(), [decLit](PtLit assign) { return assign.var == decLit.var; }); if (it == assignment.end()) { assignment.push_back(isAnd ? decLit : ~decLit); newargs.push(lit); } else { assert(decLit.var == it->var); if (decLit.sign == it->sign) { // this literal is evaluated to true if (!isAnd) { return logic.getTerm_true(); } // else isAND -> simply ignore this conjunct } else { // this literal is evaluated to false if (isAnd) { return logic.getTerm_false(); } // else isOR -> simply ignore this disjunct } } } // set my assignment and recurse on children assignments[node] = std::move(assignment); for (PTRef child : connective_children) { if (contains(cache, child)) { newargs.push(cache[child]); } else { PTRef new_child = simplifyUnderAssignment_Aggressive(child, logic, dominators, assignments, cache); newargs.push(new_child); cache[child] = new_child; } } // after we are done with this node, we don't need to remember its assignment anymore assignments.erase(node); return isAnd ? logic.mkAnd(std::move(newargs)) : logic.mkOr(std::move(newargs)); } } PTRef simplifyUnderAssignment_Aggressive(PTRef root, Logic & logic) { auto idom = getImmediateDominators(root, logic); std::unordered_map, PTRefHash> assignments; assignments[root] = {}; std::unordered_map cache; return simplifyUnderAssignment_Aggressive(root, logic, idom, assignments, cache); } opensmt-2.5.2/src/simplifiers/BoolRewriting.h000066400000000000000000000071441445011647600212770ustar00rootroot00000000000000// // Created by Martin Blicha on 20.10.18. // #ifndef OPENSMT_BOOLREWRITING_H #define OPENSMT_BOOLREWRITING_H #include "PTRef.h" #include "Logic.h" #include #include void computeIncomingEdges(const Logic& logic, PTRef tr, std::unordered_map& PTRefToIncoming); PTRef rewriteMaxArityAggresive(Logic & logic, PTRef root); PTRef rewriteMaxArityClassic(Logic & logic, PTRef root); PTRef simplifyUnderAssignment(Logic & logic, PTRef root); PTRef simplifyUnderAssignment_Aggressive(PTRef root, Logic & logic); std::vector getPostOrder(PTRef root, Logic& logic); std::unordered_map getImmediateDominators(PTRef root, Logic & logic); template PTRef mergeAndOrArgs(Logic & logic, PTRef tr, Map& cache, T doNotMerge) { assert(logic.isAnd(tr) || logic.isOr(tr)); const Pterm& t = logic.getPterm(tr); SymRef sr = t.symb(); vec new_args; bool changed = false; for (int i = 0; i < t.size(); i++) { PTRef subst = cache[t[i]]; changed |= (subst != t[i]); if (logic.getSymRef(subst) == sr && !doNotMerge(t[i])) { changed = true; const Pterm& substs_t = logic.getPterm(subst); for (int j = 0; j < substs_t.size(); j++) new_args.push(substs_t[j]); } else { new_args.push(subst); } } if (!changed) { return tr; } PTRef new_tr = (sr == logic.getSym_and() ? logic.mkAnd(std::move(new_args)) : logic.mkOr(std::move(new_args))); return new_tr; } template PTRef rewriteMaxArity(Logic & logic, const PTRef root, T doNotRewrite) { vec unprocessed_ptrefs; unprocessed_ptrefs.push(root); Map cache; while (unprocessed_ptrefs.size() > 0) { PTRef tr = unprocessed_ptrefs.last(); if (cache.has(tr)) { unprocessed_ptrefs.pop(); continue; } bool unprocessed_children = false; const Pterm& t = logic.getPterm(tr); for (int i = 0; i < t.size(); i++) { if (cache.has(t[i])) { continue; } if (logic.isBooleanOperator(t[i])) { unprocessed_ptrefs.push(t[i]); unprocessed_children = true; } else if (logic.isAtom(t[i])) { assert(!cache.has(t[i])); cache.insert(t[i], t[i]); } else { assert(false); } } if (unprocessed_children) continue; unprocessed_ptrefs.pop(); SymRef symRef = t.symb(); assert(logic.isBooleanOperator(symRef)); PTRef result = PTRef_Undef; if (logic.isAnd(symRef) or logic.isOr(symRef)) { result = ::mergeAndOrArgs(logic, tr, cache, doNotRewrite); } else if (logic.isNot(symRef)) { PTRef child = t[0]; PTRef newChild = cache[child]; result = child == newChild ? tr : logic.mkNot(newChild); } else { // general connective vec newArgs; newArgs.capacity(t.size()); bool changed = false; for (PTRef child : t) { PTRef newChild = cache[child]; changed |= (newChild != child); newArgs.push(newChild); } result = changed ? logic.insertTerm(symRef, std::move(newArgs)) : tr; } assert(result != PTRef_Undef); assert(!cache.has(tr)); cache.insert(tr, result); } PTRef top_tr = cache[root]; return top_tr; } #endif //OPENSMT_BOOLREWRITING_H opensmt-2.5.2/src/simplifiers/CMakeLists.txt000066400000000000000000000004321445011647600210710ustar00rootroot00000000000000add_library(simplifiers OBJECT "") target_sources(simplifiers PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/LA.h" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/LA.cc" "${CMAKE_CURRENT_SOURCE_DIR}/BoolRewriting.cc" ) install(FILES BoolRewriting.h DESTINATION ${INSTALL_HEADERS_DIR} ) opensmt-2.5.2/src/simplifiers/DLRescale.cc000066400000000000000000000115601445011647600204420ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso , Aliaksei Tsitovich , Edgar Pek OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #include "DLRescale.h" void DLRescale::doit( Enode * formula ) { if ( formula->isTrue( ) || formula->isFalse( ) ) return; #if USE_GMP assert( formula ); int nof_variables = 0; mpz_t lcm; mpz_init_set_ui( lcm, 1 ); egraph.initDup1( ); vector< Enode *> unprocessed_enodes; // stack for unprocessed enodes unprocessed_enodes.push_back( formula ); // formula needs to be processed // // Visit the DAG of the formula from the leaves to the root // while ( !unprocessed_enodes.empty() ) { Enode * enode = unprocessed_enodes.back(); // // Skip if the node has already been processed before // if ( egraph.isDup1( enode ) ) { unprocessed_enodes.pop_back(); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only children that haven't been processed yet, // but never children of a theory atom // if ( !egraph.isDup1( arg ) ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if (unprocessed_children) continue; unprocessed_enodes.pop_back( ); if ( !enode->hasSortBool( ) ) { if ( enode->isVar( ) ) nof_variables ++; else if ( enode->isConstant( ) ) { const Real & c = enode->getValue( ); mpz_lcm( lcm, lcm, c.get_den( ).get_mpz_t( ) ); } } assert( !egraph.isDup1( enode ) ); egraph.storeDup1( enode ); } egraph.doneDup1( ); Real rescale_factor = Real( mpz_class( lcm )) * Real( nof_variables ) * Real( nof_variables + 1 ); assert( rescale_factor > 1 ); // // Check if worst-case constants sum excees INT_MAX // If so tell the TSolver allocator to use GMP // curr_constant_sum = 0; egraph.initDup1( ); unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while ( !unprocessed_enodes.empty() ) { Enode * enode = unprocessed_enodes.back(); // // Skip if the node has already been processed before // if ( egraph.isDup1( enode ) ) { unprocessed_enodes.pop_back(); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only children that haven't been processed yet, // but never children of a theory atom // if ( !egraph.isDup1( arg ) ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if (unprocessed_children) continue; unprocessed_enodes.pop_back( ); if ( !enode->hasSortBool( ) && enode->isConstant( ) ) { Real c = enode->getValue( ); Real r = c * rescale_factor; if ( !egraph.getUseGmp( ) ) { if ( r < 0 ) curr_constant_sum += -r + 1; else curr_constant_sum += r + 1; if ( curr_constant_sum > Real( INT_MAX ) && !egraph.getUseGmp( ) ) egraph.setUseGmp( ); } } assert( !egraph.isDup1( enode ) ); egraph.storeDup1( enode ); } egraph.doneDup1( ); egraph.setRescale( rescale_factor ); mpz_clear( lcm ); #else error( "cannot rescale without GMP", "" ); #endif } opensmt-2.5.2/src/simplifiers/DLRescale.h000066400000000000000000000034671445011647600203130ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso , Aliaksei Tsitovich , Edgar Pek OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #ifndef DLRESCALE_H #define DLRESCALE_H #include "Global.h" #include "Otl.h" #include "Egraph.h" class DLRescale { public: DLRescale( Egraph & egraph_, SMTConfig & config_ ) : egraph ( egraph_ ) , config ( config_ ) , curr_constant_sum ( 0 ) { } ~DLRescale( ) { } void doit ( Enode * ); private: Egraph & egraph; SMTConfig & config; Real curr_constant_sum; }; #endif opensmt-2.5.2/src/simplifiers/ExpandITEs.cc000066400000000000000000000101361445011647600206060ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #include "ExpandITEs.h" Enode * ExpandITEs::doit( Enode * formula ) { assert( formula ); list< Enode * > new_clauses; vector< Enode * > unprocessed_enodes; egraph.initDupMap1( ); unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.valDupMap1( enode ) != NULL ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( egraph.valDupMap1( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); Enode * result = NULL; // // At this point, every child has been processed // char def_name[ 32 ]; if ( enode->isIte( ) ) { // // Retrieve arguments // Enode * i = egraph.valDupMap1( enode->get1st( ) ); Enode * t = egraph.valDupMap1( enode->get2nd( ) ); Enode * e = egraph.valDupMap1( enode->get3rd( ) ); Enode * not_i = egraph.mkNot( egraph.cons( i ) ); // // Generate variable symbol // sprintf( def_name, ITE_STR, enode->getId( ) ); Snode * sort = enode->getRetSort( ); egraph.newSymbol( def_name, NULL, sort ); // // Generate placeholder // result = egraph.mkVar( def_name ); #ifdef PRODUCE_PROOF if ( config.produce_inter != 0 ) egraph.addDefinition( result, enode ); #endif // // Generate additional clauses // Enode * eq_then = egraph.mkEq( egraph.cons( result , egraph.cons( t ) ) ); Enode * eq_else = egraph.mkEq( egraph.cons( result , egraph.cons( e ) ) ); new_clauses.push_back( egraph.mkOr( egraph.cons( not_i , egraph.cons( eq_then ) ) ) ); new_clauses.push_back( egraph.mkOr( egraph.cons( i , egraph.cons( eq_else ) ) ) ); } else { result = egraph.copyEnodeEtypeTermWithCache( enode ); } assert( result ); assert( egraph.valDupMap1( enode ) == NULL ); egraph.storeDupMap1( enode, result ); } Enode * new_formula = egraph.valDupMap1( formula ); assert( new_formula ); egraph.doneDupMap1( ); new_clauses.push_back( new_formula ); return egraph.mkAnd( egraph.cons( new_clauses ) ); } opensmt-2.5.2/src/simplifiers/ExpandITEs.h000066400000000000000000000033011445011647600204440ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #ifndef EXPAND_ITES_H #define EXPAND_ITES_H #include "Global.h" #include "Otl.h" #include "Egraph.h" class ExpandITEs { public: ExpandITEs( Egraph & egraph_, SMTConfig & config_ ) : egraph ( egraph_ ) , config ( config_ ) { } virtual ~ExpandITEs( ) { } Enode * doit ( Enode * ); // Main routine private: Egraph & egraph; // Reference to Egraph SMTConfig & config; // Reference to Config }; #endif opensmt-2.5.2/src/simplifiers/FrameSimplifiers/000077500000000000000000000000001445011647600215735ustar00rootroot00000000000000opensmt-2.5.2/src/simplifiers/FrameSimplifiers/FrameSimplifier.h000066400000000000000000000002321445011647600250170ustar00rootroot00000000000000// // Created by Martin Blicha on 2018-12-18. // #ifndef OPENSMT_FRAMESIMPLIFIER_H #define OPENSMT_FRAMESIMPLIFIER_H #endif //OPENSMT_FRAMESIMPLIFIER_H opensmt-2.5.2/src/simplifiers/FrameSimplifiers/UFFrameSimplifier.cpp000066400000000000000000000001211445011647600256020ustar00rootroot00000000000000// // Created by Martin Blicha on 2018-12-18. // #include "UFFrameSimplifier.h" opensmt-2.5.2/src/simplifiers/FrameSimplifiers/UFFrameSimplifier.h000066400000000000000000000003011445011647600252470ustar00rootroot00000000000000// // Created by Martin Blicha on 2018-12-18. // #ifndef OPENSMT_UFFRAMESIMPLIFIER_H #define OPENSMT_UFFRAMESIMPLIFIER_H class UFFrameSimplifier { }; #endif //OPENSMT_UFFRAMESIMPLIFIER_H opensmt-2.5.2/src/simplifiers/LA.cc000066400000000000000000000206201445011647600171350ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso Aliaksei Tsitovich OpenSMT2 -- copyright (C) 2012 - 2015, Antti Hyvarinen OpenSMT -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #include "LA.h" #include void LAExpression::initialize(PTRef e, bool do_canonize) { assert(logic.isNumEq(e) || logic.isLeq(e)); PTRef lhs = logic.getPterm(e)[0]; PTRef rhs = logic.getPterm(e)[1]; std::vector curr_term{lhs, rhs}; std::vector curr_const{1, -1}; while (!curr_term.empty()) { PTRef t = curr_term.back(); assert(logic.yieldsSortNum(t)); curr_term.pop_back(); opensmt::Real c = curr_const.back(); curr_const.pop_back(); // Only 3 cases are allowed // // If it is plus, enqueue the arguments with same constant if (logic.isPlus(t)) { const Pterm & term = logic.getPterm(t); for (PTRef arg : term) { curr_term.emplace_back(arg); curr_const.emplace_back(c); } } else if (logic.isTimes(t)) { // If it is times, then one side must be constant, other // is enqueued with a new constant auto [var, constant] = logic.splitTermToVarAndConst(t); opensmt::Real new_c = logic.getNumConst(constant); new_c *= c; curr_term.emplace_back(var); curr_const.emplace_back(std::move(new_c)); } else { // Otherwise it is a variable, Ite, UF or constant assert(logic.isNumVarLike(t) || logic.isConstant(t) || logic.isUF(t)); if (logic.isConstant(t)) { const opensmt::Real tval = logic.getNumConst(t); polynome[PTRef_Undef] += tval * c; } else { auto it = polynome.find(t); if (it != polynome.end()) { it->second += c; if (it->first != PTRef_Undef && it->second == 0) polynome.erase(it); } else { polynome.insert({t, c}); } } } } if (polynome.find(PTRef_Undef) == polynome.end()) { polynome.insert({PTRef_Undef, 0}); } // // Canonize // if (do_canonize) { canonize(); } } PTRef LAExpression::toPTRef(SRef sort) const { assert(polynome.find(PTRef_Undef) != polynome.end()); assert(not polynome.empty()); // // There is at least one variable // vec sum_list; opensmt::Real constant = 0; for (auto const & [var, factor] : polynome) { if (var == PTRef_Undef) { constant = factor; } else { PTRef coeff = logic.mkConst(sort, factor); sum_list.push(logic.mkTimes(coeff, var)); } } if (sum_list.size() == 0) { sum_list.push(logic.getZeroForSort(sort)); } // Return in the form ax + by + ... = -c if (r == OP::EQ || r == OP::LEQ) { PTRef poly = logic.mkPlus(sum_list); constant.negate(); PTRef c = logic.mkConst(sort, constant); if (r == OP::EQ) { return logic.mkEq(poly, c); } else { return logic.mkLeq(poly, c); } } // Return in the form ax + by + ... + c assert(r == OP::UNDEF); sum_list.push(logic.mkConst(sort, constant)); PTRef poly = logic.mkPlus(sum_list); return poly; } void LAExpression::print(std::ostream & os) const { assert(polynome.find(PTRef_Undef) != polynome.end()); assert(not polynome.empty()); if (r == OP::EQ) os << "(="; else if (r == OP::LEQ) os << "(<="; opensmt::Real constant = 0; if (polynome.size() == 1) os << " " << polynome.at(PTRef_Undef); else { // There is at least one variable os << " (+"; for (auto const & [var, factor] : polynome) { if (var == PTRef_Undef) constant = - factor; else os << " (* " << factor << " " << logic.printTerm(var) << ")"; } os << ")"; } if (r == OP::EQ || r == OP::LEQ) os << " " << constant << ")"; os << '\n'; } opensmt::pair LAExpression::getSubst() { if (polynome.size() == 1) { assert(polynome.find(PTRef_Undef) != polynome.end()); return {PTRef_Undef, PTRef_Undef}; } // There is at least one variable // Solve w.r.t. first variable solve(); vec sum_list; opensmt::Real constant = 0; PTRef var = PTRef_Undef; SRef polySort = SRef_Undef; for (auto const & [v, factor] : polynome) { if (v == PTRef_Undef) { constant = - factor; } else { polySort = polySort != SRef_Undef ? polySort : logic.getSortRef(v); if (var == PTRef_Undef) { var = v; assert(factor == 1); } else { PTRef c = logic.mkConst(polySort, - factor); sum_list.push(logic.mkTimes(c, v)); } } } assert(polySort != SRef_Undef); sum_list.push(logic.mkConst(polySort, constant)); PTRef poly = logic.mkPlus(sum_list); return {var, poly}; } // // Solve w.r.t. first variable // ex. // // 3*x + 2*y -1*z + 5 = 0 // // 1*x + 2/3*y - 1/3*z + 5/3 = 0 // // it modifies the polynome internally // PTRef LAExpression::solve() { assert(r == OP::EQ); assert(polynome.find(PTRef_Undef) != polynome.end()); if (polynome.size() == 1) { assert(polynome.find(PTRef_Undef) != polynome.end()); return PTRef_Undef; } // // Get first useful variable // auto it = polynome.begin(); if (it->first == PTRef_Undef) it++; PTRef var = it->first; const opensmt::Real coeff = it->second; // // Divide polynome by coeff // for (auto & term: polynome) { term.second /= coeff; } assert(polynome[var] == 1); return var; } // // Canonize w.r.t. first variable // ex. // // 3*x + 2*y -1*z + 5 = 0 // // 1*x + 2/3*y - 1/3*z + 5/3 = 0 // // it modifies the polynome internally // void LAExpression::canonize() { if (polynome.size() == 1) { assert(polynome.find(PTRef_Undef) != polynome.end()); return; } // Get first useful variable auto it = polynome.begin(); if (it->first == PTRef_Undef) it++; if (r == OP::LEQ) { const opensmt::Real abs_coeff = (it->second > 0 ? it->second : opensmt::Real(-it->second)); for (auto & term: polynome) { term.second /= abs_coeff; } } else { const opensmt::Real coeff = it->second; for (auto & term: polynome) { term.second /= coeff; } } assert(isCanonized()); } void LAExpression::addExprWithCoeff(const LAExpression & a, const opensmt::Real & coeff) { // // Iterate over expression to add // for (auto const & [var, factor] : a.polynome) { assert(var == PTRef_Undef or logic.yieldsSortNum(var)); auto it2 = polynome.find(var); if (it2 != polynome.end()) { it2->second += coeff * factor; if (it2->first != PTRef_Undef && it2->second == 0) polynome.erase(it2); } else { polynome.insert({var, coeff * factor}); } } } opensmt-2.5.2/src/simplifiers/LA.h000066400000000000000000000074241445011647600170060ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso Aliaksei Tsitovich OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #ifndef LA_H #define LA_H #include "PtStructs.h" #include "ArithLogic.h" #include "Real.h" #include class LAExpression { ArithLogic & logic; public: LAExpression(ArithLogic & l) : logic(l), r(OP::UNDEF) { polynome[PTRef_Undef] = 0; } LAExpression(ArithLogic & l, PTRef e, bool do_canonize) : logic(l),r(l.isNumEq(e) ? OP::EQ : (l.isLeq(e) ? OP::LEQ : OP::UNDEF)) { initialize(e, do_canonize); } LAExpression(ArithLogic & l, PTRef e) : LAExpression(l, e, true) {} inline bool isTrue() { return polynome.size() == 1 && (r == OP::EQ ? polynome[PTRef_Undef] == 0 : polynome[PTRef_Undef] >= 0); } inline bool isFalse() { return polynome.size() == 1 && (r == OP::EQ ? polynome[PTRef_Undef] != 0 : polynome[PTRef_Undef] < 0); } using polynome_t = std::map>; void initialize(PTRef, bool canonize = true); // Initialize PTRef solve(); // Solve w.r.t. some variable void canonize(); // Canonize (different from solve!) PTRef toPTRef(SRef sort) const; void print(std::ostream &) const; opensmt::pair getSubst(); // Get a valid substitution // Adds an expression to the current one multiplied by Real void addExprWithCoeff(const LAExpression &, const opensmt::Real &); // Export iterator in order to allow external procedures to read the polynomes using iterator = polynome_t::iterator; using const_iterator = polynome_t::const_iterator; inline iterator begin() { return polynome.begin(); } inline iterator end() { return polynome.end(); } inline const_iterator begin() const { return polynome.begin(); } inline const_iterator end() const { return polynome.end(); } // We assume that the first coeffient is 1 or -1 inline bool isCanonized() { if (polynome.size() == 1) return true; auto it = polynome.begin(); if (it->first == PTRef_Undef) { ++it; } PTRef var = it->first; return polynome[var].isOne() || polynome[var] == -1; } private: enum class OP : char { UNDEF, EQ, LEQ } ; polynome_t polynome; // PTRef --> coefficient (NULL for constant) const OP r; // Arithmetic relation // Print overloading inline friend std::ostream & operator<<(std::ostream & os, LAExpression & p) { p.print(os); return os; } }; #endif opensmt-2.5.2/src/simplifiers/Purify.cc000066400000000000000000000036401445011647600201220ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #include "Purify.h" void Purify::doit( Enode * formula ) { assert( config.logic == QF_UFIDL || config.logic == QF_UFLRA ); // It works as follows: // the formula is not actually purified, as it // should be in a textbook version of the algorithm. // Instead we just traverse the formula, and we collect // the terms that would have to become interface // variables egraph.gatherInterfaceTerms( formula ); } void Purify::doit( vector< Enode * > & assertions ) { #ifdef PRODUCE_PROOF assert( config.produce_inter != 0 ); #endif for ( size_t i = 0 ; i < assertions.size( ) ; i ++ ) egraph.gatherInterfaceTerms( assertions[ i ] ); } opensmt-2.5.2/src/simplifiers/Purify.h000066400000000000000000000033711445011647600177650ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #ifndef PURIFY_H #define PURIFY_H #include "Global.h" #include "Otl.h" #include "Egraph.h" class Purify { public: Purify( Egraph & egraph_, SMTConfig & config_ ) : egraph ( egraph_ ) , config ( config_ ) { } virtual ~Purify( ) { } void doit ( Enode * ); // Main routine void doit ( vector< Enode * > & ); // Main routine for interpolation private: Egraph & egraph; // Reference to Egraph SMTConfig & config; // Reference to Config }; #endif opensmt-2.5.2/src/smtsolvers/000077500000000000000000000000001445011647600162255ustar00rootroot00000000000000opensmt-2.5.2/src/smtsolvers/CMakeLists.txt000066400000000000000000000025401445011647600207660ustar00rootroot00000000000000add_library(smtsolvers OBJECT "") list(APPEND PRIVATE_SOURCES_TO_ADD "${CMAKE_CURRENT_SOURCE_DIR}/SimpSMTSolver.cc" "${CMAKE_CURRENT_SOURCE_DIR}/CoreSMTSolver.cc" "${CMAKE_CURRENT_SOURCE_DIR}/GhostSMTSolver.cc" "${CMAKE_CURRENT_SOURCE_DIR}/TheoryIF.cc" "${CMAKE_CURRENT_SOURCE_DIR}/TheoryInterpolator.h" "${CMAKE_CURRENT_SOURCE_DIR}/Debug.cc" "${CMAKE_CURRENT_SOURCE_DIR}/LookaheadSMTSolver.cc" "${CMAKE_CURRENT_SOURCE_DIR}/LookaheadSMTSolver.h" "${CMAKE_CURRENT_SOURCE_DIR}/LAScore.h" "${CMAKE_CURRENT_SOURCE_DIR}/LAScore.cc" ) list(APPEND PUBLIC_SOURCES_TO_ADD "${CMAKE_CURRENT_SOURCE_DIR}/SimpSMTSolver.h" "${CMAKE_CURRENT_SOURCE_DIR}/GhostSMTSolver.h" "${CMAKE_CURRENT_SOURCE_DIR}/CoreSMTSolver.h" ) target_sources(smtsolvers PRIVATE ${PRIVATE_SOURCES_TO_ADD} PUBLIC ${PUBLIC_SOURCES_TO_ADD} ) if(VERBOSE_SAT) target_compile_definitions(smtsolvers PRIVATE -DVERBOSE_SAT) endif() if(DEBUG_LOOKAHEAD) target_compile_definitions(smtsolvers PRIVATE -DLADEBUG) endif() if(PRINT_UNITS) target_compile_definitions(smtsolvers PRIVATE -DREPORT_DL1_THLITS) endif() target_sources(proof PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/Proof.h" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/Proof.cc") install(FILES TheoryInterpolator.h DESTINATION ${INSTALL_HEADERS_DIR}) install(FILES SimpSMTSolver.h CoreSMTSolver.h DESTINATION ${INSTALL_HEADERS_DIR}) opensmt-2.5.2/src/smtsolvers/CoreSMTSolver.cc000066400000000000000000001736751445011647600212260ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2016 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ /****************************************************************************************[Solver.C] MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson 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. **************************************************************************************************/ #include "CoreSMTSolver.h" #include "ModelBuilder.h" #include "OsmtInternalException.h" #include "Sort.h" #include #include #include #include #include "Proof.h" #include "SystemQueries.h" #include "ReportUtils.h" #include "Random.h" namespace opensmt { extern bool stop; } //================================================================================================= // Constructor/Destructor: CoreSMTSolver::CoreSMTSolver(SMTConfig & c, THandler& t ) : config (c) , theory_handler (t) , verbosity (c.verbosity()) , init (false) , stop (false) // Parameters: (formerly in 'SearchParams') , var_decay (c.sat_var_decay()) , clause_decay (c.sat_clause_decay()) , random_var_freq (c.sat_random_var_freq()) , luby_restart (c.sat_luby_restart()) , ccmin_mode (c.sat_ccmin_mode()) , rnd_pol (c.sat_rnd_pol()) , rnd_init_act (c.sat_rnd_init_act()) , garbage_frac (c.sat_garbage_frac()) , restart_first (c.sat_restart_first()) , restart_inc (c.sat_restart_inc()) , learntsize_factor((double)1/(double)3) , learntsize_inc ( 1.1 ) // More parameters: // , expensive_ccmin ( true ) , learntsize_adjust_start_confl (0) // Statistics: (formerly in 'SolverStats') // , solves(0), starts(0), decisions(0), rnd_decisions(0), propagations(0), conflicts(0), conflicts_last_update(0) , dec_vars(0), clauses_literals(0), learnts_literals(0), max_literals(0), tot_literals(0) // ADDED FOR MINIMIZATION , learnts_size(0) , all_learnts(0) , learnt_theory_conflicts(0) , top_level_lits (0) , ok (true) , conflict_frame (0) , n_clauses (0) , cla_inc (1) , var_inc (1) , watches (WatcherDeleted(ca)) , qhead (0) , simpDB_assigns (-1) , simpDB_props (0) , order_heap (VarOrderLt(activity)) , random_seed (c.getRandomSeed()) , progress_estimate (0) , remove_satisfied (true) #ifdef PEDANTIC_DEBUG , max_dl_debug (0) , analyze_cnt (0) #endif , conflict_budget (-1) , propagation_budget (-1) , asynch_interrupt (false) , learnt_t_lemmata (0) , perm_learnt_t_lemmata (0) , luby_i (0) , luby_k (1) , cuvti (false) , proof (config.produce_inter() ? new Proof(ca ) : nullptr ) #ifdef STATISTICS , preproc_time (0) , elim_tvars (0) #endif { } void CoreSMTSolver::initialize( ) { random_seed = config.getRandomSeed(); restart_first = config.sat_restart_first(); restart_inc = config.sat_restart_inc(); // Set some parameters skip_step = config.sat_initial_skip_step; skipped_calls = 0; #ifdef STATISTICS preproc_time = 0; tsolvers_time = 0; ie_generated = 0; #endif if (config.produce_inter() && !proof) { proof = std::unique_ptr(new Proof(this->ca)); } init = true; } CoreSMTSolver::~CoreSMTSolver() { #ifdef STATISTICS if ( config.produceStats() != 0 ) printStatistics ( config.getStatsOut( ) ); // TODO added for convenience if ( config.print_stats != 0 ) printStatistics ( cerr ); cerr << "; time used for choosing branch lit " << branchTimer.getTime() << endl; cerr << "; avg dec time " << branchTimer.getTime()/decisions << endl; #endif } //================================================================================================= // Minor methods: void CoreSMTSolver::addVar(Var v) { PTRef pterm = theory_handler.getTMap().varToPTRef(v); if (pterm == PTRef_Undef) { opensmt_warning("Trying to add to SAT solver a variable not bound to any pterm. Ignoring the variable!"); return; } addVar_(v); } // // Add a new var v to the solver if it does not yet exist // It also activates the variable - turns it into decision variable - if it was not active before // void CoreSMTSolver::addVar_(Var v) { if (v < nVars()) { // These are Necessary in incremental mode since previously // ignored vars can now reappear decision[v] = true; insertVarOrder(v); return; } while (v >= nVars()) newVar(true); } // Creates a new SAT variable in the solver. If 'decision_var' is cleared, variable will not be // used as a decision variable (NOTE! This has effects on the meaning of a SATISFIABLE result). // Var CoreSMTSolver::newVar(bool dvar) { int v = nVars(); watches .init(mkLit(v, false)); watches .init(mkLit(v, true)); assigns .push(l_Undef); vardata .push(mkVarData(CRef_Undef, 0)); activity .push(rnd_init_act ? opensmt::drand(random_seed) * 0.00001 : 0); seen .push(0); decision .push(); trail .capacity(v+1); setDecisionVar(v, dvar); savedPolarity.push(true); this->var_seen.push(false); // MB: Unnecessary call to insertVarOrder. This is already achieved by calling setDecisionVar above // insertVarOrder(v); assert(!decision[v] || order_heap.inHeap(v)); // Added Lines // Skip undo for varTrue and varFalse if ( v != 0 && v != 1 ) undo_stack.push(undo_stack_el(undo_stack_el::NEWVAR, v)); return v; } bool CoreSMTSolver::addOriginalClause_(const vec & _ps) { opensmt::pair fake; return addOriginalClause_(_ps, fake); } bool CoreSMTSolver::addOriginalClause_(const vec & _ps, opensmt::pair & inOutCRefs) { assert(decisionLevel() == 0); inOutCRefs = {CRef_Undef, CRef_Undef}; if (!isOK()) { return false; } bool logsProofForInterpolation = this->logsProofForInterpolation(); vec ps; _ps.copyTo(ps); // Check if clause is satisfied and remove false/duplicate literals: sort(ps); std::vector resolvedUnits; Lit p = lit_Undef; Lit ru = lit_Undef; int i, j; for (i = j = 0; i < ps.size(); i++) { if (value(ps[i]) == l_True || ps[i] == ~p) { // This original clause is already satisfied return true; } else if (value(ps[i]) != l_False && ps[i] != p) // Ignore duplicates and falsified literals { ps[j++] = p = ps[i]; } else if (logsProofForInterpolation && value(ps[i]) == l_False && ps[i] != ru) { ru = ps[i]; resolvedUnits.push_back(ps[i]); } } ps.shrink(i - j); if (logsProofForInterpolation) { vec original; ps.copyTo(original); for(Lit l : resolvedUnits) { original.push(l); } CRef inputClause = ca.alloc(original); CRef outputClause = resolvedUnits.empty() ? inputClause : ps.size() == 0 ? CRef_Undef : ca.alloc(ps); inOutCRefs = {inputClause, outputClause}; proof->newOriginalClause(inputClause); if (!resolvedUnits.empty()) { proof->beginChain( inputClause ); for(Lit l : resolvedUnits) { Var v = var(l); assert(reason(v) != CRef_Undef); proof->addResolutionStep(reason(v), v); } proof->endChain(outputClause); } } if (ps.size() == 0) { return ok = false; } if (ps.size() == 1) { assert(value(ps[0]) == l_Undef); CRef reasonForAssignment = inOutCRefs.second; assert((logsProofForInterpolation && reasonForAssignment != CRef_Undef) || (!logsProofForInterpolation && reasonForAssignment == CRef_Undef)); uncheckedEnqueue(ps[0], reasonForAssignment); CRef confl = propagate(); ok = (confl == CRef_Undef); return ok; } else { CRef clauseToAttach = logsProofForInterpolation ? inOutCRefs.second : ca.alloc(ps); inOutCRefs.second = clauseToAttach; clauses.push(clauseToAttach); attachClause(clauseToAttach); // MB: TODO: remove this undo_stack undo_stack.push(undo_stack_el(undo_stack_el::NEWCLAUSE, clauseToAttach)); } return true; } void CoreSMTSolver::attachClause(CRef cr) { const Clause& c = ca[cr]; assert(c.size() > 1); assert(value(c[0]) != l_False or value(c[1]) != l_False); watches[~c[0]].push(Watcher(cr, c[1])); watches[~c[1]].push(Watcher(cr, c[0])); if (c.learnt()) learnts_literals += c.size(); else clauses_literals += c.size(); } void CoreSMTSolver::detachClause(CRef cr, bool strict) { const Clause& c = ca[cr]; assert(c.size() > 1); if (strict) { remove(watches[~c[0]], Watcher(cr, c[1])); remove(watches[~c[1]], Watcher(cr, c[0])); } else { // Lazy detaching: (NOTE! Must clean all watcher lists before garbage collecting this clause) watches.smudge(~c[0]); watches.smudge(~c[1]); } if (c.learnt()) learnts_literals -= c.size(); else clauses_literals -= c.size(); } void CoreSMTSolver::removeClause(CRef cr) { Clause& c = ca[cr]; detachClause(cr); // Don't leave pointers to free'd memory! if (locked(c)) vardata[var(c[0])].reason = CRef_Undef; c.mark(1); if (logsProofForInterpolation()) { // Remove clause and derivations if ref becomes 0 // If ref is not 0, we keep it and remove later if (!proof->deleted(cr)) pleaves.push(cr); } else { ca.free(cr); } } bool CoreSMTSolver::satisfied(const Clause& c) const { for (unsigned i = 0; i < c.size(); i++) if (value(c[i]) == l_True) return true; return false; } // Revert to the state at given level (keeping all assignment at 'level' but not beyond). // void CoreSMTSolver::cancelUntil(int level) { if (decisionLevel() > level) { if (trail.size() > longestTrail) { for (auto p : trail) { savedPolarity[var(p)] = not sign(p); } longestTrail = trail.size(); } for (int c = trail.size()-1; c >= trail_lim[level]; c--) { Var x = var(trail[c]); #ifdef PEDANTIC_DEBUG assert(assigns[x] != l_Undef); #endif assigns [x] = l_Undef; insertVarOrder(x); } qhead = trail_lim[level]; trail.shrink(trail.size() - trail_lim[level]); trail_lim.shrink(trail_lim.size() - level); //if ( first_model_found ) theory_handler.backtrack(trail.size()); } } void CoreSMTSolver::printClause(Clause & cl) { for (unsigned i = 0; i < cl.size(); ++i) { std::cout << cl[i] << ' '; } std::cout << '\n'; } void CoreSMTSolver::printClause(CRef cref) { printClause(ca[cref]); } void CoreSMTSolver::cancelUntilVar( Var v ) { int c; for ( c = trail.size( )-1 ; var(trail[ c ]) != v ; c -- ) { Var x = var(trail[ c ]); assigns[ x ] = l_Undef; insertVarOrder( x ); } // Reset v itself assigns[ v ] = l_Undef; insertVarOrder( v ); trail.shrink(trail.size( ) - c ); qhead = trail.size( ); if ( decisionLevel( ) > level(v) ) { assert( c > 0 ); assert( c - 1 < trail.size( ) ); assert( var(trail[ c ]) == v ); int lev = level(var(trail[ c-1 ])); assert( lev < trail_lim.size( ) ); trail_lim[ lev ] = c; trail_lim.shrink(trail_lim.size( ) - lev); } theory_handler.backtrack(trail.size()); } void CoreSMTSolver::cancelUntilVarTempInit( Var v ) { assert( cuvti == false ); cuvti = true; int c; for ( c = trail.size( )-1 ; var(trail[ c ]) != v ; c -- ) { Lit p = trail[ c ]; Var x = var( p ); lit_to_restore.push( p ); val_to_restore.push( assigns[ x ] ); assigns[x] = l_Undef; } // Stores v as well Lit p = trail[ c ]; Var x = var( p ); assert( v == x ); lit_to_restore.push( p ); val_to_restore.push(assigns[x]); assigns[x] = l_Undef; // Reset v itself assigns[v] = l_Undef; trail.shrink(trail.size( ) - c ); theory_handler.backtrack(trail.size()); } void CoreSMTSolver::cancelUntilVarTempDone( ) { assert( cuvti == true ); cuvti = false; #ifdef VERBOSE_SAT cerr << "restoring " << val_to_restore.size() << " lits to trail" << endl; #endif while ( val_to_restore.size( ) > 0 ) { Lit p = lit_to_restore.last(); Var x = var(p); lit_to_restore.pop(); lbool v = val_to_restore.last(); val_to_restore.pop(); assigns[x] = v; trail.push(p); } const bool res = theory_handler.assertLits(trail); #ifdef PEDANTIC_DEBUG theory_handler.checkTrailConsistency(trail); #endif // Flush conflict if unsat if ( !res ) { // assert(false); vec< Lit > conflicting; int max_decision_level; #ifdef PEDANTIC_DEBUG theory_handler.getConflict( conflicting, vardata, max_decision_level, trail ); #else theory_handler.getConflict(conflicting, vardata, max_decision_level); #endif } } Var CoreSMTSolver::doRandomDecision() { Var next = var_Undef; if (branchLitRandom()) { next = order_heap[opensmt::irand(random_seed,order_heap.size())]; if (value(next) == l_Undef && decision[next]) rnd_decisions++; } return next; } bool CoreSMTSolver::branchLitRandom() { return opensmt::drand(random_seed) < random_var_freq && !order_heap.empty(); } Var CoreSMTSolver::doActivityDecision() { Var next = var_Undef; while (next == var_Undef || value(next) != l_Undef || !decision[next]) { if (order_heap.empty()) { next = var_Undef; break; } else { next = order_heap.removeMin(); } } return next; } Lit CoreSMTSolver::choosePolarity(Var next) { assert(next != var_Undef); bool sign = false; bool use_theory_suggested_polarity = config.use_theory_polarity_suggestion(); if (use_theory_suggested_polarity && next != var_Undef && theory_handler.isDeclared(next)) { lbool suggestion = theory_handler.getSolverHandler().getPolaritySuggestion(theory_handler.varToTerm(next)); if (suggestion != l_Undef) { sign = (suggestion != l_True); return mkLit(next, sign); } } sign = (savedPolarity[next] == flipState); return mkLit(next, sign); } //================================================================================================= // Major methods: Lit CoreSMTSolver::pickBranchLit() { Var next = var_Undef; // Pick a variable either randomly or based on activity next = doRandomDecision(); // Activity based decision if (next == var_Undef || value(next) != l_Undef || !decision[next]) next = doActivityDecision(); if (next == var_Undef) // All variables are assigned return lit_Undef; // Return the literal with the chosen polarity return choosePolarity(next); } /*_________________________________________________________________________________________________ | | analyze : (confl : CRef) (out_learnt : vec&) (out_btlevel : int&) -> [void] | | Description: | Analyze conflict and produce a reason clause. | | Pre-conditions: | * 'out_learnt' is assumed to be cleared. | * Current decision level must be greater than root level. | | Post-conditions: | * 'out_learnt[0]' is the asserting literal at level 'out_btlevel'. | | Effect: | Will undo part of the trail, upto but not beyond the assumption of the current decision level. |________________________________________________________________________________________________@*/ void CoreSMTSolver::analyze(CRef confl, vec& out_learnt, int& out_btlevel) { bool logsProofForInterpolation = this->logsProofForInterpolation(); assert(!logsProofForInterpolation || !proof->hasOpenChain()); assert(confl != CRef_Undef); assert(cleanup.size() == 0); // Cleanup stack must be empty assert(std::all_of(seen.begin(), seen.end(), [](char c) { return c == 0; })); // seen must be cleared int pathC = 0; Lit p = lit_Undef; // Generate conflict clause: // out_learnt.push(); // (leave room for the asserting literal) int index = trail.size() - 1; out_btlevel = 0; if (logsProofForInterpolation) { proof->beginChain(confl); } do { assert(confl != CRef_Undef); // (otherwise should be UIP) Clause& c = ca[confl]; if (c.learnt()) { claBumpActivity(c); const uint32_t newGlue = computeGlue(c); if (newGlue < c.getGlue()) c.setGlue(newGlue); } for (unsigned j = (p == lit_Undef) ? 0 : 1; j < c.size(); j++) { Lit q = c[j]; if (!seen[var(q)]) { if (level(var(q)) > 0) { varBumpActivity(var(q)); seen[var(q)] = 1; // Variable propagated at current level if (level(var(q)) >= decisionLevel()) // Increment counter for number of pivot variables left on which to resolve pathC++; else { // Variable propagated at previous level out_learnt.push(q); } } else if (logsProofForInterpolation) { assert(level(var(q)) == 0); assert(reason(var(q)) != CRef_Undef); proof->addResolutionStep(reason(var(q)), var(q)); } } } // Select next clause to look at: while (!seen[var(trail[index--])]) ; // Do nothing assert(index >= 0); p = trail[index+1]; if (reason(var(p)) == CRef_Fake) { // Before retrieving the reason it is necessary to backtrack // a little bit in order to remove every atom pushed after // p has been deduced Var v = var(p); assert(value(p) == l_True); // Backtracking the trail until v is the variable on the top cancelUntilVar( v ); vec r; // Retrieving the reason #ifdef STATISTICS const double start = cpuTime( ); #endif theory_handler.getReason(p, r); assert(r.size() > 0); #ifdef STATISTICS tsolvers_time += cpuTime( ) - start; #endif CRef ctr = CRef_Undef; if ( r.size() > config.sat_learn_up_to_size ) { ctr = ca.alloc(r); cleanup.push(ctr); } else { ctr = config.sat_temporary_learn ? ca.alloc(r, {true, computeGlue(r)}) : ca.alloc(r); learnts.push(ctr); attachClause(ctr); undo_stack.push(undo_stack_el(undo_stack_el::NEWLEARNT, ctr)); claBumpActivity(ca[ctr]); learnt_t_lemmata ++; if ( !config.sat_temporary_learn ) perm_learnt_t_lemmata ++; } assert( ctr != CRef_Undef ); vardata[var(p)].reason = ctr; if (logsProofForInterpolation) { proof->newTheoryClause(ctr); } } confl = reason(var(p)); // RB: If this assertion fails, most of the times // it is because you have recently propagated something // that should have been propagated before the current // decision level. This is possible in SMT as we add // new clauses like crazy in a different way as the // SAT solver normally does. Here an example of failure. // We have the trail // 1:0 // -2:0 // ... // 7:2 // where 7 is the last decision variable, and now // we add the clause ( 8 2 ), which would propagate 8 // ... // 7:2 // 8:2 // however the appropriate propagation level for // 8 is 0. You should always backtrack to the appropriate // level before doing propagations // AH: Do also remember that the first literal of the clause needs to be the implying literal. assert( pathC == 1 || confl != CRef_Undef ); seen[var(p)] = 0; pathC--; // Add resolution step only if this is not the last literal from current level // The last literal is not resolved! It is a part of the learnt clause if (logsProofForInterpolation && pathC > 0) { proof->addResolutionStep(confl, var(p)); } } while (pathC > 0); assert(p != lit_Undef); assert((~p) != lit_Undef); out_learnt[0] = ~p; // Simplify conflict clause: // int i, j; out_learnt.copyTo(analyze_toclear); if (ccmin_mode == 2) { uint32_t abstract_level = 0; for (i = 1; i < out_learnt.size(); i++) abstract_level |= abstractLevel(var(out_learnt[i])); // (maintain an abstraction of levels involved in conflict) for (i = j = 1; i < out_learnt.size(); i++) if (reason(var(out_learnt[i])) == CRef_Undef || !litRedundant(out_learnt[i], abstract_level)) out_learnt[j++] = out_learnt[i]; } else if (ccmin_mode == 1) { // Added line assert( false ); for (i = j = 1; i < out_learnt.size(); i++) { Var x = var(out_learnt[i]); if (reason(x) == CRef_Undef) out_learnt[j++] = out_learnt[i]; else { Clause& c = ca[reason(var(out_learnt[i]))]; for (unsigned k = 1; k < c.size(); k++) if (!seen[var(c[k])] && level(var(c[k])) > 0) { out_learnt[j++] = out_learnt[i]; break; } } } } else i = j = out_learnt.size(); max_literals += out_learnt.size(); out_learnt.shrink(i - j); tot_literals += out_learnt.size(); // Find correct backtrack level: // if (out_learnt.size() == 1) out_btlevel = 0; else { int max_i = 1; // Find the first literal assigned at the next-highest level: for (int i = 2; i < out_learnt.size(); i++) if (level(var(out_learnt[i])) > level(var(out_learnt[max_i]))) max_i = i; // Swap-in this literal at index 1: Lit p = out_learnt[max_i]; out_learnt[max_i] = out_learnt[1]; out_learnt[1] = p; out_btlevel = level(var(p)); } #ifdef REPORT_DL1_THLITS if (out_learnt.size() == 1) { char* ulit = theory_handler.getLogic().printTerm(theory_handler.varToTerm(var(out_learnt[0]))); cerr << "; Found a unit literal " << (sign(out_learnt[0]) ? "not " : "") << ulit << endl; free(ulit); } #endif for (Lit l : analyze_toclear) { seen[var(l)] = 0; } // ('seen[]' is now cleared) assert(std::all_of(seen.begin(), seen.end(), [](char c) { return c == 0; })); // Cleanup generated lemmata if (not logsProofForInterpolation) { for (CRef cref : cleanup) { ca.free(cref); } } cleanup.clear(); // for (int i = 0; i < out_learnt.size(); i++) // printf("%d ", out_learnt[i]); // printf("\n"); } // Check if 'p' can be removed. 'abstract_levels' is used to abort early if the algorithm is // visiting literals at levels that cannot be removed later. bool CoreSMTSolver::litRedundant(Lit p, uint32_t abstract_levels) { // MB: TODO: figure out if this is compatible with proof tracking if (logsProofForInterpolation() || config.sat_minimize_conflicts <= 0 ) return false; analyze_stack.clear(); analyze_stack.push(p); int top = analyze_toclear.size(); while (analyze_stack.size() > 0) { assert(reason(var(analyze_stack.last())) != CRef_Undef); CRef cr = reason(var(analyze_stack.last())); if ((config.sat_minimize_conflicts >= 2) && (cr == CRef_Fake)) { // Before retrieving the reason it is necessary to backtrack // a little bit in order to remove every atom pushed after // p has been deduced Lit p = analyze_stack.last(); Var v = var(p); vec< Lit > r; // Temporairly backtracking cancelUntilVarTempInit( v ); // Retrieving the reason theory_handler.getReason(p, r); // Restoring trail cancelUntilVarTempDone( ); CRef ct = CRef_Undef; if ( r.size( ) > config.sat_learn_up_to_size ) { ct = ca.alloc(r); tmp_reas.push(ct); } else { ct = config.sat_temporary_learn ? ca.alloc(r, {true, computeGlue(r)}) : ca.alloc(r); learnts.push(ct); if (config.isIncremental() != 0) undo_stack.push(undo_stack_el(undo_stack_el::NEWLEARNT, ct)); attachClause(ct); claBumpActivity(ca[ct]); learnt_t_lemmata ++; if ( !config.sat_temporary_learn ) perm_learnt_t_lemmata ++; } vardata[v].reason = ct; } else { assert(config.sat_minimize_conflicts == 1); // Just give up when fake reason is found -- but clean analyze_toclear if (cr == CRef_Fake) { for (int j = top; j < analyze_toclear.size(); j++) seen[var(analyze_toclear[j])] = 0; analyze_toclear.shrink(analyze_toclear.size() - top); return false; } } Clause& c = ca[cr]; analyze_stack.pop(); for (unsigned i = 1; i < c.size(); i++) { Lit p = c[i]; if (!seen[var(p)] && level(var(p)) > 0) { if (reason(var(p)) != CRef_Undef && (abstractLevel(var(p)) & abstract_levels) != 0) { seen[var(p)] = 1; analyze_stack.push(p); analyze_toclear.push(p); } else { for (int j = top; j < analyze_toclear.size(); j++) seen[var(analyze_toclear[j])] = 0; analyze_toclear.shrink(analyze_toclear.size() - top); return false; } } } } return true; } void CoreSMTSolver::finalizeProof(CRef finalConflict) { assert(this->logsProofForInterpolation()); assert(decisionLevel() == 0); assert(finalConflict != CRef_Undef); proof->beginChain(finalConflict); Clause const & c = ca[finalConflict]; for (unsigned j = 0; j < c.size(); ++j) { Var varToResolve = var(c[j]); assert(reason(varToResolve) != CRef_Undef && reason(varToResolve) != CRef_Fake); assert(level(varToResolve) == 0); CRef unitReason = reason(varToResolve); assert(ca[unitReason].size() == 1 && ca[unitReason][0] == ~c[j]); proof->addResolutionStep(unitReason, varToResolve); } proof->endChain(CRef_Undef); } /*_________________________________________________________________________________________________ | | analyzeFinal : (p : Lit) -> [void] | | Description: | Specialized analysis procedure to express the final conflict in terms of assumptions. | Calculates the (possibly empty) set of assumptions that led to the assignment of 'p', and | stores the result in 'out_conflict'. |________________________________________________________________________________________________@*/ void CoreSMTSolver::analyzeFinal(Lit p, vec& out_conflict) { out_conflict.clear(); out_conflict.push(p); seen[var(p)] = 1; if (logsProofForInterpolation()) { CRef assumptionUnitClause = proof->getUnitForAssumptionLiteral(~p); proof->beginChain(assumptionUnitClause); } for (int i = trail.size()-1; i >= 0; i--) { Var x = var(trail[i]); if (seen[x]) { if (reason(x) == CRef_Undef) { if (assumptions_order.has(x)) { out_conflict.push(~trail[i]); if (logsProofForInterpolation()) { assert(level(x) > 0); assert(std::find(assumptions.begin(), assumptions.end(), trail[i]) != assumptions.end()); // Add a resolution step with unit clauses for this assumption CRef assumptionUnitClause = proof->getUnitForAssumptionLiteral(trail[i]); proof->addResolutionStep(assumptionUnitClause, x); } } } else { if (reason(x) == CRef_Fake) { cancelUntilVarTempInit(x); vec r; theory_handler.getReason(trail[i], r); assert(r.size() > 0); assert(r[0] == trail[i]); for (int j = 1; j < r.size(); j++) { seen[var(r[j])] = 1; } cancelUntilVarTempDone(); if (logsProofForInterpolation()) { CRef theoryClause = ca.alloc(r); vardata[x].reason = theoryClause; proof->newTheoryClause(theoryClause); proof->addResolutionStep(theoryClause, x); } } else { Clause& c = ca[reason(x)]; assert(c[0] == trail[i]); for (unsigned j = 1; j < c.size(); j++) { seen[var(c[j])] = 1; } if (logsProofForInterpolation()) { proof->addResolutionStep(reason(x), x); } } } seen[x] = 0; } } assert(seen[var(p)] == 0); seen[var(p)] = 0; if (logsProofForInterpolation()) { // MB: Hopefully we have resolved away all literals including assumptions proof->endChain(CRef_Undef); } } void CoreSMTSolver::uncheckedEnqueue(Lit p, CRef from) { assert(from != CRef_Fake || theory_handler.getLogic().isTheoryTerm(theory_handler.varToTerm(var(p)))); assert(value(p) == l_Undef); assigns[var(p)] = lbool(!sign(p)); vardata[var(p)] = mkVarData(from, decisionLevel()); trail.push(p); } /*_________________________________________________________________________________________________ | | propagate : [void] -> [Clause*] | | Description: | Propagates all enqueued facts. If a conflict arises, the conflicting clause is returned, | otherwise NULL. | | Post-conditions: | * the propagation queue is empty, even if there was a conflict. |________________________________________________________________________________________________@*/ CRef CoreSMTSolver::propagate() { CRef confl = CRef_Undef; int num_props = 0; watches.cleanAll(); while (qhead < trail.size()) { Lit p = trail[qhead++]; // 'p' is enqueued fact to propagate. vec& ws = watches[p]; Watcher *i, *j, *end; num_props++; for (i = j = (Watcher*)ws, end = i + ws.size(); i != end;) { // Try to avoid inspecting the clause: Lit blocker = i->blocker; if (value(blocker) == l_True) { *j++ = *i++; continue; } // Make sure the false literal is data[1]: CRef cr = i->cref; Clause& c = ca[cr]; Lit false_lit = ~p; if (c[0] == false_lit) c[0] = c[1], c[1] = false_lit; assert(c[1] == false_lit); i++; // If 0th watch is true, then clause is already satisfied. Lit first = c[0]; Watcher w = Watcher(cr, first); if (first != blocker && value(first) == l_True) { *j++ = w; continue; } // Look for new watch: for (unsigned k = 2; k < c.size(); k++) if (value(c[k]) != l_False) { c[1] = c[k]; c[k] = false_lit; watches[~c[1]].push(w); goto NextClause; } // Did not find watch *j++ = w; if (value(first) == l_False) // clause is falsified { confl = cr; qhead = trail.size(); // Copy the remaining watches: while (i < end) { *j++ = *i++; } if (decisionLevel() == 0 && this->logsProofForInterpolation()) { this->finalizeProof(confl); } } else { // clause is unit under assignment: if (decisionLevel() == 0 && this->logsProofForInterpolation()) { // MB: we need to log the derivation of the unit clauses at level 0, otherwise the proof // is not constructed correctly proof->beginChain(cr); for (unsigned k = 1; k < c.size(); k++) { assert(level(var(c[k])) == 0); assert(reason(var(c[k])) != CRef_Fake); assert(reason(var(c[k])) != CRef_Undef); proof->addResolutionStep(reason(var(c[k])), var(c[k])); } CRef unitClause = ca.alloc(vec{first}); proof->endChain(unitClause); // Replace the reason for enqueing the literal with the unit clause. // Necessary for correct functioning of proof logging in analyze() cr = unitClause; } uncheckedEnqueue(first, cr); } NextClause: ; } ws.shrink(i - j); } propagations += num_props; simpDB_props -= num_props; return confl; } /*_________________________________________________________________________________________________ | | reduceDB : () -> [void] | | Description: | Remove half of the learnt clauses, minus the clauses locked by the current assignment. Locked | clauses are clauses that are reason to some assignment. Binary clauses are never removed. |________________________________________________________________________________________________@*/ struct reduceDB_lt { ClauseAllocator& ca; reduceDB_lt(ClauseAllocator& ca_) : ca(ca_) {} bool operator () (CRef x, CRef y) { return ca[x].size() > 2 && (ca[y].size() == 2 || ca[x].activity() < ca[y].activity()); } }; void CoreSMTSolver::reduceDB() { int i, j; sort(learnts, reduceDB_lt(ca)); // Don't delete binary or locked clauses. From the rest, delete clauses from the first half // and clauses with high glue score int extra = 0; for (i = j = 0; i < learnts.size(); i++) { Clause& c = ca[learnts[i]]; if (c.getGlue() <= 3) { extra++; } if (c.getGlue() > 3 and not locked(c) and (i+extra < learnts.size() / 2)) { assert(c.size() > 2); removeClause(learnts[i]); } else { learnts[j++] = learnts[i]; } } learnts.shrink(i - j); checkGarbage(); if (logsProofForInterpolation()) { // Remove unused leaves // FIXME deal with theory lemmata when proofs will be extended to theories for (i = j = 0; i < pleaves.size(); i++) { CRef cr = pleaves[i]; assert(ca[cr].mark() == 1); if (!proof->deleted(cr)) pleaves[j++] = pleaves[i]; } pleaves.shrink(i - j); } } void CoreSMTSolver::removeSatisfied(vec& cs) { int i,j; for (i = j = 0; i < cs.size(); i++) { Clause& c = ca[cs[i]]; if (satisfied(c)) removeClause(cs[i]); else cs[j++] = cs[i]; } cs.shrink(i - j); } void CoreSMTSolver::rebuildOrderHeap() { vec vs; for (Var v = 0; v < nVars(); v++) if (decision[v] && value(v) == l_Undef) vs.push(v); order_heap.build(vs); } /*_________________________________________________________________________________________________ | | simplify : [void] -> [bool] | | Description: | Simplify the clause database according to the current top-level assigment. Currently, the only | thing done here is the removal of satisfied clauses, but more things can be put here. |________________________________________________________________________________________________@*/ bool CoreSMTSolver::simplify() { assert(decisionLevel() == 0); if (!ok || propagate() != CRef_Undef) return ok = false; if (nAssigns() == simpDB_assigns || (simpDB_props > 0)) return true; // Remove satisfied clauses: removeSatisfied(learnts); // removeSatisfied(axioms); if (remove_satisfied) // Can be turned off. removeSatisfied(clauses); checkGarbage(); // rebuildOrderHeap(); order_heap.filter(VarFilter(*this)); simpDB_assigns = nAssigns(); simpDB_props = clauses_literals + learnts_literals; // (shouldn't depend on stats really, but it will do for now) return true; } void CoreSMTSolver::pushBacktrackPoint() { assert( config.isIncremental() ); // // Save undo stack size // undo_stack_size.push(undo_stack.size( )); undo_trail_size.push(trail.size( )); } void CoreSMTSolver::popBacktrackPoint() { assert( config.isIncremental() ); // // Force restart, but retain assumptions // cancelUntil(0); // // Shrink back trail // int new_trail_size = undo_trail_size.last(); undo_trail_size.pop(); for ( int i = trail.size( ) - 1 ; i >= new_trail_size ; i -- ) { Var x = var(trail[i]); assigns[x] = l_Undef; vardata[x].reason = CRef_Undef; insertVarOrder(x); } trail.shrink(trail.size( ) - new_trail_size); assert( trail_lim.size( ) == 0 ); qhead = trail.size( ); // // Undo operations // size_t new_stack_size = undo_stack_size.last(); undo_stack_size.pop(); while (static_cast(undo_stack.size()) > new_stack_size ) { const undo_stack_el op = undo_stack.last(); if (op.getType() == undo_stack_el::NEWVAR) { const Var x = op.getVar(); // Undoes insertVarOrder( ) assert( order_heap.inHeap(x) ); order_heap .remove(x); // Undoes decision_var ... watches decision .pop(); seen .pop(); activity .pop(); vardata .pop(); assigns .pop(); watches.clean(mkLit(x, true)); watches.clean(mkLit(x, false)); // Remove variable from translation tables // theory_handler->clearVar( x ); } else if (op.getType() == undo_stack_el::NEWUNIT) ; // Do nothing else if (op.getType() == undo_stack_el::NEWCLAUSE) { CRef cr = op.getClause(); assert( clauses.last() == cr ); clauses.pop(); removeClause(cr); } else if (op.getType() == undo_stack_el::NEWLEARNT) { CRef cr = op.getClause(); detachClause(cr); } else { throw OsmtInternalException("unknown undo operation in CoreSMTSolver" + std::to_string(op.getType())); } undo_stack.pop(); } // // Clear all learnts // while( learnts.size( ) > 0 ) { CRef cr = learnts.last(); learnts.pop( ); removeClause(cr); } assert( learnts.size( ) == 0 ); // Backtrack theory solvers theory_handler.backtrack(trail.size()); // Restore OK restoreOK( ); assert( isOK( ) ); } bool CoreSMTSolver::okContinue() const { return not opensmt::stop; } void CoreSMTSolver::learntSizeAdjust() { if (--learntsize_adjust_cnt == 0) { learntsize_adjust_confl *= learntsize_adjust_inc; learntsize_adjust_cnt = (int) learntsize_adjust_confl; max_learnts *= learntsize_inc; if (verbosity >= 1) fprintf(stderr, ";| %9d | %7d %8d %8d | %8d %8d %6.0f | %6.3f %% |\n", (int) conflicts, (int) dec_vars - (trail_lim.size() == 0 ? trail.size() : trail_lim[0]), nClauses(), (int) clauses_literals, (int) max_learnts, nLearnts(), (double) learnts_literals / nLearnts(), progressEstimate() * 100); } } /*_________________________________________________________________________________________________ | | search : (nof_conflicts : int) (nof_learnts : int) (params : const SearchParams&) -> [lbool] | | Description: | Search for a model the specified number of conflicts, keeping the number of learnt clauses | below the provided limit. NOTE! Use negative value for 'nof_conflicts' or 'nof_learnts' to | indicate infinity. | | Output: | 'l_True' if a partial assigment that is consistent with respect to the clauseset is found. If | all variables are decision variables, this means that the clause set is satisfiable. 'l_False' | if the clause set is unsatisfiable. 'l_Undef' if the bound on number of conflicts is reached. |________________________________________________________________________________________________@*/ lbool CoreSMTSolver::search(int nof_conflicts) { // Time my executionto search_timer // opensmt::StopWatch stopwatch = opensmt::StopWatch(search_timer); #ifdef VERBOSE_SAT cerr << "Units when starting search:" << endl; for (int i = 2; i < trail.size(); i++) { char* name; theory_handler.getVarName(var(trail[i]), &name); cerr << (sign(trail[i]) ? "not " : ""); cerr << name << endl; ::free(name); } #endif assert(ok); int backtrack_level; int conflictC = 0; vec learnt_clause; starts++; #ifdef STATISTICS const double start = cpuTime( ); #endif // (Incomplete) Check of Level-0 atoms TPropRes res = checkTheory(false, conflictC); if ( res == TPropRes::Unsat) { return zeroLevelConflictHandler(); } assert( res == TPropRes::Decide || res == TPropRes::Propagate ); // Either good for decision (from TSolver's perspective) or propagate #ifdef STATISTICS tsolvers_time += cpuTime( ) - start; #endif // // Decrease activity for booleans // // boolVarDecActivity( ); #ifdef PEDANTIC_DEBUG bool thr_backtrack = false; #endif while (okContinue()) { search_counter++; CRef confl = propagate(); runPeriodic(); if (confl != CRef_Undef) { if (conflicts > conflictsUntilFlip) { flipState = not flipState; conflictsUntilFlip += flipState ? flipIncrement / 10 : flipIncrement; } // CONFLICT if (verbosity and conflicts % 1000 == 999) { uint64_t units = trail_lim.size() == 0 ? trail.size() : trail_lim[0]; std::cout << "; conflicts: " << std::setw(5) << std::round(conflicts/1000.0) << "k" << " learnts: " << std::setw(5) << std::round(learnts.size()/1000.0) << "k" << " clauses: " << std::setw(5) << std::round(clauses.size()/1000.0) << "k" << " units: " << std::setw(5) << units << std::endl; } conflicts++; conflictC++; if (decisionLevel() == 0) { return zeroLevelConflictHandler(); } learnt_clause.clear(); analyze(confl, learnt_clause, backtrack_level); cancelUntil(backtrack_level); assert(value(learnt_clause[0]) == l_Undef); if (learnt_clause.size() == 1) { CRef reason = CRef_Undef; if (logsProofForInterpolation()) { CRef cr = ca.alloc(learnt_clause); proof->endChain(cr); reason = cr; } uncheckedEnqueue(learnt_clause[0], reason); } else { // ADDED FOR NEW MINIMIZATION learnts_size += learnt_clause.size( ); all_learnts ++; CRef cr = ca.alloc(learnt_clause, {true, computeGlue(learnt_clause)}); if (logsProofForInterpolation()) { proof->endChain(cr); } learnts.push(cr); attachClause(cr); claBumpActivity(ca[cr]); uncheckedEnqueue(learnt_clause[0], cr); } varDecayActivity(); claDecayActivity(); learntSizeAdjust(); } else { // NO CONFLICT if ((nof_conflicts >= 0 && conflictC >= nof_conflicts) || !withinBudget()) { // Reached bound on number of conflicts: progress_estimate = progressEstimate(); cancelUntil(0); return l_Undef; } // Simplify the set of problem clauses: if (decisionLevel() == 0 && !simplify()) { return zeroLevelConflictHandler(); } // Two ways of reducing the clause. The latter one seems to be working // better (not running proper tests since the cluster is down...) // if ((learnts.size()-nAssigns()) >= max_learnts) if (nof_learnts >= 0 and learnts.size() >= nof_learnts) { // Reduce the set of learnt clauses: reduceDB(); nof_learnts *= nofLearntsIncrement; } // Early Pruning Call // Step 1: check if the current assignment is theory-consistent switch (checkTheory(false, conflictC)) { case TPropRes::Unsat: return zeroLevelConflictHandler(); case TPropRes::Propagate: continue; // Theory conflict: time for bcp case TPropRes::Decide: break; // Sat and no deductions: go ahead default: assert( false ); } Lit next = lit_Undef; while (decisionLevel() < assumptions.size()) { // Perform user provided assumption: Lit p = assumptions[decisionLevel()]; if (value(p) == l_True) { // Dummy decision level: newDecisionLevel(); } else if (value(p) == l_False) { analyzeFinal(~p, conflict); int max = 0; for (Lit q : conflict) { if (!sign(q)) { max = assumptions_order[var(q)] > max ? assumptions_order[var(q)] : max; } } conflict_frame = max+1; return zeroLevelConflictHandler(); } else { next = p; break; } } if (next == lit_Undef) { switch (notifyConsistency()) { case ConsistencyAction::BacktrackToZero: cancelUntil(0); break; case ConsistencyAction::ReturnUndef: return l_Undef; case ConsistencyAction::SkipToSearchBegin: continue; case ConsistencyAction::NoOp: default: ; } // Assumptions done and the solver is in consistent state // New variable decision: decisions++; next = pickBranchLit(); // Complete Call if ( next == lit_Undef ) { TPropRes res = checkTheory(true, conflictC); if ( res == TPropRes::Propagate ) { continue; } if ( res == TPropRes::Unsat ) { return zeroLevelConflictHandler(); } assert( res == TPropRes::Decide ); // Otherwise we still have to make sure that // splitting on demand did not add any new variable decisions++; next = pickBranchLit(); } if (next == lit_Undef) // Model found: return l_True; } assert(value(next) == l_Undef); // Increase decision level and enqueue 'next' assert(value(next) == l_Undef); newDecisionLevel(); uncheckedEnqueue(next); } } cancelUntil(0); notifyEnd(); return l_Undef; } double CoreSMTSolver::progressEstimate() const { double progress = 0; double F = 1.0 / nVars(); for (int i = 0; i <= decisionLevel(); i++) { int beg = i == 0 ? 0 : trail_lim[i - 1]; int end = i == decisionLevel() ? trail.size() : trail_lim[i]; progress += pow(F, i) * (end - beg); } return progress / nVars(); } /* Finite subsequences of the Luby-sequence: 0: 1 1: 1 1 2 2: 1 1 2 1 1 2 4 3: 1 1 2 1 1 2 4 1 1 2 1 1 2 4 8 ... static double luby(double y, int x) { // Find the finite subsequence that contains index 'x', and the // size of that subsequence: int size, seq; for (size = 1, seq = 0; size < x+1; seq++, size = 2*size+1); while (size-1 != x) { size = (size-1)>>1; seq--; x = x % size; } return pow(y, seq); } */ void CoreSMTSolver::declareVarsToTheories() { // First empty the solver theory_handler.clear(); for (int i = 0; i < var_seen.size(); i++) var_seen[i] = false; for (int i = 0; i < trail.size(); i++) { Var v = var(trail[i]); if (!var_seen[v]) { var_seen[v] = true; const Logic & logic = theory_handler.getLogic(); const PTRef term = theory_handler.varToTerm(v); if (logic.isTheoryTerm(term)) { theory_handler.declareAtom(term); } } } const Logic & logic = theory_handler.getLogic(); top_level_lits = trail.size(); for (int i = 0; i < clauses.size(); i++) { Clause & c = ca[clauses[i]]; for (unsigned j = 0; j < c.size(); j++) { Var v = var(c[j]); if (!var_seen[v]) { var_seen[v] = true; assert(theory_handler.ptrefToVar(theory_handler.varToTerm(v)) == v); const PTRef term = theory_handler.varToTerm(v); if (logic.isTheoryTerm(term)) { theory_handler.declareAtom(term); } } } } for (Var v = 0; v < var_seen.size(); v++) { if (not var_seen[v]) { PTRef atom = theory_handler.varToTerm(v); bool appearsInUf = logic.appearsInUF(atom); if (appearsInUf) { theory_handler.declareAtom(atom); } else { setDecisionVar(v, false); } } } } lbool CoreSMTSolver::solve_() { // opensmt::PrintStopWatch watch("solve time", cerr); for (Lit l : this->assumptions) { this->addVar_(var(l)); } // Inform theories of the variables that are actually seen by the // SAT solver. declareVarsToTheories(); if (config.dump_only()) return l_Undef; random_seed = config.getRandomSeed(); if (config.sat_dump_cnf != 0) { dumpCNF(); } model.clear(); conflict.clear(); if (!ok) return l_False; solves++; double nof_conflicts = restart_first; max_learnts = nClauses() * learntsize_factor; learntsize_adjust_confl = learntsize_adjust_start_confl; learntsize_adjust_cnt = (int)learntsize_adjust_confl; lbool status = l_Undef; if (verbosity >= 1) { fprintf(stderr, "; ============================[ Search Statistics ]==============================\n"); fprintf(stderr, "; | Conflicts | ORIGINAL | LEARNT | Progress |\n"); fprintf(stderr, "; | | Vars Clauses Literals | Limit Clauses Lit/Cl | |\n"); fprintf(stderr, "; ===============================================================================\n"); } double next_printout = restart_first; // Search: if (config.dryrun()) stop = true; while (status == l_Undef && okContinue() && !this->stop) { // Print some information. At every restart for // standard mode or any 2^n intervarls for luby // restarts if (conflicts == 0 || conflicts >= next_printout) { if (config.verbosity() > 0) { reportf("; %9d | %8d %8d | %8.3f s | %6.3f MB\n", (int) conflicts, (int) learnts.size(), nLearnts(), cpuTime(), memUsed() / 1048576.0); fflush(stderr); } } if (config.sat_use_luby_restart) { next_printout *= 2; } else { next_printout *= restart_inc; } // XXX status = search((int)nof_conflicts); nof_conflicts = restartNextLimit(nof_conflicts); } if (status == l_True) { // Extend & copy model: model.growTo(nVars()); for (int i = 0; i < nVars(); i++) { model[i] = value(i); } } else { assert(not okContinue() || status == l_False || this->stop); } // We terminate return status; } void CoreSMTSolver::clearSearch() { cancelUntil(0); // if (first_model_found || splits.size() > 1) { theory_handler.backtrack(-1); // } } lbool CoreSMTSolver::zeroLevelConflictHandler() { ok = false; return l_False; } //================================================================================================= // Garbage Collection methods: void CoreSMTSolver::relocAll(ClauseAllocator& to) { // All watchers: // // for (int i = 0; i < watches.size(); i++) watches.cleanAll(); for (int v = 0; v < nVars(); v++) for (int s = 0; s < 2; s++) { Lit p = mkLit(v, s); // printf(" >>> RELOCING: %s%d\n", sign(p) ? "-" : "", var(p)+1); vec& ws = watches[p]; for (int j = 0; j < ws.size(); j++) ca.reloc(ws[j].cref, to); } // All reasons: // for (int i = 0; i < trail.size(); i++) { Var v = var(trail[i]); if (reason(v) != CRef_Undef && reason(v) != CRef_Fake && (ca[reason(v)].reloced() || locked(ca[reason(v)]))) ca.reloc(vardata[v].reason, to); } // All learnt: // for (int i = 0; i < learnts.size(); i++) ca.reloc(learnts[i], to); // All original: // for (int i = 0; i < clauses.size(); i++) ca.reloc(clauses[i], to); } void CoreSMTSolver::garbageCollect() { // Initialize the next region to a size corresponding to the estimated utilization degree. This // is not precise but should avoid some unnecessary reallocations for the new region: ClauseAllocator to(ca.size() - ca.wasted()); relocAll(to); // if (verbosity >= 2) // fprintf(stderr, "; | Garbage collection: %12d bytes => %12d bytes |\n", // ca.size()*ClauseAllocator::Unit_Size, to.size()*ClauseAllocator::Unit_Size); to.moveTo(ca); } void CoreSMTSolver::setAssumptions(vec const & assumps) { assumptions.clear(); assumptions_order.clear(); assumps.copyTo(assumptions); int active_assumptions = 0; for (int i = 0; i < assumptions.size(); i++) { if (sign(assumptions[i])) { assumptions_order.insert(var(assumps[i]), active_assumptions++); } } if(proof) { proof->setCurrentAssumptionLiterals(&assumps[0], &assumps[0] + assumps.size()); } } int CoreSMTSolver::restartNextLimit ( int nof_conflicts ) { // Luby's restart if ( config.sat_use_luby_restart ) { if ( ++luby_i == (unsigned) ((1 << luby_k) - 1)) luby_previous.push_back( 1 << ( luby_k ++ - 1) ); else luby_previous.push_back( luby_previous[luby_i - (1 << (luby_k - 1))]); return luby_previous.back() * lubyFactor; } // Standard restart return nof_conflicts * restart_inc; } #ifdef STATISTICS void CoreSMTSolver::printStatistics( ostream & os ) { os << "; -------------------------" << endl; os << "; STATISTICS FOR SAT SOLVER" << endl; os << "; -------------------------" << endl; os << "; Restarts.................: " << starts << endl; os << "; Conflicts................: " << conflicts << endl; os << "; Decisions................: " << (float)decisions << endl; os << "; Propagations.............: " << propagations << endl; os << "; Conflict literals........: " << tot_literals << endl; os << "; T-Lemmata learnt.........: " << learnt_t_lemmata << endl; os << "; T-Lemmata perm learnt....: " << perm_learnt_t_lemmata << endl; os << "; Conflicts learnt.........: " << conflicts << endl; os << "; T-conflicts learnt.......: " << learnt_theory_conflicts << endl; os << "; Average learnts size.....: " << learnts_size/conflicts << endl; os << "; Top level literals.......: " << top_level_lits << endl; os << "; Search time..............: " << search_timer.getTime() << " s" << endl; if ( config.sat_preprocess_booleans != 0 || config.sat_preprocess_theory != 0 ) os << "; Preprocessing time.......: " << preproc_time << " s" << endl; if ( config.sat_preprocess_theory != 0 ) os << "; T-Vars eliminated........: " << elim_tvars << " out of " << total_tvars << endl; os << "; TSolvers time............: " << tsolvers_time << " s" << endl; // if ( config.sat_lazy_dtc != 0 ) // os << "# Interf. equalities.......: " << ie_generated << " out of " << egraph.getInterfaceTermsNumber( ) * (egraph.getInterfaceTermsNumber( )-1) / 2 << endl; os << "; Init clauses.............: " << clauses.size() << endl; os << "; Variables................: " << nVars() << endl; if (config.sat_split_type() != spt_none) os << "; Ill-adviced splits.......: " << unadvised_splits << endl; } #endif // STATISTICS std::ostream& operator <<(std::ostream& out, Lit l) { out << (sign(l) ? "-" : "") << var(l); return out; } void CoreSMTSolver::fillBooleanVars(ModelBuilder &modelBuilder) { Logic& logic = theory_handler.getLogic(); for (Var v = 0; v < model.size(); ++v) { assert(v != var_Undef); PTRef atom = theory_handler.varToTerm(v); PTRef val; assert(atom != PTRef_Undef); assert(not logic.isNot(atom)); if (model[v] != l_Undef) { val = model[v] == l_True ? logic.getTerm_true() : logic.getTerm_false(); } else { // var is unassigned: use the default value val = logic.getDefaultValuePTRef(logic.getSort_bool()); } modelBuilder.addVarValue(atom, val); } } opensmt-2.5.2/src/smtsolvers/CoreSMTSolver.h000066400000000000000000001162361445011647600210560ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2016 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ /****************************************************************************************[Solver.C] MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson 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. **************************************************************************************************/ #ifndef MINISATSMTSOLVER_H #define MINISATSMTSOLVER_H #include "THandler.h" #include #include #include #include #include #include "Vec.h" #include "Heap.h" #include "Alg.h" #include "SolverTypes.h" #include "Timer.h" class Proof; class ModelBuilder; // Helper method to print Literal to a stream std::ostream& operator <<(std::ostream& out, Lit l); // MB: Feel free to find a better place for this method. template struct Pair { A first; B second; }; //================================================================================================= // Solver -- the main class: class CoreSMTSolver { friend class LookaheadScoreClassic; friend class LookaheadScoreDeep; protected: SMTConfig & config; // Stores Config THandler & theory_handler; // Handles theory bool verbosity; bool init; enum class ConsistencyAction { BacktrackToZero, ReturnUndef, SkipToSearchBegin, NoOp }; int search_counter; public: bool stop = false; // Constructor/Destructor: // CoreSMTSolver(SMTConfig&, THandler&); virtual ~CoreSMTSolver(); void initialize ( ); void clearSearch (); // Backtrack SAT solver and theories to decision level 0 // Problem specification: // protected: void addVar_ (Var v); // Ensure that var v exists in the solver virtual Var newVar(bool dvar); // Add a new variable with parameters specifying variable mode. public: void addVar(Var v); // Anounce the existence of a variable to the solver bool addOriginalClause(const vec & ps); bool addEmptyClause(); // Add the empty clause, making the solver contradictory. bool addOriginalClause(Lit p); // Add a unit clause to the solver. bool addOriginalClause(Lit p, Lit q); // Add a binary clause to the solver. bool addOriginalClause(Lit p, Lit q, Lit r); // Add a ternary clause to the solver. protected: bool addOriginalClause_(const vec & _ps); // Add a clause to the solver bool addOriginalClause_(const vec & _ps, opensmt::pair & inOutCRefs); // Add a clause to the solver without making superflous internal copy. Will change the passed vector 'ps'. Write the new clause to cr public: // Solving: // bool simplify (); // Removes already satisfied clauses. void declareVarsToTheories(); // Declare the seen variables to the theories bool solve ( const vec< Lit > & assumps ); // Search for a model that respects a given set of assumptions. void crashTest (int, Var, Var); // Stress test the theory solver void toDimacs (FILE* f, const vec& assumps); // Write CNF to file in DIMACS-format. void toDimacs (const char *file, const vec& assumps); void toDimacs (FILE* f, Clause& c, vec& map, Var& max); // Convenience versions of 'toDimacs()': void toDimacs (const char* file); void toDimacs (const char* file, Lit p); void toDimacs (const char* file, Lit p, Lit q); void toDimacs (const char* file, Lit p, Lit q, Lit r); // Variable mode: // void setDecisionVar (Var v, bool b); // Declare if a variable should be eligible for selection in the decision heuristic. // Read state: // lbool value (Var x) const; // The current value of a variable. lbool value (Lit p) const; // The current value of a literal. lbool safeValue (Var x) const; // The current value of a variable. l_Undef if the variable does not exist. lbool safeValue (Lit p) const; // The current value of a literal. l_Undef if the literal does not exist. lbool modelValue (Lit p) const; // The value of a literal in the last model. The last call to solve must have been satisfiable. int nAssigns () const; // The current number of assigned literals. int nClauses () const; // The current number of original clauses. int nLearnts () const; // The current number of learnt clauses. int nVars () const; // The current number of variables. int nFreeVars () const; void fillBooleanVars(ModelBuilder & modelBuilder); Proof const & getProof() const { assert(proof); return *proof; } // Resource contraints: // void setConfBudget(int64_t x); void setPropBudget(int64_t x); void budgetOff(); void interrupt(); // Trigger a (potentially asynchronous) interruption of the solver. void clearInterrupt(); // Clear interrupt indicator flag. // Memory management: // virtual void garbageCollect(); void checkGarbage(double gf); void checkGarbage(); // External support incremental and backtrackable APIs // MB: This is used (and needed) by BitBlaster; can be removed if BitBlaster is re-worked void pushBacktrackPoint ( ); void popBacktrackPoint ( ); void reset ( ); inline void restoreOK ( ) { ok = true; conflict_frame = 0; } inline bool isOK ( ) const { return ok; } // FALSE means solver is in a conflicting state inline int getConflictFrame ( ) const { assert(not isOK()); return conflict_frame; } template void printSMTClause (std::ostream &, const C& ); void printSMTClause (std::ostream &, vec< Lit > &, bool = false ); void printSMTClause (std::ostream &, std::vector &, bool = false ); // Added Code //================================================================================================= // Extra results: (read-only member variable) // vec model; // If problem is satisfiable, this vector contains the model (if any). (moded to SMTSolver) vec conflict; // If problem is unsatisfiable (possibly under assumptions), // this vector represent the final conflict clause expressed in the assumptions. // Mode of operation: // double var_decay; // Inverse of the variable activity decay factor. (default 1 / 0.95) double clause_decay; // Inverse of the clause activity decay factor. (1 / 0.999) double random_var_freq; // The frequency with which the decision heuristic tries to choose a random variable. (default 0.02) bool luby_restart; int ccmin_mode; // Controls conflict clause minimization (0=none, 1=basic, 2=deep). int phase_saving; // Controls the level of phase saving (0=none, 1=limited, 2=full). bool rnd_pol; // Use random polarities for branching heuristics. bool rnd_init_act; // Initialize variable activities with a small random value. double garbage_frac; // The fraction of wasted memory allowed before a garbage collection is triggered. int restart_first; // The initial restart limit. (default 100) double restart_inc; // The factor with which the restart limit is multiplied in each restart. (default 1.1) double learntsize_factor; // The intitial limit for learnt clauses is a factor of the original clauses. (default 1 / 3) double learntsize_inc; // The limit for learnt clauses is multiplied with this factor each restart. (default 1.1) bool expensive_ccmin; // Controls conflict clause minimization. (default TRUE) int learntsize_adjust_start_confl; double learntsize_adjust_inc; // Statistics: (read-only member variable) // uint64_t solves, starts, decisions, rnd_decisions, propagations, conflicts, conflicts_last_update; uint64_t dec_vars, clauses_literals, learnts_literals, max_literals, tot_literals; #ifdef STATISTICS opensmt::OSMTTimeVal search_timer; opensmt::OSMTTimeVal branchTimer; #endif double learnts_size; uint64_t all_learnts; uint64_t learnt_theory_conflicts; uint64_t top_level_lits; protected: int processed_in_frozen; // The index in Theory's frozen vec until which frozennes has been processed // Helper structures: // static inline VarData mkVarData(CRef cr, int l) { VarData d = {cr, l}; return d; } void virtual setAssumptions(vec const& assumps); struct Watcher { CRef cref; Lit blocker; Watcher(CRef cr, Lit p) : cref(cr), blocker(p) {} //================================================================================================= // Added Code Watcher() : cref(CRef_Undef), blocker(lit_Undef) {} // Added Code //================================================================================================= bool operator==(const Watcher& w) const { return cref == w.cref; } bool operator!=(const Watcher& w) const { return cref != w.cref; } }; //================================================================================================= // Added Code // struct watcher_lt // { // const ClauseAllocator& ca; // watcher_lt(const ClauseAllocator& ca_) : ca(ca_) {} // bool operator () (const Watcher& x, const Watcher& y) // { // return ca[x.cref].size() < ca[y.cref].size(); // } // }; // Added Code //================================================================================================= struct WatcherDeleted { const ClauseAllocator& ca; WatcherDeleted(const ClauseAllocator& _ca) : ca(_ca) {} bool operator()(const Watcher& w) const { return ca[w.cref].mark() == 1; } }; struct VarOrderLt { const vec& activity; bool operator () (Var x, Var y) const { return activity[x] > activity[y]; } VarOrderLt(const vec& act) : activity(act) { } }; friend class VarFilter; struct VarFilter { const CoreSMTSolver& s; VarFilter(const CoreSMTSolver& _s) : s(_s) {} bool operator()(Var v) const { return s.assigns[v] == l_Undef && s.decision[v]; } }; // Solver state: // bool ok; // If FALSE, the constraints are already unsatisfiable. No part of the solver state may be used! int conflict_frame; // Contains the frame (the assumption literal index+1) where conflict was detected. (Default is 0) uint32_t n_clauses; // number of clauses in the problem vec clauses; // List of problem clauses. vec learnts; // List of learnt clauses. vec tmp_reas; // Reasons for minimize_conflicts 2 #ifdef PEDANTIC_DEBUG vec debug_reasons; // Reasons for the theory deduced clauses Map debug_reason_map; // Maps the deduced lit to the clause used to deduce it #endif double cla_inc; // Amount to bump next clause with. vec activity; // A heuristic measurement of the activity of a variable. double var_inc; // Amount to bump next variable with. OccLists, WatcherDeleted> watches; // 'watches[lit]' is a list of constraints watching 'lit' (will go there if literal becomes true). vec assigns; // The current assignments (lbool:s stored as char:s). vec savedPolarity; int longestTrail = 0; uint64_t conflictsUntilFlip = 0; uint64_t flipIncrement = 10000; bool flipState = false; vec var_seen; vec decision; // Declares if a variable is eligible for selection in the decision heuristic. protected: #ifdef PEDANTIC_DEBUG public: vec trail; // Assignment stack; stores all assigments made in the order they were made. protected: #else vec trail; // Assignment stack; stores all assigments made in the order they were made. #endif vec trail_lim; // Separator indices for different decision levels in 'trail'. vec vardata; // Stores reason and level for each variable. int qhead; // Head of queue (as index into the trail -- no more explicit propagation queue in MiniSat). int simpDB_assigns; // Number of top-level assignments since last execution of 'simplify()'. int64_t simpDB_props; // Remaining number of propagations that must be made before next execution of 'simplify()'. vec assumptions; // Current set of assumptions provided to solve by the user. Map assumptions_order; // Defined for active assumption variables: how manyeth active assumption variable this is in assumptions Heap order_heap; // A priority queue of variables ordered with respect to the variable activity. double random_seed; // Used by the random variable selection. double progress_estimate;// Set by 'search()'. bool remove_satisfied; // Indicates whether possibly inefficient linear scan for satisfied clauses should be performed in 'simplify'. ClauseAllocator ca{512*1024}; // Temporaries (to reduce allocation overhead). Each variable is prefixed by the method in which it is // used, exept 'seen' wich is used in several places. // vec seen; vec analyze_stack; vec analyze_toclear; vec add_tmp; double max_learnts; double learntsize_adjust_confl; int learntsize_adjust_cnt; int unadvised_splits; // How many times the split happened on a PTRef that the logic considers ill-advised // Resource contraints: // int64_t conflict_budget; // -1 means no budget. int64_t propagation_budget; // -1 means no budget. bool asynch_interrupt; // Main internal methods: // virtual lbool solve_ (); // Main solve method (assumptions given in 'assumptions'). void insertVarOrder (Var x); // Insert a variable in the decision order priority queue. Var doRandomDecision(); Lit choosePolarity(Var next); virtual Var doActivityDecision(); virtual bool branchLitRandom(); virtual Lit pickBranchLit (); // Return the next decision variable. virtual void newDecisionLevel (); // Begins a new decision level. void uncheckedEnqueue (Lit p, CRef from = CRef_Undef); // Enqueue a literal. Assumes value of literal is undefined. bool enqueue (Lit p, CRef from = CRef_Undef); // Test if fact 'p' contradicts current state, enqueue otherwise. CRef propagate (); // Perform unit propagation. Returns possibly conflicting clause. virtual void cancelUntil (int level); // Backtrack until a certain level. void analyze (CRef confl, vec& out_learnt, int& out_btlevel); // (bt = backtrack) template uint32_t computeGlue(T const & ps); nat_set levelsInClause; void analyzeFinal (Lit p, vec& out_conflict); // COULD THIS BE IMPLEMENTED BY THE ORDINARIY "analyze" BY SOME REASONABLE GENERALIZATION? bool litRedundant (Lit p, uint32_t abstract_levels); // (helper method for 'analyze()') lbool search (int nof_conflicts); // Search for a given number of conflicts. int nof_learnts = 40000; double nofLearntsIncrement = 1.1; virtual bool okContinue () const; // Check search termination conditions virtual ConsistencyAction notifyConsistency() { return ConsistencyAction::NoOp; } // Called when the search has reached a consistent point virtual void notifyEnd() { } // Called at the end of the search loop void learntSizeAdjust (); // Adjust learnts size and print something void reduceDB (); // Reduce the set of learnt clauses. void removeSatisfied (vec& cs); // Shrink 'cs' to contain only non-satisfied clauses. void rebuildOrderHeap (); virtual lbool zeroLevelConflictHandler(); // Common handling of zero-level conflict as it can happen at multiple places // Maintaining Variable/Clause activity: // void varDecayActivity (); // Decay all variables with the specified factor. Implemented by increasing the 'bump' value instead. void varBumpActivity (Var v, double inc); // Increase a variable with the current 'bump' value. void varBumpActivity (Var v); // Increase a variable with the current 'bump' value. // Added Line // void boolVarDecActivity( ); // Decrease boolean atoms activity void claDecayActivity ( ); // Decay all clauses with the specified factor. Implemented by increasing the 'bump' value instead. void claBumpActivity ( Clause & c ); // Increase a clause with the current 'bump' value. // Increase a clause with the current 'bump' value. // Operations on clauses: // virtual void attachClause (CRef cr); // Attach a clause to watcher lists. virtual void detachClause (CRef cr, bool strict = false); // Detach a clause to watcher lists. void removeClause (CRef c); // Detach and free a clause. bool locked (const Clause& c) const; // Returns TRUE if a clause is a reason for some implication in the current state. bool satisfied (const Clause& c) const; // Returns TRUE if a clause is satisfied in the current state. void relocAll (ClauseAllocator& to); virtual void runPeriodic () { return; } // Run periodically and delegates clause exposing operation to parallel-splitters. // Misc: // int decisionLevel () const; // Gives the current decisionlevel. uint32_t abstractLevel (Var x) const; // Used to represent an abstraction of sets of decision levels. CRef reason (Var x) const; int level (Var x) const; double progressEstimate () const; // DELETE THIS ?? IT'S NOT VERY USEFUL ... bool withinBudget () const; void printSMTLit (std::ostream &, const Lit); virtual void verifyModel (); void checkLiteralCount(); //ADDED FOR MINIMIZATION void printClause ( vec< Lit > & ); public: void printLit (Lit l) const; template void printClause (const C& c); void printClause ( CRef ); void printClause ( Clause& ); //void printClause ( vec< Lit > & ); void populateClauses (vec & clauses, const vec & crefs, unsigned int limit = std::numeric_limits::max()); void populateClauses (vec & clauses, const vec & lits); std::string printCnfClauses (); std::string printCnfLearnts (); void printProofSMT2 (std::ostream &); // Print proof protected: #ifdef STATISTICS void printStatistics ( ostream & ); // Prints statistics #endif void printTrail ( ); // Prints the trail (debugging) TPropRes checkTheory (bool, int&); // Checks consistency in theory. The second arg is conflictC TPropRes checkTheory (bool complete) { int tmp; return checkTheory(complete, tmp); } TPropRes handleSat (); // Theory check resulted in sat TPropRes handleUnsat (); // Theory check resulted in unsat void deduceTheory (vec&); // Perform theory-deductions void cancelUntilVar ( Var ); // Backtrack until a certain variable void cancelUntilVarTempInit ( Var ); // Backtrack until a certain variable void cancelUntilVarTempDone ( ); // Backtrack until a certain variable int restartNextLimit ( int ); // Next conflict limit for restart void dumpCNF ( ); // Dumps CNF to cnf.smt2 vec cleanup; // For cleaning up // bool first_model_found; // True if we found a first boolean model double skip_step; // Steps to skip in calling tsolvers long skipped_calls; // Calls skipped so far long learnt_t_lemmata; // T-Lemmata stored during search long perm_learnt_t_lemmata; // T-Lemmata stored during search unsigned luby_i; // Keep track of luby index unsigned luby_k; // Keep track of luby k std::vector luby_previous; // Previously computed luby numbers unsigned lubyFactor = 120; bool cuvti; // For cancelUntilVarTemp vec lit_to_restore; // For cancelUntilVarTemp vec val_to_restore; // For cancelUntilVarTemp // // Proof production // bool logsProofForInterpolation() const { return static_cast(proof); } void finalizeProof(CRef finalConflict); std::unique_ptr proof; // (Pointer to) Proof store vec< CRef > pleaves; // Store clauses that are still involved in the proof // End of proof production // // Data structures required for incrementality, backtrackability // class undo_stack_el { public: enum oper_t { NEWVAR , NEWUNIT , NEWCLAUSE , NEWLEARNT , NEWAXIOM }; private: oper_t op; union { CRef c; Var v; }; public: undo_stack_el(oper_t t, CRef c_) : op(t), c(c_) {} undo_stack_el(oper_t t, Var v_) : op(t), v(v_) {} Var getVar() const { assert(op == NEWVAR); return v; } CRef getClause() const { assert(op == NEWCLAUSE || op == NEWLEARNT || op == NEWAXIOM); return c; } oper_t getType() const { return op; } }; // // Automatic push and pop, for enable undo // vec undo_stack_size; // Keep track of stack_oper size vec undo_stack; // Keep track of operations vec undo_trail_size; // Keep track of trail size // // TODO: move more data in STATISTICS // #ifdef STATISTICS double preproc_time; double tsolvers_time; unsigned elim_tvars; unsigned total_tvars; unsigned ie_generated; #endif // very debug XXX #ifdef PEDANTIC_DEBUG int max_dl_debug; int analyze_cnt; #endif // Added Code //================================================================================================= public: void printTrace() const; protected: using SplitClauses = std::vector>; TPropRes handleNewSplitClauses(SplitClauses & clauses); }; //================================================================================================= // Implementation of inline methods: //================================================================================================= inline CRef CoreSMTSolver::reason(Var x) const { return vardata[x].reason; } inline int CoreSMTSolver::level (Var x) const { return vardata[x].level; } inline void CoreSMTSolver::printTrace() const { int dl = 0; for (int i = 0; i < trail.size(); i++) { if (i == 0 || (trail_lim.size() > dl-1 && trail_lim[dl-1] == i)) printf("\ndl %d:\n ", dl++); printf("%s%d ", sign(trail[i]) ? "-" : "", var(trail[i])); } printf("\n"); } inline void CoreSMTSolver::insertVarOrder(Var x) { if (!order_heap.inHeap(x) && decision[x]) order_heap.insert(x); } inline void CoreSMTSolver::varDecayActivity() { var_inc *= var_decay; } inline void CoreSMTSolver::varBumpActivity(Var v) { varBumpActivity(v, var_inc); } inline void CoreSMTSolver::varBumpActivity(Var v, double inc) { if ( (activity[v] += inc) > 1e100 ) { // Rescale: for (int i = 0; i < nVars(); i++) activity[i] *= 1e-100; var_inc *= 1e-100; } // Update order_heap with respect to new activity: if (order_heap.inHeap(v)) order_heap.decrease(v); } //================================================================================================= // Added Code inline void CoreSMTSolver::claDecayActivity() { cla_inc *= clause_decay; } inline void CoreSMTSolver::claBumpActivity (Clause& c) { if ( (c.activity() += cla_inc) > 1e20 ) { // Rescale: for (int i = 0; i < learnts.size(); i++) ca[learnts[i]].activity() *= 1e-20; cla_inc *= 1e-20; } } inline void CoreSMTSolver::checkGarbage(void) { return checkGarbage(garbage_frac); } inline void CoreSMTSolver::checkGarbage(double gf) { // FIXME Relocation not compatible at the moment with proof tracking if (this->logsProofForInterpolation()) { return; } if (ca.wasted() > ca.size() * gf) { garbageCollect(); } } inline bool CoreSMTSolver::enqueue (Lit p, CRef from) { return value(p) != l_Undef ? value(p) != l_False : (uncheckedEnqueue(p, from), true); } inline bool CoreSMTSolver::addOriginalClause(const vec & ps) { return addOriginalClause_(ps); } inline bool CoreSMTSolver::addEmptyClause () { add_tmp.clear(); return addOriginalClause_(add_tmp); } inline bool CoreSMTSolver::addOriginalClause(Lit p) { add_tmp.clear(); add_tmp.push(p); return addOriginalClause_(add_tmp); } inline bool CoreSMTSolver::addOriginalClause(Lit p, Lit q) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addOriginalClause_(add_tmp); } inline bool CoreSMTSolver::addOriginalClause(Lit p, Lit q, Lit r) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addOriginalClause_(add_tmp); } inline bool CoreSMTSolver::locked (const Clause& c) const { return value(c[0]) == l_True && reason(var(c[0])) != CRef_Undef && reason(var(c[0])) != CRef_Fake && ca.lea(reason(var(c[0]))) == &c; } #ifndef PEDANTIC_DEBUG inline void CoreSMTSolver::newDecisionLevel() { trail_lim.push(trail.size()); levelsInClause.set_domain(trail_lim.size()+1); } #else inline void CoreSMTSolver::newDecisionLevel() { trail_lim.push(trail.size()); max_dl_debug = decisionLevel() > max_dl_debug ? decisionLevel() : max_dl_debug; } #endif inline int CoreSMTSolver::decisionLevel () const { return trail_lim.size(); } inline uint32_t CoreSMTSolver::abstractLevel (Var x) const { return 1 << (level(x) & 31); } inline lbool CoreSMTSolver::value (Var x) const { return assigns[x]; } inline lbool CoreSMTSolver::value (Lit p) const { return assigns[var(p)] ^ sign(p); } inline lbool CoreSMTSolver::safeValue (Var x) const { if (x < assigns.size()) return value(x); else return l_Undef; } inline lbool CoreSMTSolver::safeValue (Lit p) const { auto varValue = safeValue(var(p)); return varValue != l_Undef ? (varValue ^ sign(p)) : l_Undef; } inline lbool CoreSMTSolver::modelValue (Lit p) const { return model[var(p)] != l_Undef ? (model[var(p)] ^ sign(p)) : l_Undef; } inline int CoreSMTSolver::nAssigns () const { return trail.size(); } inline int CoreSMTSolver::nClauses () const { return clauses.size(); } inline int CoreSMTSolver::nLearnts () const { return learnts.size(); } inline int CoreSMTSolver::nVars () const { return vardata.size(); } inline int CoreSMTSolver::nFreeVars () const { return (int)dec_vars - (trail_lim.size() == 0 ? trail.size() : trail_lim[0]); } inline void CoreSMTSolver::setDecisionVar(Var v, bool b) { if ( b && !decision[v]) dec_vars++; else if (!b && decision[v]) dec_vars--; decision[v] = b; insertVarOrder(v); } inline void CoreSMTSolver::setConfBudget(int64_t x) { conflict_budget = conflicts + x; } inline void CoreSMTSolver::setPropBudget(int64_t x) { propagation_budget = propagations + x; } inline void CoreSMTSolver::interrupt() { asynch_interrupt = true; } inline void CoreSMTSolver::clearInterrupt() { asynch_interrupt = false; } inline void CoreSMTSolver::budgetOff() { conflict_budget = propagation_budget = -1; } inline bool CoreSMTSolver::withinBudget() const { return !asynch_interrupt && (conflict_budget < 0 || conflicts < (uint64_t)conflict_budget) && (propagation_budget < 0 || propagations < (uint64_t)propagation_budget); } /** * Compute the Glue value, as defined in Audemard & Simon: * Predicting Learnt Clauses Quality in Modern SAT Solvers. * IJCAI 2009. * * @param vector of literals each having a level in vardata * @return min (4, |{level(var(lit))}| \mid lit \in ps) */ template uint32_t CoreSMTSolver::computeGlue(T const & ps) { levelsInClause.reset(); uint32_t numLevels = 0; for (Lit lit : ps) { int level = vardata[var(lit)].level; if (level != 0 and not levelsInClause.contains(level)) { levelsInClause.insert(level); ++ numLevels; if (numLevels >= 4) { break; } } } return numLevels; } // FIXME: after the introduction of asynchronous interrruptions the solve-versions that return a // pure bool do not give a safe interface. Either interrupts must be possible to turn off here, or // all calls to solve must return an 'lbool'. I'm not yet sure which I prefer. inline bool CoreSMTSolver::solve (const vec& assumps) { budgetOff(); setAssumptions(assumps); return solve_() == l_True; } inline void CoreSMTSolver::toDimacs(const char* file) { vec as; toDimacs(file, as); } inline void CoreSMTSolver::toDimacs(const char* file, Lit p) { vec as; as.push(p); toDimacs(file, as); } inline void CoreSMTSolver::toDimacs(const char* file, Lit p, Lit q) { vec as; as.push(p); as.push(q); toDimacs(file, as); } inline void CoreSMTSolver::toDimacs(const char* file, Lit p, Lit q, Lit r) { vec as; as.push(p); as.push(q); as.push(r); toDimacs(file, as); } //================================================================================================= // Debug + etc: static inline void logLit(FILE* f, Lit l) { fprintf(f, "%sx%d", sign(l) ? "~" : "", var(l)+1); } static inline void logLits(FILE* f, const vec& ls) { fprintf(f, "[ "); if (ls.size() > 0) { logLit(f, ls[0]); for (int i = 1; i < ls.size(); i++) { fprintf(f, ", "); logLit(f, ls[i]); } } fprintf(f, "] "); } static inline const char* showBool(bool b) { return b ? "true" : "false"; } // Just like 'assert()' but expression will be evaluated in the release version as well. static inline void check(bool expr) { (void)expr; assert(expr); } inline void CoreSMTSolver::printLit(Lit l) const { std::flush(std::cout); std::cerr << l; std::flush(std::cerr); } template inline void CoreSMTSolver::printClause(const C& c) { for (unsigned i = 0; i < c.size(); i++) { printLit(c[i]); fprintf(stderr, " "); } Logic& logic = theory_handler.getLogic(); vec args; for (unsigned i = 0; i < c.size(); i++) { PTRef tr = sign(c[i]) ? logic.mkNot(theory_handler.varToTerm(var(c[i]))) : theory_handler.varToTerm(var(c[i])); args.push(tr); } PTRef tr = logic.mkOr(std::move(args)); auto clause = logic.printTerm(tr); fprintf(stderr, "; %s", clause.c_str()); } inline void CoreSMTSolver::populateClauses(vec & clauses, const vec & crefs, unsigned int limit) { Logic& logic = theory_handler.getLogic(); for (int i = 0; i < crefs.size(); i++) { Clause& clause = ca[crefs[i]]; if (clause.size() > limit) { continue; } vec literals; for (unsigned j = 0; j < clause.size(); j++) { Lit& literal = clause[j]; Var v = var(literal); PTRef ptr = theory_handler.varToTerm(v); if (sign(literal)) ptr = logic.mkNot(ptr); literals.push(ptr); } clauses.push(logic.mkOr(std::move(literals))); } } inline std::string CoreSMTSolver::printCnfClauses() { vec cnf_clauses; this->populateClauses(cnf_clauses, clauses); Logic& logic = theory_handler.getLogic(); return logic.printTerm(logic.mkAnd(std::move(cnf_clauses))); } inline std::string CoreSMTSolver::printCnfLearnts() { vec cnf_clauses; this->populateClauses(cnf_clauses, learnts, 2); //this->populateClauses(cnf_clauses, trail); Logic& logic = theory_handler.getLogic(); return logic.printTerm(logic.mkAnd(std::move(cnf_clauses))); } //================================================================================================= // Added code template inline void CoreSMTSolver::printSMTClause(std::ostream & os, const C& c ) { if ( c.size( ) == 0 ) os << "-"; if ( c.size( ) > 1 ) os << "(or "; for (unsigned i = 0; i < c.size(); i++) { Var v = var(c[i]); if ( v <= 1 ) continue; os << (sign(c[i]) ? "(not " : "") << theory_handler.getVarName(v) << (sign(c[i]) ? ") " : " "); } if ( c.size( ) > 1 ) os << ")"; } inline void CoreSMTSolver::printSMTClause(std::ostream & os, vec< Lit > & c, bool ids ) { if ( c.size( ) == 0 ) os << "-"; if ( c.size( ) > 1 ) os << "(or "; for (int i = 0; i < c.size(); i++) { Var v = var(c[i]); if ( v <= 1 ) continue; if ( ids ) os << (sign(c[i]) ? "-":" ") << v << " "; else { os << (sign(c[i]) ? "(not ":"") << theory_handler.getVarName(v) << (sign(c[i]) ? ") " : " "); } } if ( c.size( ) > 1 ) os << ")"; } inline void CoreSMTSolver::printSMTClause(std::ostream & os, std::vector< Lit > & c, bool ids ) { if ( c.size( ) == 0 ) os << "-"; if ( c.size( ) > 1 ) os << "(or "; for (size_t i = 0; i < c.size(); i++) { Var v = var(c[i]); if ( v <= 1 ) continue; if ( ids ) os << (sign(c[i]) ? "-":" ") << v << " "; else { os << (sign(c[i]) ? "(not ":"") << theory_handler.getVarName(v) << (sign(c[i])?") " : " "); } } if ( c.size( ) > 1 ) os << ")"; } inline void CoreSMTSolver::printSMTLit(std::ostream & os, const Lit l ) { Var v = var( l ); if ( v == 0 ) os << "true"; else if ( v == 1 ) os << "false"; else { os << (sign(l) ? "(not " : "") << theory_handler.getVarName(v) << (sign(l) ? ") " : " "); } } //ADDED FOR MINIMIZATION inline void CoreSMTSolver::printClause( vec< Lit > & c ) { for (int i = 0; i < c.size(); i++) { printLit(c[i]); fprintf(stderr, " "); } } #endif opensmt-2.5.2/src/smtsolvers/Debug.cc000066400000000000000000000062111445011647600175620ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #include "CoreSMTSolver.h" #include "ReportUtils.h" void CoreSMTSolver::dumpCNF( ) { const char * name = "cnf.smt2"; std::ofstream dump_out( name ); // egraph.dumpHeaderToFile( dump_out ); dump_out << "(assert" << '\n'; dump_out << "(and" << '\n'; for ( int i = 0 ; i < clauses.size( ) ; i ++ ) { Clause & c = ca[clauses[i]]; if ( c.mark( ) == 1 ) continue; // printSMTClause( dump_out, c ); dump_out << '\n'; } dump_out << "))" << '\n'; dump_out << "(check-sat)" << '\n'; dump_out << "(exit)" << '\n'; dump_out.close( ); std::cerr << "[Dumped " << name << "]" << '\n'; } void CoreSMTSolver::verifyModel() { bool failed = false; for (int i = 0; i < clauses.size(); i++) { assert(ca[clauses[i]].mark() == 0); Clause& c = ca[clauses[i]]; for (unsigned j = 0; j < c.size(); j++) if (modelValue(c[j]) == l_True) goto next; reportf("unsatisfied clause: "); printClause(ca[clauses[i]]); reportf("\n"); failed = true; next:; } assert(!failed); (void)failed; // Removed line // reportf("Verified %d original clauses.\n", clauses.size()); } void CoreSMTSolver::checkLiteralCount() { // Check that sizes are calculated correctly: int cnt = 0; for (int i = 0; i < clauses.size(); i++) if (ca[clauses[i]].mark() == 0) cnt += ca[clauses[i]].size(); if ((int)clauses_literals != cnt){ fprintf(stderr, "literal count: %d, real value = %d\n", (int)clauses_literals, cnt); assert((int)clauses_literals == cnt); } } void CoreSMTSolver::printTrail( ) { for (int i = 0; i < trail.size(); i++) { printLit(trail[i]); std::cerr << ' ' << (sign(trail[i]) ? "not " : "") << theory_handler.getLogic().printTerm(theory_handler.varToTerm(var(trail[i]))) << '\n'; } } opensmt-2.5.2/src/smtsolvers/GhostSMTSolver.cc000066400000000000000000000125461445011647600214070ustar00rootroot00000000000000// // Created by prova on 14.11.19. // #include "GhostSMTSolver.h" #include "ReportUtils.h" #include "Random.h" #include bool GhostSMTSolver::isGhost(Lit l) { if (!theory_handler.isDeclared(var(l))) return false; vec &appearances = thLitToClauses[toInt(l)]; int i; for (i = 0; i < appearances.size(); i++) { if (!satisfied(ca[appearances[i]])) { std::swap(appearances[0], appearances[i]); break; } } return i == appearances.size(); } void GhostSMTSolver::newDecisionLevel() { SimpSMTSolver::newDecisionLevel(); ghostTrailLim.push(ghostTrail.size()); } void GhostSMTSolver::cancelUntil(int level) { int prev_dl = decisionLevel(); SimpSMTSolver::cancelUntil(level); if (prev_dl > level) { for (int c = ghostTrail.size() - 1; c >= ghostTrailLim[level]; c--) { insertVarOrder(ghostTrail[c]); } ghostTrail.shrink(ghostTrail.size() - ghostTrailLim[level]); ghostTrailLim.shrink(ghostTrailLim.size() - level); } assert(ghostTrailLim.size() == trail_lim.size()); } void GhostSMTSolver::attachClause(CRef in_clause) { SimpSMTSolver::attachClause(in_clause); if (in_clause == CRef_Undef) return; const Clause& c = ca[in_clause]; if (c.learnt()) return; for (unsigned i = 0; i < c.size(); i++) { Lit l = c[i]; if (theory_handler.isDeclared(var(l))) { int idx = toInt(l); assert(idx < static_cast(thLitToClauses.size())); thLitToClauses[idx].push(in_clause); } } } void GhostSMTSolver::detachClause(CRef cr, bool strict) { SimpSMTSolver::detachClause(cr, strict); const Clause& c = ca[cr]; if (c.learnt()) return; assert(false); } Var GhostSMTSolver::newVar(bool dvar) { Var v = SimpSMTSolver::newVar(dvar); int idx = toInt(mkLit(v, true)); // true polarity has higher index while (static_cast(thLitToClauses.size()) <= idx) thLitToClauses.emplace_back(); return v; } // Random decision: Var GhostSMTSolver::pickRandomBranchVar() { if (order_heap.empty()) return var_Undef; else return order_heap[opensmt::irand(random_seed,order_heap.size())]; } // Activity based decision: Var GhostSMTSolver::pickBranchVar() { Var next; while (true) { if (order_heap.empty()) { next = var_Undef; break; } else { next = order_heap.removeMin(); } if (value(next) == l_Undef && decision[next]) break; } assert(next == var_Undef || value(next) == l_Undef); return next; } Lit GhostSMTSolver::pickBranchPolarity(Var next) { assert(next != var_Undef); assert(value(next) == l_Undef); bool sign = false; bool signSet = false; bool use_theory_suggested_polarity = config.use_theory_polarity_suggestion(); if (use_theory_suggested_polarity && theory_handler.isDeclared(next)) { lbool suggestion = this->theory_handler.getSolverHandler().getPolaritySuggestion(this->theory_handler.varToTerm(next)); if (suggestion != l_Undef) { sign = (suggestion != l_True); signSet = true; } } if (not signSet) { sign = (savedPolarity[next] == flipState); } Lit l = mkLit(next, sign); if (isGhost(l)) { if (isGhost(~l)) { ghostTrail.push(var(l)); l = lit_Undef; } else l = ~l; } return l; } Lit GhostSMTSolver::pickBranchLit() { #ifdef STATISTICS opensmt::StopWatch s(branchTimer); #endif if ((opensmt::drand(random_seed) < random_var_freq) && !order_heap.empty()) { Var v = pickRandomBranchVar(); if (v != var_Undef && value(v) == l_Undef) { Lit l = pickBranchPolarity(v); if (l != lit_Undef) { rnd_decisions++; return l; } } } Lit l = lit_Undef; while (l == lit_Undef) { Var v = pickBranchVar(); if (v == var_Undef) break; // There are no free vars l = pickBranchPolarity(v); } return l; } void GhostSMTSolver::relocAll() { for (const auto & appearances : thLitToClauses) { for (CRef cr : appearances) { cr = ca[cr].relocation(); } } } void GhostSMTSolver::garbageCollect() { ClauseAllocator to(ca.size() - ca.wasted()); cleanUpClauses(); to.extra_clause_field = ca.extra_clause_field; // NOTE: this is important to keep (or lose) the extra fields. SimpSMTSolver::relocAll(to); CoreSMTSolver::relocAll(to); relocAll(); to.moveTo(ca); } void GhostSMTSolver::verifyModel() { bool failed = false; for (int i = 0; i < clauses.size(); i++) { assert(ca[clauses[i]].mark() == 0); Clause& c = ca[clauses[i]]; for (unsigned j = 0; j < c.size(); j++) if (modelValue(c[j]) == l_True) goto next; for (unsigned j = 0; j < c.size(); j++) if (modelValue(c[j]) == l_Undef && isGhost(c[j])) goto next; reportf("unsatisfied clause: "); printClause(ca[clauses[i]]); reportf("\n"); failed = true; next:; } assert(!failed); (void)failed; // Removed line // reportf("Verified %d original clauses.\n", clauses.size()); } opensmt-2.5.2/src/smtsolvers/GhostSMTSolver.h000066400000000000000000000016401445011647600212420ustar00rootroot00000000000000// // Created by prova on 14.11.19. // #ifndef OPENSMT_GHOSTSMTSOLVER_H #define OPENSMT_GHOSTSMTSOLVER_H #include "SimpSMTSolver.h" class GhostSMTSolver : public SimpSMTSolver { private: std::vector> thLitToClauses; vec ghostTrail; vec ghostTrailLim; Var pickBranchVar(); Var pickRandomBranchVar(); Lit pickBranchPolarity(Var v); bool isGhost(Lit l); protected: void attachClause (CRef) override; void detachClause (CRef, bool strict) override; Lit pickBranchLit () override; void newDecisionLevel () override; void cancelUntil (int level) override; Var newVar (bool dvar) override; void verifyModel () override; public: GhostSMTSolver(SMTConfig& c, THandler& h) : SimpSMTSolver(c, h) {} void garbageCollect() override; void relocAll(); }; #endif //OPENSMT_GHOSTSMTSOLVER_H opensmt-2.5.2/src/smtsolvers/LAScore.cc000066400000000000000000000130151445011647600200240ustar00rootroot00000000000000// // Created by prova on 13.08.19. // #include "LAScore.h" #include "LookaheadSMTSolver.h" #include bool LookaheadScoreClassic::isAlreadyChecked(Var v) const { return (static_cast(LAexacts[v].getRound()) == latest_round); } Lit LookaheadScoreClassic::getBest() { return buf_LABests.getLit(); } void LookaheadScoreClassic::setChecked(Var v) { LAexacts[v].setRound(latest_round); } bool LookaheadScoreClassic::safeToSkip(Var v, Lit ref) const { return LAupperbounds[v].safeToSkip(LAexacts[var(ref)]); } double LookaheadScoreClassic::getSolverScore(const LookaheadSMTSolver *solver) { return solver->trail.size(); } void LookaheadScoreClassic::updateSolverScore(double &ss, const LookaheadSMTSolver* solver) { for (int j = 0; j < solver->trail.size(); j++) updateLAUB(solver->trail[j], solver->trail.size()); ss = solver->trail.size() - ss; } const LookaheadScoreClassic::UBel LookaheadScoreClassic::UBel_Undef(-1, -1); void LookaheadScoreClassic::updateLABest(Var v) { assert(value(v) == l_Undef); ExVal& e = LAexacts[v]; Lit l_v = mkLit(v, e.betterPolarity()); buf_LABests.insert(l_v, e); assert(value(buf_LABests.getLit()) == l_Undef); } void LookaheadScoreClassic::updateLAUB(Lit l, int props) { UBVal& val = LAupperbounds[var(l)]; if (sign(l)) val.updateUB_n(UBel(props, latest_round)); else val.updateUB_p(UBel(props, latest_round)); } void LookaheadScoreClassic::setLAExact(Var v, int pprops, int nprops) { LAexacts[v] = ExVal(pprops, nprops, latest_round); } void LookaheadScoreClassic::setLAValue(Var v, int pprops, int nprops) { setLAExact(v, pprops, nprops); } void LookaheadScoreClassic::newVar() { LAupperbounds.push(); // leave space for the var LAexacts.push(); // leave space for the var } const LookaheadScoreClassic::ExVal LookaheadScoreClassic::ExVal::max_val = ExVal(std::numeric_limits::max(), std::numeric_limits::max(), std::numeric_limits::max()); std::string LookaheadScoreClassic::ExVal::str() const { std::ostringstream ss; ss << "[" << this->nprops << "," << this->pprops << "," << this->round << "]"; return ss.str(); } // safeToSkip: given an exact value e for a variable b, is it safe to // skip checking my literal's extra value in the lookahead heuristic? // bool LookaheadScoreClassic::UBVal::safeToSkip(const ExVal& e) const { // My value needs to be current with respect to both polarities and // the timestamp of e if (!current(e)) return false; const UBel &ub_l = getLow(); const UBel &ub_h = getHigh(); assert(ub_l != UBel_Undef); // If my low-polarity upper bound is less than the low exact of b there is // no reason to check me if (ub_l.ub < e.getEx_l()) { return true; } // If my low-polarity upper bound is equal to the low exact of b and // my high-polarity upper bound is less than or equal to the high // exact of b there is no reason to check me if (ub_l.ub == e.getEx_l() && ub_h.ub <= e.getEx_h()) { return true; } // In all other cases the value needs to be checked. return false; } void LookaheadScoreDeep::newVar() { LAexacts.push(); // leave space for the var } void LookaheadScoreDeep::setLAValue(Var v, int p0, int p1) { LAexacts[v] = DoubleVal(latest_round, p0+p1+1024*p0*p1); } void LookaheadScoreDeep::updateSolverScore(double &ss, const LookaheadSMTSolver *solver) { double new_score = computeScoreFromClauses(solver->clauses, solver) + computeScoreFromClauses(solver->learnts, solver); ss = new_score - ss; } double LookaheadScoreDeep::getSolverScore(const LookaheadSMTSolver *solver) { if (base_score_round >= 0 && static_cast(base_score_round) == latest_round) { return cached_score; } double score = computeScoreFromClauses(solver->clauses, solver) + computeScoreFromClauses(solver->learnts, solver); base_score_round = latest_round; cached_score = score; return score; } double LookaheadScoreDeep::computeScoreFromClauses(const vec &clauses, const LookaheadSMTSolver *solver) { double score = 0; const ClauseAllocator &ca = solver->ca; for (int i = 0; i < clauses.size(); i++) { unsigned nf = 0, nu = 0; bool is_taut = false; const Clause& c = ca[clauses[i]]; for (unsigned j = 0; j < c.size(); j++) { if (value(c[j]) == l_False) { ++nf; } else if (value(c[j]) == l_True) { is_taut = true; break; } else { ++nu; } } if (!is_taut && nf > 0) { score += pow(0.5, nu); } } return score; } bool LookaheadScoreDeep::safeToSkip(Var v, Lit) const { return static_cast(LAexacts[v].getRound()) == latest_round; } void LookaheadScoreDeep::setChecked(Var v) { LAexacts[v].setRound(latest_round); } void LookaheadScoreDeep::updateLABest(Var v) { assert(value(v) == l_Undef); DoubleVal e = LAexacts[v]; Lit l_v = mkLit(v, true); buf_LABests.insert(l_v, e); assert(value(buf_LABests.getLit()) == l_Undef); } bool LookaheadScoreDeep::isAlreadyChecked(Var v) const { return (static_cast(LAexacts[v].getRound()) == latest_round); } Lit LookaheadScoreDeep::getBest() { return buf_LABests.getLit(); } const LookaheadScoreDeep::DoubleVal LookaheadScoreDeep::DoubleVal::max_val = DoubleVal(std::numeric_limits::max(), std::numeric_limits::max()); opensmt-2.5.2/src/smtsolvers/LAScore.h000066400000000000000000000250341445011647600176720ustar00rootroot00000000000000// // Created by prova on 13.08.19. // #ifndef OPENSMT_LASCORE_H #define OPENSMT_LASCORE_H #include #include #include #include #include #include class LookaheadSMTSolver; template class LABestLitBuf { private: int size; using EVLitPair = opensmt::pair; vec buf; const vec &assigns; EV heur_worst; // the lowest heuristic value currently in buf int heur_worst_loc; // The location of heur_worst in buf inline lbool value(Lit p) const { return assigns[var(p)] ^ sign(p); } // Returns a random float 0 <= x < 1. Seed must never be 0. static inline double drand(double& seed) { seed *= 1389796; int q = (int)(seed / 2147483647); seed -= (double)q * 2147483647; return seed / 2147483647; } // Returns a random integer 0 <= x < size. Seed must never be 0. static inline int irand(double& seed, int size) { return (int)(drand(seed) * size); } bool randomize; double rnd_seed; public: // Use 0 for random seed to disable randomization LABestLitBuf(int sz, const vec &assigns, bool randomize, double rnd_seed) : size(sz), assigns(assigns), randomize(randomize), rnd_seed(rnd_seed) { for (int i = 0; i < size; i++) buf.push(EVLitPair{EV(), lit_Undef}); heur_worst_loc = 0; heur_worst = buf[heur_worst_loc].first; } void insert(Lit l, EV &val) { int i; if (val < heur_worst) { return; } buf[heur_worst_loc] = EVLitPair{val, l}; EV current_worst = EV::max_val; for (i = 0; i < size; i++) { int loc = (heur_worst_loc+i) % size; EV &buf_val = buf[loc].first; if (buf_val <= current_worst) { current_worst = heur_worst = buf_val; heur_worst_loc = loc; } } } Lit getLit(int i) { assert(i < size); assert(i >= 0); for (int j = 0; j < size; j++) { if (i + j < size && buf[i + j].second != lit_Undef && value(buf[i + j].second) == l_Undef) return buf[i + j].second; if (i - j >= 0 && buf[i - j].second != lit_Undef && value(buf[i - j].second) == l_Undef) return buf[i - j].second; } return lit_Undef; } Lit getLit() { if (randomize) { int i = irand(rnd_seed, size); return getLit(i); } else return getLit(0); } int getSize() { return size; } // Debug std::string str() const { std::ostringstream ss; ss << "[ "; for (int i = 0; i < size; i++) ss << "(" << buf[i].first.str() << "," << buf[i].second.x << ") "; ss << "]" << '\n'; ss << "Worst is " << heur_worst.str() << " at location " << heur_worst_loc << '\n'; return ss.str(); } }; class LookaheadScore { protected: const vec& assigns; unsigned latest_round; // The numbering for arrays lbool value(Var x) const { return assigns[x]; } lbool value(Lit p) const { return assigns[var(p)] ^ sign(p); } public: void updateRound() { latest_round++; } explicit LookaheadScore(const vec& assigns) : assigns(assigns), latest_round(0) {} virtual ~LookaheadScore() = default; virtual void setLAValue(Var v, int p0, int p1) = 0; virtual double getSolverScore(const LookaheadSMTSolver *solver) = 0; virtual void updateSolverScore(double &ss, const LookaheadSMTSolver *solver) = 0; virtual void updateLABest(Var v) = 0; virtual void newVar() = 0; virtual Lit getBest() = 0; virtual void setChecked(Var v) = 0; virtual bool isAlreadyChecked(Var v) const = 0; virtual bool safeToSkip(Var v, Lit cmp) const = 0; // Given that the heuristic value of cmp is known, is it safe to skip checking value of v }; // The deep lookahead score of a variable v is defined as // score_p(v) + score_n(v) + 1024*score_p(v)*score_n(v), where // - score_p(v) = \sum_{c \in F} (1/2)^nfree((sigma . v | F), c) // - score_n(v) = \sum_{c \in F} (1/2)^nfree((sigma . \neg v| F), c) // - nfree(ss, c) is // - the number of free variables in clause c after ss has been run // until unit propagation closure, if c does not contain a true literal, or // - 0, if c contains a true literal class LookaheadScoreDeep : public LookaheadScore { public: class DoubleVal { int round; double val; public: DoubleVal() : round(-1), val(std::numeric_limits::lowest()) {} DoubleVal(int round, double val) : round(round), val(val) {} static const DoubleVal max_val; bool operator< (const DoubleVal& o) const { if (round > o.round) return false; if (round < o.round) return true; else { return (val < o.val); } } bool operator<= (const DoubleVal& o) const { if (round > o.round) return false; if (round < o.round) return true; return (val <= o.val); } int getRound() const { return round; } void setRound(int r) { round = r; } }; private: int base_score_round; LABestLitBuf buf_LABests; vec LAexacts; double cached_score; double computeScoreFromClauses(const vec& clauses, const LookaheadSMTSolver *solver); bool current(const DoubleVal &e) const { return latest_round == static_cast(e.getRound()); } public: explicit LookaheadScoreDeep(const vec &assigns, const SMTConfig &c) : LookaheadScore(assigns), base_score_round(-1) , buf_LABests(c.randomize_lookahead_bufsz(), assigns, c.randomize_lookahead(), c.getRandomSeed()) {std::cerr << "; Deep score\n";} void setLAValue(Var v, int p0, int p1) override; double getSolverScore(const LookaheadSMTSolver *solver) override; void updateSolverScore(double &ss, const LookaheadSMTSolver *solver) override; void updateLABest(Var v) override; void newVar() override; Lit getBest() override; void setChecked(Var v) override; bool isAlreadyChecked(Var v) const override; bool safeToSkip(Var v, Lit cmp) const override; // Given that the heuristic value of cmp is known, is it safe to skip checking value of v }; class LookaheadScoreClassic : public LookaheadScore { friend LookaheadSMTSolver; private: // ----------------------------------------------------------------------------------------- // Data type for upper bound array // class UBel { public: int ub; int round; UBel() : ub(-1), round(-1) {} UBel(int u, int r) : ub(u), round(r) {} bool operator==(const UBel &o) const { return ub == o.ub && round == o.round; } bool operator!=(const UBel &o) const { return !(operator==(o)); } }; public: class ExVal { private: int pprops; int nprops; int round; int min(int a, int b) const { return a < b ? a : b; } int max(int a, int b) const { return a >= b ? a : b; } public: ExVal() : pprops(-1), nprops(-1), round(-1) {} ExVal(int p, int n, int r) : pprops(p), nprops(n), round(r) {} bool operator<(const ExVal &e) const { if (round > e.round) return false; if (round < e.round) return true; else { return (min(pprops, nprops) < min(e.pprops, e.nprops)) || ((min(pprops, nprops) == min(e.pprops, e.nprops)) && (max(pprops, nprops) < max(e.pprops, e.nprops))); } } bool operator<=(const ExVal &e) const { if (round > e.round) return false; if (round < e.round) return true; return (min(pprops, nprops) <= min(e.pprops, e.nprops)) || ((min(pprops, nprops) == min(e.pprops, e.nprops)) && (max(pprops, nprops) <= max(e.pprops, e.nprops))); } bool betterPolarity() const { return pprops < nprops; } // Should return false if the literal should be unsigned int getRound() const { return round; } int getEx_l() const { return min(pprops, nprops); } int getEx_h() const { return max(pprops, nprops); } void setRound(int r) { round = r; } static const ExVal max_val; std::string str() const; }; private: class UBVal { private: UBel ub_p; UBel ub_n; bool current(const ExVal &e) const { return ub_p.round == ub_n.round && ub_p.round == e.getRound(); } public: UBVal() = default; UBVal(const UBel &ub_pos, const UBel &ub_neg) : ub_p(ub_pos), ub_n(ub_neg) {} void updateUB_p(const UBel &ub) { if (ub_p.round < ub.round || (ub_p.round == ub.round && ub_p.ub > ub.ub)) ub_p = ub; } void updateUB_n(const UBel &ub) { if (ub_n.round < ub.round || (ub_n.round == ub.round && ub_n.ub > ub.ub)) ub_n = ub; } bool safeToSkip(const ExVal &e) const; const UBel &getLow() const { if (ub_p.round != ub_n.round) return UBel_Undef; else return ub_p.ub < ub_n.ub ? ub_p : ub_n; } const UBel &getHigh() const { if (ub_p.round != ub_n.round) return UBel_Undef; else return ub_p.ub < ub_n.ub ? ub_n : ub_p; } }; void setLAExact(Var v, int p0, int p1); vec LAupperbounds; // The current upper bounds vec LAexacts; // The current exact values LABestLitBuf buf_LABests; static const UBel UBel_Undef; public: explicit LookaheadScoreClassic(const vec &assigns, const SMTConfig &c) : LookaheadScore(assigns), buf_LABests(c.randomize_lookahead_bufsz(), assigns, c.randomize_lookahead(), c.getRandomSeed()) { std::cerr << "; Classic score\n"; } void newVar() override; void updateLABest(Var v) override; Lit getBest() override; void setChecked(Var v) override; bool isAlreadyChecked(Var v) const override; bool safeToSkip(Var v, Lit cmp) const override; void updateLAUB(Lit l, int props); // Check the lookahead upper bound and update it if necessary void setLAValue(Var v, int pprops, int nprops) override; // Set the exact la value double getSolverScore(const LookaheadSMTSolver *solver) override; void updateSolverScore(double &ss, const LookaheadSMTSolver *solver) override; }; #endif //OPENSMT_LASCORE_H opensmt-2.5.2/src/smtsolvers/LookaheadSMTSolver.cc000066400000000000000000000305101445011647600222010ustar00rootroot00000000000000// // Created by prova on 07.02.19. // #include "LookaheadSMTSolver.h" #include "Proof.h" LookaheadSMTSolver::LookaheadSMTSolver(SMTConfig & c, THandler & thandler) : SimpSMTSolver(c, thandler), idx(0), score(c.lookahead_score_deep() ? (LookaheadScore *)(new LookaheadScoreDeep(assigns, c)) : (LookaheadScore *)(new LookaheadScoreClassic(assigns, c))) {} Var LookaheadSMTSolver::newVar(bool dvar) { Var v = SimpSMTSolver::newVar(dvar); score->newVar(); return v; } lbool LookaheadSMTSolver::solve_() { for (Lit l : this->assumptions) { this->addVar_(var(l)); } declareVarsToTheories(); double nof_conflicts = restart_first; crossed_assumptions = 0; LALoopRes res = LALoopRes::unknown; model.clear(); conflict.clear(); while (res == LALoopRes::unknown || res == LALoopRes::restart) { res = solveLookahead(); nof_conflicts = restartNextLimit(nof_conflicts); } if (res == LALoopRes::sat) { model.growTo(nVars()); for (int i = 0; i < nVars(); i++) { model[i] = value(i); } } else { assert(not okContinue() || res == LALoopRes::unsat || this->stop); } switch (res) { case LALoopRes::unknown_final: return l_Undef; case LALoopRes::sat: return l_True; case LALoopRes::unsat: { ok = false; return l_False; } default: assert(false); return l_Undef; } } // // Function for making a propagation. // max_confl is a bound on the number of conflicts the wrapper is allowed to do // Returns l_Undef if the bound on conflicts is reached. // Returns l_False if the there was a conflict. // Returns l_True if there was no conflict. // // Backtracks the solver to the correct decision level and continues until no // new conflicts or propagations are available in theory or in unit propagation // lbool LookaheadSMTSolver::laPropagateWrapper() { CRef cr; bool diff; do { diff = false; while ((cr = propagate()) != CRef_Undef) { if (decisionLevel() == 0) return l_False; // Unsat --confl_quota; // Received a conflict and decisionLevel > 0 if (confl_quota <= 0) return l_Undef; vec out_learnt; int out_btlevel; analyze(cr, out_learnt, out_btlevel); // Backtracking back to the second best decision level in the clause cancelUntil(out_btlevel); assert(value(out_learnt[0]) == l_Undef); if (out_learnt.size() == 1) { CRef unitClause = ca.alloc(vec{out_learnt[0]}); if (logsProofForInterpolation()) { proof->endChain(unitClause); } uncheckedEnqueue(out_learnt[0], unitClause); } else { CRef crd = ca.alloc(out_learnt, {true, computeGlue(out_learnt)}); if (logsProofForInterpolation()) { proof->endChain(crd); } learnts.push(crd); attachClause(crd); uncheckedEnqueue(out_learnt[0], crd); } diff = true; } if (!diff) { TPropRes res = checkTheory(true); if (res == TPropRes::Unsat) { return l_False; // Unsat } else if (res == TPropRes::Propagate) { diff = true; --confl_quota; if (confl_quota <= 0) return l_Undef; } } } while (diff); return l_True; } /** * Set solver decision stack according to the path from the root to @param n. * As a side-effect the solver is either * (i) set to the path, or * (ii) a node in the path is marked closed, meaning that there are no solutions in extensions of the path. * In case (i) @return pathbuild_success * In case (ii), either @return pathbuild_tlunsat or @return pathbuild_unsat * */ LookaheadSMTSolver::PathBuildResult LookaheadSMTSolver::setSolverToNode(LANode const & n) { vec path; LANode const * curr = &n; LANode const * parent = n.p; // Collect the truth assignment. while (parent != curr) { path.push(curr->l); curr = parent; parent = curr->p; } // setting solver to the correct dl int i = 0; if (path.size() <= decisionLevel()) { // Means we've encountered conflict and backtracked to another path in DPLL // New path is different from the old one only in the last element if (path.size() > 0) { cancelUntil(path.size() - 1); } else { cancelUntil(0); } crossed_assumptions = std::min(path.size(), assumptions.size()); } else { // Means no conflict was encountered and basic path hasn't changed // we need only propagate i new literals i = (path.size() - decisionLevel()) - 1; } if (path.size() > 0) { for (; i >= 0; i--) { newDecisionLevel(); if (value(path[i]) == l_Undef) { // propagating path[i] int curr_dl = decisionLevel(); uncheckedEnqueue(path[i]); lbool res = laPropagateWrapper(); // Here it is possible that the solver is on level 0 and in an inconsistent state. How can I check // this? if (res == l_False) { return PathBuildResult::pathbuild_tlunsat; // Indicate unsatisfiability } else if (res == l_Undef) { cancelUntil(0); return PathBuildResult::pathbuild_restart; // Do a restart } if (curr_dl != decisionLevel()) { return PathBuildResult::pathbuild_unsat; } } else { // literal to propagate was already assigned if (value(path[i]) == l_False) { return PathBuildResult::pathbuild_unsat; } else { assert(value(path[i]) == l_True); } } } if (config.sat_picky()) { rebuildOrderHeap(); } } return PathBuildResult::pathbuild_success; } LookaheadSMTSolver::laresult LookaheadSMTSolver::expandTree(LANode & n, std::unique_ptr c1, std::unique_ptr c2) { assert(c1); assert(c2); // Do the lookahead assert(decisionLevel() == n.d); auto [res, best] = lookaheadLoop(); while (best == lit_Undef && res == laresult::la_ok) { std::tie(res, best) = lookaheadLoop(); }; assert(best != lit_Undef || res != laresult::la_ok); assert(decisionLevel() <= n.d); if (res != laresult::la_ok) return res; assert(best != lit_Undef); c1->p = &n; c1->d = n.d + 1; c1->l = best; c2->p = &n; c2->d = n.d + 1; c2->l = ~best; n.c1 = std::move(c1); n.c2 = std::move(c2); return laresult::la_ok; } LookaheadSMTSolver::LALoopRes LookaheadSMTSolver::solveLookahead() { struct PlainBuildConfig { bool stopCondition(LANode &, int) { return false; } LALoopRes exitState() const { return LALoopRes::unknown; } }; return buildAndTraverse(PlainBuildConfig()).first; }; std::pair LookaheadSMTSolver::lookaheadLoop() { int pickyWidth = std::min(nVars(), config.sat_picky_w()); ConflQuota prev = confl_quota; confl_quota = ConflQuota(); // Unlimited; if (laPropagateWrapper() == l_False) { // already unsat at the point of entering loop return {laresult::la_tl_unsat, lit_Undef}; } confl_quota = prev; score->updateRound(); int i = 0; int d = decisionLevel(); bool respect_logic_partitioning_hints = config.respect_logic_partitioning_hints(); int skipped_vars_due_to_logic = 0; if (config.sat_picky()) { int k = 0, j = 0; while (k < order_heap.size() && j < pickyWidth) { if (value(order_heap[k]) == l_Undef) { j++; k++; } else { order_heap.remove(order_heap[k]); } } if (order_heap.size() == 0) { return {laresult::la_sat, lit_Undef}; } pickyWidth = std::min(order_heap.size(), pickyWidth); } for (Var v(idx % nVars()); !score->isAlreadyChecked(v); v = config.sat_picky() ? order_heap[(idx + (++i)) % pickyWidth] : Var((idx + (++i)) % nVars())) { if (!decision[v]) { score->setChecked(v); // not a decision var continue; } if (v == (idx * nVars()) && skipped_vars_due_to_logic > 0) respect_logic_partitioning_hints = false; // Allow branching on these since we looped back. if (respect_logic_partitioning_hints && !okToPartition(v)) { skipped_vars_due_to_logic++; std::cout << "Skipping " << v << " since logic says it's not good\n"; continue; // Skip the vars that the logic considers bad to split on } // checking the variable score Lit best = score->getBest(); if (value(v) != l_Undef || (best != lit_Undef && score->safeToSkip(v, best))) { score->setChecked(v); // It is possible that all variables are assigned here. // In this case it seems that we have a satisfying assignment. // This is in fact a debug check if (static_cast(trail.size()) == dec_vars) { // checking if all vars are set if (checkTheory(true) != TPropRes::Decide) return {laresult::la_tl_unsat, lit_Undef}; // Problem is trivially unsat assert(checkTheory(true) == TPropRes::Decide); #ifndef NDEBUG for (CRef cr : clauses) { Clause & c = ca[cr]; unsigned k; for (k = 0; k < c.size(); k++) { if (value(c[k]) == l_True) { break; } } assert(k < c.size()); } #endif return {laresult::la_sat, lit_Undef}; // Stands for SAT } continue; } if (trail.size() == nVars() + skipped_vars_due_to_logic) { std::cout << "; " << skipped_vars_due_to_logic << " vars were skipped\n"; respect_logic_partitioning_hints = false; continue; } int p0 = 0, p1 = 0; for (int p : {0, 1}) { // for both polarities assert(decisionLevel() == d); double ss = score->getSolverScore(this); newDecisionLevel(); Lit l = mkLit(v, p); // checking literal propagations uncheckedEnqueue(l); lbool res = laPropagateWrapper(); if (res == l_False) { return {laresult::la_tl_unsat, lit_Undef}; } else if (res == l_Undef) { cancelUntil(0); return {laresult::la_restart, lit_Undef}; } // Else we go on if (decisionLevel() == d + 1) { // literal is succesfully propagated score->updateSolverScore(ss, this); } else if (decisionLevel() == d) { // propagation resulted in backtrack score->updateRound(); break; } else { // Backtracking should happen. return {laresult::la_unsat, lit_Undef}; } p == 0 ? p0 = ss : p1 = ss; // Update also the clause deletion heuristic? cancelUntil(decisionLevel() - 1); } if (value(v) == l_Undef) { // updating var score score->setLAValue(v, p0, p1); score->updateLABest(v); } } Lit best = score->getBest(); if (static_cast(trail.size()) == dec_vars && best == lit_Undef) { // all variables are set return {laresult::la_sat, best}; } // lookahead phase is over if (!config.sat_picky()) { idx = (idx + i) % nVars(); } if (best != lit_Undef && !okToPartition(var(best))) { unadvised_splits++; } return {laresult::la_ok, best}; } void LookaheadSMTSolver::cancelUntil(int level) { assert(level >= 0); if (decisionLevel() > level) { CoreSMTSolver::cancelUntil(level); crossed_assumptions = std::min(crossed_assumptions, level); } }opensmt-2.5.2/src/smtsolvers/LookaheadSMTSolver.h000066400000000000000000000154521445011647600220530ustar00rootroot00000000000000// // Created by prova on 07.02.19. // #ifndef OPENSMT_LOOKAHEADSMTSOLVER_H #define OPENSMT_LOOKAHEADSMTSOLVER_H #include "LAScore.h" #include "SimpSMTSolver.h" #include #include class LookaheadSMTSolver : public SimpSMTSolver { protected: ConflQuota confl_quota; int idx; int crossed_assumptions; // ----------------------------------------------------------------------------------------- // Data type for exact value array static inline int min(int i, int j) { return i < j ? i : j; } static inline int max(int i, int j) { return i > j ? i : j; } class LANode { public: // The children std::unique_ptr c1; std::unique_ptr c2; LANode * p; virtual LANode * getParent() { return p; } Lit l; int d; LANode() : l(lit_Undef), d(0) {} virtual ~LANode() = default; virtual void print_local() const { for (int i = 0; i < d; i++) dprintf(STDERR_FILENO, " "); dprintf(STDERR_FILENO, "%s%d [%d]", sign(l) ? "-" : "", var(l), d); if (c1 != nullptr) { dprintf(STDERR_FILENO, " c1"); } if (c2 != nullptr) { dprintf(STDERR_FILENO, " c2"); } dprintf(STDERR_FILENO, "\n"); } void print() const { print_local(); if (c1 != nullptr) c1->print(); if (c2 != nullptr) c2->print(); } }; lbool laPropagateWrapper(); protected: // The result from the lookahead loop enum class LALoopRes { sat, unsat, unknown, unknown_final, restart }; enum class laresult { la_tl_unsat, la_sat, la_restart, la_unsat, la_ok }; template std::pair> buildAndTraverse(BuildConfig &&); virtual LALoopRes solveLookahead(); std::pair lookaheadLoop(); virtual void cancelUntil(int level) override; // Backtrack until a certain level. lbool solve_() override; // Does not change the formula enum class PathBuildResult { pathbuild_success, pathbuild_tlunsat, pathbuild_unsat, pathbuild_restart }; PathBuildResult setSolverToNode(LANode const &); // Set solver dl stack according to the path from root to n laresult expandTree(LANode & n, std::unique_ptr c1, std::unique_ptr c2); // Do lookahead. On success write the new children to c1 and c2 std::unique_ptr score; bool okToPartition(Var v) const { return theory_handler.getTheory().okToPartition(theory_handler.varToTerm(v)); }; public: LookaheadSMTSolver(SMTConfig &, THandler &); Var newVar(bool dvar) override; }; // Maintain the tree explicitly. Each internal node should have the info whether its // both children have been constructed and whether any of its two // children has been shown unsatisfiable either directly or with a // backjump. template std::pair> LookaheadSMTSolver::buildAndTraverse(BuildConfig && buildConfig) { score->updateRound(); vec queue; auto * root_raw = new Node(); auto root = std::unique_ptr(root_raw); root->p = root_raw; queue.push(root_raw); TPropRes res = checkTheory(true); if (res == TPropRes::Unsat) { return {LALoopRes::unsat, nullptr}; // unsat } while (queue.size() != 0) { Node * n = queue.last(); queue.pop(); assert(n); switch (setSolverToNode(*n)) { case PathBuildResult::pathbuild_tlunsat: return {LALoopRes::unsat, nullptr}; case PathBuildResult::pathbuild_restart: return {LALoopRes::restart, nullptr}; case PathBuildResult::pathbuild_unsat: { // Reinsert the parent to the queue assert(n != root_raw); // Unsatisfiability in root should be tlunsat Node * parent = n->getParent(); if (queue.size() > 0 and queue.last()->p == parent) { // This is the second child (searched first). Pop the other child as well queue.pop(); // Now queue does not have children of the parent assert(std::all_of(queue.begin(), queue.end(), [parent](Node const * qel) { return qel->p != parent; })); } queue.push(parent); parent->c1.reset(nullptr); parent->c2.reset(nullptr); continue; } case PathBuildResult::pathbuild_success:; } assert(n); if (buildConfig.stopCondition(*n, config.sat_split_num())) { continue; } auto c1_raw = new Node(); auto c2_raw = new Node(); auto c1 = std::unique_ptr(c1_raw); auto c2 = std::unique_ptr(c2_raw); bool checked = false; if (crossed_assumptions < assumptions.size()) { while (crossed_assumptions < assumptions.size()) { // Perform user provided assumption: Lit p = assumptions[crossed_assumptions]; if (value(p) == l_True) { // Dummy decision level: crossed_assumptions++; } else if (value(p) == l_False) { analyzeFinal(~p, conflict); int max = 0; for (Lit q : conflict) { if (!sign(q)) { max = assumptions_order[var(q)] > max ? assumptions_order[var(q)] : max; } } conflict_frame = max + 1; ok = false; return {LALoopRes::unsat, nullptr}; } else { c1_raw->p = n; c1_raw->d = (*n).d + 1; c1_raw->l = p; n->c1 = std::move(c1); crossed_assumptions++; checked = true; queue.push(c1_raw); break; } } } if (!checked) { switch (expandTree(*n, std::move(c1), std::move(c2))) { case laresult::la_tl_unsat: return {LALoopRes::unsat, nullptr}; case laresult::la_restart: return {LALoopRes::restart, nullptr}; case laresult::la_unsat: queue.push(n); continue; case laresult::la_sat: return {LALoopRes::sat, nullptr}; case laresult::la_ok:; } queue.push(c1_raw); queue.push(c2_raw); } } return {buildConfig.exitState(), std::move(root)}; } #endif // OPENSMT_LOOKAHEADSMTSOLVER_H opensmt-2.5.2/src/smtsolvers/Proof.cc000066400000000000000000000213571445011647600176310ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #include "CoreSMTSolver.h" #include "OsmtInternalException.h" #include "Proof.h" #include Proof::Proof( ClauseAllocator& cl ) : begun ( false ) , cl_al ( cl ) { } void Proof::newLeafClause(CRef c, clause_type t) { assert(c != CRef_Undef); assert(clause_to_proof_der.find(c) == clause_to_proof_der.end()); clause_to_proof_der.emplace(c, ProofDer{t}); } // // This is the beginning of a derivation chain. // void Proof::beginChain( CRef c ) { assert( c != CRef_Undef ); assert( !hasOpenChain() ); begun = true; assert(current_chain.isEmpty()); assert( clause_to_proof_der.find( c ) != clause_to_proof_der.end( ) ); current_chain.setInitial(c); // Increase reference ++clause_to_proof_der.at(c).ref; } // // Store a resolution step with chain_cla.back( ) and c // on the pivot variable p // void Proof::addResolutionStep(CRef c, Var p) { assert(hasOpenChain()); assert( c != CRef_Undef ); current_chain.addResolutionStep(c,p); assert( clause_to_proof_der.find( c ) != clause_to_proof_der.end( ) ); // Note that clause c is used as an assumption in another derivation clause_to_proof_der.at(c).ref++; } // Finalize and store the temporary chain void Proof::endChain( CRef conclusion ) { assert(hasOpenChain()); begun = false; // There was no chain (only the first clause was stored) if ( current_chain.isTrivial() ) { CRef premise = current_chain.chain_cla[0]; auto premise_type = clause_to_proof_der.at(premise).type; (void)premise_type; // MB: When analyzing theory conflict, it might happen that the learnt clause is the same as conflicting clause // (but order of literals might be different) assert(premise == conclusion || premise_type == clause_type::CLA_THEORY); if (premise != conclusion) { // It must be the case that premise is a theory clause and conclusion is an equivalent clause // Just create a separate proof chain for conclusion. this->newTheoryClause(conclusion); } assert( clause_to_proof_der.find( conclusion ) != clause_to_proof_der.end( ) ); // No need to update the chain already stored in the proof current_chain.clear(); } else { // Otherwise there was a real derivation chain // Save the temporary derivation chain in a new // derivation structure assert(!current_chain.isEmpty()); assert(current_chain.ref == 0); current_chain.type = clause_type::CLA_LEARNT; assert( clause_to_proof_der.find( conclusion ) == clause_to_proof_der.end( ) ); // Create association between res and it's derivation chain clause_to_proof_der.emplace(conclusion, std::move(current_chain)); current_chain.clear(); } } bool Proof::deleted( CRef cr ) { // Never remove units if ( cl_al[cr].size( ) == 1 ) return false; assert( clause_to_proof_der.find( cr ) != clause_to_proof_der.end( ) ); const ProofDer& d = clause_to_proof_der[ cr ]; assert( d.ref >= 0 ); // This clause is still used somewhere else, keep it if ( d.ref > 0 ) { return false; } // No derivation uses this clause as an assumption, it is safe to remove its derivation. // The assumption clauses are notified that there is one less derivation where they are used for ( unsigned i = 0 ; i < d.chain_cla.size( ) ; i ++ ) { assert( clause_to_proof_der.find( d.chain_cla[i] ) != clause_to_proof_der.end( ) ); ProofDer & parent = clause_to_proof_der.at(d.chain_cla[i]); parent.ref--; } assert( d.ref == 0 ); clause_to_proof_der.erase( cr ); // The clause itself can be removed from Clause store cl_al.free( cr ); return true; } void Proof::print( std::ostream & out, CoreSMTSolver & s, THandler & t ) { if ( clause_to_proof_der.find( CRef_Undef ) == clause_to_proof_der.end( ) ) throw OsmtInternalException("there is no proof of false"); out << "(proof " << '\n'; int nof_lets = 0; std::vector< CRef > unprocessed; unprocessed.push_back( CRef_Undef ); std::set< CRef > cache; std::set< CRef > core; while( !unprocessed.empty( ) ) { CRef cr = unprocessed.back( ); // Skip already seen if ( cache.find( cr ) != cache.end( ) ) { unprocessed.pop_back( ); continue; } assert( clause_to_proof_der.find( cr ) != clause_to_proof_der.end( ) ); ProofDer * d = &clause_to_proof_der.at(cr); // Special case in which there is not // a derivation but just an equivalence if ( d->chain_cla.size( ) == 1 ) { // Say c is done cache.insert( cr ); // Move to equiv cr = d->chain_cla[0]; // Retrieve derivation assert( clause_to_proof_der.find( cr ) != clause_to_proof_der.end( ) ); d = &clause_to_proof_der[ cr ]; } assert( d->chain_cla.size( ) != 1 ); // Look for unprocessed children bool unproc_children = false; for ( unsigned i = 0 ; i < d->chain_cla.size( ) ; i ++ ) { CRef cc = d->chain_cla[i]; if ( cache.find( cc ) == cache.end( ) ) { unproc_children = true; unprocessed.push_back( cc ); } } // Depth first if ( unproc_children ) continue; // Remove current unprocessed.pop_back( ); if ( d->chain_cla.size( ) > 0 ) { out << "; "; if ( cr == CRef_Undef ) out << "-"; else s.printSMTClause( out, cl_al[cr] ); out << '\n'; out << "(let (cls_" << cr; nof_lets ++; std::vector< CRef > & chain_cla = d->chain_cla; std::vector< Var > & chain_var = d->chain_var; assert( chain_cla.size( ) == chain_var.size( ) + 1 ); for ( unsigned i = 1 ; i < chain_cla.size( ) ; i ++ ) out << " (res"; for ( unsigned ic = 1, iv = 0 ; iv < chain_var.size( ) ; ic ++, iv ++ ) { if ( ic == 1 ) { assert( iv == 0 ); out << " cls_" << chain_cla[ 0 ] << " cls_" << chain_cla[ 1 ] << " " << t.getVarName(chain_var[0]) << ")"; } else { out << " cls_" << chain_cla[ ic ] << " " << t.getVarName(chain_var[iv]) << ")"; } } out << ")" << '\n'; } else { if ( d->type == clause_type::CLA_ORIG ) core.insert( cr ); else if ( d->type == clause_type::CLA_THEORY ) { } else { } out << "(let (cls_" << cr << " "; s.printSMTClause( out, cl_al[cr] ); out << ")" << '\n'; nof_lets ++; } cache.insert( cr ); } out << "cls_0" << '\n'; for ( int i = 0 ; i < nof_lets ; i ++ ) out << ")"; out << '\n'; out << ":core" << '\n'; out << "( "; for (CRef cref : core) { out << "cls_" << cref << " "; } out << ")" << '\n'; out << ")" << '\n'; } void Proof::cleanAssumedLiteral(Lit l) { CRef unit = assumed_literals.at(l); assert(clause_to_proof_der.find(unit) != clause_to_proof_der.end()); clause_to_proof_der.erase(unit); cl_al.free(unit); } //============================================================================= // The following functions are declared in CoreSMTSolver.h void CoreSMTSolver::printProofSMT2( std::ostream & out ) { proof->print( out, *this, theory_handler ); } std::ostream & operator<<(std::ostream & os, clause_type val) { switch (val){ case clause_type ::CLA_LEARNT: os << "learnt"; break; case clause_type ::CLA_DERIVED: os << "derived"; break; case clause_type ::CLA_ORIG: os << "original"; break; case clause_type ::CLA_THEORY: os << "theory"; break; default: assert(false); } return os; } opensmt-2.5.2/src/smtsolvers/Proof.h000066400000000000000000000157511445011647600174740ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #ifndef PROOF2_H #define PROOF2_H #include "SolverTypes.h" #include #include #include #include //================================================================================================= class CoreSMTSolver; class THandler; /** * 4 types of clauses: * - original -> part of the propositional skeleton of the original input * - theory -> theory-valid clause; not part of the original input, but adding it results in T-equivalent formula * - learnt -> clause learnt by the SAT solver, result of a derivation chain * - derived -> denotes intermediate clauses in resolution chains; needed only for ProofGraph (consider removing it) */ enum class clause_type: char { CLA_ORIG, CLA_LEARNT, CLA_THEORY, CLA_DERIVED, CLA_ASSUMPTION, CLA_SPLIT }; inline bool isLeafClauseType(clause_type ct) { return ct == clause_type::CLA_ORIG || ct == clause_type::CLA_THEORY || ct == clause_type::CLA_ASSUMPTION || ct == clause_type::CLA_SPLIT; } std::ostream &operator<<(std::ostream &os, clause_type enumTmp); /** * Helper structure for representing derivation of a clause. The clause derived is not stored here, but in the proof. * If this represents a proper resolution from assumptions, then number of clauses must be 1 + number of vars * and for each i, variables chain_var[i] is a pivot of a resolution between chain_cla[i] and chain_cla[i+1] */ struct ProofDer { ProofDer() : ref {0}, type{clause_type::CLA_ORIG} {} ProofDer(clause_type type) : ref {0}, type{type} {} ~ProofDer( ) = default; std::vector< CRef > chain_cla; // Clauses chain std::vector< Var > chain_var; // Pivot chain int ref; // Reference counter clause_type type; // The type of the clause bool isEmpty() const { return chain_cla.empty() && chain_var.empty(); } void setInitial(CRef c) { chain_cla.push_back(c); } bool isTrivial() const { return chain_cla.size() == 1 && chain_var.empty(); } void clear() { chain_cla.clear(); chain_var.clear(); ref = 0; } void addResolutionStep(CRef c, Var v) { chain_cla.push_back(c), chain_var.push_back(v); } }; class Proof { struct LitHash { std::size_t operator()(Lit l) const noexcept { return std::hash{}(l.x); } }; bool begun; // For debugging ProofDer current_chain; std::unordered_map< CRef, ProofDer> clause_to_proof_der; ClauseAllocator& cl_al; std::unordered_map assumed_literals; public: Proof ( ClauseAllocator& cl ); ~Proof( ) = default; // Notifies the proof about a new original clause. void newOriginalClause(CRef c) { newLeafClause(c, clause_type::CLA_ORIG); } // Notifies the proof about a new T-clause. void newTheoryClause(CRef c) { newLeafClause(c, clause_type::CLA_THEORY); } void newSplitClause(CRef c) { newLeafClause(c, clause_type::CLA_SPLIT); } // Notifies the proof that a new resolution chain, starting from the passed clause, is being processed. void beginChain(CRef); // Notifies the proof that the current resolution chain has ended with the passed clause. void endChain(CRef); // Notifies the proof to register a resolution step in current chain. void addResolutionStep(CRef, Var); inline bool hasOpenChain() const { return begun; } template void setCurrentAssumptionLiterals(TIt begin, TIt end){ decltype(assumed_literals) replacement; for (auto it = begin; it != end; ++it){ Lit lit = *it; auto inCurrent = assumed_literals.find(lit); if (inCurrent != assumed_literals.end()) { replacement.insert(*inCurrent); } else { CRef assumed_unit = cl_al.alloc(vec{lit}); // And store it clause_to_proof_der.emplace(assumed_unit, ProofDer{clause_type::CLA_ASSUMPTION}); replacement.insert(std::make_pair<>(lit, assumed_unit)); } } // And clean those that has not been preserved auto emptyDerIt = clause_to_proof_der.find(CRef_Undef); CRef assumedUnitReason = emptyDerIt == clause_to_proof_der.end() ? CRef_Undef : emptyDerIt->second.chain_cla[0]; for (auto const & entry : assumed_literals) { if (replacement.find(entry.first) == replacement.end()) { if (entry.second == assumedUnitReason) { clause_to_proof_der.erase(emptyDerIt); } cleanAssumedLiteral(entry.first); } } std::swap(assumed_literals, replacement); } // MB: I don't like this being public, but it is the easiest way CRef getUnitForAssumptionLiteral(Lit l) { auto it = assumed_literals.find(l); assert(it != assumed_literals.end()); return it->second; } bool deleted(CRef); // Remove clauses if possible inline Clause& getClause(CRef cr) const { return cl_al[cr]; } // Get clause from reference void print( std::ostream &, CoreSMTSolver &, THandler & ); // Print proof in SMT-LIB format std::vector getAssumedLiterals() const { std::vector res; res.reserve(assumed_literals.size()); for (auto const& entry : assumed_literals) { res.push_back(entry.first); } return res; } std::unordered_map const & getProof() const { return clause_to_proof_der; } private: // Helper methods void cleanAssumedLiteral(Lit l); void newLeafClause(CRef, clause_type t); }; //================================================================================================= #endif opensmt-2.5.2/src/smtsolvers/SimpSMTSolver.cc000066400000000000000000000616131445011647600212320ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ /************************************************************************************[SimpSolver.C] MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson 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. **************************************************************************************************/ #include "SimpSMTSolver.h" #include "ReportUtils.h" #include "Sort.h" //================================================================================================= // Constructor/Destructor: SimpSMTSolver::SimpSMTSolver(SMTConfig & c, THandler & t) : CoreSMTSolver(c, t) , grow (c.sat_grow()) , clause_lim (c.sat_clause_lim()) , subsumption_lim (c.sat_subsumption_lim()) , simp_garbage_frac (c.sat_simp_garbage_frac()) , use_asymm (c.sat_use_asymm()) , use_rcheck (c.sat_use_rcheck()) , use_elim (c.sat_use_elim()) , merges (0) , asymm_lits (0) , eliminated_vars (0) , elimorder (1) , use_simplification (true) , occurs (ClauseDeleted(ca)) , elim_heap (ElimLt(n_occ)) , bwdsub_assigns (0) , n_touched (0) { vec dummy(1,lit_Undef); ca.extra_clause_field = true; bwdsub_tmpunit = ca.alloc(dummy); remove_satisfied = false; } SimpSMTSolver::~SimpSMTSolver( ) { } void SimpSMTSolver::initialize( ) { CoreSMTSolver::initialize( ); if (config.verbosity()) verbosity = true; if (config.produce_inter()) { if (config.sat_preprocess_booleans != 0 || config.sat_preprocess_theory != 0) { if (config.verbosity() > 0) {opensmt_warning("disabling SATElite preprocessing to track proof")}; use_simplification = false; config.sat_preprocess_booleans = 0; config.sat_preprocess_theory = 0; } } else { use_simplification = config.sat_preprocess_booleans != 0; } } Var SimpSMTSolver::newVar(bool dvar) { Var v = CoreSMTSolver::newVar(dvar); frozen .push((char)false); eliminated.push((char)false); if (use_simplification) { n_occ .push(0); n_occ .push(0); occurs .init(v); frozen .push((char)false); touched .push(0); elim_heap.insert(v); } return v; } lbool SimpSMTSolver::solve_(bool do_simp, bool turn_off_simp) { vec extra_frozen; lbool result = l_True; if (config.sat_preprocess_theory != 0) { throw OsmtApiException("preprocess theory has been temporairly disabled in this version"); } // Added Code //================================================================================================= do_simp &= use_simplification; if (do_simp) { // Assumptions must be temporarily frozen to run variable elimination: for (int i = 0; i < assumptions.size(); i++) { Var v = var(assumptions[i]); // If an assumption has been eliminated, remember it. assert(!isEliminated(v)); if (!frozen[v]) { // Freeze and store. setFrozen(v, true); extra_frozen.push(v); } } result = lbool(eliminate(turn_off_simp)); } #ifdef STATISTICS CoreSMTSolver::preproc_time = cpuTime( ); #endif if (result == l_True) result = solve_(); if (result == l_True) { extendModel(); // Previous line // #ifndef NDEBUG verifyModel(); } if (do_simp) // Unfreeze the assumptions that were frozen: for (int i = 0; i < extra_frozen.size(); i++) setFrozen(extra_frozen[i], false); return result; } //================================================================================================= // Added code bool SimpSMTSolver::addOriginalSMTClause(const vec & smt_clause, opensmt::pair & inOutCRefs) { inOutCRefs = {CRef_Undef, CRef_Undef}; assert( config.sat_preprocess_theory == 0 ); // Check that the variables exist in the solver for (int i = 0; i < smt_clause.size(); i++) { Lit l = smt_clause[i]; Var v = var(l); PTRef tr = theory_handler.varToTerm(v); assert(v == theory_handler.ptrefToVar(tr)); addVar_(v); if (theory_handler.getLogic().isTheoryTerm(tr) || theory_handler.getTMap().isFrozen(v)) setFrozen(v, true); } #ifdef PEDANTIC_DEBUG for (int i = 0; i < smt_clause.size(); i++) assert(!isEliminated(var(smt_clause[i]))); #endif if (use_rcheck && implied(smt_clause)) return true; if ( config.sat_preprocess_theory != 0 && smt_clause.size( ) == 1 // Consider unit clauses && var(smt_clause[0]) >= 2 ) // Don't consider true/false { std::cerr << "XXX skipped handling of unary theory literal?" << '\n'; } int nclauses = clauses.size(); if (!CoreSMTSolver::addOriginalClause_(smt_clause, inOutCRefs)) return false; if (use_simplification && clauses.size() == nclauses + 1) { CRef cr = clauses.last(); const Clause& c = ca[cr]; // NOTE: the clause is added to the queue immediately and then // again during 'gatherTouchedClauses()'. If nothing happens // in between, it will only be checked once. Otherwise, it may // be checked twice unnecessarily. This is an unfortunate // consequence of how backward subsumption is used to mimic // forward subsumption. subsumption_queue.insert(cr); for (unsigned i = 0; i < c.size(); i++) { occurs[var(c[i])].push(cr); n_occ[toInt(c[i])]++; touched[var(c[i])] = 1; n_touched++; if (elim_heap.inHeap(var(c[i]))) elim_heap.increase(var(c[i])); assert(theory_handler.ptrefToVar(theory_handler.varToTerm(var(c[i]))) != var_Undef); } } return true; } void SimpSMTSolver::removeClause(CRef cr) { const Clause& c = ca[cr]; if (use_simplification) for (unsigned i = 0; i < c.size(); i++) { n_occ[toInt(c[i])]--; updateElimHeap(var(c[i])); occurs.smudge(var(c[i])); } CoreSMTSolver::removeClause(cr); } bool SimpSMTSolver::strengthenClause(CRef cr, Lit l) { Clause& c = ca[cr]; assert(decisionLevel() == 0); assert(use_simplification); // FIX: this is too inefficient but would be nice to have (properly implemented) // if (!find(subsumption_queue, &c)) subsumption_queue.insert(cr); if (c.size() == 2) { removeClause(cr); c.strengthen(l); } else { detachClause(cr, true); c.strengthen(l); attachClause(cr); remove(occurs[var(l)], cr); n_occ[toInt(l)]--; updateElimHeap(var(l)); } return c.size() == 1 ? enqueue(c[0]) && propagate() == CRef_Undef : true; } // Returns FALSE if clause is always satisfied ('out_clause' should not be used). bool SimpSMTSolver::merge(const Clause& _ps, const Clause& _qs, Var v, vec& out_clause) { merges++; out_clause.clear(); bool ps_smallest = _ps.size() < _qs.size(); const Clause& ps = ps_smallest ? _qs : _ps; const Clause& qs = ps_smallest ? _ps : _qs; for (unsigned i = 0; i < qs.size(); i++) { if (var(qs[i]) != v) { for (unsigned j = 0; j < ps.size(); j++) { if (var(ps[j]) == var(qs[i])) { if (ps[j] == ~qs[i]) return false; else goto next; } } out_clause.push(qs[i]); } next: ; } for (unsigned i = 0; i < ps.size(); i++) if (var(ps[i]) != v) out_clause.push(ps[i]); return true; } // Returns FALSE if clause is always satisfied. bool SimpSMTSolver::merge(const Clause& _ps, const Clause& _qs, Var v, int& size) { merges++; bool ps_smallest = _ps.size() < _qs.size(); const Clause& ps = ps_smallest ? _qs : _ps; const Clause& qs = ps_smallest ? _ps : _qs; const Lit* __ps = (const Lit*)ps; const Lit* __qs = (const Lit*)qs; size = ps.size()-1; for (unsigned i = 0; i < qs.size(); i++) { if (var(__qs[i]) != v) { for (unsigned j = 0; j < ps.size(); j++) { if (var(__ps[j]) == var(__qs[i])) { if (__ps[j] == ~__qs[i]) return false; else goto next; } } } next: ; } return true; } void SimpSMTSolver::gatherTouchedClauses() { if (n_touched == 0) return; int i,j; for (i = j = 0; i < subsumption_queue.size(); i++) if (ca[subsumption_queue[i]].mark() == 0) ca[subsumption_queue[i]].mark(2); for (i = 0; i < touched.size(); i++) if (touched[i]) { const vec& cs = occurs.lookup(i); for (j = 0; j < cs.size(); j++) if (ca[cs[j]].mark() == 0) { subsumption_queue.insert(cs[j]); ca[cs[j]].mark(2); } touched[i] = 0; } for (i = 0; i < subsumption_queue.size(); i++) if (ca[subsumption_queue[i]].mark() == 2) ca[subsumption_queue[i]].mark(0); n_touched = 0; } bool SimpSMTSolver::implied(const vec& c) { assert(decisionLevel() == 0); trail_lim.push(trail.size()); for (int i = 0; i < c.size(); i++) if (value(c[i]) == l_True) { cancelUntil(0); return false; } else if (value(c[i]) != l_False) { assert(value(c[i]) == l_Undef); uncheckedEnqueue(~c[i]); } bool result = propagate() != CRef_Undef; cancelUntil(0); return result; } // Backward subsumption + backward subsumption resolution bool SimpSMTSolver::backwardSubsumptionCheck(bool verbose) { int cnt = 0; int subsumed = 0; int deleted_literals = 0; assert(decisionLevel() == 0); while (subsumption_queue.size() > 0 || bwdsub_assigns < trail.size()) { // Empty subsumption queue and return immediately on user-interrupt: if (asynch_interrupt) { subsumption_queue.clear(); bwdsub_assigns = trail.size(); break; } // Check top-level assignments by creating a dummy clause and placing it in the queue: if (subsumption_queue.size() == 0 && bwdsub_assigns < trail.size()) { Lit l = trail[bwdsub_assigns++]; ca[bwdsub_tmpunit][0] = l; ca[bwdsub_tmpunit].calcAbstraction(); subsumption_queue.insert(bwdsub_tmpunit); } CRef cr = subsumption_queue.peek(); subsumption_queue.pop(); Clause& c = ca[cr]; if (c.mark()) continue; if (verbose && config.verbosity() > 9 && cnt++ % 1000 == 0) printf("; Subsumption left: %10d (%10d subsumed, %10d deleted literals)\r", subsumption_queue.size(), subsumed, deleted_literals); assert(c.size() > 1 || value(c[0]) == l_True); // Unit-clauses should have been propagated before this point. // Find best variable to scan: Var best = var(c[0]); for (unsigned i = 1; i < c.size(); i++) if (occurs[var(c[i])].size() < occurs[best].size()) best = var(c[i]); // Search all candidates: vec& _cs = occurs.lookup(best); CRef* cs = (CRef*)_cs; for (int j = 0; j < _cs.size(); j++) if (c.mark()) break; else if (!ca[cs[j]].mark() && cs[j] != cr && (subsumption_lim == -1 || ca[cs[j]].size() < static_cast(subsumption_lim))) { Lit l = c.subsumes(ca[cs[j]]); if (l == lit_Undef) subsumed++, removeClause(cs[j]); else if (l != lit_Error) { deleted_literals++; if (!strengthenClause(cs[j], ~l)) return false; // Did current candidate get deleted from cs? Then check candidate at index j again: if (var(l) == best) j--; } } } return true; } bool SimpSMTSolver::asymm(Var v, CRef cr) { Clause& c = ca[cr]; assert(decisionLevel() == 0); if (c.mark() || satisfied(c)) return true; trail_lim.push(trail.size()); Lit l = lit_Undef; for (unsigned i = 0; i < c.size(); i++) if (var(c[i]) != v && value(c[i]) != l_False) { uncheckedEnqueue(~c[i]); } else l = c[i]; if (propagate() != CRef_Undef) { cancelUntil(0); asymm_lits++; if (!strengthenClause(cr, l)) return false; } else cancelUntil(0); return true; } bool SimpSMTSolver::asymmVar(Var v) { assert(!frozen[v]); assert(use_simplification); const vec& cls = occurs.lookup(v); if (value(v) != l_Undef || cls.size() == 0) return true; for (int i = 0; i < cls.size(); i++) if (!asymm(v, cls[i])) return false; return backwardSubsumptionCheck(); } static void mkElimClause(vec& elimclauses, Lit x) { elimclauses.push(toInt(x)); elimclauses.push(1); } static void mkElimClause(vec& elimclauses, Var v, Clause& c) { int first = elimclauses.size(); int v_pos = -1; // Copy clause to elimclauses-vector. Remember position where the // variable 'v' occurs: for (unsigned i = 0; i < c.size(); i++) { elimclauses.push(toInt(c[i])); if (var(c[i]) == v) v_pos = i + first; } assert(v_pos != -1); // Swap the first literal with the 'v' literal, so that the literal // containing 'v' will occur first in the clause: uint32_t tmp = elimclauses[v_pos]; elimclauses[v_pos] = elimclauses[first]; elimclauses[first] = tmp; // Store the length of the clause last: elimclauses.push(c.size()); } bool SimpSMTSolver::eliminateVar(Var v) { assert(!frozen[v]); assert(!isEliminated(v)); assert(value(v) == l_Undef); // Split the occurrences into positive and negative: // const vec& cls = occurs.lookup(v); vec pos, neg; for (int i = 0; i < cls.size(); i++) (find(ca[cls[i]], mkLit(v)) ? pos : neg).push(cls[i]); // Check wether the increase in number of clauses stays within the allowed ('grow'). Moreover, no // clause must exceed the limit on the maximal clause size (if it is set): // int cnt = 0; int clause_size = 0; for (int i = 0; i < pos.size(); i++) for (int j = 0; j < neg.size(); j++) if (merge(ca[pos[i]], ca[neg[j]], v, clause_size) && (++cnt > cls.size() + grow || (clause_lim != -1 && clause_size > clause_lim))) return true; #ifdef PEDANTIC_DEBUG cerr << "XXY gonna-remove" << endl; #endif // Delete and store old clauses: eliminated[v] = true; setDecisionVar(v, false); eliminated_vars++; if (pos.size() > neg.size()) { for (int i = 0; i < neg.size(); i++) mkElimClause(elimclauses, v, ca[neg[i]]); mkElimClause(elimclauses, mkLit(v)); } else { for (int i = 0; i < pos.size(); i++) mkElimClause(elimclauses, v, ca[pos[i]]); mkElimClause(elimclauses, ~mkLit(v)); } for (int i = 0; i < cls.size(); i++) removeClause(cls[i]); // Produce clauses in cross product: vec& resolvent = add_tmp; for (int i = 0; i < pos.size(); i++) { for (int j = 0; j < neg.size(); j++) { opensmt::pair dummy {CRef_Undef, CRef_Undef}; if (merge(ca[pos[i]], ca[neg[j]], v, resolvent) && !addOriginalSMTClause(resolvent, dummy)) return false; } } // Free occurs list for this variable: occurs[v].clear(true); // Free watchers lists for this variable, if possible: if (watches[ mkLit(v)].size() == 0) watches[ mkLit(v)].clear(true); if (watches[~mkLit(v)].size() == 0) watches[~mkLit(v)].clear(true); return backwardSubsumptionCheck(); } bool SimpSMTSolver::substitute(Var v, Lit x) { assert(!frozen[v]); assert(!isEliminated(v)); assert(value(v) == l_Undef); if (!ok) return false; eliminated[v] = true; setDecisionVar(v, false); const vec& cls = occurs.lookup(v); vec& subst_clause = add_tmp; for (int i = 0; i < cls.size(); i++) { Clause& c = ca[cls[i]]; subst_clause.clear(); for (unsigned j = 0; j < c.size(); j++) { Lit p = c[j]; subst_clause.push(var(p) == v ? x ^ sign(p) : p); } removeClause(cls[i]); opensmt::pair dummy {CRef_Undef, CRef_Undef}; if (!addOriginalSMTClause(subst_clause, dummy)) return ok = false; } return true; } void SimpSMTSolver::extendModel() { int i, j; Lit x; for (i = elimclauses.size()-1; i > 0; i -= j) { for (j = elimclauses[i--]; j > 1; j--, i--) if (modelValue(toLit(elimclauses[i])) != l_False) goto next; x = toLit(elimclauses[i]); model[var(x)] = lbool(!sign(x)); next: ; } } bool SimpSMTSolver::eliminate(bool turn_off_elim) { if (!simplify()) return false; else if (!use_simplification) return true; // Main simplification loop: // while (n_touched > 0 || bwdsub_assigns < trail.size() || elim_heap.size() > 0) { gatherTouchedClauses(); // printf(" ## (time = %6.2f s) BWD-SUB: queue = %d, trail = %d\n", cpuTime(), subsumption_queue.size(), trail.size() - bwdsub_assigns); if ((subsumption_queue.size() > 0 || bwdsub_assigns < trail.size()) && !backwardSubsumptionCheck(true)) { ok = false; goto cleanup; } // Empty elim_heap and return immediately on user-interrupt: if (asynch_interrupt) { assert(bwdsub_assigns == trail.size()); assert(subsumption_queue.size() == 0); assert(n_touched == 0); elim_heap.clear(); goto cleanup; } // printf(" ## (time = %6.2f s) ELIM: vars = %d\n", cpuTime(), elim_heap.size()); while (!elim_heap.empty()) { Var elim = elim_heap.removeMin(); if (asynch_interrupt) break; if (isEliminated(elim) || value(elim) != l_Undef) continue; if (use_asymm) { // Temporarily freeze variable. Otherwise, it would immediately end up on the queue again: bool was_frozen = frozen[elim]; frozen[elim] = true; if (!asymmVar(elim)) { ok = false; goto cleanup; } frozen[elim] = was_frozen; } // At this point, the variable may have been set by assymetric branching, so check it // again. Also, don't eliminate frozen variables: if (use_elim && value(elim) == l_Undef && !frozen[elim] && !eliminateVar(elim)) { ok = false; goto cleanup; } checkGarbage(simp_garbage_frac); } assert(subsumption_queue.size() == 0); //gatherTouchedClauses(); } cleanup: // If no more simplification is needed, free all simplification-related data structures: if (turn_off_elim) { touched .clear(true); occurs .clear(true); n_occ .clear(true); elim_heap.clear(true); subsumption_queue.clear(true); use_simplification = false; remove_satisfied = true; ca.extra_clause_field = false; // Force full cleanup (this is safe and desirable since it only happens once): rebuildOrderHeap(); garbageCollect(); } else { // Cheaper cleanup: cleanUpClauses(); // TODO: can we make 'cleanUpClauses()' not be linear in the problem size somehow? checkGarbage(); } #ifdef INVARIANTS // Check that no more subsumption is possible: reportf("Checking that no more subsumption is possible\n"); for (int i = 0; i < clauses.size(); i++) { if (i % 1000 == 0) reportf("left %10d\r", clauses.size() - i); assert(ca[clauses[i]].mark() == 0); for (int j = 0; j < i; j++) assert(ca[clauses[i]].subsumes(ca[clauses[j]]) == lit_Error); } reportf("done.\n"); // Check that no more elimination is possible: reportf("Checking that no more elimination is possible\n"); for (int i = 0; i < nVars(); i++) if (!frozen[i]) eliminateVar(i); reportf("done.\n"); checkLiteralCount(); #endif return ok; } void SimpSMTSolver::cleanUpClauses() { occurs.cleanAll(); int i,j; for (i = j = 0; i < clauses.size(); i++) if (ca[clauses[i]].mark() == 0) clauses[j++] = clauses[i]; clauses.shrink(i - j); //this->n_clauses-=(i-j); } //================================================================================================= // Garbage Collection methods: void SimpSMTSolver::relocAll(ClauseAllocator& to) { if (!use_simplification) return; // All occurs lists: // for (int i = 0; i < nVars(); i++) { vec& cs = occurs[i]; for (int j = 0; j < cs.size(); j++) ca.reloc(cs[j], to); } // Subsumption queue: // for (int i = 0; i < subsumption_queue.size(); i++) ca.reloc(subsumption_queue[i], to); // Temporary clause: // ca.reloc(bwdsub_tmpunit, to); } void SimpSMTSolver::garbageCollect() { // Initialize the next region to a size corresponding to the estimated utilization degree. This // is not precise but should avoid some unnecessary reallocations for the new region: ClauseAllocator to(ca.size() - ca.wasted()); cleanUpClauses(); to.extra_clause_field = ca.extra_clause_field; // NOTE: this is important to keep (or lose) the extra fields. relocAll(to); CoreSMTSolver::relocAll(to); // if (config.verbosity() >= 2) // fprintf(stderr, ";| Garbage collection: %12d bytes => %12d bytes |\n", // ca.size()*ClauseAllocator::Unit_Size, to.size()*ClauseAllocator::Unit_Size); to.moveTo(ca); } opensmt-2.5.2/src/smtsolvers/SimpSMTSolver.h000066400000000000000000000231601445011647600210670ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ /************************************************************************************[SimpSMTSolver.h] MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson 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. **************************************************************************************************/ #ifndef SIMP_SMT_SOLVER_H #define SIMP_SMT_SOLVER_H #include "Queue.h" #include "CoreSMTSolver.h" class SimpSMTSolver : public CoreSMTSolver { public: // Constructor/Destructor: // SimpSMTSolver (SMTConfig &, THandler&); ~SimpSMTSolver( ); void initialize ( ); // Problem specification: // Var newVar (bool dvar = true) override; bool addOriginalSMTClause(const vec & smt_clause, opensmt::pair & inOutCRefs); public: bool substitute(Var v, Lit x); // Replace all occurences of v with x (may cause a contradiction). // Variable mode: // void setFrozen (Var v, bool b); // If a variable is frozen it will not be eliminated. bool isEliminated(Var v) const; // Solving: // lbool solve (const vec& assumps, bool do_simp = true, bool turn_off_simp = false); lbool solveLimited(const vec& assumps, bool do_simp = true, bool turn_off_simp = false); lbool solve ( bool do_simp = true, bool turn_off_simp = false); lbool solve (Lit p , bool do_simp = true, bool turn_off_simp = false); lbool solve (Lit p, Lit q, bool do_simp = true, bool turn_off_simp = false); lbool solve (Lit p, Lit q, Lit r, bool do_simp = true, bool turn_off_simp = false); bool eliminate (bool turn_off_elim = false); // Perform variable elimination based simplification. // Memory managment: // virtual void garbageCollect() override; // Generate a (possibly simplified) DIMACS file: // #if 0 void toDimacs (const char* file, const vec& assumps); void toDimacs (const char* file); void toDimacs (const char* file, Lit p); void toDimacs (const char* file, Lit p, Lit q); void toDimacs (const char* file, Lit p, Lit q, Lit r); #endif // Mode of operation: // int grow; // Allow a variable elimination step to grow by a number of clauses (default to zero). int clause_lim; // Variables are not eliminated if it produces a resolvent with a length above this limit. // -1 means no limit. int subsumption_lim; // Do not check if subsumption against a clause larger than this. -1 means no limit. double simp_garbage_frac; // A different limit for when to issue a GC during simplification (Also see 'garbage_frac'). bool use_asymm; // Shrink clauses by asymmetric branching. bool use_rcheck; // Check if a clause is already implied. Prett costly, and subsumes subsumptions :) bool use_elim; // Perform variable elimination. // Statistics: // int merges; int asymm_lits; int eliminated_vars; // protected: public: // Helper structures: // struct ElimLt { const vec& n_occ; explicit ElimLt(const vec& no) : n_occ(no) {} // TODO: are 64-bit operations here noticably bad on 32-bit platforms? Could use a saturating // 32-bit implementation instead then, but this will have to do for now. uint64_t cost (Var x) const { return (uint64_t)n_occ[toInt(mkLit(x))] * (uint64_t)n_occ[toInt(~mkLit(x))]; } bool operator()(Var x, Var y) const { return cost(x) < cost(y); } }; struct ClauseDeleted { const ClauseAllocator& ca; explicit ClauseDeleted(const ClauseAllocator& _ca) : ca(_ca) {} bool operator()(const CRef& cr) const { return ca[cr].mark() == 1; } }; // Solver state: // int elimorder; bool use_simplification; OccLists, ClauseDeleted> occurs; Heap elim_heap; int bwdsub_assigns; vec elimclauses; vec touched; int n_touched; vec n_occ; Queue subsumption_queue; vec frozen; vec eliminated; // Temporaries: // CRef bwdsub_tmpunit; // Main internal methods: // using CoreSMTSolver::solve_; lbool solve_ (bool do_simp, bool turn_off_simp); bool asymm (Var v, CRef cr); bool asymmVar (Var v); void updateElimHeap (Var v); void cleanOcc (Var v); vec& getOccurs (Var x); void gatherTouchedClauses (); bool merge (const Clause& _ps, const Clause& _qs, Var v, vec& out_clause); bool merge (const Clause& _ps, const Clause& _qs, Var v, int& size); bool backwardSubsumptionCheck (bool verbose = false); bool eliminateVar (Var v); void extendModel (); void removeClause (CRef cr); bool strengthenClause (CRef cr, Lit l); void cleanUpClauses (); bool implied (const vec& c); void relocAll (ClauseAllocator& to); virtual void mapEnabledFrameIdToVar(Var, uint32_t, uint32_t &) { return; } virtual void addAssumptionVar(Var) { return; } }; //================================================================================================= // Implementation of inline methods: inline bool SimpSMTSolver::isEliminated (Var v) const { return eliminated[v]; } inline void SimpSMTSolver::updateElimHeap(Var v) { assert(use_simplification); if (elim_heap.inHeap(v) || (!frozen[v] && !isEliminated(v) && value(v) == l_Undef)) elim_heap.update(v); } inline void SimpSMTSolver::setFrozen (Var v, bool b) { if ( !use_simplification ) return; frozen[v] = (char)b; if (b) { updateElimHeap(v); } } inline lbool SimpSMTSolver::solve ( bool do_simp, bool turn_off_simp) { return solve(vec{}, do_simp, turn_off_simp); } inline lbool SimpSMTSolver::solve (Lit p , bool do_simp, bool turn_off_simp) { return solve(vec{p}, do_simp, turn_off_simp); } inline lbool SimpSMTSolver::solve (Lit p, Lit q, bool do_simp, bool turn_off_simp) { return solve(vec{p,q}, do_simp, turn_off_simp); } inline lbool SimpSMTSolver::solve (Lit p, Lit q, Lit r, bool do_simp, bool turn_off_simp) { return solve(vec{p,q,r}, do_simp, turn_off_simp); } inline lbool SimpSMTSolver::solve (const vec& assumps, bool do_simp, bool turn_off_simp){ budgetOff(); setAssumptions(assumps); return solve_(do_simp, turn_off_simp); } inline lbool SimpSMTSolver::solveLimited (const vec& assumps, bool do_simp, bool turn_off_simp){ setAssumptions(assumps); return solve_(do_simp, turn_off_simp); } //inline bool CoreSMTSolver::smtSolve () { return solve(); } //================================================================================================= #endif opensmt-2.5.2/src/smtsolvers/TheoryCombination.cc000066400000000000000000000277221445011647600222030ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #include "SimpSMTSolver.h" /* inline bool isArithmeticOp( Enode * e ) { if ( e->isPlus ( ) || e->isUminus ( ) || e->isTimes ( ) || e->isLeq ( ) || e->isVar ( ) || ( e->isConstant( ) && !e->isTrue( ) && !e->isFalse( ) ) ) return true; return false; } inline bool isUFOp( Enode * e ) { if ( e->isUf ( ) || e->isUp ( ) || e->isDistinct ( ) || e->isVar ( ) || ( e->isConstant( ) && !e->isTrue( ) && !e->isFalse( ) ) ) return true; return false; } void SimpSMTSolver::gatherInterfaceTerms( Enode * e ) { assert( config.sat_lazy_dtc != 0 ); assert( config.logic == QF_UFIDL || config.logic == QF_UFLRA ); assert( e ); vector< Enode * > unprocessed_enodes; egraph.initDup1( ); unprocessed_enodes.push_back( e ); // // Visit the DAG of the term from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.isDup1( enode ) ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != egraph.enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( !egraph.isDup1( arg ) ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); // // At this point, every child has been processed // if ( isUFOp( enode ) ) { // Retrieve arguments for ( Enode * arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); if ( isArithmeticOp( arg ) ) if ( interface_terms_cache.insert( arg ).second ) { interface_terms.push_back( arg ); cerr << "Added: " << arg << endl; } } } else if ( isArithmeticOp( enode ) ) { // Retrieve arguments for ( Enode * arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); if ( isUFOp( arg ) ) if ( interface_terms_cache.insert( arg ).second ) { interface_terms.push_back( arg ); cerr << "Added: " << arg << endl; } } } assert( !egraph.isDup1( enode ) ); egraph.storeDup1( enode ); } egraph.doneDup1( ); } */ // Generates a bunch of eij, and return one Var CoreSMTSolver::generateMoreEij( ) { Var ret = var_Undef; for ( int i = 0 ; i < (config.sat_lazy_dtc_burst < 0 ? 1 : config.sat_lazy_dtc_burst) ; i ++ ) { Var v = generateNextEij( ); // Return if no more eij if ( v == var_Undef ) return v; // Save return variable if ( i == 0 ) ret = v; } return ret; } Var CoreSMTSolver::generateNextEij( ) { if ( egraph.getInterfaceTermsNumber( ) == 0 ) return var_Undef; assert( config.sat_lazy_dtc != 0 ); Var v = var_Undef; lbool pol = l_Undef; while ( v == var_Undef ) { // Already returned all the possible eij if ( next_it_i == egraph.getInterfaceTermsNumber( ) - 1 && next_it_j == egraph.getInterfaceTermsNumber( ) ) return var_Undef; // Get terms // Enode * i = interface_terms[ next_it_i ]; // Enode * j = interface_terms[ next_it_j ]; Enode * i = egraph.getInterfaceTerm( next_it_i ); Enode * j = egraph.getInterfaceTerm( next_it_j ); // Increase counters next_it_j ++; if ( next_it_j == next_it_i ) next_it_j ++; // if ( next_it_j == static_cast< int >( interface_terms.size( ) ) ) if ( next_it_j == egraph.getInterfaceTermsNumber( ) ) { next_it_i ++; next_it_j = next_it_i + 1; } // No need to create eij if both numbers, // it's either trivially true or false if ( i->isConstant( ) && j->isConstant( ) ) continue; assert( config.logic == QF_UFLRA || config.logic == QF_UFIDL ); // // Since arithmetic solvers do not // understand equalities, produce // the splitted versions of equalities // and add linking clauses // Enode * eij = egraph.mkEq( egraph.cons( i, egraph.cons( j ) ) ); // Skip as this interface equality already exists // as a theory atom, and so no need to generate it if ( atoms_seen.find( eij ) != atoms_seen.end( ) ) continue; #ifdef PRODUCE_PROOF if ( config.produce_inter != 0 && eij->getIPartitions( ) == 0 ) { eij->setIPartitions( i->getIPartitions( ) & j->getIPartitions( ) ); // Set explicitly ABmixed if ( eij->getIPartitions( ) == 0 ) eij->setIPartitions( 1 ); } #endif if ( config.verbosity > 2 ) { // cerr << "# CoreSMTSolver::Adding eij: " << eij << endl; cerr << "\rLazy DTC Progress: " << ( 100 * (float)next_it_i / (float)egraph.getInterfaceTermsNumber( ) ) << " %"; } if ( eij->isTrue( ) || eij->isFalse( ) ) continue; // Canonize LAExpression la( eij ); Enode * eij_can = la.toEnode( egraph ); // Continue if already generated equality // if ( !interface_equalities.insert( eij_can ).second ) continue; if ( eij_can->isTrue( ) || eij_can->isFalse( ) ) continue; v = theory_handler->enodeToVar( eij ); // Created one equality that is already assigned // Skip it if ( value( v ) != l_Undef ) { v = var_Undef; continue; } // Get lhs and rhs Enode * lhs = eij_can->get1st( ); Enode * rhs = eij_can->get2nd( ); Enode * leq = egraph.mkLeq( egraph.cons( lhs, egraph.cons( rhs ) ) ); // Canonize lhs LAExpression b( leq ); leq = b.toEnode( egraph ); // We need to color this guy ... #ifdef PRODUCE_PROOF if ( config.produce_inter != 0 && atoms_seen.find( leq ) == atoms_seen.end( ) && leq->getIPartitions( ) == 0 ) { leq->setIPartitions( lhs->getIPartitions( ) & rhs->getIPartitions( ) ); // Set ABmixed if ( leq->getIPartitions( ) == 0 ) leq->setIPartitions( 1 ); } #endif // Canonize rhs Enode * geq = egraph.mkGeq( egraph.cons( lhs, egraph.cons( rhs ) ) ); LAExpression c( geq ); geq = c.toEnode( egraph ); // We need to color this guy ... #ifdef PRODUCE_PROOF if ( config.produce_inter != 0 && atoms_seen.find( geq ) == atoms_seen.end( ) && geq->getIPartitions( ) == 0 ) { geq->setIPartitions( lhs->getIPartitions( ) & rhs->getIPartitions( ) ); // Set ABmixed if ( geq->getIPartitions( ) == 0 ) geq->setIPartitions( 1 ); } #endif // Add clause ( !x=y v x<=y ) vector< Enode * > clause; clause.push_back( egraph.mkNot( egraph.cons( eij ) ) ); clause.push_back( leq ); assert( !leq->isTrue( ) ); assert( !leq->isFalse( ) ); #ifdef PRODUCE_PROOF addSMTAxiomClause( clause , computeAxiomInterp( clause ) ); #else addSMTAxiomClause( clause ); #endif // Add clause ( !x=y v x>=y ) clause.pop_back( ); clause.push_back( geq ); assert( !leq->isTrue( ) ); assert( !leq->isFalse( ) ); #ifdef PRODUCE_PROOF addSMTAxiomClause( clause , computeAxiomInterp( clause ) ); #else addSMTAxiomClause( clause ); #endif // Add clause ( x=y v !x>=y v !x<=y ) clause.clear( ); clause.push_back( eij ); clause.push_back( egraph.mkNot( egraph.cons( leq ) ) ); clause.push_back( egraph.mkNot( egraph.cons( geq ) ) ); #ifdef PRODUCE_PROOF addSMTAxiomClause( clause , computeAxiomInterp( clause ) ); #else addSMTAxiomClause( clause ); #endif pol = theory_handler->evaluate( eij ); if ( pol == l_Undef ) pol = theory_handler->evaluate( leq ); if ( pol == l_Undef ) pol = theory_handler->evaluate( geq ); /* else { Enode * eij = egraph.mkEq( egraph.cons( i, egraph.cons( j ) ) ); #ifdef PRODUCE_PROOF if ( config.produce_inter != 0 ) { eij->setIPartitions( i->getIPartitions( ) & j->getIPartitions( ) ); // Set ABmixed if ( eij->getIPartitions( ) == 0 ) eij->setIPartitions( 1 ); } #endif // Continue if already generated equality if ( !interface_equalities.insert( eij ).second ) continue; if ( eij->isTrue( ) || eij->isFalse( ) ) continue; // Add new atom and get variable v = theory_handler->enodeToVar( eij ); // Initialize congruence data structure egraph.initializeCong( eij ); } */ } #ifdef STATISTICS ie_generated ++; #endif assert( v != var_Undef ); assert( polarity.size( ) > v ); // Assign to false first. We merge the least possible // Alternatively we can merge the most, or polarity[ v ] = ( pol == l_True ? false : ( pol == l_False ? true : true ) ); return v; } #ifdef PRODUCE_PROOF // // e belongs either to one partition or // to several consecutive. We set the interpolant // to be TTTTFFFF where the changing point // is the first partition e belongs to. Notice // that this clause contains only e and its variations // so, whatever is the color for e is the color for the // clause // Enode * CoreSMTSolver::computeAxiomInterp( vector< Enode * > & clause ) { ipartitions_t clause_parts = clause[ 0 ]->isNot( ) ? clause[ 0 ]->get1st( )->getIPartitions( ) : clause[ 0 ]->getIPartitions( ) ; for ( size_t i = 1 ; i < clause.size( ) ; i ++ ) { clause_parts &= clause[ i ]->isNot( ) ? clause[ i ]->get1st( )->getIPartitions( ) : clause[ i ]->getIPartitions( ) ; } list< Enode * > in_list; // Set the mask as 1..10 ipartitions_t mask = 1; mask = ~mask; Enode * curr_int = egraph.mkTrue( ); // Scan the various partitions for( unsigned in = 1 ; in < egraph.getNofPartitions( ) ; in ++ ) { // mask &= ~SETBIT( in ); clrbit( mask, in ); // McMillan algo, set AB to B if ( config.itp_bool_alg() == 0 ) { if ( isAstrict( clause_parts, mask ) ) curr_int = egraph.mkFalse( ); else curr_int = egraph.mkTrue( ); } // McMillan' algo, set AB to A else if ( config.itp_bool_alg() == 2 ) { if ( isBstrict( clause_parts, mask ) ) curr_int = egraph.mkTrue( ); else curr_int = egraph.mkFalse( ); } // For pudlak we don't care ... else if ( config.itp_bool_alg() == 1 && isAlocal( clause_parts, mask ) ) curr_int = egraph.mkFalse( ); in_list.push_front( curr_int ); } return egraph.cons( in_list ); } #endif opensmt-2.5.2/src/smtsolvers/TheoryIF.cc000066400000000000000000000352511445011647600202330ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #include #include "CoreSMTSolver.h" #include "Proof.h" #include #include // Stress test the theory solver void CoreSMTSolver::crashTest(int rounds, Var var_true, Var var_false) { srand(0); for (int i = 1; i < nVars(); i++) { int stack_sz = 0; vec tmp_trail; // <- add literals here for (int j = 0; j < rounds; j++) { // clause lengths for (int k = stack_sz; k < i; k++) { Var v = rand() % nVars(); if (v == var_true) { tmp_trail.push(mkLit(v, false)); } else if (v == var_false) { tmp_trail.push(mkLit(v, true)); } else { tmp_trail.push(mkLit(v, rand() % 2)); } } printf("Stack contains %d literals of which %d new\n", tmp_trail.size(), tmp_trail.size()-stack_sz); stack_sz = tmp_trail.size_(); bool res = theory_handler.assertLits(tmp_trail); int new_stack_sz; if (res == false) { printf("Conflict\n"); new_stack_sz = 0; } else new_stack_sz = rand() % (i+1); theory_handler.backtrack(new_stack_sz); tmp_trail.shrink(stack_sz - new_stack_sz); stack_sz = new_stack_sz; assert(tmp_trail.size() == stack_sz); } } } namespace { std::vector sortByLastAssignedLevel(std::vector> & splitClauses, std::function getVarLevel) { if (splitClauses.size() == 1) { return {0}; } std::vector lastAssignedLevels; lastAssignedLevels.resize(splitClauses.size(), 0); std::transform(splitClauses.begin(), splitClauses.end(), lastAssignedLevels.begin(), [&](auto const & clause) { auto maxLevel = 0; for (Lit l : clause) { auto level = getVarLevel(var(l)); if (level > maxLevel) { maxLevel = level; } } return maxLevel; }); std::vector indices(splitClauses.size()); std::iota(indices.begin(), indices.end(), 0); std::sort(indices.begin(), indices.end(), [&lastAssignedLevels](int first, int second) { return lastAssignedLevels[first] < lastAssignedLevels[second]; }); return indices; } } TPropRes CoreSMTSolver::handleNewSplitClauses(SplitClauses & splitClauses) { vec deds; deduceTheory(deds); // To remove possible theory deductions TPropRes res = TPropRes::Undef; struct PropagationData { Lit lit; CRef reason; }; std::vector propData; auto processNewClause = [&] (auto const & clause) { CRef cr = ca.alloc(clause); attachClause(cr); clauses.push(cr); if (logsProofForInterpolation()) { // MB: the proof needs to know about the new clause proof->newSplitClause(cr); } return cr; }; auto sortedIndices = sortByLastAssignedLevel(splitClauses, [this](Var v) { return v < nVars() ? vardata[v].level : 0; }); for (int index : sortedIndices) { auto & splitClause = splitClauses[index]; unsigned satisfied = 0; unsigned unknown = 0; // MB: ensure the SAT solver knows about the variables and that they are active int impliedIndex = -1; for (int i = 0; i < splitClause.size(); ++i) { Lit l = splitClause[i]; addVar_(var(l)); if (value(l) == l_True) { ++satisfied; } else if (value(l) != l_False) { ++unknown; impliedIndex = i; } } assert(satisfied != 0 or unknown != 0); // The clause cannot be falsified if (satisfied == 0 and unknown == 1) { // propagate // Find the lowest level where all the falsified literals are still falsified int backtrackLevel = 0; for (Lit l : splitClause) { if (value(l) == l_False and vardata[var(l)].level > backtrackLevel) { backtrackLevel = vardata[var(l)].level; } } if (backtrackLevel < decisionLevel()) { assert(propData.empty()); // This should hold when clauses are sorted according to last assigned level propData.clear(); // But let's make sure cancelUntil(backtrackLevel); } if (!this->logsProofForInterpolation()) { if (decisionLevel() == 0) { // MB: do not allocate, we can directly enqueue the implied literal uncheckedEnqueue(splitClause[impliedIndex], CRef_Undef); res = TPropRes::Propagate; continue; } } // MB: we are going to propagate, make sure the implied literal is the first one Lit implied = splitClause[impliedIndex]; std::swap(splitClause[0],splitClause[impliedIndex]); CRef cr = processNewClause(splitClause); propData.push_back(PropagationData{.lit = implied, .reason = cr}); res = TPropRes::Propagate; } else { // MB: ensure that that the first literal is not falsified if (value(splitClause[0]) == l_False and impliedIndex != -1) { std::swap(splitClause[0],splitClause[impliedIndex]); } processNewClause(splitClause); if (satisfied == 0) { if (res != TPropRes::Propagate) { res = TPropRes::Decide; } } } } assert(res != TPropRes::Undef); if (res == TPropRes::Propagate) { assert(std::all_of(propData.begin(), propData.end(), [this](auto const & datum){ return value(var(datum.lit)) == l_Undef; })); for (auto [litToPropogate, reason] : propData) { // MB: same literal can be added multiple times, coming from different clauses if (value(litToPropogate) == l_Undef) { uncheckedEnqueue(litToPropogate, reason); } else { assert(value(litToPropogate) == l_True); } } } return res; } TPropRes CoreSMTSolver::handleSat() { // Increments skip step for sat calls skip_step *= config.sat_skip_step_factor; auto newSplitClauses = theory_handler.getNewSplits(); if (not newSplitClauses.empty()) { return handleNewSplitClauses(newSplitClauses); } // Theory propagate vec deds; deduceTheory(deds); // deds will be ordered by decision levels for (int i = 0; i < deds.size(); i++) { Lit l = deds[i].l; if (deds[i].lev != decisionLevel()) { // Maybe do something someday? } CRef deducedReason = CRef_Fake; if (decisionLevel() == 0 and logsProofForInterpolation()) { vec reasonLits; theory_handler.getReason(l, reasonLits); assert(reasonLits.size() > 0); CRef theoryReason = ca.alloc(reasonLits); CRef unit = ca.alloc(vec{l}); proof->newTheoryClause(theoryReason); proof->beginChain(theoryReason); Clause const & clause = ca[theoryReason]; for (unsigned j = 0; j < clause.size(); ++j) { if (clause[j] != l) { proof->addResolutionStep(reason(var(clause[j])), var(clause[j])); } } proof->endChain(unit); vardata[var(l)].reason = unit; deducedReason = unit; } uncheckedEnqueue(l, deducedReason); } if (deds.size() > 0) { return TPropRes::Propagate; } skip_step *= config.sat_skip_step_factor; return TPropRes::Decide; // Sat and nothing to deduce, time for decision } TPropRes CoreSMTSolver::handleUnsat() { // // Query is T-Unsatisfiable // // Reset skip step for uns calls skip_step = config.sat_initial_skip_step; if (!logsProofForInterpolation()) { // Top-level conflict, problem is T-Unsatisfiable if (decisionLevel() == 0) { return TPropRes::Unsat; } } vec< Lit > conflicting; vec< Lit > learnt_clause; int max_decision_level; int backtrack_level; theory_handler.getConflict(conflicting, vardata, max_decision_level); assert(std::none_of(conflicting.begin(), conflicting.end(), [this](Lit l) { return value(l) == l_Undef; })); assert( max_decision_level <= decisionLevel( ) ); cancelUntil( max_decision_level ); if ( decisionLevel( ) == 0 ) { if (logsProofForInterpolation()) { // All conflicting atoms are dec-level 0 CRef confl = config.sat_temporary_learn ? ca.alloc(conflicting, {true, computeGlue(conflicting)}) : ca.alloc(conflicting); proof->newTheoryClause(confl); this->finalizeProof(confl); } return TPropRes::Unsat; } CRef confl = CRef_Undef; assert( conflicting.size( ) > 0 ); bool learnOnlyTemporary = conflicting.size() > config.sat_learn_up_to_size; if (learnOnlyTemporary || conflicting.size( ) == 1 ) // That might happen in bit-vector theories { confl = ca.alloc(conflicting); } // Learn theory lemma else { confl = config.sat_temporary_learn ? ca.alloc(conflicting, {true, computeGlue(conflicting)}) : ca.alloc(conflicting); learnts.push(confl); attachClause(confl); claBumpActivity(ca[confl]); learnt_t_lemmata ++; if ( !config.sat_temporary_learn ) perm_learnt_t_lemmata ++; } assert( confl != CRef_Undef ); learnt_clause.clear(); if (logsProofForInterpolation()) { proof->newTheoryClause(confl); } analyze(confl, learnt_clause, backtrack_level); if (!logsProofForInterpolation()) { // Get rid of the temporary lemma if (learnOnlyTemporary) { ca.free(confl); } } cancelUntil(backtrack_level); assert(value(learnt_clause[0]) == l_Undef); if (learnt_clause.size() == 1) { CRef reason = CRef_Undef; if (logsProofForInterpolation()) { CRef cr = ca.alloc(learnt_clause); proof->endChain(cr); reason = cr; } uncheckedEnqueue(learnt_clause[0], reason); } else { // ADDED FOR NEW MINIMIZATION learnts_size += learnt_clause.size( ); all_learnts ++; CRef cr = ca.alloc(learnt_clause, {true, computeGlue(learnt_clause)}); if (logsProofForInterpolation()) { proof->endChain(cr); } learnts.push(cr); learnt_theory_conflicts++; undo_stack.push(undo_stack_el(undo_stack_el::NEWLEARNT, cr)); attachClause(cr); claBumpActivity(ca[cr]); uncheckedEnqueue(learnt_clause[0], cr); } varDecayActivity(); claDecayActivity(); return TPropRes::Propagate; } /** * Performs the consistency check of current assignment in the theory and returns the next action for the SAT solver. * TPropRes::Unsat - 0-level theory conflict has been detected, the whole problem is UNSAT * TPropRes::Propagate - New literal has been enqued to the trail, propagation phase should follow * TPropRes::Decide - Current assignment is consistent, no propagation detected, SAT solver should decide next variable * * Note that if theory conflict is detected, this conflict is handled in handleUnsat() method. * The solver can either backtrack to consistent state, learn theory clause and return TPropRes::Propagate * or if the conflict is on level 0, return TPropRes::Unsat to indicate that the whole problem is UNSAT * * @param complete should the theory check be complete or simpler (sound but not necessary complete) check can be used * @param conflictC conflict counter * @return The action SAT solver should perform next */ TPropRes CoreSMTSolver::checkTheory(bool complete, int& conflictC) { // Skip calls to theory solvers // (does not seem to be helpful ...) if ( !complete && skipped_calls + config.sat_initial_skip_step < skip_step ) { skipped_calls ++; return TPropRes::Decide; } skipped_calls = 0; TRes res = theory_handler.assertLits(trail) ? theory_handler.check(complete) : TRes::UNSAT; // // Problem is T-Satisfiable // if ( res == TRes::SAT ) return handleSat(); else if (res == TRes::UNSAT) { conflicts++; conflictC++; return handleUnsat(); } assert(res == TRes::UNKNOWN); return TPropRes::Decide; } // // Return a vector containing deduced literals and their decision levels // void CoreSMTSolver::deduceTheory(vec& deductions) { Lit ded = lit_Undef; while (true) { ded = theory_handler.getDeduction(); if (ded == lit_Undef) break; if (value(ded) != l_Undef) continue; // Found an unassigned deduction deductions.push(LitLev(ded, decisionLevel())); } #ifdef PEDANTIC_DEBUG int max_lev = -1; for (int i = 0; i < deductions.size(); i++) { if (deductions[i].lev < max_lev) { cerr << "Bling! Expected less than " << max_lev; cerr << " " << deductions[i].lev << endl; } max_lev = deductions[i].lev; } #endif return; }opensmt-2.5.2/src/smtsolvers/TheoryInterpolator.h000066400000000000000000000130721445011647600222560ustar00rootroot00000000000000#ifndef THEORY_INTERPOLATOR_H #define THEORY_INTERPOLATOR_H #include "PtStore.h" #include "PartitionManager.h" #include "OsmtInternalException.h" #include #include class TermColorInfo { public: virtual icolor_t getColorFor(PTRef term) = 0; virtual ~TermColorInfo() = default; }; class GlobalTermColorInfo : public TermColorInfo { public: GlobalTermColorInfo(PartitionManager & pmanager, ipartitions_t mask) : pmanager(pmanager), mask(std::move(mask)) {} icolor_t getColorFor(PTRef term) override { auto const & termMask = pmanager.getIPartitions(term); auto res = getColorForMask(termMask); if (res == icolor_t::I_UNDEF) { throw OsmtInternalException("No color detected for term"); } return res; } private: PartitionManager & pmanager; ipartitions_t mask; icolor_t getColorForMask(ipartitions_t const & otherMask) { bool isInA = (otherMask & mask) != 0; bool isInB = (otherMask & ~mask) != 0; if (isInA and not isInB) { return icolor_t::I_A; } if (isInB and not isInA) { return icolor_t::I_B; } if (isInA and isInB) { return icolor_t::I_AB; } return icolor_t::I_UNDEF; } }; /* * Stores color information for a set of terms given the colors of top-level term. * * Terms can be A-local, B-local, or AB-shared. * Note: If a term f(x) is local, but both the function symbol and all the arguments are AB-shared, * then f(x) will also be stored as shared. */ class LocalTermColorInfo : public TermColorInfo { public: template LocalTermColorInfo(TMap const & topLevelMap, Logic const & logic) { termColors[logic.getTerm_true()] = icolor_t::I_AB; termColors[logic.getTerm_false()] = icolor_t::I_AB; computeColorsForAllSubterms(topLevelMap, logic); } icolor_t getColorFor(PTRef term) override { auto it = termColors.find(term); if (it == termColors.end()) { throw OsmtInternalException("No color detected for term"); } return it->second; } private: std::unordered_map termColors; template void computeColorsForAllSubterms(TMap const & topLevelColors, Logic const & logic) { // MB: NOTE! If P(a) is A-local, but both symbols P and a are shared, than P(a) should be shared and not A-local using entry_t = std::pair; auto colorUnion = [](icolor_t f, icolor_t s) { return f | s; }; std::vector queue; for (auto entry : topLevelColors) { queue.push_back(entry); } std::unordered_map symbolColors; while (not queue.empty()) { auto const entry = queue.back(); icolor_t colorToAssign = entry.second; PTRef term = entry.first; queue.pop_back(); auto it = termColors.find(term); if (it != termColors.end()) { icolor_t assignedColor = it->second; if (assignedColor == colorToAssign || assignedColor == icolor_t::I_AB) { // already processed, color does not change continue; } else { // assigning new color assert(assignedColor == icolor_t::I_A or assignedColor == icolor_t::I_B); colorToAssign = colorUnion(colorToAssign, assignedColor); assert(colorToAssign == icolor_t::I_AB); } } // if we reach here, we need to propagate colorToAssign to the whole term subtree of `term` termColors[term] = colorToAssign; for (PTRef child : logic.getPterm(term)) { queue.emplace_back(child, colorToAssign); } // add symbol information auto insertRes = symbolColors.insert(std::make_pair(logic.getSymRef(term), colorToAssign)); if (not insertRes.second) { // there was entry for this symbol already auto entryIt = insertRes.first; entryIt->second = colorUnion(entryIt->second, colorToAssign); } } // Make sure complex terms have correct color assigned vec terms; for (auto const & entry : termColors) { PTRef term = entry.first; if (entry.second != icolor_t::I_AB and (logic.isUF(term) or logic.isUP(term)) and symbolColors.at(logic.getSymRef(term)) == icolor_t::I_AB) { terms.push(term); } } sort(terms, [](PTRef p, PTRef q) { return p.x > q.x; }); // to process children before parents for (PTRef term : terms) { auto & color = termColors.at(term); assert(color != icolor_t::I_AB and (logic.isUF(term) or logic.isUP(term))); assert(symbolColors.at(logic.getSymRef(term)) == icolor_t::I_AB); // if symbol is AB and all children are AB, this term should also be AB Pterm const & pterm = logic.getPterm(term); bool hasLocalChild = std::any_of(pterm.begin(), pterm.end(), [this](PTRef child) { return termColors.at(child) != icolor_t::I_AB; }); if (not hasLocalChild) { // everything is AB -> update color = icolor_t::I_AB; } } } }; class TheoryInterpolator { public: using ItpColorMap = std::map; virtual PTRef getInterpolant(const ipartitions_t&, ItpColorMap *, PartitionManager &pmanager) = 0; }; #endif //THEORY_INTERPOLATOR_H opensmt-2.5.2/src/sorts/000077500000000000000000000000001445011647600151565ustar00rootroot00000000000000opensmt-2.5.2/src/sorts/CMakeLists.txt000066400000000000000000000001511445011647600177130ustar00rootroot00000000000000add_library(sorts OBJECT SStore.cc) install(FILES SSort.h SStore.h DESTINATION ${INSTALL_HEADERS_DIR}) opensmt-2.5.2/src/sorts/SSort.h000066400000000000000000000136111445011647600164030ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ #ifndef SORT_H #define SORT_H #include "Vec.h" #include "Alloc.h" #include struct SSymRef { uint32_t x; SSymRef & operator= (uint32_t v) { x = v; return *this; } inline friend bool operator== (SSymRef a1, SSymRef a2) {return a1.x == a2.x; } inline friend bool operator!= (SSymRef a1, SSymRef a2) {return a1.x != a2.x; } }; const static struct SSymRef SSymRef_Undef = {INT32_MAX}; struct SSymRefHash { uint32_t operator () (SSymRef s) const { return (uint32_t)s.x; } }; struct SortSymbol { static constexpr unsigned int INTERNAL = 0x1; std::string name; unsigned int arity; unsigned int flags; SortSymbol(std::string name_, unsigned int arity) : name(std::move(name_)), arity(arity), flags(0) {}; SortSymbol(std::string name_, unsigned int arity, unsigned int flags) : name(std::move(name_)), arity(arity), flags(flags) {}; SortSymbol(SortSymbol &&) = default; SortSymbol(SortSymbol const &) = default; bool isInternal() const { return (flags & INTERNAL) != 0; }; }; struct SRef { uint32_t x; SRef & operator= (uint32_t v) { x = v; return *this; } inline friend bool operator== (SRef a1, SRef a2) {return a1.x == a2.x; } inline friend bool operator!= (SRef a1, SRef a2) {return a1.x != a2.x; } }; const static struct SRef SRef_Undef = {INT32_MAX}; const static struct SRef SRef_Nil = {INT32_MAX-1}; struct SRefHash { uint32_t operator () (const SRef& s) const { return (uint32_t)s.x; } }; using sortid_t = int; class Sort { private: SSymRef symRef; sortid_t uniq_id; uint32_t size; SRef args[0]; public: Sort(SSymRef symRef_, sortid_t uniq_id_, vec const & rest) : symRef(symRef_) , uniq_id(uniq_id_) , size(rest.size_()) { for (int i = 0; i < rest.size(); i++) args[i] = rest[i]; } inline sortid_t getId() const { return uniq_id; }; SSymRef getSymRef() const { return symRef; } uint32_t getSize() const { return size; } SRef operator[](uint32_t index) const { assert(index < size); return args[index]; } }; struct SortKey { SSymRef sym; vec args; SortKey(SSymRef _sym, vec && _args) : sym(_sym), args(std::move(_args)) { } friend bool operator== (SortKey const & k1, SortKey const & k2) { if (k1.sym != k2.sym) return false; if (k1.args.size() != k2.args.size()) return false; for (int i = 0; i < k1.args.size(); i++) if (k1.args[i] != k2.args[i]) return false; return true; } }; class SortSymbolAllocator : public RegionAllocator { static int SortSymbolWord32Size() { return sizeof(SortSymbol) / sizeof(uint32_t); } public: SortSymbolAllocator() {} SortSymbolAllocator(uint32_t init_capacity): RegionAllocator(init_capacity) {} SSymRef alloc(SortSymbol symbol) { uint32_t v = RegionAllocator::alloc(SortSymbolWord32Size()); SSymRef sid {v}; new (lea(sid)) SortSymbol(std::move(symbol)); return sid; } SortSymbol& operator[](SSymRef r) { return (SortSymbol&)RegionAllocator::operator[](r.x); } const SortSymbol& operator[](SSymRef r) const { return (SortSymbol&)RegionAllocator::operator[](r.x); } SortSymbol* lea (SSymRef r) { return (SortSymbol*)RegionAllocator::lea(r.x); } void free(SSymRef) { RegionAllocator::free(SortSymbolWord32Size()); } }; class SortAllocator : public RegionAllocator { sortid_t static_uniq_id = 0; static int SortWord32Size(int size) { return (sizeof(Sort) + sizeof(SRef)*size) / sizeof(uint32_t); } public: SortAllocator() {} SortAllocator(uint32_t init_capacity): RegionAllocator(init_capacity) {} void moveTo(SortAllocator &to) { RegionAllocator::moveTo(to); } SRef alloc(SortKey const & key) { uint32_t v = RegionAllocator::alloc(SortWord32Size(key.args.size())); SRef sid = {v}; new (lea(sid)) Sort(key.sym, static_uniq_id++, key.args); return sid; } Sort& operator[](SRef r) { return (Sort&)RegionAllocator::operator[](r.x); } const Sort& operator[](SRef r) const { return (Sort&)RegionAllocator::operator[](r.x); } Sort* lea (SRef r) { return (Sort*)RegionAllocator::lea(r.x); } Ref ael (const Sort* t){ return RegionAllocator::ael((uint32_t*)t); } void free(SRef sr) { Sort& s = operator[](sr); RegionAllocator::free(SortWord32Size(s.getSize())); } }; #endif // SORT_H opensmt-2.5.2/src/sorts/SStore.cc000066400000000000000000000043731445011647600167130ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #include "SStore.h" #include #include bool SStore::peek(SortSymbol const & symbol, SSymRef & outRef) const { auto it = this->sortSymbolTable.find(symbol.name); if (it != sortSymbolTable.end()) { outRef = it->second; return true; } return false; } SSymRef SStore::newSortSymbol(SortSymbol symbol) { SSymRef res; assert(not peek(symbol, res)); res = ssa.alloc(symbol); sortSymbolTable.insert({std::move(symbol.name), res}); sortSymbols.push(res); return res; } opensmt::pair SStore::getOrCreateSort(SSymRef symbolRef, vec && rest) { SortKey key(symbolRef, std::move(rest)); auto it = sortTable.find(key); if (it != sortTable.end()) { return {it->second, false}; } SRef sr = sa.alloc(key); sorts.push(sr); auto emplaceRes = sortTable.emplace(std::move(key), sr); assert(emplaceRes.second); (void)emplaceRes; return {sr, true}; } opensmt-2.5.2/src/sorts/SStore.h000066400000000000000000000065701445011647600165560ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #ifndef SSTORE_H #define SSTORE_H #include "SSort.h" #include "Alloc.h" #include "TypeUtils.h" #include #include struct SortHash { uint32_t operator() (const SortKey& s) const { auto v = (uint32_t)s.sym.x; for (SRef arg : s.args) { v += (uint32_t)arg.x; } return v; } }; class SStore { private: SortAllocator sa {512}; SortSymbolAllocator ssa {512}; std::unordered_map sortTable; std::unordered_map sortSymbolTable; vec sorts; vec sortSymbols; public: SStore() = default; ~SStore() = default; //=========================================================================== // Public APIs for sort construction/destruction bool peek(SortSymbol const & symbol, SSymRef & outRef) const; SSymRef newSortSymbol(SortSymbol symbol); Sort const & operator [](SRef sr) const { return sa[sr]; } SortSymbol const & operator [](SSymRef sr) const { return ssa[sr]; } opensmt::pair getOrCreateSort(SSymRef symbolRef, vec && rest); SSymRef getSortSym(SRef sr) const { return sa[sr].getSymRef(); } std::string getSortSymName(SSymRef ssr) const { return ssa[ssr].name; } std::string getSortSymName(SRef sr) const { return getSortSymName(getSortSym(sr)); } unsigned int getSortSymSize(SSymRef ssr) const { return ssa[ssr].arity; } std::string printSort (SRef sr) const { std::string name = getSortSymName(sr); if (sa[sr].getSize() > 0) { name = "(" + name + " "; for (unsigned i = 0; i < sa[sr].getSize(); i++) { name += printSort(sa[sr][i]) + (i == sa[sr].getSize() - 1 ? "" : " "); } name += ")"; } return name; } int getSize(SRef sr) const { return sa[sr].getSize(); } const vec& getSorts() const { return sorts; } const vec& getSortSyms() const { return sortSymbols; } int numSorts() const { return sorts.size(); } }; #endif opensmt-2.5.2/src/symbols/000077500000000000000000000000001445011647600154745ustar00rootroot00000000000000opensmt-2.5.2/src/symbols/CMakeLists.txt000066400000000000000000000005571445011647600202430ustar00rootroot00000000000000add_library(symbols OBJECT "") target_sources(symbols PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/Symbol.h" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/SymRef.h" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/SymStore.h" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/SymStore.cc" ) #target_link_libraries(symbols sorts) install(FILES Symbol.h SymStore.h SymRef.h DESTINATION ${INSTALL_HEADERS_DIR}) opensmt-2.5.2/src/symbols/SymRef.h000066400000000000000000000036751445011647600170650ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ #ifndef OPENSMT_SYMREF_H #define OPENSMT_SYMREF_H #include "Map.h" struct SymRef { uint32_t x; void operator= (uint32_t v) { x = v; } inline friend bool operator== (const SymRef& a1, const SymRef& a2) {return a1.x == a2.x; } inline friend bool operator!= (const SymRef& a1, const SymRef& a2) {return a1.x != a2.x; } }; const static struct SymRef SymRef_Undef = {INT32_MAX}; const static struct SymRef SymRef_Nil = {INT32_MAX-1}; struct SymRefHash { uint32_t operator () (const SymRef& s) const { return (uint32_t)s.x; } }; template <> struct Equal { bool operator() (const SymRef& s1, const SymRef& s2) { return s1 == s2; } }; #endif //OPENSMT_SYMREF_H opensmt-2.5.2/src/symbols/SymStore.cc000066400000000000000000000077351445011647600176040ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ #include "string.h" #include "SymStore.h" #include "Symbol.h" const char* SymStore::e_duplicate_symbol = "Symbol Store: symbol already exists"; const int SymStore::symstore_buf_offs_idx = 1; const int SymStore::symref_buf_offs_idx = 2; const int SymStore::symname_buf_offs_idx = 3; SymStore::~SymStore() { for (int i = 0; i < idToName.size(); i++) free(idToName[i]); } SymRef SymStore::newSymb(const char * fname, SRef rsort, vec const & args, SymbolConfig const & symConfig) { // Check if there already is a term called fname with same number of arguments of the same sort auto* symrefs = getRefOrNull(fname); if (symrefs) { const vec& trs = *symrefs; for (SymRef symref : trs) { auto const & symbol = ta[symref]; if (symbol.rsort() == rsort and symbol.nargs() == args.size_() and symbol.commutes() == symConfig.commutes and symbol.noScoping() == symConfig.noScoping and symbol.isInterpreted() == symConfig.isInterpreted) { if (std::equal(symbol.begin(), symbol.end(), args.begin())) { return symref; } } } } bool newsym = (symrefs == nullptr); SymRef tr = ta.alloc(rsort, args, symConfig); SymId id = symbols.size(); symbols.push(tr); char* tmp_name = strdup(fname); idToName.push(tmp_name); // Map the id to name, used in error reporting ta[tr].id = id; // Tell the term its id, used in error reporting, and checking whether two terms could be equal in future? if (newsym) { vec trs; trs.push(tr); symbolTable.insert(tmp_name, trs); } else { symbolTable[tmp_name].push(tr); // Map the name to term reference (why not id?), used in parsing } return tr; } #ifdef PEDANTIC_DEBUG void SymStore::compare(SymStore& other) { if (symbols.size() != other.symbols.size()) assert(false); for (int i = 0; i < symbols.size(); i++) { if (symbols[i] != other.symbols[i]) assert(false); Symbol& my_sym = ta[symbols[i]]; Symbol& other_sym = other.ta[symbols[i]]; my_sym.compare(other_sym); } for (int i = 0; i < idToName.size(); i++) { assert(strcmp(other.idToName[i], idToName[i]) == 0); vec& my_v = symbolTable[idToName[i]]; vec& other_v = other.symbolTable[idToName[i]]; assert(my_v.size() == other_v.size()); for (int j = 0; j < my_v.size(); j++) assert(my_v[j] == other_v[j]); } } void SymStore::check() const { for (int i = 0; i < symbols.size(); i++) assert(operator[] (symbols[i]).id == i); } #endif opensmt-2.5.2/src/symbols/SymStore.h000066400000000000000000000056471445011647600174460ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2016 Antti Hyvarinen 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. *********************************************************************/ #ifndef SymStore_h #define SymStore_h #include "Symbol.h" #include "StringMap.h" class SymStore { private: VecMap > symbolTable; vec symbols; SymbolAllocator ta{1024}; vec idToName; public: ~SymStore(); // Constructs a new symbol. SymRef newSymb(const char *fname, SRef rsort, vec const & args, SymbolConfig const & symConfig); SymRef newSymb(const char *fname, SRef rsort, vec const & args) { return newSymb(fname, rsort, args, SymConf::Default); } bool contains(const char* fname) const { return symbolTable.has(fname); } const vec& nameToRef(const char* s) const { return symbolTable[s]; } vec& nameToRef(const char* s) { return symbolTable[s]; } const vec* getRefOrNull(const char* s) const { return symbolTable.getOrNull(s); } Symbol& operator [] (SymRef sr) { return ta[sr]; } const Symbol& operator [] (SymRef tr) const { return ta[tr]; } const char* getName(SymRef tr) const { return idToName[ta[tr].getId()]; } const vec& getSymbols() const { return symbols; } bool isInterpreted(SymRef sr) const { return ta[sr].isInterpreted(); } #ifdef PEDANTIC_DEBUG void compare(SymStore&); void check() const; #endif private: static const char* e_duplicate_symbol; // For serialization static const int symstore_buf_offs_idx; static const int symref_buf_offs_idx; static const int symname_buf_offs_idx; }; #endif opensmt-2.5.2/src/symbols/Symbol.h000066400000000000000000000177461445011647600171310ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ // Strongly MiniSat inspired implementation for Symbols #ifndef SYMBOL_H #define SYMBOL_H #include "Vec.h" #include "Alloc.h" #include "SSort.h" #include "SymRef.h" typedef uint32_t SymId; // Used as an array index enum class SymbolProperty : char { None, LeftAssoc, RightAssoc, Chainable, Pairwise }; struct SymbolConfig { bool isInterpreted; bool commutes; bool noScoping; SymbolProperty prop; }; namespace SymConf { constexpr auto Default = SymbolConfig{false, false, false, SymbolProperty::None}; constexpr auto Interpreted = SymbolConfig{true, false, false, SymbolProperty::None}; constexpr auto LeftAssoc = SymbolConfig{false, false, false, SymbolProperty::LeftAssoc}; constexpr auto RightAssoc = SymbolConfig{false, false, false, SymbolProperty::RightAssoc}; constexpr auto Chainable = SymbolConfig{false, false, false, SymbolProperty::Chainable}; constexpr auto Pairwise = SymbolConfig{false, false, false, SymbolProperty::Pairwise}; constexpr auto NoScopingLeftAssoc = SymbolConfig{true, false, true, SymbolProperty::LeftAssoc}; constexpr auto NoScopingRightAssoc = SymbolConfig{true, false, true, SymbolProperty::RightAssoc}; constexpr auto NoScopingPairwise = SymbolConfig{true, false, true, SymbolProperty::Pairwise}; constexpr auto NoScopingChainable = SymbolConfig{true, false, true, SymbolProperty::Chainable}; constexpr auto NoScoping = SymbolConfig{true, false, true, SymbolProperty::None}; constexpr auto CommutativeNoScopingLeftAssoc = SymbolConfig{true, true, true, SymbolProperty::LeftAssoc}; constexpr auto CommutativeNoScopingChainable = SymbolConfig{true, true, true, SymbolProperty::Chainable}; constexpr auto CommutativeNoScopingPairwise = SymbolConfig{true, true, true, SymbolProperty::Pairwise}; } enum class SymbolMatcher : char { Any, Interpreted, Uninterpreted }; // args[0].sort is the return sort, rest are arguments. class Symbol { struct Header { unsigned type : 3; unsigned commutes : 1; unsigned noscoping : 1; unsigned interpreted: 1; unsigned size : 26; Header(unsigned _size, SymbolConfig const & sc) : type(static_cast(sc.prop)) , commutes(sc.commutes) , noscoping(sc.noScoping) , interpreted(sc.isInterpreted) , size(_size) { } }; const Header header; SymId id; // This has to be the last union { SRef sort; SymRef rel; } args[0]; friend class SymbolAllocator; friend class SymStore; // Note: do not use directly (no memory allocation for args) Symbol(SRef rsort, vec const & argSorts, SymbolConfig const & config) : header(argSorts.size_() + 1, config) { assert(config.prop != SymbolProperty::LeftAssoc or nargs() == 2); assert(config.prop != SymbolProperty::RightAssoc or nargs() == 2); args[0].sort = rsort; for (int i = 0; i < argSorts.size(); ++i) args[i+1].sort = argSorts[i]; } public: int size () const { return static_cast(header.size); } SRef operator [] (int i) const { return args[i+1].sort; } /** * @note The function is unsafe: if used in a loop, the loop should in *absolutely no case* build new symbols in the same Symbol allocator * @return A pointer to the first child of the symbol */ SRef const * begin () const { return (SRef*)(args + 1); } /** * @note The function is unsafe: if used in a loop, the loop should in *absolutely no case* build new symbols in the same Symbol allocator * @return A pointer to right past the last child of the symbol */ SRef const * end () const { return (SRef*)(args + size()); } SRef rsort () const { return args[0].sort; } bool commutes () const { return header.commutes; } SymRef relocation () const { return args[0].rel; } SymbolProperty type () const { return static_cast(header.type); } bool left_assoc () const { return static_cast(header.type) == SymbolProperty::LeftAssoc; } bool right_assoc () const { return static_cast(header.type) == SymbolProperty::RightAssoc; } bool chainable () const { return static_cast(header.type) == SymbolProperty::Chainable; } bool pairwise () const { return static_cast(header.type) == SymbolProperty::Pairwise; } bool noScoping () const { return header.noscoping; } uint32_t nargs () const { return size() - 1; } int getId() const { return id; } void setId(int i) { id = i; } bool isInterpreted() const { return header.interpreted; } bool matches(SymbolMatcher matcher) const { switch (matcher) { case SymbolMatcher::Interpreted: return isInterpreted(); case SymbolMatcher::Uninterpreted: return not isInterpreted(); case SymbolMatcher::Any: default: return true; } } }; class SymbolAllocator : public RegionAllocator { static int symWord32Size(int size){ return (sizeof(Symbol) + (sizeof(SRef) * size )) / sizeof(uint32_t); } public: SymbolAllocator(uint32_t start_cap) : RegionAllocator(start_cap) {} SymbolAllocator() = default; void moveTo(SymbolAllocator& to){ RegionAllocator::moveTo(to); } SymRef alloc(SRef rsort, vec const & argSorts, SymbolConfig const & sc) { assert(sizeof(SRef) == sizeof(uint32_t)); assert(sizeof(float) == sizeof(uint32_t)); uint32_t v = RegionAllocator::alloc(symWord32Size(argSorts.size() + 1)); SymRef symid; symid.x = v; new (lea(symid)) Symbol(rsort, argSorts, sc); return symid; } // Deref, Load Effective Address (LEA), Inverse of LEA (AEL): Symbol& operator[](SymRef r) { return (Symbol&)RegionAllocator::operator[](r.x); } const Symbol& operator[](SymRef r) const { return (Symbol&)RegionAllocator::operator[](r.x); } Symbol* lea (SymRef r) { return (Symbol*)RegionAllocator::lea(r.x); } const Symbol* lea (SymRef r) const { return (Symbol*)RegionAllocator::lea(r.x); } SymRef ael (const Symbol* t) { RegionAllocator::Ref r = RegionAllocator::ael((uint32_t*)t); SymRef rf; rf.x = r; return rf; } void free(SymRef symid) { Symbol& s = operator[](symid); RegionAllocator::free(symWord32Size(s.size())); } }; #endif opensmt-2.5.2/src/symmetry/000077500000000000000000000000001445011647600156755ustar00rootroot00000000000000opensmt-2.5.2/src/symmetry/CMakeLists.txt000066400000000000000000000002411445011647600204320ustar00rootroot00000000000000add_library(symmetry STATIC Symmetry.h Symmetry.cc) target_include_directories(symmetry PRIVATE "${CMAKE_SOURCE_DIR}" ) target_link_libraries(symmetry logics) opensmt-2.5.2/src/symmetry/Symmetry.cc000066400000000000000000000264331445011647600200450ustar00rootroot00000000000000#include "Symmetry.h" #include #include #include "symmetry/bliss/utils.hh" #include "bliss/graph.cc" #include "Vec.h" namespace bliss { template class Digraph; } namespace symmetry { //C++11 only //using Cycle = std::vector; //C++98 compatible //typedef std::vector Cycle; // Detector::HookParams::HookParams(const bliss::Digraph& g, Logic& l, PTRef& f) : // graph(g), // logic(l), // formula(f) {} /* Permutation cycle filtering criterion */ bool Detector::CycleFilter::operator()(const Detector::Cycle& cycle) { if(cycle.size() != 2) { return true; } const PTRef* t1 = graph->get_vertex_value(cycle[0]); const PTRef* t2 = graph->get_vertex_value(cycle[1]); SRef sort1 = logic.getSortRef(*t1); SRef sort2 = logic.getSortRef(*t2); return !(logic.hasSortBool(*t1) && sort1 == sort2); } Detector::Detector(Logic& l, PTRef& formula) : nextColor(ARGUMENT_NODES_COLOR), graph( new bliss::Digraph() ), term(formula), logic(l), sbps(PTRef_Undef) { bliss::Digraph::SplittingHeuristic shs_directed = bliss::Digraph::shs_fsm; graph->set_splitting_heuristic(shs_directed); std::stack terms; terms.push(&term); while(!terms.empty()) { PTRef& currentRef = *(terms.top()); Pterm& current = logic.getPterm(currentRef); std::string symbol = logic.getSymName(currentRef); terms.pop(); //if the unique symbol is not already in the graph, add it //Detector::GraphNode symbolNode{addSymbolNode(currentRef, logic)}; Detector::GraphNode rootNode = addRootNode(currentRef); if(current.nargs()) //if arity > 0 { Detector::GraphNode root_node = addRootNode(currentRef); if(commutes(currentRef)) { //std::cerr << " ; The term " << symbol << " commutes" << std::endl; for(int i = 0; i < current.size(); ++i) { const PTRef& ti = current[i]; Detector::GraphNode ti_root_node = addRootNode(ti); graph->add_edge(root_node, ti_root_node); } } else { //TODO: ugly, think of how to fix this //this is necessary because if the term has only one arg it won't enter the next loop if(current.size() == 1) { const PTRef& ti = current[0]; Detector::GraphNode ti_arg_node = addArgumentNode(ti, currentRef); graph->add_edge(root_node, ti_arg_node); } for(int i = 0; i < current.size()-1; ++i) { const PTRef& ti = current[i]; const PTRef& ti_p_one = current[i+1]; Detector::GraphNode ti_arg_node = addArgumentNode(ti, currentRef); Detector::GraphNode ti_p_one_arg_node = addArgumentNode(ti_p_one, currentRef); graph->add_edge(ti_arg_node, ti_p_one_arg_node); if(i == 0) { graph->add_edge(root_node, ti_arg_node); } } } } for(int i = 0; i < current.size(); ++i) { PTRef* c = &(current[i]); terms.push(c); } } } Detector::~Detector() { delete graph; //graph = nullptr; graph = NULL; } /** Exports the generated graph to file in dot format */ void Detector::toDot(const std::string path) { FILE* file = fopen(path.c_str(), "w"); if(file != NULL) { graph->write_dot(file); fclose(file); } //file = nullptr; file = NULL; } /*** Utility to compute the cycle form of a permutation TODO: discuss with antti if it would be better to return a pointer to a vector instead of returning by value */ static std::vector computePermCycles(const unsigned int size, const unsigned int* perm) { assert(size > 0); assert(perm); std::vector cycles; for(unsigned int i = 0; i < size; i++) { unsigned int j = perm[i]; if(j == i) { continue; } bool is_first = true; while(j != i) { if(j < i) { is_first = false; break; } j = perm[j]; } if(!is_first) { continue; } Detector::Cycle cycle; cycle.push_back(i); j = perm[i]; while(j != i) { cycle.push_back(j); j = perm[j]; } cycles.push_back(cycle); } return cycles; } /** Computes the SBPs from a generator. param must be pointing to a Detector instance. */ void Detector::computeSBPs(void *param, unsigned int n, const unsigned int *aut) { //std::cerr << "; Helloooooo" << std::endl; assert(param); //Detector::HookParams* params = static_cast(param); Detector* params = static_cast(param); std::vector cycles = computePermCycles(n,aut); const bliss::Digraph* graph = params->graph; Logic& logic = params->logic; PTRef& formula = params->term; //filter only the "interesting" cycles cycles.erase( std::remove_if(cycles.begin(), cycles.end(), // [&](const Cycle & c) { // if(c.size() != 2) { return true; } // const PTRef* t1 = graph->get_vertex_value(c[0]); // const PTRef* t2 = graph->get_vertex_value(c[1]); // SRef sort1 = logic.getSortRef(*t1); // SRef sort2 = logic.getSortRef(*t2); // return !(logic.hasSortBool(*t1) && sort1 == sort2); // }), Detector::CycleFilter(graph, logic)), cycles.end()); vec sbps; //TODO: refactor this loop in separate function? //for i in {0..n} for(unsigned int i=0; iget_vertex_value(ci[0]); const PTRef* qi = graph->get_vertex_value(ci[1]); vec rhsTerms; rhsTerms.push(*pi); rhsTerms.push(*qi); PTRef rhs = logic.mkImpl(rhsTerms); if(i==0) { //special case, only rhs of the SBP sbps.push(rhs); } else { vec lhsTerms; for(unsigned int j=0; jget_vertex_value(cj[0]); const PTRef* qj = graph->get_vertex_value(cj[1]); vec eq; eq.push(*pj); eq.push(*qj); PTRef con = logic.mkEq(eq); lhsTerms.push(con); } PTRef lhs = logic.mkAnd(lhsTerms); vec final; final.push(lhs); final.push(rhs); PTRef sbp = logic.mkImpl(final); sbps.push(sbp); } } if(params->sbps != PTRef_Undef) { sbps.push(params->sbps); } params->sbps = logic.mkAnd(sbps); //bliss::print_permutation(stderr, n, aut, 0); //fprintf(stderr, "\n"); } /** Augments the formula passed to Detector with the symmetry breaking predicates */ void Detector::findSBPs() { bliss::Stats stats; //HookParams* params = new HookParams(*graph, logic, term); void* hookParams = static_cast(this); graph->find_automorphisms(stats, &Detector::computeSBPs, hookParams); //delete params; } /** Adds a unique symbol node to the graph, or returns it if already exists */ Detector::GraphNode Detector::addSymbolNode(const PTRef& term) { std::string symbol = logic.getSymName(term); if(!cache.symbolNodes.count(symbol)) { //std::cout << "Adding symbol node for " << symbol << "\n"; unsigned int color; //coloring uninterpreted node if(logic.isUF(term) || logic.isUP(term) || logic.isBoolAtom(term)) { //if I already assigned a color to this sort I retrieve it else I create one //std::cerr << "Term " << logic.printTerm(term) << " is uninterpreted\n"; SRef sortRef = logic.getSortRef(term); std::string sortName = logic.getSortName(sortRef); color = ((cache.symbolSortColors.count(sortName)) ? cache.symbolSortColors[sortName] : ++nextColor); cache.symbolSortColors[sortName] = color; } else { //std::cerr << "; Term " << logic.printTerm(term) << " is interpreted\n"; color = ++nextColor; } //const PTRef *termRef{&term}; Detector::GraphNode symNode= graph->add_vertex(color, symbol, &term); //std::cerr << "; [" << symNode << "] " << "Added symbol node " << symbol << std::endl; cache.symbolNodes[symbol] = symNode; return symNode; } return cache.symbolNodes[symbol]; } /** Adds a root node for a term to the graph, or return it if already inserted */ Detector::GraphNode Detector::addRootNode(const PTRef& term) { if(!cache.rootNodes.count(term)) { const Pterm& current = logic.getPterm(term); SRef sortRef = logic.getSortRef(term); std::string symbol = logic.getSymName(term); std::string sortName = logic.getSortName(sortRef); //root nodes get a color based on their sort unsigned int color = ((cache.rootSortColors.count(sortName)) ? cache.rootSortColors[sortName] : ++nextColor); cache.rootSortColors[sortName] = color; //retrieve symbol node //Detector::GraphNode symbolNode{addSymbolNode(term, logic)}; //Detector::GraphNode rootNode{ (current.nargs() == 0) ? symbolNode : graph->add_vertex(color, symbol) }; const PTRef* termRef{&term}; Detector::GraphNode rootNode = graph->add_vertex(color, symbol, &term); //std::cerr << "; [" << rootNode << "] " << "Added root node " << symbol << std::endl; if(current.nargs() > 0) { Detector::GraphNode symbolNode = addSymbolNode(term); graph->add_edge(rootNode, symbolNode); } else //this node is also the symbol node for the term { //std::cerr << "; [" << rootNode << "] " << "Symbold node for " << symbol << " is also symbol node" << std::endl; cache.symbolNodes[symbol] = rootNode; //if symbol node is interpreted, change the color to a unique one if(!(logic.isUF(term) || logic.isUP(term) || logic.isBoolAtom(term))) { unsigned int newColor = ++nextColor; graph->change_color(rootNode, newColor); } //else it is uninterpreted, so set it as the color for symbol nodes of the same sort //or should I leave it as the color for root nodes of the same sort? //(ambiguous in the algorithm description which one gets the priority) else { color = ((cache.symbolSortColors.count(sortName)) ? cache.symbolSortColors[sortName] : ++nextColor); cache.symbolSortColors[sortName] = color; graph->change_color(rootNode, color); } } cache.rootNodes[term] = rootNode; } return cache.rootNodes[term]; } /** Adds an argument node for an argument to the graph, or return it if already inserted */ Detector::GraphNode Detector::addArgumentNode(const PTRef& term, const PTRef& parent) { std::pair key = std::make_pair(term, parent); std::string symbol = logic.getSymName(term); if(!cache.argumentNodes.count(key)) { const PTRef* termRef = &term; //add argument node with specific unique color Detector::GraphNode argumentNode = graph->add_vertex(ARGUMENT_NODES_COLOR, symbol, &term); //std::cerr << "; [" << argumentNode << "] " << "Added symbol node " << symbol << std::endl; cache.argumentNodes[key] = argumentNode; //get root node Detector::GraphNode rootNode = addRootNode(term); //connect argument node to root node graph->add_edge(argumentNode, rootNode); return argumentNode; } return cache.argumentNodes[key]; } /** Check if a term commutes */ bool Detector::commutes(const PTRef& term) { return logic.commutes(logic.getSymRef(term)); } } opensmt-2.5.2/src/symmetry/Symmetry.h000066400000000000000000000032221445011647600176760ustar00rootroot00000000000000#ifndef SYMMETRY_H #define SYMMETRY_H #include #include #include "symmetry/bliss/graph.hh" #include "logics/Logic.h" #include "pterms/Pterm.h" namespace symmetry { class Detector { //for a cleaner interface (?) typedef unsigned int GraphNode; public: typedef std::vector Cycle; Detector(Logic&, PTRef&); ~Detector(); void toDot(const std::string path); void findSBPs(); inline PTRef getSBPs() { return sbps; } static const unsigned int ARGUMENT_NODES_COLOR = 1; //Functor for easy permutation cycle filtering class CycleFilter { const bliss::Digraph* graph; Logic& logic; public: CycleFilter(const bliss::Digraph* g, Logic& l): graph(g), logic(l) {} bool operator()(const Cycle&); }; private: class GraphCache { public: std::map symbolNodes; std::map rootNodes; std::map, GraphNode> argumentNodes; std::map symbolSortColors; std::map rootSortColors; }; friend class GraphCache; //do I really need this? unsigned int nextColor; bliss::Digraph* graph; PTRef& term; Logic& logic; GraphCache cache; PTRef sbps; GraphNode addSymbolNode(const PTRef&); GraphNode addRootNode(const PTRef&); GraphNode addArgumentNode(const PTRef& term, const PTRef& parent); //TODO: shouldn't this be moved to Pterm.h/c? bool commutes(const PTRef&); static void computeSBPs(void*, unsigned int, const unsigned int*); }; } #endif /* SYMMETRY_H */ opensmt-2.5.2/src/symmetry/bliss/000077500000000000000000000000001445011647600170115ustar00rootroot00000000000000opensmt-2.5.2/src/symmetry/bliss/COPYING.txt000066400000000000000000001045131445011647600206660ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, 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 them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If 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 convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU 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 Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "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 PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM 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 PROGRAM (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 PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state 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 program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . opensmt-2.5.2/src/symmetry/bliss/Doxyfile000066400000000000000000001416411445011647600205260ustar00rootroot00000000000000# Doxyfile 1.4.2 # This file describes the settings to be used by the documentation system # doxygen (www.doxygen.org) for a project # # All text after a hash (#) is considered a comment and will be ignored # The format is: # TAG = value [value, ...] # For lists items can also be appended using: # TAG += value [value, ...] # Values that contain spaces should be placed between quotes (" ") #--------------------------------------------------------------------------- # Project related configuration options #--------------------------------------------------------------------------- # The PROJECT_NAME tag is a single word (or a sequence of words surrounded # by quotes) that should identify the project. PROJECT_NAME = # The PROJECT_NUMBER tag can be used to enter a project or revision number. # This could be handy for archiving the generated documentation or # if some version control system is used. PROJECT_NUMBER = # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) # base path where the generated documentation will be put. # If a relative path is entered, it will be relative to the location # where doxygen was started. If left blank the current directory will be used. OUTPUT_DIRECTORY = # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create # 4096 sub-directories (in 2 levels) under the output directory of each output # format and will distribute the generated files over these directories. # Enabling this option can be useful when feeding doxygen a huge amount of # source files, where putting all generated files in the same directory would # otherwise cause performance problems for the file system. CREATE_SUBDIRS = NO # The OUTPUT_LANGUAGE tag is used to specify the language in which all # documentation generated by doxygen is written. Doxygen will use this # information to generate all constant output in the proper language. # The default language is English, other supported languages are: # Brazilian, Catalan, Chinese, Chinese-Traditional, Croatian, Czech, Danish, # Dutch, Finnish, French, German, Greek, Hungarian, Italian, Japanese, # Japanese-en (Japanese with English messages), Korean, Korean-en, Norwegian, # Polish, Portuguese, Romanian, Russian, Serbian, Slovak, Slovene, Spanish, # Swedish, and Ukrainian. OUTPUT_LANGUAGE = English # This tag can be used to specify the encoding used in the generated output. # The encoding is not always determined by the language that is chosen, # but also whether or not the output is meant for Windows or non-Windows users. # In case there is a difference, setting the USE_WINDOWS_ENCODING tag to YES # forces the Windows encoding (this is the default for the Windows binary), # whereas setting the tag to NO uses a Unix-style encoding (the default for # all platforms other than Windows). USE_WINDOWS_ENCODING = NO # If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will # include brief member descriptions after the members that are listed in # the file and class documentation (similar to JavaDoc). # Set to NO to disable this. BRIEF_MEMBER_DESC = YES # If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend # the brief description of a member or function before the detailed description. # Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the # brief descriptions will be completely suppressed. REPEAT_BRIEF = YES # This tag implements a quasi-intelligent brief description abbreviator # that is used to form the text in various listings. Each string # in this list, if found as the leading text of the brief description, will be # stripped from the text and the result after processing the whole list, is # used as the annotated text. Otherwise, the brief description is used as-is. # If left blank, the following values are used ("$name" is automatically # replaced with the name of the entity): "The $name class" "The $name widget" # "The $name file" "is" "provides" "specifies" "contains" # "represents" "a" "an" "the" ABBREVIATE_BRIEF = # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then # Doxygen will generate a detailed section even if there is only a brief # description. ALWAYS_DETAILED_SEC = NO # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all # inherited members of a class in the documentation of that class as if those # members were ordinary class members. Constructors, destructors and assignment # operators of the base classes will not be shown. INLINE_INHERITED_MEMB = NO # If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full # path before files name in the file list and in the header files. If set # to NO the shortest path that makes the file name unique will be used. FULL_PATH_NAMES = YES # If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag # can be used to strip a user-defined part of the path. Stripping is # only done if one of the specified strings matches the left-hand part of # the path. The tag can be used to show relative paths in the file list. # If left blank the directory from which doxygen is run is used as the # path to strip. STRIP_FROM_PATH = # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of # the path mentioned in the documentation of a class, which tells # the reader which header file to include in order to use a class. # If left blank only the name of the header file containing the class # definition is used. Otherwise one should specify the include paths that # are normally passed to the compiler using the -I flag. STRIP_FROM_INC_PATH = # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter # (but less readable) file names. This can be useful is your file systems # doesn't support long names like on DOS, Mac, or CD-ROM. SHORT_NAMES = NO # If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen # will interpret the first line (until the first dot) of a JavaDoc-style # comment as the brief description. If set to NO, the JavaDoc # comments will behave just like the Qt-style comments (thus requiring an # explicit @brief command for a brief description. JAVADOC_AUTOBRIEF = NO # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen # treat a multi-line C++ special comment block (i.e. a block of //! or /// # comments) as a brief description. This used to be the default behaviour. # The new default is to treat a multi-line C++ comment block as a detailed # description. Set this tag to YES if you prefer the old behaviour instead. MULTILINE_CPP_IS_BRIEF = NO # If the DETAILS_AT_TOP tag is set to YES then Doxygen # will output the detailed description near the top, like JavaDoc. # If set to NO, the detailed description appears after the member # documentation. DETAILS_AT_TOP = NO # If the INHERIT_DOCS tag is set to YES (the default) then an undocumented # member inherits the documentation from any documented member that it # re-implements. INHERIT_DOCS = YES # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC # tag is set to YES, then doxygen will reuse the documentation of the first # member in the group (if any) for the other members of the group. By default # all members of a group must be documented explicitly. DISTRIBUTE_GROUP_DOC = NO # If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce # a new page for each member. If set to NO, the documentation of a member will # be part of the file/class/namespace that contains it. SEPARATE_MEMBER_PAGES = NO # The TAB_SIZE tag can be used to set the number of spaces in a tab. # Doxygen uses this value to replace tabs by spaces in code fragments. TAB_SIZE = 8 # This tag can be used to specify a number of aliases that acts # as commands in the documentation. An alias has the form "name=value". # For example adding "sideeffect=\par Side Effects:\n" will allow you to # put the command \sideeffect (or @sideeffect) in the documentation, which # will result in a user-defined paragraph with heading "Side Effects:". # You can put \n's in the value part of an alias to insert newlines. ALIASES = # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C # sources only. Doxygen will then generate output that is more tailored for C. # For instance, some of the names that are used will be different. The list # of all members will be omitted, etc. OPTIMIZE_OUTPUT_FOR_C = NO # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java sources # only. Doxygen will then generate output that is more tailored for Java. # For instance, namespaces will be presented as packages, qualified scopes # will look different, etc. OPTIMIZE_OUTPUT_JAVA = NO # Set the SUBGROUPING tag to YES (the default) to allow class member groups of # the same type (for instance a group of public functions) to be put as a # subgroup of that type (e.g. under the Public Functions section). Set it to # NO to prevent subgrouping. Alternatively, this can be done per class using # the \nosubgrouping command. SUBGROUPING = YES #--------------------------------------------------------------------------- # Build related configuration options #--------------------------------------------------------------------------- # If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in # documentation are documented, even if no documentation was available. # Private class members and static file members will be hidden unless # the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES EXTRACT_ALL = NO # If the EXTRACT_PRIVATE tag is set to YES all private members of a class # will be included in the documentation. EXTRACT_PRIVATE = NO # If the EXTRACT_STATIC tag is set to YES all static members of a file # will be included in the documentation. EXTRACT_STATIC = NO # If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) # defined locally in source files will be included in the documentation. # If set to NO only classes defined in header files are included. EXTRACT_LOCAL_CLASSES = NO # This flag is only useful for Objective-C code. When set to YES local # methods, which are defined in the implementation section but not in # the interface are included in the documentation. # If set to NO (the default) only methods in the interface are included. EXTRACT_LOCAL_METHODS = NO # If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all # undocumented members of documented classes, files or namespaces. # If set to NO (the default) these members will be included in the # various overviews, but no documentation section is generated. # This option has no effect if EXTRACT_ALL is enabled. HIDE_UNDOC_MEMBERS = YES # If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all # undocumented classes that are normally visible in the class hierarchy. # If set to NO (the default) these classes will be included in the various # overviews. This option has no effect if EXTRACT_ALL is enabled. HIDE_UNDOC_CLASSES = YES # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all # friend (class|struct|union) declarations. # If set to NO (the default) these declarations will be included in the # documentation. HIDE_FRIEND_COMPOUNDS = NO # If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any # documentation blocks found inside the body of a function. # If set to NO (the default) these blocks will be appended to the # function's detailed documentation block. HIDE_IN_BODY_DOCS = NO # The INTERNAL_DOCS tag determines if documentation # that is typed after a \internal command is included. If the tag is set # to NO (the default) then the documentation will be excluded. # Set it to YES to include the internal documentation. INTERNAL_DOCS = NO # If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate # file names in lower-case letters. If set to YES upper-case letters are also # allowed. This is useful if you have classes or files whose names only differ # in case and if your file system supports case sensitive file names. Windows # and Mac users are advised to set this option to NO. CASE_SENSE_NAMES = YES # If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen # will show members with their full class and namespace scopes in the # documentation. If set to YES the scope will be hidden. HIDE_SCOPE_NAMES = NO # If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen # will put a list of the files that are included by a file in the documentation # of that file. SHOW_INCLUDE_FILES = YES # If the INLINE_INFO tag is set to YES (the default) then a tag [inline] # is inserted in the documentation for inline members. INLINE_INFO = YES # If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen # will sort the (detailed) documentation of file and class members # alphabetically by member name. If set to NO the members will appear in # declaration order. SORT_MEMBER_DOCS = YES # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the # brief documentation of file, namespace and class members alphabetically # by member name. If set to NO (the default) the members will appear in # declaration order. SORT_BRIEF_DOCS = NO # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be # sorted by fully-qualified names, including namespaces. If set to # NO (the default), the class list will be sorted only by class name, # not including the namespace part. # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. # Note: This option applies only to the class list, not to the # alphabetical list. SORT_BY_SCOPE_NAME = NO # The GENERATE_TODOLIST tag can be used to enable (YES) or # disable (NO) the todo list. This list is created by putting \todo # commands in the documentation. GENERATE_TODOLIST = YES # The GENERATE_TESTLIST tag can be used to enable (YES) or # disable (NO) the test list. This list is created by putting \test # commands in the documentation. GENERATE_TESTLIST = YES # The GENERATE_BUGLIST tag can be used to enable (YES) or # disable (NO) the bug list. This list is created by putting \bug # commands in the documentation. GENERATE_BUGLIST = YES # The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or # disable (NO) the deprecated list. This list is created by putting # \deprecated commands in the documentation. GENERATE_DEPRECATEDLIST= YES # The ENABLED_SECTIONS tag can be used to enable conditional # documentation sections, marked by \if sectionname ... \endif. ENABLED_SECTIONS = # The MAX_INITIALIZER_LINES tag determines the maximum number of lines # the initial value of a variable or define consists of for it to appear in # the documentation. If the initializer consists of more lines than specified # here it will be hidden. Use a value of 0 to hide initializers completely. # The appearance of the initializer of individual variables and defines in the # documentation can be controlled using \showinitializer or \hideinitializer # command in the documentation regardless of this setting. MAX_INITIALIZER_LINES = 30 # Set the SHOW_USED_FILES tag to NO to disable the list of files generated # at the bottom of the documentation of classes and structs. If set to YES the # list will mention the files that were used to generate the documentation. SHOW_USED_FILES = YES # If the sources in your project are distributed over multiple directories # then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy # in the documentation. SHOW_DIRECTORIES = YES # The FILE_VERSION_FILTER tag can be used to specify a program or script that # doxygen should invoke to get the current version for each file (typically from the # version control system). Doxygen will invoke the program by executing (via # popen()) the command , where is the value of # the FILE_VERSION_FILTER tag, and is the name of an input file # provided by doxygen. Whatever the progam writes to standard output # is used as the file version. See the manual for examples. FILE_VERSION_FILTER = #--------------------------------------------------------------------------- # configuration options related to warning and progress messages #--------------------------------------------------------------------------- # The QUIET tag can be used to turn on/off the messages that are generated # by doxygen. Possible values are YES and NO. If left blank NO is used. QUIET = NO # The WARNINGS tag can be used to turn on/off the warning messages that are # generated by doxygen. Possible values are YES and NO. If left blank # NO is used. WARNINGS = YES # If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings # for undocumented members. If EXTRACT_ALL is set to YES then this flag will # automatically be disabled. WARN_IF_UNDOCUMENTED = YES # If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for # potential errors in the documentation, such as not documenting some # parameters in a documented function, or documenting parameters that # don't exist or using markup commands wrongly. WARN_IF_DOC_ERROR = YES # This WARN_NO_PARAMDOC option can be abled to get warnings for # functions that are documented, but have no documentation for their parameters # or return value. If set to NO (the default) doxygen will only warn about # wrong or incomplete parameter documentation, but not about the absence of # documentation. WARN_NO_PARAMDOC = NO # The WARN_FORMAT tag determines the format of the warning messages that # doxygen can produce. The string should contain the $file, $line, and $text # tags, which will be replaced by the file and line number from which the # warning originated and the warning text. Optionally the format may contain # $version, which will be replaced by the version of the file (if it could # be obtained via FILE_VERSION_FILTER) WARN_FORMAT = "$file:$line: $text" # The WARN_LOGFILE tag can be used to specify a file to which warning # and error messages should be written. If left blank the output is written # to stderr. WARN_LOGFILE = #--------------------------------------------------------------------------- # configuration options related to the input files #--------------------------------------------------------------------------- # The INPUT tag can be used to specify the files and/or directories that contain # documented source files. You may enter file names like "myfile.cpp" or # directories like "/usr/src/myproject". Separate the files or directories # with spaces. INPUT = # If the value of the INPUT tag contains directories, you can use the # FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp # and *.h) to filter out the source-files in the directories. If left # blank the following patterns are tested: # *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx # *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm FILE_PATTERNS = # The RECURSIVE tag can be used to turn specify whether or not subdirectories # should be searched for input files as well. Possible values are YES and NO. # If left blank NO is used. RECURSIVE = NO # The EXCLUDE tag can be used to specify files and/or directories that should # excluded from the INPUT source files. This way you can easily exclude a # subdirectory from a directory tree whose root is specified with the INPUT tag. EXCLUDE = # The EXCLUDE_SYMLINKS tag can be used select whether or not files or # directories that are symbolic links (a Unix filesystem feature) are excluded # from the input. EXCLUDE_SYMLINKS = NO # If the value of the INPUT tag contains directories, you can use the # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude # certain files from those directories. EXCLUDE_PATTERNS = # The EXAMPLE_PATH tag can be used to specify one or more files or # directories that contain example code fragments that are included (see # the \include command). EXAMPLE_PATH = bliss.cc # If the value of the EXAMPLE_PATH tag contains directories, you can use the # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp # and *.h) to filter out the source-files in the directories. If left # blank all files are included. EXAMPLE_PATTERNS = # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be # searched for input files to be used with the \include or \dontinclude # commands irrespective of the value of the RECURSIVE tag. # Possible values are YES and NO. If left blank NO is used. EXAMPLE_RECURSIVE = NO # The IMAGE_PATH tag can be used to specify one or more files or # directories that contain image that are included in the documentation (see # the \image command). IMAGE_PATH = # The INPUT_FILTER tag can be used to specify a program that doxygen should # invoke to filter for each input file. Doxygen will invoke the filter program # by executing (via popen()) the command , where # is the value of the INPUT_FILTER tag, and is the name of an # input file. Doxygen will then use the output that the filter program writes # to standard output. If FILTER_PATTERNS is specified, this tag will be # ignored. INPUT_FILTER = # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern # basis. Doxygen will compare the file name with each pattern and apply the # filter if there is a match. The filters are a list of the form: # pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further # info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER # is applied to all files. FILTER_PATTERNS = # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using # INPUT_FILTER) will be used to filter the input files when producing source # files to browse (i.e. when SOURCE_BROWSER is set to YES). FILTER_SOURCE_FILES = NO #--------------------------------------------------------------------------- # configuration options related to source browsing #--------------------------------------------------------------------------- # If the SOURCE_BROWSER tag is set to YES then a list of source files will # be generated. Documented entities will be cross-referenced with these sources. # Note: To get rid of all source code in the generated output, make sure also # VERBATIM_HEADERS is set to NO. SOURCE_BROWSER = NO # Setting the INLINE_SOURCES tag to YES will include the body # of functions and classes directly in the documentation. INLINE_SOURCES = NO # Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct # doxygen to hide any special comment blocks from generated source code # fragments. Normal C and C++ comments will always remain visible. STRIP_CODE_COMMENTS = YES # If the REFERENCED_BY_RELATION tag is set to YES (the default) # then for each documented function all documented # functions referencing it will be listed. REFERENCED_BY_RELATION = NO # If the REFERENCES_RELATION tag is set to YES (the default) # then for each documented function all documented entities # called/used by that function will be listed. REFERENCES_RELATION = NO # If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen # will generate a verbatim copy of the header file for each class for # which an include is specified. Set to NO to disable this. VERBATIM_HEADERS = NO #--------------------------------------------------------------------------- # configuration options related to the alphabetical class index #--------------------------------------------------------------------------- # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index # of all compounds will be generated. Enable this if the project # contains a lot of classes, structs, unions or interfaces. ALPHABETICAL_INDEX = NO # If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then # the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns # in which this list will be split (can be a number in the range [1..20]) COLS_IN_ALPHA_INDEX = 5 # In case all classes in a project start with a common prefix, all # classes will be put under the same header in the alphabetical index. # The IGNORE_PREFIX tag can be used to specify one or more prefixes that # should be ignored while generating the index headers. IGNORE_PREFIX = #--------------------------------------------------------------------------- # configuration options related to the HTML output #--------------------------------------------------------------------------- # If the GENERATE_HTML tag is set to YES (the default) Doxygen will # generate HTML output. GENERATE_HTML = YES # The HTML_OUTPUT tag is used to specify where the HTML docs will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `html' will be used as the default path. HTML_OUTPUT = html # The HTML_FILE_EXTENSION tag can be used to specify the file extension for # each generated HTML page (for example: .htm,.php,.asp). If it is left blank # doxygen will generate files with .html extension. HTML_FILE_EXTENSION = .html # The HTML_HEADER tag can be used to specify a personal HTML header for # each generated HTML page. If it is left blank doxygen will generate a # standard header. HTML_HEADER = # The HTML_FOOTER tag can be used to specify a personal HTML footer for # each generated HTML page. If it is left blank doxygen will generate a # standard footer. HTML_FOOTER = # The HTML_STYLESHEET tag can be used to specify a user-defined cascading # style sheet that is used by each HTML page. It can be used to # fine-tune the look of the HTML output. If the tag is left blank doxygen # will generate a default style sheet. Note that doxygen will try to copy # the style sheet file to the HTML output directory, so don't put your own # stylesheet in the HTML output directory as well, or it will be erased! HTML_STYLESHEET = # If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, # files or namespaces will be aligned in HTML using tables. If set to # NO a bullet list will be used. HTML_ALIGN_MEMBERS = YES # If the GENERATE_HTMLHELP tag is set to YES, additional index files # will be generated that can be used as input for tools like the # Microsoft HTML help workshop to generate a compressed HTML help file (.chm) # of the generated HTML documentation. GENERATE_HTMLHELP = NO # If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can # be used to specify the file name of the resulting .chm file. You # can add a path in front of the file if the result should not be # written to the html output directory. CHM_FILE = # If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can # be used to specify the location (absolute path including file name) of # the HTML help compiler (hhc.exe). If non-empty doxygen will try to run # the HTML help compiler on the generated index.hhp. HHC_LOCATION = # If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag # controls if a separate .chi index file is generated (YES) or that # it should be included in the master .chm file (NO). GENERATE_CHI = NO # If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag # controls whether a binary table of contents is generated (YES) or a # normal table of contents (NO) in the .chm file. BINARY_TOC = NO # The TOC_EXPAND flag can be set to YES to add extra items for group members # to the contents of the HTML help documentation and to the tree view. TOC_EXPAND = NO # The DISABLE_INDEX tag can be used to turn on/off the condensed index at # top of each HTML page. The value NO (the default) enables the index and # the value YES disables it. DISABLE_INDEX = NO # This tag can be used to set the number of enum values (range [1..20]) # that doxygen will group on one line in the generated HTML documentation. ENUM_VALUES_PER_LINE = 4 # If the GENERATE_TREEVIEW tag is set to YES, a side panel will be # generated containing a tree-like index structure (just like the one that # is generated for HTML Help). For this to work a browser that supports # JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+, # Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are # probably better off using the HTML help feature. GENERATE_TREEVIEW = NO # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be # used to set the initial width (in pixels) of the frame in which the tree # is shown. TREEVIEW_WIDTH = 250 #--------------------------------------------------------------------------- # configuration options related to the LaTeX output #--------------------------------------------------------------------------- # If the GENERATE_LATEX tag is set to YES (the default) Doxygen will # generate Latex output. GENERATE_LATEX = NO # The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `latex' will be used as the default path. LATEX_OUTPUT = latex # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be # invoked. If left blank `latex' will be used as the default command name. LATEX_CMD_NAME = latex # The MAKEINDEX_CMD_NAME tag can be used to specify the command name to # generate index for LaTeX. If left blank `makeindex' will be used as the # default command name. MAKEINDEX_CMD_NAME = makeindex # If the COMPACT_LATEX tag is set to YES Doxygen generates more compact # LaTeX documents. This may be useful for small projects and may help to # save some trees in general. COMPACT_LATEX = NO # The PAPER_TYPE tag can be used to set the paper type that is used # by the printer. Possible values are: a4, a4wide, letter, legal and # executive. If left blank a4wide will be used. PAPER_TYPE = a4wide # The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX # packages that should be included in the LaTeX output. EXTRA_PACKAGES = # The LATEX_HEADER tag can be used to specify a personal LaTeX header for # the generated latex document. The header should contain everything until # the first chapter. If it is left blank doxygen will generate a # standard header. Notice: only use this tag if you know what you are doing! LATEX_HEADER = # If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated # is prepared for conversion to pdf (using ps2pdf). The pdf file will # contain links (just like the HTML output) instead of page references # This makes the output suitable for online browsing using a pdf viewer. PDF_HYPERLINKS = NO # If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of # plain latex in the generated Makefile. Set this option to YES to get a # higher quality PDF documentation. USE_PDFLATEX = NO # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. # command to the generated LaTeX files. This will instruct LaTeX to keep # running if errors occur, instead of asking the user for help. # This option is also used when generating formulas in HTML. LATEX_BATCHMODE = NO # If LATEX_HIDE_INDICES is set to YES then doxygen will not # include the index chapters (such as File Index, Compound Index, etc.) # in the output. LATEX_HIDE_INDICES = NO #--------------------------------------------------------------------------- # configuration options related to the RTF output #--------------------------------------------------------------------------- # If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output # The RTF output is optimized for Word 97 and may not look very pretty with # other RTF readers or editors. GENERATE_RTF = NO # The RTF_OUTPUT tag is used to specify where the RTF docs will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `rtf' will be used as the default path. RTF_OUTPUT = rtf # If the COMPACT_RTF tag is set to YES Doxygen generates more compact # RTF documents. This may be useful for small projects and may help to # save some trees in general. COMPACT_RTF = NO # If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated # will contain hyperlink fields. The RTF file will # contain links (just like the HTML output) instead of page references. # This makes the output suitable for online browsing using WORD or other # programs which support those fields. # Note: wordpad (write) and others do not support links. RTF_HYPERLINKS = NO # Load stylesheet definitions from file. Syntax is similar to doxygen's # config file, i.e. a series of assignments. You only have to provide # replacements, missing definitions are set to their default value. RTF_STYLESHEET_FILE = # Set optional variables used in the generation of an rtf document. # Syntax is similar to doxygen's config file. RTF_EXTENSIONS_FILE = #--------------------------------------------------------------------------- # configuration options related to the man page output #--------------------------------------------------------------------------- # If the GENERATE_MAN tag is set to YES (the default) Doxygen will # generate man pages GENERATE_MAN = NO # The MAN_OUTPUT tag is used to specify where the man pages will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `man' will be used as the default path. MAN_OUTPUT = man # The MAN_EXTENSION tag determines the extension that is added to # the generated man pages (default is the subroutine's section .3) MAN_EXTENSION = .3 # If the MAN_LINKS tag is set to YES and Doxygen generates man output, # then it will generate one additional man file for each entity # documented in the real man page(s). These additional files # only source the real man page, but without them the man command # would be unable to find the correct page. The default is NO. MAN_LINKS = NO #--------------------------------------------------------------------------- # configuration options related to the XML output #--------------------------------------------------------------------------- # If the GENERATE_XML tag is set to YES Doxygen will # generate an XML file that captures the structure of # the code including all documentation. GENERATE_XML = NO # The XML_OUTPUT tag is used to specify where the XML pages will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `xml' will be used as the default path. XML_OUTPUT = xml # The XML_SCHEMA tag can be used to specify an XML schema, # which can be used by a validating XML parser to check the # syntax of the XML files. XML_SCHEMA = # The XML_DTD tag can be used to specify an XML DTD, # which can be used by a validating XML parser to check the # syntax of the XML files. XML_DTD = # If the XML_PROGRAMLISTING tag is set to YES Doxygen will # dump the program listings (including syntax highlighting # and cross-referencing information) to the XML output. Note that # enabling this will significantly increase the size of the XML output. XML_PROGRAMLISTING = YES #--------------------------------------------------------------------------- # configuration options for the AutoGen Definitions output #--------------------------------------------------------------------------- # If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will # generate an AutoGen Definitions (see autogen.sf.net) file # that captures the structure of the code including all # documentation. Note that this feature is still experimental # and incomplete at the moment. GENERATE_AUTOGEN_DEF = NO #--------------------------------------------------------------------------- # configuration options related to the Perl module output #--------------------------------------------------------------------------- # If the GENERATE_PERLMOD tag is set to YES Doxygen will # generate a Perl module file that captures the structure of # the code including all documentation. Note that this # feature is still experimental and incomplete at the # moment. GENERATE_PERLMOD = NO # If the PERLMOD_LATEX tag is set to YES Doxygen will generate # the necessary Makefile rules, Perl scripts and LaTeX code to be able # to generate PDF and DVI output from the Perl module output. PERLMOD_LATEX = NO # If the PERLMOD_PRETTY tag is set to YES the Perl module output will be # nicely formatted so it can be parsed by a human reader. This is useful # if you want to understand what is going on. On the other hand, if this # tag is set to NO the size of the Perl module output will be much smaller # and Perl will parse it just the same. PERLMOD_PRETTY = YES # The names of the make variables in the generated doxyrules.make file # are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. # This is useful so different doxyrules.make files included by the same # Makefile don't overwrite each other's variables. PERLMOD_MAKEVAR_PREFIX = #--------------------------------------------------------------------------- # Configuration options related to the preprocessor #--------------------------------------------------------------------------- # If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will # evaluate all C-preprocessor directives found in the sources and include # files. ENABLE_PREPROCESSING = YES # If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro # names in the source code. If set to NO (the default) only conditional # compilation will be performed. Macro expansion can be done in a controlled # way by setting EXPAND_ONLY_PREDEF to YES. MACRO_EXPANSION = NO # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES # then the macro expansion is limited to the macros specified with the # PREDEFINED and EXPAND_AS_PREDEFINED tags. EXPAND_ONLY_PREDEF = NO # If the SEARCH_INCLUDES tag is set to YES (the default) the includes files # in the INCLUDE_PATH (see below) will be search if a #include is found. SEARCH_INCLUDES = YES # The INCLUDE_PATH tag can be used to specify one or more directories that # contain include files that are not input files but should be processed by # the preprocessor. INCLUDE_PATH = # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard # patterns (like *.h and *.hpp) to filter out the header-files in the # directories. If left blank, the patterns specified with FILE_PATTERNS will # be used. INCLUDE_FILE_PATTERNS = # The PREDEFINED tag can be used to specify one or more macro names that # are defined before the preprocessor is started (similar to the -D option of # gcc). The argument of the tag is a list of macros of the form: name # or name=definition (no spaces). If the definition and the = are # omitted =1 is assumed. To prevent a macro definition from being # undefined via #undef or recursively expanded use the := operator # instead of the = operator. PREDEFINED = # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then # this tag can be used to specify a list of macro names that should be expanded. # The macro definition that is found in the sources will be used. # Use the PREDEFINED tag if you want to use a different macro definition. EXPAND_AS_DEFINED = # If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then # doxygen's preprocessor will remove all function-like macros that are alone # on a line, have an all uppercase name, and do not end with a semicolon. Such # function macros are typically used for boiler-plate code, and will confuse # the parser if not removed. SKIP_FUNCTION_MACROS = YES #--------------------------------------------------------------------------- # Configuration::additions related to external references #--------------------------------------------------------------------------- # The TAGFILES option can be used to specify one or more tagfiles. # Optionally an initial location of the external documentation # can be added for each tagfile. The format of a tag file without # this location is as follows: # TAGFILES = file1 file2 ... # Adding location for the tag files is done as follows: # TAGFILES = file1=loc1 "file2 = loc2" ... # where "loc1" and "loc2" can be relative or absolute paths or # URLs. If a location is present for each tag, the installdox tool # does not have to be run to correct the links. # Note that each tag file must have a unique name # (where the name does NOT include the path) # If a tag file is not located in the directory in which doxygen # is run, you must also specify the path to the tagfile here. TAGFILES = # When a file name is specified after GENERATE_TAGFILE, doxygen will create # a tag file that is based on the input files it reads. GENERATE_TAGFILE = # If the ALLEXTERNALS tag is set to YES all external classes will be listed # in the class index. If set to NO only the inherited external classes # will be listed. ALLEXTERNALS = NO # If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed # in the modules index. If set to NO, only the current project's groups will # be listed. EXTERNAL_GROUPS = YES # The PERL_PATH should be the absolute path and name of the perl script # interpreter (i.e. the result of `which perl'). PERL_PATH = /usr/bin/perl #--------------------------------------------------------------------------- # Configuration options related to the dot tool #--------------------------------------------------------------------------- # If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will # generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base # or super classes. Setting the tag to NO turns the diagrams off. Note that # this option is superseded by the HAVE_DOT option below. This is only a # fallback. It is recommended to install and use dot, since it yields more # powerful graphs. CLASS_DIAGRAMS = YES # If set to YES, the inheritance and collaboration graphs will hide # inheritance and usage relations if the target is undocumented # or is not a class. HIDE_UNDOC_RELATIONS = YES # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is # available from the path. This tool is part of Graphviz, a graph visualization # toolkit from AT&T and Lucent Bell Labs. The other options in this section # have no effect if this option is set to NO (the default) HAVE_DOT = NO # If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen # will generate a graph for each documented class showing the direct and # indirect inheritance relations. Setting this tag to YES will force the # the CLASS_DIAGRAMS tag to NO. CLASS_GRAPH = YES # If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen # will generate a graph for each documented class showing the direct and # indirect implementation dependencies (inheritance, containment, and # class references variables) of the class with other documented classes. COLLABORATION_GRAPH = YES # If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen # will generate a graph for groups, showing the direct groups dependencies GROUP_GRAPHS = YES # If the UML_LOOK tag is set to YES doxygen will generate inheritance and # collaboration diagrams in a style similar to the OMG's Unified Modeling # Language. UML_LOOK = NO # If set to YES, the inheritance and collaboration graphs will show the # relations between templates and their instances. TEMPLATE_RELATIONS = NO # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT # tags are set to YES then doxygen will generate a graph for each documented # file showing the direct and indirect include dependencies of the file with # other documented files. INCLUDE_GRAPH = YES # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and # HAVE_DOT tags are set to YES then doxygen will generate a graph for each # documented header file showing the documented files that directly or # indirectly include this file. INCLUDED_BY_GRAPH = YES # If the CALL_GRAPH and HAVE_DOT tags are set to YES then doxygen will # generate a call dependency graph for every global function or class method. # Note that enabling this option will significantly increase the time of a run. # So in most cases it will be better to enable call graphs for selected # functions only using the \callgraph command. CALL_GRAPH = NO # If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen # will graphical hierarchy of all classes instead of a textual one. GRAPHICAL_HIERARCHY = YES # If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES # then doxygen will show the dependencies a directory has on other directories # in a graphical way. The dependency relations are determined by the #include # relations between the files in the directories. DIRECTORY_GRAPH = YES # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images # generated by dot. Possible values are png, jpg, or gif # If left blank png will be used. DOT_IMAGE_FORMAT = png # The tag DOT_PATH can be used to specify the path where the dot tool can be # found. If left blank, it is assumed the dot tool can be found in the path. DOT_PATH = # The DOTFILE_DIRS tag can be used to specify one or more directories that # contain dot files that are included in the documentation (see the # \dotfile command). DOTFILE_DIRS = # The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width # (in pixels) of the graphs generated by dot. If a graph becomes larger than # this value, doxygen will try to truncate the graph, so that it fits within # the specified constraint. Beware that most browsers cannot cope with very # large images. MAX_DOT_GRAPH_WIDTH = 1024 # The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height # (in pixels) of the graphs generated by dot. If a graph becomes larger than # this value, doxygen will try to truncate the graph, so that it fits within # the specified constraint. Beware that most browsers cannot cope with very # large images. MAX_DOT_GRAPH_HEIGHT = 1024 # The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the # graphs generated by dot. A depth value of 3 means that only nodes reachable # from the root by following a path via at most 3 edges will be shown. Nodes # that lay further from the root node will be omitted. Note that setting this # option to 1 or 2 may greatly reduce the computation time needed for large # code bases. Also note that a graph may be further truncated if the graph's # image dimensions are not sufficient to fit the graph (see MAX_DOT_GRAPH_WIDTH # and MAX_DOT_GRAPH_HEIGHT). If 0 is used for the depth value (the default), # the graph is not depth-constrained. MAX_DOT_GRAPH_DEPTH = 0 # Set the DOT_TRANSPARENT tag to YES to generate images with a transparent # background. This is disabled by default, which results in a white background. # Warning: Depending on the platform used, enabling this option may lead to # badly anti-aliased labels on the edges of a graph (i.e. they become hard to # read). DOT_TRANSPARENT = NO # Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output # files in one run (i.e. multiple -o and -T options on the command line). This # makes dot run faster, but since only newer versions of dot (>1.8.10) # support this, this feature is disabled by default. DOT_MULTI_TARGETS = NO # If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will # generate a legend page explaining the meaning of the various boxes and # arrows in the dot generated graphs. GENERATE_LEGEND = YES # If the DOT_CLEANUP tag is set to YES (the default) Doxygen will # remove the intermediate dot files that are used to generate # the various graphs. DOT_CLEANUP = YES #--------------------------------------------------------------------------- # Configuration::additions related to the search engine #--------------------------------------------------------------------------- # The SEARCHENGINE tag specifies whether or not a search engine should be # used. If set to NO the values of all tags below this one will be ignored. SEARCHENGINE = NO opensmt-2.5.2/src/symmetry/bliss/bignum.hh000066400000000000000000000042471445011647600206220ustar00rootroot00000000000000#ifndef BLISS_BIGNUM_HH #define BLISS_BIGNUM_HH /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ #if defined(BLISS_USE_GMP) #include #endif #include #include #include "defs.hh" namespace bliss { /** * \brief A very simple class for big integers (or approximation of them). * * If the compile time flag BLISS_USE_GMP is set, * then the GNU Multiple Precision Arithmetic library (GMP) is used to * obtain arbitrary precision, otherwise "long double" is used to * approximate big integers. */ #if defined(BLISS_USE_GMP) class BigNum { mpz_t v; public: /** * Create a new big number and set it to zero. */ BigNum() {mpz_init(v); } /** * Destroy the number. */ ~BigNum() {mpz_clear(v); } /** * Set the number to \a n. */ void assign(const int n) {mpz_set_si(v, n); } /** * Multiply the number with \a n. */ void multiply(const int n) {mpz_mul_si(v, v, n); } /** * Print the number in the file stream \a fp. */ size_t print(FILE* const fp) const {return mpz_out_str(fp, 10, v); } }; #else class BigNum { long double v; public: /** * Create a new big number and set it to zero. */ BigNum(): v(0.0) {} /** * Set the number to \a n. */ void assign(const int n) {v = (long double)n; } /** * Multiply the number with \a n. */ void multiply(const int n) {v *= (long double)n; } /** * Print the number in the file stream \a fp. */ size_t print(FILE* const fp) const {return fprintf(fp, "%Lg", v); } }; #endif } //namespace bliss #endif opensmt-2.5.2/src/symmetry/bliss/bliss.cc000066400000000000000000000211311445011647600204320ustar00rootroot00000000000000#include #include #include #include #include "defs.hh" #include "graph.hh" #include "timer.hh" #include "utils.hh" /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ /** * \page executable bliss executable * \include bliss.cc */ /* Input file name */ static const char* infilename = 0; static bool opt_directed = false; static bool opt_canonize = false; static const char* opt_output_can_file = 0; static const char* opt_splitting_heuristics = "fsm"; static bool opt_use_failure_recording = true; static bool opt_use_component_recursion = true; /* Verbosity level and target stream */ static unsigned int verbose_level = 1; static FILE* verbstr = stdout; static void usage(FILE* const fp, const char* argv0) { const char* program_name; program_name = rindex(argv0, '/'); if(program_name) program_name++; else program_name = argv0; if(!program_name or *program_name == 0) program_name = "bliss"; fprintf(fp, "bliss version %s (compiled "__DATE__")\n", bliss::version); fprintf(fp, "Copyright 2003-2011 Tommi Junttila\n"); fprintf(fp, "\n" "Usage: %s [options] []\n" "\n" " -directed the input graph is directed\n" " -can compute canonical form\n" " -ocan=f compute canonical form and output it in file f\n" " -v=N set verbose level to N [N >= 0, default: 1]\n" " -sh=X select splitting heuristics, where X is\n" " f first non-singleton cell\n" " fl first largest non-singleton cell\n" " fs first smallest non-singleton cell\n" " fm first maximally non-trivially connected\n" " non-singleton cell\n" " flm first largest maximally non-trivially connected\n" " non-singleton cell\n" " fsm first smallest maximally non-trivially connected\n" " non-singleton cell [default]\n" " -fr=X use failure recording? [X=y/n, default: y]\n" " -cr=X use component recursion? [X=y/n, default: y]\n" " -version print the version number and exit\n" " -help print this help and exit\n" ,program_name ); } static void parse_options(const int argc, const char** argv) { unsigned int tmp; for(int i = 1; i < argc; i++) { if(strcmp(argv[i], "-can") == 0) opt_canonize = true; else if((strncmp(argv[i], "-ocan=", 6) == 0) and (strlen(argv[i]) > 6)) { opt_canonize = true; opt_output_can_file = argv[i]+6; } else if(sscanf(argv[i], "-v=%u", &tmp) == 1) verbose_level = tmp; else if(strcmp(argv[i], "-directed") == 0) opt_directed = true; else if(strcmp(argv[i], "-fr=n") == 0) opt_use_failure_recording = false; else if(strcmp(argv[i], "-fr=y") == 0) opt_use_failure_recording = true; else if(strcmp(argv[i], "-cr=n") == 0) opt_use_component_recursion = false; else if(strcmp(argv[i], "-cr=y") == 0) opt_use_component_recursion = true; else if((strncmp(argv[i], "-sh=", 4) == 0) and (strlen(argv[i]) > 4)) { opt_splitting_heuristics = argv[i]+4; } else if(strcmp(argv[i], "-version") == 0) { fprintf(stdout, "bliss version %s\n", bliss::version); exit(0); } else if(strcmp(argv[i], "-help") == 0) { usage(stdout, argv[0]); exit(0); } else if(argv[i][0] == '-') { fprintf(stderr, "Unknown command line argument `%s'\n", argv[i]); usage(stderr, argv[0]); exit(1); } else { if(infilename) { fprintf(stderr, "Too many file arguments\n"); usage(stderr, argv[0]); exit(1); } else { infilename = argv[i]; } } } } /** * The hook function that prints the found automorphisms. * \a param must be a file descriptor (FILE *). */ static void report_aut(void* param, const unsigned int n, const unsigned int* aut) { assert(param); fprintf((FILE*)param, "Generator: "); bliss::print_permutation((FILE*)param, n, aut, 1); fprintf((FILE*)param, "\n"); } /* Output an error message and exit the whole program */ static void _fatal(const char* fmt, ...) { va_list ap; va_start(ap, fmt); vfprintf(stderr, fmt, ap); fprintf(stderr, "\n"); va_end(ap); exit(1); } int main(const int argc, const char** argv) { bliss::Timer timer; bliss::AbstractGraph* g = 0; parse_options(argc, argv); /* Parse splitting heuristics */ bliss::Digraph::SplittingHeuristic shs_directed = bliss::Digraph::shs_fsm; bliss::Graph::SplittingHeuristic shs_undirected = bliss::Graph::shs_fsm; if(opt_directed) { if(strcmp(opt_splitting_heuristics, "f") == 0) shs_directed = bliss::Digraph::shs_f; else if(strcmp(opt_splitting_heuristics, "fs") == 0) shs_directed = bliss::Digraph::shs_fs; else if(strcmp(opt_splitting_heuristics, "fl") == 0) shs_directed = bliss::Digraph::shs_fl; else if(strcmp(opt_splitting_heuristics, "fm") == 0) shs_directed = bliss::Digraph::shs_fm; else if(strcmp(opt_splitting_heuristics, "fsm") == 0) shs_directed = bliss::Digraph::shs_fsm; else if(strcmp(opt_splitting_heuristics, "flm") == 0) shs_directed = bliss::Digraph::shs_flm; else _fatal("Illegal option -sh=%s, aborting", opt_splitting_heuristics); } else { if(strcmp(opt_splitting_heuristics, "f") == 0) shs_undirected = bliss::Graph::shs_f; else if(strcmp(opt_splitting_heuristics, "fs") == 0) shs_undirected = bliss::Graph::shs_fs; else if(strcmp(opt_splitting_heuristics, "fl") == 0) shs_undirected = bliss::Graph::shs_fl; else if(strcmp(opt_splitting_heuristics, "fm") == 0) shs_undirected = bliss::Graph::shs_fm; else if(strcmp(opt_splitting_heuristics, "fsm") == 0) shs_undirected = bliss::Graph::shs_fsm; else if(strcmp(opt_splitting_heuristics, "flm") == 0) shs_undirected = bliss::Graph::shs_flm; else _fatal("Illegal option -sh=%s, aborting", opt_splitting_heuristics); } /* Open the input file */ FILE* infile = stdin; if(infilename) { infile = fopen(infilename, "r"); if(!infile) _fatal("Cannot not open `%s' for input, aborting", infilename); } /* Read the graph from the file */ if(opt_directed) { /* Read directed graph in the DIMACS format */ g = bliss::Digraph::read_dimacs(infile); } else { /* Read undirected graph in the DIMACS format */ g = bliss::Graph::read_dimacs(infile); } if(infile != stdin) fclose(infile); if(!g) _fatal("Failed to read the graph, aborting"); if(verbose_level >= 2) { fprintf(verbstr, "Graph read in %.2f seconds\n", timer.get_duration()); fflush(verbstr); } bliss::Stats stats; /* Set splitting heuristics and verbose level */ if(opt_directed) ((bliss::Digraph*)g)->set_splitting_heuristic(shs_directed); else ((bliss::Graph*)g)->set_splitting_heuristic(shs_undirected); g->set_verbose_level(verbose_level); g->set_verbose_file(verbstr); g->set_failure_recording(opt_use_failure_recording); g->set_component_recursion(opt_use_component_recursion); if(opt_canonize == false) { /* No canonical labeling, only automorphism group */ g->find_automorphisms(stats, &report_aut, stdout); } else { /* Canonical labeling and automorphism group */ const unsigned int* cl = g->canonical_form(stats, &report_aut, stdout); fprintf(stdout, "Canonical labeling: "); bliss::print_permutation(stdout, g->get_nof_vertices(), cl, 1); fprintf(stdout, "\n"); if(opt_output_can_file) { bliss::AbstractGraph* cf = g->permute(cl); FILE* const fp = fopen(opt_output_can_file, "w"); if(!fp) _fatal("Cannot open '%s' for outputting the canonical form, aborting", opt_output_can_file); cf->write_dimacs(fp); fclose(fp); delete cf; } } /* Output search statistics */ if(verbose_level > 0 and verbstr) stats.print(verbstr); if(verbose_level > 0) { fprintf(verbstr, "Total time:\t%.2f seconds\n", timer.get_duration()); fflush(verbstr); } delete g; g = 0; return 0; } opensmt-2.5.2/src/symmetry/bliss/bliss_C.cc000066400000000000000000000103611445011647600206770ustar00rootroot00000000000000#include #include #include #include "graph.hh" extern "C" { #include "bliss_C.h" } /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ struct bliss_graph_struct { bliss::Graph* g; }; extern "C" BlissGraph *bliss_new(const unsigned int n) { BlissGraph *graph = new bliss_graph_struct; assert(graph); graph->g = new bliss::Graph(n); assert(graph->g); return graph; } extern "C" BlissGraph *bliss_read_dimacs(FILE *fp) { bliss::Graph *g = bliss::Graph::read_dimacs(fp); if(!g) return 0; BlissGraph *graph = new bliss_graph_struct; assert(graph); graph->g = g; return graph; } extern "C" void bliss_write_dimacs(BlissGraph *graph, FILE *fp) { assert(graph); assert(graph->g); graph->g->write_dimacs(fp); } extern "C" void bliss_release(BlissGraph *graph) { assert(graph); assert(graph->g); delete graph->g; graph->g = 0; delete graph; } extern "C" void bliss_write_dot(BlissGraph *graph, FILE *fp) { assert(graph); assert(graph->g); graph->g->write_dot(fp); } extern "C" unsigned int bliss_get_nof_vertices(BlissGraph *graph) { assert(graph); assert(graph->g); return graph->g->get_nof_vertices(); } extern "C" unsigned int bliss_add_vertex(BlissGraph *graph, unsigned int l) { assert(graph); assert(graph->g); return graph->g->add_vertex(l); } extern "C" void bliss_add_edge(BlissGraph *graph, unsigned int v1, unsigned int v2) { assert(graph); assert(graph->g); graph->g->add_edge(v1, v2); } extern "C" int bliss_cmp(BlissGraph *graph1, BlissGraph *graph2) { assert(graph1); assert(graph1->g); assert(graph2); assert(graph2->g); return (*graph1->g).cmp(*graph2->g); } extern "C" unsigned int bliss_hash(BlissGraph *graph) { assert(graph); assert(graph->g); return graph->g->get_hash(); } extern "C" BlissGraph *bliss_permute(BlissGraph *graph, const unsigned int *perm) { assert(graph); assert(graph->g); assert(graph->g->get_nof_vertices() == 0 || perm); BlissGraph *permuted_graph = new bliss_graph_struct; assert(permuted_graph); permuted_graph->g = graph->g->permute(perm); return permuted_graph; } extern "C" void bliss_find_automorphisms(BlissGraph *graph, void (*hook)(void *user_param, unsigned int n, const unsigned int *aut), void *hook_user_param, BlissStats *stats) { bliss::Stats s; assert(graph); assert(graph->g); graph->g->find_automorphisms(s, hook, hook_user_param); if(stats) { stats->group_size_approx = s.get_group_size_approx(); stats->nof_nodes = s.get_nof_nodes(); stats->nof_leaf_nodes = s.get_nof_leaf_nodes(); stats->nof_bad_nodes = s.get_nof_bad_nodes(); stats->nof_canupdates = s.get_nof_canupdates(); stats->nof_generators = s.get_nof_generators(); stats->max_level = s.get_max_level(); } } extern "C" const unsigned int * bliss_find_canonical_labeling(BlissGraph *graph, void (*hook)(void *user_param, unsigned int n, const unsigned int *aut), void *hook_user_param, BlissStats *stats) { bliss::Stats s; const unsigned int *canonical_labeling = 0; assert(graph); assert(graph->g); canonical_labeling = graph->g->canonical_form(s, hook, hook_user_param); if(stats) { stats->group_size_approx = s.get_group_size_approx(); stats->nof_nodes = s.get_nof_nodes(); stats->nof_leaf_nodes = s.get_nof_leaf_nodes(); stats->nof_bad_nodes = s.get_nof_bad_nodes(); stats->nof_canupdates = s.get_nof_canupdates(); stats->nof_generators = s.get_nof_generators(); stats->max_level = s.get_max_level(); } return canonical_labeling; } opensmt-2.5.2/src/symmetry/bliss/bliss_C.h000066400000000000000000000150241445011647600205420ustar00rootroot00000000000000#ifndef BLISS_C_H #define BLISS_C_H /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ /** * \file * \brief The bliss C API. * * This is the C language API to * bliss. * Note that this C API is only a subset of the C++ API; * please consider using the C++ API whenever possible. */ #include #include /** * \brief The true bliss graph is hiding behind this typedef. */ typedef struct bliss_graph_struct BlissGraph; /** * \brief The C API version of the statistics returned by * the bliss search algorithm. */ typedef struct bliss_stats_struct { /** * An approximation (due to possible rounding errors) of * the size of the automorphism group. */ long double group_size_approx; /** The number of nodes in the search tree. */ long unsigned int nof_nodes; /** The number of leaf nodes in the search tree. */ long unsigned int nof_leaf_nodes; /** The number of bad nodes in the search tree. */ long unsigned int nof_bad_nodes; /** The number of canonical representative updates. */ long unsigned int nof_canupdates; /** The number of generator permutations. */ long unsigned int nof_generators; /** The maximal depth of the search tree. */ unsigned long int max_level; } BlissStats; /** * Create a new graph instance with \a N vertices and no edges. * \a N can be zero and bliss_add_vertex() called afterwards * to add new vertices on-the-fly. */ BlissGraph *bliss_new(const unsigned int N); /** * Read an undirected graph from a file in the DIMACS format into a new bliss * instance. * Returns 0 if an error occurred. * Note that in the DIMACS file the vertices are numbered from 1 to N while * in the bliss C API they are from 0 to N-1. * Thus the vertex n in the file corresponds to the vertex n-1 in the API. */ BlissGraph *bliss_read_dimacs(FILE *fp); /** * Output the graph in the file stream \a fp in the DIMACS format. * See the User's Guide for the file format details. * Note that in the DIMACS file the vertices are numbered from 1 to N while * in bliss they are from 0 to N-1. */ void bliss_write_dimacs(BlissGraph *graph, FILE *fp); /** * Release the graph. * Note that the memory pointed by the arguments of hook functions for * bliss_find_automorphisms() and bliss_find_canonical_labeling() * is deallocated and thus should not be accessed after calling this function. */ void bliss_release(BlissGraph *graph); /** * Print the graph in graphviz dot format. */ void bliss_write_dot(BlissGraph *graph, FILE *fp); /** * Return the number of vertices in the graph. */ unsigned int bliss_get_nof_vertices(BlissGraph *graph); /** * Add a new vertex with color \a c in the graph \a graph and return its index. * The vertex indices are always in the range * [0,bliss::bliss_get_nof_vertices(\a bliss)-1]. */ unsigned int bliss_add_vertex(BlissGraph *graph, unsigned int c); /** * Add a new undirected edge in the graph. * \a v1 and \a v2 are vertex indices returned by bliss_add_vertex(). * If duplicate edges are added, they will be ignored (however, they are not * necessarily physically ignored immediately but may consume memory for * a while so please try to avoid adding duplicate edges whenever possible). */ void bliss_add_edge(BlissGraph *graph, unsigned int v1, unsigned int v2); /** * Compare two graphs according to a total order. * Return -1, 0, or 1 if the first graph was smaller than, equal to, * or greater than, resp., the other graph. * If 0 is returned, then the graphs have the same number vertices, * the vertices in them are colored in the same way, and they contain * the same edges; that is, the graphs are equal. */ int bliss_cmp(BlissGraph *graph1, BlissGraph *graph2); /** * Get a hash value for the graph. */ unsigned int bliss_hash(BlissGraph *graph); /** * Permute the graph with the given permutation \a perm. * Returns the permuted graph, the original graph is not modified. * The argument \a perm should be an array of * N=bliss::bliss_get_nof_vertices(\a graph) elements describing * a bijection on {0,...,N-1}. */ BlissGraph *bliss_permute(BlissGraph *graph, const unsigned int *perm); /** * Find a set of generators for the automorphism group of the graph. * The hook function \a hook (if non-null) is called each time a new generator * for the automorphism group is found. * The first argument \a user_param for the hook function is * the \a hook_user_param argument, * the second argument \a N is the length of the automorphism (equal to * bliss::bliss_get_nof_vertices(\a graph)) and * the third argument \a aut is the automorphism (a bijection on {0,...,N-1}). * The memory for the automorphism \a aut will be invalidated immediately * after the return from the hook; * if you want to use the automorphism later, you have to take a copy of it. * Do not call bliss_* functions in the hook. * If \a stats is non-null, then some search statistics are copied there. */ void bliss_find_automorphisms(BlissGraph *graph, void (*hook)(void *user_param, unsigned int N, const unsigned int *aut), void *hook_user_param, BlissStats *stats); /** * Otherwise the same as bliss_find_automorphisms() except that * a canonical labeling for the graph (a bijection on {0,...,N-1}) is returned. * The returned canonical labeling will remain valid only until * the next call to a bliss_* function with the exception that * bliss_permute() can be called without invalidating the labeling. * To compute the canonical version of a graph, call this function and * then bliss_permute() with the returned canonical labeling. * Note that the computed canonical version may depend on the applied version * of bliss. */ const unsigned int * bliss_find_canonical_labeling(BlissGraph *graph, void (*hook)(void *user_param, unsigned int N, const unsigned int *aut), void *hook_user_param, BlissStats *stats); #endif opensmt-2.5.2/src/symmetry/bliss/defs.cc000066400000000000000000000017301445011647600202420ustar00rootroot00000000000000#include #include #include "defs.hh" /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ namespace bliss { void fatal_error(const char* fmt, ...) { va_list ap; va_start(ap, fmt); fprintf(stderr,"Bliss fatal error: "); vfprintf(stderr, fmt, ap); fprintf(stderr, "\nAborting!\n"); va_end(ap); exit(1); } } opensmt-2.5.2/src/symmetry/bliss/defs.hh000066400000000000000000000064511445011647600202610ustar00rootroot00000000000000#ifndef BLISS_DEFS_HH #define BLISS_DEFS_HH #include #include /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ namespace bliss { /** * The version number of bliss. */ static const char * const version = "0.72"; /* * If a fatal error (out of memory, internal error) is encountered, * this function is called. * There should not be a return from this function but exit or * a jump to code that deallocates the AbstractGraph instance that called this. */ void fatal_error(const char* fmt, ...); #if defined(BLISS_DEBUG) #define BLISS_CONSISTENCY_CHECKS #define BLISS_EXPENSIVE_CONSISTENCY_CHECKS #endif #if defined(BLISS_CONSISTENCY_CHECKS) /* Force a check that the found automorphisms are valid */ #define BLISS_VERIFY_AUTOMORPHISMS #endif #if defined(BLISS_CONSISTENCY_CHECKS) /* Force a check that the generated partitions are equitable */ #define BLISS_VERIFY_EQUITABLEDNESS #endif } // namespace bliss /*! \mainpage Bliss * * \section intro_sec Introduction * * This is the source code documentation of bliss, * produced by running doxygen in * the source directory. * The algorithms and data structures used in bliss are documented in * the papers found at the * bliss web site. * * * \section compile_sec Compiling * * Compiling bliss in Linux should be easy, just execute * \code * make * \endcode * in the bliss source directory. * This will produce the executable program \c bliss as well as * the library file \c libbliss.a that can be linked in other programs. * If you have the GNU Multiple Precision * Arithmetic Library (GMP) installed in your machine, you can also use * \code * make gmp * \endcode * to enable exact computation of automorphism group sizes. * * When linking the bliss library \c libbliss.a in other programs, * remember to include the standard c++ library * (and the GMP library if you compiled bliss to include it). * For instance, * \code gcc -o test test.c -lstdc++ -lgmp -lbliss\endcode * * \section cppapi_sec The C++ language API * * The C++ language API is the main API to bliss; * all other APIs are just more or less complete variants of it. * The C++ API consists basically of the public methods in * the classes bliss::AbstractGraph, bliss::Graph, and bliss::Digraph. * For an example of its use, * see the \ref executable "source of the bliss executable". * * * \section capi_sec The C language API * * The C language API is given in the file bliss_C.h. * It is currently more restricted than the C++ API so * consider using the C++ API whenever possible. */ #endif opensmt-2.5.2/src/symmetry/bliss/graph.cc000066400000000000000000004325041445011647600204310ustar00rootroot00000000000000#include #include #include #include #include #include #include "defs.hh" #include "timer.hh" #include "graph.hh" #include "partition.hh" #include "utils.hh" /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ namespace bliss { #define _INTERNAL_ERROR() fatal_error("%s:%d: internal error",__FILE__,__LINE__) #define _OUT_OF_MEMORY() fatal_error("%s:%d: out of memory",__FILE__,__LINE__) /*------------------------------------------------------------------------- * * Constructor and destructor routines for the abstract graph class * *-------------------------------------------------------------------------*/ AbstractGraph::AbstractGraph() { /* Initialize stuff */ first_path_labeling = 0; first_path_labeling_inv = 0; best_path_labeling = 0; best_path_labeling_inv = 0; first_path_automorphism = 0; best_path_automorphism = 0; in_search = false; /* Default value for using "long prune" */ opt_use_long_prune = true; /* Default value for using failure recording */ opt_use_failure_recording = true; /* Default value for using component recursion */ opt_use_comprec = true; verbose_level = 0; verbstr = stdout; report_hook = 0; report_user_param = 0; } AbstractGraph::~AbstractGraph() { if(first_path_labeling) { free(first_path_labeling); first_path_labeling = 0; } if(first_path_labeling_inv) { free(first_path_labeling_inv); first_path_labeling_inv = 0; } if(best_path_labeling) { free(best_path_labeling); best_path_labeling = 0; } if(best_path_labeling_inv) { free(best_path_labeling_inv); best_path_labeling_inv = 0; } if(first_path_automorphism) { free(first_path_automorphism); first_path_automorphism = 0; } if(best_path_automorphism) { free(best_path_automorphism); best_path_automorphism = 0; } report_hook = 0; report_user_param = 0; } /*------------------------------------------------------------------------- * * Verbose output management routines * *-------------------------------------------------------------------------*/ void AbstractGraph::set_verbose_level(const unsigned int level) { verbose_level = level; } void AbstractGraph::set_verbose_file(FILE* const fp) { verbstr = fp; } /*------------------------------------------------------------------------- * * Routines for refinement to equitable partition * *-------------------------------------------------------------------------*/ void AbstractGraph::refine_to_equitable() { /* Start refinement from all cells -> push 'em all in the splitting queue */ for(Partition::Cell* cell = p.first_cell; cell; cell = cell->next) p.splitting_queue_add(cell); do_refine_to_equitable(); } void AbstractGraph::refine_to_equitable(Partition::Cell* const unit_cell) { p.splitting_queue_add(unit_cell); do_refine_to_equitable(); } void AbstractGraph::refine_to_equitable(Partition::Cell* const unit_cell1, Partition::Cell* const unit_cell2) { p.splitting_queue_add(unit_cell1); p.splitting_queue_add(unit_cell2); do_refine_to_equitable(); } bool AbstractGraph::do_refine_to_equitable() { eqref_hash.reset(); while(!p.splitting_queue_is_empty()) { Partition::Cell* const cell = p.splitting_queue_pop(); if(cell->is_unit()) { if(in_search) { const unsigned int index = cell->first; if(first_path_automorphism) { /* Build the (potential) automorphism on-the-fly */ first_path_automorphism[first_path_labeling_inv[index]] = p.elements[index]; } if(best_path_automorphism) { /* Build the (potential) automorphism on-the-fly */ best_path_automorphism[best_path_labeling_inv[index]] = p.elements[index]; } } const bool worse = split_neighbourhood_of_unit_cell(cell); if(in_search and worse) goto worse_exit; } else { const bool worse = split_neighbourhood_of_cell(cell); if(in_search and worse) goto worse_exit; } } return true; worse_exit: /* Clear splitting_queue */ p.splitting_queue_clear(); return false; } /*------------------------------------------------------------------------- * * Routines for handling the canonical labeling * *-------------------------------------------------------------------------*/ /** \internal * Assign the labeling induced by the current partition 'this.p' to * \a labeling. * That is, if the partition is [[2,0],[1]], * then \a labeling will map 0 to 1, 1 to 2, and 2 to 0. */ void AbstractGraph::update_labeling(unsigned int* const labeling) { const unsigned int N = get_nof_vertices(); unsigned int* ep = p.elements; for(unsigned int i = 0; i < N; i++, ep++) labeling[*ep] = i; } /** \internal * The same as update_labeling() except that the inverse of the labeling * is also produced and assigned to \a labeling_inv. */ void AbstractGraph::update_labeling_and_its_inverse(unsigned int* const labeling, unsigned int* const labeling_inv) { const unsigned int N = get_nof_vertices(); unsigned int* ep = p.elements; unsigned int* clip = labeling_inv; for(unsigned int i = 0; i < N; ) { labeling[*ep] = i; i++; *clip = *ep; ep++; clip++; } } /*------------------------------------------------------------------------- * * Routines for handling automorphisms * *-------------------------------------------------------------------------*/ /** \internal * Reset the permutation \a perm to the identity permutation. */ void AbstractGraph::reset_permutation(unsigned int* perm) { const unsigned int N = get_nof_vertices(); for(unsigned int i = 0; i < N; i++, perm++) *perm = i; } bool AbstractGraph::is_automorphism(unsigned int* const perm) { _INTERNAL_ERROR(); return false; } bool AbstractGraph::is_automorphism(const std::vector& perm) const { _INTERNAL_ERROR(); return false; } /*------------------------------------------------------------------------- * * Certificate building * *-------------------------------------------------------------------------*/ void AbstractGraph::cert_add(const unsigned int v1, const unsigned int v2, const unsigned int v3) { if(refine_compare_certificate) { if(refine_equal_to_first) { /* So far equivalent to the first path... */ unsigned int index = certificate_current_path.size(); if(index >= refine_first_path_subcertificate_end) { refine_equal_to_first = false; } else if(certificate_first_path[index] != v1) { refine_equal_to_first = false; } else if(certificate_first_path[++index] != v2) { refine_equal_to_first = false; } else if(certificate_first_path[++index] != v3) { refine_equal_to_first = false; } if(opt_use_failure_recording and !refine_equal_to_first) { /* We just became different from the first path, * remember the deviation point tree-specific invariant * for the use of failure recording */ UintSeqHash h; h.update(v1); h.update(v2); h.update(v3); h.update(index); h.update(eqref_hash.get_value()); failure_recording_fp_deviation = h.get_value(); } } if(refine_cmp_to_best == 0) { /* So far equivalent to the current best path... */ unsigned int index = certificate_current_path.size(); if(index >= refine_best_path_subcertificate_end) { refine_cmp_to_best = 1; } else if(v1 > certificate_best_path[index]) { refine_cmp_to_best = 1; } else if(v1 < certificate_best_path[index]) { refine_cmp_to_best = -1; } else if(v2 > certificate_best_path[++index]) { refine_cmp_to_best = 1; } else if(v2 < certificate_best_path[index]) { refine_cmp_to_best = -1; } else if(v3 > certificate_best_path[++index]) { refine_cmp_to_best = 1; } else if(v3 < certificate_best_path[index]) { refine_cmp_to_best = -1; } } if((refine_equal_to_first == false) and (refine_cmp_to_best < 0)) return; } /* Update the current path certificate */ certificate_current_path.push_back(v1); certificate_current_path.push_back(v2); certificate_current_path.push_back(v3); } void AbstractGraph::cert_add_redundant(const unsigned int v1, const unsigned int v2, const unsigned int v3) { return cert_add(v1, v2, v3); } /*------------------------------------------------------------------------- * * Long prune code * *-------------------------------------------------------------------------*/ void AbstractGraph::long_prune_init() { const unsigned int N = get_nof_vertices(); long_prune_temp.clear(); long_prune_temp.resize(N); /* Of how many automorphisms we can store information in the predefined, fixed amount of memory? */ const unsigned int nof_fitting_in_max_mem = (long_prune_options_max_mem * 1024 * 1024) / (((N * 2) / 8)+1); long_prune_max_stored_autss = long_prune_options_max_stored_auts; /* Had some problems with g++ in using (a* tmp = long_prune_fixed[real_i]; long_prune_fixed[real_i] = long_prune_fixed[real_j]; long_prune_fixed[real_j] = tmp; tmp = long_prune_mcrs[real_i]; long_prune_mcrs[real_i] = long_prune_mcrs[real_j]; long_prune_mcrs[real_j] = tmp; } std::vector& AbstractGraph::long_prune_allocget_fixed(const unsigned int index) { const unsigned int i = index % long_prune_max_stored_autss; if(!long_prune_fixed[i]) long_prune_fixed[i] = new std::vector(get_nof_vertices()); return *long_prune_fixed[i]; } std::vector& AbstractGraph::long_prune_get_fixed(const unsigned int index) { return *long_prune_fixed[index % long_prune_max_stored_autss]; } std::vector& AbstractGraph::long_prune_allocget_mcrs(const unsigned int index) { const unsigned int i = index % long_prune_max_stored_autss; if(!long_prune_mcrs[i]) long_prune_mcrs[i] = new std::vector(get_nof_vertices()); return *long_prune_mcrs[i]; } std::vector& AbstractGraph::long_prune_get_mcrs(const unsigned int index) { return *long_prune_mcrs[index % long_prune_max_stored_autss]; } void AbstractGraph::long_prune_add_automorphism(const unsigned int* aut) { if(long_prune_max_stored_autss == 0) return; const unsigned int N = get_nof_vertices(); /* If the buffer of stored auts is full, remove the oldest aut */ if(long_prune_end - long_prune_begin == long_prune_max_stored_autss) { long_prune_begin++; } long_prune_end++; std::vector& fixed = long_prune_allocget_fixed(long_prune_end-1); std::vector& mcrs = long_prune_allocget_mcrs(long_prune_end-1); /* Mark nodes that are (i) fixed or (ii) minimal orbit representatives * under the automorphism 'aut' */ for(unsigned int i = 0; i < N; i++) { fixed[i] = (aut[i] == i); if(long_prune_temp[i] == false) { mcrs[i] = true; unsigned int j = aut[i]; while(j != i) { long_prune_temp[j] = true; j = aut[j]; } } else { mcrs[i] = false; } /* Clear the temp array on-the-fly... */ long_prune_temp[i] = false; } } /*------------------------------------------------------------------------- * * Routines for handling orbit information * *-------------------------------------------------------------------------*/ void AbstractGraph::update_orbit_information(Orbit& o, const unsigned int* perm) { const unsigned int N = get_nof_vertices(); for(unsigned int i = 0; i < N; i++) if(perm[i] != i) o.merge_orbits(i, perm[i]); } /*------------------------------------------------------------------------- * * The actual backtracking search * *-------------------------------------------------------------------------*/ class TreeNode { //friend class AbstractGraph; public: unsigned int split_cell_first; int split_element; static const int SPLIT_START = -1; static const int SPLIT_END = -2; Partition::BacktrackPoint partition_bt_point; unsigned int certificate_index; static const char NO = -1; static const char MAYBE = 0; static const char YES = 1; /* First path stuff */ bool fp_on; bool fp_cert_equal; char fp_extendable; /* Best path stuff */ bool in_best_path; int cmp_to_best_path; unsigned int failure_recording_ival; /* Component recursion related data */ unsigned int cr_cep_stack_size; unsigned int cr_cep_index; unsigned int cr_level; bool needs_long_prune; unsigned int long_prune_begin; std::set > long_prune_redundant; UintSeqHash eqref_hash; unsigned int subcertificate_length; }; typedef struct { unsigned int splitting_element; unsigned int certificate_index; unsigned int subcertificate_length; UintSeqHash eqref_hash; } PathInfo; void AbstractGraph::search(const bool canonical, Stats& stats) { const unsigned int N = get_nof_vertices(); unsigned int all_same_level = UINT_MAX; p.graph = this; /* * Must be done! */ remove_duplicate_edges(); /* * Reset search statistics */ stats.reset(); stats.nof_nodes = 1; stats.nof_leaf_nodes = 1; /* Free old first path data structures */ if(first_path_labeling) { free(first_path_labeling); first_path_labeling = 0; } if(first_path_labeling_inv) { free(first_path_labeling_inv); first_path_labeling_inv = 0; } if(first_path_automorphism) { free(first_path_automorphism); first_path_automorphism = 0; } /* Free old best path data structures */ if(best_path_labeling) { free(best_path_labeling); best_path_labeling = 0; } if(best_path_labeling_inv) { free(best_path_labeling_inv); best_path_labeling_inv = 0; } if(best_path_automorphism) { free(best_path_automorphism); best_path_automorphism = 0; } if(N == 0) { /* Nothing to do, return... */ return; } /* Initialize the partition ... */ p.init(N); /* ... and the component recursion data structures in the partition */ if(opt_use_comprec) p.cr_init(); neighbour_heap.init(N); in_search = false; /* Do not compute certificate when building the initial partition */ refine_compare_certificate = false; /* The 'eqref_hash' hash value is not computed when building * the initial partition as it is not used for anything at the moment. * This saves some cycles. */ compute_eqref_hash = false; Timer timer1; make_initial_equitable_partition(); if(verbstr and verbose_level >= 2) { fprintf(verbstr, "Initial partition computed in %.2f seconds\n", timer1.get_duration()); fflush(verbstr); } /* * Allocate space for the "first path" and "best path" labelings */ if(first_path_labeling) free(first_path_labeling); first_path_labeling = (unsigned int*)calloc(N, sizeof(unsigned int)); if(!first_path_labeling) _OUT_OF_MEMORY(); if(best_path_labeling) free(best_path_labeling); best_path_labeling = (unsigned int*)calloc(N, sizeof(unsigned int)); if(!best_path_labeling) _OUT_OF_MEMORY(); /* * Is the initial partition discrete? */ if(p.is_discrete()) { /* Make the best path labeling i.e. the canonical labeling */ update_labeling(best_path_labeling); /* Update statistics */ stats.nof_leaf_nodes = 1; return; } /* * Allocate the inverses of the "first path" and "best path" labelings */ if(first_path_labeling_inv) free(first_path_labeling_inv); first_path_labeling_inv = (unsigned int*)calloc(N, sizeof(unsigned int)); if(!first_path_labeling_inv) _OUT_OF_MEMORY(); if(best_path_labeling_inv) free(best_path_labeling_inv); best_path_labeling_inv = (unsigned int*)calloc(N, sizeof(unsigned int)); if(!best_path_labeling_inv) _OUT_OF_MEMORY(); /* * Allocate space for the automorphisms */ if(first_path_automorphism) free(first_path_automorphism); first_path_automorphism = (unsigned int*)malloc(N * sizeof(unsigned int)); if(!first_path_automorphism) _OUT_OF_MEMORY(); if(best_path_automorphism) free(best_path_automorphism); best_path_automorphism = (unsigned int*)malloc(N * sizeof(unsigned int)); if(!best_path_automorphism) _OUT_OF_MEMORY(); /* * Initialize orbit information so that all vertices are in their own orbits */ first_path_orbits.init(N); best_path_orbits.init(N); /* * Initialize certificate memory */ initialize_certificate(); std::vector search_stack; std::vector first_path_info; std::vector best_path_info; search_stack.clear(); /* Initialize "long prune" data structures */ if(opt_use_long_prune) long_prune_init(); /* * Initialize failure recording data structures */ typedef std::set > FailureRecordingSet; std::vector failure_recording_hashes; /* * Initialize component recursion data structures */ cr_cep_stack.clear(); unsigned int cr_cep_index = 0; { /* Inset a sentinel "component end point" */ CR_CEP sentinel; sentinel.creation_level = 0; sentinel.discrete_cell_limit = get_nof_vertices(); sentinel.next_cr_level = 0; sentinel.next_cep_index = 0; sentinel.first_checked = false; sentinel.best_checked = false; cr_cep_index = 0; cr_cep_stack.push_back(sentinel); } cr_level = 0; if(opt_use_comprec and nucr_find_first_component(cr_level) == true and p.nof_discrete_cells() + cr_component_elements < cr_cep_stack[cr_cep_index].discrete_cell_limit) { cr_level = p.cr_split_level(0, cr_component); CR_CEP cep; cep.creation_level = 0; cep.discrete_cell_limit = p.nof_discrete_cells() + cr_component_elements; cep.next_cr_level = 0; cep.next_cep_index = cr_cep_index; cep.first_checked = false; cep.best_checked = false; cr_cep_index = cr_cep_stack.size(); cr_cep_stack.push_back(cep); } /* * Build the root node of the search tree */ { TreeNode root; Partition::Cell* split_cell = find_next_cell_to_be_splitted(p.first_cell); root.split_cell_first = split_cell->first; root.split_element = TreeNode::SPLIT_START; root.partition_bt_point = p.set_backtrack_point(); root.certificate_index = 0; root.fp_on = true; root.fp_cert_equal = true; root.fp_extendable = TreeNode::MAYBE; root.in_best_path = false; root.cmp_to_best_path = 0; root.long_prune_begin = 0; root.failure_recording_ival = 0; /* Save component recursion info for backtracking */ root.cr_level = cr_level; root.cr_cep_stack_size = cr_cep_stack.size(); root.cr_cep_index = cr_cep_index; search_stack.push_back(root); } /* * Set status and global flags for search related procedures */ in_search = true; /* Do not compare certificates during refinement until the first path has been traversed to the leaf */ refine_compare_certificate = false; /* * The actual backtracking search */ while(!search_stack.empty()) { TreeNode& current_node = search_stack.back(); const unsigned int current_level = (unsigned int)search_stack.size()-1; if(opt_use_comprec) { CR_CEP& cep = cr_cep_stack[current_node.cr_cep_index]; if(cep.first_checked == true and current_node.fp_extendable == TreeNode::MAYBE and !search_stack[cep.creation_level].fp_on) { current_node.fp_extendable = TreeNode::NO; } } if(current_node.fp_on) { if(current_node.split_element == TreeNode::SPLIT_END) { search_stack.pop_back(); continue; } } else { if(current_node.fp_extendable == TreeNode::YES) { search_stack.pop_back(); continue; } if(current_node.split_element == TreeNode::SPLIT_END) { if(opt_use_failure_recording) { TreeNode& parent_node = search_stack[current_level-1]; if(parent_node.fp_on) failure_recording_hashes[current_level-1].insert(current_node.failure_recording_ival); } search_stack.pop_back(); continue; } if(current_node.fp_extendable == TreeNode::NO and (!canonical or current_node.cmp_to_best_path < 0)) { if(opt_use_failure_recording) { TreeNode& parent_node = search_stack[current_level-1]; if(parent_node.fp_on) failure_recording_hashes[current_level-1].insert(current_node.failure_recording_ival); } search_stack.pop_back(); continue; } } /* Restore partition ... */ p.goto_backtrack_point(current_node.partition_bt_point); /* ... and re-remember backtracking point */ current_node.partition_bt_point = p.set_backtrack_point(); /* Restore current path certificate */ certificate_index = current_node.certificate_index; refine_current_path_certificate_index = current_node.certificate_index; certificate_current_path.resize(certificate_index); /* Fetch split cell information */ Partition::Cell * const cell = p.get_cell(p.elements[current_node.split_cell_first]); /* Restore component recursion information */ cr_level = current_node.cr_level; cr_cep_stack.resize(current_node.cr_cep_stack_size); cr_cep_index = current_node.cr_cep_index; /* * Update long prune redundancy sets */ if(opt_use_long_prune and current_level >= 1 and !current_node.fp_on) { unsigned int begin = (current_node.long_prune_begin>long_prune_begin)?current_node.long_prune_begin:long_prune_begin; for(unsigned int i = begin; i < long_prune_end; i++) { const std::vector& fixed = long_prune_get_fixed(i); #if defined(BLISS_CONSISTENCY_CHECKS) for(unsigned int l = 0; l < search_stack.size()-2; l++) assert(fixed[search_stack[l].split_element]); #endif if(fixed[search_stack[search_stack.size()-1-1].split_element] == false) { long_prune_swap(begin, i); begin++; current_node.long_prune_begin = begin; continue; } } if(current_node.split_element == TreeNode::SPLIT_START) { current_node.needs_long_prune = true; } else if(current_node.needs_long_prune) { current_node.needs_long_prune = false; unsigned int begin = (current_node.long_prune_begin>long_prune_begin)?current_node.long_prune_begin:long_prune_begin; for(unsigned int i = begin; i < long_prune_end; i++) { const std::vector& fixed = long_prune_get_fixed(i); #if defined(BLISS_CONSISTENCY_CHECKS) for(unsigned int l = 0; l < search_stack.size()-2; l++) assert(fixed[search_stack[l].split_element]); #endif assert(fixed[search_stack[current_level-1].split_element] == true); if(fixed[search_stack[current_level-1].split_element] == false) { long_prune_swap(begin, i); begin++; current_node.long_prune_begin = begin; continue; } const std::vector& mcrs = long_prune_get_mcrs(i); unsigned int* ep = p.elements + cell->first; for(unsigned int j = cell->length; j > 0; j--, ep++) { if(mcrs[*ep] == false) current_node.long_prune_redundant.insert(*ep); } } } } /* * Find the next smallest, non-isomorphic element in the cell and * store it in current_node.split_element */ { unsigned int next_split_element = UINT_MAX; unsigned int* next_split_element_pos = 0; unsigned int* ep = p.elements + cell->first; if(current_node.fp_on) { /* Find the next larger splitting element that is * a minimal orbit representative w.r.t. first_path_orbits */ for(unsigned int i = cell->length; i > 0; i--, ep++) { if((int)(*ep) > current_node.split_element and *ep < next_split_element and first_path_orbits.is_minimal_representative(*ep)) { next_split_element = *ep; next_split_element_pos = ep; } } } else if(current_node.in_best_path) { /* Find the next larger splitting element that is * a minimal orbit representative w.r.t. best_path_orbits */ for(unsigned int i = cell->length; i > 0; i--, ep++) { if((int)(*ep) > current_node.split_element and *ep < next_split_element and best_path_orbits.is_minimal_representative(*ep) and (!opt_use_long_prune or current_node.long_prune_redundant.find(*ep) == current_node.long_prune_redundant.end())) { next_split_element = *ep; next_split_element_pos = ep; } } } else { /* Find the next larger splitting element */ for(unsigned int i = cell->length; i > 0; i--, ep++) { if((int)(*ep) > current_node.split_element and *ep < next_split_element and (!opt_use_long_prune or current_node.long_prune_redundant.find(*ep) == current_node.long_prune_redundant.end())) { next_split_element = *ep; next_split_element_pos = ep; } } } if(next_split_element == UINT_MAX) { /* No more (unexplored children) in the cell */ current_node.split_element = TreeNode::SPLIT_END; if(current_node.fp_on) { /* Update group size */ const unsigned int index = first_path_orbits.orbit_size(first_path_info[search_stack.size()-1].splitting_element); stats.group_size.multiply(index); stats.group_size_approx *= (long double)index; /* * Update all_same_level */ if(index == cell->length and all_same_level == current_level+1) all_same_level = current_level; if(verbstr and verbose_level >= 2) { fprintf(verbstr, "Level %u: orbits=%u, index=%u/%u, all_same_level=%u\n", current_level, first_path_orbits.nof_orbits(), index, cell->length, all_same_level); fflush(verbstr); } } continue; } /* Split on smallest */ current_node.split_element = next_split_element; } const unsigned int child_level = current_level+1; /* Update some statistics */ stats.nof_nodes++; if(search_stack.size() > stats.max_level) stats.max_level = search_stack.size(); /* Set flags and indices for the refiner certificate builder */ refine_equal_to_first = current_node.fp_cert_equal; refine_cmp_to_best = current_node.cmp_to_best_path; if(!first_path_info.empty()) { if(refine_equal_to_first) refine_first_path_subcertificate_end = first_path_info[search_stack.size()-1].certificate_index + first_path_info[search_stack.size()-1].subcertificate_length; if(canonical) { if(refine_cmp_to_best == 0) refine_best_path_subcertificate_end = best_path_info[search_stack.size()-1].certificate_index + best_path_info[search_stack.size()-1].subcertificate_length; } else refine_cmp_to_best = -1; } const bool was_fp_cert_equal = current_node.fp_cert_equal; /* Individualize, i.e. split the cell in two, the latter new cell * will be a unit one containing info.split_element */ Partition::Cell* const new_cell = p.individualize(cell, current_node.split_element); /* * Refine the new partition to equitable */ if(cell->is_unit()) refine_to_equitable(cell, new_cell); else refine_to_equitable(new_cell); /* Update statistics */ if(p.is_discrete()) stats.nof_leaf_nodes++; if(!first_path_info.empty()) { /* We are no longer on the first path */ const unsigned int subcertificate_length = certificate_current_path.size() - certificate_index; if(refine_equal_to_first) { /* Was equal to the first path so far */ PathInfo& first_pinfo = first_path_info[current_level]; assert(first_pinfo.certificate_index == certificate_index); if(subcertificate_length != first_pinfo.subcertificate_length) { refine_equal_to_first = false; if(opt_use_failure_recording) failure_recording_fp_deviation = subcertificate_length; } else if(first_pinfo.eqref_hash.cmp(eqref_hash) != 0) { refine_equal_to_first = false; if(opt_use_failure_recording) failure_recording_fp_deviation = eqref_hash.get_value(); } } if(canonical and (refine_cmp_to_best == 0)) { /* Was equal to the best path so far */ PathInfo& bestp_info = best_path_info[current_level]; assert(bestp_info.certificate_index == certificate_index); if(subcertificate_length < bestp_info.subcertificate_length) { refine_cmp_to_best = -1; } else if(subcertificate_length > bestp_info.subcertificate_length) { refine_cmp_to_best = 1; } else if(bestp_info.eqref_hash.cmp(eqref_hash) > 0) { refine_cmp_to_best = -1; } else if(bestp_info.eqref_hash.cmp(eqref_hash) < 0) { refine_cmp_to_best = 1; } } if(opt_use_failure_recording and was_fp_cert_equal and !refine_equal_to_first) { UintSeqHash k; k.update(failure_recording_fp_deviation); k.update(eqref_hash.get_value()); failure_recording_fp_deviation = k.get_value(); if(current_node.fp_on) failure_recording_hashes[current_level].insert(failure_recording_fp_deviation); else { for(unsigned int i = current_level; i > 0; i--) { if(search_stack[i].fp_on) break; const FailureRecordingSet& s = failure_recording_hashes[i]; if(i == current_level and s.find(failure_recording_fp_deviation) != s.end()) break; if(s.find(0) != s.end()) break; search_stack[i].fp_extendable = TreeNode::NO; } } } /* Check if no longer equal to the first path and, * if canonical labeling is desired, also worse than the * current best path */ if(refine_equal_to_first == false and (!canonical or (refine_cmp_to_best < 0))) { /* Yes, backtrack */ stats.nof_bad_nodes++; if(current_node.fp_cert_equal == true and current_level+1 > all_same_level) { assert(all_same_level >= 1); for(unsigned int i = all_same_level; i < search_stack.size(); i++) { search_stack[i].fp_extendable = TreeNode::NO; } } continue; } } #if defined(BLISS_VERIFY_EQUITABLEDNESS) /* The new partition should be equitable */ if(!is_equitable()) fatal_error("consistency check failed - partition after refinement is not equitable"); #endif /* * Next level search tree node info */ TreeNode child_node; /* No more in the first path */ child_node.fp_on = false; /* No more in the best path */ child_node.in_best_path = false; child_node.fp_cert_equal = refine_equal_to_first; if(current_node.fp_extendable == TreeNode::NO or (current_node.fp_extendable == TreeNode::MAYBE and child_node.fp_cert_equal == false)) child_node.fp_extendable = TreeNode::NO; else child_node.fp_extendable = TreeNode::MAYBE; child_node.cmp_to_best_path = refine_cmp_to_best; child_node.failure_recording_ival = 0; child_node.cr_cep_stack_size = current_node.cr_cep_stack_size; child_node.cr_cep_index = current_node.cr_cep_index; child_node.cr_level = current_node.cr_level; certificate_index = certificate_current_path.size(); current_node.eqref_hash = eqref_hash; current_node.subcertificate_length = certificate_index - current_node.certificate_index; /* * The first encountered leaf node at the end of the "first path"? */ if(p.is_discrete() and first_path_info.empty()) { //fprintf(stdout, "Level %u: FIRST\n", child_level); fflush(stdout); stats.nof_canupdates++; /* * Update labelings and their inverses */ update_labeling_and_its_inverse(first_path_labeling, first_path_labeling_inv); update_labeling_and_its_inverse(best_path_labeling, best_path_labeling_inv); /* * Reset automorphism array */ reset_permutation(first_path_automorphism); reset_permutation(best_path_automorphism); /* * Reset orbit information */ first_path_orbits.reset(); best_path_orbits.reset(); /* * Reset group size */ stats.group_size.assign(1); stats.group_size_approx = 1.0; /* * Reset all_same_level */ all_same_level = child_level; /* * Mark the current path to be the first and best one and save it */ const unsigned int base_size = search_stack.size(); best_path_info.clear(); //fprintf(stdout, " New base is: "); for(unsigned int i = 0; i < base_size; i++) { search_stack[i].fp_on = true; search_stack[i].fp_cert_equal = true; search_stack[i].fp_extendable = TreeNode::YES; search_stack[i].in_best_path = true; search_stack[i].cmp_to_best_path = 0; PathInfo path_info; path_info.splitting_element = search_stack[i].split_element; path_info.certificate_index = search_stack[i].certificate_index; path_info.eqref_hash = search_stack[i].eqref_hash; path_info.subcertificate_length = search_stack[i].subcertificate_length; first_path_info.push_back(path_info); best_path_info.push_back(path_info); //fprintf(stdout, "%u ", search_stack[i].split_element); } //fprintf(stdout, "\n"); fflush(stdout); /* Copy certificates */ certificate_first_path = certificate_current_path; certificate_best_path = certificate_current_path; /* From now on, compare certificates when refining */ refine_compare_certificate = true; if(opt_use_failure_recording) failure_recording_hashes.resize(base_size); /* for(unsigned int j = 0; j < search_stack.size(); j++) fprintf(stderr, "%u ", search_stack[j].split_element); fprintf(stderr, "\n"); p.print(stderr); fprintf(stderr, "\n"); */ /* * Backtrack to the previous level */ continue; } if(p.is_discrete() and child_node.fp_cert_equal) { /* * A leaf node that is equal to the first one. * An automorphism found: aut[i] = elements[first_path_labeling[i]] */ goto handle_first_path_automorphism; } if(!p.is_discrete()) { Partition::Cell* next_split_cell = 0; /* * An internal, non-leaf node */ if(opt_use_comprec) { assert(p.nof_discrete_cells() <= cr_cep_stack[cr_cep_index].discrete_cell_limit); assert(cr_level == child_node.cr_level); if(p.nof_discrete_cells() == cr_cep_stack[cr_cep_index].discrete_cell_limit) { /* We have reached the end of a component */ assert(cr_cep_index != 0); CR_CEP& cep = cr_cep_stack[cr_cep_index]; /* First, compare with respect to the first path */ if(first_path_info.empty() or child_node.fp_cert_equal) { if(cep.first_checked == false) { /* First time, go to the next component */ cep.first_checked = true; } else { assert(!first_path_info.empty()); assert(cep.creation_level < search_stack.size()); TreeNode& old_info = search_stack[cep.creation_level]; /* If the component was found when on the first path, * handle the found automorphism as the other * first path automorphisms */ if(old_info.fp_on) goto handle_first_path_automorphism; /* Should never get here because of CR:FP */ _INTERNAL_ERROR(); } } if(canonical and !first_path_info.empty() and child_node.cmp_to_best_path >= 0) { if(cep.best_checked == false) { /* First time, go to the next component */ cep.best_checked = true; } else { assert(cep.creation_level < search_stack.size()); TreeNode& old_info = search_stack[cep.creation_level]; if(child_node.cmp_to_best_path == 0) { /* If the component was found when on the best path, * handle the found automorphism as the other * best path automorphisms */ if(old_info.in_best_path) goto handle_best_path_automorphism; /* Otherwise, we do not remember the automorhism as * we didn't memorize the path that was invariant * equal to the best one and passed through the * component. * Thus we can only backtrack to the previous level */ child_node.cmp_to_best_path = -1; if(!child_node.fp_cert_equal) { continue; } } else { assert(child_node.cmp_to_best_path > 0); if(old_info.in_best_path) { stats.nof_canupdates++; /* * Update canonical labeling and its inverse */ for(unsigned int i = 0; i < N; i++) { if(p.get_cell(p.elements[i])->is_unit()) { best_path_labeling[p.elements[i]] = i; best_path_labeling_inv[i] = p.elements[i]; } } //update_labeling_and_its_inverse(best_path_labeling, best_path_labeling_inv); /* Reset best path automorphism */ reset_permutation(best_path_automorphism); /* Reset best path orbit structure */ best_path_orbits.reset(); /* Mark to be the best one and save prefix */ unsigned int postfix_start = cep.creation_level; assert(postfix_start < best_path_info.size()); while(p.get_cell(best_path_info[postfix_start].splitting_element)->is_unit()) { postfix_start++; assert(postfix_start < best_path_info.size()); } unsigned int postfix_start_cert = best_path_info[postfix_start].certificate_index; std::vector best_path_temp = best_path_info; best_path_info.clear(); for(unsigned int i = 0; i < search_stack.size(); i++) { TreeNode& ss_info = search_stack[i]; PathInfo bp_info; ss_info.cmp_to_best_path = 0; ss_info.in_best_path = true; bp_info.splitting_element = ss_info.split_element; bp_info.certificate_index = ss_info.certificate_index; bp_info.subcertificate_length = ss_info.subcertificate_length; bp_info.eqref_hash = ss_info.eqref_hash; best_path_info.push_back(bp_info); } /* Copy the postfix of the previous best path */ for(unsigned int i = postfix_start; i < best_path_temp.size(); i++) { best_path_info.push_back(best_path_temp[i]); best_path_info[best_path_info.size()-1].certificate_index = best_path_info[best_path_info.size()-2].certificate_index + best_path_info[best_path_info.size()-2].subcertificate_length; } std::vector certificate_best_path_old = certificate_best_path; certificate_best_path = certificate_current_path; for(unsigned int i = postfix_start_cert; i < certificate_best_path_old.size(); i++) certificate_best_path.push_back(certificate_best_path_old[i]); assert(certificate_best_path.size() == best_path_info.back().certificate_index + best_path_info.back().subcertificate_length); /* Backtrack to the previous level */ continue; } } } } /* No backtracking performed, go to next componenet */ cr_level = cep.next_cr_level; cr_cep_index = cep.next_cep_index; } /* Check if the current component has been split into * new non-uniformity subcomponents */ //if(nucr_find_first_component(cr_level) == true and // p.nof_discrete_cells() + cr_component_elements < // cr_cep_stack[cr_cep_index].discrete_cell_limit) if(nucr_find_first_component(cr_level, cr_component, cr_component_elements, next_split_cell) == true and p.nof_discrete_cells() + cr_component_elements < cr_cep_stack[cr_cep_index].discrete_cell_limit) { const unsigned int next_cr_level = p.cr_split_level(cr_level, cr_component); CR_CEP cep; cep.creation_level = search_stack.size(); cep.discrete_cell_limit = p.nof_discrete_cells() + cr_component_elements; cep.next_cr_level = cr_level; cep.next_cep_index = cr_cep_index; cep.first_checked = false; cep.best_checked = false; cr_cep_index = cr_cep_stack.size(); cr_cep_stack.push_back(cep); cr_level = next_cr_level; } } /* * Build the next node info */ /* Find the next cell to be splitted */ if(!next_split_cell) next_split_cell = find_next_cell_to_be_splitted(p.get_cell(p.elements[current_node.split_cell_first])); //Partition::Cell * const next_split_cell = find_next_cell_to_be_splitted(p.get_cell(p.elements[current_node.split_cell_first])); child_node.split_cell_first = next_split_cell->first; child_node.split_element = TreeNode::SPLIT_START; child_node.certificate_index = certificate_index; child_node.partition_bt_point = p.set_backtrack_point(); child_node.long_prune_redundant.clear(); child_node.long_prune_begin = current_node.long_prune_begin; /* Save component recursion info for backtracking */ child_node.cr_level = cr_level; child_node.cr_cep_stack_size = cr_cep_stack.size(); child_node.cr_cep_index = cr_cep_index; search_stack.push_back(child_node); continue; } /* * A leaf node not in the first path or equivalent to the first path */ if(child_node.cmp_to_best_path > 0) { /* * A new, better representative found */ //fprintf(stdout, "Level %u: NEW BEST\n", child_level); fflush(stdout); stats.nof_canupdates++; /* * Update canonical labeling and its inverse */ update_labeling_and_its_inverse(best_path_labeling, best_path_labeling_inv); /* Reset best path automorphism */ reset_permutation(best_path_automorphism); /* Reset best path orbit structure */ best_path_orbits.reset(); /* * Mark the current path to be the best one and save it */ const unsigned int base_size = search_stack.size(); assert(current_level+1 == base_size); best_path_info.clear(); for(unsigned int i = 0; i < base_size; i++) { search_stack[i].cmp_to_best_path = 0; search_stack[i].in_best_path = true; PathInfo path_info; path_info.splitting_element = search_stack[i].split_element; path_info.certificate_index = search_stack[i].certificate_index; path_info.subcertificate_length = search_stack[i].subcertificate_length; path_info.eqref_hash = search_stack[i].eqref_hash; best_path_info.push_back(path_info); } certificate_best_path = certificate_current_path; /* * Backtrack to the previous level */ continue; } handle_best_path_automorphism: /* * * Best path automorphism handling * */ { /* * Equal to the previous best path */ if(p.is_discrete()) { #if defined(BLISS_CONSISTENCY_CHECKS) /* Verify that the automorphism is correctly built */ for(unsigned int i = 0; i < N; i++) assert(best_path_automorphism[i] == p.elements[best_path_labeling[i]]); #endif } else { /* An automorphism that was found before the partition was discrete. * Set the image of all elements in non-disrete cells accordingly */ for(Partition::Cell* c = p.first_nonsingleton_cell; c; c = c->next_nonsingleton) { for(unsigned int i = c->first; i < c->first+c->length; i++) if(p.get_cell(p.elements[best_path_labeling[p.elements[i]]])->is_unit()) best_path_automorphism[p.elements[best_path_labeling[p.elements[i]]]] = p.elements[i]; else best_path_automorphism[p.elements[i]] = p.elements[i]; } } #if defined(BLISS_VERIFY_AUTOMORPHISMS) /* Verify that it really is an automorphism */ if(!is_automorphism(best_path_automorphism)) fatal_error("Best path automorhism validation check failed"); #endif unsigned int gca_level_with_first = 0; for(unsigned int i = search_stack.size(); i > 0; i--) { if((int)first_path_info[gca_level_with_first].splitting_element != search_stack[gca_level_with_first].split_element) break; gca_level_with_first++; } unsigned int gca_level_with_best = 0; for(unsigned int i = search_stack.size(); i > 0; i--) { if((int)best_path_info[gca_level_with_best].splitting_element != search_stack[gca_level_with_best].split_element) break; gca_level_with_best++; } if(opt_use_long_prune) { /* Record automorphism */ long_prune_add_automorphism(best_path_automorphism); } /* * Update orbit information */ update_orbit_information(best_path_orbits, best_path_automorphism); /* * Update orbit information */ const unsigned int nof_old_orbits = first_path_orbits.nof_orbits(); update_orbit_information(first_path_orbits, best_path_automorphism); if(nof_old_orbits != first_path_orbits.nof_orbits()) { /* Some orbits were merged */ /* Report automorphism */ if(report_hook) (*report_hook)(report_user_param, get_nof_vertices(), best_path_automorphism); /* Update statistics */ stats.nof_generators++; } /* * Compute backjumping level */ unsigned int backjumping_level = current_level+1-1; if(!first_path_orbits.is_minimal_representative(search_stack[gca_level_with_first].split_element)) { backjumping_level = gca_level_with_first; } else { assert(!best_path_orbits.is_minimal_representative(search_stack[gca_level_with_best].split_element)); backjumping_level = gca_level_with_best; } /* Backtrack */ search_stack.resize(backjumping_level + 1); continue; } _INTERNAL_ERROR(); handle_first_path_automorphism: /* * * A first-path automorphism: aut[i] = elements[first_path_labeling[i]] * */ if(p.is_discrete()) { #if defined(BLISS_CONSISTENCY_CHECKS) /* Verify that the complete automorphism is correctly built */ for(unsigned int i = 0; i < N; i++) assert(first_path_automorphism[i] == p.elements[first_path_labeling[i]]); #endif } else { /* An automorphism that was found before the partition was discrete. * Set the image of all elements in non-disrete cells accordingly */ for(Partition::Cell* c = p.first_nonsingleton_cell; c; c = c->next_nonsingleton) { for(unsigned int i = c->first; i < c->first+c->length; i++) if(p.get_cell(p.elements[first_path_labeling[p.elements[i]]])->is_unit()) first_path_automorphism[p.elements[first_path_labeling[p.elements[i]]]] = p.elements[i]; else first_path_automorphism[p.elements[i]] = p.elements[i]; } } #if defined(BLISS_VERIFY_AUTOMORPHISMS) /* Verify that it really is an automorphism */ if(!is_automorphism(first_path_automorphism)) fatal_error("First path automorphism validation check failed"); #endif if(opt_use_long_prune) { long_prune_add_automorphism(first_path_automorphism); } /* * Update orbit information */ update_orbit_information(first_path_orbits, first_path_automorphism); /* * Compute backjumping level */ for(unsigned int i = 0; i < search_stack.size(); i++) { TreeNode& n = search_stack[i]; if(n.fp_on) { ; } else { n.fp_extendable = TreeNode::YES; } } /* Report automorphism by calling the user defined hook function */ if(report_hook) (*report_hook)(report_user_param, get_nof_vertices(), first_path_automorphism); /* Update statistics */ stats.nof_generators++; continue; } /* while(!search_stack.empty()) */ /* Free "long prune" technique memory */ if(opt_use_long_prune) long_prune_deallocate(); /* Release component recursion data in partition */ if(opt_use_comprec) p.cr_free(); } void AbstractGraph::find_automorphisms(Stats& stats, void (*hook)(void *user_param, unsigned int n, const unsigned int *aut), void *user_param) { report_hook = hook; report_user_param = user_param; search(false, stats); if(first_path_labeling) { free(first_path_labeling); first_path_labeling = 0; } if(best_path_labeling) { free(best_path_labeling); best_path_labeling = 0; } } const unsigned int * AbstractGraph::canonical_form(Stats& stats, void (*hook)(void *user_param, unsigned int n, const unsigned int *aut), void *user_param) { report_hook = hook; report_user_param = user_param; search(true, stats); return best_path_labeling; } /*------------------------------------------------------------------------- * * Routines for directed graphs * *-------------------------------------------------------------------------*/ template Digraph::Vertex::Vertex() { color = 0; label = std::string{""}; //value = nullptr; value = NULL; } template Digraph::Vertex::~Vertex() { //value = nullptr; value = NULL; } template void Digraph::Vertex::add_edge_to(const unsigned int other_vertex) { edges_out.push_back(other_vertex); } template void Digraph::Vertex::add_edge_from(const unsigned int other_vertex) { edges_in.push_back(other_vertex); } templatevoid Digraph::Vertex::remove_duplicate_edges(std::vector& tmp) { #if defined(BLISS_CONSISTENCY_CHECKS) /* Pre-conditions */ for(unsigned int i = 0; i < tmp.size(); i++) assert(tmp[i] == false); #endif for(std::vector::iterator iter = edges_out.begin(); iter != edges_out.end(); ) { const unsigned int dest_vertex = *iter; if(tmp[dest_vertex] == true) { /* A duplicate edge found! */ iter = edges_out.erase(iter); } else { /* Not seen earlier, mark as seen */ tmp[dest_vertex] = true; iter++; } } /* Clear tmp */ for(std::vector::iterator iter = edges_out.begin(); iter != edges_out.end(); iter++) { tmp[*iter] = false; } for(std::vector::iterator iter = edges_in.begin(); iter != edges_in.end(); ) { const unsigned int dest_vertex = *iter; if(tmp[dest_vertex] == true) { /* A duplicate edge found! */ iter = edges_in.erase(iter); } else { /* Not seen earlier, mark as seen */ tmp[dest_vertex] = true; iter++; } } /* Clear tmp */ for(std::vector::iterator iter = edges_in.begin(); iter != edges_in.end(); iter++) { tmp[*iter] = false; } #if defined(BLISS_CONSISTENCY_CHECKS) /* Post-conditions */ for(unsigned int i = 0; i < tmp.size(); i++) assert(tmp[i] == false); #endif } /** * Sort the edges entering and leaving the vertex according to * the vertex number of the other edge end. * Time complexity: O(e log(e)), where e is the number of edges * entering/leaving the vertex. */ template void Digraph::Vertex::sort_edges() { std::sort(edges_in.begin(), edges_in.end()); std::sort(edges_out.begin(), edges_out.end()); } /*------------------------------------------------------------------------- * * Constructor and destructor for directed graphs * *-------------------------------------------------------------------------*/ template Digraph::Digraph(const unsigned int nof_vertices) { vertices.resize(nof_vertices); } template Digraph::~Digraph() { ; } template std::string Digraph::get_vertex_label(const unsigned int vertex) const { return vertices[vertex].label; } template const T* Digraph::get_vertex_value(const unsigned int vertex) const { return vertices[vertex].value; } template unsigned int Digraph::add_vertex(const unsigned int color, const std::string label, const T* value) { const unsigned int new_vertex_num = vertices.size(); vertices.resize(new_vertex_num + 1); vertices.back().color = color; vertices.back().label = label; vertices.back().value = value; return new_vertex_num; } template void Digraph::add_edge(const unsigned int vertex1, const unsigned int vertex2) { assert(vertex1 < get_nof_vertices()); assert(vertex2 < get_nof_vertices()); vertices[vertex1].add_edge_to(vertex2); vertices[vertex2].add_edge_from(vertex1); } template void Digraph::change_color(const unsigned int vertex, const unsigned int new_color) { assert(vertex < get_nof_vertices()); vertices[vertex].color = new_color; } template void Digraph::sort_edges() { for(unsigned int i = 0; i < get_nof_vertices(); i++) vertices[i].sort_edges(); } template int Digraph::cmp(Digraph& other) { /* Compare the numbers of vertices */ if(get_nof_vertices() < other.get_nof_vertices()) return -1; if(get_nof_vertices() > other.get_nof_vertices()) return 1; /* Compare vertex colors */ for(unsigned int i = 0; i < get_nof_vertices(); i++) { if(vertices[i].color < other.vertices[i].color) return -1; if(vertices[i].color > other.vertices[i].color) return 1; } /* Compare vertex degrees */ remove_duplicate_edges(); other.remove_duplicate_edges(); for(unsigned int i = 0; i < get_nof_vertices(); i++) { if(vertices[i].nof_edges_in() < other.vertices[i].nof_edges_in()) return -1; if(vertices[i].nof_edges_in() > other.vertices[i].nof_edges_in()) return 1; if(vertices[i].nof_edges_out() < other.vertices[i].nof_edges_out()) return -1; if(vertices[i].nof_edges_out() > other.vertices[i].nof_edges_out()) return 1; } /* Compare edges */ for(unsigned int i = 0; i < get_nof_vertices(); i++) { Vertex& v1 = vertices[i]; Vertex& v2 = other.vertices[i]; v1.sort_edges(); v2.sort_edges(); std::vector::const_iterator ei1 = v1.edges_in.begin(); std::vector::const_iterator ei2 = v2.edges_in.begin(); while(ei1 != v1.edges_in.end()) { if(*ei1 < *ei2) return -1; if(*ei1 > *ei2) return 1; ei1++; ei2++; } ei1 = v1.edges_out.begin(); ei2 = v2.edges_out.begin(); while(ei1 != v1.edges_out.end()) { if(*ei1 < *ei2) return -1; if(*ei1 > *ei2) return 1; ei1++; ei2++; } } return 0; } template Digraph* Digraph::permute(const std::vector& perm) const { Digraph* const g = new Digraph(get_nof_vertices()); for(unsigned int i = 0; i < get_nof_vertices(); i++) { const Vertex& v = vertices[i]; g->change_color(perm[i], v.color); for(std::vector::const_iterator ei = v.edges_out.begin(); ei != v.edges_out.end(); ei++) { g->add_edge(perm[i], perm[*ei]); } } g->sort_edges(); return g; } template Digraph* Digraph::permute(const unsigned int* const perm) const { Digraph* const g = new Digraph(get_nof_vertices()); for(unsigned int i = 0; i < get_nof_vertices(); i++) { const Vertex &v = vertices[i]; g->change_color(perm[i], v.color); for(std::vector::const_iterator ei = v.edges_out.begin(); ei != v.edges_out.end(); ei++) { g->add_edge(perm[i], perm[*ei]); } } g->sort_edges(); return g; } /*------------------------------------------------------------------------- * * Print graph in graphviz format * *-------------------------------------------------------------------------*/ template void Digraph::write_dot(const char* const filename) { FILE* const fp = fopen(filename, "w"); if(fp) { write_dot(fp); fclose(fp); } } template void Digraph::write_dot(FILE* const fp) { remove_duplicate_edges(); fprintf(fp, "digraph g {\n"); unsigned int vnum = 0; for(typename std::vector::const_iterator vi = vertices.begin(); vi != vertices.end(); vi++, vnum++) { const Vertex& v = *vi; //fprintf(fp, "v%u [label=\"%u:%u (%s)\"];\n", vnum, vnum, v.color, v.label.c_str()); fprintf(fp, "v%u [label=\"(%u) %u, %s\"];\n", vnum, vnum, v.color, v.label.c_str()); for(std::vector::const_iterator ei = v.edges_out.begin(); ei != v.edges_out.end(); ei++) { fprintf(fp, "v%u -> v%u\n", vnum, *ei); } } fprintf(fp, "}\n"); } template void Digraph::remove_duplicate_edges() { std::vector tmp(get_nof_vertices(), false); for(typename std::vector::iterator vi = vertices.begin(); vi != vertices.end(); vi++) { #if defined(BLISS_EXPENSIVE_CONSISTENCY_CHECKS) for(unsigned int i = 0; i < tmp.size(); i++) assert(tmp[i] == false); #endif (*vi).remove_duplicate_edges(tmp); } } /*------------------------------------------------------------------------- * * Get a hash value for the graph. * *-------------------------------------------------------------------------*/ template unsigned int Digraph::get_hash() { remove_duplicate_edges(); sort_edges(); UintSeqHash h; h.update(get_nof_vertices()); /* Hash the color of each vertex */ for(unsigned int i = 0; i < get_nof_vertices(); i++) { h.update(vertices[i].color); } /* Hash the edges */ for(unsigned int i = 0; i < get_nof_vertices(); i++) { Vertex &v = vertices[i]; for(std::vector::const_iterator ei = v.edges_out.begin(); ei != v.edges_out.end(); ei++) { h.update(i); h.update(*ei); } } return h.get_value(); } /*------------------------------------------------------------------------- * * Read directed graph in the DIMACS format. * Returns 0 if an error occurred. * *-------------------------------------------------------------------------*/ template Digraph* Digraph::read_dimacs(FILE* const fp, FILE* const errstr) { Digraph* g = 0; unsigned int nof_vertices; unsigned int nof_edges; unsigned int line_num = 1; const bool verbose = false; FILE* const verbstr = stdout; /* Read comments and the problem definition line */ while(1) { int c = getc(fp); if(c == 'c') { /* A comment, ignore the rest of the line */ while((c = getc(fp)) != '\n') { if(c == EOF) { if(errstr) fprintf(errstr, "error in line %u: not in DIMACS format\n", line_num); goto error_exit; } } line_num++; continue; } if(c == 'p') { /* The problem definition line */ if(fscanf(fp, " edge %u %u\n", &nof_vertices, &nof_edges) != 2) { if(errstr) fprintf(errstr, "error in line %u: not in DIMACS format\n", line_num); goto error_exit; } line_num++; break; } if(errstr) fprintf(errstr, "error in line %u: not in DIMACS format\n", line_num); goto error_exit; } if(nof_vertices <= 0) { if(errstr) fprintf(errstr, "error: no vertices\n"); goto error_exit; } if(verbose) { fprintf(verbstr, "Instance has %d vertices and %d edges\n", nof_vertices, nof_edges); fflush(verbstr); } g = new Digraph(nof_vertices); // // Read vertex colors // if(verbose) { fprintf(verbstr, "Reading vertex colors...\n"); fflush(verbstr); } while(1) { int c = getc(fp); if(c != 'n') { ungetc(c, fp); break; } ungetc(c, fp); unsigned int vertex; unsigned int color; if(fscanf(fp, "n %u %u\n", &vertex, &color) != 2) { if(errstr) fprintf(errstr, "error in line %u: not in DIMACS format\n", line_num); goto error_exit; } if(!((vertex >= 1) && (vertex <= nof_vertices))) { if(errstr) fprintf(errstr, "error in line %u: vertex %u not in range [1,...%u]\n", line_num, vertex, nof_vertices); goto error_exit; } line_num++; g->change_color(vertex - 1, color); } if(verbose) { fprintf(verbstr, "Done\n"); fflush(verbstr); } // // Read edges // if(verbose) { fprintf(verbstr, "Reading edges...\n"); fflush(verbstr); } for(unsigned i = 0; i < nof_edges; i++) { unsigned int from, to; if(fscanf(fp, "e %u %u\n", &from, &to) != 2) { if(errstr) fprintf(errstr, "error in line %u: not in DIMACS format\n", line_num); goto error_exit; } if(not((1 <= from) and (from <= nof_vertices))) { if(errstr) fprintf(errstr, "error in line %u: vertex %u not in range [1,...%u]\n", line_num, from, nof_vertices); goto error_exit; } if(not((1 <= to) and (to <= nof_vertices))) { if(errstr) fprintf(errstr, "error in line %u: vertex %u not in range [1,...%u]\n", line_num, to, nof_vertices); goto error_exit; } line_num++; g->add_edge(from-1, to-1); } if(verbose) { fprintf(verbstr, "Done\n"); fflush(verbstr); } return g; error_exit: if(g) delete g; return 0; } template void Digraph::write_dimacs(FILE* const fp) { remove_duplicate_edges(); sort_edges(); /* First count the total number of edges */ unsigned int nof_edges = 0; for(unsigned int i = 0; i < get_nof_vertices(); i++) { nof_edges += vertices[i].edges_out.size(); } /* Output the "header" line */ fprintf(fp, "p edge %u %u\n", get_nof_vertices(), nof_edges); /* Print the color of each vertex */ for(unsigned int i = 0; i < get_nof_vertices(); i++) { Vertex& v = vertices[i]; fprintf(fp, "n %u %u\n", i+1, v.color); /* if(v.color != 0) { fprintf(fp, "n %u %u\n", i+1, v.color); } */ } /* Print the edges */ for(unsigned int i = 0; i < get_nof_vertices(); i++) { Vertex& v = vertices[i]; for(std::vector::const_iterator ei = v.edges_out.begin(); ei != v.edges_out.end(); ei++) { fprintf(fp, "e %u %u\n", i+1, (*ei)+1); } } } /*------------------------------------------------------------------------- * * Partition independent invariants * *-------------------------------------------------------------------------*/ template unsigned int Digraph::vertex_color_invariant(const Digraph* const g, const unsigned int vnum) { return g->vertices[vnum].color; } template unsigned int Digraph::indegree_invariant(const Digraph* const g, const unsigned int vnum) { return g->vertices[vnum].nof_edges_in(); } template unsigned int Digraph::outdegree_invariant(const Digraph* const g, const unsigned int vnum) { return g->vertices[vnum].nof_edges_out(); } template unsigned int Digraph::selfloop_invariant(const Digraph* const g, const unsigned int vnum) { /* Quite inefficient but luckily not in the critical path */ const Vertex& v = g->vertices[vnum]; for(std::vector::const_iterator ei = v.edges_out.begin(); ei != v.edges_out.end(); ei++) { if(*ei == vnum) return 1; } return 0; } /*------------------------------------------------------------------------- * * Refine the partition p according to a partition independent invariant * *-------------------------------------------------------------------------*/ template bool Digraph::refine_according_to_invariant(unsigned int (*inv)(const Digraph* const g, const unsigned int v)) { bool refined = false; for(Partition::Cell* cell = p.first_nonsingleton_cell; cell; ) { Partition::Cell* const next_cell = cell->next_nonsingleton; const unsigned int* ep = p.elements + cell->first; for(unsigned int i = cell->length; i > 0; i--, ep++) { unsigned int ival = inv(this, *ep); p.invariant_values[*ep] = ival; if(ival > cell->max_ival) { cell->max_ival = ival; cell->max_ival_count = 1; } else if(ival == cell->max_ival) { cell->max_ival_count++; } } Partition::Cell* const last_new_cell = p.zplit_cell(cell, true); refined |= (last_new_cell != cell); cell = next_cell; } return refined; } /*------------------------------------------------------------------------- * * Split the neighbourhood of a cell according to the equitable invariant * *-------------------------------------------------------------------------*/ template bool Digraph::split_neighbourhood_of_cell(Partition::Cell* const cell) { const bool was_equal_to_first = refine_equal_to_first; if(compute_eqref_hash) { eqref_hash.update(cell->first); eqref_hash.update(cell->length); } const unsigned int* ep = p.elements + cell->first; for(unsigned int i = cell->length; i > 0; i--) { const Vertex& v = vertices[*ep++]; std::vector::const_iterator ei = v.edges_out.begin(); for(unsigned int j = v.nof_edges_out(); j != 0; j--) { const unsigned int dest_vertex = *ei++; Partition::Cell* const neighbour_cell = p.get_cell(dest_vertex); if(neighbour_cell->is_unit()) continue; const unsigned int ival = ++p.invariant_values[dest_vertex]; if(ival > neighbour_cell->max_ival) { neighbour_cell->max_ival = ival; neighbour_cell->max_ival_count = 1; if(ival == 1) neighbour_heap.insert(neighbour_cell->first); } else if(ival == neighbour_cell->max_ival) { neighbour_cell->max_ival_count++; } } } while(!neighbour_heap.is_empty()) { const unsigned int start = neighbour_heap.remove(); Partition::Cell* const neighbour_cell = p.get_cell(p.elements[start]); if(compute_eqref_hash) { eqref_hash.update(neighbour_cell->first); eqref_hash.update(neighbour_cell->length); eqref_hash.update(neighbour_cell->max_ival); eqref_hash.update(neighbour_cell->max_ival_count); } Partition::Cell* const last_new_cell = p.zplit_cell(neighbour_cell, true); /* Update certificate and hash if needed */ const Partition::Cell* c = neighbour_cell; while(1) { if(in_search) { /* Build certificate */ cert_add_redundant(CERT_SPLIT, c->first, c->length); /* No need to continue? */ if(refine_compare_certificate and (refine_equal_to_first == false) and (refine_cmp_to_best < 0)) goto worse_exit; } if(compute_eqref_hash) { eqref_hash.update(c->first); eqref_hash.update(c->length); } if(c == last_new_cell) break; c = c->next; } } if(cell->is_in_splitting_queue()) { return false; } ep = p.elements + cell->first; for(unsigned int i = cell->length; i > 0; i--) { const Vertex& v = vertices[*ep++]; std::vector::const_iterator ei = v.edges_in.begin(); for(unsigned int j = v.nof_edges_in(); j > 0; j--) { const unsigned int dest_vertex = *ei++; Partition::Cell* const neighbour_cell = p.get_cell(dest_vertex); if(neighbour_cell->is_unit()) continue; const unsigned int ival = ++p.invariant_values[dest_vertex]; if(ival > neighbour_cell->max_ival) { neighbour_cell->max_ival = ival; neighbour_cell->max_ival_count = 1; if(ival == 1) neighbour_heap.insert(neighbour_cell->first); } else if(ival == neighbour_cell->max_ival) { neighbour_cell->max_ival_count++; } } } while(!neighbour_heap.is_empty()) { const unsigned int start = neighbour_heap.remove(); Partition::Cell* const neighbour_cell = p.get_cell(p.elements[start]); if(compute_eqref_hash) { eqref_hash.update(neighbour_cell->first); eqref_hash.update(neighbour_cell->length); eqref_hash.update(neighbour_cell->max_ival); eqref_hash.update(neighbour_cell->max_ival_count); } Partition::Cell* const last_new_cell = p.zplit_cell(neighbour_cell, true); /* Update certificate and hash if needed */ const Partition::Cell* c = neighbour_cell; while(1) { if(in_search) { /* Build certificate */ cert_add_redundant(CERT_SPLIT, c->first, c->length); /* No need to continue? */ if(refine_compare_certificate and (refine_equal_to_first == false) and (refine_cmp_to_best < 0)) goto worse_exit; } if(compute_eqref_hash) { eqref_hash.update(c->first); eqref_hash.update(c->length); } if(c == last_new_cell) break; c = c->next; } } if(refine_compare_certificate and (refine_equal_to_first == false) and (refine_cmp_to_best < 0)) return true; return false; worse_exit: /* Clear neighbour heap */ UintSeqHash rest; while(!neighbour_heap.is_empty()) { const unsigned int start = neighbour_heap.remove(); Partition::Cell* const neighbour_cell = p.get_cell(p.elements[start]); if(opt_use_failure_recording and was_equal_to_first) { rest.update(neighbour_cell->first); rest.update(neighbour_cell->length); rest.update(neighbour_cell->max_ival); rest.update(neighbour_cell->max_ival_count); } neighbour_cell->max_ival = 0; neighbour_cell->max_ival_count = 0; p.clear_ivs(neighbour_cell); } if(opt_use_failure_recording and was_equal_to_first) { for(unsigned int i = p.splitting_queue.size(); i > 0; i--) { Partition::Cell* const cell = p.splitting_queue.pop_front(); rest.update(cell->first); rest.update(cell->length); p.splitting_queue.push_back(cell); } rest.update(failure_recording_fp_deviation); failure_recording_fp_deviation = rest.get_value(); } return true; } template bool Digraph::split_neighbourhood_of_unit_cell(Partition::Cell* const unit_cell) { const bool was_equal_to_first = refine_equal_to_first; if(compute_eqref_hash) { eqref_hash.update(0x87654321); eqref_hash.update(unit_cell->first); eqref_hash.update(1); } const Vertex& v = vertices[p.elements[unit_cell->first]]; /* * Phase 1 * Refine neighbours according to the edges that leave the vertex v */ std::vector::const_iterator ei = v.edges_out.begin(); for(unsigned int j = v.nof_edges_out(); j > 0; j--) { const unsigned int dest_vertex = *ei++; Partition::Cell* const neighbour_cell = p.get_cell(dest_vertex); if(neighbour_cell->is_unit()) { if(in_search) { /* Remember neighbour in order to generate certificate */ neighbour_heap.insert(neighbour_cell->first); } continue; } if(neighbour_cell->max_ival_count == 0) { neighbour_heap.insert(neighbour_cell->first); } neighbour_cell->max_ival_count++; unsigned int* const swap_position = p.elements + neighbour_cell->first + neighbour_cell->length - neighbour_cell->max_ival_count; *p.in_pos[dest_vertex] = *swap_position; p.in_pos[*swap_position] = p.in_pos[dest_vertex]; *swap_position = dest_vertex; p.in_pos[dest_vertex] = swap_position; } while(!neighbour_heap.is_empty()) { const unsigned int start = neighbour_heap.remove(); Partition::Cell* neighbour_cell = p.get_cell(p.elements[start]); #if defined(BLISS_CONSISTENCY_CHECKS) assert(neighbour_cell->first == start); if(neighbour_cell->is_unit()) { assert(neighbour_cell->max_ival_count == 0); } else { assert(neighbour_cell->max_ival_count > 0); assert(neighbour_cell->max_ival_count <= neighbour_cell->length); } #endif if(compute_eqref_hash) { eqref_hash.update(neighbour_cell->first); eqref_hash.update(neighbour_cell->length); eqref_hash.update(neighbour_cell->max_ival_count); } if(neighbour_cell->length > 1 and neighbour_cell->max_ival_count != neighbour_cell->length) { Partition::Cell* const new_cell = p.aux_split_in_two(neighbour_cell, neighbour_cell->length - neighbour_cell->max_ival_count); unsigned int* ep = p.elements + new_cell->first; unsigned int* const lp = p.elements+new_cell->first+new_cell->length; while(ep < lp) { p.element_to_cell_map[*ep] = new_cell; ep++; } neighbour_cell->max_ival_count = 0; if(compute_eqref_hash) { /* Update hash */ eqref_hash.update(neighbour_cell->first); eqref_hash.update(neighbour_cell->length); eqref_hash.update(0); eqref_hash.update(new_cell->first); eqref_hash.update(new_cell->length); eqref_hash.update(1); } /* Add cells in splitting_queue */ if(neighbour_cell->is_in_splitting_queue()) { /* Both cells must be included in splitting_queue in order to have refinement to equitable partition */ p.splitting_queue_add(new_cell); } else { Partition::Cell *min_cell, *max_cell; if(neighbour_cell->length <= new_cell->length) { min_cell = neighbour_cell; max_cell = new_cell; } else { min_cell = new_cell; max_cell = neighbour_cell; } /* Put the smaller cell in splitting_queue */ p.splitting_queue_add(min_cell); if(max_cell->is_unit()) { /* Put the "larger" cell also in splitting_queue */ p.splitting_queue_add(max_cell); } } /* Update pointer for certificate generation */ neighbour_cell = new_cell; } else { neighbour_cell->max_ival_count = 0; } /* * Build certificate if required */ if(in_search) { for(unsigned int i = neighbour_cell->first, j = neighbour_cell->length; j > 0; j--, i++) { /* Build certificate */ cert_add(CERT_EDGE, unit_cell->first, i); /* No need to continue? */ if(refine_compare_certificate and (refine_equal_to_first == false) and (refine_cmp_to_best < 0)) goto worse_exit; } } /* if(in_search) */ } /* while(!neighbour_heap.is_empty()) */ /* * Phase 2 * Refine neighbours according to the edges that enter the vertex v */ ei = v.edges_in.begin(); for(unsigned int j = v.nof_edges_in(); j > 0; j--) { const unsigned int dest_vertex = *ei++; Partition::Cell* const neighbour_cell = p.get_cell(dest_vertex); if(neighbour_cell->is_unit()) { if(in_search) { neighbour_heap.insert(neighbour_cell->first); } continue; } if(neighbour_cell->max_ival_count == 0) { neighbour_heap.insert(neighbour_cell->first); } neighbour_cell->max_ival_count++; unsigned int* const swap_position = p.elements + neighbour_cell->first + neighbour_cell->length - neighbour_cell->max_ival_count; *p.in_pos[dest_vertex] = *swap_position; p.in_pos[*swap_position] = p.in_pos[dest_vertex]; *swap_position = dest_vertex; p.in_pos[dest_vertex] = swap_position; } while(!neighbour_heap.is_empty()) { const unsigned int start = neighbour_heap.remove(); Partition::Cell* neighbour_cell = p.get_cell(p.elements[start]); #if defined(BLISS_CONSISTENCY_CHECKS) assert(neighbour_cell->first == start); if(neighbour_cell->is_unit()) { assert(neighbour_cell->max_ival_count == 0); } else { assert(neighbour_cell->max_ival_count > 0); assert(neighbour_cell->max_ival_count <= neighbour_cell->length); } #endif if(compute_eqref_hash) { eqref_hash.update(neighbour_cell->first); eqref_hash.update(neighbour_cell->length); eqref_hash.update(neighbour_cell->max_ival_count); } if(neighbour_cell->length > 1 and neighbour_cell->max_ival_count != neighbour_cell->length) { Partition::Cell* const new_cell = p.aux_split_in_two(neighbour_cell, neighbour_cell->length - neighbour_cell->max_ival_count); unsigned int* ep = p.elements + new_cell->first; unsigned int* const lp = p.elements+new_cell->first+new_cell->length; while(ep < lp) { p.element_to_cell_map[*ep] = new_cell; ep++; } neighbour_cell->max_ival_count = 0; if(compute_eqref_hash) { eqref_hash.update(neighbour_cell->first); eqref_hash.update(neighbour_cell->length); eqref_hash.update(0); eqref_hash.update(new_cell->first); eqref_hash.update(new_cell->length); eqref_hash.update(1); } /* Add cells in splitting_queue */ if(neighbour_cell->is_in_splitting_queue()) { /* Both cells must be included in splitting_queue in order to have refinement to equitable partition */ p.splitting_queue_add(new_cell); } else { Partition::Cell *min_cell, *max_cell; if(neighbour_cell->length <= new_cell->length) { min_cell = neighbour_cell; max_cell = new_cell; } else { min_cell = new_cell; max_cell = neighbour_cell; } /* Put the smaller cell in splitting_queue */ p.splitting_queue_add(min_cell); if(max_cell->is_unit()) { /* Put the "larger" cell also in splitting_queue */ p.splitting_queue_add(max_cell); } } /* Update pointer for certificate generation */ neighbour_cell = new_cell; } else { neighbour_cell->max_ival_count = 0; } /* * Build certificate if required */ if(in_search) { for(unsigned int i = neighbour_cell->first, j = neighbour_cell->length; j > 0; j--, i++) { /* Build certificate */ cert_add(CERT_EDGE, i, unit_cell->first); /* No need to continue? */ if(refine_compare_certificate and (refine_equal_to_first == false) and (refine_cmp_to_best < 0)) goto worse_exit; } } /* if(in_search) */ } /* while(!neighbour_heap.is_empty()) */ if(refine_compare_certificate and (refine_equal_to_first == false) and (refine_cmp_to_best < 0)) return true; return false; worse_exit: /* Clear neighbour heap */ UintSeqHash rest; while(!neighbour_heap.is_empty()) { const unsigned int start = neighbour_heap.remove(); Partition::Cell* const neighbour_cell = p.get_cell(p.elements[start]); if(opt_use_failure_recording and was_equal_to_first) { rest.update(neighbour_cell->first); rest.update(neighbour_cell->length); rest.update(neighbour_cell->max_ival_count); } neighbour_cell->max_ival_count = 0; } if(opt_use_failure_recording and was_equal_to_first) { rest.update(failure_recording_fp_deviation); failure_recording_fp_deviation = rest.get_value(); } return true; } /*------------------------------------------------------------------------- * * Check whether the current partition p is equitable. * Performance: very slow, use only for debugging purposes. * *-------------------------------------------------------------------------*/ template bool Digraph::is_equitable() const { const unsigned int N = get_nof_vertices(); if(N == 0) return true; std::vector first_count = std::vector(N, 0); std::vector other_count = std::vector(N, 0); /* * Check equitabledness w.r.t. outgoing edges */ for(Partition::Cell* cell = p.first_cell; cell; cell = cell->next) { if(cell->is_unit()) continue; unsigned int* ep = p.elements + cell->first; const Vertex& first_vertex = vertices[*ep++]; /* Count outgoing edges of the first vertex for cells */ for(std::vector::const_iterator ei = first_vertex.edges_out.begin(); ei != first_vertex.edges_out.end(); ei++) { first_count[p.get_cell(*ei)->first]++; } /* Count and compare outgoing edges of the other vertices */ for(unsigned int i = cell->length; i > 1; i--) { const Vertex &vertex = vertices[*ep++]; for(std::vector::const_iterator ei = vertex.edges_out.begin(); ei != vertex.edges_out.end(); ei++) { other_count[p.get_cell(*ei)->first]++; } for(Partition::Cell *cell2 = p.first_cell; cell2; cell2 = cell2->next) { if(first_count[cell2->first] != other_count[cell2->first]) { /* Not equitable */ return false; } other_count[cell2->first] = 0; } } /* Reset first_count */ for(unsigned int i = 0; i < N; i++) first_count[i] = 0; } /* * Check equitabledness w.r.t. incoming edges */ for(Partition::Cell* cell = p.first_cell; cell; cell = cell->next) { if(cell->is_unit()) continue; unsigned int* ep = p.elements + cell->first; const Vertex& first_vertex = vertices[*ep++]; /* Count incoming edges of the first vertex for cells */ for(std::vector::const_iterator ei = first_vertex.edges_in.begin(); ei != first_vertex.edges_in.end(); ei++) { first_count[p.get_cell(*ei)->first]++; } /* Count and compare incoming edges of the other vertices */ for(unsigned int i = cell->length; i > 1; i--) { const Vertex &vertex = vertices[*ep++]; for(std::vector::const_iterator ei = vertex.edges_in.begin(); ei != vertex.edges_in.end(); ei++) { other_count[p.get_cell(*ei)->first]++; } for(Partition::Cell *cell2 = p.first_cell; cell2; cell2 = cell2->next) { if(first_count[cell2->first] != other_count[cell2->first]) { /* Not equitable */ return false; } other_count[cell2->first] = 0; } } /* Reset first_count */ for(unsigned int i = 0; i < N; i++) first_count[i] = 0; } return true; } /*------------------------------------------------------------------------- * * Build the initial equitable partition * *-------------------------------------------------------------------------*/ template void Digraph::make_initial_equitable_partition() { refine_according_to_invariant(&vertex_color_invariant); p.splitting_queue_clear(); //p.print_signature(stderr); fprintf(stderr, "\n"); refine_according_to_invariant(&selfloop_invariant); p.splitting_queue_clear(); //p.print_signature(stderr); fprintf(stderr, "\n"); refine_according_to_invariant(&outdegree_invariant); p.splitting_queue_clear(); //p.print_signature(stderr); fprintf(stderr, "\n"); refine_according_to_invariant(&indegree_invariant); p.splitting_queue_clear(); //p.print_signature(stderr); fprintf(stderr, "\n"); refine_to_equitable(); //p.print_signature(stderr); fprintf(stderr, "\n"); } /*------------------------------------------------------------------------- * * Find the next cell to be splitted * *-------------------------------------------------------------------------*/ template Partition::Cell* Digraph::find_next_cell_to_be_splitted(Partition::Cell* cell) { switch(sh) { case shs_f: return sh_first(); case shs_fs: return sh_first_smallest(); case shs_fl: return sh_first_largest(); case shs_fm: return sh_first_max_neighbours(); case shs_fsm: return sh_first_smallest_max_neighbours(); case shs_flm: return sh_first_largest_max_neighbours(); default: fatal_error("Internal error - unknown splitting heuristics"); return 0; } } /** \internal * A splitting heuristic. * Returns the first nonsingleton cell in the current partition. * The argument \a cell is ignored. */ template Partition::Cell* Digraph::sh_first() { Partition::Cell* best_cell = 0; for(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) { if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level) continue; best_cell = cell; break; } return best_cell; } /** \internal * A splitting heuristic. * Returns the first smallest nonsingleton cell in the current partition. * The argument \a cell is ignored. */ template Partition::Cell* Digraph::sh_first_smallest() { Partition::Cell* best_cell = 0; unsigned int best_size = UINT_MAX; for(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) { if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level) continue; if(cell->length < best_size) { best_size = cell->length; best_cell = cell; } } return best_cell; } /** \internal * A splitting heuristic. * Returns the first largest nonsingleton cell in the current partition. * The argument \a cell is ignored. */ template Partition::Cell* Digraph::sh_first_largest() { Partition::Cell* best_cell = 0; unsigned int best_size = 0; for(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) { if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level) continue; if(cell->length > best_size) { best_size = cell->length; best_cell = cell; } } return best_cell; } /** \internal * A splitting heuristic. * Returns the first nonsingleton cell with max number of neighbouring * nonsingleton cells. * Assumes that the partition p is equitable. * Assumes that the max_ival fields of the cells are all 0. */ template Partition::Cell* Digraph::sh_first_max_neighbours() { Partition::Cell* best_cell = 0; int best_value = -1; KStack neighbour_cells_visited; neighbour_cells_visited.init(get_nof_vertices()); for(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) { if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level) continue; int value = 0; const Vertex &v = vertices[p.elements[cell->first]]; std::vector::const_iterator ei; ei = v.edges_in.begin(); for(unsigned int j = v.nof_edges_in(); j > 0; j--) { Partition::Cell * const neighbour_cell = p.get_cell(*ei++); if(neighbour_cell->is_unit()) continue; neighbour_cell->max_ival++; if(neighbour_cell->max_ival == 1) neighbour_cells_visited.push(neighbour_cell); } while(!neighbour_cells_visited.is_empty()) { Partition::Cell* const neighbour_cell = neighbour_cells_visited.pop(); if(neighbour_cell->max_ival != neighbour_cell->length) value++; neighbour_cell->max_ival = 0; } ei = v.edges_out.begin(); for(unsigned int j = v.nof_edges_out(); j > 0; j--) { Partition::Cell * const neighbour_cell = p.get_cell(*ei++); if(neighbour_cell->is_unit()) continue; neighbour_cell->max_ival++; if(neighbour_cell->max_ival == 1) neighbour_cells_visited.push(neighbour_cell); } while(!neighbour_cells_visited.is_empty()) { Partition::Cell* const neighbour_cell = neighbour_cells_visited.pop(); if(neighbour_cell->max_ival != neighbour_cell->length) value++; neighbour_cell->max_ival = 0; } if(value > best_value) { best_value = value; best_cell = cell; } } return best_cell; } /** \internal * A splitting heuristic. * Returns the first smallest nonsingleton cell with max number of neighbouring * nonsingleton cells. * Assumes that the partition p is equitable. * Assumes that the max_ival fields of the cells are all 0. */ template Partition::Cell* Digraph::sh_first_smallest_max_neighbours() { Partition::Cell* best_cell = 0; int best_value = -1; unsigned int best_size = UINT_MAX; KStack neighbour_cells_visited; neighbour_cells_visited.init(get_nof_vertices()); for(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) { if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level) continue; int value = 0; const Vertex& v = vertices[p.elements[cell->first]]; std::vector::const_iterator ei; ei = v.edges_in.begin(); for(unsigned int j = v.nof_edges_in(); j > 0; j--) { Partition::Cell * const neighbour_cell = p.get_cell(*ei++); if(neighbour_cell->is_unit()) continue; neighbour_cell->max_ival++; if(neighbour_cell->max_ival == 1) neighbour_cells_visited.push(neighbour_cell); } while(!neighbour_cells_visited.is_empty()) { Partition::Cell * const neighbour_cell = neighbour_cells_visited.pop(); if(neighbour_cell->max_ival != neighbour_cell->length) value++; neighbour_cell->max_ival = 0; } ei = v.edges_out.begin(); for(unsigned int j = v.nof_edges_out(); j > 0; j--) { Partition::Cell * const neighbour_cell = p.get_cell(*ei++); if(neighbour_cell->is_unit()) continue; neighbour_cell->max_ival++; if(neighbour_cell->max_ival == 1) neighbour_cells_visited.push(neighbour_cell); } while(!neighbour_cells_visited.is_empty()) { Partition::Cell * const neighbour_cell = neighbour_cells_visited.pop(); if(neighbour_cell->max_ival != neighbour_cell->length) value++; neighbour_cell->max_ival = 0; } if((value > best_value) or (value == best_value and cell->length < best_size)) { best_value = value; best_size = cell->length; best_cell = cell; } } return best_cell; } /** \internal * A splitting heuristic. * Returns the first largest nonsingleton cell with max number of neighbouring * nonsingleton cells. * Assumes that the partition p is equitable. * Assumes that the max_ival fields of the cells are all 0. */ template Partition::Cell* Digraph::sh_first_largest_max_neighbours() { Partition::Cell* best_cell = 0; int best_value = -1; unsigned int best_size = 0; KStack neighbour_cells_visited; neighbour_cells_visited.init(get_nof_vertices()); for(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) { if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level) continue; int value = 0; const Vertex &v = vertices[p.elements[cell->first]]; std::vector::const_iterator ei; ei = v.edges_in.begin(); for(unsigned int j = v.nof_edges_in(); j > 0; j--) { Partition::Cell* const neighbour_cell = p.get_cell(*ei++); if(neighbour_cell->is_unit()) continue; neighbour_cell->max_ival++; if(neighbour_cell->max_ival == 1) neighbour_cells_visited.push(neighbour_cell); } while(!neighbour_cells_visited.is_empty()) { Partition::Cell* const neighbour_cell = neighbour_cells_visited.pop(); if(neighbour_cell->max_ival != neighbour_cell->length) value++; neighbour_cell->max_ival = 0; } ei = v.edges_out.begin(); for(unsigned int j = v.nof_edges_out(); j > 0; j--) { Partition::Cell* const neighbour_cell = p.get_cell(*ei++); if(neighbour_cell->is_unit()) continue; neighbour_cell->max_ival++; if(neighbour_cell->max_ival == 1) neighbour_cells_visited.push(neighbour_cell); } while(!neighbour_cells_visited.is_empty()) { Partition::Cell* const neighbour_cell = neighbour_cells_visited.pop(); if(neighbour_cell->max_ival != neighbour_cell->length) value++; neighbour_cell->max_ival = 0; } if((value > best_value) || (value == best_value && cell->length > best_size)) { best_value = value; best_size = cell->length; best_cell = cell; } } return best_cell; } /*------------------------------------------------------------------------ * * Initialize the certificate size and memory * *-------------------------------------------------------------------------*/ template void Digraph::initialize_certificate() { certificate_index = 0; certificate_current_path.clear(); certificate_first_path.clear(); certificate_best_path.clear(); } /* * Check whether perm is an automorphism. * Slow, mainly for debugging and validation purposes. */ template bool Digraph::is_automorphism(unsigned int* const perm) { std::set > edges1; std::set > edges2; #if defined(BLISS_CONSISTENCY_CHECKS) if(!is_permutation(get_nof_vertices(), perm)) _INTERNAL_ERROR(); #endif for(unsigned int i = 0; i < get_nof_vertices(); i++) { Vertex& v1 = vertices[i]; Vertex& v2 = vertices[perm[i]]; edges1.clear(); for(std::vector::iterator ei = v1.edges_in.begin(); ei != v1.edges_in.end(); ei++) edges1.insert(perm[*ei]); edges2.clear(); for(std::vector::iterator ei = v2.edges_in.begin(); ei != v2.edges_in.end(); ei++) edges2.insert(*ei); if(!(edges1 == edges2)) return false; edges1.clear(); for(std::vector::iterator ei = v1.edges_out.begin(); ei != v1.edges_out.end(); ei++) edges1.insert(perm[*ei]); edges2.clear(); for(std::vector::iterator ei = v2.edges_out.begin(); ei != v2.edges_out.end(); ei++) edges2.insert(*ei); if(!(edges1 == edges2)) return false; } return true; } template bool Digraph::is_automorphism(const std::vector& perm) const { if(!(perm.size() == get_nof_vertices() and is_permutation(perm))) return false; std::set > edges1; std::set > edges2; for(unsigned int i = 0; i < get_nof_vertices(); i++) { const Vertex& v1 = vertices[i]; const Vertex& v2 = vertices[perm[i]]; edges1.clear(); for(std::vector::const_iterator ei = v1.edges_in.begin(); ei != v1.edges_in.end(); ei++) edges1.insert(perm[*ei]); edges2.clear(); for(std::vector::const_iterator ei = v2.edges_in.begin(); ei != v2.edges_in.end(); ei++) edges2.insert(*ei); if(!(edges1 == edges2)) return false; edges1.clear(); for(std::vector::const_iterator ei = v1.edges_out.begin(); ei != v1.edges_out.end(); ei++) edges1.insert(perm[*ei]); edges2.clear(); for(std::vector::const_iterator ei = v2.edges_out.begin(); ei != v2.edges_out.end(); ei++) edges2.insert(*ei); if(!(edges1 == edges2)) return false; } return true; } template bool Digraph::nucr_find_first_component(const unsigned int level) { cr_component.clear(); cr_component_elements = 0; /* Find first non-discrete cell in the component level */ Partition::Cell* first_cell = p.first_nonsingleton_cell; while(first_cell) { if(p.cr_get_level(first_cell->first) == level) break; first_cell = first_cell->next_nonsingleton; } /* The component is discrete, return false */ if(!first_cell) return false; std::vector component; first_cell->max_ival = 1; component.push_back(first_cell); for(unsigned int i = 0; i < component.size(); i++) { Partition::Cell* const cell = component[i]; const Vertex& v = vertices[p.elements[cell->first]]; std::vector::const_iterator ei; ei = v.edges_out.begin(); for(unsigned int j = v.nof_edges_out(); j > 0; j--) { const unsigned int neighbour = *ei++; Partition::Cell* const neighbour_cell = p.get_cell(neighbour); /* Skip unit neighbours */ if(neighbour_cell->is_unit()) continue; /* Already marked to be in the same component? */ if(neighbour_cell->max_ival == 1) continue; /* Is the neighbour at the same component recursion level? */ if(p.cr_get_level(neighbour_cell->first) != level) continue; if(neighbour_cell->max_ival_count == 0) neighbour_heap.insert(neighbour_cell->first); neighbour_cell->max_ival_count++; } while(!neighbour_heap.is_empty()) { const unsigned int start = neighbour_heap.remove(); Partition::Cell* const neighbour_cell = p.get_cell(p.elements[start]); /* Skip saturated neighbour cells */ if(neighbour_cell->max_ival_count == neighbour_cell->length) { neighbour_cell->max_ival_count = 0; continue; } neighbour_cell->max_ival_count = 0; neighbour_cell->max_ival = 1; component.push_back(neighbour_cell); } ei = v.edges_in.begin(); for(unsigned int j = v.nof_edges_in(); j > 0; j--) { const unsigned int neighbour = *ei++; Partition::Cell* const neighbour_cell = p.get_cell(neighbour); /* Skip unit neighbours */ if(neighbour_cell->is_unit()) continue; /* Already marked to be in the same component? */ if(neighbour_cell->max_ival == 1) continue; /* Is the neighbour at the same component recursion level? */ if(p.cr_get_level(neighbour_cell->first) != level) continue; if(neighbour_cell->max_ival_count == 0) neighbour_heap.insert(neighbour_cell->first); neighbour_cell->max_ival_count++; } while(!neighbour_heap.is_empty()) { const unsigned int start = neighbour_heap.remove(); Partition::Cell* const neighbour_cell = p.get_cell(p.elements[start]); /* Skip saturated neighbour cells */ if(neighbour_cell->max_ival_count == neighbour_cell->length) { neighbour_cell->max_ival_count = 0; continue; } neighbour_cell->max_ival_count = 0; neighbour_cell->max_ival = 1; component.push_back(neighbour_cell); } } for(unsigned int i = 0; i < component.size(); i++) { Partition::Cell* const cell = component[i]; cell->max_ival = 0; cr_component.push_back(cell->first); cr_component_elements += cell->length; } if(verbstr and verbose_level > 2) { fprintf(verbstr, "NU-component with %lu cells and %u vertices\n", (long unsigned)cr_component.size(), cr_component_elements); fflush(verbstr); } return true; } template bool Digraph::nucr_find_first_component(const unsigned int level, std::vector& component, unsigned int& component_elements, Partition::Cell*& sh_return) { component.clear(); component_elements = 0; sh_return = 0; unsigned int sh_first = 0; unsigned int sh_size = 0; unsigned int sh_nuconn = 0; /* Find first non-discrete cell in the component level */ Partition::Cell* first_cell = p.first_nonsingleton_cell; while(first_cell) { if(p.cr_get_level(first_cell->first) == level) break; first_cell = first_cell->next_nonsingleton; } /* The component is discrete, return false */ if(!first_cell) return false; std::vector comp; KStack neighbours; neighbours.init(get_nof_vertices()); first_cell->max_ival = 1; comp.push_back(first_cell); for(unsigned int i = 0; i < comp.size(); i++) { Partition::Cell* const cell = comp[i]; unsigned int nuconn = 1; const Vertex& v = vertices[p.elements[cell->first]]; std::vector::const_iterator ei; /*| Phase 1: outgoing edges */ ei = v.edges_out.begin(); for(unsigned int j = v.nof_edges_out(); j > 0; j--) { const unsigned int neighbour = *ei++; Partition::Cell* const neighbour_cell = p.get_cell(neighbour); /* Skip unit neighbours */ if(neighbour_cell->is_unit()) continue; /* Is the neighbour at the same component recursion level? */ //if(p.cr_get_level(neighbour_cell->first) != level) // continue; if(neighbour_cell->max_ival_count == 0) neighbours.push(neighbour_cell); neighbour_cell->max_ival_count++; } while(!neighbours.is_empty()) { Partition::Cell* const neighbour_cell = neighbours.pop(); /* Skip saturated neighbour cells */ if(neighbour_cell->max_ival_count == neighbour_cell->length) { neighbour_cell->max_ival_count = 0; continue; } nuconn++; neighbour_cell->max_ival_count = 0; if(neighbour_cell->max_ival == 0) { comp.push_back(neighbour_cell); neighbour_cell->max_ival = 1; } } /*| Phase 2: incoming edges */ ei = v.edges_in.begin(); for(unsigned int j = v.nof_edges_in(); j > 0; j--) { const unsigned int neighbour = *ei++; Partition::Cell* const neighbour_cell = p.get_cell(neighbour); /*| Skip unit neighbours */ if(neighbour_cell->is_unit()) continue; /* Is the neighbour at the same component recursion level? */ //if(p.cr_get_level(neighbour_cell->first) != level) // continue; if(neighbour_cell->max_ival_count == 0) neighbours.push(neighbour_cell); neighbour_cell->max_ival_count++; } while(!neighbours.is_empty()) { Partition::Cell* const neighbour_cell = neighbours.pop(); /* Skip saturated neighbour cells */ if(neighbour_cell->max_ival_count == neighbour_cell->length) { neighbour_cell->max_ival_count = 0; continue; } nuconn++; neighbour_cell->max_ival_count = 0; if(neighbour_cell->max_ival == 0) { comp.push_back(neighbour_cell); neighbour_cell->max_ival = 1; } } /*| Phase 3: splitting heuristics */ switch(sh) { case shs_f: if(cell->first <= sh_first) { sh_return = cell; sh_first = cell->first; } break; case shs_fs: if(cell->length < sh_size or (cell->length == sh_size and cell->first <= sh_first)) { sh_return = cell; sh_first = cell->first; sh_size = cell->length; } break; case shs_fl: if(cell->length > sh_size or (cell->length == sh_size and cell->first <= sh_first)) { sh_return = cell; sh_first = cell->first; sh_size = cell->length; } break; case shs_fm: if(nuconn > sh_nuconn or (nuconn == sh_nuconn and cell->first <= sh_first)) { sh_return = cell; sh_first = cell->first; sh_nuconn = nuconn; } break; case shs_fsm: if(nuconn > sh_nuconn or (nuconn == sh_nuconn and (cell->length < sh_size or (cell->length == sh_size and cell->first <= sh_first)))) { sh_return = cell; sh_first = cell->first; sh_size = cell->length; sh_nuconn = nuconn; } break; case shs_flm: if(nuconn > sh_nuconn or (nuconn == sh_nuconn and (cell->length > sh_size or (cell->length == sh_size and cell->first <= sh_first)))) { sh_return = cell; sh_first = cell->first; sh_size = cell->length; sh_nuconn = nuconn; } break; default: fatal_error("Internal error - unknown splitting heuristics"); return 0; } } assert(sh_return); for(unsigned int i = 0; i < comp.size(); i++) { Partition::Cell* const cell = comp[i]; cell->max_ival = 0; component.push_back(cell->first); component_elements += cell->length; } if(verbstr and verbose_level > 2) { fprintf(verbstr, "NU-component with %lu cells and %u vertices\n", (long unsigned)component.size(), component_elements); fflush(verbstr); } return true; } /*------------------------------------------------------------------------- * * Routines for undirected graphs * *-------------------------------------------------------------------------*/ Graph::Vertex::Vertex() { color = 0; label = std::string{""}; } Graph::Vertex::~Vertex() { ; } void Graph::Vertex::add_edge(const unsigned int other_vertex) { edges.push_back(other_vertex); } void Graph::Vertex::remove_duplicate_edges(std::vector& tmp) { #if defined(BLISS_CONSISTENCY_CHECKS) /* Pre-conditions */ for(unsigned int i = 0; i < tmp.size(); i++) assert(tmp[i] == false); #endif for(std::vector::iterator iter = edges.begin(); iter != edges.end(); ) { const unsigned int dest_vertex = *iter; if(tmp[dest_vertex] == true) { /* A duplicate edge found! */ iter = edges.erase(iter); } else { /* Not seen earlier, mark as seen */ tmp[dest_vertex] = true; iter++; } } /* Clear tmp */ for(std::vector::iterator iter = edges.begin(); iter != edges.end(); iter++) { tmp[*iter] = false; } #if defined(BLISS_CONSISTENCY_CHECKS) /* Post-conditions */ for(unsigned int i = 0; i < tmp.size(); i++) assert(tmp[i] == false); #endif } /** * Sort the edges leaving the vertex according to * the vertex number of the other edge end. * Time complexity: O(e log(e)), where e is the number of edges * leaving the vertex. */ void Graph::Vertex::sort_edges() { std::sort(edges.begin(), edges.end()); } /*------------------------------------------------------------------------- * * Constructor and destructor for undirected graphs * *-------------------------------------------------------------------------*/ Graph::Graph(const unsigned int nof_vertices) { vertices.resize(nof_vertices); sh = shs_flm; } Graph::~Graph() { ; } unsigned int Graph::add_vertex(const unsigned int color, const std::string label) { const unsigned int vertex_num = vertices.size(); vertices.resize(vertex_num + 1); vertices.back().color = color; vertices.back().label = label; return vertex_num; } std::string Graph::get_vertex_label(const unsigned int vertex) const { return vertices[vertex].label; } void Graph::add_edge(const unsigned int vertex1, const unsigned int vertex2) { //fprintf(stderr, "(%u,%u) ", vertex1, vertex2); vertices[vertex1].add_edge(vertex2); vertices[vertex2].add_edge(vertex1); } void Graph::change_color(const unsigned int vertex, const unsigned int color) { vertices[vertex].color = color; } /*------------------------------------------------------------------------- * * Read graph in the DIMACS format. * Returns 0 if an error occurred. * *-------------------------------------------------------------------------*/ Graph* Graph::read_dimacs(FILE* const fp, FILE* const errstr) { Graph *g = 0; unsigned int nof_vertices; unsigned int nof_edges; unsigned int line_num = 1; int c; const bool verbose = false; FILE* const verbstr = stdout; /* Read comments and the problem definition line */ while(1) { c = getc(fp); if(c == 'c') { /* A comment, ignore the rest of the line */ while((c = getc(fp)) != '\n') { if(c == EOF) { if(errstr) fprintf(errstr, "error in line %u: not in DIMACS format\n", line_num); goto error_exit; } } line_num++; continue; } if(c == 'p') { /* The problem definition line */ if(fscanf(fp, " edge %u %u\n", &nof_vertices, &nof_edges) != 2) { if(errstr) fprintf(errstr, "error in line %u: not in DIMACS format\n", line_num); goto error_exit; } line_num++; break; } if(errstr) fprintf(errstr, "error in line %u: not in DIMACS format\n", line_num); goto error_exit; } if(nof_vertices <= 0) { if(errstr) fprintf(errstr, "error: no vertices\n"); goto error_exit; } if(verbose) { fprintf(verbstr, "Instance has %d vertices and %d edges\n", nof_vertices, nof_edges); fflush(verbstr); } g = new Graph(nof_vertices); // // Read vertex colors // if(verbose) { fprintf(verbstr, "Reading vertex colors...\n"); fflush(verbstr); } while(1) { c = getc(fp); if(c != 'n') { ungetc(c, fp); break; } ungetc(c, fp); unsigned int vertex; unsigned int color; if(fscanf(fp, "n %u %u\n", &vertex, &color) != 2) { if(errstr) fprintf(errstr, "error in line %u: not in DIMACS format\n", line_num); goto error_exit; } if(!((vertex >= 1) && (vertex <= nof_vertices))) { if(errstr) fprintf(errstr, "error in line %u: vertex %u not in range [1,...,%u]\n", line_num, vertex, nof_vertices); goto error_exit; } line_num++; g->change_color(vertex - 1, color); } if(verbose) { fprintf(verbstr, "Done\n"); fflush(verbstr); } // // Read edges // if(verbose) { fprintf(verbstr, "Reading edges...\n"); fflush(verbstr); } for(unsigned i = 0; i < nof_edges; i++) { unsigned int from, to; if(fscanf(fp, "e %u %u\n", &from, &to) != 2) { if(errstr) fprintf(errstr, "error in line %u: not in DIMACS format\n", line_num); goto error_exit; } if(!((from >= 1) && (from <= nof_vertices))) { if(errstr) fprintf(errstr, "error in line %u: vertex %u not in range [1,...,%u]\n", line_num, from, nof_vertices); goto error_exit; } if(!((to >= 1) && (to <= nof_vertices))) { if(errstr) fprintf(errstr, "error in line %u: vertex %u not in range [1,...,%u]\n", line_num, to, nof_vertices); goto error_exit; } line_num++; g->add_edge(from-1, to-1); } if(verbose) { fprintf(verbstr, "Done\n"); fflush(verbstr); } return g; error_exit: if(g) delete g; return 0; } void Graph::write_dimacs(FILE* const fp) { remove_duplicate_edges(); sort_edges(); /* First count the total number of edges */ unsigned int nof_edges = 0; for(unsigned int i = 0; i < get_nof_vertices(); i++) { Vertex &v = vertices[i]; for(std::vector::const_iterator ei = v.edges.begin(); ei != v.edges.end(); ei++) { const unsigned int dest_i = *ei; if(dest_i < i) continue; nof_edges++; } } /* Output the "header" line */ fprintf(fp, "p edge %u %u\n", get_nof_vertices(), nof_edges); /* Print the color of each vertex */ for(unsigned int i = 0; i < get_nof_vertices(); i++) { Vertex &v = vertices[i]; fprintf(fp, "n %u %u\n", i+1, v.color); /* if(v.color != 0) { fprintf(fp, "n %u %u\n", i+1, v.color); } */ } /* Print the edges */ for(unsigned int i = 0; i < get_nof_vertices(); i++) { Vertex &v = vertices[i]; for(std::vector::const_iterator ei = v.edges.begin(); ei != v.edges.end(); ei++) { const unsigned int dest_i = *ei; if(dest_i < i) continue; fprintf(fp, "e %u %u\n", i+1, dest_i+1); } } } void Graph::sort_edges() { for(unsigned int i = 0; i < get_nof_vertices(); i++) vertices[i].sort_edges(); } int Graph::cmp(Graph& other) { /* Compare the numbers of vertices */ if(get_nof_vertices() < other.get_nof_vertices()) return -1; if(get_nof_vertices() > other.get_nof_vertices()) return 1; /* Compare vertex colors */ for(unsigned int i = 0; i < get_nof_vertices(); i++) { if(vertices[i].color < other.vertices[i].color) return -1; if(vertices[i].color > other.vertices[i].color) return 1; } /* Compare vertex degrees */ remove_duplicate_edges(); other.remove_duplicate_edges(); for(unsigned int i = 0; i < get_nof_vertices(); i++) { if(vertices[i].nof_edges() < other.vertices[i].nof_edges()) return -1; if(vertices[i].nof_edges() > other.vertices[i].nof_edges()) return 1; } /* Compare edges */ for(unsigned int i = 0; i < get_nof_vertices(); i++) { Vertex &v1 = vertices[i]; Vertex &v2 = other.vertices[i]; v1.sort_edges(); v2.sort_edges(); std::vector::const_iterator ei1 = v1.edges.begin(); std::vector::const_iterator ei2 = v2.edges.begin(); while(ei1 != v1.edges.end()) { if(*ei1 < *ei2) return -1; if(*ei1 > *ei2) return 1; ei1++; ei2++; } } return 0; } Graph* Graph::permute(const std::vector& perm) const { #if defined(BLISS_CONSISTENCY_CHECKS) #endif Graph* const g = new Graph(get_nof_vertices()); for(unsigned int i = 0; i < get_nof_vertices(); i++) { const Vertex& v = vertices[i]; Vertex& permuted_v = g->vertices[perm[i]]; permuted_v.color = v.color; for(std::vector::const_iterator ei = v.edges.begin(); ei != v.edges.end(); ei++) { const unsigned int dest_v = *ei; permuted_v.add_edge(perm[dest_v]); } permuted_v.sort_edges(); } return g; } Graph* Graph::permute(const unsigned int* perm) const { #if defined(BLISS_CONSISTENCY_CHECKS) if(!is_permutation(get_nof_vertices(), perm)) _INTERNAL_ERROR(); #endif Graph* const g = new Graph(get_nof_vertices()); for(unsigned int i = 0; i < get_nof_vertices(); i++) { const Vertex& v = vertices[i]; Vertex& permuted_v = g->vertices[perm[i]]; permuted_v.color = v.color; for(std::vector::const_iterator ei = v.edges.begin(); ei != v.edges.end(); ei++) { const unsigned int dest_v = *ei; permuted_v.add_edge(perm[dest_v]); } permuted_v.sort_edges(); } return g; } /*------------------------------------------------------------------------- * * Print graph in graphviz format * *-------------------------------------------------------------------------*/ void Graph::write_dot(const char* const filename) { FILE *fp = fopen(filename, "w"); if(fp) { write_dot(fp); fclose(fp); } } void Graph::write_dot(FILE* const fp) { remove_duplicate_edges(); fprintf(fp, "graph g {\n"); unsigned int vnum = 0; for(std::vector::iterator vi = vertices.begin(); vi != vertices.end(); vi++, vnum++) { Vertex& v = *vi; //fprintf(fp, "v%u [label=\"%u:%u (%s)\"];\n", vnum, vnum, v.color, v.label.c_str()); fprintf(fp, "v%u [label=\"(%u) %u, %s\"];\n", vnum, vnum, v.color, v.label.c_str()); for(std::vector::const_iterator ei = v.edges.begin(); ei != v.edges.end(); ei++) { const unsigned int vnum2 = *ei; if(vnum2 > vnum) fprintf(fp, "v%u -- v%u\n", vnum, vnum2); } } fprintf(fp, "}\n"); } /*------------------------------------------------------------------------- * * Get a hash value for the graph. * *-------------------------------------------------------------------------*/ unsigned int Graph::get_hash() { remove_duplicate_edges(); sort_edges(); UintSeqHash h; h.update(get_nof_vertices()); /* Hash the color of each vertex */ for(unsigned int i = 0; i < get_nof_vertices(); i++) { h.update(vertices[i].color); } /* Hash the edges */ for(unsigned int i = 0; i < get_nof_vertices(); i++) { Vertex &v = vertices[i]; for(std::vector::const_iterator ei = v.edges.begin(); ei != v.edges.end(); ei++) { const unsigned int dest_i = *ei; if(dest_i < i) continue; h.update(i); h.update(dest_i); } } return h.get_value(); } void Graph::remove_duplicate_edges() { std::vector tmp(vertices.size(), false); for(std::vector::iterator vi = vertices.begin(); vi != vertices.end(); vi++) { #if defined(BLISS_EXPENSIVE_CONSISTENCY_CHECKS) for(unsigned int i = 0; i < tmp.size(); i++) assert(tmp[i] == false); #endif (*vi).remove_duplicate_edges(tmp); } } /*------------------------------------------------------------------------- * * Partition independent invariants * *-------------------------------------------------------------------------*/ /* * Return the color of the vertex. * Time complexity: O(1) */ unsigned int Graph::vertex_color_invariant(const Graph* const g, const unsigned int v) { return g->vertices[v].color; } /* * Return the degree of the vertex. * Time complexity: O(1) */ unsigned int Graph::degree_invariant(const Graph* const g, const unsigned int v) { return g->vertices[v].nof_edges(); } /* * Return 1 if the vertex v has a self-loop, 0 otherwise * Time complexity: O(E_v), where E_v is the number of edges leaving v */ unsigned int Graph::selfloop_invariant(const Graph* const g, const unsigned int v) { const Vertex& vertex = g->vertices[v]; for(std::vector::const_iterator ei = vertex.edges.begin(); ei != vertex.edges.end(); ei++) { if(*ei == v) return 1; } return 0; } /*------------------------------------------------------------------------- * * Refine the partition p according to a partition independent invariant * *-------------------------------------------------------------------------*/ bool Graph::refine_according_to_invariant(unsigned int (*inv)(const Graph* const g, const unsigned int v)) { bool refined = false; for(Partition::Cell* cell = p.first_nonsingleton_cell; cell; ) { Partition::Cell* const next_cell = cell->next_nonsingleton; const unsigned int* ep = p.elements + cell->first; for(unsigned int i = cell->length; i > 0; i--, ep++) { const unsigned int ival = inv(this, *ep); p.invariant_values[*ep] = ival; if(ival > cell->max_ival) { cell->max_ival = ival; cell->max_ival_count = 1; } else if(ival == cell->max_ival) { cell->max_ival_count++; } } Partition::Cell* const last_new_cell = p.zplit_cell(cell, true); refined |= (last_new_cell != cell); cell = next_cell; } return refined; } /*------------------------------------------------------------------------- * * Split the neighbourhood of a cell according to the equitable invariant * *-------------------------------------------------------------------------*/ bool Graph::split_neighbourhood_of_cell(Partition::Cell* const cell) { const bool was_equal_to_first = refine_equal_to_first; if(compute_eqref_hash) { eqref_hash.update(cell->first); eqref_hash.update(cell->length); } const unsigned int* ep = p.elements + cell->first; for(unsigned int i = cell->length; i > 0; i--) { const Vertex& v = vertices[*ep++]; std::vector::const_iterator ei = v.edges.begin(); for(unsigned int j = v.nof_edges(); j != 0; j--) { const unsigned int dest_vertex = *ei++; Partition::Cell * const neighbour_cell = p.get_cell(dest_vertex); if(neighbour_cell->is_unit()) continue; const unsigned int ival = ++p.invariant_values[dest_vertex]; if(ival > neighbour_cell->max_ival) { neighbour_cell->max_ival = ival; neighbour_cell->max_ival_count = 1; if(ival == 1) neighbour_heap.insert(neighbour_cell->first); } else if(ival == neighbour_cell->max_ival) { neighbour_cell->max_ival_count++; } } } while(!neighbour_heap.is_empty()) { const unsigned int start = neighbour_heap.remove(); Partition::Cell * const neighbour_cell = p.get_cell(p.elements[start]); if(compute_eqref_hash) { eqref_hash.update(neighbour_cell->first); eqref_hash.update(neighbour_cell->length); eqref_hash.update(neighbour_cell->max_ival); eqref_hash.update(neighbour_cell->max_ival_count); } Partition::Cell* const last_new_cell = p.zplit_cell(neighbour_cell, true); /* Update certificate and hash if needed */ const Partition::Cell* c = neighbour_cell; while(1) { if(in_search) { /* Build certificate */ cert_add_redundant(CERT_SPLIT, c->first, c->length); /* No need to continue? */ if(refine_compare_certificate and (refine_equal_to_first == false) and (refine_cmp_to_best < 0)) goto worse_exit; } if(compute_eqref_hash) { eqref_hash.update(c->first); eqref_hash.update(c->length); } if(c == last_new_cell) break; c = c->next; } } if(refine_compare_certificate and (refine_equal_to_first == false) and (refine_cmp_to_best < 0)) return true; return false; worse_exit: /* Clear neighbour heap */ UintSeqHash rest; while(!neighbour_heap.is_empty()) { const unsigned int start = neighbour_heap.remove(); Partition::Cell * const neighbour_cell = p.get_cell(p.elements[start]); if(opt_use_failure_recording and was_equal_to_first) { rest.update(neighbour_cell->first); rest.update(neighbour_cell->length); rest.update(neighbour_cell->max_ival); rest.update(neighbour_cell->max_ival_count); } neighbour_cell->max_ival = 0; neighbour_cell->max_ival_count = 0; p.clear_ivs(neighbour_cell); } if(opt_use_failure_recording and was_equal_to_first) { for(unsigned int i = p.splitting_queue.size(); i > 0; i--) { Partition::Cell* const cell = p.splitting_queue.pop_front(); rest.update(cell->first); rest.update(cell->length); p.splitting_queue.push_back(cell); } rest.update(failure_recording_fp_deviation); failure_recording_fp_deviation = rest.get_value(); } return true; } bool Graph::split_neighbourhood_of_unit_cell(Partition::Cell* const unit_cell) { const bool was_equal_to_first = refine_equal_to_first; if(compute_eqref_hash) { eqref_hash.update(0x87654321); eqref_hash.update(unit_cell->first); eqref_hash.update(1); } const Vertex& v = vertices[p.elements[unit_cell->first]]; std::vector::const_iterator ei = v.edges.begin(); for(unsigned int j = v.nof_edges(); j > 0; j--) { const unsigned int dest_vertex = *ei++; Partition::Cell * const neighbour_cell = p.get_cell(dest_vertex); if(neighbour_cell->is_unit()) { if(in_search) { /* Remember neighbour in order to generate certificate */ neighbour_heap.insert(neighbour_cell->first); } continue; } if(neighbour_cell->max_ival_count == 0) { neighbour_heap.insert(neighbour_cell->first); } neighbour_cell->max_ival_count++; unsigned int * const swap_position = p.elements + neighbour_cell->first + neighbour_cell->length - neighbour_cell->max_ival_count; *p.in_pos[dest_vertex] = *swap_position; p.in_pos[*swap_position] = p.in_pos[dest_vertex]; *swap_position = dest_vertex; p.in_pos[dest_vertex] = swap_position; } while(!neighbour_heap.is_empty()) { const unsigned int start = neighbour_heap.remove(); Partition::Cell* neighbour_cell = p.get_cell(p.elements[start]); #if defined(BLISS_CONSISTENCY_CHECKS) if(neighbour_cell->is_unit()) { } else { } #endif if(compute_eqref_hash) { eqref_hash.update(neighbour_cell->first); eqref_hash.update(neighbour_cell->length); eqref_hash.update(neighbour_cell->max_ival_count); } if(neighbour_cell->length > 1 and neighbour_cell->max_ival_count != neighbour_cell->length) { Partition::Cell * const new_cell = p.aux_split_in_two(neighbour_cell, neighbour_cell->length - neighbour_cell->max_ival_count); unsigned int *ep = p.elements + new_cell->first; unsigned int * const lp = p.elements+new_cell->first+new_cell->length; while(ep < lp) { p.element_to_cell_map[*ep] = new_cell; ep++; } neighbour_cell->max_ival_count = 0; if(compute_eqref_hash) { /* Update hash */ eqref_hash.update(neighbour_cell->first); eqref_hash.update(neighbour_cell->length); eqref_hash.update(0); eqref_hash.update(new_cell->first); eqref_hash.update(new_cell->length); eqref_hash.update(1); } /* Add cells in splitting_queue */ if(neighbour_cell->is_in_splitting_queue()) { /* Both cells must be included in splitting_queue in order to ensure refinement into equitable partition */ p.splitting_queue_add(new_cell); } else { Partition::Cell *min_cell, *max_cell; if(neighbour_cell->length <= new_cell->length) { min_cell = neighbour_cell; max_cell = new_cell; } else { min_cell = new_cell; max_cell = neighbour_cell; } /* Put the smaller cell in splitting_queue */ p.splitting_queue_add(min_cell); if(max_cell->is_unit()) { /* Put the "larger" cell also in splitting_queue */ p.splitting_queue_add(max_cell); } } /* Update pointer for certificate generation */ neighbour_cell = new_cell; } else { /* neighbour_cell->length == 1 || neighbour_cell->max_ival_count == neighbour_cell->length */ neighbour_cell->max_ival_count = 0; } /* * Build certificate if required */ if(in_search) { for(unsigned int i = neighbour_cell->first, j = neighbour_cell->length; j > 0; j--, i++) { /* Build certificate */ cert_add(CERT_EDGE, unit_cell->first, i); /* No need to continue? */ if(refine_compare_certificate and (refine_equal_to_first == false) and (refine_cmp_to_best < 0)) goto worse_exit; } } /* if(in_search) */ } /* while(!neighbour_heap.is_empty()) */ if(refine_compare_certificate and (refine_equal_to_first == false) and (refine_cmp_to_best < 0)) return true; return false; worse_exit: /* Clear neighbour heap */ UintSeqHash rest; while(!neighbour_heap.is_empty()) { const unsigned int start = neighbour_heap.remove(); Partition::Cell * const neighbour_cell = p.get_cell(p.elements[start]); if(opt_use_failure_recording and was_equal_to_first) { rest.update(neighbour_cell->first); rest.update(neighbour_cell->length); rest.update(neighbour_cell->max_ival_count); } neighbour_cell->max_ival_count = 0; } if(opt_use_failure_recording and was_equal_to_first) { rest.update(failure_recording_fp_deviation); failure_recording_fp_deviation = rest.get_value(); } return true; } /*------------------------------------------------------------------------- * * Check whether the current partition p is equitable. * Performance: very slow, use only for debugging purposes. * *-------------------------------------------------------------------------*/ bool Graph::is_equitable() const { const unsigned int N = get_nof_vertices(); if(N == 0) return true; std::vector first_count = std::vector(N, 0); std::vector other_count = std::vector(N, 0); for(Partition::Cell *cell = p.first_cell; cell; cell = cell->next) { if(cell->is_unit()) continue; unsigned int *ep = p.elements + cell->first; const Vertex &first_vertex = vertices[*ep++]; /* Count how many edges lead from the first vertex to * the neighbouring cells */ for(std::vector::const_iterator ei = first_vertex.edges.begin(); ei != first_vertex.edges.end(); ei++) { first_count[p.get_cell(*ei)->first]++; } /* Count and compare to the edges of the other vertices */ for(unsigned int i = cell->length; i > 1; i--) { const Vertex &vertex = vertices[*ep++]; for(std::vector::const_iterator ei = vertex.edges.begin(); ei != vertex.edges.end(); ei++) { other_count[p.get_cell(*ei)->first]++; } for(Partition::Cell *cell2 = p.first_cell; cell2; cell2 = cell2->next) { if(first_count[cell2->first] != other_count[cell2->first]) { /* Not equitable */ return false; } other_count[cell2->first] = 0; } } /* Reset first_count */ for(unsigned int i = 0; i < N; i++) first_count[i] = 0; } return true; } /*------------------------------------------------------------------------- * * Build the initial equitable partition * *-------------------------------------------------------------------------*/ void Graph::make_initial_equitable_partition() { refine_according_to_invariant(&vertex_color_invariant); p.splitting_queue_clear(); //p.print_signature(stderr); fprintf(stderr, "\n"); refine_according_to_invariant(&selfloop_invariant); p.splitting_queue_clear(); //p.print_signature(stderr); fprintf(stderr, "\n"); refine_according_to_invariant(°ree_invariant); p.splitting_queue_clear(); //p.print_signature(stderr); fprintf(stderr, "\n"); refine_to_equitable(); //p.print_signature(stderr); fprintf(stderr, "\n"); } /*------------------------------------------------------------------------- * * Find the next cell to be splitted * *-------------------------------------------------------------------------*/ Partition::Cell* Graph::find_next_cell_to_be_splitted(Partition::Cell* cell) { switch(sh) { case shs_f: return sh_first(); case shs_fs: return sh_first_smallest(); case shs_fl: return sh_first_largest(); case shs_fm: return sh_first_max_neighbours(); case shs_fsm: return sh_first_smallest_max_neighbours(); case shs_flm: return sh_first_largest_max_neighbours(); default: fatal_error("Internal error - unknown splitting heuristics"); return 0; } } /** \internal * A splitting heuristic. * Returns the first nonsingleton cell in the current partition. */ Partition::Cell* Graph::sh_first() { Partition::Cell* best_cell = 0; for(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) { if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level) continue; best_cell = cell; break; } return best_cell; } /** \internal * A splitting heuristic. * Returns the first smallest nonsingleton cell in the current partition. */ Partition::Cell* Graph::sh_first_smallest() { Partition::Cell* best_cell = 0; unsigned int best_size = UINT_MAX; for(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) { if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level) continue; if(cell->length < best_size) { best_size = cell->length; best_cell = cell; } } return best_cell; } /** \internal * A splitting heuristic. * Returns the first largest nonsingleton cell in the current partition. */ Partition::Cell* Graph::sh_first_largest() { Partition::Cell* best_cell = 0; unsigned int best_size = 0; for(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) { if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level) continue; if(cell->length > best_size) { best_size = cell->length; best_cell = cell; } } return best_cell; } /** \internal * A splitting heuristic. * Returns the first nonsingleton cell with max number of neighbouring * nonsingleton cells. * Assumes that the partition p is equitable. * Assumes that the max_ival fields of the cells are all 0. */ Partition::Cell* Graph::sh_first_max_neighbours() { Partition::Cell* best_cell = 0; int best_value = -1; KStack neighbour_cells_visited; neighbour_cells_visited.init(get_nof_vertices()); for(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) { if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level) continue; const Vertex& v = vertices[p.elements[cell->first]]; std::vector::const_iterator ei = v.edges.begin(); for(unsigned int j = v.nof_edges(); j > 0; j--) { Partition::Cell * const neighbour_cell = p.get_cell(*ei++); if(neighbour_cell->is_unit()) continue; neighbour_cell->max_ival++; if(neighbour_cell->max_ival == 1) neighbour_cells_visited.push(neighbour_cell); } int value = 0; while(!neighbour_cells_visited.is_empty()) { Partition::Cell* const neighbour_cell = neighbour_cells_visited.pop(); if(neighbour_cell->max_ival != neighbour_cell->length) value++; neighbour_cell->max_ival = 0; } if(value > best_value) { best_value = value; best_cell = cell; } } return best_cell; } /** \internal * A splitting heuristic. * Returns the first smallest nonsingleton cell with max number of neighbouring * nonsingleton cells. * Assumes that the partition p is equitable. * Assumes that the max_ival fields of the cells are all 0. */ Partition::Cell* Graph::sh_first_smallest_max_neighbours() { Partition::Cell* best_cell = 0; int best_value = -1; unsigned int best_size = UINT_MAX; KStack neighbour_cells_visited; neighbour_cells_visited.init(get_nof_vertices()); for(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) { if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level) continue; const Vertex& v = vertices[p.elements[cell->first]]; std::vector::const_iterator ei = v.edges.begin(); for(unsigned int j = v.nof_edges(); j > 0; j--) { Partition::Cell* const neighbour_cell = p.get_cell(*ei++); if(neighbour_cell->is_unit()) continue; neighbour_cell->max_ival++; if(neighbour_cell->max_ival == 1) neighbour_cells_visited.push(neighbour_cell); } int value = 0; while(!neighbour_cells_visited.is_empty()) { Partition::Cell* const neighbour_cell = neighbour_cells_visited.pop(); if(neighbour_cell->max_ival != neighbour_cell->length) value++; neighbour_cell->max_ival = 0; } if((value > best_value) or (value == best_value and cell->length < best_size)) { best_value = value; best_size = cell->length; best_cell = cell; } } return best_cell; } /** \internal * A splitting heuristic. * Returns the first largest nonsingleton cell with max number of neighbouring * nonsingleton cells. * Assumes that the partition p is equitable. * Assumes that the max_ival fields of the cells are all 0. */ Partition::Cell* Graph::sh_first_largest_max_neighbours() { Partition::Cell* best_cell = 0; int best_value = -1; unsigned int best_size = 0; KStack neighbour_cells_visited; neighbour_cells_visited.init(get_nof_vertices()); for(Partition::Cell* cell = p.first_nonsingleton_cell; cell; cell = cell->next_nonsingleton) { if(opt_use_comprec and p.cr_get_level(cell->first) != cr_level) continue; const Vertex& v = vertices[p.elements[cell->first]]; std::vector::const_iterator ei = v.edges.begin(); for(unsigned int j = v.nof_edges(); j > 0; j--) { Partition::Cell* const neighbour_cell = p.get_cell(*ei++); if(neighbour_cell->is_unit()) continue; neighbour_cell->max_ival++; if(neighbour_cell->max_ival == 1) neighbour_cells_visited.push(neighbour_cell); } int value = 0; while(!neighbour_cells_visited.is_empty()) { Partition::Cell* const neighbour_cell = neighbour_cells_visited.pop(); if(neighbour_cell->max_ival != neighbour_cell->length) value++; neighbour_cell->max_ival = 0; } if((value > best_value) or (value == best_value and cell->length > best_size)) { best_value = value; best_size = cell->length; best_cell = cell; } } return best_cell; } /*------------------------------------------------------------------------- * * Initialize the certificate size and memory * *-------------------------------------------------------------------------*/ void Graph::initialize_certificate() { certificate_index = 0; certificate_current_path.clear(); certificate_first_path.clear(); certificate_best_path.clear(); } /*------------------------------------------------------------------------- * * Check whether perm is an automorphism. * Slow, mainly for debugging and validation purposes. * *-------------------------------------------------------------------------*/ bool Graph::is_automorphism(unsigned int* const perm) { std::set > edges1; std::set > edges2; #if defined(BLISS_CONSISTENCY_CHECKS) if(!is_permutation(get_nof_vertices(), perm)) _INTERNAL_ERROR(); #endif for(unsigned int i = 0; i < get_nof_vertices(); i++) { Vertex& v1 = vertices[i]; edges1.clear(); for(std::vector::iterator ei = v1.edges.begin(); ei != v1.edges.end(); ei++) edges1.insert(perm[*ei]); Vertex& v2 = vertices[perm[i]]; edges2.clear(); for(std::vector::iterator ei = v2.edges.begin(); ei != v2.edges.end(); ei++) edges2.insert(*ei); if(!(edges1 == edges2)) return false; } return true; } bool Graph::is_automorphism(const std::vector& perm) const { if(!(perm.size() == get_nof_vertices() and is_permutation(perm))) return false; std::set > edges1; std::set > edges2; for(unsigned int i = 0; i < get_nof_vertices(); i++) { const Vertex& v1 = vertices[i]; edges1.clear(); for(std::vector::const_iterator ei = v1.edges.begin(); ei != v1.edges.end(); ei++) edges1.insert(perm[*ei]); const Vertex& v2 = vertices[perm[i]]; edges2.clear(); for(std::vector::const_iterator ei = v2.edges.begin(); ei != v2.edges.end(); ei++) edges2.insert(*ei); if(!(edges1 == edges2)) return false; } return true; } bool Graph::nucr_find_first_component(const unsigned int level) { cr_component.clear(); cr_component_elements = 0; /* Find first non-discrete cell in the component level */ Partition::Cell* first_cell = p.first_nonsingleton_cell; while(first_cell) { if(p.cr_get_level(first_cell->first) == level) break; first_cell = first_cell->next_nonsingleton; } /* The component is discrete, return false */ if(!first_cell) return false; std::vector component; first_cell->max_ival = 1; component.push_back(first_cell); for(unsigned int i = 0; i < component.size(); i++) { Partition::Cell* const cell = component[i]; const Vertex& v = vertices[p.elements[cell->first]]; std::vector::const_iterator ei = v.edges.begin(); for(unsigned int j = v.nof_edges(); j > 0; j--) { const unsigned int neighbour = *ei++; Partition::Cell* const neighbour_cell = p.get_cell(neighbour); /* Skip unit neighbours */ if(neighbour_cell->is_unit()) continue; /* Already marked to be in the same component? */ if(neighbour_cell->max_ival == 1) continue; /* Is the neighbour at the same component recursion level? */ if(p.cr_get_level(neighbour_cell->first) != level) continue; if(neighbour_cell->max_ival_count == 0) neighbour_heap.insert(neighbour_cell->first); neighbour_cell->max_ival_count++; } while(!neighbour_heap.is_empty()) { const unsigned int start = neighbour_heap.remove(); Partition::Cell* const neighbour_cell = p.get_cell(p.elements[start]); /* Skip saturated neighbour cells */ if(neighbour_cell->max_ival_count == neighbour_cell->length) { neighbour_cell->max_ival_count = 0; continue; } neighbour_cell->max_ival_count = 0; neighbour_cell->max_ival = 1; component.push_back(neighbour_cell); } } for(unsigned int i = 0; i < component.size(); i++) { Partition::Cell* const cell = component[i]; cell->max_ival = 0; cr_component.push_back(cell->first); cr_component_elements += cell->length; } if(verbstr and verbose_level > 2) { fprintf(verbstr, "NU-component with %lu cells and %u vertices\n", (long unsigned)cr_component.size(), cr_component_elements); fflush(verbstr); } return true; } bool Graph::nucr_find_first_component(const unsigned int level, std::vector& component, unsigned int& component_elements, Partition::Cell*& sh_return) { component.clear(); component_elements = 0; sh_return = 0; unsigned int sh_first = 0; unsigned int sh_size = 0; unsigned int sh_nuconn = 0; /* Find first non-discrete cell in the component level */ Partition::Cell* first_cell = p.first_nonsingleton_cell; while(first_cell) { if(p.cr_get_level(first_cell->first) == level) break; first_cell = first_cell->next_nonsingleton; } /* The component is discrete, return false */ if(!first_cell) return false; std::vector comp; KStack neighbours; neighbours.init(get_nof_vertices()); first_cell->max_ival = 1; comp.push_back(first_cell); for(unsigned int i = 0; i < comp.size(); i++) { Partition::Cell* const cell = comp[i]; const Vertex& v = vertices[p.elements[cell->first]]; std::vector::const_iterator ei = v.edges.begin(); for(unsigned int j = v.nof_edges(); j > 0; j--) { const unsigned int neighbour = *ei++; Partition::Cell* const neighbour_cell = p.get_cell(neighbour); /* Skip unit neighbours */ if(neighbour_cell->is_unit()) continue; /* Is the neighbour at the same component recursion level? */ //if(p.cr_get_level(neighbour_cell->first) != level) // continue; if(neighbour_cell->max_ival_count == 0) neighbours.push(neighbour_cell); neighbour_cell->max_ival_count++; } unsigned int nuconn = 1; while(!neighbours.is_empty()) { Partition::Cell* const neighbour_cell = neighbours.pop(); //neighbours.pop_back(); /* Skip saturated neighbour cells */ if(neighbour_cell->max_ival_count == neighbour_cell->length) { neighbour_cell->max_ival_count = 0; continue; } nuconn++; neighbour_cell->max_ival_count = 0; if(neighbour_cell->max_ival == 0) { comp.push_back(neighbour_cell); neighbour_cell->max_ival = 1; } } switch(sh) { case shs_f: if(cell->first <= sh_first) { sh_return = cell; sh_first = cell->first; } break; case shs_fs: if(cell->length < sh_size or (cell->length == sh_size and cell->first <= sh_first)) { sh_return = cell; sh_first = cell->first; sh_size = cell->length; } break; case shs_fl: if(cell->length > sh_size or (cell->length == sh_size and cell->first <= sh_first)) { sh_return = cell; sh_first = cell->first; sh_size = cell->length; } break; case shs_fm: if(nuconn > sh_nuconn or (nuconn == sh_nuconn and cell->first <= sh_first)) { sh_return = cell; sh_first = cell->first; sh_nuconn = nuconn; } break; case shs_fsm: if(nuconn > sh_nuconn or (nuconn == sh_nuconn and (cell->length < sh_size or (cell->length == sh_size and cell->first <= sh_first)))) { sh_return = cell; sh_first = cell->first; sh_size = cell->length; sh_nuconn = nuconn; } break; case shs_flm: if(nuconn > sh_nuconn or (nuconn == sh_nuconn and (cell->length > sh_size or (cell->length == sh_size and cell->first <= sh_first)))) { sh_return = cell; sh_first = cell->first; sh_size = cell->length; sh_nuconn = nuconn; } break; default: fatal_error("Internal error - unknown splitting heuristics"); return 0; } } assert(sh_return); for(unsigned int i = 0; i < comp.size(); i++) { Partition::Cell* const cell = comp[i]; cell->max_ival = 0; component.push_back(cell->first); component_elements += cell->length; } if(verbstr and verbose_level > 2) { fprintf(verbstr, "NU-component with %lu cells and %u vertices\n", (long unsigned)component.size(), component_elements); fflush(verbstr); } return true; } } opensmt-2.5.2/src/symmetry/bliss/graph.hh000066400000000000000000000777761445011647600204630ustar00rootroot00000000000000#ifndef BLISS_GRAPH_HH #define BLISS_GRAPH_HH /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ /** * \namespace bliss * The namespace bliss contains all the classes and functions of the bliss * tool except for the C programming language API. */ namespace bliss { class AbstractGraph; } #include #include #include #include "kstack.hh" #include "kqueue.hh" #include "heap.hh" #include "orbit.hh" #include "partition.hh" #include "bignum.hh" #include "uintseqhash.hh" namespace bliss { /** * \brief Statistics returned by the bliss search algorithm. */ class Stats { friend class AbstractGraph; /** \internal The size of the automorphism group. */ BigNum group_size; /** \internal An approximation (due to possible overflows) of * the size of the automorphism group. */ long double group_size_approx; /** \internal The number of nodes in the search tree. */ long unsigned int nof_nodes; /** \internal The number of leaf nodes in the search tree. */ long unsigned int nof_leaf_nodes; /** \internal The number of bad nodes in the search tree. */ long unsigned int nof_bad_nodes; /** \internal The number of canonical representative updates. */ long unsigned int nof_canupdates; /** \internal The number of generator permutations. */ long unsigned int nof_generators; /** \internal The maximal depth of the search tree. */ unsigned long int max_level; /** */ void reset() { group_size.assign(1); group_size_approx = 1.0; nof_nodes = 0; nof_leaf_nodes = 0; nof_bad_nodes = 0; nof_canupdates = 0; nof_generators = 0; max_level = 0; } public: Stats() { reset(); } /** Print the statistics. */ size_t print(FILE* const fp) const { size_t r = 0; r += fprintf(fp, "Nodes: %lu\n", nof_nodes); r += fprintf(fp, "Leaf nodes: %lu\n", nof_leaf_nodes); r += fprintf(fp, "Bad nodes: %lu\n", nof_bad_nodes); r += fprintf(fp, "Canrep updates: %lu\n", nof_canupdates); r += fprintf(fp, "Generators: %lu\n", nof_generators); r += fprintf(fp, "Max level: %lu\n", max_level); r += fprintf(fp, "|Aut|: ")+group_size.print(fp)+fprintf(fp, "\n"); fflush(fp); return r; } /** An approximation (due to possible overflows/rounding errors) of * the size of the automorphism group. */ long double get_group_size_approx() const {return group_size_approx;} /** The number of nodes in the search tree. */ long unsigned int get_nof_nodes() const {return nof_nodes;} /** The number of leaf nodes in the search tree. */ long unsigned int get_nof_leaf_nodes() const {return nof_leaf_nodes;} /** The number of bad nodes in the search tree. */ long unsigned int get_nof_bad_nodes() const {return nof_bad_nodes;} /** The number of canonical representative updates. */ long unsigned int get_nof_canupdates() const {return nof_canupdates;} /** The number of generator permutations. */ long unsigned int get_nof_generators() const {return nof_generators;} /** The maximal depth of the search tree. */ unsigned long int get_max_level() const {return max_level;} }; /** * \brief An abstract base class for different types of graphs. */ class AbstractGraph { friend class Partition; protected: /** \internal * How much verbose output is produced (0 means none) */ unsigned int verbose_level; /** \internal * The output stream for verbose output. */ FILE *verbstr; protected: /** \internal * The ordered partition used in the search algorithm. */ Partition p; /** \internal * Whether the search for automorphisms and a canonical labeling is * in progress. */ bool in_search; /** \internal * Is failure recording in use? */ bool opt_use_failure_recording; /* The "tree-specific" invariant value for the point when current path * got different from the first path */ unsigned int failure_recording_fp_deviation; /** \internal * Is component recursion in use? */ bool opt_use_comprec; unsigned int refine_current_path_certificate_index; bool refine_compare_certificate; bool refine_equal_to_first; unsigned int refine_first_path_subcertificate_end; int refine_cmp_to_best; unsigned int refine_best_path_subcertificate_end; static const unsigned int CERT_SPLIT = 0; //UINT_MAX; static const unsigned int CERT_EDGE = 1; //UINT_MAX-1; /** \internal * Add a triple (v1,v2,v3) in the certificate. * May modify refine_equal_to_first and refine_cmp_to_best. * May also update eqref_hash and failure_recording_fp_deviation. */ void cert_add(const unsigned int v1, const unsigned int v2, const unsigned int v3); /** \internal * Add a redundant triple (v1,v2,v3) in the certificate. * Can also just dicard the triple. * May modify refine_equal_to_first and refine_cmp_to_best. * May also update eqref_hash and failure_recording_fp_deviation. */ void cert_add_redundant(const unsigned int x, const unsigned int y, const unsigned int z); /**\internal * Is the long prune method in use? */ bool opt_use_long_prune; /**\internal * Maximum amount of memory (in megabytes) available for * the long prune method */ static const unsigned int long_prune_options_max_mem = 50; /**\internal * Maximum amount of automorphisms stored for the long prune method; * less than this is stored if the memory limit above is reached first */ static const unsigned int long_prune_options_max_stored_auts = 100; unsigned int long_prune_max_stored_autss; std::vector *> long_prune_fixed; std::vector *> long_prune_mcrs; std::vector long_prune_temp; unsigned int long_prune_begin; unsigned int long_prune_end; /** \internal * Initialize the "long prune" data structures. */ void long_prune_init(); /** \internal * Release the memory allocated for "long prune" data structures. */ void long_prune_deallocate(); void long_prune_add_automorphism(const unsigned int *aut); std::vector& long_prune_get_fixed(const unsigned int index); std::vector& long_prune_allocget_fixed(const unsigned int index); std::vector& long_prune_get_mcrs(const unsigned int index); std::vector& long_prune_allocget_mcrs(const unsigned int index); /** \internal * Swap the i:th and j:th stored automorphism information; * i and j must be "in window, i.e. in [long_prune_begin,long_prune_end[ */ void long_prune_swap(const unsigned int i, const unsigned int j); /* * Data structures and routines for refining the partition p into equitable */ Heap neighbour_heap; virtual bool split_neighbourhood_of_unit_cell(Partition::Cell *) = 0; virtual bool split_neighbourhood_of_cell(Partition::Cell * const) = 0; void refine_to_equitable(); void refine_to_equitable(Partition::Cell * const unit_cell); void refine_to_equitable(Partition::Cell * const unit_cell1, Partition::Cell * const unit_cell2); /** \internal * \return false if it was detected that the current certificate * is different from the first and/or best (whether this is checked * depends on in_search and refine_compare_certificate flags. */ bool do_refine_to_equitable(); unsigned int eqref_max_certificate_index; /** \internal * Whether eqref_hash is updated during equitable refinement process. */ bool compute_eqref_hash; UintSeqHash eqref_hash; /** \internal * Check whether the current partition p is equitable. * Performance: very slow, use only for debugging purposes. */ virtual bool is_equitable() const = 0; unsigned int *first_path_labeling; unsigned int *first_path_labeling_inv; Orbit first_path_orbits; unsigned int *first_path_automorphism; unsigned int *best_path_labeling; unsigned int *best_path_labeling_inv; Orbit best_path_orbits; unsigned int *best_path_automorphism; void update_labeling(unsigned int * const lab); void update_labeling_and_its_inverse(unsigned int * const lab, unsigned int * const lab_inv); void update_orbit_information(Orbit &o, const unsigned int *perm); void reset_permutation(unsigned int *perm); /* Mainly for debugging purposes */ virtual bool is_automorphism(unsigned int* const perm); std::vector certificate_current_path; std::vector certificate_first_path; std::vector certificate_best_path; unsigned int certificate_index; virtual void initialize_certificate() = 0; virtual void remove_duplicate_edges() = 0; virtual void make_initial_equitable_partition() = 0; virtual Partition::Cell* find_next_cell_to_be_splitted(Partition::Cell *cell) = 0; void search(const bool canonical, Stats &stats); void (*report_hook)(void *user_param, unsigned int n, const unsigned int *aut); void *report_user_param; /* * * Nonuniform component recursion (NUCR) * */ /** The currently traversed component */ unsigned int cr_level; /** \internal * The "Component End Point" data structure */ class CR_CEP { public: /** At which level in the search was this CEP created */ unsigned int creation_level; /** The current component has been fully traversed when the partition has * this many discrete cells left */ unsigned int discrete_cell_limit; /** The component to be traversed after the current one */ unsigned int next_cr_level; /** The next component end point */ unsigned int next_cep_index; bool first_checked; bool best_checked; }; /** \internal * A stack for storing Component End Points */ std::vector cr_cep_stack; /** \internal * Find the first non-uniformity component at the component recursion * level \a level. * The component is stored in \a cr_component. * If no component is found, \a cr_component is empty. * Returns false if all the cells in the component recursion level \a level * were discrete. * Modifies the max_ival and max_ival_count fields of Partition:Cell * (assumes that they are 0 when called and * quarantees that they are 0 when returned). */ virtual bool nucr_find_first_component(const unsigned int level) {assert(false); } virtual bool nucr_find_first_component(const unsigned int level, std::vector& component, unsigned int& component_elements, Partition::Cell*& sh_return) {assert(false); } /** \internal * The non-uniformity component found by nucr_find_first_component() * is stored here. */ std::vector cr_component; /** \internal * The number of vertices in the component \a cr_component */ unsigned int cr_component_elements; public: AbstractGraph(); virtual ~AbstractGraph(); /** * Check whether \a perm is an automorphism of this graph. * Unoptimized, mainly for debugging purposes. */ virtual bool is_automorphism(const std::vector& perm) const; /** * Set the verbose output level for the algorithms. * \param level the level of verbose output, 0 means no verbose output */ void set_verbose_level(const unsigned int level); /** * Set the file stream for the verbose output. * \param fp the file stream; if null, no verbose output is written */ void set_verbose_file(FILE * const fp); /** Activate/deactivate failure recording. * May not be called during the search, i.e. from an automorphism reporting * hook function. * \param active if true, activate failure recording, deactivate otherwise */ void set_failure_recording(const bool active) {assert(!in_search); opt_use_failure_recording = active;} /** Activate/deactivate component recursion. * The choice affects the computed canonical labelings; * therefore, if you want to compare whether two graphs are isomorphic by * computing and comparing (for equality) their canonical versions, * be sure to use the same choice for both graphs. * May not be called during the search, i.e. from an automorphism reporting * hook function. * \param active if true, activate component recursion, deactivate otherwise */ void set_component_recursion(const bool active) {assert(!in_search); opt_use_comprec = active;} /** * Return the number of vertices in the graph. */ virtual unsigned int get_nof_vertices() const = 0; /** * Return a new graph that is the result of applying the permutation \a perm * to this graph. This graph is not modified. * \a perm must contain N=this.get_nof_vertices() elements and be a bijection * on {0,1,...,N-1}, otherwise the result is undefined or a segfault. */ virtual AbstractGraph* permute(const unsigned int* const perm) const = 0; virtual AbstractGraph* permute(const std::vector& perm) const = 0; /** * Find a set of generators for the automorphism group of the graph. * The function \a hook (if non-null) is called each time a new generator * for the automorphism group is found. * The first argument \a user_param for the hook is the * \a hook_user_param given below, * the second argument \a n is the length of the automorphism (equal to * get_nof_vertices()) and * the third argument \a aut is the automorphism * (a bijection on {0,...,get_nof_vertices()-1}). * The memory for the automorphism \a aut will be invalidated immediately * after the return from the hook function; * if you want to use the automorphism later, you have to take a copy of it. * Do not call any member functions in the hook. * The search statistics are copied in \a stats. */ void find_automorphisms(Stats& stats, void (*hook)(void* user_param, unsigned int n, const unsigned int* aut), void* hook_user_param); /** * Otherwise the same as find_automorphisms() except that * a canonical labeling of the graph (a bijection on * {0,...,get_nof_vertices()-1}) is returned. * The memory allocated for the returned canonical labeling will remain * valid only until the next call to a member function with the exception * that constant member functions (for example, bliss::Graph::permute()) can * be called without invalidating the labeling. * To compute the canonical version of an undirected graph, call this * function and then bliss::Graph::permute() with the returned canonical * labeling. * Note that the computed canonical version may depend on the applied version * of bliss as well as on some other options (for instance, the splitting * heuristic selected with bliss::Graph::set_splitting_heuristic()). */ const unsigned int* canonical_form(Stats& stats, void (*hook)(void* user_param, unsigned int n, const unsigned int* aut), void* hook_user_param); /** * Write the graph to a file in a variant of the DIMACS format. * See the bliss website * for the definition of the file format. * Note that in the DIMACS file the vertices are numbered from 1 to N while * in this C++ API they are from 0 to N-1. * Thus the vertex n in the file corresponds to the vertex n-1 in the API. * \param fp the file stream where the graph is written */ virtual void write_dimacs(FILE * const fp) = 0; /** * Write the graph to a file in the graphviz dotty format. * \param fp the file stream where the graph is written */ virtual void write_dot(FILE * const fp) = 0; /** * Write the graph in a file in the graphviz dotty format. * Do nothing if the file cannot be written. * \param file_name the name of the file to which the graph is written */ virtual void write_dot(const char * const file_name) = 0; /** * Get a hash value for the graph. * \return the hash value */ virtual unsigned int get_hash() = 0; /** * Disable/enable the "long prune" method. * The choice affects the computed canonical labelings; * therefore, if you want to compare whether two graphs are isomorphic by * computing and comparing (for equality) their canonical versions, * be sure to use the same choice for both graphs. * May not be called during the search, i.e. from an automorphism reporting * hook function. * \param active if true, activate "long prune", deactivate otherwise */ void set_long_prune_activity(const bool active) { assert(!in_search); opt_use_long_prune = active; } }; /** * \brief The class for undirected, vertex colored graphs. * * Multiple edges between vertices are not allowed (i.e., are ignored). */ class Graph : public AbstractGraph { public: /** * The possible splitting heuristics. * The selected splitting heuristics affects the computed canonical * labelings; therefore, if you want to compare whether two graphs * are isomorphic by computing and comparing (for equality) their * canonical versions, be sure to use the same splitting heuristics * for both graphs. */ typedef enum { /** First non-unit cell. * Very fast but may result in large search spaces on difficult graphs. * Use for large but easy graphs. */ shs_f = 0, /** First smallest non-unit cell. * Fast, should usually produce smaller search spaces than shs_f. */ shs_fs, /** First largest non-unit cell. * Fast, should usually produce smaller search spaces than shs_f. */ shs_fl, /** First maximally non-trivially connected non-unit cell. * Not so fast, should usually produce smaller search spaces than shs_f, * shs_fs, and shs_fl. */ shs_fm, /** First smallest maximally non-trivially connected non-unit cell. * Not so fast, should usually produce smaller search spaces than shs_f, * shs_fs, and shs_fl. */ shs_fsm, /** First largest maximally non-trivially connected non-unit cell. * Not so fast, should usually produce smaller search spaces than shs_f, * shs_fs, and shs_fl. */ shs_flm } SplittingHeuristic; protected: class Vertex { public: Vertex(); ~Vertex(); void add_edge(const unsigned int other_vertex); void remove_duplicate_edges(std::vector& tmp); void sort_edges(); unsigned int color; std::string label; std::vector edges; unsigned int nof_edges() const {return edges.size(); } }; std::vector vertices; void sort_edges(); void remove_duplicate_edges(); /** \internal * Partition independent invariant. * Returns the color of the vertex. * Time complexity: O(1). */ static unsigned int vertex_color_invariant(const Graph* const g, const unsigned int v); /** \internal * Partition independent invariant. * Returns the degree of the vertex. * DUPLICATE EDGES MUST HAVE BEEN REMOVED BEFORE. * Time complexity: O(1). */ static unsigned int degree_invariant(const Graph* const g, const unsigned int v); /** \internal * Partition independent invariant. * Returns 1 if there is an edge from the vertex to itself, 0 if not. * Time complexity: O(k), where k is the number of edges leaving the vertex. */ static unsigned int selfloop_invariant(const Graph* const g, const unsigned int v); bool refine_according_to_invariant(unsigned int (*inv)(const Graph* const g, const unsigned int v)); /* * Routines needed when refining the partition p into equitable */ bool split_neighbourhood_of_unit_cell(Partition::Cell *); bool split_neighbourhood_of_cell(Partition::Cell * const); /** \internal * \copydoc AbstractGraph::is_equitable() const */ bool is_equitable() const; /* Splitting heuristics, documented in more detail in graph.cc */ SplittingHeuristic sh; Partition::Cell* find_next_cell_to_be_splitted(Partition::Cell *cell); Partition::Cell* sh_first(); Partition::Cell* sh_first_smallest(); Partition::Cell* sh_first_largest(); Partition::Cell* sh_first_max_neighbours(); Partition::Cell* sh_first_smallest_max_neighbours(); Partition::Cell* sh_first_largest_max_neighbours(); void make_initial_equitable_partition(); void initialize_certificate(); bool is_automorphism(unsigned int* const perm); bool nucr_find_first_component(const unsigned int level); bool nucr_find_first_component(const unsigned int level, std::vector& component, unsigned int& component_elements, Partition::Cell*& sh_return); public: /** * Create a new graph with \a N vertices and no edges. */ Graph(const unsigned int N = 0); /** * Destroy the graph. */ ~Graph(); /** * Read the graph from the file \a fp in a variant of the DIMACS format. * See the bliss website * for the definition of the file format. * Note that in the DIMACS file the vertices are numbered from 1 to N while * in this C++ API they are from 0 to N-1. * Thus the vertex n in the file corresponds to the vertex n-1 in the API. * * \param fp the file stream for the graph file * \param errstr if non-null, the possible error messages are printed * in this file stream * \return a new Graph object or 0 if reading failed for some * reason */ static Graph* read_dimacs(FILE* const fp, FILE* const errstr = stderr); /** * Write the graph to a file in a variant of the DIMACS format. * See the bliss website * for the definition of the file format. */ void write_dimacs(FILE* const fp); /** * \copydoc AbstractGraph::write_dot(FILE * const fp) */ void write_dot(FILE* const fp); /** * \copydoc AbstractGraph::write_dot(const char * const file_name) */ void write_dot(const char* const file_name); /** * \copydoc AbstractGraph::is_automorphism(const std::vector& perm) const */ bool is_automorphism(const std::vector& perm) const; std::string get_vertex_label(const unsigned int vertex) const; /** * \copydoc AbstractGraph::get_hash() */ virtual unsigned int get_hash(); /** * Return the number of vertices in the graph. */ unsigned int get_nof_vertices() const {return vertices.size(); } /** * \copydoc AbstractGraph::permute(const unsigned int* const perm) const */ Graph* permute(const unsigned int* const perm) const; Graph* permute(const std::vector& perm) const; /** * Add a new vertex with color \a color in the graph and return its index. */ unsigned int add_vertex(const unsigned int color = 0, const std::string label = std::string{""}); /** * Add an edge between vertices \a v1 and \a v2. * Duplicate edges between vertices are ignored but try to avoid introducing * them in the first place as they are not ignored immediately but will * consume memory and computation resources for a while. */ void add_edge(const unsigned int v1, const unsigned int v2); /** * Change the color of the vertex \a vertex to \a color. */ void change_color(const unsigned int vertex, const unsigned int color); /** * Compare this graph with the graph \a other. * Returns 0 if the graphs are equal, and a negative (positive) integer * if this graph is "smaller than" ("greater than", resp.) than \a other. */ int cmp(Graph& other); /** * Set the splitting heuristic used by the automorphism and canonical * labeling algorithm. * The selected splitting heuristics affects the computed canonical * labelings; therefore, if you want to compare whether two graphs * are isomorphic by computing and comparing (for equality) their * canonical versions, be sure to use the same splitting heuristics * for both graphs. */ void set_splitting_heuristic(const SplittingHeuristic shs) {sh = shs; } }; /** * \brief The class for directed, vertex colored graphs. * * Multiple edges between vertices are not allowed (i.e., are ignored). */ template class Digraph : public AbstractGraph { public: /** * The possible splitting heuristics. * The selected splitting heuristics affects the computed canonical * labelings; therefore, if you want to compare whether two graphs * are isomorphic by computing and comparing (for equality) their * canonical versions, be sure to use the same splitting heuristics * for both graphs. */ typedef enum { /** First non-unit cell. * Very fast but may result in large search spaces on difficult graphs. * Use for large but easy graphs. */ shs_f = 0, /** First smallest non-unit cell. * Fast, should usually produce smaller search spaces than shs_f. */ shs_fs, /** First largest non-unit cell. * Fast, should usually produce smaller search spaces than shs_f. */ shs_fl, /** First maximally non-trivially connected non-unit cell. * Not so fast, should usually produce smaller search spaces than shs_f, * shs_fs, and shs_fl. */ shs_fm, /** First smallest maximally non-trivially connected non-unit cell. * Not so fast, should usually produce smaller search spaces than shs_f, * shs_fs, and shs_fl. */ shs_fsm, /** First largest maximally non-trivially connected non-unit cell. * Not so fast, should usually produce smaller search spaces than shs_f, * shs_fs, and shs_fl. */ shs_flm } SplittingHeuristic; protected: class Vertex { public: Vertex(); ~Vertex(); void add_edge_to(const unsigned int dest_vertex); void add_edge_from(const unsigned int source_vertex); void remove_duplicate_edges(std::vector& tmp); void sort_edges(); unsigned int color; std::string label; const T* value; std::vector edges_out; std::vector edges_in; unsigned int nof_edges_in() const {return edges_in.size(); } unsigned int nof_edges_out() const {return edges_out.size(); } }; std::vector vertices; void remove_duplicate_edges(); /** \internal * Partition independent invariant. * Returns the color of the vertex. * Time complexity: O(1). */ static unsigned int vertex_color_invariant(const Digraph* const g, const unsigned int v); /** \internal * Partition independent invariant. * Returns the indegree of the vertex. * DUPLICATE EDGES MUST HAVE BEEN REMOVED BEFORE. * Time complexity: O(1). */ static unsigned int indegree_invariant(const Digraph* const g, const unsigned int v); /** \internal * Partition independent invariant. * Returns the outdegree of the vertex. * DUPLICATE EDGES MUST HAVE BEEN REMOVED BEFORE. * Time complexity: O(1). */ static unsigned int outdegree_invariant(const Digraph* const g, const unsigned int v); /** \internal * Partition independent invariant. * Returns 1 if there is an edge from the vertex to itself, 0 if not. * Time complexity: O(k), where k is the number of edges leaving the vertex. */ static unsigned int selfloop_invariant(const Digraph* const g, const unsigned int v); /** \internal * Refine the partition \a p according to * the partition independent invariant \a inv. */ bool refine_according_to_invariant(unsigned int (*inv)(const Digraph* const g, const unsigned int v)); /* * Routines needed when refining the partition p into equitable */ bool split_neighbourhood_of_unit_cell(Partition::Cell* const); bool split_neighbourhood_of_cell(Partition::Cell* const); /** \internal * \copydoc AbstractGraph::is_equitable() const */ bool is_equitable() const; /* Splitting heuristics, documented in more detail in the cc-file. */ SplittingHeuristic sh; Partition::Cell* find_next_cell_to_be_splitted(Partition::Cell *cell); Partition::Cell* sh_first(); Partition::Cell* sh_first_smallest(); Partition::Cell* sh_first_largest(); Partition::Cell* sh_first_max_neighbours(); Partition::Cell* sh_first_smallest_max_neighbours(); Partition::Cell* sh_first_largest_max_neighbours(); void make_initial_equitable_partition(); void initialize_certificate(); bool is_automorphism(unsigned int* const perm); void sort_edges(); bool nucr_find_first_component(const unsigned int level); bool nucr_find_first_component(const unsigned int level, std::vector& component, unsigned int& component_elements, Partition::Cell*& sh_return); public: /** * Create a new directed graph with \a N vertices and no edges. */ Digraph(const unsigned int N = 0); /** * Destroy the graph. */ ~Digraph(); /** * Read the graph from the file \a fp in a variant of the DIMACS format. * See the bliss website * for the definition of the file format. * Note that in the DIMACS file the vertices are numbered from 1 to N while * in this C++ API they are from 0 to N-1. * Thus the vertex n in the file corresponds to the vertex n-1 in the API. * \param fp the file stream for the graph file * \param errstr if non-null, the possible error messages are printed * in this file stream * \return a new Digraph object or 0 if reading failed for some * reason */ static Digraph* read_dimacs(FILE* const fp, FILE* const errstr = stderr); /** * \copydoc AbstractGraph::write_dimacs(FILE * const fp) */ void write_dimacs(FILE* const fp); /** * \copydoc AbstractGraph::write_dot(FILE *fp) */ void write_dot(FILE * const fp); /** * \copydoc AbstractGraph::write_dot(const char * const file_name) */ void write_dot(const char * const file_name); /** * \copydoc AbstractGraph::is_automorphism(const std::vector& perm) const */ bool is_automorphism(const std::vector& perm) const; std::string get_vertex_label(unsigned int vertex) const; const T* get_vertex_value(unsigned int vertex) const; /** * \copydoc AbstractGraph::get_hash() */ virtual unsigned int get_hash(); /** * Return the number of vertices in the graph. */ unsigned int get_nof_vertices() const {return vertices.size(); } /** * Add a new vertex with color 'color' in the graph and return its index. */ unsigned int add_vertex(const unsigned int color = 0, const std::string label = std::string{""}, const T* value = NULL); /** * Add an edge from vertix \a v1 to vertex \a v2. * Duplicate edges are ignored but try to avoid introducing * them in the first place as they are not ignored immediately but will * consume memory and computation resources for a while. */ void add_edge(const unsigned int v1, const unsigned int v2); /** * Change the color of the vertex 'vertex' to 'color'. */ void change_color(const unsigned int vertex, const unsigned int color); /** * Compare this graph with the graph \a other. * Returns 0 if the graphs are equal, and a negative (positive) integer * if this graph is "smaller than" ("greater than", resp.) than \a other. */ int cmp(Digraph& other); /** * Set the splitting heuristic used by the automorphism and canonical * labeling algorithm. * The selected splitting heuristics affects the computed canonical * labelings; therefore, if you want to compare whether two graphs * are isomorphic by computing and comparing (for equality) their * canonical versions, be sure to use the same splitting heuristics * for both graphs. */ void set_splitting_heuristic(SplittingHeuristic shs) {sh = shs; } /** * \copydoc AbstractGraph::permute(const unsigned int* const perm) const */ Digraph* permute(const unsigned int* const perm) const; Digraph* permute(const std::vector& perm) const; }; } #endif opensmt-2.5.2/src/symmetry/bliss/heap.cc000066400000000000000000000036451445011647600202450ustar00rootroot00000000000000#include #include #include #include "defs.hh" #include "heap.hh" /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ namespace bliss { Heap::~Heap() { if(array) { free(array); array = 0; n = 0; N = 0; } } void Heap::upheap(unsigned int index) { const unsigned int v = array[index]; array[0] = 0; while(array[index/2] > v) { array[index] = array[index/2]; index = index/2; } array[index] = v; } void Heap::downheap(unsigned int index) { const unsigned int v = array[index]; const unsigned int lim = n/2; while(index <= lim) { unsigned int new_index = index + index; if((new_index < n) and (array[new_index] > array[new_index+1])) new_index++; if(v <= array[new_index]) break; array[index] = array[new_index]; index = new_index; } array[index] = v; } void Heap::init(const unsigned int size) { if(size > N) { if(array) free(array); array = (unsigned int*)malloc((size + 1) * sizeof(unsigned int)); N = size; } n = 0; } void Heap::insert(const unsigned int v) { array[++n] = v; upheap(n); } unsigned int Heap::remove() { const unsigned int v = array[1]; array[1] = array[n--]; downheap(1); return v; } } // namespace bliss opensmt-2.5.2/src/symmetry/bliss/heap.hh000066400000000000000000000036351445011647600202560ustar00rootroot00000000000000#ifndef BLISS_HEAP_HH #define BLISS_HEAP_HH /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ namespace bliss { /** \internal * \brief A capacity bounded heap data structure. */ class Heap { unsigned int N; unsigned int n; unsigned int *array; void upheap(unsigned int k); void downheap(unsigned int k); public: /** * Create a new heap. * init() must be called after this. */ Heap() {array = 0; n = 0; N = 0; } ~Heap(); /** * Initialize the heap to have the capacity to hold \e size elements. */ void init(const unsigned int size); /** * Is the heap empty? * Time complexity is O(1). */ bool is_empty() const {return(n==0); } /** * Remove all the elements in the heap. * Time complexity is O(1). */ void clear() {n = 0;} /** * Insert the element \a e in the heap. * Time complexity is O(log(N)), where N is the number of elements * currently in the heap. */ void insert(const unsigned int e); /** * Remove and return the smallest element in the heap. * Time complexity is O(log(N)), where N is the number of elements * currently in the heap. */ unsigned int remove(); /** * Get the number of elements in the heap. */ unsigned int size() const {return n; } }; } // namespace bliss #endif opensmt-2.5.2/src/symmetry/bliss/kqueue.hh000066400000000000000000000060541445011647600206360ustar00rootroot00000000000000#ifndef BLISS_KQUEUE_HH #define BLISS_KQUEUE_HH /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ #include "defs.hh" namespace bliss { /** \internal * \brief A very simple implementation of queues with fixed capacity. */ template class KQueue { public: /** * Create a new queue with capacity zero. * The function init() should be called next. */ KQueue(); ~KQueue(); /** * Initialize the queue to have the capacity to hold at most \a N elements. */ void init(const unsigned int N); /** Is the queue empty? */ bool is_empty() const; /** Return the number of elements in the queue. */ unsigned int size() const; /** Remove all the elements in the queue. */ void clear(); /** Return (but don't remove) the first element in the queue. */ Type front() const; /** Remove and return the first element of the queue. */ Type pop_front(); /** Push the element \a e in the front of the queue. */ void push_front(Type e); /** Remove and return the last element of the queue. */ Type pop_back(); /** Push the element \a e in the back of the queue. */ void push_back(Type e); private: Type *entries, *end; Type *head, *tail; }; template KQueue::KQueue() { entries = 0; end = 0; head = 0; tail = 0; } template KQueue::~KQueue() { if(entries) free(entries); } template void KQueue::init(const unsigned int k) { assert(k > 0); if(entries) free(entries); entries = (Type*)malloc((k + 1) * sizeof(Type)); end = entries + k + 1; head = entries; tail = head; } template void KQueue::clear() { head = entries; tail = head; } template bool KQueue::is_empty() const { return(head == tail); } template unsigned int KQueue::size() const { if(tail >= head) return(tail - head); return((end - head) + (tail - entries)); } template Type KQueue::front() const { return *head; } template Type KQueue::pop_front() { Type *old_head = head; head++; if(head == end) head = entries; return *old_head; } template void KQueue::push_front(Type e) { if(head == entries) head = end - 1; else head--; *head = e; } template void KQueue::push_back(Type e) { *tail = e; tail++; if(tail == end) tail = entries; } } // namespace bliss #endif opensmt-2.5.2/src/symmetry/bliss/kstack.hh000066400000000000000000000055161445011647600206210ustar00rootroot00000000000000#ifndef BLISS_KSTACK_H #define BLISS_KSTACK_H /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ #include #include "defs.hh" namespace bliss { /** \internal * \brief A very simple implementation of a stack with fixed capacity. */ template class KStack { public: /** * Create a new stack with zero capacity. * The function init() should be called next. */ KStack(); /** * Create a new stack with the capacity to hold at most \a N elements. */ KStack(int N); ~KStack(); /** * Initialize the stack to have the capacity to hold at most \a N elements. */ void init(int N); /** * Is the stack empty? */ bool is_empty() const {return(cursor == entries); } /** * Return (but don't remove) the top element of the stack. */ Type top() const {BLISS_ASSERT(cursor > entries); return *cursor; } /** * Pop (remove) the top element of the stack. */ Type pop() { return *cursor--; } /** * Push the element \a e in the stack. */ void push(Type e) { *(++cursor) = e; } /** Remove all the elements in the stack. */ void clean() {cursor = entries; } /** * Get the number of elements in the stack. */ unsigned int size() const {return(cursor - entries); } /** * Return the i:th element in the stack, where \a i is in the range * 0,...,this.size()-1; the 0:th element is the bottom element * in the stack. */ Type element_at(unsigned int i) { assert(i < size()); return entries[i+1]; } /** Return the capacity (NOT the number of elements) of the stack. */ int capacity() {return kapacity; } private: int kapacity; Type *entries; Type *cursor; }; template KStack::KStack() { kapacity = 0; entries = 0; cursor = 0; } template KStack::KStack(int k) { assert(k > 0); kapacity = k; entries = (Type*)malloc((k+1) * sizeof(Type)); cursor = entries; } template void KStack::init(int k) { assert(k > 0); if(entries) free(entries); kapacity = k; entries = (Type*)malloc((k+1) * sizeof(Type)); cursor = entries; } template KStack::~KStack() { free(entries); } } // namespace bliss #endif opensmt-2.5.2/src/symmetry/bliss/orbit.cc000066400000000000000000000055771445011647600204550ustar00rootroot00000000000000#include #include #include "defs.hh" #include "orbit.hh" /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ namespace bliss { Orbit::Orbit() { orbits = 0; in_orbit = 0; nof_elements = 0; } Orbit::~Orbit() { if(orbits) { free(orbits); orbits = 0; } if(in_orbit) { free(in_orbit); in_orbit = 0; } nof_elements = 0; } void Orbit::init(const unsigned int n) { assert(n > 0); if(orbits) free(orbits); orbits = (OrbitEntry*)malloc(n * sizeof(OrbitEntry)); if(in_orbit) free(in_orbit); in_orbit = (OrbitEntry**)malloc(n * sizeof(OrbitEntry*)); nof_elements = n; reset(); } void Orbit::reset() { assert(orbits); assert(in_orbit); for(unsigned int i = 0; i < nof_elements; i++) { orbits[i].element = i; orbits[i].next = 0; orbits[i].size = 1; in_orbit[i] = &orbits[i]; } _nof_orbits = nof_elements; } void Orbit::merge_orbits(OrbitEntry *orbit1, OrbitEntry *orbit2) { if(orbit1 != orbit2) { _nof_orbits--; /* Only update the elements in the smaller orbit */ if(orbit1->size > orbit2->size) { OrbitEntry * const temp = orbit2; orbit2 = orbit1; orbit1 = temp; } /* Link the elements of orbit1 to the almost beginning of orbit2 */ OrbitEntry *e = orbit1; while(e->next) { in_orbit[e->element] = orbit2; e = e->next; } in_orbit[e->element] = orbit2; e->next = orbit2->next; orbit2->next = orbit1; /* Keep the minimal orbit representative in the beginning */ if(orbit1->element < orbit2->element) { const unsigned int temp = orbit1->element; orbit1->element = orbit2->element; orbit2->element = temp; } orbit2->size += orbit1->size; } } void Orbit::merge_orbits(unsigned int e1, unsigned int e2) { merge_orbits(in_orbit[e1], in_orbit[e2]); } bool Orbit::is_minimal_representative(unsigned int element) const { return(get_minimal_representative(element) == element); } unsigned int Orbit::get_minimal_representative(unsigned int element) const { OrbitEntry * const orbit = in_orbit[element]; return(orbit->element); } unsigned int Orbit::orbit_size(unsigned int element) const { return(in_orbit[element]->size); } } // namespace bliss opensmt-2.5.2/src/symmetry/bliss/orbit.hh000066400000000000000000000057471445011647600204660ustar00rootroot00000000000000#ifndef BLISS_ORBIT_HH #define BLISS_ORBIT_HH /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ namespace bliss { /** \internal * \brief A class for representing orbit information. * * Given a set {0,...,N-1} of N elements, represent equivalence * classes (that is, unordered partitions) of the elements. * Supports only equivalence class merging, not splitting. * Merging two classes requires time O(k), where k is the number of * the elements in the smaller of the merged classes. * Getting the smallest representative in a class (and thus testing * whether two elements belong to the same class) is a constant time operation. */ class Orbit { class OrbitEntry { public: unsigned int element; OrbitEntry *next; unsigned int size; }; OrbitEntry *orbits; OrbitEntry **in_orbit; unsigned int nof_elements; unsigned int _nof_orbits; void merge_orbits(OrbitEntry *o1, OrbitEntry *o2); public: /** * Create a new orbit information object. * The init() function must be called next to actually initialize * the object. */ Orbit(); ~Orbit(); /** * Initialize the orbit information to consider sets of \a N elements. * It is required that \a N > 0. * The orbit information is reset so that each element forms * an orbit of its own. * Time complexity is O(N). * \sa reset() */ void init(const unsigned int N); /** * Reset the orbits so that each element forms an orbit of its own. * Time complexity is O(N). */ void reset(); /** * Merge the orbits of the elements \a e1 and \a e2. * Time complexity is O(k), where k is the number of elements in * the smaller of the merged orbits. */ void merge_orbits(unsigned int e1, unsigned int e2); /** * Is the element \a e the smallest element in its orbit? * Time complexity is O(1). */ bool is_minimal_representative(unsigned int e) const; /** * Get the smallest element in the orbit of the element \a e. * Time complexity is O(1). */ unsigned int get_minimal_representative(unsigned int e) const; /** * Get the number of elements in the orbit of the element \a e. * Time complexity is O(1). */ unsigned int orbit_size(unsigned int e) const; /** * Get the number of orbits. * Time complexity is O(1). */ unsigned int nof_orbits() const {return _nof_orbits; } }; } // namespace bliss #endif opensmt-2.5.2/src/symmetry/bliss/partition.cc000066400000000000000000000664011445011647600213400ustar00rootroot00000000000000#include #include #include #include "graph.hh" #include "partition.hh" /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ namespace bliss { Partition::Partition() { N = 0; elements = 0; in_pos = 0; invariant_values = 0; cells = 0; free_cells = 0; element_to_cell_map = 0; graph = 0; discrete_cell_count = 0; /* Initialize a distribution count sorting array. */ for(unsigned int i = 0; i < 256; i++) dcs_count[i] = 0; cr_enabled = false; cr_cells = 0; cr_levels = 0; } Partition::~Partition() { if(elements) {free(elements); elements = 0; } if(cells) {free(cells); cells = 0; } if(element_to_cell_map) {free(element_to_cell_map); element_to_cell_map = 0; } if(in_pos) {free(in_pos); in_pos = 0; } if(invariant_values) {free(invariant_values); invariant_values = 0; } N = 0; } void Partition::init(const unsigned int M) { assert(M > 0); N = M; if(elements) free(elements); elements = (unsigned int*)malloc(N * sizeof(unsigned int)); for(unsigned int i = 0; i < N; i++) elements[i] = i; if(in_pos) free(in_pos); in_pos = (unsigned int**)malloc(N * sizeof(unsigned int*)); for(unsigned int i = 0; i < N; i++) in_pos[i] = elements + i; if(invariant_values) free(invariant_values); invariant_values = (unsigned int*)malloc(N * sizeof(unsigned int)); for(unsigned int i = 0; i < N; i++) invariant_values[i] = 0; if(cells) free(cells); cells = (Cell*)malloc(N * sizeof(Cell)); cells[0].first = 0; cells[0].length = N; cells[0].max_ival = 0; cells[0].max_ival_count = 0; cells[0].in_splitting_queue = false; cells[0].in_neighbour_heap = false; cells[0].prev = 0; cells[0].next = 0; cells[0].next_nonsingleton = 0; cells[0].prev_nonsingleton = 0; cells[0].split_level = 0; first_cell = &cells[0]; if(N == 1) { first_nonsingleton_cell = 0; discrete_cell_count = 1; } else { first_nonsingleton_cell = &cells[0]; discrete_cell_count = 0; } for(unsigned int i = 1; i < N; i++) { cells[i].first = 0; cells[i].length = 0; cells[i].max_ival = 0; cells[i].max_ival_count = 0; cells[i].in_splitting_queue = false; cells[i].in_neighbour_heap = false; cells[i].prev = 0; cells[i].next = (i < N-1)?&cells[i+1]:0; cells[i].next_nonsingleton = 0; cells[i].prev_nonsingleton = 0; } if(N > 1) free_cells = &cells[1]; else free_cells = 0; if(element_to_cell_map) free(element_to_cell_map); element_to_cell_map = (Cell **)malloc(N * sizeof(Cell *)); for(unsigned int i = 0; i < N; i++) element_to_cell_map[i] = first_cell; splitting_queue.init(N); refinement_stack.init(N); /* Reset the main backtracking stack */ bt_stack.clear(); } Partition::BacktrackPoint Partition::set_backtrack_point() { BacktrackInfo info; info.refinement_stack_size = refinement_stack.size(); if(cr_enabled) info.cr_backtrack_point = cr_get_backtrack_point(); BacktrackPoint p = bt_stack.size(); bt_stack.push_back(info); return p; } void Partition::goto_backtrack_point(BacktrackPoint p) { BacktrackInfo info = bt_stack[p]; bt_stack.resize(p); if(cr_enabled) cr_goto_backtrack_point(info.cr_backtrack_point); const unsigned int dest_refinement_stack_size = info.refinement_stack_size; assert(refinement_stack.size() >= dest_refinement_stack_size); while(refinement_stack.size() > dest_refinement_stack_size) { RefInfo i = refinement_stack.pop(); const unsigned int first = i.split_cell_first; Cell* cell = get_cell(elements[first]); if(cell->first != first) { assert(cell->first < first); assert(cell->split_level <= dest_refinement_stack_size); goto done; } assert(cell->split_level > dest_refinement_stack_size); while(cell->split_level > dest_refinement_stack_size) { assert(cell->prev); cell = cell->prev; } while(cell->next and cell->next->split_level > dest_refinement_stack_size) { /* Merge next cell */ Cell* const next_cell = cell->next; if(cell->length == 1) discrete_cell_count--; if(next_cell->length == 1) discrete_cell_count--; /* Update element_to_cell_map values of elements added in cell */ unsigned int* ep = elements + next_cell->first; unsigned int* const lp = ep + next_cell->length; for( ; ep < lp; ep++) element_to_cell_map[*ep] = cell; /* Update cell parameters */ cell->length += next_cell->length; if(next_cell->next) next_cell->next->prev = cell; cell->next = next_cell->next; /* (Pseudo)free next_cell */ next_cell->first = 0; next_cell->length = 0; next_cell->prev = 0; next_cell->next = free_cells; free_cells = next_cell; } done: if(i.prev_nonsingleton_first >= 0) { Cell* const prev_cell = get_cell(elements[i.prev_nonsingleton_first]); cell->prev_nonsingleton = prev_cell; prev_cell->next_nonsingleton = cell; } else { //assert(cell->prev_nonsingleton == 0); cell->prev_nonsingleton = 0; first_nonsingleton_cell = cell; } if(i.next_nonsingleton_first >= 0) { Cell* const next_cell = get_cell(elements[i.next_nonsingleton_first]); cell->next_nonsingleton = next_cell; next_cell->prev_nonsingleton = cell; } else { //assert(cell->next_nonsingleton == 0); cell->next_nonsingleton = 0; } } } Partition::Cell* Partition::individualize(Partition::Cell * const cell, const unsigned int element) { unsigned int * const pos = in_pos[element]; const unsigned int last = cell->first + cell->length - 1; *pos = elements[last]; in_pos[*pos] = pos; elements[last] = element; in_pos[element] = elements + last; Partition::Cell * const new_cell = aux_split_in_two(cell, cell->length-1); element_to_cell_map[element] = new_cell; return new_cell; } Partition::Cell* Partition::aux_split_in_two(Partition::Cell* const cell, const unsigned int first_half_size) { RefInfo i; /* (Pseudo)allocate new cell */ Cell * const new_cell = free_cells; free_cells = new_cell->next; /* Update new cell parameters */ new_cell->first = cell->first + first_half_size; new_cell->length = cell->length - first_half_size; new_cell->next = cell->next; if(new_cell->next) new_cell->next->prev = new_cell; new_cell->prev = cell; new_cell->split_level = refinement_stack.size()+1; /* Update old, splitted cell parameters */ cell->length = first_half_size; cell->next = new_cell; /* CR */ if(cr_enabled) cr_create_at_level_trailed(new_cell->first, cr_get_level(cell->first)); /* Add cell in refinement_stack for backtracking */ i.split_cell_first = new_cell->first; if(cell->prev_nonsingleton) i.prev_nonsingleton_first = cell->prev_nonsingleton->first; else i.prev_nonsingleton_first = -1; if(cell->next_nonsingleton) i.next_nonsingleton_first = cell->next_nonsingleton->first; else i.next_nonsingleton_first = -1; refinement_stack.push(i); /* Modify nonsingleton cell list */ if(new_cell->length > 1) { new_cell->prev_nonsingleton = cell; new_cell->next_nonsingleton = cell->next_nonsingleton; if(new_cell->next_nonsingleton) new_cell->next_nonsingleton->prev_nonsingleton = new_cell; cell->next_nonsingleton = new_cell; } else { new_cell->next_nonsingleton = 0; new_cell->prev_nonsingleton = 0; discrete_cell_count++; } if(cell->is_unit()) { if(cell->prev_nonsingleton) cell->prev_nonsingleton->next_nonsingleton = cell->next_nonsingleton; else first_nonsingleton_cell = cell->next_nonsingleton; if(cell->next_nonsingleton) cell->next_nonsingleton->prev_nonsingleton = cell->prev_nonsingleton; cell->next_nonsingleton = 0; cell->prev_nonsingleton = 0; discrete_cell_count++; } return new_cell; } size_t Partition::print(FILE* const fp, const bool add_newline) const { size_t r = 0; const char* cell_sep = ""; r += fprintf(fp, "["); for(Cell* cell = first_cell; cell; cell = cell->next) { /* Print cell */ r += fprintf(fp, "%s{", cell_sep); cell_sep = ","; const char* elem_sep = ""; for(unsigned int i = 0; i < cell->length; i++) { r += fprintf(fp, "%s%u", elem_sep, elements[cell->first + i]); elem_sep = ","; } r += fprintf(fp, "}"); } r += fprintf(fp, "]"); if(add_newline) r += fprintf(fp, "\n"); return r; } size_t Partition::print_signature(FILE* const fp, const bool add_newline) const { size_t r = 0; const char* cell_sep = ""; r += fprintf(fp, "["); for(Cell* cell = first_cell; cell; cell = cell->next) { if(cell->is_unit()) continue; //fprintf(fp, "%s%u", cell_sep, cr_cells[cell->first].level); r += fprintf(fp, "%s%u", cell_sep, cell->length); cell_sep = ","; } r += fprintf(fp, "]"); if(add_newline) r += fprintf(fp, "\n"); return r; } void Partition::splitting_queue_add(Cell* const cell) { static const unsigned int smallish_cell_threshold = 1; cell->in_splitting_queue = true; if(cell->length <= smallish_cell_threshold) splitting_queue.push_front(cell); else splitting_queue.push_back(cell); } void Partition::splitting_queue_clear() { while(!splitting_queue_is_empty()) splitting_queue_pop(); } /* * Assumes that the invariant values are NOT the same * and that the cell contains more than one element */ Partition::Cell* Partition::sort_and_split_cell1(Partition::Cell* const cell) { #if defined(BLISS_EXPENSIVE_CONSISTENCY_CHECKS) assert(cell->length > 1); assert(cell->first + cell->length <= N); unsigned int nof_0_found = 0; unsigned int nof_1_found = 0; for(unsigned int i = cell->first; i < cell->first + cell->length; i++) { const unsigned int ival = invariant_values[elements[i]]; assert(ival == 0 or ival == 1); if(ival == 0) nof_0_found++; else nof_1_found++; } assert(nof_0_found > 0); assert(nof_1_found > 0); assert(nof_1_found == cell->max_ival_count); assert(nof_0_found + nof_1_found == cell->length); assert(cell->max_ival == 1); #endif /* Allocate new cell */ Cell* const new_cell = free_cells; free_cells = new_cell->next; #define NEW_SORT1 #ifdef NEW_SORT1 unsigned int *ep0 = elements + cell->first; unsigned int *ep1 = ep0 + cell->length - cell->max_ival_count; if(cell->max_ival_count > cell->length / 2) { /* There are more ones than zeros, only move zeros */ unsigned int * const end = ep0 + cell->length; while(ep1 < end) { while(invariant_values[*ep1] == 0) { const unsigned int tmp = *ep1; *ep1 = *ep0; *ep0 = tmp; in_pos[tmp] = ep0; in_pos[*ep1] = ep1; ep0++; } element_to_cell_map[*ep1] = new_cell; invariant_values[*ep1] = 0; ep1++; } } else { /* There are more zeros than ones, only move ones */ unsigned int * const end = ep1; while(ep0 < end) { while(invariant_values[*ep0] != 0) { const unsigned int tmp = *ep0; *ep0 = *ep1; *ep1 = tmp; in_pos[tmp] = ep1; in_pos[*ep0] = ep0; ep1++; } ep0++; } ep1 = end; while(ep1 < elements + cell->first + cell->length) { element_to_cell_map[*ep1] = new_cell; invariant_values[*ep1] = 0; ep1++; } } /* Update new cell parameters */ new_cell->first = cell->first + cell->length - cell->max_ival_count; new_cell->length = cell->length - (new_cell->first - cell->first); new_cell->next = cell->next; if(new_cell->next) new_cell->next->prev = new_cell; new_cell->prev = cell; new_cell->split_level = refinement_stack.size()+1; /* Update old, splitted cell parameters */ cell->length = new_cell->first - cell->first; cell->next = new_cell; /* CR */ if(cr_enabled) cr_create_at_level_trailed(new_cell->first, cr_get_level(cell->first)); #else /* Sort vertices in the cell according to the invariant values */ unsigned int *ep0 = elements + cell->first; unsigned int *ep1 = ep0 + cell->length; while(ep1 > ep0) { const unsigned int element = *ep0; const unsigned int ival = invariant_values[element]; invariant_values[element] = 0; if(ival == 0) { ep0++; } else { ep1--; *ep0 = *ep1; *ep1 = element; element_to_cell_map[element] = new_cell; in_pos[element] = ep1; in_pos[*ep0] = ep0; } } /* Update new cell parameters */ new_cell->first = ep1 - elements; new_cell->length = cell->length - (new_cell->first - cell->first); new_cell->next = cell->next; if(new_cell->next) new_cell->next->prev = new_cell; new_cell->prev = cell; new_cell->split_level = cell->split_level; /* Update old, splitted cell parameters */ cell->length = new_cell->first - cell->first; cell->next = new_cell; cell->split_level = refinement_stack.size()+1; /* CR */ if(cr_enabled) cr_create_at_level_trailed(new_cell->first, cr_get_level(cell->first)); #endif /* ifdef NEW_SORT1*/ /* Add cell in refinement stack for backtracking */ { RefInfo i; i.split_cell_first = new_cell->first; if(cell->prev_nonsingleton) i.prev_nonsingleton_first = cell->prev_nonsingleton->first; else i.prev_nonsingleton_first = -1; if(cell->next_nonsingleton) i.next_nonsingleton_first = cell->next_nonsingleton->first; else i.next_nonsingleton_first = -1; /* Modify nonsingleton cell list */ if(new_cell->length > 1) { new_cell->prev_nonsingleton = cell; new_cell->next_nonsingleton = cell->next_nonsingleton; if(new_cell->next_nonsingleton) new_cell->next_nonsingleton->prev_nonsingleton = new_cell; cell->next_nonsingleton = new_cell; } else { new_cell->next_nonsingleton = 0; new_cell->prev_nonsingleton = 0; discrete_cell_count++; } if(cell->is_unit()) { if(cell->prev_nonsingleton) cell->prev_nonsingleton->next_nonsingleton = cell->next_nonsingleton; else first_nonsingleton_cell = cell->next_nonsingleton; if(cell->next_nonsingleton) cell->next_nonsingleton->prev_nonsingleton = cell->prev_nonsingleton; cell->next_nonsingleton = 0; cell->prev_nonsingleton = 0; discrete_cell_count++; } refinement_stack.push(i); } /* Add cells in splitting queue */ if(cell->in_splitting_queue) { /* Both cells must be included in splitting_queue in order to have refinement to equitable partition */ splitting_queue_add(new_cell); } else { Cell *min_cell, *max_cell; if(cell->length <= new_cell->length) { min_cell = cell; max_cell = new_cell; } else { min_cell = new_cell; max_cell = cell; } /* Put the smaller cell in splitting_queue */ splitting_queue_add(min_cell); if(max_cell->is_unit()) { /* Put the "larger" cell also in splitting_queue */ splitting_queue_add(max_cell); } } return new_cell; } /** * An auxiliary function for distribution count sorting. * Build start array so that * dcs_start[0] = 0 and dcs_start[i+1] = dcs_start[i] + dcs_count[i]. */ void Partition::dcs_cumulate_count(const unsigned int max) { unsigned int* count_p = dcs_count; unsigned int* start_p = dcs_start; unsigned int sum = 0; for(unsigned int i = max+1; i > 0; i--) { *start_p = sum; start_p++; sum += *count_p; count_p++; } } /** * Distribution count sorting of cells with invariant values less than 256. */ Partition::Cell* Partition::sort_and_split_cell255(Partition::Cell* const cell, const unsigned int max_ival) { if(cell->is_unit()) { /* Reset invariant value */ invariant_values[elements[cell->first]] = 0; return cell; } #ifdef BLISS_CONSISTENCY_CHECKS for(unsigned int i = 0; i < 256; i++) assert(dcs_count[i] == 0); #endif /* * Compute the distribution of invariant values to the count array */ { const unsigned int *ep = elements + cell->first; const unsigned int ival = invariant_values[*ep]; dcs_count[ival]++; ep++; #if defined(BLISS_CONSISTENCY_CHECKS) bool equal_invariant_values = true; #endif for(unsigned int i = cell->length - 1; i != 0; i--) { const unsigned int ival2 = invariant_values[*ep]; dcs_count[ival2]++; #if defined(BLISS_CONSISTENCY_CHECKS) if(ival2 != ival) { equal_invariant_values = false; } #endif ep++; } #if defined(BLISS_CONSISTENCY_CHECKS) assert(!equal_invariant_values); if(equal_invariant_values) { assert(dcs_count[ival] == cell->length); dcs_count[ival] = 0; clear_ivs(cell); return cell; } #endif } /* Build start array */ dcs_cumulate_count(max_ival); /* Do the sorting */ for(unsigned int i = 0; i <= max_ival; i++) { unsigned int *ep = elements + cell->first + dcs_start[i]; for(unsigned int j = dcs_count[i]; j > 0; j--) { while(true) { const unsigned int element = *ep; const unsigned int ival = invariant_values[element]; if(ival == i) break; *ep = elements[cell->first + dcs_start[ival]]; elements[cell->first + dcs_start[ival]] = element; dcs_start[ival]++; dcs_count[ival]--; } ep++; } dcs_count[i] = 0; } #if defined(BLISS_CONSISTENCY_CHECKS) for(unsigned int i = 0; i < 256; i++) assert(dcs_count[i] == 0); #endif /* split cell */ Cell* const new_cell = split_cell(cell); return new_cell; } /* * Sort the elements in a cell according to their invariant values. * The invariant values are not cleared. * Warning: the in_pos array is left in incorrect state. */ bool Partition::shellsort_cell(Partition::Cell* const cell) { unsigned int h; unsigned int* ep; if(cell->is_unit()) return false; /* Check whether all the elements have the same invariant value */ bool equal_invariant_values = true; { ep = elements + cell->first; const unsigned int ival = invariant_values[*ep]; ep++; for(unsigned int i = cell->length - 1; i > 0; i--) { if(invariant_values[*ep] != ival) { equal_invariant_values = false; break; } ep++; } } if(equal_invariant_values) return false; ep = elements + cell->first; for(h = 1; h <= cell->length/9; h = 3*h + 1) ; for( ; h > 0; h = h/3) { for(unsigned int i = h; i < cell->length; i++) { const unsigned int element = ep[i]; const unsigned int ival = invariant_values[element]; unsigned int j = i; while(j >= h and invariant_values[ep[j-h]] > ival) { ep[j] = ep[j-h]; j -= h; } ep[j] = element; } } return true; } void Partition::clear_ivs(Cell* const cell) { unsigned int* ep = elements + cell->first; for(unsigned int i = cell->length; i > 0; i--, ep++) invariant_values[*ep] = 0; } /* * Assumes that the elements in the cell are sorted according to their * invariant values. */ Partition::Cell* Partition::split_cell(Partition::Cell* const original_cell) { Cell* cell = original_cell; const bool original_cell_was_in_splitting_queue = original_cell->in_splitting_queue; Cell* largest_new_cell = 0; while(true) { unsigned int* ep = elements + cell->first; const unsigned int* const lp = ep + cell->length; const unsigned int ival = invariant_values[*ep]; invariant_values[*ep] = 0; element_to_cell_map[*ep] = cell; in_pos[*ep] = ep; ep++; while(ep < lp) { const unsigned int e = *ep; if(invariant_values[e] != ival) break; invariant_values[e] = 0; in_pos[e] = ep; ep++; element_to_cell_map[e] = cell; } if(ep == lp) break; Cell* const new_cell = aux_split_in_two(cell, (ep - elements) - cell->first); if(graph and graph->compute_eqref_hash) { graph->eqref_hash.update(new_cell->first); graph->eqref_hash.update(new_cell->length); graph->eqref_hash.update(ival); } /* Add cells in splitting_queue */ assert(!new_cell->is_in_splitting_queue()); if(original_cell_was_in_splitting_queue) { /* In this case, all new cells are inserted in splitting_queue */ assert(cell->is_in_splitting_queue()); splitting_queue_add(new_cell); } else { /* Otherwise, we can omit one new cell from splitting_queue */ assert(!cell->is_in_splitting_queue()); if(largest_new_cell == 0) { largest_new_cell = cell; } else { assert(!largest_new_cell->is_in_splitting_queue()); if(cell->length > largest_new_cell->length) { splitting_queue_add(largest_new_cell); largest_new_cell = cell; } else { splitting_queue_add(cell); } } } /* Process the rest of the cell */ cell = new_cell; } if(original_cell == cell) { /* All the elements in cell had the same invariant value */ return cell; } /* Add cells in splitting_queue */ if(!original_cell_was_in_splitting_queue) { /* Also consider the last new cell */ assert(largest_new_cell); if(cell->length > largest_new_cell->length) { splitting_queue_add(largest_new_cell); largest_new_cell = cell; } else { splitting_queue_add(cell); } if(largest_new_cell->is_unit()) { /* Needed in certificate computation */ splitting_queue_add(largest_new_cell); } } return cell; } Partition::Cell* Partition::zplit_cell(Partition::Cell* const cell, const bool max_ival_info_ok) { Cell* last_new_cell = cell; if(!max_ival_info_ok) { /* Compute max_ival info */ assert(cell->max_ival == 0); assert(cell->max_ival_count == 0); unsigned int *ep = elements + cell->first; for(unsigned int i = cell->length; i > 0; i--, ep++) { const unsigned int ival = invariant_values[*ep]; if(ival > cell->max_ival) { cell->max_ival = ival; cell->max_ival_count = 1; } else if(ival == cell->max_ival) { cell->max_ival_count++; } } } #ifdef BLISS_CONSISTENCY_CHECKS /* Verify max_ival info */ { unsigned int nof_zeros = 0; unsigned int max_ival = 0; unsigned int max_ival_count = 0; unsigned int *ep = elements + cell->first; for(unsigned int i = cell->length; i > 0; i--, ep++) { const unsigned int ival = invariant_values[*ep]; if(ival == 0) nof_zeros++; if(ival > max_ival) { max_ival = ival; max_ival_count = 1; } else if(ival == max_ival) max_ival_count++; } assert(max_ival == cell->max_ival); assert(max_ival_count == cell->max_ival_count); } #endif /* max_ival info has been computed */ if(cell->max_ival_count == cell->length) { /* All invariant values are the same, clear 'em */ if(cell->max_ival > 0) clear_ivs(cell); } else { /* All invariant values are not the same */ if(cell->max_ival == 1) { /* Specialized splitting for cells with binary invariant values */ last_new_cell = sort_and_split_cell1(cell); } else if(cell->max_ival < 256) { /* Specialized splitting for cells with invariant values < 256 */ last_new_cell = sort_and_split_cell255(cell, cell->max_ival); } else { /* Generic sorting and splitting */ const bool sorted = shellsort_cell(cell); assert(sorted); last_new_cell = split_cell(cell); } } cell->max_ival = 0; cell->max_ival_count = 0; return last_new_cell; } /* * * Component recursion specific code * */ void Partition::cr_init() { assert(bt_stack.empty()); cr_enabled = true; if(cr_cells) free(cr_cells); cr_cells = (CRCell*)malloc(N * sizeof(CRCell)); if(!cr_cells) {assert(false && "Mem out"); } if(cr_levels) free(cr_levels); cr_levels = (CRCell**)malloc(N * sizeof(CRCell*)); if(!cr_levels) {assert(false && "Mem out"); } for(unsigned int i = 0; i < N; i++) { cr_levels[i] = 0; cr_cells[i].level = UINT_MAX; cr_cells[i].next = 0; cr_cells[i].prev_next_ptr = 0; } for(const Cell *cell = first_cell; cell; cell = cell->next) cr_create_at_level_trailed(cell->first, 0); cr_max_level = 0; } void Partition::cr_free() { if(cr_cells) {free(cr_cells); cr_cells = 0; } if(cr_levels) {free(cr_levels); cr_levels = 0; } cr_created_trail.clear(); cr_splitted_level_trail.clear(); cr_bt_info.clear(); cr_max_level = 0; cr_enabled = false; } unsigned int Partition::cr_split_level(const unsigned int level, const std::vector& splitted_cells) { assert(cr_enabled); assert(level <= cr_max_level); cr_levels[++cr_max_level] = 0; cr_splitted_level_trail.push_back(level); for(unsigned int i = 0; i < splitted_cells.size(); i++) { const unsigned int cell_index = splitted_cells[i]; assert(cell_index < N); CRCell& cr_cell = cr_cells[cell_index]; assert(cr_cell.level == level); cr_cell.detach(); cr_create_at_level(cell_index, cr_max_level); } return cr_max_level; } unsigned int Partition::cr_get_backtrack_point() { assert(cr_enabled); CR_BTInfo info; info.created_trail_index = cr_created_trail.size(); info.splitted_level_trail_index = cr_splitted_level_trail.size(); cr_bt_info.push_back(info); return cr_bt_info.size()-1; } void Partition::cr_goto_backtrack_point(const unsigned int btpoint) { assert(cr_enabled); assert(btpoint < cr_bt_info.size()); while(cr_created_trail.size() > cr_bt_info[btpoint].created_trail_index) { const unsigned int cell_index = cr_created_trail.back(); cr_created_trail.pop_back(); CRCell& cr_cell = cr_cells[cell_index]; assert(cr_cell.level != UINT_MAX); assert(cr_cell.prev_next_ptr); cr_cell.detach(); } while(cr_splitted_level_trail.size() > cr_bt_info[btpoint].splitted_level_trail_index) { const unsigned int dest_level = cr_splitted_level_trail.back(); cr_splitted_level_trail.pop_back(); assert(cr_max_level > 0); assert(dest_level < cr_max_level); while(cr_levels[cr_max_level]) { CRCell *cr_cell = cr_levels[cr_max_level]; cr_cell->detach(); cr_create_at_level(cr_cell - cr_cells, dest_level); } cr_max_level--; } cr_bt_info.resize(btpoint); } void Partition::cr_create_at_level(const unsigned int cell_index, const unsigned int level) { assert(cr_enabled); assert(cell_index < N); assert(level < N); CRCell& cr_cell = cr_cells[cell_index]; assert(cr_cell.level == UINT_MAX); assert(cr_cell.next == 0); assert(cr_cell.prev_next_ptr == 0); if(cr_levels[level]) cr_levels[level]->prev_next_ptr = &(cr_cell.next); cr_cell.next = cr_levels[level]; cr_levels[level] = &cr_cell; cr_cell.prev_next_ptr = &cr_levels[level]; cr_cell.level = level; } void Partition::cr_create_at_level_trailed(const unsigned int cell_index, const unsigned int level) { assert(cr_enabled); cr_create_at_level(cell_index, level); cr_created_trail.push_back(cell_index); } } // namespace bliss opensmt-2.5.2/src/symmetry/bliss/partition.hh000066400000000000000000000202651445011647600213500ustar00rootroot00000000000000#ifndef BLISS_PARTITION_HH #define BLISS_PARTITION_HH /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ namespace bliss { class Partition; } #include #include #include #include "kstack.hh" #include "kqueue.hh" #include "heap.hh" #include "orbit.hh" #include "graph.hh" namespace bliss { /** \internal * \brief A class for refinable, backtrackable ordered partitions. * * This is rather a data structure with some helper functions than * a proper self-contained class. * That is, for efficiency reasons the fields of this class are directly * manipulated from bliss::AbstractGraph and its subclasses. * Conversely, some methods of this class modify the fields of * bliss::AbstractGraph, too. */ class Partition { public: /** * \brief Data structure for holding information about a cell in a Partition. */ class Cell { friend class Partition; public: unsigned int length; /* Index of the first element of the cell in the Partition::elements array */ unsigned int first; unsigned int max_ival; unsigned int max_ival_count; private: bool in_splitting_queue; public: bool in_neighbour_heap; /* Pointer to the next cell, null if this is the last one. */ Cell* next; Cell* prev; Cell* next_nonsingleton; Cell* prev_nonsingleton; unsigned int split_level; /** Is this a unit cell? */ bool is_unit() const {return(length == 1); } /** Is this cell in splitting queue? */ bool is_in_splitting_queue() const {return(in_splitting_queue); } }; private: /** \internal * Data structure for remembering information about splits in order to * perform efficient backtracking over the splits. */ class RefInfo { public: unsigned int split_cell_first; int prev_nonsingleton_first; int next_nonsingleton_first; }; /** \internal * A stack for remembering the splits, used for backtracking. */ KStack refinement_stack; class BacktrackInfo { public: unsigned int refinement_stack_size; unsigned int cr_backtrack_point; }; /** \internal * The main stack for enabling backtracking. */ std::vector bt_stack; public: AbstractGraph* graph; /* Used during equitable partition refinement */ KQueue splitting_queue; void splitting_queue_add(Cell* const cell); Cell* splitting_queue_pop(); bool splitting_queue_is_empty() const; void splitting_queue_clear(); /** Type for backtracking points. */ typedef unsigned int BacktrackPoint; /** * Get a new backtrack point for the current partition */ BacktrackPoint set_backtrack_point(); /** * Backtrack to the point \a p and remove it. */ void goto_backtrack_point(BacktrackPoint p); /** * Split the non-unit Cell \a cell = {\a element,e1,e2,...,en} containing * the element \a element in two: * \a cell = {e1,...,en} and \a newcell = {\a element}. * @param cell a non-unit Cell * @param element an element in \a cell * @return the new unit Cell \a newcell */ Cell* individualize(Cell* const cell, const unsigned int element); Cell* aux_split_in_two(Cell* const cell, const unsigned int first_half_size); private: unsigned int N; Cell* cells; Cell* free_cells; unsigned int discrete_cell_count; public: Cell* first_cell; Cell* first_nonsingleton_cell; unsigned int *elements; /* invariant_values[e] gives the invariant value of the element e */ unsigned int *invariant_values; /* element_to_cell_map[e] gives the cell of the element e */ Cell **element_to_cell_map; /** Get the cell of the element \a e */ Cell* get_cell(const unsigned int e) const { return element_to_cell_map[e]; } /* in_pos[e] points to the elements array s.t. *in_pos[e] = e */ unsigned int **in_pos; Partition(); ~Partition(); /** * Initialize the partition to the unit partition (all elements in one cell) * over the \a N > 0 elements {0,...,\a N-1}. */ void init(const unsigned int N); /** * Returns true iff the partition is discrete, meaning that all * the elements are in their own cells. */ bool is_discrete() const {return(free_cells == 0); } unsigned int nof_discrete_cells() const {return(discrete_cell_count); } /** * Print the partition into the file stream \a fp. */ size_t print(FILE* const fp, const bool add_newline = true) const; /** * Print the partition cell sizes into the file stream \a fp. */ size_t print_signature(FILE* const fp, const bool add_newline = true) const; /* * Splits the Cell \a cell into [cell_1,...,cell_n] * according to the invariant_values of the elements in \a cell. * After splitting, cell_1 == \a cell. * Returns the pointer to the Cell cell_n; * cell_n != cell iff the Cell \a cell was actually splitted. * The flag \a max_ival_info_ok indicates whether the max_ival and * max_ival_count fields of the Cell \a cell have consistent values * when the method is called. * Clears the invariant values of elements in the Cell \a cell as well as * the max_ival and max_ival_count fields of the Cell \a cell. */ Cell *zplit_cell(Cell * const cell, const bool max_ival_info_ok); /* * Routines for component recursion */ void cr_init(); void cr_free(); unsigned int cr_get_level(const unsigned int cell_index) const; unsigned int cr_split_level(const unsigned int level, const std::vector& cells); /** Clear the invariant_values of the elements in the Cell \a cell. */ void clear_ivs(Cell* const cell); private: /* * Component recursion data structures */ /* Is component recursion support in use? */ bool cr_enabled; class CRCell { public: unsigned int level; CRCell* next; CRCell** prev_next_ptr; void detach() { if(next) next->prev_next_ptr = prev_next_ptr; *(prev_next_ptr) = next; level = UINT_MAX; next = 0; prev_next_ptr = 0; } }; CRCell* cr_cells; CRCell** cr_levels; class CR_BTInfo { public: unsigned int created_trail_index; unsigned int splitted_level_trail_index; }; std::vector cr_created_trail; std::vector cr_splitted_level_trail; std::vector cr_bt_info; unsigned int cr_max_level; void cr_create_at_level(const unsigned int cell_index, unsigned int level); void cr_create_at_level_trailed(const unsigned int cell_index, unsigned int level); unsigned int cr_get_backtrack_point(); void cr_goto_backtrack_point(const unsigned int btpoint); /* * * Auxiliary routines for sorting and splitting cells * */ Cell* sort_and_split_cell1(Cell* cell); Cell* sort_and_split_cell255(Cell* const cell, const unsigned int max_ival); bool shellsort_cell(Cell* cell); Cell* split_cell(Cell* const cell); /* * Some auxiliary stuff needed for distribution count sorting. * To make the code thread-safe (modulo the requirement that each graph is * only accessed in one thread at a time), the arrays are owned by * the partition instance, not statically defined. */ unsigned int dcs_count[256]; unsigned int dcs_start[256]; void dcs_cumulate_count(const unsigned int max); }; inline Partition::Cell* Partition::splitting_queue_pop() { Cell* const cell = splitting_queue.pop_front(); cell->in_splitting_queue = false; return cell; } inline bool Partition::splitting_queue_is_empty() const { return splitting_queue.is_empty(); } inline unsigned int Partition::cr_get_level(const unsigned int cell_index) const { return(cr_cells[cell_index].level); } } // namespace bliss #endif opensmt-2.5.2/src/symmetry/bliss/timer.cc000066400000000000000000000024211445011647600204370ustar00rootroot00000000000000#include #include #include "timer.hh" /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ namespace bliss { static const double numTicksPerSec = (double)(sysconf(_SC_CLK_TCK)); Timer::Timer() { reset(); } void Timer::reset() { struct tms clkticks; times(&clkticks); start_time = ((double) clkticks.tms_utime + (double) clkticks.tms_stime) / numTicksPerSec; } double Timer::get_duration() { struct tms clkticks; times(&clkticks); double intermediate = ((double) clkticks.tms_utime + (double) clkticks.tms_stime) / numTicksPerSec; return intermediate - start_time; } } // namespace bliss opensmt-2.5.2/src/symmetry/bliss/timer.hh000066400000000000000000000022531445011647600204540ustar00rootroot00000000000000#ifndef BLISS_TIMER_HH #define BLISS_TIMER_HH /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ namespace bliss { /** \internal * \brief A very simple wrapper class for measuring elapsed user+system time. */ class Timer { double start_time; public: /** * Create and start a new timer. */ Timer(); /** * Reset the timer. */ void reset(); /** * Get the user+system time (in seconds) elapsed since the creation or * the last reset() call of the timer. */ double get_duration(); }; } // namespace bliss #endif opensmt-2.5.2/src/symmetry/bliss/uintseqhash.cc000066400000000000000000000104561445011647600216620ustar00rootroot00000000000000#include "uintseqhash.hh" /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ namespace bliss { /* * Random bits generated by * http://www.fourmilab.ch/hotbits/ */ static unsigned int rtab[256] = { 0xAEAA35B8, 0x65632E16, 0x155EDBA9, 0x01349B39, 0x8EB8BD97, 0x8E4C5367, 0x8EA78B35, 0x2B1B4072, 0xC1163893, 0x269A8642, 0xC79D7F6D, 0x6A32DEA0, 0xD4D2DA56, 0xD96D4F47, 0x47B5F48A, 0x2587C6BF, 0x642B71D8, 0x5DBBAF58, 0x5C178169, 0xA16D9279, 0x75CDA063, 0x291BC48B, 0x01AC2F47, 0x5416DF7C, 0x45307514, 0xB3E1317B, 0xE1C7A8DE, 0x3ACDAC96, 0x11B96831, 0x32DE22DD, 0x6A1DA93B, 0x58B62381, 0x283810E2, 0xBC30E6A6, 0x8EE51705, 0xB06E8DFB, 0x729AB12A, 0xA9634922, 0x1A6E8525, 0x49DD4E19, 0xE5DB3D44, 0x8C5B3A02, 0xEBDE2864, 0xA9146D9F, 0x736D2CB4, 0xF5229F42, 0x712BA846, 0x20631593, 0x89C02603, 0xD5A5BF6A, 0x823F4E18, 0x5BE5DEFF, 0x1C4EBBFA, 0x5FAB8490, 0x6E559B0C, 0x1FE528D6, 0xB3198066, 0x4A965EB5, 0xFE8BB3D5, 0x4D2F6234, 0x5F125AA4, 0xBCC640FA, 0x4F8BC191, 0xA447E537, 0xAC474D3C, 0x703BFA2C, 0x617DC0E7, 0xF26299D7, 0xC90FD835, 0x33B71C7B, 0x6D83E138, 0xCBB1BB14, 0x029CF5FF, 0x7CBD093D, 0x4C9825EF, 0x845C4D6D, 0x124349A5, 0x53942D21, 0x800E60DA, 0x2BA6EB7F, 0xCEBF30D3, 0xEB18D449, 0xE281F724, 0x58B1CB09, 0xD469A13D, 0x9C7495C3, 0xE53A7810, 0xA866C08E, 0x832A038B, 0xDDDCA484, 0xD5FE0DDE, 0x0756002B, 0x2FF51342, 0x60FEC9C8, 0x061A53E3, 0x47B1884E, 0xDC17E461, 0xA17A6A37, 0x3158E7E2, 0xA40D873B, 0x45AE2140, 0xC8F36149, 0x63A4EE2D, 0xD7107447, 0x6F90994F, 0x5006770F, 0xC1F3CA9A, 0x91B317B2, 0xF61B4406, 0xA8C9EE8F, 0xC6939B75, 0xB28BBC3B, 0x36BF4AEF, 0x3B12118D, 0x4D536ECF, 0x9CF4B46B, 0xE8AB1E03, 0x8225A360, 0x7AE4A130, 0xC4EE8B50, 0x50651797, 0x5BB4C59F, 0xD120EE47, 0x24F3A386, 0xBE579B45, 0x3A378EFC, 0xC5AB007B, 0x3668942B, 0x2DBDCC3A, 0x6F37F64C, 0xC24F862A, 0xB6F97FCF, 0x9E4FA23D, 0x551AE769, 0x46A8A5A6, 0xDC1BCFDD, 0x8F684CF9, 0x501D811B, 0x84279F80, 0x2614E0AC, 0x86445276, 0xAEA0CE71, 0x0812250F, 0xB586D18A, 0xC68D721B, 0x44514E1D, 0x37CDB99A, 0x24731F89, 0xFA72E589, 0x81E6EBA2, 0x15452965, 0x55523D9D, 0x2DC47E14, 0x2E7FA107, 0xA7790F23, 0x40EBFDBB, 0x77E7906B, 0x6C1DB960, 0x1A8B9898, 0x65FA0D90, 0xED28B4D8, 0x34C3ED75, 0x768FD2EC, 0xFAB60BCB, 0x962C75F4, 0x304F0498, 0x0A41A36B, 0xF7DE2A4A, 0xF4770FE2, 0x73C93BBB, 0xD21C82C5, 0x6C387447, 0x8CDB4CB9, 0x2CC243E8, 0x41859E3D, 0xB667B9CB, 0x89681E8A, 0x61A0526C, 0x883EDDDC, 0x539DE9A4, 0xC29E1DEC, 0x97C71EC5, 0x4A560A66, 0xBD7ECACF, 0x576AE998, 0x31CE5616, 0x97172A6C, 0x83D047C4, 0x274EA9A8, 0xEB31A9DA, 0x327209B5, 0x14D1F2CB, 0x00FE1D96, 0x817DBE08, 0xD3E55AED, 0xF2D30AFC, 0xFB072660, 0x866687D6, 0x92552EB9, 0xEA8219CD, 0xF7927269, 0xF1948483, 0x694C1DF5, 0xB7D8B7BF, 0xFFBC5D2F, 0x2E88B849, 0x883FD32B, 0xA0331192, 0x8CB244DF, 0x41FAF895, 0x16902220, 0x97FB512A, 0x2BEA3CC4, 0xAF9CAE61, 0x41ACD0D5, 0xFD2F28FF, 0xE780ADFA, 0xB3A3A76E, 0x7112AD87, 0x7C3D6058, 0x69E64FFF, 0xE5F8617C, 0x8580727C, 0x41F54F04, 0xD72BE498, 0x653D1795, 0x1275A327, 0x14B499D4, 0x4E34D553, 0x4687AA39, 0x68B64292, 0x5C18ABC3, 0x41EABFCC, 0x92A85616, 0x82684CF8, 0x5B9F8A4E, 0x35382FFE, 0xFB936318, 0x52C08E15, 0x80918B2E, 0x199EDEE0, 0xA9470163, 0xEC44ACDD, 0x612D6735, 0x8F88EA7D, 0x759F5EA4, 0xE5CC7240, 0x68CFEB8B, 0x04725601, 0x0C22C23E, 0x5BC97174, 0x89965841, 0x5D939479, 0x690F338A, 0x3C2D4380, 0xDAE97F2B }; void UintSeqHash::update(unsigned int i) { i++; while(i > 0) { h ^= rtab[i & 0xff]; #if 1 const unsigned int b = (h & 0x80000000) >> 31; i = i >> 8; h = (h << 1) | b; #else const unsigned int b = h & 0x80000000; h = h << 1; if(b != 0) h++; i = i >> 8; #endif } } } // namespace bliss opensmt-2.5.2/src/symmetry/bliss/uintseqhash.hh000066400000000000000000000036531445011647600216750ustar00rootroot00000000000000#ifndef BLISS_UINTSEQHASH_HH #define BLISS_UINTSEQHASH_HH #include /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ namespace bliss { /** \internal * \brief A hash for sequences of unsigned ints. */ class UintSeqHash { protected: unsigned int h; public: UintSeqHash() {h = 0; } UintSeqHash(const UintSeqHash &other) {h = other.h; } UintSeqHash& operator=(const UintSeqHash &other) {h = other.h; return *this; } /** Reset the hash value. */ void reset() {h = 0; } /** Add the unsigned int \a n to the sequence. */ void update(unsigned int n); /** Get the hash value of the sequence seen so far. */ unsigned int get_value() const {return h; } /** Compare the hash values of this and \a other. * Return -1/0/1 if the value of this is smaller/equal/greater than * that of \a other. */ int cmp(const UintSeqHash &other) const { return (h < other.h)?-1:((h == other.h)?0:1); } /** An abbreviation for cmp(other) < 0 */ bool is_lt(const UintSeqHash &other) const {return(cmp(other) < 0); } /** An abbreviation for cmp(other) <= 0 */ bool is_le(const UintSeqHash &other) const {return(cmp(other) <= 0); } /** An abbreviation for cmp(other) == 0 */ bool is_equal(const UintSeqHash &other) const {return(cmp(other) == 0); } }; } // namespace bliss #endif opensmt-2.5.2/src/symmetry/bliss/utils.cc000066400000000000000000000051501445011647600204610ustar00rootroot00000000000000#include #include #include "utils.hh" /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ namespace bliss { void print_permutation(FILE* const fp, const unsigned int N, const unsigned int* perm, const unsigned int offset) { assert(N > 0); assert(perm); for(unsigned int i = 0; i < N; i++) { unsigned int j = perm[i]; if(j == i) continue; bool is_first = true; while(j != i) { if(j < i) { is_first = false; break; } j = perm[j]; } if(!is_first) continue; fprintf(fp, "(%u,", i+offset); j = perm[i]; while(j != i) { fprintf(fp, "%u", j+offset); j = perm[j]; if(j != i) fprintf(fp, ","); } fprintf(fp, ")"); } } void print_permutation(FILE* const fp, const std::vector& perm, const unsigned int offset) { const unsigned int N = perm.size(); for(unsigned int i = 0; i < N; i++) { unsigned int j = perm[i]; if(j == i) continue; bool is_first = true; while(j != i) { if(j < i) { is_first = false; break; } j = perm[j]; } if(!is_first) continue; fprintf(fp, "(%u,", i+offset); j = perm[i]; while(j != i) { fprintf(fp, "%u", j+offset); j = perm[j]; if(j != i) fprintf(fp, ","); } fprintf(fp, ")"); } } bool is_permutation(const unsigned int N, const unsigned int* perm) { if(N == 0) return true; std::vector m(N, false); for(unsigned int i = 0; i < N; i++) { if(perm[i] >= N) return false; if(m[perm[i]]) return false; m[perm[i]] = true; } return true; } bool is_permutation(const std::vector& perm) { const unsigned int N = perm.size(); if(N == 0) return true; std::vector m(N, false); for(unsigned int i = 0; i < N; i++) { if(perm[i] >= N) return false; if(m[perm[i]]) return false; m[perm[i]] = true; } return true; } } // namespace bliss opensmt-2.5.2/src/symmetry/bliss/utils.hh000066400000000000000000000037141445011647600204770ustar00rootroot00000000000000#ifndef BLISS_UTILS_HH #define BLISS_UTILS_HH /* Copyright (c) 2006-2011 Tommi Junttila Released under the GNU General Public License version 3. This file is part of bliss. bliss is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. bliss 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Foobar. If not, see . */ /** * \file * \brief Some small utilities. * */ #include namespace bliss { /** * Print the permutation \a perm of {0,...,N-1} in the cycle format * in the file stream \a fp. * The amount \a offset is added to each element before printing, * e.g. the permutation (2 4) is printed as (3 5) when \a offset is 1. */ void print_permutation(FILE *fp, const unsigned int N, const unsigned int *perm, const unsigned int offset = 0); /** * Print the permutation \a perm of {0,...,N-1} in the cycle format * in the file stream \a fp. * The amount \a offset is added to each element before printing, * e.g. the permutation (2 4) is printed as (3 5) when \a offset is 1. */ void print_permutation(FILE *fp, const std::vector& perm, const unsigned int offset = 0); /** * Check whether \a perm is a valid permutation on {0,...,N-1}. * Slow, mainly for debugging and validation purposes. */ bool is_permutation(const unsigned int N, const unsigned int* perm); /** * Check whether \a perm is a valid permutation on {0,...,N-1}. * Slow, mainly for debugging and validation purposes. */ bool is_permutation(const std::vector& perm); } // namespace bliss #endif opensmt-2.5.2/src/tsolvers/000077500000000000000000000000001445011647600156655ustar00rootroot00000000000000opensmt-2.5.2/src/tsolvers/ArrayTHandler.cc000066400000000000000000000010151445011647600206710ustar00rootroot00000000000000/* * Copyright (c) 2021, Martin Blicha * * SPDX-License-Identifier: MIT */ #include "ArrayTHandler.h" #include "InterpolatingEgraph.h" ArrayTHandler::ArrayTHandler(SMTConfig & c, Logic & l) : TSolverHandler(c) , logic(l) { egraph = config.produce_inter() > 0 ? new InterpolatingEgraph(config, logic) : new Egraph(config, logic); arraySolver = new ArraySolver(logic, *egraph, c); setSolverSchedule({egraph, arraySolver}); } opensmt-2.5.2/src/tsolvers/ArrayTHandler.h000066400000000000000000000013621445011647600205400ustar00rootroot00000000000000/* * Copyright (c) 2021, Martin Blicha * * SPDX-License-Identifier: MIT */ #ifndef OPENSMT_ARRAYTHANDLER_H #define OPENSMT_ARRAYTHANDLER_H #include "ArraySolver.h" #include "TSolverHandler.h" class ArrayTHandler : public TSolverHandler { Logic & logic; Egraph * egraph; ArraySolver * arraySolver; public: ArrayTHandler(SMTConfig & c, Logic & l); ~ArrayTHandler() override = default; Logic & getLogic() override { return logic; }; Logic const & getLogic() const override { return logic; } PTRef getInterpolant(const ipartitions_t & , ItpColorMap *, PartitionManager &) override { throw OsmtInternalException("Interpolation not supported yet"); }; }; #endif //OPENSMT_ARRAYTHANDLER_H opensmt-2.5.2/src/tsolvers/CMakeLists.txt000066400000000000000000000022421445011647600204250ustar00rootroot00000000000000add_library(tsolvers OBJECT "") target_sources(tsolvers PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/Deductions.h" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/Deductions.cc" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/TSolverHandler.h" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/TSolver.h" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/TResult.h" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/CUFTHandler.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/IDLTHandler.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/RDLTHandler.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/LATHandler.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/THandler.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/TSolverHandler.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/UFLATHandler.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/UFTHandler.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/TSolver.cc" PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/ArrayTHandler.cc" ) include(egraph/CMakeLists.txt) include(lasolver/CMakeLists.txt) include(bvsolver/CMakeLists.txt) include(stpsolver/CMakeLists.txt) include(axdiffsolver/CMakeLists.txt) install(FILES Deductions.h UFTHandler.h CUFTHandler.h LATHandler.h IDLTHandler.h RDLTHandler.h TSolver.h THandler.h TSolverHandler.h TResult.h DESTINATION ${INSTALL_HEADERS_DIR}) opensmt-2.5.2/src/tsolvers/CUFTHandler.cc000066400000000000000000000003501445011647600202310ustar00rootroot00000000000000#include "CUFTHandler.h" #include "CUFLogic.h" CUFTHandler::CUFTHandler(SMTConfig & c, CUFLogic & l) : UFTHandler(c, l) , logic(l) {} CUFTHandler::~CUFTHandler() {} CUFLogic& CUFTHandler::getLogic() { return logic; } opensmt-2.5.2/src/tsolvers/CUFTHandler.h000066400000000000000000000031301445011647600200720ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2017 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #ifndef CUFTHandler_h #define CUFTHandler_h #include "UFTHandler.h" #include "CUFLogic.h" class CUFTHandler : public UFTHandler { private: CUFLogic& logic; public: CUFTHandler(SMTConfig & c, CUFLogic & l); virtual ~CUFTHandler(); virtual CUFLogic& getLogic(); }; #endif opensmt-2.5.2/src/tsolvers/Deductions.cc000066400000000000000000000001601445011647600202720ustar00rootroot00000000000000#include "Deductions.h" //static SolverId SolverId_Undef = {UINT32_MAX}; uint32_t SolverDescr::id_counter = 0; opensmt-2.5.2/src/tsolvers/Deductions.h000066400000000000000000000053651445011647600201500ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #ifndef DEDUCTIONS_H #define DEDUCTIONS_H #include "SolverTypes.h" struct SolverId { uint32_t id; bool operator== (const SolverId id2) const { return id == id2.id; } bool operator!= (const SolverId id2) const { return id != id2.id; } }; static const SolverId SolverId_Undef = {UINT32_MAX}; class SolverDescr { protected: static uint32_t id_counter; const SolverId id; const char* name; const char* description; public: SolverDescr(const char* name_, const char* desc_) : id({id_counter++}) , name(name_) , description(desc_) { getSolverList().push(this); } static vec& getSolverList() { static vec options; return options; } operator SolverId (void) const { return id; } operator const char* (void) const { return name; } }; //struct DedElem { // DedElem(SolverId id, lbool p) : deducedBy(id), polarity(p) {} // SolverId deducedBy; // lbool polarity; // bool operator== (const lbool l) const { return l == polarity; } // bool operator!= (const lbool l) const { return l != polarity; } // bool operator== (const SolverId id) const { return id == deducedBy; } // bool operator!=(const SolverId id) const { return id != deducedBy; } //}; // ////static DedElem DedElem_Undef = {SolverId_Undef, l_Undef}; //static DedElem DedElem_Undef(SolverId_Undef, l_Undef); #endif opensmt-2.5.2/src/tsolvers/IDLTHandler.cc000066400000000000000000000007001445011647600202230ustar00rootroot00000000000000// // Created by Martin Blicha on 10.05.20. // #include "IDLTHandler.h" #include "ArithLogic.h" #include "IDLSolver.h" #include "TreeOps.h" IDLTHandler::IDLTHandler(SMTConfig& c, ArithLogic& l) : TSolverHandler(c) , logic(l) { idlsolver = new IDLSolver(config, logic); setSolverSchedule({idlsolver}); } Logic &IDLTHandler::getLogic() { return logic; } const Logic &IDLTHandler::getLogic() const { return logic; }opensmt-2.5.2/src/tsolvers/IDLTHandler.h000066400000000000000000000013231445011647600200670ustar00rootroot00000000000000// // Created by Martin Blicha on 10.05.20. // #ifndef OPENSMT_IDLTHANDLER_H #define OPENSMT_IDLTHANDLER_H #include "TSolverHandler.h" class ArithLogic; class IDLSolver; class IDLTHandler : public TSolverHandler { private: ArithLogic& logic; IDLSolver *idlsolver; public: IDLTHandler(SMTConfig& c, ArithLogic& l); virtual ~IDLTHandler() = default; virtual Logic& getLogic() override; virtual const Logic& getLogic() const override; // virtual lbool getPolaritySuggestion(PTRef) const override; virtual PTRef getInterpolant(const ipartitions_t&, ItpColorMap *, PartitionManager&) override { throw std::logic_error("Not implemented yet"); } }; #endif //OPENSMT_IDLTHANDLER_H opensmt-2.5.2/src/tsolvers/LATHandler.cc000066400000000000000000000016611445011647600201160ustar00rootroot00000000000000// // Created by Antti on 21.10.21. // #include "LATHandler.h" #include "TreeOps.h" #include "LASolver.h" #include "OsmtInternalException.h" LATHandler::LATHandler(SMTConfig & c, ArithLogic & l) : TSolverHandler(c) , logic(l) { lasolver = new LASolver(config, logic); setSolverSchedule({lasolver}); } PTRef LATHandler::getInterpolant(ipartitions_t const & mask, ItpColorMap * labels, PartitionManager & pmanager) { if (logic.hasReals() and not logic.hasIntegers()) { return lasolver->getRealInterpolant(mask, labels, pmanager); } else if (logic.hasIntegers() and not logic.hasReals()) { if (labels == nullptr) { throw OsmtInternalException("LIA interpolation requires partitioning map, but no map was provided"); } return lasolver->getIntegerInterpolant(*labels); } else { throw OsmtInternalException("Mixed arithmetic interpolation not supported yet"); } } opensmt-2.5.2/src/tsolvers/LATHandler.h000066400000000000000000000016001445011647600177510ustar00rootroot00000000000000/* * Copyright (c) 2021, Antti Hyvarinen * Copyright (c) 2021, Martin Blicha * * SPDX-License-Identifier: MIT */ #ifndef OPENSMT_LATHANDLER_H #define OPENSMT_LATHANDLER_H #include "TSolverHandler.h" #include "ArithLogic.h" #include "LASolver.h" class LATHandler : public TSolverHandler { private: ArithLogic & logic; LASolver * lasolver; public: LATHandler(SMTConfig & c, ArithLogic & l); virtual ~LATHandler() = default; virtual Logic & getLogic() override { return logic; } virtual Logic const & getLogic() const override { return logic; } virtual lbool getPolaritySuggestion(PTRef p) const override { return lasolver->getPolaritySuggestion(p); } virtual PTRef getInterpolant(ipartitions_t const & mask, ItpColorMap * labels, PartitionManager & pmanager) override; }; #endif //OPENSMT_LATHANDLER_H opensmt-2.5.2/src/tsolvers/RDLTHandler.cc000066400000000000000000000005751445011647600202460ustar00rootroot00000000000000#include "RDLTHandler.h" #include "ArithLogic.h" #include "RDLSolver.h" RDLTHandler::RDLTHandler(SMTConfig &c, ArithLogic &l) : TSolverHandler(c) , logic(l) { rdlsolver = new RDLSolver(config, logic); setSolverSchedule({rdlsolver}); } Logic &RDLTHandler::getLogic() { return logic; } const Logic &RDLTHandler::getLogic() const { return logic; } opensmt-2.5.2/src/tsolvers/RDLTHandler.h000066400000000000000000000011131445011647600200750ustar00rootroot00000000000000#ifndef OPENSMT_RDLTHANDLER_H #define OPENSMT_RDLTHANDLER_H #include "TSolverHandler.h" class ArithLogic; class RDLSolver; class RDLTHandler : public TSolverHandler { private: ArithLogic& logic; RDLSolver *rdlsolver; public: RDLTHandler(SMTConfig &c, ArithLogic &l); virtual ~RDLTHandler() = default; Logic &getLogic() override; const Logic &getLogic() const override; PTRef getInterpolant(const ipartitions_t &, ItpColorMap *, PartitionManager&) override { throw std::logic_error("Not implemented yet"); } }; #endif //OPENSMT_RDLTHANDLER_H opensmt-2.5.2/src/tsolvers/THandler.cc000066400000000000000000000276711445011647600177120ustar00rootroot00000000000000/* * Copyright (c) 2008-2012 Roberto Bruttomesso * Copyright (c) 2012-2022, Antti Hyvarinen * Copyright (c) 2022, Martin Blicha * * SPDX-License-Identifier: MIT */ #include "THandler.h" #include "TSolver.h" #include "ModelBuilder.h" #include #include #include #include void THandler::backtrack(int lev) { unsigned int backTrackPointsCounter = 0; // Undoes the state of theory atoms if needed while ( (int)stack.size( ) > (lev > 0 ? lev : 0) ) { PTRef e = stack.last(); stack.pop(); // It was var_True or var_False if (e == getLogic().getTerm_true() || e == getLogic().getTerm_false()) continue; assert(isDeclared(var(PTRefToLit(e))) == getLogic().isTheoryTerm(e)); if (not isDeclared(var(PTRefToLit(e)))) continue; ++backTrackPointsCounter; } for (auto solver : getSolverHandler().solverSchedule) { solver->popBacktrackPoints(backTrackPointsCounter); } checked_trail_size = stack.size( ); } // Push newly found literals from trail to the solvers bool THandler::assertLits(const vec & trail) { bool res = true; assert( checked_trail_size == stack.size_( ) ); assert( (int)stack.size( ) <= trail.size( ) ); #ifdef PEDANTIC_DEBUG vec assertions; #endif for ( int i = checked_trail_size; i < trail.size( ) && (res != false); i ++ ) { const Lit l = trail[ i ]; const Var v = var( l ); PTRef pt_r = tmap.varToPTRef(v); stack.push( pt_r ); assert(isDeclared(v) == getLogic().isTheoryTerm(pt_r)); if (not isDeclared(v)) continue; assert(getLogic().isTheoryTerm(pt_r)); if ( pt_r == getLogic().getTerm_true() ) { assert(sign(l) == false); continue; } else if ( pt_r == getLogic().getTerm_false() ) { assert(sign(l) == true ); continue; } res = assertLit(PtAsgn(pt_r, sign(l) ? l_False : l_True)); } checked_trail_size = stack.size( ); return res; } // Check the assignment with equality solver TRes THandler::check(bool complete) { return getSolverHandler().check(complete); // if ( complete && config.certification_level > 2 ) // verifyCallWithExternalTool( res, trail.size( ) - 1 ); } std::vector> THandler::getNewSplits() { vec newSplits = getSolverHandler().getSplitClauses(); std::vector> splitClauses; if (newSplits.size() == 0) { return splitClauses; } assert((std::unordered_set{newSplits.begin(), newSplits.end()}.size() == newSplits.size_())); // No duplicates in splits Logic const & logic = getLogic(); auto processLiteral = [&](PTRef litTerm){ Lit l = tmap.getOrCreateLit(litTerm); PTRef atomTerm = logic.isNot(litTerm) ? logic.getPterm(litTerm)[0] : litTerm; assert(getLogic().isAtom(atomTerm)); // MB: Needs to be an atom, otherwise the declaration would not work. declareAtom(atomTerm); informNewSplit(atomTerm); splitClauses.back().push(l); }; for (PTRef clause : newSplits) { splitClauses.emplace_back(); if (logic.isAtom(clause)) { processLiteral(clause); } else if (logic.isOr(clause)) { for (int i = 0; i < logic.getPterm(clause).size(); i++) { PTRef litTerm = logic.getPterm(clause)[i]; processLiteral(litTerm); } } else { assert(false); } } return splitClauses; } // // Return the conflict generated by a theory solver // void THandler::getConflict ( vec & conflict , vec& vardata , int & max_decision_level ) { // First of all, the explanation in a tsolver is // stored as conjunction of enodes e1,...,en // with associated polarities p1,...,pn. Since the sat-solver // wants a clause we store it in the form ( l1 | ... | ln ) // where li is the literal corresponding with ei with polarity !pi vec explanation; { bool found = false; for (auto solver : getSolverHandler().solverSchedule) { if (solver->hasExplanation()) { solver->getConflict(explanation); found = true; break; } } (void)found; assert(found); } if (explanation.size() == 0) { max_decision_level = 0; return; } max_decision_level = -1; for (int i = 0; i < explanation.size(); ++i) { PtAsgn const & ei = explanation[i]; assert(ei.sgn == l_True || ei.sgn == l_False); Var v = ptrefToVar(ei.tr); assert(v != var_Undef); bool negate = ei.sgn == l_False; Lit l = mkLit(v, !negate); conflict.push(l); if (max_decision_level < vardata[v].level) { max_decision_level = vardata[v].level; } } } PTRef THandler::getInterpolant(const ipartitions_t& mask, ItpColorMap * labels, PartitionManager &pmanager) { return getSolverHandler().getInterpolant(mask, labels, pmanager); } // // It is in principle possible that the egraph contains deduceable literals // that the SAT solver is not aware of because they have been simplified due to // appearing only in clauses that are tautological. We check this here, but it // would be better to remove them from egraph after simplifications are done. // Lit THandler::getDeduction() { PtAsgn_reason e = PtAsgn_reason_Undef; while (true) { for (auto solver : getSolverHandler().solverSchedule) { e = solver->getDeduction(); if (e.tr != PTRef_Undef) break; } if ( e.tr == PTRef_Undef ) { return lit_Undef; } //assert(e.reason != PTRef_Undef); //assert(e.sgn != l_Undef); #ifdef PEDANTIC_DEBUG if (!tmap.hasLit(e.tr)) cerr << "Missing (optimized) deduced literal ignored: " << getLogic().printTerm(e.tr) << '\n'; #endif if (!tmap.hasLit(e.tr)) continue; break; } return e.sgn == l_True ? tmap.getLit(e.tr) : ~tmap.getLit(e.tr); } Lit THandler::getSuggestion( ) { PTRef e = PTRef_Undef; // egraph.getSuggestion( ); if ( e == PTRef_Undef ) return lit_Undef; // bool negate = e->getDecPolarity( ) == l_False; // Var v = enodeToVar( e ); // return Lit( v, negate ); return tmap.getLit(e); } void THandler::getReason( Lit l, vec< Lit > & reason) { Var v = var(l); PTRef e = tmap.varToPTRef(v); // It must be a TAtom and already deduced assert(getLogic().isTheoryTerm(e)); TSolver* solver = getSolverHandler().getReasoningSolverFor(e); assert(solver); // Get Explanation vec explanation = solver->getReasonFor(PtAsgn(e, sign(l) ? l_False : l_True)); assert(explanation.size() > 0); // Reserve room for implied lit reason.push( lit_Undef ); // Copy explanation while ( explanation.size() > 0 ) { PtAsgn pa = explanation.last(); PTRef ei = pa.tr; explanation.pop(); // Toggle polarity for deduced literal if ( e == ei ) { // The deduced literal must have been pushed // with the the same polarity that has been deduced assert((pa.sgn == l_True && sign(l)) || (pa.sgn == l_False && !sign(l))); // The literal is true (sign false) iff the egraph term polarity is false reason[0] = l; } else { assert(pa.sgn != l_Undef); reason.push(pa.sgn == l_True ? ~tmap.getLit(ei) : tmap.getLit(ei)); // Swap the sign for others } } } #ifdef PEDANTIC_DEBUG bool THandler::isOnTrail( Lit l, vec& trail ) { for ( int i = 0 ; i < trail.size( ) ; i ++ ) if ( trail[ i ] == l ) return true; return false; } #endif char* THandler::printAsrtClause(vec& r) { std::stringstream os; for (int i = 0; i < r.size(); i++) { Var v = var(r[i]); bool sgn = sign(r[i]); os << (sgn ? "not " : "") << getLogic().printTerm(tmap.varToPTRef(v)) << " "; } return strdup(os.str().c_str()); } char* THandler::printAsrtClause(Clause* c) { vec v; for (unsigned i = 0; i < c->size(); i++) v.push((*c)[i]); return printAsrtClause(v); } bool THandler::checkTrailConsistency(vec& trail) { (void)trail; assert(trail.size() >= stack.size()); // There might be extra stuff // because of conflicting assignments for (int i = 0; i < stack.size(); i++) { assert(var(trail[i]) == var(tmap.getLit(stack[i]))); // || // (stack[i] == logic.getTerm_false() && // trail[i] == ~tmap.getLit(stack[i]))); } return true; } #ifdef PEDANTIC_DEBUG std::string THandler::printAssertion(Lit assertion) { stringstream os; os << "; assertions "; Var v = var(assertion); PTRef pt_r = tmap.varToPTRef(v); if (sign(assertion)) os << "!"; os << getLogic().term_store.printTerm(pt_r, true) << "[var " << v << "] " << '\n'; return os.str(); } //std::string THandler::printExplanation(vec& explanation, vec& assigns) { // stringstream os; // os << "; Conflict: "; // for ( int i = 0 ; i < explanation.size( ) ; i ++ ) { // if ( i > 0 ) // os << ", "; // Var v = tmap.getVar(explanation[i].tr); // lbool val = toLbool(assigns[v]); // assert(val != l_Undef); // if ( val == l_False ) // os << "!"; // // os << getLogic().term_store.printTerm(explanation[i].tr); // os << "[var " << v << "]"; // } // os << '\n'; // return os.str(); //} #endif void THandler::clear() { declared.clear(); getSolverHandler().clearSolver(); } // Clear the solvers from their states Theory& THandler::getTheory() { return theory; } Logic& THandler::getLogic() { return theory.getLogic(); } TSolverHandler& THandler::getSolverHandler() { return theory.getTSolverHandler(); } const TSolverHandler& THandler::getSolverHandler() const { return theory.getTSolverHandler(); } TermMapper& THandler::getTMap() { return tmap; } void THandler::fillTheoryFunctions(ModelBuilder &modelBuilder) const { getSolverHandler().fillTheoryFunctions(modelBuilder); } PTRef THandler::varToTerm ( Var v ) const { return tmap.varToPTRef(v); } // Return the term ref corresponding to a variable Pterm& THandler::varToPterm ( Var v) { return getLogic().getPterm(tmap.varToPTRef(v)); } // Return the term corresponding to a variable Lit THandler::PTRefToLit ( PTRef tr) { return tmap.getLit(tr); } std::string THandler::getVarName(Var v) const { return getLogic().printTerm(tmap.varToPTRef(v)); } Var THandler::ptrefToVar ( PTRef r ) { return tmap.getVar(r); } void THandler::computeModel () { getSolverHandler().computeModel(); } // Computes a model in the solver if necessary void THandler::clearModel () { /*getSolverHandler().clearModel();*/ } // Clear the model if necessary bool THandler::assertLit (PtAsgn pta) { return getSolverHandler().assertLit(pta); } // Push the assignment to all theory solvers void THandler::informNewSplit (PTRef tr) { getSolverHandler().informNewSplit(tr); } // The splitting variable might need data structure changes in the solver (e.g. LIA needs to re-build bounds) void THandler::declareAtom(PTRef tr) { Var v = ptrefToVar(tr); declared.growTo(v + 1, false); declared[v] = true; getSolverHandler().declareAtom(tr); } inline double THandler::drand(double& seed) { seed *= 1389796; int q = (int)(seed / 2147483647); seed -= (double)q * 2147483647; return seed / 2147483647; } // Returns a random integer 0 <= x < size. Seed must never be 0. inline int THandler::irand(double& seed, int size) { return (int)(drand(seed) * size); } inline lbool THandler::value (Lit p, vec& assigns) const { return assigns[var(p)] ^ sign(p); }opensmt-2.5.2/src/tsolvers/THandler.h000066400000000000000000000135501445011647600175430ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #ifndef THANDLER_H #define THANDLER_H #include "TermMapper.h" #include "TSolverHandler.h" #include "Theory.h" class ModelBuilder; class THandler { private: Theory & theory; TermMapper & tmap; // Mappings between TRefs and Lits vec declared; // Cache for quick check if given SAT variable has been declared to theory solvers public: using ItpColorMap = std::map; THandler(Theory & tsh, TermMapper & termMapper) : theory (tsh) , tmap (termMapper) , checked_trail_size (0) { } ~THandler() = default; void clear(); // Clear the solvers from their states bool isDeclared (Var v) { return v < declared.size() and declared[v]; } // Has v been declared to the theory solvers? Theory& getTheory();// { return theory; } Logic& getLogic() ;// { return theory.getLogic(); } const Logic& getLogic() const { return theory.getLogic(); } TSolverHandler& getSolverHandler() ;// { return theory.getTSolverHandler(); } const TSolverHandler& getSolverHandler() const;// { return theory.getTSolverHandler(); } TermMapper& getTMap() ;// { return tmap; } void getConflict ( vec&, vec&, int & ); // Returns theory conflict in terms of literals std::vector> getNewSplits(); // Return the new splits as a vector of literals that needs to be interpreted as a clause. PTRef getInterpolant (const ipartitions_t&, ItpColorMap *, PartitionManager &pmanager); Lit getDeduction (); // Returns a literal that is implied by the current state and the reason literal Lit getSuggestion ( ); // Returns a literal that is suggested by the current state void getReason ( Lit, vec< Lit > &); // Returns the explanation for a deduced literal void fillTheoryFunctions (ModelBuilder & modelBuilder) const; PTRef varToTerm ( Var v ) const;//{ return tmap.varToPTRef(v); } // Return the term ref corresponding to a variable Pterm& varToPterm ( Var v) ;// { return getLogic().getPterm(tmap.varToPTRef(v)); } // Return the term corresponding to a variable Lit PTRefToLit ( PTRef tr);// { return tmap.getLit(tr); } std::string getVarName (Var v) const; void pushDeduction ();// { getSolverHandler().deductions.push({SolverId_Undef, l_Undef}); } // Add the deduction entry for a variable Var ptrefToVar ( PTRef r );// { return tmap.getVar(r); } void computeModel () ;//{ getSolverHandler().computeModel(); } // Computes a model in the solver if necessary void clearModel ();// { /*getSolverHandler().clearModel();*/ } // Clear the model if necessary bool assertLits (const vec &); // Give to the TSolvers the newly added literals on the trail bool assertLit (PtAsgn pta);// { return getSolverHandler().assertLit(pta); } // Push the assignment to all theory solvers void declareAtom (PTRef tr); void informNewSplit (PTRef tr); // Splitting variable data structure updates (e.g., recompute bounds list) TRes check (bool); // Check trail in the theories void backtrack (int); // Remove literals that are not anymore on the trail protected: // Returns a random float 0 <= x < 1. Seed must never be 0. static inline double drand(double& seed); /*{ seed *= 1389796; int q = (int)(seed / 2147483647); seed -= (double)q * 2147483647; return seed / 2147483647; }*/ // Returns a random integer 0 <= x < size. Seed must never be 0. static inline int irand(double& seed, int size); /*{ return (int)(drand(seed) * size); }*/ void dumpHeaderToFile(std::ostream&); void dumpFormulaToFile(std::ostream&, PTRef, bool negate = false); #ifdef PEDANTIC_DEBUG bool isOnTrail ( Lit, vec& ); #endif public: vec< PTRef > stack; // Stacked atoms protected: size_t checked_trail_size; // Store last size of the trail checked by the solvers inline lbool value (Lit p, vec& assigns) const;// { return assigns[var(p)] ^ sign(p); } // Debug public: char* printAsrtClause(vec& r); char* printAsrtClause(Clause *c); bool checkTrailConsistency(vec& trail); protected: #ifdef PEDANTIC_DEBUG std::string printAssertion(Lit); #endif }; #endif opensmt-2.5.2/src/tsolvers/TResult.h000066400000000000000000000002551445011647600174420ustar00rootroot00000000000000// // Created by prova on 25.07.18. // #ifndef OPENSMT_TRESULT_H #define OPENSMT_TRESULT_H enum class TRes { SAT, UNSAT, UNKNOWN, UNDEF }; #endif //OPENSMT_TRESULT_H opensmt-2.5.2/src/tsolvers/TSolver.cc000066400000000000000000000056241445011647600176010ustar00rootroot00000000000000#include "TSolver.h" #include "Logic.h" #include "OsmtInternalException.h" void TSolver::clearSolver() { explanation.clear(); th_deductions.clear(); deductions_next = 0; deductions_lim.clear(); deductions_last.clear(); suggestions.clear(); informed_PTRefs.clear(); has_explanation = false; backtrack_points.clear(); } void TSolver::popBacktrackPoints(unsigned int counter) { for (unsigned int i = 0; i < counter; ++i) { this->popBacktrackPoint(); } } void TSolver::popBacktrackPoint() { assert( deductions_last.size() > 0 ); assert( deductions_lim.size() > 0 ); deductions_next = deductions_last.last(); deductions_last.pop(); // Restore deductions size_t new_deductions_size = deductions_lim.last(); deductions_lim.pop(); while (th_deductions.size_() > new_deductions_size) { PtAsgn_reason asgn = th_deductions.last(); clearPolarity(asgn.tr); th_deductions.pop(); } assert( deductions_next <= th_deductions.size_() ); assert( deductions_last.size( ) == deductions_lim.size( ) ); } void TSolver::pushBacktrackPoint() { deductions_lim.push(th_deductions.size()); deductions_last.push(deductions_next); assert(deductions_last.size() == deductions_lim.size()); } // MB: setPolarity and clearPolarity moved to .C file to remove the macros from the header void TSolver::setPolarity(PTRef tr, lbool p) { if (polarityMap.has(tr)) { polarityMap[tr] = p; } else { polarityMap.insert(tr, p); } } void TSolver::getNewSplits(vec&) { // Default implementation does not give splits } bool TSolver::hasNewSplits() { return splitondemand.size() > 0; } PtAsgn_reason TSolver::getDeduction() { if (deductions_next >= th_deductions.size_()) { return PtAsgn_reason_Undef; } return th_deductions[deductions_next++]; } vec TSolver::getReasonFor(PtAsgn lit) { pushBacktrackPoint(); // assert with negated polarity assert(lit.sgn != l_Undef); bool sat = assertLit(PtAsgn(lit.tr, lit.sgn == l_True ? l_False : l_True)); if (sat) { assert(false); throw OsmtInternalException("Error in computing reason for theory-propagated literal"); } vec conflict; getConflict(conflict); popBacktrackPoint(); #ifdef STATISTICS if (conflict.size() > generalTSolverStats.max_reas_size) generalTSolverStats.max_reas_size = conflict.size(); if (conflict.size() < generalTSolverStats.min_reas_size) generalTSolverStats.min_reas_size = conflict.size(); generalTSolverStats.reasons_sent ++; generalTSolverStats.avg_reas_size += conflict.size(); #endif // STATISTICS return conflict; } void TSolver::printStatistics(std::ostream & os) { os << "; -------------------------\n"; os << "; STATISTICS FOR " << getName() << '\n'; os << "; -------------------------\n"; generalTSolverStats.printStatistics(os); }opensmt-2.5.2/src/tsolvers/TSolver.h000066400000000000000000000201661445011647600174410ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #ifndef TSOLVER_H #define TSOLVER_H #include "PtStructs.h" #include "SMTConfig.h" #include "Deductions.h" #include "SolverTypes.h" #include "TResult.h" #include "MapWithKeys.h" #include // forward declaration class TheoryInterpolator; class ModelBuilder; class Logic; /////////////////////// class TSolverStats { public: long sat_calls; long unsat_calls; TSolverStats () : sat_calls ( 0 ) , unsat_calls ( 0 ) , conflicts_sent ( 0 ) , avg_conf_size ( 0 ) , max_conf_size ( 0 ) , min_conf_size ( 32767 ) , deductions_done ( 0 ) , deductions_sent ( 0 ) , reasons_sent ( 0 ) , avg_reas_size ( 0 ) , max_reas_size ( 0 ) , min_reas_size ( 32767 ) {} // Statistics for theory solvers void printStatistics ( std::ostream & os ) { os << "; Satisfiable calls........: " << sat_calls << '\n'; os << "; Unsatisfiable calls......: " << unsat_calls << '\n'; if ( unsat_calls > 0 ) { os << "; Conflicts sent...........: " << conflicts_sent << '\n'; if ( conflicts_sent > 0 ) { os << "; Average conflict size....: " << avg_conf_size / (float)conflicts_sent << '\n'; os << "; Max conflict size........: " << max_conf_size << '\n'; os << "; Min conflict size........: " << min_conf_size << '\n'; } } if ( sat_calls > 0 ) { os << "; Deductions done..........: " << deductions_done << '\n'; os << "; Deductions sent..........: " << deductions_sent << '\n'; os << "; Reasons sent.............: " << reasons_sent << '\n'; if ( reasons_sent > 0 ) { os << "; Average reason size......: " << avg_reas_size / (float)reasons_sent << '\n'; os << "; Max reason size..........: " << max_reas_size << '\n'; os << "; Min reason size..........: " << min_reas_size << '\n'; } } os << std::flush; } // Calls statistics // Conflict statistics int conflicts_sent; float avg_conf_size; int max_conf_size; int min_conf_size; // Deductions statistics int deductions_done; int deductions_sent; int reasons_sent; float avg_reas_size; int max_reas_size; int min_reas_size; }; class TSolver { private: /** * Polarity map now merges its original meaning and keeping track of deductions. * It keeps track about polarities of theory atoms the solver already knows about. * This information can come from two sources: * - from SAT solver through assertLit * - from TSolver's own deductions */ Map polarityMap; protected: SolverId id; // Solver unique identifier vec explanation; // Stores the explanation vec th_deductions; // List of deductions computed by the theory size_t deductions_next; // Index of next deduction to communicate vec deductions_lim; // Keeps track of deductions done up to a certain point vec deductions_last; // Keeps track of deductions done up to a certain point vec suggestions; // List of suggestions for decisions TSolverStats generalTSolverStats; // Methods for querying and modifying infromation about known polarities void setPolarity(PTRef tr, lbool p); lbool getPolarity(PTRef tr) const { return polarityMap[tr]; } void clearPolarity(PTRef tr) { polarityMap[tr] = l_Undef; } bool hasPolarity(PTRef tr) const { if (polarityMap.has(tr)) { return polarityMap[tr] != l_Undef; } else return false; } // Method for storing information about deductions (Derived solvers should use this and not manipulate fields themselves) void storeDeduction(PtAsgn_reason ded) { th_deductions.push(ded); setPolarity(ded.tr, ded.sgn); } vec splitondemand; public: // The states of the TSolver check query TSolver(SolverId id_, const char * name_, SMTConfig & c) : id(id_) , deductions_next(0) , has_explanation(false) , name(name_) , config (c) {} virtual ~TSolver () = default; // Called after every check-sat. virtual void clearSolver(); virtual bool assertLit (PtAsgn) = 0 ; // Assert a theory literal virtual void pushBacktrackPoint ( ) ; // Push a backtrack point virtual void popBacktrackPoint ( ) ; // Backtrack to last saved point virtual void popBacktrackPoints ( unsigned int ) ; // Backtrack given number of points virtual TRes check ( bool ) = 0 ; // Check satisfiability inline std::string getName ( ) { return name; } // The name of the solver virtual void fillTheoryFunctions(ModelBuilder &) const { throw std::logic_error{"Model computation not supported for the used theory yet!"}; } virtual void computeModel() = 0; // Compute model for variables virtual void getConflict(vec &) = 0; // Return conflict virtual vec getReasonFor(PtAsgn lit); virtual bool hasNewSplits(); // Are there new splits? virtual void getNewSplits(vec&); // Return new splits if any virtual PtAsgn_reason getDeduction(); // Return an implied literal based on the current state virtual vec collectEqualitiesFor(vec const &, std::unordered_set const &) { return {}; } SolverId getId() { return id; } bool hasExplanation() { return has_explanation; } virtual void declareAtom(PTRef tr) = 0; virtual void informNewSplit(PTRef) { }; virtual Logic& getLogic() = 0; virtual bool isValid(PTRef tr) = 0; bool isInformed(PTRef tr) const { return informed_PTRefs.has(tr); } virtual void printStatistics(std::ostream & os); protected: void setInformed(PTRef tr) { informed_PTRefs.insert(tr, true); } const vec & getInformed() { return informed_PTRefs.getKeys(); } bool has_explanation; // Does the solver have an explanation (conflict detected) std::string name; // Name of the solver SMTConfig & config; // Reference to configuration vec< size_t > backtrack_points; // Keeps track of backtrack points private: MapWithKeys informed_PTRefs; }; #endif opensmt-2.5.2/src/tsolvers/TSolverHandler.cc000066400000000000000000000046001445011647600210700ustar00rootroot00000000000000#include "TSolverHandler.h" #include "TreeOps.h" #include "TResult.h" TSolverHandler::~TSolverHandler() { for (auto solver : solverSchedule) { delete solver; } } void TSolverHandler::computeModel() { for (auto solver : solverSchedule) { solver->computeModel(); } } void TSolverHandler::fillTheoryFunctions(ModelBuilder & modelBuilder) const { for (auto solver : solverSchedule) { assert(solver); solver->fillTheoryFunctions(modelBuilder); } } bool TSolverHandler::assertLit(PtAsgn asgn) { bool res = true; // Push backtrack points and the assignments to the theory solvers // according to the schedule for (auto solver : solverSchedule) { assert(solver != nullptr); solver->pushBacktrackPoint(); if (not solver->isInformed(asgn.tr)) { continue; } bool res_new = solver->assertLit(asgn); res &= res_new; } return res; } // Clear the vars of the solvers void TSolverHandler::clearSolver() { for (auto solver : solverSchedule) { solver->clearSolver(); } } void TSolverHandler::declareAtom(PTRef tr) { for (auto solver : solverSchedule) { if (solver->isValid(tr)) { solver->declareAtom(tr); } } } void TSolverHandler::informNewSplit(PTRef tr) { for (auto solver : solverSchedule) { if (solver->isValid(tr)) { solver->informNewSplit(tr); } } } TRes TSolverHandler::check(bool complete) { TRes res_final = TRes::SAT; for (auto solver : solverSchedule) { TRes res = solver->check(complete); if (res == TRes::UNSAT) { return TRes::UNSAT; } else if (res == TRes::UNKNOWN) res_final = TRes::UNKNOWN; } return res_final; } vec TSolverHandler::getSplitClauses() { vec split_terms; for (auto solver : solverSchedule) { if (solver->hasNewSplits()) { solver->getNewSplits(split_terms); break; } } return split_terms; } // MB: This is currently needed to replace a common array of deduced elements with solver ID TSolver* TSolverHandler::getReasoningSolverFor(PTRef ptref) const { assert(getLogic().isTheoryTerm(ptref)); for (auto solver : solverSchedule) { if (solver->isValid(ptref)) return solver; } assert(false); return nullptr; }opensmt-2.5.2/src/tsolvers/TSolverHandler.h000066400000000000000000000055301445011647600207350ustar00rootroot00000000000000#ifndef TSolverHandler_H #define TSolverHandler_H /********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2015 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #include "PartitionManager.h" #include "Deductions.h" #include "TermMapper.h" #include "TSolver.h" class TheoryInterpolator; class THandler; class TSolver; class ModelBuilder; class TSolverHandler { friend THandler; vec solverSchedule; protected: SMTConfig &config; TSolverHandler(SMTConfig & c) : config(c) { } void setSolverSchedule(vec && schedule) { solverSchedule = std::move(schedule); } public: using ItpColorMap = std::map; virtual ~TSolverHandler(); virtual void clearSolver(); // Clear the solver state virtual Logic& getLogic() = 0; virtual const Logic& getLogic() const = 0; virtual PTRef getInterpolant(const ipartitions_t& mask, ItpColorMap *, PartitionManager& pmanager) = 0; void computeModel (); // Computes a model in the solver if necessary bool assertLit (PtAsgn); // Push the assignment to all theory solvers void informNewSplit(PTRef); // Recompute split datastructures virtual void declareAtom(PTRef tr); // Declare atom to the appropriate solver virtual lbool getPolaritySuggestion(PTRef) const { return l_Undef; } virtual TRes check(bool); virtual vec getSplitClauses(); virtual void fillTheoryFunctions(ModelBuilder & modelBuilder) const; private: // Helper method for computing reasons TSolver* getReasoningSolverFor(PTRef ptref) const; }; #endif opensmt-2.5.2/src/tsolvers/UFLATHandler.cc000066400000000000000000000113551445011647600203520ustar00rootroot00000000000000#include "UFLATHandler.h" #include "lasolver/LASolver.h" #include "TreeOps.h" #include "Egraph.h" #include "ArraySolver.h" UFLATHandler::UFLATHandler(SMTConfig & c, ArithLogic & l) : TSolverHandler(c) , logic(l) { lasolver = new LASolver(config, logic); ufsolver = new Egraph(config, logic); arraySolver = logic.hasArrays() ? new ArraySolver(l, *ufsolver, c) : nullptr; if (logic.hasArrays()) { setSolverSchedule({ufsolver, arraySolver, lasolver}); } else { setSolverSchedule({ufsolver,lasolver}); } } PTRef UFLATHandler::getInterpolant(const ipartitions_t&, ItpColorMap *, PartitionManager &) { throw std::logic_error("Not implemented"); } lbool UFLATHandler::getPolaritySuggestion(PTRef pt) const { if (lasolver->isInformed(pt)) { return lasolver->getPolaritySuggestion(pt); } if (ufsolver->isInformed(pt)) { return ufsolver->getPolaritySuggestion(pt); } return l_Undef; } TRes UFLATHandler::check(bool full) { auto res = TSolverHandler::check(full); if (full and res == TRes::SAT and not lasolver->hasNewSplits() and (not arraySolver or not arraySolver->hasNewSplits())) { equalitiesToPropagate = ufsolver->collectEqualitiesFor(interfaceVars, knownEqualities); // MB: Only collect equalities from LASolver if there are none from UF solver. // This prevents duplication of equalities if (equalitiesToPropagate.size() == 0) { equalitiesToPropagate = lasolver->collectEqualitiesFor(interfaceVars, knownEqualities); } } return res; } void UFLATHandler::declareAtom(PTRef atom) { TSolverHandler::declareAtom(atom); if (logic.isEquality(atom)) { knownEqualities.insert(atom); } } namespace { void addInterfaceClausesForEquality(ArithLogic & logic, PTRef eq, vec & clauses) { // create clauses corresponding to "x = y iff x >= y and x <= y" assert(logic.isNumEq(eq)); PTRef lhs = logic.getPterm(eq)[0]; PTRef rhs = logic.getPterm(eq)[1]; assert((logic.isNumVar(lhs) or logic.isNumConst(lhs)) and (logic.isNumVar(rhs) or logic.isNumConst(rhs))); PTRef leq = logic.mkLeq(lhs, rhs); PTRef geq = logic.mkGeq(lhs, rhs); vec args = {eq, logic.mkNot(leq), logic.mkNot(geq)}; // trichotomy clause clauses.push(logic.mkOr(args)); args.clear(); args.push(logic.mkNot(eq)); args.push(leq); clauses.push(logic.mkOr(args)); // x = y => x <= y args.last() = geq; clauses.push(logic.mkOr(std::move(args))); // x = y => x >= y } } vec UFLATHandler::getSplitClauses() { assert(not ufsolver->hasNewSplits()); vec res; if (lasolver->hasNewSplits()) { lasolver->getNewSplits(res); return res; } if (arraySolver and arraySolver->hasNewSplits()) { arraySolver->getNewSplits(res); vec arrayLemmas; res.copyTo(arrayLemmas); std::unordered_set equalitiesWithAddedClauses; // HACK: If array solver needs to decide equality on interface vars, we need to add corresponding lemmas already here for (PTRef lemma : arrayLemmas) { if (logic.isOr(lemma)) { for (PTRef lit : logic.getPterm(lemma)) { PTRef atom = logic.isNot(lit) ? logic.getPterm(lit)[0] : lit; if (logic.isNumEq(atom) and knownEqualities.find(atom) == knownEqualities.end() and equalitiesWithAddedClauses.find(atom) == equalitiesWithAddedClauses.end()) { PTRef lhs = logic.getPterm(atom)[0]; PTRef rhs = logic.getPterm(atom)[1]; if (std::find(interfaceVars.begin(), interfaceVars.end(), lhs) != interfaceVars.end() and std::find(interfaceVars.begin(), interfaceVars.end(), rhs) != interfaceVars.end() ) { addInterfaceClausesForEquality(logic, atom, res); equalitiesWithAddedClauses.insert(atom); } } } } } return res; } if (equalitiesToPropagate.size() == 0) { return res; } for (PTRef eq : equalitiesToPropagate) { if (knownEqualities.find(eq) == knownEqualities.end()) { addInterfaceClausesForEquality(logic, eq, res); } } equalitiesToPropagate.clear(); return res; } void UFLATHandler::fillTheoryFunctions(ModelBuilder & modelBuilder) const { // MB: To properly build model in UF solver, we already need values for the LA variables from LA solver. lasolver->fillTheoryFunctions(modelBuilder); ufsolver->fillTheoryFunctions(modelBuilder); } opensmt-2.5.2/src/tsolvers/UFLATHandler.h000066400000000000000000000046461445011647600202210ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2016 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #ifndef UFLRATHandler_H #define UFLRATHandler_H #include "TSolverHandler.h" #include "ArithLogic.h" #include class Egraph; class LASolver; class ArraySolver; class UFLATHandler : public TSolverHandler { private: ArithLogic & logic; LASolver * lasolver; Egraph * ufsolver; ArraySolver * arraySolver; vec interfaceVars; vec equalitiesToPropagate; std::unordered_set knownEqualities; public: UFLATHandler(SMTConfig & c, ArithLogic & l); ~UFLATHandler() override = default; Logic & getLogic() override { return logic; } Logic const & getLogic() const override { return logic; } PTRef getInterpolant(const ipartitions_t& mask, ItpColorMap * labels, PartitionManager &pmanager) override; lbool getPolaritySuggestion(PTRef pt) const override; void declareAtom(PTRef atom) override; TRes check(bool complete) override; void setInterfaceVars(vec && vars) { vars.moveTo(interfaceVars); } vec getSplitClauses() override; void fillTheoryFunctions(ModelBuilder & modelBuilder) const override; }; #endif opensmt-2.5.2/src/tsolvers/UFTHandler.cc000066400000000000000000000016201445011647600201270ustar00rootroot00000000000000#include "UFTHandler.h" #include "TreeOps.h" #include "Egraph.h" #include "InterpolatingEgraph.h" UFTHandler::UFTHandler(SMTConfig & c, Logic & l) : TSolverHandler(c) , logic(l) { egraph = config.produce_inter() > 0 ? new InterpolatingEgraph(config, logic) : new Egraph(config, logic); setSolverSchedule({egraph}); } UFTHandler::~UFTHandler() { } Logic &UFTHandler::getLogic() { return logic; } const Logic &UFTHandler::getLogic() const { return logic; } lbool UFTHandler::getPolaritySuggestion(PTRef p) const { if (egraph) { return egraph->getPolaritySuggestion(p); } return l_Undef; } PTRef UFTHandler::getInterpolant(const ipartitions_t& mask, ItpColorMap * labels, PartitionManager &pmanager) { InterpolatingEgraph* iegraph = dynamic_cast(egraph); assert(iegraph); return iegraph->getInterpolant(mask, labels, pmanager); } opensmt-2.5.2/src/tsolvers/UFTHandler.h000066400000000000000000000040431445011647600177730ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2015 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #ifndef UFTHandler_h #define UFTHandler_h //#include "THandler.h" #include "TSolverHandler.h" //#include "Egraph.h" class Egraph; class Logic; class UFTHandler : public TSolverHandler { private: Logic& logic; protected: Egraph* egraph; public: UFTHandler(SMTConfig & c, Logic & l); virtual ~UFTHandler(); // This is for simplification, needed to run the theory solver code // as if it were running inside a SAT solver. virtual Logic& getLogic() override; virtual const Logic& getLogic() const override; virtual lbool getPolaritySuggestion(PTRef) const override; virtual PTRef getInterpolant(const ipartitions_t& mask, ItpColorMap * labels, PartitionManager &pmanager) override; }; #endif opensmt-2.5.2/src/tsolvers/axdiffsolver/000077500000000000000000000000001445011647600203615ustar00rootroot00000000000000opensmt-2.5.2/src/tsolvers/axdiffsolver/AXDiffSolver.cc000066400000000000000000000165641445011647600232000ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #include "AXDiffSolver.h" AXDiffSolver::AXDiffSolver( const int id , const char * n , SMTConfig & c , Egraph & eg , SStore & t , vector< Enode * > & x , vector< Enode * > & de , vector< Enode * > & s ) : OrdinaryTSolver ( id, n, c, eg, t, x, de, s ) , re_p ( new RewriteEngine( id, c, eg, t, x, de ) ) , re ( *re_p ) , nof_index_eqs ( 0 ) , nof_asserted_index_eqs ( 0 ) , nof_read_terms ( 0 ) , nof_asserted_read_terms( 0 ) { } void AXDiffSolver::initialize( ) { } AXDiffSolver::~AXDiffSolver( ) { assert( re_p ); delete re_p; re_p = NULL; } lbool AXDiffSolver::inform( Enode * e ) { if ( config.verbosity > 2 ) cerr << "# AXDiffSolver::Informing of constraint " << e << endl; #ifdef PRODUCE_PROOF assert( config.produce_inter == 0 || e->getIPartitions( ) != 0 ); #endif if ( isIndexEq( e ) ) { #ifdef PRODUCE_PROOF if ( config.produce_inter != 0 ) { re.informIdx( e->get1st( ) ); re.informIdx( e->get2nd( ) ); } #endif nof_index_eqs ++; } if ( hasReadTerms( e ) ) nof_read_terms ++; (void)e; assert( e ); assert( belongsToT( e ) ); return l_Undef; } bool AXDiffSolver::assertLit ( Enode * e, bool reason ) { if ( config.verbosity > 2 ) cerr << "# AXDiffSolver::Asserting literal " << ( e->getPolarity( ) == l_True ? "" : "(not " ) << e << ( e->getPolarity( ) == l_True ? "" : ")" ) << endl; const bool negated = e->getPolarity( ) == l_False; assert( e->isEq( ) ); undo_stack_oper.push_back( ASSERT_LIT ); undo_stack_term.push_back( e ); if ( isIndexEq( e ) ) nof_asserted_index_eqs ++; if ( !negated ) { if ( isIndexEq( e ) ) re.addIndexEq( e ); else { if ( hasReadTerms( e ) ) nof_asserted_read_terms ++; re.addEq( e ); } } else if ( isElemEq( e ) ) { #ifdef PRODUCE_PROOF assert( !re.isABcommon( e ) ); if ( re.isAlocal( e ) ) re.addNeq( e ); else re.addNeqB( e ); #else re.addNeq( e ); #endif } re.resetStatus( ); (void)e; (void)reason; assert( e ); assert( belongsToT( e ) ); return true; } void AXDiffSolver::pushBacktrackPoint ( ) { // Save solver state if required assert( undo_stack_oper.size( ) == undo_stack_term.size( ) ); backtrack_points.push_back( undo_stack_term.size( ) ); // re.pushBacktrackPoint( ); } void AXDiffSolver::popBacktrackPoint ( ) { assert( backtrack_points.size( ) > 0 ); size_t undo_stack_new_size = backtrack_points.back( ); backtrack_points.pop_back( ); backtrackToStackSize( undo_stack_new_size ); // re.popBacktrackPoint( ); } void AXDiffSolver::backtrackToStackSize( size_t size ) { while ( undo_stack_term.size( ) > size ) { oper_t last_action = undo_stack_oper.back( ); Enode * e = undo_stack_term.back( ); if ( last_action == ASSERT_LIT ) { const bool negated = e->getPolarity( ) == l_False; assert( e->isEq( ) ); if ( isIndexEq( e ) ) nof_asserted_index_eqs --; if ( !negated ) { if ( isIndexEq( e ) ) re.remIndexEq( e ); else { if ( hasReadTerms( e ) ) nof_asserted_read_terms --; re.remEq( e ); } } else if ( isElemEq( e ) ) { #ifdef PRODUCE_PROOF assert( !re.isABcommon( e ) ); if ( re.isAlocal( e ) ) re.remNeq( e ); else re.remNeqB( e ); #else re.remNeq( e ); #endif } if ( config.verbosity > 2 ) cerr << "# AXDiffSolver::Deasserted literal " << ( e->getPolarity( ) == l_True ? "" : "(not " ) << e << ( e->getPolarity( ) == l_True ? "" : ")" ) << endl; re.resetStatus( ); } else { opensmt_error( "Unknown case value" ); } undo_stack_oper.pop_back( ); undo_stack_term.pop_back( ); } assert( undo_stack_term.size( ) == undo_stack_oper.size( ) ); } // // Check for consistency. If flag is // set make sure you run a complete check // bool AXDiffSolver::check( bool complete ) { (void)complete; // // Skip check until // /* * DISABILITATE CHIAMATE INDEX-TOTAL * */ if ( nof_asserted_index_eqs < nof_index_eqs ) { return true; } assert( nof_asserted_index_eqs == nof_index_eqs ); if ( config.verbosity > 2 ) { cerr << "#" << endl << "# AXDiffSolver::Checking " << ( complete ? "complete" : "incomplete" ) << endl << "#" << endl; } // Don't recompute if status is known if ( re.getStatus( ) == l_True ) return true; if ( re.getStatus( ) == l_False ) return false; // // Exhaustive completion of // ground and non-ground // rewrite rules // re.check( nof_asserted_index_eqs == nof_index_eqs ); assert( re.getStatus( ) == l_True || re.getStatus( ) == l_False ); if ( config.verbosity > 2 ) { cerr << "#" << endl << "# AXDiffSolver::Check ends with " << (re.getStatus( ) == l_True ? "sat" : "unsat" ) << endl << "#" << endl; } if ( re.getStatus( ) == l_True ) return true; return false; } bool AXDiffSolver::belongsToT( Enode * e ) { // TODO: for now we don't care about this (void)e; assert( e ); return true; } // // Copy the model into enode's data // void AXDiffSolver::computeModel( ) { } bool AXDiffSolver::isIndexEq( Enode * e ) { assert( e->isEq( ) ); Enode * lhs = e->get1st( ); return lhs->getRetSort( ) == egraph.getSortIndex( ); } bool AXDiffSolver::isElemEq( Enode * e ) { assert( e->isEq( ) ); Enode * lhs = e->get1st( ); return lhs->getRetSort( ) == egraph.getSortElem( ); } bool AXDiffSolver::hasReadTerms( Enode * e ) { assert( e->isEq( ) ); Enode * lhs = e->get1st( ); Enode * rhs = e->get2nd( ); return lhs->getRetSort( ) == egraph.getSortElem( ) && ( ( lhs->isSelect( ) && lhs->get1st( )->isVar( ) ) || ( rhs->isSelect( ) && rhs->get1st( )->isVar( ) ) ); } #ifdef PRODUCE_PROOF Enode * AXDiffSolver::getInterpolants( ) { assert( config.produce_inter != 0 ); interpolants = egraph.cons( re.getInterpolant( ) ); return interpolants; } #endif opensmt-2.5.2/src/tsolvers/axdiffsolver/AXDiffSolver.h000066400000000000000000000053331445011647600230320ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008-2012, Roberto Bruttomesso 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. *********************************************************************/ #ifndef AXDIFFSOLVER_H #define AXDIFFSOLVER_H #include "TSolver.h" #include "RewriteEngine.h" class AXDiffSolver : public OrdinaryTSolver { public: AXDiffSolver( const int , const char * , SMTConfig & , Egraph & , SStore & , vector< Enode * > & , vector< Enode * > & , vector< Enode * > & ); ~AXDiffSolver ( ); lbool inform ( Enode * ); bool assertLit ( Enode *, bool = false ); void pushBacktrackPoint ( ); void popBacktrackPoint ( ); bool check ( bool ); bool belongsToT ( Enode * ); void computeModel ( ); #ifdef PRODUCE_PROOF Enode * getInterpolants ( ); void gatherIndexes ( Enode * ); #endif void initialize ( ); private: void backtrackToStackSize ( size_t ); bool isIndexEq ( Enode * ); bool isElemEq ( Enode * ); bool hasReadTerms ( Enode * ); // // Defines the set of operations that can be performed and that should be undone // typedef enum { ASSERT_LIT } oper_t; RewriteEngine * re_p; RewriteEngine & re; vector< oper_t > undo_stack_oper; vector< Enode * > undo_stack_term; #ifdef PRODUCE_PROOF set< Enode * > indexes; #endif unsigned nof_index_eqs; unsigned nof_asserted_index_eqs; unsigned nof_read_terms; unsigned nof_asserted_read_terms; }; #endif opensmt-2.5.2/src/tsolvers/axdiffsolver/ArraySolver.cc000066400000000000000000000767261445011647600231630ustar00rootroot00000000000000/* * Copyright (c) 2021-2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #include "ArraySolver.h" #include "TreeOps.h" #include static SolverDescr descr_ax_solver("Array Solver", "Solver for Theory of Arrays"); ArraySolver::ArraySolver(Logic & logic, Egraph & egraph, SMTConfig & config) : TSolver((SolverId) descr_ax_solver, (const char *) descr_ax_solver, config), logic(logic), egraph(egraph) { } void ArraySolver::clearSolver() { clear(); TSolver::clearSolver(); } bool ArraySolver::assertLit(PtAsgn literal) { if (logic.isEquality(literal.tr)) { setPolarity(literal.tr, literal.sgn); assertedLiterals.push(literal); if (literal.sgn == l_True) { // Strong equivalence context has changed -> reset clear(); } else if (literal.sgn == l_False) { // For asserted disequality check current read-over-weak-eq lemmas to see if any is now completely falsified for (auto & lemma : lemmas) { auto & undecided = lemma.undecidedEqualities; auto it = undecided.find(literal.tr); if (it != undecided.end()) { undecided.erase(it); } if (undecided.empty()) { has_explanation = true; computeExplanation(lemma.equality); return false; } } } } return true; } void ArraySolver::pushBacktrackPoint() { backtrack_points.push(assertedLiterals.size_()); TSolver::pushBacktrackPoint(); } void ArraySolver::popBacktrackPoint() { clear(); assert(backtrack_points.size() > 0); auto lastSize = backtrack_points.last(); backtrack_points.pop(); while (assertedLiterals.size_() > lastSize) { auto lit = assertedLiterals.last(); assertedLiterals.pop(); clearPolarity(lit.tr); } TSolver::popBacktrackPoint(); } void ArraySolver::popBacktrackPoints(unsigned int i) { clear(); TSolver::popBacktrackPoints(i); } TRes ArraySolver::check(bool complete) { if (not valid) { buildWeakEq(); } for (auto const & lemma : lemmas) { if (lemma.undecidedEqualities.empty()) { has_explanation = true; computeExplanation(lemma.equality); return TRes::UNSAT; } } if (complete) { if (lemmas.empty()) { return checkExtensionality(); } else { for (auto const & lemma : lemmas) { auto conflict = readOverWeakEquivalenceConflict(lemma.equality); assert(not std::all_of(conflict.begin(), conflict.end(), [this](PtAsgn lit) { return lit.sgn == l_False ? isFalsified(lit.tr) : isSatisfied(lit.tr); })); vec args; args.capacity(conflict.size()); for (PtAsgn lit : conflict) { assert(lit.sgn != l_Undef); // MB: To obtain lemma, we need to negate the literals of the conflict PTRef arg = lit.sgn == l_True ? logic.mkNot(lit.tr) : lit.tr; args.push(arg); } splitondemand.push(logic.mkOr(std::move(args))); } } } return TRes::SAT; } void ArraySolver::fillTheoryFunctions(ModelBuilder & builder) const { TSolver::fillTheoryFunctions(builder); } void ArraySolver::computeModel() { } void ArraySolver::getConflict(vec & vec) { assert(vec.size() == 0); assert(has_explanation); assert(explanation.size() > 0); for (auto lit : explanation) { vec.push(lit); } } void ArraySolver::declareAtom(PTRef tr) { class TermCollectorConfig : public DefaultVisitorConfig { Logic const & logic; ArraySolver::Terms & arrayTerms; ArraySolver::Terms & storeTerms; ArraySolver::Terms & selectTerms; Egraph const & egraph; public: TermCollectorConfig(Logic const & logic, Terms & arrayTerms, Terms & storeTerms, Terms & selectTerms, Egraph const & egraph) : logic(logic), arrayTerms(arrayTerms), storeTerms(storeTerms), selectTerms(selectTerms), egraph(egraph) {} void visit(PTRef term) override { if (logic.isArraySort(logic.getSortRef(term))) { ERef eref = egraph.termToERef(term); arrayTerms.insert(eref); if (logic.isArrayStore(term)) { storeTerms.insert(eref); } } else if (logic.isArraySelect(term)) { ERef eref = egraph.termToERef(term); selectTerms.insert(eref); } } }; TermCollectorConfig config(logic, arrayTerms, storeTerms, selectTerms, egraph); TermVisitor(logic, config).visit(tr); if (logic.isEquality(tr)) { setInformed(tr); } } Logic & ArraySolver::getLogic() { return logic; } bool ArraySolver::isValid(PTRef tr) { return egraph.isValid(tr); } void ArraySolver::getNewSplits(vec & splits) { splitondemand.copyTo(splits); splitondemand.clear(); } /* * Internal methods for manipulating weak equivalence graph */ void ArraySolver::makeIndexedWeakRepresentative(NodeRef nodeRef) { ArrayNode & node = getNode(nodeRef); NodeRef secondaryRef = node.secondaryEdge; if (secondaryRef != NodeRef_Undef) { if (getRoot(getIndexOfPrimaryEdge(secondaryRef)) != getRoot(getIndexOfPrimaryEdge(nodeRef))) { node.secondaryEdge = getNode(secondaryRef).primaryEdge; makeIndexedWeakRepresentative(nodeRef); } else { makeIndexedWeakRepresentative(secondaryRef); // invert secondary edge getNode(secondaryRef).secondaryEdge = nodeRef; getNode(secondaryRef).secondaryStore = node.secondaryStore; node.secondaryEdge = NodeRef_Undef; node.secondaryStore = ERef_Undef; } } } void ArraySolver::makeWeakRepresentative(NodeRef nodeRef) { ArrayNode & node = getNode(nodeRef); NodeRef parentRef = node.primaryEdge; if (parentRef != NodeRef_Undef) { makeWeakRepresentative(parentRef); // Invert primary edge getNode(parentRef).primaryEdge = nodeRef; getNode(parentRef).primaryStore = node.primaryStore; // Make representative for i-weak equivalence class // Information about primary store is needed in "makeIndexedWeakRepresentative"! makeIndexedWeakRepresentative(nodeRef); node.primaryEdge = NodeRef_Undef; node.primaryStore = ERef_Undef; } } void ArraySolver::merge(ERef storeTerm) { assert(logic.isArrayStore(egraph.ERefToTerm(storeTerm))); ERef arrayTerm = getArrayFromStore(storeTerm); ERef indexTerm = getRoot(getIndexFromStore(storeTerm)); NodeRef arrayNode = getNodeRef(getRoot(arrayTerm)); NodeRef storeNode = getNodeRef(getRoot(storeTerm)); if (arrayNode == storeNode) { return; } makeWeakRepresentative(arrayNode); if (getRepresentative(storeNode) == arrayNode) { mergeSecondary(storeNode, arrayNode, storeTerm, std::unordered_set({indexTerm})); } else { // new primary edge getNode(arrayNode).primaryEdge = storeNode; getNode(arrayNode).primaryStore = storeTerm; } } void ArraySolver::mergeSecondary(NodeRef nodeRef, NodeRef root, ERef store, std::unordered_set && forbiddenIndices) { if (nodeRef == root) { return; } ArrayNode & node = getNode(nodeRef); ERef primaryIndex = getRoot(getIndexOfPrimaryEdge(nodeRef)); assert(getRoot(primaryIndex) == primaryIndex); if (forbiddenIndices.find(primaryIndex) == forbiddenIndices.end() and getIndexedRepresentative(nodeRef, primaryIndex) != root) { makeIndexedWeakRepresentative(nodeRef); node.secondaryEdge = root; node.secondaryStore = store; } forbiddenIndices.insert(primaryIndex); mergeSecondary(node.primaryEdge, root, store, std::move(forbiddenIndices)); } /* * Build the WE-graph for current context and compute read-over-weak-eq lemmas that need to be valid. */ void ArraySolver::buildWeakEq() { assert(not valid); assert(nodes.empty() and rootsMap.empty() and lemmas.empty()); for (ERef arrayTerm : arrayTerms) { ERef root = getRoot(arrayTerm); if (rootsMap.find(root) == rootsMap.end()) { NodeRef nodeRef {static_cast(nodes.size())}; nodes.emplace_back(root); rootsMap.insert({root, nodeRef}); } } for (ERef store : storeTerms) { merge(store); } lemmas = collectLemmaConditions(logic); valid = true; } void ArraySolver::computeSelectsInfo() { for (ERef select : selectTerms) { ERef index = getRoot(getIndexFromSelect(select)); NodeRef arrayNode = getNodeRef(getRoot(getArrayFromSelect(select))); NodeRef weakIRepresentative = getIndexedRepresentative(arrayNode, index); selectsInfo[weakIRepresentative].insert({index, select}); } } namespace { struct ExtensionalityInfo { using IndexValueMap = std::unordered_map; NodeRef weakEqRoot; std::unordered_map weakIRoots; IndexValueMap indexValueMap; void erase(ERef index) { indexValueMap.erase(index); weakIRoots.erase(index); } }; bool operator==(ExtensionalityInfo const & first, ExtensionalityInfo const & second) { if (first.weakEqRoot != second.weakEqRoot) { return false; } if (first.weakIRoots.size() != second.weakIRoots.size()) { return false; } if (first.indexValueMap.size() != second.indexValueMap.size()) { return false; } return first.weakIRoots == second.weakIRoots and first.indexValueMap == second.indexValueMap; } struct ExtensionalityInfoHash { uint32_t operator()(ExtensionalityInfo const & info) const { std::hash hasher{}; uint32_t res = hasher(info.weakEqRoot.id); res = std::accumulate(info.weakIRoots.begin(), info.weakIRoots.end(), res, [&](uint32_t acc, auto const & entry) { return acc ^ hasher(entry.first.x + entry.second.id); }); res = std::accumulate(info.indexValueMap.begin(), info.indexValueMap.end(), res, [&](uint32_t acc, auto const & entry) { return acc ^ hasher(entry.first.x + entry.second.x); }); return res; } }; } TRes ArraySolver::checkExtensionality() { if (selectsInfo.empty()) { computeSelectsInfo(); } std::unordered_map extensionalityInfos; std::unordered_map inverseExtensionalityInfos; vec> equalitiesToPropagate; vec queue; queue.capacity(rootsMap.size()); for (auto const & entry : rootsMap) { queue.push(entry.second); } while (queue.size() > 0) { NodeRef const current = queue.last(); if (extensionalityInfos.find(current) != extensionalityInfos.end()) { queue.pop(); continue; } ArrayNode const & node = getNode(current); if (node.primaryEdge != NodeRef_Undef and extensionalityInfos.find(node.primaryEdge) == extensionalityInfos.end()) { queue.push(node.primaryEdge); continue; } queue.pop(); ExtensionalityInfo extensionalityInfo; NodeRef const weakEqRoot = getRepresentative(current); if (current == weakEqRoot) { // Root of weak-eq class extensionalityInfo.weakEqRoot = current; auto it = selectsInfo.find(current); if (it != selectsInfo.end()) { auto const & selects = it->second; for (auto && [index, value] : selects) { extensionalityInfo.indexValueMap.insert({index, getRoot(value)}); } } } else { // not weak-eq root ERef primaryIndex = getRoot(getIndexFromStore(node.primaryStore)); assert(extensionalityInfos.find(node.primaryEdge) != extensionalityInfos.end()); // Select are the same as primary parent, except possibly at primary index extensionalityInfo = extensionalityInfos.at(node.primaryEdge); extensionalityInfo.erase(primaryIndex); NodeRef weakIRoot = getIndexedRepresentative(current, primaryIndex); auto selectsInfoIt = selectsInfo.find(weakIRoot); if (selectsInfoIt != selectsInfo.end()) { auto const & weakIRootSelects = selectsInfoIt->second; auto it = weakIRootSelects.find(primaryIndex); if (it != weakIRootSelects.end()) { ERef valueAtPrimaryIndex = getRoot(it->second); extensionalityInfo.indexValueMap.insert({primaryIndex, valueAtPrimaryIndex}); } else { extensionalityInfo.weakIRoots.insert({primaryIndex, weakIRoot}); } } else { extensionalityInfo.weakIRoots.insert({primaryIndex, weakIRoot}); } } auto it = inverseExtensionalityInfos.find(extensionalityInfo); if (it != inverseExtensionalityInfos.end()) { equalitiesToPropagate.push({current, it->second}); it->second = current; } else { inverseExtensionalityInfos.insert({extensionalityInfo, current}); } extensionalityInfos.insert({current, std::move(extensionalityInfo)}); } for (auto const & entry : equalitiesToPropagate) { PTRef extensionalityClause = computeExtensionalityClause(entry.first, entry.second); assert(logic.isOr(extensionalityClause)); // TODO: handle conflicts better: We pass literals twice now. // TODO: looks like the above graph traversal could be terminated early if a clause is all-falsified Pterm & literals = logic.getPterm(extensionalityClause); bool allFalsified = std::all_of(literals.begin(), literals.end(), [this](PTRef lit) { bool negated = logic.isNot(lit); PTRef atom = negated ? logic.getPterm(lit)[0] : lit; assert(logic.isEquality(atom)); return negated ? isSatisfied(atom) : isFalsified(atom); }); if (allFalsified) { has_explanation = true; explanation.clear(); for (PTRef lit : literals) { if (logic.isNot(lit)) { explanation.push({logic.getPterm(lit)[0], l_True}); } else { explanation.push({lit, l_False}); } } splitondemand.clear(); return TRes::UNSAT; } splitondemand.push(extensionalityClause); } return TRes::SAT; } PTRef ArraySolver::computeExtensionalityClause(NodeRef n1, NodeRef n2) { Traversal traversal(*this); ExplanationCollection explanationCollection; IndicesCollection indicesCollection; ExplanationCursor source(traversal, n1, getNode(n1).term); ExplanationCursor destination(traversal, n2, getNode(n2).term); source.collectPrimaries(destination, indicesCollection, explanationCollection); for (ERef index : indicesCollection) { explainWeakCongruencePath(explanationCollection, n1, n2, index); } vec args; args.capacity(explanationCollection.size()); for (PtAsgn lit : explanationCollection) { // Explanation collection holds the antecedent for n1 and n2 being equal // For the clause we negate the antecedent literals assert(lit.sgn != l_Undef); args.push(lit.sgn == l_True ? logic.mkNot(lit.tr) : lit.tr); } args.push(getEquality(getNode(n1).term, getNode(n2).term, logic)); return logic.mkOr(std::move(args)); } /* * Somewhat naive way how to compute all read-over-weak-eq lemmas for current WE-graph. * * Every pair of selects with weakly-equivalent array terms needs a corresponding lemma. */ std::vector ArraySolver::collectLemmaConditions(Logic & logic) const { std::unordered_map, ERefHash> indicesToSelects; for (ERef select : selectTerms) { ERef root = getRoot(getIndexFromSelect(select)); indicesToSelects[root].push(select); } std::vector newLemmas; for (auto const & [index, selects] : indicesToSelects) { if (selects.size() < 2) { continue; } // TODO: Figure out better way how to compute all candidates for lemmas for (auto first : selects) { ERef firstRoot = getRoot(first); for (auto secondIt = selects.begin(); *secondIt != first; ++secondIt) { ERef second = *secondIt; if (firstRoot == getRoot(second)) { continue; } // The selects are already the same, no lemma needed NodeRef arrayFirst = getNodeRef(getRoot(getArrayFromSelect(first))); NodeRef arraySecond = getNodeRef(getRoot(getArrayFromSelect(second))); if (arrayFirst == arraySecond or getIndexedRepresentative(arrayFirst, index) == getIndexedRepresentative(arraySecond, index)) { std::unordered_set undecidedEqualities; PTRef equalityOfSelects = getEquality(first, second, logic); if (not isFalsified(equalityOfSelects)) { assert(not isSatisfied(equalityOfSelects)); undecidedEqualities.insert(equalityOfSelects); } auto storeIndices = Traversal(*this).computeStoreIndices(arrayFirst, arraySecond, index); for (ERef storeIndex : storeIndices) { assert(storeIndex != index); PTRef equalityOfIndices = getEquality(index, storeIndex, logic); if (not isFalsified(equalityOfIndices)) { assert(not isSatisfied(equalityOfIndices)); undecidedEqualities.insert(equalityOfIndices); } } newLemmas.emplace_back(equalityOfSelects, std::move(undecidedEqualities)); } } } } return newLemmas; } /* * Collect the store indices on the path from array1 to array2 using only indices different from index. */ std::unordered_set ArraySolver::Traversal::computeStoreIndices(NodeRef array1, NodeRef array2, ERef index) const { assert(index == getRoot(index)); Cursor cursor1(getSolver(), array1); Cursor cursor2(getSolver(), array2); std::unordered_set indices; auto steps1 = cursor1.countSecondaryEdges(index); auto steps2 = cursor2.countSecondaryEdges(index); while (steps1 > steps2) { cursor1.collectOneSecondary(indices, index); --steps1; } while (steps2 > steps1) { cursor2.collectOneSecondary(indices, index); --steps2; } while (findSecondaryNode(cursor1.getCurrentNodeRef(), index) != findSecondaryNode(cursor2.getCurrentNodeRef(), index)) { cursor1.collectOneSecondary(indices, index); cursor2.collectOneSecondary(indices, index); } cursor1.collectOverPrimaries(indices, cursor2.getCurrentNodeRef()); return indices; } void ArraySolver::computeExplanation(PTRef equality) { auto conflictExplanation = readOverWeakEquivalenceConflict(equality); has_explanation = true; explanation.clear(); for (auto lit : conflictExplanation) { explanation.push(lit); } } /* * Compute the literals representing the negation of a read-over-weak-eq lemma, i.e., the conflict, for the given * equality in the current context. */ ArraySolver::ExplanationCollection ArraySolver::readOverWeakEquivalenceConflict(PTRef equality) { assert(logic.isEquality(equality)); PTRef lhs = logic.getPterm(equality)[0]; PTRef rhs = logic.getPterm(equality)[1]; assert(logic.isArraySelect(lhs)); assert(logic.isArraySelect(rhs)); ERef array1 = egraph.termToERef(logic.getPterm(lhs)[0]); ERef array2 = egraph.termToERef(logic.getPterm(rhs)[0]); ERef index1 = egraph.termToERef(logic.getPterm(lhs)[1]); ERef index2 = egraph.termToERef(logic.getPterm(rhs)[1]); // collect literals explaining why array1 is weakly equivalent to array2 ERef root1 = getRoot(index1); auto lemma = explainWeakEquivalencePath(array1, array2, root1); // collect literals explaining why index1 is equivalent to index2 in Egraph if (index1 != index2) { recordExplanationOfEgraphEquivalence(lemma, index1, index2); } // collect literals explaining why index1 is equivalent to its root if (root1 != index1) { recordExplanationOfEgraphEquivalence(lemma, index1, root1); } // add literal asserting that the selects are not equal lemma.insert({equality, l_False}); return lemma; } /* * Explain why the two input arrays are weakly equivalent on index "index". * Since they are weakly equivalent on "index", the selects "array1[index]" and "array2[index]" must have the same value. * * @returns The collection of literals that guarantees the i-weak equivalence */ ArraySolver::ExplanationCollection ArraySolver::explainWeakEquivalencePath(ERef array1, ERef array2, ERef index) { assert(getRoot(index) == index); NodeRef node1 = getNodeRef(getRoot(array1)); NodeRef node2 = getNodeRef(getRoot(array2)); assert(getIndexedRepresentative(node1, index) == getIndexedRepresentative(node2, index)); Traversal traversal(*this); IndicesCollection storeIndices; ExplanationCollection explanations; auto count1 = traversal.countSecondaryEdges(node1, index); auto count2 = traversal.countSecondaryEdges(node2, index); ExplanationCursor cursor1(traversal, node1, array1); ExplanationCursor cursor2(traversal, node2, array2); while (count1 > count2) { cursor1.collectOneSecondary(index, storeIndices, explanations); --count1; } while (count2 > count1) { cursor2.collectOneSecondary(index, storeIndices, explanations); --count2; } while (traversal.findSecondaryNode(cursor1.getCurrentNodeRef(), index) != traversal.findSecondaryNode(cursor2.getCurrentNodeRef(), index)) { cursor1.collectOneSecondary(index, storeIndices, explanations); cursor2.collectOneSecondary(index, storeIndices, explanations); } cursor1.collectPrimaries(cursor2, storeIndices, explanations); for (ERef storeIndex : storeIndices) { PTRef eq = getEquality(storeIndex, index, logic); if (eq != logic.getTerm_false()) { explanations.insert(PtAsgn(eq, l_False)); } } return explanations; } void ArraySolver::clear() { lemmas.clear(); selectsInfo.clear(); nodes.clear(); rootsMap.clear(); valid = false; has_explanation = false; explanation.clear(); } /* * Collect the explanation from Egraph why two terms are equivalent */ void ArraySolver::recordExplanationOfEgraphEquivalence(ExplanationCollection & explanationCollection, ERef lhs, ERef rhs) const { assert(getRoot(lhs) == getRoot(rhs)); auto egraphExplanation = egraph.explainer->explain(lhs, rhs); for (PtAsgn lit : egraphExplanation) { explanationCollection.insert(lit); } } void ArraySolver::explainWeakCongruencePath(ExplanationCollection & explanationCollection, NodeRef source, NodeRef target, ERef index) { ERef indexRoot = getRoot(index); if (index != indexRoot) { recordExplanationOfEgraphEquivalence(explanationCollection, index, indexRoot); index = indexRoot; } NodeRef sourceRepresentative = getIndexedRepresentative(source, index); NodeRef targetRepresentative = getIndexedRepresentative(target, index); if (sourceRepresentative == targetRepresentative) { explanationCollection.merge(explainWeakEquivalencePath(getNode(source).term, getNode(target).term, index)); return; } assert(selectsInfo.count(sourceRepresentative) > 0); assert(selectsInfo.count(targetRepresentative) > 0); ERef sourceSelect = selectsInfo.find(sourceRepresentative)->second.at(index); ERef targetSelect = selectsInfo.find(targetRepresentative)->second.at(index); auto explainPathToSelect = [&](ERef select, ERef arrayTerm) { ERef selectArray = getArrayFromSelect(select); explanationCollection.merge(explainWeakEquivalencePath(arrayTerm, selectArray, index)); recordExplanationOfEgraphEquivalence(explanationCollection, index, getIndexFromSelect(select)); }; explainPathToSelect(sourceSelect, getNode(source).term); explainPathToSelect(targetSelect, getNode(target).term); assert(getRoot(sourceSelect) == getRoot(targetSelect)); if (sourceSelect != targetSelect) { recordExplanationOfEgraphEquivalence(explanationCollection, sourceSelect, targetSelect); } } unsigned int ArraySolver::Traversal::countSecondaryEdges(NodeRef start, ERef index) const { assert(getRoot(index) == index); unsigned count = 0; NodeRef currentRef = start; while (getNode(currentRef).primaryEdge != NodeRef_Undef) { auto const & currentNode = getNode(currentRef); auto primaryIndex = getRoot(solver.getIndexOfPrimaryEdge(currentRef)); if (primaryIndex == index) { if (currentNode.secondaryEdge == NodeRef_Undef) { break; } else { currentRef = currentNode.secondaryEdge; ++count; } } else { currentRef = currentNode.primaryEdge; } } return count; } NodeRef ArraySolver::Traversal::findSecondaryNode(NodeRef nodeRef, ERef index) const { assert(getRoot(index) == index); while (getNode(nodeRef).primaryEdge != NodeRef_Undef and getRoot(getIndexOfPrimaryEdge(nodeRef)) != index) { nodeRef = getNode(nodeRef).primaryEdge; } return nodeRef; } void ArraySolver::Cursor::collectOneSecondary(IndicesCollection & indices, ERef index) { NodeRef secondaryNode = traversal.findSecondaryNode(currentNodeRef, index); ERef store = getNode(secondaryNode).secondaryStore; auto & solver = traversal.getSolver(); ERef array = solver.getArrayFromStore(store); NodeRef arrayNode = solver.getNodeRef(solver.getRoot(array)); NodeRef storeNode = solver.getNodeRef(solver.getRoot(store)); if (traversal.findSecondaryNode(arrayNode, index) == secondaryNode) { collectOverPrimaries(indices, arrayNode); currentNodeRef = storeNode; } else if (traversal.findSecondaryNode(storeNode, index) == secondaryNode) { collectOverPrimaries(indices, storeNode); currentNodeRef = arrayNode; } else { // TODO: change to assert and avoid the second check after verifying this is true throw std::logic_error("Unreachable!"); } indices.insert(solver.getIndexFromStore(store)); } unsigned int ArraySolver::Traversal::countPrimaryEdges(NodeRef start) const { unsigned count = 0; NodeRef current = start; while (getNode(current).primaryEdge != NodeRef_Undef) { current = getNode(current).primaryEdge; ++count; } return count; } void ArraySolver::Cursor::collectOverPrimaries(IndicesCollection & indices, NodeRef destination) { // compute the steps to the common root auto steps1 = countPrimaryEdges(); auto steps2 = Cursor(traversal.getSolver(),destination).countPrimaryEdges(); // if one needs more step than the other, follow the primary edges until the steps equal while (steps1 > steps2) { indices.insert(traversal.getIndexOfPrimaryEdge(currentNodeRef)); currentNodeRef = getNode(currentNodeRef).primaryEdge; steps1--; } while (steps2 > steps1) { indices.insert(traversal.getIndexOfPrimaryEdge(destination)); destination = getNode(destination).primaryEdge; steps2--; } // now follow the primary edge from both nodes until the common ancestor is found while (currentNodeRef != destination) { indices.insert(traversal.getIndexOfPrimaryEdge(currentNodeRef)); indices.insert(traversal.getIndexOfPrimaryEdge(destination)); currentNodeRef = getNode(currentNodeRef).primaryEdge; destination = getNode(destination).primaryEdge; } } void ArraySolver::ExplanationCursor::collectOneSecondary( ERef index, IndicesCollection & indices, ExplanationCollection & explanations) { NodeRef secondaryRef = traversal.findSecondaryNode(currentNode.ref, index); ERef secondaryStore = traversal.getNode(secondaryRef).secondaryStore; assert(secondaryStore != ERef_Undef); auto & solver = traversal.getSolver(); ERef array = solver.getArrayFromStore(secondaryStore); // We need to find the source of the secondary edge (in the same region as this->node), // collect the primary path to that node, and update the cursor to the target of the secondary edge NodeRef source = solver.getNodeRef(solver.getRoot(array)); NodeRef target = solver.getNodeRef(solver.getRoot(secondaryStore)); ERef sourceTerm = array; ERef targetTerm = secondaryStore; if (traversal.findSecondaryNode(target, index) == secondaryRef) { // We got the source and target wrong, target is the node in the same region as this->node, swap std::swap(source, target); std::swap(sourceTerm, targetTerm); } assert(traversal.findSecondaryNode(source, index) == secondaryRef); ExplanationCursor cursor(traversal, source, sourceTerm); collectPrimaries(cursor, indices, explanations); currentNode = {target, targetTerm}; indices.insert(solver.getIndexFromStore(secondaryStore)); } void ArraySolver::ExplanationCursor::collectPrimaries(ExplanationCursor & destination, IndicesCollection & indices, ExplanationCollection & explanations) { auto count1 = traversal.countPrimaryEdges(currentNode.ref); auto count2 = traversal.countPrimaryEdges(destination.currentNode.ref); while (count1 > count2) { collectOnePrimary(indices, explanations); --count1; } while (count2 > count1) { destination.collectOnePrimary(indices, explanations); --count2; } while (currentNode.ref != destination.currentNode.ref) { collectOnePrimary(indices, explanations); destination.collectOnePrimary(indices, explanations); } if (currentNode.term != destination.currentNode.term) { // Same array node but not same Enode traversal.getSolver().recordExplanationOfEgraphEquivalence(explanations, currentNode.term, destination.currentNode.term); } } void ArraySolver::ExplanationCursor::collectOnePrimary(IndicesCollection & indices, ExplanationCollection & explanations) { auto const & solver = traversal.getSolver(); ERef store = traversal.getNode(currentNode.ref).primaryStore; ERef source = store; ERef target = solver.getArrayFromStore(store); if (solver.getNodeRef(solver.getRoot(source)) != currentNode.ref) { std::swap(source, target); } assert(solver.getNodeRef(solver.getRoot(source)) == currentNode.ref); if (currentNode.term != source) { solver.recordExplanationOfEgraphEquivalence(explanations, currentNode.term, source); } indices.insert(traversal.getSolver().getIndexFromStore(store)); // MB: This must be the real index, not its root! currentNode = {traversal.getNode(currentNode.ref).primaryEdge, target}; } opensmt-2.5.2/src/tsolvers/axdiffsolver/ArraySolver.h000066400000000000000000000304301445011647600230030ustar00rootroot00000000000000/* * Copyright (c) 2021-2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #ifndef OPENSMT_ARRAYSOLVER_H #define OPENSMT_ARRAYSOLVER_H #include "TSolver.h" #include "Egraph.h" /* * This is an implementation of a theory solver for the theory of arrays with extensionality. * It is based on the idea of weak equivalence of arrays as presented in the paper * "Weakly Equivalent Arrays" (https://link.springer.com/chapter/10.1007/978-3-319-24246-0_8). * The implementation follows from a large part the implementation in SMTInterpol * (https://github.com/ultimate-pa/smtinterpol), and differs significantly from the description in the paper. * * The main data structure is a weak equivalence graph where nodes represent array terms and they are connected by two * types of edges: * 1. Strong edges, when the terms are equal in the current context (known from Egraph) * 2. Weak edges that connects a `store` term with the underlying array term. * * In fact, in the implementation, the WE-graph is re-built when the context of strong equivalence changes * (new equality is asserted to Egraph). Thus, the nodes in WE-graph actually represents whole equivalence classes * (not individual terms). * * Two arrays are weakly equivalent if they are connected by a path in the WE-graph. If two arrays are weakly equivalent * then they can differ only on finitely many indices. In fact, they can differ only on the indices of store terms * corresponding to the weak edges on the path. * * To check consistency of the axioms of the theory of arrays, even finer concept is used: i-weak equivalence * (for index i). Two arrays are i-weakly equivalent if they are connected by a path that does not use index i * (nor any index equivalent to i). If this is the case, then the two arrays must have the same value at index i. * This is captured by first types of lemmas: read-over-weak-eq. * The second types of lemmas are extensionality lemmas which captures that when two arrays actually have * the same elements, then the arrays are equal. This condition is harder to check, but in the end can be * detected from WE-graph: if there is a path between two arrays such that they are weakly CONGRUENT on all store * indices of that path. * Weak congruence is a weaker concept than weak equivalence. * For example, "a" and "(store a i (select a i))" are weakly congruent on i, but not weakly equivalent on i. * The implementation uses a trick how to detect if two arrays are weakly congruent, but then it uses the proper * definition to actually collect the conditions and build the extensionality lemma. * * NOTE: The paper distinguishes the cases when element theory is stably infinite or not. * Our implementation for now assumes that the element theory IS stably infinite. * * The implementation also assumes that for each store term `(store a i v)` the instance of the identity * select-over-store axiom has been added to the formula: `(= v (select i (store a i v)))`. * This is currently done in the preprocessing. */ struct NodeRef { unsigned int id; }; const struct NodeRef NodeRef_Undef = {UINT32_MAX}; inline bool operator==(NodeRef a, NodeRef b) { return a.id == b.id; } inline bool operator!=(NodeRef a, NodeRef b) { return a.id != b.id; } struct NodeRefHash { uint32_t operator()(NodeRef ref) const { return ref.id; } }; /* * Node in the WE-graph. * It remembers * 1. The corresponding array term (root of its equivalence class) * 2. Parent node following the primary edge and store term that is the cause of this edge * 3. Node following the secondary edge and the store term that is the cause of this edge */ struct ArrayNode { ERef term {ERef_Undef}; NodeRef primaryEdge {NodeRef_Undef}; ERef primaryStore {ERef_Undef}; NodeRef secondaryEdge {NodeRef_Undef}; ERef secondaryStore {ERef_Undef}; explicit ArrayNode(ERef term) : term(term) {} }; /* * Class representing both the theory solver and the WE-graph (MB: This should probably be split) */ class ArraySolver : public TSolver { Logic & logic; Egraph & egraph; // MB: Array solver needs egraph to be able to work with the current (strong) equivalence context using Terms = std::set; Terms arrayTerms; Terms storeTerms; Terms selectTerms; // WE-graph std::vector nodes; std::unordered_map rootsMap; // Whether or not WE-graph has been built for current context bool valid = false; vec assertedLiterals; public: ArraySolver(Logic & logic, Egraph & egraph, SMTConfig & config); ~ArraySolver() = default; void clearSolver() override; bool assertLit(PtAsgn asgn) override; void pushBacktrackPoint() override; void popBacktrackPoint() override; void popBacktrackPoints(unsigned int i) override; TRes check(bool b) override; void fillTheoryFunctions(ModelBuilder & builder) const override; void computeModel() override; void getConflict(vec & vec) override; void declareAtom(PTRef tr) override; Logic & getLogic() override; bool isValid(PTRef tr) override; void getNewSplits(vec & splits) override; /* * Internal methods for traversing weak equivalence graph */ private: using IndicesCollection = std::unordered_set; using ExplanationCollection = std::unordered_set; /* * Helper class for traversing the WE-graph. * Maybe this should actually properly represent the WE-graph instead of ArraySolver having the WE-graph representation */ class Traversal { ArraySolver const & solver; public: Traversal(ArraySolver const & solver) : solver(solver) {} ArraySolver const & getSolver() const { return solver; } ArrayNode const & getNode(NodeRef ref) const { return solver.getNode(ref); } ERef getRoot(ERef term) const { return solver.getRoot(term); } NodeRef findSecondaryNode(NodeRef node, ERef index) const; unsigned countSecondaryEdges(NodeRef start, ERef index) const; unsigned countPrimaryEdges(NodeRef start) const; std::unordered_set computeStoreIndices(NodeRef, NodeRef, ERef) const; ERef getIndexOfPrimaryEdge(NodeRef node) const { return solver.getIndexOfPrimaryEdge(node); } }; /* * Represents a position in the WE-graph and can move towards the root of (i-)weak equivalence class * while collecting store indices encountered. */ class Cursor { Traversal traversal; NodeRef currentNodeRef; public: Cursor(ArraySolver const & solver, NodeRef node) : traversal(solver), currentNodeRef(node) {} NodeRef getCurrentNodeRef() const { return currentNodeRef; } ArrayNode const & getNode(NodeRef ref) const { return traversal.getNode(ref); } unsigned countSecondaryEdges(ERef index) const { return traversal.countSecondaryEdges(currentNodeRef, index); } unsigned countPrimaryEdges() const { return traversal.countPrimaryEdges(currentNodeRef); } void collectOneSecondary(IndicesCollection & indices, ERef index); void collectOverPrimaries(IndicesCollection & indices, NodeRef destination); }; /* * Similar to Cursor, but also collects explanations why terms are (weakly or strongly) equivalent. */ class ExplanationCursor { Traversal const & traversal; struct CurrentNode { NodeRef ref = NodeRef_Undef; ERef term = ERef_Undef; }; CurrentNode currentNode; public: ExplanationCursor(Traversal const & traversal, NodeRef node, ERef term) : traversal(traversal), currentNode{node, term} {} NodeRef getCurrentNodeRef() const { return currentNode.ref; } void collectPrimaries(ExplanationCursor & destination, IndicesCollection & indices, ExplanationCollection & explanations); void collectOnePrimary(IndicesCollection & indices, ExplanationCollection & explanations); void collectOneSecondary(ERef index, IndicesCollection & indices, ExplanationCollection & explanations); }; /* * Internal methods for building weak equivalence graph and computing lemma consequences of the graph */ private: struct LemmaConditions { PTRef equality; std::unordered_set undecidedEqualities; public: LemmaConditions(PTRef equality, std::unordered_set && undecidedEqualities) : equality(equality), undecidedEqualities(std::move(undecidedEqualities)) {} }; std::vector lemmas; using SelectsInfo = std::unordered_map, NodeRefHash>; SelectsInfo selectsInfo; PTRef getEquality(ERef lhs, ERef rhs, Logic & logic) const { return logic.mkEq(egraph.ERefToTerm(lhs), egraph.ERefToTerm(rhs)); } bool isFalsified(PTRef equality) const { return logic.isFalse(equality) or (this->hasPolarity(equality) and this->getPolarity(equality) == l_False); } bool isSatisfied(PTRef equality) const { return logic.isTrue(equality) or (this->hasPolarity(equality) and this->getPolarity(equality) == l_True); } void computeExplanation(PTRef equality); ExplanationCollection readOverWeakEquivalenceConflict(PTRef equality); PTRef computeExtensionalityClause(NodeRef n1, NodeRef n2); void explainWeakCongruencePath(ExplanationCollection & explanationCollection, NodeRef source, NodeRef target, ERef index); ExplanationCollection explainWeakEquivalencePath(ERef array1, ERef array2, ERef index); void recordExplanationOfEgraphEquivalence(ExplanationCollection & explanationCollection, ERef lhs, ERef rhs) const; std::vector collectLemmaConditions(Logic & logic) const; void computeSelectsInfo(); TRes checkExtensionality(); void buildWeakEq(); void merge(ERef); void mergeSecondary(NodeRef, NodeRef, ERef, std::unordered_set && forbiddenIndices); void clear(); ERef getArrayFromStore(ERef storeTerm) const { PTRef ptref = egraph.ERefToTerm(storeTerm); assert(logic.isArrayStore(ptref)); PTRef arrayPTerm = logic.getPterm(ptref)[0]; return egraph.termToERef(arrayPTerm); } ERef getIndexFromStore(ERef storeTerm) const { PTRef ptref = egraph.ERefToTerm(storeTerm); assert(logic.isArrayStore(ptref)); PTRef indexPTerm = logic.getPterm(ptref)[1]; return egraph.termToERef(indexPTerm); } ERef getIndexFromSelect(ERef selectTerm) const { PTRef ptref = egraph.ERefToTerm(selectTerm); assert(logic.isArraySelect(ptref)); PTRef indexPTerm = logic.getPterm(ptref)[1]; return egraph.termToERef(indexPTerm); } ERef getArrayFromSelect(ERef selectTerm) const { PTRef ptref = egraph.ERefToTerm(selectTerm); assert(logic.isArraySelect(ptref)); PTRef arrayPTerm = logic.getPterm(ptref)[0]; return egraph.termToERef(arrayPTerm); } ERef getRoot(ERef term) const { return egraph.getRoot(term); } ArrayNode & getNode(NodeRef ref) { return nodes[ref.id]; } ArrayNode const & getNode(NodeRef ref) const { return nodes[ref.id]; } NodeRef getNodeRef(ERef root) const { auto it = rootsMap.find(root); assert(it != rootsMap.end()); return it->second; } void makeWeakRepresentative(NodeRef); void makeIndexedWeakRepresentative(NodeRef); NodeRef getRepresentative(NodeRef nodeRef) const { while (getNode(nodeRef).primaryEdge != NodeRef_Undef) { nodeRef = getNode(nodeRef).primaryEdge; } return nodeRef; } ERef getIndexOfPrimaryEdge(NodeRef node) const { return getIndexFromStore(getNode(node).primaryStore); } NodeRef getIndexedRepresentative(NodeRef nodeRef, ERef index) const { ArrayNode const & node = getNode(nodeRef); if (node.primaryEdge == NodeRef_Undef) { return nodeRef; } if (getRoot(getIndexOfPrimaryEdge(nodeRef)) != index) { return getIndexedRepresentative(node.primaryEdge, index); } if (node.secondaryEdge == NodeRef_Undef) { return nodeRef; } return getIndexedRepresentative(node.secondaryEdge, index); } }; #endif //OPENSMT_ARRAYSOLVER_H opensmt-2.5.2/src/tsolvers/axdiffsolver/CMakeLists.txt000066400000000000000000000002251445011647600231200ustar00rootroot00000000000000target_sources(tsolvers PUBLIC "${CMAKE_CURRENT_LIST_DIR}/ArraySolver.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/ArraySolver.cc" )opensmt-2.5.2/src/tsolvers/axdiffsolver/RewriteEngine.cc000066400000000000000000002751061445011647600234520ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #include "RewriteEngine.h" #include #define PRINT_EXPL_DOT 0 // Dump explanation graphs in dotty format #define LESS_R1 1 bool RewriteEngine::lessThan( Enode * l, Enode * r ) { assert( l->isVar( ) ); assert( r->isVar( ) ); #ifdef PRODUCE_PROOF if ( config.produce_inter == 0 ) return l->getId( ) < r->getId( ); // Custom lt has precedence Pair( Enode * ) p = make_pair( l, r ); if ( custom_lt.find( p ) != custom_lt.end( ) ) return true; // Interpolating version const ipartitions_t & l_parts = l->getIPartitions( ); const ipartitions_t & r_parts = r->getIPartitions( ); assert( l_parts != 0 ); assert( r_parts != 0 ); assert( (l_parts & r_parts) != 0 ); // if it's 0 means AB-mixed // Same partition, choose by id if ( l_parts == r_parts ) return l->getId( ) < r->getId( ); if ( isABcommon( l ) ) return true; assert ( isABcommon( r ) ); return false; #else // Non interpolating version return l->getId( ) < r->getId( ); #endif } bool RewriteEngine::greaterThan( Enode * l, Enode * r ) { return lessThan( r, l ); } // // Orient a rule. Returns // 0 if orientation was done // 1 if badly orientable rule found // 2 if badly orientable interpolating rule found // 3 if badly orientable to be rotated // 4 if invariant breaking rule // int RewriteEngine::orient( Enode **l, Enode **r ) { bool swap = false; // Two variables in wrong order if ( (*l)->isVar( ) && (*r)->isVar( ) && lessThan( *l, *r ) ) { swap = true; } else if ( (*r)->isSelect( ) ) { assert( (*l)->isVar( ) ); swap = true; } else if ( (*l)->isStore( ) ) { assert( (*r)->isVar( ) ); swap = true; } else if ( (*r)->isDiff( ) ) { assert( (*l)->isVar( ) ); swap = true; } if ( swap ) { Enode * tmp = (*l); (*l) = (*r); (*r) = tmp; } // // Check if badly orientable equality // Cases // rd( c, i ) = d // diff( a, b ) = d // where lhs is AB-common, rhs is A-local/B-local // This cases should never happen because of // preprocessing // if ( (*r)->isStore( ) ) { Enode * inner_var = (*r); while ( !inner_var->isVar( ) ) inner_var = inner_var->get1st( ); #if PRODUCE_PROOF if ( config.produce_inter != 0 ) { const bool cond1 = isABcommon( *l ) && ( isAlocal( *r ) || isBlocal( *r ) ); const bool cond2 = !greaterThan( (*l), inner_var ); if ( cond1 && cond2 ) return 3; // Badly orientable to be rotated else if ( cond1 ) return 2; // Badly orientable not to be rotated else if ( cond2 ) return 1; // To be rotated } else #endif if ( !greaterThan( (*l), inner_var ) ) return 1; } return 0; } void RewriteEngine::check( const bool index_total ) { #if SPLIT_ON_DEMAND candidate = NULL; nof_idxs = 0; #endif (void)index_total; assert( status == l_Undef ); // To avoid redundant explanations seen_in_expl.clear( ); // Clear reduced diffs reduced_diffs.clear( ); // Save current state pushBacktrackPoint( ); if ( config.verbosity > 2 ) cerr << "# Loading ELEM equalities (and doing completion)" << endl; // Load accumulated Equalities for ( size_t i = 0 ; i < select_equalities_to_add.size( ) && status == l_Undef ; i ++ ) { // Can turn status to l_False addGroundRule( select_equalities_to_add[ i ]->get1st( ) , select_equalities_to_add[ i ]->get2nd( ) , select_equalities_to_add[ i ] ); } if ( config.verbosity > 2 ) cerr << "# Loading ARRAY equalities (and doing completion)" << endl; for ( size_t i = 0 ; i < store_equalities_to_add.size( ) && status == l_Undef ; i ++ ) { // Can turn status to l_False addGroundRule( store_equalities_to_add[ i ]->get1st( ) , store_equalities_to_add[ i ]->get2nd( ) , store_equalities_to_add[ i ] ); #if OUTSPLIT if ( new_idx ) { goto out_split; new_idx = false; } #endif } assert( status == l_Undef || status == l_False ); #if REDUCE_TO_EUF vector< Enode * > eqs_to_unset; vector< Enode * > eqs_to_deassert; bool res = true; egraph.extPushBacktrackPoint( ); /* * NO NEED ! REMEMBER EQ-LAYERING ... * // Send all negated equalities to EUF for ( size_t i = 0 ; i < neq_list.size( ) ; i ++ ) egraph.extAssertLit( neq_list[ i ] ); */ // Now send all equalities within eqs_to_antec to EUF for ( map< Enode *, vector< Enode * > >::iterator it = eqs_to_antec.begin( ) ; it != eqs_to_antec.end( ) && res ; it ++ ) { Enode * eq = it->first; if ( !eq->hasPolarity( ) ) { eq->setPolarity( l_True ); assert( eq->hasPolarity( ) ); eqs_to_unset.push_back( eq ); } // cerr << "ASSERTING IN EQ: " << eq << endl; res = egraph.extAssertLit( eq ); } // cerr << "RES IS: " << res << endl; bool deduced = false; vector< Enode * > saved_deds; // if ( res ) // deduced = egraph.deduceMore( saved_deds ); egraph.extPopBacktrackPoint( ); if ( !res ) { /* cerr << "EXPLANATION IS: " << endl; // Send all negated equalities to EUF for ( size_t i = 0 ; i < explanation.size( ) ; i ++ ) cerr << (explanation[ i ]->getPolarity( ) == l_False ? " !":" " ) << explanation[ i ] << endl; */ // minimizeExplanation( ); // cerr << "MINIMIZED EXPLANATION IS: " << endl; // Send all negated equalities to EUF // for ( size_t i = 0 ; i < explanation.size( ) ; i ++ ) // cerr << " " << explanation[ i ] << endl; vector< Enode * > tmp_explanation; tmp_explanation.swap( explanation ); map< Enode *, vector< Enode * > >::iterator it; for ( size_t i = 0 ; i < tmp_explanation.size( ) ; i ++ ) { it = eqs_to_antec.find( tmp_explanation[ i ] ); if ( it != eqs_to_antec.end( ) ) { explanation.insert( explanation.end( ) , (it->second).begin( ) , (it->second).end( ) ); } else { explanation.push_back( tmp_explanation[ i ] ); } } sort( explanation.begin( ), explanation.end( ) ); vector< Enode * >::iterator new_end = unique( explanation.begin( ), explanation.end( ) ); explanation.erase( new_end, explanation.end( ) ); /* cerr << "FINAL EXPLANATION IS: " << endl; // Send all negated equalities to EUF for ( size_t i = 0 ; i < explanation.size( ) ; i ++ ) cerr << (explanation[ i ]->getPolarity( ) == l_False ? " !":" " ) << explanation[ i ] << endl; */ status = l_False; } else { if ( deduced ) { deductions.insert( deductions.end( ) , saved_deds.begin( ) , saved_deds.end( ) ); } #if SPLIT_ON_DEMAND // const bool deduced = false; else if ( index_total && candidate != NULL ) { cerr << "GENERATED CANDIDATE: " << candidate << endl; egraph.splitOnDemand( candidate, id ); } #endif status = l_True; } // Reset custom polarities while ( !eqs_to_unset.empty( ) ) { Enode * eq = eqs_to_unset.back( ); eqs_to_unset.pop_back( ); eq->resetPolarity( ); } // Clear eqs_to_antec eqs_to_antec.clear( ); #else // REDUCE_TO_EUF #ifdef PRODUCE_PROOF // Call interpolating version of check if ( config.produce_inter != 0 ) { computeIdxEqClasses( ); bo_to_skip.clear( ); fixBadSelect( ); fixBadlyOrientable( ); iCheck( 0 ); if ( status == l_False ) { explanation.clear( ); explanation.insert( explanation.end( ) , acc_expl.begin( ) , acc_expl.end( ) ); // Remove duplicates sort( explanation.begin( ), explanation.end( ) ); vector< Enode * >::iterator new_end = unique( explanation.begin( ), explanation.end( ) ); explanation.erase( new_end, explanation.end( ) ); } if ( status == l_False ) { assert( checkInterpolant( interpolant ) ); // Undo definitions for( int i = def_stack.size( ) - 1 ; i >= 0 ; i -- ) { Enode * r_prime = def_stack[ i ]; assert( definitions.find( r_prime ) != definitions.end( ) ); Enode * l = definitions[ r_prime ]; assert( isABcommon( l ) ); egraph.initDupMap1( ); egraph.storeDupMap1( r_prime, l ); interpolant = substitute( interpolant ); egraph.doneDupMap1( ); } assert( checkInterpolant( interpolant ) ); if ( config.verbosity > 3 ) cerr << "# Interpolant: " << interpolant << endl; } } else { check_( ground_rules, neq_list ); } #else check_( ground_rules, neq_list ); #endif #if OUTSPLIT out_split: status = l_True; #endif #endif // REDUCE_TO_EUF assert( status == l_False || status == l_True ); assert( status == l_True || !explanation.empty( ) ); popBacktrackPoint( ); } #if REDUCE_TO_EUF void RewriteEngine::minimizeExplanation( ) { assert( !explanation.empty( ) ); vector< Enode * > orig_expl; vector< bool > redundant; // Save aside explanation orig_expl.swap( explanation ); redundant.resize( orig_expl.size( ), false ); vector< Enode * > non_redundant; size_t candidate = 0; while ( candidate < orig_expl.size( ) ) { // Save state egraph.extPushBacktrackPoint( ); cerr << "Check if: " << orig_expl[ candidate ] << " is red ... " << endl; bool res = true; // Load equalities for ( size_t i = 0 ; i < orig_expl.size( ) && res ; i ++ ) { // skip candidate if ( candidate == i ) continue; // skip already proven redundant if ( redundant[ i ] ) continue; cerr << " loading: " << orig_expl[ i ] << endl; res = egraph.extAssertLit( orig_expl[ i ] ); } // Accumulate non redundant if ( res ) non_redundant.push_back( orig_expl[ candidate ] ); // Redundant if still unsat else { redundant[ candidate ] = true; explanation.clear( ); } cerr << (res?"not redundant":"redundant") << endl; // Save state egraph.extPopBacktrackPoint( ); // Next candidate, if any candidate ++; } explanation.swap( non_redundant ); assert( !explanation.empty( ) ); } #endif // // Actual check on the current set of rules // void RewriteEngine::check_( ground_rules_t & g_rules , vector< Enode * > & n_list ) { while( status == l_Undef ) { // Exhaustively apply C3, which is not considered in addAndComplete applyC3( g_rules ); // Apply reduction const bool reduced = reduction( g_rules ); // Continue to completion again if some reduction was done if ( reduced ) continue; // Check failure conditions; turns status into l_False or l_True failure( g_rules, n_list ); assert( status == l_True || status == l_False ); } } // // Iterates over the rule database and // look for applications of C3 rule. // Accumulates all the pairs, compute // critical pairs and restart until // saturation // void RewriteEngine::applyC3( ground_rules_t & g_rules ) { if ( config.verbosity > 3 ) { cerr << "# Applications of C3 ..." << endl; } vector< RewriteRule * > postponed; bool saturated = false; while ( !saturated ) { saturated = true; // // Iterates over the ground rules to // see if there is anything to be done // for ( ground_rules_t::iterator it = g_rules.begin( ) ; it != g_rules.end( ) ; it ++ ) { RewriteRule * r_i = it->second; if ( !r_i->lhs->isSelect( ) ) continue; Enode * a = r_i->lhs->get1st( ); vector< RewriteRule * > r_antec; vector< Enode * > e_antec; r_antec.push_back( r_i ); Enode * rew_a = rewriteGround( g_rules, a, r_antec, e_antec ); if ( a != rew_a ) { // Postpone Case 3 postponed.push_back( r_i ); } } while( !postponed.empty( ) ) { RewriteRule * r_i = postponed.back( ); postponed.pop_back( ); vector< RewriteRule * > r_antec; vector< Enode * > e_antec; r_antec.push_back( r_i ); Enode * a = r_i->lhs->get1st( ); Enode * rew_a = rewriteGround( g_rules, a, r_antec, e_antec ); assert( a != rew_a ); Enode * rew_lhs = egraph.mkSelect( rew_a, r_i->lhs->get2nd( ) ); Enode * rew_lhs_p = rewrite( g_rules, rew_lhs, r_antec, e_antec ); Enode * rew_rhs = rewrite( g_rules, r_i->rhs, r_antec, e_antec ); #ifdef PRODUCE_PROOF assert( config.produce_inter == 0 || rew_lhs_p->getIPartitions( ) != 0 ); assert( config.produce_inter == 0 || rew_lhs->getIPartitions( ) != 0 ); #endif if ( rew_rhs != rew_lhs_p ) { if ( config.verbosity > 3 ) { cerr << "# Case 3 applies for" << endl << "# " << rew_lhs_p << " <-- " << rew_lhs << " <--" << r_i << endl; } addGroundRule( rew_lhs_p, rew_rhs, NULL, g_rules, r_antec, e_antec ); disableGroundRule( g_rules, r_i ); saturated = false; } } } } bool RewriteEngine::reduction( ground_rules_t & g_rules ) { if ( config.verbosity > 3 ) { cerr << "# Applications of R2 and R3 ..." << endl; } // // Condition (R1) is implicit // // // Condition (R2) // vector< RewriteRule * > rules_to_process; bool reduced = false; for ( ground_rules_t::iterator it = g_rules.begin( ) ; it != g_rules.end( ) ; it ++ ) { RewriteRule * rule = it->second; if ( rule->lhs->getRetSort( ) != egraph.getSortArray( ) ) continue; if ( !rule->rhs->isStore( ) ) continue; rules_to_process.push_back( rule ); } while ( !rules_to_process.empty( ) ) { RewriteRule * rule = rules_to_process.back( ); rules_to_process.pop_back( ); vector< RewriteRule * > r_antec; vector< Enode * > e_antec; // Nothing should happen, but just to make sure ... Enode * nf = rewrite( g_rules, rule->rhs, r_antec, e_antec ); r_antec.push_back( rule ); Enode * b = nf; while ( b->isStore( ) ) b = b->get1st( ); set< Enode * > indexes_to_remove; vector< Enode * > indexes; vector< Enode * > elements; while ( nf->isStore( ) ) { // If rd(b,i) ~ e Enode * e = nf->get3rd( ); Enode * i = nf->get2nd( ); indexes.push_back( i ); elements.push_back( e ); Enode * rd = egraph.mkSelect( b, getRoot( i ) ); vector< RewriteRule * > tmp1; vector< Enode * > tmp2; rd = rewrite( g_rules, rd, tmp1, tmp2 ); e = rewrite( g_rules, e , tmp1, tmp2 ); if ( rd == e ) indexes_to_remove.insert( i ); nf = nf->get1st( ); } if ( !indexes_to_remove.empty( ) ) { Enode * new_rhs = nf; while ( !indexes.empty( ) ) { Enode * i = indexes.back( ); Enode * e = elements.back( ); indexes.pop_back( ); elements.pop_back( ); // Not adding this if ( indexes_to_remove.find( i ) != indexes_to_remove.end( ) ) continue; Enode * old_rhs = new_rhs; new_rhs = egraph.mkStore( old_rhs, i, e ); } reduced = true; disableGroundRule( g_rules, rule ); addGroundRule( rule->lhs , new_rhs , NULL , g_rules , r_antec , e_antec ); } } // // Condition (R3) // // Scan through the diff list // for ( size_t i = 0 ; i < diff_list.size( ) ; i ++ ) { #if 1 break; #endif // Prevents loops if ( reduced_diffs.find( i ) != reduced_diffs.end( ) ) continue; Enode * index = diff_list[ i ]->rhs; vector< Enode * > matches; set< Enode * > seen; Enode * a = diff_list[ i ]->lhs->get1st( ); Enode * b = diff_list[ i ]->lhs->get2nd( ); assert( a->isVar( ) ); assert( b->isVar( ) ); assert( a != b ); // Make it such that a > b if ( lessThan( a, b ) ) { Enode * tmp = a; a = b; b = tmp; } vector< RewriteRule * > r_antec; vector< Enode * > e_antec; #ifdef PRODUCE_PROOF // Internal rules don't need explanations if ( config.produce_inter == 0 || internals.find( diff_list[ i ] ) == internals.end( ) ) #endif /* egraph.explain( diff_list[ i ]->lhs , diff_list[ i ]->rhs , e_antec ); */ indexExplain( diff_list[ i ]->lhs , diff_list[ i ]->rhs , e_antec ); Enode * ra = egraph.mkSelect( a, index ); Enode * rb = egraph.mkSelect( b, index ); Enode * rew_ra = rewrite( g_rules, ra, r_antec, e_antec ); Enode * rew_rb = rewrite( g_rules, rb, r_antec, e_antec ); if ( rew_ra == rew_rb ) { addGroundRule( a, b, NULL, g_rules, r_antec, e_antec ); // Prevents loops reduced_diffs.insert( i ); reduced = true; } } if ( config.verbosity > 3 ) { if ( reduced ) cerr << "# Something was reduced" << endl; else cerr << "# Nothing was reduced" << endl; } return reduced; } void RewriteEngine::failure( ground_rules_t & g_rules , vector< Enode * > & n_list ) { if ( config.verbosity > 3 ) cerr << "# Checking failure" << endl; // // Condition (U1) // for ( size_t i = 0 ; i < n_list.size( ) ; i ++ ) { Enode * lhs = n_list[ i ]->get1st( ); Enode * rhs = n_list[ i ]->get2nd( ); vector< RewriteRule * > r_antec; vector< Enode * > e_antec; assert( lhs->isVar( ) ); assert( rhs->isVar( ) ); lhs = rewrite( g_rules, lhs, r_antec, e_antec ); rhs = rewrite( g_rules, rhs, r_antec, e_antec ); if ( lhs == rhs ) { if ( config.verbosity > 3 ) cerr << "# Failure found" << endl; #ifdef PRODUCE_PROOF assert( config.produce_inter != 0 || n_list[ i ]->hasPolarity( ) ); #endif // Neq is in conflict if ( seen_in_expl.insert( n_list[ i ] ).second && n_list[ i ]->hasPolarity( ) ) { assert( n_list[ i ]->getPolarity( ) == l_False ); explanation.push_back( n_list[ i ] ); } #ifdef PRODUCE_PROOF if ( config.produce_inter != 0 ) { Enode * neq = NULL; if ( ( turn_A && isBlocal( n_list[ i ] ) ) || ( !turn_A && isAlocal( n_list[ i ] ) ) ) { neq = n_list[ i ]; } interpolate( neq, r_antec ); } #endif // Compute conflict explain( r_antec ); // Set status false status = l_False; return; } } // // Condition (U2) // for ( size_t i = 0 ; i + 1 < diff_list.size( ) ; i ++ ) { for ( size_t j = i + 1 ; j < diff_list.size( ) ; j ++ ) { Enode * diff = diff_list[ i ]->lhs; Enode * idx = diff_list[ i ]->rhs; Enode * diff_p = diff_list[ j ]->lhs; Enode * idx_p = diff_list[ j ]->rhs; if ( idx == idx_p ) continue; Enode * a = diff->get1st( ); Enode * b = diff->get2nd( ); Enode * a_p = diff_p->get1st( ); Enode * b_p = diff_p->get2nd( ); vector< RewriteRule * > r_antec; vector< Enode * > e_antec; a = rewrite( g_rules, a, r_antec, e_antec ); b = rewrite( g_rules, b, r_antec, e_antec ); a_p = rewrite( g_rules, a_p, r_antec, e_antec ); b_p = rewrite( g_rules, b_p, r_antec, e_antec ); if ( a == a_p && b == b_p ) { explain( r_antec ); } } } if ( config.verbosity > 3 ) cerr << "# No failure" << endl; // Everything went fine status = l_True; } void RewriteEngine::addIndexEq( Enode * e ) { assert( e->isEq( ) ); assert( e->getPolarity( ) == l_True ); // Save state pushBacktrackPoint( ); // Add rule to the set of index rules vector< RewriteRule * > r_antec; addIndexRule( e->get1st( ) , e->get2nd( ) , e , r_antec ); // Use rule to simplify current ground rules assert( ground_rules.empty( ) ); // We don't know about the status status = l_Undef; } void RewriteEngine::remIndexEq( Enode * e ) { assert( e->isEq( ) ); assert( e->getPolarity( ) == l_True ); (void)e; // Restore state prior to eq popBacktrackPoint( ); // We don't know about the status status = l_Undef; } void RewriteEngine::addIndexRule( Enode * l , Enode * r , Enode * e , vector< RewriteRule * > & r_antec ) { orient( &l, &r ); vector< Enode * > e_antec; RewriteRule * rule = new RewriteRule( l, r, e, r_antec, e_antec ); if ( l->isDiff( ) ) { diff_list.push_back( rule ); assert( diff_to_index.find( l ) == diff_to_index.end( ) ); diff_to_index[ l ] = r; #ifdef PRODUCE_PROOF assert( config.produce_inter == 0 || !isABcommon( l->get1st( ) ) || !isABcommon( l->get2nd( ) ) || isABcommon( r ) ); #endif } undo_stack_oper.push_back( ADD_INDEX_RULE ); undo_stack_term.push_back( rule ); if ( config.verbosity > 3 ) { cerr << "# (+) " << rule; // cerr << " " << rule->partitions; cerr << endl; } // We don't know about the status status = l_Undef; } void RewriteEngine::addEq ( Enode * e ) { assert( e->isEq( ) ); assert( e->getPolarity( ) == l_True ); // Save equality for later assert( e->get1st( )->getRetSort( ) == egraph.getSortElem( ) || e->get1st( )->getRetSort( ) == egraph.getSortArray( ) ); if ( e->get1st( )->getRetSort( ) == egraph.getSortElem( ) ) select_equalities_to_add.push_back( e ); else store_equalities_to_add.push_back( e ); // We don't know about the status status = l_Undef; } void RewriteEngine::remEq( Enode * e ) { assert( e->isEq( ) ); assert( e->getPolarity( ) == l_True ); (void)e; if ( e->get1st( )->getRetSort( ) == egraph.getSortElem( ) ) select_equalities_to_add.pop_back( ); else store_equalities_to_add.pop_back( ); // We don't know about the status status = l_Undef; } void RewriteEngine::addGroundRule( Enode * l, Enode * r, Enode * e ) { assert( e ); vector< RewriteRule * > r_antec; vector< Enode * > e_antec; #if REDUCE_TO_EUF config.incremental = true; e_antec.push_back( e ); if ( l->getRetSort( ) == egraph.getSortElem( ) ) { l = rewriteGeneric( l, e_antec ); r = rewriteGeneric( r, e_antec ); #if SPLIT_ON_DEMAND const bool condl = l->isSelect( ) && l->get1st( )->isStore( ); const bool condr = r->isSelect( ) && r->get1st( )->isStore( ); const bool cond = candidate == NULL && (l != r) && ( condl || condr ); assert( !condl || !condr ); if ( cond ) { Enode * sel = condl ? l : r; Enode * a = sel->get1st( ); size_t idxs = 0; while ( a->isStore( ) ) { idxs ++; a = a->get1st( ); } if ( idxs > nof_idxs ) { candidate = egraph.mkEq( egraph.cons( sel->get2nd( ) , egraph.cons( sel->get1st( )->get2nd( ) ) ) ); nof_idxs = idxs; } } #endif Enode * eq = egraph.mkEq( egraph.cons( l , egraph.cons( r ) ) ); // Useless if ( eq == e ) return; // Useless if ( eq->isTrue( ) ) return; // Already there, do not add if ( eqs_to_antec.find( eq ) != eqs_to_antec.end( ) ) return; assert( !eq->isFalse( ) ); assert( eqs_to_antec.find( eq ) == eqs_to_antec.end( ) ); /* cerr << "PRODUCED: " << eq << endl; cerr << " FROM: " << e << endl; cerr << " using: " << endl; for ( size_t i = 0 ; i < e_antec.size( ) ; i ++ ) { cerr << " " << e_antec[ i ] << endl; } */ eqs_to_antec[ eq ] = e_antec; } #else // REDUCE_TO_EUF // Rewrite to simplify stores and selects generically #if LESS_R1 // // Avoids store simplification // if ( l->getRetSort( ) != egraph.getSortArray( ) ) { #endif l = rewriteGeneric( l, e_antec ); r = rewriteGeneric( r, e_antec ); #if LESS_R1 } #endif assert( !l->isSelect( ) || l->get1st( )->isVar( ) ); assert( !r->isSelect( ) || r->get1st( )->isVar( ) ); bool is_A = true; #ifdef PRODUCE_PROOF assert( l->getIPartitions( ) != 0 ); assert( r->getIPartitions( ) != 0 ); if ( config.produce_inter != 0 ) is_A = isAlocal( l ) || isAlocal( r ) || isAlocal( e ); #else (void)is_A; #endif addGroundRule( l // lhs , r // rhs , e // Reason for rule #ifdef PRODUCE_PROOF , is_A ? ground_rules // Select A : ground_rules_b // Select B #else , ground_rules #endif , r_antec // Empty antecedent reason , e_antec // Empty neq reason ); #endif // REDUCE_TO_EUF } void RewriteEngine::addGroundRule( Enode * l , Enode * r , Enode * e , ground_rules_t & g_rules , vector< RewriteRule * > & r_antec , vector< Enode * > & e_antec ) { #ifdef PRODUCE_PROOF assert( config.produce_inter == 0 || l->getIPartitions( ) != 0 ); assert( config.produce_inter == 0 || r->getIPartitions( ) != 0 ); #endif // Save sizes to restore later const size_t r_antec_size = r_antec.size( ); const size_t e_antec_size = e_antec.size( ); assert( status == l_Undef ); // Now indexes are different iff they are syntactically different l = rewriteGeneric( l, e_antec ); r = rewriteGeneric( r, e_antec ); if ( l == r ) { r_antec.resize( r_antec_size ); e_antec.resize( e_antec_size ); return; } if ( r->isVar( ) && l->isStore( ) ) { Enode * tmp = l; l = r; r = tmp; } const int badly_oriented = orient( &l, &r ); // Check orientation w.r.t. ordering if ( badly_oriented != 0 ) { assert( badly_oriented == 1 || badly_oriented == 2 || badly_oriented == 3 ); if ( badly_oriented == 2 ) { #ifdef PRODUCE_PROOF // Postpone processing assert( config.produce_inter > 0 ); // addBadlyOrientable( l, r, e, r_antec, e_antec ); // MOD // return; #endif } else if ( badly_oriented == 1 || badly_oriented == 3 ) { // Standard or interpolating badly orientable equality to be rotated Enode * a = l; Enode * b = r; assert( a->isVar( ) ); assert( b->isStore( ) ); vector< Enode * > indexes; vector< Enode * > elements; while( b->isStore( ) ) { Enode * i = b->get2nd( ); indexes.push_back( i ); elements.push_back( b->get3rd( ) ); b = b->get1st( ); } // Reflexivity applies if ( a == b ) { for ( size_t i = 0 ; i < indexes.size( ) ; i ++ ) { // Adds rd( a, I ) = E Enode * sel = egraph.mkSelect( a, indexes[ i ] ); addAndComplete( sel, elements[ i ], NULL, g_rules, r_antec, e_antec ); } return; } // Symmetry applies else { // // We have // a = wr( b, I, D ) /\ rd( b, I ) = E // // We need to construct // b = wr( a, I, E ) /\ rd( a, I ) = D // Enode * st = a; for ( size_t i = 0 ; i < indexes.size( ) ; i ++ ) { Enode * sel = egraph.mkSelect( b, indexes[ i ] ); Enode * old_st = st; st = egraph.mkStore( old_st , indexes[ i ] , sel ); // Also add rd( a, i ) = e needed by symmetry Enode * sym_sel = egraph.mkSelect( a, indexes[ i ] ); addAndComplete( sym_sel, elements[ i ], e , g_rules , r_antec , e_antec ); } vector< RewriteRule * > tmp1; vector< Enode * > tmp2; // Here we rewrite things like // rd( a, i ) // into // d // because of asserted eqs in // preprocessing for indexes in store st = rewrite( g_rules, st, tmp1, tmp2 ); l = b; r = st; #ifdef PRODUCE_PROOF if ( badly_oriented == 3 ) { if ( isABcommon( l ) && !isABcommon( r ) ) { // addBadlyOrientable( l, r, e, r_antec, e_antec ); // MOD // return; } } #endif } } } // Add rule and trigger other completion // steps C1,C2,C4,C5 (C3 is handled in check) addAndComplete( l, r, e, g_rules, r_antec, e_antec ); } // // This function takes care of critical pairs C1, C2, C4, C5 // C3 will be handled by function applyC3 once all other rules // have been produced // void RewriteEngine::addAndComplete( Enode * l , Enode * r , Enode * e , ground_rules_t & g_rules , vector< RewriteRule * > & r_antec_old , vector< Enode * > & e_antec_old , const bool propagated ) { #ifdef PRODUCE_PROOF assert( config.produce_inter == 0 || l->getIPartitions( ) != 0 ); assert( config.produce_inter == 0 || r->getIPartitions( ) != 0 ); #endif #ifdef PRODUCE_PROOF if ( config.produce_inter != 0 && l->isSelect( ) && isABcommon( l ) && !isABcommon( r ) ) { addBadSelect( l, r, e, r_antec_old, e_antec_old ); return; } #endif Enode * key = l; if ( l->isSelect( ) ) key = egraph.mkSelect( l->get1st( ) , getRoot( l->get2nd( ) ) ); map< Enode *, RewriteRule * >::iterator it = g_rules.find( key ); bool safely_add = it == g_rules.end( ); // Apply (R1) eagerly if ( safely_add ) { #if LESS_R1 // // Avoids R1 on stores // if ( !r->isStore( ) ) #endif r = rewrite( g_rules, r, r_antec_old, e_antec_old ); } // Create rule RewriteRule * new_rule = new RewriteRule( l, r, e, r_antec_old, e_antec_old, propagated ); #ifdef PRODUCE_PROOF assert( config.produce_inter == 0 || isAlocal( new_rule ) || isBlocal( new_rule ) ); assert( config.produce_inter == 0 || !isAlocal( new_rule ) || &g_rules == &ground_rules ); assert( config.produce_inter == 0 || !isBlocal( new_rule ) || &g_rules == &ground_rules_b ); #endif // printRules( g_rules ); // // Case 1, lhs is not yet part of a rule, safely add // if ( safely_add ) { g_rules[ key ] = new_rule; #ifdef PRODUCE_PROOF if ( isAlocal( new_rule ) ) { #endif undo_stack_oper.push_back( ADD_GROUND_RULE ); undo_stack_term.push_back( new_rule ); #ifdef PRODUCE_PROOF } else { undo_stack_oper.push_back( ADD_GROUND_B_RULE ); undo_stack_term.push_back( new_rule ); } #endif if ( config.verbosity > 3 ) { cerr << "# (+) " << new_rule; cerr << endl; } #ifdef PRODUCE_PROOF // Check if propagation is needed if ( config.produce_inter != 0 && isABcommon( l ) && isABcommon( r ) && !propagated ) { assert( isAlocal( new_rule ) || isBlocal( new_rule ) ); vector< RewriteRule * > r_antec; vector< Enode * > e_antec; r_antec.push_back( new_rule ); assert( isAlocal( new_rule ) || isBlocal( new_rule ) ); // Propagate rule to B if ( isAlocal( new_rule ) ) addAndComplete( l, r, e, ground_rules_b, r_antec, e_antec, true ); // Progagate rule to A else addAndComplete( l, r, e, ground_rules, r_antec, e_antec, true ); } // Check if badly orientable if ( r->isStore( ) ) { Enode * inner_var = r; while ( !inner_var->isVar( ) ) inner_var = inner_var->get1st( ); if ( config.produce_inter != 0 ) { // It is badly orientable if ( isABcommon( l ) && ( isAlocal( r ) || isBlocal( r ) ) ) { #if OUTSPLIT if ( addNewIdx( l, inner_var ) ) return; #endif badly_orientable.push_back( new_rule ); undo_stack_oper.push_back( ADD_BADLY_ORIENTABLE ); undo_stack_term.push_back( new_rule ); } } } #endif return; } // Disable one parent rule (we just do not insert new_rule) undo_stack_oper.push_back( ADD_DISABLED_GROUND_RULE ); undo_stack_term.push_back( new_rule ); // // Case 2, lhs is already there --> critical pair found // RewriteRule * r_i = it->second; RewriteRule * r_j = new_rule; // Rules is already there, let's just get out of here if ( r_i->lhs == r_j->lhs && r_i->rhs == r_j->rhs ) { return; } if ( config.verbosity > 4 ) { cerr << "# CRITICAL PAIR FOUND " << endl; cerr << "# " << r_i << endl; cerr << "# " << r_j << " (not in database)" << endl; } vector< RewriteRule * > r_antec; r_antec.push_back( r_i ); r_antec.push_back( r_j ); vector< Enode * > e_antec; // For bad selects, need to add explanation if ( r_i->lhs != r_j->lhs ) { assert( r_i->lhs->isSelect( ) ); assert( r_j->lhs->isSelect( ) ); assert( r_i->lhs->get2nd( ) != r_j->lhs->get2nd( ) ); // egraph.explain( r_i->lhs->get2nd( ), r_j->lhs->get2nd( ), e_antec ); indexExplain( r_i->lhs->get2nd( ), r_j->lhs->get2nd( ), e_antec ); } Enode * rew_ri = rewrite( g_rules, r_i->rhs, r_antec, e_antec ); Enode * rew_rj = rewrite( g_rules, r_j->rhs, r_antec, e_antec ); // Case (C1) or (C2) if ( rew_ri->isStore( ) || rew_rj->isStore( ) ) { if ( !storeEquiv( rew_ri, rew_rj ) ) { // In C1 and C2 both parent rules are to be removed. // Disable already existing disableGroundRule( g_rules, r_i ); // Apply cases C1 or C2. Calls addGroundRule inside applyC1C2( g_rules, r_i->lhs, rew_ri, rew_rj, r_antec, e_antec ); } } // Case (C4) or (C5) else { addGroundRule( rew_ri , rew_rj , NULL , g_rules , r_antec , e_antec ); } } #if OUTSPLIT bool RewriteEngine::addNewIdx( Enode * l, Enode * r ) { Enode * diff = egraph.mkDiff( l, r ); if ( diff_to_index.find( diff ) != diff_to_index.end( ) ) return false; // Otherwise create new diff Enode * idx = freshVarFrom( diff ); Enode * diff_eq = egraph. } #endif void RewriteEngine::applyC1C2( ground_rules_t & g_rules , Enode * var , Enode * rew_ri , Enode * rew_rj , vector< RewriteRule * > & r_antec , vector< Enode * > & e_antec ) { Enode * a = rew_ri; Enode * b = rew_rj; vector< Enode * > a_indexes; vector< Enode * > b_indexes; map< Enode *, Enode * > a_idx_to_elem; map< Enode *, Enode * > b_idx_to_elem; set< Enode * > a_root_indexes; set< Enode * > ab_root_indexes; // // Remark 1: because of canonization of store terms, // there are no syntactic duplicates within stores. // However there may be semantic duplicates due to // indexes which we did not rewrite // // First step, we understand if its a C1 or a C2 // At the same time we gather indexes in a and in b // while( a->isStore( ) ) { a_indexes.push_back( a->get2nd( ) ); a_idx_to_elem[ a->get2nd( ) ] = a->get3rd( ); a_root_indexes.insert( getRoot( a->get2nd( ) ) ); a = a->get1st( ); } while( b->isStore( ) ) { b_indexes.push_back( b->get2nd( ) ); b_idx_to_elem[ b->get2nd( ) ] = b->get3rd( ); if ( a_root_indexes.find( getRoot( b->get2nd( ) ) ) != a_root_indexes.end( ) ) ab_root_indexes.insert( getRoot( b->get2nd( ) ) ); b = b->get1st( ); } assert( a->isVar( ) ); assert( b->isVar( ) ); // // OK Cool. Now we have // // a_indexes : list of indexes appearing in rew_ri // b_indexes : " rew_rj // a_idx_to_elem : map from rew_ri indexes to elements // b_idx_to_elem : " rew_rj " // ab_root_indexes : roots of indexes in common, basically I // // Thery are equal: it's a Case (C2) // if ( a == b ) { // // We have to apply Confl lemma. So we need to // understand what is I, J, H, E, E', D, F // // Also we have to create // var --> wr( a, I, E ) // That's what we do next // vector< Enode * > i_indexes; vector< Enode * > j_indexes; vector< Enode * > h_indexes; Enode * wr_term = a; for ( int i = a_indexes.size( ) - 1 ; i >= 0 ; i -- ) { // Index not in I if ( ab_root_indexes.find( getRoot( a_indexes[ i ] ) ) == ab_root_indexes.end( ) ) { j_indexes.push_back( a_indexes[ i ] ); continue; } i_indexes.push_back( a_indexes[ i ] ); wr_term = egraph.mkStore( wr_term, a_indexes[ i ], a_idx_to_elem[ a_indexes[ i ] ] ); } // // We add var --> wr( a, I, E ) to the set of rules now // addGroundRule( var, wr_term, NULL, g_rules, r_antec, e_antec ); // // Adds all E = E' // for ( size_t i = 0 ; i < i_indexes.size( ) ; i ++ ) { bool found = false; for ( size_t j = 0 ; j < b_indexes.size( ) ; j ++ ) { // Found match if ( getRoot( b_indexes[ j ] ) == getRoot( i_indexes[ i ] ) ) { const size_t e_antec_size = e_antec.size( ); // Explain if necessary if ( b_indexes[ j ] != i_indexes[ i ] ) { indexExplain( b_indexes[ j ], i_indexes[ i ], e_antec ); // egraph.explain( b_indexes[ j ], i_indexes[ i ], e_antec ); } addGroundRule( b_idx_to_elem[ b_indexes[ j ] ] , a_idx_to_elem[ i_indexes[ i ] ] , NULL , g_rules , r_antec , e_antec ); // Resize back if necessary if ( b_indexes[ j ] != i_indexes[ i ] ) e_antec.resize( e_antec_size ); found = true; } else h_indexes.push_back( b_indexes[ i ] ); } assert( found ); } // // Adds all rd(a,J) = D // for ( size_t i = 0 ; i < j_indexes.size( ) ; i ++ ) { Enode * j = j_indexes[ i ]; Enode * d = a_idx_to_elem[ j ]; // This select on rew_rj for the purpose of // automatically detect index predicates to // use in e_antec of the generated rule Enode * sel = egraph.mkSelect( rew_rj, j ); addGroundRule( sel, d, NULL, g_rules, r_antec, e_antec ); } // // Adds all rd(b,H) = F // for ( size_t i = 0 ; i < h_indexes.size( ) ; i ++ ) { Enode * h = h_indexes[ i ]; Enode * f = b_idx_to_elem[ h ]; // This select on rew_ri for the purpose of // automatically detect index predicates to // use in e_antec of the generated rule Enode * sel = egraph.mkSelect( rew_ri, h ); addGroundRule( sel, f, NULL, g_rules, r_antec, e_antec ); } } // Case (C1) else { // Notice that w.r.t. the paper we have // // a is b_1 // b is b_2 // var is a // // Swap structures if a < b if ( lessThan( a, b ) ) { // Swap store terms Enode * tmp = rew_ri; rew_ri = rew_rj; rew_rj = tmp; // Swap a and b tmp = a; a = b; b = tmp; // Swap index collection a_indexes.swap( b_indexes ); // Swap index maps a_idx_to_elem.swap( b_idx_to_elem ); } // Now we have that a > b, and a is in rew_ri // Step 1: apply symm to var = rew_rj // we start from the outermost index Enode * new_store = rew_rj; for ( size_t i = 0 ; i < a_indexes.size( ) ; i ++ ) { // Save sizes const size_t r_antec_size = r_antec.size( ); const size_t e_antec_size = e_antec.size( ); // First adds rd( var, i ) = e Enode * read_var_i = egraph.mkSelect( var, a_indexes[ i ] ); Enode * e = a_idx_to_elem[ a_indexes[ i ] ]; addGroundRule( read_var_i, e, NULL, g_rules, r_antec, e_antec ); // Second, construct store term Enode * read_a_i = egraph.mkSelect( a, a_indexes[ i ] ); Enode * f = rewrite( g_rules, read_a_i, r_antec, e_antec ); Enode * old_store = new_store; (void)old_store; new_store = egraph.mkStore( new_store, a_indexes[ i ], f ); // Restore sizes r_antec.resize( r_antec_size ); e_antec.resize( e_antec_size ); } // Adds rule var --> var_store( rew_ri ) addGroundRule( a, new_store, NULL, g_rules, r_antec, e_antec ); // Adds rule var --> rew_rj addGroundRule( var, rew_rj, NULL, g_rules, r_antec, e_antec ); } } void RewriteEngine::pushBacktrackPoint ( ) { // Save solver state if required assert( undo_stack_oper.size( ) == undo_stack_term.size( ) ); backtrack_points.push_back( undo_stack_oper.size( ) ); } void RewriteEngine::popBacktrackPoint ( ) { assert( backtrack_points.size( ) > 0 ); size_t undo_stack_new_size = backtrack_points.back( ); backtrack_points.pop_back( ); backtrackToStackSize( undo_stack_new_size ); } void RewriteEngine::backtrackToStackSize( size_t size ) { while ( undo_stack_oper.size( ) > size ) { oper_t last_action = undo_stack_oper.back( ); RewriteRule * rule = undo_stack_term.back( ); undo_stack_oper.pop_back( ); undo_stack_term.pop_back( ); if ( last_action == ADD_GROUND_RULE ) { if ( config.verbosity > 3 ) cerr << "# (-) " << rule << endl; remFromDatabase( ground_rules, rule ); delete rule; } #ifdef PRODUCE_PROOF else if ( last_action == ADD_DEFINE0 ) { assert( !def_stack.empty( ) ); Enode * last = def_stack.back( ); def_stack.pop_back( ); assert( definitions.find( last ) != definitions.end( ) ); definitions.erase( last ); delete rule; } else if ( last_action == INDEX_MERGE ) { Enode * i = undo_stack_repl.back( ).first; Enode * j = undo_stack_repl.back( ).second; undo_stack_repl.pop_back( ); egraph.tmpMergeEnd( i, j ); assert( getRoot( i ) != getRoot( j ) ); } else if ( last_action == REPLACED_RULE ) { ground_rules_t & g_rules = config.produce_inter == 0 || isAlocal( rule ) ? ground_rules : ground_rules_b ; Enode * key = undo_stack_repl.back( ).first; Enode * new_key = undo_stack_repl.back( ).second; undo_stack_repl.pop_back( ); assert( g_rules.find( new_key ) != g_rules.end( ) ); // Removing this new key g_rules.erase( new_key ); assert( g_rules.find( key ) == g_rules.end( ) ); // Reinserting old key g_rules[ key ] = rule; if ( config.verbosity > 3 ) { cerr << "# (+) " << rule; cerr << endl; } } else if ( last_action == ADD_GROUND_B_RULE ) { if ( config.verbosity > 3 ) cerr << "# (-) " << rule << endl; remFromDatabase( ground_rules_b, rule ); delete rule; } else if ( last_action == ADD_REPL_GROUND_RULE ) { if ( config.verbosity > 3 ) cerr << "# (R) " << rule << endl; remFromDatabase( ground_rules, rule ); } else if ( last_action == ADD_REPL_GROUND_B_RULE ) { if ( config.verbosity > 3 ) cerr << "# (R) " << rule << endl; remFromDatabase( ground_rules_b, rule ); } else if ( last_action == SET_CUSTOM_LT ) { Pair( Enode * ) p = undo_stack_cust.back( ); undo_stack_cust.pop_back( ); assert( custom_lt.find( p ) != custom_lt.end( ) ); custom_lt.erase( p ); } else if ( last_action == PROPAGATE_A_NEQ ) { neq_list.pop_back( ); } else if ( last_action == PROPAGATE_B_NEQ ) { neq_list_b.pop_back( ); } else if ( last_action == ADD_BAD_SELECT ) { assert( !bad_selects.empty( ) ); delete bad_selects.back( ); bad_selects.pop_back( ); } else if ( last_action == ADD_BADLY_ORIENTABLE ) { assert( !badly_orientable.empty( ) ); // delete badly_orientable.back( ); badly_orientable.pop_back( ); } #endif else if ( last_action == ADD_DISABLED_GROUND_RULE ) { delete rule; } /* else if ( last_action == ADD_GENERIC_RULE ) { RewriteRule * r = generic_rules.back( ); generic_rules.pop_back( ); delete r; } */ else if ( last_action == ADD_INDEX_RULE ) { // RewriteRule * r = index_rules.back( ); // index_rules.pop_back( ); if ( rule->lhs->isDiff( ) ) { assert( rule == diff_list.back( ) ); diff_list.pop_back( ); assert( diff_to_index.find( rule->lhs ) != diff_to_index.end( ) ); diff_to_index.erase( rule->lhs ); // assert( index_to_diff.find( r->rhs ) != index_to_diff.end( ) ); // index_to_diff.erase( r->rhs ); } if ( config.verbosity > 3 ) cerr << "# (-) " << rule << endl; delete rule; } else if ( last_action == DISABLE_RULE ) { #ifdef PRODUCE_PROOF ground_rules_t & g_rules = config.produce_inter == 0 || isAlocal( rule ) ? ground_rules : ground_rules_b ; #else ground_rules_t & g_rules = ground_rules; #endif Enode * key = rule->lhs; if ( rule->lhs->isSelect( ) ) key = egraph.mkSelect( rule->lhs->get1st( ) , getRoot( rule->lhs->get2nd( ) ) ); assert( g_rules.find( key ) == g_rules.end( ) ); g_rules[ key ] = rule; if ( config.verbosity > 3 ) { cerr << "# (+) " << rule; cerr << endl; } } } assert( undo_stack_term.size( ) == undo_stack_oper.size( ) ); } Enode * RewriteEngine::rewrite( ground_rules_t & g_rules , Enode * e , vector< RewriteRule * > & r_antec , vector< Enode * > & e_antec ) { assert( e ); bool saturated = false; Enode * result = e; while( !saturated ) { Enode * res = rewriteGeneric( result, e_antec ); res = rewriteGround( g_rules, res, r_antec, e_antec ); saturated = result == res; result = res; } return result; } Enode * RewriteEngine::rewriteGeneric( Enode * e , vector< Enode * > & e_antec ) { assert( e ); #ifdef PRODUCE_PROOF assert( config.produce_inter == 0 || e->getIPartitions( ) != 0 ); #endif if ( e->isVar( ) ) return e; assert( e->isSelect( ) || e->isStore( ) ); Enode * new_e = NULL; if ( e->isSelect( ) ) { // Scan the store term, until the index // is found, or the array variable is found Enode * a = e->get1st( ); Enode * i = e->get2nd( ); while( a->isStore( ) && new_e == NULL ) { Enode * j = a->get2nd( ); // The two indexes are equal modulo eq classes if ( getRoot( i ) == getRoot( j ) ) { // Return overwriting element new_e = a->get3rd( ); // If different indexes, need to explain why so if ( i != j ) // egraph.explain( i, j, e_antec ); indexExplain( i, j, e_antec ); } else { #if 1 || SPLIT_ON_DEMAND Enode * eq = egraph.mkEq( egraph.cons( i , egraph.cons( j ) ) ); // We can simplify further if ( eq->hasPolarity( ) ) { assert( eq->getPolarity( ) == l_False ); e_antec.push_back( eq ); } // We stop simplification else break; #else e_antec.push_back( egraph.mkEq( egraph.cons( i , egraph.cons( j ) ) ) ); assert( config.produce_inter != 0 || e_antec.back( )->hasPolarity( ) ); assert( config.produce_inter != 0 || e_antec.back( )->getPolarity( ) == l_False ); #endif } a = a->get1st( ); } if ( new_e == NULL ) { #if 1 || SPLIT_ON_DEMAND #else assert( a->isVar( ) ); #endif new_e = egraph.mkSelect( a, i ); } // It might be a select, so simplify again else { new_e = rewriteGeneric( new_e, e_antec ); } #if 1 || SPLIT_ON_DEMAND #else assert( new_e->isVar( ) || new_e->get1st( )->isVar( ) ); #endif } else { vector< Enode * > useful_stores; Enode * a = e; egraph.initDup1( ); while ( a->isStore( ) ) { // Old way // Enode * i = a->get2nd( ); // // New way // Notice that we do // not need to store the reason // why a->get2nd( ) = a->get2nd( )->getRoot( ) // // In fact such reasons are to be used only // when reading from a store, as stores on their // own cannot lead to a conflict !. So consider // // b --> wr( wr( a, i, e ), j, d ) // // with i = j. Then we can simply use // // b --> wr( a, j, d ) // // Later if we read on that, we have two cases // // rd( b, j ), in which i = j does not influece // rd( b, i ), in which i = j matters, but it's // already added when simplifying reads // Enode * i = getRoot( a->get2nd( ) ); if ( !egraph.isDup1( i ) ) { useful_stores.push_back( a ); egraph.storeDup1( i ); } a = a->get1st( ); } egraph.doneDup1( ); // Create the sorted term new_e = a; while ( !useful_stores.empty( ) ) { Enode * old_new_e = new_e; Enode * elem = useful_stores.back( )->get3rd( ); #if 1 vector< Enode * > tmp; Enode * rew_elem = rewriteGeneric( elem , tmp ); #else Enode * rew_elem = rewriteGeneric( elem , e_antec ); #endif new_e = egraph.mkStore( new_e , useful_stores.back( )->get2nd( ) , rew_elem ); #ifdef PRODUCE_PROOF checkCanonizedStore( new_e ); #endif (void)old_new_e; useful_stores.pop_back( ); } } #ifdef PRODUCE_PROOF assert( config.produce_inter == 0 || new_e->getIPartitions( ) != 0 ); #endif return new_e; } Enode * RewriteEngine::rewriteGround( ground_rules_t & g_rules , Enode * e , vector< RewriteRule * > & r_antec , vector< Enode * > & e_antec ) { assert( e ); #ifdef PRODUCE_PROOF assert( config.produce_inter == 0 || e->getIPartitions( ) != 0 ); #endif map< Enode *, RewriteRule * > & cache = g_rules; egraph.initDupMap1( ); vector< Enode * > unprocessed_enodes; unprocessed_enodes.push_back( e ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.valDupMap1( enode ) != NULL ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( egraph.valDupMap1( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); Enode * result = NULL; map< Enode *, RewriteRule * >::iterator it; if ( enode->getArity( ) == 0 ) { it = cache.find( enode ); if ( it != cache.end( ) ) { result = it->second->rhs; r_antec.push_back( it->second ); } else { result = enode; } } else if ( enode->isDiff( ) ) { result = enode; } else if ( enode->isSelect( ) ) { Enode * a = egraph.valDupMap1( enode->get1st( ) ); Enode * i = egraph.valDupMap1( enode->get2nd( ) ); Enode * tmp = egraph.mkSelect( a, getRoot( i ) ); it = cache.find( tmp ); if ( it != cache.end( ) ) { result = it->second->rhs; r_antec.push_back( it->second ); assert( it->second->lhs->isSelect( ) ); // Explain if indexes are different if ( it->second->lhs->get2nd( ) != i ) // egraph.explain( i, it->second->lhs->get2nd( ), e_antec ); indexExplain( i, it->second->lhs->get2nd( ), e_antec ); } else { result = egraph.mkSelect( a, i ); } } else if ( enode->isStore( ) ) { Enode * a = egraph.valDupMap1( enode->get1st( ) ); Enode * i = egraph.valDupMap1( enode->get2nd( ) ); Enode * d = egraph.valDupMap1( enode->get3rd( ) ); Enode * tmp = egraph.mkStore( a, i, d ); it = cache.find( tmp ); if ( it != cache.end( ) ) { result = it->second->rhs; r_antec.push_back( it->second ); } else { result = tmp; } } else { assert( false ); } assert( result ); #ifdef PRODUCE_PROOF assert( config.produce_inter == 0 || result->getIPartitions( ) != 0 ); #endif egraph.storeDupMap1( enode, result ); } Enode * new_e = egraph.valDupMap1( e ); assert( new_e ); egraph.doneDupMap1( ); #ifdef PRODUCE_PROOF assert( config.produce_inter == 0 || new_e->getIPartitions( ) != 0 ); #endif return new_e; } void RewriteEngine::disableGroundRule( ground_rules_t & g_rules , RewriteRule * r ) { if ( config.verbosity > 3 ) cerr << "# (-) " << r << endl; // r->enabled = false; undo_stack_oper.push_back( DISABLE_RULE ); undo_stack_term.push_back( r ); remFromDatabase( g_rules, r ); } void RewriteEngine::addNeq( Enode * e ) { assert( e->isEq( ) ); // assert( e->getPolarity( ) == l_False ); if ( e->getRetSort( ) == egraph.getSortArray( ) ) { opensmt_error( "Negated array equalities not handled in the solver" ); } neq_list.push_back( e ); if ( config.verbosity > 3 ) cerr << "# (+) (not " << e << ")" << endl; #ifdef PRODUCE_PROOF if ( config.produce_inter != 0 && isABcommon( e->get1st( ) ) && isABcommon( e->get2nd( ) ) ) { neq_list_b.push_back( e ); undo_stack_oper.push_back( PROPAGATE_B_NEQ ); undo_stack_term.push_back( NULL ); if ( config.verbosity > 3 ) cerr << "# (Propagating to B)" << endl; } #endif // We don't know about the status status = l_Undef; } void RewriteEngine::remNeq( Enode * e ) { (void)e; assert( e->isEq( ) ); #ifdef PRODUCE_PROOF assert( config.produce_inter != 0 || e->getPolarity( ) == l_False ); #else assert( e->getPolarity( ) == l_False ); #endif Enode * tmp = neq_list.back( ); (void)tmp; neq_list.pop_back( ); assert( tmp == e ); // We don't know about the status status = l_Undef; } void RewriteEngine::printNeqs( ) { cerr << "# Negated equalities" << endl; for ( size_t i = 0 ; i < neq_list.size( ) ; i ++ ) cerr << "# " << i + 1 << ": " << neq_list[ i ] << endl; } void RewriteEngine::explain( vector< RewriteRule * > & r_antec ) { #if PRINT_EXPL_DOT static int counter = 0; stringstream ss; ss << "expl_" << counter++ << ".dot"; ofstream out( ss.str( ).c_str( ) ); out << "digraph tmp {" << endl; #endif set< RewriteRule * > seen; while ( !r_antec.empty( ) ) { RewriteRule * r = r_antec.back( ); r_antec.pop_back( ); // Skip already seen if ( !seen.insert( r ).second ) continue; #if PRINT_EXPL_DOT string color = r->partitions == 2 ? "red" : r->partitions == 4 ? "cyan" : r->partitions == 6 ? "green" : "white" ; stringstream ss; ss << "\"" << r->lhs->getId( ) << "_" << r->rhs->getId( ) << "_" << color << "\"" << " [label=\"" << r << "\",style=filled,fillcolor=" << color << "]" << endl; out << ss.str( ); if ( r->reason ) { stringstream se; se << "\"" << r->reason->getId( ) << "_" << color << "\"" << " [label=\"" << r->reason << "\",shape=box,style=filled,fillcolor=" << color << "]" << endl; out << se.str( ); stringstream ss; ss << "\"" << r->lhs->getId( ) << "_" << r->rhs->getId( ) << "_" << color << "\"" << " -> " << "\"" << r->reason->getId( ) << "_" << color << "\""; out << ss.str( ) << ";" << endl; } #endif // Adds eqs for ( vector< RewriteRule * >::iterator it = r->r_antec.begin( ) ; it != r->r_antec.end( ) ; it ++ ) { #if PRINT_EXPL_DOT string color_a = (*it)->partitions == 2 ? "red" : (*it)->partitions == 4 ? "cyan" : (*it)->partitions == 6 ? "green" : "white" ; stringstream ss; ss << "\"" << r->lhs->getId( ) << "_" << r->rhs->getId( ) << "_" << color << "\"" << " -> " << "\"" << (*it)->lhs->getId( ) << "_" << (*it)->rhs->getId( ) << "_" << color_a << "\""; out << ss.str( ) << ";" << endl; #endif r_antec.push_back( *it ); } // Adds neqs for ( vector< Enode * >::iterator it = r->e_antec.begin( ) ; it != r->e_antec.end( ) ; it ++ ) { // If it does not have polarity it measn that it // was created within the theory solver, hence we // don't insert it in the conflict if ( !(*it)->hasPolarity( ) ) continue; #if PRINT_EXPL_DOT stringstream se; se << "\"" << (*it)->getId( ) << "_" << color << "\"" << " [label=\"(not " << (*it) << ")\",shape=box,style=filled,fillcolor=" << color << "]" << endl; out << se.str( ); stringstream ss; ss << "\"" << r->lhs->getId( ) << "_" << r->rhs->getId( ) << "_" << color << "\"" << " -> " << "\"" << (*it)->getId( ) << "_" << color << "\""; out << ss.str( ) << ";" << endl; #endif // assert( (*it)->getPolarity( ) == l_False ); if ( seen_in_expl.insert( *it ).second ) explanation.push_back( *it ); } if ( r->reason ) { if ( seen_in_expl.insert( r->reason ).second ) explanation.push_back( r->reason ); } } #if PRINT_EXPL_DOT out << "}" << endl; out.close( ); #endif if ( config.verbosity > 3 ) { cerr << "# Explanation: " << endl; for ( size_t i = 0 ; i < explanation.size( ) ; i ++ ) { const bool sign = explanation[ i ]->getPolarity( ) == l_False; cerr << "# " << (sign?"(not ":" ") << explanation[ i ] << (sign?")":"") << endl; } } } void RewriteEngine::retrieveIndexes( Enode * e , vector< Enode * > & indexes ) { egraph.initDup1( ); vector< Enode * > unprocessed_enodes; unprocessed_enodes.push_back( e ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.isDup1( enode ) ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( !egraph.isDup1( arg ) ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); // Rule 1 or Rule 2 if ( enode->getRetSort( ) == egraph.getSortIndex( ) ) indexes.push_back( enode ); egraph.storeDup1( enode ); } egraph.doneDup1( ); } void RewriteEngine::remFromDatabase( ground_rules_t & g_rules , RewriteRule * rule ) { Enode * key = rule->lhs; if ( key->isSelect( ) ) key = egraph.mkSelect( key->get1st( ), getRoot( key->get2nd( ) ) ); // cerr << "key: " << key << endl; // printRules( g_rules ); assert( g_rules.find( key ) != g_rules.end( ) ); g_rules.erase( key ); } Enode * RewriteEngine::getRoot( Enode * i ) { return i->getRoot( ); } void RewriteEngine::indexExplain( Enode * i, Enode * j, vector< Enode * > & expl ) { #ifdef PRODUCE_PROOF // We do not explain newly introduced indexes if ( config.produce_inter != 0 && ( new_indexes.find( i ) != new_indexes.end( ) || new_indexes.find( j ) != new_indexes.end( ) ) ) return; #endif egraph.explain( i, j, expl ); } bool RewriteEngine::storeEquiv( Enode * a, Enode * b ) { map< Enode *, Enode * > a_, b_; while ( a->isStore( ) ) { a_[ getRoot( a->get2nd( ) ) ] = a->get3rd( ); a = a->get1st( ); } while ( b->isStore( ) ) { b_[ getRoot( b->get2nd( ) ) ] = b->get3rd( ); b = b->get1st( ); } if ( a != b ) return false; for ( map< Enode *, Enode * >::iterator it = a_.begin( ) ; it != a_.end( ) ; it ++ ) { if ( b_[ it->first ] != it->second ) return false; } return true; } // // Functions for interpolation go here ! // #ifdef PRODUCE_PROOF // // Replace old_i with new_i in rules // void RewriteEngine::replaceIndexInRules( ground_rules_t & g_rules , Enode * old_i , Enode * new_i ) { assert( getRoot( old_i ) != getRoot( new_i ) ); assert( config.produce_inter != 0 ); vector< RewriteRule * > rules; for ( ground_rules_t::iterator it = g_rules.begin( ) ; it != g_rules.end( ) ; it ++ ) { Enode * key = it->first; if ( key->isVar( ) ) continue; assert( key->isSelect( ) ); // We need to replace this if ( key->get2nd( ) == getRoot( old_i ) ) { rules.push_back( it->second ); } } // Remove all rules to be removed for ( size_t k = 0 ; k < rules.size( ) ; k ++ ) { RewriteRule * rule = rules[ k ]; disableGroundRule( g_rules, rule ); } old_i = getRoot( old_i ); new_i = getRoot( new_i ); assert( getRoot( old_i ) != getRoot( new_i ) ); egraph.tmpMergeBegin( old_i, new_i ); assert( getRoot( old_i ) == getRoot( new_i ) ); undo_stack_oper.push_back( INDEX_MERGE ); undo_stack_term.push_back( NULL ); undo_stack_repl.push_back( make_pair( old_i, new_i ) ); // Reinsert rules for ( size_t k = 0 ; k < rules.size( ) ; k ++ ) { RewriteRule * rule = rules[ k ]; addAndComplete( rule, g_rules ); } } void RewriteEngine::informIdx( Enode * e ) { assert( config.produce_inter != 0 ); idx_list.push_back( e ); } void RewriteEngine::computeIdxEqClasses( ) { assert( config.produce_inter != 0 ); for ( size_t i = 0 ; i < idx_list.size( ) ; i ++ ) { Enode * idx = idx_list[ i ]; if ( isAlocal( getIndexParts( idx ) ) ) idx_eq_classes_a.insert( getRoot( idx ) ); if ( isBlocal( getIndexParts( idx ) ) ) idx_eq_classes_b.insert( getRoot( idx ) ); } } bool RewriteEngine::areNewIdx( Enode * i, Enode * j ) { return new_indexes.find( i ) != new_indexes.end( ) || new_indexes.find( j ) != new_indexes.end( ); } void RewriteEngine::interpolate( Enode * neq , vector< RewriteRule * > & r_antec ) { assert( config.produce_inter != 0 ); Enode * interp = NULL; // assert( !explanation.empty( ) ); // Unsat happened in A interp = turn_A ? egraph.mkFalse( ) : egraph.mkTrue( ); ipartitions_t partitions = turn_A ? 2 : 4; bool done = false; set< RewriteRule * > seen; vector< RewriteRule * > rev_frontier = r_antec; // Recursively explore the antecedents to construct interpolant list< Enode * > psi_list; // Push negated equality if ( neq ) psi_list.push_back( neq ); while( !done ) { vector< RewriteRule * > new_frontier; while( !rev_frontier.empty( ) ) { RewriteRule * rule = rev_frontier.back( ); rev_frontier.pop_back( ); // Don't process already seen rules if ( !seen.insert( rule ).second ) continue; // Skip indexes if ( rule->lhs->getRetSort( ) == egraph.getSortIndex( ) ) continue; // Node of the same partition, expand further if ( rule->partitions == partitions ) { rev_frontier.insert( rev_frontier.end( ) , rule->r_antec.begin( ) , rule->r_antec.end( ) ); } // Otherwise Exchange happend. Store equality // We skip AB because they are indexes else { new_frontier.push_back( rule ); psi_list.push_back( egraph.mkEq( egraph.cons( rule->lhs , egraph.cons( rule->rhs ) ) ) ); } } // Update interpolant and // swap partitions, we have crossed the frontier ! assert( partitions == 2 || partitions == 4 ); Enode * psi = egraph.mkAnd( egraph.cons( psi_list ) ); if ( partitions == 2 ) { // Exchange 2 interp = egraph.mkImplies( egraph.cons( psi, egraph.cons( interp ) ) ); partitions = 4; } else if ( partitions == 4 ) { // Exchange 1 interp = egraph.mkAnd( egraph.cons( psi, egraph.cons( interp ) ) ); partitions = 2; } assert( checkInterpolant( interp ) ); // Reload frontier rev_frontier.swap( new_frontier ); // Termination condition done = rev_frontier.empty( ); psi_list.clear( ); } assert( checkInterpolant( interp ) ); interpolant = interp; } void RewriteEngine::iCheck( size_t level ) { assert( explanation.empty( ) ); assert( config.produce_inter != 0 ); assert( status == l_Undef ); // cerr << "BEFORE CHECK" << endl; // cerr << "BEFORE CHECK" << endl; // cerr << "BEFORE CHECK" << endl; // printRules( ground_rules ); // printRules( ground_rules_b ); interpolant = NULL; // Check A part turn_A = true; check_( ground_rules, neq_list ); if ( status == l_False ) { assert( interpolant ); accumulateAndFlushExplantion( ); return; } status = l_Undef; // Check B part turn_A = false; check_( ground_rules_b, neq_list_b ); if ( status == l_False ) { assert( interpolant ); accumulateAndFlushExplantion( ); return; } // // Consider badly orientable eqs now // handleBadlyOrientable( level ); } void RewriteEngine::handleBadlyOrientable( const size_t level ) { if ( level >= badly_orientable.size( ) ) return; // Take bo to consider RewriteRule * bo = badly_orientable[ level ]; // Skipping bo if ( bo_to_skip.find( bo ) != bo_to_skip.end( ) ) return; if ( config.verbosity > 3 ) cerr << "# " << level << ") Considering badly orientable: " << bo << endl; disableGroundRule( isAlocal( bo ) ? ground_rules : ground_rules_b, bo ); // Find out what is I1, E1 and what is I2, E2 vector< Enode * > i1, i2, e1, e2; Enode * c = bo->lhs; Enode * st = bo->rhs; while ( st->isStore( ) ) { if ( isABcommon( getIndexParts( st->get2nd( ) ) ) && isABcommon( st->get3rd( ) ) ) { i1.push_back( st->get2nd( ) ); e1.push_back( st->get3rd( ) ); } else { i2.push_back( st->get2nd( ) ); e2.push_back( st->get3rd( ) ); } st = st->get1st( ); } Enode * c_prime = st; // Now we construct wr( c_prime, I1, E1 ) while ( !i1.empty( ) ) { Enode * old_st = st; st = egraph.mkStore( old_st, i1.back( ), e1.back( ) ); i1.pop_back( ); e1.pop_back( ); } if ( config.verbosity > 3 ) cerr << "# " << level << ") Guessing: " << bo->lhs << " --> " << st << endl; status = l_Undef; list< Enode * > disjuncts; vector< RewriteRule * > r_antec; vector< Enode * > e_antec; ground_rules_t & g_rules = isAlocal( bo ) ? ground_rules : ground_rules_b; // // Case 1: we guess c --> wr( c_prime, I1, E1 ) // // Save current state pushBacktrackPoint( ); r_antec.push_back( bo ); // Adds simple case addGroundRule( c, st, NULL, g_rules, r_antec, e_antec ); iCheck( level + 1 ); // Restore state popBacktrackPoint( ); // Everything was sat, cute ! if ( status == l_True ) return; assert( interpolant ); disjuncts.push_back( interpolant ); if ( config.verbosity > 3 ) cerr << "# Partial interpolant: " << interpolant << endl; // Save state pushBacktrackPoint( ); status = l_Undef; // // Case 2: we need to try the expensive disjunctive cases (ouch!) // Enode * c_second = c_prime; Enode * saved_st = NULL; if ( c_prime != st ) { // We need introducing a new c_second c_second = freshVarFrom( c ); // Make sure the ordering is set correctly setCustomLessThan( c_second, c ); setCustomLessThan( c_prime, c_second ); // Also add c_second --> wr( c_prime, I1, E1 ) addGroundRule( c_second, st, NULL, g_rules, r_antec, e_antec ); saved_st = st; } // We need introducing diff( c, c_second ) = i Enode * diff = egraph.mkDiff( c, c_second ); Enode * i = NULL; map< Enode *, Enode * >::iterator it = diff_to_index.find( diff ); bool is_new = false; if ( it == diff_to_index.end( ) ) { i = freshVarFrom( diff ); new_indexes.insert( i ); is_new = true; } else { i = it->second; } if ( config.verbosity > 3 ) cerr << "# " << level << ") Index: " << i << " is for " << diff << endl; // We need introducing rd( c, i ) = d Enode * rd_c_i = egraph.mkSelect( c, i ); Enode * d = freshVarFrom( rd_c_i ); // We need introducing rd( c_second, i ) = d_second Enode * rd_c_second_i = egraph.mkSelect( c_second, i ); Enode * d_second = freshVarFrom( rd_c_second_i ); // Add negated equalities Enode * neq = egraph.mkEq( egraph.cons( d , egraph.cons( d_second ) ) ); // Pushes diff RewriteRule * rule = new RewriteRule( diff, i, NULL, r_antec, e_antec ); diff_list.push_back( rule ); internals.insert( rule ); // We need introducing d != d_second if ( isAlocal( bo->rhs ) ) addNeq( neq ); else addNeqB( neq ); // Add all of them // Now the actual disjunctive cases can start ! bool is_sat = false; // Iterate through all the indexes for ( size_t k = 0 ; k < i2.size( ) && !is_sat ; k ++ ) { status = l_Undef; list< Enode * > idisjuncts; // Check that *it and i merge into something meaningful if ( unmergable( i2[ k ], i ) ) continue; // Save state prior to outer guess pushBacktrackPoint( ); if ( config.verbosity > 3 ) cerr << "# " << level << ") Outer guess: " << i << " = " << i2[ k ] << endl; replaceIndexInRules( isAlocal( i2[ k ] ) ? ground_rules : ground_rules_b , i2[ k ] , i ); // Save state pushBacktrackPoint( ); if ( config.verbosity > 3 ) cerr << "# " << level << ") Inner guess: all different for " << i << endl; assert( isAlocal( i2[ k ] ) || isBlocal( i2[ k ] ) ); // Adds now c --> wr( c_second, I2 - i2[k] + i, E2 - e2[k] + d ) st = c_second; for ( int j = i2.size( ) - 1 ; j >= 0 ; j -- ) { Enode * old_st = st; if ( j == static_cast< int >( k ) ) st = egraph.mkStore( old_st, i, d ); else st = egraph.mkStore( old_st, i2[ j ], e2[ j ] ); } addGroundRule( c, st, NULL, g_rules, r_antec, e_antec ); // Rewrite bo and adds it status = l_Undef; // Check ! iCheck( level + 1 ); if ( status == l_True ) is_sat = true; else { if ( config.verbosity > 3 ) cerr << "# Partial interpolant: " << interpolant << endl; idisjuncts.push_back( interpolant ); } // Backtrack popBacktrackPoint( ); // Now we need to complete partitions. To do so, // we have to match i (which is ABcommon) with // all the possible candidates from the opposite // partition of i2[k]. We can avoid matching it // with partitions of same color of i2[k] since // we already said that it is in the same class // of i2[k], and those classes are already // partitioned set< Enode * > & idx_eq_classes = isAlocal( bo ) ? idx_eq_classes_b : idx_eq_classes_a; for ( set< Enode * >::iterator it = idx_eq_classes.begin( ) ; it != idx_eq_classes.end( ) ; it ++ ) { if ( config.verbosity > 3 ) cerr << "# " << level << ") Inner guess: " << i << " = " << *it << endl; // Check that *it and i merge into something meaningful if ( unmergable( *it, i ) ) continue; // Save state pushBacktrackPoint( ); assert( isAlocal( *it ) || isBlocal( *it ) ); replaceIndexInRules( isAlocal( *it ) ? ground_rules : ground_rules_b , *it , i ); // Rewrite bo and adds it status = l_Undef; // Adds now rd( c, i ) --> d addGroundRule( rd_c_i, d, NULL, g_rules, r_antec, e_antec ); // Adds now rd( c_second, i ) --> d_second addGroundRule( rd_c_second_i, d_second, NULL, g_rules, r_antec, e_antec ); // Adds now c --> wr( c_second, I2 - i2[k] + i, E2 - e2[k] + d ) addGroundRule( c, st, NULL, g_rules, r_antec, e_antec ); // Check ! iCheck( level + 1 ); if ( status == l_True ) is_sat = true; else { if ( config.verbosity > 3 ) cerr << "# Partial interpolant: " << interpolant << endl; idisjuncts.push_back( interpolant ); } if ( config.verbosity > 3 ) cerr << "# " << level << ") Inner guess: " << i << " = " << *it << " END" << endl; // Backtrack popBacktrackPoint( ); } disjuncts.push_back( isAlocal( bo ) ? egraph.mkAnd( egraph.cons( idisjuncts ) ) : egraph.mkOr( egraph.cons( idisjuncts ) ) ); // Restore before outer merge popBacktrackPoint( ); if ( config.verbosity > 3 ) cerr << "# " << level << ") Outer guess: " << i << " = " << i2[ k ] << " END" << endl; } // Now we undo everything if ( isAlocal( bo->rhs ) ) remNeq( neq ); else remNeqB( neq ); if ( is_new ) new_indexes.erase( i ); diff_list.pop_back( ); internals.erase( rule ); delete rule; // Restore popBacktrackPoint( ); if ( !is_sat ) { status = l_False; interpolant = isAlocal( bo ) ? egraph.mkOr( egraph.cons( disjuncts ) ) : egraph.mkAnd( egraph.cons( disjuncts ) ); egraph.initDupMap1( ); egraph.storeDupMap1( d_second, rd_c_second_i ); interpolant = substitute( interpolant ); egraph.doneDupMap1( ); egraph.initDupMap1( ); egraph.storeDupMap1( d, rd_c_i ); interpolant = substitute( interpolant ); egraph.doneDupMap1( ); egraph.initDupMap1( ); egraph.storeDupMap1( i, diff ); interpolant = substitute( interpolant ); egraph.doneDupMap1( ); // Also, we need to remove newly introduced terms if ( saved_st != NULL ) { egraph.initDupMap1( ); egraph.storeDupMap1( c_second, saved_st ); interpolant = substitute( interpolant ); egraph.doneDupMap1( ); } if ( config.verbosity > 3 ) cerr << "# Final interpolant is: " << interpolant << endl; } assert( !is_sat || status == l_True ); assert( status == l_True || status == l_False ); } void RewriteEngine::addNeqB( Enode * e ) { assert( e->isEq( ) ); #ifdef PRODUCE_PROOF assert( config.produce_inter != 0 || e->getPolarity( ) == l_False ); #else assert( e->getPolarity( ) == l_False ); #endif if ( e->getRetSort( ) == egraph.getSortArray( ) ) { opensmt_error( "Negated array equalities not handled in the solver" ); } neq_list_b.push_back( e ); if ( config.verbosity > 3 ) cerr << "# (+) (not " << e << ")" << endl; if ( isABcommon( e->get1st( ) ) && isABcommon( e->get2nd( ) ) ) { neq_list.push_back( e ); undo_stack_oper.push_back( PROPAGATE_A_NEQ ); undo_stack_term.push_back( NULL ); if ( config.verbosity > 3 ) cerr << "# (Propagating to A)" << endl; } // We don't know about the status status = l_Undef; } void RewriteEngine::remNeqB( Enode * e ) { (void)e; assert( e->isEq( ) ); #ifdef PRODUCE_PROOF assert( config.produce_inter != 0 || e->getPolarity( ) == l_False ); #else assert( e->getPolarity( ) == l_False ); #endif Enode * tmp = neq_list_b.back( ); (void)tmp; neq_list_b.pop_back( ); assert( tmp == e ); // We don't know about the status status = l_Undef; } void RewriteEngine::addBadSelect( Enode * l , Enode * r , Enode * e , vector< RewriteRule * > & r_antec , vector< Enode * > & e_antec ) { RewriteRule * rule = new RewriteRule( l, r, e, r_antec, e_antec ); bad_selects.push_back( rule ); if ( config.verbosity > 3 ) cerr << "# (b) " << rule << endl; undo_stack_oper.push_back( ADD_BAD_SELECT ); undo_stack_term.push_back( rule ); } void RewriteEngine::addBadlyOrientable( Enode * l , Enode * r , Enode * e , vector< RewriteRule * > & r_antec , vector< Enode * > & e_antec ) { assert( false ); RewriteRule * rule = new RewriteRule( l, r, e, r_antec, e_antec ); badly_orientable.push_back( rule ); if ( config.verbosity > 3 ) cerr << "# (b) " << rule << endl; undo_stack_oper.push_back( ADD_BADLY_ORIENTABLE ); undo_stack_term.push_back( rule ); } // Return the enode in the equivalence class of // e with the highest partition. By highest we mean // AB > A, B Enode * RewriteEngine::getIndexParts( Enode * e ) { if ( isABcommon( e ) ) return e; assert( isAlocal( e ) || isBlocal( e ) ); const Enode * vstart = e; for (;;) { e = e->getNext( ); if ( isABcommon( e ) ) return e; if ( e == vstart ) return e; } } bool RewriteEngine::checkInterpolant( Enode * f ) { // Check that variables are ABcommon assert( f ); egraph.initDup1( ); vector< Enode * > unprocessed_enodes; unprocessed_enodes.push_back( f ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.isDup1( enode ) ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( !egraph.isDup1( arg ) ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); if ( enode->isVar( ) && !isABcommon( enode ) ) { egraph.doneDup1( ); return false; } assert( !egraph.isDup1( enode ) ); egraph.storeDup1( enode ); } egraph.doneDup1( ); return true; } bool RewriteEngine::checkInvariants( Enode * l, Enode * r ) { if ( config.produce_inter == 0 ) return true; if ( r->isStore( ) ) { while( r->isStore( ) ) r = r->get1st( ); if ( !greaterThan( l, r ) ) return false; } // Invariant (i) and (ii) if ( isABcommon( l ) && !isABcommon( r ) ) return false; // Invariant (iii) if ( r->isStore( ) && isABcommon( r ) && !isABcommon( l ) ) return false; return true; } bool RewriteEngine::isABcommon( Enode * e ) { assert( config.produce_inter > 0 ); ipartitions_t mask = 3; mask = ~mask; // Compute some useful conditions const ipartitions_t & parts = e->getIPartitions( ); const bool is_AB = (parts & ~mask) != 0 && (parts & mask) != 0; return is_AB; } bool RewriteEngine::isAlocal( Enode * e ) { assert( config.produce_inter > 0 ); ipartitions_t mask = 3; mask = ~mask; // Compute some useful conditions const ipartitions_t & parts = e->getIPartitions( ); const bool is_A = !isABcommon( e ) && (parts & ~mask) != 0 ; return is_A; } bool RewriteEngine::isBlocal( Enode * e ) { assert( config.produce_inter > 0 ); const bool is_B = !isABcommon( e ) && !isAlocal( e ); return is_B; } bool RewriteEngine::isABcommon( RewriteRule * e ) { assert( config.produce_inter > 0 ); ipartitions_t mask = 3; mask = ~mask; // Compute some useful conditions const ipartitions_t & parts = e->partitions; const bool is_AB = (parts & ~mask) != 0 && (parts & mask) != 0; return is_AB; } bool RewriteEngine::isAlocal( RewriteRule * e ) { assert( config.produce_inter > 0 ); ipartitions_t mask = 3; mask = ~mask; // Compute some useful conditions const ipartitions_t & parts = e->partitions; const bool is_A = !isABcommon( e ) && (parts & ~mask) != 0 ; return is_A; } bool RewriteEngine::isBlocal( RewriteRule * e ) { assert( config.produce_inter > 0 ); const bool is_B = !isABcommon( e ) && !isAlocal( e ); return is_B; } void RewriteEngine::setCustomLessThan( Enode * e1, Enode * e2 ) { assert( config.produce_inter != 0 ); Pair( Enode * ) entry = make_pair( e1, e2 ); // Reverse should not be there ... assert( custom_lt.find( make_pair( e2, e1 ) ) == custom_lt.end( ) ); if ( custom_lt.insert( entry ).second ) { undo_stack_oper.push_back( SET_CUSTOM_LT ); undo_stack_term.push_back( NULL ); undo_stack_cust.push_back( entry ); } assert( lessThan( e1, e2 ) ); } Enode * RewriteEngine::freshVarFrom( Enode * e ) { char buf[ 32 ]; stringstream ss; if ( e->getRetSort( ) == egraph.getSortArray( ) ) ss << "Array"; else ss << e->getRetSort( ); sprintf( buf, "__%s_%lu" , ss.str( ).c_str( ) , egraph.nofEnodes( ) + 1 ); egraph.newSymbol( buf, NULL, e->getRetSort( ) ); Enode * var = egraph.mkVar( buf ); return var; } void RewriteEngine::accumulateAndFlushExplantion( ) { // Otherwise it was unsat // accumulate conflict if ( explanation.empty( ) ) return; acc_expl.insert( acc_expl.end( ) , explanation.begin( ) , explanation.end( ) ); explanation.clear( ); } Enode * RewriteEngine::getInterpolant( ) { return interpolant; } Enode * RewriteEngine::substitute( Enode * f ) { assert( f ); vector< Enode * > unprocessed_enodes; unprocessed_enodes.push_back( f ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( egraph.valDupMap1( enode ) != NULL ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( egraph.valDupMap1( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); Enode * result = egraph.copyEnodeEtypeTermWithCache( enode ); assert( egraph.valDupMap1( enode ) == NULL ); egraph.storeDupMap1( enode, result ); } Enode * result = egraph.valDupMap1( f ); assert( result ); return result; } bool RewriteEngine::unmergable( Enode * i, Enode * j ) { assert( i ); assert( j ); if ( !i->hasCongData( ) ) return false; if ( !j->hasCongData( ) ) return false; /* cerr << "Checking if " << i << " and " << j << " are mergable" << endl; cerr << "i class: " << endl; Enode * vs = i; Enode * es = i; for ( ; es != vs ; ) { cerr << " " << es << endl; es = es->getNext( ); } cerr << "j class: " << endl; vs = j; es = j; for ( ; es != vs ; ) { cerr << " " << es << endl; es = es->getNext( ); } */ bool found_A = false, found_B = false; // Exhamine i class Enode * vstart = i; Enode * e = i; do { if ( isAlocal( e ) ) found_A = true; if ( isBlocal( e ) ) found_B = true; e = e->getNext( ); } while( e != vstart ); if ( !found_A && !found_B ) return false; // if ( found_A ) cerr << " i contains A" << endl; // if ( found_B ) cerr << " i contains B" << endl; // Exhamine j class vstart = j; e = j; do { if ( isAlocal( e ) && found_A ) { // cerr << "UNMERGABLE !" << endl; return true; } if ( isBlocal( e ) && found_B ) { // cerr << "UNMERGABLE !" << endl; return true; } e = e->getNext( ); } while( e != vstart ); return false; } void RewriteEngine::addAndComplete( RewriteRule * rule , ground_rules_t & g_rules ) { assert( config.produce_inter != 0 ); assert( rule->lhs->isSelect( ) ); Enode * key = egraph.mkSelect( rule->lhs->get1st( ) , getRoot( rule->lhs->get2nd( ) ) ); map< Enode *, RewriteRule * >::iterator it = g_rules.find( key ); bool safely_add = it == g_rules.end( ); // // Case 1, lhs is not yet part of a rule, safely add // if ( safely_add ) { g_rules[ key ] = rule; if ( isAlocal( rule ) ) { undo_stack_oper.push_back( ADD_REPL_GROUND_RULE ); undo_stack_term.push_back( rule ); } else { undo_stack_oper.push_back( ADD_REPL_GROUND_B_RULE ); undo_stack_term.push_back( rule ); } if ( config.verbosity > 3 ) { cerr << "# (r) " << rule; cerr << endl; } // No propagation is necessary ! // How come ? Boh ! assert( !isABcommon( rule->lhs ) || !isABcommon( rule->rhs ) ); return; } // Don't touch this rule, it has to survive during // backtracking ... // FIXME: ???? // undo_stack_oper.push_back( ADD_DISABLED_GROUND_RULE ); // undo_stack_term.push_back( rule ); // // Case 2, lhs is already there --> critical pair found // RewriteRule * r_i = it->second; RewriteRule * r_j = rule; // Rules is already there, let's just get out of here if ( r_i->lhs == r_j->lhs && r_i->rhs == r_j->rhs ) { return; } if ( config.verbosity > 3 ) { cerr << "# CRITICAL PAIR FOUND " << endl; cerr << "# " << r_i << endl; cerr << "# " << r_j << " (not in database)" << endl; } vector< RewriteRule * > r_antec; r_antec.push_back( r_i ); r_antec.push_back( r_j ); vector< Enode * > e_antec; // For bad selects, need to add explanation if ( r_i->lhs != r_j->lhs ) { assert( r_i->lhs->isSelect( ) ); assert( r_j->lhs->isSelect( ) ); assert( r_i->lhs->get2nd( ) != r_j->lhs->get2nd( ) ); assert( getRoot( r_i->lhs->get2nd( ) ) != getRoot( r_j->lhs->get2nd( ) ) ); indexExplain( r_i->lhs->get2nd( ), r_j->lhs->get2nd( ), e_antec ); } Enode * rew_ri = rewrite( g_rules, r_i->rhs, r_antec, e_antec ); Enode * rew_rj = rewrite( g_rules, r_j->rhs, r_antec, e_antec ); // Case (C1) or (C2) if ( rew_ri->isStore( ) || rew_rj->isStore( ) ) { // In C1 and C2 both parent rules are to be removed. // Disable already existing disableGroundRule( g_rules, r_i ); // Apply cases C1 or C2. Calls addGroundRule inside applyC1C2( g_rules, r_i->lhs, rew_ri, rew_rj, r_antec, e_antec ); } // Case (C4) or (C5) else { addGroundRule( rew_ri , rew_rj , NULL , g_rules , r_antec , e_antec ); } } void RewriteEngine::replaceInRules( Enode *, Enode * ) { assert( false ); /* assert( isAlocal( r ) || isBlocal( r ) ); assert( isABcommon( r_prime ) ); ground_rules_t & g_rules = isAlocal( r ) ? ground_rules : ground_rules_b ; vector< RewriteRule * > to_remove; vector< Pair( Enode * ) > to_add; for ( ground_rules_t::iterator it = g_rules.begin( ) ; it != g_rules.end( ) ; it ++ ) { RewriteRule * rule = it->second; egraph.initDupMap1( ); egraph.storeDupMap1( r, r_prime ); Enode * new_rhs = substitute( rule->rhs ); assignPartitionsFrom( new_rhs, rule->rhs ); egraph.doneDupMap1( ); egraph.initDupMap1( ); egraph.storeDupMap1( r, r_prime ); Enode * new_lhs = substitute( rule->lhs ); assignPartitionsFrom( new_lhs, rule->lhs ); egraph.doneDupMap1( ); if ( new_lhs != rule->lhs || new_rhs != rule->rhs ) { to_remove.push_back( rule ); to_add.push_back( make_pair( new_lhs, new_rhs ) ); } } for ( size_t i = 0 ; i < to_remove.size( ) ; i ++ ) { RewriteRule * rule = to_remove[ i ]; Enode * new_lhs = to_add[ i ].first; Enode * new_rhs = to_add[ i ].second; // Disable old disableGroundRule( g_rules, rule ); vector< RewriteRule * > r_antec; r_antec.push_back( rule ); vector< Enode * > e_antec; // Adds new addAndComplete( new_lhs, new_rhs, NULL, g_rules, r_antec, e_antec ); } */ } // // Adds a new negated equalities, in which we replace // r with r_prime. Also, we propagate the inequality // if it gets ab-common // void RewriteEngine::replaceInNeqs( Enode * r, Enode * r_prime ) { assert( isAlocal( r ) || isBlocal( r ) ); vector< Enode * > & this_neq_list = isAlocal( r ) ? neq_list : neq_list_b ; vector< Enode * > & other_neq_list = isAlocal( r ) ? neq_list_b : neq_list ; vector< Enode * > to_add; for ( size_t i = 0 ; i < this_neq_list.size( ) ; i ++ ) { Enode * neq = this_neq_list[ i ]; Enode * new_neq = NULL; if ( neq->get1st( ) == r ) { new_neq = egraph.mkEq( egraph.cons( r_prime , egraph.cons( neq->get2nd( ) ) ) ); } if ( neq->get2nd( ) == r ) { new_neq = egraph.mkEq( egraph.cons( neq->get1st( ) , egraph.cons( r_prime ) ) ); } if ( new_neq ) { to_add.push_back( new_neq ); } } for ( size_t i = 0 ; i < to_add.size( ) ; i ++ ) { if ( config.verbosity > 4 ) cerr << "# Adding negated equality: " << to_add[ i ] << endl; this_neq_list.push_back( to_add[ i ] ); undo_stack_oper.push_back( isAlocal( r ) ? PROPAGATE_A_NEQ : PROPAGATE_B_NEQ ); undo_stack_term.push_back( NULL ); if ( isABcommon( to_add[ i ]->get1st( ) ) && isABcommon( to_add[ i ]->get2nd( ) ) ) { if ( config.verbosity > 4 ) cerr << "# Propagating negated equality: " << to_add[ i ] << endl; other_neq_list.push_back( to_add[ i ] ); undo_stack_oper.push_back( isAlocal( r ) ? PROPAGATE_B_NEQ : PROPAGATE_A_NEQ ); undo_stack_term.push_back( NULL ); } } } void RewriteEngine::fixBadSelect( ) { for ( size_t i = 0 ; i < bad_selects.size( ) ; i ++ ) { RewriteRule * rule = bad_selects[ i ]; // Adds a new definition assert( config.produce_inter != 0 ); Enode * l = rule->lhs; Enode * r = rule->rhs; Enode * r_prime = freshVarFrom( l ); assert( definitions.find( r_prime ) == definitions.end( ) ); definitions[ r_prime ] = l; def_stack.push_back( r_prime ); undo_stack_oper.push_back( ADD_DEFINE0 ); undo_stack_term.push_back( NULL ); // Apply reduction on rhs -- simulates replacement // replaceInRules( r, r_prime ); vector< RewriteRule * > r_antec; r_antec.push_back( rule ); vector< Enode * > e_antec; // Adds l --> r_prime addAndComplete( l, r_prime, NULL, isAlocal( r ) ? ground_rules : ground_rules_b , r_antec , e_antec ); // Adds r --> r_prime addAndComplete( r, r_prime, NULL, isAlocal( r ) ? ground_rules : ground_rules_b , r_antec , e_antec ); replaceInNeqs( r, r_prime ); } } void RewriteEngine::fixBadlyOrientable( ) { for ( size_t k = 0 ; k < badly_orientable.size( ) ; k ++ ) { RewriteRule * bo = badly_orientable[ k ]; if ( !bo->enabled ) { bo_to_skip.insert( bo ); continue; } Enode * l = bo->lhs; Enode * r = bo->rhs; vector< Enode * > indexes; Enode * a = l; Enode * b = r; while ( b->isStore( ) ) { indexes.push_back( b->get2nd( ) ); b = b->get1st( ); } Enode * diff = egraph.mkDiff( a, b ); map< Enode *, Enode * >::iterator it = diff_to_index.find( diff ); // There is a diff already coming from outside ... // this means that the value of the index is // already guessed if ( it != diff_to_index.end( ) ) { bo_to_skip.insert( bo ); disableGroundRule( isAlocal( bo ) ? ground_rules : ground_rules_b, bo ); bool found = false; for ( size_t i = 0 ; i < indexes.size( ) && !found ; i ++ ) found = getRoot( it->second ) == getRoot( indexes[ i ] ); if ( !found ) { vector< RewriteRule * > r_antec; vector< Enode * > e_antec; r_antec.push_back( bo ); addAndComplete( a, b, NULL , isAlocal( bo ) ? ground_rules : ground_rules_b , r_antec, e_antec ); } // Otherwise there are already // rd( a, i ) != rd( b, i ) } // Preprocess to see if it is a fake badly orientable if ( r->isStore( ) && isABcommon( l ) && !isABcommon( r ) ) { // First: try to rewrite, it may become ABcommon ... // FIXME: check that tmp1, tmp2 have to be used vector< RewriteRule * > tmp1; vector< Enode * > tmp2; Enode * new_rhs = rewriteGround( isAlocal( r ) ? ground_rules : ground_rules_b , r , tmp1 , tmp2 ); if ( isABcommon( new_rhs ) ) { bo_to_skip.insert( bo ); disableGroundRule( isAlocal( bo ) ? ground_rules : ground_rules_b, bo ); vector< RewriteRule * > r_antec; vector< Enode * > e_antec; r_antec.push_back( bo ); addGroundRule( l, new_rhs, NULL, isAlocal( bo ) ? ground_rules : ground_rules_b , r_antec, e_antec ); } else { // Process rules of the kind a --> wr( b, i, e ) // where i is ABcommon but e is not Enode * b = r; vector< Enode * > indexes; vector< Enode * > elements; bool found_one = false; while( b->isStore( ) ) { indexes.push_back( b->get2nd( ) ); if ( isABcommon( b->get2nd( ) ) && !isABcommon( b->get3rd( ) ) ) { Enode * rd = egraph.mkSelect( l, indexes.back( ) ); assert( isABcommon( l ) ); vector< RewriteRule * > tmp1; vector< Enode * > tmp2; // Since it is an ABcommon rule, it shall // be present in both ground_rules and ground_rules_b Enode * d = rewrite( ground_rules, rd, tmp1, tmp2 ); elements.push_back( d ); // Adds correspondence vector< RewriteRule * > r_antec; vector< Enode * > e_antec; r_antec.push_back( bo ); addAndComplete( b->get3rd( ) , d , NULL , isAlocal( b->get3rd( ) ) ? ground_rules : ground_rules_b , r_antec , e_antec ); found_one = true; } else elements.push_back( b->get3rd( ) ); b = b->get1st( ); } // Rewrite if found one if ( found_one ) { while( !indexes.empty( ) ) { Enode * i = indexes.back( ); Enode * e = elements.back( ); indexes.pop_back( ); elements.pop_back( ); b = egraph.mkStore( b, i, e ); } bo_to_skip.insert( bo ); disableGroundRule( isAlocal( bo ) ? ground_rules : ground_rules_b, bo ); vector< RewriteRule * > r_antec; vector< Enode * > e_antec; r_antec.push_back( bo ); addGroundRule( l, b, NULL, isAlocal( bo ) ? ground_rules : ground_rules_b , r_antec, e_antec ); } } } } } bool RewriteEngine::checkCanonizedStore( Enode * e ) { while( e->isStore( ) ) { if ( !e->get3rd( )->isVar( ) ) return false; e = e->get1st( ); } return true; } #endif // // Debugging functions go here // void RewriteEngine::printRules( ground_rules_t & g_rules ) { cerr << "List of rules " << (&g_rules == &ground_rules ? "A" : "B") << " : " << endl; for ( ground_rules_t::iterator it = g_rules.begin( ) ; it != g_rules.end( ) ; it ++ ) { cerr << " " << it->first << " : " << it->second << endl; } } void RewriteEngine::deduce( ) { } opensmt-2.5.2/src/tsolvers/axdiffsolver/RewriteEngine.h000066400000000000000000000340331445011647600233040ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #include "Egraph.h" #include "SStore.h" #include "SMTConfig.h" #ifndef REWRITE_H #define REWRITE_H #define REDUCE_TO_EUF 1 #define SPLIT_ON_DEMAND 0 #ifdef PRODUCE_PROOF #define COLORED_RULES 1 #if COLORED_RULES #define COL_START( C ) \ { \ ipartitions_t color = 0; \ if ( C == 2 ) color = 31; \ else if ( C == 4 ) color = 34; \ else if ( C == 6 ) color = 32; \ os.flush( ); \ os << "\033[1" << ";" << color << "m"; \ os.flush( ); \ } \ #define COL_END \ { \ os.flush( ); \ os << "\033[0m"; \ os.flush( ); \ } #else #define COL_START( C ) { } #define COL_END { } #endif #endif class RewriteEngine { public: RewriteEngine( const int id_ , SMTConfig & config_ , Egraph & egraph_ , SStore & sstore_ , vector< Enode * > & explanation_ , vector< Enode * > & deductions_ #if OUTSPLIT , vector< Enode * > & suggestions_ #endif ) : id ( id_ ) , config ( config_ ) , egraph ( egraph_ ) , sstore ( sstore_ ) , explanation ( explanation_ ) , deductions ( deductions_ ) , status ( l_Undef ) { } ~RewriteEngine ( ) { backtrackToStackSize( 0 ); } void check ( const bool ); void addIndexEq ( Enode * ); // Add Index EQ void addEq ( Enode * ); // Add eq void addNeq ( Enode * ); // Add neq void remIndexEq ( Enode * ); void remEq ( Enode * ); void remNeq ( Enode * ); void pushBacktrackPoint ( ); // Adds backtrack point void popBacktrackPoint ( ); // Restore backtrack point void printGroundRules ( ); void printNeqs ( ); inline lbool getStatus ( ) const { return status; } inline void resetStatus ( ) { status = l_Undef; } #ifdef PRODUCE_PROOF bool isAlocal ( Enode * ); bool isBlocal ( Enode * ); bool isABcommon ( Enode * ); void addNeqB ( Enode * ); // Add neq void remNeqB ( Enode * ); void informIdx ( Enode * ); Enode * getInterpolant ( ); #endif private: struct RewriteRule { RewriteRule( Enode * l , Enode * r , Enode * e , vector< RewriteRule * > & r_antec_ , vector< Enode * > & e_antec_ , bool p = false ) : lhs ( l ) , rhs ( r ) , reason ( e ) , r_antec ( r_antec_ ) , e_antec ( e_antec_ ) , enabled ( true ) #ifdef PRODUCE_PROOF , partitions ( 0 ) , propagated ( p ) #endif { (void)p; assert( checkSelfReference( ) ); #ifdef PRODUCE_PROOF setIPartitions( ); #endif } Enode * lhs; // Head Enode * rhs; // Tail Enode * reason; // Reason for rewriting vector< RewriteRule * > r_antec; // Antecedents vector< Enode * > e_antec; // Neq antecedents bool enabled; // Is enabled #ifdef PRODUCE_PROOF ipartitions_t partitions; // Partition mask bool propagated; #endif inline friend ostream & operator<<( ostream & os, RewriteRule * r ) { assert( r ); os << r->lhs; #ifdef PRODUCE_PROOF COL_START( r->partitions ); #endif os << " --> "; #ifdef PRODUCE_PROOF COL_END; #endif os << r->rhs; return os; } // Rule must not have itself as antec bool checkSelfReference( ) { for ( size_t i = 0 ; i < r_antec.size( ) ; i ++ ) if ( r_antec[ i ] == this ) return false; return true; } #ifdef PRODUCE_PROOF void setIPartitions( ) { partitions = 0; if ( reason ) partitions = reason->getIPartitions( ); for ( size_t i = 0 ; i < r_antec.size( ) ; i ++ ) { assert( r_antec[ i ]->partitions != 0 ); if ( partitions == 0 ) partitions = r_antec[ i ]->partitions; else partitions &= r_antec[ i ]->partitions; assert( partitions != 0 ); } if ( propagated && partitions == 2 ) partitions = 4; else if ( propagated && partitions == 4 ) partitions = 2; } #endif }; typedef map< Enode *, RewriteRule * > ground_rules_t; void addIndexRule ( Enode *, Enode *, Enode *, vector< RewriteRule * > & ); void addGroundRule ( Enode *, Enode *, Enode * ); void addGroundRule ( Enode * // lhs , Enode * // rhs , Enode * // reason , ground_rules_t & , vector< RewriteRule * > & // Add ground rule , vector< Enode * > & ); // Add ground rule void disableGroundRule ( ground_rules_t &, RewriteRule * ); Enode * rewrite ( ground_rules_t & , Enode * , vector< RewriteRule * > & , vector< Enode * > & ); // Rewrite input node exhaustively Enode * rewriteGround ( ground_rules_t & , Enode * , vector< RewriteRule * > & , vector< Enode * > & ); Enode * rewriteGeneric ( Enode *, vector< Enode * > & ); bool complete ( ground_rules_t & , const bool = false ); // Perform completion int postProcessing ( ground_rules_t & , vector< Enode * > & , vector< Enode * > & , const bool = false ); void retrieveIndexes ( Enode *, vector< Enode * > & ); bool lessThan ( Enode *, Enode * ); bool greaterThan ( Enode *, Enode * ); int orient ( Enode **, Enode ** ); void backtrackToStackSize ( size_t ); // Restores to a previous size void explain ( vector< RewriteRule * > & ); void applyC1C2 ( ground_rules_t & // List of ground rules to use , Enode * // lhs array variable , Enode *, Enode * // rhs array store terms , vector< RewriteRule * > & // r antecedents , vector< Enode * > & ); // e antecedents void applyC3 ( ground_rules_t & ); bool reduction ( ground_rules_t & ); void failure ( ground_rules_t & , vector< Enode * > & ); void addAndComplete ( Enode * , Enode * , Enode * , ground_rules_t & , vector< RewriteRule * > & , vector< Enode * > & , const bool = false ); // Return true if added void check_ ( ground_rules_t &, vector< Enode * > & ); void addBackToDatabase ( RewriteRule * ); // Return true if added void remFromDatabase ( ground_rules_t &, RewriteRule * ); Enode * getRoot ( Enode * ); void printRules ( ground_rules_t & ); void indexExplain ( Enode *, Enode *, vector< Enode * > & ); bool storeEquiv ( Enode *, Enode * ); void deduce ( ); // // Functions for interpolation go here ! // #ifdef PRODUCE_PROOF void replaceInNeqs ( Enode *, Enode * ); void replaceInRules ( Enode *, Enode * ); void replaceIndexInRules ( ground_rules_t &, Enode *, Enode * ); bool unmergable ( Enode *, Enode * ); void addAndComplete ( RewriteRule *, ground_rules_t & ); void interpolate ( Enode * , vector< RewriteRule * > & ); void iCheck ( size_t ); void addBadSelect ( Enode * , Enode * , Enode * , vector< RewriteRule * > & , vector< Enode * > & ); void addBadlyOrientable ( Enode * , Enode * , Enode * , vector< RewriteRule * > & , vector< Enode * > & ); void assignPartitionsFrom ( Enode *, Enode * ); void assignPartitionsFrom ( Enode *, Enode *, Enode * ); void assignPartitionsFrom ( Enode *, Enode *, Enode *, Enode * ); bool checkInvariants ( Enode *, Enode * ); Enode * getIndexParts ( Enode * ); bool isAlocal ( RewriteRule * ); bool isBlocal ( RewriteRule * ); bool isABcommon ( RewriteRule * ); bool checkInterpolant ( Enode * ); void handleBadlyOrientable ( const size_t ); void setCustomLessThan ( Enode *, Enode * ); Enode * freshVarFrom ( Enode * ); bool areNewIdx ( Enode *, Enode * ); void accumulateAndFlushExplantion ( ); void computeIdxEqClasses ( ); Enode * substitute ( Enode * ); void fixBadlyOrientable ( ); void fixBadSelect ( ); bool checkCanonizedStore ( Enode * ); #endif #if REDUCE_TO_EUF void minimizeExplanation ( ); #endif // // Defines the set of operations that can be performed and that should be undone // typedef enum { ADD_GROUND_RULE // Adding ground rule , ADD_INDEX_RULE // Adding generic rule , DISABLE_RULE // Disables a rewrite rule , ADD_DISABLED_GROUND_RULE // Adds a ground rule already disabled , ADD_PROP_RULE // Propagated rule #ifdef PRODUCE_PROOF , ADD_DEFINE0 , ADD_GROUND_B_RULE , ADD_REPL_GROUND_RULE , ADD_REPL_GROUND_B_RULE , ADD_BADLY_ORIENTABLE , ADD_BAD_SELECT , SET_CUSTOM_LT , PROPAGATE_A_NEQ , PROPAGATE_B_NEQ , REPLACED_RULE , INDEX_MERGE #endif } oper_t; const int id; SMTConfig & config; Egraph & egraph; SStore & sstore; vector< Enode * > & explanation; vector< Enode * > & deductions; set< Enode * > seen_in_expl; vector< Enode * > select_equalities_to_add; vector< Enode * > store_equalities_to_add; ground_rules_t ground_rules; // List of ground rules vector< oper_t > undo_stack_oper; vector< RewriteRule * > undo_stack_term; vector< size_t > backtrack_points; set< size_t > reduced_diffs; // Needed for Condition (ii) of tuning vector< RewriteRule * > diff_list; // List of index rules with diff vector< Enode * > read_list; // List of read terms seen vector< Enode * > eq_list; // List of equalities vector< Enode * > neq_list; // List of negated equalities set< Pair( Enode * ) > neq_set; // Set of neqs, for eager checks map< Enode *, Enode * > diff_to_index; // diff(...) = i map< Enode *, Enode * > index_to_diff; // diff(...) = i set< Pair( int ) > active_rule_set; // Set of active rules lbool status; // Additional data structures for interpolation #ifdef PRODUCE_PROOF set< RewriteRule * > bo_to_skip; vector< Enode * > eqs_to_add; vector< Enode * > idx_to_add; vector< Enode * > idx_list; ground_rules_t ground_rules_b; vector< Enode * > neq_list_b; // List of negated equalities set< Pair( Enode * ) > custom_lt; vector< RewriteRule * > badly_orientable; vector< RewriteRule * > bad_selects; vector< Pair( Enode * ) > undo_stack_cust; vector< Pair( Enode * ) > undo_stack_repl; bool turn_A; Enode * interpolant; set< Enode * > idx_eq_classes_a; set< Enode * > idx_eq_classes_b; set< Enode * > new_indexes; map< Enode *, Enode * > definitions; vector< Enode * > def_stack; vector< Enode * > acc_expl; set< RewriteRule * > internals; // map< Enode *, Enode * > new_indexes_to_A_root; // map< Enode *, Enode * > new_indexes_to_B_root; set< Enode * > ab_common_class; #endif #if REDUCE_TO_EUF map< Enode *, vector< Enode * > > eqs_to_antec; #if SPLIT_ON_DEMAND Enode * candidate; size_t nof_idxs; #endif #endif }; #endif opensmt-2.5.2/src/tsolvers/bvsolver/000077500000000000000000000000001445011647600175275ustar00rootroot00000000000000opensmt-2.5.2/src/tsolvers/bvsolver/BVSolver.cc000066400000000000000000000072731445011647600215510ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #include "BVSolver.h" static SolverDescr descr_bv_solver("UF Solver", "Solver for Quantifier Free Bit Vectors"); BVSolver::BVSolver(SMTConfig & c, MainSolver & s, BVLogic & l) : TSolver((SolverId) descr_bv_solver, (const char *) descr_bv_solver, c) , mainSolver(s) , B(id, c, mainSolver, l, explanation, suggestions) { } BVSolver::~BVSolver () { } // // The solver is informed of the existence of // atom e. It might be useful for initializing // the solver's data structures. This function is // called before the actual solving starts. // lbool BVSolver::declareTerm(PTRef tr) { assert(tr != PTRef_Undef); const lbool res = B.inform( tr ); return res; } // // Asserts a literal into the solver. If by chance // you are able to discover inconsistency you may // return false. The real consistency state will // be checked with "check" // bool BVSolver::assertLit ( PtAsgn pta ) { assert( pta.tr != PTRef_Undef ); assert( pta.sgn != l_Undef ); if (hasPolarity(pta.tr) && getPolarity(pta.tr) == pta.sgn) { // already known return true; } setPolarity(pta.tr, pta.sgn); stack.push(pta); const bool res = B.assertLit(pta); assert( res || explanation.size() != 0 ); return res; } // // Saves a backtrack point // void BVSolver::pushBacktrackPoint ( ) { backtrack_points.push( stack.size( ) ); // // Push a backtrack point inside the bitblaster // B.pushBacktrackPoint( ); } // // Restore a previous state. // Also make sure you clean the deductions you // did not communicate // void BVSolver::popBacktrackPoint ( ) { assert( backtrack_points.size( ) > 0 ); size_t stack_new_size = backtrack_points.last(); backtrack_points.pop(); // // Restore stack size // while (static_cast(stack.size()) > stack_new_size ) { PtAsgn popped = stack.last(); stack.pop(); clearPolarity(popped.tr); } // // Restore bitblaster state // B.popBacktrackPoint(); } // // Check for consistency. If flag is // set make sure you run a complete check // TRes BVSolver::check( bool complete ) { if ( !complete ) return TRes::SAT; assert( explanation.size() == 0 ); // Here check for consistency. No undefs allowed. const bool res = (B.check() == l_True ? true : false); assert(res || (explanation.size() != 0)); return res ? TRes::SAT : TRes::UNSAT; } void BVSolver::computeModel( ) { B.computeModel( ); } opensmt-2.5.2/src/tsolvers/bvsolver/BVSolver.h000066400000000000000000000037301445011647600214050ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #ifndef BVSOLVER_H #define BVSOLVER_H #include "TSolver.h" #include "BitBlaster.h" #include "BVLogic.h" class BVSolver : public TSolver { public: BVSolver(SMTConfig & c, MainSolver & s, BVLogic & l); ~BVSolver ( ); bool assertLit ( PtAsgn ) override; void pushBacktrackPoint ( ) override; void popBacktrackPoint ( ) override; TRes check ( bool ) override; void computeModel ( ) override; virtual lbool declareTerm ( PTRef ); private: vec stack; MainSolver& mainSolver; // BVLogic& logic; // MB: apparently not needed BitBlaster B; }; #endif opensmt-2.5.2/src/tsolvers/bvsolver/BVStore.cc000066400000000000000000000024501445011647600213630ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2017 Antti Hyvarinen 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. *********************************************************************/ #include "BVStore.h" BVStore::BVStore() {} opensmt-2.5.2/src/tsolvers/bvsolver/BVStore.h000066400000000000000000000055761445011647600212410ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2017 Antti Hyvarinen 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. *********************************************************************/ #ifndef BVSTORE_H #define BVSTORE_H #include "Bvector.h" class BVStore { BvectorAllocator bva; vec idToBVRef; Map bv_map; // Mapping of a BV variable to the bit vector (automatic) Map carryonly; // A cache mapping sum PTRefs to their carry bit public: BVStore(); BVRef newBvector(const vec& var_names, const vec& asgn, PTRef act_var, PTRef tr) { BVRef br = bva.alloc(var_names, asgn, act_var); idToBVRef.push(br); bv_map.insert(tr, br); return br; } void free(BVRef r) { bva.free(r); } Bvector& operator[] (BVRef br) { return bva[br]; } const Bvector& operator[] (BVRef br) const { return bva[br]; } BVRef operator[] (PTRef tr) { if (!has(tr)) return BVRef_Undef; return getFromPTRef(tr); } bool has(PTRef r) { return bv_map.has(r); } bool has_carryonly(PTRef tr) { return carryonly.has(tr); } PTRef getCarryOnly(PTRef tr) { return carryonly[tr]; } void insertCarryOnly(PTRef tr_sum, PTRef tr_carry) { carryonly.insert(tr_sum, tr_carry); } BVRef getFromPTRef(PTRef r) { assert(bv_map.has(r)); return bv_map[r]; } void copyAsgnTo(BVRef bv, vec& tr_vec) { for (int i = 0; i < operator[](bv).size(); i++) tr_vec.push(operator[](bv)[i]); } void copyNamesTo(BVRef bv, vec& tr_vec) { for (int i = 0; i < operator[](bv).size(); i++) tr_vec.push(operator[](bv).namebit(i)); } void copyBVTo(BVRef bv, vec& na_vec) { for (int i = 0; i < operator[](bv).size(); i++) na_vec.push(operator[](bv).nameasgn(i)); } int size() const { return idToBVRef.size(); } }; #endif opensmt-2.5.2/src/tsolvers/bvsolver/BitBlaster.cc000066400000000000000000001637011445011647600221010ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2017, Antti Hyvarinen 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #include "ModelBuilder.h" #include "BitBlaster.h" #include "BVStore.h" #include "MainSolver.h" #include "Real.h" using opensmt::Real; const char* BitBlaster::s_bbEq = ".bbEq"; const char* BitBlaster::s_bbAnd = ".bbAnd"; const char* BitBlaster::s_bbBvslt = ".bbBvslt"; const char* BitBlaster::s_bbBvule = ".bbBvule"; const char* BitBlaster::s_bbConcat = ".bbConcat"; const char* BitBlaster::s_bbExtract = ".bbExtract"; const char* BitBlaster::s_bbBvand = ".bbBvand"; const char* BitBlaster::s_bbBvland = ".bbBvland"; const char* BitBlaster::s_bbBvor = ".bbBvor"; const char* BitBlaster::s_bbBvlor = ".bbBvlor"; const char* BitBlaster::s_bbBvxor = ".bbBvxor"; const char* BitBlaster::s_bbBvcompl = ".bbBvcompl"; const char* BitBlaster::s_bbBvlnot = ".bbBvlnot"; const char* BitBlaster::s_bbBvadd = ".bbBvadd"; const char* BitBlaster::s_bbBvmul = ".bbBvmul"; const char* BitBlaster::s_bbBvudiv = ".bbBvudiv"; const char* BitBlaster::s_bbBvurem = ".bbBvurem"; const char* BitBlaster::s_bbSignExtend = ".bbSignExtend"; const char* BitBlaster::s_bbVar = ".bbVar"; const char* BitBlaster::s_bbConstant = ".bbConstant"; const char* BitBlaster::s_bbDistinct = ".bbDistinct"; const char* BitBlaster::s_bbBvlsh = ".bbBvlsh"; const char* BitBlaster::s_bbBvlrsh = "s_bbBvlrsh"; const char* BitBlaster::s_bbBvarsh = "s_bbBvarsh"; BitBlaster::BitBlaster(SolverId, SMTConfig & c, MainSolver & mainSolver, BVLogic & bvlogic, vec & ex, vec & s) : last_refined(0) , config (c) , mainSolver (mainSolver) , logic (bvlogic) , thandler (mainSolver.getTHandler()) , solverP (mainSolver.getSMTSolver()) , explanation (ex) , suggestions (s) , has_model (false) , bitwidth (logic.getBitWidth()) { } BitBlaster::~BitBlaster () { cleanGarbage( ); } BVRef BitBlaster::updateCache(PTRef tr) { // Return previous result if computed if (bs.has(tr)) return bs.getFromPTRef(tr); return BVRef_Undef; } //============================================================================= // Public Interface Routines lbool BitBlaster::inform (PTRef tr) { BVRef result = bbTerm( tr ); char* msg; vec bv; bs.copyAsgnTo(result, bv); PTRef tr_out = logic.mkImpl(bs[result].getActVar(), logic.mkAnd(bv)); sstat status = mainSolver.insertFormula(tr_out, &msg); if (status == s_True) return l_True; else if (status == s_False) return l_False; else return l_Undef; } lbool BitBlaster::insert(PTRef tr, BVRef& out) { char* msg; out = bbTerm(tr); PTRef last_bit = logic.mkEq(bs[out].lsb(), logic.getTerm_true()); sstat status = mainSolver.insertFormula(last_bit, &msg); if (status == s_True) return l_True; else if (status == s_False) return l_False; else return l_Undef; } lbool BitBlaster::insertEq(PTRef tr, BVRef& out) { assert(logic.isBVEq(tr) || logic.isBVOne(tr) || logic.isBVZero(tr)); return insert(tr, out); } lbool BitBlaster::insertOr(PTRef tr, BVRef& out) { assert(logic.isBVLor(tr) || logic.isBVOne(tr) || logic.isBVZero(tr)); return insert(tr, out); } bool BitBlaster::assertLit (PtAsgn pta) { // This needs to be re-thought. I'd like to have this activation // logic in MainSolver somehow and use the incremental interface. assert( pta.tr != PTRef_Undef ); assert(thandler.getTMap().hasLit(pta.tr)); Var act_var = thandler.ptrefToVar(pta.tr); if ( ((pta.sgn == l_False) && (thandler.varToTerm(act_var) == logic.getTerm_true() )) || thandler.varToTerm(act_var) == logic.getTerm_false()) return false; // // Activate clause for e // vec< Lit > clause; clause.push( mkLit( act_var, (pta.sgn == l_True ? false : true) ) ); bool res = addClause(clause); return res; } lbool BitBlaster::check( ) { const lbool res = solverP.solve( ); // assert( res || (explanation.size() != 0) ); return res; } void BitBlaster::pushBacktrackPoint ( ) { solverP.pushBacktrackPoint( ); } void BitBlaster::popBacktrackPoint ( ) { // Pop solver solverP.popBacktrackPoint( ); solverP.restoreOK( ); has_model = false; } char* BitBlaster::getName(const char* base) const { char* out; int written = asprintf(&out, "%s%d", base, bs.size()); assert(written >= 0); (void)written; return out; } void BitBlaster::getBVVars(const char* base, vec& vars, int width) { vars.growTo(width); for (int i = 0; i < width; i++) { char* bit_name; int written = asprintf(&bit_name, ".%s%02d_", base, i); assert(written >= 0); (void)written; vars[i] = logic.mkBoolVar(getName(bit_name)); free(bit_name); } } PTRef BitBlaster::mkActVar(const char* base) { char* name = getName(base); PTRef v = logic.mkBoolVar(name); free(name); return v; } //============================================================================= // BitBlasting Routines BVRef BitBlaster::bbTerm(PTRef tr) { assert(logic.hasSortBVNUM(tr)); // Return previous result if computed if (bs.has(tr)) return bs.getFromPTRef(tr); // // BitBlasts predicates // if (logic.isBVEq(tr)) return bbEq ( tr ); if (logic.isBVSlt(tr)) return bbBvslt ( tr ); if (logic.isBVUleq(tr)) return bbBvule ( tr ); if (logic.isDisequality(tr)) return bbDistinct ( tr ); // if ( e->isUp ( ) ) return bbUp ( e ); // // BitBlasts terms // // if ( e->isConcat ( ) ) return bbConcat ( e ); // if ( e->isExtract ( ) ) return bbExtract ( e ); if (logic.isBVBwAnd(tr)) return bbBvand (tr); if (logic.isBVBwOr(tr)) return bbBvor (tr); if (logic.isBVBwXor(tr)) return bbBvxor (tr); if (logic.isBVCompl(tr)) return bbBvcompl (tr); if (logic.isBVNot(tr)) return bbBvlnot (tr); if (logic.isBVLand(tr)) return bbBvland (tr); if (logic.isBVLor(tr)) return bbBvlor (tr); if (logic.isBVPlus(tr)) return bbBvadd (tr); if (logic.isBVTimes(tr)) return bbBvmul (tr); if (logic.isBVDiv(tr)) return bbBvudiv (tr); if (logic.isBVMod(tr)) return bbBvurem (tr); if (logic.isBVLshift(tr)) return bbBvlshift (tr); if (logic.isBVLRshift(tr)) return bbBvlrshift (tr); if (logic.isBVARshift(tr)) return bbBvarshift (tr); // if ( e->isSignExtend ( ) ) return bbSignExtend ( e ); if ( logic.isVar(tr) ) return bbVar ( tr ); if ( logic.isConstant(tr) ) return bbConstant ( tr ); // if ( e->isUf ( ) ) return bbUf ( e ); // // Exit if term is not handled // std::cerr << "term not handled (yet ?): " << logic.printTerm(tr) << "\n"; return BVRef_Undef; } // // Equality // BVRef BitBlaster::bbEq(PTRef tr) { assert(tr != PTRef_Undef); assert(logic.isEquality(tr)); // Return previous result if computed if (bs.has(tr)) return bs.getFromPTRef(tr); vec names; getBVVars("eq", names, bitwidth); Pterm& t = logic.getPterm(tr); assert( t.size() == 2 ); PTRef lhs = t[0]; PTRef rhs = t[1]; assert( !(logic.isConstant(lhs)) || !(logic.isConstant(rhs)) ); // Retrieve arguments' encodings BVRef bb_lhs = bbTerm(lhs); BVRef bb_rhs = bbTerm(rhs); assert( bs[bb_lhs].size( ) == bs[bb_rhs].size( ) ); // Produce the result vec result_args; for ( int i = 0 ; i < bs[bb_lhs].size() ; i ++ ) { result_args.push(logic.mkEq(bs[bb_lhs][i], bs[bb_rhs][i])); } PTRef res = simplify( logic.mkAnd( result_args ) ); vec tmp(bitwidth, logic.getTerm_false()); tmp[0] = res; return bs.newBvector(names, tmp, mkActVar(s_bbEq), tr); } // // Signed less than // BVRef BitBlaster::bbBvslt(PTRef tr) { assert(tr != PTRef_Undef); // assert( logic.isBvsle(tr) ); // Return previous result if computed Pterm& t = logic.getPterm(tr); if (bs.has(tr)) return bs[tr]; // Allocate new result vec names; getBVVars("sle", names, bitwidth); assert( t.size() == 2 ); PTRef lhs = t[0]; PTRef rhs = t[1]; // Retrieve arguments' encodings BVRef bb_lhs = bbTerm( lhs ); BVRef bb_rhs = bbTerm( rhs ); assert( bs[bb_lhs].size( ) == bs[bb_rhs].size( ) ); // _S < _S <=> (msb(a) <=> msb(b)) xor add(a, ~b, 1).cout PTRef tr_out = logic.mkXor(logic.mkEq(bs[bb_lhs].msb(), bs[bb_rhs].msb()), bbBvadd_carryonly(logic.mkBVPlus(lhs, logic.mkBVCompl( rhs)), logic.getTerm_true())); // Save result and return vec asgns; asgns.growTo(bitwidth, logic.getTerm_false()); asgns[0] = tr_out; return bs.newBvector(names, asgns, mkActVar(s_bbBvslt), tr); } // // Unsigned less than equal // BVRef BitBlaster::bbBvule(PTRef tr) { assert(tr != PTRef_Undef); // // What ? Isn't it an eq ? Well lt are translated into le // in creation, still we want to encode le as if it was // an eq, as le = lt or eq // // Later comment: What did I mean ?? :-) // // assert( e->isBvule( ) ); // Return previous result if computed if (bs.has(tr)) return bs[tr]; // Allocate new result vec names; getBVVars("ule", names, bitwidth); assert(logic.getPterm(tr).size() == 2 ); PTRef lhs = logic.getPterm(tr)[0]; PTRef rhs = logic.getPterm(tr)[1]; // Retrieve arguments' encodings BVRef bb_lhs = bbTerm(lhs); BVRef bb_rhs = bbTerm(rhs); assert(bs[bb_lhs].size() == bs[bb_rhs].size()); // // Produce the result // PTRef lt_prev = PTRef_Undef; for (int i = 0 ; i < bs[bb_lhs].size() ; i ++) { // Produce ~l[i] & r[i] PTRef not_l = logic.mkNot(bs[bb_lhs][i]); PTRef lt_this = logic.mkAnd(not_l, bs[bb_rhs][i]); // Produce l[i] <-> r[i] PTRef eq_this = logic.mkEq(bs[bb_lhs][i], bs[bb_rhs][i]); if (lt_prev != PTRef_Undef) lt_prev = logic.mkOr(lt_this, logic.mkAnd(eq_this, lt_prev)); else lt_prev = lt_this; } PTRef lt_part = lt_prev; BVRef eq_part = bbTerm(logic.mkBVEq(lhs, rhs)); // // Produce (lhs=rhs | lhs asgns; asgns.growTo(bitwidth, logic.getTerm_false()); asgns[0] = res; // Save result and return return bs.newBvector(names, asgns, mkActVar(s_bbBvule), tr); } // // Concatenation // BVRef BitBlaster::bbConcat(PTRef tr) { assert( tr != PTRef_Undef ); if (bs.has(tr)) return bs[tr]; // Allocate new result vec names; getBVVars("con", names, bitwidth); vec result; // Retrieve arguments and put on the stack for (int i = logic.getPterm(tr).size()-1; i >= 0; i--) { PTRef arg = logic.getPterm(tr)[i]; BVRef bb_arg = bbTerm(arg); for (int j = 0; j < bs[bb_arg].size(); j++) result.push(bs[bb_arg][j]); } // Save result and return return bs.newBvector(names, result, mkActVar(s_bbConcat), tr); } // // Extraction // BVRef BitBlaster::bbExtract(PTRef tr) { // Have a look at this, it probably shouldn't return 32 bits assert(tr != PTRef_Undef); if (bs.has(tr)) return bs[tr]; // Allocate new result vec names; getBVVars("ex", names, bitwidth); int lsb = 0, msb = 0; assert(logic.getPterm(tr).size() == 1 ); PTRef arg = logic.getPterm(tr)[0]; // Retrieve arguments' encodings BVRef bb_arg = bbTerm(arg); // Produce the result vec result; result.growTo(bitwidth, logic.getTerm_false()); for ( int i = lsb, j = 0; i <= msb ; i ++ ) result[j++] = bs[bb_arg][i]; // Save result and return return bs.newBvector(names, result, mkActVar(s_bbExtract), tr); } // // Bitwise AND // BVRef BitBlaster::bbBvand(PTRef tr) { assert(tr != PTRef_Undef); if (bs.has(tr)) return bs[tr]; // Allocate new result vec names; getBVVars("and", names, bitwidth); vec bb_args; // Bit-blast the arguments, and put the corresponding vectors // into bb_args. for (int i = 0; i < logic.getPterm(tr).size(); i++) bb_args.push(bbTerm(logic.getPterm(tr)[i])); int n_bits = bs[bb_args[0]].size(); // the number of bits in each argument // Iterate over all bits vec result; for (int i = 0; i < n_bits; i++) { vec and_args; // Iterate over all arguments for (int j = 0 ; j < bb_args.size(); j++) { assert(bs[bb_args[j]].size() == n_bits); and_args.push((bs[bb_args[j]])[i]); } result.push(logic.mkAnd(and_args)); } return bs.newBvector(names, result, mkActVar(s_bbBvand), tr); } // // Logical AND // BVRef BitBlaster::bbBvland(PTRef tr) { assert(tr != PTRef_Undef); if (bs.has(tr)) return bs[tr]; assert(logic.getPterm(tr).size() == 2); // Allocate new result vec names; getBVVars("lan", names, bitwidth); // Bit-blast the arguments, and put the corresponding vectors // into bb_args. PTRef arg1 = logic.getPterm(tr)[0]; PTRef arg2 = logic.getPterm(tr)[1]; BVRef bv1 = bbTerm(arg1); BVRef bv2 = bbTerm(arg2); assert(bs[bv1].size() == bs[bv2].size()); vec result; //result.growTo(bitwidth, logic.getTerm_false()); result.growTo(bs[bv1].size(), logic.getTerm_false()); vec bv1_bits; vec bv2_bits; bs.copyAsgnTo(bv1, bv1_bits); bs.copyAsgnTo(bv2, bv2_bits); result[0] = logic.mkAnd(logic.mkOr(std::move(bv1_bits)), logic.mkOr(std::move(bv2_bits))); // for (int i = 1; i < result.size(); i++) // result[i] = logic.getTerm_false(); return bs.newBvector(names, result, mkActVar(s_bbBvland), tr); } // // Bitwise OR // BVRef BitBlaster::bbBvor(PTRef tr) { assert(tr != PTRef_Undef); if (bs.has(tr)) return bs[tr]; // Allocate new result vec names; getBVVars("or", names, bitwidth); vec result; vec bb_args; // Bit-blast the arguments, and put the corresponding vectors // into bb_args. for (int i = 0; i < logic.getPterm(tr).size(); i++) bb_args.push(bbTerm(logic.getPterm(tr)[i])); int n_bits = bs[bb_args[0]].size(); // the number of bits in each argument // Iterate over all bits for (int i = 0; i < n_bits; i++) { vec and_args; // Iterate over all arguments for (int j = 0 ; j < bb_args.size(); j++) { assert(bs[bb_args[j]].size() == n_bits); and_args.push((bs[bb_args[j]])[i]); } result.push(logic.mkOr(std::move(and_args))); } // Save result and return return bs.newBvector(names, result, mkActVar(s_bbBvor), tr); } // // Logical OR // BVRef BitBlaster::bbBvlor(PTRef tr) { assert(tr != PTRef_Undef); assert(logic.getPterm(tr).size() == 2); if (bs.has(tr)) return bs[tr]; // Allocate new result vec names; getBVVars("lor", names, bitwidth); vec result; result.growTo(bitwidth, logic.getTerm_false()); PTRef arg1 = logic.getPterm(tr)[0]; PTRef arg2 = logic.getPterm(tr)[1]; BVRef bv1 = bbTerm(arg1); BVRef bv2 = bbTerm(arg2); vec bv1_bits; bs.copyAsgnTo(bv1, bv1_bits); vec bv2_bits; bs.copyAsgnTo(bv2, bv2_bits); result[0] = logic.mkOr(logic.mkOr(std::move(bv1_bits)), logic.mkOr(std::move(bv2_bits))); // for (int i = 1; i < result.size(); i++) // result[i] = logic.getTerm_false(); // Save result and return return bs.newBvector(names, result, mkActVar(s_bbBvlor), tr); } // // Bitwise XOR // BVRef BitBlaster::bbBvxor(PTRef tr) { assert(tr != PTRef_Undef); if (bs.has(tr)) return bs[tr]; assert( logic.getPterm(tr).size() == 2 ); // Allocate new result vec names; getBVVars("xor", names, bitwidth); // Allocate new result vec result; PTRef lhs = logic.getPterm(tr)[0]; PTRef rhs = logic.getPterm(tr)[1]; BVRef bb_lhs = bbTerm( lhs ); BVRef bb_rhs = bbTerm( rhs ); assert(bs[bb_lhs].size() == bs[bb_rhs].size()); for ( int i = 0 ; i < bs[bb_lhs].size() ; i ++ ) result.push( logic.mkXor(bs[bb_lhs][i], bs[bb_rhs][i])); return bs.newBvector(names, result, mkActVar(s_bbBvxor), tr); } // // Bitwise complement // BVRef BitBlaster::bbBvcompl(PTRef tr) { assert(tr != PTRef_Undef); assert(logic.getPterm(tr).size() == 1); if (bs.has(tr)) return bs[tr]; // Allocate new result vec names; getBVVars("not", names, bitwidth); // Allocate new result vec result; PTRef arg = logic.getPterm(tr)[0]; BVRef bb_arg = bbTerm(arg); for ( int i = 0 ; i < bs[bb_arg].size( ) ; i ++ ) result.push(logic.mkNot(bs[bb_arg][i])); // Save result and return return bs.newBvector(names, result, mkActVar(s_bbBvcompl), tr); } // // Logical NOT // BVRef BitBlaster::bbBvlnot(PTRef tr) { assert(tr != PTRef_Undef); assert(logic.getPterm(tr).size() == 1); if (bs.has(tr)) return bs[tr]; // Allocate new result vec names; getBVVars("lnot", names, bitwidth); // Allocate new result vec result; result.growTo(bitwidth, logic.getTerm_false()); PTRef arg = logic.getPterm(tr)[0]; BVRef bb_arg = bbTerm(arg); vec asgn; bs.copyAsgnTo(bb_arg, asgn); result[0] = logic.mkNot(logic.mkOr(std::move(asgn))); // for ( int i = 1 ; i < bitwidth; i ++ ) // result[i] = logic.getTerm_false(); // Save result and return return bs.newBvector(names, result, mkActVar(s_bbBvlnot), tr); } BVRef BitBlaster::bbBvadd(PTRef tr) { assert(tr != PTRef_Undef); assert( logic.getPterm(tr).size() == 2 ); if (bs.has(tr)) return bs[tr]; // Allocate new result vec names; getBVVars("add", names, bitwidth); // Allocate new result vec result; PTRef arg1 = logic.getPterm(tr)[0]; PTRef arg2 = logic.getPterm(tr)[1]; BVRef bb_arg1 = bbTerm(arg1); BVRef bb_arg2 = bbTerm(arg2); assert( bs[bb_arg1].size() == bs[bb_arg2].size() ); PTRef carry = PTRef_Undef; int bw = bs[bb_arg1].size(); // the bit width for (int i = 0 ; i < bw; i++) { PTRef bit_1 = bs[bb_arg1][i]; PTRef bit_2 = bs[bb_arg2][i]; assert(bit_1 != PTRef_Undef); assert(bit_2 != PTRef_Undef); PTRef xor_1 = logic.mkXor(bit_1, bit_2); PTRef and_1 = logic.mkAnd(bit_1, bit_2); if (carry != PTRef_Undef) { PTRef xor_2 = logic.mkXor(xor_1, carry); PTRef and_2 = logic.mkAnd(xor_1, carry); carry = logic.mkOr(and_1, and_2); result.push(xor_2); } else { carry = and_1; result.push(xor_1); } } // Save result and return return bs.newBvector(names, result, mkActVar(s_bbBvadd), tr); } PTRef BitBlaster::bbBvadd_carryonly(PTRef tr, PTRef cin) { assert(tr != PTRef_Undef); assert( logic.getPterm(tr).size() == 2 ); if (bs.has_carryonly(tr)) return bs.getCarryOnly(tr); PTRef a = logic.getPterm(tr)[0]; PTRef b = logic.getPterm(tr)[1]; BVRef bb_a = bbTerm(a); BVRef bb_b = bbTerm(b); assert( bs[bb_a].size() == bs[bb_b].size() ); PTRef carry = cin; int bw = bs[bb_a].size(); // the bit width for (int i = 0 ; i < bw; i++) { PTRef a_i = bs[bb_a][i]; PTRef b_i = bs[bb_b][i]; assert(a_i != PTRef_Undef); assert(b_i != PTRef_Undef); // Carry-out for i_th bit: // C_in comes from Carry_out for previous bit so that C_in = C_out_i-1 // C_out_i = carry(a_i, b_i, C_in) = (a_i /\ b_i) \/ ( (a_i xor b_i) /\ C_in ) PTRef xor_1 = logic.mkXor(a_i, b_i); PTRef and_1 = logic.mkAnd(a_i, b_i); PTRef and_2 = logic.mkAnd(xor_1, carry); carry = logic.mkOr(and_1, and_2); } bs.insertCarryOnly(tr, carry); // Save result and return return carry; } BVRef BitBlaster::bbBvudiv(PTRef tr) { assert(tr != PTRef_Undef); assert(logic.getPterm(tr).size() == 2); if (bs.has(tr)) return bs[tr]; // Allocate new result vec names; getBVVars("udi", names, bitwidth); // // Allocate new result // vec result; // // Garbage collect // vec minuend; PTRef arg1 = logic.getPterm(tr)[0]; PTRef arg2 = logic.getPterm(tr)[1]; BVRef dividend = bbTerm(arg1); BVRef divisor = bbTerm(arg2); assert(bs[divisor].size() == bs[dividend].size()); // // Generate condition divisor != 0 // PTRef zero = logic.getTerm_BVZero(); PTRef div_eq_zero = bs[bbTerm(logic.mkBVEq(arg2, zero))].lsb(); const unsigned size = bs[divisor].size( ); result.growTo(size); // // Initialize minuend as 0..0 q[n-1] // minuend.push(bs[dividend][size - 1]); for ( unsigned i = 1 ; i < size ; i ++ ) minuend.push(logic.getTerm_false()); // // Main loop // for ( int i = size - 1 ; i >= 0 ; i -- ) { // // Compute result[ i ] = !(minuend < divisor); // PTRef lt_prev = PTRef_Undef; for ( unsigned j = 0 ; j < size ; j ++ ) { // Produce ~l[j] & r[j] PTRef not_l = logic.mkNot(minuend[j]); PTRef lt_this = logic.mkAnd(not_l, bs[divisor][j]); // Produce l[j] <-> r[j] PTRef eq_this = logic.mkEq(minuend[j], bs[divisor][j]); if ( lt_prev != PTRef_Undef ) lt_prev = logic.mkOr(lt_this, logic.mkAnd(eq_this, lt_prev)); else lt_prev = lt_this; } assert( lt_prev != PTRef_Undef); result[i] = logic.mkOr(div_eq_zero, logic.mkNot(lt_prev)); PTRef bit_i = result[i]; // // Construct subtrahend // vec subtrahend; for ( unsigned j = 0 ; j < size ; j ++ ) subtrahend.push(logic.mkAnd(bit_i, bs[divisor][j])); // // Subtract and store in minuend // PTRef carry = PTRef_Undef; for (int j = 0; j < minuend.size(); j++ ) { PTRef bit_1 = minuend[j]; PTRef bit_2 = subtrahend[j]; assert(bit_1 != PTRef_Undef); assert(bit_2 != PTRef_Undef); PTRef bit_2_neg = logic.mkNot(bit_2); PTRef xor_1 = logic.mkXor(bit_1, bit_2_neg); PTRef and_1 = logic.mkAnd(bit_1, bit_2_neg); if (carry != PTRef_Undef) { PTRef xor_2 = logic.mkXor(xor_1, carry); PTRef and_2 = logic.mkAnd(xor_1, carry); carry = logic.mkOr(and_1, and_2); minuend[j] = xor_2; } else { carry = and_1; minuend[j] = xor_1; } } carry = PTRef_Undef; // // Adds one, if bit_i is one // for (int j = 0 ; j < minuend.size( ) ; j++) { PTRef bit_1 = minuend[j]; PTRef bit_2 = j == 0 ? logic.getTerm_true() : logic.getTerm_false(); assert(bit_1 != PTRef_Undef); PTRef xor_1 = logic.mkXor(bit_1, bit_2); PTRef and_1 = logic.mkAnd(bit_1, bit_2); if (carry != PTRef_Undef) { PTRef xor_2 = logic.mkXor(xor_1, carry); PTRef and_2 = logic.mkAnd(xor_1, carry); carry = logic.mkOr(and_1, and_2); minuend[j] = xor_2; } else { carry = and_1; minuend[j] = xor_1; } } if ( i > 0 ) { // // Prepare new minuend // // M[i-1] // // O[2] O[1] O[0] // N[2] N[1] N[0] // for (int j = size - 1 ; j >= 1 ; j --) { minuend[j] = minuend[j - 1]; } minuend[0] = bs[dividend][i - 1]; } } // // Save result and return // return bs.newBvector(names, result, mkActVar(s_bbBvudiv), tr); } BVRef BitBlaster::bbBvurem(PTRef tr) { assert(tr != PTRef_Undef); assert(logic.getPterm(tr).size() == 2); if (bs.has(tr)) return bs[tr]; // Allocate new result vec names; getBVVars("ure", names, bitwidth); // // Allocate new result // vec result; vec minuend; PTRef arg1 = logic.getPterm(tr)[0]; PTRef arg2 = logic.getPterm(tr)[1]; BVRef dividend = bbTerm(arg1); BVRef divisor = bbTerm(arg2); assert(bs[divisor].size( ) == bs[dividend].size( )); // // Generate condition divisor != 0 // PTRef zero = logic.getTerm_BVZero(); PTRef div_eq_zero = bs[bbTerm(logic.mkBVEq(arg2, zero))].lsb(); const unsigned size = bs[divisor].size(); result.growTo(size); // // Initialize minuend as 0..0 q[n-1] // minuend.push(bs[dividend][ size - 1 ]); for ( unsigned i = 1 ; i < size ; i ++ ) minuend.push(logic.getTerm_false()); // // Main loop // for ( int i = size - 1 ; i >= 0 ; i -- ) { // // Compute result[ i ] = !(minuend < divisor); // PTRef lt_prev = PTRef_Undef; for ( unsigned j = 0 ; j < size ; j ++ ) { // Produce ~l[j] & r[j] PTRef not_l = logic.mkNot(minuend[j]); PTRef lt_this = logic.mkAnd(not_l, bs[divisor][j]); // Produce l[j] <-> r[j] PTRef eq_this = logic.mkEq(minuend[j], bs[divisor][j]); if (lt_prev != PTRef_Undef) lt_prev = logic.mkOr(lt_this, logic.mkAnd(eq_this, lt_prev)); else lt_prev = lt_this; } assert(lt_prev != PTRef_Undef); PTRef bit_i = logic.mkNot(lt_prev); // // Construct subtrahend // vec subtrahend; for ( unsigned j = 0 ; j < size ; j ++ ) subtrahend.push(logic.mkAnd(bit_i, bs[divisor][j])); // // Subtract and store in minuend // PTRef carry = PTRef_Undef; for (unsigned j = 0; j < static_cast(minuend.size()); j++) { PTRef bit_1 = minuend[ j ]; PTRef bit_2 = subtrahend[ j ]; assert(bit_1 != PTRef_Undef); assert(bit_2 != PTRef_Undef); PTRef bit_2_neg = logic.mkNot(bit_2); PTRef xor_1 = logic.mkXor(bit_1, bit_2_neg); PTRef and_1 = logic.mkAnd(bit_1, bit_2_neg); if (carry != PTRef_Undef) { PTRef xor_2 = logic.mkXor(xor_1, carry); PTRef and_2 = logic.mkAnd(xor_1, carry); carry = logic.mkOr(and_1, and_2); minuend[j] = xor_2; } else { carry = and_1; minuend[j] = xor_1; } } carry = PTRef_Undef; // // Adds one, if bit_i is one // for (unsigned j = 0; j < static_cast(minuend.size()); j++) { PTRef bit_1 = minuend[ j ]; PTRef bit_2 = j == 0 ? logic.getTerm_true() : logic.getTerm_false(); assert(bit_1 != PTRef_Undef); PTRef xor_1 = logic.mkXor(bit_1, bit_2); PTRef and_1 = logic.mkAnd(bit_1, bit_2); if (carry != PTRef_Undef) { PTRef xor_2 = logic.mkXor(xor_1, carry); PTRef and_2 = logic.mkAnd(xor_1, carry); carry = logic.mkOr(and_1, and_2); minuend[j] = xor_2; } else { carry = and_1; minuend[ j ] = xor_1; } } if (i > 0) { // // Prepare new minuend // // M[i-1] // // O[2] O[1] O[0] // N[2] N[1] N[0] // for ( int j = size - 1 ; j >= 1 ; j -- ) minuend[j] = minuend[j - 1]; minuend[0] = bs[dividend][i - 1]; } else { for ( unsigned j = 0 ; j < size ; j ++ ) { result[j] = logic.mkOr(div_eq_zero, minuend[j]); } } } // // Save result and return // return bs.newBvector(names, result, mkActVar(s_bbBvurem), tr); } void BitBlaster::ls_write(int s, int i, PTRef tr, std::vector >& table) { table[s+1][i] = tr; } PTRef BitBlaster::ls_read(int s, int i, std::vector >& table) { return table[s+1][i]; } BVRef BitBlaster::bbBvlshift(PTRef tr) { assert(tr != PTRef_Undef); assert(logic.getPterm(tr).size() == 2 ); if (bs.has(tr)) return bs[tr]; // Allocate new result vec names; getBVVars("lsh", names, bitwidth); // Allocate new result vec result; vec acc; PTRef arg1 = logic.getPterm(tr)[0]; PTRef arg2 = logic.getPterm(tr)[1]; BVRef a = bbTerm(arg1); BVRef b = bbTerm(arg2); assert(opensmt::isPowOfTwo(bs[a].size())); assert(opensmt::isPowOfTwo(bs[b].size())); int l = bs[a].size(); int n = opensmt::getLogFromPowOfTwo(bs[a].size()); std::vector > ls; for (int s = -1; s <= n-1; s++) { ls.emplace_back(); for (int i = 0; i < l; i++) ls.back().push(PTRef_Undef); } for (int i = 0; i < l; i++) ls_write(-1, i, bs[a][i], ls); for (int s = 0; s <= n-1; s++) { for (int i = 0; i < l; i++) { if (i >= (1 << s)) // i >= 2^s ls_write(s, i, logic.mkIte(bs[b][s], ls_read(s-1, i-(1 << s), ls), ls_read(s-1, i, ls)), ls); else ls_write(s, i, logic.mkIte(bs[b][s], logic.getTerm_false(), ls_read(s-1, i, ls)), ls); } } return bs.newBvector(names, ls.back(), mkActVar(s_bbBvlsh), tr); } BVRef BitBlaster::bbBvlrshift(PTRef tr) { return bbBvrshift(tr, false); } BVRef BitBlaster::bbBvarshift(PTRef tr) { return bbBvrshift(tr, true); } BVRef BitBlaster::bbBvrshift(PTRef tr, bool arith) { assert(tr != PTRef_Undef); assert(logic.getPterm(tr).size() == 2 ); if (bs.has(tr)) return bs[tr]; // Allocate new result vec names; const char* name_str = arith ? "arsh" : "lrsh"; getBVVars(name_str, names, bitwidth); // Allocate new result vec result; vec acc; PTRef arg1 = logic.getPterm(tr)[0]; PTRef arg2 = logic.getPterm(tr)[1]; BVRef a = bbTerm(arg1); BVRef b = bbTerm(arg2); assert(opensmt::isPowOfTwo(bs[a].size())); assert(opensmt::isPowOfTwo(bs[b].size())); int l = bs[a].size(); int n = opensmt::getLogFromPowOfTwo(bs[a].size()); std::vector> ls; for (int s = -1; s <= n-1; s++) { ls.emplace_back(); for (int i = 0; i < l; i++) ls.back().push(PTRef_Undef); } for (int i = 0; i < l; i++) ls_write(-1, i, bs[a][i], ls); PTRef fill = arith ? bs[a].msb() : logic.getTerm_false(); for (int s = 0; s <= n-1; s++) { for (int i = 0; i < l; i++) { if (i + (1 << s) <= l-1) // i + 2^s <= l-1 ls_write(s, i, logic.mkIte(bs[b][s], ls_read(s-1, i+(1 << s), ls), ls_read(s-1, i, ls)), ls); else ls_write(s, i, logic.mkIte(bs[b][s], fill, ls_read(s-1, i, ls)), ls); } } PTRef actVar = arith ? mkActVar(s_bbBvarsh) : mkActVar(s_bbBvlrsh); return bs.newBvector(names, ls.back(), actVar, tr); } BVRef BitBlaster::bbBvmul(PTRef tr) { assert(tr != PTRef_Undef); assert(logic.getPterm(tr).size() == 2 ); if (bs.has(tr)) return bs[tr]; // Allocate new result vec names; getBVVars("mul", names, bitwidth); // Allocate new result vec result; vec acc; PTRef arg1 = logic.getPterm(tr)[0]; PTRef arg2 = logic.getPterm(tr)[1]; BVRef bb_arg1 = bbTerm(arg1); BVRef bb_arg2 = bbTerm(arg2); assert(bs[bb_arg1].size() == bs[bb_arg2].size()); const unsigned size = bs[bb_arg1].size( ); // Compute term a_{i-1}*b_{j-1} ... a_0*b_0 for ( unsigned i = 0 ; i < size ; i ++ ) acc.push(logic.mkAnd(bs[bb_arg2][0], bs[bb_arg1][i])); // Multi-arity adder for ( unsigned i = 1 ; i < size ; i ++ ) { vec addend; // Push trailing 0s for ( unsigned j = 0 ; j < i ; j ++ ) addend.push(logic.getTerm_false()); // Compute term a_{i-1}*b_i ... a_0*b_i 0 ... 0 for ( unsigned j = 0 ; j < size - i ; j ++ ) addend.push(logic.mkAnd(bs[bb_arg2][i], bs[bb_arg1][j])); assert(static_cast(addend.size()) == size); // Accumulate computed term PTRef carry = PTRef_Undef; for (unsigned k = 0 ; k < size ; k++) { PTRef bit_1 = acc[ k ]; PTRef bit_2 = addend[ k ]; assert(bit_1 != PTRef_Undef); assert(bit_2 != PTRef_Undef); PTRef xor_1 = logic.mkXor(bit_1, bit_2); PTRef and_1 = logic.mkAnd(bit_1, bit_2 ); if (carry != PTRef_Undef) { PTRef xor_2 = logic.mkXor(xor_1, carry); PTRef and_2 = logic.mkAnd(xor_1, carry); carry = logic.mkOr(and_1, and_2); if ( i == size - 1 ) result.push(xor_2); else acc[k] = xor_2; } else { carry = and_1; if ( i == size - 1 ) result.push(xor_1); else acc[k] = xor_1; } } } return bs.newBvector(names, result, mkActVar(s_bbBvmul), tr); } BVRef BitBlaster::bbSignExtend(PTRef tr) { assert(tr != PTRef_Undef); assert(logic.getPterm(tr).size() == 1 ); // Return previous result if computed if (bs.has(tr)) return bs[tr]; // Allocate new result vec names; getBVVars("se", names, bitwidth); vec result; PTRef x = logic.getPterm(tr)[0]; BVRef bb_x = bbTerm(x); // Copy x int i = 0; for ( ; i < bs[bb_x].size( ) ; i ++ ) result.push(bs[bb_x][i]); // Sign extend for ( ; i < bitwidth; i ++ ) // Should be bit width of what? result.push(bs[bb_x].lsb()); return bs.newBvector(names, result, mkActVar(s_bbSignExtend), tr); } BVRef BitBlaster::bbVar(PTRef tr) { assert(tr != PTRef_Undef); assert(logic.isVar(tr)); if (bs.has(tr)) return bs[tr]; // Allocate new result vec names; getBVVars("bv", names, bitwidth); vec result; names.copyTo(result); // Save variable variables.push(tr); BVRef rval = bs.newBvector(names, result, mkActVar(s_bbVar), tr); return rval; } BVRef BitBlaster::bbConstant(PTRef tr) { assert(tr != PTRef_Undef); assert(logic.isConstant(tr)); if (bs.has(tr)) return bs[tr]; // Allocate new result vec names; getBVVars("c", names, bitwidth); vec asgns; asgns.growTo(bitwidth, logic.getTerm_false()); // for (int i = 0; i < bitwidth; i++) { // asgns[i] = logic.getTerm_false(); // } if (logic.isTrue(tr)) asgns[0] = logic.getTerm_true(); else if (logic.isFalse(tr)) ; // already ok else { const std::string value = logic.getSymName(tr); assert(value.length() == static_cast(bitwidth)); for (int i = 0 ; i < bitwidth; i ++) { asgns[i] = value[bitwidth-i-1] == '1' ? logic.getTerm_true() : logic.getTerm_false(); } } // Save result and return return bs.newBvector(names, asgns, mkActVar(s_bbConstant), tr); } /* vector< Enode * > & BitBlaster::bbUf( Enode * ) { assert( false ); } vector< Enode * > & BitBlaster::bbUp( Enode * ) { assert( false ); } */ BVRef BitBlaster::bbDistinct(PTRef tr) { assert(tr != PTRef_Undef); assert(logic.isDisequality(tr)); if (bs.has(tr)) return bs[tr]; vec vars; getBVVars("d", vars, bitwidth); vec result; result.growTo(bitwidth, logic.getTerm_false()); vec args; for (int i = 0; i < logic.getPterm(tr).size(); i++) args.push(logic.getPterm(tr)[i]); // // Quadratic encoding // vec res_args; for (int i = 0; i < logic.getPterm(tr).size()-1; i++) { for (int j = i+1; j < logic.getPterm(tr).size(); j++) { BVRef bb_pair = bbTerm(logic.mkBVEq(args[i], args[j])); assert(bs[bb_pair].size() == 1); res_args.push(logic.mkNot(bs[bb_pair].lsb())); } } result[0] = logic.mkAnd(res_args); return bs.newBvector(vars, result, mkActVar(s_bbDistinct), tr); } bool BitBlaster::addClause(vec & c) { return solverP.addOriginalClause(c); } //============================================================================= // CNFization Routines // //Var //BitBlaster::cnfizeAndGiveToSolver( Enode * bb, Enode * atom ) //{ // // Stack for unprocessed enodes // vector< Enode * > unprocessed_enodes; // // Cnfize and give to solver // unprocessed_enodes.push_back( bb ); // // while( !unprocessed_enodes.empty( ) ) // { // Enode * enode = unprocessed_enodes.back( ); // assert( enode->hasSortBool( ) ); // // // // Skip if the node has already been processed before // // // if ( (int)cnf_cache.size( ) <= enode->getId( ) ) // cnf_cache.resize( enode->getId( ) + 1, lit_Undef ); // if ( cnf_cache[ enode->getId( ) ] != lit_Undef ) // { // unprocessed_enodes.pop_back( ); // continue; // } // // bool unprocessed_children = false; // Enode * arg_list; // for ( arg_list = enode->getCdr( ) ; // arg_list != E.enil ; // arg_list = arg_list->getCdr( ) ) // { // Enode * arg = arg_list->getCar( ); // assert( arg->isTerm( ) ); // // // // Push children if not processed already // // // if ( (int)cnf_cache.size( ) <= arg->getId( ) ) // cnf_cache.resize( arg->getId( ) + 1, lit_Undef ); // if ( cnf_cache[ arg->getId( ) ] == lit_Undef ) // { // unprocessed_enodes.push_back( arg ); // unprocessed_children = true; // } // } // // // // SKip if unprocessed children // // // if ( unprocessed_children ) // continue; // // unprocessed_enodes.pop_back( ); // Lit result = lit_Undef; // // // // At this point, every child has been processed // // // // // // Do the actual cnfization, according to the node type // // // if ( enode->isTrue( ) ) // result = constTrue; // else if ( enode->isFalse( ) ) // result = constFalse; // else if ( enode->isAtom( ) ) // { // // Allocate a new boolean variable for this atom // Var var = solverP.newVar( ); // // Keep track to retrieve model // assert( cnf_var.find( enode->getId( ) ) == cnf_var.end( ) ); // cnf_var[ enode->getId( ) ] = var; // result = Lit( var ); // } // else if ( enode->isNot( ) ) // { // assert( (int)cnf_cache.size( ) > enode->getId( ) ); // // Lit arg_def = cnf_cache[ enode->get1st( )->getId( ) ]; // assert( arg_def != lit_Undef ); // // Toggle variable // result = ~arg_def; // } // else // { // // // // Allocates a new variable for definition // // // Var var = solverP.newVar( ); // // // // Store correspondence // // // result = Lit( var ); // // // // Handle remaining cases // // // // Enode * atom_ = ( enode == bb ? atom : NULL ); // // if ( enode->isAnd( ) ) // cnfizeAnd( enode, result, atom_ ); // else if ( enode->isOr( ) ) // cnfizeOr ( enode, result, atom_ ); // /* // else if ( enode->isIff( ) ) // cnfizeIff( enode, result, atom_ ); // */ // else if ( enode->isXor( ) ) // cnfizeXor( enode, result, atom_ ); // else // opensmt_error2( "operator not handled ", enode->getCar( ) ); // } // // assert( result != lit_Undef ); // assert( cnf_cache[ enode->getId( ) ] == lit_Undef ); // // Store result // cnf_cache[ enode->getId( ) ] = result; // } // // // // // Add an activation variable // // // assert( cnf_cache[ bb->getId( ) ] != lit_Undef ); // // Lit l = cnf_cache[ bb->getId( ) ]; // // Var act = solverP.newVar( ); // Lit lact = Lit( act ); // vec< Lit > clause; // // // // Adds ~act | l // // // clause.push( ~lact ); // clause.push( l ); // addClause( clause, atom ); // // // // Adds act | ~l // // // clause.pop( ); // clause.pop( ); // clause.push( lact ); // clause.push( ~l ); // addClause( clause, atom ); // // return act; //} //void //BitBlaster::cnfizeAnd( Enode * enode, Lit def, Enode * atom ) //{ // assert( enode ); // Enode * list = NULL; // // // // ( a_0 & ... & a_{n-1} ) // // // // <=> // // // // aux = ( -aux | a_0 ) & ... & ( -aux | a_{n-1} ) & ( aux & -a_0 & ... & -a_{n-1} ) // // // vec< Lit > little_clause; // vec< Lit > big_clause; // little_clause.push( ~def ); // big_clause .push( def ); // for ( list = enode->getCdr( ) // ; list != E.enil // ; list = list->getCdr( ) ) // { // Lit arg = cnf_cache[ list->getCar( )->getId( ) ]; // assert( arg != lit_Undef ); // little_clause.push( arg ); // big_clause .push( ~arg ); // addClause( little_clause, atom ); // little_clause.pop( ); // } // addClause( big_clause, atom ); //} //void //BitBlaster::cnfizeOr( Enode * enode, Lit def, Enode * atom ) //{ // assert( enode ); // Enode * list = NULL; // // // // ( a_0 | ... | a_{n-1} ) // // // // <=> // // // // aux = ( aux | -a_0 ) & ... & ( aux | -a_{n-1} ) & ( -aux | a_0 | ... | a_{n-1} ) // // // vec< Lit > little_clause; // vec< Lit > big_clause; // little_clause.push( def ); // big_clause .push( ~def ); // for ( list = enode->getCdr( ) // ; list != E.enil // ; list = list->getCdr( ) ) // { // Lit arg = cnf_cache[ list->getCar( )->getId( ) ]; // little_clause.push( ~arg ); // big_clause .push( arg ); // addClause( little_clause, atom ); // little_clause.pop( ); // } // addClause( big_clause, atom ); //} //void //BitBlaster::cnfizeXor( Enode * enode, Lit def, Enode * atom ) //{ // assert( enode ); // Enode * list = enode->getCdr( ); // // // // ( a_0 xor a_1 ) // // // // <=> // // // // aux = ( -aux | a_0 | a_1 ) & ( -aux | -a_0 | -a_1 ) & // // ( aux | -a_0 | a_1 ) & ( aux | a_0 | a_1 ) // // // assert( list->getArity( ) == 2 ); // Lit arg0 = cnf_cache[ list->getCar( )->getId( ) ]; // Lit arg1 = cnf_cache[ list->getCdr( )->getCar( )->getId( ) ]; // vec< Lit > clause; // // clause.push( ~def ); // // // First clause // clause .push( ~arg0 ); // clause .push( ~arg1 ); // addClause( clause, atom ); // clause .pop( ); // clause .pop( ); // // // Second clause // clause .push( arg0 ); // clause .push( arg1 ); // addClause( clause, atom ); // clause .pop( ); // clause .pop( ); // // clause.pop( ); // clause.push( def ); // // // Third clause // clause .push( ~arg0 ); // clause .push( arg1 ); // addClause( clause, atom ); // clause .pop( ); // clause .pop( ); // // // Fourth clause // clause .push( arg0 ); // clause .push( ~arg1 ); // addClause( clause, atom ); //} //void //BitBlaster::cnfizeIff( Enode * enode, Lit def, Enode * atom ) //{ // assert( enode ); // Enode * list = enode->getCdr( ); // // // // ( a_0 <-> a_1 ) // // // // <=> // // // // aux = ( -aux | a_0 | -a_1 ) & ( -aux | -a_0 | a_1 ) & // // ( aux | a_0 | a_1 ) & ( aux | -a_0 | -a_1 ) // // // assert( list->getArity( ) == 2 ); // Lit arg0 = cnf_cache[ list->getCar( )->getId( ) ]; // Lit arg1 = cnf_cache[ list->getCdr( )->getCar( )->getId( ) ]; // vec< Lit > clause; // // clause.push( ~def ); // // // First clause // clause .push( arg0 ); // clause .push( ~arg1 ); // addClause( clause, atom ); // clause .pop( ); // clause .pop( ); // // // Second clause // clause .push( ~arg0 ); // clause .push( arg1 ); // addClause( clause, atom ); // clause .pop( ); // clause .pop( ); // // clause.pop( ); // clause.push( def ); // // // Third clause // clause .push( ~arg0 ); // clause .push( ~arg1 ); // addClause( clause, atom ); // clause .pop( ); // clause .pop( ); // // // Fourth clause // clause .push( arg0 ); // clause .push( arg1 ); // addClause( clause, atom ); //} //void //BitBlaster::cnfizeIfthenelse( Enode * enode, Lit def, Enode * atom ) //{ // assert( enode ); // Enode * list = enode->getCdr( ); // // // // ( if a_0 then a_1 else a_2 ) // // // // <=> // // // // aux = ( -aux | -a_0 | a_1 ) & // // ( -aux | a_0 | a_2 ) & // // ( aux | -a_0 | -a_1 ) & // // ( aux | a_0 | -a_2 ) // // // assert( list->getArity( ) == 2 ); // Lit arg0 = cnf_cache[ list->getCar( )->getId( ) ]; // Lit arg1 = cnf_cache[ list->getCdr( )->getCar( )->getId( ) ]; // vec< Lit > clause; // // clause.push( ~def ); // // // First clause // clause .push( ~arg0 ); // clause .push( arg1 ); // addClause( clause, atom ); // clause .pop( ); // clause .pop( ); // // // Second clause // clause .push( arg0 ); // clause .push( arg1 ); // addClause( clause, atom ); // clause .pop( ); // clause .pop( ); // // clause.pop( ); // clause.push( def ); // // // Third clause // clause .push( ~arg0 ); // clause .push( ~arg1 ); // addClause( clause, atom ); // clause .pop( ); // clause .pop( ); // // // Fourth clause // clause .push( arg0 ); // clause .push( ~arg1 ); // addClause( clause, atom ); //} void BitBlaster::cleanGarbage( ) { } PTRef BitBlaster::simplify( PTRef formula ) { assert(formula != PTRef_Undef); Map seen; vec unprocessed_terms; unprocessed_terms.push(formula); // // Visit the DAG of the formula from the leaves to the root // while (unprocessed_terms.size() != 0) { PTRef tr = unprocessed_terms.last(); // // Skip if the node has already been processed before // if (seen.has(tr)) { unprocessed_terms.pop(); continue; } bool unprocessed_children = false; Pterm& t = logic.getPterm(tr); for (int i = 0; i < t.size(); i++) { PTRef arg = t[i]; if (!seen.has(arg)) { unprocessed_terms.push(arg); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_terms.pop(); PTRef result = PTRef_Undef; if ( logic.isAnd(tr) && logic.getPterm(tr).size() == 2) { PTRef x = seen[logic.getPterm(tr)[0]]; PTRef y = seen[logic.getPterm(tr)[1]]; assert( x != PTRef_Undef ); assert( y != PTRef_Undef ); // // Rule 1 // // (and x (not x)) --> false // if ( ( logic.isNot(x) && logic.getPterm(x)[0] == y ) || ( logic.isNot(y) && logic.getPterm(y)[0] == x)) result = logic.getTerm_false(); // // Rule 2 // // (and (not z) (not w)) --> (not (or z w)) // else if (logic.isNot(x) && logic.isNot(y)) { PTRef z = logic.getPterm(x)[0]; PTRef w = logic.getPterm(y)[0]; assert( z != PTRef_Undef ); assert( w != PTRef_Undef ); result = logic.mkNot(logic.mkOr(z, w)); } } else if ( logic.isOr(tr) && logic.getPterm(tr).size() == 2 ) { PTRef x = seen[logic.getPterm(tr)[0]]; PTRef y = seen[logic.getPterm(tr)[1]]; assert( x != PTRef_Undef ); assert( y != PTRef_Undef ); // // Rule 3 // // (or x (and (not x) z)) --> (or x z)) // if ( logic.isAnd(y) && (logic.getPterm(y).size() == 2) && logic.isNot(logic.getPterm(y)[0]) && (logic.getPterm(logic.getPterm(y)[0])[0] == x) ) { PTRef z = logic.getPterm(y)[1]; result = logic.mkOr(x, z); } // // Rule 4 // // (or (and (not y) z) y) --> (or z y)) // if ( logic.isAnd(x) && logic.getPterm(x).size() == 2 && logic.isNot(logic.getPterm(x)[0]) && logic.getPterm(logic.getPterm(x)[0])[0] == y) { PTRef z = logic.getPterm(x)[1]; result = logic.mkOr(y, z); } } if (result == PTRef_Undef) { result = tr; //result = E.copyEnodeEtypeTermWithCache( enode, true ); } assert(result != PTRef_Undef); assert(!seen.has(tr)); seen.insert(tr, result); } PTRef new_formula = seen[formula]; assert(new_formula != PTRef_Undef); return new_formula; } // // Compute the number of incoming edges for e and children // //void BitBlaster::computeIncomingEdges( Enode * e, map< int, int > & enodeid_to_incoming_edges ) //{ // assert( e ); // // if ( !e->isBooleanOperator( ) ) // return; // // for ( Enode * list = e->getCdr( ) ; // !list->isEnil( ) ; // list = list->getCdr( ) ) // { // Enode * arg = list->getCar( ); // map< int, int >::iterator it = enodeid_to_incoming_edges.find( arg->getId( ) ); // if ( it == enodeid_to_incoming_edges.end( ) ) // enodeid_to_incoming_edges[ arg->getId( ) ] = 1; // else // it->second ++; // computeIncomingEdges( arg, enodeid_to_incoming_edges ); // } //} // // Rewrite formula with maximum arity for operators // //Enode * BitBlaster::rewriteMaxArity( Enode * formula, map< int, int > & enodeid_to_incoming_edges ) //{ // assert( formula ); // // vector< Enode * > unprocessed_enodes; // Stack for unprocessed enodes // unprocessed_enodes.push_back( formula ); // formula needs to be processed // map< int, Enode * > cache; // Cache of processed nodes // // // // Visit the DAG of the formula from the leaves to the root // // // while( !unprocessed_enodes.empty( ) ) // { // Enode * enode = unprocessed_enodes.back( ); // // // // Skip if the node has already been processed before // // // if ( cache.find( enode->getId( ) ) != cache.end( ) ) // { // unprocessed_enodes.pop_back( ); // continue; // } // // bool unprocessed_children = false; // Enode * arg_list; // for ( arg_list = enode->getCdr( ) ; // arg_list != E.enil ; // arg_list = arg_list->getCdr( ) ) // { // Enode * arg = arg_list->getCar( ); // // assert( arg->isTerm( ) ); // // // // Push only if it is an unprocessed boolean operator // // // if ( arg->isBooleanOperator( ) // && cache.find( arg->getId( ) ) == cache.end( ) ) // { // unprocessed_enodes.push_back( arg ); // unprocessed_children = true; // } // // // // If it is an atom (either boolean or theory) just // // store it in the cache // // // else if ( arg->isAtom( ) ) // { // cache.insert( make_pair( arg->getId( ), arg ) ); // } // } // // // // SKip if unprocessed_children // // // if ( unprocessed_children ) // continue; // // unprocessed_enodes.pop_back( ); // Enode * result = NULL; // // // // At this point, every child has been processed // // // assert ( enode->isBooleanOperator( ) ); // // if ( enode->isAnd( ) // || enode->isOr ( ) ) // { // assert( enode->isAnd( ) || enode->isOr( ) ); // // // // Construct the new lists for the operators // // // result = mergeEnodeArgs( enode, cache, enodeid_to_incoming_edges ); // } // else // { // result = enode; // } // // assert( result ); // assert( cache.find( enode->getId( ) ) == cache.end( ) ); // cache[ enode->getId( ) ] = result; // } // // Enode * top_enode = cache[ formula->getId( ) ]; // return top_enode; //} // // Merge collected arguments for nodes // //Enode * BitBlaster::mergeEnodeArgs( Enode * e // , map< int, Enode * > & cache // , map< int, int > & enodeid_to_incoming_edges ) //{ // assert( e->isAnd( ) || e->isOr( ) ); // // Enode * e_symb = e->getCar( ); // vector< Enode * > new_args; // // for ( Enode * list = e->getCdr( ) ; // !list->isEnil( ) ; // list = list->getCdr( ) ) // { // Enode * arg = list->getCar( ); // Enode * sub_arg = cache[ arg->getId( ) ]; // Enode * sym = arg->getCar( ); // // if ( sym->getId( ) != e_symb->getId( ) ) // { // new_args.push_back( sub_arg ); // continue; // } // // assert( enodeid_to_incoming_edges.find( arg->getId( ) ) != enodeid_to_incoming_edges.end( ) ); // assert( enodeid_to_incoming_edges[ arg->getId( ) ] >= 1 ); // // if ( enodeid_to_incoming_edges[ arg->getId( ) ] > 1 ) // { // new_args.push_back( sub_arg ); // continue; // } // // for ( Enode * sub_arg_list = sub_arg->getCdr( ) ; // !sub_arg_list->isEnil( ) ; // sub_arg_list = sub_arg_list->getCdr( ) ) // new_args.push_back( sub_arg_list->getCar( ) ); // } // // Enode * new_list = const_cast< Enode * >(E.enil); // // while ( !new_args.empty( ) ) // { // new_list = E.cons( new_args.back( ), new_list ); // new_args.pop_back( ); // } // // return E.cons( e_symb, new_list ); //} void BitBlaster::computeModel( ) { model.clear(); ModelBuilder localModelBuilder(logic); solverP.fillBooleanVars(localModelBuilder); auto localModel = localModelBuilder.build(); for (unsigned i = 0; i < variables.size_(); i++) { PTRef e = variables[ i ]; Real value = 0; Real coeff = 1; // Retrieve bitblasted vector BVRef blast = bs[e]; for (int j = 0; j < bs[blast].size(); j++) { PTRef b = bs[blast][j]; auto val = localModel->evaluate(b); assert(val == logic.getTerm_true() || val == logic.getTerm_false() ); Real bit = val == logic.getTerm_true() ? 1 : 0; if (bs[blast].is_signed() && (j = bs[blast].size()-1)) value = value - coeff * bit; // The last one is negative else value = value + coeff * bit; coeff = Real( 2 ) * coeff; } model[e] = logic.mkBVNumVar(value.get_str().c_str()); } has_model = true; } lbool BitBlaster::notifyEqualities() { int added_eqs = 0; lbool stat = l_Undef; for (int i = last_refined; i < refined.size(); i++) { for (int j = i+1; j < refined.size(); j++) { if (logic.getSortRef(refined[i]) != logic.getSortRef(refined[j])) continue; PTRef eq = logic.mkEq(refined[i], refined[j]); added_eqs++; if (!logic.isEquality(eq)) continue; stat = notifyEquality(eq); if ((stat == l_False) || (stat == l_True)) return stat; } for (int j = last_refined - 1; j >= 0; j--) { if (logic.getSortRef(refined[i]) != logic.getSortRef(refined[j])) continue; PTRef eq = logic.mkEq(refined[i], refined[j]); added_eqs++; if (!logic.isEquality(eq)) continue; stat = notifyEquality(eq); if ((stat == l_False) || (stat == l_True)) return stat; } } std::cerr << "; Added " << added_eqs << " equalities for bind" << '\n'; last_refined = refined.size(); return stat; } lbool BitBlaster::notifyEquality(PTRef tr) { assert(logic.isEquality(tr)); Pterm &t = logic.getPterm(tr); PTRef eq_arg0 = t[0]; PTRef eq_arg1 = t[1]; assert(isBound(eq_arg0)); assert(isBound(eq_arg1)); PTRef bv_tr0 = getBoundPTRef(eq_arg0); PTRef bv_tr1 = getBoundPTRef(eq_arg1); BVRef bv0_r = bs[bv_tr0]; BVRef bv1_r = bs[bv_tr1]; assert(bs[bv0_r].size() == bs[bv1_r].size()); vec and_args; for (int i = 0; i < bs[bv0_r].size(); i++) and_args.push(logic.mkEq(bs[bv0_r][i], bs[bv1_r][i])); PTRef iff_tr = logic.mkEq(tr, logic.mkAnd(and_args)); char* msg; sstat status = mainSolver.insertFormula(iff_tr, &msg); if (status == s_True) return l_True; else if (status == s_False) return l_False; else return l_Undef; } opensmt-2.5.2/src/tsolvers/bvsolver/BitBlaster.h000066400000000000000000000166701445011647600217450ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #ifndef BITBLASTER_H #define BITBLASTER_H #include "SimpSMTSolver.h" #include "BVStore.h" #include // forward declarations class BVLogic; class MainSolver; class Enode; class BitBlaster { public: BitBlaster(SolverId, SMTConfig & c, MainSolver & mainSolver, BVLogic & bvlogic, vec & ex, vec & s); ~BitBlaster ( ); lbool inform (PTRef); // For the interface for bitvector solver lbool check ( ); bool assertLit (PtAsgn); lbool insertEq (PTRef tr, BVRef& out); // For the interface for theory refinement lbool insertOr (PTRef tr, BVRef& out); // For the interface for theory refinement void pushBacktrackPoint ( ); void popBacktrackPoint ( ); void computeModel ( ); PTRef getValue (PTRef tr) const { if (has_model) { return model.at(tr); } else { return PTRef_Undef; }} // Public Theory refinement stuff lbool notifyEqualities (); // Check all refined equalities, add explicit new terms for them void bindCUFToBV (PTRef cuf_tr, PTRef bv_tr) { assert(!pToB.has(cuf_tr)); bbTerm(bv_tr); pToB.insert(cuf_tr, bv_tr); refined.push(cuf_tr); } PTRef mkCollate32 (vec& bits); PTRef mkExtract (PTRef tr, int i); // Theory refinement stuff PTRef getBoundPTRef (PTRef tr) { assert(pToB.has(tr)); return pToB[tr]; } bool isBound (PTRef tr) { return pToB.has(tr); } private: Map pToB; vec refined; int last_refined; lbool notifyEquality(PTRef tr_eq); // ----- BVRef bbTerm (PTRef); lbool insert (PTRef tr, BVRef& out); // The unsafe interface for theory refinement BVRef updateCache (PTRef tr); SMTConfig & config; // Configuration MainSolver& mainSolver; BVLogic& logic; // Egraph store THandler& thandler; SimpSMTSolver& solverP; // Solver with proof logger bool addClause(vec & c); static const char* s_bbEq; static const char* s_bbAnd; static const char* s_bbBvslt; static const char* s_bbBvule; static const char* s_bbConcat; static const char* s_bbExtract; static const char* s_bbBvand; static const char* s_bbBvland; static const char* s_bbBvor; static const char* s_bbBvlor; static const char* s_bbBvxor; static const char* s_bbBvcompl; static const char* s_bbBvlnot; static const char* s_bbBvadd; static const char* s_bbBvmul; static const char* s_bbBvudiv; static const char* s_bbBvurem; static const char* s_bbSignExtend; static const char* s_bbVar; static const char* s_bbConstant; static const char* s_bbDistinct; static const char* s_bbBvcarry; static const char* s_bbBvlsh; static const char* s_bbBvlrsh; static const char* s_bbBvarsh; char* getName(const char* base) const; void getBVVars(const char* base, vec& vars, int width); PTRef mkActVar(const char* base); // Predicates BVRef bbEq (PTRef); BVRef bbBvslt (PTRef); BVRef bbBvule (PTRef); // Terms BVRef bbConcat (PTRef); BVRef bbExtract (PTRef); BVRef bbBvand (PTRef); BVRef bbBvland (PTRef); BVRef bbBvor (PTRef); BVRef bbBvlor (PTRef); BVRef bbBvxor (PTRef); BVRef bbBvcompl (PTRef); BVRef bbBvlnot (PTRef); BVRef bbBvadd (PTRef); BVRef bbBvmul (PTRef); BVRef bbBvudiv (PTRef); BVRef bbBvurem (PTRef); BVRef bbBvlshift (PTRef); BVRef bbBvrshift (PTRef, bool); BVRef bbBvlrshift (PTRef); BVRef bbBvarshift (PTRef); BVRef bbSignExtend (PTRef); BVRef bbVar (PTRef); BVRef bbConstant (PTRef); BVRef bbDistinct (PTRef); PTRef bbBvadd_carryonly(PTRef sum, PTRef cin); // for signed comparison void ls_write(int s, int i, PTRef tr, std::vector >& table); // Helper function for shifts PTRef ls_read(int s, int i, std::vector >& table); // Helper function for shifts // Not yet considered // vector< Enode * > & bbUf ( Enode * ); // vector< Enode * > & bbUp ( Enode * ); void cleanGarbage ( ); // Clean garbage on demand PTRef simplify ( PTRef ); // Further simplifications // Enode * rewriteMaxArity ( Enode * // , map< int, int > & ); // void computeIncomingEdges ( Enode * // , map< int, int > & ); // Computes the list of incoming edges for a node // Enode * mergeEnodeArgs ( Enode * // , map< int, Enode * > & // , map< int, int > & ); // Rewrite terms using maximum arity Lit constTrue; // Constant literal set to true Lit constFalse; // Constant literal set to false BVStore bs; std::vector< Lit > cnf_cache; // Global cache for cnfizer std::vector< Var > enode_id_to_var; // Theory atom to Minisat Var correspondence std::vector< Enode * > var_to_enode; // Minisat Var to Theory Atom correspondence vec & explanation; // Reference to explanation vec & suggestions; // Reference to suggestions vec variables; // Variables std::map< int, Var > cnf_var; // BB variable to cnf var bool has_model; // Is the model computed std::unordered_map model; // Model is stored here int bitwidth; }; #endif opensmt-2.5.2/src/tsolvers/bvsolver/Bvector.h000066400000000000000000000152771445011647600213200ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2017 Antti Hyvarinen 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. *********************************************************************/ #ifndef BVECTOR_H #define BVECTOR_H #include "Vec.h" #include "Alloc.h" #include "PTRef.h" #include "Map.h" struct BVRef { uint32_t x; void operator= (uint32_t v) { x = v; } inline friend bool operator== (const BVRef& a1, const BVRef& a2) { return a1.x == a2.x; } inline friend bool operator!= (const BVRef& a1, const BVRef& a2) { return a1.x != a2.x; } inline friend bool operator< (const BVRef& a1, const BVRef& a2) { return a1.x > a2.x; } }; static struct BVRef BVRef_Undef = {INT32_MAX}; struct BVRefHash { uint32_t operator () (const BVRef& s) const { return (uint32_t)s.x; } }; template <> struct Equal { bool operator() (const BVRef& s1, const BVRef& s2) const { return s1 == s2; } }; typedef uint32_t BVId; // Used as an array index struct NameAsgn { PTRef name; PTRef asgn; }; class Bvector { struct { unsigned is_signed : 1; unsigned has_extra : 1; unsigned reloced : 1; unsigned size : 29; } header; BVId id; PTRef actVar; // This has to be the last NameAsgn args[0]; // Either the terms or the relocation reference friend class BvectorAllocator; friend class BVStore; friend void bvSort(Bvector&); public: Bvector(const vec& ps, PTRef actVar) : actVar(actVar) { header.is_signed = 0; header.has_extra = 0; header.reloced = 0; header.size = ps.size(); for (int i = 0; i < ps.size(); i++) args[i] = ps[i]; } Bvector() : actVar(PTRef_Undef) { header.is_signed = 0; header.has_extra = 0; header.reloced = 0; header.size = 0; } Bvector& operator= (Bvector const &) = delete; int size () const { return header.size; } PTRef getActVar () const { return actVar; } const PTRef& operator [] (int i) const { assert(i < size()); return args[i].asgn; } PTRef& operator [] (int i) { assert(i < size()); return args[i].asgn; } const PTRef& lsb () const { return operator[](0); } const PTRef& msb () const { return operator[](size()-1); } const PTRef& namebit(int i) const { assert(i < size()); return args[i].name; } PTRef& namebit(int i) { assert(i < size()); return args[i].name; } const NameAsgn& nameasgn(int i) const { assert(i < size()); return args[i]; } NameAsgn& nameasgn(int i) { assert(i < size()); return args[i]; } bool reloced () const { return header.reloced; } BVRef relocation () const { return { args[0].name.x }; } void relocate (BVRef t) { header.reloced = 1; args[0] = { {t.x}, {0} }; } bool is_signed () const { return header.is_signed; } void set_signed (bool m) { header.is_signed = m; } int getId() const { return id; } void setId(int i) { id = i; } void shrink(int s) { header.size -= s; } void copyTo(Bvector& to); }; class BvectorAllocator : public RegionAllocator { BVId n_terms; void setNumBitVectors(int i) { n_terms = i; } static int ptermWord32Size(int size){ return (sizeof(Bvector) + (sizeof(PTRef) * size )) / sizeof(uint32_t); } public: BvectorAllocator(uint32_t start_cap) : RegionAllocator(start_cap), n_terms(0) {} BvectorAllocator() : n_terms(0) {} int getNumTerms() const { return n_terms; } void moveTo(BvectorAllocator& to){ to.n_terms = n_terms; RegionAllocator::moveTo(to); } BVRef alloc(const vec & names, const vec & asgn, PTRef act_var) { assert(sizeof(PTRef) == sizeof(uint32_t)); assert(names.size() == asgn.size()); uint32_t v = RegionAllocator::alloc(ptermWord32Size(2*names.size())); BVRef tid = {v}; vec args; args.growTo(names.size()); for (int i = 0; i < args.size(); i++) args[i] = {names[i], asgn[i]}; new (lea(tid)) Bvector(args, act_var); operator[](tid).setId(n_terms++); return tid; } BVRef alloc(Bvector&, bool) = delete; // Deref, Load Effective Address (LEA), Inverse of LEA (AEL): Bvector& operator[](BVRef r) { return (Bvector&)RegionAllocator::operator[](r.x); } const Bvector& operator[](BVRef r) const { return (Bvector&)RegionAllocator::operator[](r.x); } Bvector* lea (BVRef r) { return (Bvector*)RegionAllocator::lea(r.x); } const Bvector* lea (BVRef r) const { return (Bvector*)RegionAllocator::lea(r.x); } BVRef ael (const Bvector* t) { RegionAllocator::Ref r = RegionAllocator::ael((uint32_t*)t); BVRef rf; rf.x = r; return rf; } void free(BVRef tid) { Bvector& t = operator[](tid); RegionAllocator::free(ptermWord32Size(t.size())); } // void reloc(BVRef& tr, BvectorAllocator& to) // { // Bvector& t = operator[](tr); // // if (t.reloced()) { tr = t.relocation(); return; } // // tr = to.alloc(t, false); // t.relocate(tr); // // // Copy extra data-fields: // to[tr].set_signed(t.is_signed()); // } friend class BVStore; }; #endif opensmt-2.5.2/src/tsolvers/bvsolver/CMakeLists.txt000066400000000000000000000010671445011647600222730ustar00rootroot00000000000000target_sources(tsolvers PRIVATE "${CMAKE_CURRENT_LIST_DIR}/BVSolver.cc" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/BVStore.cc" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/BitBlaster.cc" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/BVSolver.cc" PUBLIC "${CMAKE_CURRENT_LIST_DIR}/BVSolver.h" PUBLIC "${CMAKE_CURRENT_LIST_DIR}/BVStore.h" PUBLIC "${CMAKE_CURRENT_LIST_DIR}/BitBlaster.h" PUBLIC "${CMAKE_CURRENT_LIST_DIR}/Bvector.h" ) install(FILES ${CMAKE_CURRENT_LIST_DIR}/BitBlaster.h ${CMAKE_CURRENT_LIST_DIR}/BVStore.h ${CMAKE_CURRENT_LIST_DIR}/Bvector.h DESTINATION ${INSTALL_HEADERS_DIR}) opensmt-2.5.2/src/tsolvers/bvsolver/minisatp/000077500000000000000000000000001445011647600213535ustar00rootroot00000000000000opensmt-2.5.2/src/tsolvers/bvsolver/minisatp/MiniSATP.cc000066400000000000000000001025521445011647600232530ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ /****************************************************************************************[MiniSATP.C] MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson 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. **************************************************************************************************/ #include "MiniSATP.h" #include "Sort.h" #include //================================================================================================= // Constructor/Destructor: // Modified Line MiniSATP::MiniSATP ( const int i , vector< Enode * > & e , vector< Enode * > & d , vector< Enode * > & s , vector< Enode * > & v , const bool t ) // Parameters: (formerly in 'SearchParams') : var_decay(1 / 0.95), clause_decay(1 / 0.999), random_var_freq(0.02) , restart_first(100) // Changed from 1.5 , restart_inc(1.1) , learntsize_factor((double)1/(double)3), learntsize_inc(1.1) // More parameters: // , expensive_ccmin (true) , polarity_mode (polarity_false) , verbosity (0) // Statistics: (formerly in 'MiniSATPStats') // , starts(0), decisions(0), rnd_decisions(0), propagations(0), conflicts(0) , clauses_literals(0), learnts_literals(0), max_literals(0), tot_literals(0) //================================================================================================= // Added Code , solver_id ( i ) , explanation ( e ) , deductions ( d ) , suggestions ( s ) , var_to_enode ( v ) , theory_prop ( t ) // Added Code //================================================================================================= , ok (true) , cla_inc (1) , var_inc (1) , qhead (0) , simpDB_assigns (-1) , simpDB_props (0) , order_heap (VarOrderLt(activity)) , random_seed (91648253) , progress_estimate(0) , remove_satisfied (true) { exp_dup.reserve( 65535 ); var_dup.reserve( 65535 ); exp_dup_count = 1; var_dup_count = 1; active_exp_dup = false; active_var_dup = false; } MiniSATP::~MiniSATP() { for (int i = 0; i < learnts.size(); i++) free(learnts[i]); for (int i = 0; i < clauses.size(); i++) free(clauses[i]); } //================================================================================================= // Minor methods: // Creates a new SAT variable in the solver. If 'decision_var' is cleared, variable will not be // used as a decision variable (NOTE! This has effects on the meaning of a SATISFIABLE result). // Var MiniSATP::newVar(bool sign, bool dvar) { int v = nVars(); watches .push(); // (list for positive literal) watches .push(); // (list for negative literal) reason .push(NULL); assigns .push(toInt(l_Undef)); level .push(-1); activity .push(0); seen .push(0); polarity .push((char)sign); decision_var.push((char)dvar); insertVarOrder(v); // Added Lines undo_stack_oper.push_back( NEWVAR ); // undo_stack_elem.push_back( (void *)&v ); undo_stack_elem.push_back( reinterpret_cast< void * >( v ) ); return v; } // Modified line // bool MiniSATP::addClause(vec& ps, Enode * e) bool MiniSATP::addClause(vec& psin, Enode * e) { assert( decisionLevel() == 0 ); assert( ok ); // Added Lines vec< Lit > ps; psin.copyTo( ps ); if (!ok) return false; // Check if clause is satisfied and remove false/duplicate literals: sort(ps); Lit p; int i, j; for (i = j = 0, p = lit_Undef; i < ps.size(); i++) { if (value(ps[i]) == l_True || ps[i] == ~p) return true; else if (value(ps[i]) != l_False && ps[i] != p) ps[j++] = p = ps[i]; } ps.shrink(i - j); //================================================================================================= // Modified Code assert( psin.size( ) == 1 || ps.size() > 0 ); // // This case happens only when deductions are enabled // if (ps.size() == 0) { Clause * confl = Clause_new( psin ); if ( confl == NULL ) return ok = true; initExpDup( ); explanation.push_back( e ); storeExpDup( e ); fillExplanation( confl ); doneExpDup( ); assert( !explanation.empty( ) ); return ok = false; } if (ps.size() == 1) { assert(value(ps[0]) == l_Undef); uncheckedEnqueue(ps[0]); /* const Var v = var(ps[0]); if ( var_to_enode.size( ) <= v ) var_to_enode.resize( v + 1, NULL ); var_to_enode[ v ] = e; */ /* if ( e != NULL && seen_in_conflict.insert( e->getId( ) ).second ) explanation.push_back( e ); */ // undo_stack_oper.push_back( NEWUNIT ); // undo_stack_elem.push_back( (void *)v ); #define LAZY_PROPAGATION 0 #if LAZY_PROPAGATION #else // Modified Line // return ok = (propagate() == NULL); #if LIMIT_DEDUCTIONS deductions_done_in_call = 0; #endif Clause * confl = propagate( theory_prop ); if ( confl == NULL ) return ok = true; initExpDup( ); fillExplanation( confl ); doneExpDup( ); assert( !explanation.empty( ) ); return ok = false; #endif // Modified Code //================================================================================================= } else { Clause* c = Clause_new(ps, false); clauses.push(c); attachClause(*c); // Added Lines undo_stack_oper.push_back( NEWCLAUSE ); undo_stack_elem.push_back( (void *)c ); } return true; } void MiniSATP::attachClause(Clause& c) { assert(c.size() > 1); watches[toInt(~c[0])].push(&c); watches[toInt(~c[1])].push(&c); if (c.learnt()) learnts_literals += c.size(); else clauses_literals += c.size(); } void MiniSATP::detachClause(Clause& c) { assert(c.size() > 1); assert(find(watches[toInt(~c[0])], &c)); assert(find(watches[toInt(~c[1])], &c)); remove(watches[toInt(~c[0])], &c); remove(watches[toInt(~c[1])], &c); if (c.learnt()) learnts_literals -= c.size(); else clauses_literals -= c.size(); } // Modified Lines // void MiniSATP::removeClause(Clause& c) // { void MiniSATP::removeClause(Clause& c) { // Remove clause from reasons // for ( int i = 0 ; i < c.size( ) ; i ++ ) { const Var v = var(c[i]); if ( reason[ v ] == &c ) reason[ v ] = NULL; } detachClause(c); removed.push( &c ); } bool MiniSATP::satisfied(const Clause& c) const { for (int i = 0; i < c.size(); i++) if (value(c[i]) == l_True) return true; return false; } // Revert to the state at given level (keeping all assignment at 'level' but not beyond). // void MiniSATP::cancelUntil(int level) { if (decisionLevel() > level){ for (int c = trail.size()-1; c >= trail_lim[level]; c--){ Var x = var(trail[c]); assigns[x] = toInt(l_Undef); insertVarOrder(x); } qhead = trail_lim[level]; trail.shrink(trail.size() - trail_lim[level]); trail_lim.shrink(trail_lim.size() - level); } } //================================================================================================= // Major methods: Lit MiniSATP::pickBranchLit(int polarity_mode, double random_var_freq) { Var next = var_Undef; // Random decision: if (drand(random_seed) < random_var_freq && !order_heap.empty()){ next = order_heap[irand(random_seed,order_heap.size())]; if (toLbool(assigns[next]) == l_Undef && decision_var[next]) rnd_decisions++; } // Activity based decision: while (next == var_Undef || toLbool(assigns[next]) != l_Undef || !decision_var[next]) if (order_heap.empty()){ next = var_Undef; break; }else next = order_heap.removeMin(); bool sign = false; switch (polarity_mode){ case polarity_true: sign = false; break; case polarity_false: sign = true; break; case polarity_user: sign = polarity[next]; break; case polarity_rnd: sign = irand(random_seed, 2); break; default: assert(false); } return next == var_Undef ? lit_Undef : Lit(next, sign); } /*_________________________________________________________________________________________________ | | analyze : (confl : Clause*) (out_learnt : vec&) (out_btlevel : int&) -> [void] | | Description: | Analyze conflict and produce a reason clause. | | Pre-conditions: | * 'out_learnt' is assumed to be cleared. | * Current decision level must be greater than root level. | | Post-conditions: | * 'out_learnt[0]' is the asserting literal at level 'out_btlevel'. | | Effect: | Will undo part of the trail, upto but not beyond the assumption of the current decision level. |________________________________________________________________________________________________@*/ void MiniSATP::analyze(Clause* confl, vec& out_learnt, int& out_btlevel) { int pathC = 0; Lit p = lit_Undef; // Generate conflict clause: // out_learnt.push(); // (leave room for the asserting literal) int index = trail.size() - 1; out_btlevel = 0; do{ assert(confl != NULL); // (otherwise should be UIP) Clause& c = *confl; // Added Line fillExplanation( confl ); if (c.learnt()) claBumpActivity(c); for (int j = (p == lit_Undef) ? 0 : 1; j < c.size(); j++){ Lit q = c[j]; if (!seen[var(q)] && level[var(q)] > 0){ varBumpActivity(var(q)); seen[var(q)] = 1; if (level[var(q)] >= decisionLevel()) pathC++; else{ out_learnt.push(q); if (level[var(q)] > out_btlevel) out_btlevel = level[var(q)]; } } } // Select next clause to look at: while (!seen[var(trail[index--])]) ; // Do nothing p = trail[index+1]; confl = reason[var(p)]; seen[var(p)] = 0; pathC--; }while (pathC > 0); out_learnt[0] = ~p; // Simplify conflict clause: // int i, j; if (expensive_ccmin){ uint32_t abstract_level = 0; for (i = 1; i < out_learnt.size(); i++) abstract_level |= abstractLevel(var(out_learnt[i])); // (maintain an abstraction of levels involved in conflict) out_learnt.copyTo(analyze_toclear); for (i = j = 1; i < out_learnt.size(); i++) if (reason[var(out_learnt[i])] == NULL || !litRedundant(out_learnt[i], abstract_level)) out_learnt[j++] = out_learnt[i]; }else{ out_learnt.copyTo(analyze_toclear); for (i = j = 1; i < out_learnt.size(); i++){ Clause& c = *reason[var(out_learnt[i])]; for (int k = 1; k < c.size(); k++) if (!seen[var(c[k])] && level[var(c[k])] > 0){ out_learnt[j++] = out_learnt[i]; break; } } } max_literals += out_learnt.size(); out_learnt.shrink(i - j); tot_literals += out_learnt.size(); // Find correct backtrack level: // if (out_learnt.size() == 1) out_btlevel = 0; else{ int max_i = 1; for (int i = 2; i < out_learnt.size(); i++) if (level[var(out_learnt[i])] > level[var(out_learnt[max_i])]) max_i = i; Lit p = out_learnt[max_i]; out_learnt[max_i] = out_learnt[1]; out_learnt[1] = p; out_btlevel = level[var(p)]; } for (int j = 0; j < analyze_toclear.size(); j++) seen[var(analyze_toclear[j])] = 0; // ('seen[]' is now cleared) } //================================================================================================= // Added Code void MiniSATP::fillExplanation(Clause* confl) { assert( confl != NULL ); // Initializes cache for visited variables initVarDup( ); vector< Clause * > unprocessed_clauses; unprocessed_clauses.push_back( confl ); while( !unprocessed_clauses.empty( ) ) { Clause & c = *unprocessed_clauses.back( ); unprocessed_clauses.pop_back( ); // // First of all, add reasons for conflict clause // for ( int j = 0 ; j < c.size() ; j++ ) { Lit p = c[j]; const Var v = var(p); if ( isVarDup( v ) ) continue; storeVarDup( v ); assert( reason.size( ) > v ); // // If propagated // if ( reason[v] ) { unprocessed_clauses.push_back( reason[v] ); } // // Otherwise is activation var // else { #if 0 Map( Var, Enode * )::iterator it = var_to_enode.find( v ); if ( it != var_to_enode.end( ) && seen_in_conflict.insert( it->second->getId( ) ).second ) #else assert( (int)var_to_enode.size( ) > v ); Enode * e = var_to_enode[ v ]; if ( e != NULL && !isExpDup( e ) ) #endif { explanation.push_back( e ); storeExpDup( e ); } } } } doneVarDup( ); } // Added Code //================================================================================================= // Check if 'p' can be removed. 'abstract_levels' is used to abort early if the algorithm is // visiting literals at levels that cannot be removed later. bool MiniSATP::litRedundant(Lit p, uint32_t abstract_levels) { analyze_stack.clear(); analyze_stack.push(p); int top = analyze_toclear.size(); while (analyze_stack.size() > 0){ assert(reason[var(analyze_stack.last())] != NULL); Clause& c = *reason[var(analyze_stack.last())]; analyze_stack.pop(); for (int i = 1; i < c.size(); i++){ Lit p = c[i]; if (!seen[var(p)] && level[var(p)] > 0){ if (reason[var(p)] != NULL && (abstractLevel(var(p)) & abstract_levels) != 0){ seen[var(p)] = 1; analyze_stack.push(p); analyze_toclear.push(p); }else{ for (int j = top; j < analyze_toclear.size(); j++) seen[var(analyze_toclear[j])] = 0; analyze_toclear.shrink(analyze_toclear.size() - top); return false; } } } } return true; } /*_________________________________________________________________________________________________ | | analyzeFinal : (p : Lit) -> [void] | | Description: | Specialized analysis procedure to express the final conflict in terms of assumptions. | Calculates the (possibly empty) set of assumptions that led to the assignment of 'p', and | stores the result in 'out_conflict'. |________________________________________________________________________________________________@*/ void MiniSATP::analyzeFinal(Lit p, vec& out_conflict) { out_conflict.clear(); out_conflict.push(p); if (decisionLevel() == 0) return; seen[var(p)] = 1; for (int i = trail.size()-1; i >= trail_lim[0]; i--){ Var x = var(trail[i]); if (seen[x]){ if (reason[x] == NULL){ assert(level[x] > 0); out_conflict.push(~trail[i]); }else{ Clause& c = *reason[x]; for (int j = 1; j < c.size(); j++) if (level[var(c[j])] > 0) seen[var(c[j])] = 1; } seen[x] = 0; } } seen[var(p)] = 0; } void MiniSATP::uncheckedEnqueue(Lit p, Clause* from) { assert(value(p) == l_Undef); assigns [var(p)] = toInt(lbool(!sign(p))); // <<== abstract but not uttermost effecient level [var(p)] = decisionLevel(); reason [var(p)] = from; trail.push(p); } /*_________________________________________________________________________________________________ | | propagate : [void] -> [Clause*] | | Description: | Propagates all enqueued facts. If a conflict arises, the conflicting clause is returned, | otherwise NULL. | | Post-conditions: | * the propagation queue is empty, even if there was a conflict. |________________________________________________________________________________________________@*/ Clause* MiniSATP::propagate(const bool deduce) { Clause* confl = NULL; int num_props = 0; while (qhead < trail.size()){ Lit p = trail[qhead++]; // 'p' is enqueued fact to propagate. vec& ws = watches[toInt(p)]; Clause **i, **j, **end; num_props++; for (i = j = (Clause**)ws, end = i + ws.size(); i != end;){ Clause& c = **i++; // Make sure the false literal is data[1]: Lit false_lit = ~p; if (c[0] == false_lit) c[0] = c[1], c[1] = false_lit; assert(c[1] == false_lit); // If 0th watch is true, then clause is already satisfied. Lit first = c[0]; if (value(first) == l_True){ *j++ = &c; }else{ // Look for new watch: for (int k = 2; k < c.size(); k++) if (value(c[k]) != l_False){ c[1] = c[k]; c[k] = false_lit; watches[toInt(~c[1])].push(&c); goto FoundWatch; } // Did not find watch -- clause is unit under assignment: *j++ = &c; if (value(first) == l_False){ confl = &c; qhead = trail.size(); // Copy the remaining watches: while (i < end) *j++ = *i++; } else { uncheckedEnqueue(first, &c); //================================================================================================= // Added Code assert( (int)var_to_enode.size( ) > var( first ) ); if ( deduce && var_to_enode[ var( first ) ] != NULL ) { Enode * e = var_to_enode[ var( first ) ]; if ( !e->hasPolarity( ) && !e->isDeduced( ) ) { e->setDeduced( sign( first ), solver_id ); deductions.push_back( e ); } } // Added Code //================================================================================================= } } FoundWatch:; } ws.shrink(i - j); } propagations += num_props; simpDB_props -= num_props; return confl; } /*_________________________________________________________________________________________________ | | reduceDB : () -> [void] | | Description: | Remove half of the learnt clauses, minus the clauses locked by the current assignment. Locked | clauses are clauses that are reason to some assignment. Binary clauses are never removed. |________________________________________________________________________________________________@*/ struct reduceDB_lt { bool operator () (Clause* x, Clause* y) { return x->size() > 2 && (y->size() == 2 || x->activity() < y->activity()); } }; void MiniSATP::reduceDB() { // Added Line // Prevent any clause removal for now int i, j; double extra_lim = cla_inc / learnts.size(); // Remove any clause below this activity sort(learnts, reduceDB_lt()); for (i = j = 0; i < learnts.size() / 2; i++){ if (learnts[i]->size() > 2 && !locked(*learnts[i])) removeClause(*learnts[i]); else learnts[j++] = learnts[i]; } for (; i < learnts.size(); i++){ if (learnts[i]->size() > 2 && !locked(*learnts[i]) && learnts[i]->activity() < extra_lim) removeClause(*learnts[i]); else learnts[j++] = learnts[i]; } learnts.shrink(i - j); } void MiniSATP::removeSatisfied(vec& cs) { int i,j; for (i = j = 0; i < cs.size(); i++){ if (satisfied(*cs[i])) removeClause(*cs[i]); else cs[j++] = cs[i]; } cs.shrink(i - j); } /*_________________________________________________________________________________________________ | | simplify : [void] -> [bool] | | Description: | Simplify the clause database according to the current top-level assigment. Currently, the only | thing done here is the removal of satisfied clauses, but more things can be put here. |________________________________________________________________________________________________@*/ bool MiniSATP::simplify() { remove_satisfied = false; assert(decisionLevel() == 0); // Modified Lines // if (!ok || propagate() != NULL) // return ok = false; if (!ok) return false; Clause * confl = propagate( ); if ( confl != NULL ) { fillExplanation( confl ); return ok = false; } if (nAssigns() == simpDB_assigns || (simpDB_props > 0)) return true; // Remove satisfied clauses: removeSatisfied(learnts); if (remove_satisfied) // Can be turned off. removeSatisfied(clauses); // Remove fixed variables from the variable heap: order_heap.filter(VarFilter(*this)); simpDB_assigns = nAssigns(); simpDB_props = clauses_literals + learnts_literals; // (shouldn't depend on stats really, but it will do for now) return true; } //================================================================================================= // Added Code void MiniSATP::pushBacktrackPoint( ) { // // Save undo stack size // assert( undo_stack_oper.size( ) == undo_stack_elem.size( ) ); undo_stack_size.push_back( undo_stack_oper.size( ) ); undo_trail_size.push_back( trail.size( ) ); } void MiniSATP::popBacktrackPoint ( ) { // // Force restart, but retain assumptions // cancelUntil(0); // // Shrink back trail // int new_trail_size = undo_trail_size.back( ); undo_trail_size.pop_back( ); for ( int i = trail.size( ) - 1 ; i >= new_trail_size ; i -- ) { Var x = var(trail[i]); assigns[x] = toInt(l_Undef); reason [x] = NULL; insertVarOrder(x); } trail.shrink(trail.size( ) - new_trail_size); assert( trail_lim.size( ) == 0 ); qhead = trail.size( ); // // Undo operations // size_t new_stack_size = undo_stack_size.back( ); undo_stack_size.pop_back( ); while ( undo_stack_oper.size( ) > new_stack_size ) { const oper_t op = undo_stack_oper.back( ); if ( op == NEWVAR ) { #ifdef BUILD_64 long xl = reinterpret_cast< long >( undo_stack_elem.back( ) ); const Var x = static_cast< Var >( xl ); #else const Var x = reinterpret_cast< int >( undo_stack_elem.back( ) ); #endif // Undoes insertVarOrder( ) assert( order_heap.inHeap(x) ); order_heap .remove(x); // Undoes decision_var ... watches decision_var.pop(); polarity .pop(); seen .pop(); activity .pop(); level .pop(); assigns .pop(); reason .pop(); watches .pop(); watches .pop(); } else if ( op == NEWUNIT ) { } else if ( op == NEWCLAUSE ) { Clause * c = (Clause *)undo_stack_elem.back( ); assert( clauses.last( ) == c ); // assert( c->id + 1 == (int)clause_id_to_enode.size( ) ); clauses.pop( ); removeClause( *c ); // clause_id_to_enode.pop_back( ); } else { opensmt_error2( "unknown undo operation in BitBlaster", op ); } undo_stack_oper.pop_back( ); undo_stack_elem.pop_back( ); } while( learnts.size( ) > 0 ) { Clause * c = learnts.last( ); learnts.pop( ); removeClause( *c ); } while( removed.size( ) > 0 ) { Clause * c = removed.last( ); removed.pop( ); free( c ); } assert( undo_stack_elem.size( ) == undo_stack_oper.size( ) ); assert( learnts.size( ) == 0 ); assert( removed.size( ) == 0 ); } // Added Code //================================================================================================= /*_________________________________________________________________________________________________ | | search : (nof_conflicts : int) (nof_learnts : int) (params : const SearchParams&) -> [lbool] | | Description: | Search for a model the specified number of conflicts, keeping the number of learnt clauses | below the provided limit. NOTE! Use negative value for 'nof_conflicts' or 'nof_learnts' to | indicate infinity. | | Output: | 'l_True' if a partial assigment that is consistent with respect to the clauseset is found. If | all variables are decision variables, this means that the clause set is satisfiable. 'l_False' | if the clause set is unsatisfiable. 'l_Undef' if the bound on number of conflicts is reached. |________________________________________________________________________________________________@*/ lbool MiniSATP::search(int nof_conflicts, int nof_learnts) { assert(ok); int backtrack_level; int conflictC = 0; vec learnt_clause; starts++; bool first = true; for (;;){ Clause* confl = propagate(); if (confl != NULL){ // CONFLICT conflicts++; conflictC++; if (decisionLevel() == 0) { // Added Lines fillExplanation(confl); return l_False; } first = false; learnt_clause.clear(); analyze(confl, learnt_clause, backtrack_level); cancelUntil(backtrack_level); assert(value(learnt_clause[0]) == l_Undef); if (learnt_clause.size() == 1){ uncheckedEnqueue(learnt_clause[0]); }else{ Clause* c = Clause_new(learnt_clause, true); learnts.push(c); attachClause(*c); claBumpActivity(*c); uncheckedEnqueue(learnt_clause[0], c); } varDecayActivity(); claDecayActivity(); }else{ // NO CONFLICT if (nof_conflicts >= 0 && conflictC >= nof_conflicts){ // Reached bound on number of conflicts: progress_estimate = progressEstimate(); cancelUntil(0); return l_Undef; } // Simplify the set of problem clauses: if (decisionLevel() == 0 && !simplify()) { return l_False; } if (nof_learnts >= 0 && learnts.size()-nAssigns() >= nof_learnts) // Reduce the set of learnt clauses: reduceDB(); Lit next = lit_Undef; while (decisionLevel() < assumptions.size()){ // Perform user provided assumption: Lit p = assumptions[decisionLevel()]; if (value(p) == l_True){ // Dummy decision level: newDecisionLevel(); }else if (value(p) == l_False){ analyzeFinal(~p, conflict); return l_False; }else{ next = p; break; } } if (next == lit_Undef){ // New variable decision: decisions++; next = pickBranchLit(polarity_mode, random_var_freq); if (next == lit_Undef) { // Added Line // Clear explanation vector if satisfiable explanation.clear( ); // Model found: return l_True; } } // Increase decision level and enqueue 'next' assert(value(next) == l_Undef); newDecisionLevel(); uncheckedEnqueue(next); } } } double MiniSATP::progressEstimate() const { double progress = 0; double F = 1.0 / nVars(); for (int i = 0; i <= decisionLevel(); i++){ int beg = i == 0 ? 0 : trail_lim[i - 1]; int end = i == decisionLevel() ? trail.size() : trail_lim[i]; progress += pow(F, i) * (end - beg); } return progress / nVars(); } bool MiniSATP::solve(const vec& assumps) { // Added Line initExpDup( ); model.clear(); conflict.clear(); if (!ok) { // Added Line doneExpDup( ); return false; } assumps.copyTo(assumptions); double nof_conflicts = restart_first; double nof_learnts = nClauses() * learntsize_factor; lbool status = l_Undef; if (verbosity >= 1){ reportf("============================[ Search Statistics ]==============================\n"); reportf("| Conflicts | ORIGINAL | LEARNT | Progress |\n"); reportf("| | Vars Clauses Literals | Limit Clauses Lit/Cl | |\n"); reportf("===============================================================================\n"); } // Search: while (status == l_Undef){ if (verbosity >= 1) reportf("| %9d | %7d %8d %8d | %8d %8d %6.0f | %6.3f %% |\n", (int)conflicts, order_heap.size(), nClauses(), (int)clauses_literals, (int)nof_learnts, nLearnts(), (double)learnts_literals/nLearnts(), progress_estimate*100), fflush(stdout); status = search((int)nof_conflicts, (int)nof_learnts); nof_conflicts *= restart_inc; nof_learnts *= learntsize_inc; } if (verbosity >= 1) reportf("===============================================================================\n"); if (status == l_True){ // Extend & copy model: model.growTo(nVars()); for (int i = 0; i < nVars(); i++) model[i] = value(i); #ifndef NDEBUG verifyModel(); #endif }else{ assert(status == l_False); if (conflict.size() == 0) ok = false; } cancelUntil(0); // cerr << "SOLVE: Memory after: " << memUsed( ) / 1024.0 / 1024.0 << endl; // Added Line doneExpDup( ); assert( status == l_True || !explanation.empty( ) ); return status == l_True; } //================================================================================================= // Debug methods: void MiniSATP::verifyModel() { bool failed = false; for (int i = 0; i < clauses.size(); i++){ assert(clauses[i]->mark() == 0); Clause& c = *clauses[i]; for (int j = 0; j < c.size(); j++) if (modelValue(c[j]) == l_True) goto next; reportf("unsatisfied clause: "); printClause(*clauses[i]); reportf("\n"); failed = true; next:; } assert(!failed); // Modified Line //reportf("Verified %d original clauses.\n", clauses.size()); } void MiniSATP::checkLiteralCount() { // Check that sizes are calculated correctly: int cnt = 0; for (int i = 0; i < clauses.size(); i++) if (clauses[i]->mark() == 0) cnt += clauses[i]->size(); if ((int)clauses_literals != cnt){ fprintf(stderr, "literal count: %d, real value = %d\n", (int)clauses_literals, cnt); assert((int)clauses_literals == cnt); } } opensmt-2.5.2/src/tsolvers/bvsolver/minisatp/MiniSATP.h000066400000000000000000000505121445011647600231130ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ /****************************************************************************************[MiniSATP.h] MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson 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. **************************************************************************************************/ #ifndef MINISATP_H #define MINISATP_H #include "Global.h" #include "Enode.h" #include #include "Vec.h" #include "Heap.h" #include "Alg.h" #include "SolverTypes.h" //================================================================================================= // MiniSATP -- the main class: class MiniSATP { public: // Constructor/Destructor: // // Modified Lines MiniSATP( const int , vector< Enode * > & , vector< Enode * > & , vector< Enode * > & , vector< Enode * > & , const bool ); ~MiniSATP(); // Problem specification: // Var newVar (bool polarity = true, bool dvar = true); // Add a new variable with parameters specifying variable mode. bool addClause (vec& ps, Enode * e = NULL); // Add a clause to the solver. NOTE! 'ps' may be shrunk by this method! // Solving: // bool simplify (); // Removes already satisfied clauses. bool solve (const vec& assumps); // Search for a model that respects a given set of assumptions. bool solve (); // Search without assumptions. bool okay () const; // FALSE means solver is in a conflicting state // Variable mode: // void setPolarity (Var v, bool b); // Declare which polarity the decision heuristic should use for a variable. Requires mode 'polarity_user'. void setDecisionVar (Var v, bool b); // Declare if a variable should be eligible for selection in the decision heuristic. // Read state: // lbool value (Var x) const; // The current value of a variable. lbool value (Lit p) const; // The current value of a literal. lbool modelValue (Lit p) const; // The value of a literal in the last model. The last call to solve must have been satisfiable. int nAssigns () const; // The current number of assigned literals. int nClauses () const; // The current number of original clauses. int nLearnts () const; // The current number of learnt clauses. int nVars () const; // The current number of variables. //================================================================================================= // Added Code void pushBacktrackPoint ( ); void popBacktrackPoint ( ); inline void restoreOK ( ) { ok = true; } inline bool isOK ( ) const { return ok; } inline lbool getValue ( Var v ) const { return model[ v ]; } // Added Code //================================================================================================= // Extra results: (read-only member variable) // vec model; // If problem is satisfiable, this vector contains the model (if any). vec conflict; // If problem is unsatisfiable (possibly under assumptions), // this vector represent the final conflict clause expressed in the assumptions. // Mode of operation: // double var_decay; // Inverse of the variable activity decay factor. (default 1 / 0.95) double clause_decay; // Inverse of the clause activity decay factor. (1 / 0.999) double random_var_freq; // The frequency with which the decision heuristic tries to choose a random variable. (default 0.02) int restart_first; // The initial restart limit. (default 100) double restart_inc; // The factor with which the restart limit is multiplied in each restart. (default 1.5) double learntsize_factor; // The intitial limit for learnt clauses is a factor of the original clauses. (default 1 / 3) double learntsize_inc; // The limit for learnt clauses is multiplied with this factor each restart. (default 1.1) bool expensive_ccmin; // Controls conflict clause minimization. (default TRUE) int polarity_mode; // Controls which polarity the decision heuristic chooses. See enum below for allowed modes. (default polarity_false) int verbosity; // Verbosity level. 0=silent, 1=some progress report (default 0) enum { polarity_true = 0, polarity_false = 1, polarity_user = 2, polarity_rnd = 3 }; // Statistics: (read-only member variable) // uint64_t starts, decisions, rnd_decisions, propagations, conflicts; uint64_t clauses_literals, learnts_literals, max_literals, tot_literals; protected: // Helper structures: // struct VarOrderLt { const vec& activity; bool operator () (Var x, Var y) const { return activity[x] > activity[y]; } VarOrderLt(const vec& act) : activity(act) { } }; friend class VarFilter; struct VarFilter { const MiniSATP& s; VarFilter(const MiniSATP& _s) : s(_s) {} bool operator()(Var v) const { return toLbool(s.assigns[v]) == l_Undef && s.decision_var[v]; } }; //================================================================================================= // Added Code inline void initExpDup ( ) { assert( !active_exp_dup ); active_exp_dup = true; exp_dup_count ++; } inline void storeExpDup ( Enode * e ) { assert( active_exp_dup ); if( e->getId( ) >= (int)exp_dup.size( ) ) exp_dup.resize( e->getId( ) + 1, exp_dup_count-1 ); exp_dup[ e->getId( ) ] = exp_dup_count; } inline bool isExpDup ( Enode * e ) { assert( active_exp_dup ); if( e->getId( ) >= (int)exp_dup.size( ) ) return false; return exp_dup[ e->getId( ) ] == exp_dup_count; } inline void doneExpDup ( ) { assert( active_exp_dup ); active_exp_dup = false; } inline void initVarDup ( ) { assert( !active_var_dup ); active_var_dup = true; var_dup_count ++; } inline void storeVarDup ( const Var v ) { assert( active_var_dup ); if( v >= (int)var_dup.size( ) ) var_dup.resize( v + 1, var_dup_count-1 ); var_dup[ v ] = var_dup_count; } inline bool isVarDup ( const Var v ) { assert( active_var_dup ); if( v >= (int)var_dup.size( ) ) return false; return var_dup[ v ] == var_dup_count; } inline void doneVarDup ( ) { assert( active_var_dup ); active_var_dup = false; } // // Data structures required for communicating conflicts and deductions // incrementality, backtrackability ... // enum oper_t { NEWVAR, NEWUNIT, NEWCLAUSE }; const int solver_id; // Id of the t-solver that wraps vector< Enode * > & explanation; // For conflict sets vector< Enode * > & deductions; // For deductions during bcp vector< Enode * > & suggestions; // For suggestions vector< Enode * > & var_to_enode; // Var to enode vector< Enode * > clause_id_to_enode; // Clause --> Enode const bool theory_prop; // Theory propagation on ? bool active_exp_dup; // Fast explanation duplicate check flag vector< int > exp_dup; // Fast explanation duplicate check int exp_dup_count; // Counter bool active_var_dup; // Fast variable duplicate check flag vector< int > var_dup; // Fast variable duplicate check int var_dup_count; // Counter vector< size_t > undo_stack_size; // Keep track of stack_oper size vector< int > undo_trail_size; // Keep track of trail size vector< oper_t > undo_stack_oper; // Keep track of operations vector< void * > undo_stack_elem; // Keep track of aux info // Added Code //================================================================================================= // MiniSATP state: // bool ok; // If FALSE, the constraints are already unsatisfiable. No part of the solver state may be used! vec clauses; // List of problem clauses. vec learnts; // List of learnt clauses. // Added Line vec removed; // List of logically removed clauses. double cla_inc; // Amount to bump next clause with. vec activity; // A heuristic measurement of the activity of a variable. double var_inc; // Amount to bump next variable with. vec > watches; // 'watches[lit]' is a list of constraints watching 'lit' (will go there if literal becomes true). vec assigns; // The current assignments (lbool:s stored as char:s). vec polarity; // The preferred polarity of each variable. vec decision_var; // Declares if a variable is eligible for selection in the decision heuristic. vec trail; // Assignment stack; stores all assigments made in the order they were made. vec trail_lim; // Separator indices for different decision levels in 'trail'. vec reason; // 'reason[var]' is the clause that implied the variables current value, or 'NULL' if none. vec level; // 'level[var]' contains the level at which the assignment was made. int qhead; // Head of queue (as index into the trail -- no more explicit propagation queue in MiniSat). int simpDB_assigns; // Number of top-level assignments since last execution of 'simplify()'. int64_t simpDB_props; // Remaining number of propagations that must be made before next execution of 'simplify()'. vec assumptions; // Current set of assumptions provided to solve by the user. Heap order_heap; // A priority queue of variables ordered with respect to the variable activity. double random_seed; // Used by the random variable selection. double progress_estimate; // Set by 'search()'. bool remove_satisfied; // Indicates whether possibly inefficient linear scan for satisfied clauses should be performed in 'simplify'. // Temporaries (to reduce allocation overhead). Each variable is prefixed by the method in which it is // used, exept 'seen' wich is used in several places. // vec seen; vec analyze_stack; vec analyze_toclear; vec add_tmp; // Main internal methods: // void insertVarOrder (Var x); // Insert a variable in the decision order priority queue. Lit pickBranchLit (int polarity_mode, double random_var_freq); // Return the next decision variable. void newDecisionLevel (); // Begins a new decision level. void uncheckedEnqueue (Lit p, Clause* from = NULL); // Enqueue a literal. Assumes value of literal is undefined. bool enqueue (Lit p, Clause* from = NULL); // Test if fact 'p' contradicts current state, enqueue otherwise. Clause* propagate (const bool deduce = false); // Perform unit propagation. Returns possibly conflicting clause. void cancelUntil (int level); // Backtrack until a certain level. void analyze (Clause* confl, vec& out_learnt, int& out_btlevel); // (bt = backtrack) // Added Line void fillExplanation (Clause* confl); void analyzeFinal (Lit p, vec& out_conflict); // COULD THIS BE IMPLEMENTED BY THE ORDINARIY "analyze" BY SOME REASONABLE GENERALIZATION? bool litRedundant (Lit p, uint32_t abstract_levels); // (helper method for 'analyze()') lbool search (int nof_conflicts, int nof_learnts); // Search for a given number of conflicts. void reduceDB (); // Reduce the set of learnt clauses. void removeSatisfied (vec& cs); // Shrink 'cs' to contain only non-satisfied clauses. // Maintaining Variable/Clause activity: // void varDecayActivity (); // Decay all variables with the specified factor. Implemented by increasing the 'bump' value instead. void varBumpActivity (Var v); // Increase a variable with the current 'bump' value. void claDecayActivity (); // Decay all clauses with the specified factor. Implemented by increasing the 'bump' value instead. void claBumpActivity (Clause& c); // Increase a clause with the current 'bump' value. // Operations on clauses: // void attachClause (Clause& c); // Attach a clause to watcher lists. void detachClause (Clause& c); // Detach a clause to watcher lists. void removeClause (Clause& c); // Detach and free a clause. bool locked (const Clause& c) const; // Returns TRUE if a clause is a reason for some implication in the current state. bool satisfied (const Clause& c) const; // Returns TRUE if a clause is satisfied in the current state. // Misc: // int decisionLevel () const; // Gives the current decisionlevel. uint32_t abstractLevel (Var x) const; // Used to represent an abstraction of sets of decision levels. double progressEstimate () const; // DELETE THIS ?? IT'S NOT VERY USEFUL ... // Debug: void printLit (Lit l); template void printClause (const C& c); void verifyModel (); void checkLiteralCount(); // Static helpers: // // Returns a random float 0 <= x < 1. Seed must never be 0. static inline double drand(double& seed) { seed *= 1389796; int q = (int)(seed / 2147483647); seed -= (double)q * 2147483647; return seed / 2147483647; } // Returns a random integer 0 <= x < size. Seed must never be 0. static inline int irand(double& seed, int size) { return (int)(drand(seed) * size); } }; //================================================================================================= // Implementation of inline methods: inline void MiniSATP::insertVarOrder(Var x) { if (!order_heap.inHeap(x) && decision_var[x]) order_heap.insert(x); } inline void MiniSATP::varDecayActivity() { var_inc *= var_decay; } inline void MiniSATP::varBumpActivity(Var v) { if ( (activity[v] += var_inc) > 1e100 ) { // Rescale: for (int i = 0; i < nVars(); i++) activity[i] *= 1e-100; var_inc *= 1e-100; } // Update order_heap with respect to new activity: if (order_heap.inHeap(v)) order_heap.decrease(v); } inline void MiniSATP::claDecayActivity() { cla_inc *= clause_decay; } inline void MiniSATP::claBumpActivity (Clause& c) { if ( (c.activity() += cla_inc) > 1e20 ) { // Rescale: for (int i = 0; i < learnts.size(); i++) learnts[i]->activity() *= 1e-20; cla_inc *= 1e-20; } } inline bool MiniSATP::enqueue (Lit p, Clause* from) { return value(p) != l_Undef ? value(p) != l_False : (uncheckedEnqueue(p, from), true); } inline bool MiniSATP::locked (const Clause& c) const { return reason[var(c[0])] == &c && value(c[0]) == l_True; } inline void MiniSATP::newDecisionLevel() { trail_lim.push(trail.size()); } inline int MiniSATP::decisionLevel () const { return trail_lim.size(); } inline uint32_t MiniSATP::abstractLevel (Var x) const { return 1 << (level[x] & 31); } inline lbool MiniSATP::value (Var x) const { return toLbool(assigns[x]); } inline lbool MiniSATP::value (Lit p) const { return toLbool(assigns[var(p)]) ^ sign(p); } inline lbool MiniSATP::modelValue (Lit p) const { return model[var(p)] ^ sign(p); } inline int MiniSATP::nAssigns () const { return trail.size(); } inline int MiniSATP::nClauses () const { return clauses.size(); } inline int MiniSATP::nLearnts () const { return learnts.size(); } inline int MiniSATP::nVars () const { return assigns.size(); } inline void MiniSATP::setPolarity (Var v, bool b) { polarity [v] = (char)b; } inline void MiniSATP::setDecisionVar(Var v, bool b) { decision_var[v] = (char)b; if (b) { insertVarOrder(v); } } inline bool MiniSATP::solve () { vec tmp; return solve(tmp); } inline bool MiniSATP::okay () const { return ok; } #define reportf(format, args...) ( fflush(stdout), fprintf(stderr, format, ## args), fflush(stderr) ) inline void MiniSATP::printLit(Lit l) { reportf("%s%d:%c:%d", sign(l) ? "-" : " ", var(l)+1, value(l) == l_True ? '1' : (value(l) == l_False ? '0' : 'X'), level[var(l)]); } template inline void MiniSATP::printClause(const C& c) { for (int i = 0; i < c.size(); i++){ printLit(c[i]); fprintf(stderr, " "); } } #endif opensmt-2.5.2/src/tsolvers/dlsolver/000077500000000000000000000000001445011647600175175ustar00rootroot00000000000000opensmt-2.5.2/src/tsolvers/dlsolver/DLGraph.cc000066400000000000000000000660761445011647600213260ustar00rootroot00000000000000/********************************************************************* Author: Edgar Pek , Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. ********************************************************************/ #include "DLGraph.h" #include "DLSolver.h" // // Destructor // template< class T > DLGraph::~DLGraph( ) { typename Enode2Vertex::iterator i2v; for ( i2v = vertexMap.begin(); i2v != vertexMap.end(); ++i2v ) delete i2v->second; typename Enode2Edge::iterator i2e; for ( i2e = edgeMap.begin(); i2e != edgeMap.end(); ++i2e ){ delete (i2e->second).pos; delete (i2e->second).neg; } } // // DL Atoms have one of these shapes // // (<= (+ (* 1 x) (* (~ 1) y)) c) // (<= (+ (* (~ 1) x) (* 1 y)) c) // (<= (* (~ 1) x) c) // (<= (* 1 x) c) // template DLComplEdges DLGraph::getDLEdge( Enode * e ) { if (edgeMap.find(e) == edgeMap.end()) { bool invert = false; assert( !e->hasPolarity( ) ); Enode * lhs = e->get1st( ); Enode * rhs = e->get2nd( ); if ( lhs->isConstant( ) ) { Enode * tmp = lhs; lhs = rhs; rhs = tmp; invert = true; } Real one_ = 1; Real mone_ = -1; Enode * one = egraph.mkNum( one_ ); Enode * mone = egraph.mkNum( mone_ ); assert( rhs->isConstant( ) ); Enode * x = NULL; Enode * y = NULL; // // Standard DL constraint // if ( lhs->isPlus( ) ) { assert( lhs->get1st( )->isTimes( ) ); assert( lhs->get2nd( )->isTimes( ) ); assert( lhs->get1st( )->get1st( ) == one || lhs->get1st( )->get1st( ) == mone ); assert( lhs->get2nd( )->get1st( ) == one || lhs->get2nd( )->get1st( ) == mone ); x = lhs->get1st( )->get2nd( ); y = lhs->get2nd( )->get2nd( ); tmp_edge_weight = rhs->getValue( ); if ( invert ) tmp_edge_weight = -tmp_edge_weight; // // Swap variables if not right // if ( ( lhs->get1st( )->get1st( ) == mone && !invert ) || ( lhs->get1st( )->get1st( ) == one && invert ) ) { Enode * tmp = x; x = y; y = tmp; } } // // Bound constraint ~1*x < c // else { assert( lhs->isTimes( ) ); assert( lhs->get1st( ) == one || lhs->get1st( ) == mone ); x = lhs->get2nd( ); y = NULL; tmp_edge_weight = rhs->getValue( ); if ( invert ) tmp_edge_weight = -tmp_edge_weight; if ( ( lhs->get1st( ) == mone && !invert ) || ( lhs->get1st( ) == one && invert ) ) { Enode * tmp = x; x = y; y = tmp; } } T posWeight = getPosWeight( posWeight ) * ( config.logic == QF_RDL ? egraph.getRescale( posWeight ) : 1 ); #if FAST_RATIONALS T negWeight = -posWeight -1; #else T negWeight = -1 * posWeight -1; #endif DLVertex * u = getDLVertex( x ); DLVertex * v = getDLVertex( y ); DLEdge * pos = new DLEdge( e, 2*edgeMap.size( ), u, v, posWeight ); DLEdge * neg = new DLEdge( e, 2*edgeMap.size( ) + 1, v, u, negWeight ); DLComplEdges edges = DLComplEdges( pos, neg ); edgeMap.insert( pair< Enode *, DLComplEdges > (e, edges) ); return edges; } else { return edgeMap.find(e)->second; } } template void DLGraph::insertStatic( Enode * c ) { DLEdge * pos = getDLEdge( c ).pos; DLEdge * neg = getDLEdge( c ).neg; Vcnt = vertexMap.size(); sAdj.resize( Vcnt ); dAdj.resize( Vcnt ); dAdjInc.resize( Vcnt ); hAdj.resize( Vcnt ); hAdjInc.resize( Vcnt ); iAdj.resize( Vcnt ); pq_dx_it.resize( Vcnt ); pq_dy_it.resize( Vcnt ); sAdj[ pos->u->id ].push_back( pos ); sAdj[ neg->u->id ].push_back( neg ); sEdges.push_back( pos ); sEdges.push_back( neg ); Ecnt = Ecnt + 2; assert( sEdges.size( ) == Ecnt ); // maintaining the set of inactive edges if ( config.dl_theory_propagation > 0 ) insertInactive( c ); } template< class T > void DLGraph::deleteActive( Enode * c ) { assert ( c->hasPolarity( ) ); assert ( edgeMap.find( c ) != edgeMap.end( ) ); DLComplEdges edges = edgeMap.find( c )->second; DLEdge * e = c->getPolarity( ) == l_True ? edges.pos : edges.neg; DLEdge * d = dAdj[ e->u->id ].back( ); (void)d; assert ( d == e ); dAdj[ e->u->id ].pop_back( ); dEdges.back( ); dEdges.pop_back( ); assert( e->v->id < (int) dAdjInc.size( ) ); DLEdge * i = dAdjInc[ e->v->id ].back( ); (void)i; assert ( i == d ); dAdjInc[ e->v->id ].pop_back( ); after_backtrack = true; updateDynDegree( e ); if ( config.dl_theory_propagation > 0 ) { insertInactive( c ); } } // // TODO: Call "inactive" functions only if the // call may trigger some deduction. If deduction // is disabled, or in case we know a priori // that the call will be unsat (TODO: this is the case // for getting reasons) do not update "inactive" // data structures // template< class T> void DLGraph::insertInactive( Enode * e ) { assert ( edgeMap.find( e ) != edgeMap.end( ) ); DLComplEdges edges = edgeMap.find( e )->second; DLEdge * pos = edges.pos; hAdj [ pos->u->id ].push_back( pos ); hAdjInc[ pos->v->id ].push_back( pos ); updateHDegree( pos ); DLEdge * neg = edges.neg; hAdj [ neg->u->id ].push_back( neg ); hAdjInc[ neg->v->id ].push_back( neg ); updateHDegree( neg ); } template< class T >void DLGraph::insertImplied( Enode * c ) { assert( config.dl_theory_propagation > 0 ); deleteInactive( c ); } template < class T >DLEdge * DLGraph::insertDynamic( Enode * c, bool reason ) { (void)reason; assert( c->hasPolarity( ) ); assert( edgeMap.find( c ) != edgeMap.end( ) ); DLComplEdges edges = edgeMap.find( c )->second; DLEdge * e = c->getPolarity ( ) == l_True ? edges.pos : edges.neg; assert( e ); dAdj[ e->u->id ].push_back( e ); dEdges.push_back( e ); assert( e->v->id < (int) dAdjInc.size( ) ); dAdjInc[ e->v->id ].push_back( e ); updateDynDegree( e ); max_dyn_edges = dEdges.size( ) > max_dyn_edges ? dEdges.size( ) : max_dyn_edges; if ( config.dl_theory_propagation > 0 ) deleteInactive( c ); return e; } template< class T > void DLGraph::deleteInactive( Enode * e ) { assert ( edgeMap.find( e ) != edgeMap.end( ) ); DLComplEdges edges = edgeMap.find( e )->second; DLEdge * pos = edges.pos; DLEdge * neg; neg = edges.neg; // delete inserted edge from the set of inactive edges assert( pos->u->id < (int) hAdj.size( ) ); deleteFromAdjList( hAdj [ pos->u->id ], pos ); assert( pos->v->id < (int) hAdjInc.size( ) ); deleteFromAdjList( hAdjInc[ pos->v->id ], pos ); updateHDegree( pos ); assert( neg->u->id < (int) hAdj.size( ) ); deleteFromAdjList( hAdj [ neg->u->id ], neg ); assert( neg->v->id < (int) hAdjInc.size( ) ); deleteFromAdjList( hAdjInc[ neg->v->id ], neg ); updateHDegree( neg ); assert ( find( hEdges.begin( ), hEdges.end( ), pos ) == hEdges.end( ) ); assert ( find( hEdges.begin( ), hEdges.end( ), neg ) == hEdges.end( ) ); } // check for a neg cycle by dfs template< class T > bool DLGraph::checkNegCycleDFS( Enode *c, bool reason ) { DLEdge *e = insertDynamic( c, reason ); if ( e == NULL ) return true; assert( changed_vertices.empty( ) ); conflict_edges.resize( Vcnt ); // move the initialization! DLVertex *u = e->u; DLVertex *v = e->v; // gamma(v) = pi(u) + d - pi(v) v->gamma = u->pi + e->wt - v->pi; if (v->gamma < 0) { dfs_stack.push_back(v); conflict_edges[v->id] = e; // TODO check this } initGamma( ); initPiPrime( ); while ( !dfs_stack.empty( ) ) { DLVertex * s = dfs_stack.back( ); dfs_stack.pop_back( ); // pi'(s) = pi(s) + gamma(s) if ( ! isPiPrime( s ) ) { s->old_pi = s->pi; changed_vertices.push_back( s ); } s->pi = s->pi + s->gamma; updatePiPrime( s ); // gamma(s) = 0 s->gamma = 0; readGamma( s ); AdjList & adjList = dAdj[s->id]; for ( typename AdjList::iterator it = adjList.begin( ); it != adjList.end( ); ++it ) { DLVertex *t = (*it)->v; // if pi'(t) = pi(t) then if ( !isPiPrime( t ) ) { if ( ! isGammaRead( t ) ) { t->gamma = 0; readGamma( t ); } const T value = s->pi + (*it)->wt - t->pi; if ( t->id == u->id ) { // t = u (t is the source vertex) assert( u == t ); if ( value < t->gamma ) { negCycleVertex = u; // TODO: check this conflict_edges[t->id] = *it; // restore the old_pi for ( typename vector< DLVertex * >::iterator it = changed_vertices.begin( ); it != changed_vertices.end( ); ++ it ) (*it)->pi = (*it)->old_pi; changed_vertices.clear( ); dfs_stack.clear( ); doneGamma( ); donePiPrime( ); return false; } } else { // pq.decrease_key(t) // if ( s->pi + (*it)->wt - t->pi < t->gamma ) if ( value < t->gamma ) { // t->gamma == 0 implies that t is not on the heap if ( t->gamma == 0 ) { // t->gamma = s->pi + (*it)->wt - t->pi; t->gamma = value; dfs_stack.push_back ( t ); conflict_edges[t->id] = *it; } else { assert( t->gamma < 0 ); // find t in the vector dfs_stack O(n) typename vector< DLVertex *>::iterator v_it; for (v_it = dfs_stack.begin( ); v_it != dfs_stack.end( ); ++v_it) { if( (*v_it) == t ) // update t->gamma in the vector { (*v_it)->gamma = value; break; } } } conflict_edges[t->id] = *it; } } } } } doneGamma( ); donePiPrime( ); changed_vertices.clear( ); return true; } // // Check for a negative cycle in a constraint graph // template< class T > bool DLGraph::checkNegCycle( Enode * c, bool reason ) { assert( changed_vertices.empty( ) ); DLEdge * e = insertDynamic( c, reason ); if ( e == NULL ) return true; conflict_edges.resize( Vcnt ); // move the initialization! // run dfs when dealing with partial order //cerr << dfsVisit( e ) << endl; //bool ret_dfs = dfsVisit( e ); //cerr << "ret dfs " << ret_dfs << endl; //return ret_dfs; DLVertex *u = e->u; DLVertex *v = e->v; // gamma(v) = pi(u) + d - pi(v) v->gamma = u->pi + e->wt - v->pi; if (v->gamma < 0) { vertex_heap.push_back(v); push_heap(vertex_heap.begin(), vertex_heap.end(), typename DLVertex::gammaGreaterThan() ); assert( is_heap( vertex_heap.begin(), vertex_heap.end(), typename DLVertex::gammaGreaterThan() ) ); conflict_edges[v->id] = e; // TODO check this } initGamma( ); initPiPrime( ); while ( !vertex_heap.empty( ) ) { assert( is_heap( vertex_heap.begin(), vertex_heap.end(), typename DLVertex::gammaGreaterThan() ) ); DLVertex * s = vertex_heap.front( ); pop_heap( vertex_heap.begin( ), vertex_heap.end( ), typename DLVertex::gammaGreaterThan( ) ); vertex_heap.pop_back( ); assert( is_heap( vertex_heap.begin( ), vertex_heap.end( ), typename DLVertex::gammaGreaterThan( ) ) ); // pi'(s) = pi(s) + gamma(s) if ( ! isPiPrime( s ) ) { s->old_pi = s->pi; changed_vertices.push_back( s ); } s->pi = s->pi + s->gamma; updatePiPrime( s ); // gamma(s) = 0 s->gamma = 0; readGamma( s ); AdjList & adjList = dAdj[s->id]; for ( typename AdjList::iterator it = adjList.begin( ); it != adjList.end( ); ++it ) { DLVertex *t = (*it)->v; // if pi'(t) = pi(t) then if ( !isPiPrime( t ) ) { if ( ! isGammaRead( t ) ) { t->gamma = 0; readGamma( t ); } const T value = s->pi + (*it)->wt - t->pi; if ( t->id == u->id ) { // t = u (t is the source vertex) assert( u == t ); if ( value < t->gamma ) { negCycleVertex = u; // TODO: check this conflict_edges[t->id] = *it; // restore the old_pi for ( typename vector< DLVertex * >::iterator it = changed_vertices.begin( ); it != changed_vertices.end( ); ++ it ) (*it)->pi = (*it)->old_pi; changed_vertices.clear( ); vertex_heap.clear( ); doneGamma( ); donePiPrime( ); return false; } } else { // pq.decrease_key(t) // if ( s->pi + (*it)->wt - t->pi < t->gamma ) if ( value < t->gamma ) { // t->gamma == 0 implies that t is not on the heap if ( t->gamma == 0 ) { // t->gamma = s->pi + (*it)->wt - t->pi; t->gamma = value; vertex_heap.push_back ( t ); conflict_edges[t->id] = *it; } else { assert( t->gamma < 0 ); // find t in the vector vertex_heap O(n) typename vector< DLVertex *>::iterator v_it; for (v_it = vertex_heap.begin( ); v_it != vertex_heap.end( ); ++v_it) { if( (*v_it) == t ) // update t->gamma in the vector { (*v_it)->gamma = value; break; } } } conflict_edges[t->id] = *it; } } } } make_heap( vertex_heap.begin( ) , vertex_heap.end( ) , typename DLVertex::gammaGreaterThan( ) ); } doneGamma( ); donePiPrime( ); changed_vertices.clear( ); return true; } // // Find edges with the larger weight than the shortest path between // the edge endpoints // template< class T> void DLGraph::findHeavyEdges( Enode * c ) { assert( c->hasPolarity( ) ); //DLComplEdges edges = edgeMap.find(c)->second; DLComplEdges edges = getDLEdge( c ); DLEdge *e = c->getPolarity ( ) == l_True ? edges.pos : edges.neg; // TODO: move this in the one-time called init procedure if ( isGreedy( ) ) { if ( Vcnt > (unsigned) bSPT.size() ) bSPT.resize( Vcnt ); if ( Vcnt > (unsigned) fSPT.size() ) fSPT.resize( Vcnt ); if ( Ecnt > (unsigned) shortest_paths.size( ) ) shortest_paths.resize( Ecnt ); } // check if there is a parallel edge of smaller weight - if yes: return if ( isParallelAndHeavy( e ) ) return; if ( isGreedy( ) ) { updateSPT( e, DL_sssp_forward); updateSPT( e, DL_sssp_backward); } initRwt( ); initDxRel( ); total_in_deg_dx_rel = 0; dx_relevant_vertices.clear( ); e->v->setRelevancy( DL_sssp_forward, true ); updateDxRel( e->v ); //max_dist_from_src = 0; findSSSP( e->u, DL_sssp_forward ); initDyRel( ); total_out_deg_dy_rel = 0; dy_relevant_vertices.clear( ); e->u->setRelevancy( DL_sssp_backward, true ); updateDyRel( e->u ); findSSSP( e->v, DL_sssp_backward ); doneRwt( ); iterateInactive( e ); // clear the shortest path tree clearSPTs( ); doneDxRel( ); doneDyRel( ); } template< class T> void DLGraph::iterateInactive( DLEdge * e ) { if ( total_out_deg_dy_rel < total_in_deg_dx_rel ) { for ( typename vector< DLVertex * >::iterator it = dy_relevant_vertices.begin( ); it != dy_relevant_vertices.end( ); ++ it ) { assert( isDyRelValid( *it ) && (*it)->dy_relevant ); AdjList & adj_list = hAdj[ (*it)->id ]; for ( typename AdjList::iterator aIt = adj_list.begin( ); aIt != adj_list.end( ); ++ aIt ) { if ( (*aIt)->c->hasPolarity( ) || (*aIt)->c->isDeduced( ) ) continue; const bool v_is_relevant = isDxRelValid( (*aIt)->v ) && (*aIt)->v->dx_relevant; if ( v_is_relevant ) { const T rpath_wt = (*it)->dy + (*aIt)->v->dx - e->rwt; addIfHeavy( rpath_wt, *aIt, e ); } } } } else { for ( typename vector< DLVertex *>::iterator it = dx_relevant_vertices.begin( ); it != dx_relevant_vertices.end( ); ++ it ) { assert( isDxRelValid( *it ) ); assert( (*it)->dx_relevant ); assert( (unsigned)(*it)->id < hAdjInc.size( ) ); AdjList & adj_list = hAdjInc[ (*it)->id ]; for ( typename AdjList::iterator aIt = adj_list.begin( ); aIt != adj_list.end( ); ++ aIt ) { if ( (*aIt)->c->hasPolarity( ) || (*aIt)->c->isDeduced( ) ) continue; const bool u_is_relevant = isDyRelValid( (*aIt)->u ) && (*aIt)->u->dy_relevant; if ( u_is_relevant ) { const T rpath_wt = (*aIt)->u->dy + (*it)->dx - e->rwt; addIfHeavy( rpath_wt, *aIt, e ); } } } } } // // Shortest path computation // if direction = DL_sssp_forward then forwardSSSP ("to x") // else backwardSSSP ("from x") // template< class T > void DLGraph::findSSSP( DLVertex * x, DL_sssp_direction direction ) { unsigned no_relevant = 0; initDist( ); initFinalDist( ); // initialize a new token for dist ( direction == DL_sssp_forward ) ? assert( pq_dx.empty( ) ) : assert( pq_dy.empty( ) ) ; x->setDist( direction, 0 ); // x is the source vertex readDist( x ); x->setDistFrom( direction, 0 ); // to track depth of the shortest path tree // handle delta relevancy x->setRelevancy( direction, false ); if ( direction == DL_sssp_forward ) updateDxRel( x ); else updateDyRel( x ); pushPBheap( direction, x ); while ( !emptyPBheap( direction ) ) { DLVertex * u = topPBheap( direction ); popPBheap( direction ); finalDist( u ); if ( u->getRelevancy( direction ) == true ) { insertRelevantVertices( u, direction ); -- no_relevant; } // handle delta relevancy const bool valid_rel_u = ( direction == DL_sssp_forward) ? isDxRelValid( u ) : isDyRelValid( u ); const bool rel_u = (valid_rel_u) ? u->getRelevancy( direction ) : false; if ( direction == DL_sssp_forward ) updateDxRel( u ); else updateDyRel( u ); // iterate through the adjacency list AdjList & adj_list = (direction == DL_sssp_forward) ? dAdj[ u->id ] : dAdjInc[ u->id ]; if ( adj_list.size( ) > max_adj_list_size ) max_adj_list_size = adj_list.size( ); unsigned no_of_adj_edges = 0; for( typename AdjList::iterator it = adj_list.begin( ); it != adj_list.end ( ); ++it ) { ++ no_of_adj_edges; DLVertex * v = (direction == DL_sssp_forward) ? (*it)->v : (*it)->u; // check if v's distance is final if ( isDistFinal( v ) ) continue; // IMPORTANT: if v has the final distance then the reduced weight for the // corresponding edge will not be updated. So, the // backward and forward graphs can have different edge weights. // make sure that rwt is valid after this point if ( ! isRwtValid( *it ) ) { (*it)->rwt = (*it)->u->pi + (*it)->wt - (*it)->v->pi; assert( (*it)->rwt >= 0 ); // INVARIANT: rwt(e) >= 0 updateRwt( *it ); } assert( isRwtValid( *it ) ); // INVARIANT: rwt is not stale // find new distance const T dist = u->getDist( direction ) + (*it)->rwt; assert ( dist >= 0 ); if ( ! isDistRead( v ) ) { // initial distance is +infinity, so just assign computed distance v->setDist( direction, dist ); // set the shortest path distance if ( isGreedy( ) ) updateSPT( *it, direction ); // update the shortest path tree // handle delta relevancy const bool valid_rel_v = ( direction == DL_sssp_forward ) ? isDxRelValid( v ) : isDyRelValid( v ); if ( ! valid_rel_v ) { v->setRelevancy( direction, rel_u ); // propagate relevancy if ( direction == DL_sssp_forward ) updateDxRel( v ); else updateDyRel( v ); } // v has a valid relevancy here // INVARIANT: v is NOT on the heap ( direction == DL_sssp_forward ) ? assert( find( pq_dx.begin( ), pq_dx.end( ), v) == pq_dx.end( ) ) : assert( find( pq_dy.begin( ), pq_dy.end( ), v) == pq_dy.end( ) ); // PUSH ON THE VECTOR: push v on the heap pushPBheap( direction, v ); if ( v->getRelevancy( direction ) == true) { ++ no_relevant; v->setDistFrom( direction, u->getDistFrom( direction ) + 1 ); } } else { ( direction == DL_sssp_forward ) ? assert( find( pq_dx.begin( ), pq_dx.end( ), v) != pq_dx.end( ) ) : assert( find( pq_dy.begin( ), pq_dy.end( ), v) != pq_dy.end( ) ); if ( v->getDist( direction ) > dist ) { v->setDist( direction, dist ); if ( v->getRelevancy( direction ) == false && rel_u == true ) ++ no_relevant; else if ( v->getRelevancy( direction ) == true && rel_u == false ) -- no_relevant; v->setRelevancy( direction, rel_u ); // propagate relevancy if ( direction == DL_sssp_forward ) updateDxRel( v ); else updateDyRel( v ); modifyPBheap( direction, v ); if ( isGreedy( ) ) updateSPT( *it, direction ); if ( v->getRelevancy( direction ) == true) { v->setDistFrom( direction, u->getDistFrom( direction ) + 1 ); } } } readDist( v ); // we computed the distance } if ( no_relevant <= 0) break; } doneDist( ); doneFinalDist( ); // done with the dist computation clearPBheap( direction ); } // // Update shortest path trees: backward / forward // // TODO: refactor - change to update shortest path tree // template void DLGraph< T >::updateSPT( DLEdge * e, DL_sssp_direction go ) { if ( go == DL_sssp_forward ) { if ( e->v->dist_from_src > max_dist_from_src ) max_dist_from_src = e->v->dist_from_src; fSPT[ e->v->id ] = e; } else { if ( e->u->dist_from_dst > max_dist_from_dst ) max_dist_from_dst = e->u->dist_from_dst; bSPT[ e->u->id ] = e; } } // // Find shortest path for an edge in the SPT // // added for lazy_eager schema // template bool DLGraph::findShortestPath( DLEdge * e ) { assert( e->id < (int) shortest_paths.size( ) ); // DIRTY TRICK: reasons should be unique // --> the problem is that the edges in the inactive edges are not unique if( !shortest_paths[ e->id ].empty( ) ) return false; DLVertex *x = e->r->u; DLVertex *y = e->r->v; DLEdge *spt_edge = bSPT[ e->u->id ]; shortest_paths[ e->id ].push_back( spt_edge ); while ( spt_edge->u != x ) { spt_edge = bSPT[ spt_edge->v->id ]; assert( spt_edge ); shortest_paths[ e->id ].push_back( spt_edge ); } assert( shortest_paths[ e->id ].back( ) == e->r ); spt_edge = fSPT[ e->v->id ]; if ( spt_edge->u != x ) { list< DLEdge * > backward_path; backward_path.push_front( spt_edge ); while( spt_edge->u != y ) { spt_edge = fSPT[ spt_edge->u->id ]; assert( spt_edge ); backward_path.push_front( spt_edge ); } while( ! backward_path.empty( ) ) { shortest_paths[ e->id ].push_back( backward_path.front( ) ); backward_path.pop_front( ); } } return true; } template< class T> void DLGraph::computeModel( ) { // Iterate through all vertices for ( typename Enode2Vertex::iterator it = vertexMap.begin( ) ; it != vertexMap.end( ) ; it ++ ) { Enode * e = it->first; DLVertex * v = it->second; Real value = -v->pi; e->setValue( value ); } } // // Print adjacency list // template< class T> void DLGraph::printAdj(vector & adj) { typename vector::iterator it; int i = 0; for(it = adj.begin(); it != adj.end(); ++it, ++i) { cerr << "Vertex " << i << " ====> "; printAdjList(*it); cerr << " " << endl; } } template< class T> void DLGraph::printAdjList(AdjList & adjList) { typename AdjList::iterator it; for (it = adjList.begin(); it != adjList.end(); ++it) cerr << *it << " "; } template< class T> void DLGraph::printDynGraphAsDotty( const char * filename, DLEdge *e ) { ofstream out( filename ); out << "DiGraph dump {" << endl; for ( typename vector< DLVertex * >::iterator it = vertices.begin( ) ; it != vertices.end( ) ; ++ it ) { AdjList & adjList = dAdj[(*it)->id]; typename AdjList::iterator jt; for (jt = adjList.begin(); jt != adjList.end(); ++jt) { if ( (*jt) == e ) printPlainEdge( out, *jt, "[color=red];" ); else printPlainEdge( out, *jt ); } } out << "}" << endl; out.close( ); cerr << "[ Wrote: " << filename << " ]" << endl; } template< class T > void DLGraph::printSSSPAsDotty( const char * filename, DLVertex * u , DL_sssp_direction direction ) { ofstream out( filename ); out << "DiGraph dump {" << endl; out << "\"" << u->e << " | " << u->getDist( direction ) << "\"" << " [color=red];" << endl; for ( typename vector< DLVertex * >::iterator it = vertices.begin( ) ; it != vertices.end( ) ; ++ it ) { AdjList & adjList = dAdj[(*it)->id]; typename AdjList::iterator jt; for (jt = adjList.begin(); jt != adjList.end(); ++jt) printSSSPEdge( out, *jt, direction ); } out << "}" << endl; out.close( ); cerr << "[ Wrote: " << filename << " ]" << endl; } template< class T> void DLGraph::printInactiveAsDotty( const char * filename ) { ofstream out ( filename ); out << "DiGraph dump { " << endl; typename vector< DLEdge * >::iterator it; for ( it = hEdges.begin( ); it != hEdges.end( ); ++ it) { const bool u_is_relevant = isDyRelValid( (*it)->u ) && (*it)->u->dy_relevant; const bool v_is_relevant = isDxRelValid( (*it)->v ) && (*it)->v->dx_relevant; string attrib = (u_is_relevant && v_is_relevant) ? " [color=red]; " : " ;"; printDistEdge( out, *it, attrib ); } out << "}" << endl; out.close( ); cerr << "[ Wrote: " << filename << " ]" << endl; } template< class T > void DLGraph::printDeducedAsDotty( const char * filename ) { ofstream out( filename ); out << "DiGraph dump {" << endl; for ( typename vector< DLEdge * >::iterator it = heavy_edges.begin( ) ; it != heavy_edges.end( ); ++ it) { string attrib = " [color=green]; "; printDistEdge( out, *it, attrib ); } for ( typename vector< DLVertex * >::iterator it = vertices.begin( ) ; it != vertices.end( ) ; ++ it ) { AdjList & adjList = dAdj[(*it)->id]; typename AdjList::iterator jt; for (jt = adjList.begin(); jt != adjList.end(); ++jt) printDistEdge( out, *jt ); } out << "}" << endl; out.close( ); cerr << "[ Wrote: " << filename << " ]" << endl; } template< class T> void DLGraph::printShortestPath( DLEdge * e, const char * filename ) { assert( e ); DLPath & shortest_path = getShortestPath( e ); ofstream out( filename ); out << "DiGraph sp {" << endl; printDistEdge( out, e, "[color=red];" ); for (typename DLPath::iterator it = shortest_path.begin( ); it != shortest_path.end( ); ++ it ) { printDistEdge( out, *it ); } out << "}" << endl; out.close( ); cerr << "[ Wrote: " << filename << " ]" << endl; } template void DLGraph::printDLPath( DLPath path, const char * filename ) { //assert( path ); ofstream out( filename ); out << "DiGraph sp {" << endl; for ( typename DLPath::iterator it = path.begin( ); it != path.end( ); ++ it ) { printDistEdge( out, *it ); } out << "}" << endl; out.close( ); cerr << "[ Wrote: " << filename << " ]" << endl; } opensmt-2.5.2/src/tsolvers/dlsolver/DLGraph.h000066400000000000000000000675001445011647600211610ustar00rootroot00000000000000/********************************************************************* Author: Edgar Pek , Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ // Graph functions #ifndef DLGRAPH_H #define DLGRAPH_H #include #include "Enode.h" #include "Egraph.h" #include "SMTConfig.h" #define HASH_SET 0 #define LAZY_GENERATION 1 enum DL_sssp_direction { DL_sssp_forward, DL_sssp_backward }; // FIXME: // . constructor first // . use reference when passing Numbers // . input parameters in constructor should have different names than class attributes template struct DLVertex { DLVertex ( Enode * e_ , int id_ ) : e ( e_ ) , id ( id_ ) , gamma ( 0 ) , pi ( 0 ) , old_pi ( 0 ) , dx ( -1 ) , dy ( -1 ) , dx_relevant ( false ) , dy_relevant ( false ) , dyn_outdegree ( 0 ) , dyn_indegree ( 0 ) , h_outdegree ( 0 ) , h_indegree ( 0 ) , dist_from_src ( 0 ) , dist_from_dst ( 0 ) { } DLVertex ( DLVertex * v ) : e ( v->e ) , id ( v->id) , gamma ( v->gamma ) , pi ( v->pi ) , old_pi ( v->old_pi ) , dx ( v->dx ) , dy ( v->dy ) , dx_relevant ( v->dx_relevant ) , dy_relevant ( v->dy_relevant ) , dyn_outdegree( v->dyn_outdegree ) , dyn_indegree ( v->dyn_indegree ) , h_outdegree ( v->h_outdegree ) , h_indegree ( v->h_indegree ) , dist_from_src( v->dist_from_src ) , dist_from_dst( v->dist_from_dst ) { } inline T & getDist( DL_sssp_direction go ) { return ( go == DL_sssp_forward ) ? dx : dy; } inline void setDist( DL_sssp_direction go, T val) { if ( go == DL_sssp_forward ) dx = val; else dy = val; } inline bool getRelevancy( DL_sssp_direction go ) { return go == DL_sssp_forward ? dx_relevant : dy_relevant; } inline void setRelevancy( DL_sssp_direction go, bool val ) { if ( go == DL_sssp_forward ) dx_relevant = val; else dy_relevant = val; } inline void setDistFrom( DL_sssp_direction go, T val ) { ( go == DL_sssp_forward ) ? dist_from_src = val : dist_from_dst = val; } inline T & getDistFrom( DL_sssp_direction go ) { return ( go == DL_sssp_forward ) ? dist_from_src : dist_from_dst; } struct gammaGreaterThan { inline bool operator ( )( DLVertex * x, DLVertex * y ) { return x->gamma > y->gamma; } }; struct ssspGreaterThan { ssspGreaterThan( DL_sssp_direction go_ ) : go (go_) { } inline bool operator ( )( DLVertex * x, DLVertex * y ) { return ( go == DL_sssp_forward ) ? ( x->dx > y->dx ) : ( x->dy > y->dy ); } DL_sssp_direction go; }; struct ssspDxGreaterThan { inline bool operator ( )( DLVertex * x, DLVertex * y ) { return x->dx > y->dx ; } }; struct ssspDyGreaterThan { inline bool operator ( )( DLVertex * x, DLVertex * y ) { return x->dy > y->dy ; } }; Enode * e; const int id; T gamma; T pi; T old_pi; T dx; T dy; bool dx_relevant; bool dy_relevant; size_t dyn_outdegree; size_t dyn_indegree; size_t h_outdegree; size_t h_indegree; T dist_from_src; T dist_from_dst; }; template struct DLEdge { DLEdge( Enode * c_ , int id_ , DLVertex * u_ , DLVertex * v_ , T & wt_ ) : c ( c_ ) , id ( id_ ) , u ( u_ ) , v ( v_ ) , wt ( wt_ ) , rwt( -1 ) , r ( NULL ) // TODO: check if needed { } inline void printDLEdge( ostream &os ) { os << u->e << " --[" << wt << "]--> " << v->e; } inline friend ostream & operator<<( ostream & os, DLEdge * e ) { assert( e ); e->printDLEdge( os ); return os; } Enode * c; // reference to the original Enode const int id; // id of the edge DLVertex * u; // the source vertex DLVertex * v; // the destination vertex const T wt; // original cost of the edges T rwt; // reduced cost of the edge (nonnegative edge weight) DLEdge * r; // the edge that caused deduction TODO: check if needed! }; template struct DLComplEdges { DLComplEdges ( DLEdge * pos_ , DLEdge * neg_ ) : pos ( pos_ ) , neg ( neg_ ) { } DLEdge *pos; DLEdge *neg; }; template struct DLTwoVertices { DLTwoVertices ( DLVertex * u_ , DLVertex * v_ ) : u ( u_ ) , v ( v_ ) { } struct vertexIdGreaterThan { inline bool operator ( ) ( const DLTwoVertices & x, const DLTwoVertices & y) { return x.u->id > y.u->id; } }; DLVertex * u; DLVertex * v; }; namespace __gnu_cxx { // Hash function for DLEdge * template< typename DLEdge > struct SizeTDLEdge { size_t operator ( ) ( const DLEdge & e ) const { return (size_t) e; } }; } template< class T > class DLGraph { public: DLGraph( SMTConfig & config_, Egraph & egraph_ ) : Vcnt ( 0 ) , Ecnt ( 0 ) , active_pi_prime ( false ) , pi_prime_count ( 0 ) , active_gamma ( false ) , gamma_count ( 0 ) , active_rwt ( false ) , rwt_count ( 0 ) , active_dist ( false ) , dist_count ( 0 ) , active_final_dist ( false ) , final_dist_count ( 0 ) , active_dx_rel ( false ) , dx_rel_count ( 0 ) , active_dy_rel ( false ) , dy_rel_count ( 0 ) , active_dfs_visited ( false ) , dfs_visited_count ( 0 ) , active_dfs_finished( false ) , dfs_finished_count ( 0 ) , active_apsp_inf ( false ) , apsp_inf_count ( 0 ) , max_dist_from_src ( 0 ) , max_dist_from_dst ( 0 ) , max_adj_list_size ( 0 ) , max_dyn_vertex_id ( 0 ) , max_dyn_edges ( 0 ) , after_backtrack ( false ) , config ( config_ ) , egraph ( egraph_ ) { } ~DLGraph( ); typedef vector< DLEdge * > AdjList; typedef __gnu_cxx::SizeTDLEdge< const DLEdge * > HashDLEdge; typedef vector< DLEdge * > DLPath; typedef map< Enode *, DLVertex * > Enode2Vertex; typedef map< Enode *, DLComplEdges > Enode2Edge; inline unsigned getVcnt ( ) const { return Vcnt; } inline unsigned getEcnt ( ) const { return Ecnt; } inline Enode2Edge & getEdgeMap ( ) { return edgeMap; } inline vector< AdjList > & getDAdj ( ) { return dAdj; } inline vector< DLEdge * > & getConflictEdges ( ) { return conflict_edges; } inline DLVertex * getNegCycleVertex ( ) { return negCycleVertex; } inline double getDynGraphDensity( ) { return (double) dEdges.size( ) / (double) Vcnt; } inline void deleteFromAdjList( AdjList & adj_list, DLEdge * e) { assert( e ); typename AdjList::iterator it = find( adj_list.begin( ), adj_list.end( ), e ); if ( it != adj_list.end( )) adj_list.erase( it ); } void insertStatic ( Enode * ); DLEdge * insertDynamic ( Enode *, bool reason ); void insertImplied ( Enode * ); void insertInactive( Enode * ); void deleteActive ( Enode * ); void deleteInactive( Enode * ); inline DLEdge * getOppositePolarityEdge( Enode * c ) { assert( c->hasPolarity( ) ); assert( edgeMap.find( c ) != edgeMap.end( ) ); DLComplEdges edges = edgeMap.find( c )->second; DLEdge * e = c->getPolarity( ) == l_True ? edges.neg : edges.pos; assert( e ); return e; } inline DLEdge * getEdgeWithPolarity ( Enode * c ) { assert( c->hasPolarity( ) ); assert( edgeMap.find( c ) != edgeMap.end( ) ); DLComplEdges edges = edgeMap.find( c )->second; DLEdge * e = c->getPolarity( ) == l_True ? edges.pos : edges.neg; assert( e ); return e; } inline void updateDynDegree( DLEdge * e ) { e->u->dyn_outdegree = dAdj[ e->u->id ].size( ); e->v->dyn_indegree = dAdjInc[ e->v->id ].size( ); } inline void updateHDegree( DLEdge * e ) { e->u->h_outdegree = hAdj[ e->u->id ].size( ); e->v->h_indegree = hAdjInc[ e->v->id ].size( ); } // DFS visit - check for the cycle bool dfsVisit( DLEdge * ); bool checkNegCycle ( Enode *, bool ); bool checkNegCycleDFS ( Enode *, bool ); void findHeavyEdges( Enode * ); void iterateInactive( DLEdge * ); inline bool isParallelAndHeavy( DLEdge *e ) { // Check if there is a parallel edge of smaller weight - if yes: return AdjList & adj_list_x = dAdj[ e->u->id ]; for ( typename AdjList::iterator it = adj_list_x.begin( ); it != adj_list_x.end( ); ++ it ) if ( ( (*it)->v->id == e->v->id ) && ( (*it)->wt < e->wt ) ) return true; return false; } inline void addIfHeavy( const T & rpath_wt, DLEdge * e, DLEdge *edge ) { assert ( ! e->c->hasPolarity( ) && ! e->c->isDeduced( ) ); if ( rpath_wt + e->v->pi - e->u->pi <= e->wt ) { if ( isGreedy( ) ) { e->r = edge; if ( findShortestPath( e ) ) // added for eager_lazy schema { heavy_edges.push_back( e ); undo_stack_deduced_edges.push_back( e ); // added for eager_lazy schema } } else heavy_edges.push_back( e ); } } void findHeavyEdgesFW ( Enode * ); // find heavy edges with the Floyd-Warshall's algorithm void iterateInactiveFW ( ); // iterate through the set of inactive edges inline DLPath & getShortestPath ( DLEdge *e ) { assert( e ); return shortest_paths[ e->id ]; } inline void clearShortestPath ( DLEdge *e ) { assert( e ); shortest_paths[ e->id ].clear( ); clearSPTs( ); } inline void computeModel ( ); void printAdj ( vector & ); void printAdjList ( AdjList & ); inline void printStatAdj ( ) { printAdj(sAdj); } inline void printDynAdj ( ) { printAdj(dAdj); } Real tmp_edge_weight; vector< DLVertex * > vertices; vector< DLEdge * > heavy_edges; // TODO: deal with it when backtracking! vector< Enode * > undo_stack_inactive_enodes; // stack of inactive edges vector< DLEdge * > undo_stack_deduced_edges; // stack of deduced edges void printShortestPath ( DLEdge *, const char * ); void printDLPath ( DLPath, const char * ); // // FIXME: This is a trick to deactivate LAZY_GENERATION for // RDL. It seems that is is faster this way ... // inline bool isGreedy( ) { return ( 0 == LAZY_GENERATION || config.logic == QF_RDL ); } private: inline DLVertex * getDLVertex( Enode * x ) { if ( vertexMap.find( x ) == vertexMap.end( ) ) { DLVertex * v = new DLVertex( x, vertexMap.size( ) ); vertexMap.insert( pair< Enode *, DLVertex *> (x, v) ); vertices.resize( vertexMap.size( ) ); vertices[v->id] = v; return v; } return vertexMap.find( x )->second; } DLComplEdges getDLEdge( Enode * ); inline Real & getPosWeight ( Real & weight ) { (void)weight; return tmp_edge_weight; } inline long & getPosWeight ( long & weight ) { weight = atol( tmp_edge_weight.get_str( ).c_str( ) ); return weight; } // Fast pi prime update check. Cannot be nested! inline void initPiPrime ( ) { assert( !active_pi_prime ); active_pi_prime = true; pi_primes.resize( Vcnt, pi_prime_count ); ++ pi_prime_count; } inline void updatePiPrime ( DLVertex * v ) { assert( active_pi_prime ); assert( v->id < (int)pi_primes.size( ) ); pi_primes[ v->id ] = pi_prime_count; } inline bool isPiPrime ( DLVertex * v ) { assert( active_pi_prime ); assert( v->id < (int)pi_primes.size( ) ); return pi_primes[ v->id ] == pi_prime_count; } inline void donePiPrime ( ) { assert( active_pi_prime ); active_pi_prime = false; } // Fast gamma update check. Cannot be nested. inline void initGamma ( ) { assert( !active_gamma ); active_gamma = true; gammas.resize( Vcnt, gamma_count ); ++ gamma_count; } inline void readGamma ( DLVertex * v ) { assert( active_gamma ); assert( v->id < (int)gammas.size( ) ); gammas[ v->id ] = gamma_count; } inline bool isGammaRead ( DLVertex * v ) { assert( active_gamma ); assert( v->id < (int)gammas.size( ) ); return gammas[ v->id ] == gamma_count; } inline void doneGamma ( ) { assert( active_gamma ); active_gamma = false; } // Fast rwt update check. Cannot be nested. inline void initRwt ( ) { assert( !active_rwt ); active_rwt = true; rwts.resize( Ecnt, rwt_count); rwt_count ++;} inline void updateRwt ( DLEdge * e ) { assert( active_rwt ); assert( e->id < (int)rwts.size( ) ); rwts[ e->id ] = rwt_count; } inline bool isRwtValid ( DLEdge * e ) { assert( active_rwt ); assert( e->id < (int)rwts.size( ) ); return rwts[ e->id ] == rwt_count; } inline void doneRwt ( ) { assert( active_rwt ); active_rwt = false; } // Fast distance update check. Cannot be nested. inline void initDist ( ) { assert( !active_dist ); active_dist = true; dists.resize( Vcnt, dist_count ); ++ dist_count; } inline void readDist ( DLVertex * v ) { assert( active_dist ); assert( v->id < (int)dists.size( ) ); dists[ v->id ] = dist_count; } inline bool isDistRead ( DLVertex * v ) { assert( active_dist ); assert( v->id < (int)dists.size( ) ); return dists[ v->id ] == dist_count; } inline void doneDist ( ) { assert( active_dist ); active_dist = false; } // Fast final distance check. Cannot be nested. inline void initFinalDist ( ) { assert( !active_final_dist ); active_final_dist = true; final_dists.resize( Vcnt, final_dist_count ); ++ final_dist_count; } inline void finalDist ( DLVertex * v ) { assert( active_final_dist ); assert( v->id < (int)final_dists.size( ) ); final_dists[ v->id ] = final_dist_count; } inline bool isDistFinal ( DLVertex * v ) { assert( active_final_dist ); assert( v->id < (int)final_dists.size( ) ); return final_dists[ v->id ] == final_dist_count; } inline void doneFinalDist ( ) { assert( active_final_dist ); active_final_dist = false; } // Fast dx relevancy check. Cannot be nested. inline void initDxRel ( ) { assert ( !active_dx_rel ); active_dx_rel = true; dx_rels.resize( Vcnt, dx_rel_count ); ++ dx_rel_count; } inline void updateDxRel ( DLVertex * v ) { assert ( active_dx_rel ); assert( v->id < (int)dx_rels.size( ) ); dx_rels[ v->id ] = dx_rel_count; } inline bool isDxRelValid ( DLVertex * v ) { assert ( active_dx_rel ); assert( v->id < (int)dx_rels.size( ) ); return dx_rels[ v->id ] == dx_rel_count; } inline void doneDxRel ( ) { assert ( active_dx_rel ); active_dx_rel = false; } // Fast dy relevancy check. Cannot be nested. inline void initDyRel ( ) { assert ( !active_dy_rel ); active_dy_rel = true; dy_rels.resize( Vcnt, dy_rel_count ); ++ dy_rel_count; } inline void updateDyRel ( DLVertex * v ) { assert ( active_dy_rel ); assert( v->id < (int)dy_rels.size( ) ); dy_rels[ v->id ] = dy_rel_count; } inline bool isDyRelValid ( DLVertex * v ) { assert ( active_dy_rel ); assert( v->id < (int)dy_rels.size( ) ); return dy_rels[ v->id ] == dy_rel_count; } inline void doneDyRel ( ) { assert ( active_dy_rel ); active_dy_rel = false; } // Fast dfs visited check. Cannot be nested. inline void initDfsVisited ( ) { assert ( !active_dfs_visited ); active_dfs_visited = true; dfs_visited.resize( Vcnt, dfs_visited_count ); ++ dfs_visited_count; } inline void setDfsVisited ( DLVertex * v ) { assert ( active_dfs_visited ); assert( v->id < (int) dfs_visited.size( ) ); dfs_visited[ v->id ] = dfs_visited_count; } inline bool isDfsVisited ( DLVertex * v ) { assert ( active_dfs_visited ); assert( v->id < (int) dfs_visited.size( ) ); return dfs_visited[ v->id ] == dfs_visited_count; } inline void doneDfsVisited ( ) { assert ( active_dfs_visited ); active_dfs_visited = false; } // Fast dfs finished check. Cannot be nested. inline void initDfsFinished ( ) { assert ( !active_dfs_finished ); active_dfs_finished = true; dfs_finished.resize( Vcnt, dfs_finished_count ); ++ dfs_finished_count; } inline void setDfsFinished ( DLVertex * v ) { assert ( active_dfs_finished ); assert( v->id < (int) dfs_finished.size( ) ); dfs_finished[ v->id ] = dfs_finished_count; } inline bool isDfsFinished ( DLVertex * v ) { assert ( active_dfs_finished ); assert( v->id < (int) dfs_finished.size( ) ); return dfs_finished[ v->id ] == dfs_finished_count; } inline void doneDfsFinished ( ) { assert ( active_dfs_finished ); active_dfs_finished = false; } // Fast infinity distance check in apsp distance matrix. Cannot be nested. inline void initInfAPSP ( ) { assert ( !active_apsp_inf ); active_apsp_inf = true; apsp_infs.resize( Vcnt ); for( unsigned i = 0; i < Vcnt; ++i ) apsp_infs[i].resize(Vcnt, apsp_inf_count ); ++ apsp_inf_count; } inline void updateAPSP ( int i, int j ) { assert ( active_apsp_inf ); assert( i < (int) apsp_infs.size( ) ); assert( j < (int) apsp_infs[ i ].size( ) ); apsp_infs[ i ][ j ] = apsp_inf_count; } inline void invalidateAPSP( int i, int j ) { assert ( active_apsp_inf ); assert( i < (int) apsp_infs.size( ) ); assert( j < (int) apsp_infs[ i ].size( ) ); apsp_infs[ i ][ j ] = 0; } inline bool isValidAPSP ( int i, int j ) { assert ( active_apsp_inf ); assert( i < (int)apsp_infs.size( ) ); assert( j < (int)apsp_infs[ i ].size( ) ); return apsp_infs[ i ][ j ] == apsp_inf_count; } inline void doneInfAPSP ( ) { assert ( active_apsp_inf ); active_apsp_inf = false; } // Dotty pretty print void printDynGraphAsDotty( const char *, DLEdge *e = NULL ); inline void printEdgeWPi ( ofstream & out, DLEdge * e) { assert( e ); out << "\"" << e->u->e << " | " << e->u->pi << "\"" << " -> " << "\"" << e->v->e << " | " << e->v->pi << "\"" << " [label=" << e->wt << "];" << endl; } void printSSSPAsDotty( const char * , DLVertex * , DL_sssp_direction ); inline void printSSSPEdge( ofstream & out, DLEdge * e, DL_sssp_direction direction) { assert( e ); DLVertex * u = ( direction == DL_sssp_forward ) ? e->u : e->v; DLVertex * v = ( direction == DL_sssp_forward ) ? e->v : e->u; string attrib_u, attrib_v; const bool valid_delta_u = ( direction == DL_sssp_forward ) ? isDxRelValid( u ) : isDyRelValid( u ); const bool valid_delta_v = ( direction == DL_sssp_forward ) ? isDxRelValid( v ) : isDyRelValid( v ); attrib_u = ( valid_delta_u && u->getRelevancy( direction ) ) ? " [style=filled, fillcolor=gray] " : ""; attrib_v = ( valid_delta_v && v->getRelevancy( direction ) ) ? " [style=filled, fillcolor=gray] " : ""; out << "\"" << u->e << " | " << u->getDist( direction ) << "\"" << attrib_u << endl; out << "\"" << v->e << " | " << v->getDist( direction ) << "\"" << attrib_v << endl; out << "\"" << u->e << " | " << u->getDist( direction ) << "\"" << " -> " << "\"" << v->e << " | " << v->getDist( direction ) << "\"" << " [label=" << e->wt << "];" << endl; } inline void printDistEdge( ofstream & out, DLEdge * e, string attrib = ";" ){ assert( out ); assert( e ); out << "\"" << e->u->e << " | " << e->u->dy << "\"" << " -> " << "\"" << e->v->e << " | " << e->v->dx << "\"" << " [label=" << e->wt << "] " << attrib << endl; } inline void printPlainEdge( ofstream & out, DLEdge * e, string attrib = ";" ){ assert( out ); assert( e ); out << "\"" << e->u->e << " | " << e->u->id << "\"" << " -> " << "\"" << e->v->e << " | " << e->v->id << "\"" << " [label=" << e->wt << "] " << attrib << endl; } void printInactiveAsDotty( const char * ); void printDeducedAsDotty( const char * ); void printAdjMatrix( const char * ); void printAPSPMatrix( const char * ); // SSSP computation void findSSSP( DLVertex *, DL_sssp_direction ); inline void insertRelevantVertices( DLVertex * v, DL_sssp_direction go ) { if( go == DL_sssp_forward ) { assert( isDxRelValid( v ) && v->dx_relevant ); dx_relevant_vertices.push_back( v ); total_in_deg_dx_rel += hAdjInc[ v->id ].size( ); } else { assert( isDyRelValid( v ) && v->dy_relevant ); dy_relevant_vertices.push_back( v ); total_out_deg_dy_rel += hAdj[ v->id ].size( ); } } inline void pushPBheap( DL_sssp_direction go, DLVertex * v ) { if ( go == DL_sssp_forward ) { assert( v->id < (int)pq_dx_it.size( ) ); pq_dx_it[ v->id ] = pq_dx.push( v ); } else { assert( v->id < (int)pq_dy_it.size( ) ); pq_dy_it[ v->id ] = pq_dy.push( v ); } } inline bool emptyPBheap( DL_sssp_direction go ) { return ( go == DL_sssp_forward ) ? pq_dx.empty ( ) : pq_dy.empty( ) ; } inline DLVertex * topPBheap( DL_sssp_direction go ) { return ( go == DL_sssp_forward ) ? pq_dx.top( ) : pq_dy.top( ); } inline void popPBheap( DL_sssp_direction go ) { (go == DL_sssp_forward ) ? pq_dx.pop( ) : pq_dy.pop( ); } inline void modifyPBheap( DL_sssp_direction go, DLVertex * v ) { ( go == DL_sssp_forward ) ? pq_dx.modify( pq_dx_it[ v->id ], v ) : pq_dy.modify( pq_dy_it[ v->id ], v ); } inline void clearPBheap ( DL_sssp_direction go ) { ( go == DL_sssp_forward ) ? pq_dx.clear( ) : pq_dy.clear( ); } inline size_t sizePBheap( DL_sssp_direction go ) { return ( go == DL_sssp_forward ) ? pq_dx.size( ) : pq_dy.size( ); } inline void addToNewSpaths( int i, int j ) { assert( vertices[i]->id == i && vertices[j]->id == j ); new_spaths.insert( DLTwoVertices( vertices[i], vertices[j] ) ); } void updateSPT ( DLEdge * e, DL_sssp_direction go ); inline DLEdge * getSPT ( DLVertex * v, DL_sssp_direction go ) { assert( v ); return ( go == DL_sssp_forward ) ? fSPT[ v->id ] : bSPT[ v->id ]; } inline void clearSPTs ( ) { bSPT.clear( ); bSPT.resize( Vcnt ); fSPT.clear( ); fSPT.resize( Vcnt ); } inline void updateFringe( DLEdge * e, DL_sssp_direction go) { assert( e ); (go == DL_sssp_forward ) ? fFringe[ e->u->id ] = e : bFringe[ e->u->id ] = e; } inline DLEdge * getFringe ( DLVertex * v, DL_sssp_direction go) { assert( v ); return ( go == DL_sssp_forward ) ? fFringe[ v->id ] : bFringe[ v->id ]; } // find shortest path for an edge bool findShortestPath( DLEdge * ); unsigned Vcnt; unsigned Ecnt; bool active_pi_prime; // To prevent nested usage vector< int > pi_primes; // Fast pi prime update checking int pi_prime_count; // New pi prime token bool active_gamma; // To prevent nested usage vector< int > gammas; // Fast check if gamma was updated int gamma_count; // New gamma token bool active_rwt; // To prevent nested usage vector< int > rwts; // Fast chek if rwt was updated int rwt_count; // New rwt token bool active_dist; // To prevent nested usage vector< int > dists; // Fast check if dx was updated int dist_count; // New dist token bool active_final_dist; // To prevent nested usage vector< int > final_dists; // Fast check if dist is final int final_dist_count; // New final dist token bool active_dx_rel; // To prevent nested usage vector< int > dx_rels; // Fast check if dx is relevant int dx_rel_count; // DeltaX relevancy token bool active_dy_rel; // To prevent nested usage vector< int > dy_rels; // Fast check if dy is relevant int dy_rel_count; // DeltaY relevancy token // for DFS bool active_dfs_visited; // To prevent nested usage vector< int > dfs_visited; // Fast check if a vertex is visited during dfs int dfs_visited_count; // dfs visted token bool active_dfs_finished; // To prevent nested usage vector< int > dfs_finished; // Fast check if processing of vertex is finished int dfs_finished_count; // dfs finished count bool active_apsp_inf; // To prevent nested usage vector< vector< int > > apsp_infs; // Fast check if a value in apsp matrix is infinity int apsp_inf_count; // Apsp infinity check token Enode2Vertex vertexMap; Enode2Edge edgeMap; vector< AdjList > sAdj; // adjacency list - static constraint graph vector< DLEdge * > sEdges; // edges - static constraint graph vector< AdjList > dAdj; // adjacency list - dynamic constraint graph vector< AdjList > dAdjInc; // incoming edges adjacency list - dynamic constraint graph vector< DLEdge * > dEdges; // edges - dynamic constraint graph vector< AdjList > iAdj; // adjacency list - implied graph vector< DLEdge * > iEdges; // edges - implied graph vector< AdjList > hAdj; vector< AdjList > hAdjInc; vector< DLEdge * > hEdges; // the vector of inactive edges : d - s vector< DLEdge * > conflict_edges; // used to explain a conflict DLVertex * negCycleVertex; vector< DLVertex * > vertex_heap; vector< DLVertex * > changed_vertices; // data structures used in SSSP computations vector< DLVertex * > dist_heap; // min-heap of distances typedef priority_queue< DLVertex *, typename DLVertex::ssspDxGreaterThan, pairing_heap_tag > pq_dx_type; pq_dx_type pq_dx; vector< typename pq_dx_type::point_iterator > pq_dx_it; typedef priority_queue< DLVertex *, typename DLVertex::ssspDyGreaterThan, pairing_heap_tag > pq_dy_type; pq_dy_type pq_dy; vector< typename pq_dy_type::point_iterator > pq_dy_it; // data structures used in APSP computations set< DLTwoVertices, typename DLTwoVertices::vertexIdGreaterThan > new_spaths; // new shortest paths // used to explain deduction - i.e. to get a reason for a deduction vector< DLEdge * > bSPT; // backward shortest path tree vector< DLEdge * > fSPT; // forward shortest path tree vector< DLEdge * > bFringe; // backward fringe vector< DLEdge * > fFringe; // forward fringe vector< DLPath > shortest_paths; // shortest path for an edge vector< DLVertex * > dx_relevant_vertices; vector< DLVertex * > dy_relevant_vertices; // for dfs vector< DLVertex * > dfs_stack; vector< DLEdge * > cycle_edges; unsigned total_in_deg_dx_rel; unsigned total_out_deg_dy_rel; T max_dist_from_src; T max_dist_from_dst; unsigned max_adj_list_size; unsigned max_dyn_vertex_id; unsigned max_dyn_edges; bool after_backtrack; SMTConfig & config; Egraph & egraph; }; #endif opensmt-2.5.2/src/tsolvers/dlsolver/DLSolver.cc000066400000000000000000000314021445011647600215200ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso , Edgar Pek , Aliaksei Tsitovich OpenSMT2 -- Copyright (C) 2008-2012, Roberto Bruttomesso 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. *********************************************************************/ #include "DLSolver.h" #include "DLGraph.h" // Included to compile templates #include "DLGraph.C" #define DLVERBOSE 0 // // Allocates a new graph // template< class T > void DLSolver::initGraph( ) { G = new DLGraph( config, egraph ); } // // Deallocate graph // template< class T > DLSolver::~DLSolver( ) { delete G; } // // The solver is informed of the existence of // atom e. It might be useful for initializing // the solver's data structures. This function is // called before the actual solving starts. // template< class T > lbool DLSolver::inform( Enode * e ) { assert( e ); assert( belongsToT( e ) ); assert( !e->hasPolarity( ) ); assert( e->isLeq( ) ); #ifdef PRODUCE_PROOF assert( config.produce_inter == 0 || e->getIPartitions( ) != 0 ); #endif G->insertStatic( e ); return l_Undef; } // // Asserts a literal into the solver. If by chance // you are able to discover inconsistency you may // return false. The real consistency state will // be checked with "check" // template< class T > bool DLSolver::assertLit ( Enode * e, bool reason ) { assert( e ); assert( belongsToT( e ) ); assert( e->hasPolarity( ) ); // // If we are doing eager computation / lazy communication // DLEdge * deduced_edge = G->getOppositePolarityEdge( e ); if ( reason && G->isGreedy( ) ) { // Find the shortest path p for the deduced edge DLPath & shortest_path = G->getShortestPath( deduced_edge ); assert( ! shortest_path.empty( ) ); explanation.push_back( e ); for ( typename DLPath::iterator it = shortest_path.begin( ); it != shortest_path.end( ); ++ it ) explanation.push_back( (*it)->c ); return false; } if ( e->isDeduced( ) && e->getDeduced( ) == e->getPolarity( ) && e->getDedIndex( ) == id ) return true; undo_stack_edges.push_back( e ); //G->insertDynamic ( e ); const bool res = G->checkNegCycle( e, reason ); //const bool res = G->checkNegCycleDFS( e, reason ); // Return true if satisfiable if ( res ) { assert( false == reason ); if ( config.dl_theory_propagation > 0 ) { G->findHeavyEdges( e ); sendDeductions( ); } return true; } // // Otherwise retrieve and store negative cycle // DLVertex * s = G->getNegCycleVertex( ); DLVertex * u = s; DLPath & conflictEdges = G->getConflictEdges( ); DLPath lazy_spath; do { DLEdge *edge = conflictEdges[u->id]; u = edge->u; explanation.push_back( edge->c ); if ( reason ) lazy_spath.push_back( edge ); } while(s != u); return false; } template< class T > void DLSolver::pushBacktrackPoint ( ) { // // Undo_stack_deduced_edges is used in the lazy_eager schema // if ( G->isGreedy( ) ) { backtrack_points.push_back( G->undo_stack_deduced_edges.size( ) ); } // // Backtrack_points.push_back( G->undo_stack_inactive_enodes.size( ) ); // backtrack_points.push_back( undo_stack_edges.size( ) ); } template< class T >void DLSolver::popBacktrackPoint ( ) { assert( G->heavy_edges.empty( ) ); assert( backtrack_points.size( ) > 0 ); // // Backtrack to dyn edges stack size // size_t undo_stack_new_size = backtrack_points.back( ); backtrack_points.pop_back( ); backtrackToDynEdgesStackSize( undo_stack_new_size ); if ( G->isGreedy( ) ) { undo_stack_new_size = backtrack_points.back( ); backtrack_points.pop_back( ); backtrackToDeducedEdgesStackSize( undo_stack_new_size ); } } template < class T> bool DLSolver::check( bool complete ) { (void)complete; // // Here check for consistency // return true; } // // DL Atoms have one of these shapes // // (<= (+ (* 1 x) (* (~ 1) y)) c) // (<= (+ (* (~ 1) x) (* 1 y)) c) // (<= (* (~ 1) x) c) // (<= (* 1 x) c) // template< class T > bool DLSolver::belongsToT( Enode * e ) { assert( e ); if ( !e->isLeq( ) ) return false; Enode * lhs = e->get1st( ); Enode * rhs = e->get2nd( ); if ( !lhs->isConstant( ) && !rhs->isConstant( ) ) return false; if ( lhs->isConstant( ) ) { Enode * tmp = lhs; lhs = rhs; rhs = tmp; } Real one_ = 1; Real mone_ = -1; Enode * one = egraph.mkNum( one_ ); Enode * mone = egraph.mkNum( mone_ ); // // Two variables // if ( lhs->isPlus( ) ) { if ( lhs->getArity( ) != 2 ) return false; Enode * mon_1 = lhs->get1st( ); Enode * mon_2 = lhs->get2nd( ); if ( !mon_1->isTimes( ) ) return false; if ( !mon_2->isTimes( ) ) return false; Enode * const_1 = mon_1->get1st( ); Enode * const_2 = mon_2->get1st( ); Enode * var_1 = mon_1->get2nd( ); Enode * var_2 = mon_2->get2nd( ); if ( config.logic == QF_UFIDL && config.sat_lazy_dtc != 0 ) { if ( !var_1->isVar( ) && !var_1->isUf( ) ) return false; if ( !var_2->isVar( ) && !var_2->isUf( ) ) return false; } else { if ( !var_1->isVar( ) || !var_2->isVar( ) ) return false; } if ( !const_1->isConstant( ) || !const_2->isConstant( ) ) return false; if ( const_1 == one && const_2 == mone ) return true; if ( const_2 == one && const_1 == mone ) return true; return false; } // // One variable // if ( lhs->getArity( ) < 2 ) { opensmt_error2( "Malformed term: ", e ); } Enode * con = lhs->get1st( ); Enode * var = lhs->get2nd( ); if ( con != one && con != mone ) return false; if ( config.logic == QF_UFIDL && config.sat_lazy_dtc != 0 ) { if ( !var->isVar( ) && !var->isUf( ) ) return false; } else { if ( !var->isVar( ) ) return false; } return true; } // Backtrack stack to the size template< class T>void DLSolver::backtrackToDynEdgesStackSize( size_t size ) { // Restore the state at the previous backtrack point while ( undo_stack_edges.size( ) > size ) { Enode * e = undo_stack_edges.back( ); undo_stack_edges.pop_back( ); G->deleteActive( e ); } } // // FIXME: make sure it is correctly handled // template< class T>void DLSolver::backtrackToInactiveEnodesStackSize( size_t size ) { // Restore the state at the previous backtrack point while ( G->undo_stack_inactive_enodes.size( ) > size ) { Enode * e = G->undo_stack_inactive_enodes.back( ); G->undo_stack_inactive_enodes.pop_back( ); G->insertInactive( e ); } } template< class T >void DLSolver::backtrackToDeducedEdgesStackSize( size_t size ) { while ( G->undo_stack_deduced_edges.size( ) > size ) { DLEdge * e = G->undo_stack_deduced_edges.back( ); G->undo_stack_deduced_edges.pop_back( ); G->clearShortestPath( e ); } } template< class T >void DLSolver::sendDeductions ( ) { while ( ! (G->heavy_edges).empty() ) { DLEdge *edge = (G->heavy_edges).back( ); (G->heavy_edges).pop_back( ); assert( ! edge->c->hasPolarity( ) ); assert ( ! edge->c->isDeduced ( ) ); // // By construction: positive edges have even id (hence, negative edges have odd id) // edge->c->setDeduced( ( edge->id % 2 ) ? l_False : l_True, id ); deductions.push_back( edge->c ); } } template< class T >void DLSolver::computeModel( ) { G->computeModel( ); } #ifdef PRODUCE_PROOF // // Compute interpolants for the conflict // template Enode * DLSolver::getInterpolants( logic_t & l ) { l = config.logic == QF_IDL || config.logic == QF_UFIDL ? QF_IDL : QF_RDL ; DLVertex< T > * s = G->getNegCycleVertex( ); DLVertex< T > * u = s; DLPath & conflictEdges = G->getConflictEdges( ); assert( conflictEdges.size( ) > 1 ); list< Enode * > in_list; // Set the mask as 1..10 ipartitions_t mask = 1; mask = ~mask; // Scan the various partitions for( unsigned in = 1 ; in < egraph.getNofPartitions( ) ; in ++ ) { // Keeps track of A-chords, to be conjoined at the end list< Enode * > conj; // mask &= ~SETBIT( in ); clrbit( mask, in ); // Compute intermediate interpolants bool A_path = false; bool B_seen = false; bool AB_mixed = false; Enode * i_begin = NULL; Enode * i_end = NULL; T chord_summary = 0; // iterate over conflict - negative cycle do { DLEdge< T > * edge = conflictEdges[ u->id ]; const ipartitions_t & p = edge->c->getIPartitions( ); icolor_t color = I_UNDEF; if ( isABmixed( p ) ) { assert( config.logic == QF_UFLRA || config.logic == QF_UFIDL ); AB_mixed = true; break; } if ( isAB( p, mask ) ) color = I_AB; else if ( isAlocal( p, mask ) ) color = I_A; else if ( isBlocal( p, mask ) ) color = I_B; assert( color == I_A || color == I_AB || color == I_B ); assert( config.proof_set_inter_algo == 0 || config.proof_set_inter_algo == 1 || config.proof_set_inter_algo == 2 ); // McMillan algo: set AB as B if ( config.proof_set_inter_algo == 0 && color == I_AB ) color = I_B; // McMillan' algo: set AB as a else if ( config.proof_set_inter_algo == 2 && color == I_AB ) color = I_A; // Pudlak algo: who cares else if ( config.proof_set_inter_algo == 1 && color == I_AB ) color = I_A; assert( color == I_A || color == I_B ); // Update begin of the chord while itarating through A edges if( color == I_A ) { // If A path is already going just accumulate constant if( A_path ) { // Update last vertex i_end = edge->u->e; chord_summary += edge->wt; } // Otherwise start the A path else { A_path = true; i_begin = edge->v->e; i_end = edge->u->e; chord_summary = edge->wt; } } // Once B edge is discovered there are 3 options: else { // B has been seen -- interpolant is not trivially false B_seen = true; // If an A-path was in progress, create chord if( A_path ) { if ( i_begin && i_end ) conj.push_back( egraph.mkLeq( egraph.cons( egraph.mkMinus( egraph.cons( i_end , egraph.cons( i_begin ) ) ) , egraph.cons( egraph.mkNum( chord_summary ) ) ) ) ); else if ( i_begin ) conj.push_back( egraph.mkLeq( egraph.cons( egraph.mkUminus( egraph.cons( i_begin ) ) , egraph.cons( egraph.mkNum( chord_summary ) ) ) ) ); else if ( i_end ) conj.push_back( egraph.mkLeq( egraph.cons( i_end , egraph.cons( egraph.mkNum( chord_summary ) ) ) ) ); else conj.push_back( egraph.mkFalse( ) ); } // No A-path in progress A_path = false; } // Move to the next edge u = edge->u; } while( s != u ); // If an A-path was in progress, create chord if( A_path ) { if ( i_begin && i_end ) conj.push_back( egraph.mkLeq( egraph.cons( egraph.mkMinus( egraph.cons( i_end , egraph.cons( i_begin ) ) ) , egraph.cons( egraph.mkNum( chord_summary ) ) ) ) ); else if ( i_begin ) conj.push_back( egraph.mkLeq( egraph.cons( egraph.mkUminus( egraph.cons( i_begin ) ) , egraph.cons( egraph.mkNum( chord_summary ) ) ) ) ); else if ( i_end ) conj.push_back( egraph.mkLeq( egraph.cons( i_end , egraph.cons( egraph.mkNum( chord_summary ) ) ) ) ); else conj.push_back( egraph.mkFalse( ) ); } // Conflict is all in A, interpolant is false if ( AB_mixed ) in_list.push_front( egraph.mkFakeInterp( ) ); else if ( !B_seen ) in_list.push_front( egraph.mkFalse( ) ); else in_list.push_front( egraph.mkAnd( egraph.cons( conj ) ) ); } interpolants = egraph.cons( in_list ); return interpolants; } #endif opensmt-2.5.2/src/tsolvers/dlsolver/DLSolver.h000066400000000000000000000054471445011647600213740ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso , Edgar Pek OpenSMT2 -- Copyright (C) 2008-2012, Roberto Bruttomesso 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. *********************************************************************/ #ifndef DLSOLVER_H #define DLSOLVER_H #include "TSolver.h" #include "DLGraph.h" template class DLSolver : public OrdinaryTSolver { public: DLSolver( const int i , const char * n , SMTConfig & c , Egraph & e , SStore & t , vector< Enode * > & x , vector< Enode * > & d , vector< Enode * > & s ) : OrdinaryTSolver ( i, n, c, e, t, x, d, s ) { initGraph(); } ~DLSolver ( ); lbool inform ( Enode * ); bool assertLit ( Enode *, bool = false ); void pushBacktrackPoint ( ); void popBacktrackPoint ( ); bool check ( bool ); bool belongsToT ( Enode * ); void computeModel ( ); #ifdef PRODUCE_PROOF Enode * getInterpolants( logic_t & ); #endif private: typedef vector< DLEdge * > DLPath; void initGraph ( ); void backtrackToDynEdgesStackSize ( size_t ); void backtrackToInactiveEnodesStackSize( size_t ); void backtrackToDeducedEdgesStackSize ( size_t ); void sendDeductions ( ); DLGraph< T > * G; // The graph vector< Enode * > undo_stack_edges; // Keeps track of edges present in a graph vector< size_t > backtrack_points; // Keeps track of backtrack points }; #endif opensmt-2.5.2/src/tsolvers/egraph/000077500000000000000000000000001445011647600171335ustar00rootroot00000000000000opensmt-2.5.2/src/tsolvers/egraph/CMakeLists.txt000066400000000000000000000017001445011647600216710ustar00rootroot00000000000000target_sources(tsolvers PUBLIC "${CMAKE_CURRENT_LIST_DIR}/Egraph.h" PUBLIC "${CMAKE_CURRENT_LIST_DIR}/Enode.h" PUBLIC "${CMAKE_CURRENT_LIST_DIR}/EnodeStore.h" PUBLIC "${CMAKE_CURRENT_LIST_DIR}/CgTypes.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/Enode.cc" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/EnodeStore.cc" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/EgraphSolver.cc" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/EgraphDebug.cc" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/Explainer.cc" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/EgraphModelBuilder.cc" ) target_sources(tsolvers PUBLIC "${CMAKE_CURRENT_LIST_DIR}/UFInterpolator.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/UFInterpolator.cc" PUBLIC "${CMAKE_CURRENT_LIST_DIR}/InterpolatingEgraph.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/InterpolatingEgraph.cc" ) install(FILES ${CMAKE_CURRENT_LIST_DIR}/UFInterpolator.h DESTINATION ${INSTALL_HEADERS_DIR}) install(FILES ${CMAKE_CURRENT_LIST_DIR}/CgTypes.h DESTINATION ${INSTALL_HEADERS_DIR}) opensmt-2.5.2/src/tsolvers/egraph/CgTypes.h000066400000000000000000000026571445011647600206740ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ #ifndef CGTYPES_H #define CGTYPES_H typedef uint32_t cgId; typedef uint32_t dist_t; static cgId const cgId_Nil = 0; static int const maxDistinctClasses = 8*sizeof(dist_t); #endif opensmt-2.5.2/src/tsolvers/egraph/Egraph.h000066400000000000000000000370261445011647600205220ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #ifndef EGRAPH_H #define EGRAPH_H // FIXME: make as configure option #define MORE_DEDUCTIONS 0 #include "Timer.h" #include "SStore.h" #include "EnodeStore.h" #include "Enode.h" #include "TSolver.h" #include "SymStore.h" #include "PtStore.h" #include "Explainer.h" #ifdef PEDANTIC_DEBUG #include "GCTest.h" #endif #include class UFSolverStats { public: opensmt::OSMTTimeVal egraph_asrt_timer; opensmt::OSMTTimeVal egraph_backtrack_timer; opensmt::OSMTTimeVal egraph_explain_timer; int num_eq_classes; UFSolverStats() : num_eq_classes(0) {} void printStatistics(std::ostream & os) { os << "; egraph time..............: " << egraph_asrt_timer.getTime() << " s\n"; os << "; backtrack time...........: " << egraph_backtrack_timer.getTime() << " s\n"; os << "; explain time.............: " << egraph_explain_timer.getTime() << " s\n"; os << "; # eq classes at the end..: " << num_eq_classes << "\n"; } }; /* * Holds parents of a congruence class of terms: for a congruence class c its UseVector contains all terms p such that * some child of p belongs to c. * Moreover, if p's index in UseVector is i then p.getIndex(t) returns i for p's child t. */ class UseVector { /* First two bits represent tag: 00 - valid entry, 01 - marked entry, 11 - empty entry * In case of valid and marked entry, the data is ERef, in case of empty entry, the data is next free entry. * This data structure is a vector possibly containing a free list inside */ struct Entry { private: uint32_t data; public: static const uint32_t VALID_MASK = 0x00; // 00 static const uint32_t MARKED_MASK = 0x01; // 01 static const uint32_t FREE_MASK = 0x03; // 11 static const uint32_t TAG_MASK = 0x03; // bit mask to get the two least significant bits static const uint32_t FREE_ENTRY_LIST_GUARD = (static_cast(-1)) >> 2; // MB: This packing tag and data together means that the value of ERef is restricted to 2^30. // This is not an issue for the current benchmarks we are dealing with explicit Entry(ERef e): data{e.x << 2} { } explicit Entry(uint32_t i): data{i << 2} { } Entry(int) = delete; Entry() : data{0} {} inline bool isFree() const { return (data & TAG_MASK) == FREE_MASK; } inline bool isValid() const { return (data & TAG_MASK) == VALID_MASK; } inline bool isMarked() const { return (data & TAG_MASK) == MARKED_MASK; } inline void mark() { assert(isValid()); data &= ~TAG_MASK; data |= MARKED_MASK; assert(isMarked()); } inline void unmark() { assert(isMarked()); data &= ~TAG_MASK; assert(isValid()); } inline void free() { data |= FREE_MASK; } inline uint32_t getData() const { return data >> 2;} }; static_assert(sizeof(Entry) == 4, "Entry is not of expected size!"); std::vector data; uint32_t free; // pointer to head of a free list, FREE_ENTRY_LIST_GUARD means no free list uint32_t nelems; // the real number of elements; using iterator = decltype(data)::iterator; using const_iterator = decltype(data)::const_iterator; public: UseVector() : data{}, free{Entry::FREE_ENTRY_LIST_GUARD}, nelems{0} {} uint32_t size() const { return nelems; } uint32_t addParent(ERef parent); void clearEntryAt(int index); void markEntry(Entry& entry); void unMarkEntry(Entry& entry); iterator begin() { return data.begin(); } iterator end() { return data.end(); } const_iterator begin() const { return data.cbegin(); } const_iterator end() const { return data.cend(); } static Entry erefToEntry(ERef e) { assert(e.x >> 30 == 0); return Entry(e); } static ERef entryToERef(Entry e) { assert(e.isValid()); uint32_t val = e.getData(); return ERef{val}; } static uint32_t freeEntryToIndex(Entry e) { assert(e.isFree()); uint32_t val = e.getData(); return val; } static Entry indexToFreeEntry(uint32_t index) { assert(index >> 30 == 0); Entry ret(index); ret.free(); return ret; } const Entry& operator[](unsigned index) const { assert(index < data.size()); return data[index]; } private: uint32_t getFreeSlotIndex(); }; class Egraph : public TSolver { protected: Logic & logic; enum class ExplainerType { CLASSIC, INTERPOLATING }; std::unique_ptr explainer; friend class EgraphModelBuilder; friend class ArraySolver; private: /* * fields and methods related to parent vectors */ //*************************************************************************************************************** std::vector parents; void addToUseVectors(ERef); void ensureUseVectorFor(ERef); void removeFromUseVectorsExcept(ERef parent, CgId cgid); void removeFromUseVectors(ERef parent); unsigned getParentsSize(ERef ref) { assert(getEnode(ref).getCid() < parents.size()); return parents[getEnode(ref).getCid()].size(); } bool childDuplicatesClass(ERef parent, uint32_t childIndex); //*************************************************************************************************************** Map termToNegatedERef; ELAllocator forbid_allocator; EnodeStore enode_store; bool isEffectivelyEquality(PTRef tr) const; bool isEffectivelyUP(PTRef tr) const; bool isEffectivelyDisequality(PTRef tr) const; double fa_garbage_frac; UFSolverStats egraphStats; class Values { Map values; Map valueERefToInt; int valueCounter; public: Values() : valueCounter(0) {} void addValue(ERef t, ERef v) { if (values.has(t)) return; values.insert(t, v); if (not valueERefToInt.has(v)) { valueERefToInt.insert(v, valueCounter++); } } bool hasValue(ERef er) const { return values.has(er); } ERef getValue(ERef er) const { assert(values.has(er)); return values[er]; } int getValueIndex(ERef er) const { assert(valueERefToInt.has(er)); return valueERefToInt[er]; } }; std::unique_ptr values; static const char * s_val_prefix; static const char * s_const_prefix; static const char * s_any_prefix; static const char * s_val_true; static const char * s_val_false; protected: Egraph(SMTConfig & c, Logic & l, ExplainerType explainerType); public: Egraph(SMTConfig & c, Logic & l); virtual ~Egraph() { #ifdef STATISTICS printStatistics(std::cerr); #endif // STATISTICS } void clearSolver() override { clearModel(); } // Only clear the possible computed values protected: inline Enode & getEnode(ERef er) { return enode_store[er]; } public: inline const Enode & getEnode(ERef er) const { return enode_store[er]; } PTRef ERefToTerm(ERef er) const { return getEnode(er).getTerm(); } ERef termToERef(PTRef p) const { return enode_store.getERef(p); } ERef getRoot(ERef er) const { return getEnode(er).getRoot(); } bool isConstant(ERef er) const { return logic.isConstant(getEnode(er).getTerm()); } bool isValid(PTRef tr) override { return logic.isTheoryEquality(tr) || logic.isUP(tr) || logic.isDisequality(tr); } #ifdef STATISTICS void printMemStats (ostream &); #endif void computePolarities (ERef); //=========================================================================== // Public APIs for Theory Combination with DTC void gatherInterfaceTerms (ERef); int getInterfaceTermsNumber (); ERef getInterfaceTerm (const int); bool isRootUF (ERef); ERef canonizeDTC (ERef, bool = false); Logic& getLogic() override { return logic; } public: //=========================================================================== // Public APIs for Egraph Core Solver bool assertLit (PtAsgn) override; void pushBacktrackPoint () override; // Push a backtrack point void popBacktrackPoint () override; // Backtrack to last saved point PTRef getSuggestion (); // Return a suggested literal based on the current state lbool getPolaritySuggestion (PTRef); // Return a suggested polarity for a given literal void getConflict (vec &) override; TRes check (bool) override { return TRes::SAT; }// Check satisfiability void computeModel () override; void fillTheoryFunctions (ModelBuilder & modelBuilder) const override; void clearModel (); vec collectEqualitiesFor(vec const & vars, std::unordered_set const & knownEqualities) override; void printStatistics (std::ostream &) override; #if MORE_DEDUCTIONS bool deduceMore ( vector< ERef > & ); #endif private: // // Defines the set of operations that can be performed and that should be undone // typedef enum { // These constants are stored on undo_stack_oper when CONS // An undoable cons is done , MERGE // A merge is done , DISEQ // A negated equality is asserted , DIST // A distinction is asserted , EXPL // Explanation added , REANALYZE // A term added after init need to be reanalyzed , SET_POLARITY // A polarity of a PTRef was set , UNDEF_OP // A dummy value for default constructor #if MORE_DEDUCTIONS , ASSERT_NEQ #endif } oper_t; class Undo { public: oper_t oper; union arg_t { PTRef ptr; ERef er; } arg; Undo(oper_t o, PTRef r) : oper(o) { arg.ptr = r; } Undo(oper_t o, ERef r) : oper(o) { arg.er = r; } Undo() : oper(UNDEF_OP) { arg.ptr = PTRef_Undef; } #ifdef VERBOSE_EUF ERef merged_with; PTRef bool_term; #endif }; //=========================================================================== // Private Routines for Core Theory Solver // // Asserting literals // public: bool addDisequality ( PtAsgn ); bool addEquality ( PtAsgn ); bool addTrue ( PTRef ); bool addFalse ( PTRef ); void declareAtom(PTRef) override; // Non-recursive declare term void declareTerm (PTRef); private: std::unordered_set declared; void declareTermRecursively(PTRef); bool assertEq (PTRef, PTRef, PtAsgn); // Asserts an equality bool assertEq (ERef, ERef, PtAsgn); // Called by the above bool assertNEq (PTRef, PTRef, Expl const & r); // Asserts a negated equality bool assertNEq (ERef, ERef, Expl const & r); // Called by the above bool assertDist ( PTRef, PtAsgn); // Asserts a distinction // // Backtracking // void backtrackToStackSize ( size_t ); // Backtrack to a certain operation // // Congruence closure main routines // bool unmergeable ( ERef, ERef, Expl& ) const; // Can two nodes be merged ? void merge ( ERef, ERef, PtAsgn ); // Merge two nodes bool mergeLoop ( PtAsgn reason ); // Merge loop void deduce ( ERef, ERef, PtAsgn ); // Deduce from merging of two nodes (record the reason) void undoMerge ( ERef ); // Undoes a merge void undoDisequality ( ERef ); // Undoes a disequality void undoDistinction ( PTRef ); // Undoes a distinction vec> pending; // Pending merges vec undo_stack_main; // Keeps track of terms involved in operations void reanalyze(ERef); void doExplain(ERef, ERef, PtAsgn); // Explain why the Enodes are equivalent when PtAsgn says it should be different void explainConstants(ERef, ERef); //============================================================================ // Memory management for forbid allocator void faGarbageCollect(); inline void checkFaGarbage(void) { return checkFaGarbage(fa_garbage_frac); } inline void checkFaGarbage(double gf) { if (forbid_allocator.wasted() > forbid_allocator.size() * gf) faGarbageCollect(); } void relocAll(ELAllocator&); //============================================================================ //=========================================================================== // Debugging routines - Implemented in EgraphDebug.C public: std::string printEqClass (PTRef tr) const; std::string printDistinctions (PTRef tr) const; std::string printExplanation (PTRef tr) const { return printExplanationTreeDotty(enode_store.getERef(tr)); } private: std::string toString (ERef er) const; public: std::string printExplanationTreeDotty(ERef) const; private: const std::string printDistinctionList( ELRef, ELAllocator& ela, bool detailed = true ); void checkForbidReferences ( ERef ); void checkRefConsistency ( ); // Helper methods void mergeForbidLists(ERef to, const Enode & from); void unmergeForbidLists(ERef to, const Enode & from); static void mergeDistinctionClasses(Enode & to, const Enode & from); static void unmergeDistinctionClasses(Enode & to, const Enode & from); void mergeEquivalenceClasses(ERef newroot, ERef oldroot); void unmergeEquivalenceClasses(ERef newroot, ERef oldroot); void processParentsBeforeMerge(ERef mergedRoot); void processParentsAfterMerge(ERef mergedRoot); void processParentsBeforeUnMerge(ERef oldroot); void processParentsAfterUnMerge(ERef oldroot); }; #endif opensmt-2.5.2/src/tsolvers/egraph/EgraphDTC.cc000066400000000000000000000322771445011647600212160ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #include "Egraph.h" #include "LA.h" int Egraph::getInterfaceTermsNumber( ) { return interface_terms.size( ); } Enode * Egraph::getInterfaceTerm( const int n ) { assert( n < static_cast< int >( interface_terms.size( ) ) ); return interface_terms[ n ]; } void Egraph::gatherInterfaceTerms( Enode * e ) { assert( config.sat_lazy_dtc != 0 ); assert( config.logic == QF_UFIDL || config.logic == QF_UFLRA ); assert( e ); if ( config.verbosity > 2 ) cerr << "# Egraph::Gathering interface terms" << endl; vector< Enode * > unprocessed_enodes; initDup1( ); unprocessed_enodes.push_back( e ); // // Visit the DAG of the term from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( isDup1( enode ) ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( !isDup1( arg ) ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); // // At this point, every child has been processed // if ( enode->isUFOp( ) ) { // Retrieve arguments for ( Enode * arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); // This is for sure an interface term if ( ( arg->isArithmeticOp( ) || arg->isConstant( ) ) && interface_terms_cache.insert( arg ).second ) { interface_terms.push_back( arg ); if ( config.verbosity > 2 ) cerr << "# Egraph::Added interface term: " << arg << endl; } // We add this variable to the potential // interface terms or to interface terms if // already seen in LA else if ( arg->isVar( ) || arg->isConstant( ) ) { if ( it_la.find( arg ) == it_la.end( ) ) it_uf.insert( arg ); else if ( interface_terms_cache.insert( arg ).second ) { interface_terms.push_back( arg ); if ( config.verbosity > 2 ) cerr << "# Egraph::Added interface term: " << arg << endl; } } } } if ( enode->isArithmeticOp( ) && !isRootUF( enode ) ) { // Retrieve arguments for ( Enode * arg_list = enode->getCdr( ) ; !arg_list->isEnil( ) ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); // This is for sure an interface term if ( arg->isUFOp( ) && interface_terms_cache.insert( arg ).second ) { interface_terms.push_back( arg ); if ( config.verbosity > 2 ) cerr << "# Egraph::Added interface term: " << arg << endl; } // We add this variable to the potential // interface terms or to interface terms if // already seen in UF else if ( arg->isVar( ) || arg->isConstant( ) ) { if ( it_uf.find( arg ) == it_uf.end( ) ) it_la.insert( arg ); else if ( interface_terms_cache.insert( arg ).second ) { interface_terms.push_back( arg ); if ( config.verbosity > 2 ) cerr << "# Egraph::Added interface term: " << arg << endl; } } } } assert( !isDup1( enode ) ); storeDup1( enode ); } doneDup1( ); } #ifdef PRODUCE_PROOF void Egraph::getInterfaceVars( Enode * e, set< Enode * > & iv ) { assert( config.produce_inter != 0 ); assert( config.sat_lazy_dtc != 0 ); assert( config.logic == QF_UFIDL || config.logic == QF_UFLRA ); assert( e ); vector< Enode * > unprocessed_enodes; initDup1( ); unprocessed_enodes.push_back( e ); // // Visit the DAG of the term from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( isDup1( enode ) ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( !isDup1( arg ) ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); if ( enode->isVar( ) && interface_terms_cache.find( enode ) != interface_terms_cache.end( ) ) iv.insert( enode ); assert( !isDup1( enode ) ); storeDup1( enode ); } doneDup1( ); } #endif // // Check if the subformula is purely // bool Egraph::isPureLA( Enode * e ) { assert( config.sat_lazy_dtc != 0 ); assert( config.logic == QF_UFIDL || config.logic == QF_UFLRA ); assert( e ); vector< Enode * > unprocessed_enodes; initDup1( ); unprocessed_enodes.push_back( e ); // // Visit the DAG of the term from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( isDup1( enode ) ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( !isDup1( arg ) ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); // // At this point, every child has been processed // if ( enode->isUFOp( ) ) { doneDup1( ); return false; } assert( !isDup1( enode ) ); storeDup1( enode ); } doneDup1( ); return true; } bool Egraph::isPureUF( Enode * e ) { assert( config.sat_lazy_dtc != 0 ); assert( config.logic == QF_UFIDL || config.logic == QF_UFLRA ); assert( e ); vector< Enode * > unprocessed_enodes; initDup1( ); unprocessed_enodes.push_back( e ); // // Visit the DAG of the term from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( isDup1( enode ) ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( !isDup1( arg ) ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); // // At this point, every child has been processed // if ( enode->isArithmeticOp( ) ) { doneDup1( ); return false; } assert( !isDup1( enode ) ); storeDup1( enode ); } doneDup1( ); return true; } bool Egraph::isRootUF( Enode * e ) { assert( e ); assert( config.sat_lazy_dtc != 0 ); assert( config.logic == QF_UFIDL || config.logic == QF_UFLRA ); // // Makes sense only for TAtoms // if ( !e->isTAtom( ) ) return false; // // There is an arithmetic operator // if ( e->isArithmeticOp( ) && !e->isEq( ) ) return false; // // Uninterpreted predicates are OK // if ( e->isUp( ) ) return true; assert( e->isEq( ) ); Enode * x = e->get1st( ); Enode * y = e->get2nd( ); // // We want equalities of the form x=y // if ( x->isArithmeticOp( ) || y->isArithmeticOp( ) ) return false; // // And they also have to have at least a member // that is not interface // if ( interface_terms_cache.find( x ) == interface_terms_cache.end( ) || interface_terms_cache.find( y ) == interface_terms_cache.end( ) ) return true; return false; } Enode * Egraph::canonizeDTC( Enode * formula , bool split_eqs ) { assert( config.sat_lazy_dtc != 0 ); assert( config.logic == QF_UFLRA || config.logic == QF_UFIDL ); list< Enode * > dtc_axioms; vector< Enode * > unprocessed_enodes; initDupMap1( ); unprocessed_enodes.push_back( formula ); // // Visit the DAG of the formula from the leaves to the root // while( !unprocessed_enodes.empty( ) ) { Enode * enode = unprocessed_enodes.back( ); // // Skip if the node has already been processed before // if ( valDupMap1( enode ) != NULL ) { unprocessed_enodes.pop_back( ); continue; } bool unprocessed_children = false; Enode * arg_list; for ( arg_list = enode->getCdr( ) ; arg_list != enil ; arg_list = arg_list->getCdr( ) ) { Enode * arg = arg_list->getCar( ); assert( arg->isTerm( ) ); // // Push only if it is unprocessed // if ( valDupMap1( arg ) == NULL ) { unprocessed_enodes.push_back( arg ); unprocessed_children = true; } } // // SKip if unprocessed_children // if ( unprocessed_children ) continue; unprocessed_enodes.pop_back( ); Enode * result = NULL; // // Replace arithmetic atoms with canonized version // if ( enode->isTAtom( ) && !enode->isUp( ) ) { // No need to do anything if node is purely UF if ( isRootUF( enode ) ) { if ( config.verbosity > 2 ) cerr << "# Egraph::Skipping canonization of " << enode << " as it's root is purely UF" << endl; result = enode; } else { LAExpression a( enode ); result = a.toEnode( *this ); if ( split_eqs && result->isEq( ) ) { #ifdef PRODUCE_PROOF if ( config.produce_inter != 0 ) opensmt_error2( "can't compute interpolant for equalities at the moment ", enode ); #endif LAExpression aa( enode ); Enode * e = aa.toEnode( *this ); Enode * lhs = e->get1st( ); Enode * rhs = e->get2nd( ); Enode * leq = mkLeq( cons( lhs, cons( rhs ) ) ); LAExpression b( leq ); leq = b.toEnode( *this ); Enode * geq = mkGeq( cons( lhs, cons( rhs ) ) ); LAExpression c( geq ); geq = c.toEnode( *this ); Enode * not_e = mkNot( cons( enode ) ); Enode * not_l = mkNot( cons( leq ) ); Enode * not_g = mkNot( cons( geq ) ); // Add clause ( !x=y v x<=y ) Enode * c1 = mkOr( cons( not_e , cons( leq ) ) ); // Add clause ( !x=y v x>=y ) Enode * c2 = mkOr( cons( not_e , cons( geq ) ) ); // Add clause ( x=y v !x>=y v !x<=y ) Enode * c3 = mkOr( cons( enode , cons( not_l , cons( not_g ) ) ) ); // Add conjunction of clauses Enode * ax = mkAnd( cons( c1 , cons( c2 , cons( c3 ) ) ) ); dtc_axioms.push_back( ax ); result = enode; } } } // // If nothing have been done copy and simplify // if ( result == NULL ) result = copyEnodeEtypeTermWithCache( enode ); assert( valDupMap1( enode ) == NULL ); storeDupMap1( enode, result ); } Enode * new_formula = valDupMap1( formula ); assert( new_formula ); doneDupMap1( ); if ( !dtc_axioms.empty( ) ) { dtc_axioms.push_back( new_formula ); new_formula = mkAnd( cons( dtc_axioms ) ); } return new_formula; } opensmt-2.5.2/src/tsolvers/egraph/EgraphDebug.cc000066400000000000000000000144171445011647600216260ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #include "Egraph.h" #include class SimpSMTSolver; // Choose debugging level #define CHECK_INVARIANTS 1 #define CHECK_INVARIANT_FORBID_LIST_SYMMERTRY 0 #define CHECK_INVARIANT_SIGNATURE_TABLE_CORRECTNESS 1 #define CHECK_EXPLANATIONS 0 //============================================================================= // Printing Routines std::string Egraph::printEqClass(PTRef tr) const { std::stringstream out; const ERef er = enode_store.getERef(tr); ERef c_er = er; out << "In the same eq class with " << logic.printTerm(tr) << " are:\n[ "; while (true) { Enode const & en = getEnode(c_er); ERef next_er = en.getEqNext(); if (next_er == er) break; Enode const & en_o = getEnode(next_er); out << logic.printTerm(en_o.getTerm()) << ' '; } out << "]"; return out.str(); } std::string Egraph::printExplanationTreeDotty(ERef x) const { std::stringstream os; os << "digraph expl" << '\n'; os << "{" << '\n'; while ( x != ERef_Undef ) { std::string name = toString(x); os << name; if (getEnode(x).getExpParent() != ERef_Undef) os << " -> "; x = getEnode(x).getExpParent(); } os << '\n' << "}" << '\n'; return os.str(); } std::string Egraph::printDistinctions(PTRef x) const { if (x == PTRef_Undef) { assert(false); return ""; } std::stringstream out; out << "In different eq class with " << logic.printTerm(x) << " are:\n[ "; const ERef er = enode_store[enode_store.getERef(x)].getRoot(); ELRef elr = enode_store[er].getForbid(); if (elr == ELRef_Undef) { out << ']'; return out.str(); } ELRef c_elr = elr; while (true) { const Elist& el = forbid_allocator[c_elr]; ELRef next_elr = el.link; const Elist& el_o = forbid_allocator[next_elr]; out << logic.printTerm(enode_store[el_o.e].getTerm()) << ' '; if (next_elr == elr) break; c_elr = next_elr; } out << ']'; return out.str(); } const std::string Egraph::printDistinctionList( ELRef x, ELAllocator& ela, bool detailed ) { if ( x == ELRef_Undef ) return "(undef)"; std::stringstream os; ELRef start = x; do { if (detailed) { os << "+-----------------------------------------------------------+" << '\n' << "| Forbid list node |" << '\n' << "+-----------------------------------------------------------+" << '\n' << "| ELRef: " << x.x << '\n' << "| id: " << ela[x].getId() << '\n' << "| dirty: " << ela[x].isDirty() << '\n' << "| reason: " << (ela[x].reason.pta.sgn == l_True ? "" : "not " ) << logic.printTerm(ela[x].reason.pta.tr) << '\n'; if (ela[x].reloced()) os << "| reloced to: " << ela[x].rel_e.x << '\n'; else { os << "| different from enode " << ela[x].e.x << '\n'; os << "| term " << logic.printTerm(enode_store[ela[x].e].getTerm()) << '\n'; } os << "| link: " << ela[x].link.x << '\n'; } else { os << "+-----------------------------------------------------------+" << '\n' << "| Forbid list node |" << '\n' << "+-----------------------------------------------------------+" << '\n' << "| reason: " << (ela[x].reason.pta.sgn == l_True ? "" : "not " ) << logic.printTerm(ela[x].reason.pta.tr) << '\n'; os << "| different from enode " << ela[x].e.x << '\n'; os << "| term " << logic.printTerm(enode_store[ela[x].e].getTerm()) << '\n'; } os << "+-----------------------------------------------------------+" << '\n'; x = ela[x].link; } while( x != start ); return os.str(); } void Egraph::checkForbidReferences(ERef er) { ELRef start = enode_store[er].getForbid(); if (start == ELRef_Undef) return; ELRef er_old = start; do { Elist& e_old = forbid_allocator[er_old]; for (int j = 0; j < forbid_allocator.referenced_by[e_old.getId()].size(); j++) { assert (e_old.e != forbid_allocator.referenced_by[e_old.getId()][j]); } } while (start != er_old); } void Egraph::checkRefConsistency() { for (unsigned int i = 0; i < static_cast(forbid_allocator.referenced_by.size()); i++) { vec& referers = forbid_allocator.referenced_by[i]; for (int j = 0; j < referers.size(); j++) { ERef referer = referers[j]; if (referer == ERef_Undef) continue; assert(forbid_allocator[enode_store[referer].getForbid()].getId() == i); } } } std::string Egraph::toString(ERef er) const { if (er == ERef_Undef) { return "undef"; } const Enode & node = getEnode(er); return logic.printTerm(node.getTerm()); } opensmt-2.5.2/src/tsolvers/egraph/EgraphModelBuilder.cc000066400000000000000000000123621445011647600231440ustar00rootroot00000000000000/* * Copyright (c) 2021, Antti Hyvarinen * Copyright (c) 2021, Martin Blicha * * SPDX-License-Identifier: MIT */ #include "EgraphModelBuilder.h" #include "ArithLogic.h" #include "ModelBuilder.h" #include Map EgraphModelBuilder::computeNumericValues(ModelBuilder const & model) const { ArithLogic & arithLogic = dynamic_cast(logic); Map updatedValues; std::unordered_set delayedNumericTerms; FastRational maxModelValue = 0; auto updateMaxValue = [&maxModelValue](FastRational const & newVal) { if (newVal > maxModelValue) { maxModelValue = newVal; } }; for (ERef eref : enode_store.getTermEnodes()) { ERef root = values.getValue(eref); PTRef ptref_root = enode_store.getPTRef(root); if (not arithLogic.yieldsSortNum(ptref_root)) { continue; } if (updatedValues.has(root)) { continue; } if (arithLogic.isNumConst(ptref_root)) { updatedValues.insert(root, ptref_root); updateMaxValue(arithLogic.getNumConst(ptref_root)); continue; } PTRef ptref = enode_store.getPTRef(eref); if (logic.isVar(ptref) and model.hasVarVal(ptref)) { PTRef value = model.getVarVal(ptref); assert(arithLogic.isNumConst(value)); updatedValues.insert(root, value); updateMaxValue(arithLogic.getNumConst(value)); delayedNumericTerms.erase(root); continue; } delayedNumericTerms.insert(root); // continue with next Enode } for (ERef delayedTerm : delayedNumericTerms) { FastRational nextValue = maxModelValue + 1; SRef sort = logic.getSortRef(getEnode(delayedTerm).getTerm()); if (arithLogic.isSortInt(sort)) { nextValue = nextValue.floor(); } updatedValues.insert(delayedTerm, arithLogic.mkConst(sort, nextValue)); maxModelValue = nextValue; } return updatedValues; } /** * Add an evaluation for the function symbol of orig_tr using the value of target_er * @param modelBuilder The model builder * @param orig_tr the original pterm reference (with arity > 0) * @param target_er the target enode reference * @param substs the substitutions (used for obtaining values for the arguments of orig_tr */ void EgraphModelBuilder::addTheoryFunctionEvaluation(ModelBuilder & modelBuilder, PTRef orig_tr, ERef target_er) { ERef orig_er = enode_store.getERef(orig_tr); Enode const & orig_enode = getEnode(orig_er); assert(orig_enode.getSize() > 0); vec vals; vals.capacity(orig_enode.getSize()); for (ERef child_er : orig_enode) { PTRef child_tr = enode_store.getPTRef(child_er); vals.push(getAbstractValueForERef(child_er,logic.getSortRef(child_tr))); } modelBuilder.addToTheoryFunction(logic.getSymRef(orig_tr), vals, getAbstractValueForERef(target_er, logic.getSortRef(orig_tr))); } void EgraphModelBuilder::fill(ModelBuilder & modelBuilder) && { if (hasArithmetic()) { auto numericValues = computeNumericValues(modelBuilder); for (auto [key, val] : numericValues.getKeysAndVals()) { if (val != PTRef_Undef) { assert(not rootValues.has(key)); rootValues.insert(key, val); } } } for (ERef er : enode_store.getTermEnodes()) { PTRef tr = enode_store.getPTRef(er); if (logic.hasSortBool(tr) and (not logic.isUP(tr))) { continue; // The Boolean return sorted terms that are not uninterpreted predicates come from the SAT solver } // Check that enode_store's PTRef -> ERef conversion is consistent assert(([&](PTRef tr) { ERef tmp; enode_store.peekERef(tr, tmp); return tmp == er; })(tr)); assert(not logic.isIte(tr)); if ((logic.isVar(tr) or logic.isConstant(tr)) and logic.yieldsSortUninterpreted(tr)) { PTRef val_tr = getAbstractValueForERef(er, logic.getSortRef(tr)); modelBuilder.addVarValue(tr, val_tr); } else if (logic.isVar(tr) and not modelBuilder.hasVarVal(tr)) { PTRef val_tr = getAbstractValueForERef(er, logic.getSortRef(tr)); modelBuilder.addVarValue(tr, val_tr); } else if (logic.isUF(tr)) { addTheoryFunctionEvaluation(modelBuilder, tr, er); } } } /** * Get the abstract value (name of an element of the universe) corresponding to er. * If er is ERef_Undef, use the default element for the sort sr * @param er * @param sr the sort of er * @return */ PTRef EgraphModelBuilder::getAbstractValueForERef(ERef er, SRef sr) { if (er == ERef_Undef) { return logic.getDefaultValuePTRef(sr); } ERef val_er = values.getValue(er); PTRef val_tr = enode_store.getPTRef(val_er); assert(sr == logic.getSortRef(val_tr)); if (logic.isConstant(val_tr)) { return val_tr; } if (rootValues.has(val_er)) { return rootValues[val_er]; } std::stringstream ss; ss << Logic::s_abstract_value_prefix << values.getValueIndex(val_er); PTRef newVal = logic.mkConst(sr, ss.str().c_str()); rootValues.insert(val_er, newVal); return newVal; } opensmt-2.5.2/src/tsolvers/egraph/EgraphModelBuilder.h000066400000000000000000000020171445011647600230020ustar00rootroot00000000000000/* * Copyright (c) 2021, Antti Hyvarinen * Copyright (c) 2021, Martin Blicha * * SPDX-License-Identifier: MIT */ #ifndef OPENSMT_EGRAPHMODELBUILDER_H #define OPENSMT_EGRAPHMODELBUILDER_H #include "Egraph.h" class EgraphModelBuilder { Logic & logic; Egraph::Values & values; EnodeStore const & enode_store; Map rootValues; public: EgraphModelBuilder(Egraph const & owner) : logic(owner.logic), values(*owner.values), enode_store(owner.enode_store) {} void fill(ModelBuilder & modelBuilder) &&; private: bool hasArithmetic() const { return logic.hasIntegers() or logic.hasReals(); } void addTheoryFunctionEvaluation(ModelBuilder & modelBuilder, PTRef tr, ERef er); Map computeNumericValues (ModelBuilder const &) const; PTRef getAbstractValueForERef (ERef er, SRef sr); Enode const & getEnode(ERef ref) const { return enode_store[ref]; } }; #endif //OPENSMT_EGRAPHMODELBUILDER_H opensmt-2.5.2/src/tsolvers/egraph/EgraphSolver.cc000066400000000000000000001611111445011647600220440ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ /******************************************************************** The algorithm and data structures are inspired by the following paper: @article{Detlefs:2005:STP:1066100.1066102, author = {Detlefs, David and Nelson, Greg and Saxe, James B.}, title = {Simplify: A Theorem Prover for Program Checking}, journal = {J. ACM}, issue_date = {May 2005}, volume = {52}, number = {3}, month = may, year = {2005}, issn = {0004-5411}, pages = {365--473}, numpages = {109}, url = {http://doi.acm.org/10.1145/1066100.1066102}, doi = {10.1145/1066100.1066102}, acmid = {1066102}, publisher = {ACM}, address = {New York, NY, USA}, keywords = {Theorem proving, decision procedures, program checking}, } The important part describing the merge and its undo is described in section 7 - The E-graph in Detail The following changes have been made to the merge algorithm: Old signatures are no longer removed from the table of signatures (also they now don't have to be reinserted back in undo) This means that the table can grow in memory but we can skip the whole 5.2 from the merge, so we save one whole pass through the parents. *********************************************************************/ #include "Egraph.h" #include "EgraphModelBuilder.h" #include "Enode.h" #include "TreeOps.h" #include "Deductions.h" #include "ModelBuilder.h" static SolverDescr descr_uf_solver("UF Solver", "Solver for Quantifier Free Theory of Uninterpreted Functions with Equalities"); const char* Egraph::s_val_prefix = "u"; const char* Egraph::s_const_prefix = "n"; const char* Egraph::s_any_prefix = "a"; const char* Egraph::s_val_true = "true"; const char* Egraph::s_val_false = "false"; Egraph::Egraph(SMTConfig & c, Logic & l) : Egraph(c,l,ExplainerType::CLASSIC) {} Egraph::Egraph(SMTConfig & c, Logic & l, ExplainerType explainerType) : TSolver (descr_uf_solver, descr_uf_solver, c) , logic (l) , enode_store ( logic ) , fa_garbage_frac ( 0.5 ) , values ( nullptr ) { auto rawExplainer = [this](ExplainerType type) -> Explainer * { switch(type) { case ExplainerType::CLASSIC: { return new Explainer(enode_store); } case ExplainerType::INTERPOLATING: { return new InterpolatingExplainer(enode_store); } default: { return new Explainer(enode_store); } } }(explainerType); explainer.reset(rawExplainer); } // // Pushes a backtrack point // void Egraph::pushBacktrackPoint( ) { // Save solver state if required backtrack_points.push( undo_stack_main.size( ) ); TSolver::pushBacktrackPoint(); } // // Pops a backtrack point // void Egraph::popBacktrackPoint() { // opensmt::StopWatch sw(egraphStats.egraph_backtrack_timer); assert( backtrack_points.size( ) > 0 ); size_t undo_stack_new_size = backtrack_points.last(); backtrack_points.pop(); backtrackToStackSize( undo_stack_new_size ); // Restore deduction next TSolver::popBacktrackPoint(); } // // Returns a suggestion // PTRef Egraph::getSuggestion( ) { // Communicate suggestion while ( suggestions.size() != 0 ) { PTRef tr = suggestions.last(); suggestions.pop(); if ( hasPolarity(tr) ) continue; return tr; } // We have already returned all // the possible suggestions return PTRef_Undef; } lbool Egraph::getPolaritySuggestion(PTRef p) { if (!isInformed(p)) { return l_Undef; } // MB: it could be uninterpreted predicate! No suggestion in that case if (!logic.isEquality(p) && !logic.isDisequality(p)) { return l_Undef; } bool equality = logic.isEquality(p); Pterm const & term = logic.getPterm(p); if (term.size() > 2) { return l_Undef; } // For now focus on 2 arguments PTRef lhs = term[0]; PTRef rhs = term[1]; // isInformed may be `true` for an equality term but `false` for its argument terms when the equality is over // Booleans (and therefore handled by the SAT solver), and appears inside an uninterpreted function. if (!enode_store.has(lhs) || !enode_store.has(rhs)) { return l_Undef; } ERef e_lhs = termToERef(lhs); ERef e_rhs = termToERef(rhs); if (getEnode(e_lhs).getRoot() == getEnode(e_rhs).getRoot()) { // Already in the same equivalence class, avoid conflict return equality ? l_True : l_False; } Expl tmp; bool res = unmergeable(getEnode(e_lhs).getRoot(), getEnode(e_rhs).getRoot(), tmp); if (res) { // they are unmergable so don't assert equality return equality ? l_False : l_True; } // no decision return l_Undef; } // // Communicate conflict // void Egraph::getConflict(vec & conflict) { for (PtAsgn lit : explanation) { conflict.push(lit); } #ifdef STATISTICS if (conflict.size() > generalTSolverStats.max_conf_size) generalTSolverStats.max_conf_size = conflict.size(); if (conflict.size() < generalTSolverStats.min_conf_size) generalTSolverStats.min_conf_size = conflict.size(); generalTSolverStats.conflicts_sent ++; generalTSolverStats.avg_conf_size += conflict.size(); #endif } void Egraph::clearModel() { values.reset(nullptr); } void Egraph::computeModel( ) { if (values != nullptr) return; values = std::make_unique(); for (ERef er : enode_store.getTermEnodes()) { ERef root_r = enode_store[er].getRoot(); values->addValue(er, root_r); } } void Egraph::fillTheoryFunctions(ModelBuilder & modelBuilder) const { EgraphModelBuilder(*this).fill(modelBuilder); } void Egraph::declareAtom(PTRef atom) { if (!enode_store.needsEnode(atom)) { return; } if (isInformed(atom)) { return; } declareTermRecursively(atom); setInformed(atom); } void Egraph::declareTermRecursively(PTRef tr) { if (declared.find(tr) != declared.end()) { return; } // already declared const Pterm& term = logic.getPterm(tr); // declare first the childen and then the current term assert(not logic.isIte(tr)); for (PTRef child : term) { declareTermRecursively(child); } if (enode_store.needsEnode(tr)) { // Only mark as declared if declareTerm actually declared the term. This is important since whether // tr needs an enode could change after incremental calls in surprising ways as a result of simplifications. declareTerm(tr); declared.insert(tr); } } /** * Adds the term to the solver taking into account the arguments. * * For the Boolean terms (that appear as arguments in UF), we add also * their negations. This means that we need the negation uninterpreted * function. In this Boolean case we add that a term is not equal to * its negation, with the reason true. * * @param tr */ void Egraph::declareTerm(PTRef tr) { assert(enode_store.needsEnode(tr)); auto PTRefERefPairVec = enode_store.constructTerm(tr); if (PTRefERefPairVec.size() == 0) { return; } for (auto [term, eref] : PTRefERefPairVec) { if (logic.getPterm(term).size() > 0) { // MB: No need to insert signatures of terms who cannot be parents if (backtrack_points.size() > 0) { undo_stack_main.push(Undo(REANALYZE, eref)); } ensureUseVectorFor(eref); if (not enode_store.containsSig(eref)) { // Check needed to allow dynamic addition of new terms enode_store.insertSig(eref); addToUseVectors(eref); } } } if (logic.hasSortBool(tr) and not logic.isDisequality(tr) and PTRefERefPairVec.size() == 2) { auto [negated_tr, negated_er] = PTRefERefPairVec[1]; assert(logic.isNot(negated_tr)); termToNegatedERef.insert(tr, negated_er); assert(PTRefERefPairVec[0].tr == logic.mkNot(PTRefERefPairVec[1].tr)); assertNEq(PTRefERefPairVec[0].er, PTRefERefPairVec[1].er, Expl(Expl::Type::pol, PtAsgn_Undef, PTRefERefPairVec[0].tr)); } if (logic.hasSortBool(tr)) { setInformed(tr); } } bool Egraph::addEquality(PtAsgn pa) { Pterm const & pt = logic.getPterm(pa.tr); assert(pt.size() == 2); bool res = true; PTRef e = pt[0]; for (int i = 1; i < pt.size() && res; i++) res = assertEq(e, pt[i], pa); if (res) { bool res2; // First: I'm not sure this is the right way to do this! // second: // pa.sgn == true if this is an equality literal and false if this // is a distinct if (pa.sgn == l_True) res2 = addTrue(pa.tr); else res2 = addFalse(pa.tr); if (!res2) return false; } #ifdef STATISTICS if (res == false) generalTSolverStats.unsat_calls++; // The sat_calls is increased already in addTrue #endif return res; } bool Egraph::addDisequality(PtAsgn pa) { Pterm const & pt = logic.getPterm(pa.tr); bool res = true; if (pt.size() == 2) res = assertNEq(pt[0], pt[1], Expl(Expl::Type::std, pa, PTRef_Undef)); else res = assertDist(pa.tr, pa); #ifdef ENABLE_DIST_BOOL // This should be more efficient but osmt1 does not do it if (res == true) #else if (res && pt.size() == 2) #endif { bool res2; // pa.sgn == true if this is a disequality if (pa.sgn == l_True) res2 = addTrue(pa.tr); else res2 = addFalse(pa.tr); if (!res2) return false; } #ifdef STATISTICS if (!res) generalTSolverStats.unsat_calls++; // The sat_calls is increased already in addFalse #endif return res; } bool Egraph::addTrue(PTRef term) { assert(logic.hasSortBool(term)); assert(not logic.isNot(term)); bool res = assertEq(term, logic.getTerm_true(), PtAsgn(term, l_True)); if (res and termToNegatedERef.has(term)) { res = assertEq(termToNegatedERef[term], termToERef(logic.getTerm_false()), PtAsgn(term, l_True)); } #ifdef STATISTICS if (res == false) generalTSolverStats.unsat_calls++; else { generalTSolverStats.sat_calls++; } #endif return res; } bool Egraph::addFalse(PTRef term) { assert(logic.hasSortBool(term)); assert(not logic.isNot(term)); bool res = assertEq(term, logic.getTerm_false(), PtAsgn(term, l_False)); if (res and termToNegatedERef.has(term)) { res = assertEq(termToNegatedERef[term], termToERef(logic.getTerm_true()), PtAsgn(term, l_False)); } #ifdef STATISTICS if (res == false) generalTSolverStats.unsat_calls++; else { generalTSolverStats.sat_calls++; } #endif return res; } //=========================================================================== // Private Routines for Core Theory Solver // // Assert an equality between nodes x and y // bool Egraph::assertEq ( PTRef tr_x, PTRef tr_y, PtAsgn r ) { ERef x = termToERef(tr_x); ERef y = termToERef(tr_y); return assertEq(x, y, r); } bool Egraph::assertEq(ERef x, ERef y, PtAsgn r) { assert(pending.size() == 0); pending.push({x, y}); return mergeLoop(r); } // // Merge what is in pending and propagate to parents // bool Egraph::mergeLoop( PtAsgn reason ) { bool congruence_pending = false; while ( pending.size() != 0 ) { // Remove a pending equivalence auto [p, q] = pending.last(); pending.pop(); Enode const & en_p = getEnode(p); Enode const & en_q = getEnode(q); if ( en_p.getRoot( ) == en_q.getRoot( ) ) continue; // Store explanation, for either congruence or eq // The third argument is the reason for the merge // of p and q; they may merge because of an equality, // and in that case the reason is the id of the equality. // Or they may merge because of congruence, and in that // case the reason is empty (NULL). Notice that we store // reasons only among TERMs, and never among LISTs. That // means that the reason for p and q being equal has to // be found recursively in their arguments. We store the // reason even in case of unmergability, to have an // automatic way of retrieving a conflict. explainer->storeExplanation( p, q, congruence_pending ? PtAsgn(PTRef_Undef, l_Undef) : reason ); // Check if they can't be merged Expl reason_inequality; bool res = unmergeable( en_p.getRoot(), en_q.getRoot(), reason_inequality ); // They are not unmergable, so they can be merged if ( !res ) { merge( en_p.getRoot( ), en_q.getRoot( ), reason ); congruence_pending = true; continue; } // Conflict detected. We should retrieve the explanation // We have to distinguish 2 cases. If the reason for the // conflict is ERef_Undef, it means that a conflict arises because // we tried to merge two classes that are assigned to different // constants, otherwise we have a proper reason has_explanation = true; ERef reason_1 = ERef_Undef; ERef reason_2 = ERef_Undef; ERef enr_proot = en_p.getRoot(); ERef enr_qroot = en_q.getRoot(); if ( reason_inequality.type == Expl::Type::cons) { // Different constants explainConstants(p,q); } // Does the reason term correspond to disequality symbol else if (reason_inequality.type == Expl::Type::std) { PtAsgn pta = reason_inequality.pta; if ( logic.getPterm(pta.tr).size() > 2 ) { // A distinction. // We should iterate through the elements of the distinction // and find which atoms are causing the conflict Pterm const & pt_reason = logic.getPterm(pta.tr); for (auto ptr_arg : pt_reason) { // (1) Get the enode corresponding to the proper term // (2) Find the enode corresponding to the root // (3) Check if the root enode is the same as the root of p or q ERef enr_arg = enode_store.getERef(ptr_arg); // (1) ERef enr_arg_root = enode_store[enr_arg].getRoot(); // (2) // (3) if ( enr_arg_root == enr_proot ) { reason_1 = enr_arg; } if ( enr_arg_root == enr_qroot ) { reason_2 = enr_arg; } } assert( reason_1 != ERef_Undef ); assert( reason_2 != ERef_Undef ); doExplain(reason_1, reason_2, reason_inequality.pta); } else if ( logic.isEquality(reason_inequality.pta.tr) ) { // The reason is a negated equality assert(reason_inequality.pta.sgn == l_False); Pterm const & pt_reason = logic.getPterm(reason_inequality.pta.tr); // The equality // If properly booleanized, the left and righ sides of equality // will always be UF terms // The left hand side of the equality reason_1 = enode_store.getERef(pt_reason[0]); // The rhs of the equality reason_2 = enode_store.getERef(pt_reason[1]); assert( reason_1 != ERef_Undef ); assert( reason_2 != ERef_Undef ); doExplain(reason_1, reason_2, reason_inequality.pta); } else if ( logic.isUP(reason_inequality.pta.tr) ) { // The reason is an uninterpreted predicate assert(false); explanation.push(reason_inequality.pta); } } else if (reason_inequality.type == Expl::Type::pol) { // The reason is fundamentally that x and (not x) would go to the same eq class ERef pos = enode_store.getERef(reason_inequality.pol_term); ERef neg = enode_store.getERef(logic.mkNot(reason_inequality.pol_term)); doExplain(neg, pos, {logic.getTerm_false(), l_True}); } // Clear remaining pendings pending.clear( ); // Remove the last explanation that links // the two unmergable classes explainer->removeExplanation(); // expCleanup(); // called in expExplain(r1, r2) // Return conflict return false; } return true; } // // Assert a disequality between nodes x and y // bool Egraph::assertNEq ( PTRef x, PTRef y, const Expl &r ) { #ifdef GC_DEBUG checkRefConsistency(); assert(r.sgn != l_Undef); cerr << "Asserting distinction of " << logic.printTerm(x) << " and " << logic.printTerm(y) << " enforced by " << (r.sgn == l_True ? "" : "not ") << logic.printTerm(r.tr) << endl; #endif checkFaGarbage(); #ifdef GC_DEBUG checkRefConsistency(); #endif #if MORE_DEDUCTIONS neq_list.push_back( r ); undo_stack_oper.push_back( ASSERT_NEQ ); undo_stack_term.push_back( r ); #endif ERef xe = enode_store.getERef(x); ERef ye = enode_store.getERef(y); ERef p = getEnode(xe).getRoot(); ERef q = getEnode(ye).getRoot(); // They can't be different if the nodes are in the same class if ( p == q ) { doExplain(xe, ye, r.pta); return false; } return assertNEq(p, q, r); } bool Egraph::assertNEq(ERef p, ERef q, Expl const & r) { // Is it possible that x is already in the list of y // and viceversa ? YES. If things have // been done carefully (for instance, if x=y is the same atom // as y=x), each theory atom appears only once in the trail. // However it is possible to get x!=y and x root_to_enode; // Changed nodes recorded here for undoing the distinction in case of conflict vec nodes_changed; // Assign distinction flag to all arguments const Pterm& pt_d = logic.getPterm(tr_d); ERef inConflict = ERef_Undef; for (PTRef tr_c : pt_d) { ERef er_c = enode_store.getERef(tr_c); ERef root = getEnode(er_c).getRoot(); if (root_to_enode.has(root)) { // Two equivalent nodes in the same distinction. Conflict inConflict = er_c; break; } assert(not root_to_enode.has(root)); root_to_enode.insert(root, er_c); // Activate distinction in e // This should be done for the root of en_c, not en_c getEnode(root).addDistClass(index); nodes_changed.push(root); } if (inConflict != ERef_Undef) { // Extract the other node with the same root Enode const & en_c = getEnode(inConflict); ERef root = en_c.getRoot(); ERef p = root_to_enode[root]; assert(getEnode(p).getRoot() == en_c.getRoot()); // Retrieve explanation doExplain(inConflict, p, tr_r); // Revert changes, as the current context is inconsistent for (ERef n : nodes_changed) { // Deactivate distinction in n getEnode(n).clearDistClass(index); } return false; } assert(inConflict == ERef_Undef); // Distinction pushed without conflict undo_stack_main.push(Undo(DIST, tr_d)); return true; } void Egraph::undoDistinction(PTRef tr_d) { auto index = enode_store.getDistIndex(tr_d); Pterm const & pt_d = logic.getPterm(tr_d); for (PTRef tr_c : pt_d) { getEnode(enode_store.getERef(tr_c)).clearDistClass(index); } } // // Backtracks stack to a certain size // void Egraph::backtrackToStackSize ( size_t size ) { // Make sure explanation is cleared // (might be empty, though, if boolean backtracking happens) explanation.clear(); has_explanation = false; vec toReanalyze; // // Restore state at previous backtrack point // // printf("stack size %d > %d\n", undo_stack_term.size(), size); while (undo_stack_main.size_() > size) { Undo u = undo_stack_main.last(); oper_t last_action = u.oper; undo_stack_main.pop(); switch (last_action) { case MERGE: { ERef e = u.arg.er; undoMerge(e); explainer->removeExplanation(); break; } #if MORE_DEDUCTIONS case ASSERT_NEQ: { ERef e = u.arg.er; assert( neq_list.last( ) == e ); neq_list.pop( ); break; } #endif case DISEQ: { ERef e = u.arg.er; undoDisequality(e); break; } case DIST: { PTRef ptr = u.arg.ptr; undoDistinction(ptr); break; } case CONS: { break; } case SET_POLARITY: { assert(hasPolarity(u.arg.ptr)); clearPolarity(u.arg.ptr); break; } case REANALYZE: { ERef term = u.arg.er; assert(enode_store.lookupSig(term) != ERef_Undef); if (enode_store.lookupSig(term) == term) { enode_store.removeSig(term); removeFromUseVectors(term); } toReanalyze.push(term); break; } default: { assert(false); throw OsmtInternalException("unknown action"); break; } } } for (ERef eref : toReanalyze) { reanalyze(eref); } } //============================================================================= // Congruence Closure Routines // // Merge the class of x with the class of y // x will become the representative // void Egraph::merge ( ERef x, ERef y, PtAsgn reason ) { #ifdef GC_DEBUG checkRefConsistency(); checkForbidReferences(x); checkForbidReferences(y); #endif { // sanity checks assert(getEnode(x).getRoot() != getEnode(y).getRoot()); assert(x == getEnode(x).getRoot()); assert(y == getEnode(y).getRoot()); } // Step 1: Ensure that the constant or the one with a larger equivalence // class will be in x (and will become the root). Constants must be roots! It is an invariant that other code depends on! if (isConstant(y) || (!(isConstant(x)) && (getParentsSize(x) < getParentsSize(y)))) { std::swap(x,y); } // MB: Before we actually merge the classes, we check if we are not merging with eq. class of constant True or False deduce( x, y, reason ); Enode & en_x = getEnode(x); Enode const & en_y = getEnode(y); assert(not isConstant(y)); // Step 2: Propagate equalities to other ordinary theories // MB: We are not doing that // Step 3: MB: Also not relevant for us // Step 4: Update forbid list for x by adding elements of y mergeForbidLists(x, en_y); #ifdef GC_DEBUG checkRefConsistency(); checkForbidReferences(x); #endif // Step 4: Merge distinction classes mergeDistinctionClasses(en_x, en_y); // Step 5: Consists of several operations // Step 5.2: Remove old signatures of y’s class’s parents and remove parents of y from other use vectors processParentsBeforeMerge(y); // Step 5.3: Union of equivalence classes mergeEquivalenceClasses(x, y); // Step 5.5: Insert new signatures and propagate congruences processParentsAfterMerge(y); // Step 6: Merge parent lists -> done in 5.5 // Step 7: Not relevant -> skipped // Step 8: Push undo record undo_stack_main.push( Undo(MERGE,y) ); } // // Deduce facts from the merge of x and y // // Currently, it only deduces if something we are merging into eq. class of a constant True or False void Egraph::deduce( ERef x, ERef y, PtAsgn reason ) { lbool deduced_polarity = l_Undef; // Depends on the invariant that constants are always the root of its eq. class. // Also we assume that y is root of the class being merged into class with root x // That means only x can be constant. assert(y != enode_store.getEnode_true() && y != enode_store.getEnode_false()); if ( x == enode_store.getEnode_true() ){ deduced_polarity = l_True; } else if ( x == enode_store.getEnode_false() ){ deduced_polarity = l_False; } if ( deduced_polarity == l_Undef ) { #ifdef NEG_DEDUCE // Work on negative deductions: // Merge of x and y results in inequalities expressed in the forbid // lists. It would make sense to propagate these inequalities to the // SAT solver so that it would not need to figure them out one by one. // This is an attempt to proagate this information as well. ELRef elr = enode_store[x].getForbid(); if (elr == ELRef_Undef) return; // Nothing to be done ELRef c_elr = elr; while (true) { const Elist& el = forbid_allocator[c_elr]; ELRef next_elr = el.link; const Elist el_o = forbid_allocator[next_elr]; PTRef z = enode_store[el_o.e].getTerm(); vec two_terms; two_terms.push(x); two_terms.push(y); // repeat for both x and y: for (int i = 0; i < 2; i++) { // x != z. Do we have a term for this? vec args; args.push(enode_store[two_terms[i]].getTerm()); args.push(z); // Is there a literal for this fact? PTRef eq = logic.hasEquality(args); if (eq != PTRef_Undef && enode_store.termToERef.has(eq)) { // Found the equality, and we deduce its negation ERef ded_eq = enode_store.termToERef[eq]; enode_store[ded_eq].setDeduced(l_False); deductions.push(PtAsgn_reason(eq, l_False, reason.tr)); egraphStats.deductions_done ++; } } if (elr == next_elr) break; c_elr = next_elr; } #endif // NEG_DEDUCE return; } // x is the constant, go over the members of eq class of y and check if they have can be propagated to SAT solver ERef v = y; const ERef vstart = v; for (;;) { // We deduce only things that aren't currently assigned or // that we previously deduced on this branch PTRef v_tr = getEnode(v).getTerm(); if (not hasPolarity(v_tr) and not logic.isNot(v_tr)) { // Negated boolean terms are handled in the positive case assert(v_tr == enode_store.getPTRef(v)); storeDeduction(PtAsgn_reason(v_tr, deduced_polarity, reason.tr)); #ifdef STATISTICS generalTSolverStats.deductions_done ++; #endif } v = getEnode(v).getEqNext(); if (v == vstart) break; } } // // Starts with the E-graph state that existed after the // pertinent merge and restores the E-graph to the state // it had before the pertinent merge // void Egraph::undoMerge( ERef y ) { #ifdef GC_DEBUG checkRefConsistency(); #endif assert( y != ERef_Undef ); Enode const & en_y = enode_store[y]; // x is the node that was merged with y ERef x = en_y.getRoot( ); assert( x != ERef_Undef ); Enode & en_x = enode_store[x]; // Undo Step 6 of merge: // unmergeParentLists(en_x, en_y); // Undo Step 5 of merge // Undo Case 2 of Step 5.5 of merge processParentsBeforeUnMerge(y); // Undo Step 5.4 of merge // Undo Step 5.3 of merge unmergeEquivalenceClasses(x, y); // Undo Case 1 of Step 5.5 of merge // Since we are skipping Step 5.2 in merge. we do not have to undo that. // unmergeParentCongruenceClasses(w); // re-insert parents of y processParentsAfterUnMerge(y); // Undo step 4 of Merge unmergeDistinctionClasses(en_x, en_y); unmergeForbidLists(x, en_y); // Undo Step 2 -> not relevant #ifdef GC_DEBUG checkRefConsistency(); #endif } // // Restore the state before the addition of a disequality // void Egraph::undoDisequality(ERef x) { #ifdef GC_DEBUG checkRefConsistency(); #endif Enode & en_x = getEnode(x); assert( en_x.getForbid() != ELRef_Undef ); // We have to distinguish two cases: // If there is only one node, that is the // distinction to remove ELRef xfirst = en_x.getForbid( ); ERef y = ERef_Undef; Elist & el_xfirst = forbid_allocator[xfirst]; if ( el_xfirst.link == xfirst ) y = el_xfirst.e; else y = forbid_allocator[el_xfirst.link].e; Enode& en_y = enode_store[y]; ELRef yfirst = en_y.getForbid(); #ifdef GC_DEBUG cerr << "Distinction list for xfirst" << endl; cerr << printDistinctionList(xfirst, forbid_allocator); cerr << "Distinction list for yfirst" << endl; cerr << printDistinctionList(yfirst, forbid_allocator); #endif // Some checks assert( yfirst != ELRef_Undef ); Elist & el_yfirst = forbid_allocator[yfirst]; assert( el_yfirst.link != yfirst || el_yfirst.e == x ); assert( el_yfirst.link == yfirst || forbid_allocator[el_yfirst.link].e == x ); assert( en_x.getRoot( ) != en_y.getRoot( ) ); ELRef ydist = el_xfirst.link == xfirst ? xfirst : el_xfirst.link; Elist const & el_ydist = forbid_allocator[ydist]; // Only one node in the list if ( el_ydist.link == ydist ) { forbid_allocator.removeRef(x, en_x.getForbid()); en_x.setForbid( ELRef_Undef ); } // Other nodes in the list else el_xfirst.link = el_ydist.link; forbid_allocator.free(ydist); ELRef xdist = el_yfirst.link == yfirst ? yfirst : el_yfirst.link; Elist const & el_xdist = forbid_allocator[xdist]; // Only one node in the list if ( el_xdist.link == xdist ) { assert(en_y.getForbid() != ELRef_Undef); forbid_allocator.removeRef(y, en_y.getForbid()); en_y.setForbid( ELRef_Undef ); } // Other nodes in the list else el_yfirst.link = el_xdist.link; forbid_allocator.free(xdist); #ifdef GC_DEBUG checkRefConsistency(); #endif } bool Egraph::unmergeable(ERef x, ERef y, Expl& r) const { assert( x != ERef_Undef ); assert( y != ERef_Undef ); ERef p = getEnode(x).getRoot(); ERef q = getEnode(y).getRoot(); // If they are in the same class, they can merge if ( p == q ) return false; // Check if they have different constants. It is sufficient // to check that they both have a constant. It is not // possible that the constant is the same. In fact if it was // the same, they would be in the same class, but they are not // Check if they are part of the same distinction (general distinction) if (isConstant(p) && isConstant(q)) { r = Expl(Expl::Type::cons, PtAsgn_Undef, PTRef_Undef); return true; } Enode const & en_p = getEnode(p); Enode const & en_q = getEnode(q); if (dist_t intersection = en_p.getDistClasses() & en_q.getDistClasses()) { // Compute the first index in the intersection // TODO: Use index = std::countr_zero(intersection) when c++20 becomes available? unsigned index = 0; while ((intersection & 1) == 0) { intersection = intersection >> 1; ++index; } // Dist terms are all inequalities, hence their polarity's true PTRef ineq_tr = enode_store.getDistTerm(index); r = Expl(Expl::Type::std, {ineq_tr, l_True}, PTRef_Undef); return true; } // Check forbid lists (binary distinction) ELRef pstart = en_p.getForbid(); ELRef qstart = en_q.getForbid(); // If at least one is empty, they can merge if (pstart == ELRef_Undef || qstart == ELRef_Undef) { return false; } ELRef pptr = pstart; ELRef qptr = qstart; for (;;) { Elist const & el_pptr = forbid_allocator[pptr]; Elist const & el_qptr = forbid_allocator[qptr]; // They are unmergeable if they are on the other forbid list if (getEnode(el_pptr.e).getRoot() == q) { r = el_pptr.reason; assert((r.type == Expl::Type::pol) or ((logic.isEquality(r.pta.tr) and r.pta.sgn == l_False) or (logic.isDisequality(r.pta.tr) and r.pta.sgn == l_True))); return true; } if (getEnode(el_qptr.e).getRoot() == p) { r = el_qptr.reason; assert((r.type == Expl::Type::pol) or ((logic.isEquality(r.pta.tr) and r.pta.sgn == l_False) or (logic.isDisequality(r.pta.tr) and r.pta.sgn == l_True))); return true; } // Pass to the next element pptr = el_pptr.link; qptr = el_qptr.link; // If either list finishes, exit. This is ok because // if x is on y's forbid list, then y is on x's forbid // list as well if ( pptr == pstart ) break; if ( qptr == qstart ) break; } // If here they are mergable assert(r.type == Expl::Type::undef); return false; } bool Egraph::isEffectivelyEquality(PTRef tr) const { assert(enode_store.needsEnode(tr)); return logic.isEquality(tr) and enode_store.needsRecursiveDefinition(tr); } bool Egraph::isEffectivelyDisequality(PTRef tr) const { assert(enode_store.needsEnode(tr)); return logic.isDisequality(tr) and enode_store.needsRecursiveDefinition(tr); } bool Egraph::isEffectivelyUP(PTRef tr) const { assert(enode_store.needsEnode(tr)); return not isEffectivelyEquality(tr) and not isEffectivelyDisequality(tr); } bool Egraph::assertLit(PtAsgn pta) { // invalidate values lbool sgn = pta.sgn; PTRef pt_r = pta.tr; if (hasPolarity(pt_r) && getPolarity(pt_r) == sgn) { // Already known, no new information; // MB: The deductions done by this TSolver are also marked using polarity. // The invariant is that TSolver will not process the literal again (when asserted from the SAT solver) // once it is marked for deduction, so the implementation must count with that. generalTSolverStats.sat_calls ++; return true; } bool res = true; // MB: true means NO conflict, false means conflict undo_stack_main.push(Undo(SET_POLARITY, pt_r)); setPolarity(pt_r, sgn); // Issue185: In some cases equalities do not have a recursive definition. // They should be treated as UPs. if (isEffectivelyEquality(pt_r) && sgn == l_True) { res = addEquality(PtAsgn(pt_r, l_True)); } else if (isEffectivelyEquality(pt_r) && sgn == l_False) { res = addDisequality(PtAsgn(pt_r, l_False)); } else if (isEffectivelyDisequality(pt_r) && sgn == l_True) { res = addDisequality(PtAsgn(pt_r, l_True)); } else if (isEffectivelyDisequality(pt_r) && sgn == l_False) { if (logic.getPterm(pt_r).size() != 2) { throw OsmtInternalException("Internal error: Negated distinct asserted to Egraph"); } res = addEquality(PtAsgn(pt_r, l_False)); } else if (isEffectivelyUP(pt_r) && sgn == l_True) { // MB: Short circuit evaluation is important, the second call should NOT happen if the first returns false res = addTrue(pt_r); } else if (isEffectivelyUP(pt_r) && sgn == l_False) { // MB: Short circuit evaluation is important, the second call should NOT happen if the first returns false res = addFalse(pt_r); } else { assert(false); } !res ? generalTSolverStats.unsat_calls ++ : generalTSolverStats.sat_calls ++; return res; } //================================================================================================= // Garbage Collection methods: void Egraph::relocAll(ELAllocator& to) { for (int i = 0; i < forbid_allocator.elists.size(); i++) { // Here er points to the old allocator ELRef er = forbid_allocator.elists[i]; #ifdef GC_DEBUG cerr << "Starting gc round " << i << endl; #endif ELRef er_old = er; ELRef start = er; if (forbid_allocator[er].isDirty()) continue; if (forbid_allocator[er].reloced()) continue; #ifdef GC_DEBUG cerr << printDistinctionList(er, forbid_allocator); do { Elist& e_old = forbid_allocator[er_old]; for (int j = 0; j < forbid_allocator.referenced_by[e_old.getId()].size(); j++) { ERef referer = forbid_allocator.referenced_by[e_old.getId()][j]; if (referer == ERef_Undef) continue; assert (e_old.e != referer); } } while (start != er_old); assert(start == er_old); #endif ELRef prev_fx = ELRef_Undef; bool done = false; while (true) { #ifdef GC_DEBUG cerr << "Traversing forbid list " << endl << " node: " << er.x << " link: " << forbid_allocator[er].link.x << endl << " ERef: " << forbid_allocator[er].e.x << " Reason: " << logic.printTerm(forbid_allocator[er].reason.tr) << endl; if (enode_store[forbid_allocator[er].e].isTerm()) { cerr << " Term: " << logic.printTerm(enode_store[forbid_allocator[er].e].getTerm()) << endl; } #endif forbid_allocator.reloc(er, to); // Now er points to the new allocator #ifdef GC_DEBUG cerr << " new node: " << er.x << endl; #endif // er_old points to the old allocator auto id = to[er].getId(); for (ERef o : to.referenced_by[id]) { #ifdef GC_DEBUG cerr << "Updating owner references" << endl; #endif assert(o != ERef_Undef); enode_store[o].setForbid(er); #ifdef GC_DEBUG assert(to[er].getId() == to[enode_store[o].getForbid()].getId()); #endif } if (prev_fx != ELRef_Undef) to[prev_fx].link = er; if (done) break; prev_fx = er; er = forbid_allocator[er_old].link; #ifdef GC_DEBUG cerr << "Now going to node " << er.x << endl; #endif er_old = er; if (er == start) done = true; } #ifdef GC_DEBUG cerr << "End of gc round " << i << endl; cerr << printDistinctionList(er, to); ELRef start_old; ELRef start_new; ELRef er_new; start_old = er_old = start; start_new = er_new = forbid_allocator[er_old].rel_e; do { Elist& e_old = forbid_allocator[er_old]; Elist& e_new = to[er_new]; assert(e_old.isDirty() == e_new.isDirty()); assert(e_new.isDirty() == false); assert(e_old.reason.tr == e_new.reason.tr); // TODO MB: next 3 lines there is some legacy code that does not compile anymore. Rewrite or remove! // ERef reason_lhs = enode_store.termToERef[term_store[e_new.reason.tr][0]]; // ERef reason_rhs = enode_store.termToERef[term_store[e_new.reason.tr][1]]; // assert (enode_store[reason_lhs].getRoot() != enode_store[reason_rhs].getRoot()); for (int j = 0; j < to.referenced_by[to[er_new].getId()].size(); j++) { ERef referer = to.referenced_by[to[er_new].getId()][j]; if (referer == ERef_Undef) continue; assert (to[er_new].e != referer); } er_old = forbid_allocator[er_old].link; er_new = to[er_new].link; } while (start_old != er_old); assert(start_new == er_new); #endif } } void Egraph::faGarbageCollect() { ELAllocator to(forbid_allocator.size() - forbid_allocator.wasted()); #ifdef GC_DEBUG checkRefConsistency(); #endif relocAll(to); if (config.verbosity() >= 10) printf("Garbage collection: %12d bytes => %12d bytes|\n", forbid_allocator.size()*ELAllocator::Unit_Size, to.size()*ELAllocator::Unit_Size); to.moveTo(forbid_allocator); #ifdef GC_DEBUG checkRefConsistency(); #endif } void Egraph::mergeForbidLists(ERef toRef, const Enode & from) { Enode & to = getEnode(toRef); if ( from.getForbid( ) != ELRef_Undef ) { if ( to.getForbid( ) == ELRef_Undef ) { // We assign the same forbid list to.setForbid( from.getForbid( ) ); forbid_allocator.addReference(to.getForbid(), toRef); } else { // Otherwise we splice the two lists ELRef tmp = forbid_allocator[to.getForbid()].link; forbid_allocator[to.getForbid()].link = forbid_allocator[from.getForbid()].link; forbid_allocator[from.getForbid()].link = tmp; } } } void Egraph::mergeDistinctionClasses(Enode & to, const Enode & from) { to.setDistClasses( ( to.getDistClasses( ) | from.getDistClasses( ) ) ); } void Egraph::unmergeDistinctionClasses(Enode & to, const Enode & from) { to.setDistClasses( ( to.getDistClasses() & ~(from.getDistClasses())) ); } void Egraph::mergeEquivalenceClasses(ERef newroot, ERef oldroot) { // Perform the union of the two equivalence classes // i.e. reroot every node in y's class to point to x ERef v = oldroot; ERef vstart = v; while (true) { Enode & en_v = getEnode(v); en_v.setRoot(newroot); v = en_v.getEqNext(); if (v == vstart) break; } // Splice next lists Enode & en_x = getEnode(newroot); Enode & en_y = getEnode(oldroot); ERef tmp = en_x.getEqNext(); en_x.setEqNext(en_y.getEqNext()); en_y.setEqNext(tmp); // Update size of the congruence class en_x.setEqSize(en_x.getEqSize() + en_y.getEqSize()); } void Egraph::unmergeEquivalenceClasses(ERef newroot, ERef oldroot) { Enode & en_x = getEnode(newroot); Enode & en_y = getEnode(oldroot); // Restore the size of x's class en_x.setEqSize(en_x.getEqSize() - en_y.getEqSize()); // Unsplice next lists ERef tmp = en_x.getEqNext(); en_x.setEqNext(en_y.getEqNext()); en_y.setEqNext(tmp); // Reroot each node of y's eq class back to y ERef v = oldroot; ERef vstart = v; while (true) { Enode & en_v = getEnode(v); en_v.setRoot(oldroot); v = en_v.getEqNext(); if (v == vstart) break; } } void Egraph::unmergeForbidLists(ERef toRef, const Enode & from) { Enode & to = getEnode(toRef); // Restore forbid list for x and y if ( (to.getForbid( ) == from.getForbid() ) && to.getForbid() != ELRef_Undef ) { forbid_allocator.removeRef(toRef, to.getForbid()); to.setForbid( ELRef_Undef ); } // Unsplice back the two lists else if ( from.getForbid( ) != ELRef_Undef ) { ELRef tmp = forbid_allocator[to.getForbid()].link; forbid_allocator[to.getForbid()].link = forbid_allocator[from.getForbid()].link; forbid_allocator[from.getForbid()].link = tmp; } } /** * Before oldroot is merged, the parents of its congruence class are scanned to * 1. Remove them from signature table * 2. Remove them from use-vectors of the other children (they are kept in the oldroot's use-vector for post-merge pass) */ void Egraph::processParentsBeforeMerge(ERef oldroot) { UseVector const & oldroot_parents = parents[getEnode(oldroot).getCid()]; for (auto entry : oldroot_parents) { assert(not entry.isMarked()); if (entry.isValid()) { ERef parent = UseVector::entryToERef(entry); enode_store.removeSig(parent); removeFromUseVectorsExcept(parent, getEnode(oldroot).getCid()); } } } /** * * After merge, the parents of the merged root (oldroot) are scanned again to restore the invariants. * Their signature has changed after the merge. * Either i) there already is a term with the new signature, or ii) there is no term with the new signature. * * i) The parent is no longer a congruence root. This means there already is a representative in the signature table * and use-vectors. We only mark the parent in the old use-vector for backtracking and enqueue the discovered congruence. * * ii) There is no other representative with the new signature, so the parent remains a congruence root. * Since we removed it from signature table and use-vectors in processParentsBeforeMerge, we reintroduce it to both * data-structures. Note that the new signature will be used at this point. */ void Egraph::processParentsAfterMerge(ERef oldroot) { UseVector & oldroot_parents = parents[getEnode(oldroot).getCid()]; for (auto & entry : oldroot_parents) { assert(!entry.isMarked()); if (entry.isValid()) { ERef parent = UseVector::entryToERef(entry); ERef q = enode_store.lookupSig(parent); if (q != ERef_Undef) { // Case 1: p joins q's congruence class assert(q != parent); pending.push({parent, q}); // p is no longer in the congruence table // put a mark for backtracking entry.mark(); } else { // Case 2: p remains congruent root (but now has new signature) enode_store.insertSig(parent); addToUseVectors(parent); } } } } /** * Undoes the effect of processParentsAfterMerge */ void Egraph::processParentsBeforeUnMerge(ERef oldroot) { UseVector & oldroot_parents = parents[getEnode(oldroot).getCid()]; for (auto & entry : oldroot_parents) { if (entry.isFree()) { continue; } if (entry.isValid()) { ERef parent = UseVector::entryToERef(entry); assert(enode_store.containsSig(parent)); enode_store.removeSig(parent); removeFromUseVectors(parent); } else { assert(entry.isMarked()); entry.unmark(); } } } /** * Undoes the effect of processParentsBeforeMerge */ void Egraph::processParentsAfterUnMerge(ERef oldroot) { UseVector & oldroot_parents = parents[getEnode(oldroot).getCid()]; for (auto it = oldroot_parents.begin(); it != oldroot_parents.end(); ++it) { if (it->isValid()) { ERef parent = UseVector::entryToERef(*it); enode_store.insertSig(parent); oldroot_parents.clearEntryAt(it - oldroot_parents.begin()); // required for reinserting for all children addToUseVectors(parent); } } } void Egraph::doExplain(ERef x, ERef y, PtAsgn reason_inequality) { explanation = explainer->explain(x,y); #ifdef EXPLICIT_CONGRUENCE_EXPLANATIONS for (auto ptRefPair : explainer->getCongruences()) { PTRef x = ptRefPair.first; PTRef y = ptRefPair.second; explainer->explain(enode_store.getERef(x), enode_store.getERef(y)); } #endif explanation.push(reason_inequality); has_explanation = true; } void Egraph::explainConstants(ERef p, ERef q) { ERef enr_proot = getEnode(p).getRoot(); ERef enr_qroot = getEnode(q).getRoot(); assert(logic.isConstant(getEnode(enr_proot).getTerm())); assert(logic.isConstant(getEnode(enr_qroot).getTerm())); assert(enr_proot != enr_qroot); explanation = explainer->explain(enr_proot,enr_qroot); has_explanation = true; } uint32_t UseVector::addParent(ERef parent) { auto index = getFreeSlotIndex(); auto entry = erefToEntry(parent); data[index] = entry; ++nelems; assert(entryToERef(entry) == parent); return index; } void UseVector::clearEntryAt(int index) { assert(index >= 0 && static_cast(index) < data.size() && data[index].isValid()); data[index] = UseVector::indexToFreeEntry(free); free = index; --nelems; } uint32_t UseVector::getFreeSlotIndex() { auto ret = free; if (ret != Entry::FREE_ENTRY_LIST_GUARD) { Entry e = data[free]; assert(e.isFree()); free = freeEntryToIndex(e); assert(free == Entry::FREE_ENTRY_LIST_GUARD || static_cast(free) < data.size()); return ret; } ret = data.size(); data.emplace_back(); return ret; } void Egraph::ensureUseVectorFor(ERef eref) { auto cid = getEnode(eref).getCid(); while (cid >= parents.size()) { parents.emplace_back(); } } /** * Determines whether some earlier child of the parent enode is in the same congruence class as the given child. * @param parent parent enode * @param childIndex index in the list of children of child under consideration */ bool Egraph::childDuplicatesClass(ERef parent, uint32_t childIndex) { assert(childIndex < getEnode(parent).getSize()); if (childIndex == 0) { return false; } Enode const & parentNode = getEnode(parent); ERef child = parentNode[childIndex]; auto childClass = getEnode(getEnode(child).getRoot()).getCid(); auto precedingChildren = opensmt::span(parentNode.begin(), childIndex); return std::any_of(precedingChildren.begin(), precedingChildren.end(), [&](ERef precChild) { return childClass == getEnode(getEnode(precChild).getRoot()).getCid(); }); } /** * Adds the parent enode to the use-vectors of its children. * * The parent enode remembers its indices in the use-vectors. * If two children are in the same congruence class, only the use-vector of the first one remembers the parent. */ void Egraph::addToUseVectors(ERef parentRef) { Enode & parent = getEnode(parentRef); for (uint32_t i = 0; i < parent.getSize(); ++i) { ERef childRef = parent[i]; auto childCid = getEnode(getEnode(childRef).getRoot()).getCid(); assert(parents.size() > childCid); if (childDuplicatesClass(parentRef, i)) { parent.setIndex(i, UseVectorIndex::NotValidIndex); } else { auto index = parents[childCid].addParent(parentRef); parent.setIndex(i, UseVectorIndex{index}); } } } /** * Removes the parent enode from the use-vectors of its children. * * Note that the indices in the parent are not reset, they remain invalid. * */ void Egraph::removeFromUseVectors(ERef parent) { Enode const & parentNode = getEnode(parent); for (uint32_t i = 0; i < parentNode.getSize(); ++i) { ERef childRef = parentNode[i]; auto childCid = getEnode(getEnode(childRef).getRoot()).getCid(); auto parentIndex = parentNode.getIndex(i); if (parentIndex != UseVectorIndex::NotValidIndex) { assert(UseVector::entryToERef(parents[childCid][parentIndex.x]) == parent); parents[childCid].clearEntryAt(parentIndex.x); } } } /** * Removes the parent enode from the use-vectors of its children except the one with the given congruence id. * * Same as removeFromUseVectors except we keep the parent entry in the use-vector with the given congrunce id. */ void Egraph::removeFromUseVectorsExcept(ERef parent, CgId cgid) { Enode const & parentNode = getEnode(parent); for (uint32_t i = 0; i < parentNode.getSize(); ++i) { ERef childRef = parentNode[i]; auto childCid = getEnode(getEnode(childRef).getRoot()).getCid(); if (childCid != cgid) { auto parentIndex = parentNode.getIndex(i); if (parentIndex != UseVectorIndex::NotValidIndex) { assert(UseVector::entryToERef(parents[childCid][parentIndex.x]) == parent); parents[childCid].clearEntryAt(parentIndex.x); } } } } void Egraph::printStatistics(std::ostream & os) { TSolver::printStatistics(os); egraphStats.printStatistics(os); } void Egraph::reanalyze(ERef eref) { // FIXME: This will probably never be false, we need to find a different condition if (backtrack_points.size() > 0) { undo_stack_main.push(Undo(REANALYZE, eref)); } if (not enode_store.containsSig(eref)) { enode_store.insertSig(eref); addToUseVectors(eref); } } vec Egraph::collectEqualitiesFor(vec const & vars, std::unordered_set const & knownEqualities) { vec equalities; MapWithKeys enodes; for (PTRef var : vars) { assert(logic.isVar(var) or logic.isConstant(var)); if (not enode_store.has(var)) { continue; } ERef eref = termToERef(var); assert(not enodes.has(eref)); enodes.insert(eref, var); } std::unordered_map, ERefHash> eqClasses; for (ERef eref : enodes.getKeys()) { ERef root = getEnode(eref).getRoot(); auto it = eqClasses.find(root); if (it == eqClasses.end()) { auto insertRes = eqClasses.emplace(root, vec{}); assert(insertRes.second); // must have been inserted it = insertRes.first; } it->second.push(eref); } for (auto const & entry : eqClasses) { auto const & equivalentVars = entry.second; for (int i = 0; i < equivalentVars.size(); ++i) { for (int j = i + 1; j < equivalentVars.size(); ++j) { PTRef eq = logic.mkEq(ERefToTerm(equivalentVars[i]), ERefToTerm(equivalentVars[j])); if (not enode_store.has(eq)) { if (knownEqualities.find(eq) != knownEqualities.end()) { throw OsmtInternalException("Internal error in computing interface equalities in Egraph"); } equalities.push(eq); } } } } return equalities; } opensmt-2.5.2/src/tsolvers/egraph/Enode.cc000066400000000000000000000036251445011647600205020ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ #include "Enode.h" cgId Enode::cgid_ctr = cgId_Nil+1; UseVectorIndex UseVectorIndex::NotValidIndex = {UINT32_MAX}; Enode::Enode(SymRef symbol, opensmt::span children, ERef myRef, PTRef term) : root(myRef), cid(cgid_ctr++), eq_next(myRef), eq_size(1), pterm(term), forbid(ELRef_Undef), dist_classes(0), exp_reason(PTRef_Undef, l_Undef), exp_parent(ERef_Undef), exp_root(myRef), exp_time_stamp(0), symb(symbol), argSize(children.size()) { assert(term != PTRef_Undef); for (uint32_t i = 0; i < argSize; ++i) { args[i] = children[i]; setIndex(i, UseVectorIndex::NotValidIndex); } } opensmt-2.5.2/src/tsolvers/egraph/Enode.h000066400000000000000000000323561445011647600203470ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #ifndef ENODE_H #define ENODE_H #include "Vec.h" #include "Alloc.h" #include "PtStructs.h" #include "SymRef.h" #include "TypeUtils.h" #include "CgTypes.h" struct ERef { uint32_t x; void operator= (uint32_t v) { x = v; } inline friend bool operator< (ERef a1, ERef a2) {return a1.x < a2.x; } inline friend bool operator== (ERef a1, ERef a2) {return a1.x == a2.x; } inline friend bool operator!= (ERef a1, ERef a2) {return a1.x != a2.x; } }; static struct ERef ERef_Undef = {UINT32_MAX}; struct UseVectorIndex { uint32_t x; inline friend bool operator== (const UseVectorIndex& a1, const UseVectorIndex& a2) {return a1.x == a2.x; } inline friend bool operator!= (const UseVectorIndex& a1, const UseVectorIndex& a2) {return a1.x != a2.x; } static UseVectorIndex NotValidIndex; }; static_assert(sizeof(ERef) == sizeof(UseVectorIndex)); using CgId = uint32_t; using enodeid_t = int; // // Data structure used to store forbid lists // struct ELRef { uint32_t x; ELRef & operator= (uint32_t v) { x = v; return *this; } inline friend bool operator== (const ELRef& a1, const ELRef& a2) {return a1.x == a2.x; } inline friend bool operator!= (const ELRef& a1, const ELRef& a2) {return a1.x != a2.x; } }; static struct ELRef ELRef_Undef = {UINT32_MAX}; class EnodeAllocator; class Enode final { private: static uint32_t cgid_ctr; ERef root; // The root of this enode's equivalence class cgId cid; // The congruence id of the enode (never changes) ERef eq_next; // Next node in this enode's equivalence class int eq_size; // Size of this enode's equivalence class PTRef pterm; // The corresponding pterm ELRef forbid; // List of unmergeable Enodes dist_t dist_classes; // The bit vector for distinction classes // fields related to explanation PtAsgn exp_reason; ERef exp_parent; ERef exp_root; int exp_time_stamp; // Term representation SymRef symb; uint32_t argSize; /* * Pointer to the end of object, where ENodeAllocator allocated enough space for Enode's children and * their use-vector indices. */ ERef args[0]; friend class EnodeAllocator; Enode(SymRef symbol, opensmt::span children, ERef myRef, PTRef ptr); // Set the bit b to 1 and leave the others to 0 static uint32_t setbit(uint32_t b) { return 1 << b; } public: Enode(Enode const &) = delete; CgId getCid() const { return cid; } ERef getRoot() const { return root; } void setRoot(ERef r) { root = r; } ERef getEqNext () const { return eq_next; } void setEqNext (ERef n) { eq_next = n; } int getEqSize () const { return eq_size; } void setEqSize (int i) { eq_size = i; } PtAsgn getExpReason () const { return exp_reason; } ERef getExpParent () const { return exp_parent; } ERef getExpRoot () const { return exp_root; } int getExpTimeStamp () const { return exp_time_stamp; } void setExpReason (PtAsgn r) { exp_reason = r; } void setExpParent (ERef r) { exp_parent = r; } void setExpRoot (ERef r) { exp_root = r; } void setExpTimeStamp (const int t) { exp_time_stamp = t; } PTRef getTerm () const { return pterm; } ELRef getForbid () const { return forbid; } void setForbid (ELRef r) { forbid = r; } void addDistClass(uint32_t index) { assert(index <= 32); setDistClasses(getDistClasses() | setbit(index)); } void clearDistClass(uint32_t index) { assert(index <= 32); setDistClasses(getDistClasses() & ~setbit(index)); } void setDistClasses( const dist_t& d) { dist_classes = d; } dist_t getDistClasses() const { return dist_classes; } uint32_t getSize() const { return argSize; } SymRef getSymbol() const { return symb; } ERef operator[](std::size_t i) const { return *(args + i); } ERef const * begin() const { return args; } ERef const * end() const { return args + argSize; } UseVectorIndex getIndex(uint32_t i) const { return UseVectorIndex{(args + argSize + i)->x}; } void setIndex(uint32_t i, UseVectorIndex index) { (args + argSize + i)->x = index.x; } }; struct ERefHash { uint32_t operator () (const ERef& s) const { return (uint32_t)s.x; } }; class EnodeAllocator : public RegionAllocator { enodeid_t n_enodes; public: EnodeAllocator(uint32_t start_cap) : RegionAllocator(start_cap), n_enodes(0) {} EnodeAllocator() : n_enodes(0) {} /* The children refs and corresponding use-vector indices are stored at the end of the object */ static int enodeWord32Size(std::size_t argCount) { return (sizeof(Enode) + 2 * argCount * sizeof(ERef)) / sizeof(int32_t); } void moveTo(EnodeAllocator& to){ RegionAllocator::moveTo(to); to.n_enodes = n_enodes; } ERef alloc(SymRef symbol, opensmt::span children, PTRef term) { static_assert(sizeof(SymRef) == sizeof(uint32_t), "Expected size of types does not match"); static_assert(sizeof(ERef) == sizeof(uint32_t), "Expected size of types does not match"); uint32_t v = RegionAllocator::alloc(enodeWord32Size(children.size())); // MB: The data structures used in the satisfiability checking algorithm (UseVector) requires at the moment that // the values of ERef cannot exceed 2^30. The benchmarks that we are dealing with at the moment are far below this limit, // but here is a dynamic check just in case. if (v >= (static_cast(-1) >> 2)) { throw OutOfMemoryException(); } ERef eref{v}; ++n_enodes; new (lea(eref)) Enode(symbol, children, eref, term); return eref; } ERef alloc(Enode&) = delete; // Deref, Load Effective Address (LEA), Inverse of LEA (AEL): Enode& operator[](ERef r) { return (Enode&)RegionAllocator::operator[](r.x); } const Enode& operator[](ERef r) const { return (Enode&)RegionAllocator::operator[](r.x); } Enode* lea (ERef r) { return (Enode*)RegionAllocator::lea(r.x); } const Enode* lea (ERef r) const { return (Enode*)RegionAllocator::lea(r.x); } ERef ael (const Enode* t) { RegionAllocator::Ref r = RegionAllocator::ael((uint32_t*)t); return {r}; } void free(ERef eid) { Enode& e = operator[](eid); RegionAllocator::free(enodeWord32Size(e.getSize())); } }; /** * Expl is a generalization of an explanation inequality that covers explicitly * the standard inequality consisting of a negated equality or inequality, * difference of two constants, and a boolean atom and its negation being distinct. */ struct Expl { enum class Type { std, cons, pol, undef } type; PtAsgn pta; PTRef pol_term; Expl() : type(Type::undef), pta(PtAsgn_Undef), pol_term(PTRef_Undef) {} Expl(Type type, PtAsgn pta, PTRef pol_term) : type(type), pta(pta), pol_term(pol_term) {} }; #define ID_BITS 30 #define ID_MAX 2 << 30 class Elist { struct { unsigned rlcd : 1; unsigned dirty : 1; unsigned id : ID_BITS; } header; ELRef relocation() const { return rel_e; } void relocate(ELRef er) { header.rlcd = 1; rel_e = er; } void setId(uint32_t id) { assert(id < (uint32_t)(ID_MAX)); header.id = id; } friend class ELAllocator; public: bool reloced() const { return header.rlcd; } unsigned getId() const { return header.id; } void setDirty() { header.dirty = true; } bool isDirty() const { return header.dirty; } Expl reason; // Reason for this distinction union { ERef e; ELRef rel_e; }; // Enode that differs from this, or the reference where I was relocated ELRef link; // Link to the next element in the list Elist(ERef e_, const Expl &r) : reason(r), e(e_), link(ELRef_Undef) { header.rlcd = false; header.dirty = false; } Elist* Elist_new(ERef e_, const Expl &r) { assert(false); assert(sizeof(ELRef) == sizeof(uint32_t)); size_t sz = sizeof(ELRef) + 2*sizeof(ERef); void* mem = malloc(sz); return new (mem) Elist(e_, r); } }; class ELAllocator : public RegionAllocator { int free_ctr; static int elistWord32Size() { return sizeof(Elist)/sizeof(int32_t); } public: vec elists; std::vector > referenced_by; ELAllocator() : free_ctr(0) {} ELAllocator(uint32_t start_cap) : RegionAllocator(start_cap), free_ctr(0) {} void addReference(ELRef ref, ERef referer) { int id = operator[] (ref).getId(); referenced_by[id].push(referer); } void moveTo(ELAllocator& to) { RegionAllocator::moveTo(to); elists.copyTo(to.elists); to.referenced_by.clear(); for (const auto & referencers : referenced_by) { to.referenced_by.emplace_back(); for (auto referencer : referencers) to.referenced_by.back().push(referencer); } } ELRef alloc(ERef e, const Expl& r, ERef owner) { assert(sizeof(ERef) == sizeof(uint32_t)); uint32_t v = RegionAllocator::alloc(elistWord32Size()); ELRef elid; elid.x = v; new (lea(elid)) Elist(e, r); operator[] (elid).setId(elists.size()); #ifdef GC_DEBUG for (int i = 0; i < elists.size(); i++) assert(elists[i] != elid); #endif assert(static_cast(referenced_by.size()) == elists.size()); elists.push(elid); referenced_by.emplace_back(); referenced_by.back().push(owner); return elid; } ELRef alloc(const Elist& old) { uint32_t v = RegionAllocator::alloc(elistWord32Size()); ELRef elid; elid.x = v; new (lea(elid)) Elist(old.e, old.reason); operator[] (elid).setId(elists.size()); elists.push(elid); return elid; } Elist& operator[](ELRef r) { return (Elist&)RegionAllocator::operator[](r.x); } const Elist& operator[](ELRef r) const { return (Elist&)RegionAllocator::operator[](r.x); } Elist* lea (ELRef r) { return (Elist*)RegionAllocator::lea(r.x); } const Elist* lea (ELRef r) const { return (Elist*)RegionAllocator::lea(r.x); } ELRef ael (const Elist* t) { RegionAllocator::Ref r = RegionAllocator::ael((uint32_t*)t); ELRef rf; rf.x = r; return rf; } void free(ELRef r) { free_ctr++; RegionAllocator::free(elistWord32Size()); assert(!operator[](r).isDirty()); (operator[](r)).setDirty(); } void reloc(ELRef& elr, ELAllocator& to) { Elist& el = operator[](elr); if (el.reloced()) { elr = el.relocation(); return; } elr = to.alloc(el); to.referenced_by.emplace_back(); assert(static_cast(to.referenced_by.size()) == to[elr].getId()+1); // copy referers from old allocator to new vec& referers = referenced_by[el.getId()]; for (int i = 0; i < referers.size(); i++) { ERef er = referers[i]; if (er != ERef_Undef) to.referenced_by.back().push(er); } el.relocate(elr); } void removeRef(ERef er, ELRef elr) { int i = 0; int id = operator[] (elr).getId(); for (; i < referenced_by[id].size(); i++) { if (referenced_by[id][i] == er) { referenced_by[id][i] = ERef_Undef; break; } } assert(i < referenced_by[id].size()); #ifdef GC_DEBUG for (i++; i < referenced_by[id].size(); i++) assert(referenced_by[id][i] != er); #endif } }; #endif opensmt-2.5.2/src/tsolvers/egraph/EnodeStore.cc000066400000000000000000000126111445011647600215120ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ #include "EnodeStore.h" #include "Symbol.h" #include "Logic.h" EnodeStore::EnodeStore(Logic& l) : logic(l) , ea(1024*1024) , sig_tab(SignatureHash(ea), SignatureEqual(ea)) , dist_idx(0) { // For the uninterpreted predicates and propositional structures inside // uninterpreted functions, define function not, the terms true and false, // and an asserted disequality true != false PTRef t = logic.getTerm_true(); PTRef f = logic.getTerm_false(); constructTerm(t); constructTerm(f); ERef_True = termToERef[t]; ERef_False = termToERef[f]; } /** * Register term with this store. * This creates a new ENode representing the term, if the term has no been registered before. * @param term * @param ignoreChildren if true, creates a special version of ENode with no children * @return Reference to the newly created ENode */ ERef EnodeStore::addTerm(PTRef term, bool ignoreChildren) { if (termToERef.has(term)) return termToERef[term]; Pterm const & pterm = logic.getPterm(term); SymRef symref = pterm.symb(); vec args; auto argSpan = [&](){ if (ignoreChildren) { return opensmt::span(nullptr, 0); } args.capacity(pterm.nargs()); for (PTRef arg : pterm) { assert(termToERef.has(arg)); args.push(termToERef[arg]); } return opensmt::span(args.begin(), args.size_()); }(); ERef newEnode = ea.alloc(symref, argSpan, term); assert(not termToERef.has(term)); termToERef.insert(term, newEnode); termEnodes.push(newEnode); return newEnode; } /** * Determine if a given term represented by the PTRef tr requires an enode term. * @param tr the PTRef * @return true tr needs an enode, false otherwise. * @note Could be implemented in Logic as well. */ bool EnodeStore::needsEnode(PTRef tr) const { if (logic.isConstant(tr)) { return true; } else if (logic.isVar(tr) and not logic.hasSortBool(tr)) { return true; } else if (logic.isUF(tr) or logic.yieldsSortUninterpreted(tr)) { return true; } else if (logic.hasArrays() and (logic.isArraySort(logic.getSortRef(tr)) or logic.isArraySelect(tr))) { return true; } else if (logic.isTheoryEquality(tr)) { return true; } else if (logic.appearsInUF(tr)) { return true; } else if (logic.isUP(tr)) { return true; } else if (logic.isDisequality(tr)) { return true; } else { return false; } } /** * Construct an Enode for a given PTRef, assuming that all the child PTRefs have * already been introduced an Enode. In case of a Boolean return valued Enode, * add also an enode of the negation of the PTRef. If the Boolean Enode is * non-atomic, no child Enodes will be constructed. * @param tr The PTRef for which the Enode(s) will be constructed * @return a vector of pairs consisting either of a single element * if the PTRef is non-boolean; two elements, the first of which corresponds to * the positive form and and the second the negated form of the PTRef tr; or is empty * if the PTRef has already been inserted. */ vec EnodeStore::constructTerm(PTRef tr) { assert(needsEnode(tr)); if (termToERef.has(tr)) return {}; vec new_enodes; if (logic.isDisequality(tr)) { addDistClass(tr); } bool ignoreChildren = not needsRecursiveDefinition(tr); ERef er = addTerm(tr, ignoreChildren); new_enodes.push({tr, er}); if (logic.hasSortBool(tr)) { // Add the negated term assert(logic.isBooleanOperator(tr) || logic.isBoolAtom(tr) || logic.isTrue(tr) || logic.isFalse(tr) || logic.isEquality(tr) || logic.isUP(tr) || logic.isDisequality(tr)); assert(not logic.isNot(tr)); PTRef tr_neg = logic.mkNot(tr); if (needsEnode(tr_neg)) { ERef er_neg = addTerm(tr_neg); new_enodes.push({tr_neg, er_neg}); } } return new_enodes; } bool EnodeStore::needsRecursiveDefinition(PTRef tr) const { Pterm const & t = logic.getPterm(tr); return std::all_of(t.begin(), t.end(), [this](PTRef ch) { return needsEnode(ch); }); } opensmt-2.5.2/src/tsolvers/egraph/EnodeStore.h000066400000000000000000000125371445011647600213630ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2014 Antti Hyvarinen 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. *********************************************************************/ #ifndef ENODESTORE_H #define ENODESTORE_H #include "Enode.h" #include "OsmtInternalException.h" class Logic; struct PTRefERefPair { PTRef tr; ERef er; }; class EnodeStore { struct SignatureHash { EnodeAllocator const & ea; SignatureHash(EnodeAllocator const & ea) : ea{ea} {} // Hash function from https://stackoverflow.com/questions/20511347/a-good-hash-function-for-a-vector std::size_t operator()(ERef ref) const { Enode const & node = ea[ref]; std::size_t seed = node.getSymbol().x; for (uint32_t i = 0; i < node.getSize(); ++i) { seed ^= ea[node[i]].getRoot().x + 0x9e3779b9 + (seed << 6) + (seed >> 2); } return seed; } }; struct SignatureEqual { EnodeAllocator const & ea; SignatureEqual(EnodeAllocator const & ea) : ea{ea} {} bool operator()(ERef a, ERef b) const { if (a == b) { return true; } Enode const & anode = ea[a]; Enode const & bnode = ea[b]; if (anode.getSize() != bnode.getSize() or anode.getSymbol() != bnode.getSymbol()) { return false; } for (uint32_t i = 0; i < anode.getSize(); ++i) { if (ea[anode[i]].getRoot() != ea[bnode[i]].getRoot()) { return false; } } return true; } }; Logic& logic; EnodeAllocator ea; Map sig_tab; ERef ERef_True; ERef ERef_False; Map > dist_classes; uint32_t dist_idx; Map > termToERef; vec index_to_dist; // Table distinction index --> proper term vec termEnodes; ERef addTerm(PTRef pt, bool ignoreChildren = false); public: EnodeStore(Logic& l); bool needsEnode(PTRef tr) const; bool needsRecursiveDefinition(PTRef tr) const; const vec& getTermEnodes() const { return termEnodes; }; ERef getEnode_true() { return ERef_True; } ERef getEnode_false() { return ERef_False; } void free(ERef er) { ea.free(er); } bool has(PTRef tr) const { return termToERef.has(tr); } ERef getERef(PTRef tr) const { return termToERef[tr]; } /** * Place into er the enode ref of tr if it exists in the store. Otherwise do not change er. * @param tr the pterm ref to look for * @param er will contain the enode ref corresponding to tr, or be unchanged * @return true if tr is in the store, false if not. */ bool peekERef(PTRef tr, ERef& er) const { return termToERef.peek(tr, er); } PTRef getPTRef(ERef er) const { return ea[er].getTerm(); } vec constructTerm(PTRef tr); Enode& operator[] (ERef e) { return ea[e]; } const Enode& operator[] (ERef e) const { return ea[e]; } Enode& operator[] (PTRef tr) { return ea[termToERef[tr]]; } const Enode& operator[] (PTRef tr) const { return ea[termToERef[tr]]; } char getDistIndex(PTRef tr_d) const { assert(dist_classes.has(tr_d)); return dist_classes[tr_d]; } PTRef getDistTerm(dist_t idx) const { return index_to_dist[idx]; } void addDistClass(PTRef tr_d) { if (dist_classes.has(tr_d)) { return; } if (dist_idx >= maxDistinctClasses) { throw OsmtInternalException(); } dist_classes.insert(tr_d, dist_idx); assert(index_to_dist.size_() == dist_idx); index_to_dist.push(tr_d); dist_idx++; } inline bool containsSig(ERef e) const { return lookupSig(e) != ERef_Undef; } inline ERef lookupSig(ERef e) const { bool found = sig_tab.peek(e, e); return found ? e : ERef_Undef; } inline void removeSig(ERef e) { assert(containsSig(e)); sig_tab.remove(e); assert(not containsSig(e)); } inline void insertSig(ERef e) { assert(not containsSig(e)); sig_tab.insert(e,e); assert(containsSig(e)); } }; #endif opensmt-2.5.2/src/tsolvers/egraph/Explainer.cc000066400000000000000000000255521445011647600214020ustar00rootroot00000000000000// // Created by Martin Blicha on 15.09.20. // #include "Explainer.h" #include "UFInterpolator.h" //============================================================================= // Explanation Routines: details about these routines are in paper // // Robert Nieuwenhuis and Albert Oliveras // "Proof Producing Congruence Closure" // @inproceedings{DBLP:conf/rta/NieuwenhuisO05, // author = {Robert Nieuwenhuis and // Albert Oliveras}, // title = {Proof-Producing Congruence Closure}, // booktitle = {Term Rewriting and Applications, 16th International Conference, // RTA 2005, Nara, Japan, April 19-21, 2005, Proceedings}, // year = {2005}, // pages = {453-468}, // editor = {J{\"u}rgen Giesl}, // publisher = {Springer}, // series = {Lecture Notes in Computer Science}, // volume = {3467}, // year = {2005}, // } /** * Store explanation for an eq merge. * @arg x a term * @arg y a term to be set to the class of x * @Preconditions: x & y are terms and not in the same equivalence class. * @Postcondition: let u, v be the node in {x, y} with the smaller, respectively larger, equivalence graph. The graph of u will be re-rooted on v. */ void Explainer::storeExplanation(ERef x, ERef y, PtAsgn reason) { assert(getEnode(x).getRoot() != getEnode(y).getRoot()); // They must be different because the merge hasn't occured yet if (getEnode(x).getRoot() == getEnode(y).getRoot()) { throw OsmtInternalException("Attempting to store explanation for already known equality"); } // The main observation here is that the explanation tree, although // differently oriented, has the same size as the equivalence tree // (actually we don't keep the equivalence tree, because we use // the quick-find approach, but here we just need the size). So we // can use root_x.getSize() to know the size of the class of a node // x and therefore be sure that the explanation tree is kept // balanced (which is a requirement to keep the O(nlogn) bound // Make sure that x is the node with the larger number of edges to switch { Enode const &root_x = getEnode(getEnode(x).getRoot()); Enode const &root_y = getEnode(getEnode(y).getRoot()); if (root_x.getEqSize() < root_y.getEqSize()) { std::swap(x, y); } } // Reroot the explanation tree on y. It has an amortized cost of logn reRootOn( y ); getEnode(y).setExpParent(x); getEnode(y).setExpReason(reason); // Store both nodes. Because of rerooting operations // we don't know whether x --> y or x <-- y at the moment of // backtracking. So we just save reason and check both parts exp_undo_stack.push(x); exp_undo_stack.push(y); } // // Subroutine of explainStoreExplanation // Re-root the tree containing x, in such a way that // the new root is x itself // void Explainer::reRootOn(ERef x) { ERef p = x; ERef parent = getEnode(p).getExpParent(); PtAsgn reason = getEnode(p).getExpReason(); getEnode(x).setExpParent(ERef_Undef); getEnode(x).setExpReason(PtAsgn_Undef); while (parent != ERef_Undef) { // Save grandparent ERef grandparent = getEnode(parent).getExpParent(); // Save reason PtAsgn saved_reason = reason; reason = getEnode(parent).getExpReason(); // Reverse edge & reason getEnode(parent).setExpParent(p); getEnode(parent).setExpReason(saved_reason); // Move the two pointers p = parent; parent = grandparent; } } vec Explainer::explain(opensmt::pair nodePair) { #ifdef EXPLICIT_CONGRUENCE_EXPLANATIONS congruences.clear(); #endif DupChecker dupChecker(dcd); vec explanation; PendingQueue exp_pending; exp_pending.push(nodePair); while ( exp_pending.size() > 0 ) { ERef p = exp_pending.last().first; ERef q = exp_pending.last().second; exp_pending.pop(); if (p == q) continue; ERef w = NCA(p, q); if (w == ERef_Undef) { throw OsmtInternalException("Equality explanation queried for terms not in same equivalence class"); } explainAlongPath(p, w, explanation, exp_pending, dupChecker); explainAlongPath(q, w, explanation, exp_pending, dupChecker); } cleanup(); return explanation; } // // Produce an explanation between nodes x and y // Wrapper for expExplain // vec Explainer::explain(ERef x, ERef y) { return explain({x, y}); } void Explainer::cleanup() { // Destroy the eq classes of the explanation for (auto x : exp_cleanup) { getEnode(x).setExpRoot(x); } exp_cleanup.clear(); } // // Subroutine of explain // A step of explanation for x and y // void Explainer::explainAlongPath(ERef x, ERef y, vec &outExplanation, PendingQueue &pendingExplanations, DupChecker& dc) { auto v = findAndCompress(x); // Why this? Not in the pseudo code! auto to = findAndCompress(y); while ( v != to ) { ERef p = getEnode(v).getExpParent(); assert(p != ERef_Undef); PtAsgn edgeExplanation = explainEdge(v, p, pendingExplanations, dc); if (edgeExplanation != PtAsgn_Undef) { outExplanation.push(edgeExplanation); } v = findAndCompress(p); } } /** * Enqueue the equivalence query of two n-ary terms x(a1,...,an) and y(a1,...,an). * Preconditions: x and y are n-ary terms of the same function symbol. * @param x an n-ary term over function symbol f * @param y an n-ary term over function symbol f * @param exp_pending the vector where to place the equivalences to be queried. */ void Explainer::enqueueArguments(ERef x, ERef y, PendingQueue &exp_pending) { // No explanation needed if they are the same if (x == y) { return; } // Recursively enqueue the explanations for the args Enode const & xnode = getEnode(x); Enode const & ynode = getEnode(y); assert(xnode.getSize() == ynode.getSize()); for (uint32_t i = 0; i < xnode.getSize(); ++i) { ERef xchild = xnode[i]; ERef ychild = ynode[i]; if (xchild != ychild) { exp_pending.push({xchild, ychild}); } } } PtAsgn Explainer::explainEdge(const ERef v, const ERef p, PendingQueue &exp_pending, DupChecker &dc) { assert(getEnode(v).getExpParent() == p); PtAsgn r = getEnode(v).getExpReason(); PtAsgn expl = PtAsgn_Undef; if (r.tr != PTRef_Undef) { // Not a congruence edge if (not dc.isDup(r.tr)) { expl = r; dc.storeDup(r.tr); } } else { // A congruence edge // This means that the edge is linking nodes // like (v)f(a1,...,an) (p)f(b1,...,bn), and that // a1,...,an = b1,...bn. For each pair ai,bi // we have therefore to compute the reasons assert(getEnode(v).getSymbol() == getEnode(p).getSymbol()); enqueueArguments(v, p, exp_pending); } makeUnion(v, p); return expl; } void Explainer::makeUnion(ERef x, ERef y) { // Unions are always between a node and its parent assert(getEnode(x).getExpParent() == y); // Retrieve the representant for the explanation class for x and y ERef x_exp_root = findAndCompress(x); ERef y_exp_root = findAndCompress(y); // No need to merge elements of the same class if ( x_exp_root == y_exp_root ) return; // Save highest node. It is always the node of the parent, // as it is closest to the root of the explanation tree getEnode(x_exp_root).setExpRoot(y_exp_root); // Keep track of this union exp_cleanup.push(x_exp_root); exp_cleanup.push(y_exp_root); } // // Find the representant of x's equivalence class // and meanwhile do path compression // ERef Explainer::findAndCompress(ERef x) { // If x is the root, return x if (getEnode(x).getExpRoot() == x) return x; // Recurse ERef exp_root = findAndCompress(getEnode(x).getExpRoot()); // Path compression if (exp_root != getEnode(x).getExpRoot()) { getEnode(x).setExpRoot(exp_root); exp_cleanup.push(x); } return exp_root; } // // Explain Nearest Common Ancestor // ERef Explainer::NCA(ERef x, ERef y) { // Increase time stamp ++time_stamp; auto h_x = findAndCompress(x); auto h_y = findAndCompress(y); while ( h_x != h_y ) { assert(h_x == ERef_Undef || getEnode(h_x).getExpTimeStamp() <= time_stamp); assert(h_y == ERef_Undef || getEnode(h_y).getExpTimeStamp() <= time_stamp); if ( h_x != ERef_Undef ) { // We reached a node already marked by h_y if (getEnode(h_x).getExpTimeStamp() == time_stamp) { return h_x; } // Mark the node and move to the next if (getEnode(h_x).getExpParent() != h_x) { getEnode(h_x).setExpTimeStamp(time_stamp); h_x = getEnode(h_x).getExpParent(); } } if ( h_y != ERef_Undef ) { // We reached a node already marked by h_x if (getEnode(h_y).getExpTimeStamp() == time_stamp) { return h_y; } // Mark the node and move to the next if (getEnode(h_y).getExpParent() != h_y) { getEnode(h_y).setExpTimeStamp(time_stamp); h_y = getEnode(h_y).getExpParent(); } } } // Since h_x == h_y, we return h_x assert(h_x == h_y); return h_x; } // // Undoes the effect of storeExplanation // No need for enodes // void Explainer::removeExplanation() { assert(exp_undo_stack.size() >= 2); auto x = exp_undo_stack.last(); exp_undo_stack.pop(); auto y = exp_undo_stack.last(); exp_undo_stack.pop(); assert( x != ERef_Undef ); assert( y != ERef_Undef ); // We observe that we don't need to undo the rerooting // of the explanation trees, because it doesn't affect // correctness. We just have to reroot y on itself assert( getEnode(x).getExpParent() == y || getEnode(y).getExpParent() == x); if (getEnode(x).getExpParent() == y ) { getEnode(x).setExpParent(ERef_Undef); getEnode(x).setExpReason(PtAsgn_Undef); } else { getEnode(y).setExpParent(ERef_Undef); getEnode(y).setExpReason(PtAsgn_Undef); } } PtAsgn InterpolatingExplainer::explainEdge(ERef from, ERef to, PendingQueue &exp_pending, DupChecker &dc) { PtAsgn expl = Explainer::explainEdge(from, to, exp_pending, dc); const Enode& from_node = getEnode(from); const Enode& to_node = getEnode(to); cgraph->addCNode( from_node.getTerm() ); cgraph->addCNode( to_node.getTerm() ); cgraph->addCEdge( from_node.getTerm(), to_node.getTerm(), from_node.getExpReason().tr); return expl; } vec InterpolatingExplainer::explain(ERef x, ERef y) { cgraph.reset(new CGraph()); cgraph->setConf(getEnode(x).getTerm(), getEnode(y).getTerm()); return Explainer::explain(x,y); } opensmt-2.5.2/src/tsolvers/egraph/Explainer.h000066400000000000000000000077411445011647600212440ustar00rootroot00000000000000// // Created by Martin Blicha on 15.09.20. // #ifndef OPENSMT_EXPLAINER_H #define OPENSMT_EXPLAINER_H #include "EnodeStore.h" #include "UFInterpolator.h" #include class Explainer { protected: // // Fast duplicates checking. Cannot be nested ! // struct DupChecker; class DuplicateCheckerData { Map duplicates; // Fast duplicate checking int dup_count = 0; // Current dup token bool free = true; friend struct DupChecker; }; struct DupChecker { DuplicateCheckerData &dc; DupChecker(DuplicateCheckerData &dc) : dc(dc) { if (!dc.free) { throw OsmtInternalException(); // "Attempt to re-use DuplicateChecker without releasing" } dc.free = false; if (dc.dup_count < std::numeric_limits::max()) { ++dc.dup_count; } else { dc.duplicates.clear(); dc.dup_count = 0; } } inline void storeDup(PTRef e) { assert(!dc.free); if (dc.duplicates.has(e)) dc.duplicates[e] = dc.dup_count; else dc.duplicates.insert(e, dc.dup_count); } inline bool isDup (PTRef e) { assert(!dc.free); return !dc.duplicates.has(e) ? false : dc.duplicates[e] == dc.dup_count; } ~DupChecker() { dc.free = true; } }; DuplicateCheckerData dcd; EnodeStore & store; Enode const & getEnode(ERef ref) const { return store[ref]; } Enode & getEnode(ERef ref) { return store[ref]; } // // Explanation routines and data // using PendingQueue = vec>; virtual vec explain (opensmt::pair); // Main routine for explanation virtual PtAsgn explainEdge (ERef v, ERef p, PendingQueue &exp_pending, DupChecker& dc); void explainAlongPath (ERef, ERef, vec &outExplanation, PendingQueue &exp_pending, DupChecker& dc); // Store explanation in explanation void enqueueArguments (ERef, ERef, PendingQueue &exp_pending); // Enqueue arguments to be explained void reRootOn (ERef); // Reroot the proof tree on x void makeUnion (ERef, ERef); // Union of x and y in the explanation ERef findAndCompress (ERef); // Find for the eq classes of the explanation ERef NCA (ERef, ERef); // Return the nearest common ancestor of x and y void cleanup (); // Undoes the effect of expExplain #if MORE_DEDUCTIONS vec< ERef> neq_list; #endif vec exp_undo_stack; // Keep track of exp_parent merges vec exp_cleanup; // List of nodes to be restored int time_stamp = 0; // Need for finding NCA vec> congruences; public: Explainer(EnodeStore & store) : store(store) {} virtual ~Explainer() = default; void storeExplanation (ERef, ERef, PtAsgn); // Store the explanation for the merge void removeExplanation (); // Undoes the effect of storeExplanation virtual vec explain (ERef, ERef); // Return explanation of why the given two terms are equal const vec> &getCongruences() const { return congruences; } }; class InterpolatingExplainer : public Explainer { protected: std::unique_ptr cgraph; virtual PtAsgn explainEdge (ERef, ERef, PendingQueue &exp_pending, DupChecker& dc) override; public: InterpolatingExplainer(EnodeStore & store) : Explainer(store) {} virtual vec explain (ERef, ERef) override; std::unique_ptr getCGraph() { return std::move(cgraph); } }; #endif //OPENSMT_EXPLAINER_H opensmt-2.5.2/src/tsolvers/egraph/InterpolatingEgraph.cc000066400000000000000000000001231445011647600234040ustar00rootroot00000000000000// // Created by Martin Blicha on 2018-12-15. // #include "InterpolatingEgraph.h" opensmt-2.5.2/src/tsolvers/egraph/InterpolatingEgraph.h000066400000000000000000000014271445011647600232560ustar00rootroot00000000000000// // Created by Martin Blicha on 2018-12-15. // #ifndef OPENSMT_INTERPOLATINGEGRAPH_H #define OPENSMT_INTERPOLATINGEGRAPH_H #include #include "Egraph.h" #include "UFInterpolator.h" class InterpolatingEgraph : public Egraph { public: InterpolatingEgraph(SMTConfig & c, Logic & l) : Egraph{c, l, Egraph::ExplainerType::INTERPOLATING} {} PTRef getInterpolant(const ipartitions_t& mask, UFInterpolator::ItpColorMap * labels, PartitionManager &pmanager) { InterpolatingExplainer * itp_explainer = static_cast(explainer.get()); auto cgraph = itp_explainer->getCGraph(); return UFInterpolator(config, logic, *cgraph).getInterpolant(mask, labels, pmanager); } }; #endif //OPENSMT_INTERPOLATINGEGRAPH_H opensmt-2.5.2/src/tsolvers/egraph/UFInterpolator.cc000066400000000000000000001212041445011647600223570ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ #include #include "UFInterpolator.h" #include "Logic.h" #include "OsmtInternalException.h" //#define ITP_DEBUG //#define COLOR_DEBUG CNode * CGraph::addCNode(PTRef e) { assert (e != PTRef_Undef); auto it = cnodes_store.find(e); if (it != cnodes_store.end()) { return nullptr; } auto n = new CNode(e); cnodes_store[e] = n; cnodes.push_back(n); return n; } void CGraph::clear() { while (!cnodes.empty()) { delete cnodes.back(); cnodes.pop_back(); } while (!cedges.empty()) { delete cedges.back(); cedges.pop_back(); } cnodes_store.clear(); } void UFInterpolator::colorNodes() { for (auto node : cgraph.getNodes()) { colorNode(node); } } icolor_t UFInterpolator::colorNode(CNode * c) { // Already done if (colored_nodes.find(c) != colored_nodes.end()) return c->color; icolor_t color = getTermColor(c->e); colored_nodes.insert(c); assert(color != icolor_t::I_UNDEF); return c->color = color; } void CGraph::removeCEdge(CEdge * e) { if (e == nullptr) return; for (std::size_t i = 0; i < cedges.size(); ++i) { if (cedges[i] == e) { delete e; e = nullptr; cedges.erase(cedges.begin() + i); break; } } assert(e == nullptr); } void CGraph::addCEdge(PTRef s, PTRef t, PTRef r) { assert(s != t); assert (s != PTRef_Undef); assert (t != PTRef_Undef); // Retrieve corresponding nodes CNode * cs = cnodes_store[s]; CNode * ct = cnodes_store[t]; addCEdge(cs, ct, r); } void CGraph::addCEdge(CNode * from, CNode * to, PTRef reason) { auto edge = new CEdge(from, to, reason); // Storing edge in cs and ct assert (from->edge == nullptr); from->edge = edge; cedges.push_back(edge); } void UFInterpolator::colorCGraph() { colorNodes(); // Edges can be colored as consequence of nodes CNode * c1 = cgraph.getConflictStart(); CNode * c2 = cgraph.getConflictEnd(); assert(c1 and c2); const bool no_mixed = colorEdges(c1, c2); if (!no_mixed) throw std::logic_error("Interpolation over mixed literals not supported"); } bool UFInterpolator::colorEdges(CNode * c1, CNode * c2) { std::set cache_nodes; std::set cache_edges; std::vector unprocessed_nodes; unprocessed_nodes.emplace_back(c1, c2); bool no_mixed = true; while (!unprocessed_nodes.empty() && no_mixed) { auto node_pair = unprocessed_nodes.back(); // Skip if path already seen if (cache_nodes.find(node_pair) != cache_nodes.end()) { unprocessed_nodes.pop_back(); continue; } // Push congruence children otherwise bool unprocessed_children = false; auto processPathFromNode = [&](CNode * x) { while (x->edge != nullptr) { // // Consider only sub-paths with congruence edges // Congruence edge is the first time we see // if (x->edge->reason == PTRef_Undef and cache_edges.insert(x->edge).second) { CNode * n = x->edge->target; assert(logic.getPterm(x->e).size() == logic.getPterm(n->e).size()); Pterm const & px = logic.getPterm(x->e); Pterm const & pn = logic.getPterm(n->e); // Iterate over function's arguments for (int i = 0; i < px.size(); ++i) { PTRef arg_x = px[i]; PTRef arg_n = pn[i]; if (arg_x == arg_n) continue; CNode * arg_n1 = cgraph.getNode(arg_x); CNode * arg_n2 = cgraph.getNode(arg_n); // Push only unprocessed paths path_t next_pair {arg_n1, arg_n2}; if (cache_nodes.find(next_pair) == cache_nodes.end()) { unprocessed_nodes.push_back(next_pair); unprocessed_children = true; } } } x = x->edge->target; } }; auto [n1,n2] = node_pair; // Direction n1 ----> n2 processPathFromNode(n1); // Direction n1 <--- n2 processPathFromNode(n2); // // Color children first // if (unprocessed_children) { continue; } // // Otherwise remove this pair // unprocessed_nodes.pop_back(); // // Color this path // no_mixed = colorEdgesFrom(n1) && colorEdgesFrom(n2); // // Remember this path is done // cache_nodes.insert({n1, n2}); } return no_mixed; } // // It assumes that children have been already colored // and adjusted // bool UFInterpolator::colorEdgesFrom(CNode * x) { assert (x); // Color from x CNode * n = nullptr; while (x->edge and x->edge->color == icolor_t::I_UNDEF) { n = x->edge->target; // Color basic edge with proper color if (x->edge->reason != PTRef_Undef) { x->edge->color = getLitColor(x->edge->reason); assert(x->edge->color != icolor_t::I_AB); if (x->edge->color == icolor_t::I_AB) { throw OsmtInternalException("Error in coloring information"); } } else { // Congruence edge, recurse on arguments assert (logic.getPterm(x->e).size() == logic.getPterm(n->e).size()); // Incompatible colors: this is possible // for effect of congruence nodes: adjust if ((x->color == icolor_t::I_A && n->color == icolor_t::I_B) || (x->color == icolor_t::I_B && n->color == icolor_t::I_A)) { // Need to introduce auxiliary nodes and edges // For each argument, find node that is equivalent // and of shared color vec new_args; Pterm const & px = logic.getPterm(x->e); Pterm const & pn = logic.getPterm(n->e); for (int i = 0; i < pn.size(); ++i) { PTRef arg_x = px[i]; PTRef arg_n = pn[i]; // If same node, keep if (arg_x == arg_n) { new_args.push(arg_x); } else { CNode * cn_arg_x = cgraph.getNode(arg_x); CNode * cn_arg_n = cgraph.getNode(arg_n); // There is either a path from arg_x to ABcommon // or a path from arg_n to ABcommon (or both) assert(cn_arg_x->edge or cn_arg_n->edge); PTRef abcommon = PTRef_Undef; if (cn_arg_x->color == icolor_t::I_AB) { abcommon = cn_arg_x->e; } else if (cn_arg_n->color == icolor_t::I_AB) { abcommon = cn_arg_n->e; } else { // If argument of x is incompatible with n std::vector sorted; size_t xnl = getSortedEdges(cn_arg_x, cn_arg_n, sorted); (void) xnl; for (CEdge * edge : sorted) { CNode * from = edge->source; CNode * to = edge->target; assert(from->color != icolor_t::I_UNDEF and to->color != icolor_t::I_UNDEF); if (from->color == icolor_t::I_AB or to->color == icolor_t::I_AB) { abcommon = from->color == icolor_t::I_AB ? from->e : to->e; break; } } } assert (abcommon != PTRef_Undef); assert (cgraph.getNode(abcommon)->color == icolor_t::I_AB); new_args.push(abcommon); } } PTRef nn = logic.mkUninterpFun(logic.getPterm(x->e).symb(), std::move(new_args)); if (nn == x->e) { x->color = icolor_t::I_AB; } else if (nn == n->e) { n->color = icolor_t::I_AB; } else { splitEdge(x->edge, nn); x = x->edge->target; } } // Now all the children are colored, we can decide how to color this colorCongruenceEdge(x->edge); } // This edge has been colored colored_edges.insert(x->edge); assert (x->edge->color == icolor_t::I_A || x->edge->color == icolor_t::I_B); // Pass to next node x = n; } // No abmixed if here return true; } void UFInterpolator::colorCongruenceEdge(CEdge * edge) { assert(edge); CNode * from = edge->source; CNode * to = edge->target; if (from->color == to->color) { assert (from->color != icolor_t::I_UNDEF); edge->color = from->color == icolor_t::I_AB ? resolveABColor() : from->color; } else { // Different colors: choose intersection // It is not possible that the colors are incompatible assert (from->color != icolor_t::I_A or to->color != icolor_t::I_B); assert (from->color != icolor_t::I_B or to->color != icolor_t::I_A); edge->color = static_cast(from->color & to->color); assert (edge->color == icolor_t::I_A or edge->color == icolor_t::I_B); } } icolor_t UFInterpolator::determineDisequalityColor(PTRef t1, PTRef t2, ItpColorMap const & conflictColors) const { icolor_t conf_color = icolor_t::I_UNDEF; PTRef eq = logic.mkEq(t1, t2); if (conflictColors.find(eq) != conflictColors.end()) { conf_color = conflictColors.at(eq); if (conf_color == icolor_t::I_AB) { conf_color = resolveABColor(); } } else { auto it = std::find_if(conflictColors.begin(), conflictColors.end(), [this](auto const & entry) { return logic.isDisequality(entry.first); }); if (it != conflictColors.end()) { Pterm const & distinctTerm = logic.getPterm(it->first); bool t1Present = std::find(distinctTerm.begin(), distinctTerm.end(), t1) != distinctTerm.end(); bool t2Present = std::find(distinctTerm.begin(), distinctTerm.end(), t2) != distinctTerm.end(); assert(t1Present and t2Present); if (not(t1Present and t2Present)) { throw OsmtInternalException("Error in UF interpolator, could not determine the color of the conflict equality"); } else { conf_color = it->second; if (conf_color == icolor_t::I_AB) { conf_color = resolveABColor(); } } } else { // equality of two different constants derived assert(logic.isConstant(t1) && logic.isConstant(t2)); if (not(logic.isConstant(t1) && logic.isConstant(t2))) { throw OsmtInternalException("Error in UF interpolator, could not determine the color of the conflict equality"); } conf_color = resolveABColor(); } } assert(conf_color == icolor_t::I_A or conf_color == icolor_t::I_B); return conf_color; } // // Here mask is a bit-mask of the form 1..10..0 // which indicates the current splitting for the // formula into A and B. // PTRef UFInterpolator::getInterpolant(const ipartitions_t & mask, ItpColorMap * labels, PartitionManager & pmanager) { assert(labels); if (labels) { colorInfo = std::make_unique(pmanager, mask); litColors = *labels; } else { throw OsmtInternalException("Error in UFInterpolator::getInterpolant! No labels passed"); } srand(2); colorCGraph(); // Traverse the graph, look for edges of "color" to summarize CNode * c1 = cgraph.getConflictStart(); CNode * c2 = cgraph.getConflictEnd(); assert(c1); assert(c2); const path_t pi = path(c1, c2); // // Compute interpolant as described in Fuchs et al. paper // Ground Interpolation for the Theory of Equality // icolor_t conf_color = determineDisequalityColor(c1->e, c2->e, *labels); PTRef result = PTRef_Undef; // Conflict belongs to A part if (conf_color == icolor_t::I_A) { if (usingStrong()) result = Iprime(pi); else if (usingWeak()) result = logic.mkNot(ISwap(pi)); else if (usingRandom()) result = (rand() % 2) ? Iprime(pi) : logic.mkNot(ISwap(pi)); } // Much simpler case when conflict belongs to B else if (conf_color == icolor_t::I_B) { if (usingStrong()) result = I(pi); else if (usingWeak()) result = logic.mkNot(IprimeSwap(pi)); else if (usingRandom()) result = (rand() % 2) ? I(pi) : logic.mkNot(IprimeSwap(pi)); } else { throw OsmtInternalException("something went wrong"); } assert (result != PTRef_Undef); return result; } // // Retrieve subpaths. Returns false if the // entire path belongs to A, which means // that the interpolant is "false" // bool UFInterpolator::getSubpaths(const path_t & pi, path_t & pi_1, path_t & theta, path_t & pi_2) { CNode * x = pi.first; CNode * y = pi.second; assert(x); assert(y); // Sorted list of edges from x std::vector sorted_edges; getSortedEdges(x, y, sorted_edges); CNode * lnode = nullptr; CNode * rnode = nullptr; icolor_t scolor = x->color; icolor_t tcolor = y->color; if (scolor == icolor_t::I_B || scolor == icolor_t::I_AB) lnode = x; else if (tcolor == icolor_t::I_B || tcolor == icolor_t::I_AB) lnode = y; if (tcolor == icolor_t::I_B || tcolor == icolor_t::I_AB) rnode = y; else if (scolor == icolor_t::I_B || scolor == icolor_t::I_AB) rnode = x; if (not lnode or not rnode) { for (auto edge : sorted_edges) { scolor = edge->source->color; tcolor = edge->target->color; if (not lnode) { if (scolor == icolor_t::I_B || scolor == icolor_t::I_AB) lnode = edge->source; else if (tcolor == icolor_t::I_B || tcolor == icolor_t::I_AB) lnode = edge->target; } if (not rnode) { if (tcolor == icolor_t::I_B || tcolor == icolor_t::I_AB) rnode = edge->target; else if (scolor == icolor_t::I_B || scolor == icolor_t::I_AB) rnode = edge->source; } } } if (not lnode or not rnode or lnode == rnode) { //theta empty pi_1.first = pi.first; pi_1.second = pi.first; pi_2.first = pi.first; pi_2.second = pi.second; return false; } theta.first = lnode; theta.second = rnode; pi_1.first = pi.first; pi_1.second = theta.first; pi_2.first = theta.second; pi_2.second = pi.second; return true; } bool UFInterpolator::getSubpathsSwap(const path_t & pi, path_t & pi_1, path_t & theta, path_t & pi_2) { CNode * x = pi.first; CNode * y = pi.second; assert(x); assert(y); // Sorted list of edges from x std::vector sorted_edges; getSortedEdges(x, y, sorted_edges); CNode * lnode = nullptr; CNode * rnode = nullptr; icolor_t scolor = x->color; icolor_t tcolor = y->color; if (scolor == icolor_t::I_A || scolor == icolor_t::I_AB) lnode = x; else if (tcolor == icolor_t::I_A || tcolor == icolor_t::I_AB) lnode = y; if (tcolor == icolor_t::I_A || tcolor == icolor_t::I_AB) rnode = y; else if (scolor == icolor_t::I_A || scolor == icolor_t::I_AB) rnode = x; if (not lnode || not rnode) { for (auto edge : sorted_edges) { scolor = edge->source->color; tcolor = edge->target->color; if (not lnode) { if (scolor == icolor_t::I_A || scolor == icolor_t::I_AB) lnode = edge->source; else if (tcolor == icolor_t::I_A || tcolor == icolor_t::I_AB) lnode = edge->target; } if (not rnode) { if (tcolor == icolor_t::I_A || tcolor == icolor_t::I_AB) rnode = edge->target; else if (scolor == icolor_t::I_A || scolor == icolor_t::I_AB) rnode = edge->source; } } } if (not lnode || not rnode || lnode == rnode) { //theta empty pi_1.first = pi.first; pi_1.second = pi.first; pi_2.first = pi.first; pi_2.second = pi.second; return false; } theta.first = lnode; theta.second = rnode; pi_1.first = pi.first; pi_1.second = theta.first; pi_2.first = theta.second; pi_2.second = pi.second; return true; } PTRef UFInterpolator::J(const path_t & p, std::vector & b_paths) { // True on empty path if (p.first == p.second) return logic.getTerm_true(); vec conj; for (const auto & path : b_paths) { conj.push(logic.mkEq(path.first->e, path.second->e)); } PTRef implicant = logic.mkAnd(conj); PTRef implicated = logic.mkEq(p.first->e, p.second->e); // Notice that it works also for A-paths like // // false --> (<= x0 1) --> (<= 2 1) // // this path says that (<= 2 1) is false, so the implicated // should be (not (<= 2 1)) PTRef res = logic.mkImpl(implicant, implicated); return res; } PTRef UFInterpolator::Iprime(const path_t & pi) { vec conj; // Compute largest subpath of c1 -- c2 // with B-colorable endpoints path_t pi_1, pi_2, theta; bool empty_theta = not getSubpaths(pi, pi_1, theta, pi_2); // Compute B( pi_1 ) U B( pi_2 ) std::vector b_paths; B(pi_1, b_paths); B(pi_2, b_paths); if (!empty_theta) { conj.push(I(theta)); } for (const auto & path : b_paths) conj.push(I(path)); // Finally compute implication vec conj_impl; for (const auto & path : b_paths) conj_impl.push(logic.mkEq(path.first->e, path.second->e)); PTRef implicant = logic.mkAnd(conj_impl); PTRef implicated = PTRef_Undef; if (empty_theta) implicated = logic.getTerm_false(); else implicated = logic.mkNot(logic.mkEq(theta.first->e, theta.second->e)); conj.push(logic.mkImpl(implicant, implicated)); return logic.mkAnd(std::move(conj)); } PTRef UFInterpolator::IprimeSwap(const path_t & pi) { vec conj; // Compute largest subpath of c1 -- c2 // with B-colorable endpoints path_t pi_1, pi_2, theta; bool empty_theta = !getSubpathsSwap(pi, pi_1, theta, pi_2); // Compute B( pi_1 ) U B( pi_2 ) std::vector b_paths; BSwap(pi_1, b_paths); BSwap(pi_2, b_paths); if (!empty_theta) { conj.push(ISwap(theta)); } for (const auto & path : b_paths) conj.push(ISwap(path)); // Finally compute implication vec conj_impl; for (const auto & path : b_paths) { conj_impl.push(logic.mkEq(path.first->e, path.second->e)); } PTRef implicant = logic.mkAnd(conj_impl); PTRef implicated = PTRef_Undef; if (empty_theta) implicated = logic.getTerm_false(); else implicated = logic.mkNot(logic.mkEq(theta.first->e, theta.second->e)); conj.push(logic.mkImpl(implicant, implicated)); return logic.mkAnd(std::move(conj)); } PTRef UFInterpolator::I(const path_t & p) { std::map cache; return Irec(p, cache); } PTRef UFInterpolator::ISwap(const path_t & p) { std::map cache; return IrecSwap(p, cache); } PTRef UFInterpolator::Irec(const path_t & p, std::map & cache) { // True on empty path if (p.first == p.second) return logic.getTerm_true(); vec conj; vec conj_swap; // Will store factors std::vector factors; factors.push_back(p); // Will store parents of B-path std::vector parents; const bool a_factor = getFactorsAndParents(p, factors, parents); if (factors.size() == 1) { // It's an A-path if (a_factor) { // Compute J std::vector b_premise_set; B(p, b_premise_set); conj.push(J(p, b_premise_set)); for (const auto & fac : b_premise_set) { assert (L.find(fac) != L.end()); if (L[fac] == icolor_t::I_B) { conj.push(Irec(fac, cache)); } else { //swap here conj_swap.push(logic.mkNot(IprimeSwap(fac))); } } if (conj_swap.size() > 0) { conj.push(logic.mkAnd(conj_swap)); } } // It's a B-path else { // Recurse on parents for (auto const & parent : parents) conj.push(Irec(parent, cache)); } } else { // Recurse on factors if (factors.size() > 3 && config.itp_euf_alg() > 3) { bool la, lb, lab, ra, rb, rab; for (std::size_t i = 0; i < factors.size(); i += 3) { std::size_t j = i + 2; if (j >= factors.size()) j = (factors.size() - 1); path_t pf(factors[i].first, factors[j].second); CNode * l = pf.first; CNode * r = pf.second; std::vector infactors; infactors.push_back(pf); std::vector inparents; const bool a_factor = getFactorsAndParents(pf, infactors, inparents); if (j < (factors.size() - 1)) assert (infactors.size() >= 3); if (infactors.size() >= 2) { if (a_factor) { conj.push(logic.mkNot(IprimeSwap(pf))); } else { conj.push(Irec(pf, cache)); } continue; } la = lb = lab = ra = rb = rab = false; if (l->color == icolor_t::I_A) la = true; else if (l->color == icolor_t::I_B) lb = true; else lab = true; if (r->color == icolor_t::I_A) ra = true; else if (r->color == icolor_t::I_B) rb = true; else rab = true; assert (not ((la and rb) or (lb and ra))); bool b = true;//rand() % 2; if (la or ra) { // conflict in A, call I' or not S assert (i == 0 or j == (factors.size() - 1)); if (b and config.itp_euf_alg() == 4) { conj.push(Irec(pf, cache)); } else { conj.push(logic.mkNot(IprimeSwap(pf))); } } else if (lb or rb) { // conflict in B, call I or not S' assert (i == 0 or j == (factors.size() - 1)); if (b and config.itp_euf_alg() == 4) { conj.push(Irec(pf, cache)); } else { conj.push(logic.mkNot(IprimeSwap(pf))); } } else { // conflict has global endpoints if (b and config.itp_euf_alg() == 4) { conj.push(Irec(pf, cache)); } else { conj.push(logic.mkNot(IprimeSwap(pf))); } } } } else { for (const auto & factor : factors) conj.push(Irec(factor, cache)); } } PTRef res = logic.mkAnd(std::move(conj)); assert (res != PTRef_Undef); return res; } PTRef UFInterpolator::IrecSwap(const path_t & p, std::map & cache) { // True on empty path if (p.first == p.second) return logic.getTerm_true(); vec conj; vec conj_swap; // Will store factors std::vector factors; factors.push_back(p); // Will store parents of A-path std::vector parents; const bool a_factor = getFactorsAndParents(p, factors, parents); if (factors.size() == 1) { // It's a B-path if (!a_factor) { // Compute J std::vector b_premise_set; BSwap(p, b_premise_set); conj.push(J(p, b_premise_set)); for (const auto & fac : b_premise_set) { assert (L.find(fac) != L.end()); if (L[fac] == icolor_t::I_A) { conj.push(IrecSwap(fac, cache)); } else { conj_swap.push(logic.mkNot(Iprime(fac))); } } if (conj_swap.size() > 0) { conj.push(logic.mkAnd(conj_swap)); } } else { // It's an A-path // Recurse on parents for (const auto & parent : parents) { conj.push(IrecSwap(parent, cache)); } } } else { // Recurse on factors if (factors.size() > 3 and config.itp_euf_alg() > 3) { bool la, lb, lab, ra, rb, rab; for (std::size_t i = 0; i < factors.size(); i += 3) { std::size_t j = i + 2; if (j >= factors.size()) j = (factors.size() - 1); path_t pf(factors[i].first, factors[j].second); CNode * l = pf.first; CNode * r = pf.second; std::vector infactors; infactors.push_back(pf); std::vector inparents; const bool a_factor = getFactorsAndParents(pf, infactors, inparents); if (j < (factors.size() - 1)) assert (infactors.size() >= 3); if (infactors.size() >= 2) { if (!a_factor) conj.push(logic.mkNot(Iprime(pf))); else conj.push(IrecSwap(pf, cache)); continue; } la = lb = lab = ra = rb = rab = false; if (l->color == icolor_t::I_A) la = true; else if (l->color == icolor_t::I_B) lb = true; else lab = true; if (r->color == icolor_t::I_A) ra = true; else if (r->color == icolor_t::I_B) rb = true; else rab = true; assert (not ((la and rb) or (lb and ra))); bool b = true;//rand() % 2; if (la or ra) { assert (i == 0 or j == (factors.size() - 1)); if (b and config.itp_euf_alg() == 4) { conj.push(logic.mkNot(Iprime(pf))); } else { conj.push(IrecSwap(pf, cache)); } } else if (lb or rb) { assert (i == 0 or j == (factors.size() - 1)); if (b and config.itp_euf_alg() == 4) { conj.push(logic.mkNot(Iprime(pf))); } else { conj.push(IrecSwap(pf, cache)); } } else { // conflict has global endpoints if (b and config.itp_euf_alg() == 4) { conj.push(logic.mkNot(Iprime(pf))); } else { conj.push(IrecSwap(pf, cache)); } } } } else { for (const auto & factor : factors) { conj.push(IrecSwap(factor, cache)); } } } PTRef res = logic.mkAnd(std::move(conj)); assert (res != PTRef_Undef); return res; } void UFInterpolator::B(const path_t & p, std::vector & b_premise_set) { std::set cache; Brec(p, b_premise_set, cache); } void UFInterpolator::BSwap(const path_t & p, std::vector & a_premise_set) { std::set cache; BrecSwap(p, a_premise_set, cache); } void UFInterpolator::Brec(const path_t & p, std::vector & b_premise_set, std::set & cache) { // Skip trivial call if (p.first == p.second) return; // Skip seen calls if (!cache.insert(p).second) return; // Will store factors std::vector factors; factors.push_back(p); // Will store parents of B-path std::vector parents; const bool a_factor = getFactorsAndParents(p, factors, parents); if (factors.size() == 1) { // It's an A-path if (a_factor) { for (const auto & parent : parents) Brec(parent, b_premise_set, cache); } else { // It's a B-path b_premise_set.push_back(p); } } else { // Recurse on factors for (const auto & factor : factors) Brec(factor, b_premise_set, cache); } } void UFInterpolator::BrecSwap(const path_t & p, std::vector & a_premise_set, std::set & cache) { // Skip trivial call if (p.first == p.second) return; // Skip seen calls if (!cache.insert(p).second) return; // Will store factors std::vector factors; factors.push_back(p); // Will store parents of B-path std::vector parents; const bool a_factor = getFactorsAndParents(p, factors, parents); if (factors.size() == 1) { // It's an A-path if (not a_factor) { for (const auto & parent : parents) BrecSwap(parent, a_premise_set, cache); } else { // It's a B-path a_premise_set.push_back(p); } } else { // Recurse on factors for (const auto & factor : factors) BrecSwap(factor, a_premise_set, cache); } } // // We don't know how to reach x from y. There are // three cases to consider (see below). This procedure // retrieves the edges in the correct order to reach // y from x // size_t UFInterpolator::getSortedEdges(CNode * x, CNode * y, std::vector & sorted_edges) { assert (x); assert (y); assert (x != y); CNode * x_orig = x; CNode * y_orig = y; std::set visited; visited.insert(x); visited.insert(y); std::vector & from_x = sorted_edges; std::vector tmp; bool done = false; while (not done) { // Advance x by 1 if (x->edge != nullptr) { CEdge * candidate = x->edge; x = x->edge->target; // Touching an already seen node (by y) // x is the nearest common ancestor // Clear y vector until x is found if (not visited.insert(x).second) { while (not tmp.empty() and tmp.back()->target != x) { tmp.pop_back(); } done = true; } from_x.push_back(candidate); } if (done) break; // Advance y by 1 if (y->edge) { CEdge * candidate = y->edge; y = y->edge->target; // Touching an already seen node (by x) // y is the nearest common ancestor // Clear x vector until y is found if (not visited.insert(y).second) { while (not from_x.empty() && from_x.back()->target != y) { from_x.pop_back(); } done = true; } tmp.push_back(candidate); } } x = x_orig; y = y_orig; const size_t x_path_length = sorted_edges.size(); // The two paths must collide assert (not tmp.empty() or sorted_edges.back()->target == y); assert (not sorted_edges.empty() or tmp.back()->target == x); assert (sorted_edges.empty() or tmp.empty() or sorted_edges.back()->target == tmp.back()->target); // Now load edges from y in the correct order while (not tmp.empty()) { sorted_edges.push_back(tmp.back()); tmp.pop_back(); } return x_path_length; } icolor_t UFInterpolator::resolveABColor() const { if (usingStrong()) { return icolor_t::I_B; } else if (usingWeak()) { return icolor_t::I_A; } else if (usingRandom()) { return (rand() % 2) ? icolor_t::I_A : icolor_t::I_B; } else { assert(false); return icolor_t::I_B; } } // // Return the set of factors bool UFInterpolator::getFactorsAndParents(const path_t & p, std::vector & factors, std::vector & parents) { assert (factors.size() == 1); assert (parents.empty()); CNode * x = p.first; CNode * y = p.second; assert (x); assert (y); std::vector sorted_edges; const size_t x_path_length = getSortedEdges(x, y, sorted_edges); const bool a_factor = sorted_edges[0]->color == icolor_t::I_A; icolor_t last_color = sorted_edges[0]->color; x = 0 < x_path_length ? sorted_edges[0]->target : sorted_edges[0]->source; y = p.second; size_t i = 1; // Add parents if (sorted_edges[0]->reason == PTRef_Undef) { CNode * tx = p.first; CNode * tn = x; assert (logic.getPterm(tx->e).size() == logic.getPterm(tn->e).size()); // Examine children of the congruence edge Pterm const & px = logic.getPterm(tx->e); Pterm const & pn = logic.getPterm(tn->e); for (int j = 0; j < px.size(); ++j) { PTRef arg_tx = px[j]; PTRef arg_tn = pn[j]; if (arg_tn == arg_tx) continue; // Add parents for further recursion parents.push_back(path(cgraph.getNode(arg_tx), cgraph.getNode(arg_tn))); } } CNode * n; while (x != y) { // Next x n = i < x_path_length ? sorted_edges[i]->target : sorted_edges[i]->source; // Retrieve parents for congruence edges if (sorted_edges[i]->reason == PTRef_Undef) { assert (logic.getPterm(x->e).size() == logic.getPterm(n->e).size()); // Examine children of the congruence edge Pterm const & px = logic.getPterm(x->e); Pterm const & pn = logic.getPterm(n->e); for (int j = 0; j < px.size(); ++j) { PTRef arg_x = px[j]; PTRef arg_n = pn[j]; if (arg_n == arg_x) continue; // Add parents for further recursion parents.push_back(path(cgraph.getNode(arg_x), cgraph.getNode(arg_n))); } } // New factor if (i < sorted_edges.size() and sorted_edges[i]->color != last_color) { factors.back().second = x; factors.push_back(path(x, y)); last_color = sorted_edges[i]->color; } i++; x = n; } labelFactors(factors); return a_factor; } void UFInterpolator::labelFactors(std::vector & factors) { // McMillan if (usingStrong()) for (const auto & factor : factors) L[factor] = icolor_t::I_B; // McMillan' else if (usingWeak()) for (const auto & factor : factors) L[factor] = icolor_t::I_A; // Random else if (usingRandom()) { for (const auto & factor : factors) { if (rand() % 2) { L[factor] = icolor_t::I_B; } else { L[factor] = icolor_t::I_A; } } } } void UFInterpolator::printAsDotty(std::ostream & os) { os << "digraph cgraph {" << '\n'; // Print all nodes for (CNode * c : cgraph.getNodes()) { std::string color = "grey"; if (c->color == icolor_t::I_A) color = "red"; if (c->color == icolor_t::I_B) color = "blue"; if (c->color == icolor_t::I_AB) color = "green"; os << logic.getPterm(c->e).getId().x << " [label=\"" << logic.pp(c->e) << "\",color=\"" << color << "\",style=filled]" << '\n'; } // Print all edges for (CEdge * c : cgraph.getEdges()) { std::string color = "grey"; if (c->color == icolor_t::I_A) color = "red"; if (c->color == icolor_t::I_B) color = "blue"; if (c->color == icolor_t::I_AB) color = "green"; os << logic.getPterm(c->source->e).getId().x << " -> " << logic.getPterm(c->target->e).getId().x << " [color=\"" << color << "\",style=\"bold" << (c->reason == PTRef_Undef ? ",dashed" : "") << "\"]" << '\n'; } // Print conflict os << logic.pp(cgraph.getConflictStart()->e) << " -> " << logic.pp(cgraph.getConflictEnd()->e) << " [style=bold]" << '\n'; os << "}" << '\n'; } bool UFInterpolator::checkColors() const { for (CEdge * edge : cgraph.getEdges()) { // Edge that is not involved if (edge->color == icolor_t::I_UNDEF) continue; // Check color is A or B if (edge->color != icolor_t::I_A and edge->color != icolor_t::I_B) return false; // Check color is consistent with nodes if ((edge->color & edge->source->color) == icolor_t::I_UNDEF || (edge->color & edge->target->color) == icolor_t::I_UNDEF) { return false; } } return true; } void UFInterpolator::splitEdge(CEdge * edge, PTRef intermediateTerm) { assert(edge); CNode * from = edge->source; CNode * to = edge->target; assert (from->edge->target == to); // Adds corresponding node CNode * intermediate = nullptr; CNode * intermediate_next = nullptr; PTRef intermediate_next_reason = PTRef_Undef; if (cgraph.hasNode(intermediateTerm)) { intermediate = cgraph.getNode(intermediateTerm); if (intermediate->edge) { intermediate_next = intermediate->edge->target; intermediate_next_reason = intermediate->edge->reason; cgraph.removeCEdge(intermediate->edge); } intermediate->edge = nullptr; } else { intermediate = cgraph.addCNode(intermediateTerm); } intermediate->color = icolor_t::I_AB; // We have the intermediate node in hand, now we need to remove edge "from -> to" and // add edges "from -> intermediate"; "intermediate -> to" cgraph.removeCEdge(edge); from->edge = nullptr; cgraph.addCEdge(from, intermediate, PTRef_Undef); assert(from->edge != nullptr); // the added edge is from->next assert(from->edge->target == intermediate); // Choose a color; we know that intermediate is AB, so we color edge based on from assert (from->color == icolor_t::I_A || from->color == icolor_t::I_B || from->color == icolor_t::I_AB); from->edge->color = from->color == icolor_t::I_AB ? resolveABColor() : from->color; cgraph.addCEdge(intermediate, to, PTRef_Undef); if (intermediate_next) { // MB: There are two special cases: when `intermediate_next` was `to` and when it was `from` if (intermediate_next == to) { // In this case a new edge from `to` to `intermediate_next` would be a self-loop // We simple do not add it, but use the original reason intermediate->edge->reason = intermediate_next_reason; } else if (intermediate_next == from) { // In this case a new edge from `to` to `intermediate_next` would form a triangular loop // `from` -> `intermediate` -> `to` -> `from` // We do not add the edge, but update the reason for edge `from` -> `intermediate` assert(from->edge->reason == PTRef_Undef); from->edge->reason = intermediate_next_reason; } else { cgraph.addCEdge(to, intermediate_next, intermediate_next_reason); } } } opensmt-2.5.2/src/tsolvers/egraph/UFInterpolator.h000066400000000000000000000146501445011647600222270ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012 Roberto Bruttomesso 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. *********************************************************************/ /* Based on the paper * @article{DBLP:journals/corr/abs-1111-5652, * author = {Alexander Fuchs and Amit Goel and Jim Grundy and Sava Krstic and * Cesare Tinelli}, * title = {Ground interpolation for the theory of equality}, * journal = {Logical Methods in Computer Science}, * volume = {8}, * number = {1}, * year = {2012}, * ee = {http://dx.doi.org/10.2168/LMCS-8(1:6)2012}, * bibsource = {DBLP, http://dblp.uni-trier.de} * } */ #ifndef UF_INTERPOLATOR_H #define UF_INTERPOLATOR_H #include "SMTConfig.h" #include "PTRef.h" #include "TheoryInterpolator.h" #include #include struct CEdge; class Logic; struct CNode { CNode(PTRef e_) : e(e_), color(icolor_t::I_UNDEF), edge(nullptr) { } PTRef e; icolor_t color; CEdge * edge; }; typedef std::pair path_t; struct CEdge { CEdge(CNode * s, CNode * t, PTRef r) : source(s), target(t), reason(r), color(icolor_t::I_UNDEF) { assert(source); assert(target); } CNode * source; CNode * target; PTRef reason; icolor_t color; }; class CGraph { std::vector cnodes; std::vector cedges; std::map cnodes_store; PTRef conf1 = PTRef_Undef; PTRef conf2 = PTRef_Undef; void clear(); public: std::vector const & getNodes() const { return cnodes; } std::vector const & getEdges() const { return cedges; } bool hasNode(PTRef term) const { return cnodes_store.find(term) != cnodes_store.end(); } CNode * getNode(PTRef term) const { return cnodes_store.at(term); } CNode * addCNode (PTRef e); void addCEdge (PTRef, PTRef, PTRef); void addCEdge (CNode *, CNode *, PTRef); void removeCEdge(CEdge *); CNode* getConflictStart() const { assert(conf1 != PTRef_Undef); return cnodes_store.at(conf1); } CNode* getConflictEnd() const { assert(conf2 != PTRef_Undef); return cnodes_store.at(conf2); } inline void setConf(PTRef c1, PTRef c2) { // cout << "SetConf: " << logic.printTerm(c1) << " = " << logic.printTerm(c2) << endl; assert(conf1 == PTRef_Undef); assert(conf2 == PTRef_Undef); assert(c1 != PTRef_Undef); assert(c2 != PTRef_Undef); conf1 = c1; conf2 = c2; } ~CGraph( ) { clear( ); } }; class UFInterpolator : public TheoryInterpolator { public: UFInterpolator(SMTConfig & config_, Logic & logic_, CGraph & cgraph) : config(config_), logic(logic_), cgraph(cgraph) {} inline int verbose() const { return config.verbosity(); } PTRef getInterpolant(const ipartitions_t &, ItpColorMap *, PartitionManager &) override; void printAsDotty(std::ostream &); private: icolor_t getLitColor(PTRef term) const { assert(litColors.find(term) != litColors.end()); return litColors.at(term); } icolor_t getTermColor(PTRef term) const { assert(colorInfo); return colorInfo->getColorFor(term); } icolor_t determineDisequalityColor(PTRef t1, PTRef t2, ItpColorMap const & conflictColors) const; void colorCGraph(); void colorNodes(); icolor_t colorNode(CNode * c); bool colorEdges(CNode * c1, CNode * c2); bool colorEdgesFrom(CNode * x); void colorCongruenceEdge(CEdge * edge); void splitEdge(CEdge * edge, PTRef intermediateTerm); size_t getSortedEdges(CNode *, CNode *, std::vector &); icolor_t resolveABColor() const; bool usingStrong() const { return config.getEUFInterpolationAlgorithm() == itp_euf_alg_strong; } bool usingWeak() const { return config.getEUFInterpolationAlgorithm() == itp_euf_alg_weak; } bool usingRandom() const { return config.getEUFInterpolationAlgorithm() == itp_euf_alg_random; } bool getSubpaths(const path_t &, path_t &, path_t &, path_t &); bool getSubpathsSwap(const path_t &, path_t &, path_t &, path_t &); PTRef I(const path_t &); PTRef Iprime(const path_t &); PTRef ISwap(const path_t &); PTRef IprimeSwap(const path_t &); PTRef Irec(const path_t & p, std::map & cache); PTRef IrecSwap(const path_t & p, std::map & cache); PTRef J(const path_t &, std::vector &); PTRef JSwap(const path_t &, std::vector &); void B(const path_t &, std::vector &); void BSwap(const path_t &, std::vector &); void Brec(const path_t &, std::vector &, std::set &); void BrecSwap(const path_t &, std::vector &, std::set &); bool getFactorsAndParents(const path_t &, std::vector &, std::vector &); void labelFactors(std::vector &); inline path_t path(CNode * c1, CNode * c2) { return {c1, c2}; } bool checkColors() const; SMTConfig & config; Logic & logic; CGraph & cgraph; ItpColorMap litColors; // MB: this is needed because edges need to be colored exactly as the literals in the conflict std::set colored_nodes; std::set colored_edges; std::unique_ptr colorInfo; std::map L; }; #endif opensmt-2.5.2/src/tsolvers/emptysolver/000077500000000000000000000000001445011647600202565ustar00rootroot00000000000000opensmt-2.5.2/src/tsolvers/emptysolver/EmptySolver.cc000066400000000000000000000072661445011647600230710ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ // // This is an empty solver to be used as a template for the // development of ordinary theory solvers. // #include "EmptySolver.h" EmptySolver::EmptySolver( const int i , const char * n , SMTConfig & c , Egraph & e , SStore & t , vector< Enode * > & x , vector< Enode * > & d , vector< Enode * > & s ) : OrdinaryTSolver ( i, n, c, e, t, x, d, s ) { // Here Allocate External Solver } EmptySolver::~EmptySolver( ) { // Here Deallocate External Solver } // // The solver is informed of the existence of // atom e. It might be useful for initializing // the solver's data structures. This function is // called before the actual solving starts. // lbool EmptySolver::inform( Enode * e ) { (void)e; assert( e ); assert( belongsToT( e ) ); return l_Undef; } // // Asserts a literal into the solver. If by chance // you are able to discover inconsistency you may // return false. The real consistency state will // be checked with "check" // bool EmptySolver::assertLit ( Enode * e, bool reason ) { (void)e; (void)reason; assert( e ); assert( belongsToT( e ) ); return true; } // // Saves a backtrack point // You are supposed to keep track of the // operations, for instance in a vector // called "undo_stack_term", as happens // in EgraphSolver // void EmptySolver::pushBacktrackPoint ( ) { } // // Restore a previous state. You can now retrieve // the size of the stack when you pushed the last // backtrack point. You have to implement the // necessary backtrack operations // (see for instance backtrackToStackSize( ) // in EgraphSolver) // Also make sure you clean the deductions you // did not communicate // void EmptySolver::popBacktrackPoint ( ) { } // // Check for consistency. If flag is // set make sure you run a complete check // bool EmptySolver::check( bool complete ) { (void)complete; // Here check for consistency return true; } // // Return true if the enode belongs // to this theory. You should examine // the structure of the node to see // if it matches the theory operators // bool EmptySolver::belongsToT( Enode * e ) { (void)e; assert( e ); return true; } // // Copy the model into enode's data // void EmptySolver::computeModel( ) { } #ifdef PRODUCE_PROOF Enode * EmptySolver::getInterpolants( ) { return NULL; } #endif opensmt-2.5.2/src/tsolvers/emptysolver/EmptySolver.h000066400000000000000000000041211445011647600227160ustar00rootroot00000000000000/********************************************************************* Author: Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008-2012, Roberto Bruttomesso 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. *********************************************************************/ #ifndef EMPTYSOLVER_H #define EMPTYSOLVER_H #include "TSolver.h" class EmptySolver : public OrdinaryTSolver { public: EmptySolver( const int , const char * , SMTConfig & , Egraph & , SStore & , vector< Enode * > & , vector< Enode * > & , vector< Enode * > & ); ~EmptySolver ( ); lbool inform ( Enode * ); bool assertLit ( Enode *, bool = false ); void pushBacktrackPoint ( ); void popBacktrackPoint ( ); bool check ( bool ); bool belongsToT ( Enode * ); void computeModel ( ); #ifdef PRODUCE_PROOF Enode * getInterpolants ( ); #endif }; #endif opensmt-2.5.2/src/tsolvers/lasolver/000077500000000000000000000000001445011647600175145ustar00rootroot00000000000000opensmt-2.5.2/src/tsolvers/lasolver/CMakeLists.txt000066400000000000000000000027711445011647600222630ustar00rootroot00000000000000target_sources(tsolvers PUBLIC "${CMAKE_CURRENT_LIST_DIR}/LASolver.h" PUBLIC "${CMAKE_CURRENT_LIST_DIR}/Simplex.h" PUBLIC "${CMAKE_CURRENT_LIST_DIR}/Matrix.h" PUBLIC "${CMAKE_CURRENT_LIST_DIR}/LIAInterpolator.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/LAVar.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/LAVarMapper.cc" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/Tableau.cc" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/LABounds.cc" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/Delta.cc" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/LAVar.cc" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/Polynomial.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/Tableau.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/LAVarMapper.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/LARefs.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/LABounds.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/LRAModel.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/LRAModel.cc" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/Delta.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/LASolver.cc" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/Simplex.cc" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/FarkasInterpolator.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/FarkasInterpolator.cc" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/Matrix.cc" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/SparseMatrix.cc" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/LIAInterpolator.cc" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/CutCreator.cc" ) option(SIMPLEX_DEBUG "Deeper debugging of Simplex" OFF) if (SIMPLEX_DEBUG) add_definitions(-DSIMPLEX_DEBUG) endif (SIMPLEX_DEBUG) opensmt-2.5.2/src/tsolvers/lasolver/CutCreator.cc000066400000000000000000000022031445011647600220730ustar00rootroot00000000000000/* * Copyright (c) 2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #include "CutCreator.h" CutCreator::Cut CutCreator::makeCut(SparseLinearSystem && system, ColumnMapping const & columnMapping) { auto & matrixA = system.A; assert(matrixA.colCount() == columnMapping.size()); uint32_t varCount = matrixA.colCount(); auto [matrixU, dim] = HermiteNormalForm()(std::move(matrixA)); // Get the values of the variables std::vector varValues; varValues.reserve(varCount); for (uint32_t col = 0; col < varCount; ++col) { PTRef var = columnMapping[col]; varValues.push_back(evaluate(var)); } // Now check every row of U for infeasibility: if the cross product of the row and vector of variable values is not // an integer, the row represents an infeasible constraint for (uint32_t rowIndex = 0; rowIndex < dim; ++rowIndex) { auto const & row = matrixU[rowIndex]; auto product = row.product(varValues); if (not product.isInteger()) { return {row.toVector(), product}; } } return {}; } opensmt-2.5.2/src/tsolvers/lasolver/CutCreator.h000066400000000000000000000015111445011647600217360ustar00rootroot00000000000000/* * Copyright (c) 2022, Martin Blicha * Antti Hyvarinen * * SPDX-License-Identifier: MIT * */ #ifndef OPENSMT_CUTCREATOR_H #define OPENSMT_CUTCREATOR_H #include "Real.h" #include "Polynomial.h" #include "SparseMatrix.h" #include "PTRef.h" #include "TypeUtils.h" class CutCreator { private: std::function varValue; FastRational evaluate(PTRef var) const { return varValue(var); } public: explicit CutCreator(std::function && varValue) : varValue(std::move(varValue)) {} using Cut = opensmt::pair; using ColumnMapping = std::vector; Cut makeCut(SparseLinearSystem && constraints, ColumnMapping const &); }; #endif //OPENSMT_CUTCREATOR_H opensmt-2.5.2/src/tsolvers/lasolver/Delta.cc000066400000000000000000000034521445011647600210600ustar00rootroot00000000000000/********************************************************************* Author: Aliaksei Tsitovich Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #include "Delta.h" #include // // Set Delta to 0 // void Delta::reset() { r.reset(); d.reset(); } // // prints the Delta // void Delta::print(std::ostream & out) const { out << R() << "|" << D(); } char * Delta::printValue() const { char * out; int written = -1; written = asprintf(&out, "(%s | %s)", r.get_str().c_str(), d.get_str().c_str()); assert(written >= 0); (void) written; return out; } opensmt-2.5.2/src/tsolvers/lasolver/Delta.h000066400000000000000000000204611445011647600207210ustar00rootroot00000000000000/********************************************************************* Author: Antti Hyvarinen , Aliaksei Tsitovich , Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2012 - 2015, Antti Hyvarinen 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #ifndef DELTA_H #define DELTA_H #include "Real.h" using opensmt::Real; // // Class to keep the delta values and bounds values for the LAVar // class Delta { private: Real r; // main value Real d; // delta to keep track of < / <= difference inline bool isLess(const Real & c) const; //basic function to use in comparison with Real operator inline bool isGreater(const Real & c) const; //basic function to use in comparison with Real operator public: // possible types of initial Delta values; inline Delta(); // Same as Delta(UPPER) inline Delta(const Real & v); // Constructor for Real delta inline Delta(const Real & v, const Real & d); // Constructor for Real delta with strict part inline Delta(Real && v, Real && d); // Constructor for Real delta with strict part inline Delta(const Delta & a); // Copy constructor inline ~Delta(); // Destructor inline const Real & R() const; // main value inline const Real & D() const; // delta to keep track of < / <= difference inline bool hasDelta() const; // TRUE is delta != 0 void negate() { r.negate(); d.negate(); } void reset(); inline Delta & operator=(const Delta & a); //Assign operator inline Delta & operator=(Delta &&) noexcept; // Move assign operator inline Delta(Delta &&); // Move constructor inline Delta(Real &&); // Move constructor from Real // Comparisons overloading inline friend bool operator<(const Delta & a, const Delta & b); inline friend bool operator<=(const Delta & a, const Delta & b); inline friend bool operator>(const Delta & a, const Delta & b); inline friend bool operator>=(const Delta & a, const Delta & b); inline friend bool operator==(const Delta & a, const Delta & b); inline friend bool operator!=(const Delta & a, const Delta & b); inline friend bool operator<(const Delta & a, const Real & c); inline friend bool operator<=(const Delta & a, const Real & c); inline friend bool operator>(const Delta & a, const Real & c); inline friend bool operator>=(const Delta & a, const Real & c); inline friend bool operator<(const Real & c, const Delta & a); inline friend bool operator<=(const Real & c, const Delta & a); inline friend bool operator>(const Real & c, const Delta & a); inline friend bool operator>=(const Real & c, const Delta & a); // Arithmetic overloadings Delta& operator+=(Delta const & b); Delta& operator+=(Delta && b); Delta& operator-=(Delta const & b); Delta& operator-=(Delta && b); inline friend Delta operator-(const Delta & a, const Delta & b); inline friend Delta operator+(const Delta & a, const Delta & b); inline friend Delta operator*(const Real & c, const Delta & a); inline friend Delta operator*(const Delta & a, const Real & c); inline friend Delta operator/(const Delta & a, const Real & c); void print(std::ostream & out) const; // print the Delta char * printValue() const; inline friend std::ostream & operator<<(std::ostream & out, const Delta & b) { b.print(out); return out; } }; // main value inline const Real & Delta::R() const { return r; } // delta value (to keep track of < / <= difference) inline const Real & Delta::D() const { return d; } bool Delta::hasDelta() const { return !D().isZero(); } // Arithmetic operators definitions. inline Delta& Delta::operator+=(const Delta & b) { this->r += b.R(); this->d += b.D(); return *this; } inline Delta& Delta::operator+=(Delta && b) { this->r += std::move(b.r); this->d += std::move(b.d); return *this; } inline Delta& Delta::operator-=(Delta const & b) { this->r -= b.R(); this->d -= b.D(); return *this; } inline Delta& Delta::operator-=(Delta && b) { this->r -= std::move(b.R()); this->d -= std::move(b.D()); return *this; } Delta operator-(const Delta & a, const Delta & b) { return Delta(a.R() - b.R(), a.D() - b.D()); } Delta operator+(const Delta & a, const Delta & b) { return Delta(a.R() + b.R(), a.D() + b.D()); } Delta operator*(const Real & c, const Delta & a) { return Delta(c * a.R(), c * a.D()); } Delta operator*(const Delta & a, const Real & c) { return c * a; } Delta operator/(const Delta & a, const Real & c) { return Delta(a.R() / c, a.D() / c); } // Comparison operators definitions. // Most are implemented via calls to basic operators. // bool operator<(const Delta & a, const Delta & b) { return (a.R() < b.R() || (a.R() == b.R() && a.D() < b.D())); } bool operator<=(const Delta & a, const Delta & b) { return !(b < a); } bool operator>(const Delta & a, const Delta & b) { return b < a; } bool operator>=(const Delta & a, const Delta & b) { return !(a < b); } bool operator==(const Delta & a, const Delta & b) { return (a.R() == b.R() && a.D() == b.D()); } bool operator!=(const Delta & a, const Delta & b) { return !(a == b); } bool operator<(const Delta & a, const Real & c) { return a.isLess(c); } bool operator<=(const Delta & a, const Real & c) { return !(a > c); } bool operator>(const Delta & a, const Real & c) { return a.isGreater(c); } bool operator>=(const Delta & a, const Real & c) { return !(a < c); } bool operator<(const Real & c, const Delta & a) { return a > c; } bool operator<=(const Real & c, const Delta & a) { return a >= c; } bool operator>(const Real & c, const Delta & a) { return a < c; } bool operator>=(const Real & c, const Delta & a) { return a <= c; } // // basic function to use in comparison with Real // bool Delta::isLess(const Real & c) const { return (R() < c || (R() == c && D() < 0)); } // // basic function to use in comparison with Real // bool Delta::isGreater(const Real & c) const { return (R() > c || (R() == c && D() > 0)); } Delta::Delta() : r{0}, d{0} {} // // Constructor for Real delta // Delta::Delta(const Real & v) : r{v}, d{0} {} // // Constructor for Real delta with strict bit // Delta::Delta(const Real & v_r, const Real & v_d) : r{v_r}, d{v_d} {} Delta::Delta(Real && v_r, Real && v_d) : r{std::move(v_r)}, d{std::move(v_d)} { } // // Copy constructor // Delta::Delta(const Delta & a) : r{a.r}, d{a.d} {} // Assign operator Delta & Delta::operator=(const Delta & a) { if (this != &a) { r = a.r; d = a.d; } return *this; } // move constructor Delta::Delta(Delta && other) = default; // move constructor from real Delta::Delta(Real && other) : r{std::move(other)}, d{0} {} // move assign Delta & Delta::operator=(Delta && other) noexcept { this->r = std::move(other.r); this->d = std::move(other.d); return *this; } // Destructor Delta::~Delta() = default; #endif opensmt-2.5.2/src/tsolvers/lasolver/FarkasInterpolator.cc000066400000000000000000000670211445011647600236430ustar00rootroot00000000000000// // Created by Martin Blicha on 22.05.18. // //#ifndef NDEBUG //#define TRACE //#endif #ifdef TRACE #define trace(x) x #else #define trace(x) #endif #include "FarkasInterpolator.h" #include "ArithLogic.h" #include "Real.h" #include "LA.h" #include "OsmtInternalException.h" #include "OsmtApiException.h" #include #include using namespace opensmt; using matrix_t = std::vector>; // initializing static member DecomposedStatistics FarkasInterpolator::stats {}; namespace { // TODO: when is explanation negated? struct ItpHelper { ItpHelper(ArithLogic & logic, PtAsgn ineq, Real coeff) : explanation(ineq.tr), negated(ineq.sgn == l_False), expl_coeff(std::move(coeff)), expr(logic, ineq.tr, false) {} PTRef explanation; bool negated; Real expl_coeff; LAExpression expr; }; struct LinearTerm { LinearTerm(PTRef var_, Real coeff_): var(var_), coeff(std::move(coeff_)) {} PTRef var; Real coeff; }; using Basis = std::vector>; using Coordinates = std::vector; std::vector getLocalTerms(ItpHelper const & helper, std::function isLocal){ std::vector res; for (auto factor : helper.expr) { auto var_ref = factor.first; if (var_ref != PTRef_Undef) { if (isLocal(var_ref)) { auto coeff = factor.second; if (helper.negated) { coeff.negate(); } res.emplace_back(var_ref, coeff); } } } return res; } /** * * @param matrix * @param pivotCol * @param startRow * @return Index of row >= startRow that contains the pivot for given column pivotCol */ std::size_t getPivotRow(const matrix_t & matrix, std::size_t pivotCol, std::size_t startRow) { for (auto i = startRow; i < matrix.size(); ++i) { if (matrix[i][pivotCol] != 0) { return i; } } return matrix.size(); } /** Adds a multiple of vector of Reals to another vector with equal size. * * @param to vector to which we add * @param what vector being added * @param coeff The multiple */ void addToWithCoeff(std::vector & to, std::vector const & what, const Real & coeff) { assert(to.size() == what.size()); for (std::size_t i = 0; i < what.size(); ++i) { to[i] += coeff * what[i]; } } // assumes there are 0 on all position before col void normalize(std::vector & row, std::size_t col) { #ifndef NDEBUG for (std::size_t i = 0; i < col; ++i) { assert(row[i] == 0); } #endif //NDEBUG auto val = row[col].inverse(); for (; col < row.size(); ++col) { row[col] *= val; } } /** Transforms a matrix in a Row Echolon Form to matrix in Reduced Row Echolob Form * * @param matrix Matrix in REF */ void toReducedRowEcholonForm(std::vector> & matrix) { std::vector pivotColInds; std::size_t column = 0; for (auto & row : matrix) { auto it = std::find_if(row.begin() + column, row.end(), [](const Real & el) {return !el.isZero();}); if (it == row.end()) {continue;} column = it - row.begin(); assert(pivotColInds.empty() || pivotColInds.back() < column); pivotColInds.push_back(column); if (row[column] != 1) { normalize(row, column); } } // TODO: use long instead of int? for (auto rowInd = (int) (matrix.size() - 1); rowInd >= 0; --rowInd) { auto & row = matrix[rowInd]; auto pivotColInd = pivotColInds.back(); if (row[pivotColInd].isZero()) { continue; } pivotColInds.pop_back(); assert(row[pivotColInd] == 1); for (int rowInd2 = rowInd - 1; rowInd2 >= 0; --rowInd2) { if (matrix[rowInd2][pivotColInd].isZero()) { continue; } addToWithCoeff(matrix[rowInd2], row, -matrix[rowInd2][pivotColInd]); } } } /** Transforms a matrix to Row Echolon Form * * @param matrix */ void gaussianElimination(matrix_t & matrix) { std::size_t cols = matrix[0].size(); std::size_t pivotRow = 0; std::size_t pivotCol = 0; while (pivotCol < cols && pivotRow < matrix.size()) { // find the row with non-zero coefficient auto nextRow = getPivotRow(matrix, pivotCol, pivotRow); if (nextRow == matrix.size()) { // all remaining rows have 0 in this column -> continue with next column ++pivotCol; continue; } // put it to correct place if (nextRow != pivotRow) { std::swap(matrix[pivotRow], matrix[nextRow]); } // now zero out the column after the current row for (auto row = pivotRow + 1; row < matrix.size(); ++row) { if (matrix[row][pivotCol] == 0) { continue; } addToWithCoeff(matrix[row], matrix[pivotRow], -(matrix[row][pivotCol] / matrix[pivotRow][pivotCol])); #ifndef NDEBUG for (std::size_t col = 0; col <= pivotCol; ++col) { assert(matrix[row][col] == 0); } #endif // NDEBUG } ++pivotRow; ++pivotCol; } } /* * Returns nullity (dimension of the null space) of given matrix */ std::size_t getNullity(std::vector> const & matrix) { // nullity is the number of columns - rank auto rank = std::count_if(matrix.cbegin(), matrix.cend(), [](std::vector const & row) { return std::any_of(row.cbegin(), row.cend(), [](Real const & r) { return r != 0; }); }); auto cols = static_cast(matrix[0].size()); assert(cols >= rank); return cols - rank; } /* * Given matrix in REF, return bitmap of columns with pivot columns identified */ std::vector getPivotColsBitMap(std::vector> const & matrix) { std::vector pivotColsBitMap; auto cols = matrix[0].size(); pivotColsBitMap.resize(cols); std::size_t row = 0; for (std::size_t col = 0; col < cols; ++col) { // check if this column is a pivot column // if we are out of rows it is not a pivot if (row == matrix.size() || matrix[row][col].isZero()) { pivotColsBitMap[col] = false; } else { assert(matrix[row][col] == 1); pivotColsBitMap[col] = true; ++row; } } return pivotColsBitMap; } #ifndef NDEBUG // ======== DEBUG METHODS ================ bool isReducedRowEchelonForm(std::vector> const & matrix) { auto pivotColsBitMap = getPivotColsBitMap(matrix); auto cols = pivotColsBitMap.size(); assert(cols == matrix[0].size()); std::size_t pivotRow = 0; for (unsigned int col = 0; col < pivotColsBitMap.size(); ++col) { if(pivotColsBitMap[col]) { for (std::size_t row = 0; row < matrix.size(); ++row) { if ((row != pivotRow && matrix[row][col] != 0) || (row == pivotRow && matrix[row][col] != 1)) { return false; } } ++pivotRow; } else { // free column (not pivot) for (auto row = pivotRow; row < matrix.size(); ++row) { if (matrix[row][col] != 0) { return false; } } } } return true; } bool check_basis(std::vector> const & basis) { return std::all_of(basis.begin(), basis.end(), [](std::vector const & baseVec) { return std::none_of(baseVec.begin(), baseVec.end(), [](const Real & el) { return el < 0; }); }); } #ifdef TRACE void print_matrix(std::vector> const & matrix) { (void)print_matrix; // MB: to supress compiler warning for this unused helpful debug method for (auto const & row : matrix) { for (auto const & elem : row) { std::cout << elem << " "; } std::cout << '\n'; } std::cout << '\n'; } void print_basis(std::vector> const & nullBasis) { (void)print_basis; // MB: to supress compiler warning for this unused helpful debug method std::cout << "Basis: " << '\n'; for (auto const & base : nullBasis) { for (auto const & elem : base) { std::cout << elem << ' '; } std::cout << '\n'; } std::cout << '\n'; } #endif // TRACE bool isDecomposition(Basis const & basis, Coordinates const & coordinates, std::vector const & original) { assert(coordinates.size() == basis.size()); assert(std::all_of(basis.begin(), basis.end(), [&original](std::vector const & baseVec) { return baseVec.size() == original.size(); })); for (std::size_t i = 0; i < original.size(); ++i) { Real sum = 0; for (std::size_t j = 0; j < basis.size(); ++j) { sum += basis[j][i] * coordinates[j]; } if (sum != original[i]) { return false; } } return true; } #endif // NDEBUG // ======== DEBUG METHODS ================ /** Given matrix in RREF computes and returns a basis of its null space * * @see https://en.wikibooks.org/wiki/Linear_Algebra/Null_Spaces * @param matrix in RREF * @return Basis of null space of given matrix */ std::vector> getNullBasis(std::vector> const & matrix) { assert(isReducedRowEchelonForm(matrix)); std::vector> basis; auto pivotColsBitMap = getPivotColsBitMap(matrix); auto cols = matrix[0].size(); assert(cols == pivotColsBitMap.size()); // for non-pivot columns generate a new base vector for (std::size_t col = 0; col < cols; ++col) { if (pivotColsBitMap[col]) { continue; } basis.emplace_back(); auto & base_vector = basis.back(); // put 1 on position of this free column, 0 on positions of other free columns, and -val at pivot row unsigned int pivotRow = 0; for (unsigned int colPos = 0; colPos < cols; ++colPos) { if (pivotColsBitMap[colPos]) { base_vector.push_back(-matrix[pivotRow][col]); ++pivotRow; } else { // free column base_vector.push_back(colPos == col ? 1 : 0); } } } return basis; } PTRef sumInequalities(std::vector const & ineqs, std::vector const & coeffs, ArithLogic & logic) { assert(ineqs.size() == coeffs.size()); assert(ineqs.size() > 0); LAExpression init{logic}; auto it_ineq = ineqs.begin(); auto it_coeff = coeffs.begin(); bool delta_flag = false; SRef itpSort = logic.getSortRef(logic.getPterm(ineqs[0].explanation)[0]); for (; it_ineq != ineqs.end(); ++it_ineq, ++it_coeff) { auto const & coeff = *it_coeff; if(coeff.isZero()) {continue;} // when some basis is found, some coordinates could be zero; ignore those auto const & ineq = *it_ineq; trace(std::cout << "Original explanation: " << logic.printTerm(ineq.explanation) << "; negated: " << ineq.negated << '\n';) trace(std::cout << "LAExpr as PTrEf: " << logic.printTerm(ineq.expr.toPTRef()) << '\n';) trace(std::cout << "LAExpr as stored: ";) trace(ineq.expr.print(std::cout); std::cout << std::endl;) if (ineq.negated) { delta_flag = true; init.addExprWithCoeff(ineq.expr, -(coeff)); } else { init.addExprWithCoeff(ineq.expr, coeff); } trace(init.print(std::cout);) } // here we have to compensate for the fact that we used LAexpression to compute the coefficients, so everything is multiplied by -1 // therefore we need to create the inequality with the terms on LHS, because they are treated like LHS when LAExpressions are created PTRef rhs = logic.getZeroForSort(itpSort); PTRef lhs = init.toPTRef(itpSort); // std::cout << "LHS: " << logic.printTerm(lhs) << '\n'; return delta_flag ? logic.mkLt(lhs, rhs) : logic.mkLeq(lhs, rhs); } PTRef sumInequalities(std::vector const & ineqs, ArithLogic & logic) { std::vector coeffs; coeffs.reserve(ineqs.size()); for (const auto & helper : ineqs) { coeffs.push_back(helper.expl_coeff); } return sumInequalities(ineqs, coeffs, logic); } std::vector getFarkasCoeffs(std::vector const & inequalities) { std::vector ret; for (const auto & ineq : inequalities) { ret.push_back(ineq.expl_coeff); } return ret; } // Gets coordinates (alphas) with respect to current basis. Relies on the fact that // explanations_with_locals and columns of matrix are in 1-1 correspondence (including ordering) // Moreover, it relies on how the basis is computed, namely that for a given free (non-pivot) column // and its corresponding position, there is exactly one vector in basis with 1 in that position and all // other vectors in basis have 0 in that position. Consequently, the coordinate for that vector is the element // in Farkas coefficients at that position template std::vector getAlphas(std::vector const & allFarkasCoeffs, T & isPivot) { std::vector ret; for (std::size_t i = 0; i < allFarkasCoeffs.size(); ++i) { if (!isPivot(i)) {ret.push_back(allFarkasCoeffs[i]);} } return ret; } void ensureNonNegativeVec(std::vector & baseVec, std::size_t baseVecIndex, Coordinates & coordinates, std::vector const & vecToDecompose) { for (std::size_t i = 0; i < baseVec.size(); ++i) { if (baseVec[i] < 0) { auto coeff = (-baseVec[i] / vecToDecompose[i]); // baseVec += coeff * vecToDecompose; for (std::size_t j = 0; j < baseVec.size(); ++j) { baseVec[j] += coeff * vecToDecompose[j]; } // update coordinates Real divisor = Real{1} + (coeff * coordinates[baseVecIndex]); for (Real& coordinate : coordinates) { coordinate /= divisor; } } } } void ensureNonNegativeDecomposition(Basis& basis, Coordinates & coordinates, std::vector const & vecToDecompose) { for (std::size_t i = 0; i < basis.size(); ++i) { ensureNonNegativeVec(basis[i], i, coordinates, vecToDecompose); } } struct StatsHelper{ bool standAloneIneq = false; bool nonTrivialBasis = false; bool moreThanOneInequality = false; }; } PTRef FarkasInterpolator::getDecomposedInterpolant(icolor_t color) { assert(color == icolor_t::I_A || color == icolor_t::I_B); bool hasColors = ensureHasColorForAllTerms(); if (not hasColors) { throw OsmtInternalException("Error in computation of decomposed Farkas interpolant, colors could not be determined!"); } StatsHelper statsHelper; // this will be contain the result, inequalities corresponding to summed up partitions of explanataions (of given color) std::vector interpolant_inequalities; std::vector> candidates; assert(explanations.size() == static_cast(explanation_coeffs.size())); for (int i = 0; i < explanations.size(); ++i) { assert(explanation_coeffs[i] > 0); candidates.emplace_back(explanations[i], explanation_coeffs[i]); trace(std::cout << "Explanation " << logic.printTerm(explanations[i].tr) << " with coeff " << explanation_coeffs[i] << " is negated: " << (explanations[i].sgn == l_False) << '\n';) bool isA = this->isInPartitionOfColor(icolor_t::I_A, explanations[i].tr); bool isB = this->isInPartitionOfColor(icolor_t::I_B, explanations[i].tr); if(isA){ trace(std::cout << "This explanation is from A\n";) } if(isB){ trace(std::cout << "This explanation is from B\n";) } } auto it = std::partition(candidates.begin(), candidates.end(), [color, this](std::pair const & expl) { return this->isInPartitionOfColor(color, expl.first.tr); }); if (it == candidates.end() || it == candidates.begin()) { // all inequalities are of the same color -> trivial interpolant // return false for all of color A and true for all of color B return ((it == candidates.end() && color == icolor_t::I_A) || (it == candidates.begin() && color == icolor_t::I_B)) ? logic.getTerm_false() : logic.getTerm_true(); } std::vector helpers; ArithLogic & logic = this->logic; std::transform(candidates.begin(), it, std::back_inserter(helpers), [&logic](std::pair const & expl) { return ItpHelper{logic, expl.first, expl.second}; }); statsHelper.moreThanOneInequality = helpers.size() > 1; using local_terms_t = std::vector; // create information about local variables for each inequality std::vector ineqs_local_vars; std::vector explanations_with_locals; for (const auto & helper : helpers) { local_terms_t local_terms = getLocalTerms(helper, [this, color](PTRef ptr) { return this->isLocalFor(color, ptr); }); // explanataion with all variables shared form standalone partition if (local_terms.empty()) { statsHelper.standAloneIneq = true; interpolant_inequalities.push_back(helper.negated ? logic.mkNot(helper.explanation) : helper.explanation); } // for explanations with local variables, remember them separately else { ineqs_local_vars.push_back(std::move(local_terms)); explanations_with_locals.push_back(helper); } } if (!ineqs_local_vars.empty()) { // assign index to each local var std::unordered_map local_vars; for (const auto & info : ineqs_local_vars) { for (auto const & term : info) { if (local_vars.find(term.var) == local_vars.end()) { auto size = local_vars.size(); local_vars[term.var] = size; } } } // create a matrix from those containing local variables // rows correspond to local variables, columns correspond to explanations (inequalities) matrix_t matrix{local_vars.size()}; std::size_t colInd = 0; for (const auto & info : ineqs_local_vars) { // add coefficient to those rows whose corresponding variable occurs in the inequality for (auto const & term : info) { auto var = term.var; auto ind = local_vars[var]; matrix[ind].push_back(term.coeff); } // add 0 to other rows for (auto & row : matrix) { if (row.size() <= colInd) { assert(row.size() == colInd); // push coefficient 0 row.emplace_back(0); } } ++colInd; } trace(print_matrix(matrix);) gaussianElimination(matrix); trace(print_matrix(matrix);) auto nullity = getNullity(matrix); // if the space of solutions does not have at least two vector in basis, we cannot do anything if (nullity <= 1) { // std::cout << "Nullity space has single-vector basis" << '\n'; interpolant_inequalities.push_back(sumInequalities(explanations_with_locals, logic)); } else { toReducedRowEcholonForm(matrix); trace(print_matrix(matrix);) auto nullBasis = getNullBasis(matrix); trace(print_basis(nullBasis);) assert(explanations_with_locals.size() == matrix[0].size()); auto farkasCoeffs = getFarkasCoeffs(explanations_with_locals); const auto pivotColIndexBitMap = getPivotColsBitMap(matrix); assert(farkasCoeffs.size() == pivotColIndexBitMap.size()); auto isPivotColIndex = [&pivotColIndexBitMap](std::size_t index) { return pivotColIndexBitMap[index]; }; auto alphas = getAlphas(farkasCoeffs, isPivotColIndex); assert(std::all_of(alphas.begin(), alphas.end(), [](const Real& v) {return v > 0;})); assert(alphas.size() == nullBasis.size()); assert(isDecomposition(nullBasis, alphas, farkasCoeffs)); ensureNonNegativeDecomposition(nullBasis, alphas, farkasCoeffs); assert(std::all_of(alphas.begin(), alphas.end(), [](const Real& v) {return v > 0;})); assert(check_basis(nullBasis)); assert(isDecomposition(nullBasis, alphas, farkasCoeffs)); statsHelper.nonTrivialBasis = true; // foreach vector in the basis, cycle over the inequalities and sum it all up, with corresponding coefficient for (const auto & base : nullBasis) { interpolant_inequalities.push_back(sumInequalities(explanations_with_locals, base, logic)); } } } else{ assert(explanations_with_locals.empty()); } if (!interpolant_inequalities.empty()) { if (statsHelper.moreThanOneInequality) { FarkasInterpolator::stats.decompositionOpportunities++; } if (interpolant_inequalities.size() > 1) { FarkasInterpolator::stats.decomposedItps++; assert(statsHelper.nonTrivialBasis || statsHelper.standAloneIneq); if (statsHelper.nonTrivialBasis) { FarkasInterpolator::stats.nonTrivialBasis++; } if (statsHelper.standAloneIneq) { FarkasInterpolator::stats.standAloneIneq++; } } } vec args; for (auto const & itp : interpolant_inequalities) { args.push(itp); } PTRef itp = logic.mkAnd(args); if (color == icolor_t::I_B) { itp = logic.mkNot(itp); } return itp; } icolor_t FarkasInterpolator::getGlobalColorFor(PTRef term) const { assert(termColorInfo); return termColorInfo->getColorFor(term); } PTRef FarkasInterpolator::getDecomposedInterpolant() { return getDecomposedInterpolant(icolor_t::I_A); } PTRef FarkasInterpolator::getDualDecomposedInterpolant() { return getDecomposedInterpolant(icolor_t::I_B); } PTRef FarkasInterpolator::getFarkasInterpolant() { return getFarkasInterpolant(icolor_t::I_A); } PTRef FarkasInterpolator::getDualFarkasInterpolant() { return getFarkasInterpolant(icolor_t::I_B); } PTRef FarkasInterpolator::weightedSum(std::vector> const & system) { LAExpression interpolant(logic); bool delta_flag = false; SRef sumSort = SRef_Undef; for (auto const & entry : system) { auto literal = entry.first; PTRef atom = literal.tr; sumSort = sumSort != SRef_Undef ? sumSort : logic.getUniqueArgSort(atom); assert(sumSort != SRef_Undef); lbool sign = literal.sgn; if (sign == l_False) { interpolant.addExprWithCoeff(LAExpression(logic, atom, false), entry.second); delta_flag = true; } else { interpolant.addExprWithCoeff(LAExpression(logic, atom, false), -entry.second); } } PTRef itp = PTRef_Undef; if (interpolant.isTrue() && !delta_flag) { itp = logic.getTerm_true(); } else if (interpolant.isFalse() || (interpolant.isTrue() && delta_flag)) { itp = logic.getTerm_false(); } else { assert(sumSort != SRef_Undef); PTRef itpRef = interpolant.toPTRef(sumSort); SRef itpSort = logic.getSortRef(itpRef); vec args {logic.getZeroForSort(itpSort), itpRef}; itp = delta_flag ? logic.mkLt(args) : logic.mkLeq(args); } return itp; } PTRef FarkasInterpolator::getFarkasInterpolant(icolor_t color) { std::vector> system; for (int i = 0; i < explanations.size(); ++i) { auto litColor = getColorFor(explanations[i].tr); if (litColor == color or litColor == icolor_t::I_AB) { system.emplace_back(explanations[i], explanation_coeffs[i]); } } PTRef itp = weightedSum(system); assert(itp != PTRef_Undef); return color == icolor_t::I_B ? logic.mkNot(itp) : itp; } PTRef FarkasInterpolator::getFlexibleInterpolant(opensmt::Real strengthFactor) { if (strengthFactor < 0 or strengthFactor >= 1) { throw OsmtApiException("LRA strength factor has to be in [0,1)"); } std::vector> systemA; std::vector> systemB; for (int i = 0; i < explanations.size(); ++i) { auto litColor = getColorFor(explanations[i].tr); if (litColor == icolor_t::I_A or litColor == icolor_t::I_AB) { // We put shared literals to A (arbitrary decision, but cannot be in both A and B) systemA.emplace_back(explanations[i], explanation_coeffs[i]); } else if (litColor == icolor_t::I_B) { systemB.emplace_back(explanations[i], explanation_coeffs[i]); } } PTRef itpA = weightedSum(systemA); if (itpA == logic.getTerm_true() or itpA == logic.getTerm_false()) { assert(itpA == logic.mkNot(weightedSum(systemB))); return itpA; } PTRef itpB = weightedSum(systemB); auto extractSides = [this](PTRef inequality) { assert(logic.isLeq(inequality) or logic.isLeq(logic.mkNot(inequality))); bool negated = logic.isNot(inequality); PTRef positive = negated ? logic.mkNot(inequality) : inequality; PTRef term = logic.getTermFromLeq(positive); PTRef constant = logic.getConstantFromLeq(positive); return negated ? std::make_pair(logic.mkNeg(term), logic.mkNeg(constant)) : std::make_pair(term, constant); }; auto sidesA = extractSides(itpA); auto sidesB = extractSides(itpB); assert(sidesA.first == logic.mkNeg(sidesB.first)); opensmt::Real c1 = logic.getNumConst(sidesA.second); opensmt::Real c2 = logic.getNumConst(sidesB.second); opensmt::Real lowerBound = c1; opensmt::Real upperBound = -c2; opensmt::Real strengthDiff = upperBound - lowerBound; opensmt::Real newConstant = lowerBound + (strengthDiff * strengthFactor); SRef itpSort = logic.getSortRef(sidesA.first); PTRef itp = logic.mkLeq(logic.mkConst(itpSort, newConstant), sidesA.first); return itp; } bool FarkasInterpolator::ensureHasColorForAllTerms() { if (termColorInfo) { return true; } if (labels.empty()) { return false; } termColorInfo.reset(new LocalTermColorInfo(labels, logic)); return true; } opensmt-2.5.2/src/tsolvers/lasolver/FarkasInterpolator.h000066400000000000000000000072331445011647600235040ustar00rootroot00000000000000// // Created by Martin Blicha on 22.05.18. // #ifndef OPENSMT_FARKASINTERPOLATOR_H #define OPENSMT_FARKASINTERPOLATOR_H #include #include #include #include class ArithLogic; struct DecomposedStatistics { unsigned int decompositionOpportunities = 0; unsigned int decomposedItps = 0; unsigned int nonTrivialBasis = 0; unsigned int standAloneIneq = 0; void printStatistics(std::ostream& out) const { out << "\n###Decomposed statistics###\n" << "Total number of oportunities for decomposition: " << decompositionOpportunities << '\n' << "Total number of decomposed interpolants: " << decomposedItps << '\n' << "Out of total number of decomposed were (partly) trivially decomposable: " << standAloneIneq << '\n' << "Out of total number of decomposed had nontrivial basis of null space: " << nonTrivialBasis << '\n' << "###########################\n" << std::endl; } bool anyOpportunity() const {return decompositionOpportunities > 0;} void reset() { nonTrivialBasis = 0; decompositionOpportunities = 0; decomposedItps = 0; standAloneIneq = 0; } }; class FarkasInterpolator { public: using ItpColorMap = TheoryInterpolator::ItpColorMap; FarkasInterpolator(ArithLogic & logic, vec explanations, std::vector coeffs, ItpColorMap labels) : logic(logic), explanations(std::move(explanations)), explanation_coeffs(std::move(coeffs)), labels(std::move(labels)) {} FarkasInterpolator(ArithLogic & logic, vec explanations, std::vector coeffs, ItpColorMap labels, std::unique_ptr colorInfo) : logic(logic), explanations(std::move(explanations)), explanation_coeffs(std::move(coeffs)), labels(std::move(labels)), termColorInfo(std::move(colorInfo)) {} FarkasInterpolator(ArithLogic & logic, vec explanations, std::vector coeffs, std::unique_ptr colorInfo) : logic(logic), explanations(std::move(explanations)), explanation_coeffs(std::move(coeffs)), termColorInfo(std::move(colorInfo)) {} PTRef getFarkasInterpolant(); PTRef getDualFarkasInterpolant(); PTRef getFlexibleInterpolant(opensmt::Real); PTRef getDecomposedInterpolant(); PTRef getDualDecomposedInterpolant(); static DecomposedStatistics stats; private: PTRef getDecomposedInterpolant(icolor_t color); PTRef getFarkasInterpolant(icolor_t color); bool isLocalFor(icolor_t color, PTRef var) const{ return getColorFor(var) == color; } bool isInPartitionOfColor(icolor_t color, PTRef atom) const { auto atomColor = getColorFor(atom); return (color & atomColor) != opensmt::icolor_t::I_UNDEF; } icolor_t getColorFor(PTRef term) const { // use labels if (labels.find(term) != labels.end()){ return labels.at(term); } // otherwise use global partitioning information return getGlobalColorFor(term); } bool ensureHasColorForAllTerms(); icolor_t getGlobalColorFor(PTRef term) const; PTRef weightedSum(std::vector> const & system); private: ArithLogic & logic; const vec explanations; const std::vector explanation_coeffs; const ItpColorMap labels; std::unique_ptr termColorInfo; }; #endif //OPENSMT_FARKASINTERPOLATOR_H opensmt-2.5.2/src/tsolvers/lasolver/LABounds.cc000066400000000000000000000106411445011647600214740ustar00rootroot00000000000000#include "LABounds.h" #include "Map.h" #include "Sort.h" LABound::LABound(BoundT type, LVRef var, Delta && delta, int id) : type(type.t) , bidx(UINT32_MAX) , id(id) , var(var) , delta(std::move(delta)) {} LABoundRef LABoundAllocator::alloc(BoundT type, LVRef var, Delta && delta) { uint32_t v = RegionAllocator::alloc(laboundWord32Size()); LABoundRef id = {v}; new (lea(id)) LABound(type, var, std::move(delta), static_cast(allocatedBounds.size())); allocatedBounds.push_back(id); return id; } // Debug char* LABoundStore::printBound(LABoundRef br) const { char *str_out; char *v_str_lvr; int written = asprintf(&v_str_lvr, "v%d", ba[br].getLVRef().x); assert(written >= 0); char* v_str; written = asprintf(&v_str, "%s", v_str_lvr); assert(written >= 0); (void)written; free(v_str_lvr); const Delta & d = ba[br].getValue(); opensmt::Real const & r = d.R(); opensmt::Real const & s = d.D(); BoundT type = ba[br].getType(); if ((type == bound_l) && (s == 0)) written = asprintf(&str_out, "%s <= %s", r.get_str().c_str(), v_str); if ((type == bound_l) && (s != 0)) written = asprintf(&str_out, "%s < %s", r.get_str().c_str(), v_str); if ((type == bound_u) && (s == 0)) written = asprintf(&str_out, "%s <= %s", v_str, r.get_str().c_str()); if ((type == bound_u) && (s != 0)) written = asprintf(&str_out, "%s < %s", v_str, r.get_str().c_str()); assert(written >= 0); (void)written; free(v_str); return str_out; } char* LABoundStore::printBounds(LVRef v) const { auto const & var_bounds = getBounds(v); char* bounds_str = (char*) malloc(1); bounds_str[0] = '\0'; for (unsigned int i = 0; i < var_bounds.size_(); i++) { LABoundRef br = var_bounds[i]; char* tmp; char* tmp2 = printBound(br); int written = asprintf(&tmp, "%s(%s) ", bounds_str, tmp2); assert(written >= 0); (void)written; free(bounds_str); free(tmp2); bounds_str = tmp; } return bounds_str; } inline bool bound_lessthan::operator() (LABoundRef r1, LABoundRef r2) const { return ba[r1].getValue() < ba[r2].getValue(); } LABoundRef LABoundStore::getBoundByIdx(LVRef v, int idx) const { auto const & var_bounds = getBounds(v); assert(idx < var_bounds.size()); return var_bounds[idx]; } bool LABoundStore::isUnbounded(LVRef v) const { return getBounds(v).size() == 0; } void LABoundStore::clear() { this->ba.clear(); this->in_bounds.clear(); this->bounds.clear(); } void LABoundStore::ensureReadyFor(LVRef v) { while (bounds.size() <= getVarId(v)) { bounds.emplace_back(); } } void LABoundStore::updateBound(BoundInfo bi) { auto & varBounds = getBounds(bi.v); for (LABoundRef bound : {bi.ub, bi.lb}) { unsigned idx = varBounds.size(); varBounds.push(bound); bound_lessthan lessthan(ba); for (; idx > 0; --idx) { if (lessthan(varBounds[idx - 1], varBounds[idx])) { break; } std::swap(varBounds[idx - 1], varBounds[idx]); ba[varBounds[idx]].setIdx(LABound::BLIdx{idx}); } assert(varBounds[idx] == bound); ba[varBounds[idx]].setIdx(LABound::BLIdx{idx}); } // Post-condition; indices must correspond to the place in the bound list assert([&](){ for (unsigned i = 0; i < varBounds.size_(); ++i) { if (ba[varBounds[i]].getIdx().x != i) { return false; } } return true; }()); } void LABoundStore::buildBounds() { VecMap bounds_map; for (int i = 0; i < in_bounds.size(); i++) { LVRef v = in_bounds[i].v; if (!bounds_map.has(v)) { bounds_map.insert(v, vec()); } bounds_map[v].push(in_bounds[i]); } vec keys; bounds_map.getKeys(keys); for (LVRef v : keys) { vec refs; vec const & boundInfos = bounds_map[v]; for (BoundInfo const & info : boundInfos) { refs.push(info.ub); refs.push(info.lb); } sort(refs, refs.size(), bound_lessthan(ba)); for (unsigned j = 0; j < refs.size_(); ++j) { ba[refs[j]].setIdx(LABound::BLIdx{j}); } assert(getVarId(v) < bounds.size()); refs.moveTo(bounds.at(getVarId(v))); } } opensmt-2.5.2/src/tsolvers/lasolver/LABounds.h000066400000000000000000000106211445011647600213340ustar00rootroot00000000000000#ifndef LABOUNDS_H #define LABOUNDS_H #include "Delta.h" #include "LARefs.h" #include "LAVar.h" #include "Alloc.h" // // Bound index type. The bounds are ordered in a list, and indexed using a number in the list. // To determine if a given bound is higher than another, it suffices to check the current bound index // and the new index. However, we need special values for no lower bound and no upper bound. // // The values are a little special. Two least significant bits encode whether this is the lowest // bound, the highest bound, or a normal bound. Lowest bound is 00, highest bound is 11, and // normal bound is 01. // class LABound { char type; // Upper / lower unsigned bidx; // The index in variable's bound list int id; // The unique id of the bound LVRef var; Delta delta; public: struct BLIdx { unsigned x; }; LABound(BoundT type, LVRef var, Delta && delta, int id); inline void setIdx(BLIdx i) { bidx = i.x; } inline BLIdx getIdx() const { return {bidx}; } inline const Delta& getValue() const { return delta; } inline BoundT getType() const { return { type }; } inline LVRef getLVRef() const { return var; } int getId() const { return id; } }; class LABoundAllocator : public RegionAllocator { std::vector allocatedBounds; static int laboundWord32Size() { return (sizeof(LABound)) / sizeof(uint32_t); } public: LABoundAllocator(uint32_t start_cap) : RegionAllocator(start_cap) {} LABoundAllocator() {} ~LABoundAllocator() { clear(); } LABoundRef alloc(BoundT type, LVRef var, Delta && delta); inline LABound& operator[](LABoundRef r) { return (LABound&)RegionAllocator::operator[](r.x); } inline const LABound& operator[](LABoundRef r) const { return (LABound&)RegionAllocator::operator[](r.x); } inline LABound* lea (LABoundRef r) { return (LABound*)RegionAllocator::lea(r.x); } inline const LABound* lea (LABoundRef r) const { return (LABound*)RegionAllocator::lea(r.x); } inline LABoundRef ael (const LABound* t) { RegionAllocator::Ref r = RegionAllocator::ael((uint32_t*)t); LABoundRef rf; rf.x = r; return rf; } void clear() override { for (LABoundRef ref : allocatedBounds) { lea(ref)->LABound::~LABound(); } allocatedBounds.clear(); RegionAllocator::clear(); } }; class bound_lessthan { LABoundAllocator& ba; public: bound_lessthan(LABoundAllocator& ba) : ba(ba) {} inline bool operator() (LABoundRef r1, LABoundRef r2) const; }; class LABoundRefPair { public: LABoundRefPair(): pos{LABoundRef_Undef.x}, neg{LABoundRef_Undef.x} {} LABoundRefPair(LABoundRef pos, LABoundRef neg): pos{pos.x}, neg{neg.x} {} LABoundRef pos; LABoundRef neg; bool operator== (const LABoundRefPair& o) const { return (pos == o.pos) && (neg == o.neg); } }; class LABoundStore { public: struct BoundInfo { LVRef v; LABoundRef ub; LABoundRef lb; }; struct BoundValuePair {Delta upper; Delta lower; }; private: vec in_bounds; LABoundAllocator ba{1024}; LAVarStore & lvstore; std::vector> bounds; public: LABoundStore(LAVarStore &lvstore) : lvstore(lvstore) {} void clear(); inline LABound& operator[] (LABoundRef br) { return ba[br]; } inline const LABound& operator[] (LABoundRef br) const { return ba[br]; } void buildBounds(); void updateBound(BoundInfo bi); vec const & getBounds(LVRef v) const { return bounds.at(getVarId(v)); } vec & getBounds(LVRef v) { return bounds.at(getVarId(v)); } LABoundRef getBoundByIdx(LVRef v, int it) const; bool isUnbounded(LVRef v) const; void ensureReadyFor(LVRef v); // Debug char* printBound(LABoundRef br) const; // Print the bound br char* printBounds(LVRef v) const; // Print all bounds of v // Allocates lower and upper bound for LA var with the given values BoundInfo allocBoundPair(LVRef v, BoundValuePair boundPair) { ensureReadyFor(v); LABoundRef ub = ba.alloc(bound_u, v, std::move(boundPair.upper)); LABoundRef lb = ba.alloc(bound_l, v, std::move(boundPair.lower)); in_bounds.push(BoundInfo{v, ub, lb}); return in_bounds.last(); } LAVarStore const& getVarStore() const { return lvstore; } }; #endif opensmt-2.5.2/src/tsolvers/lasolver/LARefs.h000066400000000000000000000027771445011647600210160ustar00rootroot00000000000000#ifndef LABOUNDREFS_H #define LABOUNDREFS_H #include "osmtinttypes.h" #include #include struct BoundT { char t; bool operator== (const BoundT& o) const { return o.t == t; } bool operator!= (const BoundT& o) const { return o.t != t; } BoundT operator~ () const { return { (char)(1-t) }; } }; const BoundT bound_l = { 0 }; const BoundT bound_u = { 1 }; struct LABoundRef { uint32_t x; void operator= (uint32_t v) { x = v; } inline friend bool operator== (const LABoundRef& a1, const LABoundRef& a2) { return a1.x == a2.x; } inline friend bool operator!= (const LABoundRef& a1, const LABoundRef& a2) { return a1.x != a2.x; } }; const struct LABoundRef LABoundRef_Undef = {INT32_MAX}; const struct LABoundRef LABoundRef_Infty = { 0 }; struct LVRef { uint32_t x; void operator= (uint32_t v) { x = v; } inline friend bool operator== (const LVRef& a1, const LVRef& a2) { return a1.x == a2.x; } inline friend bool operator!= (const LVRef& a1, const LVRef& a2) { return a1.x != a2.x; } static const LVRef Undef; }; inline constexpr LVRef LVRef::Undef = LVRef { INT32_MAX }; inline unsigned getVarId(LVRef ref) { return ref.x; } // For debugging inline char* printVar (LVRef r) { char* str; int written = asprintf(&str, "v%d", r.x); assert(written >= 0); (void)written; return str; } struct LVRefHash { uint32_t operator() (const LVRef& s) const {return s.x; } }; struct LVRefComp { bool operator()(LVRef a, LVRef b) const { return a.x < b.x; } }; #endif opensmt-2.5.2/src/tsolvers/lasolver/LASolver.cc000066400000000000000000001020771445011647600215210ustar00rootroot00000000000000/* * Copyright (c) 2019-2022, Antti Hyvarinen * Copyright (c) 2019-2022, Martin Blicha * * SPDX-License-Identifier: MIT */ #include "LASolver.h" #include "FarkasInterpolator.h" #include "LA.h" #include "ModelBuilder.h" #include "LIAInterpolator.h" #include "CutCreator.h" #include "Random.h" #include static SolverDescr descr_la_solver("LA Solver", "Solver for Quantifier Free Linear Arithmetics"); PtAsgn LASolver::getAsgnByBound(LABoundRef br) const { return LABoundRefToLeqAsgn[boundStore[br].getId()]; } LABoundStore::BoundInfo LASolver::addBound(PTRef leq_tr) { auto [const_tr, sum_tr] = logic.leqToConstantAndTerm(leq_tr); assert(logic.isNumConst(const_tr) && logic.isLinearTerm(sum_tr)); bool sum_term_is_negated = laVarMapper.isNegated(sum_tr); LVRef v = laVarMapper.getVarByPTId(logic.getPterm(sum_tr).getId()); LABoundStore::BoundInfo bi; LABoundRef br_pos; LABoundRef br_neg; if (sum_term_is_negated) { opensmt::Real constr_neg = -logic.getNumConst(const_tr); bi = boundStore.allocBoundPair(v, this->getBoundsValue(v, constr_neg, false)); br_pos = bi.ub; br_neg = bi.lb; } else { const Real& constr = logic.getNumConst(const_tr); bi = boundStore.allocBoundPair(v, this->getBoundsValue(v, constr, true)); br_pos = bi.lb; br_neg = bi.ub; } int br_pos_idx = boundStore[br_pos].getId(); int br_neg_idx = boundStore[br_neg].getId(); int tid = Idx(logic.getPterm(leq_tr).getId()); if (LeqToLABoundRefPair.size() <= tid) { LeqToLABoundRefPair.growTo(tid + 1); } LeqToLABoundRefPair[tid] = LABoundRefPair{br_pos, br_neg}; if (LABoundRefToLeqAsgn.size() <= std::max(br_pos_idx, br_neg_idx)) { LABoundRefToLeqAsgn.growTo(std::max(br_pos_idx, br_neg_idx) + 1); } LABoundRefToLeqAsgn[br_pos_idx] = PtAsgn(leq_tr, l_True); LABoundRefToLeqAsgn[br_neg_idx] = PtAsgn(leq_tr, l_False); return bi; } void LASolver::updateBound(PTRef tr) { // If the bound already exists, do nothing. int id = Idx(logic.getPterm(tr).getId()); if ((LeqToLABoundRefPair.size() > id) && !(LeqToLABoundRefPair[id] == LABoundRefPair{LABoundRef_Undef, LABoundRef_Undef})) { return; } LABoundStore::BoundInfo bi = addBound(tr); boundStore.updateBound(bi); } bool LASolver::isValid(PTRef tr) { return logic.isLeq(tr); // MB: LA solver expects only inequalities in LEQ form! } void LASolver::isProperLeq(PTRef tr) { assert(logic.isAtom(tr)); assert(logic.isLeq(tr)); auto [cons, sum] = logic.leqToConstantAndTerm(tr); assert(logic.isConstant(cons)); assert(logic.isNumVar(sum) || logic.isPlus(sum) || logic.isTimes(sum)); assert(!logic.isTimes(sum) || ((logic.isNumVar(logic.getPterm(sum)[0]) && logic.isOne(logic.mkNeg(logic.getPterm(sum)[1]))) || (logic.isNumVar(logic.getPterm(sum)[1]) && logic.isOne(logic.mkNeg(logic.getPterm(sum)[0]))))); (void) cons; (void)sum; } LASolver::LASolver(SMTConfig & c, ArithLogic & l) : LASolver(descr_la_solver, c, l) {} LASolver::LASolver(SolverDescr dls, SMTConfig & c, ArithLogic & l) : TSolver((SolverId) dls, (const char *) dls, c) , logic(l) , laVarMapper(l) , boundStore(laVarStore) , simplex(boundStore) { dec_limit.push(0); status = INIT; } int LASolver::backtrackLevel() { return dec_limit.size() - 1; } void LASolver::pushDecision(PtAsgn asgn) { int_decisions.push({asgn, backtrackLevel()}); decision_trace.push(asgn); } void LASolver::clearSolver() { status = INIT; simplex.clear(); decision_trace.clear(); int_decisions.clear(); dec_limit.clear(); TSolver::clearSolver(); laVarStore.clear(); laVarMapper.clear(); boundStore.clear(); LABoundRefToLeqAsgn.clear(); LeqToLABoundRefPair.clear(); int_vars.clear(); int_vars_map.clear(); // TODO: clear statistics // this->egraphStats.clear(); } void LASolver::storeExplanation(Simplex::Explanation &&explanationBounds) { explanation.clear(); explanationCoefficients.clear(); for (std::size_t i = 0; i < explanationBounds.size(); i++) { PtAsgn asgn = getAsgnByBound(explanationBounds[i].boundref); explanation.push(asgn); explanationCoefficients.push_back(explanationBounds[i].coeff); } } bool LASolver::check_simplex(bool complete) { // opensmt::StopWatch check_timer(egraphStats.simplex_timer); // printf(" - check %d\n", debug_check_count++); (void)complete; // check if we stop reading constraints if (status == INIT) { initSolver(); } storeExplanation(simplex.checkSimplex()); if (explanation.size() == 0) setStatus(SAT); else { setStatus(UNSAT); } getStatus() ? generalTSolverStats.sat_calls ++ : generalTSolverStats.unsat_calls ++; // printf(" - check ended\n"); // printf(" => %s\n", getStatus() ? "sat" : "unsat"); // if (getStatus()) // model.printModelState(); return getStatus(); } // // The model system // /* bool LASolver::isModelOutOfBounds(LVRef v) const { return simplex.isModelOutOfBounds(v); } bool LASolver::isModelOutOfUpperBound(LVRef v) const { return simplex.isModelOutOfBounds(v); } bool LASolver::isModelOutOfLowerBound(LVRef v) const { return ( model.read(v) < model.Lb(v) ); } const Delta LASolver::overBound(LVRef v) const { assert( isModelOutOfBounds(v) ); if (isModelOutOfUpperBound(v)) { return ( Delta(model.read(v) - model.Ub(v)) ); } else if ( isModelOutOfLowerBound(v) ) { return ( Delta(model.Lb(v) - model.read(v)) ); } assert (false); printf("Problem in overBound, LRASolver.C:%d\n", __LINE__); exit(1); } */ void LASolver::setBound(PTRef leq_tr) { // printf("Setting bound for %s\n", logic.printTerm(leq_tr)); addBound(leq_tr); } opensmt::Number LASolver::getNum(PTRef r) { return logic.getNumConst(r); } void LASolver::notifyVar(LVRef v) { assert(logic.isNumVar(getVarPTRef(v))); if (logic.yieldsSortInt(getVarPTRef(v))) { markVarAsInt(v); } } void LASolver::markVarAsInt(LVRef v) { if (!int_vars_map.has(v)) { int_vars_map.insert(v, true); int_vars.push(v); } } bool LASolver::hasVar(PTRef expr) { expr = laVarMapper.isNegated(expr) ? logic.mkNeg(expr) : expr; PTId id = logic.getPterm(expr).getId(); return laVarMapper.hasVar(id); } LVRef LASolver::getVarForLeq(PTRef ref) const { assert(logic.isLeq(ref)); auto [constant, term] = logic.leqToConstantAndTerm(ref); return laVarMapper.getVarByPTId(logic.getPterm(term).getId()); } LVRef LASolver::getLAVar_single(PTRef expr_in) { assert(logic.isLinearTerm(expr_in)); PTId id = logic.getPterm(expr_in).getId(); if (laVarMapper.hasVar(id)) { return getVarForTerm(expr_in); } PTRef expr = laVarMapper.isNegated(expr_in) ? logic.mkNeg(expr_in) : expr_in; LVRef x = laVarStore.getNewVar(); laVarMapper.registerNewMapping(x, expr); return x; } std::unique_ptr LASolver::expressionToLVarPoly(PTRef term) { auto poly = std::make_unique(); bool negated = laVarMapper.isNegated(term); for (int i = 0; i < logic.getPterm(term).size(); i++) { auto [v,c] = logic.splitTermToVarAndConst(logic.getPterm(term)[i]); LVRef var = getLAVar_single(v); Real coeff = getNum(c); if (negated) { coeff.negate(); } poly->addTerm(var, std::move(coeff)); } return poly; } // // Registers an arithmetic Pterm (polynomial) with the solver. // We may assume that the term is of one of the following forms, // where x is a variable or ite, and p_i are products of a variable or ite and a constant // // (1) x // (2a) (* x -1) // (2b) (* -1 x) // (3) x + p_1 + ... + p_n // (4a) (* x -1) + p_1 + ... + p_n // (4b) (* -1 x) + p_1 + ... + p_n // // Returns internalized reference for the term LVRef LASolver::registerArithmeticTerm(PTRef expr) { LVRef x = LVRef::Undef; if (laVarMapper.hasVar(expr)){ x = getVarForTerm(expr); if (simplex.isProcessedByTableau(x)){ return x; } } if (logic.isNumVar(expr) || logic.isTimes(expr)) { // Case (1), (2a), and (2b) auto [v,c] = logic.splitTermToVarAndConst(expr); assert(logic.isNumVar(v) || (laVarMapper.isNegated(v) && logic.isNumVar(logic.mkNeg(v)))); x = getLAVar_single(v); simplex.newNonbasicVar(x); notifyVar(x); } else { // Cases (3), (4a) and (4b) x = getLAVar_single(expr); auto poly = expressionToLVarPoly(expr); // ensure the simplex knows about all the variables // and compute if this poly is always integer bool isInt = true; for (auto const & term : *poly) { notifyVar(term.var); simplex.nonbasicVar(term.var); // MB: Notify must be called before the query isIntVar! isInt &= isIntVar(term.var) && term.coeff.isInteger(); } simplex.newRow(x, std::move(poly)); if (isInt) { markVarAsInt(x); } } assert(x != LVRef::Undef); return x; } // // Reads the constraint into the solver // void LASolver::declareAtom(PTRef leq_tr) { if (!logic.isLeq(leq_tr)) { return; } if (isInformed(leq_tr)) { return; } setInformed(leq_tr); if (status != INIT) { // Treat the PTRef as it is pushed on-the-fly // status = INCREMENT; assert( status == SAT ); PTRef term = logic.getPterm(leq_tr)[1]; registerArithmeticTerm(term); updateBound(leq_tr); } // DEBUG check isProperLeq(leq_tr); } LVRef LASolver::splitOnRandom(vec const & varsToFix) { int pick = opensmt::irand(seed, varsToFix.size()); return varsToFix[pick]; } TRes LASolver::checkIntegersAndSplit() { vec varsToFix; varsToFix.capacity(int_vars.size()); for (LVRef x : int_vars) { if (not isModelInteger(x)) { assert(not simplex.hasLBound(x) or not simplex.hasUBound(x) or simplex.Ub(x) - simplex.Lb(x) >= 1); varsToFix.push(x); } } if (varsToFix.size() == 0) { setStatus(SAT); return TRes::SAT; } if (shouldTryCutFromProof()) { auto res = cutFromProof(); if (res != TRes::UNKNOWN) { return res; } } LVRef chosen = splitOnRandom(varsToFix); assert(chosen != LVRef::Undef); auto splitLowerVal = simplex.getValuation(chosen).R().floor(); //x <= c || x >= c+1; PTRef varPTRef = getVarPTRef(chosen); PTRef upperBound = logic.mkLeq(varPTRef, logic.mkIntConst(splitLowerVal)); PTRef lowerBound = logic.mkGeq(varPTRef, logic.mkIntConst(splitLowerVal + 1)); PTRef constr = logic.mkOr(upperBound, lowerBound); splitondemand.push(constr); setStatus(NEWSPLIT); return TRes::SAT; } void LASolver::getNewSplits(vec& splits) { splitondemand.copyTo(splits); splitondemand.clear(); setStatus(SAT); } // // Push the constraint into the solver and increase the level // bool LASolver::assertLit(PtAsgn asgn) { assert(asgn.sgn != l_Undef); // printf("Assert %d\n", debug_assert_count++); // Special cases of the "inequalitites" if (logic.isTrue(asgn.tr) && asgn.sgn == l_True) { generalTSolverStats.sat_calls ++; return true; } if (logic.isFalse(asgn.tr) && asgn.sgn == l_False) { generalTSolverStats.sat_calls ++; return true; } if (logic.isTrue(asgn.tr) && asgn.sgn == l_False) { generalTSolverStats.unsat_calls ++; return false; } if (logic.isFalse(asgn.tr) && asgn.sgn == l_True) { generalTSolverStats.unsat_calls ++; return false; } // check if we stop reading constraints if( status == INIT ) initSolver( ); if (hasPolarity(asgn.tr) && getPolarity(asgn.tr) == asgn.sgn) { // already known, no new information // MB: The deductions done by this TSolver are also marked using polarity. // The invariant is that TSolver will not process the literal again (when asserted from the SAT solver) // once it is marked for deduction, so the implementation must count with that. assert(getStatus()); generalTSolverStats.sat_calls ++; return getStatus(); } LABoundRefPair p = getBoundRefPair(asgn.tr); LABoundRef bound_ref = asgn.sgn == l_False ? p.neg : p.pos; // printf("Model state\n"); // model.printModelState(); // printf("Asserting %s (%d)\n", boundStore.printBound(bound_ref), asgn.tr.x); // printf(" - equal to %s%s\n", asgn.sgn == l_True ? "" : "not ", logic.pp(asgn.tr)); LVRef it = getVarForLeq(asgn.tr); // Constraint to push was not found in local storage. Most likely it was not read properly before assert(it != LVRef::Undef); if (assertBoundOnVar( it, bound_ref)) { assert(getStatus()); setPolarity(asgn.tr, asgn.sgn); pushDecision(asgn); getSimpleDeductions(it, bound_ref); generalTSolverStats.sat_calls++; } else { generalTSolverStats.unsat_calls++; } return getStatus(); } bool LASolver::assertBoundOnVar(LVRef it, LABoundRef itBound_ref) { // No check whether the bounds are consistent for the polynomials. This is done later with Simplex. assert(status == SAT); assert(it != LVRef::Undef); storeExplanation(simplex.assertBoundOnVar(it, itBound_ref)); if (explanation.size() > 0) { return setStatus(UNSAT); } return getStatus(); } // // Push the solver one level down // void LASolver::pushBacktrackPoint( ) { // Check if any updates need to be repeated after backtrack simplex.pushBacktrackPoint(); dec_limit.push(decision_trace.size()); // Update the generic deductions state TSolver::pushBacktrackPoint(); } PtAsgn LASolver::popDecisions() { PtAsgn popd = PtAsgn_Undef; assert(decision_trace.size() - dec_limit.last() == 1 || decision_trace.size() - dec_limit.last() == 0); if (decision_trace.size() - dec_limit.last() == 1) { popd = int_decisions.last().asgn; int_decisions.pop(); } decision_trace.shrink(decision_trace.size() - dec_limit.last()); return popd; } PtAsgn LASolver::popTermBacktrackPoint() { simplex.popBacktrackPoint(); PtAsgn popd = popDecisions(); dec_limit.pop(); return popd; } // Pop the solver one level up // NOTE: this method should not be used, pop multiple points is more efficient with popBacktrackPoints rather than popping one by one void LASolver::popBacktrackPoint( ) { this->popBacktrackPoints(1); } // Pop the solver given number of times // void LASolver::popBacktrackPoints(unsigned int count) { for ( ; count > 0; --count){ PtAsgn dec = popTermBacktrackPoint(); if (dec != PtAsgn_Undef) { clearPolarity(dec.tr); LVRef it = getVarForLeq(dec.tr); simplex.boundDeactivated(it); } TSolver::popBacktrackPoint(); } simplex.finalizeBacktracking(); if(status != INIT){ setStatus(SAT); } } void LASolver::initSolver() { if (status == INIT) { #ifdef GAUSSIAN_DEBUG cout << "Columns:" << '\n'; for (int i = 0; i < columns.size(); i++) cout << columns[i] << '\n'; cout << "Rows:" << '\n'; for (int i = 0; i < rows.size(); i++) cout << rows[i] << '\n'; #endif const auto & known_PTRefs = getInformed(); for(PTRef leq_tr : known_PTRefs) { Pterm const & leq_t = logic.getPterm(leq_tr); // Terms are of form c <= t where // - c is a constant and // - t is either a variable or a sum // leq_t[0] is const and leq_t[1] is term PTRef term = leq_t[1]; // Ensure that all variables exists, build the polynomial, and update the occurrences. registerArithmeticTerm(term); // Assumes that the LRA variable has been already declared setBound(leq_tr); } boundStore.buildBounds(); // Bounds are needed for gaussian elimination simplex.initModel(); status = SAT; } else { throw OsmtInternalException("Solver can not be initialized in the state different from INIT"); } } // // Returns boolean value correspondent to the current solver status // inline bool LASolver::getStatus( ) { switch( status ) { case SAT: { return true; break; } case UNSAT: { return false; break; } case NEWSPLIT: { return true; break; } case UNKNOWN: // cerr << "LA Solver status is unknown" << endl; status = SAT; return true; case INIT: case ERROR: default: throw OsmtApiException("Status is undef!"); } } // // Sets the new solver status and returns the correspondent lbool value // bool LASolver::setStatus( LASolverStatus s ) { status = s; has_explanation = (s == UNSAT); return getStatus( ); } void LASolver::getSimpleDeductions(LVRef v, LABoundRef br) { // printf("Deducing from bound %s\n", boundStore.printBound(br)); // printf("The full bound list for %s:\n%s\n", logic.printTerm(lva[v].getPTRef()), boundStore.printBounds(v)); const LABound& bound = boundStore[br]; if (bound.getType() == bound_l) { for (int it = bound.getIdx().x - 1; it >= 0; it = it - 1) { LABoundRef bound_prop_ref = boundStore.getBoundByIdx(v, it); LABound &bound_prop = boundStore[bound_prop_ref]; if (bound_prop.getType() != bound_l) continue; deduce(bound_prop_ref); } } else if (bound.getType() == bound_u) { for (int it = bound.getIdx().x + 1; it < boundStore.getBounds(v).size() - 1; it = it + 1) { LABoundRef bound_prop_ref = boundStore.getBoundByIdx(v, it); LABound & bound_prop = boundStore[bound_prop_ref]; if (bound_prop.getType() != bound_u) continue; deduce(bound_prop_ref); } } } void LASolver::deduce(LABoundRef bound_prop) { PtAsgn ba = getAsgnByBound(bound_prop); if (!hasPolarity(ba.tr)) { storeDeduction(PtAsgn_reason(ba.tr, ba.sgn, PTRef_Undef)); } } void LASolver::getConflict(vec & conflict) { for (PtAsgn lit : explanation) { conflict.push(lit); } } // We may assume that the term is of the following forms // (1) (* x c) // (2) (* c x) // (3) c opensmt::Number LASolver::evaluateTerm(PTRef tr) { opensmt::Real val(0); // Case (3) if (logic.isNumConst(tr)) return logic.getNumConst(tr); // Cases (1) & (2) auto [var, coeff] = logic.splitTermToVarAndConst(tr); if (!hasVar(var)) { // MB: This variable is not known to the LASolver. Most probably it was not part of the query. // We can assign it any value. return 0; } val += logic.getNumConst(coeff) * concrete_model[getVarId(getVarForTerm(var))]; return val; } void LASolver::fillTheoryFunctions(ModelBuilder & modelBuilder) const { for (LVRef lvar : laVarStore) { PTRef term = laVarMapper.getVarPTRef(lvar); if (logic.isNumVar(term)) { PTRef val = logic.mkConst(logic.getSortRef(term), concrete_model[getVarId(lvar)]); modelBuilder.addVarValue(term, val); } } } void LASolver::computeConcreteModel(LVRef v, const opensmt::Real& delta) { while (concrete_model.size() <= getVarId(v)) concrete_model.push_back(0); Delta val = simplex.getValuation(v); concrete_model[getVarId(v)] = val.R() + val.D() * delta; } // // Detect the appropriate value for symbolic delta and stores the model // void LASolver::computeModel() { assert( status == SAT ); opensmt::Real delta = simplex.computeDelta(); for (LVRef var : laVarStore) { computeConcreteModel(var, delta); } } LASolver::~LASolver( ) { #ifdef STATISTICS printStatistics(std::cerr); #endif // STATISTICS } ArithLogic& LASolver::getLogic() { return logic; } /** * Given an inequality v ~ c (with ~ is either < or <=), compute the correct bounds on the variable. * The correct values of the bounds are computed differently, based on whether the value of v must be Int or not. * * @param c Real number representing the upper bound * @param strict inequality is LEQ if false, LT if true * @return The values of upper and lower bound corresponding to the inequality */ LABoundStore::BoundValuePair LASolver::getBoundsValue(LVRef v, const Real & c, bool strict) { return isIntVar(v) ? getBoundsValueForIntVar(c, strict) : getBoundsValueForRealVar(c, strict); } /** * Given an imaginary inequality v ~ c (with ~ is either < or <=), compute the interger bounds on the variable * * @param c Real number representing the upper bound * @param strict inequality is LEQ if false, LT if true * @return The integer values of upper and lower bound corresponding to the inequality */ LABoundStore::BoundValuePair LASolver::getBoundsValueForIntVar(const Real & c, bool strict) { if (strict) { // v < c => UB is ceiling(c-1), LB is ceiling(c) return {Delta((c-1).ceil()), Delta(c.ceil())}; } else { // v <= c => UB is floor(c), LB is floor(c+1) return {Delta(c.floor()), Delta((c+1).floor())}; } } /** * Given an imaginary inequality v ~ c (with ~ is either < or <=), compute the real bounds on the variable * * @param c Real number representing the upper bound * @param strict inequality is LEQ if false, LT if true * @return The real values of upper and lower bound corresponding to the inequality */ LABoundStore::BoundValuePair LASolver::getBoundsValueForRealVar(const Real & c, bool strict) { if (strict) { // v < c => UB is c-\delta, LB is c return { Delta(c, -1), Delta(c) }; } else { // v <= c => UB is c, LB is c+\delta return { Delta(c), Delta(c, 1) }; } } lbool LASolver::getPolaritySuggestion(PTRef ptref) const { if (!this->isInformed(ptref)) { return l_Undef; } LVRef var = this->getVarForLeq(ptref); LABoundRefPair bounds = getBoundRefPair(ptref); assert( bounds.pos != LABoundRef_Undef && bounds.neg != LABoundRef_Undef ); return simplex.getPolaritySuggestion(var, bounds.pos, bounds.neg); } TRes LASolver::check(bool complete) { bool rval = check_simplex(complete); if (complete && rval) { return checkIntegersAndSplit(); } return rval ? TRes::SAT : TRes::UNSAT; } bool LASolver::isModelInteger(LVRef v) const { Delta val = simplex.getValuation(v); return !( val.hasDelta() || !val.R().isInteger() ); } PTRef LASolver::interpolateUsingEngine(FarkasInterpolator & interpolator) const { auto itpAlgorithm = config.getLRAInterpolationAlgorithm(); if (itpAlgorithm == itp_lra_alg_strong) { return interpolator.getFarkasInterpolant(); } else if (itpAlgorithm == itp_lra_alg_weak) { return interpolator.getDualFarkasInterpolant(); } else if (itpAlgorithm == itp_lra_alg_factor) { return interpolator.getFlexibleInterpolant(opensmt::Real(config.getLRAStrengthFactor())); } else if (itpAlgorithm == itp_lra_alg_decomposing_strong) { return interpolator.getDecomposedInterpolant(); } else if (itpAlgorithm == itp_lra_alg_decomposing_weak) { return interpolator.getDualDecomposedInterpolant(); } else { assert(false); // Incorrect value in config return interpolator.getFarkasInterpolant(); } } // // Compute interpolants for the conflict // PTRef LASolver::getRealInterpolant( const ipartitions_t & mask , ItpColorMap * labels, PartitionManager &pmanager) { assert(status == UNSAT); vec explCopy; explanation.copyTo(explCopy); FarkasInterpolator interpolator(logic, std::move(explCopy), explanationCoefficients, labels ? *labels : ItpColorMap{}, std::make_unique(pmanager, mask)); return interpolateUsingEngine(interpolator); } PTRef LASolver::getIntegerInterpolant(ItpColorMap const& labels) { assert(status == UNSAT); LIAInterpolator interpolator(logic, LAExplanations::getLIAExplanation(logic, explanation, explanationCoefficients, labels)); return interpolateUsingEngine(interpolator); } void LASolver::printStatistics(std::ostream & out) { TSolver::printStatistics(out); laSolverStats.printStatistics(out); } bool LASolver::shouldTryCutFromProof() const { if (this->config.produce_inter()) { return false; } static unsigned long counter = 0; return ++counter % 10 == 0; } namespace { struct DefiningConstraint { PTRef lhs; opensmt::Real rhs; }; /* * Translates the set of defining constraints (linear equalities) into a suitable inner representation: * - A sparse matrix A of coefficients and constants b * - a map from column indices to the corresponding variables x * - The result is to be interpreted as the linear system Ax = b */ std::pair> linearSystemFromConstraints(std::vector const & constraints, ArithLogic & logic) { vec terms; auto fillTerms = [&logic](PTRef poly, vec & terms) {// reduces linear polynomial to a vector of the polynomial's terms terms.clear(); if (logic.isPlus(poly)) { for (PTRef arg : logic.getPterm(poly)) { terms.push(arg); } } else { terms.push(poly); } }; std::unordered_map varIndices; uint32_t columns = 0; // First pass to assign indices and find out number of columns for (auto const & defConstraint : constraints) { PTRef poly = defConstraint.lhs; fillTerms(poly, terms); for (PTRef arg : terms) { auto [var, constant] = logic.splitTermToVarAndConst(arg); assert(var != PTRef_Undef); if (varIndices.find(var) == varIndices.end()) { varIndices.insert({var, columns++}); } } } uint32_t rows = constraints.size(); SparseColMatrix matrixA(RowCount{rows}, ColumnCount{columns}); std::vector rhs(rows); std::vector columnPolynomials(columns); // Second pass to build the actual matrix for (unsigned row = 0; row < constraints.size(); ++row) { rhs[row] = constraints[row].rhs; PTRef poly = constraints[row].lhs; fillTerms(poly, terms); for (PTRef arg : terms) { auto [var, constant] = logic.splitTermToVarAndConst(arg); auto col = varIndices[var]; columnPolynomials[col].addTerm(IndexType{row}, logic.getNumConst(constant)); } } for (uint32_t i = 0; i < columnPolynomials.size(); ++i) { matrixA.setColumn(ColIndex{i}, std::move(columnPolynomials[i])); } // compute the inverse map from column indices to variables std::vector columnMapping(matrixA.colCount(), PTRef_Undef); for (auto [var, index] : varIndices) { columnMapping[index] = var; } assert(matrixA.colCount() == columnMapping.size()); return {SparseLinearSystem{std::move(matrixA), std::move(rhs)}, std::move(columnMapping)}; } PTRef getSumFromTermVec(SparseColMatrix::TermVec const & termVec, vec const & toVarMap, ArithLogic & logic) { vec args; for (auto const & term : termVec) { IndexType var = term.first; auto const & coeff = term.second; args.push(logic.mkTimes(toVarMap[var.x], logic.mkIntConst(coeff))); } return logic.mkPlus(std::move(args)); } PTRef cutToSplit(CutCreator::Cut && cut, std::vector const & toVarMap, ArithLogic & logic) { auto const & termVec = cut.first; auto const & rhs = cut.second; if (termVec.empty()) { return PTRef_Undef; } PTRef constraint = getSumFromTermVec(termVec, toVarMap, logic); auto lowerBoundValue = rhs.ceil(); auto upperBoundValue = rhs.floor(); PTRef upperBound = logic.mkLeq(constraint, logic.mkIntConst(upperBoundValue)); PTRef lowerBound = logic.mkGeq(constraint, logic.mkIntConst(lowerBoundValue)); return logic.mkOr(upperBound, lowerBound); } } TRes LASolver::cutFromProof() { auto isOnLowerBound = [this](LVRef var) { return simplex.hasLBound(var) and not simplex.isModelStrictlyOverLowerBound(var); }; auto isOnUpperBound = [this](LVRef var) { return simplex.hasUBound(var) and not simplex.isModelStrictlyUnderUpperBound(var); }; // Step 1: Gather defining constraints std::vector constraints; for (LVRef var : int_vars) { bool isOnLower = isOnLowerBound(var); bool isOnUpper = isOnUpperBound(var); if (not isOnLower and not isOnUpper) { continue; } PTRef term = laVarMapper.getVarPTRef(var); auto const & val = isOnLower ? simplex.Lb(var) : simplex.Ub(var); assert(not val.hasDelta()); auto const & rhs = val.R(); assert(rhs.isInteger()); constraints.push_back(DefiningConstraint{term, rhs}); // std::cout << logic.pp(term) << " = " << rhs << std::endl; } auto getVarValue = [this](PTRef var) { assert(this->logic.isVar(var)); LVRef lvar = this->laVarMapper.getVarByPTId(logic.getPterm(var).getId()); Delta val = this->simplex.getValuation(lvar); assert(not val.hasDelta()); return val.R(); }; CutCreator cutCreator(getVarValue); auto [system, toVarMap] = linearSystemFromConstraints(constraints, logic); auto cut = cutCreator.makeCut(std::move(system), toVarMap); PTRef split = cutToSplit(std::move(cut), toVarMap, logic); if (split == PTRef_Undef) { return TRes::UNKNOWN; } splitondemand.push(split); setStatus(NEWSPLIT); return TRes::SAT; } vec LASolver::collectEqualitiesFor(vec const & vars, std::unordered_set const & knownEqualities) { struct DeltaHash { std::size_t operator()(Delta const & d) const { FastRationalHash hasher; return (hasher(d.R()) ^ hasher(d.D())); } }; vec equalities; std::unordered_map, DeltaHash> eqClasses; for (PTRef var : vars) { if (logic.isNumConst(var)) { eqClasses[logic.getNumConst(var)].push(var); } else { assert(logic.isNumVar(var)); if (not laVarMapper.hasVar(var)) { // LASolver does not have any constraints on this LA var continue; } LVRef v = laVarMapper.getVarByPTId(logic.getPterm(var).getId()); auto value = simplex.getValuation(v); eqClasses[value].push(var); } } for (auto const & entry : eqClasses) { auto const & equivalentVars = entry.second; for (int i = 0; i < equivalentVars.size(); ++i) { for (int j = i + 1; j < equivalentVars.size(); ++j) { PTRef eq = logic.mkEq(equivalentVars[i], equivalentVars[j]); if (knownEqualities.find(eq) == knownEqualities.end()) { equalities.push(eq); } } } } // Hack to ensure that when model is computed, delta is not picked so that it merges some of the equivalence // classes that are different at this point if (equalities.size() == 0 and not eqClasses.empty()) { std::vector valuesWithDelta; for (auto const & entry : eqClasses) { if (entry.first.hasDelta()) { valuesWithDelta.push_back(entry.first); } } for (auto const & val : valuesWithDelta) { for (auto const & entry : eqClasses) { // check if entry.first - val could be 0 for some value of delta, with 0 < delta <= 1 auto diff = entry.first - val; if (not diff.hasDelta()) { continue; } // MB: This takes care also of the case where val == entry.first if (isNonNegative(diff.R()) and isPositive(diff.D())) { continue; } if (isNonPositive(diff.R()) and isNegative(diff.D())) { continue; } auto ratio = diff.R() / diff.D(); assert(isNegative(ratio)); if (ratio < FastRational(-1)) { continue; } // MB: ratio is -delta; hence -1 <= ratio < 0 // They could be equal for the right value of delta, add equalities for cross-product vec const & varsOfFirstVal = eqClasses.at(val); vec const & varsOfSecondVal = entry.second; for (PTRef var1 : varsOfFirstVal) { for (PTRef var2 : varsOfSecondVal) { PTRef eq = logic.mkEq(var1, var2); if (knownEqualities.find(eq) == knownEqualities.end()) { equalities.push(eq); // MB: It should be OK to decide one such equality, we do not have to add whole cross-product at once return equalities; } } } } } } return equalities; } opensmt-2.5.2/src/tsolvers/lasolver/LASolver.h000066400000000000000000000161341445011647600213610ustar00rootroot00000000000000/* * Copyright (c) 2019-2022, Antti Hyvarinen * Copyright (c) 2019-2022, Martin Blicha * * SPDX-License-Identifier: MIT */ #ifndef LASOLVER_H #define LASOLVER_H #include "Timer.h" #include "ArithLogic.h" #include "TSolver.h" #include "LRAModel.h" #include "Tableau.h" #include "Polynomial.h" #include "Simplex.h" #include "FarkasInterpolator.h" #include "LAVarMapper.h" #include #include class LAVarStore; class Delta; class PartitionManager; class LASolverStats { public: int num_vars; opensmt::OSMTTimeVal timer; LASolverStats() : num_vars(0) {} void printStatistics(std::ostream& os) { os << "; Number of LA vars........: " << num_vars << '\n'; os << "; LA time..................: " << timer.getTime() << " s\n"; } }; // // Class to solve Linear Arithmetic theories // class LASolver: public TSolver { private: struct DecEl { PtAsgn asgn; int dl; }; ArithLogic& logic; LAVarStore laVarStore; LAVarMapper laVarMapper; LABoundStore boundStore; Simplex simplex; vec decision_trace; vec dec_limit; vec int_decisions; PtAsgn popTermBacktrackPoint(); PtAsgn popDecisions(); void pushDecision(PtAsgn); int backtrackLevel(); std::vector explanationCoefficients; vec LABoundRefToLeqAsgn; PtAsgn getAsgnByBound(LABoundRef br) const; vec LeqToLABoundRefPair; LABoundRefPair getBoundRefPair(const PTRef leq) const { auto index = Idx(logic.getPterm(leq).getId()); assert(index < LeqToLABoundRefPair.size_()); return LeqToLABoundRefPair[index]; } // Possible internal states of the solver typedef enum { INIT, INCREMENT, SAT, UNSAT, NEWSPLIT, UNKNOWN, ERROR } LASolverStatus; LASolverStats laSolverStats; void setBound(PTRef leq); bool assertBoundOnVar(LVRef it, LABoundRef itBound_ref); PTRef getVarPTRef(LVRef v) const { return laVarMapper.getVarPTRef(v); } public: using ItpColorMap = TheoryInterpolator::ItpColorMap; LASolver(SMTConfig & c, ArithLogic & l); LASolver(SolverDescr dls, SMTConfig & c, ArithLogic & l); virtual ~LASolver( ); // Destructor ;-) virtual void printStatistics(std::ostream &) override; virtual void clearSolver() override; // Remove all problem specific data from the solver. Should be called each time the solver is being used after a push or a pop in the incremental interface. void getNewSplits(vec& splits) override; void declareAtom (PTRef tr) override; // Inform the theory solver about the existence of an atom TRes check (bool) override; // Checks the satisfiability of current constraints bool check_simplex (bool); bool assertLit ( PtAsgn ) override; // Push the constraint into Solver void pushBacktrackPoint ( ) override; // Push a backtrack point void popBacktrackPoint ( ) override; // Backtrack to last saved point void popBacktrackPoints ( unsigned int ) override; // Backtrack given number of saved points lbool getPolaritySuggestion(PTRef) const; void fillTheoryFunctions(ModelBuilder & modelBuilder) const override; vec collectEqualitiesFor(vec const & vars, std::unordered_set const & knownEqualities) override; PTRef getRealInterpolant(const ipartitions_t &, ItpColorMap *, PartitionManager & pmanager); PTRef getIntegerInterpolant(ItpColorMap const &); // Return the conflicting bounds void getConflict(vec &) override; ArithLogic& getLogic() override; bool isValid(PTRef tr) override; private: Map int_vars_map; // stores problem variables for duplicate check vec int_vars; // stores the list of problem variables without duplicates double seed = 123; LABoundStore::BoundInfo addBound(PTRef leq_tr); void updateBound(PTRef leq_tr); LVRef registerArithmeticTerm(PTRef expr); // Ensures this term and all variables in it has corresponding LVAR. Returns the LAVar for the term. void storeExplanation(Simplex::Explanation &&explanationBounds); std::unique_ptr expressionToLVarPoly(PTRef term); opensmt::Number getNum(PTRef); bool isIntVar(LVRef v) { return int_vars_map.has(v); } void markVarAsInt(LVRef); // Compute the values for an upper bound v ~ c and its negation \neg (v ~ c), where ~ is < if strict and <= if !strict LABoundStore::BoundValuePair getBoundsValue(LVRef v, const Real & c, bool strict); LABoundStore::BoundValuePair getBoundsValueForIntVar(const Real & c, bool strict); LABoundStore::BoundValuePair getBoundsValueForRealVar(const Real & c, bool strict); LVRef getLAVar_single(PTRef term); // Initialize a new LA var if needed, otherwise return the old var bool hasVar(PTRef expr); LVRef getVarForLeq(PTRef ref) const; LVRef getVarForTerm(PTRef ref) const { return laVarMapper.getVarByPTId(logic.getPterm(ref).getId()); } void notifyVar(LVRef); // Notify the solver of the existence of the var. This is so that LIA can add it to integer vars list. // Random splitting heuristic LVRef splitOnRandom(vec const &); TRes checkIntegersAndSplit(); bool isModelInteger (LVRef v) const; TRes cutFromProof(); bool shouldTryCutFromProof() const; void getSuggestions( vec& dst, SolverId solver_id ); // find possible suggested atoms void getSimpleDeductions(LVRef v, LABoundRef); // find deductions from actual bounds position unsigned getIteratorByPTRef( PTRef e, bool ); // find bound iterator by the PTRef inline bool getStatus( ); // Read the status of the solver in lbool bool setStatus( LASolverStatus ); // Sets and return status of the solver void initSolver( ); // Initializes the solver void computeConcreteModel(LVRef v, const opensmt::Real& d); void computeModel() override; std::vector concrete_model; // Save here the concrete model for the vars indexed by Id opensmt::Real evaluateTerm(PTRef tr); LASolverStatus status; // Internal status of the solver (different from bool) PTRef interpolateUsingEngine(FarkasInterpolator &) const; inline int verbose ( ) const { return config.verbosity(); } // Debug stuff void isProperLeq(PTRef tr); // The Leq term conforms to the assumptions of its form. Only asserts. void deduce(LABoundRef bound_prop); }; #endif opensmt-2.5.2/src/tsolvers/lasolver/LAVar.cc000066400000000000000000000032151445011647600207710ustar00rootroot00000000000000/********************************************************************* Author: Aliaksei Tsitovich Roberto Bruttomesso Antti Hyvarinen OpenSMT2 -- Copyright (C) 2012 - 2015, Antti Hyvarinen 2008 - 2012, Roberto Bruttomesso 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. *********************************************************************/ #include "LAVar.h" LVRef LAVarStore::getNewVar() { auto idx = static_cast(lavars.size()); LVRef lv {idx}; lavars.push_back(lv); return lv; } std::size_t LAVarStore::numVars() const { return lavars.size(); } opensmt-2.5.2/src/tsolvers/lasolver/LAVar.h000066400000000000000000000034611445011647600206360ustar00rootroot00000000000000/********************************************************************* Author: Aliaksei Tsitovich , Roberto Bruttomesso OpenSMT2 -- Copyright (C) 2008-2012, Roberto Bruttomesso 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. *********************************************************************/ #ifndef LAVAR_H #define LAVAR_H #include "LARefs.h" #include class LAVarStore; class ArithLogic; class LAVarStore { private: std::vector lavars; public: LAVarStore() {} LVRef getNewVar(); inline void clear() { lavars.clear(); } std::size_t numVars() const ; using const_iterator = decltype(lavars)::const_iterator; const_iterator begin() const { return lavars.begin(); } const_iterator end() const { return lavars.end(); } }; #endif opensmt-2.5.2/src/tsolvers/lasolver/LAVarMapper.cc000066400000000000000000000046151445011647600221430ustar00rootroot00000000000000/* * Copyright (c) 2019-2022, Antti Hyvarinen * Copyright (c) 2019-2022, Martin Blicha * * SPDX-License-Identifier: MIT */ #include "LAVarMapper.h" #include "ArithLogic.h" /** * Remembers the mapping between a linear term (PTRef) and LA var (LVRef). * * The PTRef is expect to be a positive term, i.e., its leading variable does NOT have a negative coefficient. * LA var is mapped to the positive term, but both positive term and its negation are mapped to the given LVRef. * * This avoids duplicate representations and simplifies the usage of these mappings since PTRefs do not have to be * further normalized. The current implementation (26.5.2020) makes use of negative terms to represent all * possible inequalities using LEQ and negation. */ void LAVarMapper::registerNewMapping(LVRef lv, PTRef e_orig) { assert(!hasVar(e_orig)); assert(!isNegated(e_orig)); if (lv.x >= static_cast(laVarToPTRef.size())) { laVarToPTRef.growTo(lv.x+1, PTRef_Undef); } laVarToPTRef[lv.x] = e_orig; PTId id_pos = logic.getPterm(e_orig).getId(); PTId id_neg = logic.getPterm(logic.mkNeg(e_orig)).getId(); assert(!hasVar(id_pos)); int max_id = std::max(Idx(id_pos), Idx(id_neg)); if (max_id >= ptermToLavar.size()) { ptermToLavar.growTo(max_id + 1, LVRef::Undef); } assert(ptermToLavar[Idx(id_pos)] == ptermToLavar[Idx(id_neg)]); ptermToLavar[Idx(id_pos)] = lv; ptermToLavar[Idx(id_neg)] = lv; } LVRef LAVarMapper::getVarByPTId(PTId i) const { return ptermToLavar[Idx(i)]; } bool LAVarMapper::hasVar(PTRef tr) const { return hasVar(logic.getPterm(tr).getId()); } bool LAVarMapper::hasVar(PTId i) const { return static_cast(ptermToLavar.size()) > Idx(i) && ptermToLavar[Idx(i)] != LVRef::Undef; } bool LAVarMapper::isNegated(PTRef tr) const { if (logic.isNumConst(tr)) return logic.getNumConst(tr) < 0; // Case (0a) and (0b) if (logic.isNumVar(tr)) return false; // Case (1a) if (logic.isTimes(tr)) { // Cases (2) auto [v,c] = logic.splitTermToVarAndConst(tr); return isNegated(c); } if (logic.isIte(tr)) { return false; } else { // Cases(3) return isNegated(logic.getPterm(tr)[0]); } } void LAVarMapper::clear() { this->laVarToPTRef.clear(); this->ptermToLavar.clear(); } opensmt-2.5.2/src/tsolvers/lasolver/LAVarMapper.h000066400000000000000000000027461445011647600220100ustar00rootroot00000000000000/* * Copyright (c) 2019-2022, Antti Hyvarinen * Copyright (c) 2019-2022, Martin Blicha * * SPDX-License-Identifier: MIT */ #ifndef OPENSMT_LAVARMAPPER_H #define OPENSMT_LAVARMAPPER_H #include "LARefs.h" #include "Pterm.h" #include "Vec.h" class ArithLogic; /** * A class for maintaining the correspondence between the Pterms and variables of the Simplex algorithm * * Variables of the Simplex algorithm, LVRefs, represent linear terms in linear arithmetic, e.g., x, x - y, -2x + 3y, * where x and y are variables (either of type Real or Integer). * Both directions of this mapping are maintained. * * In addition, a convenience mapping is maintained to obtain the corresponding LVRef directly from an inequality, * instead of forcing to isolate the term from the constant and normalize it. */ class LAVarMapper { private: /** Mapping of linear Pterms to LVRefs */ vec ptermToLavar; /** The inverse of ptermToLavar, mapping LVRefs to PTRefs */ vec laVarToPTRef; ArithLogic& logic; public: LAVarMapper(ArithLogic &logic) : logic(logic) {} void registerNewMapping(LVRef lv, PTRef e_orig); LVRef getVarByPTId(PTId i) const; bool hasVar(PTId i) const; bool hasVar(PTRef tr) const; inline PTRef getVarPTRef(LVRef ref) const { return laVarToPTRef[ref.x]; } void clear(); bool isNegated(PTRef tr) const; }; #endif //OPENSMT_LAVARMAPPER_H opensmt-2.5.2/src/tsolvers/lasolver/LIAInterpolator.cc000066400000000000000000000052771445011647600230460ustar00rootroot00000000000000// // Created by Martin Blicha on 06.11.20. // #include "LIAInterpolator.h" #include "ArithLogic.h" #include LAExplanations LAExplanations::getLIAExplanation(ArithLogic & logic, vec const & explanations, std::vector const & coeffs, ItpColorMap const & labels) { LAExplanations liaExplanations; // We need to recompute the labels for the Farkas interpolator! // Consider this example: not (0 <= x - y) with label A; not (1 <= y - x) with label B // After strengthening we get 1 <= y - x with label A; 0 <= x - y with label B // The labels have been switched for the positive atoms, and we need to make sure that interpolator sees the second version of the labels for (auto explEntry : explanations) { PTRef positiveInequality = explEntry.tr; lbool sign = explEntry.sgn; assert(logic.isLeq(positiveInequality)); assert(sign == l_True or sign == l_False); PTRef boundVal = logic.getConstantFromLeq(positiveInequality); PTRef boundedTerm = logic.getTermFromLeq(positiveInequality); assert(logic.isNumConst(boundVal) and logic.isLinearTerm(boundedTerm)); assert(logic.getNumConst(boundVal).isInteger()); // We assume LIA inequalities are already strengthened if (sign == l_True) { // Already strengthened! liaExplanations.explanations.push(PtAsgn(positiveInequality, l_True)); } else { // 'not (c <= term)' => 'c > term' => 'term < c' => 'term <= c-1' => -(c-1) <= -term auto newBoundValue = (logic.getNumConst(boundVal) - 1); newBoundValue.negate(); PTRef nInequality = logic.mkLeq(logic.mkIntConst(newBoundValue), logic.mkNeg(boundedTerm)); assert(logic.getTermFromLeq(nInequality) == logic.mkNeg(boundedTerm)); liaExplanations.explanations.push(PtAsgn(nInequality, l_True)); } // Ensure the strengthened inequality has correct partition information PTRef nInequality = liaExplanations.explanations.last().tr; auto res = liaExplanations.labels.insert(std::make_pair(nInequality, labels.at(positiveInequality))); if (not res.second) { // key has been already present throw OsmtInternalException("Error in preparing LIA interpolation"); } } liaExplanations.coeffs = coeffs; return liaExplanations; } LIAInterpolator::LIAInterpolator(ArithLogic & logic, LAExplanations liaExplanations) : FarkasInterpolator(logic, std::move(liaExplanations.explanations), std::move(liaExplanations.coeffs), std::move(liaExplanations.labels)) { } opensmt-2.5.2/src/tsolvers/lasolver/LIAInterpolator.h000066400000000000000000000013701445011647600226760ustar00rootroot00000000000000// // Created by Martin Blicha on 06.11.20. // #ifndef OPENSMT_LIAINTERPOLATOR_H #define OPENSMT_LIAINTERPOLATOR_H #include "FarkasInterpolator.h" using ItpColorMap = TheoryInterpolator::ItpColorMap; struct LAExplanations { vec explanations; std::vector coeffs; ItpColorMap labels; static LAExplanations getLIAExplanation(ArithLogic & logic, vec const & explanations, std::vector const & coeffs, ItpColorMap const & labels); }; class LIAInterpolator : public FarkasInterpolator { public: LIAInterpolator(ArithLogic & logic, LAExplanations liaExplanations); }; #endif //OPENSMT_LIAINTERPOLATOR_H opensmt-2.5.2/src/tsolvers/lasolver/LRAModel.cc000066400000000000000000000101001445011647600214120ustar00rootroot00000000000000// // Created by prova on 04.01.18. // #include "LRAModel.h" void LRAModel::init() { LAVarStore const & varStore = bs.getVarStore(); for (LVRef ref : varStore) { addVar(ref); } } int LRAModel::addVar(LVRef v) { if (has_model.has(v)) return n_vars_with_model; while (static_cast(current_assignment.size()) <= getVarId(v)) { current_assignment.emplace_back(); last_consistent_assignment.emplace_back(); changed_vars_set.assure_domain(getVarId(v)); int_lbounds.emplace_back(); int_ubounds.emplace_back(); } has_model.insert(v, true); return ++n_vars_with_model; } void LRAModel::write(const LVRef &v, Delta val) { current_assignment[getVarId(v)] = std::move(val); if (!changed_vars_set.contains(getVarId(v))) { changed_vars_set.insert(getVarId(v)); changed_vars_vec.push(v); } } void LRAModel::pushBound(const LABoundRef br) { LABound& b = bs[br]; LVRef vr = b.getLVRef(); if (b.getType() == bound_u) { int_ubounds[getVarId(vr)].push(br); } else { int_lbounds[getVarId(vr)].push(br); } bound_trace.push(br); } void LRAModel::popBounds() { for (int i = bound_trace.size()-1; i >= bound_limits.last(); i--) { LABoundRef br = bound_trace[i]; LABound &b = bs[br]; LVRef vr = b.getLVRef(); if (b.getType() == bound_u) { int_ubounds[getVarId(vr)].pop(); } else { int_lbounds[getVarId(vr)].pop(); } } bound_trace.shrink(bound_trace.size() - bound_limits.last()); } void LRAModel::clear() { this->current_assignment.clear(); this->last_consistent_assignment.clear(); this->changed_vars_set.reset(); this->changed_vars_vec.clear(); this->int_lbounds.clear(); this->bound_trace.clear(); this->has_model.clear(); this->int_ubounds.clear(); this->bound_limits.clear(); this->n_vars_with_model = 0; bound_limits.push(0); } int LRAModel::backtrackLevel() { return bound_limits.size() - 1; } LABoundRef LRAModel::readLBoundRef(LVRef v) const { assert(hasLBound(v)); return int_lbounds[getVarId(v)].last(); } const LABound& LRAModel::readLBound(const LVRef &v) const { return bs[readLBoundRef(v)]; } LABoundRef LRAModel::readUBoundRef(LVRef v) const { assert(hasUBound(v)); return int_ubounds[getVarId(v)].last(); } const LABound& LRAModel::readUBound(const LVRef &v) const { return bs[readUBoundRef(v)]; } void LRAModel::pushBacktrackPoint() { bound_limits.push(bound_trace.size()); } void LRAModel::popBacktrackPoint() { popBounds(); bound_limits.pop(); }; // Returns the decision if the backtrack point had a decision int LRAModel::getBacktrackSize() const { return bound_limits.size(); } bool LRAModel::isEquality(LVRef v) const { return hasLBound(v) && hasUBound(v) && bs[int_lbounds[getVarId(v)].last()].getIdx().x+1 == bs[int_ubounds[getVarId(v)].last()].getIdx().x && Lb(v) == Ub(v); } bool LRAModel::isUnbounded(LVRef v) const { return bs.isUnbounded(v); } bool LRAModel::boundTriviallySatisfied(LVRef v, LABoundRef b) const { const LABound& bound = bs[b]; assert(bound.getType() == bound_l || bound.getType() == bound_u); const bool is_lower = bound.getType() == bound_l; if ((is_lower && !hasLBound(v)) || (!is_lower && !hasUBound(v))) { return false; } const LABound& toCompare = is_lower ? readLBound(v) : readUBound(v); return ((!is_lower && bound.getIdx().x >= toCompare.getIdx().x) || (is_lower && bound.getIdx().x <= toCompare.getIdx().x)); } bool LRAModel::boundTriviallyUnsatisfied(LVRef v, LABoundRef b) const { const LABound& bound = bs[b]; assert(bound.getType() == bound_l || bound.getType() == bound_u); const bool is_lower = bound.getType() == bound_l; if ((is_lower && !hasUBound(v)) || (!is_lower && !hasLBound(v))) { return false; } const LABound& toCompare = is_lower ? readUBound(v) : readLBound(v); return (is_lower ? bound.getIdx().x > toCompare.getIdx().x : bound.getIdx().x < toCompare.getIdx().x) && bound.getValue() != toCompare.getValue(); }opensmt-2.5.2/src/tsolvers/lasolver/LRAModel.h000066400000000000000000000061061445011647600212670ustar00rootroot00000000000000// // Created by prova on 04.01.18. // #ifndef OPENSMT_LRAMODEL_H #define OPENSMT_LRAMODEL_H #include #include "Delta.h" #include "LABounds.h" #include "Vec.h" #include "LARefs.h" #include "LAVarMapper.h" #include "NatSet.h" // // Class for maintaining the model of a variable // class LRAModel { protected: std::vector > int_lbounds; std::vector > int_ubounds; vec bound_limits; vec bound_trace; std::vector current_assignment; std::vector last_consistent_assignment; nat_set changed_vars_set; vec changed_vars_vec; LABoundStore &bs; int n_vars_with_model; Map has_model; int backtrackLevel(); void popBounds(); public: LRAModel(LABoundStore & bs) : bs(bs), n_vars_with_model(0) { bound_limits.push(0); } void init(); int addVar(LVRef v); // Adds a variable. Returns the total number of variables inline int nVars() { return n_vars_with_model; } void write(const LVRef &v, Delta); inline const Delta& read (const LVRef &v) const { return current_assignment[getVarId(v)]; } private: // needed from Simplex to make all work properly with backtracking and quasi-basic variables friend class Simplex; void restoreVarWithValue(LVRef v, Delta val) { current_assignment[getVarId(v)] = val; last_consistent_assignment[getVarId(v)] = std::move(val); } inline const Delta& readBackupValue (LVRef v) const { return last_consistent_assignment[getVarId(v)]; } public: void pushBound(const LABoundRef br); bool hasLBound(LVRef v) const { return int_lbounds[getVarId(v)].size() != 0; } const LABound& readLBound(const LVRef &v) const; LABoundRef readLBoundRef(LVRef v) const; bool hasUBound(LVRef v) const { return int_ubounds[getVarId(v)].size() != 0; } const LABound& readUBound(const LVRef &v) const; LABoundRef readUBoundRef(LVRef v) const; inline const Delta& Lb(LVRef v) const { return readLBound(v).getValue(); } inline const Delta& Ub(LVRef v) const { return readUBound(v).getValue(); } void pushBacktrackPoint(); void popBacktrackPoint(); int getBacktrackSize() const ; bool isEquality(LVRef v) const; bool isUnbounded(LVRef v) const; bool boundTriviallySatisfied(LVRef v, LABoundRef b) const; bool boundTriviallyUnsatisfied(LVRef v, LABoundRef b) const; void saveAssignment() { for (int i = 0; i < changed_vars_vec.size(); ++i) { LVRef v = changed_vars_vec[i]; last_consistent_assignment[getVarId(v)] = current_assignment[getVarId(v)]; } changed_vars_vec.clear(); changed_vars_set.reset(); } void restoreAssignment() { for (int i = 0; i < changed_vars_vec.size(); ++i) { LVRef v = changed_vars_vec[i]; current_assignment[getVarId(v)] = last_consistent_assignment[getVarId(v)]; } changed_vars_vec.clear(); changed_vars_set.reset(); } void clear(); }; #endif //OPENSMT_LRAMODEL_H opensmt-2.5.2/src/tsolvers/lasolver/Matrix.cc000066400000000000000000000763421445011647600213030ustar00rootroot00000000000000// // Created by prova on 24.08.18. // #include "Matrix.h" #include LAVecRef LAVecStore::getNewVec(std::vector&& ps, const opensmt::Real& den) { LAVecRef vr = lva.alloc(std::move(ps), den); return vr; } char* LAVecStore::print(LAVecRef vr) { char *str; int res = asprintf(&str, "[\n"); assert(res >= 0); (void)res; for (int i = 1; i <= operator[](vr).size(); i++) { char* tmp; std::string s = operator[](vr)[i].get_str(); int res = asprintf(&tmp, "%s%s \n", str, s.c_str()); assert(res >= 0); (void)res; free(str); str = tmp; } char *tmp; res = asprintf(&tmp, "%s]\n", str); assert(res >= 0); (void)res; free(str); str = tmp; return str; } opensmt::Real& LAMatrixStore::MM(MId mid, int row, int col) { LAMatrix& m = operator[](mid); int ncols = m.nCols(); assert(row >= 1 && col >= 1); assert(row <= m.nRows() && col <= ncols); return vs[m.getCoeffs()][ncols*(row-1) + col-1 + 1]; // Vectors are indexed from 1 ... n } MId LAMatrixStore::getNewIdMatrix(int rows, int cols) { int i, max = cols < rows ? rows : cols; MId mid = getNewMatrix(rows, cols); for (i = 1; i <= max; i++) MM(mid, i, i) = 1; return mid; } void LAMatrixStore::setIdMatrix(MId A) { LAMatrix& AM = operator[](A); for (int i = 1; i <= AM.nRows(); i ++) for (int j = 1; j <= AM.nCols(); j++) MM(A, i, j) = (i == j) ? 1 : 0; } void LAMatrixStore::submul_row(MId A, int i, int ipivot, const opensmt::Real& x) { #ifdef ENABLE_MATRIX_TRACE string s = x.get_str(); printf("submul_row i = %d, ipivot = %d, x = %s\n", i, ipivot, s.c_str()); #endif assert(x.isInteger()); assert(i != ipivot); if (A == MId_Undef) return; for (int j = 1; j <= operator[](A).nCols(); j++) { MM(A, i, j) -= x * MM(A, ipivot, j); } } void LAMatrixStore::addmul_column(MId A, int j, int jpivot, const opensmt::Real& x) { #ifdef ENABLE_MATRIX_TRACE string s = x.get_str(); printf("addmul_column j = %d, jpivot = %d, x = %s\n", j, jpivot, s.c_str()); #endif assert(x.isInteger()); assert(j != jpivot); if (A == MId_Undef) return; for (int i = 1; i <= operator[](A).nRows(); i++) MM(A, i, j) += x*MM(A, i, jpivot); } void LAMatrixStore::addmul_row(MId A, int i, int ipivot, const opensmt::Real& x) { std::string s = x.get_str(); #ifdef ENABLE_MATRIX_TRACE printf("addmul_row i = %d, ipivot = %d, x = %s\n", i, ipivot, s.c_str()); #endif assert(x.isInteger()); assert(i != ipivot); if (A == MId_Undef) return; for (int j = 1; j <= operator[](A).nCols(); j++) MM(A, i, j) += x*MM(A, ipivot, j); } void LAMatrixStore::submul_column(MId A, int j, int jpivot, const opensmt::Real& x) { #ifdef ENABLE_MATRIX_TRACE string s = x.get_str(); printf("submul_column j = %d, jpivot = %d, x = %s\n", j, jpivot, s.c_str()); #endif assert(x.isInteger()); assert(j != jpivot); if (A == MId_Undef) return; #ifdef ENABLE_MATRIX_TRACE printf("Before: "); for (int i = 1; i <= operator[](A).nRows(); i++) printf("%s%s", i == 1 ? "" : " ", MM(A, i, j).get_str().c_str()); printf("\n"); #endif for (int i = 1; i <= operator[](A).nRows(); i++) { #ifdef ENABLE_MATRIX_TRACE cout << MM(A, i, j).get_str() << " -= " << x.get_str() << " * " << MM(A, i, jpivot).get_str() << endl; #endif MM(A, i, j) -= x * MM(A, i, jpivot); #ifdef ENABLE_MATRIX_TRACE cout << " => " << MM(A, i, j).get_str() << endl; #endif } #ifdef ENABLE_MATRIX_TRACE printf("After: "); for (int i = 1; i <= operator[](A).nRows(); i++) printf("%s%s", i == 1 ? "" : " ", MM(A, i, j).get_str().c_str()); printf("\n"); #endif } void LAMatrixStore::add_row(MId A, int i, int ipivot) { assert (i != ipivot); #ifdef ENABLE_MATRIX_TRACE printf("add_row %d, %d\n", i, ipivot); #endif if (A == MId_Undef) return; for (int j = 1; j <= operator[](A).nCols(); j++) MM(A, i, j) += MM(A, ipivot, j); } void LAMatrixStore::swap_rows (MId A, int i1, int i2) { #ifdef ENABLE_MATRIX_TRACE printf("swap_rows %d, %d\n", i1, i2); #endif if (A == MId_Undef) return; for (int j = 1; j <= operator[](A).nCols(); j++) std::swap(MM(A, i1, j), MM(A, i2, j)); } void LAMatrixStore::swap_columns(MId A, int j1, int j2) { #ifdef ENABLE_MATRIX_TRACE printf("swap_cols %d, %d\n", j1, j2); #endif if (A == MId_Undef) return; for (int i = 1; i <= operator[](A).nRows(); i++) std::swap(MM(A, i, j1), MM(A, i, j2)); } void LAMatrixStore::neg_column(MId A, int j) { #ifdef ENABLE_MATRIX_TRACE printf("neg_column %d\n", j); #endif if (A == MId_Undef) return; for (int i = 1; i <= operator[](A).nRows(); i++) MM(A, i, j).negate(); } void LAMatrixStore::neg_row(MId A, int i) { #ifdef ENABLE_MATRIX_TRACE printf("neg_row %d\n", i); #endif if (A == MId_Undef) return; for (int j = 1; j <= operator[](A).nCols(); j++) MM(A, i, j).negate(); } void LAMatrixStore::sub_column(MId A, int j, int jpivot) { #ifdef ENABLE_MATRIX_TRACE printf("sub_column %d, %d\n", j, jpivot); #endif assert(j != jpivot); if (A == MId_Undef) return; LAMatrix& Am = operator[](A); for (int i = 1; i <= Am.nRows(); i++) MM(A, i, j) -= MM(A, i, jpivot); } // return the column number j>=jmin of the least absolute coefficient H[i,j]. // return 0 if H[i,j]=0 for any j>=jmin int LAMatrixStore::least_in_row(MId H, int i, int jmin) { int pos = 0; opensmt::Real least; LAMatrix& Hm = operator[](H); assert(jmin <= Hm.nCols()); for (int j = Hm.nCols(); j > jmin; j--) { if (MM(H, i, j) == 0) continue; if (pos != 0) { if (cmpabs(MM(H, i, j), least) <= 0) { pos = j; least = MM(H, i, j); } } else { pos = j; least = MM(H, i, j); } } return pos; } // return the row number imin of the least absolute coefficient in the column H[i,j] // // //i0 ↠{ i ∈ [k, n] : ai, j = min{|ai, j| : i ∈[k, n]}}; // //abs of coeffs // //if col = 1 then we look from 1 onwards, if two from two onwards and so on // //if least coeff 0 then continue to next column int LAMatrixStore::least_in_col(MId H, int imin, int j) { #ifdef ENABLE_MATRIX_TRACE printf("least %d, %d\n", imin, j); #endif int jmin; bool found; opensmt::Real valmin; LAMatrix& Hm = operator[](H); // The position of the minimum element in absolute value // not equal to 0 is denoted by (imin, jmin), and is H[imin, jmin] = valmin //if col = 1 then we look from 1 onwards, if two from two onwards and so on, that is why i = imin found = false; for (int i = imin; i <= Hm.nRows(); i++) { //i = 1 if (MM(H, i, j) == 0) continue; if (!found) { found = true; imin = i; jmin = j; valmin = MM(H, imin, jmin); //#ifdef ENABLE_MATRIX_TRACE // string s = valmin.get_str(); // printf("valmin", s.c_str()); //#endif } else if (cmpabs(valmin, MM(H, i, j)) > 0) { imin = i; jmin = j; valmin = MM(H, imin, jmin); } } return imin; } // Transform the matrix U into a Smith matrix S // and compute four matrices R, Ri, L and Li for which it holds: // - R.Ri = I, Ri.R = I, L.Li = I and Li.L = I where I is the identity matrix // - U = L.S.R // In the following k is the number of rows // and n is the number of columns. // For the moment in our application the rows are the equqlities and columns are variables. // // U is k * n // S is k * n // // Code assumes that // // - The size of L is k*k // - The size of Li is k*k // - The size of R is n*n // - The size of Ri is n*n // - The size of U is k*n // // If R == MId_Undef then it will not be computed // If Ri == MId_Undef then it will not be computed // If L == MId_Undef then it will not be computed // If Li == MId_Undef then it will not be computed // Dim is equal to the rank of the Smith matrix S of U // void LAMatrixStore::compute_snf(MId U, MId &S, int &dim, MId &L, MId &Li, MId &R, MId &Ri) { int imin = 0; int jmin = 0; bool found = false; opensmt::Real x, valmin; auto const& store = *this; (void) store; LAMatrix& Sm = operator[](S); if (R != MId_Undef) { assert(store[R].nCols() == store[R].nRows()); assert(store[R].nRows() == store[U].nCols()); } if (Ri != MId_Undef) { assert(store[Ri].nRows() == store[Ri].nCols()); assert(store[Ri].nRows() == store[R].nCols()); } if (L != MId_Undef) { assert(store[L].nCols() == store[L].nRows()); assert(store[L].nCols() == store[U].nRows()); } if (Li != MId_Undef) { assert(store[Li].nRows() == store[Li].nCols()); assert(store[Li].nRows() == store[L].nRows()); } //std::cout << " Rows U" << Um.nRows() << " Cols U " << Um.nCols() << " Rows S" << Sm.nRows() << " Cols S " << Sm.nCols() << "\n"; if (U != S) setMatrix(S, U); if (R != MId_Undef) setIdMatrix(R); if (Ri != MId_Undef) setIdMatrix(Ri); if (L != MId_Undef) setIdMatrix(L); if (Li != MId_Undef) setIdMatrix(Li); int p; for (p = 1; (p <= Sm.nCols()) && (p <= Sm.nRows()); p++) { // The position of the minimum element in absolute value // not equal to 0 is denoted by (imin, jmin), and is S[imin, jmin] = valmin // imin = 1; // Is this correct? // in = 1; // Ditto? found = false; for (int j = p; j <= Sm.nCols(); j++) { for (int i = p; i <= Sm.nRows(); i++) { if (MM(S, i, j) != 0) { if (!found) { found = true; imin = i; jmin = j; valmin = MM(S, imin, jmin); } else if (cmpabs(valmin, MM(S, i, j)) > 0) { imin = i; jmin = j; valmin = MM(S, imin, jmin); } } } } if (!found) break; while (true) { // Try to put a 0 on column jmin found = false; for (int i = p; (i <= Sm.nRows()) && !found ; i++) { if ((i != imin) && (MM(S, i, jmin) != 0)) { x = fastrat_fdiv_q(MM(S, i, jmin), valmin); // Substract row i from row imin x times submul_row(S, i, imin, x); addmul_column(L, imin, i, x); submul_row(Li, i, imin, x); // Try to find a smaller value for (int j = p; j <= Sm.nCols(); j++) { if (MM(S, i, j) != 0 && cmpabs(valmin, MM(S, i, j)) > 0) { imin = i; jmin = j; valmin = MM(S, imin, jmin); found = true; } } } } if (found) continue; // We try to put 0 on row imin assert(!found); for (int j = p; (j <= Sm.nCols()) && (!found) ; j++) { if ((j != jmin) && (MM(S, imin, j) != 0)) { x = fastrat_fdiv_q(MM(S, imin, j), valmin); // Substract column j from column jmin x times submul_column(S, j, jmin, x); addmul_row(R, jmin, j, x); submul_column (Ri, j, jmin, x); // Try to find a smaller value for (int i = p ; i <= Sm.nRows(); i++) { if (MM(S, i, j) != 0 && (cmpabs(valmin, MM(S, i, j)) > 0)) { imin = i; jmin = j; valmin = MM(S, imin, jmin); found = true; } } } } if (found) continue; // Try to find a value that cannot be divided by valmin assert(!found); for (int j = p; (j <= Sm.nCols()) && !found; j++) { for (int i = p; (i <= Sm.nRows()) && !found; i++) { if ((i != imin) && (j != jmin)) { x = MM(S, i, j) % valmin; if (x != 0) { assert(i != imin); assert(j != jmin); // Add to row i the row imin add_row(S, i, imin); sub_column(L, imin, i); add_row(Li, i, imin); x = fastrat_fdiv_q(MM(S, i, j), valmin); // Subtract from column j the column jmin x times submul_column(S, j, jmin, x); addmul_row(R, jmin, j, x); submul_column(Ri, j, jmin, x); imin = i; jmin = j; valmin = MM(S, imin, jmin); found = true; } } } } if (found) continue; else break; } // Swap rows imin and p if (imin != p) { swap_rows(S, imin, p); swap_columns(L, imin, p); swap_rows(Li, imin, p); imin = p; } // We swap columns jmin and p if (jmin != p) { swap_columns(S, jmin, p); swap_rows(R, jmin, p); swap_columns(Ri, jmin, p); jmin = p; } // Enforce valmin to be positive if (valmin < 0) { valmin.negate(); neg_column(S, p); if (R != MId_Undef) neg_row(R, p); if (Ri != MId_Undef) neg_column(Ri, p); } } dim=p-1; } ///PS: HERE I implement computation of Hermite Normal Form/// // Transform the matrix U into a Hermite matrix H // and compute two matrices R and Ri for which it holds: // - R.Ri = I, Ri.R = I where I is the identity matrix // - U = H.R // H = UA, thus U can be any k*n, A also can be k*n - U and A can have diff numbers of row and columns // In the following k is the number of rows // and n is the number of columns. // For the moment in our application the rows are the inequalities and columns are variables. //Main comment: The size of H must be the same as that of A and U must be square of compatible // dimension (having the same number of rows as A). // // U is k * n (row x column) // A is n * m (row should be equal to U column and column can be any) // H is k * k // If R == MId_Undef then it will not be computed // If Ri == MId_Undef then it will not be computed // Dim is equal to the rank of the Hermite matrix H of U // void LAMatrixStore::compute_hnf_v1(const MId U1, MId &H, int &dim1, MId &R1, MId &Ri1) { int curcol; opensmt::Real pivot, x; LAMatrix& Hm = operator[](H); LAMatrix& U1m = operator[](U1); if (R1 != MId_Undef) { assert(operator[](R1).nRows() == U1m.nRows()); } if (H != U1) setMatrix(H, U1); if (R1 != MId_Undef) setIdMatrix(R1); if (Ri1 != MId_Undef) setIdMatrix(Ri1); curcol=1; for (int p = 1; p <= U1m.nRows(); p++) { int j; while ((j = least_in_row(H, p, curcol)) !=0) //here we wanna say while least in row is not zero do something { if (j != curcol) { swap_columns(H, j, curcol); if (R1 != MId_Undef) swap_rows(R1, j, curcol); if (Ri1 != MId_Undef) swap_columns (Ri1, j, curcol); j = curcol; } pivot = MM(H, p, j); if (pivot < 0) { pivot.negate(); neg_column(H, j); assert(([this, Hm, H, j]()->bool { bool val = true; for (int i = 0; i < Hm.nRows(); i++) { val &= MM(H, i+1, j).isInteger(); } return val; })()); if (R1 != MId_Undef) neg_row(R1, j); if (Ri1 != MId_Undef) neg_column(Ri1, j); } for (int l = j + 1; l <= Hm.nCols(); l++) { if (MM(H, p, l) == 0) continue; x = fastrat_fdiv_q(MM(H, p, l), pivot); assert(x.isInteger()); //We subtract from the column l, x times the column j assert(([this, Hm, H, l]()->bool { bool val = true; for (int i = 0; i < Hm.nRows(); i++) { val &= MM(H, i+1, l).isInteger(); } return val; })()); submul_column(H, l, j, x); assert(([this, Hm, H, l]()->bool { bool val = true; for (int i = 0; i < Hm.nRows(); i++) { val &= MM(H, i+1, l).isInteger(); } return val; })()); //We add to the line l, x times the line j [To check] if (R1 != MId_Undef) addmul_row(R1, j, l, x); if (Ri1 != MId_Undef) submul_column(Ri1, l, j, x); } } pivot = MM(H, p, curcol); if (pivot < 0) { pivot.negate(); neg_column (H, curcol); if (R1 != MId_Undef) neg_row(R1, curcol); if (Ri1 != MId_Undef) neg_column(Ri1, curcol); } if (pivot != 0) { for (int l = 1; l <= curcol-1; l++) { if (MM(H, p, l) == 0) continue; x = fastrat_fdiv_q(MM(H, p, l), pivot); // We subtract from column l, x times the column curcol submul_column(H, l, curcol , x); // We add to line l, x times line curcol to check addmul_row(R1, curcol, l, x); submul_column(Ri1, l, curcol, x); } curcol++; if (curcol > U1m.nCols()) break; } } curcol--; dim1 = curcol; } /// Here is the end of computation of Hermite Normal Form /// ///compute hnf from pdf void LAMatrixStore::compute_hnf(MId &H, const MId A){//, int &dim) {//maybe no need for dim and p LAMatrix &Hm = operator[](H); if (H != A) setMatrix(H, A); int k=1, i0; opensmt::Real b, t, q, f, x, y; //int p; //for (p = 1; (p <= Am.nCols()) && (p <= Am.nRows()); p++) { for (int j = 1; j <= Hm.nCols() && k<=Hm.nRows(); j++) { //k = 1; // Choose Pivot i0 = least_in_col(H, k, j); //i0 should be equal to the number of the row that min val resides printf("leastrowvalue %d\n", i0); if (i0 > k) { //Exchange row Ak with row Ai0; swap_rows(H, k, i0); } if (MM(H, k, j) < 0) { //Ak ↠−Ak; neg_row(H, k); //std::cout << " first for loop finished" << "\n"; } // Reduce Rows //b ↠ak, j; b = MM(H, k,j); //error with k, as MM(mid, row, col) and row maybe 3 but col 4, and in this case k = 4, which breaks assersion std::cout << " b equal to " << b << "\n"; if (b == 0) continue; else { for (int i = k + 1; i <= Hm.nRows(); i++) { //q ↠⌊ai, j / b⌉; //nearest integer or exact div? i checked exact division normal div f = MM(H, i, j) / b; //Note: rounding to nearest integer does not work std::cout << " q1 equal to " << q << "\n"; if(!(f.isInteger())){ //get separate den of f (call it x) and cislitel of f (call it y) x = f.get_den(); y = f.get_num(); for (int l = 1; l <= Hm.nCols(); j++) { MM(H, i, l) = x * MM(H, i, l) - y * MM(H, k, l); } } else { //Ai ↠Ai − q × Ak; //MM(H, i, j) -= q * MM(H, k, j); submul_row(H, i, k, f); } } for (int i = k - 1; i > 0; i--) { // q ↠⌊ai,j/b⌋; q = flooor of the division 1/6 and 5.6 shoud give approx 0, if in neg then -1 t = MM(H, i, j) / b; //correct this with floor q = t.floor(); //Ai ↠Ai − q × Ak; //MM(H, i, j) -= q * MM(H, k, j); submul_row(H, i, k, q); } } k = k + 1; } } ///end of compute hnf from pdf /* void LAMatrixStore::compute_hhnf(MId &H, const MId A){//, int &dim) {//maybe no need for dim and p LAMatrix &Hm = operator[](H); LAMatrix &Am = operator[](A); LAVecRef d = vs.getNewVec(Am.nCols()); if (H != A) setMatrix(H, A); int k=1, i0; opensmt::Real b, t, s, q, f, u, v, d, y; //int p; //for (p = 1; (p <= Am.nCols()) && (p <= Am.nRows()); p++) { for (int j = 1; j <= Hm.nCols() && k<=Hm.nRows(); j++) { if (MM(H, k, j) < 0) { //Ak ↠−Ak; neg_row(H, k); //std::cout << " first for loop finished" << "\n"; } // Reduce Rows //b ↠ak, j; b = MM(H, k,j); //error with k, as MM(mid, row, col) and row maybe 3 but col 4, and in this case k = 4, which breaks assersion std::cout << " b equal to " << b << "\n"; if (b == 0) continue; else { for (int i = k + 1; i <= Hm.nRows(); i++) { if (MM(H,i,j) != 0){ // Euclidean Step //Compute (d, u, v) such that uak,j + vai,j = d = gcd(ak,j , ai,j ); u*MM(H,k,j) + v*MM(H,i,j) = d; d = gcd(MM(H,k,j), MM(H,i,j)); //Ai ↠(ak,j /d)Ai − (ai,j /d)Ak ; t = (MM(H,k,j) / d)*MM(H,i,j); //std::cout << " t equal to " << t << "\n"; s = (MM(H,i,j) / d)*MM(H,k,j); MM(H,i,j) = t - s; //Ak â†B; //B ↠uAk + vAi; //d = u*MM(H,k,j) + v*MM(H,i,j); //vecStore[d][i+1] } } for (int i = k - 1; i > 0; i--) { // q ↠⌊ai,j/b⌋; q = flooor of the division 1/6 and 5.6 shoud give approx 0, if in neg then -1 y = MM(H, i, j) / b; //correct this with floor q = y.floor(); //Ai ↠Ai − q × Ak; //MM(H, i, j) -= q * MM(H, k, j); submul_row(H, i, k, q); } } k = k+1; } } */ ///TEST HNF MINORS //The size of H must be the same as that of A //Computes an integer matrix H such that H is the unique (row) Hermite normal form of A /* void LAMatrixStore::compute_hnf_minors(MId &H, const MId A) { long j, j2, i, k, l, m, n; opensmt::Real u, v, d, r2d, r1d, q, b; LAMatrix& Hm = operator[](H); LAMatrix& Am = operator[](A); m = Am.nRows(); n = Am.nCols(); // put the kth principal minor in HNF for (k = 0, l = m-1; k < n; k++) //k=0 it was, l = m - 1 { for (j = 0; j < k; j++) //j was 0 { gcd(MM(H, j, j), MM(H, k, j)); //check fmpz_xgcd(d, u, v, fmpz_mat_entry(H, j, j), fmpz_mat_entry(H, k, j)); r1d = divexact(MM(H, j, j), d); //fmpz_divexact std::cout << "Result of exact div" << r1d << std::endl; r2d = divexact(MM(H, k, j), d); //fmpz_divexact for (j2 = j; j2 < n; j2++) { b = u * MM(H, j, j2); //fmpz_mul(b, u, MM(H, j, j2)); b += v*MM(H, k, j2); //fmpz_addmul(b, v, MM(H, k, j2)); MM(H, k, j2) = r1d * MM(H, k, j2); //fmpz_mul(MM(H, k, j2), r1d, MM(H, k, j2)); MM(H, k, j2) -= r2d*MM(H, j, j2); //fmpz_submul(MM(H, k, j2), r2d, MM(H, j, j2)); MM(H, j, j2) = b; } } // if H_k,k is zero we swap row k for some other row (starting with the last) if (MM(H, k, k) == 0) //double check fmpz_is_zero { swap_rows(H, k, l); l--; k--; continue; } // ensure H_k,k is positive if (MM(H, k, k) < 0) { for (j = k; j < n; j++) { MM(H, k, j).negate(); } } //reduce above diagonal elements of each row i for (i = k - 1; i >= 0; i--) //i>=0 it was { for (j = i + 1; j <= k; j++) { q = fastrat_fdiv_q(MM(H, i, j), MM(H, j, j)); for (j2 = j; j2 < n; j2++) { MM(H, i, j2) -= q*MM(H, j, j2); //fmpz_submul(MM(H, i, j2), q, MM(H, j, j2)); } } } l = m-1; //l = m-1 } //reduce final rows for (k = n; k < m; k++) { for (j = 1; j < n; j++) //j=0 { gcd(MM(H, j, j), MM(H, k, j)); //check fmpz_xgcd(d, u, v, MM(H, j, j), MM(H, k, j) r1d = divexact(MM(H, j, j), d); //fmpz_divexact r2d = divexact(MM(H, k, j), d); //fmpz_divexact for (j2 = j; j2 < n; j2++) { b = u*MM(H, j, j2); //fmpz_mul(b, u, MM(H, j, j2)); b += v*MM(H, k, j2); //fmpz_addmul(b, v, MM(H, k, j2)); MM(H, k, j2) = r1d * MM(H, k, j2); //fmpz_mul(MM(H, k, j2), r1d, MM(H, k, j2)); MM(H, k, j2) -= r2d*MM(H, j, j2); //fmpz_submul(MM(H, k, j2), r2d, MM(H, j, j2)); MM(H, j, j2) = b; } } //reduce above diagonal elements of each row i for (i = n-1; i >= 0; i--) // j = n - 1, i >= 0 { for (j = i + 1; j < n; j++) { q = fastrat_fdiv_q(MM(H, i, j), MM(H, j, j)); for (j2 = j; j2 < n; j2++) { MM(H, i, j2) -= q*MM(H, j, j2); //fmpz_submul(MM(H, i, j2), q, MM(H, j, j2)); } } } } } */ ///HNF classical /* //col_finished = fmpz_is_zero(MM(H, i, j)); int LAMatrixStore::fz_is_zero(FastRational& n){ assert(n.isInteger()); int col_finished; LAMatrix& HM = operator[](H); for (int i = 1; i <= HM.nRows(); i ++) for (int j = 1; j <= HM.nCols(); j++) if (MM(H, i, j) == 0) { col_finished = 1; } else { col_finished = 0; } } */ /* void LAMatrixStore::hnf_classical(MId H, const MId A) { int i, i0, j, j2, k, l, m, n; opensmt::Real min, q; bool col_finished; LAMatrix& Hm = operator[](H); LAMatrix& Am = operator[](A); m = Am.nRows(); n = Am.nCols(); for (j = 1, k = 1, l = (n - m) * (n > m); n - j != l; j++, k++) //you may want to set to 1 { //int col_finished = 1; col_finished = true; //or false for (i = k + 1; (i <= m) && col_finished; i++) //< //col_finished = fmpz_is_zero(MM(H, i, j)); col_finished = (MM(H, i, j) == 0 ? true : false); //col_finished = fz_is_zero(MM(H, i, j)); if (col_finished) { if (MM(H, k, j) < 0) { for (j2 = j; j2 <= n; j2++) MM(H, k, j2).negate(); } if (MM(H, i, j) == 0)//no need for is zero { k--; if (l > 0) l--; } else { // reduce first entries of column j with row k for (i = 1; i < k; i++) { q = fastrat_fdiv_q(MM(H, i, j), MM(H, k, j)); for (j2 = j; j2 <= n; j2++) { MM(H, i, j2) -= q * MM(H, k, j2); //fmpz_submul } } } } else { i0 = 0; // locate non-zero entry in column j below k with lowest absolute value for (i = k + 1; i <= m; i++) { if (MM(H, i, j) == 0) continue; if ((min == 0) || cmpabs(MM(H, i, j), min) < 0) //fmpz_cmpabs { i0 = i; min = abs(MM(H, i, j));//fmpz_abs } } // move the row found to row k if (i0 > k) swap_rows(H, i0, k); if (MM(H, k, j) < 0) { for (j2 = j; j2 <= n; j2++) { MM(H, k, j2).negate(); } } // reduce lower entries of column j with row k for (i = k + 1; i <= m; i++) { q = fastrat_fdiv_q(MM(H, i, j), MM(H, k, j)); for (j2 = j; j2 < n; j2++) { MM(H, i, j2) -= q * MM(H, k, j2); } } // don't move to the next column yet j--; k--; } } } */ ///END of HNF classical MId LAMatrixStore::getNewMatrix(LAVecRef v) { MId A = getNewMatrix(vs[v].size(), 1); vs[operator[](A).getCoeffs()] = vs[v]; return A; } MId LAMatrixStore::mul_matrix(const MId A, const MId B) { assert(operator[](A).nCols() == operator[](B).nRows()); // MId R = getNewMatrix(operator[](A).nCols(), operator[](B).nRows()); MId R = getNewMatrix(operator[](A).nRows(), operator[](B).nCols()); for (int i = 1; i <= operator[](A).nRows(); i++) { for (int j = 1; j <= operator[](B).nCols(); j++) { MM(R, i, j) = 0; for (int k = 1; k <= operator[](A).nCols(); k++) { MM(R, i, j) += MM(A, i, k) * MM(B, k, j); } } } return R; } LAVecRef LAMatrixStore::mul_vector(MId A, LAVecRef v) { MId vm = getNewMatrix(v); MId res = mul_matrix(A, vm); return operator[](res).getCoeffs(); } LAVecRef LAMatrixStore::discretize(const LAVecRef v) { LAVecRef v_r = vs.getNewVec(vs[v].size()); for (int i = 1; i <= vs[v].size(); i++) vs[v_r][i] = fastrat_round_to_int(vs[v][i]); return v_r; } std::string LAMatrixStore::print(MId A) { int nRows = operator[](A).nRows(); int nCols = operator[](A).nCols(); char* buf = (char*)malloc(1); char* buf_new; buf[0] = '\0'; for (int i = 1; i <= nRows; i++) { char* col_buf = (char*)malloc(1); col_buf[0] = '\0'; for (int j = 1; j <= nCols; j++) { int res = asprintf(&buf_new, "%s%s%s", col_buf, MM(A, i, j).get_str().c_str(), j < nCols ? " " : ""); assert(res >= 0); (void)res; free(col_buf); col_buf = buf_new; } int res = asprintf(&buf_new, "%s%s[%s]%s", buf, i == 1 ? "" : " ", col_buf, i < nRows ? "\n" : ""); assert(res >= 0); (void)res; free(col_buf); free(buf); buf = buf_new; } int res = asprintf(&buf_new, "[%s]", buf); assert(res >= 0); (void)res; free(buf); std::string ret = buf_new; free(buf_new); return ret; } opensmt-2.5.2/src/tsolvers/lasolver/Matrix.h000066400000000000000000000170021445011647600211310ustar00rootroot00000000000000// // Created by prova on 24.08.18. // #ifndef OPENSMT_MATRIX_H #define OPENSMT_MATRIX_H #include #include #include #include "ArithLogic.h" // // Class to store the term of constraints as a column of Simplex method tableau // class LAVec { friend class LAVecAllocator; private: struct { bool reloced : 1; unsigned size : 31; // Vector size } header; opensmt::Real den; opensmt::Real args[0]; // Either the elements or the relocation reference public: LAVec(std::vector&& ps, const opensmt::Real& den) : den(den) { header.size = ps.size(); header.reloced = 0; for (size_t i = 0; i < ps.size(); i++) { new (&args[i]) opensmt::Real(ps[i]); } } int size() const { return header.size; } opensmt::Real& operator[] (int i) { assert(i >= 1); assert(i <= size()); return args[i-1]; } const opensmt::Real& operator[] (int i) const { assert( i >= 1 && i <= size()); return args[i-1]; } void operator= (const LAVec& o) { for (int i = 0; i < size(); i++) args[i] = o.args[i]; } }; struct LAVecRef{ uint32_t x; inline friend bool operator== (const LAVecRef& a1, const LAVecRef& a2) { return a1.x == a2.x; } inline friend bool operator!= (const LAVecRef& a1, const LAVecRef& a2) { return a1.x != a2.x; } inline friend bool operator< (const LAVecRef& a1, const LAVecRef& a2) { return a1.x > a2.x; } }; static struct LAVecRef LAVecRef_Undef = {INT32_MAX}; class LAVecAllocator : public RegionAllocator { unsigned n_vecs; static int lavecWord32Size(int sz) { return (sizeof(LAVec) + (sizeof(opensmt::Real) * sz)) / sizeof(uint32_t); } private: vec lavecs; public: inline void clear() override { lavecs.clear(); RegionAllocator::clear(); } LAVecAllocator(uint32_t start_cap) : RegionAllocator(start_cap), n_vecs(0) {} LAVecAllocator() : n_vecs(0) {} unsigned getNumVecs() const { return n_vecs; }; LAVecRef alloc(std::vector&& ps, const opensmt::Real& den) { uint32_t v = RegionAllocator::alloc(lavecWord32Size(ps.size())); LAVecRef vid = {v}; new (lea(vid)) LAVec(std::move(ps), den); n_vecs++; return vid; } LAVec& operator[](LAVecRef r) { return (LAVec&)RegionAllocator::operator[](r.x); } const LAVec& operator[](LAVecRef r) const { return (LAVec&)RegionAllocator::operator[](r.x); } // Deref, Load Effective Address (LEA), Inverse of LEA (AEL): LAVec* lea (LAVecRef r) { return (LAVec*)RegionAllocator::lea(r.x); } const LAVec* lea (LAVecRef r) const { return (LAVec*)RegionAllocator::lea(r.x); } LAVecRef ael (const LAVec* t) { RegionAllocator::Ref r = RegionAllocator::ael((uint32_t*)t); LAVecRef rf; rf.x = r; return rf; } void free (LAVecRef) {} // Debug stuff char* printVec (LAVecRef r) const; }; class LAVecStore { private: vec lavecs; LAVecAllocator& lva; public: LAVecStore(LAVecAllocator& lva) : lva(lva) {} inline void clear() { lavecs.clear(); }; LAVecRef getNewVec(std::vector&& ps, const opensmt::Real& den); LAVecRef getNewVec(std::vector&& ps) { return getNewVec(std::move(ps), 1); } LAVecRef getNewVec(int size) { std::vector tmp; tmp.resize(size); return getNewVec(std::move(tmp)); } int numVecs() const ; void remove(const LAVecRef r); LAVec& operator [] (LAVecRef vr) { return lva[vr]; } char* print(LAVecRef vr); }; class LAMatrix { private: LAVecRef coeffs; int cols; int rows; public: LAMatrix() : coeffs(LAVecRef_Undef), cols(0), rows(0) {} LAMatrix(LAVecRef coeffs, int rows, int cols) : coeffs(coeffs), cols(cols), rows(rows) {} int nRows() const { return rows; } int nCols() const { return cols; } LAVecRef getCoeffs() const { return coeffs; } }; struct MId { uint32_t x; bool operator== (const MId& o) { return x == o.x; } bool operator!= (const MId& o) { return x != o.x; } }; const MId MId_Undef { UINT32_MAX }; class LAMatrixStore { private: LAVecStore& vs; vec matrices; public: // Access the element of matrix id at column col, row row. opensmt::Real& MM(MId id, int row, int col); LAMatrixStore(LAVecStore& vs) : vs(vs) {} void clear() { matrices.clear(); } // Return an n x m matrix full of 0s MId getNewMatrix(int rows, int cols) { matrices.push(LAMatrix(vs.getNewVec(rows*cols), rows, cols)); return MId{matrices.size_()-1}; } MId getNewMatrix(LAVecRef v); // Initialize a (n x 1) matrix from the contents of size n vector v LAMatrix& operator[] (MId i) { return matrices[i.x]; } const LAMatrix& operator[] (MId i) const { return matrices[i.x]; } // Set Matrix t to contain values that are equal to those of s. t and s need to agree on dimensions. void setMatrix(MId t, MId s) { assert(operator[](t).nRows() == operator[](s).nRows()); assert(operator[](t).nCols() == operator[](s).nCols()); vs[operator[](t).getCoeffs()] = vs[operator[](s).getCoeffs()]; } // Return an m x n identity matrix MId getNewIdMatrix(int rows, int cols); void setIdMatrix (MId A); // Multiply row ipivot by x and substract it from from i void submul_row (MId A, int i, int ipivot, const opensmt::Real& x); // Multiply column jpivot by x and add it to column j void addmul_column(MId A, int j, int jpivot, const opensmt::Real& x); // multiply row ipivot by x and add it to row i void addmul_row (MId A, int i, int ipivot, const opensmt::Real& x); // Multiply column jpivot byx and substract it from column j void submul_column(MId A, int j, int jpivot, const opensmt::Real& x); // Add row ipivot to row i void add_row (MId A, int i, int ipivot); // Substract column jpivot from column j void sub_column (MId A, int j, int jpivot); // Swap rows i1 and i2 void swap_rows (MId A, int i1, int i2); // Swap columns j1 and j2 void swap_columns (MId A, int j1, int j2); // Negate the column j void neg_column (MId A, int j); // Negate the row i void neg_row (MId A, int i); // Transform A into a Smith matrix S such that A = X*S*U and U*V=I and X*Y=I void compute_snf (MId A, MId &S, int &dim, MId &X, MId &Y, MId &U, MId &V); // Transform A into a Hermite matrix H such that A = H*U and U*V=I void compute_hnf_v1(const MId A1, MId &H, int &dim1, MId &U1, MId &V1); //void compute_hnf_minors(MId &H, const MId A); //void hnf_transform(MId &H, MId &U, const MId A); //void hnf(MId &H, const MId A); //void hnf_classical(MId H, const MId A); //int fz_is_zero(MId H); int least_in_row (MId H, int i, int jmin); void compute_hnf (MId &H, const MId A1); void compute_hhnf (MId &H, const MId A1); int least_in_col(MId H, int imin, int j); // Determine whether the linear integer equality defined by facs and c has a solution. // Return true and the solution in sol if yes, otherwise return false. //bool solve_diophantine(LAVecRef facs, opensmt::Real c, LAVecRef sol); LAVecRef mul_vector (MId A, LAVecRef v); MId mul_matrix (MId A, MId B); LAVecRef discretize (LAVecRef v); // compute [v], i.e., round up or down to closest integer std::string print(MId A); }; #endif //OPENSMT_MATRIX_H opensmt-2.5.2/src/tsolvers/lasolver/Polynomial.h000066400000000000000000000174631445011647600220230ustar00rootroot00000000000000/* * Copyright (c) 2018-2022, Martin Blicha * Copyright (c) 2022, Antti Hyvarinen * * SPDX-License-Identifier: MIT */ #ifndef OPENSMT_POLYNOMIAL_H #define OPENSMT_POLYNOMIAL_H #include "Real.h" #include #include #include #include template class PolynomialT { private: struct Term { VarType var; opensmt::Real coeff; Term(VarType var, opensmt::Real&& coeff): var{var.x}, coeff{std::move(coeff)} {} }; struct TermCmp { bool operator()(const Term& first, const Term& second) { return first.var.x < second.var.x; } }; public: using poly_t = std::vector; // Terms are ordered by variable num private: poly_t poly; using mergeFunctionInformerType = void(*)(VarType); public: void addTerm(VarType var, opensmt::Real coeff); std::size_t size() const; const opensmt::Real & getCoeff(VarType var) const; opensmt::Real removeVar(VarType var); void negate(); void divideBy(const opensmt::Real& r); template void merge( PolynomialT const & other, opensmt::Real const & coeff, poly_t & tmp_storage, ADD informAdded = [](VarType){}, REM informRemoved = [](VarType){} ); /* Simple version of merge that does not use the hooks and does not need external temporary storage */ void merge(PolynomialT const & other, opensmt::Real const & coeff) { poly_t tmp_storage; return merge(other, coeff, tmp_storage); } using iterator = typename poly_t::iterator; using const_iterator = typename poly_t::const_iterator; iterator begin(){ return poly.begin(); } iterator end() { return poly.end(); } const_iterator begin() const { return poly.cbegin(); } const_iterator end() const{ return poly.cend(); } // debug bool contains(VarType var) const { return findTermForVar(var) != poly.end(); } const_iterator findTermForVar(VarType var) const { return std::find_if(poly.begin(), poly.end(), [var](const Term& term) { return term.var == var; }); } iterator findTermForVar(VarType var) { return std::find_if(poly.begin(), poly.end(), [var](const Term& term) { return term.var == var; }); } void print() const; }; template template void PolynomialT::merge(PolynomialT const & other, opensmt::Real const & coeff, poly_t & tmp_storage, ADD informAdded, REM informRemoved) { if (tmp_storage.size() < this->poly.size() + other.poly.size()) { tmp_storage.resize(this->poly.size() + other.poly.size(), Term(VarType::Undef, 0)); } std::size_t storageIndex = 0; auto myIt = std::make_move_iterator(poly.begin()); auto otherIt = other.poly.cbegin(); auto myEnd = std::make_move_iterator(poly.end()); auto otherEnd = other.poly.cend(); TermCmp cmp; FastRational tmp; while(true) { if (myIt == myEnd) { for (auto it = otherIt; it != otherEnd; ++it) { tmp_storage[storageIndex].var = it->var; multiplication(tmp_storage[storageIndex].coeff, it->coeff, coeff); ++storageIndex; informAdded(it->var); } break; } if (otherIt == otherEnd) { std::move(myIt, myEnd, tmp_storage.begin() + storageIndex); storageIndex += myEnd - myIt; break; } if (cmp(*myIt, *otherIt)) { tmp_storage[storageIndex] = *myIt; ++storageIndex; ++myIt; } else if (cmp(*otherIt, *myIt)) { tmp_storage[storageIndex].var = otherIt->var; multiplication(tmp_storage[storageIndex].coeff, otherIt->coeff, coeff); ++storageIndex; informAdded(otherIt->var); ++otherIt; } else { assert(myIt->var == otherIt->var); multiplication(tmp, otherIt->coeff, coeff); myIt->coeff += tmp; if (myIt->coeff.isZero()) { informRemoved(myIt->var); } else { tmp_storage[storageIndex] = *myIt; ++storageIndex; } ++myIt; ++otherIt; } } // At this point the right elements are in `tmp_storage`, from beginning to the `storageIndex`. // We need to get these elements to `this->poly`. Note that we never change the `tmp_storage` container, we just move out // the appropriate elements. // However, we observed that we need to shrink `poly` if its size is much smaller than the capacity. // The reason is that keeping large free capacity around for many rows blows up the memory // (worse case quadratic in the size of the tableau). auto polySize = poly.size(); if (storageIndex > polySize) { // In this case we have more elements to move than the current size of the `poly` container. // We move the elements that fit the current `poly` size and then we insert the rest of the elements. std::move(tmp_storage.begin(), tmp_storage.begin() + polySize, poly.begin()); poly.insert(poly.end(), std::make_move_iterator(tmp_storage.begin() + polySize), std::make_move_iterator(tmp_storage.begin() + storageIndex)); } else if (/*storageIndex <= poly.size() and */ polySize <= 2 * storageIndex) { // In this case we have less elements that need to move than what we currently already have in `poly`, but not too litle. // We just move the appropriate elements and destroy the excess elements of `poly`. // Since we are removing too many elements, we avoid shrinking which would require re-allocation. std::move(tmp_storage.begin(), tmp_storage.begin() + storageIndex, poly.begin()); poly.erase(poly.begin() + storageIndex, poly.end()); } else { // poly.size() > 2 * storageIndex // This case is similar to case 2, but we have much less elements in the result than currently in `poly`. // To avoid too large free capacity in `poly`, we shrink its capacity to exactly the number of elements. // It is basically `poly.shrink_to_fit()`, except that `shrink_to_fit` is non-binding. std::vector(std::make_move_iterator(tmp_storage.begin()), std::make_move_iterator(tmp_storage.begin() + storageIndex)).swap(poly); } } template void PolynomialT::addTerm(VarType var, opensmt::Real coeff) { assert(!contains(var)); Term term {var, std::move(coeff)}; auto it = std::upper_bound(poly.begin(), poly.end(), term, TermCmp{}); poly.insert(it, std::move(term)); } template unsigned long PolynomialT::size() const { return poly.size(); } template const FastRational &PolynomialT::getCoeff(VarType var) const { assert(contains(var)); return findTermForVar(var)->coeff; } template opensmt::Real PolynomialT::removeVar(VarType var) { assert(contains(var)); iterator it = findTermForVar(var); auto coeff = std::move(it->coeff); poly.erase(it); return coeff; } template void PolynomialT::negate() { for(auto & term : poly) { term.coeff.negate(); } } template void PolynomialT::divideBy(const opensmt::Real &r) { for(auto & term : poly) { term.coeff /= r; } } template void PolynomialT::print() const { for (auto & term : poly) { std::cout << term.coeff << " * " << term.var.x << "v + "; } std::cout << std::endl; } #endif //OPENSMT_POLYNOMIAL_H opensmt-2.5.2/src/tsolvers/lasolver/Simplex.cc000066400000000000000000000431431445011647600214510ustar00rootroot00000000000000// // Created by prova on 06.09.19. // #include "Simplex.h" #include "OsmtInternalException.h" #include #include #ifdef SIMPLEX_DEBUG #define simplex_assert(x) assert(x) #else #define simplex_assert(x) #endif // SIMPLEX_DEBUG // MB: helper functions namespace{ bool isBoundSatisfied(Delta const & val, LABound const & bound ) { if (bound.getType() == bound_u){ return val <= bound.getValue(); } else { assert(bound.getType() == bound_l); return val >= bound.getValue(); } } } Simplex::Explanation Simplex::checkSimplex() { processBufferOfActivatedBounds(); bool bland_rule = false; unsigned repeats = 0; // keep doing pivotAndUpdate until the SAT/UNSAT status is confirmed while (true) { repeats++; LVRef x = LVRef::Undef; if (!bland_rule && (repeats > tableau.getNumOfCols())) bland_rule = true; if (bland_rule) { x = getBasicVarToFixByBland(); ++simplex_stats.num_bland_ops; } else { x = getBasicVarToFixByShortestPoly(); ++simplex_stats.num_pivot_ops; } if (x == LVRef::Undef) { // SAT refineBounds(); model->saveAssignment(); return Explanation(); } LVRef y_found = LVRef::Undef; if (bland_rule){ y_found = findNonBasicForPivotByBland(x); } else{ y_found = findNonBasicForPivotByHeuristic(x); } // if it was not found - UNSAT if (y_found == LVRef::Undef) { assert(isModelOutOfBounds(x)); bool isOutOfLowerBound = isModelOutOfLowerBound(x); model->restoreAssignment(); return getConflictingBounds(x, isOutOfLowerBound); } // if it was found - pivot old Basic x with non-basic y and do the model updates else { pivot(x, y_found); } } } const Delta Simplex::overBound(LVRef v) const { assert(isModelOutOfBounds(v)); if (isModelOutOfUpperBound(v)) { return (Delta(model->read(v) - model->Ub(v))); } else if (isModelOutOfLowerBound(v)) { return (Delta(model->Lb(v) - model->read(v))); } assert (false); printf("Problem in overBound, LRASolver.C:%d\n", __LINE__); exit(1); } bool Simplex::isUnbounded(LVRef v) const { return model->isUnbounded(v); } LVRef Simplex::getBasicVarToFixByShortestPoly() const { assert(std::all_of(candidates.begin(), candidates.end(), [&](LVRef var) { return var != LVRef::Undef && tableau.isBasic(var) && isModelOutOfBounds(var); })); // MB: replace this with std::min_element when ranges are available (to avoid duplicate calls to getPolySize) LVRef current = LVRef::Undef; std::size_t current_poly_size = std::numeric_limits::max(); for (auto it : candidates) { // Select the var with smallest row bool const doUpdate = tableau.getPolySize(it) < current_poly_size; if (doUpdate) { current = it; current_poly_size = tableau.getPolySize(it); } } return current; } LVRef Simplex::getBasicVarToFixByBland() const { assert(std::all_of(candidates.begin(), candidates.end(), [&](LVRef var) { return var != LVRef::Undef && tableau.isBasic(var) && isModelOutOfBounds(var); })); // MB: replace this with std::min_element when ranges are available (to avoid duplicate calls to getVarId) auto curr_var_id_x = std::numeric_limits::max(); LVRef current = LVRef::Undef; for (auto it : candidates) { // Select the var with the smallest id auto const id = getVarId(it); bool const doUpdate = id < curr_var_id_x; if (doUpdate) { current = it; curr_var_id_x = id; } } return current; } LVRef Simplex::findNonBasicForPivotByHeuristic(LVRef basicVar) { // favor more independent variables: those present in less rows assert(tableau.isBasic(basicVar)); LVRef v_found = LVRef::Undef; if (isModelOutOfLowerBound(basicVar)) { for (auto const &term : tableau.getRowPoly(basicVar)) { auto var = term.var; assert(tableau.isNonBasic(var)); assert(var != basicVar); auto const &coeff = term.coeff; const bool is_coeff_pos = isPositive(coeff); if ((is_coeff_pos && isModelStrictlyUnderUpperBound(var)) || (!is_coeff_pos && isModelStrictlyOverLowerBound(var))) { if (v_found == LVRef::Undef) { v_found = var; } // heuristic favoring more independent vars else if (tableau.getColumn(v_found).size() > tableau.getColumn(var).size()) { v_found = var; } } } } else if (isModelOutOfUpperBound(basicVar)) { for (auto const &term : tableau.getRowPoly(basicVar)) { auto var = term.var; assert(tableau.isNonBasic(var)); assert(var != basicVar); auto const &coeff = term.coeff; const bool is_coeff_pos = isPositive(coeff); if ((!is_coeff_pos && isModelStrictlyUnderUpperBound(var)) || (is_coeff_pos && isModelStrictlyOverLowerBound(var))) { if (v_found == LVRef::Undef) { v_found = var; } // heuristic favoring more independent vars else if (tableau.getColumn(v_found).size() > tableau.getColumn(var).size()) { v_found = var; } } } } else { assert(false); throw OsmtInternalException("Examined basic var is not out of bounds, but it should be!"); } return v_found; } LVRef Simplex::findNonBasicForPivotByBland(LVRef basicVar) { auto max_var_id = std::numeric_limits::max(); LVRef y_found = LVRef::Undef; // Model doesn't fit the lower bound if (isModelOutOfLowerBound(basicVar)) { // For the Bland rule auto curr_var_id_y = max_var_id; // look for nonbasic terms to fix the breaking of the bound for (auto const & term : tableau.getRowPoly(basicVar)) { auto y = term.var; assert(basicVar != y); assert(tableau.isNonBasic(y)); auto const &coeff = term.coeff; const bool coeff_is_pos = isPositive(coeff); if ((coeff_is_pos && isModelStrictlyUnderUpperBound(y)) || (!coeff_is_pos && isModelStrictlyOverLowerBound(y))) { // Choose the leftmost nonbasic variable with a negative (reduced) cost y_found = getVarId(y) < curr_var_id_y ? y : y_found; curr_var_id_y = getVarId(y) < curr_var_id_y ? getVarId(y) : curr_var_id_y; } } } else if (isModelOutOfUpperBound(basicVar)) { auto curr_var_id_y = max_var_id; // look for nonbasic terms to fix the unbounding for (auto const & term : tableau.getRowPoly(basicVar)) { auto y = term.var; assert(basicVar != y); assert(tableau.isNonBasic(y)); auto const &coeff = term.coeff; const bool coeff_is_pos = isPositive(coeff); if ((!coeff_is_pos && isModelStrictlyUnderUpperBound(y)) || (coeff_is_pos && isModelStrictlyOverLowerBound(y))) { // Choose the leftmost nonbasic variable with a negative (reduced) cost y_found = getVarId(y) < curr_var_id_y ? y : y_found; curr_var_id_y = getVarId(y) < curr_var_id_y ? getVarId(y) : curr_var_id_y; } } } else { assert(false); throw OsmtInternalException("Examined basic var is not out of bounds, but it should be!"); } return y_found; } Simplex::Explanation Simplex::assertBoundOnVar(LVRef it, LABoundRef itBound_ref) { assert(!model->isUnbounded(it)); assert(boundStore[itBound_ref].getLVRef() == it); // Check if simple UNSAT can be given. The last check checks that this is not actually about asserting equality. if (model->boundTriviallyUnsatisfied(it, itBound_ref)) { const LABound & itBound = boundStore[itBound_ref]; assert(itBound.getType() == bound_u || itBound.getType() == bound_l); LABoundRef br = itBound.getType() == bound_u ? model->readLBoundRef(it) : model->readUBoundRef(it); return {{br, 1}, {itBound_ref, 1}}; } // Here we count the bound as activated boundActivated(it); // Check if simple SAT can be given if (model->boundTriviallySatisfied(it, itBound_ref)) { return {}; } model->pushBound(itBound_ref); bufferOfActivatedBounds.emplace_back(it, itBound_ref); return {}; } void Simplex::newCandidate(LVRef candidateVar) { assert(tableau.isBasic(candidateVar)); candidates.insert(candidateVar); } void Simplex::eraseCandidate(LVRef candidateVar) { candidates.erase(candidateVar); } void Simplex::pivot(const LVRef bv, const LVRef nv){ assert(tableau.isBasic(bv)); assert(tableau.isNonBasic(nv)); simplex_assert(valueConsistent(bv)); // tableau.print(); updateValues(bv, nv); tableau.pivot(bv, nv); // after pivot, bv is not longer a candidate eraseCandidate(bv); // and nv can be a candidate if (getNumOfBoundsActive(nv) == 0) { tableau.basicToQuasi(nv); } else { if (isModelOutOfBounds(nv)) { newCandidate(nv); } } // tableau.print(); simplex_assert(checkTableauConsistency()); simplex_assert(checkValueConsistency()); } void Simplex::changeValueBy(LVRef var, const Delta & diff) { // update var's value model->write(var, model->read(var) + diff); // update all (active) rows where var is present for ( LVRef row : tableau.getColumn(var)){ assert(!tableau.isNonBasic(row)); if (tableau.isBasic(row)) { // skip quasi-basic variables model->write(row, model->read(row) + (tableau.getCoeff(row, var) * diff)); if (isModelOutOfBounds(row)) { newCandidate(row); } else { eraseCandidate(row); } } } } void Simplex::updateValues(const LVRef bv, const LVRef nv){ assert(isModelOutOfBounds(bv)); auto const & bvNewVal = (isModelOutOfLowerBound(bv)) ? model->Lb(bv) : model->Ub(bv); const auto & coeff = tableau.getCoeff(bv, nv); // nvDiff represents how much we need to change nv, so that bv gets to the right value auto nvDiff = (bvNewVal - model->read(bv)) / coeff; // update nv's value changeValueBy(nv, nvDiff); } // // Returns the bounds conflicting with the actual model. // Simplex::Explanation Simplex::getConflictingBounds(LVRef x, bool conflictOnLower) { LABoundRef br_f = conflictOnLower ? model->readLBoundRef(x) : model->readUBoundRef(x); auto const & row = tableau.getRowPoly(x); Explanation expl; expl.reserve(row.size() + 1); expl.push_back({br_f,1}); // add all bounds for polynomial elements which limit the given bound for (auto const & term : row) { Real const & coeff = term.coeff; auto const var = term.var; assert(!coeff.isZero() && var != x); if (isNegative(coeff)) { LABoundRef br = conflictOnLower ? model->readLBoundRef(var) : model->readUBoundRef(var); expl.push_back({br, -coeff}); } else { LABoundRef br = conflictOnLower ? model->readUBoundRef(var) : model->readLBoundRef(var); expl.push_back({br, coeff}); } } return expl; } bool Simplex::checkValueConsistency() const { bool res = true; auto const & rows = tableau.getRows(); for (unsigned i = 0; i < rows.size(); ++i) { if (!rows[i]) { continue; } LVRef var {i}; assert(!tableau.isNonBasic(var)); if (tableau.isBasic(var)) { res &= valueConsistent(var); } } assert(res); return res; } bool Simplex::valueConsistent(LVRef v) const { const Delta& value = model->read(v); Delta sum(0); for (auto & term : tableau.getRowPoly(v)){ sum += term.coeff * model->read(term.var); } assert(value == sum); return value == sum; } bool Simplex::invariantHolds() const { bool rval = true; auto vars = tableau.getNonBasicVars(); for (auto var : vars){ if (isModelOutOfBounds(var)) { rval = false; if (isModelOutOfUpperBound(var)) { printf("Non-basic (column) LRA var %s has value %s > %s (upper bound)\n", printVar(var), model->read(var).printValue(), model->Ub(var).printValue()); } if (isModelOutOfLowerBound(var)) { printf("Non-basic (column) LRA var %s has value %s < %s (lower bound)\n", printVar(var), model->read(var).printValue(), model->Lb(var).printValue()); } assert(false); } } return rval; } bool Simplex::checkTableauConsistency() const { bool res = tableau.checkConsistency(); assert(res); return res; } bool Simplex::isProcessedByTableau(LVRef var) const { return tableau.isProcessed(var); } const LABoundRef Simplex::getBound(LVRef v, int idx) const { return boundStore.getBoundByIdx(v, idx); } Delta Simplex::getValuation(LVRef v) const { if (tableau.isQuasiBasic(v)) { (const_cast(this))->quasiToBasic(v); } Delta val = model->read(v); return val; } opensmt::Real Simplex::computeDelta() const { /* Delta computation according to the Technical Report accompanying the Simple paper https://yices.csl.sri.com/papers/sri-csl-06-01.pdf For a pair (c,k) \in Q_\delta representing Real value c + k * \delta if the inequality (c_1, k_1) <= (c_2, k_2) holds then there exists \delta_0 such that \forall 0 < \epsilon < \delta_0 the inequality c_1 + k_1 * \epsilon <= c_2 + k_2 * \epsilon holds. \delta_0 can be defined as (c_2 - c_1) / (k_1 - k_2) if c_1 < c_2 and k_1 > k_2 ( and \delta_0 = 1 otherwise) Extending to a set of inequilities, we can take minimum of deltas needed to satisfy every inequality separately In our case, for each variable we need to consider both lower and upper bound (if they exist) */ Delta delta_abst; bool deltaNotSet = true; const LAVarStore& laVarStore = boundStore.getVarStore(); for (LVRef v : laVarStore) { assert( !isModelOutOfBounds(v) ); if (model->read(v).D() == 0) continue; // If values are exact we do not need to consider them for delta computation auto const & val = model->read(v); // Computing delta to satisfy lower bound if (model->hasLBound(v)) { auto const & lb = model->Lb(v); assert(lb.R() <= val.R()); if (lb.R() < val.R() && lb.D() > val.D()) { Real valOfDelta = (val.R() - lb.R()) / (lb.D() - val.D()); assert(valOfDelta > 0); if (deltaNotSet || delta_abst > valOfDelta) { deltaNotSet = false; delta_abst = valOfDelta; } } } // Computing delta to satisfy upper bound if (model->hasUBound(v)) { auto const & ub = model->Ub(v); assert(ub.R() >= val.R()); if (val.R() < ub.R() && val.D() > ub.D()) { Real valOfDelta = (ub.R() - val.R()) / (val.D() - ub.D()); assert(valOfDelta > 0); if (deltaNotSet || delta_abst > valOfDelta) { deltaNotSet = false; delta_abst = valOfDelta; } } } } if (deltaNotSet || delta_abst > 1) { return 1; } return delta_abst.R()/2; } void Simplex::quasiToBasic(LVRef it) { tableau.quasiToBasic(it); // Recompute the value of the row variable // Literals are asserted in groups, so the current assignment might already be different then the last consistent one // Fix the last consistent value for this var, then fix the current value of the var Delta val; // initialized to 0 assert(model->changed_vars_vec.size() == 0); for (auto const & term : tableau.getRowPoly(it)) { assert(model->read(term.var) == model->readBackupValue(term.var)); val += term.coeff * model->read(term.var); } model->restoreVarWithValue(it, std::move(val)); } Simplex::~Simplex() { #ifdef STATISTICS simplex_stats.printStatistics(cerr); #endif // STATISTICS } void Simplex::processBufferOfActivatedBounds() { while (!bufferOfActivatedBounds.empty()) { LVRef var = bufferOfActivatedBounds.back().first; LABoundRef boundRef = bufferOfActivatedBounds.back().second; bufferOfActivatedBounds.pop_back(); assert(!tableau.isQuasiBasic(var)); // Update the Tableau data if a non-basic variable if (tableau.isNonBasic(var)) { auto const & bound = boundStore[boundRef]; if (!isBoundSatisfied(model->read(var), bound)) { changeValueBy(var, bound.getValue() - model->read(var)); } } else // basic variable got a new bound, it becomes a possible candidate { assert(tableau.isBasic(var)); if (isModelOutOfBounds(var)) { newCandidate(var); } else { // MB: Experience shows this should really not happen assert(candidates.find(var) == candidates.end()); } } } } opensmt-2.5.2/src/tsolvers/lasolver/Simplex.h000066400000000000000000000171051445011647600213120ustar00rootroot00000000000000// // Created by prova on 06.09.19. // #ifndef OPENSMT_SIMPLEX_H #define OPENSMT_SIMPLEX_H #include "lasolver/LABounds.h" #include "lasolver/Tableau.h" #include "lasolver/LAVar.h" #include "LRAModel.h" #include "SMTConfig.h" class SimplexStats { public: int num_bland_ops; int num_pivot_ops; SimplexStats() : num_bland_ops(0), num_pivot_ops(0) {} void printStatistics(std::ostream& os) { os << "; -------------------------" << '\n'; os << "; STATISTICS FOR SIMPLEX " << '\n'; os << "; -------------------------" << '\n'; os << "; Pivot operations.........: " << num_pivot_ops << '\n'; os << "; Bland operations.........: " << num_bland_ops << '\n'; } }; class Simplex { std::unique_ptr model; LABoundStore& boundStore; Tableau tableau; SimplexStats simplex_stats; void pivot(LVRef basic, LVRef nonBasic); LVRef getBasicVarToFixByBland() const; LVRef getBasicVarToFixByShortestPoly() const; LVRef findNonBasicForPivotByBland(LVRef basicVar); LVRef findNonBasicForPivotByHeuristic(LVRef basicVar); void updateValues(LVRef basicVar, LVRef nonBasicVar); inline void newCandidate(LVRef candidateVar); inline void eraseCandidate(LVRef candidateVar); void changeValueBy( LVRef, const Delta & ); // Updates the bounds after constraint pushing void refineBounds() { return; } // Compute the bounds for touched polynomials and deduces new bounds from it // Out of bound candidates // mutable std::unordered_set candidates; mutable std::set candidates; // bool isEquality(LVRef) const; const Delta overBound(LVRef) const; // Model & bounds const LABoundRef getBound(LVRef v, int idx) const ;//{ return boundStore.getBoundByIdx(v, idx); } bool isUnbounded (LVRef v) const; bool valueConsistent(LVRef v) const; // Debug: Checks that the value of v in the model is consistent with the evaluated value of the polynomial of v in the same model. bool checkTableauConsistency() const; public: struct ExplTerm { LABoundRef boundref; opensmt::Real coeff; }; using Explanation = std::vector; Simplex(std::unique_ptr model, LABoundStore &bs) : model(std::move(model)), boundStore(bs) {} Simplex(LABoundStore&bs) : model(new LRAModel(bs)), boundStore(bs) {} ~Simplex(); void initModel() { model->init(); } void clear() { model->clear(); candidates.clear(); tableau.clear(); boundsActivated.clear(); } Explanation checkSimplex(); void pushBacktrackPoint() { model->pushBacktrackPoint(); } void popBacktrackPoint() { model->popBacktrackPoint(); } inline void finalizeBacktracking() { assert(model->changed_vars_vec.size() == 0); candidates.clear(); bufferOfActivatedBounds.clear(); assert(checkValueConsistency()); assert(invariantHolds()); } void quasiToBasic(LVRef it); Explanation assertBoundOnVar(LVRef it, LABoundRef itBound_ref); bool isProcessedByTableau (LVRef var) const; inline bool isModelOutOfBounds (LVRef v) const { return isModelOutOfUpperBound(v) || isModelOutOfLowerBound(v); } inline bool isModelOutOfUpperBound(LVRef v) const { return ( model->hasUBound(v) && model->read(v) > model->Ub(v) ); } inline bool isModelOutOfLowerBound(LVRef v) const { return ( model->hasLBound(v) && model->read(v) < model->Lb(v) ); } // No upper bound count as +infinity inline bool isModelStrictlyUnderUpperBound(LVRef v) const { return ( !model->hasUBound(v) || model->read(v) < model->Ub(v) ); } // No lower bound count as -infinity inline bool isModelStrictlyOverLowerBound(LVRef v) const { return ( !model->hasLBound(v) || model->read(v) > model->Lb(v) ); } void newNonbasicVar(LVRef v) { newVar(v); tableau.newNonbasicVar(v); } void nonbasicVar(LVRef v) { newVar(v); tableau.nonbasicVar(v); } void newRow(LVRef x, std::unique_ptr poly) { newVar(x); tableau.newRow(x, std::move(poly)); } Explanation getConflictingBounds(LVRef x, bool conflictOnLower); bool checkValueConsistency() const; bool invariantHolds() const; opensmt::Real computeDelta() const; Delta getValuation(LVRef) const; // Understands also variables deleted by gaussian elimination // Delta read(LVRef v) const { assert(!tableau.isQuasiBasic(v)); return model->read(v); } // ignores unsafely variables deleted by gaussian elimination const LABoundRef readLBoundRef(const LVRef &v) const { return model->readLBoundRef(v); } const LABoundRef readUBoundRef(const LVRef &v) const { return model->readUBoundRef(v); } const Delta& Lb(LVRef v) const { return model->Lb(v); } const Delta& Ub(LVRef v) const { return model->Ub(v); } bool hasLBound(LVRef v) const {return model->hasLBound(v); } bool hasUBound(LVRef v) const {return model->hasUBound(v); } // Keeping track of activated bounds private: std::vector> bufferOfActivatedBounds; std::vector boundsActivated; unsigned int getNumOfBoundsActive(LVRef var) const { assert(getVarId(var) < boundsActivated.size()); return boundsActivated[getVarId(var)]; } void newVar(LVRef v) { while (getVarId(v) >= boundsActivated.size()) { boundsActivated.push_back(0); } model->addVar(v); boundStore.ensureReadyFor(v); } void processBufferOfActivatedBounds(); public: void boundActivated(LVRef v) { assert(!tableau.isQuasiBasic(v) || boundsActivated[getVarId(v)] == 0); if(tableau.isQuasiBasic(v)) { quasiToBasic(v); } ++boundsActivated[getVarId(v)]; } void boundDeactivated(LVRef v) { assert(boundsActivated[getVarId(v)] > 0); --boundsActivated[getVarId(v)]; if (getNumOfBoundsActive(v) == 0 && tableau.isBasic(v)) { tableau.basicToQuasi(v); } } lbool getPolaritySuggestion(LVRef var, LABoundRef pos, LABoundRef neg) const { if (tableau.isQuasiBasic(var)) { (const_cast(this))->quasiToBasic(var); } auto const& val = model->read(var); bool positive = false; auto const& positive_bound = this->boundStore[pos]; if ((positive_bound.getType() == bound_l && positive_bound.getValue() <= val) || (positive_bound.getType() == bound_u && positive_bound.getValue() >= val)) { // The current value of the variable is consistent with the positive bound positive = true; } bool negative = false; auto const& negative_bound = this->boundStore[neg]; if ((negative_bound.getType() == bound_l && negative_bound.getValue() <= val) || (negative_bound.getType() == bound_u && negative_bound.getValue() >= val)) { // The current value of the variable is consistent with the negative bound negative = true; } // The value cannot be consistent with bound positive and negative bound at the same time assert(!positive || !negative); // It can happen that neither bound is consistent with the current assignment. Consider the current value // of variable "x" as <0,-1/2> with term "x >= 0". The positive bound is lower with value <0,0> and the negative // bound is upper with value <0, -1>. Then both "positive" and "negative" will be false if (positive) { return l_True; } if (negative) { return l_False; } return l_Undef; } }; #endif //OPENSMT_SIMPLEX_H opensmt-2.5.2/src/tsolvers/lasolver/SparseMatrix.cc000066400000000000000000000156241445011647600224550ustar00rootroot00000000000000/* * Copyright (c) 2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #include "SparseMatrix.h" void SparseColMatrix::Col::negate() { this->poly.negate(); } void SparseColMatrix::Col::add(Col const & other, opensmt::Real const & multiple) { this->poly.merge(other.poly, multiple); } opensmt::Real SparseColMatrix::Col::product(const std::vector & values) const { opensmt::Real sum = 0; for (auto const & term : poly) { uint32_t index = term.var.x; assert(index < values.size()); sum += term.coeff * values[index]; } return sum; } SparseColMatrix::TermVec SparseColMatrix::Col::toVector() const { std::vector> args; args.reserve(poly.size()); for (auto & term : poly) { args.emplace_back(term.var, term.coeff); } return args; } const FastRational * SparseColMatrix::Col::tryGetCoeffFor(RowIndex rowIndex) const { IndexType bound {rowIndex.count}; auto it = std::lower_bound(poly.begin(), poly.end(), bound, [](auto const & term, IndexType val) { return term.var.x < val.x; }); if (it == poly.end()) { return nullptr; } return it->var == bound ? &it->coeff : nullptr; } namespace { SparseColMatrix identityMatrix(uint32_t size) { SparseColMatrix id(RowCount{size}, ColumnCount{size}); for (uint32_t i = 0; i < size; ++i) { SparseColMatrix::ColumnPolynomial poly; poly.addTerm(IndexType{i}, 1); id.setColumn(ColIndex{i}, std::move(poly)); } return id; } void negateColumn(SparseColMatrix & A, ColIndex colIndex, SparseColMatrix & U) { A[colIndex].negate(); U[colIndex].negate(); } void swapColumns(SparseColMatrix & A, ColIndex pivotIndex, ColIndex otherIndex, SparseColMatrix & U) { assert(pivotIndex != otherIndex); A.swapCols(pivotIndex, otherIndex); U.swapCols(pivotIndex, otherIndex); } void addColumnMultiple(SparseColMatrix & A, ColIndex colFrom, opensmt::Real const & multiple, ColIndex colTo, SparseColMatrix & U) { A[colTo].add(A[colFrom], multiple); // For U we do the inverse operation: colFrom += -multiple * colTo U[colFrom].add(U[colTo], -multiple); } /* * Normalizes row so that all entries to the right of pivot are zero. * Returns true if the pivot is non-zero. */ bool normalizeRow(SparseColMatrix & A, RowIndex rowIndex, ColIndex pivotIndex, SparseColMatrix & U) { // Collect all columns with non-zero entry at given row; ensure they are positive std::vector activeColumns; auto size = A.colCount(); activeColumns.reserve(size - pivotIndex); for (uint32_t col = pivotIndex; col < size; ++col) { if (A[col].isFirst(rowIndex)) { activeColumns.push_back(ColIndex{col}); if (A[col].getFirstCoeff().sign() < 0) { negateColumn(A, ColIndex{col}, U); } } } if (activeColumns.empty()) { return false; } // Reduce the set of active columns until there is only a single one. // Current implementation: Find minimal value, reduce others, and repeat // Alternative possiblity: Rosser's algorithm (see Yices), which uses largest values to for reductions while (activeColumns.size() > 1) { auto it = std::min_element(activeColumns.begin(), activeColumns.end(), [&A](ColIndex first, ColIndex second) { assert(A[first].getFirstCoeff().sign() > 0 and A[second].getFirstCoeff().sign() > 0); return A[first].getFirstCoeff() < A[second].getFirstCoeff(); }); std::iter_swap(it, activeColumns.begin()); // Now the index of column with smallest value is first in activeColumns auto smallestValue = A[activeColumns[0]].getFirstCoeff(); uint32_t nextColIndex = 1; while (nextColIndex < activeColumns.size()) { auto const & nextCol = A[activeColumns[nextColIndex]]; auto quotient = -fastrat_fdiv_q(nextCol.getFirstCoeff(), smallestValue); assert(not quotient.isZero()); addColumnMultiple(A, activeColumns[0], quotient, activeColumns[nextColIndex], U); if (not nextCol.isFirst(rowIndex)) { // the entry in this column is zero now, remove the column from active set std::swap(activeColumns[nextColIndex], activeColumns.back()); activeColumns.pop_back(); // do not advance index! } else { // the entry in this column is not zero yet, just continue with next column ++nextColIndex; } } } // Single active column left, move it to the pivot's position assert(activeColumns.size() == 1); if (activeColumns[0] != pivotIndex) { swapColumns(A, activeColumns[0], pivotIndex, U); } return true; } void reduceToTheLeft(SparseColMatrix & A, RowIndex rowIndex, ColIndex pivotIndex, SparseColMatrix & U) { auto const & pivotCol = A[pivotIndex]; assert(pivotCol.isFirst(rowIndex)); auto const & pivotVal = pivotCol.getFirstCoeff(); for (uint32_t col = 0; col < pivotIndex; ++col) { auto const * otherVal = A[col].tryGetCoeffFor(rowIndex); if (not otherVal) { continue; } auto quotient = -fastrat_fdiv_q(*otherVal, pivotVal); if (not quotient.isZero()) { addColumnMultiple(A, pivotIndex, quotient, ColIndex{col}, U); } } } } HermiteNormalForm::HNFOperationsResult HermiteNormalForm::operator()(SparseColMatrix && A) const { // We perform column operations on A to transform it to HNF // At the same time we record the inverse operations in U // We maintain the invariant that A'*U' = A; starting with U:=I, the identity matrix // We actually maintain the transpose of U' as column matrix and not U' as row matrix uint32_t cols = A.colCount(); uint32_t rows = A.rowCount(); SparseColMatrix UT = identityMatrix(cols); uint32_t pivotCol = 0; for (uint32_t currRow = 0; currRow < rows and pivotCol < cols; ++currRow) { // First make sure the current row conforms to the lower triangular form bool hasPivot = normalizeRow(A, RowIndex{currRow}, ColIndex{pivotCol}, UT); if (not hasPivot) { // a row that is linearly dependent on rows above it; skip it and continue with the next row // DO NOT INCREMENT PIVOT! continue; } // Now make sure it conforms to HNF rule that elements to the left of pivot are smaller and positive reduceToTheLeft(A, RowIndex{currRow}, ColIndex{pivotCol}, UT); // DO NOT FORGET TO INCREMENT PIVOT! ++pivotCol; } return {std::move(UT), pivotCol}; }opensmt-2.5.2/src/tsolvers/lasolver/SparseMatrix.h000066400000000000000000000063711445011647600223160ustar00rootroot00000000000000/* * Copyright (c) 2022, Martin Blicha * Antti Hyvarinen * * SPDX-License-Identifier: MIT * */ #ifndef OPENSMT_SPARSEMATRIX_H #define OPENSMT_SPARSEMATRIX_H #include "osmtinttypes.h" #include "Polynomial.h" #include #include struct ColumnCount { uint32_t count; operator uint32_t () const { return count; } }; using ColIndex = ColumnCount; struct RowCount { uint32_t count; operator uint32_t () const { return count; } }; using RowIndex = RowCount; struct IndexType { uint32_t x; bool operator==(IndexType const o) const { return x == o.x; } static const IndexType Undef; }; inline constexpr IndexType IndexType::Undef = IndexType { INT32_MAX }; class SparseColMatrix { public: using ColumnPolynomial = PolynomialT; using TermVec = std::vector>; class Col { ColumnPolynomial poly; public: Col() = default; Col(Col const &) = delete; Col(Col &&) = default; void setPolynomial(ColumnPolynomial && _poly) { assert(this->poly.size() == 0); this->poly = std::move(_poly); } uint32_t size() const { return poly.size(); } void negate(); void add(Col const & other, FastRational const & multiple); bool isFirst(RowIndex row) const { return poly.size() > 0 and poly.begin()->var.x == row.count; } FastRational const * tryGetFirstCoeff() const { return poly.size() > 0 ? &poly.begin()->coeff : nullptr; } FastRational const & getFirstCoeff() const { assert(poly.size() > 0); return poly.begin()->coeff; } FastRational const * tryGetCoeffFor(RowIndex rowIndex) const; FastRational product(std::vector const & values) const; TermVec toVector() const; }; private: RowCount _rowCount; ColumnCount _colCount; std::vector cols; std::vector colPermutation; public: explicit SparseColMatrix(RowCount rowCount, ColumnCount colCount) : _rowCount(rowCount), _colCount{colCount} { cols.resize(colCount.count); colPermutation.resize(colCount); std::iota(colPermutation.begin(), colPermutation.end(), 0); } SparseColMatrix(SparseColMatrix const &) = delete; SparseColMatrix(SparseColMatrix &&) = default; Col & operator[](uint32_t index) { return cols[colPermutation[index]]; } Col const & operator[](uint32_t index) const { return cols[colPermutation[index]]; } void swapCols(uint32_t first, uint32_t second) { std::swap(colPermutation[first], colPermutation[second]); } uint32_t colCount() const { return _colCount; } uint32_t rowCount() const { return _rowCount; } void setColumn(ColIndex colIndex, ColumnPolynomial && poly) { assert(colIndex < _colCount); cols[colIndex].setPolynomial(std::move(poly)); } }; class HermiteNormalForm { public: struct HNFOperationsResult { SparseColMatrix operations; uint32_t HNFdimension; }; HNFOperationsResult operator() (SparseColMatrix &&) const; }; struct SparseLinearSystem { SparseColMatrix A; std::vector rhs; }; #endif //OPENSMT_SPARSEMATRIX_H opensmt-2.5.2/src/tsolvers/lasolver/Tableau.cc000066400000000000000000000207371445011647600214110ustar00rootroot00000000000000/* * Copyright (c) 2018-2022, Martin Blicha * * SPDX-License-Identifier: MIT */ #include "Tableau.h" #include #ifdef SIMPLEX_DEBUG #define simplex_assert(x) assert(x) #else #define simplex_assert(x) #endif // SIMPLEX_DEBUG using namespace opensmt; namespace { template inline bool contains(const C & container, const E & elem) { return container.find(elem) != container.end(); } } // namespace void Tableau::nonbasicVar(LVRef v) { if (isProcessed(v)) { return; } newNonbasicVar(v); } void Tableau::newNonbasicVar(LVRef v) { assert(!isProcessed(v)); ensureTableauReadyFor(v); assert(!cols[v.x]); cols[v.x] = std::make_unique(); varTypes[getVarId(v)] = VarType::NONBASIC; } void Tableau::newRow(LVRef v, std::unique_ptr poly) { assert(!isProcessed(v)); ensureTableauReadyFor(v); addRow(v, std::move(poly)); varTypes[getVarId(v)] = VarType::QUASIBASIC; normalizeRow(v); } std::size_t Tableau::getNumOfCols() const { return cols.size(); } std::size_t Tableau::getPolySize(LVRef basicVar) const { assert(rows[basicVar.x]); return rows[basicVar.x]->size(); } const opensmt::Real & Tableau::getCoeff(LVRef basicVar, LVRef nonBasicVar) const { assert(rows[basicVar.x]); return rows[basicVar.x]->getCoeff(nonBasicVar); } const Tableau::column_t & Tableau::getColumn(LVRef nonBasicVar) const { assert(cols[nonBasicVar.x]); return *cols[nonBasicVar.x]; } const Tableau::Polynomial & Tableau::getRowPoly(LVRef basicVar) const { assert(rows[basicVar.x]); return *rows[basicVar.x]; } Tableau::Polynomial & Tableau::getRowPoly(LVRef basicVar) { assert(rows[basicVar.x]); return *rows[basicVar.x]; } const Tableau::rows_t & Tableau::getRows() const { return rows; } std::vector Tableau::getNonBasicVars() const { std::vector res; res.resize(varTypes.size()); for (unsigned i = 0; i < varTypes.size(); ++i) { if (varTypes[i] == VarType::NONBASIC) { res.push_back(LVRef{i}); } } return res; } void Tableau::addRow(LVRef v, std::unique_ptr p) { assert(!rows[v.x]); rows[v.x] = std::move(p); } std::unique_ptr Tableau::removeRow(LVRef v) { assert(rows[v.x]); std::unique_ptr res; assert(!res); res.swap(rows[v.x]); return res; } void Tableau::moveRowFromTo(LVRef from, LVRef to) { assert(!rows[to.x]); assert(rows[from.x]); rows[to.x] = std::move(rows[from.x]); } void Tableau::moveColFromTo(LVRef from, LVRef to) { assert(!cols[to.x]); assert(cols[from.x]); cols[to.x] = std::move(cols[from.x]); } bool Tableau::isProcessed(LVRef v) const { return varTypes.size() > getVarId(v) && varTypes[getVarId(v)] != VarType::NONE; } void Tableau::pivot(LVRef bv, LVRef nv) { assert(isBasic(bv)); assert(isNonBasic(nv)); varTypes[getVarId(bv)] = VarType::NONBASIC; varTypes[getVarId(nv)] = VarType::BASIC; assert(cols[nv.x]); assert(!cols[bv.x]); // compute the polynomial for nv assert(rows[bv.x]); assert(!rows[nv.x]); { Polynomial & nvPoly = getRowPoly(bv); const auto coeff = nvPoly.removeVar(nv); if (not coeff.isOne()) { nvPoly.divideBy(coeff); } nvPoly.negate(); nvPoly.addTerm(bv, coeff.inverse()); } // remove row for bv, add row for nv moveRowFromTo(bv, nv); // move the column from nv tto bv moveColFromTo(nv, bv); Polynomial & nvPoly = getRowPoly(nv); // update column information regarding this one poly for (auto & term : nvPoly) { auto var = term.var; assert(cols[var.x]); removeRowFromColumn(bv, var); addRowToColumn(nv, var); } // for all (active) rows containing nv, substitute for (auto rowVar : getColumn(bv)) { if (rowVar == nv || isQuasiBasic(rowVar)) { continue; } // update the polynomials auto & poly = getRowPoly(rowVar); const auto nvCoeff = poly.removeVar(nv); poly.merge( nvPoly, nvCoeff, tmp_storage, // informAdded [this, bv, rowVar](LVRef addedVar) { if (addedVar == bv) { return; } assert(cols[addedVar.x]); assert(!contains(getColumn(addedVar), rowVar)); addRowToColumn(rowVar, addedVar); }, // informRemoved [this, rowVar](LVRef removedVar) { assert(cols[removedVar.x]); assert(contains(getColumn(removedVar), rowVar)); removeRowFromColumn(rowVar, removedVar); }); } assert(!cols[nv.x]); assert(cols[bv.x]); assert(!rows[bv.x]); assert(rows[nv.x]); } void Tableau::clear() { this->rows.clear(); this->cols.clear(); this->varTypes.clear(); } bool Tableau::isBasic(LVRef v) const { return varTypes.size() > getVarId(v) && varTypes[getVarId(v)] == VarType::BASIC; } bool Tableau::isNonBasic(LVRef v) const { return varTypes.size() > getVarId(v) && varTypes[getVarId(v)] == VarType::NONBASIC; } bool Tableau::isQuasiBasic(LVRef v) const { return varTypes.size() > getVarId(v) && varTypes[getVarId(v)] == VarType::QUASIBASIC; } void Tableau::print() const { std::cout << "Rows:\n"; for (unsigned i = 0; i != rows.size(); ++i) { if (!rows[i]) { continue; } std::cout << "Var of the row: " << i << ';'; for (const auto & term : this->getRowPoly(LVRef{i})) { std::cout << "( " << term.coeff << " | " << term.var.x << " ) "; } std::cout << '\n'; } std::cout << '\n'; std::cout << "Columns:\n"; for (unsigned i = 0; i != cols.size(); ++i) { if (!cols[i]) { continue; } std::cout << "Var of the column: " << i << "; Contains: "; for (auto var : getColumn(LVRef{i})) { std::cout << var.x << ' '; } std::cout << '\n'; } std::cout << '\n'; } bool Tableau::checkConsistency() const { bool res = true; for (unsigned i = 0; i < cols.size(); ++i) { LVRef var{i}; if (isNonBasic(var)) { res &= (cols[i] != nullptr); assert(res); for (auto row : *cols[i]) { res &= this->getRowPoly(row).contains(var); assert(res); } } else { assert(!cols[i]); } } for (unsigned i = 0; i < rows.size(); ++i) { LVRef var{i}; if (isQuasiBasic(var)) { continue; } if (!rows[i]) { assert(isNonBasic(var)); continue; } res &= isBasic(var); assert(res); for (auto const & term : *rows[i]) { auto termVar = term.var; res &= isNonBasic(termVar) && cols[termVar.x]; assert(res); res &= contains(getColumn(termVar), var); assert(res); } } return res; } // Makes sures the representing polynomial of this row contains only nonbasic variables void Tableau::normalizeRow(LVRef v) { assert(isQuasiBasic(v)); // Do not call this for non quasi rows Polynomial & row = getRowPoly(v); std::vector toEliminate; for (auto const & term : row) { if (isQuasiBasic(term.var)) { normalizeRow(term.var); toEliminate.push_back(term.var); } if (isBasic(term.var)) { toEliminate.push_back(term.var); } } for (LVRef var : toEliminate) { auto const coeff = row.removeVar(var); row.merge(getRowPoly(var), coeff, tmp_storage); } } // Eliminates basic variables from representation of this row. void Tableau::quasiToBasic(LVRef v) { assert(isQuasiBasic(v)); normalizeRow(v); for (auto const & term : getRowPoly(v)) { addRowToColumn(v, term.var); } varTypes[getVarId(v)] = VarType::BASIC; assert(isBasic(v)); simplex_assert(checkConsistency()); } void Tableau::basicToQuasi(LVRef v) { assert(isBasic(v)); varTypes[getVarId(v)] = VarType::QUASIBASIC; assert(isQuasiBasic(v)); Polynomial & row = getRowPoly(v); for (auto & term : row) { assert(isNonBasic(term.var)); removeRowFromColumn(v, term.var); } simplex_assert(checkConsistency()); } void Tableau::ensureTableauReadyFor(LVRef v) { auto id = getVarId(v); while (cols.size() <= id) { cols.emplace_back(); } while (rows.size() <= id) { rows.emplace_back(); } while (varTypes.size() <= id) { varTypes.push_back(VarType::NONE); } } opensmt-2.5.2/src/tsolvers/lasolver/Tableau.h000066400000000000000000000065061445011647600212510ustar00rootroot00000000000000/* * Copyright (c) 2018-2022, Martin Blicha * * SPDX-License-Identifier: MIT */ #ifndef OPENSMT_TABLEAU_H #define OPENSMT_TABLEAU_H #include "LAVar.h" #include "Polynomial.h" #include "Real.h" #include #include #include #include #include class Tableau { class Column { std::vector rows; using iterator_t = std::vector::iterator; using const_iterator_t = std::vector::const_iterator; public: void addRow(LVRef row) { rows.push_back(row); } void removeRow(LVRef row) { auto beg = rows.rbegin(); auto it = std::find(beg, rows.rend(), row); assert(it != rows.rend()); std::iter_swap(it, beg); rows.pop_back(); } void clear() { rows.clear(); } bool empty() const { return rows.empty(); } unsigned int size() const { return rows.size(); } iterator_t begin() { return rows.begin(); } iterator_t end() { return rows.end(); } const_iterator_t begin() const { return rows.cbegin(); } const_iterator_t end() const { return rows.cend(); } const_iterator_t find(LVRef row) const { return std::find(begin(), end(), row); } }; public: using Polynomial = PolynomialT; protected: // using column_t = std::unordered_set; using column_t = Column; using rows_t = std::vector>; // using vars_t = std::unordered_set; using vars_t = std::set; public: void newNonbasicVar(LVRef v); void nonbasicVar(LVRef v); void newRow(LVRef v, std::unique_ptr poly); std::size_t getNumOfCols() const; std::size_t getPolySize(LVRef basicVar) const; const opensmt::Real & getCoeff(LVRef basicVar, LVRef nonBasicVar) const; const column_t & getColumn(LVRef nonBasicVar) const; const Polynomial & getRowPoly(LVRef basicVar) const; Polynomial & getRowPoly(LVRef basicVar); const rows_t & getRows() const; void clear(); void pivot(LVRef bv, LVRef nv); bool isBasic(LVRef v) const; bool isNonBasic(LVRef v) const; bool isQuasiBasic(LVRef v) const; bool isProcessed(LVRef v) const; void quasiToBasic(LVRef v); void basicToQuasi(LVRef v); // debug void print() const; bool checkConsistency() const; std::vector getNonBasicVars() const; private: std::vector> cols; rows_t rows; enum class VarType : char { NONE, BASIC, NONBASIC, QUASIBASIC }; std::vector varTypes; Tableau::Polynomial::poly_t tmp_storage; void ensureTableauReadyFor(LVRef v); void addRow(LVRef v, std::unique_ptr p); std::unique_ptr removeRow(LVRef v); void moveRowFromTo(LVRef from, LVRef to); void moveColFromTo(LVRef from, LVRef to); void addRowToColumn(LVRef row, LVRef col) { assert(cols[col.x]); cols[col.x]->addRow(row); } void removeRowFromColumn(LVRef row, LVRef col) { assert(cols[col.x]); cols[col.x]->removeRow(row); } void clearColumn(LVRef col) { assert(cols[col.x]); cols[col.x]->clear(); } void normalizeRow(LVRef row); }; #endif // OPENSMT_TABLEAU_H opensmt-2.5.2/src/tsolvers/stpsolver/000077500000000000000000000000001445011647600177265ustar00rootroot00000000000000opensmt-2.5.2/src/tsolvers/stpsolver/CMakeLists.txt000066400000000000000000000017051445011647600224710ustar00rootroot00000000000000target_sources(tsolvers PRIVATE "${CMAKE_CURRENT_LIST_DIR}/STPSolver.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/STPStore.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/STPMapper.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/STPEdgeGraph.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/STPGraphManager.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/STPModel.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/SafeInt.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/Converter.h" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/STPSolver_implementations.hpp" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/STPStore_implementations.hpp" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/STPMapper_implementations.hpp" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/STPGraphManager_implementations.hpp" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/STPModel_implementations.hpp" PRIVATE "${CMAKE_CURRENT_LIST_DIR}/STPEdgeGraph.cc" PUBLIC "${CMAKE_CURRENT_LIST_DIR}/IDLSolver.h" PUBLIC "${CMAKE_CURRENT_LIST_DIR}/RDLSolver.h" ) opensmt-2.5.2/src/tsolvers/stpsolver/Converter.h000066400000000000000000000007661445011647600220570ustar00rootroot00000000000000#ifndef OPENSMT_CONVERTER_H #define OPENSMT_CONVERTER_H #include "FastRational.h" template class Converter { public: // Converts a given value to a T value static T getValue(const FastRational &val); static T getValue(ptrdiff_t val); // given (a-b<=c), returns c' such that not(a-b<=c) == (b-a<=c') static T negate(const T &val); // Converts given T to a string static std::string show(const T &val); Converter() = delete; }; #endif //OPENSMT_CONVERTER_H opensmt-2.5.2/src/tsolvers/stpsolver/IDLSolver.h000066400000000000000000000024031445011647600217010ustar00rootroot00000000000000#ifndef OPENSMT_IDLSOLVER_H #define OPENSMT_IDLSOLVER_H #include "STPSolver.h" #include "SafeInt.h" #include "Converter.h" #include "ModelBuilder.h" class IDLSolver : public STPSolver { public: IDLSolver(SMTConfig &c, ArithLogic &l) : STPSolver(c, l) {}; }; template<> SafeInt Converter::getValue(const FastRational &val) { assert(val.isInteger()); return SafeInt(static_cast(val.get_d())); } template<> SafeInt Converter::getValue(ptrdiff_t val) { return SafeInt(val); } template<> SafeInt Converter::negate(const SafeInt &val) { return SafeInt(-(val.value() + 1)); } template<> std::string Converter::show(const SafeInt &val) { return std::to_string(val.value()); } template<> void STPSolver::fillTheoryFunctions(ModelBuilder & modelBuilder) const { auto knownValues = this->model->getAllValues(); for (auto const & entry : knownValues) { PTRef var = this->mapper.getPTRef(entry.first); if (var == PTRef_Undef) { continue; } assert(logic.isVar(var)); auto stringVal = Converter::show(entry.second); PTRef val = logic.mkConst(stringVal.c_str()); modelBuilder.addVarValue(var, val); } } #endif //OPENSMT_IDLSOLVER_H opensmt-2.5.2/src/tsolvers/stpsolver/RDLSolver.h000066400000000000000000000046241445011647600217210ustar00rootroot00000000000000#ifndef OPENSMT_RDLSOLVER_H #define OPENSMT_RDLSOLVER_H #include "STPSolver.h" #include "Delta.h" #include "Converter.h" #include "ModelBuilder.h" class RDLSolver : public STPSolver { public: RDLSolver(SMTConfig &c, ArithLogic &l) : STPSolver(c, l) {}; }; template<> Delta Converter::getValue(const FastRational &val) { return Delta(val, 0); } template<> Delta Converter::getValue(ptrdiff_t val) { return Delta(FastRational(val, 1), 0); } template<> Delta Converter::negate(const Delta &val) { assert(!val.hasDelta()); // not(a-b <= c) == (b-a < -c) == (b-a <= -c-delta) return Delta(-val.R(), -1); } template<> std::string Converter::show(const Delta &val) { return val.printValue(); } template<> void STPSolver::fillTheoryFunctions(ModelBuilder & modelBuilder) const { auto knownValues = this->model->getAllValues(); // Now we need to compute the proper values as Rationals, not as \delta-Rationals // Compute the right value for delta: Delta delta; FastRational deltaVal; bool deltaSet = false; // I need to iterate over all edges and find the minimum from deltas making the edges true auto const & edges = this->model->getGraph().addedEdges; for (EdgeRef edgeRef : edges) { auto const &edge = store.getEdge(edgeRef); Delta realDiff = knownValues.at(edge.from) - knownValues.at(edge.to); Delta const &upperBound = edge.cost; assert(upperBound.R() >= realDiff.R()); if (realDiff.R() < upperBound.R() and realDiff.D() > upperBound.D()) { Real valOfDelta = (upperBound.R() - realDiff.R()) / (realDiff.D() - upperBound.D()); assert(valOfDelta > 0); if (not deltaSet or delta > valOfDelta) { deltaSet = true; delta = valOfDelta; } } } if (not deltaSet || delta > 1) { deltaVal = opensmt::Number(1); } else { deltaVal = delta.R()/2; } for (auto const & entry : knownValues) { PTRef var = this->mapper.getPTRef(entry.first); if (var == PTRef_Undef) { continue; } assert(logic.isVar(var)); Delta const & varDeltaValue = entry.second; FastRational varValue = varDeltaValue.R() + varDeltaValue.D() * deltaVal; PTRef val = logic.mkRealConst(varValue); modelBuilder.addVarValue(var, val); } } #endif //OPENSMT_RDLSOLVER_H opensmt-2.5.2/src/tsolvers/stpsolver/STPEdgeGraph.cc000066400000000000000000000010471445011647600224540ustar00rootroot00000000000000#include "STPEdgeGraph.h" void EdgeGraph::addEdge(EdgeRef e, VertexRef from, VertexRef to) { auto max = std::max(from.x, to.x); if (incoming.size() <= max) { incoming.resize(max + 1); outgoing.resize(max + 1); } addedEdges.push_back(e); incoming[to.x].push_back(e); outgoing[from.x].push_back(e); } void EdgeGraph::clear() { addedEdges.clear(); incoming.clear(); outgoing.clear(); } bool EdgeGraph::isEmpty() const { assert(incoming.size() == outgoing.size()); return incoming.empty(); } opensmt-2.5.2/src/tsolvers/stpsolver/STPEdgeGraph.h000066400000000000000000000005261445011647600223170ustar00rootroot00000000000000#ifndef OPENSMT_STPEDGEGRAPH_H #define OPENSMT_STPEDGEGRAPH_H #include "STPStore.h" struct EdgeGraph { std::vector addedEdges; std::vector> incoming, outgoing; void addEdge(EdgeRef e, VertexRef from, VertexRef to); void clear(); bool isEmpty() const; }; #endif //OPENSMT_STPEDGEGRAPH_H opensmt-2.5.2/src/tsolvers/stpsolver/STPGraphManager.h000066400000000000000000000032151445011647600230230ustar00rootroot00000000000000#ifndef OPENSMT_STPGRAPHMANAGER_H #define OPENSMT_STPGRAPHMANAGER_H #include "STPStore.h" #include "STPMapper.h" #include "STPEdgeGraph.h" // implementations of template functions #included below class definitions // stores edges set as true and finds consequences of each added edge template class STPGraphManager { private: // helper struct to return results of DFS struct DFSResult { std::vector visited; // map of which vertices were visited std::vector distance; // map of distances to each visited vertex size_t total{}; // sum of all edges each vertex appears in DFSResult(std::vector &&vis, std::vector &&dist, size_t total) : visited(std::move(vis)), distance(std::move(dist)), total(total) {} }; STPStore &store; STPMapper &mapper; EdgeGraph graph; uint32_t timestamp; // timestamp of the latest 'setTrue' call std::vector deductions; DFSResult dfsSearch(VertexRef init, bool forward); void setDeduction(EdgeRef e); public: explicit STPGraphManager(STPStore &store, STPMapper &mapper) : store(store), mapper(mapper), timestamp(0) {} const EdgeGraph &getGraph() const { return graph; } bool isTrue(EdgeRef e) const; uint32_t getAddedCount() const { return timestamp; } void setTrue(EdgeRef e, PtAsgn asgn); std::vector findConsequences(EdgeRef e); void findExplanation(EdgeRef e, vec &v); void removeAfter(uint32_t point); void clear(); }; #include "STPGraphManager_implementations.hpp" #endif //OPENSMT_STPGRAPHMANAGER_H opensmt-2.5.2/src/tsolvers/stpsolver/STPGraphManager_implementations.hpp000066400000000000000000000145601445011647600266600ustar00rootroot00000000000000#ifndef OPENSMT_STPGRAPHMANAGER_IMPLEMENTATIONS_HPP #define OPENSMT_STPGRAPHMANAGER_IMPLEMENTATIONS_HPP #include #include "STPGraphManager.h" #include "Converter.h" template bool STPGraphManager::isTrue(EdgeRef e) const { return e != EdgeRef_Undef && store.getEdge(e).setTime != 0; } template void STPGraphManager::setTrue(EdgeRef e, PtAsgn asgn) { Edge &edge = store.getEdge(e); if (edge.setTime != 0) return; // edge was already set to true - it is already stored ++timestamp; edge.setTime = timestamp; mapper.setAssignment(e, asgn); graph.addEdge(e, edge.from, edge.to); } template void STPGraphManager::setDeduction(EdgeRef e) { deductions.push_back(e); store.getEdge(e).setTime = timestamp; } // Searches through the graph to find consequences of currently assigned edges, starting from 'e' template std::vector STPGraphManager::findConsequences(EdgeRef e) { size_t n = store.vertexNum(); auto &start = store.getEdge(e); // find potential starts/ends of an edge with a path going through 'e' auto aRes = dfsSearch(start.from, false); auto bRes = dfsSearch(start.to, true); // we scan through the side which appears in fewer total edges auto &thisRes = aRes.total < bRes.total ? aRes : bRes; auto &otherRes = aRes.total < bRes.total ? bRes : aRes; std::vector ret; // for each (WLOG) 'a', go through its edges and find each 'a -> b' edge that has cost higher than length found by DFS // such edges are consequences of the current graph for (uint32_t i = 0; i < n; ++i) { if (!thisRes.visited[i]) continue; for (auto eRef : mapper.edgesOf(VertexRef{i})) { if (eRef == e) continue; const Edge &edge = store.getEdge(eRef); auto thisSide = (aRes.total < bRes.total) ? edge.from.x : edge.to.x; auto otherSide = (aRes.total < bRes.total) ? edge.to.x : edge.from.x; if (thisSide == i && otherRes.visited[otherSide] && edge.cost >= thisRes.distance[thisSide] + start.cost + otherRes.distance[otherSide]) { if (edge.setTime == 0) { ret.push_back(eRef); setDeduction(eRef); } } } } return ret; } // DFS through the graph to find shortest paths to all reachable vertices from 'init' in the given direction template typename STPGraphManager::DFSResult STPGraphManager::dfsSearch(VertexRef init, bool forward) { std::vector visited(store.vertexNum()); std::vector length(store.vertexNum()); size_t total = 0; std::stack open; visited[init.x] = true; length[init.x] = Converter::getValue(0); open.push(init); while (!open.empty()) { VertexRef curr = open.top(); open.pop(); auto &toScan = forward ? graph.outgoing[curr.x] : graph.incoming[curr.x]; for (auto eRef : toScan) { const Edge &edge = store.getEdge(eRef); auto next = forward ? edge.to : edge.from; if (!visited[next.x]) { visited[next.x] = true; open.push(next); length[next.x] = length[curr.x] + edge.cost; total += mapper.edgesOf(next).size(); } else if (length[next.x] > length[curr.x] + edge.cost) { length[next.x] = length[curr.x] + edge.cost; open.push(next); } } } return DFSResult(std::move(visited), std::move(length), total); } // removes all edges that have timestamp strictly later than 'point' from the graph template void STPGraphManager::removeAfter(uint32_t point) { if (graph.addedEdges.empty()) return; for (int i = graph.addedEdges.size() - 1; i >= 0; --i) { EdgeRef eRef = graph.addedEdges[i]; auto &edge = store.getEdge(eRef); if (edge.setTime <= point) { // edges appear in 'addedEdges' in timestamp order timestamp = edge.setTime; break; } // edges are added in the same order to all three lists - no need to check the values of incoming / outgoing graph.incoming[edge.to.x].pop_back(); graph.outgoing[edge.from.x].pop_back(); graph.addedEdges.pop_back(); edge.setTime = 0; mapper.removeAssignment(eRef); } if (deductions.empty()) return; for (int i = deductions.size() - 1; i >= 0; --i) { EdgeRef ded = deductions[i]; auto &edge = store.getEdge(ded); if (edge.setTime <= point) { return; } edge.setTime = 0; deductions.pop_back(); } } template void STPGraphManager::findExplanation(EdgeRef e, vec &v) { const Edge &expl = store.getEdge(e); if (mapper.getAssignment(e) != PtAsgn_Undef) { // explanation for explicitly assigned edge is trivial v.push(mapper.getAssignment(e)); return; } std::vector visited(store.vertexNum(), EdgeRef_Undef); std::vector length(store.vertexNum()); std::stack open; open.push(expl.from); while (!open.empty()) { auto curr = open.top(); open.pop(); if (curr == expl.to && length[curr.x] <= expl.cost) break; for (auto eRef : graph.outgoing[curr.x]) { if (eRef == e) continue; const Edge &edge = store.getEdge(eRef); if (edge.setTime > expl.setTime) continue; assert(mapper.getAssignment(eRef) != PtAsgn_Undef); // deductions aren't stored in graph auto next = edge.to; if (visited[next.x] == EdgeRef_Undef || length[next.x] > length[curr.x] + edge.cost) { visited[next.x] = eRef; length[next.x] = length[curr.x] + edge.cost; open.push(next); } } } auto backtrack = visited[expl.to.x]; while (true) { assert(backtrack != EdgeRef_Undef); const Edge &edge = store.getEdge(backtrack); assert(mapper.getAssignment(backtrack) != PtAsgn_Undef); v.push(mapper.getAssignment(backtrack)); if (edge.from == expl.from) break; backtrack = visited[edge.from.x]; } } template void STPGraphManager::clear() { timestamp = 0; graph.clear(); } #endif //OPENSMT_STPGRAPHMANAGER_IMPLEMENTATIONS_HPPopensmt-2.5.2/src/tsolvers/stpsolver/STPMapper.h000066400000000000000000000032111445011647600217070ustar00rootroot00000000000000#ifndef OPENSMT_STPMAPPER_H #define OPENSMT_STPMAPPER_H #include #include "ArithLogic.h" #include #include "STPStore.h" // implementations of template functions #included below class definition template class STPMapper { private: const ArithLogic &logic; const STPStore &store; std::vector vertRefToVar; // maps VertRefs to variables' PTRefs std::vector varToVertRef; // maps PTRefs of variables to VertRefs std::vector leqToEdgeRef; // maps PTRefs of inequalities to EdgeRefs std::vector edgeRefToLeq; // reverse of leqToEdgeRef std::vector edgeRefToAsgn; // maps assigned edges to assignments that set them std::vector> edgesContainingVert; // list of edges each vertex appears in public: STPMapper(const ArithLogic &l, const STPStore &s); void setVert(PTRef var, VertexRef vert); void registerEdge(EdgeRef edge); void mapEdge(PTRef leq, EdgeRef edge); void setAssignment(EdgeRef edge, PtAsgn asgn); void removeAssignment(EdgeRef edge); PtAsgn getAssignment(EdgeRef edge) const; PTRef getPTRef(VertexRef var) const; VertexRef getVertRef(PTRef var) const; EdgeRef getEdgeRef(PTRef leq) const; EdgeRef getEdgeRef(VertexRef y, VertexRef x, T c) const; PTRef getPTRef(EdgeRef edge) const; const std::vector &edgesOf(VertexRef v) { return edgesContainingVert[v.x]; } void clear(); }; #include "STPMapper_implementations.hpp" #endif //OPENSMT_STPMAPPER_H opensmt-2.5.2/src/tsolvers/stpsolver/STPMapper_implementations.hpp000066400000000000000000000077031445011647600255510ustar00rootroot00000000000000#ifndef OPENSMT_STPMAPPER_IMPLEMENTATIONS_HPP #define OPENSMT_STPMAPPER_IMPLEMENTATIONS_HPP #include #include "STPMapper.h" template STPMapper::STPMapper(const ArithLogic &l, const STPStore &s) : logic(l), store(s) {} // assigns a VertexRef to a PTRef variable template void STPMapper::setVert(PTRef var, VertexRef vert) { assert(var != PTRef_Undef); assert(logic.isVar(var)); uint32_t idx = Idx(logic.getPterm(var).getId()); if (varToVertRef.size() <= idx) varToVertRef.resize(idx + 1, VertRef_Undef); varToVertRef[idx] = vert; if (vertRefToVar.size() <= vert.x) { vertRefToVar.resize(vert.x + 1, PTRef_Undef); } vertRefToVar[vert.x] = var; } // adds an EdgeRef to the 'edgesOf' lists of its vertices template void STPMapper::registerEdge(EdgeRef edge) { auto &e = store.getEdge(edge); if (edgesContainingVert.size() <= std::max(e.from.x, e.to.x)) edgesContainingVert.resize(std::max(e.from.x, e.to.x) + 1); edgesContainingVert[e.from.x].push_back(edge); edgesContainingVert[e.to.x].push_back(edge); } // assigns an EdgeRef to a PTRef inequality template void STPMapper::mapEdge(PTRef leq, EdgeRef edge) { uint32_t idx = Idx(logic.getPterm(leq).getId()); if (leqToEdgeRef.size() <= idx) leqToEdgeRef.resize(idx + 1, EdgeRef_Undef); if (edgeRefToLeq.size() <= edge.x) { edgeRefToLeq.resize(edge.x + 1, PTRef_Undef); } leqToEdgeRef[idx] = edge; edgeRefToLeq[edge.x] = leq; } template void STPMapper::setAssignment(EdgeRef edge, PtAsgn asgn) { if (edgeRefToAsgn.size() <= edge.x) edgeRefToAsgn.resize(edge.x + 1, PtAsgn_Undef); edgeRefToAsgn[edge.x] = asgn; } template void STPMapper::removeAssignment(EdgeRef edge) { assert(edgeRefToAsgn.size() > edge.x); edgeRefToAsgn[edge.x] = PtAsgn_Undef; } template PtAsgn STPMapper::getAssignment(EdgeRef edge) const { if (edgeRefToAsgn.size() <= edge.x) return PtAsgn_Undef; return edgeRefToAsgn[edge.x]; } // returns the PTRef corresponding to a VertRef template PTRef STPMapper::getPTRef(VertexRef vertex) const { return vertRefToVar.size() <= vertex.x ? PTRef_Undef : vertRefToVar[vertex.x]; } // returns the VertexRef corresponding to a PTRef, if it exists template VertexRef STPMapper::getVertRef(PTRef var) const { // missing variables in inequality are replaced with 'zero' variable if (var == PTRef_Undef) return STPStore::zero(); uint32_t idx = Idx(logic.getPterm(var).getId()); return varToVertRef.size() <= idx ? VertRef_Undef : varToVertRef[idx]; } // returns the EdgeRef corresponding to a PTRef, if it exists template EdgeRef STPMapper::getEdgeRef(PTRef leq) const { uint32_t idx = Idx(logic.getPterm(leq).getId()); return leqToEdgeRef.size() <= idx ? EdgeRef_Undef : leqToEdgeRef[idx]; } // returns a registered EdgeRef corresponding to these parameters, if it exists template EdgeRef STPMapper::getEdgeRef(VertexRef y, VertexRef x, T c) const { if (y == VertRef_Undef || x == VertRef_Undef) return EdgeRef_Undef; // scans through all edges of y to find the one matching our parameters // only used in 'declareAtom' to look for negations, so we don't mind the linear time as much auto &possible = edgesContainingVert[y.x]; for (EdgeRef eRef : possible) { auto &edge = store.getEdge(eRef); if (edge.from == y && edge.to == x && edge.cost == c) return eRef; } return EdgeRef_Undef; } template PTRef STPMapper::getPTRef(EdgeRef edge) const { return edgeRefToLeq.size() > edge.x ? edgeRefToLeq[edge.x] : PTRef_Undef; } template void STPMapper::clear() { edgesContainingVert.clear(); vertRefToVar.clear(); varToVertRef.clear(); leqToEdgeRef.clear(); edgeRefToLeq.clear(); edgeRefToAsgn.clear(); } #endif //OPENSMT_STPMAPPER_IMPLEMENTATIONS_HPPopensmt-2.5.2/src/tsolvers/stpsolver/STPModel.h000066400000000000000000000021671445011647600215340ustar00rootroot00000000000000#ifndef OPENSMT_STPVALMAPPER_HPP #define OPENSMT_STPVALMAPPER_HPP #include "STPGraphManager.h" #include // implementations of template functions #included below class definition // holds the mapping from vertices to their values template class STPModel { private: STPStore &store; EdgeGraph graph; std::unordered_map valMap; // for each vertex, distance from the added starting vertex std::vector vertsInGraph() const; VertexRef addStartingPoint(); void bellmanFord(VertexRef start); void shiftZero(); public: STPModel(STPStore &store, EdgeGraph graph) : store(store), graph(std::move(graph)) {} void createModel(); bool hasValue(VertexRef v) const { return valMap.count(v.x); } T getValue(VertexRef v) const { return Converter::getValue(0) - valMap.at(v.x); } // valid assignment is actually the inverse of distance std::unordered_map getAllValues() const; EdgeGraph const & getGraph() const { return graph; } }; #include "STPModel_implementations.hpp" #endif //OPENSMT_STPVALMAPPER_HPP opensmt-2.5.2/src/tsolvers/stpsolver/STPModel_implementations.hpp000066400000000000000000000053521445011647600253630ustar00rootroot00000000000000#ifndef OPENSMT_STPMODEL_IMPLEMENTATIONS_HPP #define OPENSMT_STPMODEL_IMPLEMENTATIONS_HPP #include "STPModel.h" #include #include // returns a list of all vertices present in graph template std::vector STPModel::vertsInGraph() const { std::vector found; uint32_t n = std::min(graph.incoming.size(), graph.outgoing.size()); uint32_t i = 0; // scans the incoming/outgoing vectors to see if they contain edges for (; i < n; ++i) { if (!graph.incoming[i].empty() || !graph.outgoing[i].empty()) found.push_back(VertexRef{i}); } const auto &rest = (n == graph.incoming.size()) ? graph.outgoing : graph.incoming; for (; i < rest.size(); ++i) { if (!rest[i].empty()) found.push_back(VertexRef{i}); } return found; } // creates a common point from which to start the search, and connects it to all vertices in graph template VertexRef STPModel::addStartingPoint() { VertexRef start = store.createVertex(); for (VertexRef v : vertsInGraph()) { EdgeRef eRef = store.createEdge(start, v, Converter::getValue(0)); graph.addEdge(eRef, start, v); } return start; } template void STPModel::bellmanFord(VertexRef start) { std::unordered_map dist; std::queue open; dist.emplace(start.x, 0); open.push(start); while (!open.empty()) { VertexRef v = open.front(); open.pop(); for (auto eRef : graph.outgoing[v.x]) { const Edge &edge = store.getEdge(eRef); if (!dist.count(edge.to.x) || dist[edge.to.x] > dist[v.x] + edge.cost) { dist[edge.to.x] = dist[v.x] + edge.cost; open.push(edge.to); } } } valMap = std::move(dist); } // shifts 'valMap' values so that valMap[zero] == 0 template void STPModel::shiftZero() { VertexRef zero = STPStore::zero(); if (!valMap.count(zero.x)) return; // if 'zero' isn't present, no need to shift anything T shift = valMap[zero.x]; for (auto &pair : valMap) { pair.second -= shift; } assert(valMap[zero.x] == Converter::getValue(0)); } template void STPModel::createModel() { if (graph.isEmpty()) { return; } VertexRef start = addStartingPoint(); bellmanFord(start); shiftZero(); } template std::unordered_map STPModel::getAllValues() const { std::unordered_map values; for (auto const & entry : valMap) { VertexRef vref{entry.first}; values.insert({vref, this->getValue(vref)}); } return values; } #endif //OPENSMT_STPMODEL_IMPLEMENTATIONS_HPPopensmt-2.5.2/src/tsolvers/stpsolver/STPSolver.h000066400000000000000000000034011445011647600217360ustar00rootroot00000000000000// // Created by Martin Blicha on 12.12.19. // #ifndef OPENSMT_STPSOLVER_H #define OPENSMT_STPSOLVER_H #include #include "TSolver.h" #include "ArithLogic.h" #include "SMTConfig.h" #include "STPMapper.h" #include "STPGraphManager.h" #include "STPModel.h" #include "SafeInt.h" // implementations of template functions #included below class definition template class STPSolver : public TSolver { private: struct ParsedPTRef { // represents inequalities of the form 'y - x <= c' // this corresponds to edges 'y --c--> x' PTRef x; // destination of the edge PTRef y; // source of the edge T c; // cost of the edge }; ArithLogic &logic; STPStore store; STPMapper mapper; STPGraphManager graphMgr; size_t inv_bpoint; // backtrack point where we entered an inconsistent state PtAsgn inv_asgn; std::unique_ptr> model; // mapping of vertices (vars) to valid assignments, if it was computed ParsedPTRef parseRef(PTRef ref) const; public: STPSolver(SMTConfig &c, ArithLogic &l); ~STPSolver() override; void clearSolver() override; bool assertLit(PtAsgn asgn) override; void pushBacktrackPoint() override; void popBacktrackPoint() override; void popBacktrackPoints(unsigned int i) override; TRes check(bool b) override; void fillTheoryFunctions(ModelBuilder & modelBuilder) const override; void computeModel() override; void getConflict(vec &) override; void declareAtom(PTRef tr) override; Logic &getLogic() override; bool isValid(PTRef tr) override; }; #include "STPSolver_implementations.hpp" #endif //OPENSMT_STPSOLVER_H opensmt-2.5.2/src/tsolvers/stpsolver/STPSolver_implementations.hpp000066400000000000000000000207051445011647600255740ustar00rootroot00000000000000// // Created by Martin Blicha on 12.12.19. // #ifndef OPENSMT_STPSOLVER_IMPLEMENTATIONS_HPP #define OPENSMT_STPSOLVER_IMPLEMENTATIONS_HPP #include "STPSolver.h" #include "Converter.h" static SolverDescr descr_stp_solver("STP Solver", "Solver for Simple Temporal Problem (Difference Logic)"); template STPSolver::STPSolver(SMTConfig &c, ArithLogic &l) : TSolver((SolverId) descr_stp_solver, (const char *) descr_stp_solver, c), logic(l), mapper(l, store) // store is initialized before mapper and graph, so these constructors are valid , graphMgr(store, mapper) // similarly, mapper is initialized before graph (per declaration in header) , inv_bpoint(-1), inv_asgn(PtAsgn_Undef) {} template STPSolver::~STPSolver() = default; template typename STPSolver::ParsedPTRef STPSolver::parseRef(PTRef ref) const { // inequalities are in the form (c <= (x + (-1 * y))) // due to how LALogic creates terms, we won't ever encounter <, >, or >= inequalities assert(logic.isLeq(ref)); Pterm &leq = logic.getPterm(ref); assert(logic.isNumConst(leq[0])); auto c = -logic.getNumConst(leq[0]); // -'c': since we want the form (y <= x + c), the constant is negated PTRef rhs = leq[1]; // 'x + (-1 * y)' PTRef x{}, y{}; // variables on the right hand side if (logic.isNumVar(rhs)) { // inequality with a single positive variable x = rhs; y = PTRef_Undef; } else { // right hand side contains at least a negative variable Pterm &rhsPt = logic.getPterm(rhs); PTRef mul{}; // (-1 * y) term if (logic.isPlus(rhs)) { // usual DL inequality with two variables uint8_t ix = logic.isNumVar(rhsPt[0]) ? 0 : 1; uint8_t iy = 1 - ix; x = rhsPt[ix]; mul = rhsPt[iy]; } else { // RHS contains just a negative variable x = PTRef_Undef; mul = rhs; } assert(logic.isTimes(mul)); Pterm &mulPt = logic.getPterm(mul); assert(logic.isNumConst(mulPt[0]) && logic.getNumConst(mulPt[0]) == -1); y = mulPt[1]; assert(logic.isNumVar(y)); } return ParsedPTRef{x, y, Converter::getValue(c)}; } template void STPSolver::declareAtom(PTRef tr) { // This method is used from outside to tell the solver about a possible atom that can later be asserted positively // or negatively // Ignore everything else other than atoms of the form "x - y <= c"; i.e., variable minus variable is less or equal // to some constant if (isInformed(tr)) { return; } setInformed(tr); auto parsed = parseRef(tr); // find out if edge already exists (created as part of a negation) VertexRef x = mapper.getVertRef(parsed.x); VertexRef y = mapper.getVertRef(parsed.y); EdgeRef e = mapper.getEdgeRef(y, x, parsed.c); if (e != EdgeRef_Undef) { mapper.mapEdge(tr, e); // edges created as negations of another atom only need to add PTRef mapping return; } // create new variables in store if (x == VertRef_Undef) { x = store.createVertex(); mapper.setVert(parsed.x, x); } if (y == VertRef_Undef) { y = store.createVertex(); mapper.setVert(parsed.y, y); } // e is definitely EdgeRef_Undef e = store.createEdge(y, x, parsed.c); EdgeRef neg = store.createEdge(x, y, Converter::negate(parsed.c)); store.setNegation(e, neg); mapper.registerEdge(e); mapper.mapEdge(tr, e); mapper.registerEdge(neg); // adding 'neg' to the 'edgesOf' map even without a PTRef to assign to it } template bool STPSolver::assertLit(PtAsgn asgn) { // Actually asserting an atom to the solver - adding a new constraint to the current set // asgn.tr is the atom to add // asgn.sgn is the polarity (positive or negative) if (inv_asgn != PtAsgn_Undef) return false; // no need to check anything if we're inconsistent already EdgeRef e = mapper.getEdgeRef(asgn.tr); assert(e != EdgeRef_Undef); EdgeRef neg = store.getNegation(e); assert(neg != EdgeRef_Undef); EdgeRef set = (asgn.sgn == l_True) ? e : neg; // edge corresponding to 'true' assignment of 'asgn.tr' EdgeRef nset = (set == e) ? neg : e; // 'false' // literal was already assigned or found as a consequence if (graphMgr.isTrue(set)) { return true; } // negation of literal was already assigned or found as a consequence if (graphMgr.isTrue(nset)) { inv_bpoint = backtrack_points.size(); // remember the first time we reached inconsistent state inv_asgn = asgn; has_explanation = true; // marks this TSolver as the cause of inconsistency return false; } // The assignment isn't decided yet, so we set it as true and find all of its consequences graphMgr.setTrue(set, asgn); std::vector deductions = graphMgr.findConsequences(set); // pass all found deductions to TSolver PTRef nleq = mapper.getPTRef(nset); if (nleq != PTRef_Undef) storeDeduction(PtAsgn_reason(nleq, l_False, PTRef_Undef)); for (auto eRef : deductions) { PTRef leq = mapper.getPTRef(eRef); nleq = mapper.getPTRef(store.getNegation(eRef)); if (leq != PTRef_Undef && !hasPolarity(leq)) storeDeduction(PtAsgn_reason(leq, l_True, PTRef_Undef)); if (nleq != PTRef_Undef && !hasPolarity(nleq)) storeDeduction(PtAsgn_reason(nleq, l_False, PTRef_Undef)); } return true; } template TRes STPSolver::check(bool) { // The main method checking the consistency of the current set of constraints // Return SAT if the current set of constraints is satisfiable, UNSAT if unsatisfiable // we check the validity of each assertLit, so this just returns the consistency of current state return inv_asgn == PtAsgn_Undef ? TRes::SAT : TRes::UNSAT; } template void STPSolver::clearSolver() { TSolver::clearSolver(); graphMgr.clear(); mapper.clear(); store.clear(); } template void STPSolver::pushBacktrackPoint() { // Marks a checkpoint for the set of constraints in the solver // Important for backtracking TSolver::pushBacktrackPoint(); backtrack_points.push(graphMgr.getAddedCount()); } template void STPSolver::popBacktrackPoint() { // This is just for compatibility with older architecture // Typically multiple backtrack points are popped together, hence popBacktackPoints is the important method to implement popBacktrackPoints(1); } template void STPSolver::popBacktrackPoints(unsigned int i) { // This method is called after unsatisfiable state is detected // The solver should remove all constraints that were pushed to the solver in the last "i" backtrackpoints if (i == 0) return; assert(backtrack_points.size_() >= i); if (inv_bpoint > backtrack_points.size_() - i) { // if we returned back to a consistent state, we reset inv_bpoint inv_bpoint = 0; inv_asgn = PtAsgn_Undef; has_explanation = false; } backtrack_points.shrink(i - 1); // pop 'i-1' values from the backtrack stack graphMgr.removeAfter(backtrack_points.last()); backtrack_points.shrink(1); // no need to modify mapper or store - the values stored there can't change for (size_t j = 0; j < i; ++j) TSolver::popBacktrackPoint(); // calling TSolver::popBacktrackPoints(i) would result in a stack overflow } template void STPSolver::computeModel() { // a model of an unsatisfiable assignment can't be created if (inv_asgn != PtAsgn_Undef) { model = nullptr; return; } // In case of satisfiability prepare a model witnessing the satisfiability of the current set of constraints model = std::unique_ptr>(new STPModel(store, graphMgr.getGraph())); model->createModel(); } template void STPSolver::getConflict(vec & conflict) { if (inv_asgn == PtAsgn_Undef) return; conflict.push(inv_asgn); EdgeRef e = mapper.getEdgeRef(inv_asgn.tr); if (inv_asgn.sgn == l_True) { e = store.getNegation(e); } assert(graphMgr.isTrue(e)); graphMgr.findExplanation(e, conflict); } template Logic &STPSolver::getLogic() { return logic; } template bool STPSolver::isValid(PTRef tr) { return logic.isLeq(tr); } #endif //OPENSMT_STPSOLVER_IMPLEMENTATIONS_HPPopensmt-2.5.2/src/tsolvers/stpsolver/STPStore.h000066400000000000000000000046141445011647600215670ustar00rootroot00000000000000#ifndef OPENSMT_STPSTORE_H #define OPENSMT_STPSTORE_H #include #include #include #include #include // implementations of template functions #included below class definitions struct VertexRef { uint32_t x; inline bool operator==(VertexRef other) const { return x == other.x; } inline bool operator!=(VertexRef other) const { return x != other.x; } }; struct VertexRefHash { uint32_t operator() (const VertexRef& v) const { return v.x; } }; struct EdgeRef { uint32_t x; inline bool operator==(EdgeRef other) const { return x == other.x; } inline bool operator!=(EdgeRef other) const { return x != other.x; } }; static VertexRef VertRef_Undef = VertexRef{UINT32_MAX}; static EdgeRef EdgeRef_Undef = EdgeRef{UINT32_MAX}; template struct Edge { VertexRef from, to; // vertices of this edge EdgeRef neg; // the logical negation of this edge T cost; // cost of this edge uint32_t setTime; // timestamp of when this was assigned as true (0 if it wasn't assigned) Edge() = default; Edge(Edge &&other) = default; Edge(VertexRef from, VertexRef to, EdgeRef neg, T cost, uint32_t setTime) : from(from), to(to), neg(neg), cost(cost), setTime(setTime) {} Edge &operator=(Edge &&other) = default; // copy semantics are disabled (we want edges to only exist in a store) Edge(const Edge &other) = delete; Edge &operator=(const Edge &other) = delete; }; template class STPStore { private: uint32_t vertices; // number of created vertices (a vertex doesn't actually carry any information) std::vector> edges; // list of all created edges public: STPStore() : vertices(1) {} // the 'zero' vertex is created implicitly VertexRef createVertex(); EdgeRef createEdge(VertexRef from, VertexRef to, T cost); size_t vertexNum() const { return vertices; } size_t edgeNum() const { return edges.size(); } Edge &getEdge(EdgeRef e) { return edges[e.x]; } const Edge &getEdge(EdgeRef e) const { return edges[e.x]; } EdgeRef getNegation(EdgeRef e) { return edges[e.x].neg; } static VertexRef zero() { return VertexRef{0}; } void setNegation(EdgeRef a, EdgeRef b); void clear(); }; #include "STPStore_implementations.hpp" #endif //OPENSMT_STPSTORE_H opensmt-2.5.2/src/tsolvers/stpsolver/STPStore_implementations.hpp000066400000000000000000000013121445011647600254070ustar00rootroot00000000000000#ifndef OPENSMT_STPSTORE_IMPLEMENTATIONS_HPP #define OPENSMT_STPSTORE_IMPLEMENTATIONS_HPP #include "STPStore.h" template VertexRef STPStore::createVertex() { return VertexRef{vertices++}; } template EdgeRef STPStore::createEdge(VertexRef from, VertexRef to, T cost) { uint32_t i = edges.size(); EdgeRef r{i}; edges.emplace_back(from, to, EdgeRef_Undef, cost, 0); return r; } template void STPStore::setNegation(EdgeRef a, EdgeRef b) { edges[a.x].neg = b; edges[b.x].neg = a; } template void STPStore::clear() { edges.clear(); vertices = 1; // clear all vertices except zero } #endif //OPENSMT_STPSTORE_IMPLEMENTATIONS_HPP opensmt-2.5.2/src/tsolvers/stpsolver/SafeInt.h000066400000000000000000000026451445011647600214370ustar00rootroot00000000000000#ifndef OPENSMT_SAFEINT_H #define OPENSMT_SAFEINT_H #include #include struct SafeInt { private: ptrdiff_t val; public: SafeInt() = default; explicit SafeInt(ptrdiff_t val) : val(val) {} ptrdiff_t value() const { return val; } SafeInt operator+(SafeInt other) const { // a+b > MAX ==> MAX-a < b // a+b < MIN ==> MIN-a > b if ((val > 0 && PTRDIFF_MAX - val < other.val) || (val < 0 && PTRDIFF_MIN - val > other.val)) { throw std::overflow_error("Overflow detected during SafeInt addition"); } return SafeInt(val + other.val); } SafeInt &operator-=(SafeInt other) { if ((other.val > 0 && PTRDIFF_MIN + other.val > val) || (other.val < 0 && PTRDIFF_MAX + other.val < val)) { throw std::underflow_error("Underflow detected during SafeInt subtraction"); } val -= other.val; return *this; } bool operator==(SafeInt other) const { return val == other.val; } bool operator>=(SafeInt other) const { return val >= other.val; } bool operator>(SafeInt other) const { return val > other.val; } bool operator<=(SafeInt other) const { return val <= other.val; } SafeInt operator-(SafeInt other) const { SafeInt res = *this; res -= other; return res; } SafeInt operator-() const { return SafeInt(-val); } }; #endif //OPENSMT_SAFEINT_H opensmt-2.5.2/test/000077500000000000000000000000001445011647600141745ustar00rootroot00000000000000opensmt-2.5.2/test/._bvnor.smt2000066400000000000000000000003011445011647600163400ustar00rootroot00000000000000Mac OS X  2ÁATTRd÷Á˜)˜)com.apple.quarantineq/0000;5010efb4;Safari;|com.apple.Safariopensmt-2.5.2/test/CMakeLists.txt000066400000000000000000000005661445011647600167430ustar00rootroot00000000000000include(FetchContent) FetchContent_Declare( googletest GIT_REPOSITORY https://github.com/google/googletest.git GIT_TAG release-1.12.1 ) FetchContent_GetProperties(googletest) if(NOT googletest_POPULATED) FetchContent_Populate(googletest) add_subdirectory(${googletest_SOURCE_DIR} ${googletest_BINARY_DIR} EXCLUDE_FROM_ALL) endif() add_subdirectory(unit) opensmt-2.5.2/test/Makefile.am000066400000000000000000000004761445011647600162370ustar00rootroot00000000000000 BUILT_SOURCES = smt2newparser.h AM_YFLAGS = -d --name-prefix=smt2new AM_LFLAGS = -olex.yy.c -Psmt2new bin_PROGRAMS = parsetest parsetest_SOURCES = parsetest.cc smt2newcontext.cc LDADD = libsmt2newparser.la noinst_LTLIBRARIES = libsmt2newparser.la libsmt2newparser_la_SOURCES = smt2newparser.yy smt2newlexer.ll opensmt-2.5.2/test/NEQ004_size4.smt2000066400000000000000000000405011445011647600167700ustar00rootroot00000000000000(set-logic QF_UF) (set-info :source | CADE ATP System competition. See http://www.cs.miami.edu/~tptp/CASC for more information. This benchmark was obtained by trying to find a finite model of a first-order formula (Albert Oliveras). |) (set-info :smt-lib-version 2.0) (set-info :category "crafted") (declare-sort U 0) (declare-fun c14 () U) (declare-fun c12 () U) (declare-fun p4 (U U) Bool) (declare-fun c13 () U) (declare-fun p3 (U U) Bool) (declare-fun c15 () U) (declare-fun c17 () U) (declare-fun p6 (U U) Bool) (declare-fun p2 (U U) Bool) (declare-fun p1 (U U) Bool) (declare-fun c11 () U) (declare-fun f5 (U U) U) (declare-fun c10 () U) (declare-fun p8 (U) Bool) (declare-fun c16 () U) (declare-fun p9 (U U) Bool) (declare-fun p7 (U U) Bool) (declare-fun c_0 () U) (declare-fun c_1 () U) (declare-fun c_2 () U) (declare-fun c_3 () U) (assert (let ((?v_52 (= c_0 c_0))) (let ((?v_16 (not ?v_52)) (?v_32 (p3 c_0 c_0)) (?v_55 (= c_0 c_1))) (let ((?v_17 (not ?v_55)) (?v_33 (p3 c_0 c_1)) (?v_58 (= c_0 c_2))) (let ((?v_18 (not ?v_58)) (?v_34 (p3 c_0 c_2)) (?v_61 (= c_0 c_3))) (let ((?v_19 (not ?v_61)) (?v_35 (p3 c_0 c_3)) (?v_64 (= c_1 c_0))) (let ((?v_20 (not ?v_64)) (?v_36 (p3 c_1 c_0)) (?v_67 (= c_1 c_1))) (let ((?v_21 (not ?v_67)) (?v_37 (p3 c_1 c_1)) (?v_70 (= c_1 c_2))) (let ((?v_22 (not ?v_70)) (?v_38 (p3 c_1 c_2)) (?v_73 (= c_1 c_3))) (let ((?v_23 (not ?v_73)) (?v_39 (p3 c_1 c_3)) (?v_76 (= c_2 c_0))) (let ((?v_24 (not ?v_76)) (?v_40 (p3 c_2 c_0)) (?v_79 (= c_2 c_1))) (let ((?v_25 (not ?v_79)) (?v_41 (p3 c_2 c_1)) (?v_82 (= c_2 c_2))) (let ((?v_26 (not ?v_82)) (?v_42 (p3 c_2 c_2)) (?v_85 (= c_2 c_3))) (let ((?v_27 (not ?v_85)) (?v_43 (p3 c_2 c_3)) (?v_88 (= c_3 c_0))) (let ((?v_28 (not ?v_88)) (?v_44 (p3 c_3 c_0)) (?v_91 (= c_3 c_1))) (let ((?v_29 (not ?v_91)) (?v_45 (p3 c_3 c_1)) (?v_94 (= c_3 c_2))) (let ((?v_30 (not ?v_94)) (?v_46 (p3 c_3 c_2)) (?v_97 (= c_3 c_3))) (let ((?v_31 (not ?v_97)) (?v_47 (p3 c_3 c_3)) (?v_53 (p4 c_0 c_0))) (let ((?v_0 (not ?v_53)) (?v_56 (p4 c_0 c_1))) (let ((?v_2 (not ?v_56)) (?v_65 (p4 c_1 c_0))) (let ((?v_1 (not ?v_65)) (?v_59 (p4 c_0 c_2))) (let ((?v_5 (not ?v_59)) (?v_77 (p4 c_2 c_0))) (let ((?v_4 (not ?v_77)) (?v_62 (p4 c_0 c_3))) (let ((?v_10 (not ?v_62)) (?v_89 (p4 c_3 c_0))) (let ((?v_9 (not ?v_89)) (?v_68 (p4 c_1 c_1))) (let ((?v_3 (not ?v_68)) (?v_71 (p4 c_1 c_2))) (let ((?v_7 (not ?v_71)) (?v_80 (p4 c_2 c_1))) (let ((?v_6 (not ?v_80)) (?v_74 (p4 c_1 c_3))) (let ((?v_12 (not ?v_74)) (?v_92 (p4 c_3 c_1))) (let ((?v_11 (not ?v_92)) (?v_83 (p4 c_2 c_2))) (let ((?v_8 (not ?v_83)) (?v_86 (p4 c_2 c_3))) (let ((?v_14 (not ?v_86)) (?v_95 (p4 c_3 c_2))) (let ((?v_13 (not ?v_95)) (?v_98 (p4 c_3 c_3))) (let ((?v_15 (not ?v_98)) (?v_54 (p2 c_0 c_0)) (?v_66 (p2 c_1 c_0)) (?v_78 (p2 c_2 c_0)) (?v_90 (p2 c_3 c_0)) (?v_57 (p2 c_0 c_1)) (?v_69 (p2 c_1 c_1)) (?v_81 (p2 c_2 c_1)) (?v_93 (p2 c_3 c_1)) (?v_60 (p2 c_0 c_2)) (?v_72 (p2 c_1 c_2)) (?v_84 (p2 c_2 c_2)) (?v_96 (p2 c_3 c_2)) (?v_63 (p2 c_0 c_3)) (?v_75 (p2 c_1 c_3)) (?v_87 (p2 c_2 c_3)) (?v_99 (p2 c_3 c_3)) (?v_100 (p1 c_0 c_0)) (?v_101 (p1 c_0 c_1)) (?v_102 (p1 c_0 c_2)) (?v_103 (p1 c_0 c_3)) (?v_104 (p1 c_1 c_0)) (?v_105 (p1 c_1 c_1)) (?v_106 (p1 c_1 c_2)) (?v_107 (p1 c_1 c_3)) (?v_108 (p1 c_2 c_0)) (?v_109 (p1 c_2 c_1)) (?v_110 (p1 c_2 c_2)) (?v_111 (p1 c_2 c_3)) (?v_112 (p1 c_3 c_0)) (?v_113 (p1 c_3 c_1)) (?v_114 (p1 c_3 c_2)) (?v_115 (p1 c_3 c_3)) (?v_117 (f5 c_0 c_0)) (?v_48 (not (p8 c_0))) (?v_116 (p6 c_0 c_0)) (?v_119 (f5 c_0 c_1)) (?v_118 (p6 c_0 c_1)) (?v_121 (f5 c_0 c_2)) (?v_120 (p6 c_0 c_2)) (?v_123 (f5 c_0 c_3)) (?v_122 (p6 c_0 c_3)) (?v_125 (f5 c_1 c_0)) (?v_49 (not (p8 c_1))) (?v_124 (p6 c_1 c_0)) (?v_127 (f5 c_1 c_1)) (?v_126 (p6 c_1 c_1)) (?v_129 (f5 c_1 c_2)) (?v_128 (p6 c_1 c_2)) (?v_131 (f5 c_1 c_3)) (?v_130 (p6 c_1 c_3)) (?v_133 (f5 c_2 c_0)) (?v_50 (not (p8 c_2))) (?v_132 (p6 c_2 c_0)) (?v_135 (f5 c_2 c_1)) (?v_134 (p6 c_2 c_1)) (?v_137 (f5 c_2 c_2)) (?v_136 (p6 c_2 c_2)) (?v_139 (f5 c_2 c_3)) (?v_138 (p6 c_2 c_3)) (?v_141 (f5 c_3 c_0)) (?v_51 (not (p8 c_3))) (?v_140 (p6 c_3 c_0)) (?v_143 (f5 c_3 c_1)) (?v_142 (p6 c_3 c_1)) (?v_145 (f5 c_3 c_2)) (?v_144 (p6 c_3 c_2)) (?v_147 (f5 c_3 c_3)) (?v_146 (p6 c_3 c_3))) (let ((?v_148 (not ?v_54)) (?v_152 (not ?v_66)) (?v_156 (not ?v_78)) (?v_160 (not ?v_90)) (?v_149 (not ?v_57)) (?v_153 (not ?v_69)) (?v_157 (not ?v_81)) (?v_161 (not ?v_93)) (?v_150 (not ?v_60)) (?v_154 (not ?v_72)) (?v_158 (not ?v_84)) (?v_162 (not ?v_96)) (?v_151 (not ?v_63)) (?v_155 (not ?v_75)) (?v_159 (not ?v_87)) (?v_163 (not ?v_99)) (?v_164 (p9 c_0 c_0))) (let ((?v_212 (not ?v_164)) (?v_196 (p7 c_0 c_0))) (let ((?v_165 (not ?v_196)) (?v_166 (p9 c_0 c_1))) (let ((?v_213 (not ?v_166)) (?v_197 (p7 c_0 c_1))) (let ((?v_167 (not ?v_197)) (?v_168 (p9 c_0 c_2))) (let ((?v_214 (not ?v_168)) (?v_198 (p7 c_0 c_2))) (let ((?v_169 (not ?v_198)) (?v_170 (p9 c_0 c_3))) (let ((?v_215 (not ?v_170)) (?v_199 (p7 c_0 c_3))) (let ((?v_171 (not ?v_199)) (?v_172 (p9 c_1 c_0))) (let ((?v_216 (not ?v_172)) (?v_200 (p7 c_1 c_0))) (let ((?v_173 (not ?v_200)) (?v_174 (p9 c_1 c_1))) (let ((?v_217 (not ?v_174)) (?v_201 (p7 c_1 c_1))) (let ((?v_175 (not ?v_201)) (?v_176 (p9 c_1 c_2))) (let ((?v_218 (not ?v_176)) (?v_202 (p7 c_1 c_2))) (let ((?v_177 (not ?v_202)) (?v_178 (p9 c_1 c_3))) (let ((?v_219 (not ?v_178)) (?v_203 (p7 c_1 c_3))) (let ((?v_179 (not ?v_203)) (?v_180 (p9 c_2 c_0))) (let ((?v_220 (not ?v_180)) (?v_204 (p7 c_2 c_0))) (let ((?v_181 (not ?v_204)) (?v_182 (p9 c_2 c_1))) (let ((?v_221 (not ?v_182)) (?v_205 (p7 c_2 c_1))) (let ((?v_183 (not ?v_205)) (?v_184 (p9 c_2 c_2))) (let ((?v_222 (not ?v_184)) (?v_206 (p7 c_2 c_2))) (let ((?v_185 (not ?v_206)) (?v_186 (p9 c_2 c_3))) (let ((?v_223 (not ?v_186)) (?v_207 (p7 c_2 c_3))) (let ((?v_187 (not ?v_207)) (?v_188 (p9 c_3 c_0))) (let ((?v_224 (not ?v_188)) (?v_208 (p7 c_3 c_0))) (let ((?v_189 (not ?v_208)) (?v_190 (p9 c_3 c_1))) (let ((?v_225 (not ?v_190)) (?v_209 (p7 c_3 c_1))) (let ((?v_191 (not ?v_209)) (?v_192 (p9 c_3 c_2))) (let ((?v_226 (not ?v_192)) (?v_210 (p7 c_3 c_2))) (let ((?v_193 (not ?v_210)) (?v_194 (p9 c_3 c_3))) (let ((?v_227 (not ?v_194)) (?v_211 (p7 c_3 c_3))) (let ((?v_195 (not ?v_211))) (and (distinct c_0 c_1 c_2 c_3) (p4 c14 c12) (p4 c14 c13) (or ?v_16 ?v_32) (or ?v_17 ?v_33) (or ?v_18 ?v_34) (or ?v_19 ?v_35) (or ?v_20 ?v_36) (or ?v_21 ?v_37) (or ?v_22 ?v_38) (or ?v_23 ?v_39) (or ?v_24 ?v_40) (or ?v_25 ?v_41) (or ?v_26 ?v_42) (or ?v_27 ?v_43) (or ?v_28 ?v_44) (or ?v_29 ?v_45) (or ?v_30 ?v_46) (or ?v_31 ?v_47) (or ?v_0 ?v_0) (or ?v_2 ?v_1) (or ?v_5 ?v_4) (or ?v_10 ?v_9) (or ?v_1 ?v_2) (or ?v_3 ?v_3) (or ?v_7 ?v_6) (or ?v_12 ?v_11) (or ?v_4 ?v_5) (or ?v_6 ?v_7) (or ?v_8 ?v_8) (or ?v_14 ?v_13) (or ?v_9 ?v_10) (or ?v_11 ?v_12) (or ?v_13 ?v_14) (or ?v_15 ?v_15) (not (p6 c15 c17)) (or ?v_0 ?v_54) (or ?v_2 ?v_66) (or ?v_5 ?v_78) (or ?v_10 ?v_90) (or ?v_1 ?v_57) (or ?v_3 ?v_69) (or ?v_7 ?v_81) (or ?v_12 ?v_93) (or ?v_4 ?v_60) (or ?v_6 ?v_72) (or ?v_8 ?v_84) (or ?v_14 ?v_96) (or ?v_9 ?v_63) (or ?v_11 ?v_75) (or ?v_13 ?v_87) (or ?v_15 ?v_99) (or ?v_100 ?v_16) (or ?v_101 ?v_17) (or ?v_102 ?v_18) (or ?v_103 ?v_19) (or ?v_104 ?v_20) (or ?v_105 ?v_21) (or ?v_106 ?v_22) (or ?v_107 ?v_23) (or ?v_108 ?v_24) (or ?v_109 ?v_25) (or ?v_110 ?v_26) (or ?v_111 ?v_27) (or ?v_112 ?v_28) (or ?v_113 ?v_29) (or ?v_114 ?v_30) (or ?v_115 ?v_31) (p4 c13 c11) (or ?v_0 ?v_32) (or ?v_2 ?v_33) (or ?v_5 ?v_34) (or ?v_10 ?v_35) (or ?v_1 ?v_36) (or ?v_3 ?v_37) (or ?v_7 ?v_38) (or ?v_12 ?v_39) (or ?v_4 ?v_40) (or ?v_6 ?v_41) (or ?v_8 ?v_42) (or ?v_14 ?v_43) (or ?v_9 ?v_44) (or ?v_11 ?v_45) (or ?v_13 ?v_46) (or ?v_15 ?v_47) (or (= ?v_117 c10) ?v_48 (not ?v_116)) (or (= ?v_119 c10) ?v_48 (not ?v_118)) (or (= ?v_121 c10) ?v_48 (not ?v_120)) (or (= ?v_123 c10) ?v_48 (not ?v_122)) (or (= ?v_125 c10) ?v_49 (not ?v_124)) (or (= ?v_127 c10) ?v_49 (not ?v_126)) (or (= ?v_129 c10) ?v_49 (not ?v_128)) (or (= ?v_131 c10) ?v_49 (not ?v_130)) (or (= ?v_133 c10) ?v_50 (not ?v_132)) (or (= ?v_135 c10) ?v_50 (not ?v_134)) (or (= ?v_137 c10) ?v_50 (not ?v_136)) (or (= ?v_139 c10) ?v_50 (not ?v_138)) (or (= ?v_141 c10) ?v_51 (not ?v_140)) (or (= ?v_143 c10) ?v_51 (not ?v_142)) (or (= ?v_145 c10) ?v_51 (not ?v_144)) (or (= ?v_147 c10) ?v_51 (not ?v_146)) (p6 c15 c16) (p8 c15) (not (p4 (f5 c15 c17) (f5 c15 c16))) (or ?v_52 ?v_53 ?v_54) (or ?v_55 ?v_56 ?v_57) (or ?v_58 ?v_59 ?v_60) (or ?v_61 ?v_62 ?v_63) (or ?v_64 ?v_65 ?v_66) (or ?v_67 ?v_68 ?v_69) (or ?v_70 ?v_71 ?v_72) (or ?v_73 ?v_74 ?v_75) (or ?v_76 ?v_77 ?v_78) (or ?v_79 ?v_80 ?v_81) (or ?v_82 ?v_83 ?v_84) (or ?v_85 ?v_86 ?v_87) (or ?v_88 ?v_89 ?v_90) (or ?v_91 ?v_92 ?v_93) (or ?v_94 ?v_95 ?v_96) (or ?v_97 ?v_98 ?v_99) (p4 c12 c11) (or ?v_52 (not ?v_100) ?v_54) (or ?v_55 (not ?v_101) ?v_57) (or ?v_58 (not ?v_102) ?v_60) (or ?v_61 (not ?v_103) ?v_63) (or ?v_64 (not ?v_104) ?v_66) (or ?v_67 (not ?v_105) ?v_69) (or ?v_70 (not ?v_106) ?v_72) (or ?v_73 (not ?v_107) ?v_75) (or ?v_76 (not ?v_108) ?v_78) (or ?v_79 (not ?v_109) ?v_81) (or ?v_82 (not ?v_110) ?v_84) (or ?v_85 (not ?v_111) ?v_87) (or ?v_88 (not ?v_112) ?v_90) (or ?v_91 (not ?v_113) ?v_93) (or ?v_94 (not ?v_114) ?v_96) (or ?v_97 (not ?v_115) ?v_99) (or ?v_53 ?v_148) (or ?v_56 ?v_152) (or ?v_59 ?v_156) (or ?v_62 ?v_160) (or ?v_65 ?v_149) (or ?v_68 ?v_153) (or ?v_71 ?v_157) (or ?v_74 ?v_161) (or ?v_77 ?v_150) (or ?v_80 ?v_154) (or ?v_83 ?v_158) (or ?v_86 ?v_162) (or ?v_89 ?v_151) (or ?v_92 ?v_155) (or ?v_95 ?v_159) (or ?v_98 ?v_163) (or ?v_52 ?v_53 (not ?v_32)) (or ?v_55 ?v_56 (not ?v_33)) (or ?v_58 ?v_59 (not ?v_34)) (or ?v_61 ?v_62 (not ?v_35)) (or ?v_64 ?v_65 (not ?v_36)) (or ?v_67 ?v_68 (not ?v_37)) (or ?v_70 ?v_71 (not ?v_38)) (or ?v_73 ?v_74 (not ?v_39)) (or ?v_76 ?v_77 (not ?v_40)) (or ?v_79 ?v_80 (not ?v_41)) (or ?v_82 ?v_83 (not ?v_42)) (or ?v_85 ?v_86 (not ?v_43)) (or ?v_88 ?v_89 (not ?v_44)) (or ?v_91 ?v_92 (not ?v_45)) (or ?v_94 ?v_95 (not ?v_46)) (or ?v_97 ?v_98 (not ?v_47)) (p4 c11 c10) (or ?v_0 ?v_53 ?v_0) (or ?v_0 ?v_56 ?v_2) (or ?v_0 ?v_59 ?v_5) (or ?v_0 ?v_62 ?v_10) (or ?v_2 ?v_53 ?v_1) (or ?v_2 ?v_56 ?v_3) (or ?v_2 ?v_59 ?v_7) (or ?v_2 ?v_62 ?v_12) (or ?v_5 ?v_53 ?v_4) (or ?v_5 ?v_56 ?v_6) (or ?v_5 ?v_59 ?v_8) (or ?v_5 ?v_62 ?v_14) (or ?v_10 ?v_53 ?v_9) (or ?v_10 ?v_56 ?v_11) (or ?v_10 ?v_59 ?v_13) (or ?v_10 ?v_62 ?v_15) (or ?v_1 ?v_65 ?v_0) (or ?v_1 ?v_68 ?v_2) (or ?v_1 ?v_71 ?v_5) (or ?v_1 ?v_74 ?v_10) (or ?v_3 ?v_65 ?v_1) (or ?v_3 ?v_68 ?v_3) (or ?v_3 ?v_71 ?v_7) (or ?v_3 ?v_74 ?v_12) (or ?v_7 ?v_65 ?v_4) (or ?v_7 ?v_68 ?v_6) (or ?v_7 ?v_71 ?v_8) (or ?v_7 ?v_74 ?v_14) (or ?v_12 ?v_65 ?v_9) (or ?v_12 ?v_68 ?v_11) (or ?v_12 ?v_71 ?v_13) (or ?v_12 ?v_74 ?v_15) (or ?v_4 ?v_77 ?v_0) (or ?v_4 ?v_80 ?v_2) (or ?v_4 ?v_83 ?v_5) (or ?v_4 ?v_86 ?v_10) (or ?v_6 ?v_77 ?v_1) (or ?v_6 ?v_80 ?v_3) (or ?v_6 ?v_83 ?v_7) (or ?v_6 ?v_86 ?v_12) (or ?v_8 ?v_77 ?v_4) (or ?v_8 ?v_80 ?v_6) (or ?v_8 ?v_83 ?v_8) (or ?v_8 ?v_86 ?v_14) (or ?v_14 ?v_77 ?v_9) (or ?v_14 ?v_80 ?v_11) (or ?v_14 ?v_83 ?v_13) (or ?v_14 ?v_86 ?v_15) (or ?v_9 ?v_89 ?v_0) (or ?v_9 ?v_92 ?v_2) (or ?v_9 ?v_95 ?v_5) (or ?v_9 ?v_98 ?v_10) (or ?v_11 ?v_89 ?v_1) (or ?v_11 ?v_92 ?v_3) (or ?v_11 ?v_95 ?v_7) (or ?v_11 ?v_98 ?v_12) (or ?v_13 ?v_89 ?v_4) (or ?v_13 ?v_92 ?v_6) (or ?v_13 ?v_95 ?v_8) (or ?v_13 ?v_98 ?v_14) (or ?v_15 ?v_89 ?v_9) (or ?v_15 ?v_92 ?v_11) (or ?v_15 ?v_95 ?v_13) (or ?v_15 ?v_98 ?v_15) (or ?v_212 ?v_116 ?v_48 ?v_165 (= ?v_117 c11)) (or ?v_213 ?v_118 ?v_48 ?v_167 (= ?v_119 c11)) (or ?v_214 ?v_120 ?v_48 ?v_169 (= ?v_121 c11)) (or ?v_215 ?v_122 ?v_48 ?v_171 (= ?v_123 c11)) (or ?v_216 ?v_124 ?v_49 ?v_173 (= ?v_125 c11)) (or ?v_217 ?v_126 ?v_49 ?v_175 (= ?v_127 c11)) (or ?v_218 ?v_128 ?v_49 ?v_177 (= ?v_129 c11)) (or ?v_219 ?v_130 ?v_49 ?v_179 (= ?v_131 c11)) (or ?v_220 ?v_132 ?v_50 ?v_181 (= ?v_133 c11)) (or ?v_221 ?v_134 ?v_50 ?v_183 (= ?v_135 c11)) (or ?v_222 ?v_136 ?v_50 ?v_185 (= ?v_137 c11)) (or ?v_223 ?v_138 ?v_50 ?v_187 (= ?v_139 c11)) (or ?v_224 ?v_140 ?v_51 ?v_189 (= ?v_141 c11)) (or ?v_225 ?v_142 ?v_51 ?v_191 (= ?v_143 c11)) (or ?v_226 ?v_144 ?v_51 ?v_193 (= ?v_145 c11)) (or ?v_227 ?v_146 ?v_51 ?v_195 (= ?v_147 c11)) (or ?v_148 ?v_100) (or ?v_149 ?v_101) (or ?v_150 ?v_102) (or ?v_151 ?v_103) (or ?v_152 ?v_104) (or ?v_153 ?v_105) (or ?v_154 ?v_106) (or ?v_155 ?v_107) (or ?v_156 ?v_108) (or ?v_157 ?v_109) (or ?v_158 ?v_110) (or ?v_159 ?v_111) (or ?v_160 ?v_112) (or ?v_161 ?v_113) (or ?v_162 ?v_114) (or ?v_163 ?v_115) (or ?v_116 (= ?v_117 c13) ?v_164 ?v_48 ?v_165) (or ?v_118 (= ?v_119 c13) ?v_166 ?v_48 ?v_167) (or ?v_120 (= ?v_121 c13) ?v_168 ?v_48 ?v_169) (or ?v_122 (= ?v_123 c13) ?v_170 ?v_48 ?v_171) (or ?v_124 (= ?v_125 c13) ?v_172 ?v_49 ?v_173) (or ?v_126 (= ?v_127 c13) ?v_174 ?v_49 ?v_175) (or ?v_128 (= ?v_129 c13) ?v_176 ?v_49 ?v_177) (or ?v_130 (= ?v_131 c13) ?v_178 ?v_49 ?v_179) (or ?v_132 (= ?v_133 c13) ?v_180 ?v_50 ?v_181) (or ?v_134 (= ?v_135 c13) ?v_182 ?v_50 ?v_183) (or ?v_136 (= ?v_137 c13) ?v_184 ?v_50 ?v_185) (or ?v_138 (= ?v_139 c13) ?v_186 ?v_50 ?v_187) (or ?v_140 (= ?v_141 c13) ?v_188 ?v_51 ?v_189) (or ?v_142 (= ?v_143 c13) ?v_190 ?v_51 ?v_191) (or ?v_144 (= ?v_145 c13) ?v_192 ?v_51 ?v_193) (or ?v_146 (= ?v_147 c13) ?v_194 ?v_51 ?v_195) (or (= ?v_117 c14) ?v_196 ?v_116 ?v_48 ?v_164) (or (= ?v_119 c14) ?v_197 ?v_118 ?v_48 ?v_166) (or (= ?v_121 c14) ?v_198 ?v_120 ?v_48 ?v_168) (or (= ?v_123 c14) ?v_199 ?v_122 ?v_48 ?v_170) (or (= ?v_125 c14) ?v_200 ?v_124 ?v_49 ?v_172) (or (= ?v_127 c14) ?v_201 ?v_126 ?v_49 ?v_174) (or (= ?v_129 c14) ?v_202 ?v_128 ?v_49 ?v_176) (or (= ?v_131 c14) ?v_203 ?v_130 ?v_49 ?v_178) (or (= ?v_133 c14) ?v_204 ?v_132 ?v_50 ?v_180) (or (= ?v_135 c14) ?v_205 ?v_134 ?v_50 ?v_182) (or (= ?v_137 c14) ?v_206 ?v_136 ?v_50 ?v_184) (or (= ?v_139 c14) ?v_207 ?v_138 ?v_50 ?v_186) (or (= ?v_141 c14) ?v_208 ?v_140 ?v_51 ?v_188) (or (= ?v_143 c14) ?v_209 ?v_142 ?v_51 ?v_190) (or (= ?v_145 c14) ?v_210 ?v_144 ?v_51 ?v_192) (or (= ?v_147 c14) ?v_211 ?v_146 ?v_51 ?v_194) (or ?v_116 ?v_212 ?v_196 (= ?v_117 c12) ?v_48) (or ?v_118 ?v_213 ?v_197 (= ?v_119 c12) ?v_48) (or ?v_120 ?v_214 ?v_198 (= ?v_121 c12) ?v_48) (or ?v_122 ?v_215 ?v_199 (= ?v_123 c12) ?v_48) (or ?v_124 ?v_216 ?v_200 (= ?v_125 c12) ?v_49) (or ?v_126 ?v_217 ?v_201 (= ?v_127 c12) ?v_49) (or ?v_128 ?v_218 ?v_202 (= ?v_129 c12) ?v_49) (or ?v_130 ?v_219 ?v_203 (= ?v_131 c12) ?v_49) (or ?v_132 ?v_220 ?v_204 (= ?v_133 c12) ?v_50) (or ?v_134 ?v_221 ?v_205 (= ?v_135 c12) ?v_50) (or ?v_136 ?v_222 ?v_206 (= ?v_137 c12) ?v_50) (or ?v_138 ?v_223 ?v_207 (= ?v_139 c12) ?v_50) (or ?v_140 ?v_224 ?v_208 (= ?v_141 c12) ?v_51) (or ?v_142 ?v_225 ?v_209 (= ?v_143 c12) ?v_51) (or ?v_144 ?v_226 ?v_210 (= ?v_145 c12) ?v_51) (or ?v_146 ?v_227 ?v_211 (= ?v_147 c12) ?v_51) (or (= ?v_117 c_0) (= ?v_117 c_1) (= ?v_117 c_2) (= ?v_117 c_3)) (or (= ?v_119 c_0) (= ?v_119 c_1) (= ?v_119 c_2) (= ?v_119 c_3)) (or (= ?v_121 c_0) (= ?v_121 c_1) (= ?v_121 c_2) (= ?v_121 c_3)) (or (= ?v_123 c_0) (= ?v_123 c_1) (= ?v_123 c_2) (= ?v_123 c_3)) (or (= ?v_125 c_0) (= ?v_125 c_1) (= ?v_125 c_2) (= ?v_125 c_3)) (or (= ?v_127 c_0) (= ?v_127 c_1) (= ?v_127 c_2) (= ?v_127 c_3)) (or (= ?v_129 c_0) (= ?v_129 c_1) (= ?v_129 c_2) (= ?v_129 c_3)) (or (= ?v_131 c_0) (= ?v_131 c_1) (= ?v_131 c_2) (= ?v_131 c_3)) (or (= ?v_133 c_0) (= ?v_133 c_1) (= ?v_133 c_2) (= ?v_133 c_3)) (or (= ?v_135 c_0) (= ?v_135 c_1) (= ?v_135 c_2) (= ?v_135 c_3)) (or (= ?v_137 c_0) (= ?v_137 c_1) (= ?v_137 c_2) (= ?v_137 c_3)) (or (= ?v_139 c_0) (= ?v_139 c_1) (= ?v_139 c_2) (= ?v_139 c_3)) (or (= ?v_141 c_0) (= ?v_141 c_1) (= ?v_141 c_2) (= ?v_141 c_3)) (or (= ?v_143 c_0) (= ?v_143 c_1) (= ?v_143 c_2) (= ?v_143 c_3)) (or (= ?v_145 c_0) (= ?v_145 c_1) (= ?v_145 c_2) (= ?v_145 c_3)) (or (= ?v_147 c_0) (= ?v_147 c_1) (= ?v_147 c_2) (= ?v_147 c_3)) (or (= c14 c_0) (= c14 c_1) (= c14 c_2) (= c14 c_3)) (or (= c12 c_0) (= c12 c_1) (= c12 c_2) (= c12 c_3)) (or (= c13 c_0) (= c13 c_1) (= c13 c_2) (= c13 c_3)) (or (= c15 c_0) (= c15 c_1) (= c15 c_2) (= c15 c_3)) (or (= c17 c_0) (= c17 c_1) (= c17 c_2) (= c17 c_3)) (or (= c11 c_0) (= c11 c_1) (= c11 c_2) (= c11 c_3)) (or (= c10 c_0) (= c10 c_1) (= c10 c_2) (= c10 c_3)) (or (= c16 c_0) (= c16 c_1) (= c16 c_2) (= c16 c_3)) ) ))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) (check-sat) (exit) opensmt-2.5.2/test/QF_UF-2018-Goel-hwbench-QF_UF_mpeg_ab_cti_max_simplified_0.smt2000066400000000000000000000006051445011647600272740ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort u1 0) (declare-sort u2 0) (declare-fun Concat (Bool u1) u2) (declare-fun y () Bool) (declare-fun mod () Bool) (declare-fun n1 () u1) (declare-fun n2 () u2) (declare-fun w2 () u2) (declare-fun w5 () u2) (assert (= w5 (Concat false n1))) (assert (= n2 w5)) (assert (= w2 (Concat mod n1))) (assert (= mod (not y))) (assert (not (= n2 w2))) (check-sat) (exit) opensmt-2.5.2/test/SEQ_SEQ020_size3_delta_2.smt2000066400000000000000000000005661445011647600211030ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort U 0) (declare-fun p3 (U) Bool) (declare-fun f11 (U) U) (declare-fun f5 (U) U) (declare-fun c8 () U) (declare-fun c_0 () U) (declare-fun c_1 () U) (declare-fun c_2 () U) (assert (and (not (p3 (f11 c_1))) (p3 (f11 (f11 c_1))) (or (= (f11 (f11 c_1)) c_0) (= (f11 (f11 c_1)) (f11 c_1))) (or (= c_1 c8) (= (f11 c_1) c8)) )) (check-sat) (exit) opensmt-2.5.2/test/Snode.h000066400000000000000000000000661445011647600154170ustar00rootroot00000000000000#include #include #include opensmt-2.5.2/test/bar.smt2000066400000000000000000000003101445011647600155410ustar00rootroot00000000000000(set-logic QF_BV) (declare-fun v0 () (_ BitVec 4)) (declare-fun v1 () (_ BitVec 4)) (assert (or (= (_ extract 1 1 v0) (_ extract 1 1 v1)) (not (= (_ extract 1 1 v0) (_ extract 1 1 v1))))) (check-sat) opensmt-2.5.2/test/bvnor.smt2000066400000000000000000000005131445011647600161300ustar00rootroot00000000000000(set-logic QF_BV) (set-info :source | Constructed by Trevor Hansen to test bvnor nesting. |) (set-info :smt-lib-version 2.0) (set-info :category "check") (set-info :status unsat) (declare-fun v0 () (_ BitVec 1)) (assert (= (_ bv0 1) ((_ extract 1 1) (bvnor (_ bv0 2) (bvnor (_ bv2 2) (concat (_ bv0 1) v0)))))) (check-sat) (exit) opensmt-2.5.2/test/configure.ac000066400000000000000000000153171445011647600164710ustar00rootroot00000000000000AC_PREREQ(2.59) AC_INIT([OpenSMT 1.0.1], [(unstable)], [roberto.bruttomesso@gmail.com]) AC_CONFIG_AUX_DIR(autotools) AM_INIT_AUTOMAKE AC_CONFIG_MACRO_DIR([m4]) AC_PROG_CC AC_PROG_CXX AC_PROG_YACC AM_PROG_LEX AC_PROG_INSTALL AC_PROG_LN_S AC_PROG_MAKE_SET LT_INIT AC_DISABLE_SHARED AC_ARG_ENABLE(library, AC_HELP_STRING([--enable-library], [produces OpenSMT libraries (default=no)]), want_library="yes", want_library="no") AM_CONDITIONAL([WANT_LIBRARY], [test "$want_library" = "yes"]) # # Statically linked version # AC_ARG_ENABLE(statically, AC_HELP_STRING([--enable-statically], [enable statically linked libraries (--static) (default=no)]), enablestatically=$enableval, enablestatically="no") if test $enablestatically = "yes" ; then config_statically="--static" elif test $enablestatically = "no" ; then config_statically="" else config_statically=$enablestatically fi echo "setting static flags to... ${config_statically:-none}" # # Profiling # AC_ARG_ENABLE(profiling, AC_HELP_STRING([--enable-profiling], [enable profiling (-pg) (default=no)]), enableprofiling=$enableval, enableprofiling="no") if test $enableprofiling = "yes" ; then config_profiling="-pg" elif test $enableprofiling = "no" ; then config_profiling="" else config_profiling=$enableprofiling fi echo "setting profiling flags to... ${config_profiling:-none}" # # Optimization # AC_ARG_ENABLE(optimization, AC_HELP_STRING([--enable-optimization], [enable optimization by compiler (-O3) (default=yes)]), enableoptimization=$enableval, enableoptimization="yes") if test $enableoptimization = "yes" ; then config_optimization="-O3 -DOPTIMIZE -DNDEBUG" elif test $enableoptimization = "no" ; then config_optimization="" else config_optimization=$enableoptimization fi echo "setting optimization flags to... ${config_optimization:-none}" # # Proof production # AC_ARG_ENABLE(proof, AC_HELP_STRING([--enable-proof], [enable proof production (default=no)]), enableproof=$enableval, enableproof="no") if test $enableproof = "yes" ; then config_proof="-DPRODUCE_PROOF" elif test $enableproof = "no" ; then config_proof="" else config_proof=$enableproof fi echo "setting proof flags to... ${config_proof:-none}" # # Enable Pedantic Assertion Checking # AC_ARG_ENABLE(pedantic_debug, AC_HELP_STRING([--enable-pedantic_debug], [enable pedantic assertion checking (default=no)]), enablepedantic_debug=$enableval, enablepedantic_debug="no") if test $enablepedantic_debug = "yes" ; then config_pedantic_debug="-DPEDANTIC_DEBUG" elif test $enablepedantic_debug = "no" ; then config_pedantic_debug="" else config_pedantic_debug=$enablepedantic_debug fi echo "setting pedantic debug flags to... ${config_pedantic_debug:-none}" # # SMTCOMP version # AC_ARG_ENABLE(smtcomp, AC_HELP_STRING([--enable-smtcomp], [enable smtcomp mode (default=no)]), enablesmtcomp=$enableval, enablesmtcomp="no") if test $enablesmtcomp = "yes" ; then config_smtcomp="-DSMTCOMP -march=opteron --static" elif test $enablesmtcomp = "no" ; then config_smtcomp="" else config_smtcomp=$enablesmtcomp fi echo "setting smtcomp flags to... ${config_smtcomp:-none}" # Complain if both pedantic debug and optimization are enabled if test $enablepedantic_debug = "yes" -a $enableoptimization = "yes" ; then echo "Error: cannot enable both pedantic debug and optimization" exit fi # Complain if smtcomp is enabled and optimization is disabled if test $enablesmtcomp = "yes" -a $enableoptimization = "no" ; then echo "Error: smtcomp requires optimizations" exit fi # Complain if smtcomp is enabled and proof is enabled if test $enablesmtcomp = "yes" -a $enableproof = "yes" ; then echo "Error: cannot enable proof with smtcomp" exit fi AM_CFLAGS="-W -Wall -g -Wno-deprecated $config_profiling $config_optimization $config_pedantic_debug $config_smtcomp $config_statically $config_proof" AM_CXXFLAGS="-W -Wall -g -Wno-deprecated $config_profiling $config_optimization $config_pedantic_debug $config_smtcomp $config_statically $config_proof" CFLAGS="" CXXFLAGS="" # Allow user to use a GMP lib in a non-standard location AC_ARG_WITH([gmp], [AS_HELP_STRING([--with-gmp=prefix], [Use this when GMP is in a non-standard location (e.g /opt/local in MacPorts)])], [NONSTDGMPPATH=1], [NONSTDGMPPATH=0]) if test $NONSTDGMPPATH = 1 ; then AM_CXXFLAGS="$AM_CXXFLAGS -I$with_gmp/include" AM_LDFLAGS="$AM_LDFLAGS -L$with_gmp/lib" fi AC_SUBST(AM_CFLAGS) AC_SUBST(AM_CXXFLAGS) AC_SUBST(CFLAGS) AC_SUBST(CXXFLAGS) AC_SUBST(AM_LDFLAGS) # Setup comilation/linking flags for library checks OLDCPPFLAGS=$CPPFLAGS CPPFLAGS=$CXXFLAGS OLDLDFLAGS=$LDFLAGS LDFLAGS="$LDFLAGS $AM_LDFLAGS" # Check for GMP header GMP_HEADER_FOUND=1 if test $NONSTDGMPPATH = 1 ; then AC_CHECK_HEADERS($with_gmp/include/gmp.h, , [AC_MSG_ERROR([ The GMP header gmp.h was not found.])]) else AC_CHECK_HEADERS(gmp.h, , [AC_MSG_ERROR([ The GMP header gmp.h was not found.])]) fi # Check for GMP library AC_CHECK_LIB(gmp, __gmpz_init, ,[AC_MSG_ERROR([GMP library not found])]) # Restore original flags CPPFLAGS=$OLDCPPFLAGS LDFLAGS=$OLDLDFLAGS # # List of directories to include # config_includedirs="-I\${top_srcdir}/src \\\ -I\${top_srcdir}/src/minisat/mtl \\\ -I\${top_srcdir}/src/minisat/core \\\ -I\${top_srcdir}/src/smtsolvers \\\ -I\${top_srcdir}/src/simplifiers \\\ -I\${top_srcdir}/src/common \\\ -I\${top_srcdir}/src/egraph \\\ -I\${top_srcdir}/src/sorts \\\ -I\${top_srcdir}/src/cnfizers \\\ -I\${top_srcdir}/src/proof \\\ -I\${top_srcdir}/src/api \\\ -I\${top_srcdir}/src/tsolvers \\\ -I\${top_srcdir}/src/tsolvers/emptysolver \\\ -I\${top_srcdir}/src/tsolvers/bvsolver \\\ -I\${top_srcdir}/src/tsolvers/bvsolver/minisatp \\\ -I\${top_srcdir}/src/tsolvers/lrasolver \\\ -I\${top_srcdir}/src/tsolvers/liasolver \\\ -I\${top_srcdir}/src/tsolvers/ctsolver \\\ -I\${top_srcdir}/src/tsolvers/axdiffsolver \\\ -I\${top_srcdir}/src/tsolvers/dlsolver" AC_SUBST(config_includedirs) AC_CONFIG_FILES([ \ Makefile \ src/Makefile \ src/parsers/Makefile \ src/parsers/smt/Makefile \ src/parsers/smt2/Makefile \ src/parsers/cnf/Makefile \ src/cnfizers/Makefile \ src/smtsolvers/Makefile \ src/simplifiers/Makefile \ src/proof/Makefile \ src/common/Makefile \ src/egraph/Makefile \ src/sorts/Makefile \ src/tsolvers/Makefile \ src/tsolvers/emptysolver/Makefile \ src/tsolvers/axdiffsolver/Makefile \ src/tsolvers/bvsolver/Makefile \ src/tsolvers/bvsolver/minisatp/Makefile \ src/tsolvers/lrasolver/Makefile \ src/tsolvers/ctsolver/Makefile \ src/tsolvers/dlsolver/Makefile \ src/api/Makefile \ test/Makefile \ ]) AC_OUTPUT opensmt-2.5.2/test/dead_dnd007.smt2000066400000000000000000000752331445011647600167660ustar00rootroot00000000000000(set-logic QF_UF) (set-info :source | http://www.cs.bham.ac.uk/~vxs/quasigroups/benchmark/ |) (set-info :smt-lib-version 2.0) (set-info :category "crafted") ;(set-info :status unsat) (declare-sort U 0) (declare-sort I 0) (declare-fun unit () I) (declare-fun op (I I) I) (declare-fun e5 () I) (declare-fun e4 () I) (declare-fun e3 () I) (declare-fun e2 () I) (declare-fun e1 () I) (declare-fun e0 () I) (assert (let ((?v_0 (op e0 e0)) (?v_1 (op e0 e1)) (?v_2 (op e0 e2)) (?v_3 (op e0 e3)) (?v_4 (op e0 e4)) (?v_5 (op e0 e5)) (?v_6 (op e1 e0)) (?v_7 (op e1 e1)) (?v_8 (op e1 e2)) (?v_9 (op e1 e3)) (?v_10 (op e1 e4)) (?v_11 (op e1 e5)) (?v_12 (op e2 e0)) (?v_13 (op e2 e1)) (?v_14 (op e2 e2)) (?v_15 (op e2 e3)) (?v_16 (op e2 e4)) (?v_17 (op e2 e5)) (?v_18 (op e3 e0)) (?v_19 (op e3 e1)) (?v_20 (op e3 e2)) (?v_21 (op e3 e3)) (?v_22 (op e3 e4)) (?v_23 (op e3 e5)) (?v_24 (op e4 e0)) (?v_25 (op e4 e1)) (?v_26 (op e4 e2)) (?v_27 (op e4 e3)) (?v_28 (op e4 e4)) (?v_29 (op e4 e5)) (?v_30 (op e5 e0)) (?v_31 (op e5 e1)) (?v_32 (op e5 e2)) (?v_33 (op e5 e3)) (?v_34 (op e5 e4)) (?v_35 (op e5 e5))) (and (and (and (and (and (and (and (and (and (and (or (or (or (or (or (= ?v_0 e0) (= ?v_0 e1)) (= ?v_0 e2)) (= ?v_0 e3)) (= ?v_0 e4)) (= ?v_0 e5)) (or (or (or (or (or (= ?v_1 e0) (= ?v_1 e1)) (= ?v_1 e2)) (= ?v_1 e3)) (= ?v_1 e4)) (= ?v_1 e5))) (or (or (or (or (or (= ?v_2 e0) (= ?v_2 e1)) (= ?v_2 e2)) (= ?v_2 e3)) (= ?v_2 e4)) (= ?v_2 e5))) (or (or (or (or (or (= ?v_3 e0) (= ?v_3 e1)) (= ?v_3 e2)) (= ?v_3 e3)) (= ?v_3 e4)) (= ?v_3 e5))) (or (or (or (or (or (= ?v_4 e0) (= ?v_4 e1)) (= ?v_4 e2)) (= ?v_4 e3)) (= ?v_4 e4)) (= ?v_4 e5))) (or (or (or (or (or (= ?v_5 e0) (= ?v_5 e1)) (= ?v_5 e2)) (= ?v_5 e3)) (= ?v_5 e4)) (= ?v_5 e5))) (and (and (and (and (and (or (or (or (or (or (= ?v_6 e0) (= ?v_6 e1)) (= ?v_6 e2)) (= ?v_6 e3)) (= ?v_6 e4)) (= ?v_6 e5)) (or (or (or (or (or (= ?v_7 e0) (= ?v_7 e1)) (= ?v_7 e2)) (= ?v_7 e3)) (= ?v_7 e4)) (= ?v_7 e5))) (or (or (or (or (or (= ?v_8 e0) (= ?v_8 e1)) (= ?v_8 e2)) (= ?v_8 e3)) (= ?v_8 e4)) (= ?v_8 e5))) (or (or (or (or (or (= ?v_9 e0) (= ?v_9 e1)) (= ?v_9 e2)) (= ?v_9 e3)) (= ?v_9 e4)) (= ?v_9 e5))) (or (or (or (or (or (= ?v_10 e0) (= ?v_10 e1)) (= ?v_10 e2)) (= ?v_10 e3)) (= ?v_10 e4)) (= ?v_10 e5))) (or (or (or (or (or (= ?v_11 e0) (= ?v_11 e1)) (= ?v_11 e2)) (= ?v_11 e3)) (= ?v_11 e4)) (= ?v_11 e5)))) (and (and (and (and (and (or (or (or (or (or (= ?v_12 e0) (= ?v_12 e1)) (= ?v_12 e2)) (= ?v_12 e3)) (= ?v_12 e4)) (= ?v_12 e5)) (or (or (or (or (or (= ?v_13 e0) (= ?v_13 e1)) (= ?v_13 e2)) (= ?v_13 e3)) (= ?v_13 e4)) (= ?v_13 e5))) (or (or (or (or (or (= ?v_14 e0) (= ?v_14 e1)) (= ?v_14 e2)) (= ?v_14 e3)) (= ?v_14 e4)) (= ?v_14 e5))) (or (or (or (or (or (= ?v_15 e0) (= ?v_15 e1)) (= ?v_15 e2)) (= ?v_15 e3)) (= ?v_15 e4)) (= ?v_15 e5))) (or (or (or (or (or (= ?v_16 e0) (= ?v_16 e1)) (= ?v_16 e2)) (= ?v_16 e3)) (= ?v_16 e4)) (= ?v_16 e5))) (or (or (or (or (or (= ?v_17 e0) (= ?v_17 e1)) (= ?v_17 e2)) (= ?v_17 e3)) (= ?v_17 e4)) (= ?v_17 e5)))) (and (and (and (and (and (or (or (or (or (or (= ?v_18 e0) (= ?v_18 e1)) (= ?v_18 e2)) (= ?v_18 e3)) (= ?v_18 e4)) (= ?v_18 e5)) (or (or (or (or (or (= ?v_19 e0) (= ?v_19 e1)) (= ?v_19 e2)) (= ?v_19 e3)) (= ?v_19 e4)) (= ?v_19 e5))) (or (or (or (or (or (= ?v_20 e0) (= ?v_20 e1)) (= ?v_20 e2)) (= ?v_20 e3)) (= ?v_20 e4)) (= ?v_20 e5))) (or (or (or (or (or (= ?v_21 e0) (= ?v_21 e1)) (= ?v_21 e2)) (= ?v_21 e3)) (= ?v_21 e4)) (= ?v_21 e5))) (or (or (or (or (or (= ?v_22 e0) (= ?v_22 e1)) (= ?v_22 e2)) (= ?v_22 e3)) (= ?v_22 e4)) (= ?v_22 e5))) (or (or (or (or (or (= ?v_23 e0) (= ?v_23 e1)) (= ?v_23 e2)) (= ?v_23 e3)) (= ?v_23 e4)) (= ?v_23 e5)))) (and (and (and (and (and (or (or (or (or (or (= ?v_24 e0) (= ?v_24 e1)) (= ?v_24 e2)) (= ?v_24 e3)) (= ?v_24 e4)) (= ?v_24 e5)) (or (or (or (or (or (= ?v_25 e0) (= ?v_25 e1)) (= ?v_25 e2)) (= ?v_25 e3)) (= ?v_25 e4)) (= ?v_25 e5))) (or (or (or (or (or (= ?v_26 e0) (= ?v_26 e1)) (= ?v_26 e2)) (= ?v_26 e3)) (= ?v_26 e4)) (= ?v_26 e5))) (or (or (or (or (or (= ?v_27 e0) (= ?v_27 e1)) (= ?v_27 e2)) (= ?v_27 e3)) (= ?v_27 e4)) (= ?v_27 e5))) (or (or (or (or (or (= ?v_28 e0) (= ?v_28 e1)) (= ?v_28 e2)) (= ?v_28 e3)) (= ?v_28 e4)) (= ?v_28 e5))) (or (or (or (or (or (= ?v_29 e0) (= ?v_29 e1)) (= ?v_29 e2)) (= ?v_29 e3)) (= ?v_29 e4)) (= ?v_29 e5)))) (and (and (and (and (and (or (or (or (or (or (= ?v_30 e0) (= ?v_30 e1)) (= ?v_30 e2)) (= ?v_30 e3)) (= ?v_30 e4)) (= ?v_30 e5)) (or (or (or (or (or (= ?v_31 e0) (= ?v_31 e1)) (= ?v_31 e2)) (= ?v_31 e3)) (= ?v_31 e4)) (= ?v_31 e5))) (or (or (or (or (or (= ?v_32 e0) (= ?v_32 e1)) (= ?v_32 e2)) (= ?v_32 e3)) (= ?v_32 e4)) (= ?v_32 e5))) (or (or (or (or (or (= ?v_33 e0) (= ?v_33 e1)) (= ?v_33 e2)) (= ?v_33 e3)) (= ?v_33 e4)) (= ?v_33 e5))) (or (or (or (or (or (= ?v_34 e0) (= ?v_34 e1)) (= ?v_34 e2)) (= ?v_34 e3)) (= ?v_34 e4)) (= ?v_34 e5))) (or (or (or (or (or (= ?v_35 e0) (= ?v_35 e1)) (= ?v_35 e2)) (= ?v_35 e3)) (= ?v_35 e4)) (= ?v_35 e5)))))) (assert (let ((?v_1 (op e0 e0)) (?v_2 (op e0 e1)) (?v_3 (op e0 e2)) (?v_4 (op e0 e3)) (?v_5 (op e0 e4)) (?v_6 (op e0 e5)) (?v_8 (op e1 e0)) (?v_21 (op e1 e1)) (?v_22 (op e1 e2)) (?v_23 (op e1 e3)) (?v_24 (op e1 e4)) (?v_25 (op e1 e5)) (?v_9 (op e2 e0)) (?v_28 (op e2 e1)) (?v_51 (op e2 e2)) (?v_52 (op e2 e3)) (?v_53 (op e2 e4)) (?v_54 (op e2 e5)) (?v_10 (op e3 e0)) (?v_29 (op e3 e1)) (?v_58 (op e3 e2)) (?v_91 (op e3 e3)) (?v_92 (op e3 e4)) (?v_93 (op e3 e5)) (?v_11 (op e4 e0)) (?v_30 (op e4 e1)) (?v_59 (op e4 e2)) (?v_98 (op e4 e3)) (?v_141 (op e4 e4)) (?v_142 (op e4 e5)) (?v_12 (op e5 e0)) (?v_31 (op e5 e1)) (?v_60 (op e5 e2)) (?v_99 (op e5 e3)) (?v_148 (op e5 e4)) (?v_201 (op e5 e5))) (let ((?v_0 (= ?v_1 e0)) (?v_7 (= ?v_1 e1)) (?v_13 (= ?v_1 e2)) (?v_14 (= ?v_1 e3)) (?v_15 (= ?v_1 e4)) (?v_16 (= ?v_1 e5)) (?v_18 (= ?v_2 e0)) (?v_26 (= ?v_2 e1)) (?v_33 (= ?v_2 e2)) (?v_36 (= ?v_2 e3)) (?v_39 (= ?v_2 e4)) (?v_42 (= ?v_2 e5)) (?v_46 (= ?v_3 e0)) (?v_55 (= ?v_3 e1)) (?v_63 (= ?v_3 e2)) (?v_68 (= ?v_3 e3)) (?v_73 (= ?v_3 e4)) (?v_78 (= ?v_3 e5)) (?v_84 (= ?v_4 e0)) (?v_94 (= ?v_4 e1)) (?v_103 (= ?v_4 e2)) (?v_110 (= ?v_4 e3)) (?v_117 (= ?v_4 e4)) (?v_124 (= ?v_4 e5)) (?v_132 (= ?v_5 e0)) (?v_143 (= ?v_5 e1)) (?v_153 (= ?v_5 e2)) (?v_162 (= ?v_5 e3)) (?v_171 (= ?v_5 e4)) (?v_180 (= ?v_5 e5)) (?v_190 (= ?v_6 e0)) (?v_202 (= ?v_6 e1)) (?v_213 (= ?v_6 e2)) (?v_224 (= ?v_6 e3)) (?v_235 (= ?v_6 e4)) (?v_246 (= ?v_6 e5)) (?v_17 (= ?v_8 e0)) (?v_20 (= ?v_8 e1)) (?v_32 (= ?v_8 e2)) (?v_35 (= ?v_8 e3)) (?v_38 (= ?v_8 e4)) (?v_41 (= ?v_8 e5)) (?v_19 (= ?v_21 e0)) (?v_27 (= ?v_21 e1)) (?v_34 (= ?v_21 e2)) (?v_37 (= ?v_21 e3)) (?v_40 (= ?v_21 e4)) (?v_43 (= ?v_21 e5)) (?v_47 (= ?v_22 e0)) (?v_56 (= ?v_22 e1)) (?v_64 (= ?v_22 e2)) (?v_69 (= ?v_22 e3)) (?v_74 (= ?v_22 e4)) (?v_79 (= ?v_22 e5)) (?v_85 (= ?v_23 e0)) (?v_95 (= ?v_23 e1)) (?v_104 (= ?v_23 e2)) (?v_111 (= ?v_23 e3)) (?v_118 (= ?v_23 e4)) (?v_125 (= ?v_23 e5)) (?v_133 (= ?v_24 e0)) (?v_144 (= ?v_24 e1)) (?v_154 (= ?v_24 e2)) (?v_163 (= ?v_24 e3)) (?v_172 (= ?v_24 e4)) (?v_181 (= ?v_24 e5)) (?v_191 (= ?v_25 e0)) (?v_203 (= ?v_25 e1)) (?v_214 (= ?v_25 e2)) (?v_225 (= ?v_25 e3)) (?v_236 (= ?v_25 e4)) (?v_247 (= ?v_25 e5)) (?v_44 (= ?v_9 e0)) (?v_49 (= ?v_9 e1)) (?v_61 (= ?v_9 e2)) (?v_66 (= ?v_9 e3)) (?v_71 (= ?v_9 e4)) (?v_76 (= ?v_9 e5)) (?v_45 (= ?v_28 e0)) (?v_50 (= ?v_28 e1)) (?v_62 (= ?v_28 e2)) (?v_67 (= ?v_28 e3)) (?v_72 (= ?v_28 e4)) (?v_77 (= ?v_28 e5)) (?v_48 (= ?v_51 e0)) (?v_57 (= ?v_51 e1)) (?v_65 (= ?v_51 e2)) (?v_70 (= ?v_51 e3)) (?v_75 (= ?v_51 e4)) (?v_80 (= ?v_51 e5)) (?v_86 (= ?v_52 e0)) (?v_96 (= ?v_52 e1)) (?v_105 (= ?v_52 e2)) (?v_112 (= ?v_52 e3)) (?v_119 (= ?v_52 e4)) (?v_126 (= ?v_52 e5)) (?v_134 (= ?v_53 e0)) (?v_145 (= ?v_53 e1)) (?v_155 (= ?v_53 e2)) (?v_164 (= ?v_53 e3)) (?v_173 (= ?v_53 e4)) (?v_182 (= ?v_53 e5)) (?v_192 (= ?v_54 e0)) (?v_204 (= ?v_54 e1)) (?v_215 (= ?v_54 e2)) (?v_226 (= ?v_54 e3)) (?v_237 (= ?v_54 e4)) (?v_248 (= ?v_54 e5)) (?v_81 (= ?v_10 e0)) (?v_88 (= ?v_10 e1)) (?v_100 (= ?v_10 e2)) (?v_107 (= ?v_10 e3)) (?v_114 (= ?v_10 e4)) (?v_121 (= ?v_10 e5)) (?v_82 (= ?v_29 e0)) (?v_89 (= ?v_29 e1)) (?v_101 (= ?v_29 e2)) (?v_108 (= ?v_29 e3)) (?v_115 (= ?v_29 e4)) (?v_122 (= ?v_29 e5)) (?v_83 (= ?v_58 e0)) (?v_90 (= ?v_58 e1)) (?v_102 (= ?v_58 e2)) (?v_109 (= ?v_58 e3)) (?v_116 (= ?v_58 e4)) (?v_123 (= ?v_58 e5)) (?v_87 (= ?v_91 e0)) (?v_97 (= ?v_91 e1)) (?v_106 (= ?v_91 e2)) (?v_113 (= ?v_91 e3)) (?v_120 (= ?v_91 e4)) (?v_127 (= ?v_91 e5)) (?v_135 (= ?v_92 e0)) (?v_146 (= ?v_92 e1)) (?v_156 (= ?v_92 e2)) (?v_165 (= ?v_92 e3)) (?v_174 (= ?v_92 e4)) (?v_183 (= ?v_92 e5)) (?v_193 (= ?v_93 e0)) (?v_205 (= ?v_93 e1)) (?v_216 (= ?v_93 e2)) (?v_227 (= ?v_93 e3)) (?v_238 (= ?v_93 e4)) (?v_249 (= ?v_93 e5)) (?v_128 (= ?v_11 e0)) (?v_137 (= ?v_11 e1)) (?v_149 (= ?v_11 e2)) (?v_158 (= ?v_11 e3)) (?v_167 (= ?v_11 e4)) (?v_176 (= ?v_11 e5)) (?v_129 (= ?v_30 e0)) (?v_138 (= ?v_30 e1)) (?v_150 (= ?v_30 e2)) (?v_159 (= ?v_30 e3)) (?v_168 (= ?v_30 e4)) (?v_177 (= ?v_30 e5)) (?v_130 (= ?v_59 e0)) (?v_139 (= ?v_59 e1)) (?v_151 (= ?v_59 e2)) (?v_160 (= ?v_59 e3)) (?v_169 (= ?v_59 e4)) (?v_178 (= ?v_59 e5)) (?v_131 (= ?v_98 e0)) (?v_140 (= ?v_98 e1)) (?v_152 (= ?v_98 e2)) (?v_161 (= ?v_98 e3)) (?v_170 (= ?v_98 e4)) (?v_179 (= ?v_98 e5)) (?v_136 (= ?v_141 e0)) (?v_147 (= ?v_141 e1)) (?v_157 (= ?v_141 e2)) (?v_166 (= ?v_141 e3)) (?v_175 (= ?v_141 e4)) (?v_184 (= ?v_141 e5)) (?v_194 (= ?v_142 e0)) (?v_206 (= ?v_142 e1)) (?v_217 (= ?v_142 e2)) (?v_228 (= ?v_142 e3)) (?v_239 (= ?v_142 e4)) (?v_250 (= ?v_142 e5)) (?v_185 (= ?v_12 e0)) (?v_196 (= ?v_12 e1)) (?v_208 (= ?v_12 e2)) (?v_219 (= ?v_12 e3)) (?v_230 (= ?v_12 e4)) (?v_241 (= ?v_12 e5)) (?v_186 (= ?v_31 e0)) (?v_197 (= ?v_31 e1)) (?v_209 (= ?v_31 e2)) (?v_220 (= ?v_31 e3)) (?v_231 (= ?v_31 e4)) (?v_242 (= ?v_31 e5)) (?v_187 (= ?v_60 e0)) (?v_198 (= ?v_60 e1)) (?v_210 (= ?v_60 e2)) (?v_221 (= ?v_60 e3)) (?v_232 (= ?v_60 e4)) (?v_243 (= ?v_60 e5)) (?v_188 (= ?v_99 e0)) (?v_199 (= ?v_99 e1)) (?v_211 (= ?v_99 e2)) (?v_222 (= ?v_99 e3)) (?v_233 (= ?v_99 e4)) (?v_244 (= ?v_99 e5)) (?v_189 (= ?v_148 e0)) (?v_200 (= ?v_148 e1)) (?v_212 (= ?v_148 e2)) (?v_223 (= ?v_148 e3)) (?v_234 (= ?v_148 e4)) (?v_245 (= ?v_148 e5)) (?v_195 (= ?v_201 e0)) (?v_207 (= ?v_201 e1)) (?v_218 (= ?v_201 e2)) (?v_229 (= ?v_201 e3)) (?v_240 (= ?v_201 e4)) (?v_251 (= ?v_201 e5))) (and (and (and (and (and (and (and (and (and (and (and (or (or (or (or (or ?v_0 ?v_18) ?v_46) ?v_84) ?v_132) ?v_190) (or (or (or (or (or ?v_0 ?v_17) ?v_44) ?v_81) ?v_128) ?v_185)) (and (or (or (or (or (or ?v_7 ?v_26) ?v_55) ?v_94) ?v_143) ?v_202) (or (or (or (or (or ?v_7 ?v_20) ?v_49) ?v_88) ?v_137) ?v_196))) (and (or (or (or (or (or ?v_13 ?v_33) ?v_63) ?v_103) ?v_153) ?v_213) (or (or (or (or (or ?v_13 ?v_32) ?v_61) ?v_100) ?v_149) ?v_208))) (and (or (or (or (or (or ?v_14 ?v_36) ?v_68) ?v_110) ?v_162) ?v_224) (or (or (or (or (or ?v_14 ?v_35) ?v_66) ?v_107) ?v_158) ?v_219))) (and (or (or (or (or (or ?v_15 ?v_39) ?v_73) ?v_117) ?v_171) ?v_235) (or (or (or (or (or ?v_15 ?v_38) ?v_71) ?v_114) ?v_167) ?v_230))) (and (or (or (or (or (or ?v_16 ?v_42) ?v_78) ?v_124) ?v_180) ?v_246) (or (or (or (or (or ?v_16 ?v_41) ?v_76) ?v_121) ?v_176) ?v_241))) (and (and (and (and (and (and (or (or (or (or (or ?v_17 ?v_19) ?v_47) ?v_85) ?v_133) ?v_191) (or (or (or (or (or ?v_18 ?v_19) ?v_45) ?v_82) ?v_129) ?v_186)) (and (or (or (or (or (or ?v_20 ?v_27) ?v_56) ?v_95) ?v_144) ?v_203) (or (or (or (or (or ?v_26 ?v_27) ?v_50) ?v_89) ?v_138) ?v_197))) (and (or (or (or (or (or ?v_32 ?v_34) ?v_64) ?v_104) ?v_154) ?v_214) (or (or (or (or (or ?v_33 ?v_34) ?v_62) ?v_101) ?v_150) ?v_209))) (and (or (or (or (or (or ?v_35 ?v_37) ?v_69) ?v_111) ?v_163) ?v_225) (or (or (or (or (or ?v_36 ?v_37) ?v_67) ?v_108) ?v_159) ?v_220))) (and (or (or (or (or (or ?v_38 ?v_40) ?v_74) ?v_118) ?v_172) ?v_236) (or (or (or (or (or ?v_39 ?v_40) ?v_72) ?v_115) ?v_168) ?v_231))) (and (or (or (or (or (or ?v_41 ?v_43) ?v_79) ?v_125) ?v_181) ?v_247) (or (or (or (or (or ?v_42 ?v_43) ?v_77) ?v_122) ?v_177) ?v_242)))) (and (and (and (and (and (and (or (or (or (or (or ?v_44 ?v_45) ?v_48) ?v_86) ?v_134) ?v_192) (or (or (or (or (or ?v_46 ?v_47) ?v_48) ?v_83) ?v_130) ?v_187)) (and (or (or (or (or (or ?v_49 ?v_50) ?v_57) ?v_96) ?v_145) ?v_204) (or (or (or (or (or ?v_55 ?v_56) ?v_57) ?v_90) ?v_139) ?v_198))) (and (or (or (or (or (or ?v_61 ?v_62) ?v_65) ?v_105) ?v_155) ?v_215) (or (or (or (or (or ?v_63 ?v_64) ?v_65) ?v_102) ?v_151) ?v_210))) (and (or (or (or (or (or ?v_66 ?v_67) ?v_70) ?v_112) ?v_164) ?v_226) (or (or (or (or (or ?v_68 ?v_69) ?v_70) ?v_109) ?v_160) ?v_221))) (and (or (or (or (or (or ?v_71 ?v_72) ?v_75) ?v_119) ?v_173) ?v_237) (or (or (or (or (or ?v_73 ?v_74) ?v_75) ?v_116) ?v_169) ?v_232))) (and (or (or (or (or (or ?v_76 ?v_77) ?v_80) ?v_126) ?v_182) ?v_248) (or (or (or (or (or ?v_78 ?v_79) ?v_80) ?v_123) ?v_178) ?v_243)))) (and (and (and (and (and (and (or (or (or (or (or ?v_81 ?v_82) ?v_83) ?v_87) ?v_135) ?v_193) (or (or (or (or (or ?v_84 ?v_85) ?v_86) ?v_87) ?v_131) ?v_188)) (and (or (or (or (or (or ?v_88 ?v_89) ?v_90) ?v_97) ?v_146) ?v_205) (or (or (or (or (or ?v_94 ?v_95) ?v_96) ?v_97) ?v_140) ?v_199))) (and (or (or (or (or (or ?v_100 ?v_101) ?v_102) ?v_106) ?v_156) ?v_216) (or (or (or (or (or ?v_103 ?v_104) ?v_105) ?v_106) ?v_152) ?v_211))) (and (or (or (or (or (or ?v_107 ?v_108) ?v_109) ?v_113) ?v_165) ?v_227) (or (or (or (or (or ?v_110 ?v_111) ?v_112) ?v_113) ?v_161) ?v_222))) (and (or (or (or (or (or ?v_114 ?v_115) ?v_116) ?v_120) ?v_174) ?v_238) (or (or (or (or (or ?v_117 ?v_118) ?v_119) ?v_120) ?v_170) ?v_233))) (and (or (or (or (or (or ?v_121 ?v_122) ?v_123) ?v_127) ?v_183) ?v_249) (or (or (or (or (or ?v_124 ?v_125) ?v_126) ?v_127) ?v_179) ?v_244)))) (and (and (and (and (and (and (or (or (or (or (or ?v_128 ?v_129) ?v_130) ?v_131) ?v_136) ?v_194) (or (or (or (or (or ?v_132 ?v_133) ?v_134) ?v_135) ?v_136) ?v_189)) (and (or (or (or (or (or ?v_137 ?v_138) ?v_139) ?v_140) ?v_147) ?v_206) (or (or (or (or (or ?v_143 ?v_144) ?v_145) ?v_146) ?v_147) ?v_200))) (and (or (or (or (or (or ?v_149 ?v_150) ?v_151) ?v_152) ?v_157) ?v_217) (or (or (or (or (or ?v_153 ?v_154) ?v_155) ?v_156) ?v_157) ?v_212))) (and (or (or (or (or (or ?v_158 ?v_159) ?v_160) ?v_161) ?v_166) ?v_228) (or (or (or (or (or ?v_162 ?v_163) ?v_164) ?v_165) ?v_166) ?v_223))) (and (or (or (or (or (or ?v_167 ?v_168) ?v_169) ?v_170) ?v_175) ?v_239) (or (or (or (or (or ?v_171 ?v_172) ?v_173) ?v_174) ?v_175) ?v_234))) (and (or (or (or (or (or ?v_176 ?v_177) ?v_178) ?v_179) ?v_184) ?v_250) (or (or (or (or (or ?v_180 ?v_181) ?v_182) ?v_183) ?v_184) ?v_245)))) (and (and (and (and (and (and (or (or (or (or (or ?v_185 ?v_186) ?v_187) ?v_188) ?v_189) ?v_195) (or (or (or (or (or ?v_190 ?v_191) ?v_192) ?v_193) ?v_194) ?v_195)) (and (or (or (or (or (or ?v_196 ?v_197) ?v_198) ?v_199) ?v_200) ?v_207) (or (or (or (or (or ?v_202 ?v_203) ?v_204) ?v_205) ?v_206) ?v_207))) (and (or (or (or (or (or ?v_208 ?v_209) ?v_210) ?v_211) ?v_212) ?v_218) (or (or (or (or (or ?v_213 ?v_214) ?v_215) ?v_216) ?v_217) ?v_218))) (and (or (or (or (or (or ?v_219 ?v_220) ?v_221) ?v_222) ?v_223) ?v_229) (or (or (or (or (or ?v_224 ?v_225) ?v_226) ?v_227) ?v_228) ?v_229))) (and (or (or (or (or (or ?v_230 ?v_231) ?v_232) ?v_233) ?v_234) ?v_240) (or (or (or (or (or ?v_235 ?v_236) ?v_237) ?v_238) ?v_239) ?v_240))) (and (or (or (or (or (or ?v_241 ?v_242) ?v_243) ?v_244) ?v_245) ?v_251) (or (or (or (or (or ?v_246 ?v_247) ?v_248) ?v_249) ?v_250) ?v_251))))))) (assert (and (and (and (and (and (and (and (= (op unit e0) e0) (= (op e0 unit) e0)) (and (= (op unit e1) e1) (= (op e1 unit) e1))) (and (= (op unit e2) e2) (= (op e2 unit) e2))) (and (= (op unit e3) e3) (= (op e3 unit) e3))) (and (= (op unit e4) e4) (= (op e4 unit) e4))) (and (= (op unit e5) e5) (= (op e5 unit) e5))) (or (or (or (or (or (= unit e0) (= unit e1)) (= unit e2)) (= unit e3)) (= unit e4)) (= unit e5)))) (assert (let ((?v_0 (op e0 e0)) (?v_1 (op e0 e1)) (?v_4 (op e0 e2)) (?v_9 (op e0 e3)) (?v_16 (op e0 e4)) (?v_25 (op e0 e5)) (?v_2 (op e1 e0)) (?v_3 (op e1 e1)) (?v_6 (op e1 e2)) (?v_11 (op e1 e3)) (?v_18 (op e1 e4)) (?v_27 (op e1 e5)) (?v_5 (op e2 e0)) (?v_7 (op e2 e1)) (?v_8 (op e2 e2)) (?v_13 (op e2 e3)) (?v_20 (op e2 e4)) (?v_29 (op e2 e5)) (?v_10 (op e3 e0)) (?v_12 (op e3 e1)) (?v_14 (op e3 e2)) (?v_15 (op e3 e3)) (?v_22 (op e3 e4)) (?v_31 (op e3 e5)) (?v_17 (op e4 e0)) (?v_19 (op e4 e1)) (?v_21 (op e4 e2)) (?v_23 (op e4 e3)) (?v_24 (op e4 e4)) (?v_33 (op e4 e5)) (?v_26 (op e5 e0)) (?v_28 (op e5 e1)) (?v_30 (op e5 e2)) (?v_32 (op e5 e3)) (?v_34 (op e5 e4)) (?v_35 (op e5 e5))) (or (or (or (or (or (or (or (or (or (or (not (= ?v_0 ?v_0)) (not (= ?v_2 ?v_1))) (not (= ?v_5 ?v_4))) (not (= ?v_10 ?v_9))) (not (= ?v_17 ?v_16))) (not (= ?v_26 ?v_25))) (or (or (or (or (or (not (= ?v_1 ?v_2)) (not (= ?v_3 ?v_3))) (not (= ?v_7 ?v_6))) (not (= ?v_12 ?v_11))) (not (= ?v_19 ?v_18))) (not (= ?v_28 ?v_27)))) (or (or (or (or (or (not (= ?v_4 ?v_5)) (not (= ?v_6 ?v_7))) (not (= ?v_8 ?v_8))) (not (= ?v_14 ?v_13))) (not (= ?v_21 ?v_20))) (not (= ?v_30 ?v_29)))) (or (or (or (or (or (not (= ?v_9 ?v_10)) (not (= ?v_11 ?v_12))) (not (= ?v_13 ?v_14))) (not (= ?v_15 ?v_15))) (not (= ?v_23 ?v_22))) (not (= ?v_32 ?v_31)))) (or (or (or (or (or (not (= ?v_16 ?v_17)) (not (= ?v_18 ?v_19))) (not (= ?v_20 ?v_21))) (not (= ?v_22 ?v_23))) (not (= ?v_24 ?v_24))) (not (= ?v_34 ?v_33)))) (or (or (or (or (or (not (= ?v_25 ?v_26)) (not (= ?v_27 ?v_28))) (not (= ?v_29 ?v_30))) (not (= ?v_31 ?v_32))) (not (= ?v_33 ?v_34))) (not (= ?v_35 ?v_35)))))) (assert (or (or (or (or (or (and (and (and (and (and (not (= (op (op e0 e0) e0) e0)) (not (= (op (op e0 e1) e0) e1))) (not (= (op (op e0 e2) e0) e2))) (not (= (op (op e0 e3) e0) e3))) (not (= (op (op e0 e4) e0) e4))) (not (= (op (op e0 e5) e0) e5))) (and (and (and (and (and (not (= (op (op e1 e0) e1) e0)) (not (= (op (op e1 e1) e1) e1))) (not (= (op (op e1 e2) e1) e2))) (not (= (op (op e1 e3) e1) e3))) (not (= (op (op e1 e4) e1) e4))) (not (= (op (op e1 e5) e1) e5)))) (and (and (and (and (and (not (= (op (op e2 e0) e2) e0)) (not (= (op (op e2 e1) e2) e1))) (not (= (op (op e2 e2) e2) e2))) (not (= (op (op e2 e3) e2) e3))) (not (= (op (op e2 e4) e2) e4))) (not (= (op (op e2 e5) e2) e5)))) (and (and (and (and (and (not (= (op (op e3 e0) e3) e0)) (not (= (op (op e3 e1) e3) e1))) (not (= (op (op e3 e2) e3) e2))) (not (= (op (op e3 e3) e3) e3))) (not (= (op (op e3 e4) e3) e4))) (not (= (op (op e3 e5) e3) e5)))) (and (and (and (and (and (not (= (op (op e4 e0) e4) e0)) (not (= (op (op e4 e1) e4) e1))) (not (= (op (op e4 e2) e4) e2))) (not (= (op (op e4 e3) e4) e3))) (not (= (op (op e4 e4) e4) e4))) (not (= (op (op e4 e5) e4) e5)))) (and (and (and (and (and (not (= (op (op e5 e0) e5) e0)) (not (= (op (op e5 e1) e5) e1))) (not (= (op (op e5 e2) e5) e2))) (not (= (op (op e5 e3) e5) e3))) (not (= (op (op e5 e4) e5) e4))) (not (= (op (op e5 e5) e5) e5))))) (assert (let ((?v_0 (op e0 e0)) (?v_1 (op e0 e1)) (?v_2 (op e0 e2)) (?v_3 (op e0 e3)) (?v_4 (op e0 e4)) (?v_5 (op e0 e5)) (?v_6 (op e1 e0)) (?v_7 (op e1 e1)) (?v_8 (op e1 e2)) (?v_9 (op e1 e3)) (?v_10 (op e1 e4)) (?v_11 (op e1 e5)) (?v_12 (op e2 e0)) (?v_13 (op e2 e1)) (?v_14 (op e2 e2)) (?v_15 (op e2 e3)) (?v_16 (op e2 e4)) (?v_17 (op e2 e5)) (?v_18 (op e3 e0)) (?v_19 (op e3 e1)) (?v_20 (op e3 e2)) (?v_21 (op e3 e3)) (?v_22 (op e3 e4)) (?v_23 (op e3 e5)) (?v_24 (op e4 e0)) (?v_25 (op e4 e1)) (?v_26 (op e4 e2)) (?v_27 (op e4 e3)) (?v_28 (op e4 e4)) (?v_29 (op e4 e5)) (?v_30 (op e5 e0)) (?v_31 (op e5 e1)) (?v_32 (op e5 e2)) (?v_33 (op e5 e3)) (?v_34 (op e5 e4)) (?v_35 (op e5 e5))) (and (and (and (and (and (or (or (or (or (or (= (op ?v_0 ?v_0) e0) (= (op ?v_1 ?v_1) e1)) (= (op ?v_2 ?v_2) e2)) (= (op ?v_3 ?v_3) e3)) (= (op ?v_4 ?v_4) e4)) (= (op ?v_5 ?v_5) e5)) (or (or (or (or (or (= (op ?v_6 ?v_6) e0) (= (op ?v_7 ?v_7) e1)) (= (op ?v_8 ?v_8) e2)) (= (op ?v_9 ?v_9) e3)) (= (op ?v_10 ?v_10) e4)) (= (op ?v_11 ?v_11) e5))) (or (or (or (or (or (= (op ?v_12 ?v_12) e0) (= (op ?v_13 ?v_13) e1)) (= (op ?v_14 ?v_14) e2)) (= (op ?v_15 ?v_15) e3)) (= (op ?v_16 ?v_16) e4)) (= (op ?v_17 ?v_17) e5))) (or (or (or (or (or (= (op ?v_18 ?v_18) e0) (= (op ?v_19 ?v_19) e1)) (= (op ?v_20 ?v_20) e2)) (= (op ?v_21 ?v_21) e3)) (= (op ?v_22 ?v_22) e4)) (= (op ?v_23 ?v_23) e5))) (or (or (or (or (or (= (op ?v_24 ?v_24) e0) (= (op ?v_25 ?v_25) e1)) (= (op ?v_26 ?v_26) e2)) (= (op ?v_27 ?v_27) e3)) (= (op ?v_28 ?v_28) e4)) (= (op ?v_29 ?v_29) e5))) (or (or (or (or (or (= (op ?v_30 ?v_30) e0) (= (op ?v_31 ?v_31) e1)) (= (op ?v_32 ?v_32) e2)) (= (op ?v_33 ?v_33) e3)) (= (op ?v_34 ?v_34) e4)) (= (op ?v_35 ?v_35) e5))))) (assert (let ((?v_0 (op e0 e0)) (?v_6 (op e0 e1)) (?v_12 (op e0 e2)) (?v_18 (op e0 e3)) (?v_24 (op e0 e4)) (?v_30 (op e0 e5)) (?v_1 (op e1 e0)) (?v_7 (op e1 e1)) (?v_13 (op e1 e2)) (?v_19 (op e1 e3)) (?v_25 (op e1 e4)) (?v_31 (op e1 e5)) (?v_2 (op e2 e0)) (?v_8 (op e2 e1)) (?v_14 (op e2 e2)) (?v_20 (op e2 e3)) (?v_26 (op e2 e4)) (?v_32 (op e2 e5)) (?v_3 (op e3 e0)) (?v_9 (op e3 e1)) (?v_15 (op e3 e2)) (?v_21 (op e3 e3)) (?v_27 (op e3 e4)) (?v_33 (op e3 e5)) (?v_4 (op e4 e0)) (?v_10 (op e4 e1)) (?v_16 (op e4 e2)) (?v_22 (op e4 e3)) (?v_28 (op e4 e4)) (?v_34 (op e4 e5)) (?v_5 (op e5 e0)) (?v_11 (op e5 e1)) (?v_17 (op e5 e2)) (?v_23 (op e5 e3)) (?v_29 (op e5 e4)) (?v_35 (op e5 e5))) (or (or (or (or (or (and (and (and (and (and (not (= (op ?v_0 ?v_0) e0)) (not (= (op ?v_1 ?v_1) e1))) (not (= (op ?v_2 ?v_2) e2))) (not (= (op ?v_3 ?v_3) e3))) (not (= (op ?v_4 ?v_4) e4))) (not (= (op ?v_5 ?v_5) e5))) (and (and (and (and (and (not (= (op ?v_6 ?v_6) e0)) (not (= (op ?v_7 ?v_7) e1))) (not (= (op ?v_8 ?v_8) e2))) (not (= (op ?v_9 ?v_9) e3))) (not (= (op ?v_10 ?v_10) e4))) (not (= (op ?v_11 ?v_11) e5)))) (and (and (and (and (and (not (= (op ?v_12 ?v_12) e0)) (not (= (op ?v_13 ?v_13) e1))) (not (= (op ?v_14 ?v_14) e2))) (not (= (op ?v_15 ?v_15) e3))) (not (= (op ?v_16 ?v_16) e4))) (not (= (op ?v_17 ?v_17) e5)))) (and (and (and (and (and (not (= (op ?v_18 ?v_18) e0)) (not (= (op ?v_19 ?v_19) e1))) (not (= (op ?v_20 ?v_20) e2))) (not (= (op ?v_21 ?v_21) e3))) (not (= (op ?v_22 ?v_22) e4))) (not (= (op ?v_23 ?v_23) e5)))) (and (and (and (and (and (not (= (op ?v_24 ?v_24) e0)) (not (= (op ?v_25 ?v_25) e1))) (not (= (op ?v_26 ?v_26) e2))) (not (= (op ?v_27 ?v_27) e3))) (not (= (op ?v_28 ?v_28) e4))) (not (= (op ?v_29 ?v_29) e5)))) (and (and (and (and (and (not (= (op ?v_30 ?v_30) e0)) (not (= (op ?v_31 ?v_31) e1))) (not (= (op ?v_32 ?v_32) e2))) (not (= (op ?v_33 ?v_33) e3))) (not (= (op ?v_34 ?v_34) e4))) (not (= (op ?v_35 ?v_35) e5)))))) (assert (let ((?v_1 (op e0 e0)) (?v_7 (op e0 e1)) (?v_14 (op e0 e2)) (?v_21 (op e0 e3)) (?v_28 (op e0 e4)) (?v_35 (op e0 e5)) (?v_2 (op e1 e0)) (?v_9 (op e1 e1)) (?v_15 (op e1 e2)) (?v_22 (op e1 e3)) (?v_29 (op e1 e4)) (?v_36 (op e1 e5)) (?v_3 (op e2 e0)) (?v_10 (op e2 e1)) (?v_17 (op e2 e2)) (?v_23 (op e2 e3)) (?v_30 (op e2 e4)) (?v_37 (op e2 e5)) (?v_4 (op e3 e0)) (?v_11 (op e3 e1)) (?v_18 (op e3 e2)) (?v_25 (op e3 e3)) (?v_31 (op e3 e4)) (?v_38 (op e3 e5)) (?v_5 (op e4 e0)) (?v_12 (op e4 e1)) (?v_19 (op e4 e2)) (?v_26 (op e4 e3)) (?v_33 (op e4 e4)) (?v_39 (op e4 e5)) (?v_6 (op e5 e0)) (?v_13 (op e5 e1)) (?v_20 (op e5 e2)) (?v_27 (op e5 e3)) (?v_34 (op e5 e4)) (?v_41 (op e5 e5))) (let ((?v_0 (= (op e0 ?v_1) e0)) (?v_8 (= (op e1 ?v_9) e1)) (?v_16 (= (op e2 ?v_17) e2)) (?v_24 (= (op e3 ?v_25) e3)) (?v_32 (= (op e4 ?v_33) e4)) (?v_40 (= (op e5 ?v_41) e5))) (and (or (or (or (or (or (and ?v_0 (not (= e0 unit))) (and ?v_8 (not (= e1 unit)))) (and ?v_16 (not (= e2 unit)))) (and ?v_24 (not (= e3 unit)))) (and ?v_32 (not (= e4 unit)))) (and ?v_40 (not (= e5 unit)))) (or (or (or (or (or (and (and (and (and (and (or (not ?v_0) (= ?v_1 unit)) (or (not (= (op e1 ?v_2) e0)) (= ?v_2 unit))) (or (not (= (op e2 ?v_3) e0)) (= ?v_3 unit))) (or (not (= (op e3 ?v_4) e0)) (= ?v_4 unit))) (or (not (= (op e4 ?v_5) e0)) (= ?v_5 unit))) (or (not (= (op e5 ?v_6) e0)) (= ?v_6 unit))) (and (and (and (and (and (or (not (= (op e0 ?v_7) e1)) (= ?v_7 unit)) (or (not ?v_8) (= ?v_9 unit))) (or (not (= (op e2 ?v_10) e1)) (= ?v_10 unit))) (or (not (= (op e3 ?v_11) e1)) (= ?v_11 unit))) (or (not (= (op e4 ?v_12) e1)) (= ?v_12 unit))) (or (not (= (op e5 ?v_13) e1)) (= ?v_13 unit)))) (and (and (and (and (and (or (not (= (op e0 ?v_14) e2)) (= ?v_14 unit)) (or (not (= (op e1 ?v_15) e2)) (= ?v_15 unit))) (or (not ?v_16) (= ?v_17 unit))) (or (not (= (op e3 ?v_18) e2)) (= ?v_18 unit))) (or (not (= (op e4 ?v_19) e2)) (= ?v_19 unit))) (or (not (= (op e5 ?v_20) e2)) (= ?v_20 unit)))) (and (and (and (and (and (or (not (= (op e0 ?v_21) e3)) (= ?v_21 unit)) (or (not (= (op e1 ?v_22) e3)) (= ?v_22 unit))) (or (not (= (op e2 ?v_23) e3)) (= ?v_23 unit))) (or (not ?v_24) (= ?v_25 unit))) (or (not (= (op e4 ?v_26) e3)) (= ?v_26 unit))) (or (not (= (op e5 ?v_27) e3)) (= ?v_27 unit)))) (and (and (and (and (and (or (not (= (op e0 ?v_28) e4)) (= ?v_28 unit)) (or (not (= (op e1 ?v_29) e4)) (= ?v_29 unit))) (or (not (= (op e2 ?v_30) e4)) (= ?v_30 unit))) (or (not (= (op e3 ?v_31) e4)) (= ?v_31 unit))) (or (not ?v_32) (= ?v_33 unit))) (or (not (= (op e5 ?v_34) e4)) (= ?v_34 unit)))) (and (and (and (and (and (or (not (= (op e0 ?v_35) e5)) (= ?v_35 unit)) (or (not (= (op e1 ?v_36) e5)) (= ?v_36 unit))) (or (not (= (op e2 ?v_37) e5)) (= ?v_37 unit))) (or (not (= (op e3 ?v_38) e5)) (= ?v_38 unit))) (or (not (= (op e4 ?v_39) e5)) (= ?v_39 unit))) (or (not ?v_40) (= ?v_41 unit)))))))) (assert (= unit e0)) (assert (let ((?v_0 (op e0 e0)) (?v_6 (op e0 e1)) (?v_12 (op e0 e2)) (?v_18 (op e0 e3)) (?v_24 (op e0 e4)) (?v_30 (op e0 e5)) (?v_1 (op e1 e0)) (?v_7 (op e1 e1)) (?v_13 (op e1 e2)) (?v_19 (op e1 e3)) (?v_25 (op e1 e4)) (?v_31 (op e1 e5)) (?v_2 (op e2 e0)) (?v_8 (op e2 e1)) (?v_14 (op e2 e2)) (?v_20 (op e2 e3)) (?v_26 (op e2 e4)) (?v_32 (op e2 e5)) (?v_3 (op e3 e0)) (?v_9 (op e3 e1)) (?v_15 (op e3 e2)) (?v_21 (op e3 e3)) (?v_27 (op e3 e4)) (?v_33 (op e3 e5)) (?v_4 (op e4 e0)) (?v_10 (op e4 e1)) (?v_16 (op e4 e2)) (?v_22 (op e4 e3)) (?v_28 (op e4 e4)) (?v_34 (op e4 e5)) (?v_5 (op e5 e0)) (?v_11 (op e5 e1)) (?v_17 (op e5 e2)) (?v_23 (op e5 e3)) (?v_29 (op e5 e4)) (?v_35 (op e5 e5))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_1)) (not (= ?v_0 ?v_2))) (not (= ?v_0 ?v_3))) (not (= ?v_0 ?v_4))) (not (= ?v_0 ?v_5))) (not (= ?v_1 ?v_2))) (not (= ?v_1 ?v_3))) (not (= ?v_1 ?v_4))) (not (= ?v_1 ?v_5))) (not (= ?v_2 ?v_3))) (not (= ?v_2 ?v_4))) (not (= ?v_2 ?v_5))) (not (= ?v_3 ?v_4))) (not (= ?v_3 ?v_5))) (not (= ?v_4 ?v_5))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_6 ?v_7)) (not (= ?v_6 ?v_8))) (not (= ?v_6 ?v_9))) (not (= ?v_6 ?v_10))) (not (= ?v_6 ?v_11))) (not (= ?v_7 ?v_8))) (not (= ?v_7 ?v_9))) (not (= ?v_7 ?v_10))) (not (= ?v_7 ?v_11))) (not (= ?v_8 ?v_9))) (not (= ?v_8 ?v_10))) (not (= ?v_8 ?v_11))) (not (= ?v_9 ?v_10))) (not (= ?v_9 ?v_11))) (not (= ?v_10 ?v_11)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_12 ?v_13)) (not (= ?v_12 ?v_14))) (not (= ?v_12 ?v_15))) (not (= ?v_12 ?v_16))) (not (= ?v_12 ?v_17))) (not (= ?v_13 ?v_14))) (not (= ?v_13 ?v_15))) (not (= ?v_13 ?v_16))) (not (= ?v_13 ?v_17))) (not (= ?v_14 ?v_15))) (not (= ?v_14 ?v_16))) (not (= ?v_14 ?v_17))) (not (= ?v_15 ?v_16))) (not (= ?v_15 ?v_17))) (not (= ?v_16 ?v_17)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_18 ?v_19)) (not (= ?v_18 ?v_20))) (not (= ?v_18 ?v_21))) (not (= ?v_18 ?v_22))) (not (= ?v_18 ?v_23))) (not (= ?v_19 ?v_20))) (not (= ?v_19 ?v_21))) (not (= ?v_19 ?v_22))) (not (= ?v_19 ?v_23))) (not (= ?v_20 ?v_21))) (not (= ?v_20 ?v_22))) (not (= ?v_20 ?v_23))) (not (= ?v_21 ?v_22))) (not (= ?v_21 ?v_23))) (not (= ?v_22 ?v_23)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_24 ?v_25)) (not (= ?v_24 ?v_26))) (not (= ?v_24 ?v_27))) (not (= ?v_24 ?v_28))) (not (= ?v_24 ?v_29))) (not (= ?v_25 ?v_26))) (not (= ?v_25 ?v_27))) (not (= ?v_25 ?v_28))) (not (= ?v_25 ?v_29))) (not (= ?v_26 ?v_27))) (not (= ?v_26 ?v_28))) (not (= ?v_26 ?v_29))) (not (= ?v_27 ?v_28))) (not (= ?v_27 ?v_29))) (not (= ?v_28 ?v_29)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_30 ?v_31)) (not (= ?v_30 ?v_32))) (not (= ?v_30 ?v_33))) (not (= ?v_30 ?v_34))) (not (= ?v_30 ?v_35))) (not (= ?v_31 ?v_32))) (not (= ?v_31 ?v_33))) (not (= ?v_31 ?v_34))) (not (= ?v_31 ?v_35))) (not (= ?v_32 ?v_33))) (not (= ?v_32 ?v_34))) (not (= ?v_32 ?v_35))) (not (= ?v_33 ?v_34))) (not (= ?v_33 ?v_35))) (not (= ?v_34 ?v_35)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_0 ?v_6)) (not (= ?v_0 ?v_12))) (not (= ?v_0 ?v_18))) (not (= ?v_0 ?v_24))) (not (= ?v_0 ?v_30))) (not (= ?v_6 ?v_12))) (not (= ?v_6 ?v_18))) (not (= ?v_6 ?v_24))) (not (= ?v_6 ?v_30))) (not (= ?v_12 ?v_18))) (not (= ?v_12 ?v_24))) (not (= ?v_12 ?v_30))) (not (= ?v_18 ?v_24))) (not (= ?v_18 ?v_30))) (not (= ?v_24 ?v_30))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_1 ?v_7)) (not (= ?v_1 ?v_13))) (not (= ?v_1 ?v_19))) (not (= ?v_1 ?v_25))) (not (= ?v_1 ?v_31))) (not (= ?v_7 ?v_13))) (not (= ?v_7 ?v_19))) (not (= ?v_7 ?v_25))) (not (= ?v_7 ?v_31))) (not (= ?v_13 ?v_19))) (not (= ?v_13 ?v_25))) (not (= ?v_13 ?v_31))) (not (= ?v_19 ?v_25))) (not (= ?v_19 ?v_31))) (not (= ?v_25 ?v_31)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_2 ?v_8)) (not (= ?v_2 ?v_14))) (not (= ?v_2 ?v_20))) (not (= ?v_2 ?v_26))) (not (= ?v_2 ?v_32))) (not (= ?v_8 ?v_14))) (not (= ?v_8 ?v_20))) (not (= ?v_8 ?v_26))) (not (= ?v_8 ?v_32))) (not (= ?v_14 ?v_20))) (not (= ?v_14 ?v_26))) (not (= ?v_14 ?v_32))) (not (= ?v_20 ?v_26))) (not (= ?v_20 ?v_32))) (not (= ?v_26 ?v_32)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_3 ?v_9)) (not (= ?v_3 ?v_15))) (not (= ?v_3 ?v_21))) (not (= ?v_3 ?v_27))) (not (= ?v_3 ?v_33))) (not (= ?v_9 ?v_15))) (not (= ?v_9 ?v_21))) (not (= ?v_9 ?v_27))) (not (= ?v_9 ?v_33))) (not (= ?v_15 ?v_21))) (not (= ?v_15 ?v_27))) (not (= ?v_15 ?v_33))) (not (= ?v_21 ?v_27))) (not (= ?v_21 ?v_33))) (not (= ?v_27 ?v_33)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_4 ?v_10)) (not (= ?v_4 ?v_16))) (not (= ?v_4 ?v_22))) (not (= ?v_4 ?v_28))) (not (= ?v_4 ?v_34))) (not (= ?v_10 ?v_16))) (not (= ?v_10 ?v_22))) (not (= ?v_10 ?v_28))) (not (= ?v_10 ?v_34))) (not (= ?v_16 ?v_22))) (not (= ?v_16 ?v_28))) (not (= ?v_16 ?v_34))) (not (= ?v_22 ?v_28))) (not (= ?v_22 ?v_34))) (not (= ?v_28 ?v_34)))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= ?v_5 ?v_11)) (not (= ?v_5 ?v_17))) (not (= ?v_5 ?v_23))) (not (= ?v_5 ?v_29))) (not (= ?v_5 ?v_35))) (not (= ?v_11 ?v_17))) (not (= ?v_11 ?v_23))) (not (= ?v_11 ?v_29))) (not (= ?v_11 ?v_35))) (not (= ?v_17 ?v_23))) (not (= ?v_17 ?v_29))) (not (= ?v_17 ?v_35))) (not (= ?v_23 ?v_29))) (not (= ?v_23 ?v_35))) (not (= ?v_29 ?v_35))))))) (assert (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (= e0 e1)) (not (= e0 e2))) (not (= e0 e3))) (not (= e0 e4))) (not (= e0 e5))) (not (= e1 e2))) (not (= e1 e3))) (not (= e1 e4))) (not (= e1 e5))) (not (= e2 e3))) (not (= e2 e4))) (not (= e2 e5))) (not (= e3 e4))) (not (= e3 e5))) (not (= e4 e5)))) (check-sat) (exit) opensmt-2.5.2/test/define-fun.smt2000066400000000000000000000001541445011647600170230ustar00rootroot00000000000000(define-fun foo ((a integer) (b real) (c frobbozian)) ((_ bv0 1 2 3 4) q q1 q2 q3) (let ((x 1) (y 2)) bar)) opensmt-2.5.2/test/edit.smt2000066400000000000000000000004451445011647600157330ustar00rootroot00000000000000; This example is completed with comments. (set-logic QF_BV) (set-info :source | Constructed by Trevor Hansen to test bvnor nesting. |) (set-info :smt-lib-version 2.0) (set-info :category "check") (set-info :status unsat) (declare-fun v0 () (_ BitVec 1)) (assert (not (= v0 v0))) (check-sat) opensmt-2.5.2/test/error.smt2000066400000000000000000000000371445011647600161340ustar00rootroot00000000000000(assert foo) (set-logic AB_CD) opensmt-2.5.2/test/let-example.smt2000066400000000000000000000004261445011647600172220ustar00rootroot00000000000000(set-logic QF_UF) (declare-sort U 0) (declare-fun v0 () U) (declare-fun v1 () U) (declare-fun b0 () Bool) (assert (and (let ((?e0 (= v0 v1))) (let ((?d1 (not b0))) (or ?e0 ?d1))) (let ((?e0 (distinct v0 v1))) (let ((?d1 b0)) (or ?e0 ?d1))))) (check-sat) opensmt-2.5.2/test/let-example2.smt2000066400000000000000000000002051445011647600172770ustar00rootroot00000000000000(set-logic QF_UF) (assert (or (let ((a true) (b (let ((a false)) (not a)))) (and a b)) (let ((a true)) (not a)))) (check-sat) (exit) opensmt-2.5.2/test/options.smt2000066400000000000000000000002241445011647600164740ustar00rootroot00000000000000(set-option :print-success true) (set-option :foo bar) (get-option :foo) (get-option :print-success) ; should fail (set-option :print-success quux) opensmt-2.5.2/test/parse_test.list000066400000000000000000025146311445011647600172560ustar00rootroot00000000000000/Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_4_1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_4_2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_4_3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_4_4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_4_5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_4_6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_11.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_13.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_14.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_16.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_17.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_18.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_19.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_20.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_21.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_22.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_23.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_24.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_25.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_26.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_28.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_31.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_33.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_34.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_35.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_36.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_37.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_38.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_39.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_40.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_41.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_42.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_43.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_44.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_45.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_46.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_47.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_48.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_49.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_50.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_51.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_52.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_53.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_54.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_55.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_56.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_57.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_58.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_59.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_60.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_61.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_62.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_63.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_64.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_5_9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_11.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_12.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_13.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_14.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_15.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_16.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_17.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_18.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_19.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_20.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_21.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_22.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_23.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_24.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_25.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_26.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_27.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_28.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_29.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_30.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_31.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_32.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_33.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_34.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_35.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_36.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_37.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_38.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_39.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_40.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_41.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_42.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_43.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_44.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_45.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_46.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_47.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_48.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_49.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_50.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_51.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_52.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_53.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_54.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_55.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_56.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_57.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_58.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_59.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_60.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_61.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_62.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_63.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_64.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_65.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_66.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_67.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_68.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_69.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_70.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_71.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_72.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_73.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_74.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_75.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_76.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_77.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_78.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_79.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_80.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/model/model_6_9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_11.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_12.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_13.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_14.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_15.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_16.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_17.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_18.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_19.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_20.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_21.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_22.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_23.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_24.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_25.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_26.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_27.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_28.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_29.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_30.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_3_9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_11.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_12.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_13.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_14.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_15.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_16.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_17.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_18.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_19.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_20.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_21.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_22.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_23.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_24.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_25.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_26.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_27.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_28.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_29.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_30.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_4_9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_11.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_12.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_13.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_14.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_15.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_16.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_17.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_18.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_19.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_20.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_21.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_22.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_23.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_24.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_25.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_26.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_27.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_28.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_29.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_30.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_31.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_32.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_33.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_34.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_35.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_36.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_37.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_38.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_39.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_40.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RND/RND_6_9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_11.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_12.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_13.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_14.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_15.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_16.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_17.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_18.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_19.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_20.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_21.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_22.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_23.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_24.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_25.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_26.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_27.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_28.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_29.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_30.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_31.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_32.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_33.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_34.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_35.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_36.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_37.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_38.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_39.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_40.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_41.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_42.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_43.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_44.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_45.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_46.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_47.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_48.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_49.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_50.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_51.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_52.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_53.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_54.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_55.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_56.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_57.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_58.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_59.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_60.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_3_9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_11.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_12.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_13.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_14.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_15.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_16.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_17.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_18.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_19.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_20.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_21.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_22.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_23.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_24.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_25.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_26.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_27.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_28.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_29.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_30.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_31.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_32.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_33.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_34.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_35.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_36.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_37.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_38.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_39.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_40.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_41.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_42.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_43.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_44.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_45.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_46.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_47.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_48.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_49.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_50.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_51.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_52.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_53.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_54.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_55.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_56.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_57.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_58.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_59.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_60.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_61.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_62.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_63.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_64.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_65.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_66.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_67.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_68.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_69.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_70.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/LRA/scholl-smt08/RNDPRE/RNDPRE_4_9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/altair1.10.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/altair1.16.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/altair1.20.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/altair1.37.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/altair1.42.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/altair1.48.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/altair1.54.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/altair1.9.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/penrose.11.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/penrose.12.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/penrose.31.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/penrose.34.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/penrose.35.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/penrose.44.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/penrose.45.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/penrose.48.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/penrose.50.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/penrose.60.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/penrosesmall.5.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/trisquares.11.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/trisquares.19.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/trisquares.35.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/trisquares.40.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/trisquares.41.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/trisquares.43.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/trisquares.47.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/trisquares.49.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/trisquares.54.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_BV/asp/GeneralizedSlitherlink/trisquares.59.asp.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/check/bignum_lra1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/check/bignum_lra2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_10clocks.main_invar.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_10clocks.main_invar.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_10clocks.worst_case_skew.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_10clocks.worst_case_skew.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_2clocks.main_invar.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_2clocks.main_invar.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_2clocks.worst_case_skew.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_2clocks.worst_case_skew.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_3clocks.main_invar.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_3clocks.main_invar.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_3clocks.worst_case_skew.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_3clocks.worst_case_skew.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_4clocks.main_invar.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_4clocks.main_invar.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_4clocks.worst_case_skew.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_4clocks.worst_case_skew.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_5clocks.main_invar.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_5clocks.main_invar.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_5clocks.worst_case_skew.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_5clocks.worst_case_skew.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_6clocks.main_invar.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_6clocks.main_invar.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_6clocks.worst_case_skew.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_6clocks.worst_case_skew.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_7clocks.main_invar.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_7clocks.main_invar.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_7clocks.worst_case_skew.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_7clocks.worst_case_skew.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_8clocks.main_invar.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_8clocks.main_invar.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_8clocks.worst_case_skew.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_8clocks.worst_case_skew.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_9clocks.main_invar.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_9clocks.main_invar.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_9clocks.worst_case_skew.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/clock_synchro/clocksynchro_9clocks.worst_case_skew.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking01.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking02.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking03.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking04.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking05.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking06.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking07.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking08.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking09.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking11.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking12.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking13.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking14.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking15.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking16.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking17.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking18.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking19.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking20.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking21.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking22.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-cooking23.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-depth-10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-depth-100.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-depth-150.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-depth-2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-depth-20.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-depth-3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-depth-30.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-depth-4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-depth-40.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-depth-5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-depth-50.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-depth-6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-depth-7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-depth-8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-depth-9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-matrix1x1.pddl.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-matrix2x2.pddl.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-matrix3x3.pddl.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-matrix4x4.pddl.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-matrix5x5.pddl.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-matrix6x6.pddl.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-matrix7x7.pddl.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-matrix8x8.pddl.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-width-1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-width-10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-width-2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-width-20.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-width-3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-width-30.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-width-4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-width-40.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-width-5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-width-50.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-width-6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-width-60.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-width-7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-width-70.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-width-8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tempo-width-9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-temporal-machine-shop-2-3-A03.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-temporal-machine-shop-2-3-A04.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-temporal-machine-shop-2-3-A05.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-temporal-machine-shop-2-3-A06.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-temporal-machine-shop-2-3-A07.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-temporal-machine-shop-2-3-A08.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-temporal-machine-shop-2-3-A09.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-temporal-machine-shop-2-3-A10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-temporal-machine-shop-2-3-A20.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-temporal-machine-shop-2-3-A30.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-temporal-machine-shop-2-3-A40.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-temporal-machine-shop-2-3-A60.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-temporal-machine-shop-2-3-A70.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-temporal-machine-shop-2-3-A80.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tms-2-3-light-03.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tms-2-3-light-04.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tms-2-3-light-05.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tms-2-3-light-06.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tms-2-3-light-07.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tms-2-3-light-08.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tms-2-3-light-09.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tms-2-3-light-10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tms-2-3-light-20.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tms-2-3-light-30.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tms-2-3-light-40.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tms-2-3-light-60.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tms-2-3-light-70.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tms-2-3-light-80.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/DTP-Scheduling/constraints-tms-2-3-light-90.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/danoint-166.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/danoint-266.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/danoint-30.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/danoint-50.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/danoint-65.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/danoint-66.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/fixnet-1000.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/fixnet-3000.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/fixnet-3983.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/fixnet-5000.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/fixnet-7000.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/opt1217--1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/opt1217--11.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/opt1217--16.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/opt1217--17.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/opt1217--27.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/opt1217--37.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/opt1217--57.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/opt1217--6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/pk1--1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/pk1-0.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/pk1-100.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/pk1-11.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/pk1-20.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/pk1-50.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/pp08a-1000.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/pp08a-10000.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/pp08a-11000.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/pp08a-12000.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/pp08a-2000.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/pp08a-3000.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/pp08a-4000.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/pp08a-5000.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/pp08a-7349.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/pp08a-7350.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/pp08a-9000.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/vpm2-0.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/vpm2-10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/vpm2-13.75.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/vpm2-20.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/vpm2-30.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/miplib/vpm2-5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/carpark/Carpark2-ausgabe-1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/carpark/Carpark2-ausgabe-2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/carpark/Carpark2-ausgabe-3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/carpark/Carpark2-ausgabe-4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/carpark/Carpark2-ausgabe-5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/carpark/Carpark2-ausgabe-6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/carpark/Carpark2-ausgabe-7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/carpark/Carpark2-ausgabe-8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/carpark/Carpark2-t1-1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/carpark/Carpark2-t1-2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/carpark/Carpark2-t1-3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/carpark/Carpark2-t1-4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/gasburner/gasburner-prop3-1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/gasburner/gasburner-prop3-10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/gasburner/gasburner-prop3-11.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/gasburner/gasburner-prop3-12.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/gasburner/gasburner-prop3-13.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/gasburner/gasburner-prop3-14.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/gasburner/gasburner-prop3-15.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/gasburner/gasburner-prop3-16.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/gasburner/gasburner-prop3-17.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/gasburner/gasburner-prop3-18.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/gasburner/gasburner-prop3-19.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/gasburner/gasburner-prop3-2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/gasburner/gasburner-prop3-20.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/gasburner/gasburner-prop3-3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/gasburner/gasburner-prop3-4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/gasburner/gasburner-prop3-5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/gasburner/gasburner-prop3-6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/gasburner/gasburner-prop3-7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/gasburner/gasburner-prop3-8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/gasburner/gasburner-prop3-9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/pursuit/pursuit-safety-1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/pursuit/pursuit-safety-10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/pursuit/pursuit-safety-11.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/pursuit/pursuit-safety-12.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/pursuit/pursuit-safety-13.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/pursuit/pursuit-safety-14.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/pursuit/pursuit-safety-15.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/pursuit/pursuit-safety-16.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/pursuit/pursuit-safety-17.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/pursuit/pursuit-safety-18.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/pursuit/pursuit-safety-19.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/pursuit/pursuit-safety-2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/pursuit/pursuit-safety-20.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/pursuit/pursuit-safety-3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/pursuit/pursuit-safety-4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/pursuit/pursuit-safety-5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/pursuit/pursuit-safety-6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/pursuit/pursuit-safety-7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/pursuit/pursuit-safety-8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/pursuit/pursuit-safety-9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-nosafe-1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-nosafe-2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-nosafe-3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-nosafe-4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-nosafe-5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-nosafe-6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-nosafe-7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-safe-1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-safe-10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-safe-11.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-safe-12.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-safe-13.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-safe-14.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-safe-15.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-safe-16.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-safe-17.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-safe-18.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-safe-19.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-safe-2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-safe-20.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-safe-3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-safe-4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-safe-5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-safe-6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-safe-7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-safe-8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/tgc/tgc_io-safe-9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-no_t_deadlock-1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-no_t_deadlock-10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-no_t_deadlock-11.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-no_t_deadlock-12.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-no_t_deadlock-13.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-no_t_deadlock-14.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-no_t_deadlock-15.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-no_t_deadlock-16.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-no_t_deadlock-17.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-no_t_deadlock-18.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-no_t_deadlock-19.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-no_t_deadlock-2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-no_t_deadlock-20.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-no_t_deadlock-3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-no_t_deadlock-4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-no_t_deadlock-5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-no_t_deadlock-6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-no_t_deadlock-7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-no_t_deadlock-8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-no_t_deadlock-9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-safe-1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-safe-2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-safe-3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-safe-4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-safe2-1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-safe2-2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-safe2-3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sal/windowreal/windowreal-safe2-4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-10.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-10.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-10.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-10.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-11.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-11.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-11.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-11.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-12.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-12.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-12.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-12.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-13.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-13.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-13.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-13.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-14.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-14.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-14.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-14.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-15.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-15.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-15.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-15.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-16.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-16.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-16.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-16.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-17.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-17.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-17.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-17.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-18.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-18.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-18.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-18.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-19.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-19.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-19.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-19.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-20.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-20.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-20.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-20.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-21.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-21.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-21.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-21.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-22.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-22.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-22.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-22.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-23.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-23.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-23.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-23.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-24.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-24.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-24.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-24.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-25.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-25.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-25.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-25.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-26.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-26.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-26.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-26.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-27.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-27.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-27.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-27.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-28.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-28.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-28.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-28.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-29.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-29.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-29.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-29.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-30.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-30.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-30.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-30.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-31.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-31.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-31.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-31.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-32.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-32.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-32.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-32.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-33.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-33.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-33.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-33.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-34.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-34.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-34.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-34.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-35.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-35.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-35.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-35.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-36.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-36.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-36.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-36.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-37.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-37.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-37.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-37.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-38.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-38.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-38.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-38.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-39.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-39.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-39.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-39.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-40.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-40.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-40.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-40.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-5.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-5.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-5.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-5.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-6.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-6.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-6.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-6.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-7.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-7.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-7.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-7.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-8.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-8.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-8.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-8.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-9.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-9.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-9.induction2.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/sc/sc-9.induction3.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/bad_echos_ascend.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/bad_echos_ascend.induction.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/current_frame.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/current_frame.induction.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/frame_prop.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/frame_prop.induction.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/fs_frame_gap.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/fs_frame_gap.induction.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/fs_init_no_op_accs.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/fs_init_no_op_accs.induction.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/fs_no_op_accs.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/fs_no_op_accs.induction.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/fs_not_sc_seen.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/fs_not_sc_seen.induction.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/fs_window.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/fs_window.induction.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/good_frame_update.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/good_frame_update.induction.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/mode_cntrl.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/mode_cntrl.induction.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/no_op_accs.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/no_op_accs.induction.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/op_seen_less2.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/op_seen_less2.induction.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/op_seen_more1.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/op_seen_more1.induction.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/pd_finish.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/pd_finish.induction.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/pd_init_op_accs.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/pd_init_op_accs.induction.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/pd_no_op_accs.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/pd_no_op_accs.induction.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/pd_not_fs_seen.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/pd_not_fs_seen.induction.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/pd_not_sc_seen.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/pd_not_sc_seen.induction.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/reint_to_least.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/reint_to_least.induction.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/sc_init_frame_gap.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/sc_init_frame_gap.induction.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/synched.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/spider_benchmarks/synched.induction.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p-0-bucket_s10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p-0-bucket_s13.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p-0-bucket_s7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p-1-bucket_s9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p-2-bucket_s11.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p-3-bucket_s10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p-DepotsNum_s8.msat.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p-driverlogNumeric_s7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p2-driverlogNumeric_s10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p2-zenonumeric_s6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p3-driverlogNumeric_s8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p3-zenonumeric_s5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p4-driverlogNumeric_s8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p4-zenonumeric_s5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p5-driverlogNumeric_s8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p5-driverlogNumeric_s9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p5-zenonumeric_s5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p5-zenonumeric_s7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p6-driverlogNumeric_s5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p6-zenonumeric_s5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p6-zenonumeric_s7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p6-zenonumeric_s9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p7-driverlogNumeric_s7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p7-driverlogNumeric_s8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/TM/p7-zenonumeric_s6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_10nodes.abstract.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_10nodes.abstract.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_10nodes.bug.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_10nodes.missing.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_10nodes.synchro.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_10nodes.synchro.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_11nodes.abstract.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_11nodes.abstract.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_11nodes.bug.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_11nodes.missing.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_11nodes.synchro.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_11nodes.synchro.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_12nodes.abstract.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_12nodes.abstract.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_12nodes.bug.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_12nodes.missing.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_12nodes.synchro.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_12nodes.synchro.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_14nodes.abstract.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_14nodes.abstract.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_14nodes.bug.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_14nodes.missing.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_14nodes.synchro.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_14nodes.synchro.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_15nodes.abstract.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_15nodes.abstract.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_15nodes.bug.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_15nodes.missing.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_15nodes.synchro.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_15nodes.synchro.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_3nodes.abstract.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_3nodes.abstract.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_3nodes.bug.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_3nodes.missing.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_3nodes.synchro.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_3nodes.synchro.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_4nodes.abstract.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_4nodes.abstract.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_4nodes.bug.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_4nodes.missing.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_4nodes.synchro.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_4nodes.synchro.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_5nodes.abstract.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_5nodes.abstract.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_5nodes.bug.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_5nodes.missing.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_5nodes.synchro.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_5nodes.synchro.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_6nodes.abstract.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_6nodes.abstract.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_6nodes.bug.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_6nodes.missing.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_6nodes.synchro.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_6nodes.synchro.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_7nodes.abstract.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_7nodes.abstract.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_7nodes.bug.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_7nodes.missing.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_7nodes.synchro.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_7nodes.synchro.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_8nodes.abstract.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_8nodes.abstract.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_8nodes.bug.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_8nodes.missing.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_8nodes.synchro.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_8nodes.synchro.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_9nodes.abstract.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_9nodes.abstract.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_9nodes.bug.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_9nodes.missing.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_9nodes.synchro.base.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/tta_startup/simple_startup_9nodes.synchro.induct.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-10.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-10.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-11.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-11.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-12.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-12.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-13.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-13.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-14.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-14.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-15.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-15.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-16.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-16.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-17.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-17.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-18.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-18.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-19.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-19.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-20-with-lemmas.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-20.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-20.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-21.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-21.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-22.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-22.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-23.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-23.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-24.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-24.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-25.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-25.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-26.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-26.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-27.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-27.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-28.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-28.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-29.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-29.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-30.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-30.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-31.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-31.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-32.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-32.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-33.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-33.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-34.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-34.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-35.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-35.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-36.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-36.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-37.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-37.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-38.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-38.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-39.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-39.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-40.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-40.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-5.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-5.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-6.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-6.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-7.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-7.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-8.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-8.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-9.base.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_LRA/uart/uart-9.induction.cvc.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond1.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond100.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond11.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond12.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond13.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond14.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond15.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond16.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond17.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond18.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond19.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond20.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond21.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond22.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond23.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond24.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond25.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond26.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond27.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond28.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond29.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond30.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond31.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond32.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond33.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond34.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond35.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond36.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond37.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond38.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond39.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond40.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond41.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond42.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond43.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond44.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond45.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond46.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond47.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond48.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond49.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond50.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond51.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond52.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond53.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond54.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond55.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond56.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond57.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond58.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond59.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond60.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond61.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond62.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond63.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond64.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond65.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond66.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond67.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond68.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond69.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond70.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond71.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond72.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond73.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond74.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond75.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond76.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond77.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond78.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond79.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond80.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond81.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond82.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond83.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond84.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond85.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond86.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond87.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond88.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond89.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond90.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond91.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond92.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond93.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond94.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond95.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond96.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond97.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond98.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/eq_diamond/eq_diamond99.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ004_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ004_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ004_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ004_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ006_size3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ006_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ006_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ006_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ015_size3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ015_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ015_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ015_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ016_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ016_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ016_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ016_size8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ023_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ023_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ023_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ023_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ027_size10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ027_size11.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ027_size8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ027_size9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ031_size10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ031_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ031_size8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ031_size9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ032_size3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ032_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ032_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ032_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ033_size3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ033_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ033_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ033_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ041_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ041_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ041_size8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ041_size9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ046_size3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ046_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ046_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ046_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ048_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ048_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ048_size8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/NEQ/NEQ048_size9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ002_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ002_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ002_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ002_size8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ003_size10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ003_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ003_size8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ003_size9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ004_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ004_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ004_size8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ004_size9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ010_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ010_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ010_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ010_size8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ011_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ011_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ011_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ011_size8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ012_size3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ012_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ012_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ012_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ013_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ013_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ013_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ013_size8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ014_size10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ014_size11.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ014_size8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ014_size9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ016_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ016_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ016_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ016_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ018_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ018_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ018_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ018_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ019_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ019_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ019_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ019_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ020_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ020_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/PEQ/PEQ020_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/dead_dnd001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/dead_dnd002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/dead_dnd003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/dead_dnd004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/dead_dnd005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/dead_dnd006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/dead_dnd007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/dead_dnd008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/dead_dnd009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/dead_dnd010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/dead_dnd011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/dead_dnd012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/dead_dnd013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/dead_dnd014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/dead_dnd015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/dead_dnd016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/dead_dnd017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/dead_dnd018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn019.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn020.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn021.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn022.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn023.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn024.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn025.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn026.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn027.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn028.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn029.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn030.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn031.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn032.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn033.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn034.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn035.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn036.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn037.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn038.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn039.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn040.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn041.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn042.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn043.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn044.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn045.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn046.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn047.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn048.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn049.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn050.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn051.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn052.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn053.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn054.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn055.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn056.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn057.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn058.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn059.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn060.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn061.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn062.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn063.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn064.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn065.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn066.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn067.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn068.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn069.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn070.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn071.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn072.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn073.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn074.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn075.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn076.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn077.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn078.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn079.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn080.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn081.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn082.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn083.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn084.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn085.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn086.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn087.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn088.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn089.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn090.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn091.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn092.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn093.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn094.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn095.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn096.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn097.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn098.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn099.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn100.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn101.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn102.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn103.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn104.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn105.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_brn106.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl019.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl020.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl021.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl022.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl023.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl024.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl025.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl026.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl027.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl028.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl029.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl030.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl031.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl032.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl033.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl034.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl035.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl036.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl037.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl038.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl039.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl040.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl041.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl042.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl043.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl044.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl045.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl046.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl047.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl048.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl049.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl050.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl051.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl052.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl053.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl054.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl055.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl056.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl057.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl058.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl059.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl060.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl061.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl062.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl063.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl064.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl065.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl066.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl067.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl068.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl069.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl070.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl071.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl072.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl073.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl074.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl075.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl076.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl077.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl078.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl079.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl080.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl081.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl082.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl083.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl084.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl085.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl086.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl087.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl088.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl089.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl090.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl091.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl092.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl093.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl094.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl095.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl096.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl097.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl098.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl099.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl100.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl101.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl102.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl103.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl104.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl105.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl106.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl107.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl108.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/gensys_icl109.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn019.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn020.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn021.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn022.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn023.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn024.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn025.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn026.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn027.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn028.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn029.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn030.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn031.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn032.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn033.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn034.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn035.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn036.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn037.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn038.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn039.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn040.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn041.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn042.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn043.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn044.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn045.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn046.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn047.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn048.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn049.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn050.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn051.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn052.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn053.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn054.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn055.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn056.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn057.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn058.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn059.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn060.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn061.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn062.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn063.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn064.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn065.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn066.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn067.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn068.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn069.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn070.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn071.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn072.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn073.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn074.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn075.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn076.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn077.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn078.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn079.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn080.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn081.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn082.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn083.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn084.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn085.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn086.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn087.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn088.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn089.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn090.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn091.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn092.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn093.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn094.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn095.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn096.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn097.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn098.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn099.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn100.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn101.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn102.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn103.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn104.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn105.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_brn106.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl019.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl020.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl021.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl022.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl023.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl024.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl025.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl026.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl027.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl028.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl029.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl030.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl031.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl032.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl033.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl034.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl035.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl036.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl037.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl038.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl039.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl040.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl041.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl042.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl043.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl044.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl045.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl046.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl047.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl048.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl049.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl050.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl051.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl052.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl053.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl054.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl055.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl056.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl057.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl058.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl059.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl060.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl061.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl062.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl063.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl064.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl065.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl066.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl067.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl068.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl069.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl070.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl071.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl072.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl073.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl074.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl075.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl076.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl077.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl078.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl079.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl080.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl081.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl082.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl083.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl084.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl085.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl086.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl087.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl088.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl089.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl090.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl091.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl092.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl093.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl094.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl095.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl096.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl097.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl098.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl099.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl100.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl101.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl102.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl103.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl104.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl105.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl106.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl107.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl108.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/loops6/iso_icl109.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd019.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd020.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd021.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd022.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd023.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd024.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd025.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd026.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd027.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd028.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd029.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd030.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd031.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd032.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd033.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd034.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd035.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd036.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd037.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd038.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd039.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd040.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd041.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd042.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd043.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd044.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd045.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd046.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd047.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd048.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd049.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd050.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd051.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd052.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd053.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd054.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd055.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd056.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd057.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd058.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd059.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd060.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd061.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd062.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd063.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd064.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd065.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/dead_dnd066.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn019.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn020.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn021.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn022.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn023.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn024.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn025.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn026.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn027.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn028.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn029.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn030.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn031.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn032.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn033.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn034.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn035.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn036.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn037.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn038.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn039.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn040.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn041.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn042.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn043.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn044.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn045.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn046.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn047.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn048.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn049.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn050.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn051.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn052.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn053.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn054.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn055.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn056.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn057.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn058.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn059.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn060.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn061.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn062.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn063.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn064.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn065.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn066.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn067.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn068.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn069.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn070.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn071.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn072.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn073.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn074.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn075.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn076.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn077.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn078.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn079.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn080.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn081.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn082.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn083.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn084.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn085.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn086.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn087.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn088.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn089.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn090.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn091.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn092.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn093.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn094.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn095.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn096.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn097.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn098.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn099.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn100.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1000.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn101.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1019.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn102.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1020.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1021.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1022.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1023.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1024.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1025.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1026.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1027.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1028.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1029.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn103.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1030.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1031.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1032.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1033.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1034.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1035.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1036.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1037.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1038.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1039.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn104.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1040.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1041.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1042.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1043.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1044.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1045.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1046.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1047.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1048.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1049.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn105.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1050.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1051.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1052.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1053.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1054.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1055.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1056.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1057.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1058.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1059.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn106.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1060.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1061.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1062.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1063.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1064.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1065.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1066.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1067.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1068.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1069.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn107.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1070.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1071.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1072.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1073.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1074.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1075.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1076.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1077.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1078.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1079.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn108.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1080.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1081.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1082.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1083.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1084.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1085.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1086.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1087.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1088.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1089.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn109.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1090.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1091.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1092.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1093.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1094.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1095.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1096.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1097.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1098.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1099.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn110.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1100.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1101.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1102.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1103.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1104.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1105.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1106.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1107.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1108.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1109.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn111.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1110.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1111.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1112.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1113.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1114.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1115.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1116.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1117.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1118.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1119.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn112.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1120.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1121.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1122.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1123.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1124.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1125.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1126.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1127.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1128.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1129.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn113.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1130.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1131.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1132.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1133.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1134.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1135.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1136.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1137.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1138.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1139.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn114.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1140.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1141.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1142.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1143.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1144.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1145.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1146.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1147.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1148.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1149.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn115.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1150.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1151.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1152.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1153.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1154.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1155.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1156.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1157.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1158.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1159.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn116.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1160.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1161.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1162.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1163.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1164.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1165.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1166.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1167.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1168.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1169.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn117.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1170.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1171.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1172.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1173.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1174.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1175.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1176.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1177.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1178.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1179.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn118.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1180.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1181.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1182.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1183.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1184.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1185.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1186.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1187.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1188.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1189.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn119.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1190.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1191.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1192.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1193.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1194.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1195.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1196.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1197.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1198.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1199.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn120.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1200.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1201.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1202.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1203.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1204.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1205.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1206.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1207.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1208.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1209.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn121.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1210.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1211.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1212.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1213.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1214.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1215.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1216.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1217.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1218.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1219.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn122.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1220.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1221.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1222.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1223.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1224.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1225.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1226.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1227.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1228.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1229.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn123.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1230.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1231.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1232.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1233.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1234.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1235.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1236.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1237.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1238.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1239.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn124.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1240.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1241.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1242.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1243.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1244.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1245.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1246.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1247.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1248.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1249.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn125.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1250.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1251.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1252.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1253.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1254.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1255.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1256.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1257.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1258.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1259.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn126.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1260.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1261.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1262.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1263.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1264.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1265.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1266.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1267.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1268.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1269.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn127.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1270.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1271.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1272.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1273.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1274.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1275.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1276.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1277.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1278.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1279.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn128.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1280.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1281.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1282.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1283.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1284.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1285.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1286.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1287.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1288.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1289.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn129.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1290.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1291.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1292.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1293.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1294.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1295.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1296.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1297.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1298.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1299.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn130.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1300.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1301.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1302.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1303.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1304.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1305.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1306.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1307.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1308.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1309.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn131.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1310.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1311.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1312.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1313.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1314.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1315.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1316.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1317.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1318.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1319.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn132.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1320.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1321.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1322.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1323.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1324.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1325.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1326.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn1327.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn133.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn134.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn135.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn136.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn137.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn138.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn139.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn140.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn141.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn142.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn143.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn144.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn145.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn146.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn147.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn148.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn149.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn150.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn151.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn152.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn153.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn154.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn155.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn156.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn157.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn158.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn159.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn160.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn161.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn162.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn163.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn164.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn165.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn166.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn167.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn168.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn169.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn170.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn171.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn172.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn173.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn174.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn175.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn176.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn177.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn178.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn179.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn180.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn181.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn182.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn183.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn184.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn185.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn186.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn187.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn188.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn189.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn190.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn191.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn192.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn193.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn194.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn195.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn196.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn197.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn198.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn199.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn200.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn201.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn202.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn203.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn204.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn205.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn206.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn207.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn208.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn209.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn210.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn211.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn212.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn213.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn214.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn215.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn216.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn217.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn218.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn219.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn220.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn221.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn222.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn223.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn224.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn225.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn226.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn227.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn228.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn229.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn230.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn231.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn232.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn233.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn234.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn235.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn236.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn237.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn238.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn239.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn240.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn241.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn242.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn243.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn244.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn245.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn246.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn247.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn248.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn249.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn250.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn251.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn252.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn253.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn254.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn255.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn256.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn257.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn258.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn259.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn260.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn261.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn262.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn263.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn264.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn265.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn266.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn267.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn268.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn269.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn270.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn271.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn272.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn273.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn274.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn275.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn276.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn277.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn278.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn279.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn280.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn281.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn282.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn283.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn284.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn285.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn286.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn287.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn288.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn289.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn290.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn291.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn292.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn293.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn294.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn295.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn296.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn297.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn298.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn299.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn300.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn301.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn302.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn303.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn304.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn305.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn306.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn307.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn308.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn309.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn310.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn311.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn312.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn313.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn314.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn315.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn316.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn317.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn318.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn319.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn320.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn321.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn322.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn323.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn324.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn325.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn326.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn327.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn328.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn329.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn330.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn331.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn332.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn333.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn334.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn335.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn336.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn337.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn338.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn339.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn340.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn341.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn342.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn343.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn344.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn345.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn346.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn347.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn348.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn349.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn350.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn351.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn352.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn353.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn354.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn355.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn356.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn357.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn358.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn359.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn360.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn361.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn362.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn363.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn364.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn365.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn366.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn367.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn368.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn369.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn370.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn371.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn372.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn373.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn374.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn375.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn376.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn377.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn378.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn379.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn380.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn381.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn382.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn383.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn384.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn385.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn386.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn387.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn388.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn389.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn390.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn391.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn392.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn393.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn394.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn395.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn396.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn397.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn398.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn399.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn400.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn401.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn402.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn403.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn404.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn405.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn406.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn407.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn408.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn409.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn410.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn411.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn412.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn413.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn414.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn415.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn416.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn417.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn418.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn419.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn420.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn421.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn422.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn423.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn424.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn425.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn426.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn427.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn428.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn429.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn430.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn431.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn432.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn433.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn434.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn435.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn436.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn437.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn438.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn439.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn440.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn441.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn442.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn443.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn444.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn445.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn446.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn447.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn448.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn449.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn450.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn451.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn452.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn453.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn454.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn455.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn456.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn457.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn458.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn459.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn460.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn461.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn462.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn463.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn464.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn465.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn466.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn467.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn468.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn469.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn470.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn471.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn472.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn473.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn474.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn475.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn476.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn477.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn478.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn479.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn480.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn481.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn482.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn483.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn484.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn485.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn486.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn487.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn488.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn489.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn490.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn491.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn492.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn493.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn494.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn495.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn496.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn497.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn498.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn499.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn500.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn501.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn502.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn503.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn504.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn505.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn506.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn507.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn508.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn509.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn510.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn511.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn512.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn513.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn514.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn515.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn516.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn517.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn518.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn519.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn520.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn521.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn522.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn523.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn524.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn525.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn526.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn527.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn528.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn529.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn530.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn531.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn532.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn533.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn534.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn535.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn536.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn537.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn538.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn539.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn540.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn541.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn542.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn543.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn544.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn545.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn546.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn547.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn548.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn549.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn550.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn551.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn552.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn553.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn554.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn555.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn556.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn557.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn558.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn559.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn560.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn561.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn562.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn563.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn564.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn565.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn566.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn567.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn568.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn569.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn570.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn571.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn572.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn573.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn574.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn575.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn576.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn577.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn578.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn579.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn580.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn581.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn582.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn583.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn584.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn585.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn586.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn587.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn588.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn589.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn590.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn591.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn592.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn593.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn594.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn595.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn596.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn597.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn598.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn599.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn600.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn601.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn602.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn603.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn604.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn605.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn606.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn607.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn608.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn609.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn610.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn611.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn612.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn613.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn614.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn615.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn616.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn617.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn618.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn619.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn620.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn621.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn622.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn623.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn624.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn625.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn626.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn627.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn628.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn629.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn630.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn631.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn632.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn633.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn634.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn635.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn636.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn637.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn638.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn639.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn640.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn641.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn642.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn643.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn644.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn645.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn646.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn647.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn648.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn649.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn650.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn651.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn652.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn653.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn654.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn655.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn656.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn657.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn658.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn659.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn660.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn661.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn662.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn663.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn664.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn665.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn666.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn667.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn668.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn669.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn670.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn671.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn672.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn673.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn674.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn675.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn676.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn677.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn678.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn679.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn680.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn681.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn682.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn683.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn684.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn685.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn686.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn687.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn688.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn689.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn690.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn691.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn692.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn693.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn694.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn695.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn696.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn697.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn698.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn699.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn700.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn701.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn702.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn703.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn704.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn705.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn706.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn707.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn708.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn709.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn710.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn711.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn712.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn713.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn714.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn715.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn716.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn717.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn718.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn719.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn720.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn721.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn722.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn723.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn724.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn725.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn726.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn727.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn728.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn729.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn730.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn731.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn732.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn733.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn734.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn735.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn736.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn737.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn738.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn739.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn740.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn741.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn742.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn743.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn744.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn745.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn746.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn747.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn748.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn749.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn750.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn751.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn752.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn753.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn754.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn755.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn756.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn757.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn758.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn759.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn760.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn761.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn762.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn763.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn764.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn765.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn766.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn767.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn768.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn769.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn770.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn771.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn772.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn773.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn774.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn775.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn776.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn777.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn778.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn779.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn780.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn781.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn782.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn783.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn784.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn785.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn786.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn787.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn788.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn789.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn790.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn791.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn792.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn793.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn794.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn795.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn796.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn797.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn798.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn799.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn800.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn801.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn802.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn803.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn804.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn805.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn806.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn807.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn808.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn809.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn810.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn811.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn812.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn813.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn814.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn815.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn816.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn817.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn818.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn819.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn820.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn821.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn822.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn823.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn824.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn825.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn826.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn827.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn828.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn829.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn830.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn831.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn832.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn833.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn834.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn835.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn836.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn837.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn838.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn839.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn840.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn841.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn842.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn843.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn844.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn845.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn846.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn847.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn848.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn849.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn850.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn851.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn852.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn853.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn854.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn855.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn856.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn857.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn858.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn859.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn860.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn861.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn862.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn863.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn864.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn865.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn866.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn867.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn868.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn869.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn870.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn871.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn872.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn873.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn874.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn875.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn876.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn877.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn878.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn879.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn880.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn881.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn882.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn883.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn884.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn885.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn886.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn887.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn888.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn889.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn890.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn891.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn892.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn893.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn894.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn895.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn896.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn897.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn898.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn899.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn900.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn901.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn902.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn903.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn904.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn905.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn906.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn907.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn908.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn909.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn910.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn911.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn912.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn913.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn914.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn915.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn916.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn917.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn918.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn919.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn920.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn921.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn922.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn923.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn924.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn925.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn926.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn927.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn928.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn929.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn930.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn931.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn932.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn933.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn934.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn935.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn936.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn937.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn938.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn939.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn940.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn941.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn942.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn943.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn944.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn945.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn946.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn947.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn948.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn949.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn950.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn951.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn952.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn953.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn954.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn955.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn956.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn957.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn958.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn959.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn960.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn961.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn962.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn963.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn964.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn965.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn966.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn967.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn968.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn969.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn970.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn971.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn972.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn973.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn974.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn975.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn976.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn977.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn978.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn979.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn980.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn981.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn982.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn983.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn984.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn985.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn986.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn987.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn988.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn989.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn990.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn991.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn992.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn993.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn994.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn995.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn996.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn997.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn998.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_brn999.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl019.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl020.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl021.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl022.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl023.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl024.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl025.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl026.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl027.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl028.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl029.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl030.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl031.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl032.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl033.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl034.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl035.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl036.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl037.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl038.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl039.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl040.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl041.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl042.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl043.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl044.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl045.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl046.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl047.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl048.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl049.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl050.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl051.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl052.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl053.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl054.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl055.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl056.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl057.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl058.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl059.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl060.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl061.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl062.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl063.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl064.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl065.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl066.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl067.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl068.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl069.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl070.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl071.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl072.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl073.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl074.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl075.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl076.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl077.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl078.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl079.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl080.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl081.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl082.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl083.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl084.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl085.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl086.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl087.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl088.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl089.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl090.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl091.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl092.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl093.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl094.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl095.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl096.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl097.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl098.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl099.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl100.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1000.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl101.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1019.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl102.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1020.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1021.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1022.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1023.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1024.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1025.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1026.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1027.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1028.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1029.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl103.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1030.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1031.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1032.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1033.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1034.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1035.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1036.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1037.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1038.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1039.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl104.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1040.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1041.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1042.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1043.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1044.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1045.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1046.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1047.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1048.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1049.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl105.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1050.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1051.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1052.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1053.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1054.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1055.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1056.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1057.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1058.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1059.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl106.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1060.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1061.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1062.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1063.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1064.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1065.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1066.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1067.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1068.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1069.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl107.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1070.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1071.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1072.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1073.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1074.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1075.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1076.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1077.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1078.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1079.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl108.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1080.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1081.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1082.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1083.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1084.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1085.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1086.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1087.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1088.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1089.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl109.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1090.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1091.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1092.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1093.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1094.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1095.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1096.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1097.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1098.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1099.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl110.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1100.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1101.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1102.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1103.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1104.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1105.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1106.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1107.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1108.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1109.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl111.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1110.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1111.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1112.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1113.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1114.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1115.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1116.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1117.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1118.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1119.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl112.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1120.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1121.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1122.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1123.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1124.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1125.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1126.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1127.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1128.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1129.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl113.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1130.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1131.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1132.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1133.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1134.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1135.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1136.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1137.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1138.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1139.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl114.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1140.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1141.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1142.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1143.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1144.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1145.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1146.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1147.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1148.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1149.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl115.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1150.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1151.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1152.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1153.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1154.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1155.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1156.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1157.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1158.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1159.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl116.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1160.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1161.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1162.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1163.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1164.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1165.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1166.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1167.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1168.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1169.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl117.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1170.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1171.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1172.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1173.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1174.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1175.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1176.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1177.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1178.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1179.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl118.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1180.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1181.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1182.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1183.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1184.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1185.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1186.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1187.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1188.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1189.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl119.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1190.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1191.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1192.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1193.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1194.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1195.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1196.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1197.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1198.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1199.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl120.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1200.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1201.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1202.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1203.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1204.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1205.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1206.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1207.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1208.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1209.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl121.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1210.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1211.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1212.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1213.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1214.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1215.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1216.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1217.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1218.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1219.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl122.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1220.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1221.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1222.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1223.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1224.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1225.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1226.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1227.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1228.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1229.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl123.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1230.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1231.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1232.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1233.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1234.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1235.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1236.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1237.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1238.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1239.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl124.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1240.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1241.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1242.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1243.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1244.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1245.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1246.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1247.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1248.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1249.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl125.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1250.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1251.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1252.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1253.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1254.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1255.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1256.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1257.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1258.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1259.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl126.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1260.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1261.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1262.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1263.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1264.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1265.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1266.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1267.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1268.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1269.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl127.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1270.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1271.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1272.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1273.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1274.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1275.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1276.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1277.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1278.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1279.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl128.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1280.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1281.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1282.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl1283.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl129.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl130.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl131.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl132.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl133.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl134.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl135.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl136.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl137.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl138.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl139.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl140.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl141.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl142.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl143.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl144.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl145.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl146.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl147.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl148.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl149.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl150.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl151.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl152.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl153.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl154.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl155.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl156.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl157.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl158.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl159.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl160.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl161.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl162.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl163.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl164.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl165.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl166.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl167.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl168.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl169.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl170.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl171.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl172.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl173.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl174.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl175.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl176.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl177.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl178.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl179.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl180.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl181.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl182.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl183.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl184.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl185.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl186.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl187.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl188.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl189.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl190.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl191.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl192.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl193.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl194.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl195.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl196.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl197.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl198.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl199.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl200.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl201.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl202.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl203.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl204.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl205.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl206.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl207.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl208.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl209.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl210.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl211.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl212.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl213.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl214.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl215.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl216.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl217.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl218.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl219.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl220.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl221.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl222.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl223.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl224.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl225.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl226.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl227.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl228.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl229.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl230.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl231.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl232.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl233.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl234.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl235.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl236.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl237.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl238.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl239.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl240.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl241.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl242.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl243.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl244.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl245.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl246.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl247.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl248.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl249.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl250.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl251.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl252.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl253.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl254.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl255.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl256.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl257.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl258.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl259.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl260.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl261.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl262.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl263.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl264.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl265.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl266.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl267.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl268.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl269.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl270.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl271.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl272.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl273.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl274.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl275.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl276.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl277.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl278.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl279.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl280.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl281.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl282.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl283.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl284.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl285.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl286.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl287.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl288.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl289.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl290.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl291.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl292.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl293.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl294.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl295.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl296.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl297.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl298.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl299.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl300.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl301.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl302.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl303.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl304.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl305.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl306.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl307.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl308.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl309.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl310.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl311.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl312.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl313.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl314.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl315.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl316.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl317.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl318.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl319.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl320.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl321.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl322.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl323.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl324.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl325.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl326.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl327.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl328.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl329.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl330.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl331.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl332.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl333.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl334.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl335.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl336.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl337.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl338.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl339.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl340.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl341.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl342.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl343.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl344.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl345.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl346.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl347.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl348.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl349.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl350.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl351.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl352.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl353.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl354.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl355.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl356.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl357.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl358.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl359.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl360.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl361.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl362.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl363.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl364.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl365.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl366.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl367.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl368.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl369.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl370.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl371.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl372.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl373.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl374.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl375.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl376.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl377.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl378.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl379.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl380.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl381.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl382.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl383.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl384.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl385.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl386.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl387.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl388.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl389.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl390.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl391.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl392.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl393.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl394.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl395.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl396.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl397.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl398.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl399.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl400.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl401.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl402.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl403.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl404.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl405.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl406.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl407.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl408.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl409.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl410.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl411.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl412.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl413.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl414.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl415.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl416.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl417.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl418.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl419.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl420.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl421.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl422.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl423.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl424.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl425.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl426.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl427.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl428.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl429.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl430.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl431.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl432.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl433.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl434.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl435.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl436.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl437.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl438.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl439.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl440.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl441.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl442.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl443.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl444.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl445.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl446.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl447.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl448.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl449.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl450.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl451.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl452.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl453.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl454.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl455.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl456.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl457.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl458.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl459.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl460.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl461.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl462.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl463.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl464.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl465.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl466.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl467.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl468.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl469.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl470.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl471.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl472.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl473.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl474.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl475.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl476.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl477.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl478.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl479.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl480.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl481.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl482.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl483.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl484.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl485.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl486.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl487.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl488.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl489.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl490.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl491.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl492.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl493.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl494.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl495.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl496.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl497.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl498.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl499.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl500.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl501.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl502.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl503.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl504.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl505.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl506.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl507.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl508.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl509.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl510.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl511.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl512.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl513.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl514.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl515.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl516.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl517.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl518.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl519.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl520.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl521.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl522.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl523.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl524.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl525.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl526.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl527.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl528.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl529.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl530.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl531.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl532.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl533.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl534.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl535.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl536.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl537.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl538.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl539.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl540.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl541.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl542.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl543.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl544.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl545.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl546.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl547.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl548.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl549.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl550.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl551.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl552.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl553.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl554.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl555.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl556.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl557.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl558.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl559.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl560.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl561.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl562.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl563.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl564.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl565.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl566.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl567.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl568.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl569.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl570.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl571.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl572.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl573.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl574.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl575.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl576.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl577.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl578.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl579.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl580.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl581.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl582.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl583.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl584.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl585.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl586.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl587.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl588.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl589.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl590.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl591.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl592.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl593.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl594.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl595.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl596.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl597.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl598.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl599.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl600.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl601.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl602.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl603.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl604.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl605.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl606.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl607.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl608.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl609.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl610.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl611.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl612.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl613.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl614.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl615.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl616.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl617.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl618.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl619.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl620.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl621.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl622.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl623.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl624.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl625.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl626.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl627.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl628.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl629.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl630.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl631.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl632.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl633.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl634.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl635.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl636.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl637.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl638.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl639.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl640.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl641.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl642.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl643.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl644.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl645.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl646.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl647.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl648.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl649.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl650.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl651.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl652.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl653.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl654.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl655.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl656.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl657.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl658.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl659.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl660.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl661.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl662.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl663.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl664.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl665.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl666.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl667.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl668.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl669.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl670.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl671.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl672.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl673.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl674.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl675.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl676.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl677.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl678.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl679.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl680.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl681.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl682.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl683.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl684.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl685.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl686.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl687.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl688.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl689.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl690.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl691.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl692.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl693.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl694.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl695.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl696.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl697.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl698.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl699.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl700.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl701.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl702.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl703.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl704.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl705.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl706.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl707.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl708.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl709.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl710.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl711.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl712.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl713.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl714.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl715.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl716.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl717.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl718.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl719.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl720.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl721.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl722.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl723.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl724.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl725.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl726.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl727.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl728.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl729.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl730.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl731.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl732.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl733.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl734.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl735.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl736.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl737.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl738.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl739.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl740.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl741.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl742.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl743.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl744.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl745.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl746.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl747.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl748.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl749.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl750.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl751.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl752.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl753.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl754.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl755.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl756.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl757.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl758.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl759.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl760.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl761.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl762.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl763.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl764.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl765.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl766.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl767.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl768.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl769.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl770.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl771.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl772.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl773.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl774.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl775.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl776.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl777.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl778.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl779.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl780.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl781.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl782.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl783.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl784.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl785.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl786.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl787.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl788.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl789.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl790.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl791.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl792.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl793.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl794.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl795.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl796.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl797.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl798.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl799.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl800.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl801.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl802.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl803.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl804.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl805.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl806.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl807.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl808.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl809.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl810.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl811.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl812.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl813.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl814.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl815.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl816.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl817.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl818.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl819.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl820.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl821.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl822.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl823.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl824.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl825.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl826.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl827.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl828.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl829.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl830.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl831.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl832.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl833.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl834.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl835.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl836.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl837.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl838.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl839.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl840.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl841.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl842.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl843.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl844.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl845.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl846.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl847.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl848.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl849.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl850.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl851.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl852.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl853.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl854.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl855.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl856.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl857.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl858.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl859.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl860.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl861.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl862.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl863.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl864.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl865.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl866.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl867.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl868.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl869.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl870.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl871.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl872.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl873.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl874.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl875.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl876.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl877.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl878.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl879.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl880.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl881.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl882.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl883.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl884.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl885.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl886.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl887.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl888.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl889.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl890.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl891.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl892.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl893.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl894.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl895.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl896.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl897.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl898.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl899.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl900.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl901.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl902.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl903.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl904.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl905.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl906.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl907.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl908.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl909.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl910.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl911.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl912.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl913.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl914.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl915.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl916.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl917.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl918.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl919.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl920.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl921.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl922.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl923.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl924.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl925.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl926.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl927.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl928.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl929.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl930.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl931.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl932.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl933.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl934.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl935.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl936.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl937.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl938.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl939.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl940.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl941.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl942.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl943.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl944.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl945.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl946.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl947.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl948.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl949.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl950.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl951.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl952.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl953.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl954.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl955.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl956.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl957.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl958.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl959.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl960.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl961.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl962.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl963.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl964.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl965.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl966.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl967.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl968.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl969.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl970.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl971.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl972.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl973.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl974.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl975.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl976.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl977.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl978.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl979.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl980.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl981.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl982.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl983.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl984.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl985.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl986.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl987.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl988.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl989.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl990.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl991.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl992.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl993.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl994.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl995.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl996.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl997.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl998.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/gensys_icl999.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn019.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn020.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn021.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn022.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn023.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn024.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn025.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn026.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn027.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn028.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn029.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn030.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn031.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn032.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn033.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn034.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn035.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn036.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn037.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn038.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn039.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn040.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn041.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn042.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn043.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn044.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn045.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn046.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn047.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn048.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn049.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn050.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn051.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn052.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn053.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn054.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn055.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn056.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn057.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn058.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn059.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn060.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn061.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn062.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn063.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn064.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn065.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn066.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn067.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn068.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn069.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn070.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn071.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn072.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn073.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn074.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn075.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn076.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn077.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn078.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn079.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn080.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn081.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn082.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn083.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn084.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn085.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn086.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn087.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn088.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn089.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn090.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn091.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn092.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn093.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn094.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn095.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn096.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn097.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn098.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn099.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn100.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1000.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn101.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1019.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn102.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1020.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1021.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1022.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1023.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1024.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1025.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1026.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1027.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1028.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1029.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn103.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1030.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1031.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1032.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1033.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1034.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1035.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1036.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1037.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1038.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1039.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn104.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1040.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1041.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1042.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1043.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1044.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1045.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1046.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1047.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1048.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1049.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn105.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1050.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1051.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1052.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1053.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1054.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1055.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1056.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1057.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1058.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1059.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn106.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1060.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1061.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1062.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1063.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1064.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1065.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1066.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1067.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1068.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1069.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn107.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1070.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1071.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1072.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1073.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1074.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1075.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1076.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1077.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1078.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1079.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn108.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1080.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1081.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1082.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1083.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1084.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1085.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1086.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1087.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1088.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1089.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn109.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1090.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1091.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1092.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1093.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1094.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1095.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1096.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1097.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1098.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1099.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn110.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1100.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1101.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1102.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1103.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1104.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1105.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1106.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1107.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1108.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1109.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn111.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1110.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1111.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1112.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1113.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1114.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1115.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1116.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1117.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1118.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1119.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn112.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1120.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1121.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1122.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1123.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1124.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1125.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1126.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1127.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1128.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1129.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn113.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1130.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1131.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1132.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1133.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1134.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1135.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1136.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1137.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1138.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1139.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn114.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1140.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1141.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1142.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1143.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1144.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1145.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1146.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1147.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1148.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1149.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn115.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1150.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1151.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1152.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1153.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1154.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1155.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1156.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1157.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1158.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1159.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn116.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1160.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1161.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1162.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1163.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1164.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1165.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1166.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1167.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1168.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1169.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn117.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1170.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1171.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1172.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1173.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1174.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1175.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1176.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1177.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1178.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1179.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn118.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1180.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1181.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1182.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1183.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1184.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1185.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1186.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1187.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1188.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1189.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn119.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1190.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1191.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1192.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1193.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1194.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1195.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1196.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1197.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1198.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1199.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn120.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1200.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1201.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1202.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1203.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1204.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1205.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1206.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1207.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1208.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1209.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn121.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1210.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1211.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1212.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1213.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1214.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1215.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1216.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1217.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1218.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1219.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn122.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1220.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1221.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1222.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1223.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1224.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1225.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1226.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1227.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1228.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1229.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn123.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1230.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1231.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1232.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1233.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1234.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1235.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1236.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1237.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1238.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1239.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn124.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1240.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1241.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1242.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1243.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1244.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1245.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1246.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1247.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1248.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1249.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn125.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1250.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1251.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1252.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1253.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1254.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1255.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1256.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1257.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1258.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1259.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn126.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1260.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1261.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1262.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1263.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1264.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1265.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1266.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1267.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1268.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1269.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn127.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1270.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1271.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1272.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1273.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1274.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1275.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1276.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1277.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1278.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1279.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn128.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1280.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1281.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1282.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1283.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1284.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1285.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1286.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1287.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1288.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1289.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn129.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1290.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1291.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1292.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1293.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1294.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1295.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1296.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1297.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1298.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1299.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn130.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1300.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1301.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1302.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1303.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1304.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1305.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1306.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1307.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1308.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1309.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn131.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1310.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1311.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1312.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1313.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1314.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1315.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1316.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1317.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1318.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1319.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn132.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1320.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1321.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1322.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1323.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1324.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1325.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1326.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn1327.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn133.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn134.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn135.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn136.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn137.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn138.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn139.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn140.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn141.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn142.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn143.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn144.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn145.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn146.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn147.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn148.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn149.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn150.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn151.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn152.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn153.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn154.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn155.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn156.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn157.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn158.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn159.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn160.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn161.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn162.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn163.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn164.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn165.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn166.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn167.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn168.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn169.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn170.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn171.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn172.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn173.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn174.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn175.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn176.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn177.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn178.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn179.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn180.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn181.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn182.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn183.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn184.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn185.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn186.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn187.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn188.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn189.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn190.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn191.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn192.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn193.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn194.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn195.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn196.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn197.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn198.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn199.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn200.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn201.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn202.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn203.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn204.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn205.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn206.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn207.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn208.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn209.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn210.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn211.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn212.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn213.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn214.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn215.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn216.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn217.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn218.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn219.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn220.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn221.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn222.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn223.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn224.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn225.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn226.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn227.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn228.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn229.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn230.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn231.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn232.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn233.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn234.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn235.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn236.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn237.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn238.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn239.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn240.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn241.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn242.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn243.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn244.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn245.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn246.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn247.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn248.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn249.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn250.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn251.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn252.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn253.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn254.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn255.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn256.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn257.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn258.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn259.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn260.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn261.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn262.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn263.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn264.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn265.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn266.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn267.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn268.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn269.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn270.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn271.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn272.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn273.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn274.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn275.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn276.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn277.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn278.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn279.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn280.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn281.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn282.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn283.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn284.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn285.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn286.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn287.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn288.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn289.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn290.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn291.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn292.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn293.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn294.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn295.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn296.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn297.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn298.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn299.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn300.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn301.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn302.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn303.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn304.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn305.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn306.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn307.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn308.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn309.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn310.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn311.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn312.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn313.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn314.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn315.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn316.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn317.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn318.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn319.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn320.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn321.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn322.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn323.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn324.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn325.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn326.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn327.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn328.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn329.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn330.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn331.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn332.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn333.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn334.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn335.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn336.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn337.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn338.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn339.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn340.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn341.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn342.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn343.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn344.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn345.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn346.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn347.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn348.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn349.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn350.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn351.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn352.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn353.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn354.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn355.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn356.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn357.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn358.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn359.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn360.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn361.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn362.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn363.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn364.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn365.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn366.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn367.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn368.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn369.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn370.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn371.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn372.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn373.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn374.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn375.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn376.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn377.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn378.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn379.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn380.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn381.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn382.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn383.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn384.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn385.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn386.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn387.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn388.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn389.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn390.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn391.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn392.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn393.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn394.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn395.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn396.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn397.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn398.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn399.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn400.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn401.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn402.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn403.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn404.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn405.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn406.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn407.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn408.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn409.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn410.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn411.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn412.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn413.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn414.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn415.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn416.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn417.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn418.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn419.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn420.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn421.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn422.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn423.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn424.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn425.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn426.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn427.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn428.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn429.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn430.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn431.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn432.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn433.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn434.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn435.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn436.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn437.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn438.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn439.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn440.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn441.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn442.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn443.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn444.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn445.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn446.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn447.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn448.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn449.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn450.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn451.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn452.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn453.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn454.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn455.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn456.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn457.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn458.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn459.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn460.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn461.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn462.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn463.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn464.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn465.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn466.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn467.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn468.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn469.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn470.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn471.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn472.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn473.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn474.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn475.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn476.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn477.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn478.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn479.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn480.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn481.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn482.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn483.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn484.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn485.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn486.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn487.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn488.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn489.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn490.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn491.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn492.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn493.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn494.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn495.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn496.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn497.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn498.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn499.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn500.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn501.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn502.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn503.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn504.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn505.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn506.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn507.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn508.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn509.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn510.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn511.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn512.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn513.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn514.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn515.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn516.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn517.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn518.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn519.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn520.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn521.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn522.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn523.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn524.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn525.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn526.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn527.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn528.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn529.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn530.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn531.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn532.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn533.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn534.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn535.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn536.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn537.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn538.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn539.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn540.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn541.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn542.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn543.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn544.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn545.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn546.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn547.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn548.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn549.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn550.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn551.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn552.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn553.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn554.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn555.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn556.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn557.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn558.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn559.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn560.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn561.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn562.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn563.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn564.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn565.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn566.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn567.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn568.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn569.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn570.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn571.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn572.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn573.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn574.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn575.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn576.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn577.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn578.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn579.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn580.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn581.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn582.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn583.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn584.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn585.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn586.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn587.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn588.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn589.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn590.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn591.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn592.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn593.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn594.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn595.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn596.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn597.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn598.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn599.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn600.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn601.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn602.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn603.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn604.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn605.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn606.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn607.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn608.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn609.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn610.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn611.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn612.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn613.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn614.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn615.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn616.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn617.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn618.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn619.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn620.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn621.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn622.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn623.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn624.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn625.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn626.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn627.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn628.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn629.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn630.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn631.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn632.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn633.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn634.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn635.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn636.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn637.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn638.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn639.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn640.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn641.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn642.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn643.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn644.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn645.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn646.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn647.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn648.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn649.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn650.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn651.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn652.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn653.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn654.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn655.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn656.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn657.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn658.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn659.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn660.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn661.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn662.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn663.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn664.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn665.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn666.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn667.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn668.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn669.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn670.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn671.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn672.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn673.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn674.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn675.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn676.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn677.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn678.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn679.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn680.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn681.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn682.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn683.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn684.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn685.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn686.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn687.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn688.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn689.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn690.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn691.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn692.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn693.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn694.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn695.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn696.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn697.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn698.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn699.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn700.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn701.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn702.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn703.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn704.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn705.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn706.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn707.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn708.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn709.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn710.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn711.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn712.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn713.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn714.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn715.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn716.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn717.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn718.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn719.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn720.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn721.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn722.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn723.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn724.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn725.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn726.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn727.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn728.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn729.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn730.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn731.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn732.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn733.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn734.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn735.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn736.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn737.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn738.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn739.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn740.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn741.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn742.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn743.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn744.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn745.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn746.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn747.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn748.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn749.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn750.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn751.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn752.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn753.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn754.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn755.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn756.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn757.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn758.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn759.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn760.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn761.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn762.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn763.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn764.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn765.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn766.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn767.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn768.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn769.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn770.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn771.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn772.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn773.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn774.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn775.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn776.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn777.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn778.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn779.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn780.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn781.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn782.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn783.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn784.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn785.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn786.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn787.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn788.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn789.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn790.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn791.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn792.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn793.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn794.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn795.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn796.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn797.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn798.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn799.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn800.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn801.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn802.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn803.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn804.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn805.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn806.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn807.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn808.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn809.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn810.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn811.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn812.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn813.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn814.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn815.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn816.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn817.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn818.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn819.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn820.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn821.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn822.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn823.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn824.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn825.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn826.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn827.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn828.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn829.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn830.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn831.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn832.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn833.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn834.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn835.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn836.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn837.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn838.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn839.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn840.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn841.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn842.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn843.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn844.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn845.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn846.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn847.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn848.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn849.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn850.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn851.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn852.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn853.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn854.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn855.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn856.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn857.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn858.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn859.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn860.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn861.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn862.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn863.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn864.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn865.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn866.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn867.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn868.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn869.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn870.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn871.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn872.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn873.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn874.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn875.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn876.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn877.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn878.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn879.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn880.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn881.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn882.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn883.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn884.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn885.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn886.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn887.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn888.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn889.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn890.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn891.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn892.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn893.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn894.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn895.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn896.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn897.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn898.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn899.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn900.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn901.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn902.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn903.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn904.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn905.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn906.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn907.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn908.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn909.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn910.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn911.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn912.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn913.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn914.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn915.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn916.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn917.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn918.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn919.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn920.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn921.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn922.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn923.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn924.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn925.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn926.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn927.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn928.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn929.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn930.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn931.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn932.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn933.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn934.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn935.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn936.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn937.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn938.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn939.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn940.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn941.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn942.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn943.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn944.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn945.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn946.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn947.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn948.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn949.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn950.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn951.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn952.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn953.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn954.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn955.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn956.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn957.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn958.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn959.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn960.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn961.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn962.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn963.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn964.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn965.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn966.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn967.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn968.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn969.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn970.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn971.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn972.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn973.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn974.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn975.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn976.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn977.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn978.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn979.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn980.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn981.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn982.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn983.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn984.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn985.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn986.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn987.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn988.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn989.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn990.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn991.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn992.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn993.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn994.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn995.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn996.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn997.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn998.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_brn999.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl019.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl020.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl021.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl022.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl023.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl024.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl025.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl026.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl027.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl028.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl029.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl030.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl031.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl032.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl033.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl034.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl035.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl036.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl037.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl038.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl039.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl040.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl041.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl042.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl043.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl044.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl045.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl046.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl047.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl048.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl049.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl050.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl051.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl052.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl053.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl054.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl055.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl056.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl057.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl058.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl059.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl060.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl061.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl062.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl063.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl064.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl065.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl066.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl067.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl068.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl069.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl070.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl071.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl072.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl073.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl074.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl075.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl076.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl077.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl078.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl079.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl080.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl081.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl082.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl083.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl084.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl085.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl086.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl087.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl088.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl089.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl090.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl091.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl092.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl093.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl094.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl095.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl096.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl097.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl098.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl099.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl100.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1000.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl101.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1019.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl102.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1020.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1021.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1022.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1023.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1024.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1025.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1026.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1027.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1028.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1029.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl103.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1030.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1031.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1032.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1033.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1034.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1035.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1036.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1037.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1038.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1039.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl104.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1040.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1041.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1042.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1043.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1044.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1045.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1046.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1047.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1048.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1049.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl105.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1050.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1051.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1052.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1053.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1054.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1055.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1056.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1057.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1058.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1059.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl106.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1060.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1061.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1062.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1063.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1064.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1065.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1066.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1067.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1068.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1069.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl107.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1070.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1071.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1072.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1073.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1074.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1075.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1076.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1077.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1078.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1079.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl108.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1080.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1081.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1082.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1083.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1084.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1085.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1086.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1087.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1088.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1089.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl109.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1090.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1091.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1092.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1093.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1094.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1095.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1096.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1097.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1098.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1099.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl110.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1100.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1101.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1102.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1103.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1104.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1105.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1106.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1107.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1108.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1109.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl111.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1110.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1111.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1112.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1113.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1114.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1115.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1116.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1117.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1118.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1119.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl112.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1120.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1121.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1122.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1123.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1124.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1125.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1126.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1127.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1128.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1129.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl113.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1130.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1131.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1132.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1133.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1134.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1135.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1136.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1137.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1138.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1139.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl114.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1140.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1141.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1142.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1143.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1144.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1145.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1146.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1147.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1148.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1149.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl115.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1150.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1151.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1152.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1153.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1154.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1155.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1156.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1157.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1158.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1159.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl116.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1160.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1161.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1162.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1163.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1164.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1165.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1166.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1167.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1168.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1169.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl117.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1170.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1171.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1172.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1173.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1174.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1175.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1176.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1177.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1178.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1179.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl118.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1180.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1181.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1182.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1183.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1184.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1185.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1186.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1187.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1188.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1189.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl119.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1190.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1191.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1192.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1193.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1194.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1195.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1196.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1197.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1198.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1199.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl120.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1200.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1201.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1202.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1203.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1204.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1205.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1206.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1207.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1208.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1209.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl121.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1210.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1211.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1212.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1213.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1214.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1215.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1216.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1217.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1218.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1219.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl122.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1220.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1221.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1222.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1223.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1224.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1225.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1226.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1227.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1228.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1229.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl123.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1230.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1231.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1232.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1233.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1234.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1235.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1236.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1237.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1238.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1239.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl124.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1240.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1241.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1242.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1243.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1244.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1245.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1246.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1247.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1248.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1249.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl125.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1250.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1251.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1252.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1253.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1254.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1255.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1256.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1257.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1258.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1259.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl126.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1260.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1261.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1262.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1263.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1264.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1265.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1266.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1267.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1268.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1269.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl127.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1270.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1271.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1272.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1273.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1274.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1275.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1276.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1277.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1278.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1279.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl128.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1280.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1281.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1282.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl1283.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl129.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl130.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl131.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl132.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl133.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl134.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl135.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl136.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl137.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl138.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl139.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl140.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl141.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl142.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl143.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl144.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl145.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl146.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl147.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl148.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl149.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl150.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl151.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl152.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl153.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl154.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl155.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl156.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl157.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl158.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl159.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl160.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl161.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl162.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl163.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl164.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl165.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl166.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl167.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl168.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl169.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl170.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl171.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl172.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl173.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl174.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl175.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl176.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl177.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl178.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl179.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl180.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl181.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl182.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl183.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl184.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl185.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl186.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl187.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl188.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl189.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl190.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl191.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl192.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl193.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl194.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl195.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl196.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl197.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl198.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl199.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl200.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl201.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl202.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl203.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl204.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl205.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl206.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl207.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl208.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl209.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl210.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl211.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl212.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl213.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl214.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl215.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl216.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl217.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl218.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl219.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl220.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl221.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl222.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl223.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl224.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl225.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl226.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl227.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl228.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl229.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl230.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl231.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl232.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl233.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl234.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl235.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl236.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl237.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl238.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl239.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl240.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl241.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl242.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl243.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl244.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl245.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl246.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl247.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl248.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl249.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl250.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl251.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl252.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl253.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl254.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl255.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl256.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl257.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl258.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl259.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl260.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl261.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl262.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl263.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl264.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl265.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl266.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl267.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl268.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl269.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl270.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl271.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl272.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl273.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl274.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl275.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl276.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl277.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl278.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl279.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl280.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl281.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl282.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl283.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl284.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl285.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl286.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl287.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl288.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl289.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl290.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl291.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl292.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl293.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl294.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl295.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl296.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl297.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl298.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl299.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl300.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl301.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl302.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl303.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl304.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl305.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl306.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl307.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl308.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl309.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl310.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl311.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl312.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl313.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl314.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl315.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl316.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl317.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl318.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl319.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl320.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl321.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl322.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl323.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl324.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl325.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl326.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl327.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl328.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl329.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl330.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl331.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl332.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl333.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl334.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl335.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl336.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl337.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl338.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl339.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl340.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl341.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl342.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl343.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl344.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl345.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl346.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl347.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl348.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl349.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl350.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl351.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl352.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl353.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl354.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl355.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl356.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl357.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl358.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl359.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl360.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl361.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl362.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl363.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl364.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl365.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl366.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl367.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl368.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl369.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl370.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl371.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl372.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl373.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl374.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl375.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl376.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl377.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl378.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl379.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl380.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl381.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl382.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl383.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl384.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl385.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl386.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl387.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl388.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl389.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl390.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl391.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl392.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl393.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl394.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl395.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl396.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl397.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl398.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl399.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl400.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl401.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl402.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl403.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl404.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl405.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl406.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl407.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl408.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl409.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl410.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl411.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl412.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl413.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl414.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl415.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl416.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl417.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl418.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl419.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl420.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl421.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl422.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl423.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl424.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl425.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl426.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl427.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl428.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl429.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl430.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl431.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl432.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl433.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl434.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl435.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl436.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl437.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl438.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl439.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl440.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl441.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl442.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl443.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl444.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl445.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl446.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl447.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl448.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl449.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl450.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl451.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl452.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl453.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl454.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl455.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl456.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl457.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl458.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl459.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl460.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl461.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl462.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl463.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl464.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl465.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl466.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl467.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl468.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl469.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl470.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl471.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl472.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl473.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl474.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl475.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl476.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl477.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl478.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl479.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl480.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl481.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl482.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl483.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl484.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl485.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl486.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl487.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl488.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl489.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl490.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl491.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl492.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl493.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl494.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl495.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl496.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl497.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl498.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl499.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl500.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl501.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl502.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl503.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl504.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl505.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl506.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl507.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl508.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl509.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl510.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl511.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl512.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl513.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl514.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl515.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl516.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl517.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl518.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl519.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl520.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl521.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl522.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl523.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl524.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl525.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl526.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl527.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl528.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl529.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl530.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl531.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl532.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl533.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl534.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl535.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl536.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl537.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl538.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl539.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl540.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl541.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl542.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl543.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl544.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl545.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl546.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl547.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl548.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl549.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl550.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl551.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl552.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl553.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl554.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl555.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl556.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl557.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl558.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl559.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl560.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl561.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl562.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl563.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl564.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl565.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl566.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl567.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl568.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl569.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl570.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl571.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl572.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl573.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl574.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl575.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl576.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl577.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl578.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl579.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl580.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl581.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl582.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl583.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl584.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl585.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl586.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl587.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl588.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl589.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl590.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl591.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl592.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl593.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl594.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl595.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl596.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl597.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl598.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl599.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl600.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl601.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl602.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl603.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl604.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl605.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl606.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl607.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl608.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl609.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl610.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl611.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl612.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl613.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl614.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl615.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl616.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl617.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl618.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl619.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl620.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl621.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl622.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl623.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl624.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl625.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl626.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl627.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl628.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl629.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl630.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl631.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl632.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl633.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl634.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl635.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl636.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl637.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl638.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl639.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl640.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl641.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl642.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl643.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl644.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl645.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl646.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl647.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl648.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl649.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl650.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl651.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl652.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl653.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl654.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl655.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl656.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl657.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl658.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl659.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl660.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl661.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl662.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl663.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl664.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl665.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl666.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl667.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl668.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl669.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl670.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl671.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl672.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl673.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl674.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl675.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl676.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl677.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl678.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl679.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl680.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl681.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl682.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl683.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl684.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl685.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl686.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl687.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl688.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl689.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl690.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl691.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl692.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl693.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl694.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl695.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl696.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl697.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl698.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl699.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl700.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl701.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl702.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl703.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl704.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl705.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl706.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl707.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl708.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl709.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl710.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl711.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl712.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl713.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl714.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl715.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl716.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl717.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl718.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl719.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl720.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl721.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl722.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl723.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl724.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl725.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl726.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl727.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl728.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl729.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl730.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl731.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl732.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl733.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl734.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl735.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl736.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl737.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl738.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl739.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl740.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl741.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl742.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl743.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl744.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl745.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl746.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl747.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl748.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl749.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl750.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl751.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl752.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl753.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl754.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl755.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl756.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl757.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl758.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl759.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl760.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl761.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl762.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl763.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl764.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl765.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl766.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl767.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl768.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl769.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl770.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl771.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl772.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl773.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl774.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl775.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl776.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl777.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl778.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl779.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl780.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl781.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl782.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl783.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl784.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl785.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl786.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl787.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl788.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl789.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl790.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl791.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl792.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl793.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl794.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl795.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl796.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl797.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl798.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl799.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl800.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl801.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl802.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl803.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl804.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl805.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl806.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl807.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl808.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl809.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl810.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl811.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl812.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl813.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl814.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl815.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl816.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl817.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl818.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl819.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl820.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl821.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl822.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl823.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl824.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl825.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl826.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl827.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl828.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl829.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl830.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl831.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl832.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl833.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl834.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl835.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl836.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl837.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl838.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl839.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl840.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl841.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl842.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl843.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl844.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl845.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl846.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl847.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl848.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl849.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl850.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl851.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl852.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl853.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl854.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl855.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl856.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl857.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl858.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl859.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl860.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl861.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl862.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl863.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl864.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl865.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl866.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl867.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl868.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl869.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl870.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl871.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl872.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl873.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl874.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl875.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl876.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl877.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl878.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl879.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl880.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl881.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl882.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl883.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl884.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl885.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl886.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl887.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl888.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl889.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl890.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl891.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl892.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl893.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl894.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl895.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl896.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl897.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl898.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl899.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl900.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl901.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl902.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl903.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl904.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl905.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl906.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl907.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl908.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl909.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl910.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl911.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl912.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl913.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl914.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl915.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl916.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl917.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl918.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl919.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl920.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl921.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl922.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl923.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl924.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl925.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl926.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl927.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl928.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl929.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl930.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl931.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl932.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl933.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl934.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl935.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl936.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl937.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl938.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl939.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl940.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl941.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl942.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl943.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl944.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl945.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl946.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl947.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl948.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl949.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl950.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl951.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl952.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl953.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl954.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl955.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl956.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl957.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl958.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl959.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl960.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl961.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl962.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl963.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl964.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl965.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl966.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl967.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl968.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl969.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl970.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl971.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl972.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl973.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl974.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl975.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl976.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl977.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl978.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl979.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl980.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl981.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl982.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl983.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl984.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl985.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl986.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl987.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl988.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl989.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl990.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl991.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl992.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl993.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl994.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl995.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl996.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl997.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl998.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg5/iso_icl999.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/dead_dnd001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/dead_dnd002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/dead_dnd_sk001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/dead_dnd_sk002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn_sk001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn_sk002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn_sk003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn_sk004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn_sk005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn_sk006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn_sk007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn_sk008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn_sk009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn_sk010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn_sk011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn_sk012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn_sk013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn_sk014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn_sk015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn_sk016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_brn_sk017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl_sk001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl_sk002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl_sk003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl_sk004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl_sk005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl_sk006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl_sk007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl_sk008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl_sk009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl_sk010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl_sk011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl_sk012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/gensys_icl_sk013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen_sk001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen_sk002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen_sk003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen_sk004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen_sk005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen_sk006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen_sk007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen_sk008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen_sk009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen_sk010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen_sk011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen_sk012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen_sk013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen_sk014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen_sk015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen_sk016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_nogen_sk017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen_sk001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen_sk002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen_sk003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen_sk004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen_sk005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen_sk006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen_sk007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen_sk008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen_sk009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen_sk010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen_sk011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen_sk012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen_sk013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen_sk014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen_sk015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen_sk016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_repgen_sk017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_sk001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_sk002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_sk003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_sk004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_sk005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_sk006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_sk007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_sk008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_sk009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_sk010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_sk011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_sk012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_sk013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_sk014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_sk015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_sk016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_brn_sk017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen_sk001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen_sk002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen_sk003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen_sk004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen_sk005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen_sk006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen_sk007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen_sk008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen_sk009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen_sk010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen_sk011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen_sk012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_nogen_sk013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen_sk001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen_sk002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen_sk003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen_sk004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen_sk005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen_sk006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen_sk007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen_sk008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen_sk009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen_sk010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen_sk011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen_sk012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_repgen_sk013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_sk001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_sk002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_sk003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_sk004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_sk005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_sk006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_sk007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_sk008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_sk009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_sk010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_sk011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_sk012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg6/iso_icl_sk013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn019.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn020.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn021.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn022.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn023.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn024.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn025.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn026.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn027.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn028.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn029.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn030.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn031.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn032.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn033.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn034.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn035.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn036.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn037.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn038.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn039.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn040.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn041.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn042.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn043.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn044.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn045.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn046.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn047.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn048.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn049.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn050.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn051.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn052.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn053.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn054.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn055.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk019.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk020.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk021.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk022.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk023.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk024.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk025.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk026.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk027.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk028.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk029.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk030.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk031.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk032.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk033.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk034.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk035.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk036.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk037.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk038.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk039.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk040.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk041.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk042.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk043.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk044.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk045.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk046.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk047.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk048.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk049.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk050.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk051.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk052.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk053.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk054.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_brn_sk055.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_icl001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_icl002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_icl003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_icl004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_icl005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_icl006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_icl007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_icl_sk001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_icl_sk002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_icl_sk003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_icl_sk004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_icl_sk005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_icl_sk006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/gensys_icl_sk007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn019.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn020.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn021.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn022.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn023.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn024.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn025.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn026.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn027.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn028.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn029.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn030.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn031.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn032.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn033.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn034.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn035.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn036.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn037.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn038.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn039.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn040.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn041.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn042.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn043.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn044.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn045.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn046.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn047.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn048.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn049.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn050.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn051.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn052.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn053.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn054.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn055.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen019.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen020.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen_sk002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen_sk003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen_sk004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen_sk005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen_sk006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen_sk007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen_sk008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen_sk009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen_sk010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen_sk011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen_sk012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen_sk013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen_sk014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen_sk015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen_sk016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen_sk017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen_sk018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen_sk019.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_nogen_sk020.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen019.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen020.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen021.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen022.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen023.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen024.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen025.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen026.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen027.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen028.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen029.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen030.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen031.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen032.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen033.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen034.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen035.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen036.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen037.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen038.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen039.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen040.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen041.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen042.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen043.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen044.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen045.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen046.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen047.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen048.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen049.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen050.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen051.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen052.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen053.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen054.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen055.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk019.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk020.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk021.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk022.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk023.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk024.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk025.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk026.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk027.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk028.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk029.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk030.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk031.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk032.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk033.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk034.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk035.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk036.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk037.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk038.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk039.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk040.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk041.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk042.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk043.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk044.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk045.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk046.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk047.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk048.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk049.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk050.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk051.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk052.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk053.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk054.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_repgen_sk055.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk008.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk009.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk010.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk011.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk012.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk013.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk014.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk015.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk016.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk017.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk018.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk019.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk020.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk021.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk022.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk023.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk024.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk025.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk026.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk027.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk028.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk029.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk030.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk031.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk032.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk033.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk034.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk035.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk036.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk037.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk038.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk039.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk040.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk041.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk042.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk043.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk044.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk045.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk046.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk047.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk048.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk049.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk050.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk051.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk052.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk053.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk054.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_brn_sk055.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_nogen001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_nogen002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_nogen003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_nogen004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_nogen005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_nogen006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_nogen007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_nogen_sk001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_nogen_sk002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_nogen_sk003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_nogen_sk004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_nogen_sk005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_nogen_sk006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_nogen_sk007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_repgen001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_repgen002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_repgen003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_repgen004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_repgen005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_repgen006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_repgen007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_repgen_sk001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_repgen_sk002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_repgen_sk003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_repgen_sk004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_repgen_sk005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_repgen_sk006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_repgen_sk007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_sk001.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_sk002.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_sk003.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_sk004.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_sk005.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_sk006.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/QG-classification/qg7/iso_icl_sk007.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ004_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ004_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ004_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ005_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ005_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ005_size8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ005_size9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ009_size10.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ009_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ009_size8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ009_size9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ010_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ010_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ010_size8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ010_size9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ011_size2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ011_size3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ011_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ013_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ013_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ013_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ015_size2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ015_size3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ015_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ017_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ017_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ017_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ018_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ018_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ018_size8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ019_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ019_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ019_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ020_size2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ020_size3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ020_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ026_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ026_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ026_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ026_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ032_size2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ032_size3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ032_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ035_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ035_size5.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ035_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ038_size6.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ038_size7.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ038_size8.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ038_size9.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ042_size2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ042_size3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ042_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ050_size2.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ050_size3.smt2 /Users/aehyvari/work/smtlib//smtlib-20120625/QF_UF/SEQ/SEQ050_size4.smt2 /Users/aehyvari/work/smtlib//smtlib-20120726/QF_BV/check2/bigHex.smt2 /Users/aehyvari/work/smtlib//smtlib-20120726/QF_BV/check2/bvnor.smt2 /Users/aehyvari/work/smtlib//smtlib-20120726/QF_BV/check2/bvsdiv.smt2 /Users/aehyvari/work/smtlib//smtlib-20120726/QF_BV/check2/bvsmod.smt2 /Users/aehyvari/work/smtlib//smtlib-20120726/QF_BV/check2/repeat.smt2 /Users/aehyvari/work/smtlib//smtlib-20120726/QF_BV/check2/symbols.smt2 /Users/aehyvari/work/smtlib//smtlib-20120726/QF_BV/pipe/pipe-noabs.atlas.qf_bv.smt2 /Users/aehyvari/work/smtlib//smtlib-20120726/QF_BV/spear/xinetd_v2.3.14/xinetd_xinetd_vc18132.smt2 /Users/aehyvari/work/smtlib//smtlib-20120726/QF_BV/spear/xinetd_v2.3.14/xinetd_xinetd_vc18154.smt2 /Users/aehyvari/work/smtlib//smtlib-20120726/QF_BV/uclid/tcas/tcas45_k_0.smt2 /Users/aehyvari/work/smtlib//smtlib-20120726/QF_BV/uclid/tcas/tcas60_k_0.smt2 opensmt-2.5.2/test/parsetest.cc000066400000000000000000000013601445011647600165150ustar00rootroot00000000000000#include #include #include #include #include "smt2newcontext.h" extern void smt2newset_in ( FILE * ); extern void smt2newparse ( ); int main(int argc, char ** argv) { if (argc > 1 && strcmp(argv[1], "--help") == 0) { printf("Usage: %s [file]\n", argv[0]); return 1; } FILE* in; if (argc == 2 && (in = fopen(argv[1], "r")) == 0) { perror("Error opening file"); return 1; } else in = fopen("/dev/stdin", "r"); Smt2newContext context(in); int rval = smt2newparse(&context); printf("Parser returned with result %d and ret val %d\n", context.result, rval); if (rval == 0) context.prettyPrint(cout); fclose(in); return rval; } opensmt-2.5.2/test/post-logic.smt2000066400000000000000000000000741445011647600170640ustar00rootroot00000000000000(set-logic AB_CD) (declare-sort U 0) (declare-fun c15 () U) opensmt-2.5.2/test/pre-logic.smt2000066400000000000000000000020501445011647600166610ustar00rootroot00000000000000; set-option test suite (set-option :print-success true) (set-option :my-option quux) (set-option :my-option-2 "Longer story") (set-option :verbosity 3) (set-option :diagnostic-output-channel "/dev/null") (set-option :foo-option) (set-option :bar-option 0) (set-option :pi 3.1415926535879323) (set-option :hex #xdeafbeef) (set-option :bin #b1010101) (set-option :sexprs ( foo "string" #b1010 #xfeb 1.23 2 ( () bar ( :keyword ) ) )) ; get-option test suite (get-option :print-success) (get-option :my-option) (get-option :my-option-2) (get-option :verbosity) (get-option :diagnostic-output-channel) (get-option :foo-option) (get-option :bar-option) (get-option :pi) (get-option :hex) (get-option :bin) (get-option :sexprs) (get-option :non-existing-option) ; set-info test suite (set-info :foo) (set-info :interactive-mode true) (set-info :error-behavior commit-adultery) (set-info :name "OpenSMT") (set-info :authors "Muumi-peikko") ; get-info test suite (get-info :foo) (get-info :error-behavior) (get-info :name) (get-info :authors) (exit) (set-logic foo) opensmt-2.5.2/test/scatter_config.smt2000066400000000000000000000004151445011647600177750ustar00rootroot00000000000000(set-option :split-type "scattering") (set-option :split-units "decisions") (set-option :split-asap true) (set-option :split-init-tune 2) (set-option :split-mid-tune 2) (set-option :split-num 4) (set-option :split-format "smt2") (set-option :dump-state "/dev/shm/asd") opensmt-2.5.2/test/scatter_la_config.smt2000066400000000000000000000001511445011647600204460ustar00rootroot00000000000000(set-option :split-type "lookahead") (set-option :split-num 64) (set-option :dump-state "/tmp/bar/dump") opensmt-2.5.2/test/setlogic.smt2000066400000000000000000000000221445011647600166060ustar00rootroot00000000000000(set-logic QF_BV) opensmt-2.5.2/test/simplanglexer.ll.backup000066400000000000000000000013151445011647600206430ustar00rootroot00000000000000%{ #include #include #include #include #include "Snode.h" using namespace std; #include "simplangparser.h" %} %x start_source %x start_comment %option noyywrap %option yylineno %option nounput %% [ \t\n] { } ";".*\n { } 0|[1-9][0-9]* { simplanglval.str = strdup( yytext ); return TK_NUM; } [a-zA-Z~!@\$\%\^&\*\-\+=\<\>\.\?\/'][a-zA-Z0-9~!@\$\%\^&\*_\-\+=\<\>\.\?\/']*|_[a-zA-Z0-9~!@\$\%\^&\*_\-\+=\<\>\.\?\/']+ { simplanglval.str = strdup( yytext ); return TK_SYM; } . { printf( "Syntax error at line %d near %s\n", yylineno, yytext ); exit( 1 ); } %% opensmt-2.5.2/test/simplanglexer_orig.ll000066400000000000000000000074211445011647600204230ustar00rootroot00000000000000%option prefix="simplang" %option reentrant %option bison-bridge %option bison-locations %option noyywrap %option yylineno %{ #include #include #include #include #include "simplangcontext.h" #include "simplangparser.h" #define YY_EXTRA_TYPE SimplangContext* #define YY_USER_ACTION yylloc->first_line = yylineno; #define YY_INPUT(buf,result,max_size) \ { \ char c; \ (yyextra->is) >> c; \ if (yyextra->is.eof()) \ result = YY_NULL; \ else { \ buf[0] = c; \ result = 1; \ } \ } %} %x start_source %x start_string %% "declare-fun" { yylval->str = strdup( yytext ); printf("f: declare-fun\n"); return TK_DECLAREFUN; } /*"set-logic" { yylval->str = strdup( yytext ); printf("f: set-logic\n"); return TK_SETLOGIC; } "set-info" { yylval->str = strdup( yytext ); printf("f: set-info\n"); return TK_SETINFO; } [ \t\n]+ // Eat up whitespace ";".*\n { printf("A comment\n"); }*/ /* \:[a-zA-Z0-9~!@\$\%\^&\*_\-\+=\<\>\.\?\/]+ { yylval->str = strdup( yytext ); return TK_KEY; } 0|[1-9][0-9]* { yylval->str = strdup( yytext ); return TK_NUM; } [0-9]+\.0*[0-9]+ { yylval->str = strdup( yytext ); return TK_DEC; } #x[a-fA-F0-9]+ { yylval->str = strdup( yytext ); return TK_HEX; } #b[0-1]+ { yylval->str = strdup( yytext ); return TK_BIN; } */ [a-zA-Z~!@\$\%\^&\*\-\+=\<\>\.\?\/'][a-zA-Z0-9~!@\$\%\^&\*_\-\+=\<\>\.\?\/']*|_[a-zA-Z0-9~!@\$\%\^&\*_\-\+=\<\>\.\?\/']+ { yylval->str = strdup( yytext ); return TK_SYM; } [()] { return *yytext; } /* _ { return *yytext; } \" { BEGIN(start_string); printf("Noticed a string\n"); } { \" { yylval->str = strdup(yyextra->getBuf()); yyextra->clearBuf(); BEGIN(INITIAL); printf("Noticed an end of a string\n"); return TK_STR; } [ ] { yyextra->insertBuf(' '); printf("Noticed a space\n"); } [\t] { yyextra->insertBuf('\t'); printf("Noticed a tab\n"); } \n { yyextra->insertBuf('\n'); printf("Noticed a newline\n"); } "b" { printf("Noticed a special letter b\n"); } \\ { if (yytext[1] == '"') { yyextra->insertBuf('"'); printf("Noticed an escaped double quote\n"); } else if (yytext[1] == '\\') { yyextra->insertBuf('\\'); printf("Noticed an escaped backslash\n"); } yytext ++; } [^\\\n\"b] { yyextra->insertBuf(yytext[0]); printf("Noticed a character `%c'\n", yytext[0]); } } \| { BEGIN(start_source); } { [^\|\n] { yyextra->insertBuf(yytext[0]); } \n { yyextra->insertBuf('\n'); } \| { yylval->str = strdup(yyextra->getBuf()); yyextra->clearBuf(); BEGIN(INITIAL); return TK_SYM; } } */ . { printf( "Syntax error at line %d near %s\n", yylineno, yytext ); exit( 1 ); } %% void SimplangContext::init_scanner() { yylex_init(&scanner); yyset_extra(this, scanner); } void SimplangContext::destroy_scanner() { yylex_destroy(scanner); } opensmt-2.5.2/test/simplangparser.cc000066400000000000000000002533261445011647600175450ustar00rootroot00000000000000/* A Bison parser, made by GNU Bison 2.3. */ /* Skeleton implementation for Bison's Yacc-like parsers in C Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ /* As a special exception, you may create a larger work that contains part or all of the Bison parser skeleton and distribute that work under terms of your choice, so long as that work isn't itself a parser generator using the skeleton or a modified version thereof as a parser skeleton. Alternatively, if you modify or redistribute the parser skeleton itself, you may (at your option) remove this special exception, which will cause the skeleton and the resulting Bison output files to be licensed under the GNU General Public License without this special exception. This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ /* C LALR(1) parser skeleton written by Richard Stallman, by simplifying the original so-called "semantic" parser. */ /* All symbols defined below should begin with yy or YY, to avoid infringing on user name space. This should be done even for local variables, as they might otherwise be expanded by user macros. There are some unavoidable exceptions within include files to define necessary library symbols; they are noted "INFRINGES ON USER NAME SPACE" below. */ /* Identify Bison output. */ #define YYBISON 1 /* Bison version. */ #define YYBISON_VERSION "2.3" /* Skeleton name. */ #define YYSKELETON_NAME "yacc.c" /* Pure parsers. */ #define YYPURE 1 /* Using locations. */ #define YYLSP_NEEDED 1 /* Substitute the variable and function names. */ #define yyparse simplangparse #define yylex simplanglex #define yyerror simplangerror #define yylval simplanglval #define yychar simplangchar #define yydebug simplangdebug #define yynerrs simplangnerrs #define yylloc simplanglloc /* Tokens. */ #ifndef YYTOKENTYPE # define YYTOKENTYPE /* Put the tokens into the symbol table, so that GDB and other debuggers know about them. */ enum yytokentype { TK_AS = 258, TK_DECIMAL = 259, TK_EXISTS = 260, TK_FORALL = 261, TK_LET = 262, TK_NUMERAL = 263, TK_PAR = 264, TK_STRING = 265, TK_ASSERT = 266, TK_CHECKSAT = 267, TK_DECLARESORT = 268, TK_DECLAREFUN = 269, TK_DEFINESORT = 270, TK_DEFINEFUN = 271, TK_EXIT = 272, TK_GETASSERTIONS = 273, TK_GETASSIGNMENT = 274, TK_GETINFO = 275, TK_GETOPTION = 276, TK_GETPROOF = 277, TK_GETUNSATCORE = 278, TK_GETVALUE = 279, TK_POP = 280, TK_PUSH = 281, TK_SETLOGIC = 282, TK_SETINFO = 283, TK_SETOPTION = 284, TK_THEORY = 285, TK_NUM = 286, TK_SYM = 287, TK_KEY = 288, TK_STR = 289, TK_DEC = 290, TK_HEX = 291, TK_BIN = 292, KW_SORTS = 293, KW_FUNS = 294, KW_SORTSDESCRIPTION = 295, KW_FUNSDESCRIPTION = 296, KW_DEFINITION = 297, KW_NOTES = 298, KW_THEORIES = 299, KW_LANGUAGE = 300, KW_EXTENSIONS = 301, KW_VALUES = 302, KW_PRINTSUCCESS = 303, KW_EXPANDDEFINITIONS = 304, KW_INTERACTIVEMODE = 305, KW_PRODUCEPROOFS = 306, KW_PRODUCEUNSATCORES = 307, KW_PRODUCEMODELS = 308, KW_PRODUCEASSIGNMENTS = 309, KW_REGULAROUTPUTCHANNEL = 310, KW_DIAGNOSTICOUTPUTCHANNEL = 311, KW_RANDOMSEED = 312, KW_VERBOSITY = 313, KW_ERRORBEHAVIOR = 314, KW_NAME = 315, KW_AUTHORS = 316, KW_VERSION = 317, KW_STATUS = 318, KW_REASONUNKNOWN = 319, KW_ALLSTATISTICS = 320 }; #endif /* Tokens. */ #define TK_AS 258 #define TK_DECIMAL 259 #define TK_EXISTS 260 #define TK_FORALL 261 #define TK_LET 262 #define TK_NUMERAL 263 #define TK_PAR 264 #define TK_STRING 265 #define TK_ASSERT 266 #define TK_CHECKSAT 267 #define TK_DECLARESORT 268 #define TK_DECLAREFUN 269 #define TK_DEFINESORT 270 #define TK_DEFINEFUN 271 #define TK_EXIT 272 #define TK_GETASSERTIONS 273 #define TK_GETASSIGNMENT 274 #define TK_GETINFO 275 #define TK_GETOPTION 276 #define TK_GETPROOF 277 #define TK_GETUNSATCORE 278 #define TK_GETVALUE 279 #define TK_POP 280 #define TK_PUSH 281 #define TK_SETLOGIC 282 #define TK_SETINFO 283 #define TK_SETOPTION 284 #define TK_THEORY 285 #define TK_NUM 286 #define TK_SYM 287 #define TK_KEY 288 #define TK_STR 289 #define TK_DEC 290 #define TK_HEX 291 #define TK_BIN 292 #define KW_SORTS 293 #define KW_FUNS 294 #define KW_SORTSDESCRIPTION 295 #define KW_FUNSDESCRIPTION 296 #define KW_DEFINITION 297 #define KW_NOTES 298 #define KW_THEORIES 299 #define KW_LANGUAGE 300 #define KW_EXTENSIONS 301 #define KW_VALUES 302 #define KW_PRINTSUCCESS 303 #define KW_EXPANDDEFINITIONS 304 #define KW_INTERACTIVEMODE 305 #define KW_PRODUCEPROOFS 306 #define KW_PRODUCEUNSATCORES 307 #define KW_PRODUCEMODELS 308 #define KW_PRODUCEASSIGNMENTS 309 #define KW_REGULAROUTPUTCHANNEL 310 #define KW_DIAGNOSTICOUTPUTCHANNEL 311 #define KW_RANDOMSEED 312 #define KW_VERBOSITY 313 #define KW_ERRORBEHAVIOR 314 #define KW_NAME 315 #define KW_AUTHORS 316 #define KW_VERSION 317 #define KW_STATUS 318 #define KW_REASONUNKNOWN 319 #define KW_ALLSTATISTICS 320 /* Copy the first part of user declarations. */ #line 9 "simplangparser.yy" #include #include #include #include #include #include #include #include "simplangcontext.h" #include "simplangparser.h" int simplanglex(YYSTYPE* lvalp, YYLTYPE* llocp, void* scanner); void simplangerror( YYLTYPE* locp, SimplangContext* context, const char * s ) { printf( "At line %d: %s\n", locp->first_line, s ); exit( 1 ); } #define scanner context->scanner /* Overallocation to prevent stack overflow */ #define YYMAXDEPTH 1024 * 1024 /* Enabling traces. */ #ifndef YYDEBUG # define YYDEBUG 0 #endif /* Enabling verbose error messages. */ #ifdef YYERROR_VERBOSE # undef YYERROR_VERBOSE # define YYERROR_VERBOSE 1 #else # define YYERROR_VERBOSE 1 #endif /* Enabling the token table. */ #ifndef YYTOKEN_TABLE # define YYTOKEN_TABLE 0 #endif #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED typedef union YYSTYPE #line 37 "simplangparser.yy" { char * str; vector< string > * str_list; ASTNode * snode; list< ASTNode * > * snode_list; } /* Line 193 of yacc.c. */ #line 268 "simplangparser.cc" YYSTYPE; # define yystype YYSTYPE /* obsolescent; will be withdrawn */ # define YYSTYPE_IS_DECLARED 1 # define YYSTYPE_IS_TRIVIAL 1 #endif #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED typedef struct YYLTYPE { int first_line; int first_column; int last_line; int last_column; } YYLTYPE; # define yyltype YYLTYPE /* obsolescent; will be withdrawn */ # define YYLTYPE_IS_DECLARED 1 # define YYLTYPE_IS_TRIVIAL 1 #endif /* Copy the second part of user declarations. */ /* Line 216 of yacc.c. */ #line 293 "simplangparser.cc" #ifdef short # undef short #endif #ifdef YYTYPE_UINT8 typedef YYTYPE_UINT8 yytype_uint8; #else typedef unsigned char yytype_uint8; #endif #ifdef YYTYPE_INT8 typedef YYTYPE_INT8 yytype_int8; #elif (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) typedef signed char yytype_int8; #else typedef short int yytype_int8; #endif #ifdef YYTYPE_UINT16 typedef YYTYPE_UINT16 yytype_uint16; #else typedef unsigned short int yytype_uint16; #endif #ifdef YYTYPE_INT16 typedef YYTYPE_INT16 yytype_int16; #else typedef short int yytype_int16; #endif #ifndef YYSIZE_T # ifdef __SIZE_TYPE__ # define YYSIZE_T __SIZE_TYPE__ # elif defined size_t # define YYSIZE_T size_t # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) # include /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T size_t # else # define YYSIZE_T unsigned int # endif #endif #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) #ifndef YY_ # if defined YYENABLE_NLS && YYENABLE_NLS # if ENABLE_NLS # include /* INFRINGES ON USER NAME SPACE */ # define YY_(msgid) dgettext ("bison-runtime", msgid) # endif # endif # ifndef YY_ # define YY_(msgid) msgid # endif #endif /* Suppress unused-variable warnings by "using" E. */ #if ! defined lint || defined __GNUC__ # define YYUSE(e) ((void) (e)) #else # define YYUSE(e) /* empty */ #endif /* Identity function, used to suppress warnings about constant conditions. */ #ifndef lint # define YYID(n) (n) #else #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) static int YYID (int i) #else static int YYID (i) int i; #endif { return i; } #endif #if ! defined yyoverflow || YYERROR_VERBOSE /* The parser invokes alloca or malloc; define the necessary symbols. */ # ifdef YYSTACK_USE_ALLOCA # if YYSTACK_USE_ALLOCA # ifdef __GNUC__ # define YYSTACK_ALLOC __builtin_alloca # elif defined __BUILTIN_VA_ARG_INCR # include /* INFRINGES ON USER NAME SPACE */ # elif defined _AIX # define YYSTACK_ALLOC __alloca # elif defined _MSC_VER # include /* INFRINGES ON USER NAME SPACE */ # define alloca _alloca # else # define YYSTACK_ALLOC alloca # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) # include /* INFRINGES ON USER NAME SPACE */ # ifndef _STDLIB_H # define _STDLIB_H 1 # endif # endif # endif # endif # endif # ifdef YYSTACK_ALLOC /* Pacify GCC's `empty if-body' warning. */ # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) # ifndef YYSTACK_ALLOC_MAXIMUM /* The OS might guarantee only one guard page at the bottom of the stack, and a page size can be as small as 4096 bytes. So we cannot safely invoke alloca (N) if N exceeds 4096. Use a slightly smaller number to allow for a few compiler-allocated temporary stack slots. */ # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ # endif # else # define YYSTACK_ALLOC YYMALLOC # define YYSTACK_FREE YYFREE # ifndef YYSTACK_ALLOC_MAXIMUM # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM # endif # if (defined __cplusplus && ! defined _STDLIB_H \ && ! ((defined YYMALLOC || defined malloc) \ && (defined YYFREE || defined free))) # include /* INFRINGES ON USER NAME SPACE */ # ifndef _STDLIB_H # define _STDLIB_H 1 # endif # endif # ifndef YYMALLOC # define YYMALLOC malloc # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ # endif # endif # ifndef YYFREE # define YYFREE free # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) void free (void *); /* INFRINGES ON USER NAME SPACE */ # endif # endif # endif #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ #if (! defined yyoverflow \ && (! defined __cplusplus \ || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \ && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) /* A type that is properly aligned for any stack member. */ union yyalloc { yytype_int16 yyss; YYSTYPE yyvs; YYLTYPE yyls; }; /* The size of the maximum gap between one aligned stack and the next. */ # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) /* The size of an array large to enough to hold all stacks, each with N elements. */ # define YYSTACK_BYTES(N) \ ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ + 2 * YYSTACK_GAP_MAXIMUM) /* Copy COUNT objects from FROM to TO. The source and destination do not overlap. */ # ifndef YYCOPY # if defined __GNUC__ && 1 < __GNUC__ # define YYCOPY(To, From, Count) \ __builtin_memcpy (To, From, (Count) * sizeof (*(From))) # else # define YYCOPY(To, From, Count) \ do \ { \ YYSIZE_T yyi; \ for (yyi = 0; yyi < (Count); yyi++) \ (To)[yyi] = (From)[yyi]; \ } \ while (YYID (0)) # endif # endif /* Relocate STACK from its old location to the new one. The local variables YYSIZE and YYSTACKSIZE give the old and new number of elements in the stack, and YYPTR gives the new location of the stack. Advance YYPTR to a properly aligned location for the next stack. */ # define YYSTACK_RELOCATE(Stack) \ do \ { \ YYSIZE_T yynewbytes; \ YYCOPY (&yyptr->Stack, Stack, yysize); \ Stack = &yyptr->Stack; \ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ yyptr += yynewbytes / sizeof (*yyptr); \ } \ while (YYID (0)) #endif /* YYFINAL -- State number of the termination state. */ #define YYFINAL 3 /* YYLAST -- Last index in YYTABLE. */ #define YYLAST 313 /* YYNTOKENS -- Number of terminals. */ #define YYNTOKENS 70 /* YYNNTS -- Number of nonterminals. */ #define YYNNTS 26 /* YYNRULES -- Number of rules. */ #define YYNRULES 120 /* YYNRULES -- Number of states. */ #define YYNSTATES 223 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ #define YYUNDEFTOK 2 #define YYMAXUTOK 320 #define YYTRANSLATE(YYX) \ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ static const yytype_uint8 yytranslate[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 69, 2, 2, 2, 2, 2, 2, 66, 67, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 68, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65 }; #if YYDEBUG /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in YYRHS. */ static const yytype_uint16 yyprhs[] = { 0, 0, 3, 5, 6, 9, 14, 19, 24, 30, 39, 48, 58, 63, 68, 73, 77, 81, 85, 89, 97, 101, 106, 111, 116, 120, 121, 124, 126, 129, 131, 134, 136, 138, 142, 144, 150, 152, 158, 161, 162, 164, 166, 168, 172, 173, 176, 178, 180, 182, 184, 186, 189, 191, 193, 199, 200, 203, 208, 209, 212, 217, 218, 221, 223, 225, 231, 240, 249, 258, 263, 264, 267, 269, 272, 275, 278, 281, 284, 287, 290, 293, 296, 299, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374 }; /* YYRHS -- A `-1'-separated list of the rules' RHS. */ static const yytype_int8 yyrhs[] = { 71, 0, -1, 72, -1, -1, 72, 73, -1, 66, 27, 32, 67, -1, 66, 29, 93, 67, -1, 66, 28, 75, 67, -1, 66, 13, 32, 31, 67, -1, 66, 15, 32, 66, 91, 67, 78, 67, -1, 66, 14, 32, 66, 79, 67, 78, 67, -1, 66, 16, 32, 66, 87, 67, 78, 90, 67, -1, 66, 26, 31, 67, -1, 66, 25, 31, 67, -1, 66, 11, 90, 67, -1, 66, 12, 67, -1, 66, 18, 67, -1, 66, 22, 67, -1, 66, 23, 67, -1, 66, 24, 66, 90, 89, 67, 67, -1, 66, 19, 67, -1, 66, 21, 33, 67, -1, 66, 21, 94, 67, -1, 66, 20, 95, 67, -1, 66, 17, 67, -1, -1, 74, 75, -1, 33, -1, 33, 76, -1, 94, -1, 94, 76, -1, 82, -1, 32, -1, 66, 81, 67, -1, 32, -1, 66, 68, 32, 83, 67, -1, 77, -1, 66, 77, 78, 79, 67, -1, 79, 78, -1, -1, 82, -1, 32, -1, 33, -1, 66, 81, 67, -1, -1, 81, 80, -1, 31, -1, 35, -1, 36, -1, 37, -1, 34, -1, 83, 31, -1, 31, -1, 77, -1, 66, 3, 77, 78, 67, -1, -1, 85, 86, -1, 66, 32, 90, 67, -1, -1, 87, 88, -1, 66, 32, 78, 67, -1, -1, 89, 90, -1, 82, -1, 84, -1, 66, 84, 90, 89, 67, -1, 66, 7, 66, 86, 85, 67, 90, 67, -1, 66, 6, 66, 88, 87, 67, 90, 67, -1, 66, 5, 66, 88, 87, 67, 90, 67, -1, 69, 90, 75, 74, -1, -1, 91, 32, -1, 32, -1, 48, 92, -1, 49, 92, -1, 50, 92, -1, 51, 92, -1, 52, 92, -1, 53, 92, -1, 54, 92, -1, 55, 34, -1, 56, 34, -1, 57, 31, -1, 58, 31, -1, 75, -1, 38, -1, 39, -1, 40, -1, 41, -1, 42, -1, 47, -1, 43, -1, 44, -1, 45, -1, 46, -1, 48, -1, 49, -1, 50, -1, 51, -1, 52, -1, 53, -1, 54, -1, 55, -1, 56, -1, 57, -1, 58, -1, 59, -1, 60, -1, 61, -1, 62, -1, 63, -1, 64, -1, 65, -1, 59, -1, 60, -1, 61, -1, 62, -1, 63, -1, 64, -1, 65, -1, 33, -1 }; /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ static const yytype_uint16 yyrline[] = { 0, 66, 66, 70, 71, 75, 81, 87, 93, 100, 113, 125, 138, 144, 150, 156, 160, 164, 168, 172, 178, 182, 188, 194, 200, 205, 206, 210, 212, 214, 216, 220, 222, 226, 233, 235, 239, 241, 249, 252, 255, 261, 265, 269, 277, 280, 287, 289, 291, 293, 295, 299, 301, 305, 307, 317, 318, 322, 327, 328, 332, 336, 337, 341, 343, 345, 351, 361, 371, 381, 456, 457, 614, 627, 633, 639, 645, 651, 657, 663, 669, 675, 681, 687, 693, 701, 703, 705, 707, 709, 711, 713, 715, 717, 719, 721, 723, 725, 727, 729, 731, 733, 735, 737, 739, 741, 743, 745, 747, 749, 751, 753, 755, 759, 761, 763, 765, 767, 769, 771, 773 }; #endif #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. First, the terminals, then, starting at YYNTOKENS, nonterminals. */ static const char *const yytname[] = { "$end", "error", "$undefined", "TK_AS", "TK_DECIMAL", "TK_EXISTS", "TK_FORALL", "TK_LET", "TK_NUMERAL", "TK_PAR", "TK_STRING", "TK_ASSERT", "TK_CHECKSAT", "TK_DECLARESORT", "TK_DECLAREFUN", "TK_DEFINESORT", "TK_DEFINEFUN", "TK_EXIT", "TK_GETASSERTIONS", "TK_GETASSIGNMENT", "TK_GETINFO", "TK_GETOPTION", "TK_GETPROOF", "TK_GETUNSATCORE", "TK_GETVALUE", "TK_POP", "TK_PUSH", "TK_SETLOGIC", "TK_SETINFO", "TK_SETOPTION", "TK_THEORY", "TK_NUM", "TK_SYM", "TK_KEY", "TK_STR", "TK_DEC", "TK_HEX", "TK_BIN", "KW_SORTS", "KW_FUNS", "KW_SORTSDESCRIPTION", "KW_FUNSDESCRIPTION", "KW_DEFINITION", "KW_NOTES", "KW_THEORIES", "KW_LANGUAGE", "KW_EXTENSIONS", "KW_VALUES", "KW_PRINTSUCCESS", "KW_EXPANDDEFINITIONS", "KW_INTERACTIVEMODE", "KW_PRODUCEPROOFS", "KW_PRODUCEUNSATCORES", "KW_PRODUCEMODELS", "KW_PRODUCEASSIGNMENTS", "KW_REGULAROUTPUTCHANNEL", "KW_DIAGNOSTICOUTPUTCHANNEL", "KW_RANDOMSEED", "KW_VERBOSITY", "KW_ERRORBEHAVIOR", "KW_NAME", "KW_AUTHORS", "KW_VERSION", "KW_STATUS", "KW_REASONUNKNOWN", "KW_ALLSTATISTICS", "'('", "')'", "'_'", "'!'", "$accept", "script", "command_list", "command", "attribute_list", "attribute", "attribute_value", "identifier", "sort", "sort_list", "s_expr", "s_expr_list", "spec_const", "numeral_list", "qual_identifier", "var_binding_list", "var_binding", "sorted_var_list", "sorted_var", "term_list", "term", "symbol_list", "b_value", "option", "predef_key", "info_flag", 0 }; #endif # ifdef YYPRINT /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to token YYLEX-NUM. */ static const yytype_uint16 yytoknum[] = { 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 40, 41, 95, 33 }; # endif /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ static const yytype_uint8 yyr1[] = { 0, 70, 71, 72, 72, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 74, 74, 75, 75, 75, 75, 76, 76, 76, 77, 77, 78, 78, 79, 79, 80, 80, 80, 80, 81, 81, 82, 82, 82, 82, 82, 83, 83, 84, 84, 85, 85, 86, 87, 87, 88, 89, 89, 90, 90, 90, 90, 90, 90, 90, 91, 91, 92, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 95, 95, 95, 95, 95, 95, 95, 95 }; /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ static const yytype_uint8 yyr2[] = { 0, 2, 1, 0, 2, 4, 4, 4, 5, 8, 8, 9, 4, 4, 4, 3, 3, 3, 3, 7, 3, 4, 4, 4, 3, 0, 2, 1, 2, 1, 2, 1, 1, 3, 1, 5, 1, 5, 2, 0, 1, 1, 1, 3, 0, 2, 1, 1, 1, 1, 1, 2, 1, 1, 5, 0, 2, 4, 0, 2, 4, 0, 2, 1, 1, 5, 8, 8, 8, 4, 0, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state STATE-NUM when YYTABLE doesn't specify something else to do. Zero means the default is an error. */ static const yytype_uint8 yydefact[] = { 3, 0, 2, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, 34, 50, 47, 48, 49, 0, 0, 53, 63, 64, 0, 15, 0, 0, 0, 0, 24, 16, 20, 120, 113, 114, 115, 116, 117, 118, 119, 0, 0, 85, 86, 87, 88, 89, 91, 92, 93, 94, 90, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 0, 17, 18, 0, 0, 0, 0, 27, 0, 29, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 39, 70, 58, 23, 21, 22, 61, 13, 12, 5, 32, 44, 28, 31, 7, 30, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 6, 0, 0, 0, 0, 0, 0, 61, 25, 8, 0, 0, 0, 0, 0, 0, 36, 0, 0, 58, 58, 0, 55, 52, 0, 0, 69, 0, 38, 71, 0, 0, 59, 0, 62, 41, 42, 44, 33, 45, 40, 0, 54, 0, 0, 0, 0, 0, 51, 35, 65, 26, 0, 0, 0, 19, 0, 39, 0, 0, 0, 0, 0, 56, 10, 9, 0, 43, 0, 60, 0, 0, 57, 0, 11, 37, 68, 67, 66 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { -1, 1, 2, 5, 170, 91, 128, 33, 172, 154, 183, 158, 34, 168, 35, 191, 166, 156, 176, 157, 178, 155, 133, 105, 92, 53 }; /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ #define YYPACT_NINF -142 static const yytype_int16 yypact[] = { -142, 8, -50, -142, 284, -142, 65, -43, -3, 0, 13, 16, 2, 14, 20, 109, 163, 21, 22, -2, 36, 52, 59, 196, 229, -142, -142, -142, -142, -142, -142, 7, 65, -142, -142, -142, 27, -142, 67, 37, 38, 39, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, 40, 41, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, 43, -142, -142, 65, 44, 60, 61, 101, 62, 101, 98, 98, 98, 98, 98, 98, 98, 105, 106, 110, 112, -142, 77, -25, 79, 80, 84, 6, 119, 65, 196, -142, 85, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, 86, -7, 87, 87, 97, 133, -142, -142, -142, -17, -13, -39, -14, 82, -26, -142, 99, 143, -142, -142, 144, -142, -142, -20, 26, 196, -7, -142, -142, -7, -7, -142, 111, -142, -142, -142, -142, -142, -142, -142, -7, -142, -7, -31, -29, 65, 10, -142, -142, -142, -142, 113, 114, 65, -142, 89, -142, 115, 65, 65, 116, 65, -142, -142, -142, 118, -142, -1, -142, 120, 121, -142, 122, -142, -142, -142, -142, -142 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { -142, -142, -142, -142, -142, -23, 73, -103, -141, -24, -142, 5, -88, -142, 148, -142, 3, -85, -62, 42, -6, -142, 63, -142, 174, -142 }; /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If positive, shift that token. If negative, reduce the rule which number is the opposite. If zero, do what YYDEFACT says. If YYTABLE_NINF, syntax error. */ #define YYTABLE_NINF -1 static const yytype_uint8 yytable[] = { 36, 104, 129, 146, 129, 161, 26, 26, 3, 106, 106, 192, 107, 108, 109, 26, 4, 25, 26, 173, 27, 28, 29, 30, 37, 26, 113, 162, 175, 38, 196, 26, 39, 197, 198, 162, 203, 162, 204, 26, 145, 145, 111, 160, 201, 40, 202, 193, 41, 159, 171, 160, 31, 177, 174, 32, 185, 25, 26, 159, 27, 28, 29, 30, 86, 159, 219, 87, 160, 42, 184, 160, 160, 110, 111, 111, 165, 206, 188, 189, 122, 43, 160, 88, 160, 163, 164, 44, 84, 85, 152, 89, 31, 194, 114, 32, 25, 26, 115, 27, 28, 29, 30, 116, 117, 118, 151, 119, 120, 160, 121, 123, 184, 25, 179, 180, 27, 28, 29, 30, 25, 179, 180, 27, 28, 29, 30, 124, 125, 130, 132, 31, 25, 126, 32, 27, 28, 29, 30, 140, 141, 142, 45, 143, 144, 147, 148, 195, 181, 182, 149, 150, 153, 162, 111, 181, 211, 134, 135, 136, 137, 138, 139, 165, 167, 131, 186, 127, 46, 47, 48, 49, 50, 51, 52, 187, 190, 212, 199, 112, 208, 209, 213, 216, 205, 218, 200, 220, 221, 222, 83, 0, 210, 169, 207, 0, 54, 214, 215, 0, 217, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 90, 0, 0, 0, 0, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 90, 0, 0, 0, 0, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 76, 77, 78, 79, 80, 81, 82, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24 }; static const yytype_int16 yycheck[] = { 6, 24, 90, 106, 92, 146, 32, 32, 0, 3, 3, 31, 5, 6, 7, 32, 66, 31, 32, 32, 34, 35, 36, 37, 67, 32, 32, 66, 67, 32, 171, 32, 32, 174, 175, 66, 67, 66, 67, 32, 66, 66, 68, 146, 185, 32, 187, 67, 32, 66, 67, 154, 66, 67, 67, 69, 159, 31, 32, 66, 34, 35, 36, 37, 66, 66, 67, 31, 171, 67, 158, 174, 175, 66, 68, 68, 66, 67, 163, 164, 86, 67, 185, 31, 187, 147, 148, 67, 67, 67, 113, 32, 66, 67, 67, 69, 31, 32, 31, 34, 35, 36, 37, 66, 66, 66, 112, 67, 67, 212, 67, 67, 200, 31, 32, 33, 34, 35, 36, 37, 31, 32, 33, 34, 35, 36, 37, 67, 67, 67, 32, 66, 31, 32, 69, 34, 35, 36, 37, 34, 34, 31, 33, 31, 67, 66, 66, 170, 66, 67, 66, 32, 67, 66, 68, 66, 67, 94, 95, 96, 97, 98, 99, 66, 31, 92, 67, 66, 59, 60, 61, 62, 63, 64, 65, 32, 32, 201, 67, 31, 67, 67, 67, 67, 190, 67, 181, 67, 67, 67, 16, -1, 198, 151, 191, -1, 33, 203, 204, -1, 206, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 33, -1, -1, -1, -1, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 33, -1, -1, -1, -1, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing symbol of state STATE-NUM. */ static const yytype_uint8 yystos[] = { 0, 71, 72, 0, 66, 73, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 31, 32, 34, 35, 36, 37, 66, 69, 77, 82, 84, 90, 67, 32, 32, 32, 32, 67, 67, 67, 33, 59, 60, 61, 62, 63, 64, 65, 95, 33, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 94, 67, 67, 66, 31, 31, 32, 33, 75, 94, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 75, 93, 3, 5, 6, 7, 66, 68, 84, 90, 67, 31, 66, 66, 66, 67, 67, 67, 90, 67, 67, 67, 32, 66, 76, 82, 67, 76, 32, 92, 92, 92, 92, 92, 92, 92, 34, 34, 31, 31, 67, 66, 77, 66, 66, 66, 32, 90, 75, 67, 79, 91, 87, 89, 81, 66, 77, 78, 66, 88, 88, 66, 86, 31, 83, 89, 74, 67, 78, 32, 67, 67, 88, 67, 90, 32, 33, 66, 67, 80, 82, 77, 67, 32, 87, 87, 32, 85, 31, 67, 67, 75, 78, 78, 78, 67, 81, 78, 78, 67, 67, 90, 67, 86, 67, 67, 90, 67, 79, 67, 90, 90, 67, 90, 67, 67, 67, 67, 67 }; #define yyerrok (yyerrstatus = 0) #define yyclearin (yychar = YYEMPTY) #define YYEMPTY (-2) #define YYEOF 0 #define YYACCEPT goto yyacceptlab #define YYABORT goto yyabortlab #define YYERROR goto yyerrorlab /* Like YYERROR except do call yyerror. This remains here temporarily to ease the transition to the new meaning of YYERROR, for GCC. Once GCC version 2 has supplanted version 1, this can go. */ #define YYFAIL goto yyerrlab #define YYRECOVERING() (!!yyerrstatus) #define YYBACKUP(Token, Value) \ do \ if (yychar == YYEMPTY && yylen == 1) \ { \ yychar = (Token); \ yylval = (Value); \ yytoken = YYTRANSLATE (yychar); \ YYPOPSTACK (1); \ goto yybackup; \ } \ else \ { \ yyerror (&yylloc, context, YY_("syntax error: cannot back up")); \ YYERROR; \ } \ while (YYID (0)) #define YYTERROR 1 #define YYERRCODE 256 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. If N is 0, then set CURRENT to the empty location which ends the previous symbol: RHS[0] (always defined). */ #define YYRHSLOC(Rhs, K) ((Rhs)[K]) #ifndef YYLLOC_DEFAULT # define YYLLOC_DEFAULT(Current, Rhs, N) \ do \ if (YYID (N)) \ { \ (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ } \ else \ { \ (Current).first_line = (Current).last_line = \ YYRHSLOC (Rhs, 0).last_line; \ (Current).first_column = (Current).last_column = \ YYRHSLOC (Rhs, 0).last_column; \ } \ while (YYID (0)) #endif /* YY_LOCATION_PRINT -- Print the location on the stream. This macro was not mandated originally: define only if we know we won't break user code: when these are the locations we know. */ #ifndef YY_LOCATION_PRINT # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL # define YY_LOCATION_PRINT(File, Loc) \ fprintf (File, "%d.%d-%d.%d", \ (Loc).first_line, (Loc).first_column, \ (Loc).last_line, (Loc).last_column) # else # define YY_LOCATION_PRINT(File, Loc) ((void) 0) # endif #endif /* YYLEX -- calling `yylex' with the right arguments. */ #ifdef YYLEX_PARAM # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) #else # define YYLEX yylex (&yylval, &yylloc, scanner) #endif /* Enable debugging if requested. */ #if YYDEBUG # ifndef YYFPRINTF # include /* INFRINGES ON USER NAME SPACE */ # define YYFPRINTF fprintf # endif # define YYDPRINTF(Args) \ do { \ if (yydebug) \ YYFPRINTF Args; \ } while (YYID (0)) # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ do { \ if (yydebug) \ { \ YYFPRINTF (stderr, "%s ", Title); \ yy_symbol_print (stderr, \ Type, Value, Location, context); \ YYFPRINTF (stderr, "\n"); \ } \ } while (YYID (0)) /*--------------------------------. | Print this symbol on YYOUTPUT. | `--------------------------------*/ /*ARGSUSED*/ #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) static void yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, SimplangContext* context) #else static void yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, context) FILE *yyoutput; int yytype; YYSTYPE const * const yyvaluep; YYLTYPE const * const yylocationp; SimplangContext* context; #endif { if (!yyvaluep) return; YYUSE (yylocationp); YYUSE (context); # ifdef YYPRINT if (yytype < YYNTOKENS) YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); # else YYUSE (yyoutput); # endif switch (yytype) { default: break; } } /*--------------------------------. | Print this symbol on YYOUTPUT. | `--------------------------------*/ #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) static void yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, SimplangContext* context) #else static void yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, context) FILE *yyoutput; int yytype; YYSTYPE const * const yyvaluep; YYLTYPE const * const yylocationp; SimplangContext* context; #endif { if (yytype < YYNTOKENS) YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); else YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); YY_LOCATION_PRINT (yyoutput, *yylocationp); YYFPRINTF (yyoutput, ": "); yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, context); YYFPRINTF (yyoutput, ")"); } /*------------------------------------------------------------------. | yy_stack_print -- Print the state stack from its BOTTOM up to its | | TOP (included). | `------------------------------------------------------------------*/ #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) static void yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) #else static void yy_stack_print (bottom, top) yytype_int16 *bottom; yytype_int16 *top; #endif { YYFPRINTF (stderr, "Stack now"); for (; bottom <= top; ++bottom) YYFPRINTF (stderr, " %d", *bottom); YYFPRINTF (stderr, "\n"); } # define YY_STACK_PRINT(Bottom, Top) \ do { \ if (yydebug) \ yy_stack_print ((Bottom), (Top)); \ } while (YYID (0)) /*------------------------------------------------. | Report that the YYRULE is going to be reduced. | `------------------------------------------------*/ #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) static void yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, SimplangContext* context) #else static void yy_reduce_print (yyvsp, yylsp, yyrule, context) YYSTYPE *yyvsp; YYLTYPE *yylsp; int yyrule; SimplangContext* context; #endif { int yynrhs = yyr2[yyrule]; int yyi; unsigned long int yylno = yyrline[yyrule]; YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", yyrule - 1, yylno); /* The symbols being reduced. */ for (yyi = 0; yyi < yynrhs; yyi++) { fprintf (stderr, " $%d = ", yyi + 1); yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], &(yyvsp[(yyi + 1) - (yynrhs)]) , &(yylsp[(yyi + 1) - (yynrhs)]) , context); fprintf (stderr, "\n"); } } # define YY_REDUCE_PRINT(Rule) \ do { \ if (yydebug) \ yy_reduce_print (yyvsp, yylsp, Rule, context); \ } while (YYID (0)) /* Nonzero means print parse trace. It is left uninitialized so that multiple parsers can coexist. */ int yydebug; #else /* !YYDEBUG */ # define YYDPRINTF(Args) # define YY_SYMBOL_PRINT(Title, Type, Value, Location) # define YY_STACK_PRINT(Bottom, Top) # define YY_REDUCE_PRINT(Rule) #endif /* !YYDEBUG */ /* YYINITDEPTH -- initial size of the parser's stacks. */ #ifndef YYINITDEPTH # define YYINITDEPTH 200 #endif /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only if the built-in stack extension method is used). Do not make this value too large; the results are undefined if YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) evaluated with infinite-precision integer arithmetic. */ #ifndef YYMAXDEPTH # define YYMAXDEPTH 10000 #endif #if YYERROR_VERBOSE # ifndef yystrlen # if defined __GLIBC__ && defined _STRING_H # define yystrlen strlen # else /* Return the length of YYSTR. */ #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) static YYSIZE_T yystrlen (const char *yystr) #else static YYSIZE_T yystrlen (yystr) const char *yystr; #endif { YYSIZE_T yylen; for (yylen = 0; yystr[yylen]; yylen++) continue; return yylen; } # endif # endif # ifndef yystpcpy # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE # define yystpcpy stpcpy # else /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in YYDEST. */ #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) static char * yystpcpy (char *yydest, const char *yysrc) #else static char * yystpcpy (yydest, yysrc) char *yydest; const char *yysrc; #endif { char *yyd = yydest; const char *yys = yysrc; while ((*yyd++ = *yys++) != '\0') continue; return yyd - 1; } # endif # endif # ifndef yytnamerr /* Copy to YYRES the contents of YYSTR after stripping away unnecessary quotes and backslashes, so that it's suitable for yyerror. The heuristic is that double-quoting is unnecessary unless the string contains an apostrophe, a comma, or backslash (other than backslash-backslash). YYSTR is taken from yytname. If YYRES is null, do not copy; instead, return the length of what the result would have been. */ static YYSIZE_T yytnamerr (char *yyres, const char *yystr) { if (*yystr == '"') { YYSIZE_T yyn = 0; char const *yyp = yystr; for (;;) switch (*++yyp) { case '\'': case ',': goto do_not_strip_quotes; case '\\': if (*++yyp != '\\') goto do_not_strip_quotes; /* Fall through. */ default: if (yyres) yyres[yyn] = *yyp; yyn++; break; case '"': if (yyres) yyres[yyn] = '\0'; return yyn; } do_not_strip_quotes: ; } if (! yyres) return yystrlen (yystr); return yystpcpy (yyres, yystr) - yyres; } # endif /* Copy into YYRESULT an error message about the unexpected token YYCHAR while in state YYSTATE. Return the number of bytes copied, including the terminating null byte. If YYRESULT is null, do not copy anything; just return the number of bytes that would be copied. As a special case, return 0 if an ordinary "syntax error" message will do. Return YYSIZE_MAXIMUM if overflow occurs during size calculation. */ static YYSIZE_T yysyntax_error (char *yyresult, int yystate, int yychar) { int yyn = yypact[yystate]; if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) return 0; else { int yytype = YYTRANSLATE (yychar); YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); YYSIZE_T yysize = yysize0; YYSIZE_T yysize1; int yysize_overflow = 0; enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; int yyx; # if 0 /* This is so xgettext sees the translatable formats that are constructed on the fly. */ YY_("syntax error, unexpected %s"); YY_("syntax error, unexpected %s, expecting %s"); YY_("syntax error, unexpected %s, expecting %s or %s"); YY_("syntax error, unexpected %s, expecting %s or %s or %s"); YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); # endif char *yyfmt; char const *yyf; static char const yyunexpected[] = "syntax error, unexpected %s"; static char const yyexpecting[] = ", expecting %s"; static char const yyor[] = " or %s"; char yyformat[sizeof yyunexpected + sizeof yyexpecting - 1 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) * (sizeof yyor - 1))]; char const *yyprefix = yyexpecting; /* Start YYX at -YYN if negative to avoid negative indexes in YYCHECK. */ int yyxbegin = yyn < 0 ? -yyn : 0; /* Stay within bounds of both yycheck and yytname. */ int yychecklim = YYLAST - yyn + 1; int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; int yycount = 1; yyarg[0] = yytname[yytype]; yyfmt = yystpcpy (yyformat, yyunexpected); for (yyx = yyxbegin; yyx < yyxend; ++yyx) if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) { if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) { yycount = 1; yysize = yysize0; yyformat[sizeof yyunexpected - 1] = '\0'; break; } yyarg[yycount++] = yytname[yyx]; yysize1 = yysize + yytnamerr (0, yytname[yyx]); yysize_overflow |= (yysize1 < yysize); yysize = yysize1; yyfmt = yystpcpy (yyfmt, yyprefix); yyprefix = yyor; } yyf = YY_(yyformat); yysize1 = yysize + yystrlen (yyf); yysize_overflow |= (yysize1 < yysize); yysize = yysize1; if (yysize_overflow) return YYSIZE_MAXIMUM; if (yyresult) { /* Avoid sprintf, as that infringes on the user's name space. Don't have undefined behavior even if the translation produced a string with the wrong number of "%s"s. */ char *yyp = yyresult; int yyi = 0; while ((*yyp = *yyf) != '\0') { if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) { yyp += yytnamerr (yyp, yyarg[yyi++]); yyf += 2; } else { yyp++; yyf++; } } } return yysize; } } #endif /* YYERROR_VERBOSE */ /*-----------------------------------------------. | Release the memory associated to this symbol. | `-----------------------------------------------*/ /*ARGSUSED*/ #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) static void yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, SimplangContext* context) #else static void yydestruct (yymsg, yytype, yyvaluep, yylocationp, context) const char *yymsg; int yytype; YYSTYPE *yyvaluep; YYLTYPE *yylocationp; SimplangContext* context; #endif { YYUSE (yyvaluep); YYUSE (yylocationp); YYUSE (context); if (!yymsg) yymsg = "Deleting"; YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); switch (yytype) { default: break; } } /* Prevent warnings from -Wmissing-prototypes. */ #ifdef YYPARSE_PARAM #if defined __STDC__ || defined __cplusplus int yyparse (void *YYPARSE_PARAM); #else int yyparse (); #endif #else /* ! YYPARSE_PARAM */ #if defined __STDC__ || defined __cplusplus int yyparse (SimplangContext* context); #else int yyparse (); #endif #endif /* ! YYPARSE_PARAM */ /*----------. | yyparse. | `----------*/ #ifdef YYPARSE_PARAM #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) int yyparse (void *YYPARSE_PARAM) #else int yyparse (YYPARSE_PARAM) void *YYPARSE_PARAM; #endif #else /* ! YYPARSE_PARAM */ #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) int yyparse (SimplangContext* context) #else int yyparse (context) SimplangContext* context; #endif #endif { /* The look-ahead symbol. */ int yychar; /* The semantic value of the look-ahead symbol. */ YYSTYPE yylval; /* Number of syntax errors so far. */ int yynerrs; /* Location data for the look-ahead symbol. */ YYLTYPE yylloc; int yystate; int yyn; int yyresult; /* Number of tokens to shift before error messages enabled. */ int yyerrstatus; /* Look-ahead token as an internal (translated) token number. */ int yytoken = 0; #if YYERROR_VERBOSE /* Buffer for error messages, and its allocated size. */ char yymsgbuf[128]; char *yymsg = yymsgbuf; YYSIZE_T yymsg_alloc = sizeof yymsgbuf; #endif /* Three stacks and their tools: `yyss': related to states, `yyvs': related to semantic values, `yyls': related to locations. Refer to the stacks thru separate pointers, to allow yyoverflow to reallocate them elsewhere. */ /* The state stack. */ yytype_int16 yyssa[YYINITDEPTH]; yytype_int16 *yyss = yyssa; yytype_int16 *yyssp; /* The semantic value stack. */ YYSTYPE yyvsa[YYINITDEPTH]; YYSTYPE *yyvs = yyvsa; YYSTYPE *yyvsp; /* The location stack. */ YYLTYPE yylsa[YYINITDEPTH]; YYLTYPE *yyls = yylsa; YYLTYPE *yylsp; /* The locations where the error started and ended. */ YYLTYPE yyerror_range[2]; #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) YYSIZE_T yystacksize = YYINITDEPTH; /* The variables used to return semantic value and location from the action routines. */ YYSTYPE yyval; YYLTYPE yyloc; /* The number of symbols on the RHS of the reduced rule. Keep to zero when no symbol should be popped. */ int yylen = 0; YYDPRINTF ((stderr, "Starting parse\n")); yystate = 0; yyerrstatus = 0; yynerrs = 0; yychar = YYEMPTY; /* Cause a token to be read. */ /* Initialize stack pointers. Waste one element of value and location stack so that they stay on the same level as the state stack. The wasted elements are never initialized. */ yyssp = yyss; yyvsp = yyvs; yylsp = yyls; #if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL /* Initialize the default location before parsing starts. */ yylloc.first_line = yylloc.last_line = 1; yylloc.first_column = yylloc.last_column = 0; #endif goto yysetstate; /*------------------------------------------------------------. | yynewstate -- Push a new state, which is found in yystate. | `------------------------------------------------------------*/ yynewstate: /* In all cases, when you get here, the value and location stacks have just been pushed. So pushing a state here evens the stacks. */ yyssp++; yysetstate: *yyssp = yystate; if (yyss + yystacksize - 1 <= yyssp) { /* Get the current used size of the three stacks, in elements. */ YYSIZE_T yysize = yyssp - yyss + 1; #ifdef yyoverflow { /* Give user a chance to reallocate the stack. Use copies of these so that the &'s don't force the real ones into memory. */ YYSTYPE *yyvs1 = yyvs; yytype_int16 *yyss1 = yyss; YYLTYPE *yyls1 = yyls; /* Each stack pointer address is followed by the size of the data in use in that stack, in bytes. This used to be a conditional around just the two extra args, but that might be undefined if yyoverflow is a macro. */ yyoverflow (YY_("memory exhausted"), &yyss1, yysize * sizeof (*yyssp), &yyvs1, yysize * sizeof (*yyvsp), &yyls1, yysize * sizeof (*yylsp), &yystacksize); yyls = yyls1; yyss = yyss1; yyvs = yyvs1; } #else /* no yyoverflow */ # ifndef YYSTACK_RELOCATE goto yyexhaustedlab; # else /* Extend the stack our own way. */ if (YYMAXDEPTH <= yystacksize) goto yyexhaustedlab; yystacksize *= 2; if (YYMAXDEPTH < yystacksize) yystacksize = YYMAXDEPTH; { yytype_int16 *yyss1 = yyss; union yyalloc *yyptr = (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); if (! yyptr) goto yyexhaustedlab; YYSTACK_RELOCATE (yyss); YYSTACK_RELOCATE (yyvs); YYSTACK_RELOCATE (yyls); # undef YYSTACK_RELOCATE if (yyss1 != yyssa) YYSTACK_FREE (yyss1); } # endif #endif /* no yyoverflow */ yyssp = yyss + yysize - 1; yyvsp = yyvs + yysize - 1; yylsp = yyls + yysize - 1; YYDPRINTF ((stderr, "Stack size increased to %lu\n", (unsigned long int) yystacksize)); if (yyss + yystacksize - 1 <= yyssp) YYABORT; } YYDPRINTF ((stderr, "Entering state %d\n", yystate)); goto yybackup; /*-----------. | yybackup. | `-----------*/ yybackup: /* Do appropriate processing given the current state. Read a look-ahead token if we need one and don't already have one. */ /* First try to decide what to do without reference to look-ahead token. */ yyn = yypact[yystate]; if (yyn == YYPACT_NINF) goto yydefault; /* Not known => get a look-ahead token if don't already have one. */ /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ if (yychar == YYEMPTY) { YYDPRINTF ((stderr, "Reading a token: ")); yychar = YYLEX; } if (yychar <= YYEOF) { yychar = yytoken = YYEOF; YYDPRINTF ((stderr, "Now at end of input.\n")); } else { yytoken = YYTRANSLATE (yychar); YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); } /* If the proper action on seeing token YYTOKEN is to reduce or to detect an error, take that action. */ yyn += yytoken; if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) goto yydefault; yyn = yytable[yyn]; if (yyn <= 0) { if (yyn == 0 || yyn == YYTABLE_NINF) goto yyerrlab; yyn = -yyn; goto yyreduce; } if (yyn == YYFINAL) YYACCEPT; /* Count tokens shifted since error; after three, turn off error status. */ if (yyerrstatus) yyerrstatus--; /* Shift the look-ahead token. */ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); /* Discard the shifted token unless it is eof. */ if (yychar != YYEOF) yychar = YYEMPTY; yystate = yyn; *++yyvsp = yylval; *++yylsp = yylloc; goto yynewstate; /*-----------------------------------------------------------. | yydefault -- do the default action for the current state. | `-----------------------------------------------------------*/ yydefault: yyn = yydefact[yystate]; if (yyn == 0) goto yyerrlab; goto yyreduce; /*-----------------------------. | yyreduce -- Do a reduction. | `-----------------------------*/ yyreduce: /* yyn is the number of a rule to reduce with. */ yylen = yyr2[yyn]; /* If YYLEN is nonzero, implement the default value of the action: `$$ = $1'. Otherwise, the following line sets YYVAL to garbage. This behavior is undocumented and Bison users should not rely upon it. Assigning to YYVAL unconditionally makes the parser a bit smaller, and it avoids a GCC warning that YYVAL may be used uninitialized. */ yyval = yyvsp[1-yylen]; /* Default location. */ YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); YY_REDUCE_PRINT (yyn); switch (yyn) { case 2: #line 66 "simplangparser.yy" { ASTNode *n = new ASTNode(CMDL_T, "main-script"); n->children = (yyvsp[(1) - (1)].snode_list); context->insertRoot(n); } break; case 3: #line 70 "simplangparser.yy" { (yyval.snode_list) = new list(); } break; case 4: #line 72 "simplangparser.yy" { (*(yyvsp[(1) - (2)].snode_list)).push_back((yyvsp[(2) - (2)].snode)); (yyval.snode_list) = (yyvsp[(1) - (2)].snode_list); } break; case 5: #line 76 "simplangparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(SYM_T, (yyvsp[(3) - (4)].str))); } break; case 6: #line 82 "simplangparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(3) - (4)].snode)); } break; case 7: #line 88 "simplangparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(3) - (4)].snode)); } break; case 8: #line 94 "simplangparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (5)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(SYM_T, (yyvsp[(3) - (5)].str))); (yyval.snode)->children->push_back(new ASTNode(NUM_T, (yyvsp[(4) - (5)].str))); } break; case 9: #line 101 "simplangparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (8)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(SYM_T, (yyvsp[(3) - (8)].str))); ASTNode* syml = new ASTNode(SYML_T, NULL); syml->children = (yyvsp[(5) - (8)].snode_list); (yyval.snode)->children->push_back(syml); (yyval.snode)->children->push_back((yyvsp[(7) - (8)].snode)); } break; case 10: #line 114 "simplangparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (8)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(SYM_T, (yyvsp[(3) - (8)].str))); ASTNode* sortl = new ASTNode(SORTL_T, NULL); sortl->children = (yyvsp[(5) - (8)].snode_list); (yyval.snode)->children->push_back(sortl); (yyval.snode)->children->push_back((yyvsp[(7) - (8)].snode)); } break; case 11: #line 126 "simplangparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (9)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(SYM_T, (yyvsp[(3) - (9)].str))); ASTNode* svl = new ASTNode(SVL_T, NULL); svl->children = (yyvsp[(5) - (9)].snode_list); (yyval.snode)->children->push_back(svl); (yyval.snode)->children->push_back((yyvsp[(7) - (9)].snode)); (yyval.snode)->children->push_back((yyvsp[(8) - (9)].snode)); } break; case 12: #line 139 "simplangparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(NUM_T, (yyvsp[(3) - (4)].str))); } break; case 13: #line 145 "simplangparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(NUM_T, (yyvsp[(3) - (4)].str))); } break; case 14: #line 151 "simplangparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(3) - (4)].snode)); } break; case 15: #line 157 "simplangparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (3)].str)); } break; case 16: #line 161 "simplangparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (3)].str)); } break; case 17: #line 165 "simplangparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (3)].str)); } break; case 18: #line 169 "simplangparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (3)].str)); } break; case 19: #line 173 "simplangparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (7)].str)); (yyval.snode)->children = (yyvsp[(5) - (7)].snode_list); (yyval.snode)->children->push_front((yyvsp[(4) - (7)].snode)); } break; case 20: #line 179 "simplangparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (3)].str)); } break; case 21: #line 183 "simplangparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(UATTR_T, (yyvsp[(3) - (4)].str))); } break; case 22: #line 189 "simplangparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(PATTR_T, (yyvsp[(3) - (4)].str))); } break; case 23: #line 195 "simplangparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(3) - (4)].snode)); } break; case 24: #line 201 "simplangparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (3)].str)); } break; case 25: #line 205 "simplangparser.yy" { (yyval.snode_list) = new list(); } break; case 26: #line 207 "simplangparser.yy" { (yyvsp[(1) - (2)].snode_list)->push_back((yyvsp[(2) - (2)].snode)); (yyval.snode_list) = (yyvsp[(1) - (2)].snode_list); } break; case 27: #line 211 "simplangparser.yy" { (yyval.snode) = new ASTNode(UATTR_T, (yyvsp[(1) - (1)].str)); } break; case 28: #line 213 "simplangparser.yy" { (yyval.snode) = new ASTNode(UATTR_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(2) - (2)].snode)); } break; case 29: #line 215 "simplangparser.yy" { (yyval.snode) = new ASTNode(PATTR_T, (yyvsp[(1) - (1)].str)); } break; case 30: #line 217 "simplangparser.yy" { (yyval.snode) = new ASTNode(PATTR_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(2) - (2)].snode)); } break; case 31: #line 221 "simplangparser.yy" { (yyval.snode) = new ASTNode(SPECC_T, NULL); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(1) - (1)].snode)); } break; case 32: #line 223 "simplangparser.yy" { (yyval.snode) = new ASTNode(SYM_T, (yyvsp[(1) - (1)].str)); } break; case 33: #line 227 "simplangparser.yy" { (yyval.snode) = new ASTNode(SEXPRL_T, NULL); (yyval.snode)->children = (yyvsp[(2) - (3)].snode_list); } break; case 34: #line 234 "simplangparser.yy" { (yyval.snode) = new ASTNode(SYM_T, (yyvsp[(1) - (1)].str)); } break; case 35: #line 236 "simplangparser.yy" { (yyval.snode) = new ASTNode(SYM_T, (yyvsp[(3) - (5)].str)); (yyval.snode)->children = (yyvsp[(4) - (5)].snode_list); } break; case 36: #line 240 "simplangparser.yy" { (yyval.snode) = new ASTNode(ID_T, NULL); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(1) - (1)].snode)); } break; case 37: #line 242 "simplangparser.yy" { (yyval.snode) = new ASTNode(LID_T, NULL); (yyval.snode)->children = (yyvsp[(4) - (5)].snode_list); (yyval.snode)->children->push_front((yyvsp[(3) - (5)].snode)); } break; case 38: #line 250 "simplangparser.yy" { (yyvsp[(1) - (2)].snode_list)->push_back((yyvsp[(2) - (2)].snode)); (yyval.snode_list) = (yyvsp[(1) - (2)].snode_list); } break; case 39: #line 252 "simplangparser.yy" { (yyval.snode_list) = new list(); } break; case 40: #line 256 "simplangparser.yy" { (yyval.snode) = new ASTNode(SPECC_T, NULL); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(1) - (1)].snode)); } break; case 41: #line 262 "simplangparser.yy" { (yyval.snode) = new ASTNode(SYM_T, (yyvsp[(1) - (1)].str)); } break; case 42: #line 266 "simplangparser.yy" { (yyval.snode) = new ASTNode(UATTR_T, (yyvsp[(1) - (1)].str)); } break; case 43: #line 270 "simplangparser.yy" { (yyval.snode) = new ASTNode(SEXPRL_T, NULL); (yyval.snode)->children = (yyvsp[(2) - (3)].snode_list); } break; case 44: #line 277 "simplangparser.yy" { (yyval.snode_list) = new list(); } break; case 45: #line 281 "simplangparser.yy" { (yyvsp[(1) - (2)].snode_list)->push_back((yyvsp[(2) - (2)].snode)); (yyval.snode_list) = (yyvsp[(1) - (2)].snode_list); } break; case 46: #line 288 "simplangparser.yy" { (yyval.snode) = new ASTNode(NUM_T, (yyvsp[(1) - (1)].str)); } break; case 47: #line 290 "simplangparser.yy" { (yyval.snode) = new ASTNode(DEC_T, (yyvsp[(1) - (1)].str)); } break; case 48: #line 292 "simplangparser.yy" { (yyval.snode) = new ASTNode(HEX_T, (yyvsp[(1) - (1)].str)); } break; case 49: #line 294 "simplangparser.yy" { (yyval.snode) = new ASTNode(BIN_T, (yyvsp[(1) - (1)].str)); } break; case 50: #line 296 "simplangparser.yy" { (yyval.snode) = new ASTNode(STR_T, (yyvsp[(1) - (1)].str)); } break; case 51: #line 300 "simplangparser.yy" { (yyvsp[(1) - (2)].snode_list)->push_back(new ASTNode(NUM_T, (yyvsp[(2) - (2)].str))); (yyval.snode_list) = (yyvsp[(1) - (2)].snode_list); } break; case 52: #line 302 "simplangparser.yy" { (yyval.snode_list) = new list(); (yyval.snode_list)->push_back(new ASTNode(NUM_T, (yyvsp[(1) - (1)].str))); } break; case 53: #line 306 "simplangparser.yy" { (yyval.snode) = (yyvsp[(1) - (1)].snode); } break; case 54: #line 308 "simplangparser.yy" { (yyval.snode) = new ASTNode(AS_T, NULL); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(3) - (5)].snode)); (yyval.snode)->children->push_back((yyvsp[(4) - (5)].snode)); } break; case 55: #line 317 "simplangparser.yy" { (yyval.snode_list) = new list(); } break; case 56: #line 319 "simplangparser.yy" { (yyvsp[(1) - (2)].snode_list)->push_back((yyvsp[(2) - (2)].snode)); (yyval.snode_list) = (yyvsp[(1) - (2)].snode_list); } break; case 57: #line 323 "simplangparser.yy" { (yyval.snode) = new ASTNode(VARB_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(3) - (4)].snode)); } break; case 58: #line 327 "simplangparser.yy" { (yyval.snode_list) = new list(); } break; case 59: #line 329 "simplangparser.yy" { (yyvsp[(1) - (2)].snode_list)->push_back((yyvsp[(2) - (2)].snode)); (yyval.snode_list) = (yyvsp[(1) - (2)].snode_list); } break; case 60: #line 333 "simplangparser.yy" { (yyval.snode) = new ASTNode(SV_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(3) - (4)].snode)); } break; case 61: #line 336 "simplangparser.yy" { (yyval.snode_list) = new list(); } break; case 62: #line 338 "simplangparser.yy" { (yyvsp[(1) - (2)].snode_list)->push_back((yyvsp[(2) - (2)].snode)); (yyval.snode_list) = (yyvsp[(1) - (2)].snode_list); } break; case 63: #line 342 "simplangparser.yy" { (yyval.snode) = new ASTNode(TERM_T, NULL); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(1) - (1)].snode)); } break; case 64: #line 344 "simplangparser.yy" { (yyval.snode) = new ASTNode(QID_T, NULL); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(1) - (1)].snode)); } break; case 65: #line 346 "simplangparser.yy" { (yyval.snode) = new ASTNode(LQID_T, NULL); (yyval.snode)->children = (yyvsp[(4) - (5)].snode_list); (yyval.snode)->children->push_front((yyvsp[(3) - (5)].snode)); } break; case 66: #line 352 "simplangparser.yy" { (yyval.snode) = new ASTNode(LET_T, NULL); (yyval.snode)->children = new list(); (yyvsp[(5) - (8)].snode_list)->push_front((yyvsp[(4) - (8)].snode)); ASTNode* vbl = new ASTNode(VARBL_T, NULL); vbl->children = (yyvsp[(5) - (8)].snode_list); (yyval.snode)->children->push_back(vbl); (yyval.snode)->children->push_back((yyvsp[(7) - (8)].snode)); } break; case 67: #line 362 "simplangparser.yy" { (yyval.snode) = new ASTNode(FORALL_T, NULL); (yyval.snode)->children = new list(); (yyvsp[(5) - (8)].snode_list)->push_front((yyvsp[(4) - (8)].snode)); ASTNode* svl = new ASTNode(SVL_T, NULL); svl->children = (yyvsp[(5) - (8)].snode_list); (yyval.snode)->children->push_back(svl); (yyval.snode)->children->push_back((yyvsp[(7) - (8)].snode)); } break; case 68: #line 372 "simplangparser.yy" { (yyval.snode) = new ASTNode(EXISTS_T, NULL); (yyval.snode)->children = new list(); (yyvsp[(5) - (8)].snode_list)->push_front((yyvsp[(4) - (8)].snode)); ASTNode* svl = new ASTNode(SVL_T, NULL); svl->children = (yyvsp[(5) - (8)].snode_list); (yyval.snode)->children->push_back(svl); (yyval.snode)->children->push_back((yyvsp[(7) - (8)].snode)); } break; case 69: #line 382 "simplangparser.yy" { (yyval.snode) = new ASTNode(BANG_T, NULL); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(2) - (4)].snode)); (yyvsp[(4) - (4)].snode_list)->push_front((yyvsp[(3) - (4)].snode)); (yyval.snode)->children = (yyvsp[(4) - (4)].snode_list); } break; case 70: #line 456 "simplangparser.yy" { (yyval.snode_list) = new list(); } break; case 71: #line 458 "simplangparser.yy" { (yyvsp[(1) - (2)].snode_list)->push_back(new ASTNode(SYM_T, (yyvsp[(2) - (2)].str))); (yyval.snode_list) = (yyvsp[(1) - (2)].snode_list); } break; case 72: #line 615 "simplangparser.yy" { if (strcmp((yyvsp[(1) - (1)].str), "true") == 0) (yyval.snode) = new ASTNode(BOOL_T, "true"); else if (strcmp((yyvsp[(1) - (1)].str), "false") == 0) (yyval.snode) = new ASTNode(BOOL_T, "false"); else { printf("Syntax error: expecting either 'true' or 'false', got '%s'\n", (yyvsp[(1) - (1)].str)); YYERROR; } } break; case 73: #line 628 "simplangparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(2) - (2)].snode)); } break; case 74: #line 634 "simplangparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(2) - (2)].snode)); } break; case 75: #line 640 "simplangparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(2) - (2)].snode)); } break; case 76: #line 646 "simplangparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(2) - (2)].snode)); } break; case 77: #line 652 "simplangparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(2) - (2)].snode)); } break; case 78: #line 658 "simplangparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(2) - (2)].snode)); } break; case 79: #line 664 "simplangparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(2) - (2)].snode)); } break; case 80: #line 670 "simplangparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(STR_T, (yyvsp[(2) - (2)].str))); } break; case 81: #line 676 "simplangparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(STR_T, (yyvsp[(2) - (2)].str))); } break; case 82: #line 682 "simplangparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(NUM_T, (yyvsp[(2) - (2)].str))); } break; case 83: #line 688 "simplangparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(NUM_T, (yyvsp[(2) - (2)].str))); } break; case 84: #line 694 "simplangparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, NULL); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(1) - (1)].snode)); } break; case 85: #line 702 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 86: #line 704 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 87: #line 706 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 88: #line 708 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 89: #line 710 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 90: #line 712 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 91: #line 714 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 92: #line 716 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 93: #line 718 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 94: #line 720 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 95: #line 722 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 96: #line 724 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 97: #line 726 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 98: #line 728 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 99: #line 730 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 100: #line 732 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 101: #line 734 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 102: #line 736 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 103: #line 738 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 104: #line 740 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 105: #line 742 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 106: #line 744 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 107: #line 746 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 108: #line 748 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 109: #line 750 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 110: #line 752 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 111: #line 754 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 112: #line 756 "simplangparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 113: #line 760 "simplangparser.yy" { (yyval.snode) = new ASTNode(INFO_T, (yyvsp[(1) - (1)].str)); } break; case 114: #line 762 "simplangparser.yy" { (yyval.snode) = new ASTNode(INFO_T, (yyvsp[(1) - (1)].str)); } break; case 115: #line 764 "simplangparser.yy" { (yyval.snode) = new ASTNode(INFO_T, (yyvsp[(1) - (1)].str)); } break; case 116: #line 766 "simplangparser.yy" { (yyval.snode) = new ASTNode(INFO_T, (yyvsp[(1) - (1)].str)); } break; case 117: #line 768 "simplangparser.yy" { (yyval.snode) = new ASTNode(INFO_T, (yyvsp[(1) - (1)].str)); } break; case 118: #line 770 "simplangparser.yy" { (yyval.snode) = new ASTNode(INFO_T, (yyvsp[(1) - (1)].str)); } break; case 119: #line 772 "simplangparser.yy" { (yyval.snode) = new ASTNode(INFO_T, (yyvsp[(1) - (1)].str)); } break; case 120: #line 774 "simplangparser.yy" { (yyval.snode) = new ASTNode(INFO_T, NULL); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(GATTR_T, (yyvsp[(1) - (1)].str))); } break; /* Line 1267 of yacc.c. */ #line 2558 "simplangparser.cc" default: break; } YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); YYPOPSTACK (yylen); yylen = 0; YY_STACK_PRINT (yyss, yyssp); *++yyvsp = yyval; *++yylsp = yyloc; /* Now `shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by. */ yyn = yyr1[yyn]; yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) yystate = yytable[yystate]; else yystate = yydefgoto[yyn - YYNTOKENS]; goto yynewstate; /*------------------------------------. | yyerrlab -- here on detecting error | `------------------------------------*/ yyerrlab: /* If not already recovering from an error, report this error. */ if (!yyerrstatus) { ++yynerrs; #if ! YYERROR_VERBOSE yyerror (&yylloc, context, YY_("syntax error")); #else { YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) { YYSIZE_T yyalloc = 2 * yysize; if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) yyalloc = YYSTACK_ALLOC_MAXIMUM; if (yymsg != yymsgbuf) YYSTACK_FREE (yymsg); yymsg = (char *) YYSTACK_ALLOC (yyalloc); if (yymsg) yymsg_alloc = yyalloc; else { yymsg = yymsgbuf; yymsg_alloc = sizeof yymsgbuf; } } if (0 < yysize && yysize <= yymsg_alloc) { (void) yysyntax_error (yymsg, yystate, yychar); yyerror (&yylloc, context, yymsg); } else { yyerror (&yylloc, context, YY_("syntax error")); if (yysize != 0) goto yyexhaustedlab; } } #endif } yyerror_range[0] = yylloc; if (yyerrstatus == 3) { /* If just tried and failed to reuse look-ahead token after an error, discard it. */ if (yychar <= YYEOF) { /* Return failure if at end of input. */ if (yychar == YYEOF) YYABORT; } else { yydestruct ("Error: discarding", yytoken, &yylval, &yylloc, context); yychar = YYEMPTY; } } /* Else will try to reuse look-ahead token after shifting the error token. */ goto yyerrlab1; /*---------------------------------------------------. | yyerrorlab -- error raised explicitly by YYERROR. | `---------------------------------------------------*/ yyerrorlab: /* Pacify compilers like GCC when the user code never invokes YYERROR and the label yyerrorlab therefore never appears in user code. */ if (/*CONSTCOND*/ 0) goto yyerrorlab; yyerror_range[0] = yylsp[1-yylen]; /* Do not reclaim the symbols of the rule which action triggered this YYERROR. */ YYPOPSTACK (yylen); yylen = 0; YY_STACK_PRINT (yyss, yyssp); yystate = *yyssp; goto yyerrlab1; /*-------------------------------------------------------------. | yyerrlab1 -- common code for both syntax error and YYERROR. | `-------------------------------------------------------------*/ yyerrlab1: yyerrstatus = 3; /* Each real token shifted decrements this. */ for (;;) { yyn = yypact[yystate]; if (yyn != YYPACT_NINF) { yyn += YYTERROR; if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) { yyn = yytable[yyn]; if (0 < yyn) break; } } /* Pop the current state because it cannot handle the error token. */ if (yyssp == yyss) YYABORT; yyerror_range[0] = *yylsp; yydestruct ("Error: popping", yystos[yystate], yyvsp, yylsp, context); YYPOPSTACK (1); yystate = *yyssp; YY_STACK_PRINT (yyss, yyssp); } if (yyn == YYFINAL) YYACCEPT; *++yyvsp = yylval; yyerror_range[1] = yylloc; /* Using YYLLOC is tempting, but would change the location of the look-ahead. YYLOC is available though. */ YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2); *++yylsp = yyloc; /* Shift the error token. */ YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); yystate = yyn; goto yynewstate; /*-------------------------------------. | yyacceptlab -- YYACCEPT comes here. | `-------------------------------------*/ yyacceptlab: yyresult = 0; goto yyreturn; /*-----------------------------------. | yyabortlab -- YYABORT comes here. | `-----------------------------------*/ yyabortlab: yyresult = 1; goto yyreturn; #ifndef yyoverflow /*-------------------------------------------------. | yyexhaustedlab -- memory exhaustion comes here. | `-------------------------------------------------*/ yyexhaustedlab: yyerror (&yylloc, context, YY_("memory exhausted")); yyresult = 2; /* Fall through. */ #endif yyreturn: if (yychar != YYEOF && yychar != YYEMPTY) yydestruct ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc, context); /* Do not reclaim the symbols of the rule which action triggered this YYABORT or YYACCEPT. */ YYPOPSTACK (yylen); YY_STACK_PRINT (yyss, yyssp); while (yyssp != yyss) { yydestruct ("Cleanup: popping", yystos[*yyssp], yyvsp, yylsp, context); YYPOPSTACK (1); } #ifndef yyoverflow if (yyss != yyssa) YYSTACK_FREE (yyss); #endif #if YYERROR_VERBOSE if (yymsg != yymsgbuf) YYSTACK_FREE (yymsg); #endif /* Make sure YYID is used. */ return YYID (yyresult); } #line 781 "simplangparser.yy" //======================================================================================= // Auxiliary Routines opensmt-2.5.2/test/simplangparser.h000066400000000000000000000130651445011647600174010ustar00rootroot00000000000000/* A Bison parser, made by GNU Bison 2.3. */ /* Skeleton interface for Bison's Yacc-like parsers in C Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ /* As a special exception, you may create a larger work that contains part or all of the Bison parser skeleton and distribute that work under terms of your choice, so long as that work isn't itself a parser generator using the skeleton or a modified version thereof as a parser skeleton. Alternatively, if you modify or redistribute the parser skeleton itself, you may (at your option) remove this special exception, which will cause the skeleton and the resulting Bison output files to be licensed under the GNU General Public License without this special exception. This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ /* Tokens. */ #ifndef YYTOKENTYPE # define YYTOKENTYPE /* Put the tokens into the symbol table, so that GDB and other debuggers know about them. */ enum yytokentype { TK_AS = 258, TK_DECIMAL = 259, TK_EXISTS = 260, TK_FORALL = 261, TK_LET = 262, TK_NUMERAL = 263, TK_PAR = 264, TK_STRING = 265, TK_ASSERT = 266, TK_CHECKSAT = 267, TK_DECLARESORT = 268, TK_DECLAREFUN = 269, TK_DEFINESORT = 270, TK_DEFINEFUN = 271, TK_EXIT = 272, TK_GETASSERTIONS = 273, TK_GETASSIGNMENT = 274, TK_GETINFO = 275, TK_GETOPTION = 276, TK_GETPROOF = 277, TK_GETUNSATCORE = 278, TK_GETVALUE = 279, TK_POP = 280, TK_PUSH = 281, TK_SETLOGIC = 282, TK_SETINFO = 283, TK_SETOPTION = 284, TK_THEORY = 285, TK_NUM = 286, TK_SYM = 287, TK_KEY = 288, TK_STR = 289, TK_DEC = 290, TK_HEX = 291, TK_BIN = 292, KW_SORTS = 293, KW_FUNS = 294, KW_SORTSDESCRIPTION = 295, KW_FUNSDESCRIPTION = 296, KW_DEFINITION = 297, KW_NOTES = 298, KW_THEORIES = 299, KW_LANGUAGE = 300, KW_EXTENSIONS = 301, KW_VALUES = 302, KW_PRINTSUCCESS = 303, KW_EXPANDDEFINITIONS = 304, KW_INTERACTIVEMODE = 305, KW_PRODUCEPROOFS = 306, KW_PRODUCEUNSATCORES = 307, KW_PRODUCEMODELS = 308, KW_PRODUCEASSIGNMENTS = 309, KW_REGULAROUTPUTCHANNEL = 310, KW_DIAGNOSTICOUTPUTCHANNEL = 311, KW_RANDOMSEED = 312, KW_VERBOSITY = 313, KW_ERRORBEHAVIOR = 314, KW_NAME = 315, KW_AUTHORS = 316, KW_VERSION = 317, KW_STATUS = 318, KW_REASONUNKNOWN = 319, KW_ALLSTATISTICS = 320 }; #endif /* Tokens. */ #define TK_AS 258 #define TK_DECIMAL 259 #define TK_EXISTS 260 #define TK_FORALL 261 #define TK_LET 262 #define TK_NUMERAL 263 #define TK_PAR 264 #define TK_STRING 265 #define TK_ASSERT 266 #define TK_CHECKSAT 267 #define TK_DECLARESORT 268 #define TK_DECLAREFUN 269 #define TK_DEFINESORT 270 #define TK_DEFINEFUN 271 #define TK_EXIT 272 #define TK_GETASSERTIONS 273 #define TK_GETASSIGNMENT 274 #define TK_GETINFO 275 #define TK_GETOPTION 276 #define TK_GETPROOF 277 #define TK_GETUNSATCORE 278 #define TK_GETVALUE 279 #define TK_POP 280 #define TK_PUSH 281 #define TK_SETLOGIC 282 #define TK_SETINFO 283 #define TK_SETOPTION 284 #define TK_THEORY 285 #define TK_NUM 286 #define TK_SYM 287 #define TK_KEY 288 #define TK_STR 289 #define TK_DEC 290 #define TK_HEX 291 #define TK_BIN 292 #define KW_SORTS 293 #define KW_FUNS 294 #define KW_SORTSDESCRIPTION 295 #define KW_FUNSDESCRIPTION 296 #define KW_DEFINITION 297 #define KW_NOTES 298 #define KW_THEORIES 299 #define KW_LANGUAGE 300 #define KW_EXTENSIONS 301 #define KW_VALUES 302 #define KW_PRINTSUCCESS 303 #define KW_EXPANDDEFINITIONS 304 #define KW_INTERACTIVEMODE 305 #define KW_PRODUCEPROOFS 306 #define KW_PRODUCEUNSATCORES 307 #define KW_PRODUCEMODELS 308 #define KW_PRODUCEASSIGNMENTS 309 #define KW_REGULAROUTPUTCHANNEL 310 #define KW_DIAGNOSTICOUTPUTCHANNEL 311 #define KW_RANDOMSEED 312 #define KW_VERBOSITY 313 #define KW_ERRORBEHAVIOR 314 #define KW_NAME 315 #define KW_AUTHORS 316 #define KW_VERSION 317 #define KW_STATUS 318 #define KW_REASONUNKNOWN 319 #define KW_ALLSTATISTICS 320 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED typedef union YYSTYPE #line 37 "simplangparser.yy" { char * str; vector< string > * str_list; ASTNode * snode; list< ASTNode * > * snode_list; } /* Line 1529 of yacc.c. */ #line 186 "simplangparser.h" YYSTYPE; # define yystype YYSTYPE /* obsolescent; will be withdrawn */ # define YYSTYPE_IS_DECLARED 1 # define YYSTYPE_IS_TRIVIAL 1 #endif #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED typedef struct YYLTYPE { int first_line; int first_column; int last_line; int last_column; } YYLTYPE; # define yyltype YYLTYPE /* obsolescent; will be withdrawn */ # define YYLTYPE_IS_DECLARED 1 # define YYLTYPE_IS_TRIVIAL 1 #endif opensmt-2.5.2/test/simple.smt2000066400000000000000000000006571445011647600163040ustar00rootroot00000000000000; This is an example (set-info :bar "foo \"bar quux") (set-info :quux "bar quux frobboz") (set-info :frobboz (foo :bar (quux bar))) (set-logic AB_CD) (declare-fun f () a) (set-info :quux "bar quux frob\\boz\"") (declare-fun _foo () b) (declare-fun - () ..foo) (declare-fun |bar "this is internal" quux| () ||) (declare-fun q () (_ foo 1 2 3 4)) (declare-fun q1 () ((_ foo 1 2 3 4) (_ bar 4 3 2 1) (_ quux 1 2 3 4))) opensmt-2.5.2/test/simple2.smt2000066400000000000000000000000731445011647600163560ustar00rootroot00000000000000(set-info :bar "foo" ) (set-info :quux "bar quux frobbo") opensmt-2.5.2/test/simplified.smt2000066400000000000000000000142551445011647600171370ustar00rootroot00000000000000(set-logic QF_UF) (set-info :source | CADE ATP System competition. See http://www.cs.miami.edu/~tptp/CASC for more information. This benchmark was obtained by trying to find a finite model of a first-order formula (Albert Oliveras). |) (set-info :smt-lib-version 2.0) (set-info :category "crafted") (set-info :status unsat) (declare-sort U 0) (declare-fun c14 () U) (declare-fun c12 () U) (declare-fun p4 (U U) Bool) (declare-fun c13 () U) (declare-fun p3 (U U) Bool) (declare-fun c15 () U) (declare-fun c17 () U) (declare-fun p6 (U U) Bool) (declare-fun p2 (U U) Bool) (declare-fun p1 (U U) Bool) (declare-fun c11 () U) (declare-fun f5 (U U) U) (declare-fun c10 () U) (declare-fun p8 (U) Bool) (declare-fun c16 () U) (declare-fun p9 (U U) Bool) (declare-fun p7 (U U) Bool) (declare-fun c_0 () U) (declare-fun c_1 () U) (declare-fun c_2 () U) (declare-fun c_3 () U) (declare-fun b0 () Bool) (assert (let ((?v_52 (= c_0 c_0))) (let ((?v_16 (not ?v_52)) (?v_32 (p3 c_0 c_0)) (?v_55 (= c_0 c_1))) (let ((?v_17 (not ?v_55)) (?v_33 (p3 c_0 c_1)) (?v_58 (= c_0 c_2))) (let ((?v_18 (not ?v_58)) (?v_34 (p3 c_0 c_2)) (?v_61 (= c_0 c_3))) (let ((?v_19 (not ?v_61)) (?v_35 (p3 c_0 c_3)) (?v_64 (= c_1 c_0))) (let ((?v_20 (not ?v_64)) (?v_36 (p3 c_1 c_0)) (?v_67 (= c_1 c_1))) (let ((?v_21 (not ?v_67)) (?v_37 (p3 c_1 c_1)) (?v_70 (= c_1 c_2))) (let ((?v_22 (not ?v_70)) (?v_38 (p3 c_1 c_2)) (?v_73 (= c_1 c_3))) (let ((?v_23 (not ?v_73)) (?v_39 (p3 c_1 c_3)) (?v_76 (= c_2 c_0))) (let ((?v_24 (not ?v_76)) (?v_40 (p3 c_2 c_0)) (?v_79 (= c_2 c_1))) (let ((?v_25 (not ?v_79)) (?v_41 (p3 c_2 c_1)) (?v_82 (= c_2 c_2))) (let ((?v_26 (not ?v_82)) (?v_42 (p3 c_2 c_2)) (?v_85 (= c_2 c_3))) (let ((?v_27 (not ?v_85)) (?v_43 (p3 c_2 c_3)) (?v_88 (= c_3 c_0))) (let ((?v_28 (not ?v_88)) (?v_44 (p3 c_3 c_0)) (?v_91 (= c_3 c_1))) (let ((?v_29 (not ?v_91)) (?v_45 (p3 c_3 c_1)) (?v_94 (= c_3 c_2))) (let ((?v_30 (not ?v_94)) (?v_46 (p3 c_3 c_2)) (?v_97 (= c_3 c_3))) (let ((?v_31 (not ?v_97)) (?v_47 (p3 c_3 c_3)) (?v_53 (p4 c_0 c_0))) (let ((?v_0 (not ?v_53)) (?v_56 (p4 c_0 c_1))) (let ((?v_2 (not ?v_56)) (?v_65 (p4 c_1 c_0))) (let ((?v_1 (not ?v_65)) (?v_59 (p4 c_0 c_2))) (let ((?v_5 (not ?v_59)) (?v_77 (p4 c_2 c_0))) (let ((?v_4 (not ?v_77)) (?v_62 (p4 c_0 c_3))) (let ((?v_10 (not ?v_62)) (?v_89 (p4 c_3 c_0))) (let ((?v_9 (not ?v_89)) (?v_68 (p4 c_1 c_1))) (let ((?v_3 (not ?v_68)) (?v_71 (p4 c_1 c_2))) (let ((?v_7 (not ?v_71)) (?v_80 (p4 c_2 c_1))) (let ((?v_6 (not ?v_80)) (?v_74 (p4 c_1 c_3))) (let ((?v_12 (not ?v_74)) (?v_92 (p4 c_3 c_1))) (let ((?v_11 (not ?v_92)) (?v_83 (p4 c_2 c_2))) (let ((?v_8 (not ?v_83)) (?v_86 (p4 c_2 c_3))) (let ((?v_14 (not ?v_86)) (?v_95 (p4 c_3 c_2))) (let ((?v_13 (not ?v_95)) (?v_98 (p4 c_3 c_3))) (let ((?v_15 (not ?v_98)) (?v_54 (p2 c_0 c_0)) (?v_66 (p2 c_1 c_0)) (?v_78 (p2 c_2 c_0)) (?v_90 (p2 c_3 c_0)) (?v_57 (p2 c_0 c_1)) (?v_69 (p2 c_1 c_1)) (?v_81 (p2 c_2 c_1)) (?v_93 (p2 c_3 c_1)) (?v_60 (p2 c_0 c_2)) (?v_72 (p2 c_1 c_2)) (?v_84 (p2 c_2 c_2)) (?v_96 (p2 c_3 c_2)) (?v_63 (p2 c_0 c_3)) (?v_75 (p2 c_1 c_3)) (?v_87 (p2 c_2 c_3)) (?v_99 (p2 c_3 c_3)) (?v_100 (p1 c_0 c_0)) (?v_101 (p1 c_0 c_1)) (?v_102 (p1 c_0 c_2)) (?v_103 (p1 c_0 c_3)) (?v_104 (p1 c_1 c_0)) (?v_105 (p1 c_1 c_1)) (?v_106 (p1 c_1 c_2)) (?v_107 (p1 c_1 c_3)) (?v_108 (p1 c_2 c_0)) (?v_109 (p1 c_2 c_1)) (?v_110 (p1 c_2 c_2)) (?v_111 (p1 c_2 c_3)) (?v_112 (p1 c_3 c_0)) (?v_113 (p1 c_3 c_1)) (?v_114 (p1 c_3 c_2)) (?v_115 (p1 c_3 c_3)) (?v_117 (f5 c_0 c_0)) (?v_48 (not (p8 c_0))) (?v_116 (p6 c_0 c_0)) (?v_119 (f5 c_0 c_1)) (?v_118 (p6 c_0 c_1)) (?v_121 (f5 c_0 c_2)) (?v_120 (p6 c_0 c_2)) (?v_123 (f5 c_0 c_3)) (?v_122 (p6 c_0 c_3)) (?v_125 (f5 c_1 c_0)) (?v_49 (not (p8 c_1))) (?v_124 (p6 c_1 c_0)) (?v_127 (f5 c_1 c_1)) (?v_126 (p6 c_1 c_1)) (?v_129 (f5 c_1 c_2)) (?v_128 (p6 c_1 c_2)) (?v_131 (f5 c_1 c_3)) (?v_130 (p6 c_1 c_3)) (?v_133 (f5 c_2 c_0)) (?v_50 (not (p8 c_2))) (?v_132 (p6 c_2 c_0)) (?v_135 (f5 c_2 c_1)) (?v_134 (p6 c_2 c_1)) (?v_137 (f5 c_2 c_2)) (?v_136 (p6 c_2 c_2)) (?v_139 (f5 c_2 c_3)) (?v_138 (p6 c_2 c_3)) (?v_141 (f5 c_3 c_0)) (?v_51 (not (p8 c_3))) (?v_140 (p6 c_3 c_0)) (?v_143 (f5 c_3 c_1)) (?v_142 (p6 c_3 c_1)) (?v_145 (f5 c_3 c_2)) (?v_144 (p6 c_3 c_2)) (?v_147 (f5 c_3 c_3)) (?v_146 (p6 c_3 c_3))) (let ((?v_148 (not ?v_54)) (?v_152 (not ?v_66)) (?v_156 (not ?v_78)) (?v_160 (not ?v_90)) (?v_149 (not ?v_57)) (?v_153 (not ?v_69)) (?v_157 (not ?v_81)) (?v_161 (not ?v_93)) (?v_150 (not ?v_60)) (?v_154 (not ?v_72)) (?v_158 (not ?v_84)) (?v_162 (not ?v_96)) (?v_151 (not ?v_63)) (?v_155 (not ?v_75)) (?v_159 (not ?v_87)) (?v_163 (not ?v_99)) (?v_164 (p9 c_0 c_0))) (let ((?v_212 (not ?v_164)) (?v_196 (p7 c_0 c_0))) (let ((?v_165 (not ?v_196)) (?v_166 (p9 c_0 c_1))) (let ((?v_213 (not ?v_166)) (?v_197 (p7 c_0 c_1))) (let ((?v_167 (not ?v_197)) (?v_168 (p9 c_0 c_2))) (let ((?v_214 (not ?v_168)) (?v_198 (p7 c_0 c_2))) (let ((?v_169 (not ?v_198)) (?v_170 (p9 c_0 c_3))) (let ((?v_215 (not ?v_170)) (?v_199 (p7 c_0 c_3))) (let ((?v_171 (not ?v_199)) (?v_172 (p9 c_1 c_0))) (let ((?v_216 (not ?v_172)) (?v_200 (p7 c_1 c_0))) (let ((?v_173 (not ?v_200)) (?v_174 (p9 c_1 c_1))) (let ((?v_217 (not ?v_174)) (?v_201 (p7 c_1 c_1))) (let ((?v_175 (not ?v_201)) (?v_176 (p9 c_1 c_2))) (let ((?v_218 (not ?v_176)) (?v_202 (p7 c_1 c_2))) (let ((?v_177 (not ?v_202)) (?v_178 (p9 c_1 c_3))) (let ((?v_219 (not ?v_178)) (?v_203 (p7 c_1 c_3))) (let ((?v_179 (not ?v_203)) (?v_180 (p9 c_2 c_0))) (let ((?v_220 (not ?v_180)) (?v_204 (p7 c_2 c_0))) (let ((?v_181 (not ?v_204)) (?v_182 (p9 c_2 c_1))) (let ((?v_221 (not ?v_182)) (?v_205 (p7 c_2 c_1))) (let ((?v_183 (not ?v_205)) (?v_184 (p9 c_2 c_2))) (let ((?v_222 (not ?v_184)) (?v_206 (p7 c_2 c_2))) (let ((?v_185 (not ?v_206)) (?v_186 (p9 c_2 c_3))) (let ((?v_223 (not ?v_186)) (?v_207 (p7 c_2 c_3))) (let ((?v_187 (not ?v_207)) (?v_188 (p9 c_3 c_0))) (let ((?v_224 (not ?v_188)) (?v_208 (p7 c_3 c_0))) (let ((?v_189 (not ?v_208)) (?v_190 (p9 c_3 c_1))) (let ((?v_225 (not ?v_190)) (?v_209 (p7 c_3 c_1))) (let ((?v_191 (not ?v_209)) (?v_192 (p9 c_3 c_2))) (let ((?v_226 (not ?v_192)) (?v_210 (p7 c_3 c_2))) (let ((?v_193 (not ?v_210)) (?v_194 (p9 c_3 c_3))) (let ((?v_227 (not ?v_194)) (?v_211 (p7 c_3 c_3))) (let ((?v_195 (not ?v_211))) (or (?v_52 b0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) (check-sat) (exit) opensmt-2.5.2/test/smt2newcontext.cc000066400000000000000000000053041445011647600175110ustar00rootroot00000000000000#include "smt2newcontext.h" void ASTNode::print(ostream& o, int indent) { for (int i = 0; i < indent; i++) printf(" "); o << "" << endl; if (children == NULL) return; for (list::iterator i = children->begin(); i != children->end(); i++) (*i)->print(o, indent+1); } const char* ASTNode::typestr[] = { "command" , "command-list" // CMD , "symbol" , "symbol-list" // SYM , "number" , "number_list" // NUM , "sort" , "sort-list" // SORT , "sorted-var" , "sorted-var-list" // SV , "user-attr" , "user-attr-list" // UATTR , "predef-attr" , "predef-attr-list" // PATTR , "gen-attr" , "gen-attr-list" // GATTR , "spec-const" , "spec-const-list" // SPECC , "s-expr" , "s-expr-list" // SEXPR , "identifier" , "identifier-list" // ID , "long-identifier" , "long-identifier-list" // LID , "decimal" , "decimal-list" // DEC , "hex" , "hex-list" // HEX , "binary" , "binary-list" // BIN , "string" , "string-list" // STR , "as" , "as-list" // AS , "var-binding" , "var-binding-list" // VARB , "term" , "term-list" // TERM , "qualified-id" , "qualified-id-list" // QID , "long-qual-id" , "long-qual-id-list" // LQID , "let" , "let-list" // LET , "forall" , "forall-list" // FORALL , "exists" , "exists-list" // EXISTS , "!" , "!-list" // BANG , "sort-sym-decl" , "sort-sym-decl-list" // SSYMD , "fun-sym-decl" , "fun-sym-decl-list" // FSYMD , "par-fun-sym-decl", "par-fun-sym-decl-list" // PFSYMD , "pf-2nd" , "pf-2nd-list" // PFID , "theory-attr" , "theory-attr-list" // TATTR , "theory-decl" , "theory-decl-list" // TDECL , "logic-attr" , "logic-attr-list" // LATTR , "logic" , "logic-list" // LOGIC , "bool" , "bool-list" // BOOL , "option" , "option-list" // OPTION , "info-flag" , "info-flag-list" // INFO }; opensmt-2.5.2/test/smt2newcontext.h000066400000000000000000000050111445011647600173460ustar00rootroot00000000000000#ifndef SMT2NEWCONTEXT_H #define SMT2NEWCONTEXT_H #include #include #include using namespace std; enum ASTType { CMD_T , CMDL_T , SYM_T , SYML_T , NUM_T , NUML_T , SORT_T , SORTL_T , SV_T , SVL_T , UATTR_T , UATTRL_T , PATTR_T , PATTRL_T , GATTR_T , GATTRL_T , SPECC_T , SPECCL_T , SEXPR_T , SEXPRL_T , ID_T , IDL_T , LID_T , LIDL_T , DEC_T , DECL_T , HEX_T , HEXL_T , BIN_T , BINL_T , STR_T , STRL_T , AS_T , ASL_T , VARB_T , VARBL_T , TERM_T , TERML_T , QID_T , QITL_T , LQID_T , LQIDL_T , LET_T , LETL_T , FORALL_T , FORALLL_T , EXISTS_T , EXISTSL_T , BANG_T , BANGL_T , SSYMD_T , SSYMDL_T , FSYMD_T , FSYMDL_T , PFSYMD_T , PFSYMDL_T , PFID_T , PFIDL_T , TATTR_T , TATTRL_T , TDECL_T , TDECLL_T , LATTR_T , LATTRL_T , LOGIC_T , LOGICL_T , BOOL_T , BOOLL_T , OPTION_T , OPTIONL_T , INFO_T , INFOL_T }; class ASTNode { private: ASTType type; const char* val; static const char* typestr[]; public: list< ASTNode* >* children; ASTNode(ASTType t, const char* v) : type(t), val(v), children(NULL) {} void print(ostream& o, int indent); inline const char *typeToStr() { return typestr[type]; } }; class Smt2newContext { private: void init_scanner(); void destroy_scanner(); char* buffer; int buffer_sz; int buffer_cap; ASTNode* root; public: void* scanner; int result; FILE* is; Smt2newContext(FILE* in) : buffer_sz(0) , buffer_cap(1) , root(NULL) , result(0) , is(in) { init_scanner(); buffer = (char *)malloc(buffer_cap); } ~Smt2newContext() { destroy_scanner(); } void insertBuf(char c) { if (buffer_cap < buffer_sz + 1) { buffer_cap *= 2; buffer = (char*) realloc(buffer, buffer_cap); } buffer[buffer_sz++] = c; } const char* getBuf() { insertBuf('\0'); return buffer; } void clearBuf() { buffer_sz = 0; } void insertRoot(ASTNode* n) { root = n; } void prettyPrint(ostream& o) { o << "Starting print" << endl; root->print(o, 0); } }; int smt2newparse(Smt2newContext*); #endif opensmt-2.5.2/test/smt2newlexer.cc000066400000000000000000002567061445011647600171620ustar00rootroot00000000000000#line 2 "smt2newlexer.cc" #line 4 "smt2newlexer.cc" #define YY_INT_ALIGNED short int /* A lexical scanner generated by flex */ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MINOR_VERSION 5 #define YY_FLEX_SUBMINOR_VERSION 35 #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif /* First, we deal with platform-specific or compiler-specific issues. */ /* begin standard C headers. */ #include #include #include #include /* end standard C headers. */ /* flex integer type definitions */ #ifndef FLEXINT_H #define FLEXINT_H /* C99 systems have . Non-C99 systems may or may not. */ #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, * if you want the limit (max/min) macros for int types. */ #ifndef __STDC_LIMIT_MACROS #define __STDC_LIMIT_MACROS 1 #endif #include typedef int8_t flex_int8_t; typedef uint8_t flex_uint8_t; typedef int16_t flex_int16_t; typedef uint16_t flex_uint16_t; typedef int32_t flex_int32_t; typedef uint32_t flex_uint32_t; #else typedef signed char flex_int8_t; typedef short int flex_int16_t; typedef int flex_int32_t; typedef unsigned char flex_uint8_t; typedef unsigned short int flex_uint16_t; typedef unsigned int flex_uint32_t; #endif /* ! C99 */ /* Limits of integral types. */ #ifndef INT8_MIN #define INT8_MIN (-128) #endif #ifndef INT16_MIN #define INT16_MIN (-32767-1) #endif #ifndef INT32_MIN #define INT32_MIN (-2147483647-1) #endif #ifndef INT8_MAX #define INT8_MAX (127) #endif #ifndef INT16_MAX #define INT16_MAX (32767) #endif #ifndef INT32_MAX #define INT32_MAX (2147483647) #endif #ifndef UINT8_MAX #define UINT8_MAX (255U) #endif #ifndef UINT16_MAX #define UINT16_MAX (65535U) #endif #ifndef UINT32_MAX #define UINT32_MAX (4294967295U) #endif #endif /* ! FLEXINT_H */ #ifdef __cplusplus /* The "const" storage-class-modifier is valid. */ #define YY_USE_CONST #else /* ! __cplusplus */ /* C99 requires __STDC__ to be defined as 1. */ #if defined (__STDC__) #define YY_USE_CONST #endif /* defined (__STDC__) */ #endif /* ! __cplusplus */ #ifdef YY_USE_CONST #define yyconst const #else #define yyconst #endif /* Returned upon end-of-file. */ #define YY_NULL 0 /* Promotes a possibly negative, possibly signed char to an unsigned * integer for use as an array index. If the signed char is negative, * we want to instead treat it as an 8-bit unsigned char, hence the * double cast. */ #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) /* An opaque pointer. */ #ifndef YY_TYPEDEF_YY_SCANNER_T #define YY_TYPEDEF_YY_SCANNER_T typedef void* yyscan_t; #endif /* For convenience, these vars (plus the bison vars far below) are macros in the reentrant scanner. */ #define yyin yyg->yyin_r #define yyout yyg->yyout_r #define yyextra yyg->yyextra_r #define yyleng yyg->yyleng_r #define yytext yyg->yytext_r #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) #define yy_flex_debug yyg->yy_flex_debug_r /* Enter a start condition. This macro really ought to take a parameter, * but we do it the disgusting crufty way forced on us by the ()-less * definition of BEGIN. */ #define BEGIN yyg->yy_start = 1 + 2 * /* Translate the current start state into a value that can be later handed * to BEGIN to return to the state. The YYSTATE alias is for lex * compatibility. */ #define YY_START ((yyg->yy_start - 1) / 2) #define YYSTATE YY_START /* Action number for EOF rule of a given start state. */ #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) /* Special action meaning "start processing a new file". */ #define YY_NEW_FILE smt2newrestart(yyin ,yyscanner ) #define YY_END_OF_BUFFER_CHAR 0 /* Size of default input buffer. */ #ifndef YY_BUF_SIZE #define YY_BUF_SIZE 16384 #endif /* The state buf must be large enough to hold one state per character in the main buffer. */ #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) #ifndef YY_TYPEDEF_YY_BUFFER_STATE #define YY_TYPEDEF_YY_BUFFER_STATE typedef struct yy_buffer_state *YY_BUFFER_STATE; #endif #ifndef YY_TYPEDEF_YY_SIZE_T #define YY_TYPEDEF_YY_SIZE_T typedef size_t yy_size_t; #endif #define EOB_ACT_CONTINUE_SCAN 0 #define EOB_ACT_END_OF_FILE 1 #define EOB_ACT_LAST_MATCH 2 /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires * access to the local variable yy_act. Since yyless() is a macro, it would break * existing scanners that call yyless() from OUTSIDE smt2newlex. * One obvious solution it to make yy_act a global. I tried that, and saw * a 5% performance hit in a non-yylineno scanner, because yy_act is * normally declared as a register variable-- so it is not worth it. */ #define YY_LESS_LINENO(n) \ do { \ int yyl;\ for ( yyl = n; yyl < yyleng; ++yyl )\ if ( yytext[yyl] == '\n' )\ --yylineno;\ }while(0) /* Return all but the first "n" matched characters back to the input stream. */ #define yyless(n) \ do \ { \ /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ *yy_cp = yyg->yy_hold_char; \ YY_RESTORE_YY_MORE_OFFSET \ yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ YY_DO_BEFORE_ACTION; /* set up yytext again */ \ } \ while ( 0 ) #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner ) #ifndef YY_STRUCT_YY_BUFFER_STATE #define YY_STRUCT_YY_BUFFER_STATE struct yy_buffer_state { FILE *yy_input_file; char *yy_ch_buf; /* input buffer */ char *yy_buf_pos; /* current position in input buffer */ /* Size of input buffer in bytes, not including room for EOB * characters. */ yy_size_t yy_buf_size; /* Number of characters read into yy_ch_buf, not including EOB * characters. */ yy_size_t yy_n_chars; /* Whether we "own" the buffer - i.e., we know we created it, * and can realloc() it to grow it, and should free() it to * delete it. */ int yy_is_our_buffer; /* Whether this is an "interactive" input source; if so, and * if we're using stdio for input, then we want to use getc() * instead of fread(), to make sure we stop fetching input after * each newline. */ int yy_is_interactive; /* Whether we're considered to be at the beginning of a line. * If so, '^' rules will be active on the next match, otherwise * not. */ int yy_at_bol; int yy_bs_lineno; /**< The line count. */ int yy_bs_column; /**< The column count. */ /* Whether to try to fill the input buffer when we reach the * end of it. */ int yy_fill_buffer; int yy_buffer_status; #define YY_BUFFER_NEW 0 #define YY_BUFFER_NORMAL 1 /* When an EOF's been seen but there's still some text to process * then we mark the buffer as YY_EOF_PENDING, to indicate that we * shouldn't try reading from the input source any more. We might * still have a bunch of tokens to match, though, because of * possible backing-up. * * When we actually see the EOF, we change the status to "new" * (via smt2newrestart()), so that the user can continue scanning by * just pointing yyin at a new input file. */ #define YY_BUFFER_EOF_PENDING 2 }; #endif /* !YY_STRUCT_YY_BUFFER_STATE */ /* We provide macros for accessing buffer states in case in the * future we want to put the buffer states in a more general * "scanner state". * * Returns the top of the stack, or NULL. */ #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ : NULL) /* Same as previous macro, but useful when we know that the buffer stack is not * NULL or when we need an lvalue. For internal use only. */ #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] void smt2newrestart (FILE *input_file ,yyscan_t yyscanner ); void smt2new_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner ); YY_BUFFER_STATE smt2new_create_buffer (FILE *file,int size ,yyscan_t yyscanner ); void smt2new_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner ); void smt2new_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner ); void smt2newpush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner ); void smt2newpop_buffer_state (yyscan_t yyscanner ); static void smt2newensure_buffer_stack (yyscan_t yyscanner ); static void smt2new_load_buffer_state (yyscan_t yyscanner ); static void smt2new_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner ); #define YY_FLUSH_BUFFER smt2new_flush_buffer(YY_CURRENT_BUFFER ,yyscanner) YY_BUFFER_STATE smt2new_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner ); YY_BUFFER_STATE smt2new_scan_string (yyconst char *yy_str ,yyscan_t yyscanner ); YY_BUFFER_STATE smt2new_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner ); void *smt2newalloc (yy_size_t ,yyscan_t yyscanner ); void *smt2newrealloc (void *,yy_size_t ,yyscan_t yyscanner ); void smt2newfree (void * ,yyscan_t yyscanner ); #define yy_new_buffer smt2new_create_buffer #define yy_set_interactive(is_interactive) \ { \ if ( ! YY_CURRENT_BUFFER ){ \ smt2newensure_buffer_stack (yyscanner); \ YY_CURRENT_BUFFER_LVALUE = \ smt2new_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ } #define yy_set_bol(at_bol) \ { \ if ( ! YY_CURRENT_BUFFER ){\ smt2newensure_buffer_stack (yyscanner); \ YY_CURRENT_BUFFER_LVALUE = \ smt2new_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ } #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) /* Begin user sect3 */ #define smt2newwrap(n) 1 #define YY_SKIP_YYWRAP typedef unsigned char YY_CHAR; typedef int yy_state_type; #define yytext_ptr yytext_r static yy_state_type yy_get_previous_state (yyscan_t yyscanner ); static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner); static int yy_get_next_buffer (yyscan_t yyscanner ); static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner ); /* Done after the current pattern has been matched and before the * corresponding action - sets up yytext. */ #define YY_DO_BEFORE_ACTION \ yyg->yytext_ptr = yy_bp; \ yyleng = (size_t) (yy_cp - yy_bp); \ yyg->yy_hold_char = *yy_cp; \ *yy_cp = '\0'; \ yyg->yy_c_buf_p = yy_cp; #define YY_NUM_RULES 84 #define YY_END_OF_BUFFER 85 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info { flex_int32_t yy_verify; flex_int32_t yy_nxt; }; static yyconst flex_int16_t yy_accept[499] = { 0, 0, 0, 0, 0, 0, 0, 85, 83, 2, 2, 3, 68, 83, 65, 67, 61, 61, 83, 83, 65, 65, 65, 4, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 76, 74, 70, 71, 69, 75, 84, 80, 78, 79, 77, 82, 81, 2, 65, 0, 0, 0, 0, 61, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 0, 1, 65, 65, 65, 5, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 72, 73, 64, 63, 62, 62, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 9, 11, 27, 65, 65, 65, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 65, 65, 65, 65, 65, 65, 65, 65, 19, 65, 65, 28, 65, 65, 66, 66, 66, 66, 66, 66, 66, 34, 66, 66, 55, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 39, 66, 66, 66, 66, 66, 33, 66, 66, 66, 66, 66, 65, 65, 12, 13, 65, 65, 65, 7, 8, 65, 65, 65, 65, 65, 65, 65, 65, 65, 32, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 58, 66, 38, 66, 66, 6, 10, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 66, 56, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 57, 65, 65, 65, 65, 65, 65, 22, 65, 65, 65, 65, 30, 65, 65, 66, 66, 66, 66, 66, 66, 66, 66, 41, 66, 66, 66, 66, 66, 66, 40, 66, 14, 65, 65, 65, 65, 65, 65, 65, 24, 65, 26, 29, 65, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 53, 65, 65, 18, 65, 65, 65, 23, 65, 31, 66, 37, 66, 66, 66, 42, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 16, 65, 17, 65, 65, 65, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 52, 66, 66, 66, 15, 65, 65, 65, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 65, 65, 65, 66, 66, 66, 66, 66, 66, 43, 66, 66, 66, 66, 66, 66, 66, 20, 21, 25, 60, 66, 54, 66, 66, 66, 66, 48, 46, 66, 59, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 36, 45, 66, 66, 66, 66, 66, 66, 66, 66, 66, 35, 66, 44, 66, 66, 66, 66, 49, 47, 66, 66, 66, 66, 66, 66, 50, 66, 66, 51, 0 } ; static yyconst flex_int32_t yy_ec[256] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 5, 6, 7, 8, 8, 8, 9, 10, 10, 8, 8, 1, 11, 12, 8, 13, 14, 15, 15, 15, 15, 15, 15, 15, 15, 16, 17, 8, 8, 8, 8, 8, 18, 19, 20, 21, 22, 19, 23, 8, 24, 8, 8, 25, 26, 27, 8, 8, 8, 28, 29, 30, 31, 8, 8, 8, 8, 8, 1, 32, 1, 8, 33, 1, 34, 35, 36, 37, 38, 39, 40, 41, 42, 8, 43, 44, 45, 46, 47, 48, 8, 49, 50, 51, 52, 53, 54, 55, 56, 8, 1, 57, 1, 8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 } ; static yyconst flex_int32_t yy_meta[58] = { 0, 1, 1, 1, 1, 2, 1, 1, 2, 3, 1, 2, 2, 4, 4, 4, 1, 1, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 } ; static yyconst flex_int16_t yy_base[505] = { 0, 0, 0, 56, 61, 66, 69, 575, 576, 72, 75, 0, 576, 26, 0, 576, 70, 77, 93, 571, 551, 541, 541, 0, 520, 528, 530, 512, 519, 527, 526, 52, 525, 521, 576, 576, 576, 576, 576, 576, 74, 576, 576, 576, 576, 576, 576, 92, 0, 89, 0, 94, 98, 102, 0, 53, 80, 70, 509, 514, 525, 53, 509, 86, 82, 516, 100, 553, 576, 535, 528, 525, 502, 513, 109, 508, 500, 497, 496, 497, 497, 494, 492, 504, 576, 576, 136, 0, 138, 141, 497, 489, 500, 504, 488, 109, 490, 484, 488, 488, 481, 116, 485, 125, 481, 495, 490, 483, 477, 501, 502, 499, 484, 485, 476, 477, 111, 484, 506, 0, 0, 0, 475, 504, 467, 502, 471, 469, 470, 462, 474, 469, 456, 467, 464, 465, 464, 455, 463, 462, 448, 445, 445, 444, 447, 441, 86, 466, 463, 463, 440, 445, 453, 440, 434, 0, 440, 130, 0, 124, 434, 432, 434, 434, 433, 429, 431, 430, 464, 425, 421, 0, 422, 420, 418, 422, 421, 423, 416, 413, 415, 425, 415, 419, 442, 441, 435, 406, 445, 406, 416, 403, 408, 401, 404, 401, 399, 401, 412, 399, 397, 395, 386, 390, 391, 397, 391, 426, 399, 385, 397, 399, 398, 0, 420, 394, 384, 382, 393, 415, 375, 382, 373, 372, 374, 395, 394, 0, 0, 368, 379, 405, 0, 0, 365, 375, 362, 365, 361, 366, 370, 368, 356, 0, 372, 355, 353, 353, 367, 390, 358, 361, 362, 357, 346, 357, 383, 382, 343, 354, 0, 352, 0, 347, 342, 0, 0, 353, 375, 130, 132, 338, 342, 336, 348, 329, 333, 337, 336, 326, 0, 334, 324, 336, 336, 325, 321, 319, 331, 316, 356, 316, 313, 353, 325, 312, 310, 0, 309, 134, 307, 311, 308, 316, 0, 308, 315, 302, 314, 0, 315, 303, 307, 301, 305, 305, 307, 298, 307, 300, 0, 305, 141, 302, 293, 291, 287, 0, 280, 0, 283, 287, 287, 283, 280, 284, 283, 0, 317, 0, 0, 281, 276, 279, 288, 289, 283, 271, 271, 266, 282, 267, 269, 266, 268, 275, 269, 259, 274, 0, 263, 259, 0, 256, 264, 260, 0, 268, 0, 252, 0, 291, 248, 258, 0, 257, 260, 259, 246, 258, 247, 243, 255, 245, 239, 240, 0, 237, 0, 240, 248, 238, 242, 236, 240, 235, 232, 268, 228, 235, 238, 228, 240, 0, 226, 224, 229, 0, 224, 223, 219, 231, 214, 218, 222, 212, 217, 211, 220, 215, 219, 206, 202, 203, 206, 203, 201, 213, 200, 198, 199, 196, 204, 198, 0, 198, 193, 192, 230, 194, 188, 187, 0, 0, 0, 0, 189, 0, 194, 188, 197, 188, 0, 0, 196, 0, 220, 188, 177, 181, 181, 188, 187, 177, 187, 175, 170, 174, 0, 0, 173, 169, 176, 170, 204, 164, 162, 174, 172, 0, 156, 0, 141, 140, 142, 146, 0, 0, 139, 147, 141, 130, 123, 101, 0, 102, 84, 0, 576, 193, 197, 200, 203, 207, 62 } ; static yyconst flex_int16_t yy_def[505] = { 0, 498, 1, 499, 499, 500, 500, 498, 498, 498, 498, 501, 498, 498, 501, 498, 498, 498, 502, 503, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 501, 498, 504, 498, 498, 498, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 503, 498, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 498, 498, 498, 504, 498, 498, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 501, 501, 501, 501, 501, 501, 501, 501, 501, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 501, 501, 501, 501, 501, 501, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 501, 501, 501, 501, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 501, 501, 501, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 501, 501, 501, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 0, 498, 498, 498, 498, 498, 498 } ; static yyconst flex_int16_t yy_nxt[634] = { 0, 8, 9, 10, 9, 11, 12, 13, 14, 14, 15, 14, 14, 16, 17, 17, 18, 19, 14, 14, 14, 20, 14, 14, 14, 14, 14, 21, 14, 22, 14, 14, 8, 23, 24, 14, 25, 26, 27, 28, 29, 14, 14, 14, 30, 14, 14, 14, 31, 14, 32, 33, 14, 14, 14, 14, 14, 34, 36, 37, 38, 49, 39, 36, 37, 38, 87, 39, 42, 43, 44, 42, 43, 44, 47, 47, 47, 47, 47, 47, 84, 50, 51, 52, 52, 52, 79, 99, 40, 51, 53, 53, 53, 40, 47, 47, 47, 90, 45, 80, 100, 45, 86, 86, 81, 91, 85, 88, 89, 89, 51, 52, 52, 52, 51, 53, 53, 53, 92, 94, 102, 182, 93, 46, 103, 95, 46, 55, 497, 104, 56, 57, 58, 105, 107, 59, 183, 60, 108, 61, 496, 62, 63, 64, 65, 114, 66, 495, 115, 86, 86, 88, 89, 89, 89, 89, 89, 130, 137, 140, 131, 154, 155, 138, 193, 141, 199, 494, 200, 300, 302, 201, 194, 330, 303, 351, 493, 195, 196, 492, 301, 491, 197, 198, 331, 490, 352, 489, 488, 353, 487, 486, 485, 354, 35, 35, 35, 35, 41, 41, 41, 41, 48, 48, 48, 54, 484, 54, 67, 67, 67, 67, 483, 482, 481, 480, 479, 478, 477, 476, 475, 474, 473, 472, 471, 470, 469, 468, 467, 466, 465, 464, 463, 462, 461, 460, 459, 458, 457, 456, 455, 454, 453, 452, 451, 450, 449, 448, 447, 446, 445, 444, 443, 442, 441, 440, 439, 438, 437, 436, 435, 434, 433, 432, 431, 430, 429, 428, 427, 426, 425, 424, 423, 422, 421, 420, 419, 418, 417, 416, 415, 414, 413, 412, 411, 410, 409, 408, 407, 406, 405, 404, 403, 402, 401, 400, 399, 398, 397, 396, 395, 394, 393, 392, 391, 390, 389, 388, 387, 386, 385, 384, 383, 382, 381, 380, 379, 378, 377, 376, 375, 374, 373, 372, 371, 370, 369, 368, 367, 366, 365, 364, 363, 362, 361, 360, 359, 358, 357, 356, 355, 350, 349, 348, 347, 346, 345, 344, 343, 342, 341, 340, 339, 338, 337, 336, 335, 334, 333, 332, 329, 328, 327, 326, 325, 324, 323, 322, 321, 320, 319, 318, 317, 316, 315, 314, 313, 312, 311, 310, 309, 308, 307, 306, 305, 304, 299, 298, 297, 296, 295, 294, 293, 292, 291, 290, 289, 288, 287, 286, 285, 284, 283, 282, 281, 280, 279, 278, 277, 276, 275, 274, 273, 272, 271, 270, 269, 268, 267, 266, 265, 264, 263, 262, 261, 260, 259, 258, 257, 256, 255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240, 239, 238, 237, 236, 235, 234, 233, 232, 231, 230, 229, 228, 227, 226, 225, 224, 223, 222, 221, 220, 219, 218, 217, 216, 215, 214, 213, 212, 211, 210, 209, 208, 207, 206, 205, 204, 203, 202, 192, 191, 190, 189, 188, 187, 186, 185, 184, 181, 180, 179, 178, 177, 176, 175, 174, 173, 172, 171, 170, 169, 168, 167, 166, 165, 164, 163, 162, 161, 160, 159, 158, 157, 156, 153, 152, 151, 150, 149, 148, 147, 146, 145, 144, 143, 142, 139, 136, 135, 134, 133, 132, 129, 128, 127, 126, 125, 124, 123, 122, 121, 120, 119, 118, 117, 116, 113, 112, 111, 110, 109, 68, 106, 101, 98, 97, 96, 83, 82, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, 68, 498, 7, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498 } ; static yyconst flex_int16_t yy_chk[634] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 3, 13, 3, 4, 4, 4, 504, 4, 5, 5, 5, 6, 6, 6, 9, 9, 9, 10, 10, 10, 40, 13, 16, 16, 16, 16, 31, 61, 3, 17, 17, 17, 17, 4, 47, 47, 47, 55, 5, 31, 61, 6, 49, 49, 31, 55, 40, 51, 51, 51, 52, 52, 52, 52, 53, 53, 53, 53, 56, 57, 63, 146, 56, 5, 63, 57, 6, 18, 496, 64, 18, 18, 18, 64, 66, 18, 146, 18, 66, 18, 495, 18, 18, 18, 18, 74, 18, 493, 74, 86, 86, 88, 88, 88, 89, 89, 89, 95, 101, 103, 95, 116, 116, 101, 157, 103, 159, 492, 159, 269, 270, 159, 157, 299, 270, 322, 491, 157, 157, 490, 269, 489, 157, 157, 299, 488, 322, 485, 484, 322, 483, 482, 480, 322, 499, 499, 499, 499, 500, 500, 500, 500, 501, 501, 501, 502, 478, 502, 503, 503, 503, 503, 477, 476, 475, 474, 473, 472, 471, 470, 467, 466, 465, 464, 463, 462, 461, 460, 459, 458, 457, 456, 454, 451, 450, 449, 448, 446, 441, 440, 439, 438, 437, 436, 435, 433, 432, 431, 430, 429, 428, 427, 426, 425, 424, 423, 422, 421, 420, 419, 418, 417, 416, 415, 414, 413, 412, 411, 410, 409, 408, 406, 405, 404, 402, 401, 400, 399, 398, 397, 396, 395, 394, 393, 392, 391, 390, 389, 387, 385, 384, 383, 382, 381, 380, 379, 378, 377, 376, 375, 373, 372, 371, 369, 367, 365, 364, 363, 361, 360, 358, 357, 356, 355, 354, 353, 352, 351, 350, 349, 348, 347, 346, 345, 344, 343, 342, 341, 338, 336, 335, 334, 333, 332, 331, 330, 328, 326, 325, 324, 323, 321, 319, 318, 317, 316, 315, 314, 313, 312, 311, 310, 308, 307, 306, 305, 303, 302, 301, 300, 298, 296, 295, 294, 293, 292, 291, 290, 289, 288, 287, 286, 285, 284, 283, 282, 281, 279, 278, 277, 276, 275, 274, 273, 272, 271, 268, 267, 264, 263, 261, 259, 258, 257, 256, 255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 242, 241, 240, 239, 238, 237, 236, 235, 234, 231, 230, 229, 226, 225, 224, 223, 222, 221, 220, 219, 218, 217, 216, 215, 214, 212, 211, 210, 209, 208, 207, 206, 205, 204, 203, 202, 201, 200, 199, 198, 197, 196, 195, 194, 193, 192, 191, 190, 189, 188, 187, 186, 185, 184, 183, 182, 181, 180, 179, 178, 177, 176, 175, 174, 173, 172, 170, 169, 168, 167, 166, 165, 164, 163, 162, 161, 160, 156, 154, 153, 152, 151, 150, 149, 148, 147, 145, 144, 143, 142, 141, 140, 139, 138, 137, 136, 135, 134, 133, 132, 131, 130, 129, 128, 127, 126, 125, 124, 123, 122, 118, 117, 115, 114, 113, 112, 111, 110, 109, 108, 107, 106, 105, 104, 102, 100, 99, 98, 97, 96, 94, 93, 92, 91, 90, 83, 82, 81, 80, 79, 78, 77, 76, 75, 73, 72, 71, 70, 69, 67, 65, 62, 60, 59, 58, 33, 32, 30, 29, 28, 27, 26, 25, 24, 22, 21, 20, 19, 7, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498, 498 } ; /* Table of booleans, true if rule could match eol. */ static yyconst flex_int32_t yy_rule_can_match_eol[85] = { 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, }; /* The intent behind this definition is that it'll catch * any uses of REJECT which flex missed. */ #define REJECT reject_used_but_not_detected #define yymore() yymore_used_but_not_detected #define YY_MORE_ADJ 0 #define YY_RESTORE_YY_MORE_OFFSET #line 1 "smt2newlexer.ll" #line 10 "smt2newlexer.ll" #include #include #include #include #include "smt2newcontext.h" #include "smt2newparser.h" #define YY_EXTRA_TYPE Smt2newContext* #define YY_USER_ACTION smt2newget_lloc(yyscanner)->first_line = smt2newget_lineno(yyscanner); /* #define YY_INPUT(buf,result,max_size) \ { \ char c; \ (yyextra->is) >> c; \ if (yyextra->is.eof()) \ result = YY_NULL; \ else { \ buf[0] = c; \ result = 1; \ } \ } */ #line 788 "smt2newlexer.cc" #define INITIAL 0 #define STR 1 #define PSYM 2 #ifndef YY_NO_UNISTD_H /* Special case for "unistd.h", since it is non-ANSI. We include it way * down here because we want the user's section 1 to have been scanned first. * The user has a chance to override it with an option. */ #include #endif #ifndef YY_EXTRA_TYPE #define YY_EXTRA_TYPE void * #endif /* Holds the entire state of the reentrant scanner. */ struct yyguts_t { /* User-defined. Not touched by flex. */ YY_EXTRA_TYPE yyextra_r; /* The rest are the same as the globals declared in the non-reentrant scanner. */ FILE *yyin_r, *yyout_r; size_t yy_buffer_stack_top; /**< index of top of stack. */ size_t yy_buffer_stack_max; /**< capacity of stack. */ YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */ char yy_hold_char; yy_size_t yy_n_chars; yy_size_t yyleng_r; char *yy_c_buf_p; int yy_init; int yy_start; int yy_did_buffer_switch_on_eof; int yy_start_stack_ptr; int yy_start_stack_depth; int *yy_start_stack; yy_state_type yy_last_accepting_state; char* yy_last_accepting_cpos; int yylineno_r; int yy_flex_debug_r; char *yytext_r; int yy_more_flag; int yy_more_len; YYSTYPE * yylval_r; YYLTYPE * yylloc_r; }; /* end struct yyguts_t */ static int yy_init_globals (yyscan_t yyscanner ); /* This must go here because YYSTYPE and YYLTYPE are included * from bison output in section 1.*/ # define yylval yyg->yylval_r # define yylloc yyg->yylloc_r int smt2newlex_init (yyscan_t* scanner); int smt2newlex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner); /* Accessor methods to globals. These are made visible to non-reentrant scanners for convenience. */ int smt2newlex_destroy (yyscan_t yyscanner ); int smt2newget_debug (yyscan_t yyscanner ); void smt2newset_debug (int debug_flag ,yyscan_t yyscanner ); YY_EXTRA_TYPE smt2newget_extra (yyscan_t yyscanner ); void smt2newset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner ); FILE *smt2newget_in (yyscan_t yyscanner ); void smt2newset_in (FILE * in_str ,yyscan_t yyscanner ); FILE *smt2newget_out (yyscan_t yyscanner ); void smt2newset_out (FILE * out_str ,yyscan_t yyscanner ); yy_size_t smt2newget_leng (yyscan_t yyscanner ); char *smt2newget_text (yyscan_t yyscanner ); int smt2newget_lineno (yyscan_t yyscanner ); void smt2newset_lineno (int line_number ,yyscan_t yyscanner ); YYSTYPE * smt2newget_lval (yyscan_t yyscanner ); void smt2newset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner ); YYLTYPE *smt2newget_lloc (yyscan_t yyscanner ); void smt2newset_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner ); /* Macros after this point can all be overridden by user definitions in * section 1. */ #ifndef YY_SKIP_YYWRAP #ifdef __cplusplus extern "C" int smt2newwrap (yyscan_t yyscanner ); #else extern int smt2newwrap (yyscan_t yyscanner ); #endif #endif static void yyunput (int c,char *buf_ptr ,yyscan_t yyscanner); #ifndef yytext_ptr static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner); #endif #ifdef YY_NEED_STRLEN static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner); #endif #ifndef YY_NO_INPUT #ifdef __cplusplus static int yyinput (yyscan_t yyscanner ); #else static int input (yyscan_t yyscanner ); #endif #endif static void yy_push_state (int new_state ,yyscan_t yyscanner); static void yy_pop_state (yyscan_t yyscanner ); static int yy_top_state (yyscan_t yyscanner ); /* Amount of stuff to slurp up with each read. */ #ifndef YY_READ_BUF_SIZE #define YY_READ_BUF_SIZE 8192 #endif /* Copy whatever the last rule matched to the standard output. */ #ifndef ECHO /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */ #define ECHO fwrite( yytext, yyleng, 1, yyout ) #endif /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, * is returned in "result". */ #ifndef YY_INPUT #define YY_INPUT(buf,result,max_size) \ if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ int c = '*'; \ yy_size_t n; \ for ( n = 0; n < max_size && \ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ if ( c == '\n' ) \ buf[n++] = (char) c; \ if ( c == EOF && ferror( yyin ) ) \ YY_FATAL_ERROR( "input in flex scanner failed" ); \ result = n; \ } \ else \ { \ errno=0; \ while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ { \ if( errno != EINTR) \ { \ YY_FATAL_ERROR( "input in flex scanner failed" ); \ break; \ } \ errno=0; \ clearerr(yyin); \ } \ }\ \ #endif /* No semi-colon after return; correct usage is to write "yyterminate();" - * we don't want an extra ';' after the "return" because that will cause * some compilers to complain about unreachable statements. */ #ifndef yyterminate #define yyterminate() return YY_NULL #endif /* Number of entries by which start-condition stack grows. */ #ifndef YY_START_STACK_INCR #define YY_START_STACK_INCR 25 #endif /* Report a fatal error. */ #ifndef YY_FATAL_ERROR #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) #endif /* end tables serialization structures and prototypes */ /* Default declaration of generated scanner - a define so the user can * easily add parameters. */ #ifndef YY_DECL #define YY_DECL_IS_OURS 1 extern int smt2newlex \ (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner); #define YY_DECL int smt2newlex \ (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner) #endif /* !YY_DECL */ /* Code executed at the beginning of each rule, after yytext and yyleng * have been set up. */ #ifndef YY_USER_ACTION #define YY_USER_ACTION #endif /* Code executed at the end of each rule. */ #ifndef YY_BREAK #define YY_BREAK break; #endif #define YY_RULE_SETUP \ YY_USER_ACTION /** The main scanner function which does all the work. */ YY_DECL { register yy_state_type yy_current_state; register char *yy_cp, *yy_bp; register int yy_act; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; #line 39 "smt2newlexer.ll" #line 1040 "smt2newlexer.cc" yylval = yylval_param; yylloc = yylloc_param; if ( !yyg->yy_init ) { yyg->yy_init = 1; #ifdef YY_USER_INIT YY_USER_INIT; #endif if ( ! yyg->yy_start ) yyg->yy_start = 1; /* first start state */ if ( ! yyin ) yyin = stdin; if ( ! yyout ) yyout = stdout; if ( ! YY_CURRENT_BUFFER ) { smt2newensure_buffer_stack (yyscanner); YY_CURRENT_BUFFER_LVALUE = smt2new_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); } smt2new_load_buffer_state(yyscanner ); } while ( 1 ) /* loops until end-of-file is reached */ { yy_cp = yyg->yy_c_buf_p; /* Support of yytext. */ *yy_cp = yyg->yy_hold_char; /* yy_bp points to the position in yy_ch_buf of the start of * the current run. */ yy_bp = yy_cp; yy_current_state = yyg->yy_start; yy_match: do { register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; if ( yy_accept[yy_current_state] ) { yyg->yy_last_accepting_state = yy_current_state; yyg->yy_last_accepting_cpos = yy_cp; } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 499 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; ++yy_cp; } while ( yy_base[yy_current_state] != 576 ); yy_find_action: yy_act = yy_accept[yy_current_state]; if ( yy_act == 0 ) { /* have to back up */ yy_cp = yyg->yy_last_accepting_cpos; yy_current_state = yyg->yy_last_accepting_state; yy_act = yy_accept[yy_current_state]; } YY_DO_BEFORE_ACTION; if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) { int yyl; for ( yyl = 0; yyl < yyleng; ++yyl ) if ( yytext[yyl] == '\n' ) do{ yylineno++; yycolumn=0; }while(0) ; } do_action: /* This label is used only to access EOF actions. */ switch ( yy_act ) { /* beginning of action switch */ case 0: /* must back up */ /* undo the effects of YY_DO_BEFORE_ACTION */ *yy_cp = yyg->yy_hold_char; yy_cp = yyg->yy_last_accepting_cpos; yy_current_state = yyg->yy_last_accepting_state; goto yy_find_action; case 1: /* rule 1 can match eol */ YY_RULE_SETUP #line 41 "smt2newlexer.ll" // Eat comments YY_BREAK case 2: /* rule 2 can match eol */ YY_RULE_SETUP #line 42 "smt2newlexer.ll" // Eat spaces YY_BREAK case 3: YY_RULE_SETUP #line 44 "smt2newlexer.ll" { return *smt2newget_text(yyscanner); } YY_BREAK case 4: YY_RULE_SETUP #line 45 "smt2newlexer.ll" { return *smt2newget_text(yyscanner); } YY_BREAK case 5: YY_RULE_SETUP #line 46 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_AS; } YY_BREAK case 6: YY_RULE_SETUP #line 47 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_DECIMAL; } YY_BREAK case 7: YY_RULE_SETUP #line 48 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_EXISTS; } YY_BREAK case 8: YY_RULE_SETUP #line 49 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_FORALL; } YY_BREAK case 9: YY_RULE_SETUP #line 50 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_LET; } YY_BREAK case 10: YY_RULE_SETUP #line 51 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_NUMERAL; } YY_BREAK case 11: YY_RULE_SETUP #line 52 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_PAR; } YY_BREAK case 12: YY_RULE_SETUP #line 53 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_STRING; } YY_BREAK case 13: YY_RULE_SETUP #line 55 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_ASSERT; } YY_BREAK case 14: YY_RULE_SETUP #line 56 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_CHECKSAT; } YY_BREAK case 15: YY_RULE_SETUP #line 57 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_DECLARESORT; } YY_BREAK case 16: YY_RULE_SETUP #line 58 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_DECLAREFUN; } YY_BREAK case 17: YY_RULE_SETUP #line 59 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_DEFINESORT; } YY_BREAK case 18: YY_RULE_SETUP #line 60 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_DEFINEFUN; } YY_BREAK case 19: YY_RULE_SETUP #line 61 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_EXIT; } YY_BREAK case 20: YY_RULE_SETUP #line 62 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_GETASSERTIONS; } YY_BREAK case 21: YY_RULE_SETUP #line 63 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_GETASSIGNMENT; } YY_BREAK case 22: YY_RULE_SETUP #line 64 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_GETINFO; } YY_BREAK case 23: YY_RULE_SETUP #line 65 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_GETOPTION; } YY_BREAK case 24: YY_RULE_SETUP #line 66 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_GETPROOF; } YY_BREAK case 25: YY_RULE_SETUP #line 67 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_GETUNSATCORE; } YY_BREAK case 26: YY_RULE_SETUP #line 68 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_GETVALUE; } YY_BREAK case 27: YY_RULE_SETUP #line 69 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_POP; } YY_BREAK case 28: YY_RULE_SETUP #line 70 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_PUSH; } YY_BREAK case 29: YY_RULE_SETUP #line 71 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_SETLOGIC; } YY_BREAK case 30: YY_RULE_SETUP #line 72 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_SETINFO; } YY_BREAK case 31: YY_RULE_SETUP #line 73 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_SETOPTION; } YY_BREAK case 32: YY_RULE_SETUP #line 74 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_THEORY; } YY_BREAK case 33: YY_RULE_SETUP #line 76 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_SORTS; } YY_BREAK case 34: YY_RULE_SETUP #line 77 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_FUNS; } YY_BREAK case 35: YY_RULE_SETUP #line 78 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_SORTSDESCRIPTION; } YY_BREAK case 36: YY_RULE_SETUP #line 79 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_FUNSDESCRIPTION; } YY_BREAK case 37: YY_RULE_SETUP #line 80 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_DEFINITION; } YY_BREAK case 38: YY_RULE_SETUP #line 81 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_VALUES; } YY_BREAK case 39: YY_RULE_SETUP #line 82 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_NOTES; } YY_BREAK case 40: YY_RULE_SETUP #line 83 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_THEORIES; } YY_BREAK case 41: YY_RULE_SETUP #line 84 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_LANGUAGE; } YY_BREAK case 42: YY_RULE_SETUP #line 85 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_EXTENSIONS; } YY_BREAK case 43: YY_RULE_SETUP #line 86 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_PRINTSUCCESS; } YY_BREAK case 44: YY_RULE_SETUP #line 87 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_EXPANDDEFINITIONS; } YY_BREAK case 45: YY_RULE_SETUP #line 88 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_INTERACTIVEMODE; } YY_BREAK case 46: YY_RULE_SETUP #line 89 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_PRODUCEPROOFS; } YY_BREAK case 47: YY_RULE_SETUP #line 90 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_PRODUCEUNSATCORES; } YY_BREAK case 48: YY_RULE_SETUP #line 91 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_PRODUCEMODELS; } YY_BREAK case 49: YY_RULE_SETUP #line 92 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_PRODUCEASSIGNMENTS; } YY_BREAK case 50: YY_RULE_SETUP #line 93 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_REGULAROUTPUTCHANNEL; } YY_BREAK case 51: YY_RULE_SETUP #line 94 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_DIAGNOSTICOUTPUTCHANNEL; } YY_BREAK case 52: YY_RULE_SETUP #line 95 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_RANDOMSEED; } YY_BREAK case 53: YY_RULE_SETUP #line 96 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_VERBOSITY; } YY_BREAK case 54: YY_RULE_SETUP #line 97 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_ERRORBEHAVIOR; } YY_BREAK case 55: YY_RULE_SETUP #line 98 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_NAME; } YY_BREAK case 56: YY_RULE_SETUP #line 99 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_AUTHORS; } YY_BREAK case 57: YY_RULE_SETUP #line 100 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_VERSION; } YY_BREAK case 58: YY_RULE_SETUP #line 101 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_STATUS; } YY_BREAK case 59: YY_RULE_SETUP #line 102 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_REASONUNKNOWN; } YY_BREAK case 60: YY_RULE_SETUP #line 103 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return KW_ALLSTATISTICS; } YY_BREAK case 61: YY_RULE_SETUP #line 106 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_NUM; } YY_BREAK case 62: YY_RULE_SETUP #line 107 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_DEC; } YY_BREAK case 63: YY_RULE_SETUP #line 108 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_HEX; } YY_BREAK case 64: YY_RULE_SETUP #line 109 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_BIN; } YY_BREAK case 65: YY_RULE_SETUP #line 111 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_SYM; } YY_BREAK case 66: YY_RULE_SETUP #line 112 "smt2newlexer.ll" { smt2newget_lval(yyscanner)->str = strdup( smt2newget_text(yyscanner) ); return TK_KEY; } YY_BREAK case 67: YY_RULE_SETUP #line 114 "smt2newlexer.ll" { return *smt2newget_text(yyscanner); } YY_BREAK case 68: YY_RULE_SETUP #line 116 "smt2newlexer.ll" { yy_push_state(STR, yyscanner); } YY_BREAK case 69: YY_RULE_SETUP #line 119 "smt2newlexer.ll" { yyextra->insertBuf(' '); } YY_BREAK case 70: YY_RULE_SETUP #line 120 "smt2newlexer.ll" { yyextra->insertBuf('\t'); } YY_BREAK case 71: /* rule 71 can match eol */ YY_RULE_SETUP #line 121 "smt2newlexer.ll" { yyextra->insertBuf('\n'); } YY_BREAK case 72: YY_RULE_SETUP #line 122 "smt2newlexer.ll" { yyextra->insertBuf('"'); } YY_BREAK case 73: YY_RULE_SETUP #line 123 "smt2newlexer.ll" { yyextra->insertBuf('\\'); } YY_BREAK case 74: YY_RULE_SETUP #line 124 "smt2newlexer.ll" { yyextra->insertBuf(smt2newget_text(yyscanner)[0]); } YY_BREAK case 75: YY_RULE_SETUP #line 125 "smt2newlexer.ll" { yylval->str = strdup(yyextra->getBuf()); yyextra->clearBuf(); yy_pop_state(yyscanner); return TK_STR; } YY_BREAK case 76: YY_RULE_SETUP #line 129 "smt2newlexer.ll" { yy_push_state(PSYM, yyscanner); } YY_BREAK case 77: YY_RULE_SETUP #line 132 "smt2newlexer.ll" { yyextra->insertBuf(' '); } YY_BREAK case 78: YY_RULE_SETUP #line 133 "smt2newlexer.ll" { yyextra->insertBuf('\t'); } YY_BREAK case 79: /* rule 79 can match eol */ YY_RULE_SETUP #line 134 "smt2newlexer.ll" { yyextra->insertBuf('\n'); } YY_BREAK case 80: YY_RULE_SETUP #line 135 "smt2newlexer.ll" { yyextra->insertBuf(smt2newget_text(yyscanner)[0]); } YY_BREAK case 81: YY_RULE_SETUP #line 136 "smt2newlexer.ll" { yylval->str = strdup(yyextra->getBuf()); yyextra->clearBuf(); yy_pop_state(yyscanner); return TK_SYM; } YY_BREAK case 82: YY_RULE_SETUP #line 138 "smt2newlexer.ll" { printf("Syntax error at line %d near %s, \\ not allowed inside | ... |\n", smt2newget_lineno(yyscanner), smt2newget_text(yyscanner)); exit(1); } YY_BREAK case 83: YY_RULE_SETUP #line 141 "smt2newlexer.ll" { printf( "Syntax error at line %d near %s\n", smt2newget_lineno(yyscanner), smt2newget_text(yyscanner) ); exit( 1 ); } YY_BREAK case 84: YY_RULE_SETUP #line 143 "smt2newlexer.ll" ECHO; YY_BREAK #line 1569 "smt2newlexer.cc" case YY_STATE_EOF(INITIAL): case YY_STATE_EOF(STR): case YY_STATE_EOF(PSYM): yyterminate(); case YY_END_OF_BUFFER: { /* Amount of text matched not including the EOB char. */ int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; /* Undo the effects of YY_DO_BEFORE_ACTION. */ *yy_cp = yyg->yy_hold_char; YY_RESTORE_YY_MORE_OFFSET if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) { /* We're scanning a new file or input source. It's * possible that this happened because the user * just pointed yyin at a new source and called * smt2newlex(). If so, then we have to assure * consistency between YY_CURRENT_BUFFER and our * globals. Here is the right place to do so, because * this is the first action (other than possibly a * back-up) that will match for the new input source. */ yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; } /* Note that here we test for yy_c_buf_p "<=" to the position * of the first EOB in the buffer, since yy_c_buf_p will * already have been incremented past the NUL character * (since all states make transitions on EOB to the * end-of-buffer state). Contrast this with the test * in input(). */ if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) { /* This was really a NUL. */ yy_state_type yy_next_state; yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; yy_current_state = yy_get_previous_state( yyscanner ); /* Okay, we're now positioned to make the NUL * transition. We couldn't have * yy_get_previous_state() go ahead and do it * for us because it doesn't know how to deal * with the possibility of jamming (and we don't * want to build jamming into it because then it * will run more slowly). */ yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; if ( yy_next_state ) { /* Consume the NUL. */ yy_cp = ++yyg->yy_c_buf_p; yy_current_state = yy_next_state; goto yy_match; } else { yy_cp = yyg->yy_c_buf_p; goto yy_find_action; } } else switch ( yy_get_next_buffer( yyscanner ) ) { case EOB_ACT_END_OF_FILE: { yyg->yy_did_buffer_switch_on_eof = 0; if ( smt2newwrap(yyscanner ) ) { /* Note: because we've taken care in * yy_get_next_buffer() to have set up * yytext, we can now set up * yy_c_buf_p so that if some total * hoser (like flex itself) wants to * call the scanner after we return the * YY_NULL, it'll still work - another * YY_NULL will get returned. */ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; yy_act = YY_STATE_EOF(YY_START); goto do_action; } else { if ( ! yyg->yy_did_buffer_switch_on_eof ) YY_NEW_FILE; } break; } case EOB_ACT_CONTINUE_SCAN: yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; yy_current_state = yy_get_previous_state( yyscanner ); yy_cp = yyg->yy_c_buf_p; yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; goto yy_match; case EOB_ACT_LAST_MATCH: yyg->yy_c_buf_p = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; yy_current_state = yy_get_previous_state( yyscanner ); yy_cp = yyg->yy_c_buf_p; yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; goto yy_find_action; } break; } default: YY_FATAL_ERROR( "fatal flex scanner internal error--no action found" ); } /* end of action switch */ } /* end of scanning one token */ } /* end of smt2newlex */ /* yy_get_next_buffer - try to read in a new buffer * * Returns a code representing an action: * EOB_ACT_LAST_MATCH - * EOB_ACT_CONTINUE_SCAN - continue scanning from current position * EOB_ACT_END_OF_FILE - end of file */ static int yy_get_next_buffer (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; register char *source = yyg->yytext_ptr; register int number_to_move, i; int ret_val; if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) YY_FATAL_ERROR( "fatal flex scanner internal error--end of buffer missed" ); if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) { /* Don't try to fill the buffer, so this is an EOF. */ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) { /* We matched a single character, the EOB, so * treat this as a final EOF. */ return EOB_ACT_END_OF_FILE; } else { /* We matched some text prior to the EOB, first * process it. */ return EOB_ACT_LAST_MATCH; } } /* Try to read more data. */ /* First move last chars to start of buffer. */ number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1; for ( i = 0; i < number_to_move; ++i ) *(dest++) = *(source++); if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) /* don't do the read, it's not guaranteed to return an EOF, * just force an EOF */ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; else { yy_size_t num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; while ( num_to_read <= 0 ) { /* Not enough room in the buffer - grow it. */ /* just a shorter name for the current buffer */ YY_BUFFER_STATE b = YY_CURRENT_BUFFER; int yy_c_buf_p_offset = (int) (yyg->yy_c_buf_p - b->yy_ch_buf); if ( b->yy_is_our_buffer ) { yy_size_t new_size = b->yy_buf_size * 2; if ( new_size <= 0 ) b->yy_buf_size += b->yy_buf_size / 8; else b->yy_buf_size *= 2; b->yy_ch_buf = (char *) /* Include room in for 2 EOB chars. */ smt2newrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner ); } else /* Can't grow it, we don't own it. */ b->yy_ch_buf = 0; if ( ! b->yy_ch_buf ) YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" ); yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; } if ( num_to_read > YY_READ_BUF_SIZE ) num_to_read = YY_READ_BUF_SIZE; /* Read in more data. */ YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), yyg->yy_n_chars, num_to_read ); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; } if ( yyg->yy_n_chars == 0 ) { if ( number_to_move == YY_MORE_ADJ ) { ret_val = EOB_ACT_END_OF_FILE; smt2newrestart(yyin ,yyscanner); } else { ret_val = EOB_ACT_LAST_MATCH; YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_EOF_PENDING; } } else ret_val = EOB_ACT_CONTINUE_SCAN; if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { /* Extend the array by 50%, plus the number we really need. */ yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) smt2newrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner ); if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); } yyg->yy_n_chars += number_to_move; YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; return ret_val; } /* yy_get_previous_state - get the state just before the EOB char was reached */ static yy_state_type yy_get_previous_state (yyscan_t yyscanner) { register yy_state_type yy_current_state; register char *yy_cp; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yy_current_state = yyg->yy_start; for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) { register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); if ( yy_accept[yy_current_state] ) { yyg->yy_last_accepting_state = yy_current_state; yyg->yy_last_accepting_cpos = yy_cp; } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 499 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; } return yy_current_state; } /* yy_try_NUL_trans - try to make a transition on the NUL character * * synopsis * next_state = yy_try_NUL_trans( current_state ); */ static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner) { register int yy_is_jam; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ register char *yy_cp = yyg->yy_c_buf_p; register YY_CHAR yy_c = 1; if ( yy_accept[yy_current_state] ) { yyg->yy_last_accepting_state = yy_current_state; yyg->yy_last_accepting_cpos = yy_cp; } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 499 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; yy_is_jam = (yy_current_state == 498); return yy_is_jam ? 0 : yy_current_state; } static void yyunput (int c, register char * yy_bp , yyscan_t yyscanner) { register char *yy_cp; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yy_cp = yyg->yy_c_buf_p; /* undo effects of setting up yytext */ *yy_cp = yyg->yy_hold_char; if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) { /* need to shift things up to make room */ /* +2 for EOB chars. */ register yy_size_t number_to_move = yyg->yy_n_chars + 2; register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; register char *source = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) *--dest = *--source; yy_cp += (int) (dest - source); yy_bp += (int) (dest - source); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) YY_FATAL_ERROR( "flex scanner push-back overflow" ); } *--yy_cp = (char) c; if ( c == '\n' ){ --yylineno; } yyg->yytext_ptr = yy_bp; yyg->yy_hold_char = *yy_cp; yyg->yy_c_buf_p = yy_cp; } #ifndef YY_NO_INPUT #ifdef __cplusplus static int yyinput (yyscan_t yyscanner) #else static int input (yyscan_t yyscanner) #endif { int c; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; *yyg->yy_c_buf_p = yyg->yy_hold_char; if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) { /* yy_c_buf_p now points to the character we want to return. * If this occurs *before* the EOB characters, then it's a * valid NUL; if not, then we've hit the end of the buffer. */ if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) /* This was really a NUL. */ *yyg->yy_c_buf_p = '\0'; else { /* need more input */ yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr; ++yyg->yy_c_buf_p; switch ( yy_get_next_buffer( yyscanner ) ) { case EOB_ACT_LAST_MATCH: /* This happens because yy_g_n_b() * sees that we've accumulated a * token and flags that we need to * try matching the token before * proceeding. But for input(), * there's no matching to consider. * So convert the EOB_ACT_LAST_MATCH * to EOB_ACT_END_OF_FILE. */ /* Reset buffer status. */ smt2newrestart(yyin ,yyscanner); /*FALLTHROUGH*/ case EOB_ACT_END_OF_FILE: { if ( smt2newwrap(yyscanner ) ) return 0; if ( ! yyg->yy_did_buffer_switch_on_eof ) YY_NEW_FILE; #ifdef __cplusplus return yyinput(yyscanner); #else return input(yyscanner); #endif } case EOB_ACT_CONTINUE_SCAN: yyg->yy_c_buf_p = yyg->yytext_ptr + offset; break; } } } c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */ *yyg->yy_c_buf_p = '\0'; /* preserve yytext */ yyg->yy_hold_char = *++yyg->yy_c_buf_p; if ( c == '\n' ) do{ yylineno++; yycolumn=0; }while(0) ; return c; } #endif /* ifndef YY_NO_INPUT */ /** Immediately switch to a different input stream. * @param input_file A readable stream. * @param yyscanner The scanner object. * @note This function does not reset the start condition to @c INITIAL . */ void smt2newrestart (FILE * input_file , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if ( ! YY_CURRENT_BUFFER ){ smt2newensure_buffer_stack (yyscanner); YY_CURRENT_BUFFER_LVALUE = smt2new_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); } smt2new_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner); smt2new_load_buffer_state(yyscanner ); } /** Switch to a different input buffer. * @param new_buffer The new input buffer. * @param yyscanner The scanner object. */ void smt2new_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* TODO. We should be able to replace this entire function body * with * smt2newpop_buffer_state(); * smt2newpush_buffer_state(new_buffer); */ smt2newensure_buffer_stack (yyscanner); if ( YY_CURRENT_BUFFER == new_buffer ) return; if ( YY_CURRENT_BUFFER ) { /* Flush out information for old buffer. */ *yyg->yy_c_buf_p = yyg->yy_hold_char; YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; } YY_CURRENT_BUFFER_LVALUE = new_buffer; smt2new_load_buffer_state(yyscanner ); /* We don't actually know whether we did this switch during * EOF (smt2newwrap()) processing, but the only time this flag * is looked at is after smt2newwrap() is called, so it's safe * to go ahead and always set it. */ yyg->yy_did_buffer_switch_on_eof = 1; } static void smt2new_load_buffer_state (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; yyg->yy_hold_char = *yyg->yy_c_buf_p; } /** Allocate and initialize an input buffer state. * @param file A readable stream. * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. * @param yyscanner The scanner object. * @return the allocated buffer state. */ YY_BUFFER_STATE smt2new_create_buffer (FILE * file, int size , yyscan_t yyscanner) { YY_BUFFER_STATE b; b = (YY_BUFFER_STATE) smt2newalloc(sizeof( struct yy_buffer_state ) ,yyscanner ); if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in smt2new_create_buffer()" ); b->yy_buf_size = size; /* yy_ch_buf has to be 2 characters longer than the size given because * we need to put in 2 end-of-buffer characters. */ b->yy_ch_buf = (char *) smt2newalloc(b->yy_buf_size + 2 ,yyscanner ); if ( ! b->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in smt2new_create_buffer()" ); b->yy_is_our_buffer = 1; smt2new_init_buffer(b,file ,yyscanner); return b; } /** Destroy the buffer. * @param b a buffer created with smt2new_create_buffer() * @param yyscanner The scanner object. */ void smt2new_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if ( ! b ) return; if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; if ( b->yy_is_our_buffer ) smt2newfree((void *) b->yy_ch_buf ,yyscanner ); smt2newfree((void *) b ,yyscanner ); } #ifndef __cplusplus extern int isatty (int ); #endif /* __cplusplus */ /* Initializes or reinitializes a buffer. * This function is sometimes called more than once on the same buffer, * such as during a smt2newrestart() or at EOF. */ static void smt2new_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner) { int oerrno = errno; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; smt2new_flush_buffer(b ,yyscanner); b->yy_input_file = file; b->yy_fill_buffer = 1; /* If b is the current buffer, then smt2new_init_buffer was _probably_ * called from smt2newrestart() or through yy_get_next_buffer. * In that case, we don't want to reset the lineno or column. */ if (b != YY_CURRENT_BUFFER){ b->yy_bs_lineno = 1; b->yy_bs_column = 0; } b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; errno = oerrno; } /** Discard all buffered characters. On the next scan, YY_INPUT will be called. * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. * @param yyscanner The scanner object. */ void smt2new_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if ( ! b ) return; b->yy_n_chars = 0; /* We always need two end-of-buffer characters. The first causes * a transition to the end-of-buffer state. The second causes * a jam in that state. */ b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; b->yy_buf_pos = &b->yy_ch_buf[0]; b->yy_at_bol = 1; b->yy_buffer_status = YY_BUFFER_NEW; if ( b == YY_CURRENT_BUFFER ) smt2new_load_buffer_state(yyscanner ); } /** Pushes the new state onto the stack. The new state becomes * the current state. This function will allocate the stack * if necessary. * @param new_buffer The new state. * @param yyscanner The scanner object. */ void smt2newpush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if (new_buffer == NULL) return; smt2newensure_buffer_stack(yyscanner); /* This block is copied from smt2new_switch_to_buffer. */ if ( YY_CURRENT_BUFFER ) { /* Flush out information for old buffer. */ *yyg->yy_c_buf_p = yyg->yy_hold_char; YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; } /* Only push if top exists. Otherwise, replace top. */ if (YY_CURRENT_BUFFER) yyg->yy_buffer_stack_top++; YY_CURRENT_BUFFER_LVALUE = new_buffer; /* copied from smt2new_switch_to_buffer. */ smt2new_load_buffer_state(yyscanner ); yyg->yy_did_buffer_switch_on_eof = 1; } /** Removes and deletes the top of the stack, if present. * The next element becomes the new top. * @param yyscanner The scanner object. */ void smt2newpop_buffer_state (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if (!YY_CURRENT_BUFFER) return; smt2new_delete_buffer(YY_CURRENT_BUFFER ,yyscanner); YY_CURRENT_BUFFER_LVALUE = NULL; if (yyg->yy_buffer_stack_top > 0) --yyg->yy_buffer_stack_top; if (YY_CURRENT_BUFFER) { smt2new_load_buffer_state(yyscanner ); yyg->yy_did_buffer_switch_on_eof = 1; } } /* Allocates the stack if it does not exist. * Guarantees space for at least one push. */ static void smt2newensure_buffer_stack (yyscan_t yyscanner) { yy_size_t num_to_alloc; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if (!yyg->yy_buffer_stack) { /* First allocation is just for 2 elements, since we don't know if this * scanner will even need a stack. We use 2 instead of 1 to avoid an * immediate realloc on the next call. */ num_to_alloc = 1; yyg->yy_buffer_stack = (struct yy_buffer_state**)smt2newalloc (num_to_alloc * sizeof(struct yy_buffer_state*) , yyscanner); if ( ! yyg->yy_buffer_stack ) YY_FATAL_ERROR( "out of dynamic memory in smt2newensure_buffer_stack()" ); memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); yyg->yy_buffer_stack_max = num_to_alloc; yyg->yy_buffer_stack_top = 0; return; } if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ /* Increase the buffer to prepare for a possible push. */ int grow_size = 8 /* arbitrary grow size */; num_to_alloc = yyg->yy_buffer_stack_max + grow_size; yyg->yy_buffer_stack = (struct yy_buffer_state**)smt2newrealloc (yyg->yy_buffer_stack, num_to_alloc * sizeof(struct yy_buffer_state*) , yyscanner); if ( ! yyg->yy_buffer_stack ) YY_FATAL_ERROR( "out of dynamic memory in smt2newensure_buffer_stack()" ); /* zero only the new slots.*/ memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); yyg->yy_buffer_stack_max = num_to_alloc; } } /** Setup the input buffer state to scan directly from a user-specified character buffer. * @param lib the character buffer * @param size the size in bytes of the character buffer * @param yyscanner The scanner object. * @return the newly allocated buffer state object. */ YY_BUFFER_STATE smt2new_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner) { YY_BUFFER_STATE b; if ( size < 2 || base[size-2] != YY_END_OF_BUFFER_CHAR || base[size-1] != YY_END_OF_BUFFER_CHAR ) /* They forgot to leave room for the EOB's. */ return 0; b = (YY_BUFFER_STATE) smt2newalloc(sizeof( struct yy_buffer_state ) ,yyscanner ); if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in smt2new_scan_buffer()" ); b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ b->yy_buf_pos = b->yy_ch_buf = base; b->yy_is_our_buffer = 0; b->yy_input_file = 0; b->yy_n_chars = b->yy_buf_size; b->yy_is_interactive = 0; b->yy_at_bol = 1; b->yy_fill_buffer = 0; b->yy_buffer_status = YY_BUFFER_NEW; smt2new_switch_to_buffer(b ,yyscanner ); return b; } /** Setup the input buffer state to scan a string. The next call to smt2newlex() will * scan from a @e copy of @a str. * @param yystr a NUL-terminated string to scan * @param yyscanner The scanner object. * @return the newly allocated buffer state object. * @note If you want to scan bytes that may contain NUL values, then use * smt2new_scan_bytes() instead. */ YY_BUFFER_STATE smt2new_scan_string (yyconst char * yystr , yyscan_t yyscanner) { return smt2new_scan_bytes(yystr,strlen(yystr) ,yyscanner); } /** Setup the input buffer state to scan the given bytes. The next call to smt2newlex() will * scan from a @e copy of @a bytes. * @param bytes the byte buffer to scan * @param len the number of bytes in the buffer pointed to by @a bytes. * @param yyscanner The scanner object. * @return the newly allocated buffer state object. */ YY_BUFFER_STATE smt2new_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len , yyscan_t yyscanner) { YY_BUFFER_STATE b; char *buf; yy_size_t n, i; /* Get memory for full buffer, including space for trailing EOB's. */ n = _yybytes_len + 2; buf = (char *) smt2newalloc(n ,yyscanner ); if ( ! buf ) YY_FATAL_ERROR( "out of dynamic memory in smt2new_scan_bytes()" ); for ( i = 0; i < _yybytes_len; ++i ) buf[i] = yybytes[i]; buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; b = smt2new_scan_buffer(buf,n ,yyscanner); if ( ! b ) YY_FATAL_ERROR( "bad buffer in smt2new_scan_bytes()" ); /* It's okay to grow etc. this buffer, and we should throw it * away when we're done. */ b->yy_is_our_buffer = 1; return b; } static void yy_push_state (int new_state , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if ( yyg->yy_start_stack_ptr >= yyg->yy_start_stack_depth ) { yy_size_t new_size; yyg->yy_start_stack_depth += YY_START_STACK_INCR; new_size = yyg->yy_start_stack_depth * sizeof( int ); if ( ! yyg->yy_start_stack ) yyg->yy_start_stack = (int *) smt2newalloc(new_size ,yyscanner ); else yyg->yy_start_stack = (int *) smt2newrealloc((void *) yyg->yy_start_stack,new_size ,yyscanner ); if ( ! yyg->yy_start_stack ) YY_FATAL_ERROR( "out of memory expanding start-condition stack" ); } yyg->yy_start_stack[yyg->yy_start_stack_ptr++] = YY_START; BEGIN(new_state); } static void yy_pop_state (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if ( --yyg->yy_start_stack_ptr < 0 ) YY_FATAL_ERROR( "start-condition stack underflow" ); BEGIN(yyg->yy_start_stack[yyg->yy_start_stack_ptr]); } static int yy_top_state (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yyg->yy_start_stack[yyg->yy_start_stack_ptr - 1]; } #ifndef YY_EXIT_FAILURE #define YY_EXIT_FAILURE 2 #endif static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner) { (void) fprintf( stderr, "%s\n", msg ); exit( YY_EXIT_FAILURE ); } /* Redefine yyless() so it works in section 3 code. */ #undef yyless #define yyless(n) \ do \ { \ /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ yytext[yyleng] = yyg->yy_hold_char; \ yyg->yy_c_buf_p = yytext + yyless_macro_arg; \ yyg->yy_hold_char = *yyg->yy_c_buf_p; \ *yyg->yy_c_buf_p = '\0'; \ yyleng = yyless_macro_arg; \ } \ while ( 0 ) /* Accessor methods (get/set functions) to struct members. */ /** Get the user-defined data for this scanner. * @param yyscanner The scanner object. */ YY_EXTRA_TYPE smt2newget_extra (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yyextra; } /** Get the current line number. * @param yyscanner The scanner object. */ int smt2newget_lineno (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if (! YY_CURRENT_BUFFER) return 0; return yylineno; } /** Get the current column number. * @param yyscanner The scanner object. */ int smt2newget_column (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if (! YY_CURRENT_BUFFER) return 0; return yycolumn; } /** Get the input stream. * @param yyscanner The scanner object. */ FILE *smt2newget_in (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yyin; } /** Get the output stream. * @param yyscanner The scanner object. */ FILE *smt2newget_out (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yyout; } /** Get the length of the current token. * @param yyscanner The scanner object. */ yy_size_t smt2newget_leng (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yyleng; } /** Get the current token. * @param yyscanner The scanner object. */ char *smt2newget_text (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yytext; } /** Set the user-defined data. This data is never touched by the scanner. * @param user_defined The data to be associated with this scanner. * @param yyscanner The scanner object. */ void smt2newset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yyextra = user_defined ; } /** Set the current line number. * @param line_number * @param yyscanner The scanner object. */ void smt2newset_lineno (int line_number , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* lineno is only valid if an input buffer exists. */ if (! YY_CURRENT_BUFFER ) yy_fatal_error( "smt2newset_lineno called with no buffer" , yyscanner); yylineno = line_number; } /** Set the current column. * @param line_number * @param yyscanner The scanner object. */ void smt2newset_column (int column_no , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* column is only valid if an input buffer exists. */ if (! YY_CURRENT_BUFFER ) yy_fatal_error( "smt2newset_column called with no buffer" , yyscanner); yycolumn = column_no; } /** Set the input stream. This does not discard the current * input buffer. * @param in_str A readable stream. * @param yyscanner The scanner object. * @see smt2new_switch_to_buffer */ void smt2newset_in (FILE * in_str , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yyin = in_str ; } void smt2newset_out (FILE * out_str , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yyout = out_str ; } int smt2newget_debug (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yy_flex_debug; } void smt2newset_debug (int bdebug , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yy_flex_debug = bdebug ; } /* Accessor methods for yylval and yylloc */ YYSTYPE * smt2newget_lval (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yylval; } void smt2newset_lval (YYSTYPE * yylval_param , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yylval = yylval_param; } YYLTYPE *smt2newget_lloc (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yylloc; } void smt2newset_lloc (YYLTYPE * yylloc_param , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yylloc = yylloc_param; } /* User-visible API */ /* smt2newlex_init is special because it creates the scanner itself, so it is * the ONLY reentrant function that doesn't take the scanner as the last argument. * That's why we explicitly handle the declaration, instead of using our macros. */ int smt2newlex_init(yyscan_t* ptr_yy_globals) { if (ptr_yy_globals == NULL){ errno = EINVAL; return 1; } *ptr_yy_globals = (yyscan_t) smt2newalloc ( sizeof( struct yyguts_t ), NULL ); if (*ptr_yy_globals == NULL){ errno = ENOMEM; return 1; } /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); return yy_init_globals ( *ptr_yy_globals ); } /* smt2newlex_init_extra has the same functionality as smt2newlex_init, but follows the * convention of taking the scanner as the last argument. Note however, that * this is a *pointer* to a scanner, as it will be allocated by this call (and * is the reason, too, why this function also must handle its own declaration). * The user defined value in the first argument will be available to smt2newalloc in * the yyextra field. */ int smt2newlex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals ) { struct yyguts_t dummy_yyguts; smt2newset_extra (yy_user_defined, &dummy_yyguts); if (ptr_yy_globals == NULL){ errno = EINVAL; return 1; } *ptr_yy_globals = (yyscan_t) smt2newalloc ( sizeof( struct yyguts_t ), &dummy_yyguts ); if (*ptr_yy_globals == NULL){ errno = ENOMEM; return 1; } /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); smt2newset_extra (yy_user_defined, *ptr_yy_globals); return yy_init_globals ( *ptr_yy_globals ); } static int yy_init_globals (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* Initialization is the same as for the non-reentrant scanner. * This function is called from smt2newlex_destroy(), so don't allocate here. */ yyg->yy_buffer_stack = 0; yyg->yy_buffer_stack_top = 0; yyg->yy_buffer_stack_max = 0; yyg->yy_c_buf_p = (char *) 0; yyg->yy_init = 0; yyg->yy_start = 0; yyg->yy_start_stack_ptr = 0; yyg->yy_start_stack_depth = 0; yyg->yy_start_stack = NULL; /* Defined in main.c */ #ifdef YY_STDINIT yyin = stdin; yyout = stdout; #else yyin = (FILE *) 0; yyout = (FILE *) 0; #endif /* For future reference: Set errno on error, since we are called by * smt2newlex_init() */ return 0; } /* smt2newlex_destroy is for both reentrant and non-reentrant scanners. */ int smt2newlex_destroy (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* Pop the buffer stack, destroying each element. */ while(YY_CURRENT_BUFFER){ smt2new_delete_buffer(YY_CURRENT_BUFFER ,yyscanner ); YY_CURRENT_BUFFER_LVALUE = NULL; smt2newpop_buffer_state(yyscanner); } /* Destroy the stack itself. */ smt2newfree(yyg->yy_buffer_stack ,yyscanner); yyg->yy_buffer_stack = NULL; /* Destroy the start condition stack. */ smt2newfree(yyg->yy_start_stack ,yyscanner ); yyg->yy_start_stack = NULL; /* Reset the globals. This is important in a non-reentrant scanner so the next time * smt2newlex() is called, initialization will occur. */ yy_init_globals( yyscanner); /* Destroy the main struct (reentrant only). */ smt2newfree ( yyscanner , yyscanner ); yyscanner = NULL; return 0; } /* * Internal utility routines. */ #ifndef yytext_ptr static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner) { register int i; for ( i = 0; i < n; ++i ) s1[i] = s2[i]; } #endif #ifdef YY_NEED_STRLEN static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner) { register int n; for ( n = 0; s[n]; ++n ) ; return n; } #endif void *smt2newalloc (yy_size_t size , yyscan_t yyscanner) { return (void *) malloc( size ); } void *smt2newrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner) { /* The cast to (char *) in the following accommodates both * implementations that use char* generic pointers, and those * that use void* generic pointers. It works with the latter * because both ANSI C and C++ allow castless assignment from * any pointer type to void*, and deal with argument conversions * as though doing an assignment. */ return (void *) realloc( (char *) ptr, size ); } void smt2newfree (void * ptr , yyscan_t yyscanner) { free( (char *) ptr ); /* see smt2newrealloc() for (char *) cast */ } #define YYTABLES_NAME "yytables" #line 143 "smt2newlexer.ll" void Smt2newContext::init_scanner() { smt2newlex_init_extra(this,&scanner); smt2newset_in(is,scanner); } void Smt2newContext::destroy_scanner() { smt2newlex_destroy(scanner); } opensmt-2.5.2/test/smt2newlexer.ll000066400000000000000000000240641445011647600171720ustar00rootroot00000000000000%option prefix="smt2new" %option reentrant %option bison-bridge %option bison-locations %option noyywrap %option yylineno %option stack %{ #include #include #include #include #include "smt2newcontext.h" #include "smt2newparser.h" #define YY_EXTRA_TYPE Smt2newContext* #define YY_USER_ACTION yyget_lloc(yyscanner)->first_line = yyget_lineno(yyscanner); /* #define YY_INPUT(buf,result,max_size) \ { \ char c; \ (yyextra->is) >> c; \ if (yyextra->is.eof()) \ result = YY_NULL; \ else { \ buf[0] = c; \ result = 1; \ } \ } */ %} %x STR %x PSYM %% ";".*\n // Eat comments [ \t\n]+ // Eat spaces "!" { return *yyget_text(yyscanner); } "_" { return *yyget_text(yyscanner); } "as" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_AS; } "DECIMAL" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_DECIMAL; } "exists" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_EXISTS; } "forall" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_FORALL; } "let" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_LET; } "NUMERAL" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_NUMERAL; } "par" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_PAR; } "STRING" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_STRING; } "assert" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_ASSERT; } "check-sat" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_CHECKSAT; } "declare-sort" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_DECLARESORT; } "declare-fun" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_DECLAREFUN; } "define-sort" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_DEFINESORT; } "define-fun" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_DEFINEFUN; } "exit" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_EXIT; } "get-assertions" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_GETASSERTIONS; } "get-assignment" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_GETASSIGNMENT; } "get-info" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_GETINFO; } "get-option" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_GETOPTION; } "get-proof" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_GETPROOF; } "get-unsat-core" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_GETUNSATCORE; } "get-value" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_GETVALUE; } "pop" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_POP; } "push" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_PUSH; } "set-logic" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_SETLOGIC; } "set-info" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_SETINFO; } "set-option" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_SETOPTION; } "theory" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_THEORY; } ":sorts" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_SORTS; } ":funs" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_FUNS; } ":sorts-description" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_SORTSDESCRIPTION; } ":funs-description" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_FUNSDESCRIPTION; } ":definition" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_DEFINITION; } ":values" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_VALUES; } ":notes" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_NOTES; } ":theories" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_THEORIES; } ":language" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_LANGUAGE; } ":extensions" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_EXTENSIONS; } ":print-success" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_PRINTSUCCESS; } ":expand-definitions" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_EXPANDDEFINITIONS; } ":interactive-mode" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_INTERACTIVEMODE; } ":produce-proofs" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_PRODUCEPROOFS; } ":produce-unsat-cores" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_PRODUCEUNSATCORES; } ":produce-models" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_PRODUCEMODELS; } ":produce-assignments" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_PRODUCEASSIGNMENTS; } ":regular-output-channel" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_REGULAROUTPUTCHANNEL; } ":diagnostic-output-channel" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_DIAGNOSTICOUTPUTCHANNEL; } ":random-seed" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_RANDOMSEED; } ":verbosity" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_VERBOSITY; } ":error-behavior" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_ERRORBEHAVIOR; } ":name" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_NAME; } ":authors" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_AUTHORS; } ":version" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_VERSION; } ":status" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_STATUS; } ":reason-unknown" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_REASONUNKNOWN; } ":all-statistics" { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return KW_ALLSTATISTICS; } 0|[1-9][0-9]* { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_NUM; } [0-9]+\.0*[0-9]+ { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_DEC; } #x[0-9a-fA-F]+ { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_HEX; } #b[01]+ { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_BIN; } [a-zA-Z~!@\$\%\^&\*\-\+=\<\>\.\?\/'_][a-zA-Z0-9~!@\$\%\^&\*_\-\+=\<\>\.\?\/']* { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_SYM; } \:[a-zA-Z0-9~!@\$\%\^&\*_\-\+=\<\>\.\?\/]+ { yyget_lval(yyscanner)->str = strdup( yyget_text(yyscanner) ); return TK_KEY; } [()] { return *yyget_text(yyscanner); } \" { yy_push_state(STR, yyscanner); } { [ ] { yyextra->insertBuf(' '); } [\t] { yyextra->insertBuf('\t'); } \n { yyextra->insertBuf('\n'); } \\\" { yyextra->insertBuf('"'); } \\\\ { yyextra->insertBuf('\\'); } [^\\\n\"] { yyextra->insertBuf(yyget_text(yyscanner)[0]); } \" { yylval->str = strdup(yyextra->getBuf()); yyextra->clearBuf(); yy_pop_state(yyscanner); return TK_STR; } } \| { yy_push_state(PSYM, yyscanner); } { [ ] { yyextra->insertBuf(' '); } [\t] { yyextra->insertBuf('\t'); } \n { yyextra->insertBuf('\n'); } [^ \t\n\\\|] { yyextra->insertBuf(yyget_text(yyscanner)[0]); } \| { yylval->str = strdup(yyextra->getBuf()); yyextra->clearBuf(); yy_pop_state(yyscanner); return TK_SYM; } \\ { printf("Syntax error at line %d near %s, \\ not allowed inside | ... |\n", yyget_lineno(yyscanner), yyget_text(yyscanner)); exit(1); } } . { printf( "Syntax error at line %d near %s\n", yyget_lineno(yyscanner), yyget_text(yyscanner) ); exit( 1 ); } %% void Smt2newContext::init_scanner() { yylex_init_extra(this, &scanner); yyset_in(is, scanner); } void Smt2newContext::destroy_scanner() { yylex_destroy(scanner); } opensmt-2.5.2/test/smt2newparser.cc000066400000000000000000002531011445011647600173210ustar00rootroot00000000000000/* A Bison parser, made by GNU Bison 2.3. */ /* Skeleton implementation for Bison's Yacc-like parsers in C Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ /* As a special exception, you may create a larger work that contains part or all of the Bison parser skeleton and distribute that work under terms of your choice, so long as that work isn't itself a parser generator using the skeleton or a modified version thereof as a parser skeleton. Alternatively, if you modify or redistribute the parser skeleton itself, you may (at your option) remove this special exception, which will cause the skeleton and the resulting Bison output files to be licensed under the GNU General Public License without this special exception. This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ /* C LALR(1) parser skeleton written by Richard Stallman, by simplifying the original so-called "semantic" parser. */ /* All symbols defined below should begin with yy or YY, to avoid infringing on user name space. This should be done even for local variables, as they might otherwise be expanded by user macros. There are some unavoidable exceptions within include files to define necessary library symbols; they are noted "INFRINGES ON USER NAME SPACE" below. */ /* Identify Bison output. */ #define YYBISON 1 /* Bison version. */ #define YYBISON_VERSION "2.3" /* Skeleton name. */ #define YYSKELETON_NAME "yacc.c" /* Pure parsers. */ #define YYPURE 1 /* Using locations. */ #define YYLSP_NEEDED 1 /* Substitute the variable and function names. */ #define yyparse smt2newparse #define yylex smt2newlex #define yyerror smt2newerror #define yylval smt2newlval #define yychar smt2newchar #define yydebug smt2newdebug #define yynerrs smt2newnerrs #define yylloc smt2newlloc /* Tokens. */ #ifndef YYTOKENTYPE # define YYTOKENTYPE /* Put the tokens into the symbol table, so that GDB and other debuggers know about them. */ enum yytokentype { TK_AS = 258, TK_DECIMAL = 259, TK_EXISTS = 260, TK_FORALL = 261, TK_LET = 262, TK_NUMERAL = 263, TK_PAR = 264, TK_STRING = 265, TK_ASSERT = 266, TK_CHECKSAT = 267, TK_DECLARESORT = 268, TK_DECLAREFUN = 269, TK_DEFINESORT = 270, TK_DEFINEFUN = 271, TK_EXIT = 272, TK_GETASSERTIONS = 273, TK_GETASSIGNMENT = 274, TK_GETINFO = 275, TK_GETOPTION = 276, TK_GETPROOF = 277, TK_GETUNSATCORE = 278, TK_GETVALUE = 279, TK_POP = 280, TK_PUSH = 281, TK_SETLOGIC = 282, TK_SETINFO = 283, TK_SETOPTION = 284, TK_THEORY = 285, TK_NUM = 286, TK_SYM = 287, TK_KEY = 288, TK_STR = 289, TK_DEC = 290, TK_HEX = 291, TK_BIN = 292, KW_SORTS = 293, KW_FUNS = 294, KW_SORTSDESCRIPTION = 295, KW_FUNSDESCRIPTION = 296, KW_DEFINITION = 297, KW_NOTES = 298, KW_THEORIES = 299, KW_LANGUAGE = 300, KW_EXTENSIONS = 301, KW_VALUES = 302, KW_PRINTSUCCESS = 303, KW_EXPANDDEFINITIONS = 304, KW_INTERACTIVEMODE = 305, KW_PRODUCEPROOFS = 306, KW_PRODUCEUNSATCORES = 307, KW_PRODUCEMODELS = 308, KW_PRODUCEASSIGNMENTS = 309, KW_REGULAROUTPUTCHANNEL = 310, KW_DIAGNOSTICOUTPUTCHANNEL = 311, KW_RANDOMSEED = 312, KW_VERBOSITY = 313, KW_ERRORBEHAVIOR = 314, KW_NAME = 315, KW_AUTHORS = 316, KW_VERSION = 317, KW_STATUS = 318, KW_REASONUNKNOWN = 319, KW_ALLSTATISTICS = 320 }; #endif /* Tokens. */ #define TK_AS 258 #define TK_DECIMAL 259 #define TK_EXISTS 260 #define TK_FORALL 261 #define TK_LET 262 #define TK_NUMERAL 263 #define TK_PAR 264 #define TK_STRING 265 #define TK_ASSERT 266 #define TK_CHECKSAT 267 #define TK_DECLARESORT 268 #define TK_DECLAREFUN 269 #define TK_DEFINESORT 270 #define TK_DEFINEFUN 271 #define TK_EXIT 272 #define TK_GETASSERTIONS 273 #define TK_GETASSIGNMENT 274 #define TK_GETINFO 275 #define TK_GETOPTION 276 #define TK_GETPROOF 277 #define TK_GETUNSATCORE 278 #define TK_GETVALUE 279 #define TK_POP 280 #define TK_PUSH 281 #define TK_SETLOGIC 282 #define TK_SETINFO 283 #define TK_SETOPTION 284 #define TK_THEORY 285 #define TK_NUM 286 #define TK_SYM 287 #define TK_KEY 288 #define TK_STR 289 #define TK_DEC 290 #define TK_HEX 291 #define TK_BIN 292 #define KW_SORTS 293 #define KW_FUNS 294 #define KW_SORTSDESCRIPTION 295 #define KW_FUNSDESCRIPTION 296 #define KW_DEFINITION 297 #define KW_NOTES 298 #define KW_THEORIES 299 #define KW_LANGUAGE 300 #define KW_EXTENSIONS 301 #define KW_VALUES 302 #define KW_PRINTSUCCESS 303 #define KW_EXPANDDEFINITIONS 304 #define KW_INTERACTIVEMODE 305 #define KW_PRODUCEPROOFS 306 #define KW_PRODUCEUNSATCORES 307 #define KW_PRODUCEMODELS 308 #define KW_PRODUCEASSIGNMENTS 309 #define KW_REGULAROUTPUTCHANNEL 310 #define KW_DIAGNOSTICOUTPUTCHANNEL 311 #define KW_RANDOMSEED 312 #define KW_VERBOSITY 313 #define KW_ERRORBEHAVIOR 314 #define KW_NAME 315 #define KW_AUTHORS 316 #define KW_VERSION 317 #define KW_STATUS 318 #define KW_REASONUNKNOWN 319 #define KW_ALLSTATISTICS 320 /* Copy the first part of user declarations. */ #line 9 "smt2newparser.yy" #include #include #include #include #include #include #include #include "smt2newcontext.h" #include "smt2newparser.h" int smt2newlex(YYSTYPE* lvalp, YYLTYPE* llocp, void* scanner); void smt2newerror( YYLTYPE* locp, Smt2newContext* context, const char * s ) { printf( "At line %d: %s\n", locp->first_line, s ); exit( 1 ); } #define scanner context->scanner /* Overallocation to prevent stack overflow */ #define YYMAXDEPTH 1024 * 1024 /* Enabling traces. */ #ifndef YYDEBUG # define YYDEBUG 0 #endif /* Enabling verbose error messages. */ #ifdef YYERROR_VERBOSE # undef YYERROR_VERBOSE # define YYERROR_VERBOSE 1 #else # define YYERROR_VERBOSE 1 #endif /* Enabling the token table. */ #ifndef YYTOKEN_TABLE # define YYTOKEN_TABLE 0 #endif #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED typedef union YYSTYPE #line 37 "smt2newparser.yy" { char * str; vector< string > * str_list; ASTNode * snode; list< ASTNode * > * snode_list; } /* Line 193 of yacc.c. */ #line 268 "smt2newparser.cc" YYSTYPE; # define yystype YYSTYPE /* obsolescent; will be withdrawn */ # define YYSTYPE_IS_DECLARED 1 # define YYSTYPE_IS_TRIVIAL 1 #endif #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED typedef struct YYLTYPE { int first_line; int first_column; int last_line; int last_column; } YYLTYPE; # define yyltype YYLTYPE /* obsolescent; will be withdrawn */ # define YYLTYPE_IS_DECLARED 1 # define YYLTYPE_IS_TRIVIAL 1 #endif /* Copy the second part of user declarations. */ /* Line 216 of yacc.c. */ #line 293 "smt2newparser.cc" #ifdef short # undef short #endif #ifdef YYTYPE_UINT8 typedef YYTYPE_UINT8 yytype_uint8; #else typedef unsigned char yytype_uint8; #endif #ifdef YYTYPE_INT8 typedef YYTYPE_INT8 yytype_int8; #elif (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) typedef signed char yytype_int8; #else typedef short int yytype_int8; #endif #ifdef YYTYPE_UINT16 typedef YYTYPE_UINT16 yytype_uint16; #else typedef unsigned short int yytype_uint16; #endif #ifdef YYTYPE_INT16 typedef YYTYPE_INT16 yytype_int16; #else typedef short int yytype_int16; #endif #ifndef YYSIZE_T # ifdef __SIZE_TYPE__ # define YYSIZE_T __SIZE_TYPE__ # elif defined size_t # define YYSIZE_T size_t # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) # include /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T size_t # else # define YYSIZE_T unsigned int # endif #endif #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) #ifndef YY_ # if defined YYENABLE_NLS && YYENABLE_NLS # if ENABLE_NLS # include /* INFRINGES ON USER NAME SPACE */ # define YY_(msgid) dgettext ("bison-runtime", msgid) # endif # endif # ifndef YY_ # define YY_(msgid) msgid # endif #endif /* Suppress unused-variable warnings by "using" E. */ #if ! defined lint || defined __GNUC__ # define YYUSE(e) ((void) (e)) #else # define YYUSE(e) /* empty */ #endif /* Identity function, used to suppress warnings about constant conditions. */ #ifndef lint # define YYID(n) (n) #else #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) static int YYID (int i) #else static int YYID (i) int i; #endif { return i; } #endif #if ! defined yyoverflow || YYERROR_VERBOSE /* The parser invokes alloca or malloc; define the necessary symbols. */ # ifdef YYSTACK_USE_ALLOCA # if YYSTACK_USE_ALLOCA # ifdef __GNUC__ # define YYSTACK_ALLOC __builtin_alloca # elif defined __BUILTIN_VA_ARG_INCR # include /* INFRINGES ON USER NAME SPACE */ # elif defined _AIX # define YYSTACK_ALLOC __alloca # elif defined _MSC_VER # include /* INFRINGES ON USER NAME SPACE */ # define alloca _alloca # else # define YYSTACK_ALLOC alloca # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) # include /* INFRINGES ON USER NAME SPACE */ # ifndef _STDLIB_H # define _STDLIB_H 1 # endif # endif # endif # endif # endif # ifdef YYSTACK_ALLOC /* Pacify GCC's `empty if-body' warning. */ # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) # ifndef YYSTACK_ALLOC_MAXIMUM /* The OS might guarantee only one guard page at the bottom of the stack, and a page size can be as small as 4096 bytes. So we cannot safely invoke alloca (N) if N exceeds 4096. Use a slightly smaller number to allow for a few compiler-allocated temporary stack slots. */ # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ # endif # else # define YYSTACK_ALLOC YYMALLOC # define YYSTACK_FREE YYFREE # ifndef YYSTACK_ALLOC_MAXIMUM # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM # endif # if (defined __cplusplus && ! defined _STDLIB_H \ && ! ((defined YYMALLOC || defined malloc) \ && (defined YYFREE || defined free))) # include /* INFRINGES ON USER NAME SPACE */ # ifndef _STDLIB_H # define _STDLIB_H 1 # endif # endif # ifndef YYMALLOC # define YYMALLOC malloc # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ # endif # endif # ifndef YYFREE # define YYFREE free # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) void free (void *); /* INFRINGES ON USER NAME SPACE */ # endif # endif # endif #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ #if (! defined yyoverflow \ && (! defined __cplusplus \ || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \ && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) /* A type that is properly aligned for any stack member. */ union yyalloc { yytype_int16 yyss; YYSTYPE yyvs; YYLTYPE yyls; }; /* The size of the maximum gap between one aligned stack and the next. */ # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) /* The size of an array large to enough to hold all stacks, each with N elements. */ # define YYSTACK_BYTES(N) \ ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ + 2 * YYSTACK_GAP_MAXIMUM) /* Copy COUNT objects from FROM to TO. The source and destination do not overlap. */ # ifndef YYCOPY # if defined __GNUC__ && 1 < __GNUC__ # define YYCOPY(To, From, Count) \ __builtin_memcpy (To, From, (Count) * sizeof (*(From))) # else # define YYCOPY(To, From, Count) \ do \ { \ YYSIZE_T yyi; \ for (yyi = 0; yyi < (Count); yyi++) \ (To)[yyi] = (From)[yyi]; \ } \ while (YYID (0)) # endif # endif /* Relocate STACK from its old location to the new one. The local variables YYSIZE and YYSTACKSIZE give the old and new number of elements in the stack, and YYPTR gives the new location of the stack. Advance YYPTR to a properly aligned location for the next stack. */ # define YYSTACK_RELOCATE(Stack) \ do \ { \ YYSIZE_T yynewbytes; \ YYCOPY (&yyptr->Stack, Stack, yysize); \ Stack = &yyptr->Stack; \ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ yyptr += yynewbytes / sizeof (*yyptr); \ } \ while (YYID (0)) #endif /* YYFINAL -- State number of the termination state. */ #define YYFINAL 3 /* YYLAST -- Last index in YYTABLE. */ #define YYLAST 313 /* YYNTOKENS -- Number of terminals. */ #define YYNTOKENS 70 /* YYNNTS -- Number of nonterminals. */ #define YYNNTS 26 /* YYNRULES -- Number of rules. */ #define YYNRULES 120 /* YYNRULES -- Number of states. */ #define YYNSTATES 223 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ #define YYUNDEFTOK 2 #define YYMAXUTOK 320 #define YYTRANSLATE(YYX) \ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ static const yytype_uint8 yytranslate[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 69, 2, 2, 2, 2, 2, 2, 66, 67, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 68, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65 }; #if YYDEBUG /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in YYRHS. */ static const yytype_uint16 yyprhs[] = { 0, 0, 3, 5, 6, 9, 14, 19, 24, 30, 39, 48, 58, 63, 68, 73, 77, 81, 85, 89, 97, 101, 106, 111, 116, 120, 121, 124, 126, 129, 131, 134, 136, 138, 142, 144, 150, 152, 158, 161, 162, 164, 166, 168, 172, 173, 176, 178, 180, 182, 184, 186, 189, 191, 193, 199, 200, 203, 208, 209, 212, 217, 218, 221, 223, 225, 231, 240, 249, 258, 263, 264, 267, 269, 272, 275, 278, 281, 284, 287, 290, 293, 296, 299, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374 }; /* YYRHS -- A `-1'-separated list of the rules' RHS. */ static const yytype_int8 yyrhs[] = { 71, 0, -1, 72, -1, -1, 72, 73, -1, 66, 27, 32, 67, -1, 66, 29, 93, 67, -1, 66, 28, 75, 67, -1, 66, 13, 32, 31, 67, -1, 66, 15, 32, 66, 91, 67, 78, 67, -1, 66, 14, 32, 66, 79, 67, 78, 67, -1, 66, 16, 32, 66, 87, 67, 78, 90, 67, -1, 66, 26, 31, 67, -1, 66, 25, 31, 67, -1, 66, 11, 90, 67, -1, 66, 12, 67, -1, 66, 18, 67, -1, 66, 22, 67, -1, 66, 23, 67, -1, 66, 24, 66, 90, 89, 67, 67, -1, 66, 19, 67, -1, 66, 21, 33, 67, -1, 66, 21, 94, 67, -1, 66, 20, 95, 67, -1, 66, 17, 67, -1, -1, 74, 75, -1, 33, -1, 33, 76, -1, 94, -1, 94, 76, -1, 82, -1, 32, -1, 66, 81, 67, -1, 32, -1, 66, 68, 32, 83, 67, -1, 77, -1, 66, 77, 78, 79, 67, -1, 79, 78, -1, -1, 82, -1, 32, -1, 33, -1, 66, 81, 67, -1, -1, 81, 80, -1, 31, -1, 35, -1, 36, -1, 37, -1, 34, -1, 83, 31, -1, 31, -1, 77, -1, 66, 3, 77, 78, 67, -1, -1, 85, 86, -1, 66, 32, 90, 67, -1, -1, 87, 88, -1, 66, 32, 78, 67, -1, -1, 89, 90, -1, 82, -1, 84, -1, 66, 84, 90, 89, 67, -1, 66, 7, 66, 86, 85, 67, 90, 67, -1, 66, 6, 66, 88, 87, 67, 90, 67, -1, 66, 5, 66, 88, 87, 67, 90, 67, -1, 69, 90, 75, 74, -1, -1, 91, 32, -1, 32, -1, 48, 92, -1, 49, 92, -1, 50, 92, -1, 51, 92, -1, 52, 92, -1, 53, 92, -1, 54, 92, -1, 55, 34, -1, 56, 34, -1, 57, 31, -1, 58, 31, -1, 75, -1, 38, -1, 39, -1, 40, -1, 41, -1, 42, -1, 47, -1, 43, -1, 44, -1, 45, -1, 46, -1, 48, -1, 49, -1, 50, -1, 51, -1, 52, -1, 53, -1, 54, -1, 55, -1, 56, -1, 57, -1, 58, -1, 59, -1, 60, -1, 61, -1, 62, -1, 63, -1, 64, -1, 65, -1, 59, -1, 60, -1, 61, -1, 62, -1, 63, -1, 64, -1, 65, -1, 33, -1 }; /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ static const yytype_uint16 yyrline[] = { 0, 66, 66, 70, 71, 75, 81, 87, 93, 100, 113, 125, 138, 144, 150, 156, 160, 164, 168, 172, 178, 182, 188, 194, 200, 205, 206, 210, 212, 214, 216, 220, 222, 226, 233, 235, 239, 241, 249, 252, 255, 261, 265, 269, 277, 280, 287, 289, 291, 293, 295, 299, 301, 305, 307, 317, 318, 322, 327, 328, 332, 336, 337, 341, 343, 345, 351, 361, 371, 381, 456, 457, 614, 627, 633, 639, 645, 651, 657, 663, 669, 675, 681, 687, 693, 701, 703, 705, 707, 709, 711, 713, 715, 717, 719, 721, 723, 725, 727, 729, 731, 733, 735, 737, 739, 741, 743, 745, 747, 749, 751, 753, 755, 759, 761, 763, 765, 767, 769, 771, 773 }; #endif #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. First, the terminals, then, starting at YYNTOKENS, nonterminals. */ static const char *const yytname[] = { "$end", "error", "$undefined", "TK_AS", "TK_DECIMAL", "TK_EXISTS", "TK_FORALL", "TK_LET", "TK_NUMERAL", "TK_PAR", "TK_STRING", "TK_ASSERT", "TK_CHECKSAT", "TK_DECLARESORT", "TK_DECLAREFUN", "TK_DEFINESORT", "TK_DEFINEFUN", "TK_EXIT", "TK_GETASSERTIONS", "TK_GETASSIGNMENT", "TK_GETINFO", "TK_GETOPTION", "TK_GETPROOF", "TK_GETUNSATCORE", "TK_GETVALUE", "TK_POP", "TK_PUSH", "TK_SETLOGIC", "TK_SETINFO", "TK_SETOPTION", "TK_THEORY", "TK_NUM", "TK_SYM", "TK_KEY", "TK_STR", "TK_DEC", "TK_HEX", "TK_BIN", "KW_SORTS", "KW_FUNS", "KW_SORTSDESCRIPTION", "KW_FUNSDESCRIPTION", "KW_DEFINITION", "KW_NOTES", "KW_THEORIES", "KW_LANGUAGE", "KW_EXTENSIONS", "KW_VALUES", "KW_PRINTSUCCESS", "KW_EXPANDDEFINITIONS", "KW_INTERACTIVEMODE", "KW_PRODUCEPROOFS", "KW_PRODUCEUNSATCORES", "KW_PRODUCEMODELS", "KW_PRODUCEASSIGNMENTS", "KW_REGULAROUTPUTCHANNEL", "KW_DIAGNOSTICOUTPUTCHANNEL", "KW_RANDOMSEED", "KW_VERBOSITY", "KW_ERRORBEHAVIOR", "KW_NAME", "KW_AUTHORS", "KW_VERSION", "KW_STATUS", "KW_REASONUNKNOWN", "KW_ALLSTATISTICS", "'('", "')'", "'_'", "'!'", "$accept", "script", "command_list", "command", "attribute_list", "attribute", "attribute_value", "identifier", "sort", "sort_list", "s_expr", "s_expr_list", "spec_const", "numeral_list", "qual_identifier", "var_binding_list", "var_binding", "sorted_var_list", "sorted_var", "term_list", "term", "symbol_list", "b_value", "option", "predef_key", "info_flag", 0 }; #endif # ifdef YYPRINT /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to token YYLEX-NUM. */ static const yytype_uint16 yytoknum[] = { 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 40, 41, 95, 33 }; # endif /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ static const yytype_uint8 yyr1[] = { 0, 70, 71, 72, 72, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 74, 74, 75, 75, 75, 75, 76, 76, 76, 77, 77, 78, 78, 79, 79, 80, 80, 80, 80, 81, 81, 82, 82, 82, 82, 82, 83, 83, 84, 84, 85, 85, 86, 87, 87, 88, 89, 89, 90, 90, 90, 90, 90, 90, 90, 91, 91, 92, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 95, 95, 95, 95, 95, 95, 95, 95 }; /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ static const yytype_uint8 yyr2[] = { 0, 2, 1, 0, 2, 4, 4, 4, 5, 8, 8, 9, 4, 4, 4, 3, 3, 3, 3, 7, 3, 4, 4, 4, 3, 0, 2, 1, 2, 1, 2, 1, 1, 3, 1, 5, 1, 5, 2, 0, 1, 1, 1, 3, 0, 2, 1, 1, 1, 1, 1, 2, 1, 1, 5, 0, 2, 4, 0, 2, 4, 0, 2, 1, 1, 5, 8, 8, 8, 4, 0, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state STATE-NUM when YYTABLE doesn't specify something else to do. Zero means the default is an error. */ static const yytype_uint8 yydefact[] = { 3, 0, 2, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, 34, 50, 47, 48, 49, 0, 0, 53, 63, 64, 0, 15, 0, 0, 0, 0, 24, 16, 20, 120, 113, 114, 115, 116, 117, 118, 119, 0, 0, 85, 86, 87, 88, 89, 91, 92, 93, 94, 90, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 0, 17, 18, 0, 0, 0, 0, 27, 0, 29, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 39, 70, 58, 23, 21, 22, 61, 13, 12, 5, 32, 44, 28, 31, 7, 30, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 6, 0, 0, 0, 0, 0, 0, 61, 25, 8, 0, 0, 0, 0, 0, 0, 36, 0, 0, 58, 58, 0, 55, 52, 0, 0, 69, 0, 38, 71, 0, 0, 59, 0, 62, 41, 42, 44, 33, 45, 40, 0, 54, 0, 0, 0, 0, 0, 51, 35, 65, 26, 0, 0, 0, 19, 0, 39, 0, 0, 0, 0, 0, 56, 10, 9, 0, 43, 0, 60, 0, 0, 57, 0, 11, 37, 68, 67, 66 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { -1, 1, 2, 5, 170, 91, 128, 33, 172, 154, 183, 158, 34, 168, 35, 191, 166, 156, 176, 157, 178, 155, 133, 105, 92, 53 }; /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ #define YYPACT_NINF -142 static const yytype_int16 yypact[] = { -142, 8, -50, -142, 284, -142, 65, -43, -3, 0, 13, 16, 2, 14, 20, 109, 163, 21, 22, -2, 36, 52, 59, 196, 229, -142, -142, -142, -142, -142, -142, 7, 65, -142, -142, -142, 27, -142, 67, 37, 38, 39, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, 40, 41, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, 43, -142, -142, 65, 44, 60, 61, 101, 62, 101, 98, 98, 98, 98, 98, 98, 98, 105, 106, 110, 112, -142, 77, -25, 79, 80, 84, 6, 119, 65, 196, -142, 85, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, 86, -7, 87, 87, 97, 133, -142, -142, -142, -17, -13, -39, -14, 82, -26, -142, 99, 143, -142, -142, 144, -142, -142, -20, 26, 196, -7, -142, -142, -7, -7, -142, 111, -142, -142, -142, -142, -142, -142, -142, -7, -142, -7, -31, -29, 65, 10, -142, -142, -142, -142, 113, 114, 65, -142, 89, -142, 115, 65, 65, 116, 65, -142, -142, -142, 118, -142, -1, -142, 120, 121, -142, 122, -142, -142, -142, -142, -142 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { -142, -142, -142, -142, -142, -23, 73, -103, -141, -24, -142, 5, -88, -142, 148, -142, 3, -85, -62, 42, -6, -142, 63, -142, 174, -142 }; /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If positive, shift that token. If negative, reduce the rule which number is the opposite. If zero, do what YYDEFACT says. If YYTABLE_NINF, syntax error. */ #define YYTABLE_NINF -1 static const yytype_uint8 yytable[] = { 36, 104, 129, 146, 129, 161, 26, 26, 3, 106, 106, 192, 107, 108, 109, 26, 4, 25, 26, 173, 27, 28, 29, 30, 37, 26, 113, 162, 175, 38, 196, 26, 39, 197, 198, 162, 203, 162, 204, 26, 145, 145, 111, 160, 201, 40, 202, 193, 41, 159, 171, 160, 31, 177, 174, 32, 185, 25, 26, 159, 27, 28, 29, 30, 86, 159, 219, 87, 160, 42, 184, 160, 160, 110, 111, 111, 165, 206, 188, 189, 122, 43, 160, 88, 160, 163, 164, 44, 84, 85, 152, 89, 31, 194, 114, 32, 25, 26, 115, 27, 28, 29, 30, 116, 117, 118, 151, 119, 120, 160, 121, 123, 184, 25, 179, 180, 27, 28, 29, 30, 25, 179, 180, 27, 28, 29, 30, 124, 125, 130, 132, 31, 25, 126, 32, 27, 28, 29, 30, 140, 141, 142, 45, 143, 144, 147, 148, 195, 181, 182, 149, 150, 153, 162, 111, 181, 211, 134, 135, 136, 137, 138, 139, 165, 167, 131, 186, 127, 46, 47, 48, 49, 50, 51, 52, 187, 190, 212, 199, 112, 208, 209, 213, 216, 205, 218, 200, 220, 221, 222, 83, 0, 210, 169, 207, 0, 54, 214, 215, 0, 217, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 90, 0, 0, 0, 0, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 90, 0, 0, 0, 0, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 76, 77, 78, 79, 80, 81, 82, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24 }; static const yytype_int16 yycheck[] = { 6, 24, 90, 106, 92, 146, 32, 32, 0, 3, 3, 31, 5, 6, 7, 32, 66, 31, 32, 32, 34, 35, 36, 37, 67, 32, 32, 66, 67, 32, 171, 32, 32, 174, 175, 66, 67, 66, 67, 32, 66, 66, 68, 146, 185, 32, 187, 67, 32, 66, 67, 154, 66, 67, 67, 69, 159, 31, 32, 66, 34, 35, 36, 37, 66, 66, 67, 31, 171, 67, 158, 174, 175, 66, 68, 68, 66, 67, 163, 164, 86, 67, 185, 31, 187, 147, 148, 67, 67, 67, 113, 32, 66, 67, 67, 69, 31, 32, 31, 34, 35, 36, 37, 66, 66, 66, 112, 67, 67, 212, 67, 67, 200, 31, 32, 33, 34, 35, 36, 37, 31, 32, 33, 34, 35, 36, 37, 67, 67, 67, 32, 66, 31, 32, 69, 34, 35, 36, 37, 34, 34, 31, 33, 31, 67, 66, 66, 170, 66, 67, 66, 32, 67, 66, 68, 66, 67, 94, 95, 96, 97, 98, 99, 66, 31, 92, 67, 66, 59, 60, 61, 62, 63, 64, 65, 32, 32, 201, 67, 31, 67, 67, 67, 67, 190, 67, 181, 67, 67, 67, 16, -1, 198, 151, 191, -1, 33, 203, 204, -1, 206, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 33, -1, -1, -1, -1, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 33, -1, -1, -1, -1, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing symbol of state STATE-NUM. */ static const yytype_uint8 yystos[] = { 0, 71, 72, 0, 66, 73, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 31, 32, 34, 35, 36, 37, 66, 69, 77, 82, 84, 90, 67, 32, 32, 32, 32, 67, 67, 67, 33, 59, 60, 61, 62, 63, 64, 65, 95, 33, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 94, 67, 67, 66, 31, 31, 32, 33, 75, 94, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 75, 93, 3, 5, 6, 7, 66, 68, 84, 90, 67, 31, 66, 66, 66, 67, 67, 67, 90, 67, 67, 67, 32, 66, 76, 82, 67, 76, 32, 92, 92, 92, 92, 92, 92, 92, 34, 34, 31, 31, 67, 66, 77, 66, 66, 66, 32, 90, 75, 67, 79, 91, 87, 89, 81, 66, 77, 78, 66, 88, 88, 66, 86, 31, 83, 89, 74, 67, 78, 32, 67, 67, 88, 67, 90, 32, 33, 66, 67, 80, 82, 77, 67, 32, 87, 87, 32, 85, 31, 67, 67, 75, 78, 78, 78, 67, 81, 78, 78, 67, 67, 90, 67, 86, 67, 67, 90, 67, 79, 67, 90, 90, 67, 90, 67, 67, 67, 67, 67 }; #define yyerrok (yyerrstatus = 0) #define yyclearin (yychar = YYEMPTY) #define YYEMPTY (-2) #define YYEOF 0 #define YYACCEPT goto yyacceptlab #define YYABORT goto yyabortlab #define YYERROR goto yyerrorlab /* Like YYERROR except do call yyerror. This remains here temporarily to ease the transition to the new meaning of YYERROR, for GCC. Once GCC version 2 has supplanted version 1, this can go. */ #define YYFAIL goto yyerrlab #define YYRECOVERING() (!!yyerrstatus) #define YYBACKUP(Token, Value) \ do \ if (yychar == YYEMPTY && yylen == 1) \ { \ yychar = (Token); \ yylval = (Value); \ yytoken = YYTRANSLATE (yychar); \ YYPOPSTACK (1); \ goto yybackup; \ } \ else \ { \ yyerror (&yylloc, context, YY_("syntax error: cannot back up")); \ YYERROR; \ } \ while (YYID (0)) #define YYTERROR 1 #define YYERRCODE 256 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. If N is 0, then set CURRENT to the empty location which ends the previous symbol: RHS[0] (always defined). */ #define YYRHSLOC(Rhs, K) ((Rhs)[K]) #ifndef YYLLOC_DEFAULT # define YYLLOC_DEFAULT(Current, Rhs, N) \ do \ if (YYID (N)) \ { \ (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ } \ else \ { \ (Current).first_line = (Current).last_line = \ YYRHSLOC (Rhs, 0).last_line; \ (Current).first_column = (Current).last_column = \ YYRHSLOC (Rhs, 0).last_column; \ } \ while (YYID (0)) #endif /* YY_LOCATION_PRINT -- Print the location on the stream. This macro was not mandated originally: define only if we know we won't break user code: when these are the locations we know. */ #ifndef YY_LOCATION_PRINT # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL # define YY_LOCATION_PRINT(File, Loc) \ fprintf (File, "%d.%d-%d.%d", \ (Loc).first_line, (Loc).first_column, \ (Loc).last_line, (Loc).last_column) # else # define YY_LOCATION_PRINT(File, Loc) ((void) 0) # endif #endif /* YYLEX -- calling `yylex' with the right arguments. */ #ifdef YYLEX_PARAM # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) #else # define YYLEX yylex (&yylval, &yylloc, scanner) #endif /* Enable debugging if requested. */ #if YYDEBUG # ifndef YYFPRINTF # include /* INFRINGES ON USER NAME SPACE */ # define YYFPRINTF fprintf # endif # define YYDPRINTF(Args) \ do { \ if (yydebug) \ YYFPRINTF Args; \ } while (YYID (0)) # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ do { \ if (yydebug) \ { \ YYFPRINTF (stderr, "%s ", Title); \ yy_symbol_print (stderr, \ Type, Value, Location, context); \ YYFPRINTF (stderr, "\n"); \ } \ } while (YYID (0)) /*--------------------------------. | Print this symbol on YYOUTPUT. | `--------------------------------*/ /*ARGSUSED*/ #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) static void yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, Smt2newContext* context) #else static void yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, context) FILE *yyoutput; int yytype; YYSTYPE const * const yyvaluep; YYLTYPE const * const yylocationp; Smt2newContext* context; #endif { if (!yyvaluep) return; YYUSE (yylocationp); YYUSE (context); # ifdef YYPRINT if (yytype < YYNTOKENS) YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); # else YYUSE (yyoutput); # endif switch (yytype) { default: break; } } /*--------------------------------. | Print this symbol on YYOUTPUT. | `--------------------------------*/ #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) static void yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, Smt2newContext* context) #else static void yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, context) FILE *yyoutput; int yytype; YYSTYPE const * const yyvaluep; YYLTYPE const * const yylocationp; Smt2newContext* context; #endif { if (yytype < YYNTOKENS) YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); else YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); YY_LOCATION_PRINT (yyoutput, *yylocationp); YYFPRINTF (yyoutput, ": "); yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, context); YYFPRINTF (yyoutput, ")"); } /*------------------------------------------------------------------. | yy_stack_print -- Print the state stack from its BOTTOM up to its | | TOP (included). | `------------------------------------------------------------------*/ #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) static void yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) #else static void yy_stack_print (bottom, top) yytype_int16 *bottom; yytype_int16 *top; #endif { YYFPRINTF (stderr, "Stack now"); for (; bottom <= top; ++bottom) YYFPRINTF (stderr, " %d", *bottom); YYFPRINTF (stderr, "\n"); } # define YY_STACK_PRINT(Bottom, Top) \ do { \ if (yydebug) \ yy_stack_print ((Bottom), (Top)); \ } while (YYID (0)) /*------------------------------------------------. | Report that the YYRULE is going to be reduced. | `------------------------------------------------*/ #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) static void yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, Smt2newContext* context) #else static void yy_reduce_print (yyvsp, yylsp, yyrule, context) YYSTYPE *yyvsp; YYLTYPE *yylsp; int yyrule; Smt2newContext* context; #endif { int yynrhs = yyr2[yyrule]; int yyi; unsigned long int yylno = yyrline[yyrule]; YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", yyrule - 1, yylno); /* The symbols being reduced. */ for (yyi = 0; yyi < yynrhs; yyi++) { fprintf (stderr, " $%d = ", yyi + 1); yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], &(yyvsp[(yyi + 1) - (yynrhs)]) , &(yylsp[(yyi + 1) - (yynrhs)]) , context); fprintf (stderr, "\n"); } } # define YY_REDUCE_PRINT(Rule) \ do { \ if (yydebug) \ yy_reduce_print (yyvsp, yylsp, Rule, context); \ } while (YYID (0)) /* Nonzero means print parse trace. It is left uninitialized so that multiple parsers can coexist. */ int yydebug; #else /* !YYDEBUG */ # define YYDPRINTF(Args) # define YY_SYMBOL_PRINT(Title, Type, Value, Location) # define YY_STACK_PRINT(Bottom, Top) # define YY_REDUCE_PRINT(Rule) #endif /* !YYDEBUG */ /* YYINITDEPTH -- initial size of the parser's stacks. */ #ifndef YYINITDEPTH # define YYINITDEPTH 200 #endif /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only if the built-in stack extension method is used). Do not make this value too large; the results are undefined if YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) evaluated with infinite-precision integer arithmetic. */ #ifndef YYMAXDEPTH # define YYMAXDEPTH 10000 #endif #if YYERROR_VERBOSE # ifndef yystrlen # if defined __GLIBC__ && defined _STRING_H # define yystrlen strlen # else /* Return the length of YYSTR. */ #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) static YYSIZE_T yystrlen (const char *yystr) #else static YYSIZE_T yystrlen (yystr) const char *yystr; #endif { YYSIZE_T yylen; for (yylen = 0; yystr[yylen]; yylen++) continue; return yylen; } # endif # endif # ifndef yystpcpy # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE # define yystpcpy stpcpy # else /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in YYDEST. */ #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) static char * yystpcpy (char *yydest, const char *yysrc) #else static char * yystpcpy (yydest, yysrc) char *yydest; const char *yysrc; #endif { char *yyd = yydest; const char *yys = yysrc; while ((*yyd++ = *yys++) != '\0') continue; return yyd - 1; } # endif # endif # ifndef yytnamerr /* Copy to YYRES the contents of YYSTR after stripping away unnecessary quotes and backslashes, so that it's suitable for yyerror. The heuristic is that double-quoting is unnecessary unless the string contains an apostrophe, a comma, or backslash (other than backslash-backslash). YYSTR is taken from yytname. If YYRES is null, do not copy; instead, return the length of what the result would have been. */ static YYSIZE_T yytnamerr (char *yyres, const char *yystr) { if (*yystr == '"') { YYSIZE_T yyn = 0; char const *yyp = yystr; for (;;) switch (*++yyp) { case '\'': case ',': goto do_not_strip_quotes; case '\\': if (*++yyp != '\\') goto do_not_strip_quotes; /* Fall through. */ default: if (yyres) yyres[yyn] = *yyp; yyn++; break; case '"': if (yyres) yyres[yyn] = '\0'; return yyn; } do_not_strip_quotes: ; } if (! yyres) return yystrlen (yystr); return yystpcpy (yyres, yystr) - yyres; } # endif /* Copy into YYRESULT an error message about the unexpected token YYCHAR while in state YYSTATE. Return the number of bytes copied, including the terminating null byte. If YYRESULT is null, do not copy anything; just return the number of bytes that would be copied. As a special case, return 0 if an ordinary "syntax error" message will do. Return YYSIZE_MAXIMUM if overflow occurs during size calculation. */ static YYSIZE_T yysyntax_error (char *yyresult, int yystate, int yychar) { int yyn = yypact[yystate]; if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) return 0; else { int yytype = YYTRANSLATE (yychar); YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); YYSIZE_T yysize = yysize0; YYSIZE_T yysize1; int yysize_overflow = 0; enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; int yyx; # if 0 /* This is so xgettext sees the translatable formats that are constructed on the fly. */ YY_("syntax error, unexpected %s"); YY_("syntax error, unexpected %s, expecting %s"); YY_("syntax error, unexpected %s, expecting %s or %s"); YY_("syntax error, unexpected %s, expecting %s or %s or %s"); YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); # endif char *yyfmt; char const *yyf; static char const yyunexpected[] = "syntax error, unexpected %s"; static char const yyexpecting[] = ", expecting %s"; static char const yyor[] = " or %s"; char yyformat[sizeof yyunexpected + sizeof yyexpecting - 1 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) * (sizeof yyor - 1))]; char const *yyprefix = yyexpecting; /* Start YYX at -YYN if negative to avoid negative indexes in YYCHECK. */ int yyxbegin = yyn < 0 ? -yyn : 0; /* Stay within bounds of both yycheck and yytname. */ int yychecklim = YYLAST - yyn + 1; int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; int yycount = 1; yyarg[0] = yytname[yytype]; yyfmt = yystpcpy (yyformat, yyunexpected); for (yyx = yyxbegin; yyx < yyxend; ++yyx) if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) { if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) { yycount = 1; yysize = yysize0; yyformat[sizeof yyunexpected - 1] = '\0'; break; } yyarg[yycount++] = yytname[yyx]; yysize1 = yysize + yytnamerr (0, yytname[yyx]); yysize_overflow |= (yysize1 < yysize); yysize = yysize1; yyfmt = yystpcpy (yyfmt, yyprefix); yyprefix = yyor; } yyf = YY_(yyformat); yysize1 = yysize + yystrlen (yyf); yysize_overflow |= (yysize1 < yysize); yysize = yysize1; if (yysize_overflow) return YYSIZE_MAXIMUM; if (yyresult) { /* Avoid sprintf, as that infringes on the user's name space. Don't have undefined behavior even if the translation produced a string with the wrong number of "%s"s. */ char *yyp = yyresult; int yyi = 0; while ((*yyp = *yyf) != '\0') { if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) { yyp += yytnamerr (yyp, yyarg[yyi++]); yyf += 2; } else { yyp++; yyf++; } } } return yysize; } } #endif /* YYERROR_VERBOSE */ /*-----------------------------------------------. | Release the memory associated to this symbol. | `-----------------------------------------------*/ /*ARGSUSED*/ #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) static void yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, Smt2newContext* context) #else static void yydestruct (yymsg, yytype, yyvaluep, yylocationp, context) const char *yymsg; int yytype; YYSTYPE *yyvaluep; YYLTYPE *yylocationp; Smt2newContext* context; #endif { YYUSE (yyvaluep); YYUSE (yylocationp); YYUSE (context); if (!yymsg) yymsg = "Deleting"; YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); switch (yytype) { default: break; } } /* Prevent warnings from -Wmissing-prototypes. */ #ifdef YYPARSE_PARAM #if defined __STDC__ || defined __cplusplus int yyparse (void *YYPARSE_PARAM); #else int yyparse (); #endif #else /* ! YYPARSE_PARAM */ #if defined __STDC__ || defined __cplusplus int yyparse (Smt2newContext* context); #else int yyparse (); #endif #endif /* ! YYPARSE_PARAM */ /*----------. | yyparse. | `----------*/ #ifdef YYPARSE_PARAM #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) int yyparse (void *YYPARSE_PARAM) #else int yyparse (YYPARSE_PARAM) void *YYPARSE_PARAM; #endif #else /* ! YYPARSE_PARAM */ #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) int yyparse (Smt2newContext* context) #else int yyparse (context) Smt2newContext* context; #endif #endif { /* The look-ahead symbol. */ int yychar; /* The semantic value of the look-ahead symbol. */ YYSTYPE yylval; /* Number of syntax errors so far. */ int yynerrs; /* Location data for the look-ahead symbol. */ YYLTYPE yylloc; int yystate; int yyn; int yyresult; /* Number of tokens to shift before error messages enabled. */ int yyerrstatus; /* Look-ahead token as an internal (translated) token number. */ int yytoken = 0; #if YYERROR_VERBOSE /* Buffer for error messages, and its allocated size. */ char yymsgbuf[128]; char *yymsg = yymsgbuf; YYSIZE_T yymsg_alloc = sizeof yymsgbuf; #endif /* Three stacks and their tools: `yyss': related to states, `yyvs': related to semantic values, `yyls': related to locations. Refer to the stacks thru separate pointers, to allow yyoverflow to reallocate them elsewhere. */ /* The state stack. */ yytype_int16 yyssa[YYINITDEPTH]; yytype_int16 *yyss = yyssa; yytype_int16 *yyssp; /* The semantic value stack. */ YYSTYPE yyvsa[YYINITDEPTH]; YYSTYPE *yyvs = yyvsa; YYSTYPE *yyvsp; /* The location stack. */ YYLTYPE yylsa[YYINITDEPTH]; YYLTYPE *yyls = yylsa; YYLTYPE *yylsp; /* The locations where the error started and ended. */ YYLTYPE yyerror_range[2]; #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) YYSIZE_T yystacksize = YYINITDEPTH; /* The variables used to return semantic value and location from the action routines. */ YYSTYPE yyval; YYLTYPE yyloc; /* The number of symbols on the RHS of the reduced rule. Keep to zero when no symbol should be popped. */ int yylen = 0; YYDPRINTF ((stderr, "Starting parse\n")); yystate = 0; yyerrstatus = 0; yynerrs = 0; yychar = YYEMPTY; /* Cause a token to be read. */ /* Initialize stack pointers. Waste one element of value and location stack so that they stay on the same level as the state stack. The wasted elements are never initialized. */ yyssp = yyss; yyvsp = yyvs; yylsp = yyls; #if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL /* Initialize the default location before parsing starts. */ yylloc.first_line = yylloc.last_line = 1; yylloc.first_column = yylloc.last_column = 0; #endif goto yysetstate; /*------------------------------------------------------------. | yynewstate -- Push a new state, which is found in yystate. | `------------------------------------------------------------*/ yynewstate: /* In all cases, when you get here, the value and location stacks have just been pushed. So pushing a state here evens the stacks. */ yyssp++; yysetstate: *yyssp = yystate; if (yyss + yystacksize - 1 <= yyssp) { /* Get the current used size of the three stacks, in elements. */ YYSIZE_T yysize = yyssp - yyss + 1; #ifdef yyoverflow { /* Give user a chance to reallocate the stack. Use copies of these so that the &'s don't force the real ones into memory. */ YYSTYPE *yyvs1 = yyvs; yytype_int16 *yyss1 = yyss; YYLTYPE *yyls1 = yyls; /* Each stack pointer address is followed by the size of the data in use in that stack, in bytes. This used to be a conditional around just the two extra args, but that might be undefined if yyoverflow is a macro. */ yyoverflow (YY_("memory exhausted"), &yyss1, yysize * sizeof (*yyssp), &yyvs1, yysize * sizeof (*yyvsp), &yyls1, yysize * sizeof (*yylsp), &yystacksize); yyls = yyls1; yyss = yyss1; yyvs = yyvs1; } #else /* no yyoverflow */ # ifndef YYSTACK_RELOCATE goto yyexhaustedlab; # else /* Extend the stack our own way. */ if (YYMAXDEPTH <= yystacksize) goto yyexhaustedlab; yystacksize *= 2; if (YYMAXDEPTH < yystacksize) yystacksize = YYMAXDEPTH; { yytype_int16 *yyss1 = yyss; union yyalloc *yyptr = (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); if (! yyptr) goto yyexhaustedlab; YYSTACK_RELOCATE (yyss); YYSTACK_RELOCATE (yyvs); YYSTACK_RELOCATE (yyls); # undef YYSTACK_RELOCATE if (yyss1 != yyssa) YYSTACK_FREE (yyss1); } # endif #endif /* no yyoverflow */ yyssp = yyss + yysize - 1; yyvsp = yyvs + yysize - 1; yylsp = yyls + yysize - 1; YYDPRINTF ((stderr, "Stack size increased to %lu\n", (unsigned long int) yystacksize)); if (yyss + yystacksize - 1 <= yyssp) YYABORT; } YYDPRINTF ((stderr, "Entering state %d\n", yystate)); goto yybackup; /*-----------. | yybackup. | `-----------*/ yybackup: /* Do appropriate processing given the current state. Read a look-ahead token if we need one and don't already have one. */ /* First try to decide what to do without reference to look-ahead token. */ yyn = yypact[yystate]; if (yyn == YYPACT_NINF) goto yydefault; /* Not known => get a look-ahead token if don't already have one. */ /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ if (yychar == YYEMPTY) { YYDPRINTF ((stderr, "Reading a token: ")); yychar = YYLEX; } if (yychar <= YYEOF) { yychar = yytoken = YYEOF; YYDPRINTF ((stderr, "Now at end of input.\n")); } else { yytoken = YYTRANSLATE (yychar); YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); } /* If the proper action on seeing token YYTOKEN is to reduce or to detect an error, take that action. */ yyn += yytoken; if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) goto yydefault; yyn = yytable[yyn]; if (yyn <= 0) { if (yyn == 0 || yyn == YYTABLE_NINF) goto yyerrlab; yyn = -yyn; goto yyreduce; } if (yyn == YYFINAL) YYACCEPT; /* Count tokens shifted since error; after three, turn off error status. */ if (yyerrstatus) yyerrstatus--; /* Shift the look-ahead token. */ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); /* Discard the shifted token unless it is eof. */ if (yychar != YYEOF) yychar = YYEMPTY; yystate = yyn; *++yyvsp = yylval; *++yylsp = yylloc; goto yynewstate; /*-----------------------------------------------------------. | yydefault -- do the default action for the current state. | `-----------------------------------------------------------*/ yydefault: yyn = yydefact[yystate]; if (yyn == 0) goto yyerrlab; goto yyreduce; /*-----------------------------. | yyreduce -- Do a reduction. | `-----------------------------*/ yyreduce: /* yyn is the number of a rule to reduce with. */ yylen = yyr2[yyn]; /* If YYLEN is nonzero, implement the default value of the action: `$$ = $1'. Otherwise, the following line sets YYVAL to garbage. This behavior is undocumented and Bison users should not rely upon it. Assigning to YYVAL unconditionally makes the parser a bit smaller, and it avoids a GCC warning that YYVAL may be used uninitialized. */ yyval = yyvsp[1-yylen]; /* Default location. */ YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); YY_REDUCE_PRINT (yyn); switch (yyn) { case 2: #line 66 "smt2newparser.yy" { ASTNode *n = new ASTNode(CMDL_T, "main-script"); n->children = (yyvsp[(1) - (1)].snode_list); context->insertRoot(n); } break; case 3: #line 70 "smt2newparser.yy" { (yyval.snode_list) = new list(); } break; case 4: #line 72 "smt2newparser.yy" { (*(yyvsp[(1) - (2)].snode_list)).push_back((yyvsp[(2) - (2)].snode)); (yyval.snode_list) = (yyvsp[(1) - (2)].snode_list); } break; case 5: #line 76 "smt2newparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(SYM_T, (yyvsp[(3) - (4)].str))); } break; case 6: #line 82 "smt2newparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(3) - (4)].snode)); } break; case 7: #line 88 "smt2newparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(3) - (4)].snode)); } break; case 8: #line 94 "smt2newparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (5)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(SYM_T, (yyvsp[(3) - (5)].str))); (yyval.snode)->children->push_back(new ASTNode(NUM_T, (yyvsp[(4) - (5)].str))); } break; case 9: #line 101 "smt2newparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (8)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(SYM_T, (yyvsp[(3) - (8)].str))); ASTNode* syml = new ASTNode(SYML_T, NULL); syml->children = (yyvsp[(5) - (8)].snode_list); (yyval.snode)->children->push_back(syml); (yyval.snode)->children->push_back((yyvsp[(7) - (8)].snode)); } break; case 10: #line 114 "smt2newparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (8)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(SYM_T, (yyvsp[(3) - (8)].str))); ASTNode* sortl = new ASTNode(SORTL_T, NULL); sortl->children = (yyvsp[(5) - (8)].snode_list); (yyval.snode)->children->push_back(sortl); (yyval.snode)->children->push_back((yyvsp[(7) - (8)].snode)); } break; case 11: #line 126 "smt2newparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (9)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(SYM_T, (yyvsp[(3) - (9)].str))); ASTNode* svl = new ASTNode(SVL_T, NULL); svl->children = (yyvsp[(5) - (9)].snode_list); (yyval.snode)->children->push_back(svl); (yyval.snode)->children->push_back((yyvsp[(7) - (9)].snode)); (yyval.snode)->children->push_back((yyvsp[(8) - (9)].snode)); } break; case 12: #line 139 "smt2newparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(NUM_T, (yyvsp[(3) - (4)].str))); } break; case 13: #line 145 "smt2newparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(NUM_T, (yyvsp[(3) - (4)].str))); } break; case 14: #line 151 "smt2newparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(3) - (4)].snode)); } break; case 15: #line 157 "smt2newparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (3)].str)); } break; case 16: #line 161 "smt2newparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (3)].str)); } break; case 17: #line 165 "smt2newparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (3)].str)); } break; case 18: #line 169 "smt2newparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (3)].str)); } break; case 19: #line 173 "smt2newparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (7)].str)); (yyval.snode)->children = (yyvsp[(5) - (7)].snode_list); (yyval.snode)->children->push_front((yyvsp[(4) - (7)].snode)); } break; case 20: #line 179 "smt2newparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (3)].str)); } break; case 21: #line 183 "smt2newparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(UATTR_T, (yyvsp[(3) - (4)].str))); } break; case 22: #line 189 "smt2newparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(PATTR_T, (yyvsp[(3) - (4)].str))); } break; case 23: #line 195 "smt2newparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(3) - (4)].snode)); } break; case 24: #line 201 "smt2newparser.yy" { (yyval.snode) = new ASTNode(CMD_T, (yyvsp[(2) - (3)].str)); } break; case 25: #line 205 "smt2newparser.yy" { (yyval.snode_list) = new list(); } break; case 26: #line 207 "smt2newparser.yy" { (yyvsp[(1) - (2)].snode_list)->push_back((yyvsp[(2) - (2)].snode)); (yyval.snode_list) = (yyvsp[(1) - (2)].snode_list); } break; case 27: #line 211 "smt2newparser.yy" { (yyval.snode) = new ASTNode(UATTR_T, (yyvsp[(1) - (1)].str)); } break; case 28: #line 213 "smt2newparser.yy" { (yyval.snode) = new ASTNode(UATTR_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(2) - (2)].snode)); } break; case 29: #line 215 "smt2newparser.yy" { (yyval.snode) = new ASTNode(PATTR_T, (yyvsp[(1) - (1)].str)); } break; case 30: #line 217 "smt2newparser.yy" { (yyval.snode) = new ASTNode(PATTR_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(2) - (2)].snode)); } break; case 31: #line 221 "smt2newparser.yy" { (yyval.snode) = new ASTNode(SPECC_T, NULL); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(1) - (1)].snode)); } break; case 32: #line 223 "smt2newparser.yy" { (yyval.snode) = new ASTNode(SYM_T, (yyvsp[(1) - (1)].str)); } break; case 33: #line 227 "smt2newparser.yy" { (yyval.snode) = new ASTNode(SEXPRL_T, NULL); (yyval.snode)->children = (yyvsp[(2) - (3)].snode_list); } break; case 34: #line 234 "smt2newparser.yy" { (yyval.snode) = new ASTNode(SYM_T, (yyvsp[(1) - (1)].str)); } break; case 35: #line 236 "smt2newparser.yy" { (yyval.snode) = new ASTNode(SYM_T, (yyvsp[(3) - (5)].str)); (yyval.snode)->children = (yyvsp[(4) - (5)].snode_list); } break; case 36: #line 240 "smt2newparser.yy" { (yyval.snode) = new ASTNode(ID_T, NULL); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(1) - (1)].snode)); } break; case 37: #line 242 "smt2newparser.yy" { (yyval.snode) = new ASTNode(LID_T, NULL); (yyval.snode)->children = (yyvsp[(4) - (5)].snode_list); (yyval.snode)->children->push_front((yyvsp[(3) - (5)].snode)); } break; case 38: #line 250 "smt2newparser.yy" { (yyvsp[(1) - (2)].snode_list)->push_back((yyvsp[(2) - (2)].snode)); (yyval.snode_list) = (yyvsp[(1) - (2)].snode_list); } break; case 39: #line 252 "smt2newparser.yy" { (yyval.snode_list) = new list(); } break; case 40: #line 256 "smt2newparser.yy" { (yyval.snode) = new ASTNode(SPECC_T, NULL); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(1) - (1)].snode)); } break; case 41: #line 262 "smt2newparser.yy" { (yyval.snode) = new ASTNode(SYM_T, (yyvsp[(1) - (1)].str)); } break; case 42: #line 266 "smt2newparser.yy" { (yyval.snode) = new ASTNode(UATTR_T, (yyvsp[(1) - (1)].str)); } break; case 43: #line 270 "smt2newparser.yy" { (yyval.snode) = new ASTNode(SEXPRL_T, NULL); (yyval.snode)->children = (yyvsp[(2) - (3)].snode_list); } break; case 44: #line 277 "smt2newparser.yy" { (yyval.snode_list) = new list(); } break; case 45: #line 281 "smt2newparser.yy" { (yyvsp[(1) - (2)].snode_list)->push_back((yyvsp[(2) - (2)].snode)); (yyval.snode_list) = (yyvsp[(1) - (2)].snode_list); } break; case 46: #line 288 "smt2newparser.yy" { (yyval.snode) = new ASTNode(NUM_T, (yyvsp[(1) - (1)].str)); } break; case 47: #line 290 "smt2newparser.yy" { (yyval.snode) = new ASTNode(DEC_T, (yyvsp[(1) - (1)].str)); } break; case 48: #line 292 "smt2newparser.yy" { (yyval.snode) = new ASTNode(HEX_T, (yyvsp[(1) - (1)].str)); } break; case 49: #line 294 "smt2newparser.yy" { (yyval.snode) = new ASTNode(BIN_T, (yyvsp[(1) - (1)].str)); } break; case 50: #line 296 "smt2newparser.yy" { (yyval.snode) = new ASTNode(STR_T, (yyvsp[(1) - (1)].str)); } break; case 51: #line 300 "smt2newparser.yy" { (yyvsp[(1) - (2)].snode_list)->push_back(new ASTNode(NUM_T, (yyvsp[(2) - (2)].str))); (yyval.snode_list) = (yyvsp[(1) - (2)].snode_list); } break; case 52: #line 302 "smt2newparser.yy" { (yyval.snode_list) = new list(); (yyval.snode_list)->push_back(new ASTNode(NUM_T, (yyvsp[(1) - (1)].str))); } break; case 53: #line 306 "smt2newparser.yy" { (yyval.snode) = (yyvsp[(1) - (1)].snode); } break; case 54: #line 308 "smt2newparser.yy" { (yyval.snode) = new ASTNode(AS_T, NULL); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(3) - (5)].snode)); (yyval.snode)->children->push_back((yyvsp[(4) - (5)].snode)); } break; case 55: #line 317 "smt2newparser.yy" { (yyval.snode_list) = new list(); } break; case 56: #line 319 "smt2newparser.yy" { (yyvsp[(1) - (2)].snode_list)->push_back((yyvsp[(2) - (2)].snode)); (yyval.snode_list) = (yyvsp[(1) - (2)].snode_list); } break; case 57: #line 323 "smt2newparser.yy" { (yyval.snode) = new ASTNode(VARB_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(3) - (4)].snode)); } break; case 58: #line 327 "smt2newparser.yy" { (yyval.snode_list) = new list(); } break; case 59: #line 329 "smt2newparser.yy" { (yyvsp[(1) - (2)].snode_list)->push_back((yyvsp[(2) - (2)].snode)); (yyval.snode_list) = (yyvsp[(1) - (2)].snode_list); } break; case 60: #line 333 "smt2newparser.yy" { (yyval.snode) = new ASTNode(SV_T, (yyvsp[(2) - (4)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(3) - (4)].snode)); } break; case 61: #line 336 "smt2newparser.yy" { (yyval.snode_list) = new list(); } break; case 62: #line 338 "smt2newparser.yy" { (yyvsp[(1) - (2)].snode_list)->push_back((yyvsp[(2) - (2)].snode)); (yyval.snode_list) = (yyvsp[(1) - (2)].snode_list); } break; case 63: #line 342 "smt2newparser.yy" { (yyval.snode) = new ASTNode(TERM_T, NULL); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(1) - (1)].snode)); } break; case 64: #line 344 "smt2newparser.yy" { (yyval.snode) = new ASTNode(QID_T, NULL); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(1) - (1)].snode)); } break; case 65: #line 346 "smt2newparser.yy" { (yyval.snode) = new ASTNode(LQID_T, NULL); (yyval.snode)->children = (yyvsp[(4) - (5)].snode_list); (yyval.snode)->children->push_front((yyvsp[(3) - (5)].snode)); } break; case 66: #line 352 "smt2newparser.yy" { (yyval.snode) = new ASTNode(LET_T, NULL); (yyval.snode)->children = new list(); (yyvsp[(5) - (8)].snode_list)->push_front((yyvsp[(4) - (8)].snode)); ASTNode* vbl = new ASTNode(VARBL_T, NULL); vbl->children = (yyvsp[(5) - (8)].snode_list); (yyval.snode)->children->push_back(vbl); (yyval.snode)->children->push_back((yyvsp[(7) - (8)].snode)); } break; case 67: #line 362 "smt2newparser.yy" { (yyval.snode) = new ASTNode(FORALL_T, NULL); (yyval.snode)->children = new list(); (yyvsp[(5) - (8)].snode_list)->push_front((yyvsp[(4) - (8)].snode)); ASTNode* svl = new ASTNode(SVL_T, NULL); svl->children = (yyvsp[(5) - (8)].snode_list); (yyval.snode)->children->push_back(svl); (yyval.snode)->children->push_back((yyvsp[(7) - (8)].snode)); } break; case 68: #line 372 "smt2newparser.yy" { (yyval.snode) = new ASTNode(EXISTS_T, NULL); (yyval.snode)->children = new list(); (yyvsp[(5) - (8)].snode_list)->push_front((yyvsp[(4) - (8)].snode)); ASTNode* svl = new ASTNode(SVL_T, NULL); svl->children = (yyvsp[(5) - (8)].snode_list); (yyval.snode)->children->push_back(svl); (yyval.snode)->children->push_back((yyvsp[(7) - (8)].snode)); } break; case 69: #line 382 "smt2newparser.yy" { (yyval.snode) = new ASTNode(BANG_T, NULL); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(2) - (4)].snode)); (yyvsp[(4) - (4)].snode_list)->push_front((yyvsp[(3) - (4)].snode)); (yyval.snode)->children = (yyvsp[(4) - (4)].snode_list); } break; case 70: #line 456 "smt2newparser.yy" { (yyval.snode_list) = new list(); } break; case 71: #line 458 "smt2newparser.yy" { (yyvsp[(1) - (2)].snode_list)->push_back(new ASTNode(SYM_T, (yyvsp[(2) - (2)].str))); (yyval.snode_list) = (yyvsp[(1) - (2)].snode_list); } break; case 72: #line 615 "smt2newparser.yy" { if (strcmp((yyvsp[(1) - (1)].str), "true") == 0) (yyval.snode) = new ASTNode(BOOL_T, "true"); else if (strcmp((yyvsp[(1) - (1)].str), "false") == 0) (yyval.snode) = new ASTNode(BOOL_T, "false"); else { printf("Syntax error: expecting either 'true' or 'false', got '%s'\n", (yyvsp[(1) - (1)].str)); YYERROR; } } break; case 73: #line 628 "smt2newparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(2) - (2)].snode)); } break; case 74: #line 634 "smt2newparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(2) - (2)].snode)); } break; case 75: #line 640 "smt2newparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(2) - (2)].snode)); } break; case 76: #line 646 "smt2newparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(2) - (2)].snode)); } break; case 77: #line 652 "smt2newparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(2) - (2)].snode)); } break; case 78: #line 658 "smt2newparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(2) - (2)].snode)); } break; case 79: #line 664 "smt2newparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(2) - (2)].snode)); } break; case 80: #line 670 "smt2newparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(STR_T, (yyvsp[(2) - (2)].str))); } break; case 81: #line 676 "smt2newparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(STR_T, (yyvsp[(2) - (2)].str))); } break; case 82: #line 682 "smt2newparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(NUM_T, (yyvsp[(2) - (2)].str))); } break; case 83: #line 688 "smt2newparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, (yyvsp[(1) - (2)].str)); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(NUM_T, (yyvsp[(2) - (2)].str))); } break; case 84: #line 694 "smt2newparser.yy" { (yyval.snode) = new ASTNode(OPTION_T, NULL); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back((yyvsp[(1) - (1)].snode)); } break; case 85: #line 702 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 86: #line 704 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 87: #line 706 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 88: #line 708 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 89: #line 710 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 90: #line 712 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 91: #line 714 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 92: #line 716 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 93: #line 718 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 94: #line 720 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 95: #line 722 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 96: #line 724 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 97: #line 726 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 98: #line 728 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 99: #line 730 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 100: #line 732 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 101: #line 734 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 102: #line 736 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 103: #line 738 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 104: #line 740 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 105: #line 742 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 106: #line 744 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 107: #line 746 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 108: #line 748 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 109: #line 750 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 110: #line 752 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 111: #line 754 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 112: #line 756 "smt2newparser.yy" { (yyval.str) = (yyvsp[(1) - (1)].str); } break; case 113: #line 760 "smt2newparser.yy" { (yyval.snode) = new ASTNode(INFO_T, (yyvsp[(1) - (1)].str)); } break; case 114: #line 762 "smt2newparser.yy" { (yyval.snode) = new ASTNode(INFO_T, (yyvsp[(1) - (1)].str)); } break; case 115: #line 764 "smt2newparser.yy" { (yyval.snode) = new ASTNode(INFO_T, (yyvsp[(1) - (1)].str)); } break; case 116: #line 766 "smt2newparser.yy" { (yyval.snode) = new ASTNode(INFO_T, (yyvsp[(1) - (1)].str)); } break; case 117: #line 768 "smt2newparser.yy" { (yyval.snode) = new ASTNode(INFO_T, (yyvsp[(1) - (1)].str)); } break; case 118: #line 770 "smt2newparser.yy" { (yyval.snode) = new ASTNode(INFO_T, (yyvsp[(1) - (1)].str)); } break; case 119: #line 772 "smt2newparser.yy" { (yyval.snode) = new ASTNode(INFO_T, (yyvsp[(1) - (1)].str)); } break; case 120: #line 774 "smt2newparser.yy" { (yyval.snode) = new ASTNode(INFO_T, NULL); (yyval.snode)->children = new list(); (yyval.snode)->children->push_back(new ASTNode(GATTR_T, (yyvsp[(1) - (1)].str))); } break; /* Line 1267 of yacc.c. */ #line 2558 "smt2newparser.cc" default: break; } YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); YYPOPSTACK (yylen); yylen = 0; YY_STACK_PRINT (yyss, yyssp); *++yyvsp = yyval; *++yylsp = yyloc; /* Now `shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by. */ yyn = yyr1[yyn]; yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) yystate = yytable[yystate]; else yystate = yydefgoto[yyn - YYNTOKENS]; goto yynewstate; /*------------------------------------. | yyerrlab -- here on detecting error | `------------------------------------*/ yyerrlab: /* If not already recovering from an error, report this error. */ if (!yyerrstatus) { ++yynerrs; #if ! YYERROR_VERBOSE yyerror (&yylloc, context, YY_("syntax error")); #else { YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) { YYSIZE_T yyalloc = 2 * yysize; if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) yyalloc = YYSTACK_ALLOC_MAXIMUM; if (yymsg != yymsgbuf) YYSTACK_FREE (yymsg); yymsg = (char *) YYSTACK_ALLOC (yyalloc); if (yymsg) yymsg_alloc = yyalloc; else { yymsg = yymsgbuf; yymsg_alloc = sizeof yymsgbuf; } } if (0 < yysize && yysize <= yymsg_alloc) { (void) yysyntax_error (yymsg, yystate, yychar); yyerror (&yylloc, context, yymsg); } else { yyerror (&yylloc, context, YY_("syntax error")); if (yysize != 0) goto yyexhaustedlab; } } #endif } yyerror_range[0] = yylloc; if (yyerrstatus == 3) { /* If just tried and failed to reuse look-ahead token after an error, discard it. */ if (yychar <= YYEOF) { /* Return failure if at end of input. */ if (yychar == YYEOF) YYABORT; } else { yydestruct ("Error: discarding", yytoken, &yylval, &yylloc, context); yychar = YYEMPTY; } } /* Else will try to reuse look-ahead token after shifting the error token. */ goto yyerrlab1; /*---------------------------------------------------. | yyerrorlab -- error raised explicitly by YYERROR. | `---------------------------------------------------*/ yyerrorlab: /* Pacify compilers like GCC when the user code never invokes YYERROR and the label yyerrorlab therefore never appears in user code. */ if (/*CONSTCOND*/ 0) goto yyerrorlab; yyerror_range[0] = yylsp[1-yylen]; /* Do not reclaim the symbols of the rule which action triggered this YYERROR. */ YYPOPSTACK (yylen); yylen = 0; YY_STACK_PRINT (yyss, yyssp); yystate = *yyssp; goto yyerrlab1; /*-------------------------------------------------------------. | yyerrlab1 -- common code for both syntax error and YYERROR. | `-------------------------------------------------------------*/ yyerrlab1: yyerrstatus = 3; /* Each real token shifted decrements this. */ for (;;) { yyn = yypact[yystate]; if (yyn != YYPACT_NINF) { yyn += YYTERROR; if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) { yyn = yytable[yyn]; if (0 < yyn) break; } } /* Pop the current state because it cannot handle the error token. */ if (yyssp == yyss) YYABORT; yyerror_range[0] = *yylsp; yydestruct ("Error: popping", yystos[yystate], yyvsp, yylsp, context); YYPOPSTACK (1); yystate = *yyssp; YY_STACK_PRINT (yyss, yyssp); } if (yyn == YYFINAL) YYACCEPT; *++yyvsp = yylval; yyerror_range[1] = yylloc; /* Using YYLLOC is tempting, but would change the location of the look-ahead. YYLOC is available though. */ YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2); *++yylsp = yyloc; /* Shift the error token. */ YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); yystate = yyn; goto yynewstate; /*-------------------------------------. | yyacceptlab -- YYACCEPT comes here. | `-------------------------------------*/ yyacceptlab: yyresult = 0; goto yyreturn; /*-----------------------------------. | yyabortlab -- YYABORT comes here. | `-----------------------------------*/ yyabortlab: yyresult = 1; goto yyreturn; #ifndef yyoverflow /*-------------------------------------------------. | yyexhaustedlab -- memory exhaustion comes here. | `-------------------------------------------------*/ yyexhaustedlab: yyerror (&yylloc, context, YY_("memory exhausted")); yyresult = 2; /* Fall through. */ #endif yyreturn: if (yychar != YYEOF && yychar != YYEMPTY) yydestruct ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc, context); /* Do not reclaim the symbols of the rule which action triggered this YYABORT or YYACCEPT. */ YYPOPSTACK (yylen); YY_STACK_PRINT (yyss, yyssp); while (yyssp != yyss) { yydestruct ("Cleanup: popping", yystos[*yyssp], yyvsp, yylsp, context); YYPOPSTACK (1); } #ifndef yyoverflow if (yyss != yyssa) YYSTACK_FREE (yyss); #endif #if YYERROR_VERBOSE if (yymsg != yymsgbuf) YYSTACK_FREE (yymsg); #endif /* Make sure YYID is used. */ return YYID (yyresult); } #line 781 "smt2newparser.yy" //======================================================================================= // Auxiliary Routines opensmt-2.5.2/test/smt2newparser.h000066400000000000000000000130631445011647600171640ustar00rootroot00000000000000/* A Bison parser, made by GNU Bison 2.3. */ /* Skeleton interface for Bison's Yacc-like parsers in C Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ /* As a special exception, you may create a larger work that contains part or all of the Bison parser skeleton and distribute that work under terms of your choice, so long as that work isn't itself a parser generator using the skeleton or a modified version thereof as a parser skeleton. Alternatively, if you modify or redistribute the parser skeleton itself, you may (at your option) remove this special exception, which will cause the skeleton and the resulting Bison output files to be licensed under the GNU General Public License without this special exception. This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ /* Tokens. */ #ifndef YYTOKENTYPE # define YYTOKENTYPE /* Put the tokens into the symbol table, so that GDB and other debuggers know about them. */ enum yytokentype { TK_AS = 258, TK_DECIMAL = 259, TK_EXISTS = 260, TK_FORALL = 261, TK_LET = 262, TK_NUMERAL = 263, TK_PAR = 264, TK_STRING = 265, TK_ASSERT = 266, TK_CHECKSAT = 267, TK_DECLARESORT = 268, TK_DECLAREFUN = 269, TK_DEFINESORT = 270, TK_DEFINEFUN = 271, TK_EXIT = 272, TK_GETASSERTIONS = 273, TK_GETASSIGNMENT = 274, TK_GETINFO = 275, TK_GETOPTION = 276, TK_GETPROOF = 277, TK_GETUNSATCORE = 278, TK_GETVALUE = 279, TK_POP = 280, TK_PUSH = 281, TK_SETLOGIC = 282, TK_SETINFO = 283, TK_SETOPTION = 284, TK_THEORY = 285, TK_NUM = 286, TK_SYM = 287, TK_KEY = 288, TK_STR = 289, TK_DEC = 290, TK_HEX = 291, TK_BIN = 292, KW_SORTS = 293, KW_FUNS = 294, KW_SORTSDESCRIPTION = 295, KW_FUNSDESCRIPTION = 296, KW_DEFINITION = 297, KW_NOTES = 298, KW_THEORIES = 299, KW_LANGUAGE = 300, KW_EXTENSIONS = 301, KW_VALUES = 302, KW_PRINTSUCCESS = 303, KW_EXPANDDEFINITIONS = 304, KW_INTERACTIVEMODE = 305, KW_PRODUCEPROOFS = 306, KW_PRODUCEUNSATCORES = 307, KW_PRODUCEMODELS = 308, KW_PRODUCEASSIGNMENTS = 309, KW_REGULAROUTPUTCHANNEL = 310, KW_DIAGNOSTICOUTPUTCHANNEL = 311, KW_RANDOMSEED = 312, KW_VERBOSITY = 313, KW_ERRORBEHAVIOR = 314, KW_NAME = 315, KW_AUTHORS = 316, KW_VERSION = 317, KW_STATUS = 318, KW_REASONUNKNOWN = 319, KW_ALLSTATISTICS = 320 }; #endif /* Tokens. */ #define TK_AS 258 #define TK_DECIMAL 259 #define TK_EXISTS 260 #define TK_FORALL 261 #define TK_LET 262 #define TK_NUMERAL 263 #define TK_PAR 264 #define TK_STRING 265 #define TK_ASSERT 266 #define TK_CHECKSAT 267 #define TK_DECLARESORT 268 #define TK_DECLAREFUN 269 #define TK_DEFINESORT 270 #define TK_DEFINEFUN 271 #define TK_EXIT 272 #define TK_GETASSERTIONS 273 #define TK_GETASSIGNMENT 274 #define TK_GETINFO 275 #define TK_GETOPTION 276 #define TK_GETPROOF 277 #define TK_GETUNSATCORE 278 #define TK_GETVALUE 279 #define TK_POP 280 #define TK_PUSH 281 #define TK_SETLOGIC 282 #define TK_SETINFO 283 #define TK_SETOPTION 284 #define TK_THEORY 285 #define TK_NUM 286 #define TK_SYM 287 #define TK_KEY 288 #define TK_STR 289 #define TK_DEC 290 #define TK_HEX 291 #define TK_BIN 292 #define KW_SORTS 293 #define KW_FUNS 294 #define KW_SORTSDESCRIPTION 295 #define KW_FUNSDESCRIPTION 296 #define KW_DEFINITION 297 #define KW_NOTES 298 #define KW_THEORIES 299 #define KW_LANGUAGE 300 #define KW_EXTENSIONS 301 #define KW_VALUES 302 #define KW_PRINTSUCCESS 303 #define KW_EXPANDDEFINITIONS 304 #define KW_INTERACTIVEMODE 305 #define KW_PRODUCEPROOFS 306 #define KW_PRODUCEUNSATCORES 307 #define KW_PRODUCEMODELS 308 #define KW_PRODUCEASSIGNMENTS 309 #define KW_REGULAROUTPUTCHANNEL 310 #define KW_DIAGNOSTICOUTPUTCHANNEL 311 #define KW_RANDOMSEED 312 #define KW_VERBOSITY 313 #define KW_ERRORBEHAVIOR 314 #define KW_NAME 315 #define KW_AUTHORS 316 #define KW_VERSION 317 #define KW_STATUS 318 #define KW_REASONUNKNOWN 319 #define KW_ALLSTATISTICS 320 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED typedef union YYSTYPE #line 37 "smt2newparser.yy" { char * str; vector< string > * str_list; ASTNode * snode; list< ASTNode * > * snode_list; } /* Line 1529 of yacc.c. */ #line 186 "smt2newparser.h" YYSTYPE; # define yystype YYSTYPE /* obsolescent; will be withdrawn */ # define YYSTYPE_IS_DECLARED 1 # define YYSTYPE_IS_TRIVIAL 1 #endif #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED typedef struct YYLTYPE { int first_line; int first_column; int last_line; int last_column; } YYLTYPE; # define yyltype YYLTYPE /* obsolescent; will be withdrawn */ # define YYLTYPE_IS_DECLARED 1 # define YYLTYPE_IS_TRIVIAL 1 #endif opensmt-2.5.2/test/smt2newparser.yy000066400000000000000000000566121445011647600174050ustar00rootroot00000000000000%pure-parser %name-prefix="smt2new" %locations %defines %error-verbose %parse-param { Smt2newContext* context } %lex-param { void* scanner } %{ #include #include #include #include #include #include #include #include "smt2newcontext.h" #include "smt2newparser.h" int smt2newlex(YYSTYPE* lvalp, YYLTYPE* llocp, void* scanner); void smt2newerror( YYLTYPE* locp, Smt2newContext* context, const char * s ) { printf( "At line %d: %s\n", locp->first_line, s ); exit( 1 ); } #define scanner context->scanner /* Overallocation to prevent stack overflow */ #define YYMAXDEPTH 1024 * 1024 %} %union { char * str; vector< string > * str_list; ASTNode * snode; list< ASTNode * > * snode_list; } %token TK_AS TK_DECIMAL TK_EXISTS TK_FORALL TK_LET TK_NUMERAL TK_PAR TK_STRING %token TK_ASSERT TK_CHECKSAT TK_DECLARESORT TK_DECLAREFUN TK_DEFINESORT TK_DEFINEFUN TK_EXIT TK_GETASSERTIONS TK_GETASSIGNMENT TK_GETINFO TK_GETOPTION TK_GETPROOF TK_GETUNSATCORE TK_GETVALUE TK_POP TK_PUSH TK_SETLOGIC TK_SETINFO TK_SETOPTION TK_THEORY %token TK_NUM TK_SYM TK_KEY TK_STR TK_DEC TK_HEX TK_BIN %token KW_SORTS KW_FUNS KW_SORTSDESCRIPTION KW_FUNSDESCRIPTION KW_DEFINITION KW_NOTES KW_THEORIES KW_LANGUAGE KW_EXTENSIONS KW_VALUES KW_PRINTSUCCESS KW_EXPANDDEFINITIONS KW_INTERACTIVEMODE KW_PRODUCEPROOFS KW_PRODUCEUNSATCORES KW_PRODUCEMODELS KW_PRODUCEASSIGNMENTS KW_REGULAROUTPUTCHANNEL KW_DIAGNOSTICOUTPUTCHANNEL KW_RANDOMSEED KW_VERBOSITY KW_ERRORBEHAVIOR KW_NAME KW_AUTHORS KW_VERSION KW_STATUS KW_REASONUNKNOWN KW_ALLSTATISTICS %type TK_AS TK_DECIMAL TK_EXISTS TK_FORALL TK_LET TK_NUMERAL TK_PAR TK_STRING %type TK_ASSERT TK_CHECKSAT TK_DECLARESORT TK_DECLAREFUN TK_DEFINESORT TK_DEFINEFUN TK_EXIT TK_GETASSERTIONS TK_GETASSIGNMENT TK_GETINFO TK_GETOPTION TK_GETPROOF TK_GETUNSATCORE TK_GETVALUE TK_POP TK_PUSH TK_SETLOGIC TK_SETINFO TK_SETOPTION %type TK_NUM TK_SYM TK_KEY TK_STR TK_DEC TK_HEX TK_BIN meta_spec_const %type KW_SORTS KW_FUNS KW_SORTSDESCRIPTION KW_FUNSDESCRIPTION KW_DEFINITION KW_NOTES KW_THEORIES KW_LANGUAGE KW_EXTENSIONS KW_VALUES KW_PRINTSUCCESS KW_EXPANDDEFINITIONS KW_INTERACTIVEMODE KW_PRODUCEPROOFS KW_PRODUCEUNSATCORES KW_PRODUCEMODELS KW_PRODUCEASSIGNMENTS KW_REGULAROUTPUTCHANNEL KW_DIAGNOSTICOUTPUTCHANNEL KW_RANDOMSEED KW_VERBOSITY KW_ERRORBEHAVIOR KW_NAME KW_AUTHORS KW_VERSION KW_STATUS KW_REASONUNKNOWN KW_ALLSTATISTICS predef_key %type identifier sort command attribute attribute_value s_expr spec_const qual_identifier var_binding sorted_var term %type sort_list command_list s_expr_list numeral_list term_list var_binding_list attribute_list sorted_var_list symbol_list %type sort_symbol_decl fun_symbol_decl par_fun_symbol_decl %type sort_symbol_decl_list par_fun_symbol_decl_list %type theory_attribute theory_decl logic_attribute logic %type theory_attribute_list logic_attribute_list %type b_value option info_flag %start script %% script: command_list { ASTNode *n = new ASTNode(CMDL_T, "main-script"); n->children = $1; context->insertRoot(n); }; command_list: { $$ = new list(); } | command_list command { (*$1).push_back($2); $$ = $1; } ; command: '(' TK_SETLOGIC TK_SYM ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new list(); $$->children->push_back(new ASTNode(SYM_T, $3)); } | '(' TK_SETOPTION option ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new list(); $$->children->push_back($3); } | '(' TK_SETINFO attribute ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new list(); $$->children->push_back($3); } | '(' TK_DECLARESORT TK_SYM TK_NUM ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new list(); $$->children->push_back(new ASTNode(SYM_T, $3)); $$->children->push_back(new ASTNode(NUM_T, $4)); } | '(' TK_DEFINESORT TK_SYM '(' symbol_list ')' sort ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new list(); $$->children->push_back(new ASTNode(SYM_T, $3)); ASTNode* syml = new ASTNode(SYML_T, NULL); syml->children = $5; $$->children->push_back(syml); $$->children->push_back($7); } | '(' TK_DECLAREFUN TK_SYM '(' sort_list ')' sort ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new list(); $$->children->push_back(new ASTNode(SYM_T, $3)); ASTNode* sortl = new ASTNode(SORTL_T, NULL); sortl->children = $5; $$->children->push_back(sortl); $$->children->push_back($7); } | '(' TK_DEFINEFUN TK_SYM '(' sorted_var_list ')' sort term ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new list(); $$->children->push_back(new ASTNode(SYM_T, $3)); ASTNode* svl = new ASTNode(SVL_T, NULL); svl->children = $5; $$->children->push_back(svl); $$->children->push_back($7); $$->children->push_back($8); } | '(' TK_PUSH TK_NUM ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new list(); $$->children->push_back(new ASTNode(NUM_T, $3)); } | '(' TK_POP TK_NUM ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new list(); $$->children->push_back(new ASTNode(NUM_T, $3)); } | '(' TK_ASSERT term ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new list(); $$->children->push_back($3); } | '(' TK_CHECKSAT ')' { $$ = new ASTNode(CMD_T, $2); } | '(' TK_GETASSERTIONS ')' { $$ = new ASTNode(CMD_T, $2); } | '(' TK_GETPROOF ')' { $$ = new ASTNode(CMD_T, $2); } | '(' TK_GETUNSATCORE ')' { $$ = new ASTNode(CMD_T, $2); } | '(' TK_GETVALUE '(' term term_list ')' ')' { $$ = new ASTNode(CMD_T, $2); $$->children = $5; $$->children->push_front($4); } | '(' TK_GETASSIGNMENT ')' { $$ = new ASTNode(CMD_T, $2); } | '(' TK_GETOPTION TK_KEY ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new list(); $$->children->push_back(new ASTNode(UATTR_T, $3)); } | '(' TK_GETOPTION predef_key ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new list(); $$->children->push_back(new ASTNode(PATTR_T, $3)); } | '(' TK_GETINFO info_flag ')' { $$ = new ASTNode(CMD_T, $2); $$->children = new list(); $$->children->push_back($3); } | '(' TK_EXIT ')' { $$ = new ASTNode(CMD_T, $2); } ; attribute_list: { $$ = new list(); } | attribute_list attribute { $1->push_back($2); $$ = $1; } ; attribute: TK_KEY { $$ = new ASTNode(UATTR_T, $1); } | TK_KEY attribute_value { $$ = new ASTNode(UATTR_T, $1); $$->children = new list(); $$->children->push_back($2); } | predef_key { $$ = new ASTNode(PATTR_T, $1); } | predef_key attribute_value { $$ = new ASTNode(PATTR_T, $1); $$->children = new list(); $$->children->push_back($2); } ; attribute_value: spec_const { $$ = new ASTNode(SPECC_T, NULL); $$->children = new list(); $$->children->push_back($1); } | TK_SYM { $$ = new ASTNode(SYM_T, $1); } | '(' s_expr_list ')' { $$ = new ASTNode(SEXPRL_T, NULL); $$->children = $2; } ; identifier: TK_SYM { $$ = new ASTNode(SYM_T, $1); } | '(' '_' TK_SYM numeral_list ')' { $$ = new ASTNode(SYM_T, $3); $$->children = $4; } ; sort: identifier { $$ = new ASTNode(ID_T, NULL); $$->children = new list(); $$->children->push_back($1); } | '(' identifier sort sort_list ')' { $$ = new ASTNode(LID_T, NULL); $$->children = $4; $$->children->push_front($3); } ; sort_list: sort_list sort { $1->push_back($2); $$ = $1; } | { $$ = new list(); } ; s_expr: spec_const { $$ = new ASTNode(SPECC_T, NULL); $$->children = new list(); $$->children->push_back($1); } | TK_SYM { $$ = new ASTNode(SYM_T, $1); } | TK_KEY { $$ = new ASTNode(UATTR_T, $1); } | '(' s_expr_list ')' { $$ = new ASTNode(SEXPRL_T, NULL); $$->children = $2; } ; s_expr_list: { $$ = new list(); } | s_expr_list s_expr { $1->push_back($2); $$ = $1; } ; spec_const: TK_NUM { $$ = new ASTNode(NUM_T, $1); } | TK_DEC { $$ = new ASTNode(DEC_T, $1); } | TK_HEX { $$ = new ASTNode(HEX_T, $1); } | TK_BIN { $$ = new ASTNode(BIN_T, $1); } | TK_STR { $$ = new ASTNode(STR_T, $1); } ; numeral_list: numeral_list TK_NUM { $1->push_back(new ASTNode(NUM_T, $2)); $$ = $1; } | TK_NUM { $$ = new list(); $$->push_back(new ASTNode(NUM_T, $1)); } ; qual_identifier: identifier { $$ = $1; } | '(' TK_AS identifier sort ')' { $$ = new ASTNode(AS_T, NULL); $$->children = new list(); $$->children->push_back($3); $$->children->push_back($4); } ; var_binding_list: { $$ = new list(); } | var_binding_list var_binding { $1->push_back($2); $$ = $1; } ; var_binding: '(' TK_SYM term ')' { $$ = new ASTNode(VARB_T, $2); $$->children = new list(); $$->children->push_back($3); } ; sorted_var_list: { $$ = new list(); } | sorted_var_list sorted_var { $1->push_back($2); $$ = $1; } ; sorted_var: '(' TK_SYM sort ')' { $$ = new ASTNode(SV_T, $2); $$->children = new list(); $$->children->push_back($3); } term_list: { $$ = new list(); } | term_list term { $1->push_back($2); $$ = $1; } ; term: spec_const { $$ = new ASTNode(TERM_T, NULL); $$->children = new list(); $$->children->push_back($1); } | qual_identifier { $$ = new ASTNode(QID_T, NULL); $$->children = new list(); $$->children->push_back($1); } | '(' qual_identifier term term_list ')' { $$ = new ASTNode(LQID_T, NULL); $$->children = $4; $$->children->push_front($3); } | '(' TK_LET '(' var_binding var_binding_list ')' term ')' { $$ = new ASTNode(LET_T, NULL); $$->children = new list(); $5->push_front($4); ASTNode* vbl = new ASTNode(VARBL_T, NULL); vbl->children = $5; $$->children->push_back(vbl); $$->children->push_back($7); } | '(' TK_FORALL '(' sorted_var sorted_var_list ')' term ')' { $$ = new ASTNode(FORALL_T, NULL); $$->children = new list(); $5->push_front($4); ASTNode* svl = new ASTNode(SVL_T, NULL); svl->children = $5; $$->children->push_back(svl); $$->children->push_back($7); } | '(' TK_EXISTS '(' sorted_var sorted_var_list ')' term ')' { $$ = new ASTNode(EXISTS_T, NULL); $$->children = new list(); $5->push_front($4); ASTNode* svl = new ASTNode(SVL_T, NULL); svl->children = $5; $$->children->push_back(svl); $$->children->push_back($7); } | '!' term attribute attribute_list { $$ = new ASTNode(BANG_T, NULL); $$->children = new list(); $$->children->push_back($2); $4->push_front($3); $$->children = $4; } ; sort_symbol_decl_list: { $$ = new list(); } | sort_symbol_decl_list sort_symbol_decl { $1->push_back($2); $$ = $1; } ; sort_symbol_decl: '(' identifier TK_NUM attribute_list ')' { $$ = new ASTNode(SSYMD_T, NULL); $$->children = $4; $$->children->push_front(new ASTNode(NUM_T, $3)); $$->children->push_front($2); } ; meta_spec_const: TK_NUM { $$ = new ASTNode(NUM_T, $1); } | TK_DEC { $$ = new ASTNode(DEC_T, $1); } | TK_STR { $$ = new ASTNode(STR_T, $1); } ; fun_symbol_decl:'(' spec_const sort attribute_list ')' { $$ = new ASTNode(FSYMD_T, NULL); $$->children = new list(); $$->children->push_back($2); $$->children->push_back($3); ASTNode* al = new ASTNode(GATTRL_T, NULL); al->children = $4; $$->children->push_back(al); } | '(' meta_spec_const sort attribute_list ')' { $$ = new ASTNode(FSYMD_T, NULL); $$->children = new list(); $$->children->push_back($2); $$->children->push_back($3); ASTNode* al = new ASTNode(GATTRL_T, NULL); al->children = $4; $$->children->push_back(al); } | '(' identifier sort sort_list attribute_list ')' { $$ = new ASTNode(FSYMD_T, NULL); $$->children = new list(); $$->children->push_back($2); ASTNode* sl = new ASTNode(SORTL_T, NULL); sl->children = $4; sl->children->push_front($3); $$->children->push_back(sl); ASTNode* al = new ASTNode(GATTRL_T, NULL); al->children = $4; $$->children->push_back(al); } ; symbol_list: { $$ = new list(); } | symbol_list TK_SYM { $1->push_back(new ASTNode(SYM_T, $2)); $$ = $1; } ; par_fun_symbol_decl_list: { $$ = new list(); } | par_fun_symbol_decl_list par_fun_symbol_decl { $1->push_back($2); $$ = $1; } ; par_fun_symbol_decl: fun_symbol_decl { $$ = new ASTNode(PFSYMD_T, NULL); $$->children = new list(); $$->children->push_back($1); } | '(' TK_PAR '(' TK_SYM symbol_list ')' '(' identifier sort sort_list attribute_list ')' ')' { $$ = new ASTNode(PFSYMD_T, NULL); ASTNode* syml = new ASTNode(SYML_T, NULL); $$->children = new list(); syml->children = $5; syml->children->push_front($4); $$->children->push_back(syml); ASTNode* id = new ASTNode(PFID_T, NULL) id->children = new list(); id->children->push_back($8); ASTNode* sortl = new ASTNode(SORTL_T, NULL); sortl->children = $10; sortl->push_front($9); id->children->push_back(sortl); ASTNode* attrl = new ASTNode(GATTRL_T, NULL); attrl->children = $11; id->children->push_back(attrl); $$->children->push_back(id); } ; theory_attribute_list: { $$ = new list(); } | theory_attribute_list theory_attribute { $1->push_back($2); $$ = $1; } ; theory_attribute: KW_SORTS '(' sort_symbol_decl sort_symbol_decl_list ')' { $$ = new ASTNode(TATTR_T, $1); $4->push_front($3); $$->children = $4; } | KW_FUNS '(' par_fun_symbol_decl par_fun_symbol_decl_list ')' { $$ = new ASTNode(TATTR_T, $1); $4->push_front($3); $$->children = $4; } | KW_SORTSDESCRIPTION TK_STR { $$ = new ASTNode(TATTR_T, $1); $$->children = new list(); $$->children->push_back(new ASTNode(STR_T, $1)); } | KW_FUNSDESCRIPTION TK_STR { $$ = new ASTNode(TATTR_T, $1); $$->children = new list(); $$->children->push_back(new ASTNode(STR_T, $1)); } | KW_DEFINITION TK_STR { $$ = new ASTNode(TATTR_T, $1); $$->children = new list(); $$->children->push_back(new ASTNode(STR_T, $1)); } | KW_VALUES TK_STR { $$ = new ASTNode(TATTR_T, $1); $$->children = new list(); $$->children->push_back(new ASTNode(STR_T, $1)); } | KW_NOTES TK_STR { $$ = new ASTNode(TATTR_T, $1); $$->children = new list(); $$->children->push_back(new ASTNode(STR_T, $1)); } | attribute { $$ = new ASTNode(TATTR_T, NULL); $$->children = new list(); $$->children->push_back($1); } ; theory_decl: '(' TK_THEORY TK_SYM theory_attribute theory_attribute_list ')' { $$ = new ASTNode(TDECL_T, $3); $$->children = $5; $$->children->push_back($4); } ; logic_attribute_list: { $$ = new list(); } | logic_attribute_list logic_attribute { $1->push_back($2); $$ = $1; } ; logic_attribute: KW_THEORIES '(' TK_SYM symbol_list ')' { $$ = new ASTNode(LATTR_T, $1); $4->push_front(new ASTNode(SYM_T, $3)); $$->children = $4; } | KW_LANGUAGE TK_STR { $$ = new ASTNode(LATTR_T, $1); $$->children = new list(); $$->children->push_back(new ASTNode(STR_T, $2)); } | KW_EXTENSIONS TK_STR { $$ = new ASTNode(LATTR_T, $1); $$->children = new list(); $$->children->push_back(new ASTNode(STR_T, $2)); } | KW_VALUES TK_STR { $$ = new ASTNode(LATTR_T, $1); $$->children = new list(); $$->children->push_back(new ASTNode(STR_T, $2)); } | KW_NOTES TK_STR { $$ = new ASTNode(LATTR_T, $1); $$->children = new list(); $$->children->push_back(new ASTNode(STR_T, $2)); } | attribute { $$ = new ASTNode(LATTR_T, $1); } ; logic: '(' TK_SYM logic_attribute logic_attribute_list ')' { $$ = new ASTNode(LOGIC_T, $2); $$->children = $4; $$->push_front($3); } ; b_value: TK_SYM { if (strcmp($1, "true") == 0) $$ = new ASTNode(BOOL_T, "true"); else if (strcmp($1, "false") == 0) $$ = new ASTNode(BOOL_T, "false"); else { printf("Syntax error: expecting either 'true' or 'false', got '%s'\n", $1); YYERROR; } } ; option: KW_PRINTSUCCESS b_value { $$ = new ASTNode(OPTION_T, $1); $$->children = new list(); $$->children->push_back($2); } | KW_EXPANDDEFINITIONS b_value { $$ = new ASTNode(OPTION_T, $1); $$->children = new list(); $$->children->push_back($2); } | KW_INTERACTIVEMODE b_value { $$ = new ASTNode(OPTION_T, $1); $$->children = new list(); $$->children->push_back($2); } | KW_PRODUCEPROOFS b_value { $$ = new ASTNode(OPTION_T, $1); $$->children = new list(); $$->children->push_back($2); } | KW_PRODUCEUNSATCORES b_value { $$ = new ASTNode(OPTION_T, $1); $$->children = new list(); $$->children->push_back($2); } | KW_PRODUCEMODELS b_value { $$ = new ASTNode(OPTION_T, $1); $$->children = new list(); $$->children->push_back($2); } | KW_PRODUCEASSIGNMENTS b_value { $$ = new ASTNode(OPTION_T, $1); $$->children = new list(); $$->children->push_back($2); } | KW_REGULAROUTPUTCHANNEL TK_STR { $$ = new ASTNode(OPTION_T, $1); $$->children = new list(); $$->children->push_back(new ASTNode(STR_T, $2)); } | KW_DIAGNOSTICOUTPUTCHANNEL TK_STR { $$ = new ASTNode(OPTION_T, $1); $$->children = new list(); $$->children->push_back(new ASTNode(STR_T, $2)); } | KW_RANDOMSEED TK_NUM { $$ = new ASTNode(OPTION_T, $1); $$->children = new list(); $$->children->push_back(new ASTNode(NUM_T, $2)); } | KW_VERBOSITY TK_NUM { $$ = new ASTNode(OPTION_T, $1); $$->children = new list(); $$->children->push_back(new ASTNode(NUM_T, $2)); } | attribute { $$ = new ASTNode(OPTION_T, NULL); $$->children = new list(); $$->children->push_back($1); } ; predef_key: KW_SORTS { $$ = $1; } | KW_FUNS { $$ = $1; } | KW_SORTSDESCRIPTION { $$ = $1; } | KW_FUNSDESCRIPTION { $$ = $1; } | KW_DEFINITION { $$ = $1; } | KW_VALUES { $$ = $1; } | KW_NOTES { $$ = $1; } | KW_THEORIES { $$ = $1; } | KW_LANGUAGE { $$ = $1; } | KW_EXTENSIONS { $$ = $1; } | KW_PRINTSUCCESS { $$ = $1; } | KW_EXPANDDEFINITIONS { $$ = $1; } | KW_INTERACTIVEMODE { $$ = $1; } | KW_PRODUCEPROOFS { $$ = $1; } | KW_PRODUCEUNSATCORES { $$ = $1; } | KW_PRODUCEMODELS { $$ = $1; } | KW_PRODUCEASSIGNMENTS { $$ = $1; } | KW_REGULAROUTPUTCHANNEL { $$ = $1; } | KW_DIAGNOSTICOUTPUTCHANNEL { $$ = $1; } | KW_RANDOMSEED { $$ = $1; } | KW_VERBOSITY { $$ = $1; } | KW_ERRORBEHAVIOR { $$ = $1; } | KW_NAME { $$ = $1; } | KW_AUTHORS { $$ = $1; } | KW_VERSION { $$ = $1; } | KW_STATUS { $$ = $1; } | KW_REASONUNKNOWN { $$ = $1; } | KW_ALLSTATISTICS { $$ = $1; } ; info_flag: KW_ERRORBEHAVIOR { $$ = new ASTNode(INFO_T, $1); } | KW_NAME { $$ = new ASTNode(INFO_T, $1); } | KW_AUTHORS { $$ = new ASTNode(INFO_T, $1); } | KW_VERSION { $$ = new ASTNode(INFO_T, $1); } | KW_STATUS { $$ = new ASTNode(INFO_T, $1); } | KW_REASONUNKNOWN { $$ = new ASTNode(INFO_T, $1); } | KW_ALLSTATISTICS { $$ = new ASTNode(INFO_T, $1); } | TK_KEY { $$ = new ASTNode(INFO_T, NULL); $$->children = new list(); $$->children->push_back(new ASTNode(GATTR_T, $1)); } ; %% //======================================================================================= // Auxiliary Routines opensmt-2.5.2/test/test.cc000066400000000000000000000001551445011647600154630ustar00rootroot00000000000000#include #include vector * int main(int argc, char ** argv) vector opensmt-2.5.2/test/test/000077500000000000000000000000001445011647600151535ustar00rootroot00000000000000opensmt-2.5.2/test/test/01.smt2000066400000000000000000000005131445011647600162010ustar00rootroot00000000000000(set-logic QF_BV) (set-info :source | Constructed by Trevor Hansen to test bvnor nesting. |) (set-info :smt-lib-version 2.0) (set-info :category "check") (set-info :status unsat) (declare-fun v0 () (_ BitVec 1)) (assert (= (_ bv0 1) ((_ extract 1 1) (bvnor (_ bv0 2) (bvnor (_ bv2 2) (concat (_ bv0 1) v0)))))) (check-sat) (exit) opensmt-2.5.2/test/test/02.smt2000066400000000000000000000001551445011647600162040ustar00rootroot00000000000000#include #include vector * int main(int argc, char ** argv) vector opensmt-2.5.2/test/test/03.smt2000066400000000000000000000000221445011647600161760ustar00rootroot00000000000000(set-logic QF_BV) opensmt-2.5.2/test/unit/000077500000000000000000000000001445011647600151535ustar00rootroot00000000000000opensmt-2.5.2/test/unit/CMakeLists.txt000066400000000000000000000166561445011647600177310ustar00rootroot00000000000000include(GoogleTest) add_executable(LRATest) target_sources(LRATest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_Rationals.cpp" # PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_Delta.cpp" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_Matrix.cc" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_Polynomial.cpp" ) target_link_libraries(LRATest OpenSMT gtest gtest_main) gtest_add_tests(TARGET LRATest) add_executable(RewritingTest) target_sources(RewritingTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_simplifyAssignment.cpp" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_Dominators.cpp" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_Rewriting.cc" ) target_link_libraries(RewritingTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET RewritingTest) add_executable(TheorySimplificationsTest) target_sources(TheorySimplificationsTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_TheorySimplifications.cc" ) target_link_libraries(TheorySimplificationsTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET TheorySimplificationsTest) add_executable(EGraphTest) target_sources(EGraphTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_Egraph.cc" ) target_link_libraries(EGraphTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET EGraphTest) add_executable(LATest) target_sources(LATest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_Lookahead.cpp" ) target_link_libraries(LATest OpenSMT gtest gtest_main) gtest_add_tests(TARGET LATest) add_executable(SimplexTest) target_sources(SimplexTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_Simplex.cc" ) target_link_libraries(SimplexTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET SimplexTest) add_executable(HermiteTest) target_sources(HermiteTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_HNF.cc" ) target_link_libraries(HermiteTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET HermiteTest) add_executable(LIACutTest) target_sources(LIACutTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_LIACutSolver.cpp" ) target_link_libraries(LIACutTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET LIACutTest) add_executable(STPSolverTest) target_sources(STPSolverTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_IDLSolver.cpp" ) target_link_libraries(STPSolverTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET STPSolverTest) add_executable(SubstitutionsTest) target_sources(SubstitutionsTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_SubstitutionBreaker.cpp" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_Substitutions.cc" ) target_link_libraries(SubstitutionsTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET SubstitutionsTest) add_executable(LogicMkTermsTest) target_sources(LogicMkTermsTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_LogicMkTerms.cc" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_LIALogicMkTerms.cc" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_LRALogicMkTerms.cc" ) target_link_libraries(LogicMkTermsTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET LogicMkTermsTest) add_executable(BoundTest) target_sources(BoundTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_Bounds.cc" ) target_link_libraries(BoundTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET BoundTest) add_executable(ModelTest) target_sources(ModelTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_Model.cc" ) target_link_libraries(ModelTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET ModelTest) add_executable(IteTest) target_sources(IteTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_Ites.cc" ) target_link_libraries(IteTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET IteTest) add_executable(LIAStrengtheningTest) target_sources(LIAStrengtheningTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_LIAStrengthening.cc" ) target_link_libraries(LIAStrengtheningTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET LIAStrengtheningTest) add_executable(InterpolationTest) target_sources(InterpolationTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_UFInterpolation.cc" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_LRAInterpolation.cc" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_LIAInterpolation.cc" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_ResolutionProofInterpolation.cc" ) target_link_libraries(InterpolationTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET InterpolationTest) add_executable(ExplainTest) target_sources(ExplainTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_Explain.cc" ) target_link_libraries(ExplainTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET ExplainTest) add_executable(EnodeStoreTest) target_sources(EnodeStoreTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_EnodeStore.cc" ) target_link_libraries(EnodeStoreTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET EnodeStoreTest) add_executable(FunctionTemplateTest) target_sources(FunctionTemplateTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_FunctionTemplate.cc" ) target_link_libraries(FunctionTemplateTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET FunctionTemplateTest) add_executable(ProofTest) target_sources(ProofTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_Proof.cc" ) target_link_libraries(ProofTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET ProofTest) add_executable(SplitTest) target_sources(SplitTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_Splitting.cc" ) target_link_libraries(SplitTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET SplitTest) add_executable(NumberParserTest) target_sources(NumberParserTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_NumberParser.cc" ) target_link_libraries(NumberParserTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET NumberParserTest) add_executable(TermTypecheckingTest) target_sources(TermTypecheckingTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_TermTypechecking.cc" ) target_link_libraries(TermTypecheckingTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET TermTypecheckingTest) add_executable(ArithLogicApiTest) target_sources(ArithLogicApiTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_ArithLogicApi.cc" ) target_link_libraries(ArithLogicApiTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET ArithLogicApiTest) add_executable(TermsTest) target_sources(TermsTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_Sorts.cc" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_Visitors.cc" ) target_link_libraries(TermsTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET TermsTest) add_executable(LASolverIncrementalityTest) target_sources(LASolverIncrementalityTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_LASolverIncrementality.cc" ) target_link_libraries(LASolverIncrementalityTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET LASolverIncrementalityTest) add_executable(NameProtectionTest) target_sources(NameProtectionTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_NameProtection.cc" ) target_link_libraries(NameProtectionTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET NameProtectionTest) add_executable(SATSolverTypesTest) target_sources(SATSolverTypesTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_SATSolverTypes.cc" ) target_link_libraries(SATSolverTypesTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET SATSolverTypesTest) add_executable(ArraysTest) target_sources(ArraysTest PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_Arrays.cc" ) target_link_libraries(ArraysTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET ArraysTest) opensmt-2.5.2/test/unit/test_ArithLogicApi.cc000066400000000000000000000035051445011647600212030ustar00rootroot00000000000000// // Created by Antti on 16.09.21. // #include #include #include class ArithLogicApiTest: public ::testing::Test { public: ArithLogicApiTest() : lraLogic(opensmt::Logic_t::QF_LRA) , liaLogic(opensmt::Logic_t::QF_LIA) , liraLogic(opensmt::Logic_t::QF_LIRA) {} ArithLogic lraLogic; ArithLogic liaLogic; ArithLogic liraLogic; }; TEST_F(ArithLogicApiTest, test_LRA) { PTRef c1 = lraLogic.mkConst("213"); PTRef r1 = lraLogic.mkConst("213.0"); ASSERT_EQ(c1, r1); ASSERT_TRUE(lraLogic.yieldsSortReal(c1)); ASSERT_TRUE(lraLogic.yieldsSortReal(r1)); PTRef c2 = lraLogic.mkRealVar("a"); ASSERT_NO_THROW(lraLogic.mkPlus(c1, c2)); ASSERT_THROW(lraLogic.mkTimes(c2, c2), LANonLinearException); ASSERT_THROW(lraLogic.mkIntVar("x"), OsmtApiException); ASSERT_THROW(lraLogic.mkIntConst(2), OsmtApiException); } TEST_F(ArithLogicApiTest, test_LIA) { PTRef c1 = liaLogic.mkConst("213"); ASSERT_TRUE(liaLogic.yieldsSortInt(c1)); ASSERT_THROW(liaLogic.mkConst("213.0"), OsmtApiException); PTRef c2 = liaLogic.mkIntVar("a"); ASSERT_NO_THROW(liaLogic.mkPlus(c1, c2)); ASSERT_THROW(liaLogic.mkTimes(c2, c2), LANonLinearException); ASSERT_THROW(liaLogic.mkRealVar("a"), OsmtApiException); ASSERT_THROW(liaLogic.mkRealConst(2), OsmtApiException); } TEST_F(ArithLogicApiTest, test_Mixed) { PTRef c1 = liraLogic.mkConst("213"); ASSERT_TRUE(liraLogic.yieldsSortInt(c1)); PTRef r1 = liraLogic.mkConst("213.0"); ASSERT_TRUE(liraLogic.yieldsSortReal(r1)); PTRef c2 = liraLogic.mkRealVar("a"); ASSERT_THROW(liraLogic.mkPlus(c1, c2), OsmtApiException); ASSERT_THROW(liraLogic.mkEq(c1, c2), OsmtApiException); PTRef d2 = liraLogic.mkIntVar("a"); ASSERT_NO_THROW(liraLogic.mkPlus(c1, d2)); }opensmt-2.5.2/test/unit/test_Arrays.cc000066400000000000000000000021021445011647600177550ustar00rootroot00000000000000/* * Copyright (c) 2023, Martin Blicha * * SPDX-License-Identifier: MIT * */ #include #include #include class ArraysTest: public ::testing::Test { public: ArraysTest() : logic(opensmt::Logic_t::QF_ALIA), zero(logic.getTerm_IntZero()), one(logic.getTerm_IntOne()) {} ArithLogic logic; PTRef zero; PTRef one; }; TEST_F(ArraysTest, test_NoDuplicateSorts) { SRef s1 = logic.getArraySort(logic.getSort_int(), logic.getSort_int()); SRef s2 = logic.getArraySort(logic.getSort_int(), logic.getSort_int()); ASSERT_EQ(s1, s2); } TEST_F(ArraysTest, test_ReadOverWrite) { SRef sref = logic.getArraySort(logic.getSort_int(), logic.getSort_int()); PTRef a = logic.mkVar(sref, "a"); PTRef store = logic.mkStore({a, zero, one}); PTRef select = logic.mkSelect({store, zero}); SMTConfig config; MainSolver solver(logic, config, "solver"); solver.insertFormula(logic.mkNot(logic.mkEq(select, one))); auto res = solver.check(); ASSERT_EQ(res, s_False); } opensmt-2.5.2/test/unit/test_Bounds.cc000066400000000000000000000013501445011647600177520ustar00rootroot00000000000000// // Created by Antti on 31.03.20. // #include #include class BoundTest: public ::testing::Test { public: BoundTest() {} }; TEST_F(BoundTest, test_LABounds) { LAVarStore vs; LABoundStore bs(vs); for (int k = 0; k < 100; k++) { vec vars; for (int i = 0; i < 100; i++) { vars.push(vs.getNewVar()); for (int j = 0; j < 10; j++) { if (j % 2 == 0) { bs.allocBoundPair(vars[i], { Delta(j), Delta(j, 1) }); } else { bs.allocBoundPair(vars[i], { Delta(j, -1), Delta(j) }); } } } bs.buildBounds(); bs.clear(); } } opensmt-2.5.2/test/unit/test_Delta.cpp000066400000000000000000000012401445011647600177440ustar00rootroot00000000000000#include #include TEST(Delta_test, test_ops_in_Delta) { Delta plus_infty(Delta::UPPER); Delta minus_infty(Delta::LOWER); ASSERT_EQ(plus_infty.isPlusInf(), true); ASSERT_EQ(minus_infty.isMinusInf(), true); ASSERT_EQ(minus_infty < plus_infty, true); ASSERT_EQ(minus_infty <= plus_infty, true); ASSERT_EQ(plus_infty > minus_infty, true); ASSERT_EQ(plus_infty >= minus_infty, true); ASSERT_EQ(!(plus_infty < minus_infty), true); ASSERT_EQ(!(plus_infty < minus_infty), true); ASSERT_EQ(!(minus_infty > plus_infty), true); ASSERT_EQ(!(minus_infty >= plus_infty), true); } opensmt-2.5.2/test/unit/test_Dominators.cpp000066400000000000000000000042371445011647600210430ustar00rootroot00000000000000// // Created by Martin Blicha on 31.10.18. // #include #include #include #include class Dominators_test : public ::testing::Test { public: Logic logic; PTRef a; PTRef b; PTRef c; Dominators_test() : logic{opensmt::Logic_t::QF_BOOL}, a(logic.mkBoolVar("a")), b(logic.mkBoolVar("b")), c(logic.mkBoolVar("c")) {} }; TEST_F(Dominators_test, test_PostOrderSimpleTree) { PTRef conj = logic.mkAnd(a,b); auto postOrder = getPostOrder(conj, logic); ASSERT_EQ(postOrder.size(), 3); ASSERT_EQ(postOrder[2], conj); } TEST_F(Dominators_test, test_PostOrderSimpleDAG) { PTRef conj = logic.mkAnd(a,b); PTRef neg = logic.mkNot(a); PTRef root = logic.mkOr(neg, conj); auto postOrder = getPostOrder(root, logic); ASSERT_EQ(postOrder.size(), 5); ASSERT_EQ(postOrder[4], root); ASSERT_GT(std::find(postOrder.begin(), postOrder.end(), neg) - std::find(postOrder.begin(), postOrder.end(), a), 0); ASSERT_GT(std::find(postOrder.begin(), postOrder.end(), conj) - std::find(postOrder.begin(), postOrder.end(), a), 0); ASSERT_GT(std::find(postOrder.begin(), postOrder.end(), conj) - std::find(postOrder.begin(), postOrder.end(), b), 0); } TEST_F(Dominators_test, test_Trivial) { auto idom = getImmediateDominators(a, logic); ASSERT_EQ(idom.size(), 1); ASSERT_EQ(idom.at(a), a); } TEST_F(Dominators_test, test_Tree) { PTRef a = logic.mkBoolVar("a"); PTRef b = logic.mkBoolVar("b"); PTRef conj = logic.mkAnd(a,b); auto idom = getImmediateDominators(conj, logic); ASSERT_EQ(idom.size(), 3); ASSERT_EQ(idom.at(a),conj); ASSERT_EQ(idom.at(b),conj); ASSERT_EQ(idom.at(conj),conj); } TEST_F(Dominators_test, test_SimpleDAG) { PTRef a = logic.mkBoolVar("a"); PTRef b = logic.mkBoolVar("b"); PTRef conj = logic.mkAnd(a,b); PTRef neg = logic.mkNot(a); PTRef root = logic.mkOr(neg, conj); auto idom = getImmediateDominators(root, logic); ASSERT_EQ(idom.size(), 5); ASSERT_EQ(idom.at(a),root); ASSERT_EQ(idom.at(b),conj); ASSERT_EQ(idom.at(conj),root); ASSERT_EQ(idom.at(neg),root); ASSERT_EQ(idom.at(root),root); } opensmt-2.5.2/test/unit/test_Egraph.cc000066400000000000000000000074411445011647600177350ustar00rootroot00000000000000/* * Copyright (c) 2018-2021, Martin Blicha * * SPDX-License-Identifier: MIT */ #include #include "Egraph.h" #include "TreeOps.h" TEST(UseVector_test, testAdd){ UseVector uv; ERef x{0}; uv.addParent(x); ASSERT_EQ(uv.size(), 1); EXPECT_TRUE(uv[0].isValid()); } TEST(UseVector_test, testAddAndRemove){ UseVector uv; ERef x{0}; uv.addParent(x); ASSERT_EQ(uv.size(), 1); uv.clearEntryAt(0); ASSERT_EQ(uv.size(), 0); auto entry = uv[0]; EXPECT_TRUE(entry.isFree()); uv.addParent(x); ASSERT_EQ(uv.size(), 1); entry = uv[0]; EXPECT_TRUE(entry.isValid()); } TEST(UseVector_test, testAddAndRemoveMultiple){ UseVector uv; ERef x{0}; uv.addParent(x); uv.addParent(x); ASSERT_EQ(uv.size(), 2); uv.clearEntryAt(0); ASSERT_EQ(uv.size(), 1); uv.clearEntryAt(1); ASSERT_EQ(uv.size(), 0); uv.addParent(x); ASSERT_EQ(uv.size(), 1); uv.addParent(x); ASSERT_EQ(uv.size(), 2); } TEST(UseVector_test, testWriteRead){ UseVector uv; ERef x{137}; auto index = uv.addParent(x); ASSERT_EQ(uv.size(), 1); auto entry = uv[index]; ASSERT_EQ(UseVector::entryToERef(entry), x); entry.mark(); entry.unmark(); ASSERT_EQ(UseVector::entryToERef(entry), x); } class EgraphTest: public ::testing::Test { public: Logic logic; Egraph egraph; SMTConfig c; EgraphTest() : logic{opensmt::Logic_t::QF_UF}, egraph(c, logic) {} }; TEST_F(EgraphTest, test_booleans) { PTRef v3 = logic.mkBoolVar("v3"); PTRef v7 = logic.mkBoolVar("v7"); SymRef uf3 = logic.declareFun("uf3", logic.getSort_bool(), {logic.getSort_bool()}); PTRef uf3_v7 = logic.mkUninterpFun(uf3, {v7}); PTRef uf3_v3 = logic.mkUninterpFun(uf3, {v3}); // Intentionally not declared to egraph PTRef eq = logic.mkEq(logic.mkNot(v3), uf3_v7); PTRef uf3_eq = logic.mkUninterpFun(uf3, {eq}); // Intentionally not declared to egraph AppearsInUfVisitor visitor(logic); // to mark booleans as needed for EGraph visitor.visit(uf3_v3); visitor.visit(uf3_eq); egraph.declareAtom(eq); egraph.declareAtom(v3); egraph.declareAtom(uf3_v7); ASSERT_TRUE(egraph.assertLit({v3, l_True})); ASSERT_TRUE(egraph.assertLit({uf3_v7, l_True})); ASSERT_FALSE(egraph.assertLit({eq, l_True})); vec expl; egraph.getConflict(expl); ASSERT_EQ(expl.size(), 3); for (auto pta : expl) { bool pta_found = false; for (auto pta_ref : vec{{v3, l_True}, {uf3_v7, l_True}, {eq, l_True}}) { pta_found |= (pta_ref == pta); } ASSERT_TRUE(pta_found); } } TEST_F(EgraphTest, test_IncrementalAddition) { SRef sref = logic.declareUninterpretedSort("U"); PTRef x = logic.mkVar(sref, "x"); PTRef y = logic.mkVar(sref, "y"); PTRef z = logic.mkVar(sref, "z"); SymRef f = logic.declareFun("f", sref, {sref}); PTRef fx = logic.mkUninterpFun(f, {x}); PTRef fy = logic.mkUninterpFun(f, {y}); PTRef eq1 = logic.mkEq(fx,fy); egraph.declareAtom(eq1); egraph.pushBacktrackPoint(); ASSERT_TRUE(egraph.assertLit({eq1, l_False})); ASSERT_EQ(egraph.check(true), TRes::SAT); PTRef eq2 = logic.mkEq(x,z); egraph.declareAtom(eq2); egraph.pushBacktrackPoint(); ASSERT_TRUE(egraph.assertLit({eq2, l_True})); ASSERT_EQ(egraph.check(true), TRes::SAT); PTRef eq3 = logic.mkEq(y,z); egraph.declareAtom(eq3); egraph.pushBacktrackPoint(); ASSERT_FALSE(egraph.assertLit({eq3, l_True})); egraph.popBacktrackPoint(); egraph.popBacktrackPoint(); egraph.pushBacktrackPoint(); ASSERT_TRUE(egraph.assertLit({eq2, l_False})); egraph.pushBacktrackPoint(); ASSERT_TRUE(egraph.assertLit({eq3, l_True})); ASSERT_EQ(egraph.check(true), TRes::SAT); } opensmt-2.5.2/test/unit/test_EnodeStore.cc000066400000000000000000000075041445011647600205760ustar00rootroot00000000000000// // Created by prova on 20.10.20. // #include #include #include #include class EnodeStoreTest : public ::testing::Test { protected: Logic logic; EnodeStoreTest() : logic(opensmt::Logic_t::QF_UF){} }; TEST_F(EnodeStoreTest, testUP) { PTRef A = logic.mkBoolVar("A"); PTRef B = logic.mkBoolVar("B"); PTRef conj = logic.mkAnd({A, B}); PTRef P_A = logic.mkUninterpFun(logic.declareFun("P", logic.getSort_bool(), {logic.getSort_bool()}), {A}); AppearsInUfVisitor(logic).visit(P_A); EnodeStore enodeStore(logic); for (auto tr : {B, conj}) { // No enode needed: B is a boolean atom not appearing in UF, and conj is a boolean operator not appearing in UF ASSERT_FALSE(enodeStore.needsEnode(tr)); } for (auto tr: {A, P_A}) { // Enode is needed: A appears in P_A and P_A is an uninterpreted predicate ASSERT_TRUE(enodeStore.needsEnode(tr)); } } TEST_F(EnodeStoreTest, testUPWithInternalConjIncr) { PTRef A = logic.mkBoolVar("A"); PTRef B = logic.mkBoolVar("B"); EnodeStore enodeStore(logic); for (auto tr : {A, B}) { // No enode needed: A and B are boolean predicates not appearing in UF ASSERT_FALSE(enodeStore.needsEnode(tr)); } PTRef conj = logic.mkAnd({A, B}); // No enode needed: conj is a boolean operator not appearing in UF ASSERT_FALSE(enodeStore.needsEnode(conj)); PTRef P_conj = logic.mkUninterpFun(logic.declareFun("P", logic.getSort_bool(), {logic.getSort_bool()}), {conj}); AppearsInUfVisitor(logic).visit(P_conj); // Enode needed: P is a UP ASSERT_TRUE(enodeStore.needsEnode(P_conj)); // Enode needed: conj appears in a UP ASSERT_TRUE(enodeStore.needsEnode(conj)); for (auto tr : {A, B}) { // No enode needed: A and B appear in conj, but not directly in P. ASSERT_FALSE(enodeStore.needsEnode(tr)); } PTRef Q_A = logic.mkUninterpFun(logic.declareFun("Q", logic.getSort_bool(), {logic.getSort_bool()}), {A}); AppearsInUfVisitor(logic).visit(Q_A); for (auto tr : {A, conj, Q_A}) { // Enode needed: A appears in the UP Q, conj still appears in P, Q_A is a UP ASSERT_TRUE(enodeStore.needsEnode(tr)); } // No enode needed: B appears only in conj, but not directly in a UF ASSERT_FALSE(enodeStore.needsEnode(B)); // Needs to be local } TEST_F(EnodeStoreTest, testUFEquality) { PTRef x = logic.mkBoolVar("x"); PTRef y = logic.mkBoolVar("y"); PTRef eq = logic.mkEq(x, y); EnodeStore enodeStore(logic); for (auto tr : {x, y, eq}) { // No enode: x, y, and eq are booleans not appearing in UF ASSERT_FALSE(enodeStore.needsEnode(tr)); } PTRef f = logic.mkUninterpFun(logic.declareFun("f", logic.getSort_bool(), {logic.getSort_bool()}), {eq}); AppearsInUfVisitor(logic).visit(f); for (auto tr : {f, eq}) { // Enodes needed: f is a UP and eq appears in f ASSERT_TRUE(enodeStore.needsEnode(tr)); } for (auto tr : {x, y}) { // No enodes needed: x and y do not appear directly in a UF ASSERT_FALSE(enodeStore.needsEnode(tr)); } } TEST_F(EnodeStoreTest, testUFMixed) { PTRef x = logic.mkBoolVar("x"); EnodeStore enodeStore(logic); // No enode needed: x is a boolean var not apparing in UF ASSERT_FALSE(enodeStore.needsEnode(x)); SRef ufsort = logic.declareUninterpretedSort("U"); PTRef a = logic.mkUninterpFun(logic.declareFun("a", ufsort, {}), {}); PTRef mixed = logic.mkUninterpFun(logic.declareFun("P", logic.getSort_bool(), {ufsort, logic.getSort_bool()}), {a, x}); AppearsInUfVisitor(logic).visit(mixed); // Enode needed: a is a UF, mixed is a UP, and x appears in mixed ASSERT_TRUE(enodeStore.needsEnode(a)); ASSERT_TRUE(enodeStore.needsEnode(mixed)); ASSERT_TRUE(enodeStore.needsEnode(x)); }opensmt-2.5.2/test/unit/test_Explain.cc000066400000000000000000000047511445011647600201300ustar00rootroot00000000000000// // Created by prova on 28.09.20. // #include #include #include #include #include class UFExplainTest : public ::testing::Test { using PTERef = PTRefERefPair; SRef ufsort; PTERef makeAndStorePTRef(PTRef tr) { vec v = store.constructTerm(tr); assert(v.size() == 1); return v[0]; } protected: Logic logic; EnodeStore store; PTERef c0; PTERef c1; PTERef c2; PTERef f_c1_c0; PTERef f_c2_c0; PTERef f_f_c2_c0_c0; UFExplainTest(): logic{opensmt::Logic_t::QF_UF}, store(logic) {} virtual void SetUp() { ufsort = logic.declareUninterpretedSort("U"); c0 = makeAndStorePTRef(logic.mkVar(ufsort, "c0")); c1 = makeAndStorePTRef(logic.mkVar(ufsort, "c1")); c2 = makeAndStorePTRef(logic.mkVar(ufsort, "c2")); SymRef f = logic.declareFun("f", ufsort, {ufsort, ufsort}); f_c1_c0 = makeAndStorePTRef(logic.insertTerm(f, {c1.tr, c0.tr})); f_c2_c0 = makeAndStorePTRef(logic.insertTerm(f, {c2.tr, c0.tr})); f_f_c2_c0_c0 = makeAndStorePTRef(logic.insertTerm(f, {f_c2_c0.tr, c0.tr})); } EnodeStore& getStore() { return store; } }; TEST_F(UFExplainTest, test_UFExplain) { PTRef eq1 = logic.mkEq(c2.tr, c1.tr); PTRef eq3 = logic.mkEq(f_f_c2_c0_c0.tr, c0.tr); PTRef eq7 = logic.mkEq(f_c1_c0.tr, c1.tr); Explainer explainer(store); explainer.storeExplanation(c2.er, c1.er, {eq1, l_True}); explainer.storeExplanation(f_f_c2_c0_c0.er, c0.er, {eq3, l_True}); explainer.storeExplanation(c1.er, f_c1_c0.er, {eq7, l_True}); explainer.storeExplanation(f_c1_c0.er, f_f_c2_c0_c0.er, PtAsgn_Undef); ASSERT_THROW(explainer.explain(c1.er, f_c2_c0.er), OsmtInternalException); explainer.storeExplanation(f_c2_c0.er, f_c1_c0.er, PtAsgn_Undef); ASSERT_NO_THROW(explainer.explain(c1.er, f_c2_c0.er)); ASSERT_NO_THROW(explainer.explain(c2.er, c0.er)); std::cout << logic.pp(c2.tr) << " = " << logic.pp(c0.tr) << ": " << std::endl; for (PtAsgn pta : explainer.explain(c2.er, c0.er)) { std::cout << " " << logic.pp(pta.tr) << std::endl; } for (auto ptRefPair : explainer.getCongruences()) { PTRef x = ptRefPair.first; PTRef y = ptRefPair.second; std::cout << logic.pp(x) << " = " << logic.pp(y) << std::endl; for (PtAsgn pta : explainer.explain(store.getERef(x), store.getERef(y))) { std::cout << " " << logic.pp(pta.tr) << std::endl; } } }opensmt-2.5.2/test/unit/test_FunctionTemplate.cc000066400000000000000000000054431445011647600220100ustar00rootroot00000000000000// // Created by Antti on 01.06.21. // #include #include #include #include class TemplateTest : public ::testing::Test { protected: Logic logic; SRef s; PTRef a1; PTRef a2; PTRef b1; PTRef b2; public: TemplateTest() : logic{opensmt::Logic_t::QF_UF} , s(logic.declareUninterpretedSort("S")) , a1(logic.mkVar(s, "a1")) , a2(logic.mkVar(s, "a2")) , b1(logic.mkVar(s, "b1")) , b2(logic.mkVar(s, "b2")) {} }; TEST_F(TemplateTest, test_functionSignature) { FunctionSignature fs("f", {a1, a2}, s); EXPECT_EQ(fs.getName(), "f"); EXPECT_EQ(fs.getRetSort(), s); const auto & args = fs.getArgs(); EXPECT_EQ(args[0], a1); EXPECT_EQ(args[1], a2); } TEST_F(TemplateTest, test_functionTemplate) { TemplateFunction templateFunction("f", {a1, a2}, s, a1); EXPECT_EQ(templateFunction.getName(), "f"); EXPECT_EQ(templateFunction.getRetSort(), s); EXPECT_EQ(templateFunction.getBody(), a1); const auto & args = templateFunction.getArgs(); EXPECT_EQ(args[0], a1); EXPECT_EQ(args[1], a2); templateFunction.updateBody(a2); EXPECT_EQ(templateFunction.getBody(), a2); TemplateFunction tf2(FunctionSignature("g", {a1, a2}, s), a2); EXPECT_EQ(tf2.getName(), "g"); EXPECT_EQ(tf2.getRetSort(), s); EXPECT_EQ(tf2.getBody(), a2); const auto & args2 = tf2.getArgs(); EXPECT_EQ(args2[0], a1); EXPECT_EQ(args2[1], a2); tf2.updateBody(a1); EXPECT_EQ(tf2.getBody(), a1); tf2 = std::move(templateFunction); EXPECT_EQ(tf2.getName(), "f"); EXPECT_EQ(tf2.getRetSort(), s); EXPECT_EQ(tf2.getBody(), a2); const auto & args3 = tf2.getArgs(); EXPECT_EQ(args3[0], a1); EXPECT_EQ(args3[1], a2); TemplateFunction tf3(tf2); EXPECT_EQ(tf3.getName(), tf2.getName()); EXPECT_EQ(tf3.getRetSort(), tf2.getRetSort()); EXPECT_EQ(tf3.getBody(), tf2.getBody()); EXPECT_EQ(tf3.getArgs()[0], tf2.getArgs()[0]); EXPECT_EQ(tf3.getArgs()[1], tf2.getArgs()[1]); TemplateFunction tf4(std::move(tf2)); EXPECT_EQ(tf3.getName(), tf4.getName()); EXPECT_EQ(tf3.getRetSort(), tf4.getRetSort()); EXPECT_EQ(tf3.getBody(), tf4.getBody()); EXPECT_EQ(tf3.getArgs()[0], tf4.getArgs()[0]); EXPECT_EQ(tf3.getArgs()[1], tf4.getArgs()[1]); } TEST_F(TemplateTest, test_template) { FunctionSignature fs("f", {a1, a2}, s); TemplateFunction temp("f", {a1, a2}, logic.getSort_bool(), logic.mkEq(a1, a2)); ASSERT_ANY_THROW(logic.instantiateFunctionTemplate(temp, {})); ASSERT_ANY_THROW(logic.instantiateFunctionTemplate(temp, {a1, logic.getTerm_true()})); PTRef res = logic.instantiateFunctionTemplate(temp, {b1,b2}); PTRef ref = logic.mkEq(b1, b2); ASSERT_EQ(res, ref); }opensmt-2.5.2/test/unit/test_HNF.cc000066400000000000000000000201421445011647600171330ustar00rootroot00000000000000#include #include #include class HNF_test : public ::testing::Test { protected: virtual void SetUp() { } LAVecAllocator va; LAVecStore vecStore {va}; LAMatrixStore ms {vecStore}; }; TEST_F(HNF_test, test_hnf1) { MId U = ms.getNewMatrix(4, 4); int u[4][4] = {{3, 0, 0, 0}, {3, 1, 0, 0}, {1, 0, 19, 0}, {4, 0, 16, 3}}; for (int i = 0; i < 4; i++) for (int j = 0; j < 4; j++) ms.MM(U, i+1, j+1) = u[i][j]; //HNF int hnf_ref[4][4] = {{3, 0, 0, 0}, {0, 1, 0, 0}, {1, 0, 19, 0}, {1, 0, 1, 3}}; MId H = ms.getNewMatrix(4, 4); int dim; MId U1 = MId_Undef; MId V1 = MId_Undef; ms.compute_hnf_v1(U, H, dim, U1, V1); printf("The hnf matrix:\n%s\n", ms.print(H).c_str()); for (int i = 0; i < 4; i++) for (int j = 0; j < 4; j++) ASSERT_EQ(ms.MM(H, i+1, j+1), hnf_ref[i][j]); } TEST_F(HNF_test, test_hnf2) { MId U = ms.getNewMatrix(4, 4); int u[4][4] = {{0, -2, -6, 4}, {-1, 3, -1, -2}, {1, 2, -2, -2}, {0, 1, 0, 10}}; for (int i = 0; i < 4; i++) for (int j = 0; j < 4; j++) ms.MM(U, i+1, j+1) = u[i][j]; //HNF int hnf_ref[4][4] = {{2, 0, 0, 0}, {0, 1, 0, 0}, {1, 5, 6, 0}, {11, 12, 12, 33}}; // Checked form numbertheory.org MId H = ms.getNewMatrix(4, 4); int dim; MId U1 = MId_Undef; MId V1 = MId_Undef; ms.compute_hnf_v1(U, H, dim, U1, V1); std::cout << "The hnf matrix: " << std::endl << ms.print(H) << std::endl; for (int i = 0; i < 4; i++) for (int j = 0; j < 4; j++) ASSERT_EQ(ms.MM(H, i+1, j+1), hnf_ref[i][j]); } TEST_F(HNF_test, test_hnf3) { int rows = 4; int cols = 3; MId U = ms.getNewMatrix(rows, cols); int u[4][3] = {{2, 5, 8}, {3, 6, 3}, {6, 1, 1}, {2, 6, 1}}; for (int i = 0; i < rows; i++) for (int j = 0; j < cols; j++) ms.MM(U, i+1, j+1) = u[i][j]; //HNF int hnf_ref[4][3] = {{1, 0, 0}, {0, 3, 0}, {50, 28, 61}, {-11, -2, -13}}; MId H = ms.getNewMatrix(rows, cols); int dim; MId U1 = MId_Undef; MId V1 = MId_Undef; ms.compute_hnf_v1(U, H, dim, U1, V1); std::cout << "The hnf matrix:" << std::endl << ms.print(H) << std::endl; for (int i = 0; i < rows; i++) for (int j = 0; j < cols; j++) ASSERT_EQ(ms.MM(H, i+1, j+1), hnf_ref[i][j]); } TEST_F(HNF_test, test_hnf4) { int rows = 4; int cols = 4; MId U = ms.getNewMatrix(rows, cols); int u[4][4] = {{1, 2, -6, -6}, {2, -5, -3, 7}, {-4, -3, 0, 0}, {1, -3, 5, -8}}; for (int i = 0; i < rows; i++) for (int j = 0; j < cols; j++) ms.MM(U, i+1, j+1) = u[i][j]; //HNF int hnf_ref[4][4] = {{1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}, {335, 286, 1663, 2873}}; MId H = ms.getNewMatrix(rows, cols); int dim; MId U1 = MId_Undef; MId V1 = MId_Undef; ms.compute_hnf_v1(U, H, dim, U1, V1); std::cout << "The hnf matrix:" << std::endl << ms.print(H) << std::endl; for (int i = 0; i < rows; i++) for (int j = 0; j < cols; j++) ASSERT_EQ(ms.MM(H, i+1, j+1), hnf_ref[i][j]); } TEST_F(HNF_test, test_hnf5) { int rows = 3; int cols = 3; MId U = ms.getNewMatrix(rows, cols); int u[3][3] = {{9, -36, 30}, {-36, 192, -180}, {30, -180, 180}}; for (int i = 0; i < rows; i++) for (int j = 0; j < cols; j++) ms.MM(U, i+1, j+1) = u[i][j]; //HNF int hnf_ref[3][3] = {{3, 0, 0}, {0, 12, 0}, {30, 0, 60}}; MId H = ms.getNewMatrix(rows, cols); int dim; MId U1 = MId_Undef; MId V1 = MId_Undef; ms.compute_hnf_v1(U, H, dim, U1, V1); std::cout << "The hnf matrix:" << std::endl << ms.print(H) << std::endl; for (int i = 0; i < rows; i++) for (int j = 0; j < cols; j++) ASSERT_EQ(ms.MM(H, i+1, j+1), hnf_ref[i][j]); } /* TEST_F(HNF_test, test_hnf6) { int rows = 4; int cols = 4; MId U = ms.getNewMatrix(rows, cols); int u[4][4] = {{-25, 15, -52, -16}, {36, -10, 26, -21}, {-44, 35, -66, 98}, {20, -12, 72, -30}}; for (int i = 0; i < rows; i++) for (int j = 0; j < cols; j++) ms.MM(U, i+1, j+1) = u[i][j]; //HNF int hnf_ref[4][4] = {{1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 2, 0}, {148191, 959683, 327841, 1083310}}; MId H = ms.getNewMatrix(rows, cols); int dim; MId U1 = MId_Undef; MId V1 = MId_Undef; ms.compute_hnf_v1(U, H, dim, U1, V1); cout << "The hnf matrix:" << endl << ms.print(H) << endl; for (int i = 0; i < rows; i++) for (int j = 0; j < cols; j++) ASSERT_EQ(ms.MM(H, i+1, j+1), hnf_ref[i][j]); } TEST_F(HNF_test, test_hnf7) { int rows = 5; int cols = 5; MId U = ms.getNewMatrix(rows, cols); int u[5][5] = {{25, -300, 1050, -1400, 630}, {-300, 4800, -18900, 26880, -12600}, {1050, -18900, 79380, -117600, 56700}, {-1400, 26880, -117600, 179200, -88200}, {630, -12600, 56700, -88200, 44100}}; for (int i = 0; i < rows; i++) for (int j = 0; j < cols; j++) ms.MM(U, i+1, j+1) = u[i][j]; //HNF int hnf_ref[5][5] = {{5, 0, 0, 0, 0}, {0, 60, 0, 0, 0}, {-210, 0, 420, 0, 0}, {-280, 0, 0, 840, 0}, {630, 0, 0, 0, 2520}}; MId H = ms.getNewMatrix(rows, cols); int dim; MId U1 = MId_Undef; MId V1 = MId_Undef; ms.compute_hnf_v1(U, H, dim, U1, V1); cout << "The hnf matrix:" << endl << ms.print(H) << endl; for (int i = 0; i < rows; i++) for (int j = 0; j < cols; j++) ASSERT_EQ(ms.MM(H, i+1, j+1), hnf_ref[i][j]); } */ TEST_F(HNF_test, test_hnf8) { int rows = 4; int cols = 5; MId U = ms.getNewMatrix(rows, cols); int u[4][5] = {{9, 6, 0, -8, 0}, {-5, -8, 0, 0, 0}, {0, 0, 0, 4, 0}, {0, 0, 0, -5, 0}}; for (int i = 0; i < rows; i++) for (int j = 0; j < cols; j++) ms.MM(U, i+1, j+1) = u[i][j]; //HNF int hnf_ref[4][5] = {{1, 0, 0, 0, 0}, {1, 2, 0, 0, 0}, {28, 36, 84, 0, 0}, {-35, -45, -105, 0, 0}}; MId H = ms.getNewMatrix(rows, cols); int dim; MId U1 = MId_Undef; MId V1 = MId_Undef; ms.compute_hnf_v1(U, H, dim, U1, V1); std::cout << "The hnf matrix:" << std::endl << ms.print(H) << std::endl; for (int i = 0; i < rows; i++) for (int j = 0; j < cols; j++) ASSERT_EQ(ms.MM(H, i+1, j+1), hnf_ref[i][j]); } TEST_F(HNF_test, test_hnf9) { int rows = 6; int cols = 4; MId U = ms.getNewMatrix(rows, cols); int u[6][4] = {{-5, -2, 7, 1}, {8, 8, -5, -1}, {-3, -2, -8, 6}, {-9, -2, 4, 0}, {5, 8, 3, 8}, {5, 5, -4, -3}}; for (int i = 0; i < rows; i++) for (int j = 0; j < cols; j++) ms.MM(U, i+1, j+1) = u[i][j]; //HNF int hnf_ref[6][4] = {{1, 0, 0, 0}, {0, 1, 0, 0}, {3, 1, 4, 0}, {237, 103, 352, 486}, {-299, -130, -450, -627}, {90, 40, 135, 188}}; MId H = ms.getNewMatrix(rows, cols); int dim; MId U1 = MId_Undef; MId V1 = MId_Undef; ms.compute_hnf_v1(U, H, dim, U1, V1); std::cout << "The hnf matrix:" << std::endl << ms.print(H) << std::endl; for (int i = 0; i < rows; i++) for (int j = 0; j < cols; j++) ASSERT_EQ(ms.MM(H, i+1, j+1), hnf_ref[i][j]); } opensmt-2.5.2/test/unit/test_IDLSolver.cpp000066400000000000000000000075031445011647600205260ustar00rootroot00000000000000// // Created by Martin Blicha on 12.12.19. // #include #include #include #include class IDLSolverTest : public ::testing::Test { protected: IDLSolverTest() : logic{opensmt::Logic_t::QF_IDL} {} virtual void SetUp() { x = logic.mkIntVar("x"); y = logic.mkIntVar("y"); z = logic.mkIntVar("z"); } SMTConfig config; ArithLogic logic; SRef ufsort; PTRef x; PTRef y; PTRef z; }; TEST_F(IDLSolverTest, test_SimpleTest){ PTRef ineq1 = logic.mkLeq(logic.mkMinus(x, y), logic.getTerm_IntZero()); PTRef ineq2 = logic.mkLeq(logic.mkMinus(y, z), logic.getTerm_IntZero()); PTRef ineq3 = logic.mkLeq(logic.mkMinus({z, x}), logic.mkIntConst(-1)); PTRef ineq4 = logic.mkLeq(logic.mkIntConst(3), x); PTRef ineq5 = logic.mkLeq(y, logic.mkIntConst(-2)); IDLSolver solver(config, logic); solver.declareAtom(ineq1); solver.declareAtom(ineq2); solver.declareAtom(ineq3); solver.declareAtom(ineq4); solver.declareAtom(ineq5); solver.pushBacktrackPoint(); solver.assertLit(PtAsgn(ineq1, l_True)); TRes res = solver.check(true); ASSERT_EQ(res, TRes::SAT); solver.pushBacktrackPoint(); solver.assertLit(PtAsgn(ineq2, l_True)); res = solver.check(true); ASSERT_EQ(res, TRes::SAT); solver.pushBacktrackPoint(); solver.assertLit(PtAsgn(ineq3, l_True)); res = solver.check(true); ASSERT_EQ(res, TRes::UNSAT); //vec v{}; //solver.getConflict(true, v); //ASSERT_TRUE(v[0] == PtAsgn(ineq1, l_True) && v[1] == PtAsgn(ineq2, l_True) // || v[0] == PtAsgn(ineq2, l_True) && v[1] == PtAsgn(ineq1, l_True)); solver.popBacktrackPoints(1); solver.assertLit(PtAsgn(ineq3, l_False)); res = solver.check(true); ASSERT_EQ(res, TRes::SAT); /**/ solver.pushBacktrackPoint(); solver.assertLit(PtAsgn(ineq4, l_True)); res = solver.check(true); ASSERT_EQ(res, TRes::SAT); solver.pushBacktrackPoint(); solver.assertLit(PtAsgn(ineq5, l_True)); res = solver.check(true); ASSERT_EQ(res, TRes::UNSAT); solver.popBacktrackPoints(1); solver.assertLit(PtAsgn(ineq5, l_False)); res = solver.check(true); ASSERT_EQ(res, TRes::SAT); /**/ solver.computeModel(); ModelBuilder builder(logic); solver.fillTheoryFunctions(builder); auto model = builder.build(); auto valX = model->evaluate(x); auto valY = model->evaluate(y); auto valZ = model->evaluate(z); ASSERT_NE(valX, PTRef_Undef); ASSERT_NE(valY, PTRef_Undef); ASSERT_NE(valZ, PTRef_Undef); ptrdiff_t numX, numY, numZ; std::stringstream ss(logic.pp(valX)); ss >> numX; std::stringstream ss2(logic.pp(valY)); ss2 >> numY; std::stringstream ss3(logic.pp(valZ)); ss3 >> numZ; ASSERT_LE(numX - numY, 0); ASSERT_LE(numY - numZ, 0); ASSERT_GT(numZ - numX, -1); ASSERT_LE(3, numX); ASSERT_GT(numY, -2); } class SafeIntTest : public ::testing::Test {}; TEST_F(SafeIntTest, test_add_pass){ SafeInt a(PTRDIFF_MAX - 1), b(1); SafeInt c(PTRDIFF_MIN + 1), d(-1); SafeInt e{}; ASSERT_NO_THROW(e = a + b); ASSERT_NO_THROW(e = c + d); } TEST_F(SafeIntTest, test_add_fail_over){ SafeInt a(PTRDIFF_MAX-2); SafeInt b(3); ASSERT_ANY_THROW(a+b); } TEST_F(SafeIntTest, test_add_fail_under){ SafeInt a(PTRDIFF_MIN + 100), b(-200); ASSERT_ANY_THROW(a+b); } TEST_F(SafeIntTest, test_sub_pass){ SafeInt a(PTRDIFF_MAX - 10); ASSERT_NO_THROW(a -= SafeInt(-10)); SafeInt b(PTRDIFF_MIN + 5); ASSERT_NO_THROW(b -= SafeInt(5)); } TEST_F(SafeIntTest, test_sub_fail_under){ SafeInt a(PTRDIFF_MIN + 100); ASSERT_ANY_THROW(a -= SafeInt(101)); } TEST_F(SafeIntTest, test_sub_fail_over){ SafeInt a(PTRDIFF_MAX - 42); ASSERT_ANY_THROW(a -= SafeInt(-43)); } opensmt-2.5.2/test/unit/test_Ites.cc000066400000000000000000000235011445011647600174260ustar00rootroot00000000000000// // Created by Antti on 04.08.20. // #include #include #include #include #include #include class LogicIteTest: public ::testing::Test { public: Logic logic; LogicIteTest() : logic{opensmt::Logic_t::QF_BOOL} {} }; class LRAIteTest: public ::testing::Test { public: ArithLogic logic; SRef lrasort; LRAIteTest() : logic{opensmt::Logic_t::QF_LRA}, lrasort(logic.getSort_real()) {} }; class IteManagerTest: public ::testing::Test { public: class IteToSwitchInternal: public IteToSwitch { public: const vec & getTopLevelItes() const { return iteDag.getTopLevelItes(); } IteToSwitchInternal(Logic &l, PTRef tr) : IteToSwitch(l, tr) {} }; ArithLogic logic; SRef lrasort; IteManagerTest() : logic{opensmt::Logic_t::QF_LRA}, lrasort(logic.getSort_real()) {} void printTopLevelSwitches(IteToSwitch &iteManager) { PTRef tr = logic.getTerm_true(); tr = iteManager.conjoin(tr); std::cout << logic.pp(tr) << std::endl; } static bool contains(const vec& trs, PTRef tr) { return std::any_of(trs.begin(), trs.end(), [tr](PTRef tr_in_vec) { return tr_in_vec == tr; }); } }; TEST_F(LogicIteTest, test_UFIte) { SRef ufsort = logic.declareUninterpretedSort("U"); PTRef x = logic.mkVar(ufsort, "x"); PTRef y = logic.mkVar(ufsort, "y"); PTRef cond = logic.mkEq(x, y); PTRef ite = logic.mkIte(cond, x, y); ASSERT_TRUE(logic.isIte(ite)); std::cout << logic.pp(ite) << std::endl; ite = logic.mkIte(logic.getTerm_true(), x, y); ASSERT_EQ(ite, x); ite = logic.mkIte(logic.getTerm_false(), x, y); ASSERT_EQ(ite, y); } TEST_F(LogicIteTest, test_BoolIte) { SRef boolsort = logic.getSort_bool(); PTRef x = logic.mkVar(boolsort, "x"); PTRef y = logic.mkVar(boolsort, "y"); PTRef cond = logic.mkEq(x, y); PTRef ite = logic.mkIte(cond, x, y); ASSERT_TRUE(logic.isIte(ite)); std::cout << logic.pp(ite) << std::endl; } TEST_F(LRAIteTest, test_LRAIte) { PTRef x = logic.mkVar(lrasort, "x"); PTRef y = logic.mkVar(lrasort, "y"); PTRef cond = logic.mkEq(x, y); PTRef ite = logic.mkIte(cond, x, y); ASSERT_TRUE(logic.isIte(ite)); std::cout << logic.pp(ite) << std::endl; } TEST_F(IteManagerTest, test_Basic) { PTRef x = logic.mkVar(lrasort, "x"); PTRef y = logic.mkVar(lrasort, "y"); PTRef cond = logic.mkEq(x, y); PTRef ite = logic.mkIte(cond, x, y); SRef sr = logic.getSortRef(ite); ASSERT_EQ(sr, lrasort); PTRef eq = logic.mkEq(x, ite); IteToSwitch iteManager(logic, eq); PTRef ites = iteManager.conjoin(logic.getTerm_true()); ASSERT_TRUE(logic.isAnd(ites)); Pterm& and_term = logic.getPterm(ites); ASSERT_TRUE(logic.isOr(and_term[0])); ASSERT_TRUE(logic.isOr(and_term[1])); Pterm& or_term_0 = logic.getPterm(and_term[0]); Pterm& or_term_1 = logic.getPterm(and_term[1]); ASSERT_TRUE(or_term_0[0] == cond || or_term_1[0] == cond || or_term_0[0] == logic.mkNot(cond) || or_term_1[0] == logic.mkNot(cond)); std::cout << logic.pp(ites) << std::endl; printTopLevelSwitches(iteManager); } TEST_F(IteManagerTest, test_IteTimesConst) { PTRef x = logic.mkVar(lrasort, "x"); PTRef y = logic.mkVar(lrasort, "y"); PTRef cond = logic.mkEq(x, y); PTRef c1 = logic.mkConst("1"); PTRef c2 = logic.mkConst("2"); PTRef ite = logic.mkIte(cond, c1, c2); EXPECT_NO_THROW(logic.mkTimes(ite, c2)); } TEST_F(IteManagerTest, test_IteTimesVar) { PTRef x = logic.mkVar(lrasort, "x"); PTRef y = logic.mkVar(lrasort, "y"); PTRef cond = logic.mkEq(x, y); PTRef c1 = logic.mkConst("1"); PTRef c2 = logic.mkConst("2"); PTRef ite = logic.mkIte(cond, c1, c2); EXPECT_THROW(logic.mkTimes(ite, x), LANonLinearException); } TEST_F(IteManagerTest, test_IteTimesIte) { PTRef x = logic.mkVar(lrasort, "x"); PTRef y = logic.mkVar(lrasort, "y"); PTRef z = logic.mkVar(lrasort, "z"); PTRef cond1 = logic.mkEq(x, y); PTRef c1 = logic.mkConst("1"); PTRef c2 = logic.mkConst("2"); PTRef ite1 = logic.mkIte(cond1, c1, c2); PTRef cond2 = logic.mkEq(x, z); PTRef ite2 = logic.mkIte(cond2, c2, c1); EXPECT_THROW(logic.mkTimes(ite1, ite2), LANonLinearException); } TEST_F(IteManagerTest, test_IteChain) { PTRef x = logic.mkVar(lrasort, "x"); PTRef y = logic.mkVar(lrasort, "y"); PTRef z = logic.mkVar(lrasort, "z"); PTRef cond1 = logic.mkEq(x, y); PTRef c1 = logic.mkConst("1"); PTRef c2 = logic.mkConst("2"); PTRef ite1 = logic.mkIte(cond1, c1, c2); PTRef cond2 = logic.mkEq(x, z); PTRef ite2 = logic.mkIte(cond2, ite1, c1); PTRef eq = logic.mkEq(x, ite2); IteToSwitchInternal iteManager(logic, eq); const vec & ites = iteManager.getTopLevelItes(); ASSERT_TRUE(contains(ites, ite2)); ASSERT_FALSE(contains(ites, ite1)); printTopLevelSwitches(iteManager); } TEST_F(IteManagerTest, test_IteSum) { PTRef x = logic.mkVar(lrasort, "x"); PTRef y = logic.mkVar(lrasort, "y"); PTRef cond = logic.mkEq(x, y); PTRef c1 = logic.mkConst("1"); PTRef c2 = logic.mkConst("2"); PTRef ite = logic.mkIte(cond, c1, c2); EXPECT_NO_THROW(logic.mkPlus(ite, c2)); } TEST_F(IteManagerTest, testBoolean) { PTRef c = logic.mkBoolVar("c"); PTRef a = logic.mkBoolVar("a"); // (ite c (and (ite c a (not a)) (not c)) (and a c))) PTRef ite1 = logic.mkIte(c, a, logic.mkNot(a)); PTRef and_tr = logic.mkAnd(ite1, logic.mkNot(c)); PTRef ite2 = logic.mkIte(c, and_tr, logic.mkAnd(a, c)); IteToSwitchInternal iteToSwitch(logic, ite2); ASSERT_TRUE(contains(iteToSwitch.getTopLevelItes(), ite1)); ASSERT_TRUE(contains(iteToSwitch.getTopLevelItes(), ite2)); PTRef tr = iteToSwitch.conjoin(logic.getTerm_true()); std::cout << logic.pp(tr) << std::endl << std::endl; std::cout << logic.pp(ite2) << std::endl; } TEST_F(LogicIteTest, test_IteHandlerNestedIte) { // (ite b (ite c a (not a)) d) PTRef a = logic.mkBoolVar("a"); PTRef b = logic.mkBoolVar("b"); PTRef c = logic.mkBoolVar("c"); PTRef d = logic.mkBoolVar("d"); PTRef inner = logic.mkIte(c, a, logic.mkNot(a)); PTRef outer = logic.mkIte(b, inner, d); IteHandler handler(logic); PTRef res = handler.rewrite(outer); std::cout << logic.pp(res) << std::endl; // only 1 variable should be introduced for the single top-level ITE auto vars = variables(logic, res); ASSERT_EQ(vars.size(), 5); // 4 original + 1 auxiliary variable } TEST_F(LogicIteTest, test_IteHandlerNestedAndTopLevelAtTheSameTime) { // (and (ite b (ite c a (not a)) d) (or d (ite c a (not a))) PTRef a = logic.mkBoolVar("a"); PTRef b = logic.mkBoolVar("b"); PTRef c = logic.mkBoolVar("c"); PTRef d = logic.mkBoolVar("d"); PTRef inner = logic.mkIte(c, a, logic.mkNot(a)); PTRef outer = logic.mkIte(b, inner, d); PTRef part2 = logic.mkOr(d, inner); PTRef fla = logic.mkAnd(outer, part2); IteHandler handler(logic); PTRef res = handler.rewrite(fla); std::cout << logic.pp(res) << std::endl; // 2 variables should be introduced since the ITE that is nested in the first part is top-level in the second part of the formula auto vars = variables(logic, res); ASSERT_EQ(vars.size(), 6); // 4 original + 2 auxiliary variables } TEST_F(LogicIteTest, test_IteHandler_RewriteTwiceSame) { // (ite b (ite c a (not a)) d) PTRef a = logic.mkBoolVar("a"); PTRef b = logic.mkBoolVar("b"); PTRef c = logic.mkBoolVar("c"); PTRef d = logic.mkBoolVar("d"); PTRef inner = logic.mkIte(c, a, logic.mkNot(a)); PTRef fla = logic.mkIte(b, inner, d); PTRef res1 = IteHandler(logic).rewrite(fla); PTRef res2 = IteHandler(logic).rewrite(fla); ASSERT_EQ(res1, res2); } TEST_F(LogicIteTest, test_IteHandler_RewriteTwiceDifferent) { // (ite b (ite c a (not a)) d) PTRef a = logic.mkBoolVar("a"); PTRef b = logic.mkBoolVar("b"); PTRef c = logic.mkBoolVar("c"); PTRef d = logic.mkBoolVar("d"); PTRef inner = logic.mkIte(c, a, logic.mkNot(a)); PTRef fla = logic.mkIte(b, inner, d); PTRef res1 = IteHandler(logic, 0).rewrite(fla); PTRef res2 = IteHandler(logic, 1).rewrite(fla); ASSERT_NE(res1, res2); } TEST_F(LogicIteTest, test_IteHandler_Inverse) { // (ite b (ite c a (not a)) d) PTRef a = logic.mkBoolVar("a"); PTRef b = logic.mkBoolVar("b"); PTRef c = logic.mkBoolVar("c"); PTRef d = logic.mkBoolVar("d"); SymRef PSym = logic.declareFun("P", logic.getSort_bool(), {logic.getSort_bool()}); PTRef inner = logic.mkIte(c, a, logic.mkNot(a)); PTRef fla = logic.mkIte(b, inner, d); PTRef P = logic.mkUninterpFun(PSym, {fla}); PTRef P2 = logic.mkUninterpFun(PSym, {inner}); PTRef PConj = logic.mkAnd({P, P2}); PTRef res = IteHandler(logic).rewrite(fla); PTRef res2 = IteHandler(logic).rewrite(PConj); PTRef res3 = IteHandler(logic, 0).rewrite(fla); PTRef res4 = IteHandler(logic, 0).rewrite(PConj); class AuxIteSymbolMatcher { Logic const & logic; public: AuxIteSymbolMatcher(Logic const & logic) : logic(logic) {} bool operator () (PTRef tr) { return std::string(logic.getSymName(tr)).compare(0, IteHandler::itePrefix.size(), IteHandler::itePrefix) == 0; } }; for (PTRef root : {res, res2, res3, res4}) { auto auxIteSymbolMatcherPredicate = AuxIteSymbolMatcher(logic); auto auxIteSymbolMatcherConfig = TermCollectorConfig(auxIteSymbolMatcherPredicate); PTRef rootWithItes = logic.removeAuxVars(root); TermVisitor(logic, auxIteSymbolMatcherConfig).visit(rootWithItes); auto auxIteTerms = auxIteSymbolMatcherConfig.extractCollectedTerms(); ASSERT_EQ(auxIteTerms.size(), 0); std::cout << logic.pp(root) << std::endl; std::cout << logic.pp(rootWithItes) << std::endl; } }opensmt-2.5.2/test/unit/test_LASolverIncrementality.cc000066400000000000000000000023731445011647600231250ustar00rootroot00000000000000/* * Copyright (c) 2021, Antti Hyvarinen * Copyright (c) 2021, Martin Blicha * * SPDX-License-Identifier: MIT */ #include #include class LASolverIncrementalityTest : public ::testing::Test { public: LASolverIncrementalityTest() : logic(opensmt::Logic_t::QF_LRA), solver(c, logic) {} SMTConfig c; ArithLogic logic; LASolver solver; }; TEST_F(LASolverIncrementalityTest, test_Incrementality) { // x >= 1 PTRef c1 = logic.getTerm_RealOne(); PTRef x = logic.mkRealVar("x"); PTRef constr1 = logic.mkGeq(x, c1); solver.declareAtom(constr1); solver.assertLit({constr1, l_True}); auto res = solver.check(true); ASSERT_EQ(res, TRes::SAT); // 0 <= -y - x PTRef y = logic.mkRealVar("y"); PTRef p1 = logic.mkMinus(logic.mkNeg(y), x); PTRef constr3 = logic.mkLeq(logic.getTerm_RealZero(), p1); solver.declareAtom(constr3); solver.assertLit({constr3, l_True}); res = solver.check(true); ASSERT_EQ(res, TRes::SAT); // y >= 1 PTRef constr2 = logic.mkGeq(y, c1); solver.declareAtom(constr2); solver.assertLit({constr2, l_True}); res = solver.check(true); ASSERT_EQ(res, TRes::UNSAT); }opensmt-2.5.2/test/unit/test_LIACutSolver.cpp000066400000000000000000000074711445011647600212030ustar00rootroot00000000000000#include #include #include #include #include #include #include #include using Polynomial = PolynomialT; TEST(LIACutSolver_test, test_computeEqualityBasis) { SMTConfig c; LAVarStore vs; //our system //y >= x + 0.5 //y >= -10x + 20 //y <= x - 5 LVRef x = vs.getNewVar(); LVRef y = vs.getNewVar(); //y - x LVRef y_minus_x = vs.getNewVar(); auto p_y_minus_x = std::make_unique(); p_y_minus_x->addTerm(x, -1); p_y_minus_x->addTerm(y, 1); //-y - 10x LVRef minus_y_minus_ten_x = vs.getNewVar(); auto p_minus_y_minus_ten_x = std::make_unique(); p_minus_y_minus_ten_x->addTerm(x, -10); p_minus_y_minus_ten_x->addTerm(y, -1); //2x - 2y LVRef two_x_minus_two_y = vs.getNewVar(); auto p_two_x_minus_two_y = std::make_unique(); p_two_x_minus_two_y->addTerm(y, -2); p_two_x_minus_two_y->addTerm(x, 2); LABoundStore bs(vs); //LABoundStore::BoundInfo y_minus_x_nostrict_m5 = bs.allocBoundPair(y_minus_x, -5, false); // y - x + 5 <= 0 //LABoundStore::BoundInfo two_x_minus_two_y_nostrict_m1 = bs.allocBoundPair(two_x_minus_two_y, -1, false); // 2x - 2y + 1 <= 0 //LABoundStore::BoundInfo minus_y_minus_ten_x_nostrict_m20 = bs.allocBoundPair(minus_y_minus_ten_x, -20, false); // -y - 10x + 20 <= 0 bs.buildBounds(); //Simplex s(c, m, bs); auto s = std::make_unique(bs); s->newNonbasicVar(x); s->newNonbasicVar(y); s->newRow(y_minus_x, std::move(p_y_minus_x)); s->newRow(two_x_minus_two_y, std::move(p_two_x_minus_two_y)); s->newRow(minus_y_minus_ten_x, std::move(p_minus_y_minus_ten_x)); Simplex::Explanation explanation = s->checkSimplex(); ASSERT_EQ(explanation.size(), 0); //this property has to be failed as the system is UNSAT then explanation size has to be >0 } /* * vec ex; ex.clear(); bool complete; ex = s->check_simplex(complete); ASSERT_EQ(ex.size(), 0); Real d = s->computeDelta(); Delta x_val = s.getValuation(x); cout << x_val.R() + x_val.D() * d << endl; Delta y_val = s.getValuation(y); cout << y_val.R() + y_val.D() * d << endl; Delta sum = s.getValuation(y_minus_x); cout << sum.R() + sum.D() * d << endl; //call initialize function and check delta part to see if initilize did its job ///up to now we created vars, polynomial, checked simplex on them and if simplex not UNSAT then compute equal basis std::unique_ptr eqBasisModel = model.copyFlat(); // copy the model as a snapshot of the most recent values auto eqBasisSimplex = std::unique_ptr(new Simplex(config, *eqBasisModel, boundStore)); eqBasisSimplex->initFromSimplex(s); // Initialize the new simplex (mostly tableau) from the old simplex //removes all bounds that cannot produce equalities and turns Ax<=b to Ax explanationBounds; eqBasisSimplex->checkSimplex(explanationBounds, explanationCoefficients); //size of explanation now has to increase, should not be zero d = eqBasisSimplex->computeDelta(); Delta x_val = eqBasisSimplex.getValuation(x); cout << x_val.R() + x_val.D() * d << endl; cout << x_val.D() << endl; Delta y_val = eqBasisSimplex.getValuation(y); cout << y_val.R() + y_val.D() * d << endl; cout << y_val.D() << endl; Delta sum = eqBasisSimplex.getValuation(y_minus_x); cout << sum.R() + sum.D() * d << endl; cout << sum.D() << endl; //1. give an example of inequallity system that implies equality //2. give it bounds //3. initialize removes all bounds that cannot produce equalities and turns Ax<=b to Ax #include #include #include #include using ItpColorMap = LIAInterpolator::ItpColorMap; class LIAInterpolationTest : public ::testing::Test { protected: LIAInterpolationTest(): logic{opensmt::Logic_t::QF_LIA} {} virtual void SetUp() { x = logic.mkIntVar("x"); y = logic.mkIntVar("y"); x1 = logic.mkIntVar("x1"); x2 = logic.mkIntVar("x2"); x3 = logic.mkIntVar("x3"); x4 = logic.mkIntVar("x4"); } ArithLogic logic; SMTConfig config; PTRef x, y, x1, x2, x3, x4; bool verifyInterpolant(PTRef A, PTRef B, PTRef itp) { return VerificationUtils(logic).verifyInterpolantInternal(A, B, itp); } }; TEST_F(LIAInterpolationTest, test_InterpolationLRASat){ /* * A: x > 0 * * B x < 1 */ PTRef zero = logic.getTerm_IntZero(); PTRef one = logic.getTerm_IntOne(); PTRef leq1 = logic.mkGt(x, zero); PTRef leq2 = logic.mkLt(x, one); vec conflict {PtAsgn(logic.mkNot(leq1), l_False), PtAsgn(logic.mkNot(leq2), l_False)}; ASSERT_TRUE(std::all_of(conflict.begin(), conflict.end(), [this](PtAsgn p) { return not logic.isNot(p.tr); })); ItpColorMap labels {{conflict[0].tr, icolor_t::I_A}, {conflict[1].tr, icolor_t::I_B}}; LIAInterpolator interpolator(logic, LAExplanations::getLIAExplanation(logic, conflict, {1,1}, labels)); PTRef farkasItp = interpolator.getFarkasInterpolant(); std::cout << logic.pp(farkasItp) << std::endl; EXPECT_TRUE(verifyInterpolant(leq1, leq2, farkasItp)); PTRef dualFarkasItp = interpolator.getDualFarkasInterpolant(); std::cout << logic.pp(dualFarkasItp) << std::endl; EXPECT_TRUE(verifyInterpolant(leq1, leq2, dualFarkasItp)); PTRef halfFarkasItp = interpolator.getFlexibleInterpolant(FastRational(1,2)); std::cout << logic.pp(halfFarkasItp) << std::endl; EXPECT_TRUE(verifyInterpolant(leq1, leq2, halfFarkasItp)); } TEST_F(LIAInterpolationTest, test_DecompositionInLIA){ /* * A: x1 > -1 * x2 - x1 > -1 * -x3 - x1 > -1 * B: * x3 - x4 > 0 * -x4 - x2 >= 0 * x4 >= 0 */ PTRef zero = logic.getTerm_IntZero(); PTRef minusOne = logic.getTerm_IntMinusOne(); PTRef leq1 = logic.mkGt(x1, minusOne); PTRef leq2 = logic.mkGt(logic.mkMinus(x2,x1), minusOne); PTRef leq3 = logic.mkGt(logic.mkNeg(logic.mkPlus(x3,x1)), minusOne); PTRef leq4 = logic.mkGt(logic.mkMinus(x3,x4), zero); PTRef leq5 = logic.mkGeq(logic.mkNeg(logic.mkPlus(x4,x2)), zero); PTRef leq6 = logic.mkGeq(x4, zero); vec conflict {PtAsgn(logic.mkNot(leq1), l_False), PtAsgn(logic.mkNot(leq2), l_False), PtAsgn(logic.mkNot(leq3), l_False), PtAsgn(logic.mkNot(leq4), l_False), PtAsgn(leq5, l_True), PtAsgn(leq6, l_True)}; ASSERT_TRUE(std::all_of(conflict.begin(), conflict.end(), [this](PtAsgn p) { return not logic.isNot(p.tr); })); ItpColorMap labels {{conflict[0].tr, icolor_t::I_A}, {conflict[1].tr, icolor_t::I_A}, {conflict[2].tr, icolor_t::I_A}, {conflict[3].tr, icolor_t::I_B}, {conflict[4].tr, icolor_t::I_B}, {conflict[5].tr, icolor_t::I_B}}; LIAInterpolator interpolator(logic, LAExplanations::getLIAExplanation(logic, std::move(conflict), {2,1,1,1,1,2}, labels)); PTRef decomposedFarkasItp = interpolator.getDecomposedInterpolant(); EXPECT_TRUE(verifyInterpolant(logic.mkAnd({leq1, leq2, leq3}), logic.mkAnd({leq4, leq5, leq6}), decomposedFarkasItp)); std::cout << logic.pp(decomposedFarkasItp) << std::endl; ASSERT_TRUE(logic.isAnd(decomposedFarkasItp)); PTRef dualDecomposedFarkasItp = interpolator.getDualDecomposedInterpolant(); EXPECT_TRUE(verifyInterpolant(logic.mkAnd({leq1, leq2, leq3}), logic.mkAnd({leq4, leq5, leq6}), dualDecomposedFarkasItp)); // std::cout << logic.pp(dualDecomposedFarkasItp) << std::endl; } TEST_F(LIAInterpolationTest, test_Split_ALocal){ /* * A: 3y - 2x >= 0 * 2x - y >= 2 * B: * y <= 1 */ PTRef zero = logic.getTerm_IntZero(); PTRef one = logic.getTerm_IntOne(); PTRef two = logic.mkConst("2"); PTRef three = logic.mkConst("3"); PTRef leq1 = logic.mkGeq(logic.mkMinus(logic.mkTimes(three, y), logic.mkTimes(two, x)), zero); PTRef leq2 = logic.mkGeq(logic.mkMinus(logic.mkTimes(two, x), y), two); PTRef leq3 = logic.mkLeq(y, one); const char* msg = "ok"; config.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); MainSolver solver(logic, config, "test"); PTRef partA = logic.mkAnd(leq1, leq2); PTRef partB = leq3; solver.insertFormula(partA); solver.insertFormula(partB); auto res = solver.check(); ASSERT_EQ(res, s_False); auto itpCtx = solver.getInterpolationContext(); vec interpolants; ipartitions_t mask; opensmt::setbit(mask, 0); itpCtx->getSingleInterpolant(interpolants, mask); std::cout << logic.pp(interpolants[0]) << std::endl; EXPECT_TRUE(verifyInterpolant(partA, partB, interpolants[0])); } TEST_F(LIAInterpolationTest, test_Split_BLocal){ /* * B: 3y - 2x >= 0 * 2x - y >= 2 * A: * y <= 1 */ PTRef zero = logic.getTerm_IntZero(); PTRef one = logic.getTerm_IntOne(); PTRef two = logic.mkConst("2"); PTRef three = logic.mkConst("3"); PTRef leq1 = logic.mkGeq(logic.mkMinus(logic.mkTimes(three, y), logic.mkTimes(two, x)), zero); PTRef leq2 = logic.mkGeq(logic.mkMinus(logic.mkTimes(two, x), y), two); PTRef leq3 = logic.mkLeq(y, one); const char* msg = "ok"; config.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); MainSolver solver(logic, config, "test"); PTRef partB = logic.mkAnd(leq1, leq2); PTRef partA = leq3; solver.insertFormula(partA); solver.insertFormula(partB); auto res = solver.check(); ASSERT_EQ(res, s_False); auto itpCtx = solver.getInterpolationContext(); vec interpolants; ipartitions_t mask; opensmt::setbit(mask, 0); itpCtx->getSingleInterpolant(interpolants, mask); std::cout << logic.pp(interpolants[0]) << std::endl; EXPECT_TRUE(verifyInterpolant(partA, partB, interpolants[0])); } TEST_F(LIAInterpolationTest, test_Split_ABShared) { /* * A: 3y - 2x >= 0 * * B: * 2x - y >= 2 * y <= 1 */ PTRef zero = logic.getTerm_IntZero(); PTRef one = logic.getTerm_IntOne(); PTRef two = logic.mkConst("2"); PTRef three = logic.mkConst("3"); PTRef leq1 = logic.mkGeq(logic.mkMinus(logic.mkTimes(three, y), logic.mkTimes(two, x)), zero); PTRef leq2 = logic.mkGeq(logic.mkMinus(logic.mkTimes(two, x), y), two); PTRef leq3 = logic.mkLeq(y, one); const char* msg = "ok"; config.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); MainSolver solver(logic, config, "test"); PTRef partA = leq1; PTRef partB = logic.mkAnd(leq2, leq3); solver.insertFormula(partA); solver.insertFormula(partB); auto res = solver.check(); ASSERT_EQ(res, s_False); auto itpCtx = solver.getInterpolationContext(); vec interpolants; ipartitions_t mask; opensmt::setbit(mask, 0); itpCtx->getSingleInterpolant(interpolants, mask); std::cout << logic.pp(interpolants[0]) << std::endl; EXPECT_TRUE(verifyInterpolant(partA, partB, interpolants[0])); interpolants.clear(); config.setBooleanInterpolationAlgorithm(itp_alg_pudlak); itpCtx->getSingleInterpolant(interpolants, mask); std::cout << logic.pp(interpolants[0]) << std::endl; EXPECT_TRUE(verifyInterpolant(partA, partB, interpolants[0])); interpolants.clear(); config.setBooleanInterpolationAlgorithm(itp_alg_mcmillanp); itpCtx->getSingleInterpolant(interpolants, mask); std::cout << logic.pp(interpolants[0]) << std::endl; EXPECT_TRUE(verifyInterpolant(partA, partB, interpolants[0])); interpolants.clear(); }opensmt-2.5.2/test/unit/test_LIALogicMkTerms.cc000066400000000000000000000175051445011647600214170ustar00rootroot00000000000000// // Created by prova on 11.09.20. // #include #include #include "DivModRewriter.h" #include "IteHandler.h" #include "TreeOps.h" class LIALogicMkTermsTest: public ::testing::Test { protected: LIALogicMkTermsTest() : logic(opensmt::Logic_t::QF_LIA) {} virtual void SetUp() { x = logic.mkIntVar("x"); y = logic.mkIntVar("y"); z = logic.mkIntVar("z"); } ArithLogic logic; PTRef x; PTRef y; PTRef z; }; TEST_F(LIALogicMkTermsTest, testIsNumTerm) { PTRef c = logic.mkBoolVar("c"); ASSERT_FALSE(logic.isNumTerm(c)); PTRef t = logic.mkIntVar("t"); ASSERT_TRUE(logic.isNumTerm(t)); PTRef e = logic.mkTimes(logic.mkIntVar("e"), logic.mkIntConst(-114)); ASSERT_TRUE(logic.isNumTerm(e)); PTRef ite = logic.mkIte(c, t, e); ASSERT_TRUE(logic.isNumTerm(ite)); PTRef ite_term = logic.mkTimes(ite, logic.mkIntConst(14)); ASSERT_TRUE(logic.isNumTerm(ite_term)); PTRef sum = logic.mkPlus(t, e); ASSERT_FALSE(logic.isNumTerm(sum)); } TEST_F(LIALogicMkTermsTest, testDeepLessThan) { PTRef a = logic.mkIntConst(3); PTRef b = logic.mkIntConst(-4); PTRef prod2 = logic.mkTimes(y, b); PTRef prod1 = logic.mkTimes(x, a); LessThan_deepPTRef lt_deep(logic); ASSERT_EQ(lt_deep(prod1, prod2), lt_deep(x, y)); // LessThan_PTRef lt_shallow; // ASSERT_NE(lt_shallow(prod1, prod2), lt_shallow(x, y)); } TEST_F(LIALogicMkTermsTest, testDivMod) { PTRef two = logic.mkIntConst(2); PTRef div = logic.mkIntDiv(x,two); PTRef mod = logic.mkMod(x, two); EXPECT_EQ(logic.getSymRef(div), logic.get_sym_Int_DIV()); EXPECT_EQ(logic.getSymRef(mod), logic.get_sym_Int_MOD()); } TEST_F(LIALogicMkTermsTest, testMod_Plus) { PTRef two = logic.mkIntConst(2); PTRef mod = logic.mkMod(x,two); PTRef plus = logic.mkPlus(mod, two); EXPECT_EQ(logic.getSymRef(plus), logic.get_sym_Int_PLUS()); } TEST_F(LIALogicMkTermsTest, testMod_Times) { PTRef two = logic.mkIntConst(2); PTRef three = logic.mkIntConst(3); PTRef mod = logic.mkMod(x,two); PTRef times = logic.mkTimes(mod, three); EXPECT_EQ(logic.getSymRef(times), logic.get_sym_Int_TIMES()); } TEST_F(LIALogicMkTermsTest, testMod_Leq) { PTRef two = logic.mkIntConst(2); PTRef three = logic.mkIntConst(3); PTRef mod = logic.mkMod(x,two); PTRef leq = logic.mkLeq(mod, three); EXPECT_EQ(logic.getSymRef(leq), logic.get_sym_Int_LEQ()); } TEST_F(LIALogicMkTermsTest, testMod_One) { PTRef one = logic.getTerm_IntOne(); PTRef zero = logic.getTerm_IntZero(); PTRef mod = logic.mkMod(x, one); EXPECT_EQ(mod, zero); PTRef minusOne = logic.getTerm_IntMinusOne(); mod = logic.mkMod(x, minusOne); EXPECT_EQ(mod, zero); } TEST_F(LIALogicMkTermsTest, testDiv_Constants_PosPos) { PTRef two = logic.mkIntConst(2); PTRef three = logic.mkIntConst(3); PTRef div = logic.mkIntDiv(two, three); PTRef mod = logic.mkMod(two, three); EXPECT_EQ(div, logic.getTerm_IntZero()); EXPECT_EQ(mod, two); } TEST_F(LIALogicMkTermsTest, testDiv_Constants_PosNeg) { PTRef two = logic.mkIntConst(2); PTRef mthree = logic.mkIntConst(-3); PTRef div = logic.mkIntDiv(two, mthree); PTRef mod = logic.mkMod(two, mthree); EXPECT_EQ(div, logic.getTerm_IntZero()); EXPECT_EQ(mod, two); } TEST_F(LIALogicMkTermsTest, testDiv_Constants_NegPos) { PTRef mtwo = logic.mkIntConst(-2); PTRef three = logic.mkIntConst(3); PTRef div = logic.mkIntDiv(mtwo, three); PTRef mod = logic.mkMod(mtwo, three); EXPECT_EQ(div, logic.mkIntConst(-1)); EXPECT_EQ(mod, logic.getTerm_IntOne()); } TEST_F(LIALogicMkTermsTest, testDiv_Constants_NegNeg) { PTRef mtwo = logic.mkIntConst(-2); PTRef mthree = logic.mkIntConst(-3); PTRef div = logic.mkIntDiv(mtwo, mthree); PTRef mod = logic.mkMod(mtwo, mthree); EXPECT_EQ(div, logic.getTerm_IntOne()); EXPECT_EQ(mod, logic.getTerm_IntOne()); } TEST_F(LIALogicMkTermsTest, testDiv_One) { PTRef one = logic.getTerm_IntOne(); PTRef div = logic.mkIntDiv(x, one); EXPECT_EQ(div, x); PTRef minusOne = logic.getTerm_IntMinusOne(); div = logic.mkIntDiv(x, minusOne); EXPECT_EQ(div, logic.mkNeg(x)); } TEST_F(LIALogicMkTermsTest, test_Inequality_Simplification) { PTRef two = logic.mkConst("2"); ASSERT_EQ( logic.mkLeq(logic.mkPlus(x,y), z), logic.mkLeq( logic.mkPlus(logic.mkTimes(x, two), logic.mkTimes(y, two)), logic.mkTimes(z, two) ) ); } TEST_F(LIALogicMkTermsTest, test_EqualityNormalization_Commutativity) { PTRef two = logic.mkIntConst(2); PTRef eq1 = logic.mkEq(x, two); PTRef eq2 = logic.mkEq(two, x); ASSERT_EQ(eq1, eq2); } TEST_F(LIALogicMkTermsTest, test_EqualityNormalization) { PTRef two = logic.mkIntConst(2); PTRef eq1 = logic.mkEq(x, y); PTRef eq2 = logic.mkEq(logic.mkTimes(x, two), logic.mkTimes(y, two)); // std::cout << logic.printTerm(eq1) << std::endl; // std::cout << logic.printTerm(eq2) << std::endl; EXPECT_EQ(eq1, eq2); } TEST_F(LIALogicMkTermsTest, test_EqualityNormalization_ToConstantExpression) { PTRef two = logic.mkIntConst(2); PTRef eq1 = logic.mkEq(x, logic.mkPlus(x, two)); EXPECT_EQ(eq1, logic.getTerm_false()); PTRef eq2 = logic.mkEq(logic.mkTimes(x, two), logic.getTerm_IntOne()); EXPECT_EQ(eq2, logic.getTerm_false()); } TEST_F(LIALogicMkTermsTest, test_EqualityNormalization_AlreadyNormalized) { PTRef two = logic.mkIntConst(2); PTRef three = logic.mkIntConst(3); PTRef eq1 = logic.mkEq(logic.mkPlus(logic.mkTimes(x, two), logic.mkTimes(y, three)), logic.getTerm_IntOne()); ASSERT_NE(eq1, logic.getTerm_false()); EXPECT_EQ(logic.getSymRef(eq1), logic.get_sym_Int_EQ()); } TEST_F(LIALogicMkTermsTest, test_EqualityNormalization_EqualityToConstant) { PTRef two = logic.mkIntConst(2); PTRef eq = logic.mkEq(x, two); PTRef lhs = logic.getPterm(eq)[0]; PTRef rhs = logic.getPterm(eq)[1]; EXPECT_NE(logic.getSymRef(lhs), logic.get_sym_Int_TIMES()); EXPECT_NE(logic.getSymRef(rhs), logic.get_sym_Int_TIMES()); } TEST_F(LIALogicMkTermsTest, test_ReverseAuxRewrite) { static constexpr std::initializer_list prefixes = {IteHandler::itePrefix, DivModConfig::divPrefix, DivModConfig::modPrefix}; auto hasAuxSymbols = [this](PTRef tr) { class AuxSymbolMatcher { ArithLogic const & logic; public: AuxSymbolMatcher(ArithLogic const & logic) : logic(logic) {} bool operator()(PTRef tr) { std::string_view const name = logic.getSymName(tr); return std::any_of(prefixes.begin(), prefixes.end(), [&name](std::string_view const prefix) { return name.compare(0, prefix.size(), prefix) == 0; }); }; }; auto predicate = AuxSymbolMatcher(logic); auto config = TermCollectorConfig(predicate); TermVisitor(logic, config).visit(tr); return config.extractCollectedTerms().size() > 0; }; PTRef a = logic.mkIntVar("a"); PTRef c = logic.mkIntConst(5); PTRef modTerm = logic.mkMod(a, c); PTRef term = logic.mkEq(logic.getTerm_IntZero(), modTerm); PTRef res = logic.mkIntVar("res"); PTRef cond = logic.mkBoolVar("cond"); PTRef divTerm = logic.mkIntDiv(a, c); PTRef ite = logic.mkIte(cond, modTerm, divTerm); PTRef eq = logic.mkEq(res, ite); PTRef nested = logic.mkEq(logic.getTerm_IntZero(), logic.mkMod(ite, c)); for (PTRef tr : {term, eq, nested}) { PTRef termWithAux = DivModRewriter(logic).rewrite(IteHandler(logic).rewrite(tr)); ASSERT_TRUE(hasAuxSymbols(termWithAux)); PTRef termWithoutAux = logic.removeAuxVars(termWithAux); std::cout << logic.pp(termWithoutAux) << std::endl; ASSERT_FALSE(hasAuxSymbols(termWithoutAux)); } }opensmt-2.5.2/test/unit/test_LIAStrengthening.cc000066400000000000000000000013511445011647600216660ustar00rootroot00000000000000// // Created by prova on 30.09.20. // #include #include #include #include #include #include #include class LIAStrengthening: public ::testing::Test { public: ArithLogic logic; LIAStrengthening() : logic{opensmt::Logic_t::QF_LIA} {} }; TEST_F(LIAStrengthening, test_LIAStrengthening) { PTRef c2 = logic.mkIntConst(2); PTRef c3 = logic.mkIntConst(3); PTRef x = logic.mkIntVar("x"); PTRef y = logic.mkIntVar("y"); PTRef sum = logic.mkTimes(c2, logic.mkPlus(x, y)); PTRef ineq = logic.mkGeq(sum, c3); ASSERT_EQ(logic.getConstantFromLeq(ineq), logic.mkConst("2")); ASSERT_EQ(logic.getTermFromLeq(ineq), logic.mkPlus(x,y)); } opensmt-2.5.2/test/unit/test_LRAInterpolation.cc000066400000000000000000000361541445011647600217200ustar00rootroot00000000000000// // Created by Martin Blicha on 19.09.20. // #include #include #include #include using ItpColorMap = FarkasInterpolator::ItpColorMap; class LRAInterpolationTest : public ::testing::Test { protected: LRAInterpolationTest(): logic{opensmt::Logic_t::QF_LRA} {} virtual void SetUp() { x = logic.mkRealVar("x"); y = logic.mkRealVar("y"); x1 = logic.mkRealVar("x1"); x2 = logic.mkRealVar("x2"); x3 = logic.mkRealVar("x3"); x4 = logic.mkRealVar("x4"); } ArithLogic logic; PTRef x, y, x1, x2, x3, x4; bool verifyInterpolant(PTRef A, PTRef B, PTRef itp) { return VerificationUtils(logic).verifyInterpolantInternal(A, B, itp); } }; TEST_F(LRAInterpolationTest, test_FarkasInterpolation_BothNonstrict){ /* * A: x1 + x2 <= 0 * -x2 - x3 <= 0 * * B x1 - x4 >= 1 * x4 - x3 >= 0 */ PTRef zero = logic.getTerm_RealZero(); PTRef leq1 = logic.mkLeq(logic.mkPlus(x1,x2), zero); PTRef leq2 = logic.mkLeq(logic.mkNeg(logic.mkPlus(x2,x3)), zero); PTRef leq3 = logic.mkGeq(logic.mkMinus(x1,x4), logic.getTerm_RealOne()); PTRef leq4 = logic.mkGeq(logic.mkMinus(x4,x3), zero); vec conflict {PtAsgn(leq1, l_True), PtAsgn(leq2, l_True), PtAsgn(leq3, l_True), PtAsgn(leq4, l_True)}; ASSERT_TRUE(std::all_of(conflict.begin(), conflict.end(), [this](PtAsgn p) { return not logic.isNot(p.tr); })); ItpColorMap labels {{conflict[0].tr, icolor_t::I_A}, {conflict[1].tr, icolor_t::I_A}, {conflict[2].tr, icolor_t::I_B}, {conflict[3].tr, icolor_t::I_B}}; FarkasInterpolator interpolator(logic, std::move(conflict), {1,1,1,1}, labels); PTRef farkasItp = interpolator.getFarkasInterpolant(); // std::cout << logic.pp(farkasItp) << std::endl; EXPECT_TRUE(verifyInterpolant(logic.mkAnd(leq1, leq2), logic.mkAnd(leq3, leq4), farkasItp)); PTRef dualFarkasItp = interpolator.getDualFarkasInterpolant(); // std::cout << logic.pp(dualFarkasItp) << std::endl; EXPECT_TRUE(verifyInterpolant(logic.mkAnd(leq1, leq2), logic.mkAnd(leq3, leq4), dualFarkasItp)); PTRef halfFarkasItp = interpolator.getFlexibleInterpolant(FastRational(1,2)); // std::cout << logic.pp(halfFarkasItp) << std::endl; EXPECT_TRUE(verifyInterpolant(logic.mkAnd(leq1, leq2), logic.mkAnd(leq3, leq4), halfFarkasItp)); } TEST_F(LRAInterpolationTest, test_FarkasInterpolation_Astrict){ /* * A: x1 + x2 < 0 * -x2 - x3 <= 0 * * B x1 - x4 >= 1 * x4 - x3 >= 0 */ PTRef zero = logic.getTerm_RealZero(); PTRef leq1 = logic.mkLt(logic.mkPlus(x1,x2), zero); PTRef leq2 = logic.mkLeq(logic.mkNeg(logic.mkPlus(x2,x3)), zero); PTRef leq3 = logic.mkGeq(logic.mkMinus(x1,x4), logic.getTerm_RealOne()); PTRef leq4 = logic.mkGeq(logic.mkMinus(x4,x3), zero); vec conflict {PtAsgn(logic.mkNot(leq1), l_False), PtAsgn(leq2, l_True), PtAsgn(leq3, l_True), PtAsgn(leq4, l_True)}; ASSERT_TRUE(std::all_of(conflict.begin(), conflict.end(), [this](PtAsgn p) { return not logic.isNot(p.tr); })); ItpColorMap labels {{conflict[0].tr, icolor_t::I_A}, {conflict[1].tr, icolor_t::I_A}, {conflict[2].tr, icolor_t::I_B}, {conflict[3].tr, icolor_t::I_B}}; FarkasInterpolator interpolator(logic, std::move(conflict), {1,1,1,1}, labels); PTRef farkasItp = interpolator.getFarkasInterpolant(); // std::cout << logic.pp(farkasItp) << std::endl; EXPECT_TRUE(verifyInterpolant(logic.mkAnd(leq1, leq2), logic.mkAnd(leq3, leq4), farkasItp)); PTRef dualFarkasItp = interpolator.getDualFarkasInterpolant(); // std::cout << logic.pp(dualFarkasItp) << std::endl; EXPECT_TRUE(verifyInterpolant(logic.mkAnd(leq1, leq2), logic.mkAnd(leq3, leq4), dualFarkasItp)); PTRef halfFarkasItp = interpolator.getFlexibleInterpolant(FastRational(1,2)); // std::cout << logic.pp(halfFarkasItp) << std::endl; EXPECT_TRUE(verifyInterpolant(logic.mkAnd(leq1, leq2), logic.mkAnd(leq3, leq4), halfFarkasItp)); } TEST_F(LRAInterpolationTest, test_FarkasInterpolation_Bstrict){ /* * A: x1 + x2 <= 0 * -x2 - x3 <= 0 * * B x1 - x4 > 1 * x4 - x3 >= 0 */ PTRef zero = logic.getTerm_RealZero(); PTRef leq1 = logic.mkLeq(logic.mkPlus(x1,x2), zero); PTRef leq2 = logic.mkLeq(logic.mkNeg(logic.mkPlus(x2,x3)), zero); PTRef leq3 = logic.mkGt(logic.mkMinus(x1,x4), logic.getTerm_RealOne()); PTRef leq4 = logic.mkGeq(logic.mkMinus(x4,x3), zero); vec conflict {PtAsgn(leq1, l_True), PtAsgn(leq2, l_True), PtAsgn(logic.mkNot(leq3), l_False), PtAsgn(leq4, l_True)}; ASSERT_TRUE(std::all_of(conflict.begin(), conflict.end(), [this](PtAsgn p) { return not logic.isNot(p.tr); })); ItpColorMap labels {{conflict[0].tr, icolor_t::I_A}, {conflict[1].tr, icolor_t::I_A}, {conflict[2].tr, icolor_t::I_B}, {conflict[3].tr, icolor_t::I_B}}; FarkasInterpolator interpolator(logic, std::move(conflict), {1,1,1,1}, labels); PTRef farkasItp = interpolator.getFarkasInterpolant(); // std::cout << logic.pp(farkasItp) << std::endl; EXPECT_TRUE(verifyInterpolant(logic.mkAnd(leq1, leq2), logic.mkAnd(leq3, leq4), farkasItp)); PTRef dualFarkasItp = interpolator.getDualFarkasInterpolant(); // std::cout << logic.pp(dualFarkasItp) << std::endl; EXPECT_TRUE(verifyInterpolant(logic.mkAnd(leq1, leq2), logic.mkAnd(leq3, leq4), dualFarkasItp)); PTRef halfFarkasItp = interpolator.getFlexibleInterpolant(FastRational(1,2)); // std::cout << logic.pp(halfFarkasItp) << std::endl; EXPECT_TRUE(verifyInterpolant(logic.mkAnd(leq1, leq2), logic.mkAnd(leq3, leq4), halfFarkasItp)); } TEST_F(LRAInterpolationTest, test_FarkasInterpolation_BothStrict){ /* * A: x1 + x2 < 0 * -x2 - x3 <= 0 * * B x1 - x4 > 1 * x4 - x3 >= 0 */ PTRef zero = logic.getTerm_RealZero(); PTRef leq1 = logic.mkLt(logic.mkPlus(x1,x2), zero); PTRef leq2 = logic.mkLeq(logic.mkNeg(logic.mkPlus(x2,x3)), zero); PTRef leq3 = logic.mkGt(logic.mkMinus(x1,x4), logic.getTerm_RealOne()); PTRef leq4 = logic.mkGeq(logic.mkMinus(x4,x3), zero); vec conflict {PtAsgn(logic.mkNot(leq1), l_False), PtAsgn(leq2, l_True), PtAsgn(logic.mkNot(leq3), l_False), PtAsgn(leq4, l_True)}; ASSERT_TRUE(std::all_of(conflict.begin(), conflict.end(), [this](PtAsgn p) { return not logic.isNot(p.tr); })); ItpColorMap labels {{conflict[0].tr, icolor_t::I_A}, {conflict[1].tr, icolor_t::I_A}, {conflict[2].tr, icolor_t::I_B}, {conflict[3].tr, icolor_t::I_B}}; FarkasInterpolator interpolator(logic, std::move(conflict), {1,1,1,1}, labels); PTRef farkasItp = interpolator.getFarkasInterpolant(); std::cout << logic.pp(farkasItp) << std::endl; EXPECT_TRUE(verifyInterpolant(logic.mkAnd(leq1, leq2), logic.mkAnd(leq3, leq4), farkasItp)); PTRef dualFarkasItp = interpolator.getDualFarkasInterpolant(); std::cout << logic.pp(dualFarkasItp) << std::endl; EXPECT_TRUE(verifyInterpolant(logic.mkAnd(leq1, leq2), logic.mkAnd(leq3, leq4), dualFarkasItp)); PTRef halfFarkasItp = interpolator.getFlexibleInterpolant(FastRational(1,2)); std::cout << logic.pp(halfFarkasItp) << std::endl; EXPECT_TRUE(verifyInterpolant(logic.mkAnd(leq1, leq2), logic.mkAnd(leq3, leq4), halfFarkasItp)); } TEST_F(LRAInterpolationTest, test_AllInA){ /* * A: x1 + x2 <= 0 * -x2 - x3 <= 0 * x1 - x4 >= 1 * x4 - x3 >= 0 */ PTRef zero = logic.getTerm_RealZero(); PTRef leq1 = logic.mkLeq(logic.mkPlus(x1,x2), zero); PTRef leq2 = logic.mkLeq(logic.mkNeg(logic.mkPlus(x2,x3)), zero); PTRef leq3 = logic.mkGeq(logic.mkMinus(x1,x4), logic.getTerm_RealOne()); PTRef leq4 = logic.mkGeq(logic.mkMinus(x4,x3), zero); vec conflict {PtAsgn(leq1, l_True), PtAsgn(leq2, l_True), PtAsgn(leq3, l_True), PtAsgn(leq4, l_True)}; ASSERT_TRUE(std::all_of(conflict.begin(), conflict.end(), [this](PtAsgn p) { return not logic.isNot(p.tr); })); ItpColorMap labels {{conflict[0].tr, icolor_t::I_A}, {conflict[1].tr, icolor_t::I_A}, {conflict[2].tr, icolor_t::I_A}, {conflict[3].tr, icolor_t::I_A}}; FarkasInterpolator interpolator(logic, std::move(conflict), {1,1,1,1}, labels); PTRef farkasItp = interpolator.getFarkasInterpolant(); EXPECT_TRUE(verifyInterpolant(logic.mkAnd({leq1, leq2, leq3, leq4}), logic.getTerm_true(), farkasItp)); EXPECT_EQ(farkasItp, logic.getTerm_false()); PTRef dualFarkasItp = interpolator.getDualFarkasInterpolant(); EXPECT_TRUE(verifyInterpolant(logic.mkAnd({leq1, leq2, leq3, leq4}), logic.getTerm_true(), dualFarkasItp)); EXPECT_EQ(dualFarkasItp, logic.getTerm_false()); PTRef halfFarkasItp = interpolator.getFlexibleInterpolant(FastRational(1,2)); EXPECT_TRUE(verifyInterpolant(logic.mkAnd({leq1, leq2, leq3, leq4}), logic.getTerm_true(), halfFarkasItp)); EXPECT_EQ(halfFarkasItp, logic.getTerm_false()); PTRef decomposedFarkasItp = interpolator.getDecomposedInterpolant(); EXPECT_TRUE(verifyInterpolant(logic.mkAnd({leq1, leq2, leq3, leq4}), logic.getTerm_true(), decomposedFarkasItp)); EXPECT_EQ(decomposedFarkasItp, logic.getTerm_false()); PTRef dualDecomposedFarkasItp = interpolator.getDualDecomposedInterpolant(); EXPECT_TRUE(verifyInterpolant(logic.mkAnd({leq1, leq2, leq3, leq4}), logic.getTerm_true(), dualDecomposedFarkasItp)); EXPECT_EQ(dualDecomposedFarkasItp, logic.getTerm_false()); } TEST_F(LRAInterpolationTest, test_AllInB){ /* * B: x1 + x2 <= 0 * -x2 - x3 <= 0 * x1 - x4 >= 1 * x4 - x3 >= 0 */ PTRef zero = logic.getTerm_RealZero(); PTRef leq1 = logic.mkLeq(logic.mkPlus(x1,x2), zero); PTRef leq2 = logic.mkLeq(logic.mkNeg(logic.mkPlus(x2,x3)), zero); PTRef leq3 = logic.mkGeq(logic.mkMinus(x1,x4), logic.getTerm_RealOne()); PTRef leq4 = logic.mkGeq(logic.mkMinus(x4,x3), zero); vec conflict {PtAsgn(leq1, l_True), PtAsgn(leq2, l_True), PtAsgn(leq3, l_True), PtAsgn(leq4, l_True)}; ASSERT_TRUE(std::all_of(conflict.begin(), conflict.end(), [this](PtAsgn p) { return not logic.isNot(p.tr); })); ItpColorMap labels {{conflict[0].tr, icolor_t::I_B}, {conflict[1].tr, icolor_t::I_B}, {conflict[2].tr, icolor_t::I_B}, {conflict[3].tr, icolor_t::I_B}}; FarkasInterpolator interpolator(logic, std::move(conflict), {1,1,1,1}, labels); PTRef farkasItp = interpolator.getFarkasInterpolant(); EXPECT_TRUE(verifyInterpolant(logic.getTerm_true(), logic.mkAnd({leq1, leq2, leq3, leq4}), farkasItp)); EXPECT_EQ(farkasItp, logic.getTerm_true()); PTRef dualFarkasItp = interpolator.getDualFarkasInterpolant(); EXPECT_TRUE(verifyInterpolant(logic.getTerm_true(), logic.mkAnd({leq1, leq2, leq3, leq4}), dualFarkasItp)); EXPECT_EQ(dualFarkasItp, logic.getTerm_true()); PTRef halfFarkasItp = interpolator.getFlexibleInterpolant(FastRational(1,2)); EXPECT_TRUE(verifyInterpolant(logic.getTerm_true(), logic.mkAnd({leq1, leq2, leq3, leq4}), halfFarkasItp)); EXPECT_EQ(halfFarkasItp, logic.getTerm_true()); PTRef decomposedFarkasItp = interpolator.getDecomposedInterpolant(); EXPECT_TRUE(verifyInterpolant(logic.getTerm_true(), logic.mkAnd({leq1, leq2, leq3, leq4}), decomposedFarkasItp)); EXPECT_EQ(decomposedFarkasItp, logic.getTerm_true()); PTRef dualDecomposedFarkasItp = interpolator.getDualDecomposedInterpolant(); EXPECT_TRUE(verifyInterpolant(logic.getTerm_true(), logic.mkAnd({leq1, leq2, leq3, leq4}), dualDecomposedFarkasItp)); EXPECT_EQ(dualDecomposedFarkasItp, logic.getTerm_true()); } TEST_F(LRAInterpolationTest, test_Decomposition_NonStrict){ /* * A: x1 >= 0 * x2 - x1 >= 0 * -x3 - x1 >= 0 * B: * x3 - x4 >= 0 * -x4 - x2 >= 0 * x4 >= 1 */ PTRef zero = logic.getTerm_RealZero(); PTRef leq1 = logic.mkGeq(x1, zero); PTRef leq2 = logic.mkGeq(logic.mkMinus(x2,x1), zero); PTRef leq3 = logic.mkGeq(logic.mkNeg(logic.mkPlus(x3,x1)), zero); PTRef leq4 = logic.mkGeq(logic.mkMinus(x3,x4), zero); PTRef leq5 = logic.mkGeq(logic.mkNeg(logic.mkPlus(x4,x2)), zero); PTRef leq6 = logic.mkGeq(x4, logic.getTerm_RealOne()); vec conflict {PtAsgn(leq1, l_True), PtAsgn(leq2, l_True), PtAsgn(leq3, l_True), PtAsgn(leq4, l_True), PtAsgn(leq5, l_True), PtAsgn(leq6, l_True)}; ASSERT_TRUE(std::all_of(conflict.begin(), conflict.end(), [this](PtAsgn p) { return not logic.isNot(p.tr); })); ItpColorMap labels {{conflict[0].tr, icolor_t::I_A}, {conflict[1].tr, icolor_t::I_A}, {conflict[2].tr, icolor_t::I_A}, {conflict[3].tr, icolor_t::I_B}, {conflict[4].tr, icolor_t::I_B}, {conflict[5].tr, icolor_t::I_B}}; FarkasInterpolator interpolator(logic, std::move(conflict), {2,1,1,1,1,2}, labels); PTRef decomposedFarkasItp = interpolator.getDecomposedInterpolant(); EXPECT_TRUE(verifyInterpolant(logic.mkAnd({leq1, leq2, leq3}), logic.mkAnd({leq4, leq5, leq6}), decomposedFarkasItp)); ASSERT_TRUE(logic.isAnd(decomposedFarkasItp)); EXPECT_EQ(decomposedFarkasItp, logic.mkAnd(logic.mkLeq(zero, x2), logic.mkLeq(zero, logic.mkNeg(x3)))); PTRef dualDecomposedFarkasItp = interpolator.getDualDecomposedInterpolant(); EXPECT_TRUE(verifyInterpolant(logic.mkAnd({leq1, leq2, leq3}), logic.mkAnd({leq4, leq5, leq6}), dualDecomposedFarkasItp)); } TEST_F(LRAInterpolationTest, test_Decomposition_Strict){ /* * A: x1 >= 0 * x2 - x1 > 0 * -x3 - x1 >= 0 * B: * x3 - x4 > 0 * -x4 - x2 >= 0 * x4 >= 0 */ PTRef zero = logic.getTerm_RealZero(); PTRef leq1 = logic.mkGeq(x1, zero); PTRef leq2 = logic.mkGt(logic.mkMinus(x2,x1), zero); PTRef leq3 = logic.mkGeq(logic.mkNeg(logic.mkPlus(x3,x1)), zero); PTRef leq4 = logic.mkGt(logic.mkMinus(x3,x4), zero); PTRef leq5 = logic.mkGeq(logic.mkNeg(logic.mkPlus(x4,x2)), zero); PTRef leq6 = logic.mkGeq(x4, logic.getTerm_RealOne()); vec conflict {PtAsgn(leq1, l_True), PtAsgn(logic.mkNot(leq2), l_False), PtAsgn(leq3, l_True), PtAsgn(logic.mkNot(leq4), l_False), PtAsgn(leq5, l_True), PtAsgn(leq6, l_True)}; ASSERT_TRUE(std::all_of(conflict.begin(), conflict.end(), [this](PtAsgn p) { return not logic.isNot(p.tr); })); ItpColorMap labels {{conflict[0].tr, icolor_t::I_A}, {conflict[1].tr, icolor_t::I_A}, {conflict[2].tr, icolor_t::I_A}, {conflict[3].tr, icolor_t::I_B}, {conflict[4].tr, icolor_t::I_B}, {conflict[5].tr, icolor_t::I_B}}; FarkasInterpolator interpolator(logic, std::move(conflict), {2,1,1,1,1,2}, labels); PTRef decomposedFarkasItp = interpolator.getDecomposedInterpolant(); EXPECT_TRUE(verifyInterpolant(logic.mkAnd({leq1, leq2, leq3}), logic.mkAnd({leq4, leq5, leq6}), decomposedFarkasItp)); ASSERT_TRUE(logic.isAnd(decomposedFarkasItp)); EXPECT_EQ(decomposedFarkasItp, logic.mkAnd(logic.mkLt(zero, x2), logic.mkLeq(zero, logic.mkNeg(x3)))); PTRef dualDecomposedFarkasItp = interpolator.getDualDecomposedInterpolant(); EXPECT_TRUE(verifyInterpolant(logic.mkAnd({leq1, leq2, leq3}), logic.mkAnd({leq4, leq5, leq6}), dualDecomposedFarkasItp)); // std::cout << logic.pp(dualDecomposedFarkasItp) << std::endl; }opensmt-2.5.2/test/unit/test_LRALogicMkTerms.cc000066400000000000000000000170431445011647600214250ustar00rootroot00000000000000// // Created by Martin Blicha on 02.11.18. // #include #include "ArithLogic.h" class LRALogicMkTermsTest : public ::testing::Test { protected: LRALogicMkTermsTest(): logic{opensmt::Logic_t::QF_LRA} {} virtual void SetUp() { x = logic.mkRealVar("x"); y = logic.mkRealVar("y"); z = logic.mkRealVar("z"); } ArithLogic logic; PTRef x; PTRef y; PTRef z; }; TEST_F(LRALogicMkTermsTest, test_Sum_Zero) { PTRef zero = logic.mkConst("0"); vec args; args.push(zero); PTRef res = logic.mkPlus(args); ASSERT_EQ(res, zero); } TEST_F(LRALogicMkTermsTest, test_Sum_Ignore_Zeros) { PTRef zero = logic.mkConst("0"); PTRef a = logic.mkRealVar("a"); PTRef res = logic.mkPlus(zero, a); ASSERT_EQ(res, a); } TEST_F(LRALogicMkTermsTest, test_One_Arg_Multiplication) { PTRef two = logic.mkConst("2"); PTRef one = logic.mkConst("1"); PTRef a = logic.mkRealVar("a"); PTRef div = logic.mkRealDiv(a, two); PTRef res = logic.mkTimes(div, one); ASSERT_EQ(res, div); } TEST_F(LRALogicMkTermsTest, test_Times_Ignore_Ones) { PTRef one = logic.mkConst("1"); PTRef a = logic.mkRealVar("a"); PTRef res = logic.mkTimes(a, one); ASSERT_EQ(res, a); } TEST_F(LRALogicMkTermsTest, test_Times_Single_Arg) { PTRef a = logic.mkRealVar("a"); vec args; args.push(a); PTRef res = logic.mkTimes(args); ASSERT_EQ(res, a); } TEST_F(LRALogicMkTermsTest, test_Sum_Single_Arg) { PTRef a = logic.mkRealVar("a"); vec args; args.push(a); PTRef res = logic.mkPlus(args); ASSERT_EQ(res, a); } TEST_F(LRALogicMkTermsTest, test_Sum_Single_Arg_Nested) { PTRef a = logic.mkRealVar("a"); PTRef two = logic.mkConst("2"); PTRef times = logic.mkTimes(a,two); vec args; args.push(times); PTRef res = logic.mkPlus(args); ASSERT_EQ(res, times); } TEST_F(LRALogicMkTermsTest, test_Sum_Single_Arg_Nested_With_Simplification) { PTRef a = logic.mkRealVar("a"); PTRef two = logic.mkConst("2"); PTRef zero = logic.mkConst("0"); PTRef times = logic.mkTimes(a,two); PTRef res = logic.mkPlus(times, zero); ASSERT_EQ(res, times); } TEST_F(LRALogicMkTermsTest, test_Simple_Leq) { PTRef a = logic.mkRealVar("a"); PTRef zero = logic.mkConst("0"); PTRef res = logic.mkLeq(zero, a); ASSERT_EQ(logic.getSymRef(res),logic.get_sym_Real_LEQ()); ASSERT_EQ(logic.getPterm(res)[0], zero); ASSERT_EQ(logic.getPterm(res)[1], a); } TEST_F(LRALogicMkTermsTest, test_Simple_Leq_Two_Vars) { PTRef a = logic.mkRealVar("a"); PTRef b = logic.mkRealVar("b"); PTRef zero = logic.mkConst("0"); PTRef res = logic.mkLeq(b, a); ASSERT_EQ(logic.getSymRef(res),logic.get_sym_Real_LEQ()); ASSERT_EQ(logic.getPterm(res)[0], zero); } TEST_F(LRALogicMkTermsTest, test_Simple_Leq_Two_Vars2) { PTRef a = logic.mkRealVar("a"); PTRef b = logic.mkRealVar("b"); PTRef zero = logic.mkConst("0"); PTRef res = logic.mkLeq(a, b); ASSERT_EQ(logic.getSymRef(res),logic.get_sym_Real_LEQ()); ASSERT_EQ(logic.getPterm(res)[0], zero); } TEST_F(LRALogicMkTermsTest, test_mkNumNeg) { PTRef one = logic.getTerm_RealOne(); PTRef minus = logic.mkNeg(one); ASSERT_TRUE(logic.isConstant(minus)); ASSERT_TRUE(logic.isNumConst(minus)); ASSERT_LT(logic.getNumConst(minus), 0); ASSERT_EQ(logic.mkNeg(minus), one); ASSERT_EQ(logic.getNumConst(minus), -1); } TEST_F(LRALogicMkTermsTest, test_Inequality_Var_WithCoeff) { PTRef a = logic.mkRealVar("a"); PTRef minus = logic.mkNeg(a); PTRef leq = logic.mkLeq(minus, a); ASSERT_TRUE(logic.isLeq(leq)); ASSERT_EQ(leq, logic.mkLeq(logic.getTerm_RealZero(), a)); } TEST_F(LRALogicMkTermsTest, test_Inequality_Var_NonZero) { PTRef one = logic.getTerm_RealOne(); PTRef a = logic.mkRealVar("a"); PTRef leq = logic.mkLeq(one, a); PTRef geq = logic.mkGeq(one, a); ASSERT_TRUE(logic.isLeq(leq)); ASSERT_TRUE(logic.isLeq(geq)); } TEST_F(LRALogicMkTermsTest, test_SumToZero) { PTRef var = logic.mkRealVar("a"); PTRef minusVar = logic.mkNeg(var); PTRef sum = logic.mkPlus(minusVar, var); ASSERT_EQ(sum, logic.getTerm_RealZero()); sum = logic.mkPlus(var, minusVar); ASSERT_EQ(sum, logic.getTerm_RealZero()); } TEST_F(LRALogicMkTermsTest, test_NonLinearException) { EXPECT_THROW(logic.mkTimes(x,y), LANonLinearException); PTRef two = logic.mkConst("2"); EXPECT_NO_THROW(logic.mkTimes(x,two)); } TEST_F(LRALogicMkTermsTest, test_ConstantSimplification) { PTRef two = logic.mkConst("2"); EXPECT_EQ(logic.mkConst("1/2"), logic.mkRealDiv(logic.getTerm_RealOne(), two)); EXPECT_EQ(two, logic.mkRealDiv(logic.mkConst("4"), two)); } TEST_F(LRALogicMkTermsTest, test_Inequality_Constant) { PTRef one = logic.getTerm_RealOne(); PTRef a = logic.mkRealVar("a"); PTRef sum = logic.mkPlus(a, one); ASSERT_EQ(logic.mkLeq(a, a), logic.getTerm_true()); ASSERT_EQ(logic.mkLeq(a, sum), logic.getTerm_true()); ASSERT_EQ(logic.mkGeq(a, sum), logic.getTerm_false()); } TEST_F(LRALogicMkTermsTest, test_Inequality_Simplification) { PTRef two = logic.mkConst("2"); ASSERT_EQ( logic.mkLeq(logic.mkPlus(x,y), z), logic.mkLeq( logic.mkPlus(logic.mkTimes(x, two), logic.mkTimes(y, two)), logic.mkTimes(z, two) ) ); } TEST_F(LRALogicMkTermsTest, testAtom_LRA) { PTRef ineq = logic.mkLeq(x, logic.getTerm_RealZero()); EXPECT_TRUE(logic.isAtom(ineq)); EXPECT_FALSE(logic.isAtom(logic.mkNot(ineq))); PTRef strict = logic.mkLt(x, logic.getTerm_RealZero()); EXPECT_FALSE(logic.isAtom(strict)); EXPECT_TRUE(logic.isAtom(logic.mkNot(strict))); PTRef eq = logic.mkEq(x, logic.getTerm_RealZero()); EXPECT_TRUE(logic.isAtom(eq)); EXPECT_FALSE(logic.isAtom(logic.mkNot(eq))); PTRef sum = logic.mkPlus(x,y); EXPECT_FALSE(logic.isAtom(sum)); PTRef product = logic.mkTimes(x, logic.mkRealConst(2)); EXPECT_FALSE(logic.isAtom(product)); } TEST_F(LRALogicMkTermsTest, test_ChainableInequality) { PTRef multiArgsLeq = logic.mkLeq({x,y,z}); PTRef expandedLeq = logic.mkAnd(logic.mkLeq(x,y), logic.mkLeq(y,z)); EXPECT_EQ(multiArgsLeq, expandedLeq); PTRef multiArgsLt = logic.mkLt({x,y,z}); PTRef expandedLt = logic.mkAnd(logic.mkLt(x,y), logic.mkLt(y,z)); EXPECT_EQ(multiArgsLt, expandedLt); PTRef multiArgsGeq = logic.mkGeq({x,y,z}); PTRef expandedGeq = logic.mkAnd(logic.mkGeq(x,y), logic.mkGeq(y,z)); EXPECT_EQ(multiArgsGeq, expandedGeq); PTRef multiArgsGt = logic.mkGt({x,y,z}); PTRef expandedGt = logic.mkAnd(logic.mkGt(x,y), logic.mkGt(y,z)); EXPECT_EQ(multiArgsGt, expandedGt); } TEST_F(LRALogicMkTermsTest, test_EqualityNormalization_Commutativity) { PTRef two = logic.mkRealConst(2); PTRef eq1 = logic.mkEq(x, two); PTRef eq2 = logic.mkEq(two, x); ASSERT_EQ(eq1, eq2); } TEST_F(LRALogicMkTermsTest, test_EqualityNormalization) { PTRef two = logic.mkRealConst(2); PTRef eq1 = logic.mkEq(x, y); PTRef eq2 = logic.mkEq(logic.mkTimes(x, two), logic.mkTimes(y, two)); // std::cout << logic.printTerm(eq1) << std::endl; // std::cout << logic.printTerm(eq2) << std::endl; EXPECT_EQ(eq1, eq2); } TEST_F(LRALogicMkTermsTest, test_EqualityNormalization_ToConstantExpression) { PTRef two = logic.mkRealConst(2); PTRef eq1 = logic.mkEq(x, logic.mkPlus(x, two)); EXPECT_EQ(eq1, logic.getTerm_false()); } TEST_F(LRALogicMkTermsTest, test_FailWithIntArgs) { EXPECT_THROW(logic.mkIntConst(2), OsmtApiException); }opensmt-2.5.2/test/unit/test_LogicMkTerms.cc000066400000000000000000000160261445011647600210660ustar00rootroot00000000000000// // Created by Antti on 31.03.20. // #include #include #include class LogicMkTermsTest: public ::testing::Test { public: Logic logic; LogicMkTermsTest(): logic{opensmt::Logic_t::QF_UF} {} }; TEST_F(LogicMkTermsTest, test_Distinct){ SRef ufsort = logic.declareUninterpretedSort("U"); PTRef x = logic.mkVar(ufsort, "x"); PTRef y = logic.mkVar(ufsort, "y"); PTRef distinct = logic.mkDistinct({x,y}); ASSERT_NE(distinct, logic.getTerm_false()); ASSERT_NE(distinct, logic.getTerm_true()); distinct = logic.mkDistinct({x}); ASSERT_EQ(distinct, logic.getTerm_true()); distinct = logic.mkDistinct({}); ASSERT_EQ(distinct, logic.getTerm_true()); distinct = logic.mkDistinct({x,x}); ASSERT_EQ(distinct, logic.getTerm_false()); distinct = logic.mkDistinct({x,y,x}); ASSERT_EQ(distinct, logic.getTerm_false()); distinct = logic.mkDistinct({x,y}); // MB: dinstinct(x,y) is equivalent to not equal(x,y) and the second version is preferred ASSERT_TRUE(logic.isNot(distinct) && logic.isEquality(logic.getPterm(distinct)[0])); PTRef b1 = logic.mkBoolVar("b1"); PTRef b2 = logic.mkBoolVar("b2"); PTRef b3 = logic.mkBoolVar("b3"); distinct = logic.mkDistinct({b1,b2,b3}); ASSERT_EQ(distinct, logic.getTerm_false()); PTRef z = logic.mkVar(ufsort, "z"); distinct = logic.mkDistinct({x, y, z}); ASSERT_TRUE(logic.isDisequality(distinct)); } TEST_F(LogicMkTermsTest, test_ManyDistinct) { SRef ufsort = logic.declareUninterpretedSort("U"); vec names; for (int i = 0; i < 9; i++) { std::string name = "x" + std::to_string(i); names.push(logic.mkVar(ufsort, name.c_str())); } vec distincts1; for (int i = 0; i < 9; i++) { for (int j = i+1; j < 9; j++) { for (int k = j+1; k < 9; k++) { distincts1.push(logic.mkDistinct({names[i], names[j], names[k]})); } } } vec distincts2; for (int i = 0; i < 9; i++) { for (int j = i+1; j < 9; j++) { for (int k = j+1; k < 9; k++) { distincts2.push(logic.mkDistinct({names[j], names[i], names[k]})); } } } vec distincts3; for (int i = 0; i < 9; i++) { for (int j = i+1; j < 9; j++) { for (int k = j+1; k < 9; k++) { distincts3.push(logic.mkDistinct({names[k], names[i], names[j]})); } } } for (int i = 0; i < distincts1.size(); i++) { ASSERT_EQ(distincts1[i].x, distincts2[i].x); ASSERT_EQ(distincts1[i].x, distincts3[i].x); } } TEST_F(LogicMkTermsTest, testMkOrTautology) { PTRef a = logic.mkBoolVar("a"); PTRef nota = logic.mkNot(a); ASSERT_EQ(logic.mkOr(a, nota), logic.getTerm_true()); } TEST_F(LogicMkTermsTest, testMkAndContradiction) { PTRef a = logic.mkBoolVar("a"); PTRef nota = logic.mkNot(a); ASSERT_EQ(logic.mkAnd(a, nota), logic.getTerm_false()); } TEST_F(LogicMkTermsTest, testIteration) { PTRef a = logic.mkBoolVar("a"); PTRef b = logic.mkBoolVar("b"); PTRef conj = logic.mkAnd({a, b}); PTRef c = logic.mkBoolVar("c"); PTRef disj = logic.mkOr({a, b, c}); for (auto tr : {a, b, c}) { int count = 0; for (auto ch : logic.getPterm(tr)) { (void)ch; count++; } ASSERT_EQ(count, 0); } for (auto tr : {conj, disj}) { Pterm const &t = logic.getPterm(tr); for (auto ch : t) { bool found = false; for (int i = 0; i < t.size(); i++) { found |= ch == t[i]; } ASSERT_TRUE(found); } } } TEST_F(LogicMkTermsTest, testUniqueAbstractValue) { PTRef uniq1 = logic.mkUniqueAbstractValue(logic.getSort_bool()); PTRef uniq2 = logic.mkUniqueAbstractValue(logic.getSort_bool()); ASSERT_NE(uniq1, uniq2); } TEST_F(LogicMkTermsTest, testAtom_Bool) { PTRef a = logic.mkBoolVar("a"); PTRef b = logic.mkBoolVar("b"); PTRef c = logic.mkBoolVar("c"); EXPECT_TRUE(logic.isAtom(a)); EXPECT_FALSE(logic.isAtom(logic.mkNot(a))); EXPECT_FALSE(logic.isAtom(logic.mkAnd(a,b))); EXPECT_FALSE(logic.isAtom(logic.mkOr(a,b))); EXPECT_FALSE(logic.isAtom(logic.mkXor(a,b))); EXPECT_FALSE(logic.isAtom(logic.mkImpl(a,b))); // Boolean equivalence is not considered an atom! EXPECT_FALSE(logic.isAtom(logic.mkEq(a,b))); // Boolean ITE is not considered an atom! EXPECT_FALSE(logic.isAtom(logic.mkIte(c,a,b))); EXPECT_TRUE(logic.isAtom(logic.getTerm_true())); EXPECT_TRUE(logic.isAtom(logic.getTerm_false())); } TEST_F(LogicMkTermsTest, testAtom_UF) { SRef sref = logic.declareUninterpretedSort("U"); PTRef a = logic.mkVar(sref, "a"); PTRef b = logic.mkVar(sref, "b"); PTRef c = logic.mkVar(sref, "c"); PTRef eq = logic.mkEq(a,b); PTRef dist = logic.mkDistinct({a,b,c}); EXPECT_TRUE(logic.isAtom(eq)); EXPECT_FALSE(logic.isAtom(logic.mkNot(eq))); EXPECT_TRUE(logic.isAtom(dist)); EXPECT_FALSE(logic.isAtom(logic.mkNot(dist))); SymRef predicate = logic.declareFun("p", logic.getSort_bool(), {sref}); PTRef pa = logic.mkUninterpFun(predicate, {a}); EXPECT_TRUE(logic.isAtom(pa)); EXPECT_FALSE(logic.isAtom(logic.mkNot(pa))); } bool contains(vec const& v, PTRef t) { for (PTRef e : v) { if (t == e) { return true; } } return false; } TEST_F(LogicMkTermsTest, testTopLevelConjuncts_flat) { PTRef a = logic.mkBoolVar("a"); PTRef b = logic.mkBoolVar("b"); PTRef c = logic.mkBoolVar("c"); PTRef fla = logic.mkAnd({a,b,c}); auto conjuncts = topLevelConjuncts(logic, fla); ASSERT_EQ(conjuncts.size(), 3); for (PTRef p : {a,b,c}) { EXPECT_TRUE(contains(conjuncts, p)); } } TEST_F(LogicMkTermsTest, testTopLevelConjuncts_nested) { PTRef a = logic.mkBoolVar("a"); PTRef b = logic.mkBoolVar("b"); PTRef c = logic.mkBoolVar("c"); PTRef d = logic.mkBoolVar("d"); PTRef fla = logic.mkAnd(logic.mkAnd(a,b), logic.mkAnd(c,d)); auto conjuncts = topLevelConjuncts(logic, fla); ASSERT_EQ(conjuncts.size(), 4); for (PTRef p : {a,b,c,d}) { EXPECT_TRUE(contains(conjuncts, p)); } } TEST_F(LogicMkTermsTest, testTopLevelConjuncts_noDuplicates) { PTRef a = logic.mkBoolVar("a"); PTRef b = logic.mkBoolVar("b"); PTRef c = logic.mkBoolVar("c"); PTRef fla = logic.mkAnd(logic.mkAnd(a,b), logic.mkAnd(c,a)); auto conjuncts = topLevelConjuncts(logic, fla); ASSERT_EQ(conjuncts.size(), 3); for (PTRef p : {a,b,c}) { EXPECT_TRUE(contains(conjuncts, p)); } } TEST_F(LogicMkTermsTest, testTopLevelConjuncts_notConjunction) { PTRef a = logic.mkBoolVar("a"); PTRef b = logic.mkBoolVar("b"); auto conjuncts1 = topLevelConjuncts(logic, a); ASSERT_EQ(conjuncts1.size(), 1); EXPECT_EQ(conjuncts1[0], a); PTRef fla = logic.mkOr(a,b); auto conjuncts2 = topLevelConjuncts(logic, fla); ASSERT_EQ(conjuncts2.size(), 1); EXPECT_EQ(conjuncts2[0], fla); } opensmt-2.5.2/test/unit/test_Lookahead.cpp000066400000000000000000000055231445011647600206120ustar00rootroot00000000000000// // Created by antti on 23.08.19. // #include #include #include #include #include #include class BestLitBufTestClassic: public ::testing::Test { public: BestLitBufTestClassic() {} }; class BestLitBufTestDeep: public ::testing::Test { public: BestLitBufTestDeep() {} }; TEST_F(BestLitBufTestClassic, test_UnitLookahead) { vec assigns; for (int i = 0; i < 10; i++) assigns.push(l_Undef); LABestLitBuf buf(2, assigns, true, 1); LookaheadScoreClassic::ExVal v1(1,1,1); Lit l1 = mkLit(0, true); LookaheadScoreClassic::ExVal v2(2, 1, 1); Lit l2 = mkLit(1, true); LookaheadScoreClassic::ExVal v3(1, 2, 1); Lit l3 = mkLit(2, true); LookaheadScoreClassic::ExVal v4(2, 2, 1); Lit l4 = mkLit(3, true); LookaheadScoreClassic::ExVal v5(1, 1, 2); Lit l5 = mkLit(4, true); LookaheadScoreClassic::ExVal v6(2, 1, 1); Lit l6 = mkLit(5, true); buf.insert(l1, v1); ASSERT_EQ(buf.getLit(0), l1); buf.insert(l2, v2); ASSERT_EQ(buf.getLit(1), l2); buf.insert(l3, v3); ASSERT_EQ(buf.getLit(0), l3); buf.insert(l4, v4); ASSERT_TRUE(buf.getLit(0) == l3 || buf.getLit(0) == l4); ASSERT_TRUE(buf.getLit(1) == l3 || buf.getLit(1) == l4); ASSERT_TRUE(buf.getLit(0) != buf.getLit(1)); buf.insert(l5,v5); ASSERT_TRUE(buf.getLit(0) == l5 || buf.getLit(1) == l5); buf.insert(l6,v6); ASSERT_TRUE(buf.getLit(0) != l6 && buf.getLit(1) != l6); } TEST_F(BestLitBufTestDeep, test_UnitLookahead) { vec assigns; for (int i = 0; i < 10; i++) assigns.push(l_Undef); LABestLitBuf buf(2, assigns, true, 1); LookaheadScoreDeep::DoubleVal v1(1, 1); Lit l1 = mkLit(0, true); LookaheadScoreDeep::DoubleVal v2(2, 1); Lit l2 = mkLit(1, true); LookaheadScoreDeep::DoubleVal v3(1, 2); Lit l3 = mkLit(2, true); LookaheadScoreDeep::DoubleVal v4(2, 2); Lit l4 = mkLit(3, true); LookaheadScoreDeep::DoubleVal v5(1, 1); Lit l5 = mkLit(4, true); LookaheadScoreDeep::DoubleVal v6(2, 1); Lit l6 = mkLit(5, true); buf.insert(l1, v1); ASSERT_EQ(buf.getLit(0), l1); buf.insert(l2, v2); ASSERT_EQ(buf.getLit(1), l2); buf.insert(l3, v3); ASSERT_TRUE(buf.getLit(0) == l2 || buf.getLit(1) == l2); ASSERT_TRUE(buf.getLit(0) == l3 || buf.getLit(1) == l3); buf.insert(l4, v4); ASSERT_TRUE(buf.getLit(0) == l2 || buf.getLit(0) == l4); ASSERT_TRUE(buf.getLit(1) == l2 || buf.getLit(1) == l4); ASSERT_TRUE(buf.getLit(0) != buf.getLit(1)); buf.insert(l5,v5); ASSERT_TRUE(buf.getLit(0) == l2 || buf.getLit(0) == l4); ASSERT_TRUE(buf.getLit(1) == l2 || buf.getLit(1) == l4); buf.insert(l6,v6); ASSERT_TRUE(buf.getLit(0) == l4 || buf.getLit(1) == l4); }opensmt-2.5.2/test/unit/test_Matrix.cc000066400000000000000000000326351445011647600177760ustar00rootroot00000000000000// // Created by prova on 24.08.18. // #include #include #include #include using Real = opensmt::Real; class MatrixTest : public ::testing::Test { protected: LAVecAllocator va; LAVecStore vecStore {va}; LAMatrixStore ms {vecStore}; }; TEST(Matrix_test, cmpabs_test) { Real zero; Real one = 1; Real minus_one = -1; ASSERT_EQ(cmpabs(zero, zero), 0); ASSERT_EQ(cmpabs(zero, one), -1); ASSERT_EQ(cmpabs(zero, minus_one), -1); ASSERT_EQ(cmpabs(one, zero), 1); ASSERT_EQ(cmpabs(one, one), 0); ASSERT_EQ(cmpabs(one, minus_one), 0); ASSERT_EQ(cmpabs(minus_one, zero), 1); ASSERT_EQ(cmpabs(minus_one, one), 0); ASSERT_EQ(cmpabs(minus_one, minus_one), 0); } TEST(Matrix_test, floor_div) { Real x(11, 10); // 1.1 x = x.floor(); ASSERT_EQ(x, 1); Real y(-11, 10); // -1.1 y = y.floor(); ASSERT_EQ(y, -2); ASSERT_EQ(x % (-y), 1); ASSERT_EQ(x % y, -1); x = INT32_MAX; y = INT32_MAX; x *= 2; y *= 2; y = y+1; ASSERT_EQ(x % y, x); ASSERT_EQ(y % x, 1); Real z = -x; ASSERT_EQ(y % z, Real{"-4294967293"}); Real v(-4, 3); v = v.floor(); ASSERT_EQ(v.isInteger(), true); Real w(-3, 1); w = w.floor(); ASSERT_EQ(w, -3); FastRational f = fastrat_fdiv_q(FastRational(-1, 1), FastRational(2, 1)); ASSERT_EQ(f, -1); FastRational f2 = fastrat_fdiv_q(FastRational(1, 1), FastRational(-2, 1)); ASSERT_EQ(f2, -1); Real x1 = fastrat_fdiv_q(-2936, 276); ASSERT_EQ(x1, -11); Real x2 = fastrat_fdiv_q(FastRational(-3480, 1), FastRational(-768)); ASSERT_EQ(x2, 4); ASSERT_EQ(fastrat_fdiv_q(4, 4), 1); ASSERT_EQ(fastrat_fdiv_q(-4, -4), 1); ASSERT_EQ(fastrat_fdiv_q(4, -4), -1); ASSERT_EQ(fastrat_fdiv_q(-4, 4), -1); ASSERT_EQ(fastrat_fdiv_q(8, 4), 2); ASSERT_EQ(fastrat_fdiv_q(-8, -4), 2); ASSERT_EQ(fastrat_fdiv_q(8, -4), -2); ASSERT_EQ(fastrat_fdiv_q(-8, 4), -2); ASSERT_EQ(fastrat_fdiv_q(INT_MIN, 1), INT_MIN); ASSERT_EQ(fastrat_fdiv_q(INT_MIN, -1), FastRational(INT_MAX)+1); ASSERT_EQ(fastrat_fdiv_q(INT_MAX, 1), INT_MAX); ASSERT_EQ(fastrat_fdiv_q(INT_MAX, -1), -INT_MAX); } TEST_F(MatrixTest, vec_creation) { // INT32_MIN Real r {"-2147483648"}; std::vector reals; reals.resize(10); for (int i = 0; i < 10; i++) { reals[i] = Real(i); } LAVecRef vr = vecStore.getNewVec(std::move(reals)); for (int i = 1; i <= va[vr].size(); i++) { ASSERT_EQ(va[vr][i], i-1); } LAVecRef vr2 = vecStore.getNewVec(10); va[vr2] = va[vr]; for (int i = 1; i <= va[vr2].size(); i++) ASSERT_EQ(va[vr2][i], va[vr][i]); MId m = ms.getNewMatrix(2,2); ASSERT_EQ(ms[m].nRows(), 2); ASSERT_EQ(ms[m].nCols(), 2); MId m2 = ms.getNewMatrix(2,2); ms.setMatrix(m2, m); MId idmx = ms.getNewIdMatrix(2, 2); for (int i = 1; i <= 2; i++) { for (int j = 1; j <= 2; j++) { if (i == j) ASSERT_EQ(ms.MM(idmx, i, j), 1); else ASSERT_EQ(ms.MM(idmx, i, j), 0); } } MId diag = ms.getNewIdMatrix(2, 2); ms.swap_rows(diag, 1, 2); ASSERT_EQ(ms.MM(diag, 1, 1), 0); ASSERT_EQ(ms.MM(diag, 1, 2), 1); ASSERT_EQ(ms.MM(diag, 2, 1), 1); ASSERT_EQ(ms.MM(diag, 2, 2), 0); ms.swap_columns(diag, 1, 2); ASSERT_EQ(ms.MM(diag, 1, 1), 1); ASSERT_EQ(ms.MM(diag, 1, 2), 0); ASSERT_EQ(ms.MM(diag, 2, 1), 0); ASSERT_EQ(ms.MM(diag, 2, 2), 1); ms.neg_column(diag, 1); ASSERT_EQ(ms.MM(diag, 1, 1), -1); ASSERT_EQ(ms.MM(diag, 1, 2), 0); ASSERT_EQ(ms.MM(diag, 2, 1), 0); ASSERT_EQ(ms.MM(diag, 2, 2), 1); ms.neg_row(diag, 2); ASSERT_EQ(ms.MM(diag, 1, 1), -1); ASSERT_EQ(ms.MM(diag, 1, 2), 0); ASSERT_EQ(ms.MM(diag, 2, 1), 0); ASSERT_EQ(ms.MM(diag, 2, 2), -1); ms.setIdMatrix(diag); ASSERT_EQ(ms.MM(diag, 1, 1), 1); ASSERT_EQ(ms.MM(diag, 1, 2), 0); ASSERT_EQ(ms.MM(diag, 2, 1), 0); ASSERT_EQ(ms.MM(diag, 2, 2), 1); } TEST_F(MatrixTest, smith_matrix1) { MId U = ms.getNewMatrix(3, 3); // 2 4 4 // -6 6 12 // 10 -4 -16 ms.MM(U, 1, 1) = 2; ms.MM(U, 1, 2) = 4; ms.MM(U, 1, 3) = 4; ms.MM(U, 2, 1) = -6; ms.MM(U, 2, 2) = 6; ms.MM(U, 2, 3) = 12; ms.MM(U, 3, 1) = 10; ms.MM(U, 3, 2) = -4; ms.MM(U, 3, 3) = -16; MId L = ms.getNewMatrix(3, 3); MId R = ms.getNewMatrix(3, 3); MId Li = ms.getNewMatrix(3, 3); MId Ri = ms.getNewMatrix(3, 3); MId S = ms.getNewMatrix(3, 3); int dim; ms.compute_snf(U, S, dim, L, Li, R, Ri); printf("The snf matrix:\n%s\n", ms.print(S).c_str()); int diag[] = {2, 6, 12}; for (int i = 1; i <= 3; i++) { for (int j = 1; j <= 3; j++) { if (i != j) ASSERT_EQ(ms.MM(S, i, j), 0); else ASSERT_EQ(ms.MM(S, i, j), diag[i - 1]); } } } TEST_F(MatrixTest, smith_matrix111) { MId U = ms.getNewMatrix(4, 4); // -6 111 -36 6 // 5 -672 210 74 // 0 -255 81 24 // -7 255 -81 -10 ms.MM(U, 1, 1) = -6; ms.MM(U, 1, 2) = 111; ms.MM(U, 1, 3) = -36; ms.MM(U, 1, 4) = 6; ms.MM(U, 2, 1) = 5; ms.MM(U, 2, 2) = -672; ms.MM(U, 2, 3) = 210; ms.MM(U, 2, 4) = 74; ms.MM(U, 3, 1) = 0; ms.MM(U, 3, 2) = -255; ms.MM(U, 3, 3) = 81; ms.MM(U, 3, 4) = 24; ms.MM(U, 4, 1) = -7; ms.MM(U, 4, 2) = 255; ms.MM(U, 4, 3) = -81; ms.MM(U, 4, 4) = -10; MId L = ms.getNewMatrix(4, 4); MId R = ms.getNewMatrix(4, 4); MId Li = ms.getNewMatrix(4, 4); MId Ri = ms.getNewMatrix(4, 4); MId S = ms.getNewMatrix(4, 4); // 1 3 21 0 in diagonal should be for S int dim; ms.compute_snf(U, S, dim, L, Li, R, Ri); printf("The snf matrix:\n%s\n", ms.print(S).c_str()); int diag[] = {1, 3, 21, 0}; for (int i = 1; i <= 4; i++) { for (int j = 1; j <= 4; j++) { if (i != j) ASSERT_EQ(ms.MM(S, i, j), 0); else ASSERT_EQ(ms.MM(S, i, j), diag[i - 1]); } } } TEST_F(MatrixTest, smith_matrix2) { // [[-2561 1265 2517 -3732 1490 1769 1203 -4213 2948 -3189 129 -129 1475 4601 -1635 768 -3204 3619 337 657] // [0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0]] MId T = ms.getNewMatrix(20, 2); ms.MM(T, 1, 1) = -2561; ms.MM(T, 2, 1) = 1265; ms.MM(T, 3, 1) = 2517; ms.MM(T, 4, 1) = -3732; ms.MM(T, 5, 1) = 1490; ms.MM(T, 6, 1) = 1769; ms.MM(T, 7, 1) = 1203; ms.MM(T, 8, 1) = -4213; ms.MM(T, 9, 1) = 2948; ms.MM(T, 10, 1) = -3189; ms.MM(T, 11, 1) = 129; ms.MM(T, 12, 1) = -129; ms.MM(T, 13, 1) = 1475; ms.MM(T, 14, 1) = 4601; ms.MM(T, 15, 1) = -1635; ms.MM(T, 16, 1) = 768; ms.MM(T, 17, 1) = -3204; ms.MM(T, 18, 1) = 3619; ms.MM(T, 19, 1) = 337; ms.MM(T, 20, 1) = 657; ms.MM(T, 1, 2) = 0; ms.MM(T, 2, 2) = 0; ms.MM(T, 3, 2) = 0; ms.MM(T, 4, 2) = 0; ms.MM(T, 5, 2) = 0; ms.MM(T, 6, 2) = 0; ms.MM(T, 7, 2) = 0; ms.MM(T, 8, 2) = 1; ms.MM(T, 9, 2) = 0; ms.MM(T, 10, 2) = 0; ms.MM(T, 11, 2) = 0; ms.MM(T, 12, 2) = 0; ms.MM(T, 13, 2) = 0; ms.MM(T, 14, 2) = 0; ms.MM(T, 15, 2) = 0; ms.MM(T, 16, 2) = 0; ms.MM(T, 17, 2) = 0; ms.MM(T, 18, 2) = 0; ms.MM(T, 19, 2) = 0; ms.MM(T, 20, 2) = 0; MId S2 = ms.getNewMatrix(20, 2); MId L2 = ms.getNewMatrix(20, 20); MId L2i = ms.getNewMatrix(20, 20); MId R2 = ms.getNewMatrix(2, 2); MId R2i = ms.getNewMatrix(2, 2); int dim; ms.compute_snf(T, S2, dim, L2, L2i, R2, R2i); printf("snf matrix:\n%s\n", ms.print(S2).c_str()); } TEST_F(MatrixTest, smith_matrix3) { MId T3 = ms.getNewMatrix(21, 1); ms.MM(T3, 1, 1) = -2936; ms.MM(T3, 2, 1) = 768; ms.MM(T3, 3, 1) = 344; ms.MM(T3, 4, 1) = -688; ms.MM(T3, 5, 1) = 3192; ms.MM(T3, 6, 1) = -4092; ms.MM(T3, 7, 1) = 1848; ms.MM(T3, 8, 1) = -2640; ms.MM(T3, 9, 1) = -3872; ms.MM(T3, 10, 1) = 1988; ms.MM(T3, 11, 1) = 2340; ms.MM(T3, 12, 1) = -3317; ms.MM(T3, 13, 1) = 276; ms.MM(T3, 14, 1) = -2188; ms.MM(T3, 15, 1) = 1836; ms.MM(T3, 16, 1) = -912; ms.MM(T3, 17, 1) = -1225; ms.MM(T3, 18, 1) = 1788; ms.MM(T3, 19, 1) = -1988; ms.MM(T3, 20, 1) = 1588; ms.MM(T3, 21, 1) = 448; MId S3 = ms.getNewMatrix(21, 1); MId L3 = ms.getNewMatrix(21, 21); MId L3i = ms.getNewMatrix(21, 21); MId R3 = ms.getNewMatrix(1, 1); MId R3i = ms.getNewMatrix(1, 1); int dim; ms.compute_snf(T3, S3, dim, L3, L3i, R3, R3i); printf("snf matrix:\n%s\n", ms.print(S3).c_str()); } TEST_F(MatrixTest, smith_matrix4) { const int N = 20; MId T3 = ms.getNewMatrix(N, 1); int vals[N] = {-3480, -1956, -768, -1732, 1700, 15748, 800, 4280, 5276, -963, -3576, 5324, 23800, -5324, -2820, 1732, 3532, -1796, -868, 3269}; for (int i = 1; i <= N; i++) ms.MM(T3, i, 1) = vals[i-1]; MId S3 = ms.getNewMatrix(N, 1); MId L3 = ms.getNewMatrix(N, N); MId L3i = ms.getNewMatrix(N, N); MId R3 = ms.getNewMatrix(1, 1); MId R3i = ms.getNewMatrix(1, 1); int dim; ms.compute_snf(T3, S3, dim, L3, L3i, R3, R3i); printf("snf matrix:\n%s\n", ms.print(S3).c_str()); } TEST_F(MatrixTest, matrix_mult) { MId A = ms.getNewMatrix(2, 2); ms.MM(A, 1, 1) = 1; ms.MM(A, 2, 1) = 2; ms.MM(A, 1, 2) = 3; ms.MM(A, 2, 2) = 4; MId R = ms.mul_matrix(A, A); ASSERT_EQ(ms.MM(R, 1, 1), 7); ASSERT_EQ(ms.MM(R, 2, 1), 10); ASSERT_EQ(ms.MM(R, 1, 2), 15); ASSERT_EQ(ms.MM(R, 2, 2), 22); MId B = ms.getNewMatrix(2, 3); MId C = ms.getNewMatrix(3, 2); ms.MM(B, 1, 1) = 1; ms.MM(B, 2, 1) = 2; ms.MM(B, 1, 2) = 3; ms.MM(B, 2, 2) = 4; ms.MM(B, 1, 3) = 5; ms.MM(B, 2, 3) = 6; ms.MM(C, 1, 1) = 1; ms.MM(C, 2, 1) = 2; ms.MM(C, 3, 1) = 3; ms.MM(C, 1, 2) = 4; ms.MM(C, 2, 2) = 5; ms.MM(C, 3, 2) = 6; MId R2 = ms.mul_matrix(B, C); printf("The matrix:\n%s\n", ms.print(R2).c_str()); ASSERT_EQ(ms.MM(R2, 1, 1), 22); ASSERT_EQ(ms.MM(R2, 2, 1), 28); ASSERT_EQ(ms.MM(R2, 1, 2), 49); ASSERT_EQ(ms.MM(R2, 2, 2), 64); LAVecRef x = vecStore.getNewVec({1, 2, 3}); LAVecRef v = ms.mul_vector(B, x); ASSERT_EQ(vecStore[v][1], 22); ASSERT_EQ(vecStore[v][2], 28); } TEST_F(MatrixTest, discretize) { LAVecRef v = vecStore.getNewVec(13); vecStore[v][1] = 0; vecStore[v][2] = FastRational("1/10"); vecStore[v][3] = FastRational("-1/10"); vecStore[v][4] = FastRational("-1/2"); vecStore[v][5] = FastRational("-7/10"); vecStore[v][6] = FastRational("7/10"); vecStore[v][7] = FastRational("11/10"); vecStore[v][8] = FastRational("-11/10"); vecStore[v][9] = FastRational("2147483648/2147483647"); vecStore[v][10] = FastRational("-2147483649/2147483648"); vecStore[v][11] = FastRational("1/2147483648"); vecStore[v][12] = FastRational("-1/2147483649"); LAVecRef u = ms.discretize(v); ASSERT_EQ(vecStore[u][1], 0); ASSERT_EQ(vecStore[u][2], 0); ASSERT_EQ(vecStore[u][3], 0); ASSERT_EQ(vecStore[u][4], 0); ASSERT_EQ(vecStore[u][5], -1); ASSERT_EQ(vecStore[u][6], 1); ASSERT_EQ(vecStore[u][7], 1); ASSERT_EQ(vecStore[u][8], -1); ASSERT_EQ(vecStore[u][9], 1); ASSERT_EQ(vecStore[u][10], -1); ASSERT_EQ(vecStore[u][11], 0); ASSERT_EQ(vecStore[u][12], 0); } TEST_F(MatrixTest, non_square) { MId U = ms.getNewMatrix(2,3); // Should be 2 columns, 3 rows ms.MM(U, 1, 1) = 11; ms.MM(U, 2, 1) = 21; ms.MM(U, 1, 2) = 12; ms.MM(U, 2, 2) = 22; ms.MM(U, 1, 3) = 13; ms.MM(U, 2, 3) = 23; printf("The matrix:\n%s\n", ms.print(U).c_str()); } TEST(gcd_test, gcd) { FastRational p1(7177); FastRational p2(7817); FastRational p3(173); FastRational q1 = p1*p3; FastRational q2 = p2*p3; ASSERT_EQ(gcd(p1, p2), 1); ASSERT_EQ(gcd(p1, p3), 1); ASSERT_EQ(gcd(p2, p3), 1); ASSERT_EQ(gcd(q1, q2), p3); ASSERT_EQ(gcd(q2, q1), p3); FastRational p4(7919); FastRational p5(7907); FastRational q3 = p1*p2*p4; FastRational q4 = p1*p2*p5; ASSERT_EQ(gcd(q3, q4), p1*p2); FastRational r1 = q3*q4; FastRational r2 = q3*q4*p3; ASSERT_EQ(gcd(r1, r2), q3*q4); } TEST(lcm_test, lcm) { FastRational p1(2); FastRational p2(6); ASSERT_EQ(lcm(p1, p2), 6); ASSERT_EQ(lcm(p2, p1), 6); FastRational p3(7177); FastRational p4(7817); FastRational p5(7919); FastRational p6(7907); ASSERT_EQ(lcm(p3, p4), p3*p4); FastRational q1 = p3*p4; FastRational q2 = p5*p6; ASSERT_EQ(lcm(q1, q2), p3*p4*p5*p6); FastRational p7(4); FastRational p8("2147483648"); FastRational q3 = p7*p8; ASSERT_EQ(lcm(p7, p8), p8); ASSERT_EQ(lcm(p8, p7), p8); } TEST(lcm_test, lcm_list) { FastRational p1(2, 5); FastRational p2(3, 7); FastRational p3(5, 11); std::vector l = {p1, p2, p3}; FastRational r = get_multiplicand(l); ASSERT_EQ(r, 385); } TEST_F(MatrixTest, least_in_row) { MId U = ms.getNewMatrix(4, 4); int u[4][4] = {{2, 3, 6, 2}, {5, -6, -1, 6}, {8, 3, -1, 1}, {0, 0, 0, 0}}; for (int i = 0; i < 4; i++) for (int j = 0; j < 4; j++) ms.MM(U, i+1, j+1) = u[i][j]; ASSERT_EQ(ms.least_in_row(U, 1, 1), 4); ASSERT_EQ(ms.least_in_row(U, 2, 2), 3); ASSERT_EQ(ms.least_in_row(U, 3, 3), 4); ASSERT_EQ(ms.least_in_row(U, 4, 1), 0); } opensmt-2.5.2/test/unit/test_Model.cc000066400000000000000000000315561445011647600175730ustar00rootroot00000000000000// // Created by Martin Blicha on 14.06.20. // #include #include #include #include #include #include #include #include class UFModelTest : public ::testing::Test { protected: UFModelTest(): logic{opensmt::Logic_t::QF_UF} {} virtual void SetUp() { S = logic.declareUninterpretedSort("U"); x = logic.mkVar(S, "x"); y = logic.mkVar(S, "y"); z = logic.mkVar(S, "z"); f_sym = logic.declareFun("f", S, {S, S}); f = logic.mkUninterpFun(f_sym, {x, y}); v0 = logic.mkConst(S, "@0"); v1 = logic.mkConst(S, "@1"); a = logic.mkBoolVar("a"); b = logic.mkBoolVar("b"); } SMTConfig config; Logic logic; SRef S; PTRef x; PTRef y; PTRef z; PTRef f; PTRef a; PTRef b; PTRef v0; PTRef v1; SymRef f_sym; std::unique_ptr getModel() { Model::Evaluation eval { std::make_pair(x, v0), std::make_pair(y, v0), std::make_pair(z, v1), std::make_pair(a, logic.getTerm_true()), std::make_pair(b, logic.getTerm_false()), }; Model::SymbolDefinition symDef { std::make_pair(f_sym, TemplateFunction("f", {x, y}, S, logic.mkIte(logic.mkEq(x, v1), v0, v1))) }; return std::unique_ptr(new Model(logic, eval, symDef)); } }; class UFModelBuilderTest : public ::testing::Test { protected: UFModelBuilderTest(): logic{opensmt::Logic_t::QF_UF} {} virtual void SetUp() { S = logic.declareUninterpretedSort("U"); x = logic.mkVar(S, "x"); y = logic.mkVar(S, "y"); z = logic.mkVar(S, "z"); f_sym = logic.declareFun("f", S, {S, S}); f = logic.mkUninterpFun(f_sym, {x, y}); v0 = logic.mkConst(S, "@0"); v1 = logic.mkConst(S, "@1"); a = logic.mkBoolVar("a"); b = logic.mkBoolVar("b"); } SMTConfig config; Logic logic; SRef S; PTRef x; PTRef y; PTRef z; PTRef f; PTRef a; PTRef b; PTRef v0; PTRef v1; SymRef f_sym; std::unique_ptr getModel() { ModelBuilder mb(logic); Model::Evaluation eval { std::make_pair(x, v0), std::make_pair(y, v0), std::make_pair(z, v1), std::make_pair(a, logic.getTerm_true()), std::make_pair(b, logic.getTerm_false()), }; mb.addToTheoryFunction(f_sym, {v0, v0}, v0); mb.addVarValues(eval.begin(), eval.end()); return mb.build(); } }; TEST_F(UFModelTest, test_varAndFunctionEvaluation) { auto model = getModel(); EXPECT_EQ(model->evaluate(x), v0); EXPECT_EQ(model->evaluate(y), v0); EXPECT_EQ(model->evaluate(z), v1); EXPECT_EQ(model->evaluate(f), v1); EXPECT_EQ(model->evaluate(logic.mkUninterpFun(f_sym, {logic.mkUninterpFun(f_sym, {x, y}), x})), v0); EXPECT_EQ(model->evaluate(a), logic.getTerm_true()); EXPECT_EQ(model->evaluate(b), logic.getTerm_false()); } TEST_F(UFModelBuilderTest, test_modelBuilderVarAndFunction) { auto model = getModel(); EXPECT_EQ(model->evaluate(x), v0); EXPECT_EQ(model->evaluate(y), v0); EXPECT_EQ(model->evaluate(z), v1); EXPECT_EQ(model->evaluate(f), v0); EXPECT_EQ(model->evaluate(logic.mkUninterpFun(f_sym, {logic.mkUninterpFun(f_sym, {x, y}), x})), v0); EXPECT_EQ(model->evaluate(a), logic.getTerm_true()); EXPECT_EQ(model->evaluate(b), logic.getTerm_false()); } TEST_F(UFModelBuilderTest, test_NameCollision) { ModelBuilder mb(logic); std::string symName("x0"); SymRef x1_sym = logic.declareFun(symName.c_str(), S, {S}); mb.addToTheoryFunction(x1_sym, {v0}, v0); auto m = mb.build(); auto templateFun = m->getDefinition(x1_sym); std::cout << "testing name collision: the following should be different from `x0`" << std::endl; for (PTRef tr : templateFun.getArgs()) { std::string argName(logic.getSymName(tr)); std::cout << argName << std::endl; ASSERT_NE(argName, symName); } } TEST_F(UFModelBuilderTest, test_functionModel) { auto model = getModel(); auto templateFun = model->getDefinition(f_sym); std::cout << logic.pp(templateFun.getBody()) << std::endl; ASSERT_TRUE(logic.isIte(templateFun.getBody())); } class UFConstModelTest : public ::testing::Test { protected: UFConstModelTest() : logic(opensmt::Logic_t::QF_UF), ms(logic, c, "uf-solver") { SRef U = logic.declareUninterpretedSort("U"); fs = logic.declareFun("f", U, {U}); x = logic.mkVar(U, "x"); a = logic.mkConst(U, "a"); f_a = logic.mkUninterpFun(fs, {a}); eq_x_f_a = logic.mkEq(x, f_a); ms.insertFormula(eq_x_f_a); ms.check(); model = ms.getModel(); } PTRef getModelFor(PTRef tr) { return model->evaluate(tr); } TemplateFunction getDefinitionFor(SymRef sr) { return model->getDefinition(sr); } Logic logic; SMTConfig c; MainSolver ms; std::unique_ptr model; SymRef fs; PTRef a; PTRef x; PTRef f_a; PTRef eq_x_f_a; }; TEST_F(UFConstModelTest, test_constModel) { PTRef a_model = getModelFor(a); auto a_model_name = logic.pp(a_model); ASSERT_EQ(a_model_name, "a"); PTRef f_a_model = getModelFor(f_a); PTRef x_model = getModelFor(x); ASSERT_EQ(f_a_model, x_model); TemplateFunction tf = model->getDefinition(fs); Logic::SubstMap sm; sm.insert(tf.getArgs()[0], a); PTRef rewritten = Substitutor(logic, sm).rewrite(tf.getBody()); ASSERT_EQ(rewritten, x_model); } class LAModelTest : public ::testing::Test { protected: LAModelTest(): logic{opensmt::Logic_t::QF_LRA} {} virtual void SetUp() { x = logic.mkRealVar("x"); y = logic.mkRealVar("y"); z = logic.mkRealVar("z"); a = logic.mkBoolVar("a"); b = logic.mkBoolVar("b"); tval = logic.getTerm_true(); fval = logic.getTerm_false(); } SMTConfig config; ArithLogic logic; PTRef x; PTRef y; PTRef z; PTRef a; PTRef b; PTRef tval; PTRef fval; std::unique_ptr getModel() { Model::Evaluation eval { std::make_pair(x, logic.getTerm_RealOne()), std::make_pair(y, logic.getTerm_RealZero()), std::make_pair(z, logic.getTerm_RealOne()), std::make_pair(a, logic.getTerm_true()), std::make_pair(b, logic.getTerm_false()) }; return std::unique_ptr(new Model(logic, eval)); } }; TEST_F(LAModelTest, test_inputVarValues) { auto model = getModel(); EXPECT_EQ(model->evaluate(x), logic.getTerm_RealOne()); EXPECT_EQ(model->evaluate(y), logic.getTerm_RealZero()); EXPECT_EQ(model->evaluate(z), logic.getTerm_RealOne()); EXPECT_EQ(model->evaluate(a), logic.getTerm_true()); EXPECT_EQ(model->evaluate(b), logic.getTerm_false()); } TEST_F(LAModelTest, test_constants) { auto model = getModel(); EXPECT_EQ(model->evaluate(fval), fval); EXPECT_EQ(model->evaluate(tval), tval); PTRef fortytwo = logic.mkRealConst(42); EXPECT_EQ(model->evaluate(fortytwo), fortytwo); PTRef one = logic.mkRealConst(1); EXPECT_EQ(model->evaluate(one), logic.getTerm_RealOne()); PTRef zero = logic.mkRealConst(FastRational(0)); EXPECT_EQ(model->evaluate(zero), logic.getTerm_RealZero()); } TEST_F(LAModelTest, test_derivedBooleanTerms) { auto model = getModel(); PTRef and_false = logic.mkAnd(a,b); PTRef or_true = logic.mkOr(a,b); PTRef not_true = logic.mkNot(b); PTRef not_false = logic.mkNot(a); EXPECT_EQ(model->evaluate(and_false), fval); EXPECT_EQ(model->evaluate(or_true), tval); EXPECT_EQ(model->evaluate(not_true), tval); EXPECT_EQ(model->evaluate(not_false), fval); } TEST_F(LAModelTest, test_derivedArithmeticTerms) { auto model = getModel(); PTRef two = logic.mkRealConst(2); PTRef five = logic.mkRealConst(5); vec args {x,z}; EXPECT_EQ(model->evaluate(logic.mkPlus(args)), two); EXPECT_EQ(model->evaluate(logic.mkTimes(five, x)), five); EXPECT_EQ(model->evaluate(logic.mkTimes(five, y)), logic.getTerm_RealZero()); } TEST_F(LAModelTest, test_derivedArithmeticAtoms) { auto model = getModel(); EXPECT_EQ(model->evaluate(logic.mkLeq(x, y)), fval); EXPECT_EQ(model->evaluate(logic.mkLt(x, y)), fval); EXPECT_EQ(model->evaluate(logic.mkGeq(x, y)), tval); EXPECT_EQ(model->evaluate(logic.mkGt(x, y)), tval); EXPECT_EQ(model->evaluate(logic.mkLeq(y, z)), tval); EXPECT_EQ(model->evaluate(logic.mkLt(y, z)), tval); EXPECT_EQ(model->evaluate(logic.mkGeq(y, z)), fval); EXPECT_EQ(model->evaluate(logic.mkGt(y, z)), fval); EXPECT_EQ(model->evaluate(logic.mkLeq(x, z)), tval); EXPECT_EQ(model->evaluate(logic.mkLt(x, z)), fval); EXPECT_EQ(model->evaluate(logic.mkGeq(x, z)), tval); EXPECT_EQ(model->evaluate(logic.mkGt(x, z)), fval); } TEST_F(LAModelTest, test_distinctOperator) { auto model = getModel(); PTRef distinct = logic.mkDistinct({logic.getTerm_RealZero(), logic.getTerm_RealMinusOne(), x}); EXPECT_EQ(model->evaluate(distinct), tval); } class ModelIntegrationTest : public ::testing::Test { protected: ModelIntegrationTest() {} std::unique_ptr getLRAOsmt() { return std::unique_ptr(new Opensmt(opensmt_logic::qf_lra, "test")); } std::unique_ptr getUFOsmt() { return std::unique_ptr(new Opensmt(opensmt_logic::qf_uf, "test")); } }; TEST_F(ModelIntegrationTest, testSingleAssert) { auto osmt = getLRAOsmt(); ArithLogic& logic = osmt->getLRALogic(); PTRef x = logic.mkRealVar("x"); PTRef y = logic.mkRealVar("y"); PTRef fla = logic.mkLt(x, y); MainSolver& mainSolver = osmt->getMainSolver(); mainSolver.insertFormula(fla); sstat res = mainSolver.check(); ASSERT_EQ(res, s_True); auto model = mainSolver.getModel(); EXPECT_EQ(model->evaluate(fla), logic.getTerm_true()); } TEST_F(ModelIntegrationTest, testSubstitutions) { auto osmt = getLRAOsmt(); Logic& logic = osmt->getLogic(); PTRef x = logic.mkBoolVar("x"); PTRef y = logic.mkBoolVar("y"); PTRef fla = logic.mkEq(x, logic.mkNot(y)); MainSolver& mainSolver = osmt->getMainSolver(); mainSolver.insertFormula(fla); sstat res = mainSolver.check(); ASSERT_EQ(res, s_True); // auto xval = mainSolver.getValue(x); // auto yval = mainSolver.getValue(y); // std::cout << logic.printTerm(xval.tr) << " : " << xval.val << '\n'; // std::cout << logic.printTerm(yval.tr) << " : " << yval.val << std::endl; auto model = mainSolver.getModel(); EXPECT_EQ(model->evaluate(fla), logic.getTerm_true()); } TEST_F(ModelIntegrationTest, testTrivialBooleanSubstitutionNegation) { auto osmt = getLRAOsmt(); Logic& logic = osmt->getLogic(); PTRef x = logic.mkBoolVar("x"); PTRef fla = logic.mkNot(x); MainSolver& mainSolver = osmt->getMainSolver(); mainSolver.insertFormula(fla); sstat res = mainSolver.check(); ASSERT_EQ(res, s_True); auto model = mainSolver.getModel(); EXPECT_EQ(model->evaluate(x), logic.getTerm_false()); EXPECT_EQ(model->evaluate(fla), logic.getTerm_true()); } TEST_F(ModelIntegrationTest, testIteWithSubstitution) { auto osmt = getLRAOsmt(); ArithLogic& logic = osmt->getLRALogic(); PTRef x = logic.mkRealVar("x"); PTRef y = logic.mkRealVar("y"); PTRef ite = logic.mkIte(logic.mkBoolVar("c"), x, logic.mkPlus(x, logic.getTerm_RealOne())); PTRef fla = logic.mkEq(y, ite); MainSolver & mainSolver = osmt->getMainSolver(); mainSolver.insertFormula(fla); auto res = mainSolver.check(); ASSERT_EQ(res, s_True); auto model = mainSolver.getModel(); EXPECT_EQ(model->evaluate(fla), logic.getTerm_true()); } TEST_F(ModelIntegrationTest, testIteWithSubstitution_SubtermsHaveValue) { auto osmt = getLRAOsmt(); ArithLogic& logic = osmt->getLRALogic(); PTRef x = logic.mkRealVar("x"); PTRef y = logic.mkRealVar("y"); PTRef c = logic.mkBoolVar("c"); PTRef one = logic.getTerm_RealOne(); PTRef ite = logic.mkIte(c, x, logic.mkPlus(x, one)); PTRef eq = logic.mkEq(y, ite); PTRef fla = logic.mkAnd({eq, logic.mkLeq(one, y), logic.mkLeq(x, logic.getTerm_RealZero())}); MainSolver & mainSolver = osmt->getMainSolver(); mainSolver.insertFormula(fla); auto res = mainSolver.check(); ASSERT_EQ(res, s_True); auto model = mainSolver.getModel(); // std::cout << logic.printTerm(x) << " := " << logic.printTerm(model->evaluate(x)) << '\n'; // std::cout << logic.printTerm(y) << " := " << logic.printTerm(model->evaluate(y)) << '\n'; // std::cout << logic.printTerm(c) << " := " << logic.printTerm(model->evaluate(c)) << '\n'; EXPECT_EQ(model->evaluate(fla), logic.getTerm_true()); EXPECT_EQ(model->evaluate(c), logic.getTerm_false()); } opensmt-2.5.2/test/unit/test_NameProtection.cc000066400000000000000000000065311445011647600214550ustar00rootroot00000000000000/* * Copyright (c) 2022, Antti Hyvarinen * Copyright (c) 2022, Seyedmasoud Asadzadeh * * SPDX-License-Identifier: MIT */ #include #include class NameProtectionTest : public ::testing::Test { public: NameProtectionTest() : arithLogic(opensmt::Logic_t::QF_LIA), ufLogic(opensmt::Logic_t::QF_UF), ufliaLogic(opensmt::Logic_t::QF_UFLIA) {} ArithLogic arithLogic; Logic ufLogic; ArithLogic ufliaLogic; }; TEST_F(NameProtectionTest, test_NumberEscape) { PTRef numberOne = arithLogic.mkIntConst(1); ASSERT_EQ(arithLogic.pp(numberOne), "1"); PTRef numberTen = arithLogic.mkIntConst(10); ASSERT_EQ(arithLogic.pp(numberTen), "10"); PTRef varOne = arithLogic.mkIntVar("1"); ASSERT_NE(varOne, numberOne); ASSERT_EQ(arithLogic.pp(varOne), "|1|"); PTRef numericVar = arithLogic.mkIntVar("10abc"); ASSERT_EQ(arithLogic.pp(numericVar), "|10abc|"); } TEST_F(NameProtectionTest, test_SymbolEscape) { PTRef symbolOne = ufLogic.mkVar(ufLogic.getSort_bool(), "1"); ASSERT_EQ(ufLogic.pp(symbolOne), "|1|"); PTRef symbolTen = ufLogic.mkVar(ufLogic.getSort_bool(), "10"); ASSERT_EQ(ufLogic.pp(symbolTen), "|10|"); PTRef symbolNumericStart = ufLogic.mkVar(ufLogic.getSort_bool(), "10ab"); ASSERT_EQ(ufLogic.pp(symbolNumericStart), "|10ab|"); } TEST_F(NameProtectionTest, test_SymbolExcapeMixed) { PTRef symbolOne = ufliaLogic.mkVar(ufliaLogic.getSort_bool(), "1"); PTRef numberOne = ufliaLogic.mkIntConst(1); ASSERT_EQ(ufliaLogic.pp(symbolOne), "|1|"); ASSERT_EQ(ufliaLogic.pp(numberOne), "1"); SymRef functionOne = ufliaLogic.declareFun("1", ufliaLogic.getSort_int(), {ufliaLogic.getSort_int()}); PTRef funSymbolOne = ufliaLogic.mkUninterpFun(functionOne, {ufliaLogic.mkIntConst(1)}); ASSERT_EQ(ufliaLogic.pp(funSymbolOne), "(|1| 1)"); } TEST_F(NameProtectionTest, test_ReservedWord) { PTRef symbolLet = ufLogic.mkVar(ufLogic.getSort_bool(), "let"); ASSERT_EQ(ufLogic.pp(symbolLet), "|let|"); PTRef symbolLet2 = arithLogic.mkVar(arithLogic.getSort_bool(), "let"); ASSERT_EQ(arithLogic.pp(symbolLet2), "|let|"); PTRef symbolLet3 = ufliaLogic.mkVar(ufliaLogic.getSort_bool(), "let"); ASSERT_EQ(ufliaLogic.pp(symbolLet3), "|let|"); } TEST_F(NameProtectionTest, test_AmbiguousVarPrinting) { PTRef intVar = arithLogic.mkVar(arithLogic.getSort_int(), "a"); PTRef boolVar = arithLogic.mkVar(arithLogic.getSort_bool(), "a"); ASSERT_NE(intVar, boolVar); std::string intVar_pp = arithLogic.pp(intVar); std::string boolVar_pp = arithLogic.pp(boolVar); ASSERT_EQ(intVar_pp, "(as a Int)"); ASSERT_EQ(boolVar_pp, "(as a Bool)"); PTRef boolVarWithNumericName = arithLogic.mkVar(arithLogic.getSort_bool(), "1"); PTRef intVar2 = arithLogic.mkVar(arithLogic.getSort_int(), "b"); PTRef intEquality = arithLogic.mkEq(intVar2, arithLogic.mkIntConst(1)); std::string boolVarWithNumericName_s = arithLogic.pp(boolVarWithNumericName); std::string intEquality_s = arithLogic.pp(intEquality); std::cout << boolVarWithNumericName_s << std::endl; ASSERT_EQ(boolVarWithNumericName_s, "|1|"); // No disambiguation necessary std::cout << intEquality_s << std::endl; ASSERT_TRUE(intEquality_s.find("(as ") == std::string::npos); // No disambiguation necessary } opensmt-2.5.2/test/unit/test_NumberParser.cc000066400000000000000000000033171445011647600211320ustar00rootroot00000000000000// // Created by Antti on 16.09.21. // #include #include using namespace opensmt; class NumberParserTest : public ::testing::Test { public: NumberParserTest() {} }; TEST_F(NumberParserTest, test_RealCheck) { std::vector pos_cases = {"1", "-1", ".1", "-.1", "0.1", "-0.1", "0", "-0", "1/2", "-1/2", "0.1/2", ".1/2", "-.1/2", "1/.2", "-1/.2", "-0.1/2", "0.1/0.2", "-0.1/0.2", ".1/.2", "-.1/.2", "123", "123/234", "123.456", "123.456/234.567"}; std::vector neg_cases = {"", "a", "1a", "/2", "1/", "1/-2"}; std::cout << "Postitive cases:" << std::endl; for (auto s : pos_cases) { std::cout << " - " << s << std::endl; ASSERT_TRUE(isRealString(s.data())); } std::cout << "Negative cases:" << std::endl; for (auto s: neg_cases) { std::cout << " - " << s << std::endl; ASSERT_FALSE(isRealString(s.data())); } } TEST_F(NumberParserTest, test_IntCheck) { std::vector pos_cases = {"1", "-1", "0", "-0", "123", "-123"}; std::vector neg_cases = {"", "a", "1a", "/2", "1/", "1/-2", ".1", "-.1", "0.1", "-0.1", "1/2", "-1/2", "0.1/2", ".1/2", "-.1/2", "1/.2", "-1/.2", "-0.1/2", "0.1/0.2", "-0.1/0.2", ".1/.2", "-.1/.2"}; std::cout << "Postitive cases:" << std::endl; for (auto s : pos_cases) { std::cout << " - " << s << std::endl; ASSERT_TRUE(isIntString(s.data())); } std::cout << "Negative cases:" << std::endl; for (auto s: neg_cases) { std::cout << " - " << s << std::endl; ASSERT_FALSE(isIntString(s.data())); } }opensmt-2.5.2/test/unit/test_Polynomial.cpp000066400000000000000000000046511445011647600210470ustar00rootroot00000000000000/* * Copyright (c) 2019-2022, Martin Blicha * * SPDX-License-Identifier: MIT */ #include #include #include using Polynomial = PolynomialT; class PolyTest : public ::testing::Test { protected: Polynomial::poly_t tmp_storage {}; Polynomial poly1 {}; Polynomial poly2 {}; }; TEST_F(PolyTest, test_AddTerm){ LVRef var {10}; poly1.addTerm(var, 1); EXPECT_EQ(poly1.getCoeff(var), 1); } TEST_F(PolyTest, test_Merge){ LVRef x {10}; LVRef y {20}; LVRef z {30}; poly1.addTerm(x, 1); poly1.addTerm(y, -3); poly2.addTerm(z, 1); poly2.addTerm(y, 3); std::vector added; std::vector removed; auto add = [&added](LVRef v) { added.push_back(v); }; auto remove = [&removed](LVRef v) { removed.push_back(v); }; poly1.merge(poly2, 1, tmp_storage, add, remove); ASSERT_EQ(added.size(),1); EXPECT_EQ(added[0], z); ASSERT_EQ(removed.size(),1); EXPECT_EQ(removed[0], y); ASSERT_TRUE(poly1.contains(x)); ASSERT_TRUE(poly1.contains(z)); EXPECT_FALSE(poly1.contains(y)); EXPECT_EQ(poly1.getCoeff(x), 1); EXPECT_EQ(poly1.getCoeff(z), 1); } TEST_F(PolyTest, test_Merge2){ LVRef x1 {4772}; LVRef x2 {4776}; LVRef y1 {2604}; LVRef y2 {4624}; poly1.addTerm(x1, 1); poly1.addTerm(x2, -1); poly2.addTerm(y1, -1); poly2.addTerm(y2, 1); std::vector added; std::vector removed; auto add = [&added](LVRef v) { added.push_back(v); }; auto remove = [&removed](LVRef v) { removed.push_back(v); }; poly1.merge(poly2, 1, tmp_storage, add, remove); ASSERT_EQ(added.size(),2); ASSERT_EQ(removed.size(),0); ASSERT_TRUE(poly1.contains(x1)); ASSERT_TRUE(poly1.contains(x2)); ASSERT_TRUE(poly1.contains(y1)); ASSERT_TRUE(poly1.contains(y2)); } TEST_F(PolyTest, test_Merge3){ LVRef x1 {4772}; LVRef x2 {4776}; poly1.addTerm(x1, 1); poly1.addTerm(x2, -2); poly2.addTerm(x2, 1); std::vector added; std::vector removed; auto add = [&added](LVRef v) { added.push_back(v); }; auto remove = [&removed](LVRef v) { removed.push_back(v); }; poly1.merge(poly2, 2, tmp_storage, add, remove); ASSERT_EQ(added.size(),0); ASSERT_EQ(removed.size(),1); EXPECT_EQ(removed[0], x2); ASSERT_TRUE(poly1.contains(x1)); ASSERT_TRUE(!poly1.contains(x2)); }opensmt-2.5.2/test/unit/test_Proof.cc000066400000000000000000000332111445011647600176060ustar00rootroot00000000000000// // Created by Martin Blicha on 07.07.21. // #include #include TEST(ProofTest, test_mergeClauses_PivotPresent_NoDuplicates) { std::vector left { mkLit(0, true), mkLit(1,false) }; std::vector right { mkLit(1, true), mkLit(2,false) }; std::vector res; Var pivot = 1; ProofGraph::mergeClauses(left, right, res, pivot); ASSERT_EQ(res.size(), 2); EXPECT_EQ(res[0], mkLit(0,true)); EXPECT_EQ(res[1], mkLit(2,false)); } TEST(ProofTest, test_mergeClauses_PivotPresent_Duplicates) { std::vector left { mkLit(0, true), mkLit(1,false), mkLit(2,false) }; std::vector right { mkLit(1, true), mkLit(2,false), mkLit(3,false) }; std::vector res; Var pivot = 1; ProofGraph::mergeClauses(left, right, res, pivot); ASSERT_EQ(res.size(), 3); EXPECT_EQ(res[0], mkLit(0,true)); EXPECT_EQ(res[1], mkLit(2,false)); EXPECT_EQ(res[2], mkLit(3,false)); } TEST(ProofTest, test_mergeClauses_GarbageInResult) { std::vector left { mkLit(0, true), mkLit(1,false) }; std::vector right { mkLit(1, true), mkLit(2,false) }; std::vector res { mkLit(100, true), mkLit(42, false), mkLit(0, true), mkLit(0, true) }; Var pivot = 1; ProofGraph::mergeClauses(left, right, res, pivot); ASSERT_EQ(res.size(), 2); EXPECT_EQ(res[0], mkLit(0,true)); EXPECT_EQ(res[1], mkLit(2,false)); } TEST(ProofTest, test_mergeClauses_DuplicateAfterFirstEnd) { std::vector left { mkLit(0, true), mkLit(1,false), mkLit(4,false) }; std::vector right { mkLit(1, true), mkLit(2,false), mkLit(3,false), mkLit(4,false) }; std::vector res; Var pivot = 1; ProofGraph::mergeClauses(left, right, res, pivot); ASSERT_EQ(res.size(), 4); EXPECT_EQ(res[0], mkLit(0,true)); EXPECT_EQ(res[1], mkLit(2,false)); EXPECT_EQ(res[2], mkLit(3,false)); EXPECT_EQ(res[3], mkLit(4,false)); } TEST(ProofTest, test_mergeClauses_DuplicateAfterSecondEnd) { std::vector left { mkLit(1, true), mkLit(2,false), mkLit(3,false), mkLit(4,false) }; std::vector right { mkLit(0, true), mkLit(1,false), mkLit(4,false) }; std::vector res; Var pivot = 1; ProofGraph::mergeClauses(left, right, res, pivot); ASSERT_EQ(res.size(), 4); EXPECT_EQ(res[0], mkLit(0,true)); EXPECT_EQ(res[1], mkLit(2,false)); EXPECT_EQ(res[2], mkLit(3,false)); EXPECT_EQ(res[3], mkLit(4,false)); } TEST(ProofTest, test_mergeClauses_PivotAfterSecondEnd) { std::vector left { mkLit(1, true), mkLit(2,false), mkLit(3,false), mkLit(4,false) }; std::vector right { mkLit(1, false) }; std::vector res; Var pivot = 1; ProofGraph::mergeClauses(left, right, res, pivot); ASSERT_EQ(res.size(), 3); EXPECT_EQ(res[0], mkLit(2,false)); EXPECT_EQ(res[1], mkLit(3,false)); EXPECT_EQ(res[2], mkLit(4,false)); } TEST(ProofTest, test_mergeClauses_PivotAfterFirstEnd) { std::vector left { mkLit(1, false) }; std::vector right { mkLit(1, true), mkLit(2,false), mkLit(3,false), mkLit(4,false) }; std::vector res; Var pivot = 1; ProofGraph::mergeClauses(left, right, res, pivot); ASSERT_EQ(res.size(), 3); EXPECT_EQ(res[0], mkLit(2,false)); EXPECT_EQ(res[1], mkLit(3,false)); EXPECT_EQ(res[2], mkLit(4,false)); } // Reduction algorithms class ReductionTest : public ::testing::Test { protected: ReductionTest(): logic{opensmt::Logic_t::QF_BOOL}, config{}, theory{config, logic}, partitionManager{logic}, termMapper{logic}, ca{}, proof{ca} {} virtual void SetUp() { a_term = logic.mkBoolVar("a"); b_term = logic.mkBoolVar("b"); c_term = logic.mkBoolVar("c"); d_term = logic.mkBoolVar("d"); e_term = logic.mkBoolVar("e"); a = termMapper.getOrCreateLit(a_term); b = termMapper.getOrCreateLit(b_term); c = termMapper.getOrCreateLit(c_term); d = termMapper.getOrCreateLit(d_term); e = termMapper.getOrCreateLit(e_term); partitionManager.addIPartitions(a_term, 1); partitionManager.addIPartitions(b_term, 1); partitionManager.addIPartitions(c_term, 1); partitionManager.addIPartitions(d_term, 1); partitionManager.addIPartitions(e_term, 1); } Logic logic; SMTConfig config; UFTheory theory; PartitionManager partitionManager; TermMapper termMapper; ClauseAllocator ca; Proof proof; PTRef a_term; PTRef b_term; PTRef c_term; PTRef d_term; PTRef e_term; Lit a; Lit b; Lit c; Lit d; Lit e; }; TEST_F(ReductionTest, test_recyclePivots) { CRef a_b = ca.alloc(vec{a,b}); CRef nb_c = ca.alloc(vec{~b,c}); CRef nb_nc = ca.alloc(vec{~b,~c}); CRef b_nc = ca.alloc(vec{b,~c}); CRef na_c = ca.alloc(vec{~a,c}); CRef nc_nd = ca.alloc(vec{~c,~d}); CRef nc_d = ca.alloc(vec{~c,d}); CRef na_d = ca.alloc(vec{~a,d}); vec clauses = {a_b,nb_c, nb_nc, b_nc, na_c, nc_nd, nc_d, na_d}; for (CRef cr : clauses) { partitionManager.addClauseClassMask(cr, 1); } for (CRef cr : clauses) { proof.newOriginalClause(cr); } // Learnt clauses CRef a_c = ca.alloc(vec{a,c}, {true, 0}); CRef nd = ca.alloc(vec{~d}, {true, 0}); proof.beginChain(a_b); proof.addResolutionStep(nb_c, var(b)); proof.endChain(a_c); proof.beginChain(nb_nc); proof.addResolutionStep(a_c, var(c)); proof.addResolutionStep(a_b, var(b)); proof.addResolutionStep(na_c, var(a)); proof.addResolutionStep(nc_nd, var(c)); proof.endChain(nd); proof.beginChain(nc_d); proof.addResolutionStep(a_c, var(c)); proof.addResolutionStep(na_d,var(a)); proof.addResolutionStep(nd, var(d)); proof.endChain(CRef_Undef); ProofGraph pg(config, theory.getLogic(), termMapper, proof); pg.fillProofGraph(); pg.checkProof(true); // pg.printProofAsDotty(std::cout); pg.recyclePivotsIter(); pg.checkProof(true); // std::cout << "\n\n\n"; // pg.printProofAsDotty(std::cout); pg.emptyProofGraph(); EXPECT_TRUE(true); } TEST_F(ReductionTest, test_recyclePivots_IdenticalAntecedents) { CRef a_d = ca.alloc(vec{a,d}); CRef b_nd = ca.alloc(vec{b,~d}); CRef na_c = ca.alloc(vec{~a,c}); CRef na_nc = ca.alloc(vec{~a,~c}); CRef nb_nd = ca.alloc(vec{~b,~d}); CRef d_e = ca.alloc(vec{d,e}); CRef b_nc_nd_ne = ca.alloc(vec{b,~c,~d,~e}); CRef d_ne = ca.alloc(vec{d,~e}); CRef nb_ne = ca.alloc(vec{~b,~e}); vec clauses = {a_d, b_nd, na_c, na_nc, nb_nd, d_e, b_nc_nd_ne, d_ne, nb_ne}; for (CRef cr : clauses) { partitionManager.addClauseClassMask(cr, 1); } for (CRef cr : clauses) { proof.newOriginalClause(cr); } // Learnt clauses CRef a_b = ca.alloc(vec{a,b}, {true, 0}); proof.beginChain(a_d); proof.addResolutionStep(b_nd, var(d)); proof.endChain(a_b); CRef b_c = ca.alloc(vec{b,c}, {true, 0}); proof.beginChain(na_c); proof.addResolutionStep(a_b, var(a)); proof.endChain(b_c); CRef ne = ca.alloc(vec{~e}, {true, 0}); proof.beginChain(b_nc_nd_ne); proof.addResolutionStep(b_c, var(c)); proof.addResolutionStep(nb_ne, var(b)); proof.addResolutionStep(d_ne, var(d)); proof.endChain(ne); // bot proof.beginChain(na_nc); proof.addResolutionStep(b_c, var(c)); proof.addResolutionStep(a_b,var(a)); proof.addResolutionStep(nb_nd, var(b)); proof.addResolutionStep(d_e, var(d)); proof.addResolutionStep(ne, var(e)); proof.endChain(CRef_Undef); ProofGraph pg(config, theory.getLogic(), termMapper, proof); pg.fillProofGraph(); pg.checkProof(true); // pg.printProofAsDotty(std::cout); pg.recyclePivotsIter(); pg.checkProof(true); // std::cout << "\n\n\n"; // pg.printProofAsDotty(std::cout); pg.emptyProofGraph(); EXPECT_TRUE(true); } TEST_F(ReductionTest, test_recyclePivots_IdenticalAntecedents_AfterPhaseOneReplace) { CRef a_d = ca.alloc(vec{a,d}); CRef b_nd = ca.alloc(vec{b,~d}); CRef na_c = ca.alloc(vec{~a,c}); CRef na_nc = ca.alloc(vec{~a,~c}); CRef nb_c_nd = ca.alloc(vec{~b,c,~d}); CRef nc_nd = ca.alloc(vec{~c,~d}); CRef d_e = ca.alloc(vec{d,e}); CRef b_nc_nd_ne = ca.alloc(vec{b,~c,~d,~e}); CRef d_ne = ca.alloc(vec{d,~e}); CRef nb_ne = ca.alloc(vec{~b,~e}); vec clauses = {a_d, b_nd, na_c, na_nc, nb_c_nd, nc_nd, d_e, b_nc_nd_ne, d_ne, nb_ne}; for (CRef cr : clauses) { partitionManager.addClauseClassMask(cr, 1); } for (CRef cr : clauses) { proof.newOriginalClause(cr); } // Learnt clauses CRef a_b = ca.alloc(vec{a,b}, {true, 0}); proof.beginChain(a_d); proof.addResolutionStep(b_nd, var(d)); proof.endChain(a_b); CRef b_c = ca.alloc(vec{b,c}, {true, 0}); proof.beginChain(na_c); proof.addResolutionStep(a_b, var(a)); proof.endChain(b_c); CRef ne = ca.alloc(vec{~e}, {true, 0}); proof.beginChain(b_nc_nd_ne); proof.addResolutionStep(b_c, var(c)); proof.addResolutionStep(nb_ne, var(b)); proof.addResolutionStep(d_ne, var(d)); proof.endChain(ne); // bot proof.beginChain(na_nc); proof.addResolutionStep(b_c, var(c)); proof.addResolutionStep(a_b,var(a)); proof.addResolutionStep(nb_c_nd, var(b)); proof.addResolutionStep(nc_nd, var(c)); proof.addResolutionStep(d_e, var(d)); proof.addResolutionStep(ne, var(e)); proof.endChain(CRef_Undef); ProofGraph pg(config, theory.getLogic(), termMapper, proof); pg.fillProofGraph(); pg.checkProof(true); // pg.printProofAsDotty(std::cout); pg.recyclePivotsIter(); pg.checkProof(true); // std::cout << "\n\n\n"; // pg.printProofAsDotty(std::cout); pg.emptyProofGraph(); EXPECT_TRUE(true); } TEST_F(ReductionTest, test_proofTransformAndRestructure) { CRef a_b = ca.alloc(vec{a,b}); CRef na_c = ca.alloc(vec{~a,c}); CRef na_nb_d = ca.alloc(vec{~a,~b,d}); CRef a_e = ca.alloc(vec{a,e}); CRef d_ne = ca.alloc(vec{d,~e}); CRef nc_d = ca.alloc(vec{~c,d}); CRef nd = ca.alloc(vec{~d}); vec clauses = {a_b, na_c, na_nb_d, a_e, d_ne, nc_d, nd}; for (CRef cr : clauses) { partitionManager.addClauseClassMask(cr, 1); } for (CRef cr : clauses) { proof.newOriginalClause(cr); } // Learnt clauses CRef a_d = ca.alloc(vec{a,d}, {true, 0}); proof.beginChain(a_e); proof.addResolutionStep(d_ne, var(e)); proof.endChain(a_d); // bot proof.beginChain(a_b); proof.addResolutionStep(na_c, var(a)); proof.addResolutionStep(na_nb_d,var(b)); proof.addResolutionStep(a_d, var(a)); proof.addResolutionStep(nc_d, var(c)); proof.addResolutionStep(nd, var(d)); proof.endChain(CRef_Undef); ProofGraph pg(config, theory.getLogic(), termMapper, proof); pg.fillProofGraph(); pg.checkProof(true); // pg.printProofAsDotty(std::cout); pg.proofTransformAndRestructure(-1,1,true, [&pg](RuleContext & ra1, RuleContext & ra2) { return pg.handleRuleApplicationForReduction(ra1, ra2); }); pg.checkProof(true); // std::cout << "\n\n\n"; // pg.printProofAsDotty(std::cout); pg.emptyProofGraph(); EXPECT_TRUE(true); } /* * This proof shows a situation where a node can end up with identical antecedents in the algorithm * ProofGraph::proofTransformAndRestructure with ProofGraph::handleRuleApplicationForReduction * as the rule selection method. * * The smallest example of that (shown in this test) is a diamond-like subproof * ~ab a v C ~a~b * b v C ~b v C * C * If the literal 'a' in "a v C" turns out to be unnecessary (because of redundancies above it) then * the algorithm runs into the situation when two antecedents of a node is the same node. * However, the situation is not problematic and such node should just be replaced with its single parent. * */ TEST_F(ReductionTest, test_proofTransformAndRestructure_IdenticalAntecedents) { CRef a_b = ca.alloc(vec{a,b}); CRef na_c = ca.alloc(vec{~a,c}); CRef na_nb_d = ca.alloc(vec{~a,~b,d}); CRef nd_e = ca.alloc(vec{~d,e}); CRef nd_ne = ca.alloc(vec{~d,~e}); CRef nc = ca.alloc(vec{~c}); CRef aa = ca.alloc(vec{a}); vec clauses = {a_b, na_c, na_nb_d, nd_e, nd_ne, nc, aa}; for (CRef cr : clauses) { partitionManager.addClauseClassMask(cr, 1); } for (CRef cr : clauses) { proof.newOriginalClause(cr); } // learnt clauses CRef na_c_d = ca.alloc(vec{~a,c,d}, {true, 0}); proof.beginChain(a_b); proof.addResolutionStep(na_c, var(a)); proof.addResolutionStep(na_nb_d,var(b)); proof.endChain(na_c_d); CRef na_c_e = ca.alloc(vec{~a,c,e}, {true, 0}); proof.beginChain(nd_e); proof.addResolutionStep(na_c_d, var(d)); proof.endChain(na_c_e); // bot proof.beginChain(nd_ne); proof.addResolutionStep(na_c_d, var(d)); proof.addResolutionStep(na_c_e, var(e)); proof.addResolutionStep(aa, var(a)); proof.addResolutionStep(nc, var(c)); proof.endChain(CRef_Undef); ProofGraph pg(config, theory.getLogic(), termMapper, proof); pg.fillProofGraph(); pg.checkProof(true); // pg.printProofAsDotty(std::cout); pg.proofTransformAndRestructure(-1,1,true, [&pg](RuleContext & ra1, RuleContext & ra2) { return pg.handleRuleApplicationForReduction(ra1, ra2); }); pg.checkProof(true); // std::cout << "\n\n\n"; // pg.printProofAsDotty(std::cout); pg.emptyProofGraph(); EXPECT_TRUE(true); } opensmt-2.5.2/test/unit/test_Rationals.cpp000066400000000000000000000307721445011647600206630ustar00rootroot00000000000000#include #include #include #include #include using Real = opensmt::Real; TEST(Rationals_test, test_division_int32min) { // INT32_MIN Real r {"-2147483648"}; ASSERT_LT(r,0); Real nom = r/2047; Real den = r/3071; ASSERT_LT(nom, 0); ASSERT_LT(den, 0); ASSERT_GT(nom/den, 0); nom /= den; ASSERT_GT(nom, 0); } TEST(Rationals_test, test_abs_val_int32min) { int32_t x = -2147483648; ASSERT_EQ(absVal(x), 2147483648); } TEST(Rationals_test, test_normalized) { FastRational toNormalize(2,4); EXPECT_EQ(toNormalize.get_num(), 1); EXPECT_EQ(toNormalize.get_den(), 2); } TEST(Rationals_test, test_hash_function) { vec hashes; for (int i = 0; i < 10; i++) { Real r((int)random()); hashes.push(r.getHashValue()); } for (int i = 0; i < 10; i++) { Real r(i); hashes.push(r.getHashValue()); } for (int i = 0; i < 10; i++) { char* str; int written = asprintf(&str, "%ld/%u", random(), UINT32_MAX); assert(written != -1); (void)written; Real r(str); free(str); hashes.push(r.getHashValue()); } for (int i = 0; i < 10; i++) { char num_str[21]; for (int j = 0; j < 20; j++) { num_str[j] = 48+(random() % 10); } num_str[20] = 0; char den_str[21]; for (int j = 0; j < 20; j++) { den_str[j] = 48+(random() % 10); } den_str[20] = 0; char *str; int written = asprintf(&str, "%s/%s", num_str, den_str); assert(written != -1); (void)written; Real r(str); free(str); hashes.push(r.getHashValue()); } for (int k = 0; k < 10; k++) { char den_str[21]; for (int j = 0; j < 19; j++) { den_str[j] = 48+(random() % 10); } den_str[20] = 0; for (int i = 0; i < 10; i++) { den_str[19] = 48 + i; char *str; int written = asprintf(&str, "1/%s", den_str); assert(written != -1); (void)written; Real r(str); free(str); hashes.push(r.getHashValue()); } } sort(hashes); int prev = hashes[0]; for (int i = 1; i < hashes.size(); i++) { ASSERT_NE(prev, hashes[i]); prev = hashes[i]; } } TEST(Rationals_test, test_doubleRepresentation) { int val = 100000; Real r{val}; Real overflow = r * r; EXPECT_TRUE(overflow > 0); r.negate(); Real res = r * val; EXPECT_TRUE(res < 0); } TEST(Rationals_test, test_negate_int32min) { // INT32_MIN Real r {"-2147483648"}; r.negate(); EXPECT_TRUE(r > 0); } TEST(Rationals_test, test_negate_minus_int32min) { // - INT32_MIN = 2^31 Real r {"2147483648"}; Real neg = -r; EXPECT_TRUE(neg.isWellFormed()); EXPECT_TRUE(neg < 0); r.negate(); EXPECT_TRUE(r.isWellFormed()); } TEST(Rationals_test, test_additionAssign) { Real a {"2147483640"}; Real b {"10"}; additionAssign(a,b); EXPECT_EQ(a, Real{"2147483650"} ); } TEST(Rationals_test, test_overwrite) { Real r(INT32_MAX); Real q(0); r *= 10; r = 0; r = INT32_MAX; r *= 10; r = q; } TEST(Rationals_test, test_uword) { uint32_t x = 2589903246; FastRational f(x); ASSERT_TRUE(f.mpqPartValid()); } TEST(Rationals_test, test_modulo) { FastRational a(-37033300); FastRational b(1); FastRational mod = a % b; ASSERT_EQ(mod, 0); } TEST(Rationals_test, test_creation) { { // a = INT_MIN / INT_MAX is the number that has the smallest nominator and biggest denominator such that it still fits the word representation FastRational a(INT_MIN, INT_MAX); ASSERT_TRUE(a.wordPartValid()); ASSERT_FALSE(a.mpqMemoryAllocated()); ASSERT_EQ(a, FastRational("-2147483648/2147483647")); } { // a = INT_MAX / INT_MAX = 1 but in current implementation handles big values. FastRational a(INT_MAX,INT_MAX); ASSERT_TRUE(a.wordPartValid()); ASSERT_FALSE(a.mpqMemoryAllocated()); ASSERT_EQ(a, 1); } } TEST(Rationals_test, test_addition) { { // b.num == 0 FastRational a(1, 3); FastRational b(0); ASSERT_EQ(a + b, FastRational(1, 3)); ASSERT_EQ(-a + b, FastRational(-1, 3)); } { // a.num == 0 FastRational a(0); FastRational b(1, 3); ASSERT_EQ(a + b, FastRational(1, 3)); ASSERT_EQ(a + (-b), FastRational(-1, 3)); } { // a == -b FastRational a(1,3); FastRational b(-1,3); ASSERT_EQ(a+b, 0); } { // b.den == 1 // result fits in word FastRational a(1,3); FastRational b(1); ASSERT_EQ(a+b, FastRational(4,3)); } { // b.den == 1 // a.num + b.num*a.den does not fit in word (but fits by definition in lword) // (a.num + b.num*a.den) / gcd(a.num+b.num*a.den, a.den) does not fit in word FastRational a(INT_MAX,UINT_MAX); FastRational b(INT_MAX); FastRational sum = a+b; ASSERT_EQ(sum, FastRational("9223372032559808512/4294967295")); ASSERT_FALSE(sum.wordPartValid()); } { // b.den == 1 // a and b negative // a.num + b.num*a.den does not fit in word (but fits by definition in lword) // (a.num + b.num*a.den) / gcd(a.num+b.num*a.den, a.den) does not fit in word FastRational a(INT_MIN,UINT_MAX); FastRational b(INT_MIN); FastRational sum = a+b; ASSERT_EQ(sum, FastRational("-9223372036854775808/4294967295")); ASSERT_FALSE(sum.wordPartValid()); } { // b.den == 1 // a.num + b.num*a.den does not fit in a word (but fits by definition in lword) FastRational a(INT_MAX,8); FastRational b(2); FastRational sum = a+b; ASSERT_EQ(sum, FastRational("2147483663/8")); ASSERT_FALSE(sum.wordPartValid()); } } TEST(Rationals_test, test_multiplicand) { { std::vector rs{FastRational(1, 3), FastRational(1, 5), FastRational(1, 6)}; FastRational mul = get_multiplicand(rs); ASSERT_EQ(mul, 30); } { std::vector rs{FastRational(1, 3), FastRational(1, 5), FastRational(2, 5)}; FastRational mul = get_multiplicand(rs); ASSERT_EQ(mul, 15); } } TEST(Rationals_test, test_subtraction) { { FastRational a(10); FastRational b(0); FastRational c = a-b; ASSERT_EQ(c, a); ASSERT_TRUE(c.wordPartValid()); ASSERT_FALSE(c.mpqPartValid()); } { FastRational a(0); FastRational s = a - FastRational(INT_MIN); ASSERT_FALSE(s.wordPartValid()); ASSERT_TRUE(s.mpqPartValid()); ASSERT_EQ(s, FastRational(INT_MAX)+1); } { FastRational a(INT_MAX,UINT_MAX); FastRational b(INT_MIN); ASSERT_TRUE(a.wordPartValid()); ASSERT_FALSE(a.mpqMemoryAllocated()); ASSERT_TRUE(b.wordPartValid()); ASSERT_FALSE(b.mpqMemoryAllocated()); FastRational c = a - b; FastRational res("9223372036854775807/4294967295"); ASSERT_TRUE(res.mpqPartValid()); ASSERT_EQ(c, res); } { FastRational a(INT_MIN, UINT_MAX); FastRational b(INT_MAX); FastRational c = a - b; } { FastRational a("-2147483645/4294967294"); FastRational b("2147483647/4294967295"); ASSERT_TRUE(a.wordPartValid()); ASSERT_TRUE(b.wordPartValid()); FastRational c = a - b; ASSERT_TRUE(c.mpqPartValid()); FastRational res("-18446744050087231493/18446744060824649730"); ASSERT_EQ(c, res); } { FastRational a("-2147483647/4294967292"); FastRational b("2147483645/4294967294"); ASSERT_TRUE(a.wordPartValid()); ASSERT_TRUE(b.wordPartValid()); FastRational c = a - b; ASSERT_TRUE(c.mpqPartValid()); } } TEST(Rationals_test, test_division) { { FastRational a(-1); FastRational b(-1); a /= b; ASSERT_EQ(a, 1); } { FastRational a(-3); FastRational b(2); a /= b; ASSERT_EQ(a, FastRational(-3, 2)); ASSERT_TRUE(a.wordPartValid()); ASSERT_FALSE(a.mpqMemoryAllocated()); } } TEST(Rationals_test, test_operatorAssign) { { FastRational f(0); f -= FastRational(-3) * FastRational(-1); ASSERT_EQ(f, -3); ASSERT_TRUE(f.wordPartValid()); ASSERT_FALSE(f.mpqMemoryAllocated()); } { FastRational f(0); f += FastRational(-3) * FastRational(-1); ASSERT_EQ(f, 3); ASSERT_TRUE(f.wordPartValid()); ASSERT_FALSE(f.mpqMemoryAllocated()); } { // (/ 1333332 329664997) += (- 332667998001/329664997000) FastRational f(1333332, 329664997); f += -FastRational("332667998001/329664997000"); // 331334666001/329664997000 ASSERT_EQ(f, -FastRational("331334666001/329664997000")); ASSERT_TRUE(f.mpqMemoryAllocated()); ASSERT_FALSE(f.wordPartValid()); } { FastRational f(-1); f += FastRational("-1/2") * FastRational(-1); ASSERT_EQ(f, FastRational("-1/2")); ASSERT_TRUE(f.wordPartValid()); ASSERT_FALSE(f.mpqMemoryAllocated()); } { FastRational res = FastRational(1) - FastRational(0); ASSERT_EQ(res, 1); ASSERT_TRUE(res.wordPartValid()); ASSERT_FALSE(res.mpqMemoryAllocated()); // 1 - (/ (- 335) 666) = (/ (- 1001) 666) res = FastRational(1) - FastRational("-335/666"); ASSERT_EQ(res, FastRational("1001/666")); ASSERT_TRUE(res.wordPartValid()); ASSERT_FALSE(res.mpqMemoryAllocated()); } { FastRational a(-1,12); FastRational b(-1); a += b; ASSERT_EQ(a, FastRational(-13,12)); ASSERT_TRUE(a.wordPartValid()); ASSERT_FALSE(a.mpqMemoryAllocated()); ASSERT_TRUE(b.wordPartValid()); ASSERT_FALSE(b.mpqMemoryAllocated()); } } TEST(Rationals_test, test_CHECK_WORD) { word a(INT_MAX); uword b(UINT_MAX); uword res = 0; CHECK_WORD(res, lword(a)*b); ASSERT_EQ(res, (lword)(9223372030412324865)); overflow: std::cout << "Overflow" << std::endl; } TEST(Rationals_test, test_sub_lword_underflow_min) { lword res; (void)res; lword s1 = 0; lword s2 = LWORD_MIN; CHECK_SUB_OVERFLOWS_LWORD(res, s1, s2); ASSERT_TRUE(false); overflow: ASSERT_TRUE(true); } TEST(Rationals_test, test_sub_lword_nounderflow) { lword res; (void)res; lword s1 = 0; lword s2 = LWORD_MIN+1; CHECK_SUB_OVERFLOWS_LWORD(res, s1, s2); return; overflow: ASSERT_TRUE(false); } TEST(Rationals_test, test_sub_lword_nooverflow) { lword res; (void)res; lword s1 = -1; lword s2 = LWORD_MAX; CHECK_SUB_OVERFLOWS_LWORD(res, s1, s2); return; overflow: ASSERT_TRUE(false); } TEST(Rationals_test, test_sub_lword_overflow) { lword res; (void)res; lword s1 = -2; lword s2 = LWORD_MAX; CHECK_SUB_OVERFLOWS_LWORD(res, s1, s2); ASSERT_FALSE(true); overflow: ASSERT_TRUE(true); } TEST(Rationals_test, test_ceil) { word a(INT_MIN); uword b(3); FastRational f(a, b); f.ceil(); } TEST(Rationals_test, test_mod) { FastRational a(INT_MAX); FastRational b(INT_MIN); FastRational res = a % b; ASSERT_EQ(res, (INT_MIN+1)); } TEST(Rationals_test, test_addNegated) { { FastRational a(15); FastRational b(-15); FastRational res = a+b; ASSERT_EQ(res, 0); } { FastRational a(INT_MAX); FastRational b(INT_MIN); FastRational res = a + b; ASSERT_EQ(res, -1); } } TEST(Rationals_test, testWordRepresentation_Negate) { FastRational a(INT_MIN); // a fits into word representation ASSERT_TRUE(a.wordPartValid()); a.negate(); // a now does not fit into word representation ASSERT_FALSE(a.wordPartValid()); a.negate(); // a now again fits into word representation ASSERT_TRUE(a.wordPartValid()); } TEST(Rationals_test, testWordRepresentation_Inverse) { uword val = INT_MAX; ++val; FastRational a(1, val); // a fits into word representation ASSERT_TRUE(a.wordPartValid()); a = a.inverse(); // a now does not fit into word representation ASSERT_FALSE(a.wordPartValid()); a = a.inverse(); // a now again fits into word representation ASSERT_TRUE(a.wordPartValid()); } opensmt-2.5.2/test/unit/test_ResolutionProofInterpolation.cc000066400000000000000000000140121445011647600244400ustar00rootroot00000000000000/* * Copyright (c) 2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #include #include "Logic.h" #include "MainSolver.h" #include "VerificationUtils.h" #include "FarkasInterpolator.h" class ResolutionProofInterpolationTest : public ::testing::Test { protected: ResolutionProofInterpolationTest(): logic{opensmt::Logic_t::QF_UF} {} virtual void SetUp() { const char* msg; config.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); solver = std::make_unique(logic, config, "test"); a = logic.mkBoolVar("a"); b = logic.mkBoolVar("c"); c = logic.mkBoolVar("b"); na = logic.mkNot(a); nb = logic.mkNot(b); nc = logic.mkNot(c); A_part = logic.mkAnd(logic.mkOr(a, nb), logic.mkOr(a, b)); B_part = logic.mkAnd(logic.mkOr(na, nc), logic.mkOr(na, c)); solver->insertFormula(A_part); solver->insertFormula(B_part); auto res = solver->check(); ASSERT_EQ(res, s_False); } Logic logic; SMTConfig config; std::unique_ptr solver; PTRef a, b, c, na, nb, nc; PTRef A_part, B_part; bool verifyInterpolant(PTRef A, PTRef B, PTRef itp) { return VerificationUtils(logic).verifyInterpolantInternal(A, B, itp); } }; TEST_F(ResolutionProofInterpolationTest, test_McMillanInterpolant) { config.setBooleanInterpolationAlgorithm(itp_alg_mcmillan); auto itpContext = solver->getInterpolationContext(); vec itps; ipartitions_t A_mask = 1; itpContext->getSingleInterpolant(itps, A_mask); PTRef itp = itps.last(); // std::cout << logic.pp(itp); ASSERT_TRUE(verifyInterpolant(A_part, B_part, itp)); } TEST_F(ResolutionProofInterpolationTest, test_PudlakInterpolant) { config.setBooleanInterpolationAlgorithm(itp_alg_pudlak); auto itpContext = solver->getInterpolationContext(); vec itps; ipartitions_t A_mask = 1; itpContext->getSingleInterpolant(itps, A_mask); PTRef itp = itps.last(); // std::cout << logic.pp(itp); ASSERT_TRUE(verifyInterpolant(A_part, B_part, itp)); } TEST_F(ResolutionProofInterpolationTest, test_McMillanPrimeInterpolant) { config.setBooleanInterpolationAlgorithm(itp_alg_mcmillanp); auto itpContext = solver->getInterpolationContext(); vec itps; ipartitions_t A_mask = 1; itpContext->getSingleInterpolant(itps, A_mask); PTRef itp = itps.last(); // std::cout << logic.pp(itp); ASSERT_TRUE(verifyInterpolant(A_part, B_part, itp)); } class ResolutionProofInterpolationTestWithReduction : public ::testing::Test { protected: ResolutionProofInterpolationTestWithReduction(): logic{opensmt::Logic_t::QF_UF} {} virtual void SetUp() { const char* msg; config.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); // config.setOption(SMTConfig::o_verbosity, SMTOption(2), msg); solver = std::make_unique(logic, config, "test"); a = logic.mkBoolVar("a"); b = logic.mkBoolVar("b"); c = logic.mkBoolVar("c"); d = logic.mkBoolVar("d"); e = logic.mkBoolVar("e"); na = logic.mkNot(a); nb = logic.mkNot(b); nc = logic.mkNot(c); nd = logic.mkNot(d); ne = logic.mkNot(e); A_part = logic.mkAnd({logic.mkOr(a, b), logic.mkOr(na,c)}); B_part = logic.mkAnd({logic.mkOr(a, e), nd, logic.mkOr(d, ne), logic.mkOr(d, nc), logic.mkOr({na, nb, d})}); solver->insertFormula(A_part); solver->insertFormula(B_part); auto res = solver->check(); ASSERT_EQ(res, s_False); } Logic logic; SMTConfig config; std::unique_ptr solver; PTRef a, b, c, d, e, na, nb, nc, nd, ne; PTRef A_part, B_part; bool verifyInterpolant(PTRef A, PTRef B, PTRef itp) { return VerificationUtils(logic).verifyInterpolantInternal(A, B, itp); } }; TEST_F(ResolutionProofInterpolationTestWithReduction, test_InterpolationAfterReduction) { config.setBooleanInterpolationAlgorithm(itp_alg_mcmillan); config.setReduction(1); auto itpContext = solver->getInterpolationContext(); vec itps; ipartitions_t A_mask = 1; itpContext->getSingleInterpolant(itps, A_mask); PTRef itp = itps.last(); std::cout << logic.pp(itp); ASSERT_TRUE(verifyInterpolant(A_part, B_part, itp)); } /*************** TESTS FOR INTERPOLATION FOR INCREMENTAL SOLVING *****************/ class ResolutionProofIncrementalInterpolationTest : public ::testing::Test { protected: ResolutionProofIncrementalInterpolationTest(): logic{opensmt::Logic_t::QF_UF} {} virtual void SetUp() { const char* msg; config.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); solver = std::make_unique(logic, config, "test"); a = logic.mkBoolVar("a"); b = logic.mkBoolVar("c"); c = logic.mkBoolVar("b"); na = logic.mkNot(a); nb = logic.mkNot(b); nc = logic.mkNot(c); A_part = logic.mkAnd(logic.mkOr(a, nb), logic.mkOr(a, b)); B_part = logic.mkAnd(logic.mkOr(na, nc), logic.mkOr(na, c)); solver->push(); solver->insertFormula(A_part); solver->push(); solver->insertFormula(B_part); auto res = solver->check(); ASSERT_EQ(res, s_False); } Logic logic; SMTConfig config; std::unique_ptr solver; PTRef a, b, c, na, nb, nc; PTRef A_part, B_part; bool verifyInterpolant(PTRef A, PTRef B, PTRef itp) { return VerificationUtils(logic).verifyInterpolantInternal(A, B, itp); } }; TEST_F(ResolutionProofIncrementalInterpolationTest, test_McMillanInterpolant) { config.setBooleanInterpolationAlgorithm(itp_alg_mcmillan); auto itpContext = solver->getInterpolationContext(); vec itps; ipartitions_t A_mask = 1; itpContext->getSingleInterpolant(itps, A_mask); PTRef itp = itps.last(); // std::cout << logic.pp(itp); ASSERT_TRUE(verifyInterpolant(A_part, B_part, itp)); }opensmt-2.5.2/test/unit/test_Rewriting.cc000066400000000000000000000112431445011647600204740ustar00rootroot00000000000000// // Created by Martin Blicha on 17.05.20. // #include #include #include #include #include #include #include #include #include TEST(Rewriting_test, test_RewriteClassicConjunction) { Logic logic{opensmt::Logic_t::QF_UF}; PTRef a = logic.mkBoolVar("a"); PTRef b = logic.mkBoolVar("b"); PTRef c = logic.mkBoolVar("c"); PTRef d = logic.mkBoolVar("d"); PTRef conj = logic.mkAnd(logic.mkAnd(a,b), logic.mkAnd(c,d)); PTRef res = ::rewriteMaxArityClassic(logic, conj); vec args {a,b,c,d}; ASSERT_EQ(res, logic.mkAnd(args)); } TEST(Rewriting_test, test_RewriteClassicWithSimplification) { Logic logic{opensmt::Logic_t::QF_UF}; PTRef a = logic.mkBoolVar("a"); PTRef b = logic.mkBoolVar("b"); PTRef c = logic.mkBoolVar("c"); PTRef d = logic.mkBoolVar("d"); PTRef l3 = logic.mkAnd(a, logic.mkAnd(b, logic.mkNot(a))); PTRef l2 = logic.mkOr(l3, logic.mkAnd(c,d)); PTRef l1 = logic.mkAnd(b, l2); // l1 is (and b (or (and c d) (and a (and b (not a))))) // which is equivalent to (and b c d) PTRef res = ::rewriteMaxArityClassic(logic, l1); // std::cout << logic.printTerm(res) << std::endl; vec args {b,c,d}; ASSERT_EQ(res, logic.mkAnd(args)); } TEST(Rewriting_test, test_RewriteClassicUnderNegation) { Logic logic{opensmt::Logic_t::QF_UF}; PTRef a = logic.mkBoolVar("a"); PTRef b = logic.mkBoolVar("b"); PTRef c = logic.mkBoolVar("c"); PTRef positive = logic.mkAnd(a, logic.mkAnd(b,c)); PTRef negative = logic.mkNot(positive); // (not (and a (and b c))) // is equivalent to (not (and a b c)) PTRef res = ::rewriteMaxArityClassic(logic, negative); // std::cout << logic.printTerm(res) << std::endl; ASSERT_EQ(res, logic.mkNot(logic.mkAnd({a,b,c}))); } TEST(Rewriting_test, test_RewriteEquality) { ArithLogic logic{opensmt::Logic_t::QF_LRA}; PTRef x = logic.mkRealVar("x"); PTRef y = logic.mkRealVar("y"); PTRef eq = logic.mkEq(x,y); ArithmeticEqualityRewriter rewriter(logic); PTRef res = rewriter.rewrite(eq); ASSERT_EQ(res, logic.mkAnd(logic.mkGeq(x,y), logic.mkLeq(x,y))); ASSERT_EQ(res, rewriter.rewrite(res)); } TEST(Rewriting_test, test_RewriteDivMod) { ArithLogic logic{opensmt::Logic_t::QF_LIA}; PTRef x = logic.mkIntVar("x"); PTRef two = logic.mkIntConst(2); PTRef div = logic.mkIntDiv(x,two); PTRef mod = logic.mkMod(x,two); PTRef fla = logic.mkAnd(logic.mkEq(div, two), logic.mkEq(mod, logic.getTerm_IntZero())); PTRef rewritten = DivModRewriter(logic).rewrite(fla); // std::cout << logic.printTerm(rewritten) << std::endl; SMTConfig config; MainSolver solver(logic, config, "test"); solver.insertFormula(rewritten); auto res = solver.check(); ASSERT_EQ(res, s_True); auto model = solver.getModel(); ASSERT_EQ(model->evaluate(x), logic.mkIntConst(4)); } class RewriteDistinctTest : public ::testing::Test { protected: RewriteDistinctTest() : logic{opensmt::Logic_t::QF_UF} {} virtual void SetUp() { ufsort = logic.declareUninterpretedSort("U"); x = logic.mkVar(ufsort, "x"); y = logic.mkVar(ufsort, "y"); z = logic.mkVar(ufsort, "z"); b = logic.mkBoolVar("b"); } Logic logic; SRef ufsort; PTRef x, y, z; PTRef b; }; TEST_F(RewriteDistinctTest, test_RewriteDistinct_TopLevel) { PTRef dist = logic.mkDistinct({x, y, z}); PTRef fla = logic.mkAnd(b, dist); // dist is top-level distinct EXPECT_NE(::rewriteDistincts(logic, fla), fla); // fla should be rewritten EXPECT_EQ(::rewriteDistinctsKeepTopLevel(logic, fla), fla); // fla should be kept the same } TEST_F(RewriteDistinctTest, test_RewriteDistinct_Negated) { PTRef dist = logic.mkDistinct({x, y, z}); PTRef fla = logic.mkNot(dist); // dist is not top-level distinct PTRef rewritten1 = ::rewriteDistincts(logic, fla); EXPECT_NE(rewritten1, fla); // fla should be rewritten PTRef rewritten2 = ::rewriteDistinctsKeepTopLevel(logic, fla); EXPECT_NE(rewritten2, fla); // fla should be rewritten EXPECT_EQ(rewritten1, rewritten2); ASSERT_TRUE(logic.isNot(rewritten1)); PTRef conj = logic.getPterm(rewritten1)[0]; ASSERT_TRUE(logic.isAnd(conj)); vec disequalities { logic.mkNot(logic.mkEq(x,y)), logic.mkNot(logic.mkEq(z,x)), logic.mkNot(logic.mkEq(z,y)) }; Pterm const & conjTerm = logic.getPterm(conj); for (PTRef arg : conjTerm) { EXPECT_TRUE(std::find(disequalities.begin(), disequalities.end(), arg) != disequalities.end()); } } opensmt-2.5.2/test/unit/test_SATSolverTypes.cc000066400000000000000000000010231445011647600213640ustar00rootroot00000000000000/* * Copyright (c) 2022, Antti Hyvarinen * * SPDX-License-Identifier: MIT */ #include #include "SolverTypes.h" #include class SATSolverTypesTest : public ::testing::Test { protected: ClauseAllocator ca; }; TEST_F(SATSolverTypesTest, test_ClauseIterator) { vec v(100); for (int i = 0; i < 100; i++) { v[i] = mkLit(i, i % 2); } CRef c = ca.alloc(v); int i = 0; for (Lit l : ca[c]) { ASSERT_EQ(l, v[i]); i++; } }opensmt-2.5.2/test/unit/test_Simplex.cc000066400000000000000000000135051445011647600201460ustar00rootroot00000000000000// // Created by prova on 08.10.19. // #include #include #include #include #include TEST(Simplex_test, test_ops_in_Simplex) { SMTConfig c; LAVarStore vs; LVRef x = vs.getNewVar(); LVRef y = vs.getNewVar(); LVRef y_minus_x = vs.getNewVar(); auto p_y_minus_x = std::make_unique>(); p_y_minus_x->addTerm(x, -1); p_y_minus_x->addTerm(y, 1); LABoundStore bs(vs); Delta zero = Delta(0); Delta one = Delta(1); LABoundStore::BoundInfo x_strict_0 = bs.allocBoundPair(x, { Delta(0, -1), zero }); // x < 0 and x >= 0 LABoundStore::BoundInfo y_strict_0 = bs.allocBoundPair(y, { Delta(0, -1), zero }); // y < 0 and y >= 0 // LABoundStore::BoundInfo x_nostrict_0 = bs.allocBoundPair(x, 0, false); // x <= 0 and x > 0 // LABoundStore::BoundInfo y_nostrict_0 = bs.allocBoundPair(y, 0, false); // y <= 0 and y > 0 LABoundStore::BoundInfo x_strict_1 = bs.allocBoundPair(x, { Delta(1, -1), one }); // x < 1 and x >= 1 LABoundStore::BoundInfo x_nostrict_1 = bs.allocBoundPair(x, { one, Delta(1, 1) }); // x <= 1 and x > 1 LABoundStore::BoundInfo y_strict_1 = bs.allocBoundPair(y, { Delta(1, -1), one }); // y < 1 and y >= 1 LABoundStore::BoundInfo y_nostrict_1 = bs.allocBoundPair(y, { one, Delta(1, 1) }); // y <= 1 and y > 1 LABoundStore::BoundInfo y_minus_x_nostrict_0 = bs.allocBoundPair(y_minus_x, { zero, Delta(0, 1) }); // y - x <= 0 and y - x > 0 LABoundStore::BoundInfo y_minus_x_nostrict_1 = bs.allocBoundPair(y_minus_x, { one, Delta(1, 1) }); // y - x - 1 <= 0 //LABoundStore::BoundInfo y_minus_x_strict_0 = bs.allocBoundPair(y_minus_x, 0, true); // y - x < 0 and y - x >= 0 //LABoundStore::BoundInfo y_minus_x_strict_m1 = bs.allocBoundPair(y_minus_x, -1, true); // y - x + 1 < 0 //LABoundStore::BoundInfo y_minus_x_nostrict_m1 = bs.allocBoundPair(y_minus_x, -1, false); // y - x + 1 <= 0 //LABoundStore::BoundInfo y_minus_x_strict_1 = bs.allocBoundPair(y_minus_x, 1, true); // y - x - 1 < 0 bs.buildBounds(); Simplex s(bs); s.newNonbasicVar(x); s.newNonbasicVar(y); s.newRow(y_minus_x, std::move(p_y_minus_x)); s.initModel(); Simplex::Explanation ex = s.checkSimplex(); ASSERT_EQ(ex.size(), 0); Real d = s.computeDelta(); Delta x_val = s.getValuation(x); std::cout << x_val.R() + x_val.D() * d << '\n'; Delta y_val = s.getValuation(y); std::cout << y_val.R() + y_val.D() * d << '\n'; Delta sum = s.getValuation(y_minus_x); std::cout << sum.R() + sum.D() * d << '\n'; s.assertBoundOnVar(x, x_strict_0.lb); s.assertBoundOnVar(y, y_strict_0.lb); s.pushBacktrackPoint(); s.assertBoundOnVar(x, x_strict_1.ub); s.assertBoundOnVar(y, y_strict_1.ub); ex = s.checkSimplex(); ASSERT_EQ(ex.size(), 0); d = s.computeDelta(); x_val = s.getValuation(x); std::cout << x_val.R() + x_val.D() * d << '\n'; y_val = s.getValuation(y); std::cout << y_val.R() + y_val.D() * d << '\n'; sum = s.getValuation(y_minus_x); std::cout << sum.R() + sum.D() * d << '\n'; ex = s.assertBoundOnVar(y_minus_x, y_minus_x_nostrict_1.lb); ASSERT_EQ(ex.size(), 0); // not detectable at this point ex = s.checkSimplex(); ASSERT_EQ(ex.size(), 3); s.popBacktrackPoint(); s.finalizeBacktracking(); ex = s.assertBoundOnVar(y_minus_x, y_minus_x_nostrict_0.lb); s.assertBoundOnVar(x, x_nostrict_1.lb); s.assertBoundOnVar(y, y_nostrict_1.lb); ex = s.checkSimplex(); ASSERT_EQ(ex.size(), 0); d = s.computeDelta(); x_val = s.getValuation(x); std::cout << "x = " << x_val.R() + x_val.D() * d << '\n'; y_val = s.getValuation(y); std::cout << "y = " << y_val.R() + y_val.D() * d << '\n'; sum = s.getValuation(y_minus_x); std::cout << "y - x = " << sum.R() + sum.D() * d << std::endl; } TEST(Simplex_test, test_Assignment) { SMTConfig c; LAVarStore vs; LVRef x = vs.getNewVar(); LVRef y = vs.getNewVar(); LVRef y_minus_x = vs.getNewVar(); LABoundStore bs(vs); LABoundStore::BoundInfo x_nostrict_1 = bs.allocBoundPair(x, { Delta(1), Delta(1,1) }); // x <= 1 and x > 1 LABoundStore::BoundInfo y_strict_0 = bs.allocBoundPair(y, { Delta(0, -1), Delta(0) }); // y < 0 and y >= 0 LABoundStore::BoundInfo x_strict_m5 = bs.allocBoundPair(x, { Delta(-5, -1), Delta(-5) }); // x < -5 and x >= -5 LABoundStore::BoundInfo y_minus_x_strict_0 = bs.allocBoundPair(y_minus_x, { Delta(0, -1), Delta(0) }); // y - x < 0 and y - x >= 0 LABoundStore::BoundInfo y_minus_x_nostrict_0 = bs.allocBoundPair(y_minus_x, { Delta(0), Delta(0,1) }); // y - x <= 0 and y - x > 0 bs.buildBounds(); Simplex s(bs); s.newNonbasicVar(x); s.newNonbasicVar(y); auto p_y_plus_x = std::make_unique>(); p_y_plus_x->addTerm(x, 1); p_y_plus_x->addTerm(y, 1); s.newRow(y_minus_x, std::move(p_y_plus_x)); s.initModel(); s.assertBoundOnVar(x_nostrict_1.v, x_nostrict_1.ub); s.assertBoundOnVar(x_strict_m5.v, x_strict_m5.lb); s.assertBoundOnVar(y_strict_0.v, y_strict_0.ub); s.assertBoundOnVar(y_minus_x_strict_0.v, y_minus_x_strict_0.lb); s.assertBoundOnVar(y_minus_x_nostrict_0.v, y_minus_x_nostrict_0.ub); Simplex::Explanation ex = s.checkSimplex(); ASSERT_EQ(ex.size(), 0); ASSERT_LT(s.getValuation(y), (Delta{0,0})); ASSERT_LE(s.getValuation(x), (Delta{1,0})); ASSERT_GE(s.getValuation(x), (Delta{-5,0})); ASSERT_EQ(s.getValuation(x), -1 * s.getValuation(y)); Real d = s.computeDelta(); Real x_val = s.getValuation(x).R() + s.getValuation(x).D() * d; Real y_val = s.getValuation(y).R() + s.getValuation(y).D() * d; EXPECT_LT(y_val, 0); EXPECT_LE(x_val, 1); EXPECT_GE(x_val, -5); EXPECT_EQ(x_val, -1 * y_val); } opensmt-2.5.2/test/unit/test_Sorts.cc000066400000000000000000000052131445011647600176340ustar00rootroot00000000000000/* * Copyright (c) 2021, Antti Hyvarinen * * SPDX-License-Identifier: MIT */ #include #include #include class SortTest : public ::testing::Test { protected: SortTest(): logic{opensmt::Logic_t::QF_UF} {} Logic logic; }; TEST_F(SortTest, test_indexedSort) { SRef fooSort = logic.getSort(logic.declareSortSymbol({"Foo", 0}), {}); SRef barSort = logic.getSort(logic.declareSortSymbol({"Bar", 0}), {}); SRef indexedSort = logic.getSort(logic.getSortSymIndexed(), {fooSort, barSort}); ASSERT_NE(indexedSort, SRef_Undef); std::cout << logic.printSort(indexedSort) << std::endl; PTRef foo = logic.mkConst(fooSort, "foo"); PTRef bar = logic.mkConst(barSort, "bar"); std::cout << logic.pp(foo) << std::endl; std::cout << logic.pp(bar) << std::endl; SRef indexedSort2 = logic.getSort(logic.getSortSymIndexed(), {barSort, fooSort}); ASSERT_NE(indexedSort2, indexedSort); std::cout << logic.printSort(indexedSort2) << std::endl; SRef quuxSort = logic.getSort(logic.declareSortSymbol({"Quux", 0}), {}); SRef frobbozSort = logic.getSort(logic.declareSortSymbol({"Frobboz", 0}), {}); SRef indexedSort3 = logic.getSort(logic.getSortSymIndexed(), {quuxSort, frobbozSort}); ASSERT_NE(indexedSort, indexedSort3); std::cout << logic.printSort(indexedSort3) << std::endl; } TEST_F(SortTest, test_parametricSort) { SortSymbol symbolU("U", 1); logic.declareSortSymbol(std::move(symbolU)); SortSymbol symbolV("V", 0); logic.declareSortSymbol(std::move(symbolV)); SortSymbol symbolW("W", 0); logic.declareSortSymbol(std::move(symbolW)); SortSymbol symbolV2("V", 0); SSymRef symbolRefV; bool rval = logic.peekSortSymbol(symbolV2, symbolRefV); ASSERT_TRUE(rval); SRef sortV = logic.getSort(symbolRefV, {}); ASSERT_NE(sortV, SRef_Undef); SortSymbol symbolW2("W", 0); SSymRef symbolRefW; rval = logic.peekSortSymbol(symbolW2, symbolRefW); ASSERT_TRUE(rval); SRef sortW = logic.getSort(symbolRefW, {}); ASSERT_NE(sortW, SRef_Undef); SortSymbol symbolU2("U", 1); SSymRef symbolRefU; rval = logic.peekSortSymbol(symbolU2, symbolRefU); ASSERT_TRUE(rval); SRef sortU_V = logic.getSort(symbolRefU, {sortV}); std::cout << logic.printSort(sortU_V) << std::endl; SRef sortU_W = logic.getSort(symbolRefU, {sortW}); std::cout << logic.printSort(sortU_V) << std::endl; std::cout << logic.printSort(sortU_W) << std::endl; ASSERT_NE(sortU_V, SRef_Undef); ASSERT_NE(sortU_W, SRef_Undef); logic.declareFun("a", sortU_V, {}); logic.declareFun("b", sortU_W, {}); } opensmt-2.5.2/test/unit/test_Splitting.cc000066400000000000000000000011241445011647600204740ustar00rootroot00000000000000// // Created by Antti on 30.09.21. // #include #include class SplitTest : public ::testing::Test { protected: SplitTest() : logic{opensmt::Logic_t::QF_UF} {} Logic logic; }; TEST_F(SplitTest, test_TermPrinting) { SRef U = logic.declareUninterpretedSort("U"); SymRef sr = logic.declareFun("f", U, {U, U}); PTRef a = logic.mkVar(U, "a"); PTRef f_a = logic.mkUninterpFun(sr, {a, a}); std::string str = logic.printTerm(f_a); std::string reference = "(f a a)"; std::cout << str << std::endl; ASSERT_EQ(str.compare(reference), 0); }opensmt-2.5.2/test/unit/test_SubstitutionBreaker.cpp000066400000000000000000000117371445011647600227370ustar00rootroot00000000000000// // Created by prova on 21.11.19. // #include #include #include #include typedef Map::Pair spair; class SubstitutionBreaker : public ::testing::Test { public: Logic logic; SubstitutionBreaker() : logic{opensmt::Logic_t::QF_UF} {} }; TEST_F(SubstitutionBreaker, test_getVars) { SRef U = logic.declareUninterpretedSort("U"); PTRef a = logic.mkVar(U, "a"); PTRef b = logic.mkVar(U, "b"); PTRef c = logic.mkVar(U, "c"); SymRef fun = logic.declareFun("f", U, {U, U, U}); PTRef f = logic.mkUninterpFun(fun, {a, b, a}); PTRef f1 = logic.mkUninterpFun(fun, {f, c, f}); TargetVarListAllocator tvl(1024); SubstNodeAllocator sna(tvl, logic, 1024); SNRef snr = sna.alloc(a, f1); for (int i = 0; i < sna[snr].nChildren(); i++) { std::cerr << logic.pp(sna[snr].getChildTerm(i)) << " \n"; } ASSERT_EQ(sna[snr].nChildren(), 3); } TEST_F(SubstitutionBreaker, test_Simple) { PTRef a = logic.mkVar(logic.getSort_bool(), "a"); MapWithKeys substs; substs.insert(a, {logic.getTerm_true(), l_True}); SubstLoopBreaker slb(logic); Logic::SubstMap subst_map = slb(std::move(substs)); ASSERT_TRUE(subst_map.has(a)); } TEST_F(SubstitutionBreaker, test_getLoops) { SRef U = logic.declareUninterpretedSort("U"); PTRef a = logic.mkVar(U, "a"); PTRef b = logic.mkVar(U, "b"); PTRef c = logic.mkVar(U, "c"); PTRef d = logic.mkVar(U, "d"); PTRef e = logic.mkVar(U, "e"); SymRef fun = logic.declareFun("f", U, {U}); PTRef f = logic.mkUninterpFun(fun, {a}); MapWithKeys substs; substs.insert(a, {f, l_True}); substs.insert(b, {a, l_True}); substs.insert(c, {b, l_True}); substs.insert(d, {e, l_True}); SubstLoopBreaker slb(logic); vec startNodes = slb.constructSubstitutionGraph(std::move(substs)); std::cerr << slb.printGraphAndLoops(startNodes, {}) << std::endl; ASSERT_GT(startNodes.size(), 0); auto loops = slb.findLoops(startNodes); ASSERT_EQ(loops.size(), 0); // The system does not remove self-loops std::cerr << slb.printGraphAndLoops(startNodes, loops) << std::endl; } TEST_F(SubstitutionBreaker, test_getLoops2) { SRef U = logic.declareUninterpretedSort("U"); PTRef a1 = logic.mkVar(U, "a1"); PTRef b1 = logic.mkVar(U, "b1"); PTRef c1 = logic.mkVar(U, "c1"); PTRef a2 = logic.mkVar(U, "a2"); PTRef b2 = logic.mkVar(U, "b2"); PTRef c2 = logic.mkVar(U, "c2"); PTRef start = logic.mkVar(U, "start"); SymRef symb_f = logic.declareFun("f", U, {U}); SymRef symb_g = logic.declareFun("g", U, {U}); SymRef symb_h = logic.declareFun("g", U, {U, U}); SymRef symb_h2 = logic.declareFun("g", U, {U, U, U}); PTRef f_b1 = logic.mkUninterpFun(symb_f, {b1}); PTRef h_c1_c2 = logic.mkUninterpFun(symb_h, {c1, c2}); PTRef f_a1 = logic.mkUninterpFun(symb_f, {a1}); PTRef g_b2 = logic.mkUninterpFun(symb_g, {b2}); PTRef g_c2 = logic.mkUninterpFun(symb_g, {c2}); PTRef h2_a1_b1_a2 = logic.mkUninterpFun(symb_h2, {a1, b1, a2}); PTRef h_b1_a2 = logic.mkUninterpFun(symb_h, {b1, a2}); MapWithKeys substs; substs.insert(a1, {f_b1, l_True}); substs.insert(b1, {h_c1_c2, l_True}); substs.insert(c1, {f_a1, l_True}); substs.insert(a2, {g_b2, l_True}); substs.insert(b2, {g_c2, l_True}); substs.insert(c2, {h2_a1_b1_a2, l_True}); substs.insert(start, {h_b1_a2, l_True}); SubstLoopBreaker slb(logic); vec startNodes = slb.constructSubstitutionGraph(std::move(substs)); ASSERT_GT(startNodes.size(), 0); auto loops = slb.findLoops(startNodes); ASSERT_EQ(loops.size(), 1); } TEST_F(SubstitutionBreaker, test_getLoops3) { SRef U = logic.declareUninterpretedSort("U"); PTRef e0 = logic.mkVar(U, "e0"); PTRef e1 = logic.mkVar(U, "e1"); PTRef e2 = logic.mkVar(U, "e2"); PTRef e4 = logic.mkVar(U, "e4"); SymRef symb_op = logic.declareFun("op", U, {U, U}); PTRef op_e2_e1 = logic.mkUninterpFun(symb_op, {e2, e1}); PTRef op_e2_e2 = logic.mkUninterpFun(symb_op, {e2, e2}); PTRef op_e0_e0 = logic.mkUninterpFun(symb_op, {e0, e0}); PTRef op_e4_e1 = logic.mkUninterpFun(symb_op, {e4, e1}); MapWithKeys substs; substs.insert(e0, {op_e2_e1, l_True}); substs.insert(e4, {op_e2_e2, l_True}); substs.insert(e1, {op_e0_e0, l_True}); substs.insert(e2, {op_e4_e1, l_True}); SubstLoopBreaker slb(logic); auto new_substs = slb(std::move(substs)); SubstLoopBreaker slb2(logic); MapWithKeys new_substs2; for (auto key : new_substs.getKeys()) { new_substs2.insert(key, {new_substs[key], l_True}); } vec startNodes = slb2.constructSubstitutionGraph(std::move(new_substs2)); std::cerr << slb2.printGraphAndLoops(startNodes, {}) << std::endl; auto loops = slb2.findLoops(startNodes); ASSERT_EQ(loops.size(), 0); } opensmt-2.5.2/test/unit/test_Substitutions.cc000066400000000000000000000115551445011647600214270ustar00rootroot00000000000000/* * Copyright (c) 2020-2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #include #include class LIASubstitutionsRegression: public ::testing::Test { public: std::unique_ptr getLIAOsmt() { return std::make_unique(opensmt_logic::qf_lia, "test"); } }; class UFLRASubstitutionsRegression: public ::testing::Test { protected: ArithLogic logic; SymRef f; PTRef a,b,c,x,y,z; PTRef fa,fb,fc,fx,fy,fz; public: UFLRASubstitutionsRegression() : logic(opensmt::Logic_t::QF_UFLRA) { f = logic.declareFun("f", logic.getSort_real(), {logic.getSort_real()}); x = logic.mkRealVar("x"); y = logic.mkRealVar("y"); z = logic.mkRealVar("z"); a = logic.mkRealVar("a"); b = logic.mkRealVar("b"); c = logic.mkRealVar("c"); fx = logic.mkUninterpFun(f,{x}); fy = logic.mkUninterpFun(f,{y}); fz = logic.mkUninterpFun(f,{z}); fa = logic.mkUninterpFun(f,{a}); fb = logic.mkUninterpFun(f,{b}); fc = logic.mkUninterpFun(f,{c}); } }; TEST_F(LIASubstitutionsRegression, test_LIAsubstitution) { auto const osmt = getLIAOsmt(); auto & mainSolver = osmt->getMainSolver(); auto & lialogic = osmt->getLIALogic(); PTRef x = lialogic.mkIntVar("x"); PTRef y = lialogic.mkIntVar("y"); PTRef two = lialogic.mkIntConst(2); PTRef eq = lialogic.mkEq(x, lialogic.mkTimes(two, y)); PTRef a = lialogic.mkBoolVar("a"); PTRef conj = lialogic.mkAnd( lialogic.mkImpl(a, lialogic.mkEq(x, lialogic.getTerm_IntOne())), lialogic.mkImpl(lialogic.mkNot(a), lialogic.mkEq(x, lialogic.getTerm_IntOne())) ); PTRef fla = lialogic.mkAnd(conj, eq); // x = 2y AND (a => x=1) AND (~a => x=1) char* msg; mainSolver.insertFormula(fla, &msg); auto res = mainSolver.check(); ASSERT_EQ(res, s_False); } TEST_F(LIASubstitutionsRegression, test_InconsistentSubstitutions) { auto const osmt = getLIAOsmt(); auto & lialogic = osmt->getLIALogic(); PTRef x = lialogic.mkIntVar("x"); PTRef y = lialogic.mkIntVar("y"); PTRef one = lialogic.getTerm_IntOne(); PTRef eq1 = lialogic.mkEq(x, y); PTRef eq2 = lialogic.mkEq(one, lialogic.mkMinus(x,y)); Logic::SubstMap substMap; lialogic.arithmeticElimination({eq1,eq2}, substMap); ASSERT_TRUE(true); } TEST_F(LIASubstitutionsRegression, test_InconsistentSubstitutions_WithConstants) { auto const osmt = getLIAOsmt(); auto & lialogic = osmt->getLIALogic(); PTRef x = lialogic.mkIntVar("x"); PTRef y = lialogic.mkIntVar("y"); PTRef z = lialogic.mkIntVar("z"); PTRef zero = lialogic.getTerm_IntZero(); PTRef one = lialogic.getTerm_IntOne(); PTRef eq1 = lialogic.mkEq(x, zero); PTRef eq2 = lialogic.mkEq(y, one); PTRef eq3 = lialogic.mkEq(z, one); PTRef eq4 = lialogic.mkEq(lialogic.mkPlus(vec{x,y,z}), one); Logic::SubstMap substMap; lialogic.arithmeticElimination({eq1,eq2,eq3,eq4}, substMap); ASSERT_TRUE(true); } TEST_F(LIASubstitutionsRegression, test_RedundantEquality) { auto const osmt = getLIAOsmt(); auto & lialogic = osmt->getLIALogic(); PTRef x = lialogic.mkIntVar("x"); PTRef y = lialogic.mkIntVar("y"); PTRef z = lialogic.mkIntVar("z"); PTRef zero = lialogic.getTerm_IntZero(); PTRef one = lialogic.getTerm_IntOne(); PTRef eq1 = lialogic.mkEq(x, zero); PTRef eq2 = lialogic.mkEq(y, zero); PTRef eq3 = lialogic.mkEq(z, one); PTRef eq4 = lialogic.mkEq(lialogic.mkPlus(vec{x,y,z}), one); Logic::SubstMap substMap; lialogic.arithmeticElimination({eq1,eq2,eq3,eq4}, substMap); ASSERT_TRUE(true); } TEST_F(LIASubstitutionsRegression, test_TwoVarsEqual) { auto const osmt = getLIAOsmt(); auto & lialogic = osmt->getLIALogic(); PTRef x = lialogic.mkIntVar("x"); PTRef y = lialogic.mkIntVar("y"); PTRef eq1 = lialogic.mkEq(x, y); Logic::SubstMap substMap; lialogic.arithmeticElimination({eq1}, substMap); ASSERT_EQ(substMap.getSize(), 1); PTRef key = substMap.getKeys()[0]; PTRef value = substMap[key]; ASSERT_TRUE((key == x and value == y) or (key == y and value == x)); } TEST_F(UFLRASubstitutionsRegression, test_NoProblematicSubstitutions) { vec equalities; equalities.push(logic.mkEq(x,fx)); equalities.push(logic.mkEq(y,fy)); equalities.push(logic.mkEq(z,fz)); equalities.push(logic.mkEq(a,fa)); equalities.push(logic.mkEq(b,fb)); equalities.push(logic.mkEq(c,fc)); Logic::SubstMap map; logic.arithmeticElimination(equalities, map); // Substitutions of the form 'var -> term' where term contains the variable are forbidden! EXPECT_FALSE(map.has(x)); EXPECT_FALSE(map.has(y)); EXPECT_FALSE(map.has(z)); EXPECT_FALSE(map.has(a)); EXPECT_FALSE(map.has(b)); EXPECT_FALSE(map.has(c)); } opensmt-2.5.2/test/unit/test_TermTypechecking.cc000066400000000000000000000070201445011647600217650ustar00rootroot00000000000000// // Created by Antti Hyvarinen on 14.11.21. // #include #include class TermTypecheckingTest: public ::testing::Test { public: Logic logic; SRef usort = logic.declareUninterpretedSort("U"); SRef vsort = logic.declareUninterpretedSort("V"); PTRef uvar; PTRef vvar; SymRef ufun1; SymRef ufun2; SymRef mixfun2; SymRef mixfun3; SymRef chainableFun; SymRef pairwiseFun; SymRef leftAssocFun; SymRef rightAssocFun; TermTypecheckingTest() : logic{opensmt::Logic_t::QF_UF} , usort(logic.declareUninterpretedSort("U")) , vsort(logic.declareUninterpretedSort("V")) , uvar(logic.mkVar(usort, "u")) , vvar(logic.mkVar(vsort, "v")) , ufun1(logic.declareFun("uf1", usort, {usort})) , ufun2(logic.declareFun("uf2", usort, {usort, usort})) , mixfun2(logic.declareFun("mf2", usort, {usort, vsort})) , mixfun3(logic.declareFun("mf3", usort, {usort, vsort, usort})) , chainableFun(logic.declareFun_Chainable("cf", logic.getSort_bool(), {usort, usort})) , pairwiseFun(logic.declareFun_Pairwise("pf", logic.getSort_bool(), {usort, usort})) , leftAssocFun(logic.declareFun_LeftAssoc("lf", usort, {usort, vsort})) , rightAssocFun(logic.declareFun_RightAssoc("rf", usort, {vsort, usort})) {} }; TEST_F(TermTypecheckingTest, test_UnaryFun) { std::string msg; ASSERT_TRUE(logic.typeCheck(ufun1, {uvar}, msg)); ASSERT_FALSE(logic.typeCheck(ufun1, {vvar}, msg)); ASSERT_FALSE(logic.typeCheck(ufun1, {}, msg)); ASSERT_FALSE(logic.typeCheck(ufun1, {uvar, uvar}, msg)); } TEST_F(TermTypecheckingTest, test_BinaryFun) { std::string msg; ASSERT_TRUE(logic.typeCheck(ufun2, {uvar, uvar}, msg)); ASSERT_FALSE(logic.typeCheck(ufun2, {uvar, vvar}, msg)); ASSERT_FALSE(logic.typeCheck(ufun2, {}, msg)); ASSERT_FALSE(logic.typeCheck(ufun2, {uvar, uvar, uvar}, msg)); } TEST_F(TermTypecheckingTest, test_MixedFun) { std::string msg; ASSERT_TRUE(logic.typeCheck(mixfun2, {uvar, vvar}, msg)); ASSERT_FALSE(logic.typeCheck(mixfun2, {uvar, uvar}, msg)); ASSERT_TRUE(logic.typeCheck(mixfun3, {uvar, vvar, uvar}, msg)); ASSERT_FALSE(logic.typeCheck(mixfun3, {uvar, vvar, vvar}, msg)); } TEST_F(TermTypecheckingTest, test_PairwiseAndChainable) { for (SymRef f: {chainableFun, pairwiseFun}) { std::string msg; ASSERT_TRUE(logic.typeCheck(f, {uvar, uvar}, msg)); ASSERT_TRUE(logic.typeCheck(f, {uvar, uvar, uvar, uvar, uvar}, msg)); ASSERT_FALSE(logic.typeCheck(f, {uvar}, msg)); ASSERT_FALSE(logic.typeCheck(f, {}, msg)); ASSERT_FALSE(logic.typeCheck(f, {uvar, vvar}, msg)); ASSERT_FALSE(logic.typeCheck(f, {uvar, uvar, uvar, uvar, vvar}, msg)); } } TEST_F(TermTypecheckingTest, test_AssociativeFun) { std::string msg; ASSERT_TRUE(logic.typeCheck(leftAssocFun, {uvar, vvar}, msg)); ASSERT_TRUE(logic.typeCheck(leftAssocFun, {uvar, vvar, vvar, vvar}, msg)); ASSERT_FALSE(logic.typeCheck(leftAssocFun, {}, msg)); ASSERT_FALSE(logic.typeCheck(leftAssocFun, {uvar}, msg)); ASSERT_FALSE(logic.typeCheck(leftAssocFun, {uvar, vvar, vvar, uvar}, msg)); ASSERT_TRUE(logic.typeCheck(rightAssocFun, {vvar, uvar}, msg)); ASSERT_TRUE(logic.typeCheck(rightAssocFun, {vvar, vvar, vvar, uvar}, msg)); ASSERT_FALSE(logic.typeCheck(rightAssocFun, {}, msg)); ASSERT_FALSE(logic.typeCheck(rightAssocFun, {vvar}, msg)); ASSERT_FALSE(logic.typeCheck(rightAssocFun, {vvar, vvar, vvar, vvar}, msg)); } opensmt-2.5.2/test/unit/test_TheorySimplifications.cc000066400000000000000000000145061445011647600230570ustar00rootroot00000000000000// // Created by Martin Blicha on 2018-12-20. // #include #include #include class GetFactsTest : public ::testing::Test { protected: GetFactsTest(): logic{opensmt::Logic_t::QF_UF} {} virtual void SetUp() { ufsort = logic.declareUninterpretedSort("U"); x = logic.mkVar(ufsort, "x"); y = logic.mkVar(ufsort, "y"); } Logic logic; SRef ufsort; PTRef x; PTRef y; PTRef z; }; TEST_F(GetFactsTest, test_UnitFact){ PTRef eq = logic.mkEq(x,y); MapWithKeys newFacts; logic.getNewFacts(eq, newFacts); ASSERT_TRUE(newFacts.has(eq)); EXPECT_EQ(newFacts[eq], l_True); } TEST_F(GetFactsTest, test_NegatedUnitFact){ PTRef eq = logic.mkEq(x,y); PTRef neq = logic.mkNot(eq); MapWithKeys newFacts; // MB: Currently it does not learn inequalities. Should it? logic.getNewFacts(neq, newFacts); // ASSERT_TRUE(newFacts.has(neq)); // EXPECT_EQ(newFacts[eq], l_True); } TEST_F(GetFactsTest, test_NegatedBoolLiteral){ PTRef var = logic.mkBoolVar("a"); PTRef neq = logic.mkNot(var); MapWithKeys newFacts; logic.getNewFacts(neq, newFacts); ASSERT_TRUE(newFacts.has(var)); EXPECT_EQ(newFacts[var], l_False); } TEST_F(GetFactsTest, test_MultipleFacts){ PTRef a = logic.mkBoolVar("a"); PTRef b = logic.mkBoolVar("b"); PTRef eq = logic.mkEq(x,y); PTRef neq = logic.mkNot(eq); PTRef conj = logic.mkAnd(a, logic.mkNot(logic.mkOr(b, neq))); MapWithKeys newFacts; logic.getNewFacts(conj, newFacts); ASSERT_TRUE(newFacts.has(a)); ASSERT_TRUE(newFacts.has(b)); ASSERT_TRUE(newFacts.has(eq)); EXPECT_EQ(newFacts[a], l_True); EXPECT_EQ(newFacts[b], l_False); EXPECT_EQ(newFacts[eq], l_True); } //========================== TEST for retrieving sustituitions ========================================================= class RetrieveSubstitutionTest : public ::testing::Test { protected: RetrieveSubstitutionTest(): logic{opensmt::Logic_t::QF_UF} {} virtual void SetUp() { ufsort = logic.declareUninterpretedSort("U"); x = logic.mkVar(ufsort, "x"); y = logic.mkVar(ufsort, "y"); z = logic.mkVar(ufsort, "z"); c = logic.mkConst(ufsort, "c"); f = logic.declareFun("f", ufsort, {ufsort}); } Logic logic; SRef ufsort; PTRef x; PTRef y; PTRef z; PTRef c; SymRef f; }; TEST_F(RetrieveSubstitutionTest, test_VarVarSubstituition) { PTRef eq = logic.mkEq(x,y); vec facts; facts.push(PtAsgn{eq, l_True}); auto subst = logic.retrieveSubstitutions(facts); ASSERT_TRUE(subst.second.has(x)); EXPECT_EQ(subst.second[x], y); } TEST_F(RetrieveSubstitutionTest, test_AtomSubstituition) { PTRef a = logic.mkBoolVar("a"); vec facts; facts.push(PtAsgn{a, l_True}); auto subst = logic.retrieveSubstitutions(facts); ASSERT_TRUE(subst.second.has(a)); EXPECT_EQ(subst.second[a], logic.getTerm_true()); } TEST_F(RetrieveSubstitutionTest, test_ConstantSubstituition) { PTRef fx = logic.mkUninterpFun(f, {x}); PTRef eq = logic.mkEq(fx, c); vec facts; facts.push(PtAsgn{eq, l_True}); auto subst = logic.retrieveSubstitutions(facts); ASSERT_TRUE(subst.second.has(fx)); EXPECT_EQ(subst.second[fx], c); } TEST_F(RetrieveSubstitutionTest, test_NestedSubstitution) { PTRef fx = logic.mkUninterpFun(f, {x}); PTRef fy = logic.mkUninterpFun(f, {y}); PTRef eq = logic.mkEq(fx, y); PTRef eq2 = logic.mkEq(fy, z); vec facts; facts.push(PtAsgn{eq, l_True}); facts.push(PtAsgn{eq2, l_True}); auto subst = logic.retrieveSubstitutions(facts); ASSERT_TRUE(subst.second.has(z)); ASSERT_TRUE(subst.second.has(y)); EXPECT_EQ(subst.second[z], fy); EXPECT_EQ(subst.second[y], fx); } //========================== TEST for applying sustituitions =========================================================== class ApplySubstitutionTest : public ::testing::Test { protected: ApplySubstitutionTest(): logic{opensmt::Logic_t::QF_UF} {} virtual void SetUp() { ufsort = logic.declareUninterpretedSort("U"); x = logic.mkVar(ufsort, "x"); y = logic.mkVar(ufsort, "y"); z = logic.mkVar(ufsort, "z"); c = logic.mkConst(ufsort, "c"); f = logic.declareFun("f", ufsort, {ufsort}); } Logic logic; SRef ufsort; PTRef x; PTRef y; PTRef z; PTRef c; SymRef f; }; // MB: Logic::varsubstitute does only one-sweep substitution, it does not check the new terms for new possibilities TEST_F(ApplySubstitutionTest, test_BoolAtomSub) { PTRef a = logic.mkBoolVar("a"); PTRef b = logic.mkBoolVar("b"); PTRef fla = logic.mkAnd(a, logic.mkNot(b)); Logic::SubstMap subst; subst.insert(b, logic.getTerm_true()); PTRef res = Substitutor(logic, subst).rewrite(fla); EXPECT_EQ(res, logic.getTerm_false()); } TEST_F(ApplySubstitutionTest, test_VarVarSub) { PTRef fla = logic.mkEq(x, z); Logic::SubstMap subst; subst.insert(x, y); PTRef res = Substitutor(logic, subst).rewrite(fla); EXPECT_EQ(res, logic.mkEq(y,z)); } TEST_F(ApplySubstitutionTest, test_NestedSub) { PTRef fy = logic.mkUninterpFun(f, {y}); PTRef fz = logic.mkUninterpFun(f, {z}); PTRef fla = logic.mkEq(x, logic.mkUninterpFun(f, {fz})); Logic::SubstMap subst; subst.insert(x, fy); subst.insert(y, fz); PTRef res = Substitutor(logic, subst).rewrite(fla); // EXPECT_EQ(res, logic.getTerm_true()); // MB: This requires something like fixed-point substitution EXPECT_EQ(res, logic.mkEq(fy, logic.mkUninterpFun(f, {fz}))); } //========================== TEST for transitive closure of substitutions =========================================================== TEST(SubstitutionTransitiveClosure, test_twoStepSubstitution) { Logic logic{opensmt::Logic_t::QF_UF}; Logic::SubstMap substitutions; PTRef a = logic.mkBoolVar("a"); PTRef b = logic.mkBoolVar("b"); PTRef c = logic.mkBoolVar("c"); PTRef d = logic.mkBoolVar("d"); substitutions.insert(a, logic.mkAnd(b,c)); substitutions.insert(b, c); substitutions.insert(c, d); logic.substitutionsTransitiveClosure(substitutions); ASSERT_EQ(substitutions.getSize(), 3); ASSERT_EQ(substitutions[a], d); } opensmt-2.5.2/test/unit/test_UFInterpolation.cc000066400000000000000000000477611445011647600216220ustar00rootroot00000000000000// // Created by Martin Blicha on 19.09.20. // #include #include #include #include "VerificationUtils.h" bool verifyInterpolant(PTRef itp, PartitionManager & pManager, ipartitions_t const & Amask, Logic & logic) { return VerificationUtils(logic).verifyInterpolantInternal(pManager.getPartition(Amask, PartitionManager::part::A), pManager.getPartition(Amask, PartitionManager::part::B), itp); } class UFInterpolationTest : public ::testing::Test { protected: UFInterpolationTest(): logic{opensmt::Logic_t::QF_UF} {} virtual void SetUp() { ufsort = logic.declareUninterpretedSort("U"); x = logic.mkVar(ufsort, "x"); y = logic.mkVar(ufsort, "y"); x1 = logic.mkVar(ufsort, "x1"); x2 = logic.mkVar(ufsort, "x2"); x3 = logic.mkVar(ufsort, "x3"); x4 = logic.mkVar(ufsort, "x4"); y1 = logic.mkVar(ufsort, "y1"); y2 = logic.mkVar(ufsort, "y2"); z1 = logic.mkVar(ufsort, "z1"); z2 = logic.mkVar(ufsort, "z2"); z3 = logic.mkVar(ufsort, "z3"); z4 = logic.mkVar(ufsort, "z4"); z5 = logic.mkVar(ufsort, "z5"); z6 = logic.mkVar(ufsort, "z6"); z7 = logic.mkVar(ufsort, "z7"); z8 = logic.mkVar(ufsort, "z8"); f = logic.declareFun("f", ufsort, {ufsort}); g = logic.declareFun("g", ufsort, {ufsort, ufsort}); p = logic.declareFun("p", logic.getSort_bool(), {ufsort}); } Logic logic; SMTConfig config; SRef ufsort; PTRef x, y, x1, x2, x3, x4, y1, y2, z1, z2, z3, z4, z5, z6, z7, z8; SymRef f, g, p; bool verifyInterpolant(PTRef itp, PartitionManager & pManager, ipartitions_t const & Amask) { return ::verifyInterpolant(itp, pManager, Amask, logic); } }; TEST_F(UFInterpolationTest, test_SimpleTransitivity){ /* * Simple conflict x=y, y=z, not(x=z) */ PTRef eq1 = logic.mkEq(x,y); PTRef eq2 = logic.mkEq(y,z1); PTRef eq3 = logic.mkEq(z1,x); const char* msg = "ok"; config.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); MainSolver solver(logic, config, "ufinterpolator"); solver.insertFormula(eq1); solver.insertFormula(eq2); solver.insertFormula(logic.mkNot(eq3)); auto res = solver.check(); ASSERT_EQ(res, s_False); auto itpCtx = solver.getInterpolationContext(); vec interpolants; ipartitions_t mask; opensmt::setbit(mask, 0); itpCtx->getSingleInterpolant(interpolants, mask); EXPECT_TRUE(verifyInterpolant(interpolants[0], solver.getPartitionManager(), mask)); interpolants.clear(); opensmt::setbit(mask, 1); itpCtx->getSingleInterpolant(interpolants, mask); EXPECT_TRUE(verifyInterpolant(interpolants[0], solver.getPartitionManager(), mask)); } TEST_F(UFInterpolationTest, test_SimpleTransitivityReversed){ /* * Same as SimpleTransitivy but the disequality is always in A instead of B */ PTRef eq1 = logic.mkEq(x,y); PTRef eq2 = logic.mkEq(y,z1); PTRef eq3 = logic.mkEq(z1,x); const char* msg = "ok"; config.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); MainSolver solver(logic, config, "ufinterpolator"); solver.insertFormula(logic.mkNot(eq3)); solver.insertFormula(eq2); solver.insertFormula(eq1); auto res = solver.check(); ASSERT_EQ(res, s_False); auto itpCtx = solver.getInterpolationContext(); vec interpolants; ipartitions_t mask; opensmt::setbit(mask, 0); itpCtx->getSingleInterpolant(interpolants, mask); EXPECT_TRUE(verifyInterpolant(interpolants[0], solver.getPartitionManager(), mask)); interpolants.clear(); opensmt::setbit(mask, 1); itpCtx->getSingleInterpolant(interpolants, mask); EXPECT_TRUE(verifyInterpolant(interpolants[0], solver.getPartitionManager(), mask)); } TEST_F(UFInterpolationTest, test_SimpleCongruence){ /* * Simple conflict using congruence: x=y, f(x) != f(y) */ PTRef eq1 = logic.mkEq(x,y); PTRef eq2 = logic.mkEq(logic.mkUninterpFun(f, {x}), logic.mkUninterpFun(f, {y})); const char* msg = "ok"; config.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); MainSolver solver(logic, config, "ufinterpolator"); solver.insertFormula(eq1); solver.insertFormula(logic.mkNot(eq2)); auto res = solver.check(); ASSERT_EQ(res, s_False); auto itpCtx = solver.getInterpolationContext(); vec interpolants; ipartitions_t mask; opensmt::setbit(mask, 0); itpCtx->getSingleInterpolant(interpolants, mask); EXPECT_TRUE(verifyInterpolant(interpolants[0], solver.getPartitionManager(), mask)); } TEST_F(UFInterpolationTest, test_SimpleCongruenceReversed){ /* * Same as SimpleCongruence, but the disequality is in A, not B */ PTRef eq1 = logic.mkEq(x,y); PTRef eq2 = logic.mkEq(logic.mkUninterpFun(f, {x}), logic.mkUninterpFun(f, {y})); const char* msg = "ok"; config.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); MainSolver solver(logic, config, "ufinterpolator"); solver.insertFormula(logic.mkNot(eq2)); solver.insertFormula(eq1); auto res = solver.check(); ASSERT_EQ(res, s_False); auto itpCtx = solver.getInterpolationContext(); vec interpolants; ipartitions_t mask; opensmt::setbit(mask, 0); itpCtx->getSingleInterpolant(interpolants, mask); EXPECT_TRUE(verifyInterpolant(interpolants[0], solver.getPartitionManager(), mask)); } TEST_F(UFInterpolationTest, test_NotImmediatelyColorableCGraph){ /* * A = {x=z1, g(x,z2)=z3}; B = {y=z2, not(g(z1,y)=z3)} */ PTRef eqA1 = logic.mkEq(x,z1); PTRef eqA2 = logic.mkEq(logic.mkUninterpFun(g, {x,z2}),z3); PTRef eqB1 = logic.mkEq(y,z2); PTRef eqB2 = logic.mkEq(logic.mkUninterpFun(g, {z1,y}),z3); const char* msg = "ok"; config.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); MainSolver solver(logic, config, "ufinterpolator"); solver.insertFormula(logic.mkAnd(eqA1, eqA2)); solver.insertFormula(logic.mkAnd(eqB1, logic.mkNot(eqB2))); auto res = solver.check(); ASSERT_EQ(res, s_False); auto itpCtx = solver.getInterpolationContext(); vec interpolants; ipartitions_t mask; opensmt::setbit(mask, 0); itpCtx->getSingleInterpolant(interpolants, mask); EXPECT_TRUE(verifyInterpolant(interpolants[0], solver.getPartitionManager(), mask)); // change the interpolation algorithm config.setEUFInterpolationAlgorithm(itp_euf_alg_weak); interpolants.clear(); itpCtx->getSingleInterpolant(interpolants, mask); EXPECT_TRUE(verifyInterpolant(interpolants[0], solver.getPartitionManager(), mask)); } TEST_F(UFInterpolationTest, test_NotImmediatelyColorableCGraphReversed){ /* * Same as NotImmediatelyColorableCGraph, but reversed A and B * B = {x=z1, g(x,z2)=z3}; A = {y=z2, not(g(z1,y)=z3)} */ PTRef eqB1 = logic.mkEq(x,z1); PTRef eqB2 = logic.mkEq(logic.mkUninterpFun(g, {x,z2}),z3); PTRef eqA1 = logic.mkEq(y,z2); PTRef eqA2 = logic.mkEq(logic.mkUninterpFun(g, {z1,y}),z3); const char* msg = "ok"; config.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); MainSolver solver(logic, config, "ufinterpolator"); solver.insertFormula(logic.mkAnd(eqA1, logic.mkNot(eqA2))); solver.insertFormula(logic.mkAnd(eqB1, eqB2)); auto res = solver.check(); ASSERT_EQ(res, s_False); auto itpCtx = solver.getInterpolationContext(); vec interpolants; ipartitions_t mask; opensmt::setbit(mask, 0); itpCtx->getSingleInterpolant(interpolants, mask); EXPECT_TRUE(verifyInterpolant(interpolants[0], solver.getPartitionManager(), mask)); // change the interpolation algorithm config.setEUFInterpolationAlgorithm(itp_euf_alg_weak); interpolants.clear(); itpCtx->getSingleInterpolant(interpolants, mask); EXPECT_TRUE(verifyInterpolant(interpolants[0], solver.getPartitionManager(), mask)); } TEST_F(UFInterpolationTest, test_JustificationRequired){ /* * A = {x1=z1, z2=x2, z3=f(x1), f(x2)=z4, x3=z5, z6=x4, z7=f(x3), f(x4)=z8} * B = {z1=z2, z5=f(z3), f(z4)=z6, y1=z7, z8=y2, not(y1=y2)} */ PTRef eqA1 = logic.mkEq(x1,z1); PTRef eqA2 = logic.mkEq(z2,x2); PTRef eqA3 = logic.mkEq(z3,logic.mkUninterpFun(f, {x1})); PTRef eqA4 = logic.mkEq(logic.mkUninterpFun(f, {x2}), z4); PTRef eqA5 = logic.mkEq(x3,z5); PTRef eqA6 = logic.mkEq(z6,x4); PTRef eqA7 = logic.mkEq(z7,logic.mkUninterpFun(f, {x3})); PTRef eqA8 = logic.mkEq(logic.mkUninterpFun(f, {x4}), z8); PTRef eqB1 = logic.mkEq(z1,z2); PTRef eqB2 = logic.mkEq(z5,logic.mkUninterpFun(f, {z3})); PTRef eqB3 = logic.mkEq(logic.mkUninterpFun(f, {z4}), z6); PTRef eqB4 = logic.mkEq(y1,z7); PTRef eqB5 = logic.mkEq(z8,y2); PTRef eqB6 = logic.mkEq(y1,y2); const char* msg = "ok"; config.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); MainSolver solver(logic, config, "ufinterpolator"); solver.insertFormula(logic.mkAnd({eqA1, eqA2, eqA3, eqA4, eqA5, eqA6, eqA7, eqA8})); solver.insertFormula(logic.mkAnd({eqB1, eqB2, eqB3, eqB4, eqB5, logic.mkNot(eqB6)})); auto res = solver.check(); ASSERT_EQ(res, s_False); auto itpCtx = solver.getInterpolationContext(); vec interpolants; ipartitions_t mask; opensmt::setbit(mask, 0); itpCtx->getSingleInterpolant(interpolants, mask); EXPECT_TRUE(verifyInterpolant(interpolants[0], solver.getPartitionManager(), mask)); // change the interpolation algorithm config.setEUFInterpolationAlgorithm(itp_euf_alg_weak); interpolants.clear(); itpCtx->getSingleInterpolant(interpolants, mask); EXPECT_TRUE(verifyInterpolant(interpolants[0], solver.getPartitionManager(), mask)); } TEST_F(UFInterpolationTest, test_JustificationRequiredReversed){ /* * Same as JustificationRequired, but A and B switched * B = {x1=z1, z2=x2, z3=f(x1), f(x2)=z4, x3=z5, z6=x4, z7=f(x3), f(x4)=z8} * A = {z1=z2, z5=f(z3), f(z4)=z6, y1=z7, z8=y2, not(y1=y2)} */ PTRef eqB1 = logic.mkEq(x1,z1); PTRef eqB2 = logic.mkEq(z2,x2); PTRef eqB3 = logic.mkEq(z3,logic.mkUninterpFun(f, {x1})); PTRef eqB4 = logic.mkEq(logic.mkUninterpFun(f, {x2}), z4); PTRef eqB5 = logic.mkEq(x3,z5); PTRef eqB6 = logic.mkEq(z6,x4); PTRef eqB7 = logic.mkEq(z7,logic.mkUninterpFun(f, {x3})); PTRef eqB8 = logic.mkEq(logic.mkUninterpFun(f, {x4}), z8); PTRef eqA1 = logic.mkEq(z1,z2); PTRef eqA2 = logic.mkEq(z5,logic.mkUninterpFun(f, {z3})); PTRef eqA3 = logic.mkEq(logic.mkUninterpFun(f, {z4}), z6); PTRef eqA4 = logic.mkEq(y1,z7); PTRef eqA5 = logic.mkEq(z8,y2); PTRef eqA6 = logic.mkEq(y1,y2); const char* msg = "ok"; config.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); MainSolver solver(logic, config, "ufinterpolator"); solver.insertFormula(logic.mkAnd({eqA1, eqA2, eqA3, eqA4, eqA5, logic.mkNot(eqA6)})); solver.insertFormula(logic.mkAnd({eqB1, eqB2, eqB3, eqB4, eqB5, eqB6, eqB7,eqB8})); auto res = solver.check(); ASSERT_EQ(res, s_False); auto itpCtx = solver.getInterpolationContext(); vec interpolants; ipartitions_t mask; opensmt::setbit(mask, 0); itpCtx->getSingleInterpolant(interpolants, mask); EXPECT_TRUE(verifyInterpolant(interpolants[0], solver.getPartitionManager(), mask)); // change the interpolation algorithm config.setEUFInterpolationAlgorithm(itp_euf_alg_weak); interpolants.clear(); itpCtx->getSingleInterpolant(interpolants, mask); EXPECT_TRUE(verifyInterpolant(interpolants[0], solver.getPartitionManager(), mask)); } TEST_F(UFInterpolationTest, test_SimpleUninterpretedPredicate){ /* * Simple conflict using congruence: x=y, P(x), not(P(y)) */ PTRef eq = logic.mkEq(x,y); PTRef px = logic.mkUninterpFun(p, {x}); PTRef py = logic.mkUninterpFun(p, {y}); const char* msg = "ok"; config.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); MainSolver solver(logic, config, "ufinterpolator"); solver.insertFormula(px); solver.insertFormula(eq); solver.insertFormula(logic.mkNot(py)); auto res = solver.check(); ASSERT_EQ(res, s_False); auto itpCtx = solver.getInterpolationContext(); vec interpolants; ipartitions_t mask; opensmt::setbit(mask, 0); itpCtx->getSingleInterpolant(interpolants, mask); EXPECT_TRUE(verifyInterpolant(interpolants[0], solver.getPartitionManager(), mask)); } TEST_F(UFInterpolationTest, test_ConstantsConflict){ /* * Simple conflict using uninterpreted constants (implicitly different): c=x, x=d */ PTRef c = logic.mkConst(ufsort, "c"); PTRef d = logic.mkConst(ufsort, "d"); PTRef eqA = logic.mkEq(c,x); PTRef eqB = logic.mkEq(x,d); const char* msg = "ok"; config.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); MainSolver solver(logic, config, "ufinterpolator"); solver.insertFormula(eqA); solver.insertFormula(eqB); auto res = solver.check(); ASSERT_EQ(res, s_False); auto itpCtx = solver.getInterpolationContext(); vec interpolants; ipartitions_t mask; opensmt::setbit(mask, 0); itpCtx->getSingleInterpolant(interpolants, mask); EXPECT_TRUE(verifyInterpolant(interpolants[0], solver.getPartitionManager(), mask)); } TEST_F(UFInterpolationTest, test_TwoLevelJustification){ /* * B = {z1=g(y1,z3}, g(y1,z4)=z2 * A = {x1=f(z1), x2=f(z2), z3=z4} * not(x1=x2) in A */ PTRef eqB1 = logic.mkEq(z1,logic.mkUninterpFun(g, {y1,z3})); PTRef eqB2 = logic.mkEq(logic.mkUninterpFun(g, {y1, z4}), z2); PTRef eqA1 = logic.mkEq(x1,logic.mkUninterpFun(f, {z1})); PTRef eqA2 = logic.mkEq(logic.mkUninterpFun(f, {z2}), x2); PTRef eqA3 = logic.mkEq(z3,z4); PTRef dis = logic.mkNot(logic.mkEq(x1, x2)); const char* msg = "ok"; config.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); MainSolver solver(logic, config, "ufinterpolator"); solver.insertFormula(logic.mkAnd({eqA1, eqA2, eqA3, dis})); solver.insertFormula(logic.mkAnd({eqB1, eqB2})); auto res = solver.check(); ASSERT_EQ(res, s_False); auto itpCtx = solver.getInterpolationContext(); vec interpolants; ipartitions_t mask; opensmt::setbit(mask, 0); itpCtx->getSingleInterpolant(interpolants, mask); EXPECT_TRUE(verifyInterpolant(interpolants[0], solver.getPartitionManager(), mask)); // change the interpolation algorithm config.setEUFInterpolationAlgorithm(itp_euf_alg_weak); interpolants.clear(); itpCtx->getSingleInterpolant(interpolants, mask); EXPECT_TRUE(verifyInterpolant(interpolants[0], solver.getPartitionManager(), mask)); } TEST_F(UFInterpolationTest, test_TwoLevelJustificationDiseqInB){ /* * B = {z1=g(y1,z3}, g(y1,z4)=z2 * A = {x1=f(z1), x2=f(z2), z3=z4} * not(x1=x2) in B */ PTRef eqB1 = logic.mkEq(z1,logic.mkUninterpFun(g, {y1,z3})); PTRef eqB2 = logic.mkEq(logic.mkUninterpFun(g, {y1, z4}), z2); PTRef eqA1 = logic.mkEq(x1,logic.mkUninterpFun(f, {z1})); PTRef eqA2 = logic.mkEq(logic.mkUninterpFun(f, {z2}), x2); PTRef eqA3 = logic.mkEq(z3,z4); PTRef dis = logic.mkNot(logic.mkEq(x1, x2)); const char* msg = "ok"; config.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); MainSolver solver(logic, config, "ufinterpolator"); solver.insertFormula(logic.mkAnd({eqA1, eqA2, eqA3})); solver.insertFormula(logic.mkAnd({eqB1, eqB2, dis})); auto res = solver.check(); ASSERT_EQ(res, s_False); auto itpCtx = solver.getInterpolationContext(); vec interpolants; ipartitions_t mask; opensmt::setbit(mask, 0); itpCtx->getSingleInterpolant(interpolants, mask); EXPECT_TRUE(verifyInterpolant(interpolants[0], solver.getPartitionManager(), mask)); // change the interpolation algorithm config.setEUFInterpolationAlgorithm(itp_euf_alg_weak); interpolants.clear(); itpCtx->getSingleInterpolant(interpolants, mask); EXPECT_TRUE(verifyInterpolant(interpolants[0], solver.getPartitionManager(), mask)); } TEST_F(UFInterpolationTest, test_LocalColorInformationInsufficient){ /* * B = {z1=g(a1,b1}, g(a2,b2)=z2 * A = {P(g(x,y)), x=a1, y=b1, x=a2, y=b2} * not(z1=z2) in A */ // Note: this requires a set-up in specific order, different from the set-up we have in UFInterpolationTest Logic logic{opensmt::Logic_t::QF_UF}; SRef ufsort = logic.declareUninterpretedSort("U"); SymRef P = logic.declareFun("P", logic.getSort_bool(), {ufsort}); SymRef f = logic.declareFun("f", ufsort, {ufsort, ufsort}); logic.declareFun("x", ufsort, {}); logic.declareFun("y", ufsort, {}); logic.declareFun("r1", ufsort, {}); logic.declareFun("r2", ufsort, {}); logic.declareFun("a1", ufsort, {}); logic.declareFun("a2", ufsort, {}); logic.declareFun("b1", ufsort, {}); logic.declareFun("b2", ufsort, {}); PTRef r1 = logic.mkVar(ufsort, "r1"); PTRef a1 = logic.mkVar(ufsort, "a1"); PTRef b1 = logic.mkVar(ufsort, "b1"); PTRef f_a1_b1 = logic.mkUninterpFun(f, {a1,b1}); PTRef r2 = logic.mkVar(ufsort, "r2"); PTRef a2 = logic.mkVar(ufsort, "a2"); PTRef b2 = logic.mkVar(ufsort, "b2"); PTRef f_a2_b2 = logic.mkUninterpFun(f, {a2,b2}); PTRef x = logic.mkVar(ufsort, "x"); PTRef y = logic.mkVar(ufsort, "y"); PTRef f_x_y = logic.mkUninterpFun(f, {x,y}); PTRef P_f = logic.mkUninterpFun(P, {f_x_y}); PTRef eqB1 = logic.mkEq(r1, f_a1_b1); PTRef eqB2 = logic.mkEq(r2,f_a2_b2); PTRef A = logic.mkAnd({ P_f, logic.mkEq(a1, x), logic.mkEq(b1, y), logic.mkEq(a2, x), logic.mkEq(b2, y), logic.mkNot(logic.mkEq(r1, r2)) }); const char* msg = "ok"; config.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); MainSolver solver(logic, config, "ufinterpolator"); solver.insertFormula(logic.mkAnd(eqB1, eqB2)); solver.insertFormula(A); auto res = solver.check(); ASSERT_EQ(res, s_False); auto itpCtx = solver.getInterpolationContext(); vec interpolants; ipartitions_t mask; opensmt::setbit(mask, 1); itpCtx->getSingleInterpolant(interpolants, mask); // std::cout << logic.printTerm(interpolants[0]) << std::endl; EXPECT_TRUE(::verifyInterpolant(interpolants[0], solver.getPartitionManager(), mask, logic)); } TEST_F(UFInterpolationTest, test_DistinctInA){ /* * B = { distinct(x1,x3,x4) } * A = { x1 = x2, x2 = x3 } */ PTRef eqA1 = logic.mkEq(x1,x2); PTRef eqA2 = logic.mkEq(x2,x3); PTRef deqB = logic.mkDistinct({x1,x4,x3}); const char* msg = "ok"; config.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); MainSolver solver(logic, config, "ufinterpolator"); solver.insertFormula(logic.mkAnd(eqA1, eqA2)); solver.insertFormula(deqB); auto res = solver.check(); ASSERT_EQ(res, s_False); auto itpCtx = solver.getInterpolationContext(); vec interpolants; ipartitions_t mask = 1; itpCtx->getSingleInterpolant(interpolants, mask); PTRef itp = interpolants[0]; // std::cout << "Interpolant: " << logic.pp(itp) << std::endl; EXPECT_TRUE(verifyInterpolant(itp, solver.getPartitionManager(), mask)); ASSERT_EQ(itp, logic.mkEq(x1,x3)); } TEST_F(UFInterpolationTest, test_DistinctInB){ /* * A = { distinct(x1,x3,x4) } * B = { x1 = x2, x2 = x3 } */ PTRef eqB1 = logic.mkEq(x1,x2); PTRef eqB2 = logic.mkEq(x2,x3); PTRef deqA = logic.mkDistinct({x1,x4,x3}); const char* msg = "ok"; config.setOption(SMTConfig::o_produce_inter, SMTOption(true), msg); MainSolver solver(logic, config, "ufinterpolator"); solver.insertFormula(deqA); solver.insertFormula(logic.mkAnd(eqB1, eqB2)); auto res = solver.check(); ASSERT_EQ(res, s_False); auto itpCtx = solver.getInterpolationContext(); vec interpolants; ipartitions_t mask = 1; itpCtx->getSingleInterpolant(interpolants, mask); PTRef itp = interpolants[0]; // std::cout << "Interpolant: " << logic.pp(itp) << std::endl; EXPECT_TRUE(verifyInterpolant(itp, solver.getPartitionManager(), mask)); ASSERT_EQ(itp, logic.mkNot(logic.mkEq(x1,x3))); } opensmt-2.5.2/test/unit/test_Visitors.cc000066400000000000000000000066051445011647600203520ustar00rootroot00000000000000/* * Copyright (c) 2022, Martin Blicha * * SPDX-License-Identifier: MIT * */ #include #include #include #include class VisitorTest : public ::testing::Test { protected: VisitorTest() : logic{opensmt::Logic_t::QF_LRA} {} virtual void SetUp() { x = logic.mkRealVar("x"); y = logic.mkRealVar("y"); z = logic.mkRealVar("z"); b = logic.mkBoolVar("b"); } ArithLogic logic; PTRef x, y, z; PTRef b; bool contains(vec const & terms, PTRef term) const { return std::find(terms.begin(), terms.end(), term) != terms.end(); } }; TEST_F(VisitorTest, test_GetVariablesZero) { auto vars = variables(logic, logic.getTerm_RealZero()); ASSERT_TRUE(vars.size() == 0); } TEST_F(VisitorTest, test_GetVariablesOne) { auto vars = variables(logic, x); ASSERT_TRUE(vars.size() == 1); ASSERT_EQ(vars[0], x); } TEST_F(VisitorTest, test_GetVariablesMany) { auto vars = variables(logic, logic.mkPlus(vec{x, y, logic.mkTimes(z, logic.mkRealConst(2))})); ASSERT_TRUE(vars.size() == 3); EXPECT_TRUE(contains(vars,x)); EXPECT_TRUE(contains(vars,y)); EXPECT_TRUE(contains(vars,z)); } TEST_F(VisitorTest, test_GetVariablesNoDuplicates) { PTRef term = logic.mkAnd(logic.mkGeq(x, y), logic.mkGeq(x,z)); auto vars = variables(logic, term); ASSERT_TRUE(vars.size() == 3); EXPECT_TRUE(contains(vars,x)); EXPECT_TRUE(contains(vars,y)); EXPECT_TRUE(contains(vars,z)); } TEST_F(VisitorTest, test_GetAllSubTermsConstant) { auto subterms = subTerms(logic, logic.getTerm_true()); ASSERT_TRUE(subterms.size() == 1); ASSERT_EQ(subterms[0], logic.getTerm_true()); } TEST_F(VisitorTest, test_GetAllSubTermsBasicSum) { PTRef sum = logic.mkPlus(x,y); auto subterms = subTerms(logic, sum); ASSERT_TRUE(subterms.size() == 3); EXPECT_TRUE(contains(subterms,x)); EXPECT_TRUE(contains(subterms,y)); EXPECT_TRUE(contains(subterms,sum)); } TEST_F(VisitorTest, test_GetSubTermsArbitraryPredicate) { PTRef zero = logic.getTerm_RealZero(); PTRef plus1 = logic.mkPlus(x,y); PTRef plus2 = logic.mkPlus(x,z); PTRef fla = logic.mkAnd(logic.mkGeq(plus1, zero), logic.mkGeq(plus2, zero)); auto subterms = matchingSubTerms(logic, fla, [&](PTRef subterm) { return logic.isPlus(subterm); }); ASSERT_TRUE(subterms.size() == 2); EXPECT_TRUE(contains(subterms,plus1)); EXPECT_TRUE(contains(subterms,plus2)); } TEST_F(VisitorTest, test_PtermNodeCounter) { PTRef zero = logic.getTerm_RealZero(); PTRef plus1 = logic.mkPlus(x, y); PTRef plus2 = logic.mkPlus(x, z); PTRef fla = logic.mkAnd(logic.mkGeq(plus1, zero), logic.mkGeq(plus2, zero)); for (auto limit : {UINT32_MAX, 2u, 9u, 10u}) { PtermNodeCounter counter(logic, limit); counter.visit(fla); if (limit < 10) { ASSERT_TRUE(counter.limitReached()); } else { ASSERT_EQ(counter.getCount(), 9); ASSERT_FALSE(counter.limitReached()); } } for (auto tr : {plus1, plus2, fla, fla}) { PtermNodeCounter counter(logic, 4u); counter.visit(tr); if (tr == plus1 or tr == plus2) { ASSERT_FALSE(counter.limitReached()); ASSERT_EQ(counter.getCount(), 3); } else { ASSERT_TRUE(counter.limitReached()); } } }opensmt-2.5.2/test/unit/test_simplifyAssignment.cpp000066400000000000000000000117461445011647600226140ustar00rootroot00000000000000// // Created by Martin Blicha on 31.10.18. // #include #include #include class SimplifyUnderAssignment_test : public ::testing::Test { public: Logic logic; PTRef a; PTRef b; PTRef c; SimplifyUnderAssignment_test() : logic{opensmt::Logic_t::QF_BOOL}, a(logic.mkBoolVar("a")), b(logic.mkBoolVar("b")), c(logic.mkBoolVar("c")) {} }; TEST_F(SimplifyUnderAssignment_test, test_Simple_Conjunction) { PTRef conj = logic.mkAnd(a, logic.mkOr( logic.mkNot(a), b )); PTRef res = simplifyUnderAssignment(logic, conj); ASSERT_EQ(res, logic.mkAnd(a,b)); } TEST_F(SimplifyUnderAssignment_test, test_ConjunctionToConstant) { PTRef conj = logic.mkAnd(a, logic.mkAnd(logic.mkNot(a), b)); PTRef res = simplifyUnderAssignment(logic, conj); ASSERT_EQ(res, logic.getTerm_false()); } TEST_F(SimplifyUnderAssignment_test, test_DisjunctionToConstant) { PTRef disj = logic.mkOr(a, logic.mkOr(logic.mkNot(a), b)); PTRef res = simplifyUnderAssignment(logic, disj); ASSERT_EQ(res, logic.getTerm_true()); } TEST_F(SimplifyUnderAssignment_test, test_Simple_Disjunction) { PTRef disj = logic.mkOr(a, logic.mkAnd( logic.mkNot(a), b )); PTRef res = simplifyUnderAssignment(logic, disj); ASSERT_EQ(res, logic.mkOr(a,b)); } TEST_F(SimplifyUnderAssignment_test, test_Do_Not_Simplify_Shared) { PTRef conj = logic.mkAnd(a,b); PTRef cdisj = logic.mkOr(c, conj); PTRef top = logic.mkAnd( cdisj, logic.mkOr(logic.mkNot(a), conj) ); PTRef res = simplifyUnderAssignment(logic, top); ASSERT_EQ(res, top); } TEST_F(SimplifyUnderAssignment_test, test_NestedStructure) { PTRef nota = logic.mkNot(a); PTRef top = logic.mkAnd( logic.mkOr(nota, logic.mkAnd(b, nota)), c ); PTRef res = simplifyUnderAssignment(logic, top); ASSERT_EQ(res, logic.mkAnd(nota, c)); } TEST_F(SimplifyUnderAssignment_test, test_BooleanEquality) { PTRef nota = logic.mkNot(a); PTRef eq = logic.mkEq(a,b); vec args; args.push(eq); args.push(nota); args.push(logic.mkOr(a, logic.mkNot(eq))); PTRef top = logic.mkAnd(args); PTRef res = simplifyUnderAssignment(logic, top); ASSERT_TRUE(res == logic.getTerm_false()); } // ===================== Tests of agressive simplification based on dominators ======================================== TEST_F(SimplifyUnderAssignment_test, test_Simple_Conjunction_Aggressive) { PTRef conj = logic.mkAnd(a, logic.mkOr( logic.mkNot(a), b )); PTRef res = simplifyUnderAssignment_Aggressive(conj, logic); ASSERT_EQ(res, logic.mkAnd(a,b)); } TEST_F(SimplifyUnderAssignment_test, test_ConjunctionToConstant_Aggressive) { PTRef conj = logic.mkAnd(a, logic.mkAnd(logic.mkNot(a), b)); PTRef res = simplifyUnderAssignment_Aggressive(conj, logic); ASSERT_EQ(res, logic.getTerm_false()); } TEST_F(SimplifyUnderAssignment_test, test_DisjunctionToConstant_Aggressive) { PTRef disj = logic.mkOr(a, logic.mkOr(logic.mkNot(a), b)); PTRef res = simplifyUnderAssignment_Aggressive(disj, logic); ASSERT_EQ(res, logic.getTerm_true()); } TEST_F(SimplifyUnderAssignment_test, test_Simple_Disjunction_Aggressive) { PTRef disj = logic.mkOr(a, logic.mkAnd( logic.mkNot(a), b )); PTRef res = simplifyUnderAssignment_Aggressive(disj, logic); ASSERT_EQ(res, logic.mkOr(a,b)); } TEST_F(SimplifyUnderAssignment_test, test_Do_Not_Simplify_Aggressive) { PTRef conj = logic.mkAnd(a,b); PTRef cdisj = logic.mkOr(c, conj); PTRef top = logic.mkAnd( cdisj, logic.mkOr(logic.mkNot(a), conj) ); PTRef res = simplifyUnderAssignment(logic, top); ASSERT_EQ(res, top); } TEST_F(SimplifyUnderAssignment_test, test_NestedStructure_Aggressive) { PTRef nota = logic.mkNot(a); PTRef top = logic.mkAnd( logic.mkOr(nota, logic.mkAnd(b, nota)), c ); PTRef res = simplifyUnderAssignment_Aggressive(top, logic); ASSERT_EQ(res, logic.mkAnd(nota, c)); } TEST_F(SimplifyUnderAssignment_test, test_BooleanEquality_Aggressive) { PTRef nota = logic.mkNot(a); PTRef eq = logic.mkEq(a,b); vec args; args.push(eq); args.push(nota); args.push(logic.mkOr(a, logic.mkNot(eq))); PTRef top = logic.mkAnd(args); PTRef res = simplifyUnderAssignment_Aggressive(top, logic); ASSERT_TRUE(res == logic.getTerm_false()); } TEST_F(SimplifyUnderAssignment_test, test_SimplifyByDominator_Aggressive) { PTRef nota = logic.mkNot(a); PTRef notb = logic.mkNot(b); PTRef conj = logic.mkAnd(nota, b); vec args; args.push(a); args.push(logic.mkOr(notb, conj)); args.push(logic.mkOr(c, conj)); PTRef top = logic.mkAnd(args); PTRef res = simplifyUnderAssignment_Aggressive(top, logic); args.clear(); args.push(a); args.push(notb); args.push(c); ASSERT_TRUE(res == logic.mkAnd(args)); } opensmt-2.5.2/tool_wrapper.sh000077500000000000000000000003611445011647600162710ustar00rootroot00000000000000opensmt $1 > toolwrappertmp 2>&1 res=`cat toolwrappertmp |grep '^sat\|^unsat'` rm toolwrappertmp ret_val=0; if [ "$res" = "unsat" ] then ret_val=0 else if [ "$res" = "sat" ] then ret_val=1 else echo "$res" ret_val=2 fi fi exit $ret_val